Statistics
| Branch: | Revision:

ffmpeg / libavcodec / ffv1.c @ b0e1d0d9

History | View | Annotate | Download (58.5 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[41];
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
    int gob_count;
255
    int packed_at_lsb;
256

    
257
    int quant_table_count;
258

    
259
    DSPContext dsp;
260

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

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

    
280
    return diff;
281
}
282

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

    
288
    return mid_pred(L, L + T - LT, T);
289
}
290

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

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

    
306
static void find_best_state(uint8_t best_state[256][256], const uint8_t one_state[256]){
307
    int i,j,k,m;
308
    double l2tab[256];
309

    
310
    for(i=1; i<256; i++)
311
        l2tab[i]= log2(i/256.0);
312

    
313
    for(i=0; i<256; i++){
314
        double best_len[256];
315
        double p= i/256.0;
316

    
317
        for(j=0; j<256; j++)
318
            best_len[j]= 1<<30;
319

    
320
        for(j=FFMAX(i-10,1); j<FFMIN(i+11,256); j++){
321
            double occ[256]={0};
322
            double len=0;
323
            occ[j]=1.0;
324
            for(k=0; k<256; k++){
325
                double newocc[256]={0};
326
                for(m=0; m<256; m++){
327
                    if(occ[m]){
328
                        len -=occ[m]*(     p *l2tab[    m]
329
                                      + (1-p)*l2tab[256-m]);
330
                    }
331
                }
332
                if(len < best_len[k]){
333
                    best_len[k]= len;
334
                    best_state[i][k]= j;
335
                }
336
                for(m=0; m<256; m++){
337
                    if(occ[m]){
338
                        newocc[    one_state[    m]] += occ[m]*   p ;
339
                        newocc[256-one_state[256-m]] += occ[m]*(1-p);
340
                    }
341
                }
342
                memcpy(occ, newocc, sizeof(occ));
343
            }
344
        }
345
    }
346
}
347

    
348
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]){
349
    int i;
350

    
351
#define put_rac(C,S,B) \
352
do{\
353
    if(rc_stat){\
354
    rc_stat[*(S)][B]++;\
355
        rc_stat2[(S)-state][B]++;\
356
    }\
357
    put_rac(C,S,B);\
358
}while(0)
359

    
360
    if(v){
361
        const int a= FFABS(v);
362
        const int e= av_log2(a);
363
        put_rac(c, state+0, 0);
364
        if(e<=9){
365
            for(i=0; i<e; i++){
366
                put_rac(c, state+1+i, 1);  //1..10
367
            }
368
            put_rac(c, state+1+i, 0);
369

    
370
            for(i=e-1; i>=0; i--){
371
                put_rac(c, state+22+i, (a>>i)&1); //22..31
372
            }
373

    
374
            if(is_signed)
375
                put_rac(c, state+11 + e, v < 0); //11..21
376
        }else{
377
            for(i=0; i<e; i++){
378
                put_rac(c, state+1+FFMIN(i,9), 1);  //1..10
379
            }
380
            put_rac(c, state+1+9, 0);
381

    
382
            for(i=e-1; i>=0; i--){
383
                put_rac(c, state+22+FFMIN(i,9), (a>>i)&1); //22..31
384
            }
385

    
386
            if(is_signed)
387
                put_rac(c, state+11 + 10, v < 0); //11..21
388
        }
389
    }else{
390
        put_rac(c, state+0, 1);
391
    }
392
#undef put_rac
393
}
394

    
395
static void av_noinline put_symbol(RangeCoder *c, uint8_t *state, int v, int is_signed){
396
    put_symbol_inline(c, state, v, is_signed, NULL, NULL);
397
}
398

    
399
static inline av_flatten int get_symbol_inline(RangeCoder *c, uint8_t *state, int is_signed){
400
    if(get_rac(c, state+0))
401
        return 0;
402
    else{
403
        int i, e, a;
404
        e= 0;
405
        while(get_rac(c, state+1 + FFMIN(e,9))){ //1..10
406
            e++;
407
        }
408

    
409
        a= 1;
410
        for(i=e-1; i>=0; i--){
411
            a += a + get_rac(c, state+22 + FFMIN(i,9)); //22..31
412
        }
413

    
414
        e= -(is_signed && get_rac(c, state+11 + FFMIN(e, 10))); //11..21
415
        return (a^e)-e;
416
    }
417
}
418

    
419
static int av_noinline get_symbol(RangeCoder *c, uint8_t *state, int is_signed){
420
    return get_symbol_inline(c, state, is_signed);
421
}
422

    
423
static inline void update_vlc_state(VlcState * const state, const int v){
424
    int drift= state->drift;
425
    int count= state->count;
426
    state->error_sum += FFABS(v);
427
    drift += v;
428

    
429
    if(count == 128){ //FIXME variable
430
        count >>= 1;
431
        drift >>= 1;
432
        state->error_sum >>= 1;
433
    }
434
    count++;
435

    
436
    if(drift <= -count){
437
        if(state->bias > -128) state->bias--;
438

    
439
        drift += count;
440
        if(drift <= -count)
441
            drift= -count + 1;
442
    }else if(drift > 0){
443
        if(state->bias <  127) state->bias++;
444

    
445
        drift -= count;
446
        if(drift > 0)
447
            drift= 0;
448
    }
449

    
450
    state->drift= drift;
451
    state->count= count;
452
}
453

    
454
static inline void put_vlc_symbol(PutBitContext *pb, VlcState * const state, int v, int bits){
455
    int i, k, code;
456
//printf("final: %d ", v);
457
    v = fold(v - state->bias, bits);
458

    
459
    i= state->count;
460
    k=0;
461
    while(i < state->error_sum){ //FIXME optimize
462
        k++;
463
        i += i;
464
    }
465

    
466
    assert(k<=8);
467

    
468
#if 0 // JPEG LS
469
    if(k==0 && 2*state->drift <= - state->count) code= v ^ (-1);
470
    else                                         code= v;
471
#else
472
     code= v ^ ((2*state->drift + state->count)>>31);
473
#endif
474

    
475
//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);
476
    set_sr_golomb(pb, code, k, 12, bits);
477

    
478
    update_vlc_state(state, v);
479
}
480

    
481
static inline int get_vlc_symbol(GetBitContext *gb, VlcState * const state, int bits){
482
    int k, i, v, ret;
483

    
484
    i= state->count;
485
    k=0;
486
    while(i < state->error_sum){ //FIXME optimize
487
        k++;
488
        i += i;
489
    }
490

    
491
    assert(k<=8);
492

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

    
496
#if 0 // JPEG LS
497
    if(k==0 && 2*state->drift <= - state->count) v ^= (-1);
498
#else
499
     v ^= ((2*state->drift + state->count)>>31);
500
#endif
501

    
502
    ret= fold(v + state->bias, bits);
503

    
504
    update_vlc_state(state, v);
505
//printf("final: %d\n", ret);
506
    return ret;
507
}
508

    
509
#if CONFIG_FFV1_ENCODER
510
static av_always_inline int encode_line(FFV1Context *s, int w, int_fast16_t *sample[2], int plane_index, int bits){
511
    PlaneContext * const p= &s->plane[plane_index];
512
    RangeCoder * const c= &s->c;
513
    int x;
514
    int run_index= s->run_index;
515
    int run_count=0;
516
    int run_mode=0;
517

    
518
    if(s->ac){
519
        if(c->bytestream_end - c->bytestream < w*20){
520
            av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
521
            return -1;
522
        }
523
    }else{
524
        if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < w*4){
525
            av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
526
            return -1;
527
        }
528
    }
