Statistics
| Branch: | Revision:

ffmpeg / libavcodec / ffv1.c @ 28a3f525

History | View | Annotate | Download (53.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
#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[32];
44

    
45
static const int8_t quant3[256]={
46
 0, 0, 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,-1,
58
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-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,-1,-1,-1,-1,-1,-1,-1,-1,-1, 0,
62
};
63

    
64
static const int8_t quant5_10bit[256]={
65
 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1,
66
 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
67
 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
68
 1, 1, 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,-1,
78
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
79
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
80
-1,-1,-1,-1,-1,-1,-0,-0,-0,-0,-0,-0,-0,-0,-0,-0,
81
};
82

    
83
static const int8_t quant5[256]={
84
 0, 1, 1, 1, 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,-2,-2,-2,
96
-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
97
-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
98
-2,-2,-2,-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,-1,-1,-1,
100
};
101
static const int8_t quant7[256]={
102
 0, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
103
 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
104
 2, 2, 2, 2, 2, 2, 2, 2, 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,-3,-3,-3,-3,-3,-3,-3,
112
-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
113
-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
114
-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
115
-3,-3,-3,-3,-3,-3,-3,-3,-3,-2,-2,-2,-2,-2,-2,-2,
116
-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
117
-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-1,-1,
118
};
119
static const int8_t quant9[256]={
120
 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3,
121
 3, 3, 3, 3, 3, 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,-4,-4,-4,-4,
131
-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
132
-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
133
-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
134
-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-3,-3,-3,-3,
135
-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-2,-2,-2,-2,-1,-1,
136
};
137
static const int8_t quant9_10bit[256]={
138
 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2,
139
 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3,
140
 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
141
 3, 3, 3, 3, 3, 3, 3, 3, 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,-4,-4,-4,-4,-4,-4,-4,
147
-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
148
-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
149
-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
150
-4,-4,-4,-4,-4,-4,-4,-4,-4,-3,-3,-3,-3,-3,-3,-3,
151
-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
152
-3,-3,-3,-3,-3,-3,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
153
-2,-2,-2,-2,-1,-1,-1,-1,-1,-1,-1,-1,-0,-0,-0,-0,
154
};
155

    
156
static const int8_t quant11[256]={
157
 0, 1, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4,
158
 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
159
 4, 4, 4, 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,-5,-5,
167
-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
168
-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
169
-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
170
-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-4,-4,
171
-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
172
-4,-4,-4,-4,-4,-3,-3,-3,-3,-3,-3,-3,-2,-2,-2,-1,
173
};
174
static const int8_t quant13[256]={
175
 0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
176
 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
177
 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
178
 5, 5, 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,-6,
184
-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,
185
-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,
186
-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,
187
-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-5,
188
-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
189
-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
190
-4,-4,-4,-4,-4,-4,-4,-4,-4,-3,-3,-3,-3,-2,-2,-1,
191
};
192

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

    
212
typedef struct VlcState{
213
    int16_t drift;
214
    uint16_t error_sum;
215
    int8_t bias;
216
    uint8_t count;
217
} VlcState;
218

    
219
typedef struct PlaneContext{
220
    int16_t quant_table[MAX_CONTEXT_INPUTS][256];
221
    int quant_table_index;
222
    int context_count;
223
    uint8_t (*state)[CONTEXT_SIZE];
224
    VlcState *vlc_state;
225
    uint8_t interlace_bit_state[2];
226
} PlaneContext;
227

    
228
#define MAX_SLICES 256
229

    
230
typedef struct FFV1Context{
231
    AVCodecContext *avctx;
232
    RangeCoder c;
233
    GetBitContext gb;
234
    PutBitContext pb;
235
    uint64_t rc_stat[256][2];
236
    uint64_t (*rc_stat2[MAX_QUANT_TABLES])[32][2];
237
    int version;
238
    int width, height;
239
    int chroma_h_shift, chroma_v_shift;
240
    int flags;
241
    int picture_number;
242
    AVFrame picture;
243
    int plane_count;
244
    int ac;                              ///< 1=range coder <-> 0=golomb rice
245
    PlaneContext plane[MAX_PLANES];
246
    int16_t quant_table[MAX_CONTEXT_INPUTS][256];
247
    int16_t quant_tables[MAX_QUANT_TABLES][MAX_CONTEXT_INPUTS][256];
248
    int context_count[MAX_QUANT_TABLES];
249
    uint8_t state_transition[256];
250
    uint8_t (*initial_states[MAX_QUANT_TABLES])[32];
251
    int run_index;
252
    int colorspace;
253
    int_fast16_t *sample_buffer;
254

    
255
    int quant_table_count;
256

    
257
    DSPContext dsp;
258

    
259
    struct FFV1Context *slice_context[MAX_SLICES];
260
    int slice_count;
261
    int num_v_slices;
262
    int num_h_slices;
263
    int slice_width;
264
    int slice_height;
265
    int slice_x;
266
    int slice_y;
267
}FFV1Context;
268

    
269
static av_always_inline int fold(int diff, int bits){
270
    if(bits==8)
271
        diff= (int8_t)diff;
272
    else{
273
        diff+= 1<<(bits-1);
274
        diff&=(1<<bits)-1;
275
        diff-= 1<<(bits-1);
276
    }
277

    
278
    return diff;
279
}
280

    
281
static inline int predict(int_fast16_t *src, int_fast16_t *last){
282
    const int LT= last[-1];
283
    const int  T= last[ 0];
284
    const int L =  src[-1];
285

    
286
    return mid_pred(L, L + T - LT, T);
287
}
288

    
289
static inline int get_context(PlaneContext *p, int_fast16_t *src, int_fast16_t *last, int_fast16_t *last2){
290
    const int LT= last[-1];
291
    const int  T= last[ 0];
292
    const int RT= last[ 1];
293
    const int L =  src[-1];
294

    
295
    if(p->quant_table[3][127]){
296
        const int TT= last2[0];
297
        const int LL=  src[-2];
298
        return p->quant_table[0][(L-LT) & 0xFF] + p->quant_table[1][(LT-T) & 0xFF] + p->quant_table[2][(T-RT) & 0xFF]
299
              +p->quant_table[3][(LL-L) & 0xFF] + p->quant_table[4][(TT-T) & 0xFF];
300
    }else
301
        return p->quant_table[0][(L-LT) & 0xFF] + p->quant_table[1][(LT-T) & 0xFF] + p->quant_table[2][(T-RT) & 0xFF];
302
}
303

    
304
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]){
305
    int i;
306

    
307
#define put_rac(C,S,B) \
308
do{\
309
    if(rc_stat){\
310
    rc_stat[*(S)][B]++;\
311
        rc_stat2[(S)-state][B]++;\
312
    }\
313
    put_rac(C,S,B);\
314
}while(0)
315

    
316
    if(v){
317
        const int a= FFABS(v);
318
        const int e= av_log2(a);
319
        put_rac(c, state+0, 0);
320
        if(e<=9){
321
            for(i=0; i<e; i++){
322
                put_rac(c, state+1+i, 1);  //1..10
323
            }
324
            put_rac(c, state+1+i, 0);
325

    
326
            for(i=e-1; i>=0; i--){
327
                put_rac(c, state+22+i, (a>>i)&1); //22..31
328
            }
329

    
330
            if(is_signed)
331
                put_rac(c, state+11 + e, v < 0); //11..21
332
        }else{
333
            for(i=0; i<e; i++){
334
                put_rac(c, state+1+FFMIN(i,9), 1);  //1..10
335
            }
336
            put_rac(c, state+1+9, 0);
337

    
338
            for(i=e-1; i>=0; i--){
339
                put_rac(c, state+22+FFMIN(i,9), (a>>i)&1); //22..31
340
            }
341

    
342
            if(is_signed)
343
                put_rac(c, state+11 + 10, v < 0); //11..21
344
        }
345
    }else{
346
        put_rac(c, state+0, 1);
347
    }
348
#undef put_rac
349
}
350

    
351
static void av_noinline put_symbol(RangeCoder *c, uint8_t *state, int v, int is_signed){
352
    put_symbol_inline(c, state, v, is_signed, NULL, NULL);
353
}
354

    
355
static inline av_flatten int get_symbol_inline(RangeCoder *c, uint8_t *state, int is_signed){
356
    if(get_rac(c, state+0))
357
        return 0;
358
    else{
359
        int i, e, a;
360
        e= 0;
361
        while(get_rac(c, state+1 + FFMIN(e,9))){ //1..10
362
            e++;
363
        }
364

    
365
        a= 1;
366
        for(i=e-1; i>=0; i--){
367
            a += a + get_rac(c, state+22 + FFMIN(i,9)); //22..31
368
        }
369

    
370
        e= -(is_signed && get_rac(c, state+11 + FFMIN(e, 10))); //11..21
371
        return (a^e)-e;
372
    }
373
}
374

    
375
static int av_noinline get_symbol(RangeCoder *c, uint8_t *state, int is_signed){
376
    return get_symbol_inline(c, state, is_signed);
377
}
378

    
379
static inline void update_vlc_state(VlcState * const state, const int v){
380
    int drift= state->drift;
381
    int count= state->count;
382
    state->error_sum += FFABS(v);
383
    drift += v;
384

    
385
    if(count == 128){ //FIXME variable
386
        count >>= 1;
387
        drift >>= 1;
388
        state->error_sum >>= 1;
389
    }
390
    count++;
391

    
392
    if(drift <= -count){
393
        if(state->bias > -128) state->bias--;
394

    
395
        drift += count;
396
        if(drift <= -count)
397
            drift= -count + 1;
398
    }else if(drift > 0){
399
        if(state->bias <  127) state->bias++;
400

    
401
        drift -= count;
402
        if(drift > 0)
403
            drift= 0;
404
    }
405

    
406
    state->drift= drift;
407
    state->count= count;
408
}
409

    
410
static inline void put_vlc_symbol(PutBitContext *pb, VlcState * const state, int v, int bits){
411
    int i, k, code;
412
//printf("final: %d ", v);
413
    v = fold(v - state->bias, bits);
414

    
415
    i= state->count;
416
    k=0;
417
    while(i < state->error_sum){ //FIXME optimize
418
        k++;
419
        i += i;
420
    }
421

    
422
    assert(k<=8);
423

    
424
#if 0 // JPEG LS
425
    if(k==0 && 2*state->drift <= - state->count) code= v ^ (-1);
426
    else                                         code= v;
427
#else
428
     code= v ^ ((2*state->drift + state->count)>>31);
429
#endif
430

    
431
//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);
432
    set_sr_golomb(pb, code, k, 12, bits);
433

    
434
    update_vlc_state(state, v);
435
}
436

    
437
static inline int get_vlc_symbol(GetBitContext *gb, VlcState * const state, int bits){
438
    int k, i, v, ret;
439

    
440
    i= state->count;
441
    k=0;
442
    while(i < state->error_sum){ //FIXME optimize
443
        k++;
444
        i += i;
445
    }
446

    
447
    assert(k<=8);
448

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

    
452
#if 0 // JPEG LS
453
    if(k==0 && 2*state->drift <= - state->count) v ^= (-1);
454
#else
455
     v ^= ((2*state->drift + state->count)>>31);
456
#endif
457

    
458
    ret= fold(v + state->bias, bits);
459

    
460
    update_vlc_state(state, v);
461
//printf("final: %d\n", ret);
462
    return ret;
463
}
464

    
465
#if CONFIG_FFV1_ENCODER
466
static av_always_inline int encode_line(FFV1Context *s, int w, int_fast16_t *sample[2], int plane_index, int bits){
467
    PlaneContext * const p= &s->plane[plane_index];
468
    RangeCoder * const c= &s->c;
469
    int x;
470
    int run_index= s->run_index;
471
    int run_count=0;
472
    int run_mode=0;
473

    
474
    if(s->ac){
475
        if(c->bytestream_end - c->bytestream < w*20){
476
            av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
477
            return -1;
478
        }
479
    }else{
480
        if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < w*4){
481
            av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
482
            return -1;
483
        }
484
    }
