Statistics
| Branch: | Revision:

ffmpeg / libavcodec / ffv1.c @ 7b874dcc

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

    
1008
    s->picture_number=0;
1009

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

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

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

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

    
1063
        for(i=0; i<s->quant_table_count; i++){
1064
            for(j=0; j<s->context_count[i]; j++){
1065
                for(k=0; k<32; k++){
1066
                    double p= 128;
1067
                    if(s->rc_stat2[i][j][k][0]+s->rc_stat2[i][j][k][1]){
1068
                        p=256.0*s->rc_stat2[i][j][k][1] / (s->rc_stat2[i][j][k][0]+s->rc_stat2[i][j][k][1]);
1069
                    }
1070
                    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)];
1071
                }
1072
            }
1073
        }
1074
    }
1075

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

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

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

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

    
1105

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

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

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

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

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

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

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

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

    
1159
    return 0;
1160
}
1161

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1318
    return 0;
1319
}
1320

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

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

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

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

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

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

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

    
1372
        if(sign) diff= -diff;
1373

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

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

    
1385
    s->run_index=0;
1386

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

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

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

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

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

    
1420
static void decode_rgb_frame(FFV1Context *s, uint32_t *src, int w, int h, int stride){
1421
    int x, y, p;
1422
    int_fast16_t *sample[3][2];
1423
    for(x=0; x<3; x++){
1424
        sample[x][0] = s->sample_buffer +  x*2   *(w+6) + 3;
1425
        sample[x][1] = s->sample_buffer + (x*2+1)*(w+6) + 3;
1426
    }
1427

    
1428
    s->run_index=0;
1429

    
1430
    memset(s->sample_buffer, 0, 6*(w+6)*sizeof(*s->sample_buffer));
1431

    
1432
    for(y=0; y<h; y++){
1433
        for(p=0; p<3; p++){
1434
            int_fast16_t *temp= sample[p][0]; //FIXME try a normal buffer
1435

    
1436
            sample[p][0]= sample[p][1];
1437
            sample[p][1]= temp;
1438

    
1439
            sample[p][1][-1]= sample[p][0][0  ];
1440
            sample[p][0][ w]= sample[p][0][w-1];
1441
            decode_line(s, w, sample[p], FFMIN(p, 1), 9);
1442
        }
1443
        for(x=0; x<w; x++){
1444
            int g= sample[0][1][x];
1445
            int b= sample[1][1][x];
1446
            int r= sample[2][1][x];
1447

    
1448
//            assert(g>=0 && b>=0 && r>=0);
1449
//            assert(g<256 && b<512 && r<512);
1450

    
1451
            b -= 0x100;
1452
            r -= 0x100;
1453
            g -= (b + r)>>2;
1454
            b += g;
1455
            r += g;
1456

    
1457
            src[x + stride*y]= b + (g<<8) + (r<<16) + (0xFF<<24);
1458
        }
1459
    }
1460
}
1461

    
1462
static int decode_slice(AVCodecContext *c, void *arg){
1463
    FFV1Context *fs= *(void**)arg;
1464
    FFV1Context *f= fs->avctx->priv_data;
1465
    int width = fs->slice_width;
1466
    int height= fs->slice_height;
1467
    int x= fs->slice_x;
1468
    int y= fs->slice_y;
1469
    AVFrame * const p= &f->picture;
1470

    
1471
    av_assert1(width && height);
1472
    if(f->colorspace==0){
1473
        const int chroma_width = -((-width )>>f->chroma_h_shift);
1474
        const int chroma_height= -((-height)>>f->chroma_v_shift);
1475
        const int cx= x>>f->chroma_h_shift;
1476
        const int cy= y>>f->chroma_v_shift;
1477
        decode_plane(fs, p->data[0] + x + y*p->linesize[0], width, height, p->linesize[0], 0);
1478

    
1479
        decode_plane(fs, p->data[1] + cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1);
1480
        decode_plane(fs, p->data[2] + cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[2], 1);
1481
    }else{
1482
        decode_rgb_frame(fs, (uint32_t*)p->data[0] + x + y*(p->linesize[0]/4), width, height, p->linesize[0]/4);
1483
    }
1484

    
1485
    emms_c();
1486

    
1487
    return 0;
1488
}
1489

    
1490
static int read_quant_table(RangeCoder *c, int16_t *quant_table, int scale){
1491
    int v;
1492
    int i=0;
1493
    uint8_t state[CONTEXT_SIZE];
1494

    
1495
    memset(state, 128, sizeof(state));
1496

    
1497
    for(v=0; i<128 ; v++){
1498
        int len= get_symbol(c, state, 0) + 1;
1499

    
1500
        if(len + i > 128) return -1;
1501

    
1502
        while(len--){
1503
            quant_table[i] = scale*v;
1504
            i++;
1505
//printf("%2d ",v);
1506
//if(i%16==0) printf("\n");
1507
        }
1508
    }
1509

    
1510
    for(i=1; i<128; i++){
1511
        quant_table[256-i]= -quant_table[i];
1512
    }
1513
    quant_table[128]= -quant_table[127];
1514

    
1515
    return 2*v - 1;
1516
}
1517

    
1518
static int read_quant_tables(RangeCoder *c, int16_t quant_table[MAX_CONTEXT_INPUTS][256]){
1519
    int i;
1520
    int context_count=1;
1521

    
1522
    for(i=0; i<5; i++){
1523
        context_count*= read_quant_table(c, quant_table[i], context_count);
1524
        if(context_count > 32768U){
1525
            return -1;
1526
        }
1527
    }
1528
    return (context_count+1)/2;
1529
}
1530

    
1531
static int read_extra_header(FFV1Context *f){
1532
    RangeCoder * const c= &f->c;
1533
    uint8_t state[CONTEXT_SIZE];
1534
    int i, j, k;
1535
    uint8_t state2[32][CONTEXT_SIZE];
1536

    
1537
    memset(state2, 128, sizeof(state2));
1538
    memset(state, 128, sizeof(state));
1539

    
1540
    ff_init_range_decoder(c, f->avctx->extradata, f->avctx->extradata_size);
1541
    ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
1542

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

    
1564
    f->quant_table_count= get_symbol(c, state, 0);
1565
    if(f->quant_table_count > (unsigned)MAX_QUANT_TABLES)
1566
        return -1;
1567
    for(i=0; i<f->quant_table_count; i++){
1568
        if((f->context_count[i]= read_quant_tables(c, f->quant_tables[i])) < 0){
1569
            av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
1570
            return -1;
1571
        }
1572
    }
1573

    
1574
    if(allocate_initial_states(f) < 0)
1575
        return AVERROR(ENOMEM);
1576

    
1577
    for(i=0; i<f->quant_table_count; i++){
1578
        if(get_rac(c, state)){
1579
            for(j=0; j<f->context_count[i]; j++){
1580
                for(k=0; k<CONTEXT_SIZE; k++){
1581
                    int pred= j ? f->initial_states[i][j-1][k] : 128;
1582
                    f->initial_states[i][j][k]= (pred+get_symbol(c, state2[k], 1))&0xFF;
1583
                }
1584
            }
1585
        }
1586
    }
1587

    
1588
    return 0;
1589
}
1590

    
1591
static int read_header(FFV1Context *f){
1592
    uint8_t state[CONTEXT_SIZE];
1593
    int i, j, context_count;
1594
    RangeCoder * const c= &f->slice_context[0]->c;
1595

    
1596
    memset(state, 128, sizeof(state));
1597

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

    
1616
    if(f->colorspace==0){
1617
        if(f->avctx->bits_per_raw_sample<=8){
1618
            switch(16*f->chroma_h_shift + f->chroma_v_shift){
1619
            case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P; break;
1620
            case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P; break;
1621
            case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P; break;
1622
            case 0x20: f->avctx->pix_fmt= PIX_FMT_YUV411P; break;
1623
            case 0x22: f->avctx->pix_fmt= PIX_FMT_YUV410P; break;
1624
            default:
1625
                av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
1626
                return -1;
1627
            }
1628
        }else if(f->avctx->bits_per_raw_sample==9) {
1629
            switch(16*f->chroma_h_shift + f->chroma_v_shift){
1630
            case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P16; break;
1631
            case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P16; break;
1632
            case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P9 ; f->packed_at_lsb=1; break;
1633
            default:
1634
                av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
1635
                return -1;
1636
            }
1637
        }else if(f->avctx->bits_per_raw_sample==10) {
1638
            switch(16*f->chroma_h_shift + f->chroma_v_shift){
1639
            case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P16; break;
1640
            case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P10; f->packed_at_lsb=1; break;
1641
            case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P10; f->packed_at_lsb=1; break;
1642
            default:
1643
                av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
1644
                return -1;
1645
            }
1646
        }else {
1647
            switch(16*f->chroma_h_shift + f->chroma_v_shift){
1648
            case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P16; break;
1649
            case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P16; break;
1650
            case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P16; break;
1651
            default:
1652
                av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
1653
                return -1;
1654
            }
1655
        }
1656
    }else if(f->colorspace==1){
1657
        if(f->chroma_h_shift || f->chroma_v_shift){
1658
            av_log(f->avctx, AV_LOG_ERROR, "chroma subsampling not supported in this colorspace\n");
1659
            return -1;
1660
        }
1661
        f->avctx->pix_fmt= PIX_FMT_RGB32;
1662
    }else{
1663
        av_log(f->avctx, AV_LOG_ERROR, "colorspace not supported\n");
1664
        return -1;
1665
    }
1666

    
1667
//printf("%d %d %d\n", f->chroma_h_shift, f->chroma_v_shift,f->avctx->pix_fmt);
1668
    if(f->version < 2){
1669
        context_count= read_quant_tables(c, f->quant_table);
1670
        if(context_count < 0){
1671
                av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
1672
                return -1;
1673
        }
1674
    }else{
1675
        f->slice_count= get_symbol(c, state, 0);
1676
        if(f->slice_count > (unsigned)MAX_SLICES)
1677
            return -1;
1678
    }
1679

    
1680
    for(j=0; j<f->slice_count; j++){
1681
        FFV1Context *fs= f->slice_context[j];
1682
        fs->ac= f->ac;
1683
        fs->packed_at_lsb= f->packed_at_lsb;
1684

    
1685
        if(f->version >= 2){
1686
            fs->slice_x     = get_symbol(c, state, 0)   *f->width ;
1687
            fs->slice_y     = get_symbol(c, state, 0)   *f->height;
1688
            fs->slice_width =(get_symbol(c, state, 0)+1)*f->width  + fs->slice_x;
1689
            fs->slice_height=(get_symbol(c, state, 0)+1)*f->height + fs->slice_y;
1690

    
1691
            fs->slice_x /= f->num_h_slices;
1692
            fs->slice_y /= f->num_v_slices;
1693
            fs->slice_width  = fs->slice_width /f->num_h_slices - fs->slice_x;
1694
            fs->slice_height = fs->slice_height/f->num_v_slices - fs->slice_y;
1695
            if((unsigned)fs->slice_width > f->width || (unsigned)fs->slice_height > f->height)
1696
                return -1;
1697
            if(    (unsigned)fs->slice_x + (uint64_t)fs->slice_width  > f->width
1698
                || (unsigned)fs->slice_y + (uint64_t)fs->slice_height > f->height)
1699
                return -1;
1700
        }
1701

    
1702
        for(i=0; i<f->plane_count; i++){
1703
            PlaneContext * const p= &fs->plane[i];
1704

    
1705
            if(f->version >= 2){
1706
                int idx=get_symbol(c, state, 0);
1707
                if(idx > (unsigned)f->quant_table_count){
1708
                    av_log(f->avctx, AV_LOG_ERROR, "quant_table_index out of range\n");
1709
                    return -1;
1710
                }
1711
                p->quant_table_index= idx;
1712
                memcpy(p->quant_table, f->quant_tables[idx], sizeof(p->quant_table));
1713
                context_count= f->context_count[idx];
1714
            }else{
1715
                memcpy(p->quant_table, f->quant_table, sizeof(p->quant_table));
1716
            }
1717

    
1718
            if(p->context_count < context_count){
1719
                av_freep(&p->state);
1720
                av_freep(&p->vlc_state);
1721
            }
1722
            p->context_count= context_count;
1723
        }
1724
    }
1725

    
1726
    return 0;
1727
}
1728

    
1729
static av_cold int decode_init(AVCodecContext *avctx)
1730
{
1731
    FFV1Context *f = avctx->priv_data;
1732

    
1733
    common_init(avctx);
1734

    
1735
    if(avctx->extradata && read_extra_header(f) < 0)
1736
        return -1;
1737

    
1738
    if(init_slice_contexts(f) < 0)
1739
        return -1;
1740

    
1741
    return 0;
1742
}
1743

    
1744
static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt){
1745
    const uint8_t *buf = avpkt->data;
1746
    int buf_size = avpkt->size;
1747
    FFV1Context *f = avctx->priv_data;
1748
    RangeCoder * const c= &f->slice_context[0]->c;
1749
    AVFrame * const p= &f->picture;
1750
    int bytes_read, i;
1751
    uint8_t keystate= 128;
1752
    const uint8_t *buf_p;
1753

    
1754
    AVFrame *picture = data;
1755

    
1756
    /* release previously stored data */
1757
    if (p->data[0])
1758
        avctx->release_buffer(avctx, p);
1759

    
1760
    ff_init_range_decoder(c, buf, buf_size);
1761
    ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
1762

    
1763

    
1764
    p->pict_type= AV_PICTURE_TYPE_I; //FIXME I vs. P
1765
    if(get_rac(c, &keystate)){
1766
        p->key_frame= 1;
1767
        if(read_header(f) < 0)
1768
            return -1;
1769
        if(init_slice_state(f) < 0)
1770
            return -1;
1771

    
1772
        clear_state(f);
1773
    }else{
1774
        p->key_frame= 0;
1775
    }
1776
    if(f->ac>1){
1777
        int i;
1778
        for(i=1; i<256; i++){
1779
            c->one_state[i]= f->state_transition[i];
1780
            c->zero_state[256-i]= 256-c->one_state[i];
1781
        }
1782
    }
1783

    
1784
    p->reference= 0;
1785
    if(avctx->get_buffer(avctx, p) < 0){
1786
        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1787
        return -1;
1788
    }
1789

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

    
1793
    if(!f->ac){
1794
        bytes_read = c->bytestream - c->bytestream_start - 1;
1795
        if(bytes_read ==0) av_log(avctx, AV_LOG_ERROR, "error at end of AC stream\n"); //FIXME
1796
//printf("pos=%d\n", bytes_read);
1797
        init_get_bits(&f->slice_context[0]->gb, buf + bytes_read, buf_size - bytes_read);
1798
    } else {
1799
        bytes_read = 0; /* avoid warning */
1800
    }
1801

    
1802
    buf_p= buf + buf_size;
1803
    for(i=f->slice_count-1; i>0; i--){
1804
        FFV1Context *fs= f->slice_context[i];
1805
        int v= AV_RB24(buf_p-3)+3;
1806
        if(buf_p - buf <= v){
1807
            av_log(avctx, AV_LOG_ERROR, "Slice pointer chain broken\n");
1808
            return -1;
1809
        }
1810
        buf_p -= v;
1811
        if(fs->ac){
1812
            ff_init_range_decoder(&fs->c, buf_p, v);
1813
        }else{
1814
            init_get_bits(&fs->gb, buf_p, v);
1815
        }
1816
    }
1817

    
1818
    avctx->execute(avctx, decode_slice, &f->slice_context[0], NULL, f->slice_count, sizeof(void*));
1819
    f->picture_number++;
1820

    
1821
    *picture= *p;
1822
    *data_size = sizeof(AVFrame);
1823

    
1824
    return buf_size;
1825
}
1826

    
1827
AVCodec ff_ffv1_decoder = {
1828
    "ffv1",
1829
    AVMEDIA_TYPE_VIDEO,
1830
    CODEC_ID_FFV1,
1831
    sizeof(FFV1Context),
1832
    decode_init,
1833
    NULL,
1834
    common_end,
1835
    decode_frame,
1836
    CODEC_CAP_DR1 /*| CODEC_CAP_DRAW_HORIZ_BAND*/ | CODEC_CAP_SLICE_THREADS,
1837
    NULL,
1838
    .long_name= NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1839
};
1840

    
1841
#if CONFIG_FFV1_ENCODER
1842
AVCodec ff_ffv1_encoder = {
1843
    "ffv1",
1844
    AVMEDIA_TYPE_VIDEO,
1845
    CODEC_ID_FFV1,
1846
    sizeof(FFV1Context),
1847
    encode_init,
1848
    encode_frame,
1849
    common_end,
1850
    .capabilities = CODEC_CAP_SLICE_THREADS,
1851
    .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_YUV420P9, PIX_FMT_YUV420P10, PIX_FMT_YUV422P10, PIX_FMT_NONE},
1852
    .long_name= NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1853
};
1854
#endif