529

    
530
    for(x=0; x<w; x++){
531
        int diff, context;
532

    
533
        context= get_context(p, sample[0]+x, sample[1]+x, sample[2]+x);
534
        diff= sample[0][x] - predict(sample[0]+x, sample[1]+x);
535

    
536
        if(context < 0){
537
            context = -context;
538
            diff= -diff;
539
        }
540

    
541
        diff= fold(diff, bits);
542

    
543
        if(s->ac){
544
            if(s->flags & CODEC_FLAG_PASS1){
545
                put_symbol_inline(c, p->state[context], diff, 1, s->rc_stat, s->rc_stat2[p->quant_table_index][context]);
546
            }else{
547
                put_symbol_inline(c, p->state[context], diff, 1, NULL, NULL);
548
            }
549
        }else{
550
            if(context == 0) run_mode=1;
551

    
552
            if(run_mode){
553

    
554
                if(diff){
555
                    while(run_count >= 1<<ff_log2_run[run_index]){
556
                        run_count -= 1<<ff_log2_run[run_index];
557
                        run_index++;
558
                        put_bits(&s->pb, 1, 1);
559
                    }
560

    
561
                    put_bits(&s->pb, 1 + ff_log2_run[run_index], run_count);
562
                    if(run_index) run_index--;
563
                    run_count=0;
564
                    run_mode=0;
565
                    if(diff>0) diff--;
566
                }else{
567
                    run_count++;
568
                }
569
            }
570

    
571
//            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));
572

    
573
            if(run_mode == 0)
574
                put_vlc_symbol(&s->pb, &p->vlc_state[context], diff, bits);
575
        }
576
    }
577
    if(run_mode){
578
        while(run_count >= 1<<ff_log2_run[run_index]){
579
            run_count -= 1<<ff_log2_run[run_index];
580
            run_index++;
581
            put_bits(&s->pb, 1, 1);
582
        }
583

    
584
        if(run_count)
585
            put_bits(&s->pb, 1, 1);
586
    }
587
    s->run_index= run_index;
588

    
589
    return 0;
590
}
591

    
592
static void encode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
593
    int x,y,i;
594
    const int ring_size= s->avctx->context_model ? 3 : 2;
595
    int_fast16_t *sample[3];
596
    s->run_index=0;
597

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

    
600
    for(y=0; y<h; y++){
601
        for(i=0; i<ring_size; i++)
602
            sample[i]= s->sample_buffer + (w+6)*((h+i-y)%ring_size) + 3;
603

    
604
        sample[0][-1]= sample[1][0  ];
605
        sample[1][ w]= sample[1][w-1];
606
//{START_TIMER
607
        if(s->avctx->bits_per_raw_sample<=8){
608
            for(x=0; x<w; x++){
609
                sample[0][x]= src[x + stride*y];
610
            }
611
            encode_line(s, w, sample, plane_index, 8);
612
        }else{
613
            if(s->packed_at_lsb){
614
                for(x=0; x<w; x++){
615
                    sample[0][x]= ((uint16_t*)(src + stride*y))[x];
616
                }
617
            }else{
618
                for(x=0; x<w; x++){
619
                    sample[0][x]= ((uint16_t*)(src + stride*y))[x] >> (16 - s->avctx->bits_per_raw_sample);
620
                }
621
            }
622
            encode_line(s, w, sample, plane_index, s->avctx->bits_per_raw_sample);
623
        }
624
//STOP_TIMER("encode line")}
625
    }