485

    
486
    for(x=0; x<w; x++){
487
        int diff, context;
488

    
489
        context= get_context(p, sample[0]+x, sample[1]+x, sample[2]+x);
490
        diff= sample[0][x] - predict(sample[0]+x, sample[1]+x);
491

    
492
        if(context < 0){
493
            context = -context;
494
            diff= -diff;
495
        }
496

    
497
        diff= fold(diff, bits);
498

    
499
        if(s->ac){
500
            if(s->flags & CODEC_FLAG_PASS1){
501
                put_symbol_inline(c, p->state[context], diff, 1, s->rc_stat, s->rc_stat2[p->quant_table_index][context]);
502
            }else{
503
                put_symbol_inline(c, p->state[context], diff, 1, NULL, NULL);
504
            }
505
        }else{
506
            if(context == 0) run_mode=1;
507

    
508
            if(run_mode){
509

    
510
                if(diff){
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
                    put_bits(&s->pb, 1 + ff_log2_run[run_index], run_count);
518
                    if(run_index) run_index--;
519
                    run_count=0;
520
                    run_mode=0;
521
                    if(diff>0) diff--;
522
                }else{
523
                    run_count++;
524
                }
525
            }
526

    
527
//            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));
528

    
529
            if(run_mode == 0)
530
                put_vlc_symbol(&s->pb, &p->vlc_state[context], diff, bits);
531
        }
532
    }
533
    if(run_mode){
534
        while(run_count >= 1<<ff_log2_run[run_index]){
535
            run_count -= 1<<ff_log2_run[run_index];
536
            run_index++;
537
            put_bits(&s->pb, 1, 1);
538
        }
539

    
540
        if(run_count)
541
            put_bits(&s->pb, 1, 1);
542
    }
543
    s->run_index= run_index;
544

    
545
    return 0;
546
}
547

    
548
static void encode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
549
    int x,y,i;
550
    const int ring_size= s->avctx->context_model ? 3 : 2;
551
    int_fast16_t *sample[3];
552
    s->run_index=0;
553

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

    
556
    for(y=0; y<h; y++){
557
        for(i=0; i<ring_size; i++)
558
            sample[i]= s->sample_buffer + (w+6)*((h+i-y)%ring_size) + 3;
559

    
560
        sample[0][-1]= sample[1][0  ];
561
        sample[1][ w]= sample[1][w-1];
562
//{START_TIMER
563
        if(s->avctx->bits_per_raw_sample<=8){
564
            for(x=0; x<w; x++){
565
                sample[0][x]= src[x + stride*y];
566
            }
567
            encode_line(s, w, sample, plane_index, 8);
568
        }else{
569
            for(x=0; x<w; x++){
570
                sample[0][x]= ((uint16_t*)(src + stride*y))[x] >> (16 - s->avctx->bits_per_raw_sample);
571
            }
572
            encode_line(s, w, sample, plane_index, s->avctx->bits_per_raw_sample);
573
        }
574
//STOP_TIMER("encode line")}
575
    }
576
}
577

    
578
static void encode_rgb_frame(FFV1Context *s, uint32_t *src, int w, int h, int stride){
579
    int x, y, p, i;
580
    const int ring_size= s->avctx->context_model ? 3 : 2;
581
    int_fast16_t *sample[3][3];
582
    s->run_index=0;
583

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

    
586
    for(y=0; y<h; y++){
587
        for(i=0; i<ring_size; i++)
588
            for(p=0; p<3; p++)
589
                sample[p][i]= s->sample_buffer + p*ring_size*(w+6) + ((h+i-y)%ring_size)*(w+6) + 3;
590

    
591
        for(x=0; x<w; x++){
592
            int v= src[x + stride*y];
593
            int b= v&0xFF;
594
            int g= (v>>8)&0xFF;
595
            int r= (v>>16)&0xFF;
596

    
597
            b -= g;
598
            r -= g;
599
            g += (b + r)>>2;
600
            b += 0x100;
601
            r += 0x100;
602

    
603
//            assert(g>=0 && b>=0 && r>=0);
604
//            assert(g<256 && b<512 && r<512);
605
            sample[0][0][x]= g;
606
            sample[1][0][x]= b;
607
            sample[2][0][x]= r;
608
        }
609
        for(p=0; p<3; p++){
610
            sample[p][0][-1]= sample[p][1][0  ];
611
            sample[p][1][ w]= sample[p][1][w-1];
612
            encode_line(s, w, sample[p], FFMIN(p, 1), 9);
613
        }
614
    }
615
}
616

    
617
static void write_quant_table(RangeCoder *c, int16_t *quant_table){
618
    int last=0;
619
    int i;
620
    uint8_t state[CONTEXT_SIZE];
621
    memset(state, 128, sizeof(state));
622

    
623
    for(i=1; i<128 ; i++){
624
        if(quant_table[i] != quant_table[i-1]){
625
            put_symbol(c, state, i-last-1, 0);
626
            last= i;
627
        }
628
    }
629
    put_symbol(c, state, i-last-1, 0);
630
}
631

    
632
static void write_quant_tables(RangeCoder *c, int16_t quant_table[MAX_CONTEXT_INPUTS][256]){
633
    int i;
634
    for(i=0; i<5; i++)
635
        write_quant_table(c, quant_table[i]);
636
}
637

    
638
static void write_header(FFV1Context *f){
639
    uint8_t state[CONTEXT_SIZE];
640
    int i, j;
641
    RangeCoder * const c= &f->slice_context[0]->c;
642

    
643
    memset(state, 128, sizeof(state));
644

    
645
    if(f->version < 2){
646
        put_symbol(c, state, f->version, 0);
647
        put_symbol(c, state, f->ac, 0);
648
        if(f->ac>1){
649
            for(i=1; i<256; i++){
650
                put_symbol(c, state, f->state_transition[i] - c->one_state[i], 1);
651
            }
652
        }
653
        put_symbol(c, state, f->colorspace, 0); //YUV cs type
654
        if(f->version>0)
655
            put_symbol(c, state, f->avctx->bits_per_raw_sample, 0);
656
        put_rac(c, state, 1); //chroma planes
657
            put_symbol(c, state, f->chroma_h_shift, 0);
658
            put_symbol(c, state, f->chroma_v_shift, 0);
659
        put_rac(c, state, 0); //no transparency plane
660

    
661
        write_quant_tables(c, f->quant_table);
662
    }else{
663
        put_symbol(c, state, f->slice_count, 0);
664
        for(i=0; i<f->slice_count; i++){
665
            FFV1Context *fs= f->slice_context[i];
666
            put_symbol(c, state, (fs->slice_x     +1)*f->num_h_slices / f->width   , 0);
667
            put_symbol(c, state, (fs->slice_y     +1)*f->num_v_slices / f->height  , 0);
668
            put_symbol(c, state, (fs->slice_width +1)*f->num_h_slices / f->width -1, 0);
669
            put_symbol(c, state, (fs->slice_height+1)*f->num_v_slices / f->height-1, 0);
670
            for(j=0; j<f->plane_count; j++){
671
                put_symbol(c, state, f->plane[j].quant_table_index, 0);
672
                av_assert0(f->plane[j].quant_table_index == f->avctx->context_model);
673
            }
674
        }
675
    }
676
}
677
#endif /* CONFIG_FFV1_ENCODER */
678

    
679
static av_cold int common_init(AVCodecContext *avctx){
680
    FFV1Context *s = avctx->priv_data;
681

    
682
    s->avctx= avctx;
683
    s->flags= avctx->flags;
684

    
685
    dsputil_init(&s->dsp, avctx);
686

    
687
    s->width = avctx->width;
688
    s->height= avctx->height;
689

    
690
    assert(s->width && s->height);
691
    //defaults
692
    s->num_h_slices=1;
693
    s->num_v_slices=1;
694

    
695

    
696
    return 0;
697
}
698

    
699
static int init_slice_state(FFV1Context *f){
700
    int i, j;
701

    
702
    for(i=0; i<f->slice_count; i++){
703
        FFV1Context *fs= f->slice_context[i];
704
        for(j=0; j<f->plane_count; j++){
705
            PlaneContext * const p= &fs->plane[j];
706

    
707
            if(fs->ac){
708
                if(!p->    state) p->    state= av_malloc(CONTEXT_SIZE*p->context_count*sizeof(uint8_t));
709
                if(!p->    state)
710
                    return AVERROR(ENOMEM);
711
            }else{
712
                if(!p->vlc_state) p->vlc_state= av_malloc(p->context_count*sizeof(VlcState));
713
                if(!p->vlc_state)
714
                    return AVERROR(ENOMEM);
715
            }
716
        }
717

    
718
        if (fs->ac>1){
719
            //FIXME only redo if state_transition changed
720
            for(j=1; j<256; j++){
721
                fs->c.one_state [    j]= fs->state_transition[j];
722
                fs->c.zero_state[256-j]= 256-fs->c.one_state [j];
723
            }
724
        }
725
    }
726

    
727
    return 0;
728
}
729

    
730
static av_cold int init_slice_contexts(FFV1Context *f){
731
    int i;
732

    
733
    f->slice_count= f->num_h_slices * f->num_v_slices;
734

    
735
    for(i=0; i<f->slice_count; i++){
736
        FFV1Context *fs= av_mallocz(sizeof(*fs));
737
        int sx= i % f->num_h_slices;
738
        int sy= i / f->num_h_slices;
739
        int sxs= f->avctx->width * sx    / f->num_h_slices;
740
        int sxe= f->avctx->width *(sx+1) / f->num_h_slices;
741
        int sys= f->avctx->height* sy    / f->num_v_slices;
742
        int sye= f->avctx->height*(sy+1) / f->num_v_slices;
743
        f->slice_context[i]= fs;
744
        memcpy(fs, f, sizeof(*fs));
745

    
746
        fs->slice_width = sxe - sxs;
747
        fs->slice_height= sye - sys;
748
        fs->slice_x     = sxs;
749
        fs->slice_y     = sys;
750

    
751
        fs->sample_buffer = av_malloc(6 * (fs->width+6) * sizeof(*fs->sample_buffer));
752
        if (!fs->sample_buffer)
753
            return AVERROR(ENOMEM);
754
    }
755
    return 0;
756
}
757

    
758
static int allocate_initial_states(FFV1Context *f){
759
    int i;
760

    
761
    for(i=0; i<f->quant_table_count; i++){
762
        f->initial_states[i]= av_malloc(f->context_count[i]*sizeof(*f->initial_states[i]));
763
        if(!f->initial_states[i])
764
            return AVERROR(ENOMEM);
765
        memset(f->initial_states[i], 128, f->context_count[i]*sizeof(*f->initial_states[i]));
766
    }
767
    return 0;
768
}
769

    
770
#if CONFIG_FFV1_ENCODER
771
static int write_extra_header(FFV1Context *f){
772
    RangeCoder * const c= &f->c;
773
    uint8_t state[CONTEXT_SIZE];
774
    int i, j, k;
775
    uint8_t state2[32][CONTEXT_SIZE];
776

    
777
    memset(state2, 128, sizeof(state2));
778
    memset(state, 128, sizeof(state));
779

    
780
    f->avctx->extradata= av_malloc(f->avctx->extradata_size= 10000 + (11*11*5*5*5+11*11*11)*32);
781
    ff_init_range_encoder(c, f->avctx->extradata, f->avctx->extradata_size);
782
    ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
783

    
784
    put_symbol(c, state, f->version, 0);
785
    put_symbol(c, state, f->ac, 0);
786
    if(f->ac>1){
787
        for(i=1; i<256; i++){
788
            put_symbol(c, state, f->state_transition[i] - c->one_state[i], 1);
789
        }
790
    }
791
    put_symbol(c, state, f->colorspace, 0); //YUV cs type
792
    put_symbol(c, state, f->avctx->bits_per_raw_sample, 0);
793
    put_rac(c, state, 1); //chroma planes
794
        put_symbol(c, state, f->chroma_h_shift, 0);
795
        put_symbol(c, state, f->chroma_v_shift, 0);
796
    put_rac(c, state, 0); //no transparency plane
797
    put_symbol(c, state, f->num_h_slices-1, 0);
798
    put_symbol(c, state, f->num_v_slices-1, 0);
799

    
800
    put_symbol(c, state, f->quant_table_count, 0);
801
    for(i=0; i<f->quant_table_count; i++)
802
        write_quant_tables(c, f->quant_tables[i]);
803

    
804
    for(i=0; i<f->quant_table_count; i++){
805
        for(j=0; j<f->context_count[i]*CONTEXT_SIZE; j++)
806
            if(f->initial_states[i] && f->initial_states[i][0][j] != 128)
807
                break;
808
        if(j<f->context_count[i]*CONTEXT_SIZE){
809
            put_rac(c, state, 1);
810
            for(j=0; j<f->context_count[i]; j++){
811
                for(k=0; k<CONTEXT_SIZE; k++){
812
                    int pred= j ? f->initial_states[i][j-1][k] : 128;
813
                    put_symbol(c, state2[k], (int8_t)(f->initial_states[i][j][k]-pred), 1);
814
                }
815
            }
816
        }else{
817
            put_rac(c, state, 0);
818
        }
819
    }
820

    
821
    f->avctx->extradata_size= ff_rac_terminate(c);
822

    
823
    return 0;
824
}
825

    
826
static int sort_stt(FFV1Context *s, uint8_t stt[256]){
827
    int i,i2,changed,print=0;
828

    
829
    do{
830
        changed=0;
831
        for(i=12; i<244; i++){
832
            for(i2=i+1; i2<245 && i2<i+4; i2++){
833
#define COST(old, new) \
834
    s->rc_stat[old][0]*-log2((256-(new))/256.0)\
835
   +s->rc_stat[old][1]*-log2(     (new) /256.0)
836

    
837
#define COST2(old, new) \
838
    COST(old, new)\
839
   +COST(256-(old), 256-(new))
840

    
841
                double size0= COST2(i, i ) + COST2(i2, i2);
842
                double sizeX= COST2(i, i2) + COST2(i2, i );
843
                if(sizeX < size0 && i!=128 && i2!=128){
844
                    int j;
845
                    FFSWAP(int, stt[    i], stt[    i2]);
846
                    FFSWAP(int, s->rc_stat[i    ][0],s->rc_stat[    i2][0]);
847
                    FFSWAP(int, s->rc_stat[i    ][1],s->rc_stat[    i2][1]);
848
                    if(i != 256-i2){
849
                        FFSWAP(int, stt[256-i], stt[256-i2]);
850
                        FFSWAP(int, s->rc_stat[256-i][0],s->rc_stat[256-i2][0]);
851
                        FFSWAP(int, s->rc_stat[256-i][1],s->rc_stat[256-i2][1]);
852
                    }
853
                    for(j=1; j<256; j++){
854
                        if     (stt[j] == i ) stt[j] = i2;
855
                        else if(stt[j] == i2) stt[j] = i ;
856
                        if(i != 256-i2){
857
                            if     (stt[256-j] == 256-i ) stt[256-j] = 256-i2;
858
                            else if(stt[256-j] == 256-i2) stt[256-j] = 256-i ;
859
                        }
860
                    }
861
                    print=changed=1;
862
                }
863
            }
864
        }
865
    }while(changed);
866
    return print;
867
}
868

    
869
static av_cold int encode_init(AVCodecContext *avctx)
870
{
871
    FFV1Context *s = avctx->priv_data;
872
    int i, j;
873

    
874
    common_init(avctx);
875

    
876
    s->version=0;
877
    s->ac= avctx->coder_type ? 2:0;
878

    
879
    if(s->ac>1)
880
        for(i=1; i<256; i++)
881
            s->state_transition[i]=ver2_state[i];
882

    
883
    s->plane_count=2;
884
    for(i=0; i<256; i++){
885
        s->quant_table_count=2;
886
        if(avctx->bits_per_raw_sample <=8){
887
            s->quant_tables[0][0][i]=           quant11[i];
888
            s->quant_tables[0][1][i]=        11*quant11[i];
889
            s->quant_tables[0][2][i]=     11*11*quant11[i];
890
            s->quant_tables[1][0][i]=           quant11[i];
891
            s->quant_tables[1][1][i]=        11*quant11[i];
892
            s->quant_tables[1][2][i]=     11*11*quant5 [i];
893
            s->quant_tables[1][3][i]=   5*11*11*quant5 [i];
894
            s->quant_tables[1][4][i]= 5*5*11*11*quant5 [i];
895
        }else{
896
            s->quant_tables[0][0][i]=           quant9_10bit[i];
897
            s->quant_tables[0][1][i]=        11*quant9_10bit[i];
898
            s->quant_tables[0][2][i]=     11*11*quant9_10bit[i];
899
            s->quant_tables[1][0][i]=           quant9_10bit[i];
900
            s->quant_tables[1][1][i]=        11*quant9_10bit[i];
901
            s->quant_tables[1][2][i]=     11*11*quant5_10bit[i];
902
            s->quant_tables[1][3][i]=   5*11*11*quant5_10bit[i];
903
            s->quant_tables[1][4][i]= 5*5*11*11*quant5_10bit[i];
904
        }
905
    }
906
    s->context_count[0]= (11*11*11+1)/2;
907
    s->context_count[1]= (11*11*5*5*5+1)/2;
908
    memcpy(s->quant_table, s->quant_tables[avctx->context_model], sizeof(s->quant_table));
909

    
910
    for(i=0; i<s->plane_count; i++){
911
        PlaneContext * const p= &s->plane[i];
912

    
913
        memcpy(p->quant_table, s->quant_table, sizeof(p->quant_table));
914
        p->quant_table_index= avctx->context_model;
915
        p->context_count= s->context_count[p->quant_table_index];
916
    }
917

    
918
    if(allocate_initial_states(s) < 0)
919
        return AVERROR(ENOMEM);
920

    
921
    avctx->coded_frame= &s->picture;
922
    switch(avctx->pix_fmt){
923
    case PIX_FMT_YUV444P16:
924
    case PIX_FMT_YUV422P16:
925
    case PIX_FMT_YUV420P16:
926
        if(avctx->bits_per_raw_sample <=8){
927
            av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");
928
            return -1;
929
        }
930
        if(!s->ac){
931
            av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample of more than 8 needs -coder 1 currently\n");
932
            return -1;
933
        }
934
        s->version= FFMAX(s->version, 1);
935
    case PIX_FMT_YUV444P:
936
    case PIX_FMT_YUV422P:
937
    case PIX_FMT_YUV420P:
938
    case PIX_FMT_YUV411P:
939
    case PIX_FMT_YUV410P:
940
        s->colorspace= 0;
941
        break;
942
    case PIX_FMT_RGB32:
943
        s->colorspace= 1;
944
        break;
945
    default:
946
        av_log(avctx, AV_LOG_ERROR, "format not supported\n");
947
        return -1;
948
    }
949
    avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
950

    
951
    s->picture_number=0;
952

    
953
    if(avctx->stats_in){
954
        char *p= avctx->stats_in;
955

    
956
        for(;;){
957
            for(j=0; j<256; j++){
958
                for(i=0; i<2; i++){
959
                    char *next;
960
                    s->rc_stat[j][i]= strtol(p, &next, 0);
961
                    if(next==p){
962
                        av_log(avctx, AV_LOG_ERROR, "2Pass file invalid at %d %d [%s]\n", j,i,p);
963
                        return -1;
964
                    }
965
                    p=next;
966
                }
967
            }
968
            while(*p=='\n' || *p==' ') p++;
969
            if(p[0]==0) break;
970
        }
971
        sort_stt(s, s->state_transition);
972
    }
973

    
974
    if(s->version>1){
975
        s->num_h_slices=2;
976
        s->num_v_slices=2;
977
        write_extra_header(s);
978
    }
979

    
980
    if(init_slice_contexts(s) < 0)
981
        return -1;
982
    if(init_slice_state(s) < 0)
983
        return -1;
984

    
985
#define STATS_OUT_SIZE 1024*30
986
    if(avctx->flags & CODEC_FLAG_PASS1){
987
    avctx->stats_out= av_mallocz(STATS_OUT_SIZE);
988
        for(i=0; i<s->quant_table_count; i++){
989
            for(j=0; j<s->slice_count; j++){
990
                FFV1Context *sf= s->slice_context[j];
991
                av_assert0(!sf->rc_stat2[i]);
992
                sf->rc_stat2[i]= av_mallocz(s->context_count[i]*sizeof(*sf->rc_stat2[i]));
993
                if(!sf->rc_stat2[i])
994
                    return AVERROR(ENOMEM);
995
            }
996
        }
997
    }
998

    
999
    return 0;
1000
}
1001
#endif /* CONFIG_FFV1_ENCODER */
1002

    
1003

    
1004
static void clear_state(FFV1Context *f){
1005
    int i, si, j;
1006

    
1007
    for(si=0; si<f->slice_count; si++){
1008
        FFV1Context *fs= f->slice_context[si];
1009
        for(i=0; i<f->plane_count; i++){
1010
            PlaneContext *p= &fs->plane[i];
1011

    
1012
            p->interlace_bit_state[0]= 128;
1013
            p->interlace_bit_state[1]= 128;
1014

    
1015
            if(fs->ac){
1016
                if(f->initial_states[p->quant_table_index]){
1017
                    memcpy(p->state, f->initial_states[p->quant_table_index], CONTEXT_SIZE*p->context_count);
1018
                }else
1019
                memset(p->state, 128, CONTEXT_SIZE*p->context_count);
1020
            }else{
1021
            for(j=0; j<p->context_count; j++){
1022
                    p->vlc_state[j].drift= 0;
1023
                    p->vlc_state[j].error_sum= 4; //FFMAX((RANGE + 32)/64, 2);
1024
                    p->vlc_state[j].bias= 0;
1025
                    p->vlc_state[j].count= 1;
1026
            }
1027
            }
1028
        }
1029
    }
1030
}
1031

    
1032
#if CONFIG_FFV1_ENCODER
1033
static int encode_slice(AVCodecContext *c, void *arg){
1034
    FFV1Context *fs= *(void**)arg;
1035
    FFV1Context *f= fs->avctx->priv_data;
1036
    int width = fs->slice_width;
1037
    int height= fs->slice_height;
1038
    int x= fs->slice_x;
1039
    int y= fs->slice_y;
1040
    AVFrame * const p= &f->picture;
1041

    
1042
    if(f->colorspace==0){
1043
        const int chroma_width = -((-width )>>f->chroma_h_shift);
1044
        const int chroma_height= -((-height)>>f->chroma_v_shift);
1045
        const int cx= x>>f->chroma_h_shift;
1046
        const int cy= y>>f->chroma_v_shift;
1047

    
1048
        encode_plane(fs, p->data[0] + x + y*p->linesize[0], width, height, p->linesize[0], 0);
1049

    
1050
        encode_plane(fs, p->data[1] + cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1);
1051
        encode_plane(fs, p->data[2] + cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1);
1052
    }else{
1053
        encode_rgb_frame(fs, (uint32_t*)(p->data[0]) + x + y*(p->linesize[0]/4), width, height, p->linesize[0]/4);
1054
    }
1055
    emms_c();
1056

    
1057
    return 0;
1058
}
1059

    
1060
static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
1061
    FFV1Context *f = avctx->priv_data;