626
}
627

    
628
static void encode_rgb_frame(FFV1Context *s, uint32_t *src, int w, int h, int stride){
629
    int x, y, p, i;
630
    const int ring_size= s->avctx->context_model ? 3 : 2;
631
    int_fast16_t *sample[3][3];
632
    s->run_index=0;
633

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

    
636
    for(y=0; y<h; y++){
637
        for(i=0; i<ring_size; i++)
638
            for(p=0; p<3; p++)
639
                sample[p][i]= s->sample_buffer + p*ring_size*(w+6) + ((h+i-y)%ring_size)*(w+6) + 3;
640

    
641
        for(x=0; x<w; x++){
642
            int v= src[x + stride*y];
643
            int b= v&0xFF;
644
            int g= (v>>8)&0xFF;
645
            int r= (v>>16)&0xFF;
646

    
647
            b -= g;
648
            r -= g;
649
            g += (b + r)>>2;
650
            b += 0x100;
651
            r += 0x100;
652

    
653
//            assert(g>=0 && b>=0 && r>=0);
654
//            assert(g<256 && b<512 && r<512);
655
            sample[0][0][x]= g;
656
            sample[1][0][x]= b;
657
            sample[2][0][x]= r;
658
        }
659
        for(p=0; p<3; p++){
660
            sample[p][0][-1]= sample[p][1][0  ];
661
            sample[p][1][ w]= sample[p][1][w-1];
662
            encode_line(s, w, sample[p], FFMIN(p, 1), 9);
663
        }
664
    }
665
}
666

    
667
static void write_quant_table(RangeCoder *c, int16_t *quant_table){
668
    int last=0;
669
    int i;
670
    uint8_t state[CONTEXT_SIZE];
671
    memset(state, 128, sizeof(state));
672

    
673
    for(i=1; i<128 ; i++){
674
        if(quant_table[i] != quant_table[i-1]){
675
            put_symbol(c, state, i-last-1, 0);
676
            last= i;
677
        }
678
    }
679
    put_symbol(c, state, i-last-1, 0);
680
}
681

    
682
static void write_quant_tables(RangeCoder *c, int16_t quant_table[MAX_CONTEXT_INPUTS][256]){
683
    int i;
684
    for(i=0; i<5; i++)
685
        write_quant_table(c, quant_table[i]);
686
}
687

    
688
static void write_header(FFV1Context *f){
689
    uint8_t state[CONTEXT_SIZE];
690
    int i, j;
691
    RangeCoder * const c= &f->slice_context[0]->c;
692

    
693
    memset(state, 128, sizeof(state));
694

    
695
    if(f->version < 2){
696
        put_symbol(c, state, f->version, 0);
697
        put_symbol(c, state, f->ac, 0);
698
        if(f->ac>1){
699
            for(i=1; i<256; i++){
700
                put_symbol(c, state, f->state_transition[i] - c->one_state[i], 1);
701
            }
702
        }
703
        put_symbol(c, state, f->colorspace, 0); //YUV cs type
704
        if(f->version>0)
705
            put_symbol(c, state, f->avctx->bits_per_raw_sample, 0);
706
        put_rac(c, state, 1); //chroma planes
707
            put_symbol(c, state, f->chroma_h_shift, 0);
708
            put_symbol(c, state, f->chroma_v_shift, 0);
709
        put_rac(c, state, 0); //no transparency plane
710

    
711
        write_quant_tables(c, f->quant_table);
712
    }else{
713
        put_symbol(c, state, f->slice_count, 0);
714
        for(i=0; i<f->slice_count; i++){
715
            FFV1Context *fs= f->slice_context[i];
716
            put_symbol(c, state, (fs->slice_x     +1)*f->num_h_slices / f->width   , 0);
717
            put_symbol(c, state, (fs->slice_y     +1)*f->num_v_slices / f->height  , 0);
718
            put_symbol(c, state, (fs->slice_width +1)*f->num_h_slices / f->width -1, 0);
719
            put_symbol(c, state, (fs->slice_height+1)*f->num_v_slices / f->height-1, 0);
720
            for(j=0; j<f->plane_count; j++){
721
                put_symbol(c, state, f->plane[j].quant_table_index, 0);
722
                av_assert0(f->plane[j].quant_table_index == f->avctx->context_model);
723
            }
724
        }
725
    }
726
}
727
#endif /* CONFIG_FFV1_ENCODER */
728

    
729
static av_cold int common_init(AVCodecContext *avctx){
730
    FFV1Context *s = avctx->priv_data;
731

    
732
    s->avctx= avctx;
733
    s->flags= avctx->flags;
734

    
735
    avcodec_get_frame_defaults(&s->picture);
736

    
737
    dsputil_init(&s->dsp, avctx);
738

    
739
    s->width = avctx->width;
740
    s->height= avctx->height;
741

    
742
    assert(s->width && s->height);
743
    //defaults
744
    s->num_h_slices=1;
745
    s->num_v_slices=1;
746

    
747

    
748
    return 0;
749
}
750

    
751
static int init_slice_state(FFV1Context *f){
752
    int i, j;
753

    
754
    for(i=0; i<f->slice_count; i++){
755
        FFV1Context *fs= f->slice_context[i];
756
        for(j=0; j<f->plane_count; j++){
757
            PlaneContext * const p= &fs->plane[j];
758

    
759
            if(fs->ac){
760
                if(!p->    state) p->    state= av_malloc(CONTEXT_SIZE*p->context_count*sizeof(uint8_t));
761
                if(!p->    state)
762
                    return AVERROR(ENOMEM);
763
            }else{
764
                if(!p->vlc_state) p->vlc_state= av_malloc(p->context_count*sizeof(VlcState));
765
                if(!p->vlc_state)
766
                    return AVERROR(ENOMEM);
767
            }
768
        }
769

    
770
        if (fs->ac>1){
771
            //FIXME only redo if state_transition changed
772
            for(j=1; j<256; j++){
773
                fs->c.one_state [    j]= fs->state_transition[j];
774
                fs->c.zero_state[256-j]= 256-fs->c.one_state [j];
775
            }
776
        }
777
    }
778

    
779
    return 0;
780
}
781

    
782
static av_cold int init_slice_contexts(FFV1Context *f){
783
    int i;
784

    
785
    f->slice_count= f->num_h_slices * f->num_v_slices;
786

    
787
    for(i=0; i<f->slice_count; i++){
788
        FFV1Context *fs= av_mallocz(sizeof(*fs));
789
        int sx= i % f->num_h_slices;
790
        int sy= i / f->num_h_slices;
791
        int sxs= f->avctx->width * sx    / f->num_h_slices;
792
        int sxe= f->avctx->width *(sx+1) / f->num_h_slices;
793
        int sys= f->avctx->height* sy    / f->num_v_slices;
794
        int sye= f->avctx->height*(sy+1) / f->num_v_slices;
795
        f->slice_context[i]= fs;
796
        memcpy(fs, f, sizeof(*fs));
797
        memset(fs->rc_stat2, 0, sizeof(fs->rc_stat2));
798

    
799
        fs->slice_width = sxe - sxs;
800
        fs->slice_height= sye - sys;
801
        fs->slice_x     = sxs;
802
        fs->slice_y     = sys;
803

    
804
        fs->sample_buffer = av_malloc(9 * (fs->width+6) * sizeof(*fs->sample_buffer));
805
        if (!fs->sample_buffer)
806
            return AVERROR(ENOMEM);
807
    }
808
    return 0;
809
}
810

    
811
static int allocate_initial_states(FFV1Context *f){
812
    int i;
813

    
814
    for(i=0; i<f->quant_table_count; i++){
815
        f->initial_states[i]= av_malloc(f->context_count[i]*sizeof(*f->initial_states[i]));
816
        if(!f->initial_states[i])
817
            return AVERROR(ENOMEM);
818
        memset(f->initial_states[i], 128, f->context_count[i]*sizeof(*f->initial_states[i]));
819
    }
820
    return 0;
821
}
822

    
823
#if CONFIG_FFV1_ENCODER
824
static int write_extra_header(FFV1Context *f){
825
    RangeCoder * const c= &f->c;
826
    uint8_t state[CONTEXT_SIZE];
827
    int i, j, k;
828
    uint8_t state2[32][CONTEXT_SIZE];
829

    
830
    memset(state2, 128, sizeof(state2));
831
    memset(state, 128, sizeof(state));
832

    
833
    f->avctx->extradata= av_malloc(f->avctx->extradata_size= 10000 + (11*11*5*5*5+11*11*11)*32);
834
    ff_init_range_encoder(c, f->avctx->extradata, f->avctx->extradata_size);
835
    ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
836

    
837
    put_symbol(c, state, f->version, 0);
838
    put_symbol(c, state, f->ac, 0);
839
    if(f->ac>1){
840
        for(i=1; i<256; i++){
841
            put_symbol(c, state, f->state_transition[i] - c->one_state[i], 1);
842
        }
843
    }
844
    put_symbol(c, state, f->colorspace, 0); //YUV cs type
845
    put_symbol(c, state, f->avctx->bits_per_raw_sample, 0);
846
    put_rac(c, state, 1); //chroma planes
847
        put_symbol(c, state, f->chroma_h_shift, 0);
848
        put_symbol(c, state, f->chroma_v_shift, 0);
849
    put_rac(c, state, 0); //no transparency plane
850
    put_symbol(c, state, f->num_h_slices-1, 0);
851
    put_symbol(c, state, f->num_v_slices-1, 0);
852

    
853
    put_symbol(c, state, f->quant_table_count, 0);
854
    for(i=0; i<f->quant_table_count; i++)
855
        write_quant_tables(c, f->quant_tables[i]);
856

    
857
    for(i=0; i<f->quant_table_count; i++){
858
        for(j=0; j<f->context_count[i]*CONTEXT_SIZE; j++)
859
            if(f->initial_states[i] && f->initial_states[i][0][j] != 128)
860
                break;
861
        if(j<f->context_count[i]*CONTEXT_SIZE){
862
            put_rac(c, state, 1);
863
            for(j=0; j<f->context_count[i]; j++){
864
                for(k=0; k<CONTEXT_SIZE; k++){
865
                    int pred= j ? f->initial_states[i][j-1][k] : 128;
866
                    put_symbol(c, state2[k], (int8_t)(f->initial_states[i][j][k]-pred), 1);
867
                }
868
            }
869
        }else{
870
            put_rac(c, state, 0);
871
        }
872
    }
873

    
874
    f->avctx->extradata_size= ff_rac_terminate(c);
875

    
876
    return 0;
877
}
878

    
879
static int sort_stt(FFV1Context *s, uint8_t stt[256]){
880
    int i,i2,changed,print=0;
881

    
882
    do{
883
        changed=0;
884
        for(i=12; i<244; i++){
885
            for(i2=i+1; i2<245 && i2<i+4; i2++){
886
#define COST(old, new) \
887
    s->rc_stat[old][0]*-log2((256-(new))/256.0)\
888
   +s->rc_stat[old][1]*-log2(     (new) /256.0)
889

    
890
#define COST2(old, new) \
891
    COST(old, new)\
892
   +COST(256-(old), 256-(new))
893

    
894
                double size0= COST2(i, i ) + COST2(i2, i2);
895
                double sizeX= COST2(i, i2) + COST2(i2, i );
896
                if(sizeX < size0 && i!=128 && i2!=128){
897
                    int j;
898
                    FFSWAP(int, stt[    i], stt[    i2]);
899
                    FFSWAP(int, s->rc_stat[i    ][0],s->rc_stat[    i2][0]);
900
                    FFSWAP(int, s->rc_stat[i    ][1],s->rc_stat[    i2][1]);
901
                    if(i != 256-i2){
902
                        FFSWAP(int, stt[256-i], stt[256-i2]);
903
                        FFSWAP(int, s->rc_stat[256-i][0],s->rc_stat[256-i2][0]);
904
                        FFSWAP(int, s->rc_stat[256-i][1],s->rc_stat[256-i2][1]);
905
                    }
906
                    for(j=1; j<256; j++){
907
                        if     (stt[j] == i ) stt[j] = i2;
908
                        else if(stt[j] == i2) stt[j] = i ;
909
                        if(i != 256-i2){
910
                            if     (stt[256-j] == 256-i ) stt[256-j] = 256-i2;
911
                            else if(stt[256-j] == 256-i2) stt[256-j] = 256-i ;
912
                        }
913
                    }
914
                    print=changed=1;
915
                }
916
            }
917
        }
918
    }while(changed);
919
    return print;
920
}
921

    
922
static av_cold int encode_init(AVCodecContext *avctx)
923
{
924
    FFV1Context *s = avctx->priv_data;
925
    int i, j, k, m;
926

    
927
    common_init(avctx);
928

    
929
    s->version=0;
930
    s->ac= avctx->coder_type ? 2:0;
931

    
932
    if(s->ac>1)
933
        for(i=1; i<256; i++)
934
            s->state_transition[i]=ver2_state[i];
935

    
936
    s->plane_count=2;
937
    for(i=0; i<256; i++){
938
        s->quant_table_count=2;
939
        if(avctx->bits_per_raw_sample <=8){
940
            s->quant_tables[0][0][i]=           quant11[i];
941
            s->quant_tables[0][1][i]=        11*quant11[i];
942
            s->quant_tables[0][2][i]=     11*11*quant11[i];
943
            s->quant_tables[1][0][i]=           quant11[i];
944
            s->quant_tables[1][1][i]=        11*quant11[i];
945
            s->quant_tables[1][2][i]=     11*11*quant5 [i];
946
            s->quant_tables[1][3][i]=   5*11*11*quant5 [i];
947
            s->quant_tables[1][4][i]= 5*5*11*11*quant5 [i];
948
        }else{
949
            s->quant_tables[0][0][i]=           quant9_10bit[i];
950
            s->quant_tables[0][1][i]=        11*quant9_10bit[i];
951
            s->quant_tables[0][2][i]=     11*11*quant9_10bit[i];
952
            s->quant_tables[1][0][i]=           quant9_10bit[i];
953
            s->quant_tables[1][1][i]=        11*quant9_10bit[i];
954
            s->quant_tables[1][2][i]=     11*11*quant5_10bit[i];
955
            s->quant_tables[1][3][i]=   5*11*11*quant5_10bit[i];
956
            s->quant_tables[1][4][i]= 5*5*11*11*quant5_10bit[i];
957
        }
958
    }
959
    s->context_count[0]= (11*11*11+1)/2;
960
    s->context_count[1]= (11*11*5*5*5+1)/2;
961
    memcpy(s->quant_table, s->quant_tables[avctx->context_model], sizeof(s->quant_table));
962

    
963
    for(i=0; i<s->plane_count; i++){
964
        PlaneContext * const p= &s->plane[i];
965

    
966
        memcpy(p->quant_table, s->quant_table, sizeof(p->quant_table));
967
        p->quant_table_index= avctx->context_model;
968
        p->context_count= s->context_count[p->quant_table_index];
969
    }
970

    
971
    if(allocate_initial_states(s) < 0)
972
        return AVERROR(ENOMEM);
973

    
974
    avctx->coded_frame= &s->picture;
975
    switch(avctx->pix_fmt){
976
    case PIX_FMT_YUV420P10:
977
    case PIX_FMT_YUV422P10:
978
        s->packed_at_lsb = 1;
979
    case PIX_FMT_YUV444P16:
980
    case PIX_FMT_YUV422P16:
981
    case PIX_FMT_YUV420P16:
982
        if(avctx->bits_per_raw_sample <=8){
983
            av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");
984
            return -1;
985
        }
986
        if(!s->ac){
987
            av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample of more than 8 needs -coder 1 currently\n");
988
            return -1;
989
        }
990
        s->version= FFMAX(s->version, 1);
991
    case PIX_FMT_YUV444P:
992
    case PIX_FMT_YUV422P:
993
    case PIX_FMT_YUV420P:
994
    case PIX_FMT_YUV411P:
995
    case PIX_FMT_YUV410P:
996
        s->colorspace= 0;
997
        break;
998
    case PIX_FMT_RGB32:
999
        s->colorspace= 1;
1000
        break;
1001
    default:
1002
        av_log(avctx, AV_LOG_ERROR, "format not supported\n");
1003
        return -1;
1004
    }
1005
    avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
1006

    
1007
    s->picture_number=0;
1008

    
1009
    if(avctx->flags & (CODEC_FLAG_PASS1|CODEC_FLAG_PASS2)){
1010
        for(i=0; i<s->quant_table_count; i++){
1011
            s->rc_stat2[i]= av_mallocz(s->context_count[i]*sizeof(*s->rc_stat2[i]));
1012
            if(!s->rc_stat2[i])
1013
                return AVERROR(ENOMEM);
1014
        }
1015
    }
1016
    if(avctx->stats_in){
1017
        char *p= avctx->stats_in;
1018
        uint8_t best_state[256][256];
1019
        int gob_count=0;
1020
        char *next;
1021

    
1022
        av_assert0(s->version>=2);
1023

    
1024
        for(;;){
1025
            for(j=0; j<256; j++){
1026
                for(i=0; i<2; i++){
1027
                    s->rc_stat[j][i]= strtol(p, &next, 0);
1028
                    if(next==p){
1029
                        av_log(avctx, AV_LOG_ERROR, "2Pass file invalid at %d %d [%s]\n", j,i,p);
1030
                        return -1;
1031
                    }
1032
                    p=next;
1033
                }
1034
            }
1035
            for(i=0; i<s->quant_table_count; i++){
1036
                for(j=0; j<s->context_count[i]; j++){
1037
                    for(k=0; k<32; k++){
1038
                        for(m=0; m<2; m++){
1039
                            s->rc_stat2[i][j][k][m]= strtol(p, &next, 0);
1040
                            if(next==p){
1041
                                av_log(avctx, AV_LOG_ERROR, "2Pass file invalid at %d %d %d %d [%s]\n", i,j,k,m,p);
1042
                                return -1;
1043
                            }
1044
                            p=next;
1045
                        }
1046
                    }
1047
                }
1048
            }
1049
            gob_count= strtol(p, &next, 0);
1050
            if(next==p || gob_count <0){
1051
                av_log(avctx, AV_LOG_ERROR, "2Pass file invalid\n");
1052
                return -1;
1053
            }
1054
            p=next;
1055
            while(*p=='\n' || *p==' ') p++;
1056
            if(p[0]==0) break;
1057
        }
1058
        sort_stt(s, s->state_transition);
1059

    
1060
        find_best_state(best_state, s->state_transition);
1061

    
1062
        for(i=0; i<s->quant_table_count; i++){
1063
            for(j=0; j<s->context_count[i]; j++){
1064
                for(k=0; k<32; k++){
1065
                    double p= 128;
1066
                    if(s->rc_stat2[i][j][k][0]+s->rc_stat2[i][j][k][1]){
1067
                        p=256.0*s->rc_stat2[i][j][k][1] / (s->rc_stat2[i][j][k][0]+s->rc_stat2[i][j][k][1]);
1068
                    }
1069
                    s->initial_states[i][j][k]= best_state[av_clip(round(p), 1, 255)][av_clip((s->rc_stat2[i][j][k][0]+s->rc_stat2[i][j][k][1])/gob_count, 0, 255)];
1070
                }
1071
            }
1072
        }
1073
    }
1074

    
1075
    if(s->version>1){
1076
        s->num_h_slices=2;
1077
        s->num_v_slices=2;
1078
        write_extra_header(s);
1079
    }
1080

    
1081
    if(init_slice_contexts(s) < 0)
1082
        return -1;
1083
    if(init_slice_state(s) < 0)
1084
        return -1;
1085

    
1086
#define STATS_OUT_SIZE 1024*1024*6
1087
    if(avctx->flags & CODEC_FLAG_PASS1){
1088
        avctx->stats_out= av_mallocz(STATS_OUT_SIZE);
1089
        for(i=0; i<s->quant_table_count; i++){
1090
            for(j=0; j<s->slice_count; j++){
1091
                FFV1Context *sf= s->slice_context[j];
1092
                av_assert0(!sf->rc_stat2[i]);
1093
                sf->rc_stat2[i]= av_mallocz(s->context_count[i]*sizeof(*sf->rc_stat2[i]));
1094
                if(!sf->rc_stat2[i])
1095
                    return AVERROR(ENOMEM);
1096
            }
1097
        }
1098
    }
1099

    
1100
    return 0;
1101
}
1102
#endif /* CONFIG_FFV1_ENCODER */
1103

    
1104

    
1105
static void clear_state(FFV1Context *f){
1106
    int i, si, j;
1107

    
1108
    for(si=0; si<f->slice_count; si++){
1109
        FFV1Context *fs= f->slice_context[si];
1110
        for(i=0; i<f->plane_count; i++){
1111
            PlaneContext *p= &fs->plane[i];
1112

    
1113
            p->interlace_bit_state[0]= 128;
1114
            p->interlace_bit_state[1]= 128;
1115

    
1116
            if(fs->ac){
1117
                if(f->initial_states[p->quant_table_index]){
1118
                    memcpy(p->state, f->initial_states[p->quant_table_index], CONTEXT_SIZE*p->context_count);
1119
                }else
1120
                memset(p->state, 128, CONTEXT_SIZE*p->context_count);
1121
            }else{
1122
            for(j=0; j<p->context_count; j++){
1123
                    p->vlc_state[j].drift= 0;
1124
                    p->vlc_state[j].error_sum= 4; //FFMAX((RANGE + 32)/64, 2);
1125
                    p->vlc_state[j].bias= 0;
1126
                    p->vlc_state[j].count= 1;
1127
            }
1128
            }
1129
        }
1130
    }
1131
}
1132

    
1133
#if CONFIG_FFV1_ENCODER
1134
static int encode_slice(AVCodecContext *c, void *arg){
1135
    FFV1Context *fs= *(void**)arg;
1136
    FFV1Context *f= fs->avctx->priv_data;
1137
    int width = fs->slice_width;
1138
    int height= fs->slice_height;
1139
    int x= fs->slice_x;
1140
    int y= fs->slice_y;
1141
    AVFrame * const p= &f->picture;
1142

    
1143
    if(f->colorspace==0){
1144
        const int chroma_width = -((-width )>>f->chroma_h_shift);
1145
        const int chroma_height= -((-height)>>f->chroma_v_shift);
1146
        const int cx= x>>f->chroma_h_shift;
1147
        const int cy= y>>f->chroma_v_shift;
1148

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

    
1151
        encode_plane(fs, p->data[1] + cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1);
1152
        encode_plane(fs, p->data[2] + cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1);
1153
    }else{
1154
        encode_rgb_frame(fs, (uint32_t*)(p->data[0]) + x + y*(p->linesize[0]/4), width, height, p->linesize[0]/4);
1155
    }
1156
    emms_c();
1157

    
1158
    return 0;
1159
}
1160

    
1161
static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
1162
    FFV1Context *f = avctx->priv_data;
1163
    RangeCoder * const c= &f->slice_context[0]->c;
1164
    AVFrame *pict = data;
1165
    AVFrame * const p= &f->picture;
1166
    int used_count= 0;
1167
    uint8_t keystate=128;
1168
    uint8_t *buf_p;
1169
    int i;
1170

    
1171
    ff_init_range_encoder(c, buf, buf_size);
1172
    ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
1173

    
1174
    *p = *pict;
1175
    p->pict_type= AV_PICTURE_TYPE_I;
1176

    
1177
    if(avctx->gop_size==0 || f->picture_number % avctx->gop_size == 0){
1178
        put_rac(c, &keystate, 1);
1179
        p->key_frame= 1;
1180
        f->gob_count++;
1181
        write_header(f);
1182
        clear_state(f);
1183
    }else{
1184
        put_rac(c, &keystate, 0);
1185
        p->key_frame= 0;
1186
    }
1187

    
1188
    if(!f->ac){
1189
        used_count += ff_rac_terminate(c);
1190
//printf("pos=%d\n", used_count);
1191
        init_put_bits(&f->slice_context[0]->pb, buf + used_count, buf_size - used_count);
1192
    }else if (f->ac>1){
1193
        int i;
1194
        for(i=1; i<256; i++){
1195
            c->one_state[i]= f->state_transition[i];
1196
            c->zero_state[256-i]= 256-c->one_state[i];
1197
        }
1198
    }