1062
    RangeCoder * const c= &f->slice_context[0]->c;
1063
    AVFrame *pict = data;
1064
    AVFrame * const p= &f->picture;
1065
    int used_count= 0;
1066
    uint8_t keystate=128;
1067
    uint8_t *buf_p;
1068
    int i;
1069

    
1070
    ff_init_range_encoder(c, buf, buf_size);
1071
    ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
1072

    
1073
    *p = *pict;
1074
    p->pict_type= FF_I_TYPE;
1075

    
1076
    if(avctx->gop_size==0 || f->picture_number % avctx->gop_size == 0){
1077
        put_rac(c, &keystate, 1);
1078
        p->key_frame= 1;
1079
        write_header(f);
1080
        clear_state(f);
1081
    }else{
1082
        put_rac(c, &keystate, 0);
1083
        p->key_frame= 0;
1084
    }
1085

    
1086
    if(!f->ac){
1087
        used_count += ff_rac_terminate(c);
1088
//printf("pos=%d\n", used_count);
1089
        init_put_bits(&f->slice_context[0]->pb, buf + used_count, buf_size - used_count);
1090
    }else if (f->ac>1){
1091
        int i;
1092
        for(i=1; i<256; i++){
1093
            c->one_state[i]= f->state_transition[i];
1094
            c->zero_state[256-i]= 256-c->one_state[i];
1095
        }
1096
    }