1199

    
1200
    for(i=1; i<f->slice_count; i++){
1201
        FFV1Context *fs= f->slice_context[i];
1202
        uint8_t *start= buf + (buf_size-used_count)*i/f->slice_count;
1203
        int len= buf_size/f->slice_count;
1204

    
1205
        if(fs->ac){
1206
            ff_init_range_encoder(&fs->c, start, len);
1207
        }else{
1208
            init_put_bits(&fs->pb, start, len);
1209
        }
1210
    }
1211
    avctx->execute(avctx, encode_slice, &f->slice_context[0], NULL, f->slice_count, sizeof(void*));
1212

    
1213
    buf_p=buf;
1214
    for(i=0; i<f->slice_count; i++){
1215
        FFV1Context *fs= f->slice_context[i];
1216
        int bytes;
1217

    
1218
        if(fs->ac){
1219
            uint8_t state=128;
1220
            put_rac(&fs->c, &state, 0);
1221
            bytes= ff_rac_terminate(&fs->c);
1222
        }else{
1223
            flush_put_bits(&fs->pb); //nicer padding FIXME
1224
            bytes= used_count + (put_bits_count(&fs->pb)+7)/8;
1225
            used_count= 0;
1226
        }
1227
        if(i>0){
1228
            av_assert0(bytes < buf_size/f->slice_count);
1229
            memmove(buf_p, fs->ac ? fs->c.bytestream_start : fs->pb.buf, bytes);
1230
            av_assert0(bytes < (1<<24));
1231
            AV_WB24(buf_p+bytes, bytes);
1232
            bytes+=3;
1233
        }
1234
        buf_p += bytes;
1235
    }
1236

    
1237
    if((avctx->flags&CODEC_FLAG_PASS1) && (f->picture_number&31)==0){
1238
        int j, k, m;
1239
        char *p= avctx->stats_out;
1240
        char *end= p + STATS_OUT_SIZE;
1241

    
1242
        memset(f->rc_stat, 0, sizeof(f->rc_stat));
1243
        for(i=0; i<f->quant_table_count; i++)
1244
            memset(f->rc_stat2[i], 0, f->context_count[i]*sizeof(*f->rc_stat2[i]));
1245

    
1246
        for(j=0; j<f->slice_count; j++){
1247
            FFV1Context *fs= f->slice_context[j];
1248
            for(i=0; i<256; i++){
1249
                f->rc_stat[i][0] += fs->rc_stat[i][0];
1250
                f->rc_stat[i][1] += fs->rc_stat[i][1];
1251
            }
1252
            for(i=0; i<f->quant_table_count; i++){
1253
                for(k=0; k<f->context_count[i]; k++){
1254
                    for(m=0; m<32; m++){
1255
                        f->rc_stat2[i][k][m][0] += fs->rc_stat2[i][k][m][0];
1256
                        f->rc_stat2[i][k][m][1] += fs->rc_stat2[i][k][m][1];
1257
                    }
1258
                }
1259
            }
1260
        }
1261

    
1262
        for(j=0; j<256; j++){
1263
            snprintf(p, end-p, "%"PRIu64" %"PRIu64" ", f->rc_stat[j][0], f->rc_stat[j][1]);
1264
            p+= strlen(p);
1265
        }
1266
        snprintf(p, end-p, "\n");
1267

    
1268
        for(i=0; i<f->quant_table_count; i++){
1269
            for(j=0; j<f->context_count[i]; j++){
1270
                for(m=0; m<32; m++){
1271
                    snprintf(p, end-p, "%"PRIu64" %"PRIu64" ", f->rc_stat2[i][j][m][0], f->rc_stat2[i][j][m][1]);
1272
                    p+= strlen(p);
1273
                }
1274
            }
1275
        }
1276
        snprintf(p, end-p, "%d\n", f->gob_count);
1277
    } else if(avctx->flags&CODEC_FLAG_PASS1)