1097

    
1098
    for(i=1; i<f->slice_count; i++){
1099
        FFV1Context *fs= f->slice_context[i];
1100
        uint8_t *start= buf + (buf_size-used_count)*i/f->slice_count;
1101
        int len= buf_size/f->slice_count;
1102

    
1103
        if(fs->ac){
1104
            ff_init_range_encoder(&fs->c, start, len);
1105
        }else{
1106
            init_put_bits(&fs->pb, start, len);
1107
        }
1108
    }
1109
    avctx->execute(avctx, encode_slice, &f->slice_context[0], NULL, f->slice_count, sizeof(void*));
1110

    
1111
    buf_p=buf;
1112
    for(i=0; i<f->slice_count; i++){
1113
        FFV1Context *fs= f->slice_context[i];
1114
        int bytes;
1115

    
1116
        if(fs->ac){
1117
            uint8_t state=128;
1118
            put_rac(&fs->c, &state, 0);
1119
            bytes= ff_rac_terminate(&fs->c);
1120
        }else{
1121
            flush_put_bits(&fs->pb); //nicer padding FIXME
1122
            bytes= used_count + (put_bits_count(&fs->pb)+7)/8;
1123
            used_count= 0;
1124
        }
1125
        if(i>0){
1126
            av_assert0(bytes < buf_size/f->slice_count);
1127
            memmove(buf_p, fs->ac ? fs->c.bytestream_start : fs->pb.buf, bytes);
1128
            av_assert0(bytes < (1<<24));
1129
            AV_WB24(buf_p+bytes, bytes);
1130
            bytes+=3;
1131
        }
1132
        buf_p += bytes;
1133
    }
1134

    
1135
    if((avctx->flags&CODEC_FLAG_PASS1) && (f->picture_number&31)==0){
1136
        int j;
1137
        char *p= avctx->stats_out;
1138
        char *end= p + STATS_OUT_SIZE;
1139

    
1140
        memset(f->rc_stat, 0, sizeof(f->rc_stat));
1141
        for(j=0; j<f->slice_count; j++){
1142
            FFV1Context *fs= f->slice_context[j];
1143
            for(i=0; i<256; i++){
1144
                f->rc_stat[i][0] += fs->rc_stat[i][0];
1145
                f->rc_stat[i][1] += fs->rc_stat[i][1];
1146
            }
1147
        }
1148

    
1149
        for(j=0; j<256; j++){
1150
            snprintf(p, end-p, "%"PRIu64" %"PRIu64" ", f->rc_stat[j][0], f->rc_stat[j][1]);
1151
            p+= strlen(p);
1152
        }
1153
        snprintf(p, end-p, "\n");
1154
    } else if(avctx->flags&CODEC_FLAG_PASS1)
1155
        avctx->stats_out[0] = '\0';
1156

    
1157
    f->picture_number++;
1158
    return buf_p-buf;
1159
}
1160
#endif /* CONFIG_FFV1_ENCODER */
1161

    
1162
static av_cold int common_end(AVCodecContext *avctx){
1163
    FFV1Context *s = avctx->priv_data;
1164
    int i, j;
1165

    
1166
    for(j=0; j<s->slice_count; j++){
1167
        FFV1Context *fs= s->slice_context[j];
1168
        for(i=0; i<s->plane_count; i++){
1169
            PlaneContext *p= &fs->plane[i];
1170

    
1171
            av_freep(&p->state);
1172
            av_freep(&p->vlc_state);
1173
        }
1174
        av_freep(&fs->sample_buffer);
1175
    }
1176

    
1177
    av_freep(&avctx->stats_out);
1178
    for(j=0; j<s->quant_table_count; j++){
1179
        av_freep(&s->initial_states[j]);
1180
        for(i=0; i<s->slice_count; i++){
1181
            FFV1Context *sf= s->slice_context[i];
1182
            av_freep(&sf->rc_stat2[j]);
1183
        }
1184
    }
1185

    
1186
    return 0;
1187
}
1188

    
1189
static av_always_inline void decode_line(FFV1Context *s, int w, int_fast16_t *sample[2], int plane_index, int bits){
1190
    PlaneContext * const p= &s->plane[plane_index];
1191
    RangeCoder * const c= &s->c;
1192
    int x;
1193
    int run_count=0;
1194
    int run_mode=0;
1195
    int run_index= s->run_index;
1196

    
1197
    for(x=0; x<w; x++){
1198
        int diff, context, sign;
1199

    
1200
        context= get_context(p, sample[1] + x, sample[0] + x, sample[1] + x);
1201
        if(context < 0){
1202
            context= -context;
1203
            sign=1;
1204
        }else
1205
            sign=0;
1206

    
1207
        av_assert2(context < p->context_count);
1208

    
1209
        if(s->ac){
1210
            diff= get_symbol_inline(c, p->state[context], 1);
1211
        }else{
1212
            if(context == 0 && run_mode==0) run_mode=1;
1213

    
1214
            if(run_mode){
1215
                if(run_count==0 && run_mode==1){
1216
                    if(get_bits1(&s->gb)){
1217
                        run_count = 1<<ff_log2_run[run_index];
1218
                        if(x + run_count <= w) run_index++;
1219
                    }else{
1220
                        if(ff_log2_run[run_index]) run_count = get_bits(&s->gb, ff_log2_run[run_index]);
1221
                        else run_count=0;
1222
                        if(run_index) run_index--;
1223
                        run_mode=2;
1224
                    }
1225
                }
1226
                run_count--;
1227
                if(run_count < 0){
1228
                    run_mode=0;
1229
                    run_count=0;
1230
                    diff= get_vlc_symbol(&s->gb, &p->vlc_state[context], bits);
1231
                    if(diff>=0) diff++;
1232
                }else
1233
                    diff=0;
1234
            }else
1235
                diff= get_vlc_symbol(&s->gb, &p->vlc_state[context], bits);
1236

    
1237
//            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));
1238
        }
1239

    
1240
        if(sign) diff= -diff;
1241

    
1242
        sample[1][x]= (predict(sample[1] + x, sample[0] + x) + diff) & ((1<<bits)-1);
1243
    }
1244
    s->run_index= run_index;
1245
}
1246

    
1247
static void decode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
1248
    int x, y;
1249
    int_fast16_t *sample[2];
1250
    sample[0]=s->sample_buffer    +3;
1251
    sample[1]=s->sample_buffer+w+6+3;
1252

    
1253
    s->run_index=0;
1254

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

    
1257
    for(y=0; y<h; y++){
1258
        int_fast16_t *temp= sample[0]; //FIXME try a normal buffer
1259

    
1260
        sample[0]= sample[1];
1261
        sample[1]= temp;
1262

    
1263
        sample[1][-1]= sample[0][0  ];
1264
        sample[0][ w]= sample[0][w-1];
1265

    
1266
//{START_TIMER
1267
        if(s->avctx->bits_per_raw_sample <= 8){
1268
            decode_line(s, w, sample, plane_index, 8);
1269
            for(x=0; x<w; x++){
1270
                src[x + stride*y]= sample[1][x];
1271
            }
1272
        }else{
1273
            decode_line(s, w, sample, plane_index, s->avctx->bits_per_raw_sample);
1274
            for(x=0; x<w; x++){
1275
                ((uint16_t*)(src + stride*y))[x]= sample[1][x] << (16 - s->avctx->bits_per_raw_sample);
1276
            }
1277
        }
1278
//STOP_TIMER("decode-line")}
1279
    }