1278
        avctx->stats_out[0] = '\0';
1279

    
1280
    f->picture_number++;
1281
    return buf_p-buf;
1282
}
1283
#endif /* CONFIG_FFV1_ENCODER */
1284

    
1285
static av_cold int common_end(AVCodecContext *avctx){
1286
    FFV1Context *s = avctx->priv_data;
1287
    int i, j;
1288

    
1289
    if (avctx->codec->decode && s->picture.data[0])
1290
        avctx->release_buffer(avctx, &s->picture);
1291

    
1292
    for(j=0; j<s->slice_count; j++){
1293
        FFV1Context *fs= s->slice_context[j];
1294
        for(i=0; i<s->plane_count; i++){
1295
            PlaneContext *p= &fs->plane[i];
1296

    
1297
            av_freep(&p->state);
1298
            av_freep(&p->vlc_state);
1299
        }
1300
        av_freep(&fs->sample_buffer);
1301
    }
1302

    
1303
    av_freep(&avctx->stats_out);
1304
    for(j=0; j<s->quant_table_count; j++){
1305
        av_freep(&s->initial_states[j]);
1306
        for(i=0; i<s->slice_count; i++){
1307
            FFV1Context *sf= s->slice_context[i];
1308
            av_freep(&sf->rc_stat2[j]);
1309
        }
1310
        av_freep(&s->rc_stat2[j]);
1311
    }
1312

    
1313
    for(i=0; i<s->slice_count; i++){
1314
        av_freep(&s->slice_context[i]);
1315
    }
1316

    
1317
    return 0;
1318
}
1319

    
1320
static av_always_inline void decode_line(FFV1Context *s, int w, int_fast16_t *sample[2], int plane_index, int bits){
1321
    PlaneContext * const p= &s->plane[plane_index];
1322
    RangeCoder * const c= &s->c;
1323
    int x;
1324
    int run_count=0;
1325
    int run_mode=0;
1326
    int run_index= s->run_index;
1327

    
1328
    for(x=0; x<w; x++){
1329
        int diff, context, sign;
1330

    
1331
        context= get_context(p, sample[1] + x, sample[0] + x, sample[1] + x);
1332
        if(context < 0){
1333
            context= -context;
1334
            sign=1;
1335
        }else
1336
            sign=0;
1337

    
1338
        av_assert2(context < p->context_count);
1339

    
1340
        if(s->ac){
1341
            diff= get_symbol_inline(c, p->state[context], 1);
1342
        }else{
1343
            if(context == 0 && run_mode==0) run_mode=1;
1344

    
1345
            if(run_mode){
1346
                if(run_count==0 && run_mode==1){
1347
                    if(get_bits1(&s->gb)){
1348
                        run_count = 1<<ff_log2_run[run_index];
1349
                        if(x + run_count <= w) run_index++;
1350
                    }else{
1351
                        if(ff_log2_run[run_index]) run_count = get_bits(&s->gb, ff_log2_run[run_index]);
1352
                        else run_count=0;
1353
                        if(run_index) run_index--;
1354
                        run_mode=2;
1355
                    }
1356
                }
1357
                run_count--;
1358
                if(run_count < 0){
1359
                    run_mode=0;
1360
                    run_count=0;
1361
                    diff= get_vlc_symbol(&s->gb, &p->vlc_state[context], bits);
1362
                    if(diff>=0) diff++;
1363
                }else
1364
                    diff=0;
1365
            }else
1366
                diff= get_vlc_symbol(&s->gb, &p->vlc_state[context], bits);
1367

    
1368
//            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));
1369
        }
1370

    
1371
        if(sign) diff= -diff;
1372

    
1373
        sample[1][x]= (predict(sample[1] + x, sample[0] + x) + diff) & ((1<<bits)-1);
1374
    }
1375
    s->run_index= run_index;
1376
}
1377

    
1378
static void decode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
1379
    int x, y;
1380
    int_fast16_t *sample[2];
1381
    sample[0]=s->sample_buffer    +3;
1382
    sample[1]=s->sample_buffer+w+6+3;
1383

    
1384
    s->run_index=0;
1385

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

    
1388
    for(y=0; y<h; y++){
1389
        int_fast16_t *temp= sample[0]; //FIXME try a normal buffer
1390

    
1391
        sample[0]= sample[1];
1392
        sample[1]= temp;
1393

    
1394
        sample[1][-1]= sample[0][0  ];
1395
        sample[0][ w]= sample[0][w-1];
1396

    
1397
//{START_TIMER
1398
        if(s->avctx->bits_per_raw_sample <= 8){
1399
            decode_line(s, w, sample, plane_index, 8);
1400
            for(x=0; x<w; x++){
1401
                src[x + stride*y]= sample[1][x];
1402
            }
1403
        }else{
1404
            decode_line(s, w, sample, plane_index, s->avctx->bits_per_raw_sample);
1405
            for(x=0; x<w; x++){
1406
                ((uint16_t*)(src + stride*y))[x]= sample[1][x] << (16 - s->avctx->bits_per_raw_sample);
1407
            }
1408
        }
1409
//STOP_TIMER("decode-line")}
1410
    }
1411
}
1412

    
1413
static void decode_rgb_frame(FFV1Context *s, uint32_t *src, int w, int h, int stride){
1414
    int x, y, p;
1415
    int_fast16_t *sample[3][2];
1416
    for(x=0; x<3; x++){
1417
        sample[x][0] = s->sample_buffer +  x*2   *(w+6) + 3;
1418
        sample[x][1] = s->sample_buffer + (x*2+1)*(w+6) + 3;
1419
    }
1420

    
1421
    s->run_index=0;
1422

    
1423
    memset(s->sample_buffer, 0, 6*(w+6)*sizeof(*s->sample_buffer));
1424

    
1425
    for(y=0; y<h; y++){
1426
        for(p=0; p<3; p++){
1427
            int_fast16_t *temp= sample[p][0]; //FIXME try a normal buffer
1428

    
1429
            sample[p][0]= sample[p][1];
1430
            sample[p][1]= temp;
1431

    
1432
            sample[p][1][-1]= sample[p][0][0  ];
1433
            sample[p][0][ w]= sample[p][0][w-1];
1434
            decode_line(s, w, sample[p], FFMIN(p, 1), 9);
1435
        }
1436
        for(x=0; x<w; x++){
1437
            int g= sample[0][1][x];
1438
            int b= sample[1][1][x];
1439
            int r= sample[2][1][x];
1440

    
1441
//            assert(g>=0 && b>=0 && r>=0);
1442
//            assert(g<256 && b<512 && r<512);
1443

    
1444
            b -= 0x100;
1445
            r -= 0x100;
1446
            g -= (b + r)>>2;
1447
            b += g;
1448
            r += g;
1449

    
1450
            src[x + stride*y]= b + (g<<8) + (r<<16) + (0xFF<<24);
1451
        }
1452
    }
1453
}
1454

    
1455
static int decode_slice(AVCodecContext *c, void *arg){
1456
    FFV1Context *fs= *(void**)arg;
1457
    FFV1Context *f= fs->avctx->priv_data;
1458
    int width = fs->slice_width;
1459
    int height= fs->slice_height;
1460
    int x= fs->slice_x;
1461
    int y= fs->slice_y;
1462
    AVFrame * const p= &f->picture;
1463

    
1464
    av_assert1(width && height);
1465
    if(f->colorspace==0){
1466
        const int chroma_width = -((-width )>>f->chroma_h_shift);
1467
        const int chroma_height= -((-height)>>f->chroma_v_shift);
1468
        const int cx= x>>f->chroma_h_shift;
1469
        const int cy= y>>f->chroma_v_shift;
1470
        decode_plane(fs, p->data[0] + x + y*p->linesize[0], width, height, p->linesize[0], 0);
1471

    
1472
        decode_plane(fs, p->data[1] + cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1);
1473
        decode_plane(fs, p->data[2] + cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[2], 1);
1474
    }else{
1475
        decode_rgb_frame(fs, (uint32_t*)p->data[0] + x + y*(p->linesize[0]/4), width, height, p->linesize[0]/4);
1476
    }
1477

    
1478
    emms_c();
1479

    
1480
    return 0;
1481
}
1482

    
1483
static int read_quant_table(RangeCoder *c, int16_t *quant_table, int scale){
1484
    int v;
1485
    int i=0;
1486
    uint8_t state[CONTEXT_SIZE];
1487

    
1488
    memset(state, 128, sizeof(state));
1489

    
1490
    for(v=0; i<128 ; v++){
1491
        int len= get_symbol(c, state, 0) + 1;
1492

    
1493
        if(len + i > 128) return -1;
1494

    
1495
        while(len--){
1496
            quant_table[i] = scale*v;
1497
            i++;
1498
//printf("%2d ",v);
1499
//if(i%16==0) printf("\n");
1500
        }
1501
    }
1502

    
1503
    for(i=1; i<128; i++){
1504
        quant_table[256-i]= -quant_table[i];
1505
    }
1506
    quant_table[128]= -quant_table[127];
1507

    
1508
    return 2*v - 1;
1509
}
1510

    
1511
static int read_quant_tables(RangeCoder *c, int16_t quant_table[MAX_CONTEXT_INPUTS][256]){
1512
    int i;
1513
    int context_count=1;
1514

    
1515
    for(i=0; i<5; i++){
1516
        context_count*= read_quant_table(c, quant_table[i], context_count);
1517
        if(context_count > 32768U){
1518
            return -1;
1519
        }
1520
    }
1521
    return (context_count+1)/2;
1522
}
1523

    
1524
static int read_extra_header(FFV1Context *f){
1525
    RangeCoder * const c= &f->c;
1526
    uint8_t state[CONTEXT_SIZE];
1527
    int i, j, k;
1528
    uint8_t state2[32][CONTEXT_SIZE];
1529

    
1530
    memset(state2, 128, sizeof(state2));
1531
    memset(state, 128, sizeof(state));
1532

    
1533
    ff_init_range_decoder(c, f->avctx->extradata, f->avctx->extradata_size);
1534
    ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
1535

    
1536
    f->version= get_symbol(c, state, 0);
1537
    f->ac= f->avctx->coder_type= get_symbol(c, state, 0);
1538
    if(f->ac>1){
1539
        for(i=1; i<256; i++){
1540
            f->state_transition[i]= get_symbol(c, state, 1) + c->one_state[i];
1541
        }
1542
    }
1543
    f->colorspace= get_symbol(c, state, 0); //YUV cs type
1544
    f->avctx->bits_per_raw_sample= get_symbol(c, state, 0);
1545
    get_rac(c, state); //no chroma = false
1546
    f->chroma_h_shift= get_symbol(c, state, 0);
1547
    f->chroma_v_shift= get_symbol(c, state, 0);
1548
    get_rac(c, state); //transparency plane
1549
    f->plane_count= 2;
1550
    f->num_h_slices= 1 + get_symbol(c, state, 0);
1551
    f->num_v_slices= 1 + get_symbol(c, state, 0);
1552
    if(f->num_h_slices > (unsigned)f->width || f->num_v_slices > (unsigned)f->height){
1553
        av_log(f->avctx, AV_LOG_ERROR, "too many slices\n");
1554
        return -1;
1555
    }
1556

    
1557
    f->quant_table_count= get_symbol(c, state, 0);
1558
    if(f->quant_table_count > (unsigned)MAX_QUANT_TABLES)
1559
        return -1;
1560
    for(i=0; i<f->quant_table_count; i++){
1561
        if((f->context_count[i]= read_quant_tables(c, f->quant_tables[i])) < 0){
1562
            av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
1563
            return -1;
1564
        }
1565
    }
1566

    
1567
    if(allocate_initial_states(f) < 0)
1568
        return AVERROR(ENOMEM);
1569

    
1570
    for(i=0; i<f->quant_table_count; i++){
1571
        if(get_rac(c, state)){
1572
            for(j=0; j<f->context_count[i]; j++){
1573
                for(k=0; k<CONTEXT_SIZE; k++){
1574
                    int pred= j ? f->initial_states[i][j-1][k] : 128;
1575
                    f->initial_states[i][j][k]= (pred+get_symbol(c, state2[k], 1))&0xFF;
1576
                }
1577
            }
1578
        }
1579
    }
1580

    
1581
    return 0;
1582
}
1583

    
1584
static int read_header(FFV1Context *f){
1585
    uint8_t state[CONTEXT_SIZE];
1586
    int i, j, context_count;
1587
    RangeCoder * const c= &f->slice_context[0]->c;
1588

    
1589
    memset(state, 128, sizeof(state));
1590

    
1591
    if(f->version < 2){
1592
        f->version= get_symbol(c, state, 0);
1593
        f->ac= f->avctx->coder_type= get_symbol(c, state, 0);
1594
        if(f->ac>1){
1595
            for(i=1; i<256; i++){
1596
                f->state_transition[i]= get_symbol(c, state, 1) + c->one_state[i];
1597
            }
1598
        }
1599
        f->colorspace= get_symbol(c, state, 0); //YUV cs type
1600
        if(f->version>0)
1601
            f->avctx->bits_per_raw_sample= get_symbol(c, state, 0);
1602
        get_rac(c, state); //no chroma = false
1603
        f->chroma_h_shift= get_symbol(c, state, 0);
1604
        f->chroma_v_shift= get_symbol(c, state, 0);
1605
        get_rac(c, state); //transparency plane
1606
        f->plane_count= 2;
1607
    }
1608

    
1609
    if(f->colorspace==0){
1610
        if(f->avctx->bits_per_raw_sample<=8){
1611
            switch(16*f->chroma_h_shift + f->chroma_v_shift){
1612
            case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P; break;
1613
            case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P; break;
1614
            case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P; break;
1615
            case 0x20: f->avctx->pix_fmt= PIX_FMT_YUV411P; break;
1616
            case 0x22: f->avctx->pix_fmt= PIX_FMT_YUV410P; break;
1617
            default:
1618
                av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
1619
                return -1;
1620
            }
1621
        }else{
1622
            switch(16*f->chroma_h_shift + f->chroma_v_shift){
1623
            case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P16; break;
1624
            case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P16; break;
1625
            case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P16; break;
1626
            default:
1627
                av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
1628
                return -1;
1629
            }
1630
        }
1631
    }else if(f->colorspace==1){
1632
        if(f->chroma_h_shift || f->chroma_v_shift){
1633
            av_log(f->avctx, AV_LOG_ERROR, "chroma subsampling not supported in this colorspace\n");
1634
            return -1;
1635
        }
1636
        f->avctx->pix_fmt= PIX_FMT_RGB32;
1637
    }else{
1638
        av_log(f->avctx, AV_LOG_ERROR, "colorspace not supported\n");
1639
        return -1;
1640
    }
1641

    
1642
//printf("%d %d %d\n", f->chroma_h_shift, f->chroma_v_shift,f->avctx->pix_fmt);
1643
    if(f->version < 2){
1644
        context_count= read_quant_tables(c, f->quant_table);
1645
        if(context_count < 0){
1646
                av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
1647
                return -1;
1648
        }
1649
    }else{
1650
        f->slice_count= get_symbol(c, state, 0);
1651
        if(f->slice_count > (unsigned)MAX_SLICES)
1652
            return -1;
1653
    }
1654

    
1655
    for(j=0; j<f->slice_count; j++){
1656
        FFV1Context *fs= f->slice_context[j];
1657
        fs->ac= f->ac;
1658

    
1659
        if(f->version >= 2){
1660
            fs->slice_x     = get_symbol(c, state, 0)   *f->width ;
1661
            fs->slice_y     = get_symbol(c, state, 0)   *f->height;
1662
            fs->slice_width =(get_symbol(c, state, 0)+1)*f->width  + fs->slice_x;
1663
            fs->slice_height=(get_symbol(c, state, 0)+1)*f->height + fs->slice_y;
1664

    
1665
            fs->slice_x /= f->num_h_slices;
1666
            fs->slice_y /= f->num_v_slices;
1667
            fs->slice_width  = fs->slice_width /f->num_h_slices - fs->slice_x;
1668
            fs->slice_height = fs->slice_height/f->num_v_slices - fs->slice_y;
1669
            if((unsigned)fs->slice_width > f->width || (unsigned)fs->slice_height > f->height)
1670
                return -1;
1671
            if(    (unsigned)fs->slice_x + (uint64_t)fs->slice_width  > f->width
1672
                || (unsigned)fs->slice_y + (uint64_t)fs->slice_height > f->height)
1673
                return -1;
1674
        }
1675

    
1676
        for(i=0; i<f->plane_count; i++){
1677
            PlaneContext * const p= &fs->plane[i];
1678

    
1679
            if(f->version >= 2){
1680
                int idx=get_symbol(c, state, 0);
1681
                if(idx > (unsigned)f->quant_table_count){
1682
                    av_log(f->avctx, AV_LOG_ERROR, "quant_table_index out of range\n");
1683
                    return -1;
1684
                }
1685
                p->quant_table_index= idx;
1686
                memcpy(p->quant_table, f->quant_tables[idx], sizeof(p->quant_table));
1687
                context_count= f->context_count[idx];
1688
            }else{
1689
                memcpy(p->quant_table, f->quant_table, sizeof(p->quant_table));
1690
            }
1691

    
1692
            if(p->context_count < context_count){
1693
                av_freep(&p->state);
1694
                av_freep(&p->vlc_state);
1695
            }
1696
            p->context_count= context_count;
1697
        }
1698
    }
1699

    
1700
    return 0;
1701
}
1702

    
1703
static av_cold int decode_init(AVCodecContext *avctx)
1704
{
1705
    FFV1Context *f = avctx->priv_data;
1706

    
1707
    common_init(avctx);
1708

    
1709
    if(avctx->extradata && read_extra_header(f) < 0)
1710
        return -1;
1711

    
1712
    if(init_slice_contexts(f) < 0)
1713
        return -1;
1714

    
1715
    return 0;
1716
}
1717

    
1718
static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt){
1719
    const uint8_t *buf = avpkt->data;
1720
    int buf_size = avpkt->size;
1721
    FFV1Context *f = avctx->priv_data;
1722
    RangeCoder * const c= &f->slice_context[0]->c;
1723
    AVFrame * const p= &f->picture;
1724
    int bytes_read, i;
1725
    uint8_t keystate= 128;
1726
    const uint8_t *buf_p;
1727

    
1728
    AVFrame *picture = data;
1729

    
1730
    /* release previously stored data */
1731
    if (p->data[0])
1732
        avctx->release_buffer(avctx, p);
1733

    
1734
    ff_init_range_decoder(c, buf, buf_size);
1735
    ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
1736

    
1737

    
1738
    p->pict_type= AV_PICTURE_TYPE_I; //FIXME I vs. P
1739
    if(get_rac(c, &keystate)){
1740
        p->key_frame= 1;
1741
        if(read_header(f) < 0)
1742
            return -1;
1743
        if(init_slice_state(f) < 0)
1744
            return -1;
1745

    
1746
        clear_state(f);
1747
    }else{
1748
        p->key_frame= 0;
1749
    }
1750
    if(f->ac>1){
1751
        int i;
1752
        for(i=1; i<256; i++){
1753
            c->one_state[i]= f->state_transition[i];
1754
            c->zero_state[256-i]= 256-c->one_state[i];
1755
        }
1756
    }
1757

    
1758
    p->reference= 0;
1759
    if(avctx->get_buffer(avctx, p) < 0){
1760
        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1761
        return -1;
1762
    }
1763

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

    
1767
    if(!f->ac){
1768
        bytes_read = c->bytestream - c->bytestream_start - 1;
1769
        if(bytes_read ==0) av_log(avctx, AV_LOG_ERROR, "error at end of AC stream\n"); //FIXME
1770
//printf("pos=%d\n", bytes_read);
1771
        init_get_bits(&f->slice_context[0]->gb, buf + bytes_read, buf_size - bytes_read);
1772
    } else {
1773
        bytes_read = 0; /* avoid warning */
1774
    }
1775

    
1776
    buf_p= buf + buf_size;
1777
    for(i=f->slice_count-1; i>0; i--){
1778
        FFV1Context *fs= f->slice_context[i];
1779
        int v= AV_RB24(buf_p-3)+3;
1780
        if(buf_p - buf <= v){
1781
            av_log(avctx, AV_LOG_ERROR, "Slice pointer chain broken\n");
1782
            return -1;
1783
        }
1784
        buf_p -= v;
1785
        if(fs->ac){
1786
            ff_init_range_decoder(&fs->c, buf_p, v);
1787
        }else{
1788
            init_get_bits(&fs->gb, buf_p, v);
1789
        }
1790
    }
1791

    
1792
    avctx->execute(avctx, decode_slice, &f->slice_context[0], NULL, f->slice_count, sizeof(void*));
1793
    f->picture_number++;
1794

    
1795
    *picture= *p;
1796
    *data_size = sizeof(AVFrame);
1797

    
1798
    return buf_size;
1799
}
1800

    
1801
AVCodec ff_ffv1_decoder = {
1802
    "ffv1",
1803
    AVMEDIA_TYPE_VIDEO,
1804
    CODEC_ID_FFV1,
1805
    sizeof(FFV1Context),
1806
    decode_init,
1807
    NULL,
1808
    common_end,
1809
    decode_frame,
1810
    CODEC_CAP_DR1 /*| CODEC_CAP_DRAW_HORIZ_BAND*/ | CODEC_CAP_SLICE_THREADS,
1811
    NULL,
1812
    .long_name= NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1813
};
1814

    
1815
#if CONFIG_FFV1_ENCODER
1816
AVCodec ff_ffv1_encoder = {
1817
    "ffv1",
1818
    AVMEDIA_TYPE_VIDEO,
1819
    CODEC_ID_FFV1,
1820
    sizeof(FFV1Context),
1821
    encode_init,
1822
    encode_frame,
1823
    common_end,
1824
    .capabilities = CODEC_CAP_SLICE_THREADS,
1825
    .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_YUV420P10, PIX_FMT_YUV422P10, PIX_FMT_NONE},
1826
    .long_name= NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1827
};
1828
#endif