1280
}
1281

    
1282
static void decode_rgb_frame(FFV1Context *s, uint32_t *src, int w, int h, int stride){
1283
    int x, y, p;
1284
    int_fast16_t *sample[3][2];
1285
    for(x=0; x<3; x++){
1286
        sample[x][0] = s->sample_buffer +  x*2   *(w+6) + 3;
1287
        sample[x][1] = s->sample_buffer + (x*2+1)*(w+6) + 3;
1288
    }
1289

    
1290
    s->run_index=0;
1291

    
1292
    memset(s->sample_buffer, 0, 6*(w+6)*sizeof(*s->sample_buffer));
1293

    
1294
    for(y=0; y<h; y++){
1295
        for(p=0; p<3; p++){
1296
            int_fast16_t *temp= sample[p][0]; //FIXME try a normal buffer
1297

    
1298
            sample[p][0]= sample[p][1];
1299
            sample[p][1]= temp;
1300

    
1301
            sample[p][1][-1]= sample[p][0][0  ];
1302
            sample[p][0][ w]= sample[p][0][w-1];
1303
            decode_line(s, w, sample[p], FFMIN(p, 1), 9);
1304
        }
1305
        for(x=0; x<w; x++){
1306
            int g= sample[0][1][x];
1307
            int b= sample[1][1][x];
1308
            int r= sample[2][1][x];
1309

    
1310
//            assert(g>=0 && b>=0 && r>=0);
1311
//            assert(g<256 && b<512 && r<512);
1312

    
1313
            b -= 0x100;
1314
            r -= 0x100;
1315
            g -= (b + r)>>2;
1316
            b += g;
1317
            r += g;
1318

    
1319
            src[x + stride*y]= b + (g<<8) + (r<<16) + (0xFF<<24);
1320
        }
1321
    }
1322
}
1323

    
1324
static int decode_slice(AVCodecContext *c, void *arg){
1325
    FFV1Context *fs= *(void**)arg;
1326
    FFV1Context *f= fs->avctx->priv_data;
1327
    int width = fs->slice_width;
1328
    int height= fs->slice_height;
1329
    int x= fs->slice_x;
1330
    int y= fs->slice_y;
1331
    AVFrame * const p= &f->picture;
1332

    
1333
    av_assert1(width && height);
1334
    if(f->colorspace==0){
1335
        const int chroma_width = -((-width )>>f->chroma_h_shift);
1336
        const int chroma_height= -((-height)>>f->chroma_v_shift);
1337
        const int cx= x>>f->chroma_h_shift;
1338
        const int cy= y>>f->chroma_v_shift;
1339
        decode_plane(fs, p->data[0] + x + y*p->linesize[0], width, height, p->linesize[0], 0);
1340

    
1341
        decode_plane(fs, p->data[1] + cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1);
1342
        decode_plane(fs, p->data[2] + cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[2], 1);
1343
    }else{
1344
        decode_rgb_frame(fs, (uint32_t*)p->data[0] + x + y*(p->linesize[0]/4), width, height, p->linesize[0]/4);
1345
    }
1346

    
1347
    emms_c();
1348

    
1349
    return 0;
1350
}
1351

    
1352
static int read_quant_table(RangeCoder *c, int16_t *quant_table, int scale){
1353
    int v;
1354
    int i=0;
1355
    uint8_t state[CONTEXT_SIZE];
1356

    
1357
    memset(state, 128, sizeof(state));
1358

    
1359
    for(v=0; i<128 ; v++){
1360
        int len= get_symbol(c, state, 0) + 1;
1361

    
1362
        if(len + i > 128) return -1;
1363

    
1364
        while(len--){
1365
            quant_table[i] = scale*v;
1366
            i++;
1367
//printf("%2d ",v);
1368
//if(i%16==0) printf("\n");
1369
        }
1370
    }
1371

    
1372
    for(i=1; i<128; i++){
1373
        quant_table[256-i]= -quant_table[i];
1374
    }
1375
    quant_table[128]= -quant_table[127];
1376

    
1377
    return 2*v - 1;
1378
}
1379

    
1380
static int read_quant_tables(RangeCoder *c, int16_t quant_table[MAX_CONTEXT_INPUTS][256]){
1381
    int i;
1382
    int context_count=1;
1383

    
1384
    for(i=0; i<5; i++){
1385
        context_count*= read_quant_table(c, quant_table[i], context_count);
1386
        if(context_count > 32768U){
1387
            return -1;
1388
        }
1389
    }
1390
    return (context_count+1)/2;
1391
}
1392

    
1393
static int read_extra_header(FFV1Context *f){
1394
    RangeCoder * const c= &f->c;
1395
    uint8_t state[CONTEXT_SIZE];
1396
    int i, j, k;
1397
    uint8_t state2[32][CONTEXT_SIZE];
1398

    
1399
    memset(state2, 128, sizeof(state2));
1400
    memset(state, 128, sizeof(state));
1401

    
1402
    ff_init_range_decoder(c, f->avctx->extradata, f->avctx->extradata_size);
1403
    ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
1404

    
1405
    f->version= get_symbol(c, state, 0);
1406
    f->ac= f->avctx->coder_type= get_symbol(c, state, 0);
1407
    if(f->ac>1){
1408
        for(i=1; i<256; i++){
1409
            f->state_transition[i]= get_symbol(c, state, 1) + c->one_state[i];
1410
        }
1411
    }
1412
    f->colorspace= get_symbol(c, state, 0); //YUV cs type
1413
    f->avctx->bits_per_raw_sample= get_symbol(c, state, 0);
1414
    get_rac(c, state); //no chroma = false
1415
    f->chroma_h_shift= get_symbol(c, state, 0);
1416
    f->chroma_v_shift= get_symbol(c, state, 0);
1417
    get_rac(c, state); //transparency plane
1418
    f->plane_count= 2;
1419
    f->num_h_slices= 1 + get_symbol(c, state, 0);
1420
    f->num_v_slices= 1 + get_symbol(c, state, 0);
1421
    if(f->num_h_slices > (unsigned)f->width || f->num_v_slices > (unsigned)f->height){
1422
        av_log(f->avctx, AV_LOG_ERROR, "too many slices\n");
1423
        return -1;
1424
    }
1425

    
1426
    f->quant_table_count= get_symbol(c, state, 0);
1427
    if(f->quant_table_count > (unsigned)MAX_QUANT_TABLES)
1428
        return -1;
1429
    for(i=0; i<f->quant_table_count; i++){
1430
        if((f->context_count[i]= read_quant_tables(c, f->quant_tables[i])) < 0){
1431
            av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
1432
            return -1;
1433
        }
1434
    }
1435

    
1436
    if(allocate_initial_states(f) < 0)
1437
        return AVERROR(ENOMEM);
1438

    
1439
    for(i=0; i<f->quant_table_count; i++){
1440
        if(get_rac(c, state)){
1441
            for(j=0; j<f->context_count[i]; j++){
1442
                for(k=0; k<CONTEXT_SIZE; k++){
1443
                    int pred= j ? f->initial_states[i][j-1][k] : 128;
1444
                    f->initial_states[i][j][k]= (pred+get_symbol(c, state2[k], 1))&0xFF;
1445
                }
1446
            }
1447
        }
1448
    }
1449

    
1450
    return 0;
1451
}
1452

    
1453
static int read_header(FFV1Context *f){
1454
    uint8_t state[CONTEXT_SIZE];
1455
    int i, j, context_count;
1456
    RangeCoder * const c= &f->slice_context[0]->c;
1457

    
1458
    memset(state, 128, sizeof(state));
1459

    
1460
    if(f->version < 2){
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
        if(f->version>0)
1470
            f->avctx->bits_per_raw_sample= get_symbol(c, state, 0);
1471
        get_rac(c, state); //no chroma = false
1472
        f->chroma_h_shift= get_symbol(c, state, 0);
1473
        f->chroma_v_shift= get_symbol(c, state, 0);
1474
        get_rac(c, state); //transparency plane
1475
        f->plane_count= 2;
1476
    }
1477

    
1478
    if(f->colorspace==0){
1479
        if(f->avctx->bits_per_raw_sample<=8){
1480
            switch(16*f->chroma_h_shift + f->chroma_v_shift){
1481
            case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P; break;
1482
            case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P; break;
1483
            case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P; break;
1484
            case 0x20: f->avctx->pix_fmt= PIX_FMT_YUV411P; break;
1485
            case 0x22: f->avctx->pix_fmt= PIX_FMT_YUV410P; break;
1486
            default:
1487
                av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
1488
                return -1;
1489
            }
1490
        }else{
1491
            switch(16*f->chroma_h_shift + f->chroma_v_shift){
1492
            case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P16; break;
1493
            case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P16; break;
1494
            case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P16; break;
1495
            default:
1496
                av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
1497
                return -1;
1498
            }
1499
        }
1500
    }else if(f->colorspace==1){
1501
        if(f->chroma_h_shift || f->chroma_v_shift){
1502
            av_log(f->avctx, AV_LOG_ERROR, "chroma subsampling not supported in this colorspace\n");
1503
            return -1;
1504
        }
1505
        f->avctx->pix_fmt= PIX_FMT_RGB32;
1506
    }else{
1507
        av_log(f->avctx, AV_LOG_ERROR, "colorspace not supported\n");
1508
        return -1;
1509
    }
1510

    
1511
//printf("%d %d %d\n", f->chroma_h_shift, f->chroma_v_shift,f->avctx->pix_fmt);
1512
    if(f->version < 2){
1513
        context_count= read_quant_tables(c, f->quant_table);
1514
        if(context_count < 0){
1515
                av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
1516
                return -1;
1517
        }
1518
    }else{
1519
        f->slice_count= get_symbol(c, state, 0);
1520
        if(f->slice_count > (unsigned)MAX_SLICES)
1521
            return -1;
1522
    }
1523

    
1524
    for(j=0; j<f->slice_count; j++){
1525
        FFV1Context *fs= f->slice_context[j];
1526
        fs->ac= f->ac;
1527

    
1528
        if(f->version >= 2){
1529
            fs->slice_x     = get_symbol(c, state, 0)   *f->width ;
1530
            fs->slice_y     = get_symbol(c, state, 0)   *f->height;
1531
            fs->slice_width =(get_symbol(c, state, 0)+1)*f->width  + fs->slice_x;
1532
            fs->slice_height=(get_symbol(c, state, 0)+1)*f->height + fs->slice_y;
1533

    
1534
            fs->slice_x /= f->num_h_slices;
1535
            fs->slice_y /= f->num_v_slices;
1536
            fs->slice_width  = fs->slice_width /f->num_h_slices - fs->slice_x;
1537
            fs->slice_height = fs->slice_height/f->num_v_slices - fs->slice_y;
1538
            if((unsigned)fs->slice_width > f->width || (unsigned)fs->slice_height > f->height)
1539
                return -1;
1540
            if(    (unsigned)fs->slice_x + (uint64_t)fs->slice_width  > f->width
1541
                || (unsigned)fs->slice_y + (uint64_t)fs->slice_height > f->height)
1542
                return -1;
1543
        }
1544

    
1545
        for(i=0; i<f->plane_count; i++){
1546
            PlaneContext * const p= &fs->plane[i];
1547

    
1548
            if(f->version >= 2){
1549
                int idx=get_symbol(c, state, 0);
1550
                if(idx > (unsigned)f->quant_table_count){
1551
                    av_log(f->avctx, AV_LOG_ERROR, "quant_table_index out of range\n");
1552
                    return -1;
1553
                }
1554
                p->quant_table_index= idx;
1555
                memcpy(p->quant_table, f->quant_tables[idx], sizeof(p->quant_table));
1556
                context_count= f->context_count[idx];
1557
            }else{
1558
                memcpy(p->quant_table, f->quant_table, sizeof(p->quant_table));
1559
            }
1560

    
1561
            if(p->context_count < context_count){
1562
                av_freep(&p->state);
1563
                av_freep(&p->vlc_state);
1564
            }
1565
            p->context_count= context_count;
1566
        }
1567
    }
1568

    
1569
    return 0;
1570
}
1571

    
1572
static av_cold int decode_init(AVCodecContext *avctx)
1573
{
1574
    FFV1Context *f = avctx->priv_data;
1575

    
1576
    common_init(avctx);
1577

    
1578
    if(avctx->extradata && read_extra_header(f) < 0)
1579
        return -1;
1580

    
1581
    if(init_slice_contexts(f) < 0)
1582
        return -1;
1583

    
1584
    return 0;
1585
}
1586

    
1587
static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt){
1588
    const uint8_t *buf = avpkt->data;
1589
    int buf_size = avpkt->size;
1590
    FFV1Context *f = avctx->priv_data;
1591
    RangeCoder * const c= &f->slice_context[0]->c;
1592
    AVFrame * const p= &f->picture;
1593
    int bytes_read, i;
1594
    uint8_t keystate= 128;
1595
    const uint8_t *buf_p;
1596

    
1597
    AVFrame *picture = data;
1598

    
1599
    ff_init_range_decoder(c, buf, buf_size);
1600
    ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
1601

    
1602

    
1603
    p->pict_type= FF_I_TYPE; //FIXME I vs. P
1604
    if(get_rac(c, &keystate)){
1605
        p->key_frame= 1;
1606
        if(read_header(f) < 0)
1607
            return -1;
1608
        if(init_slice_state(f) < 0)
1609
            return -1;
1610

    
1611
        clear_state(f);
1612
    }else{
1613
        p->key_frame= 0;
1614
    }
1615
    if(f->ac>1){
1616
        int i;
1617
        for(i=1; i<256; i++){
1618
            c->one_state[i]= f->state_transition[i];
1619
            c->zero_state[256-i]= 256-c->one_state[i];
1620
        }
1621
    }
1622

    
1623
    p->reference= 0;
1624
    if(avctx->get_buffer(avctx, p) < 0){
1625
        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1626
        return -1;
1627
    }
1628

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

    
1632
    if(!f->ac){
1633
        bytes_read = c->bytestream - c->bytestream_start - 1;
1634
        if(bytes_read ==0) av_log(avctx, AV_LOG_ERROR, "error at end of AC stream\n"); //FIXME
1635
//printf("pos=%d\n", bytes_read);
1636
        init_get_bits(&f->slice_context[0]->gb, buf + bytes_read, buf_size - bytes_read);
1637
    } else {
1638
        bytes_read = 0; /* avoid warning */
1639
    }
1640

    
1641
    buf_p= buf + buf_size;
1642
    for(i=f->slice_count-1; i>0; i--){
1643
        FFV1Context *fs= f->slice_context[i];
1644
        int v= AV_RB24(buf_p-3)+3;
1645
        if(buf_p - buf <= v){
1646
            av_log(avctx, AV_LOG_ERROR, "Slice pointer chain broken\n");
1647
            return -1;
1648
        }
1649
        buf_p -= v;
1650
        if(fs->ac){
1651
            ff_init_range_decoder(&fs->c, buf_p, v);
1652
        }else{
1653
            init_get_bits(&fs->gb, buf_p, v);
1654
        }
1655
    }
1656

    
1657
    avctx->execute(avctx, decode_slice, &f->slice_context[0], NULL, f->slice_count, sizeof(void*));
1658
    f->picture_number++;
1659

    
1660
    *picture= *p;
1661

    
1662
    avctx->release_buffer(avctx, p); //FIXME
1663

    
1664
    *data_size = sizeof(AVFrame);
1665

    
1666
    return buf_size;
1667
}
1668

    
1669
AVCodec ffv1_decoder = {
1670
    "ffv1",
1671
    AVMEDIA_TYPE_VIDEO,
1672
    CODEC_ID_FFV1,
1673
    sizeof(FFV1Context),
1674
    decode_init,
1675
    NULL,
1676
    common_end,
1677
    decode_frame,
1678
    CODEC_CAP_DR1 /*| CODEC_CAP_DRAW_HORIZ_BAND*/,
1679
    NULL,
1680
    .long_name= NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1681
};
1682

    
1683
#if CONFIG_FFV1_ENCODER
1684
AVCodec ffv1_encoder = {
1685
    "ffv1",
1686
    AVMEDIA_TYPE_VIDEO,
1687
    CODEC_ID_FFV1,
1688
    sizeof(FFV1Context),
1689
    encode_init,
1690
    encode_frame,
1691
    common_end,
1692
    .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},
1693
    .long_name= NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1694
};
1695
#endif