vp9: assert -> av_assert and fix associated compile error.
[ffmpeg.git] / libavcodec / ffv1enc.c
1 /*
2  * FFV1 encoder
3  *
4  * Copyright (c) 2003-2013 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) encoder
26  */
27
28 #include "libavutil/attributes.h"
29 #include "libavutil/avassert.h"
30 #include "libavutil/crc.h"
31 #include "libavutil/opt.h"
32 #include "libavutil/imgutils.h"
33 #include "libavutil/pixdesc.h"
34 #include "libavutil/timer.h"
35
36 #include "avcodec.h"
37 #include "internal.h"
38 #include "put_bits.h"
39 #include "rangecoder.h"
40 #include "golomb.h"
41 #include "mathops.h"
42 #include "ffv1.h"
43
44 static const int8_t quant5_10bit[256] = {
45      0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  1,  1,  1,  1,  1,
46      1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
47      1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
48      1,  1,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
49      2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
50      2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
51      2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
52      2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
53     -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
54     -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
55     -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
56     -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
57     -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -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, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0,
61 };
62
63 static const int8_t quant5[256] = {
64      0,  1,  1,  1,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
65      2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
66      2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
67      2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
68      2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
69      2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
70      2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
71      2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
72     -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
73     -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
74     -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
75     -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
76     -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
77     -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
78     -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
79     -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -1, -1, -1,
80 };
81
82 static const int8_t quant9_10bit[256] = {
83      0,  0,  0,  0,  0,  1,  1,  1,  1,  1,  1,  1,  1,  2,  2,  2,
84      2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  3,  3,  3,  3,  3,
85      3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,
86      3,  3,  3,  3,  3,  3,  3,  3,  4,  4,  4,  4,  4,  4,  4,  4,
87      4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,
88      4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,
89      4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,
90      4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,
91     -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4,
92     -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4,
93     -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4,
94     -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4,
95     -4, -4, -4, -4, -4, -4, -4, -4, -4, -3, -3, -3, -3, -3, -3, -3,
96     -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3,
97     -3, -3, -3, -3, -3, -3, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
98     -2, -2, -2, -2, -1, -1, -1, -1, -1, -1, -1, -1, -0, -0, -0, -0,
99 };
100
101 static const int8_t quant11[256] = {
102      0,  1,  2,  2,  2,  3,  3,  3,  3,  3,  3,  3,  4,  4,  4,  4,
103      4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,
104      4,  4,  4,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,
105      5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,
106      5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,
107      5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,
108      5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,
109      5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,
110     -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5,
111     -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5,
112     -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5,
113     -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5,
114     -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5,
115     -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -4, -4,
116     -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4,
117     -4, -4, -4, -4, -4, -3, -3, -3, -3, -3, -3, -3, -2, -2, -2, -1,
118 };
119
120 static const uint8_t ver2_state[256] = {
121       0,  10,  10,  10,  10,  16,  16,  16, 28,   16,  16,  29,  42,  49,  20,  49,
122      59,  25,  26,  26,  27,  31,  33,  33, 33,   34,  34,  37,  67,  38,  39,  39,
123      40,  40,  41,  79,  43,  44,  45,  45, 48,   48,  64,  50,  51,  52,  88,  52,
124      53,  74,  55,  57,  58,  58,  74,  60, 101,  61,  62,  84,  66,  66,  68,  69,
125      87,  82,  71,  97,  73,  73,  82,  75, 111,  77,  94,  78,  87,  81,  83,  97,
126      85,  83,  94,  86,  99,  89,  90,  99, 111,  92,  93,  134, 95,  98,  105, 98,
127     105, 110, 102, 108, 102, 118, 103, 106, 106, 113, 109, 112, 114, 112, 116, 125,
128     115, 116, 117, 117, 126, 119, 125, 121, 121, 123, 145, 124, 126, 131, 127, 129,
129     165, 130, 132, 138, 133, 135, 145, 136, 137, 139, 146, 141, 143, 142, 144, 148,
130     147, 155, 151, 149, 151, 150, 152, 157, 153, 154, 156, 168, 158, 162, 161, 160,
131     172, 163, 169, 164, 166, 184, 167, 170, 177, 174, 171, 173, 182, 176, 180, 178,
132     175, 189, 179, 181, 186, 183, 192, 185, 200, 187, 191, 188, 190, 197, 193, 196,
133     197, 194, 195, 196, 198, 202, 199, 201, 210, 203, 207, 204, 205, 206, 208, 214,
134     209, 211, 221, 212, 213, 215, 224, 216, 217, 218, 219, 220, 222, 228, 223, 225,
135     226, 224, 227, 229, 240, 230, 231, 232, 233, 234, 235, 236, 238, 239, 237, 242,
136     241, 243, 242, 244, 245, 246, 247, 248, 249, 250, 251, 252, 252, 253, 254, 255,
137 };
138
139 static void find_best_state(uint8_t best_state[256][256],
140                             const uint8_t one_state[256])
141 {
142     int i, j, k, m;
143     double l2tab[256];
144
145     for (i = 1; i < 256; i++)
146         l2tab[i] = log2(i / 256.0);
147
148     for (i = 0; i < 256; i++) {
149         double best_len[256];
150         double p = i / 256.0;
151
152         for (j = 0; j < 256; j++)
153             best_len[j] = 1 << 30;
154
155         for (j = FFMAX(i - 10, 1); j < FFMIN(i + 11, 256); j++) {
156             double occ[256] = { 0 };
157             double len      = 0;
158             occ[j] = 1.0;
159
160             if (!one_state[j])
161                 continue;
162
163             for (k = 0; k < 256; k++) {
164                 double newocc[256] = { 0 };
165                 for (m = 1; m < 256; m++)
166                     if (occ[m]) {
167                         len -=occ[m]*(     p *l2tab[    m]
168                                       + (1-p)*l2tab[256-m]);
169                     }
170                 if (len < best_len[k]) {
171                     best_len[k]      = len;
172                     best_state[i][k] = j;
173                 }
174                 for (m = 1; m < 256; m++)
175                     if (occ[m]) {
176                         newocc[      one_state[      m]] += occ[m] * p;
177                         newocc[256 - one_state[256 - m]] += occ[m] * (1 - p);
178                     }
179                 memcpy(occ, newocc, sizeof(occ));
180             }
181         }
182     }
183 }
184
185 static av_always_inline av_flatten void put_symbol_inline(RangeCoder *c,
186                                                           uint8_t *state, int v,
187                                                           int is_signed,
188                                                           uint64_t rc_stat[256][2],
189                                                           uint64_t rc_stat2[32][2])
190 {
191     int i;
192
193 #define put_rac(C, S, B)                        \
194     do {                                        \
195         if (rc_stat) {                          \
196             rc_stat[*(S)][B]++;                 \
197             rc_stat2[(S) - state][B]++;         \
198         }                                       \
199         put_rac(C, S, B);                       \
200     } while (0)
201
202     if (v) {
203         const int a = FFABS(v);
204         const int e = av_log2(a);
205         put_rac(c, state + 0, 0);
206         if (e <= 9) {
207             for (i = 0; i < e; i++)
208                 put_rac(c, state + 1 + i, 1);  // 1..10
209             put_rac(c, state + 1 + i, 0);
210
211             for (i = e - 1; i >= 0; i--)
212                 put_rac(c, state + 22 + i, (a >> i) & 1);  // 22..31
213
214             if (is_signed)
215                 put_rac(c, state + 11 + e, v < 0);  // 11..21
216         } else {
217             for (i = 0; i < e; i++)
218                 put_rac(c, state + 1 + FFMIN(i, 9), 1);  // 1..10
219             put_rac(c, state + 1 + 9, 0);
220
221             for (i = e - 1; i >= 0; i--)
222                 put_rac(c, state + 22 + FFMIN(i, 9), (a >> i) & 1);  // 22..31
223
224             if (is_signed)
225                 put_rac(c, state + 11 + 10, v < 0);  // 11..21
226         }
227     } else {
228         put_rac(c, state + 0, 1);
229     }
230 #undef put_rac
231 }
232
233 static av_noinline void put_symbol(RangeCoder *c, uint8_t *state,
234                                    int v, int is_signed)
235 {
236     put_symbol_inline(c, state, v, is_signed, NULL, NULL);
237 }
238
239
240 static inline void put_vlc_symbol(PutBitContext *pb, VlcState *const state,
241                                   int v, int bits)
242 {
243     int i, k, code;
244     v = fold(v - state->bias, bits);
245
246     i = state->count;
247     k = 0;
248     while (i < state->error_sum) { // FIXME: optimize
249         k++;
250         i += i;
251     }
252
253     av_assert2(k <= 13);
254
255     code = v ^ ((2 * state->drift + state->count) >> 31);
256
257     ff_dlog(NULL, "v:%d/%d bias:%d error:%d drift:%d count:%d k:%d\n", v, code,
258             state->bias, state->error_sum, state->drift, state->count, k);
259     set_sr_golomb(pb, code, k, 12, bits);
260
261     update_vlc_state(state, v);
262 }
263
264 #define TYPE int16_t
265 #define RENAME(name) name
266 #include "ffv1enc_template.c"
267 #undef TYPE
268 #undef RENAME
269
270 #define TYPE int32_t
271 #define RENAME(name) name ## 32
272 #include "ffv1enc_template.c"
273
274 static int encode_plane(FFV1Context *s, uint8_t *src, int w, int h,
275                          int stride, int plane_index, int pixel_stride)
276 {
277     int x, y, i, ret;
278     const int ring_size = s->context_model ? 3 : 2;
279     int16_t *sample[3];
280     s->run_index = 0;
281
282     memset(s->sample_buffer, 0, ring_size * (w + 6) * sizeof(*s->sample_buffer));
283
284     for (y = 0; y < h; y++) {
285         for (i = 0; i < ring_size; i++)
286             sample[i] = s->sample_buffer + (w + 6) * ((h + i - y) % ring_size) + 3;
287
288         sample[0][-1]= sample[1][0  ];
289         sample[1][ w]= sample[1][w-1];
290 // { START_TIMER
291         if (s->bits_per_raw_sample <= 8) {
292             for (x = 0; x < w; x++)
293                 sample[0][x] = src[x * pixel_stride + stride * y];
294             if((ret = encode_line(s, w, sample, plane_index, 8)) < 0)
295                 return ret;
296         } else {
297             if (s->packed_at_lsb) {
298                 for (x = 0; x < w; x++) {
299                     sample[0][x] = ((uint16_t*)(src + stride*y))[x];
300                 }
301             } else {
302                 for (x = 0; x < w; x++) {
303                     sample[0][x] = ((uint16_t*)(src + stride*y))[x] >> (16 - s->bits_per_raw_sample);
304                 }
305             }
306             if((ret = encode_line(s, w, sample, plane_index, s->bits_per_raw_sample)) < 0)
307                 return ret;
308         }
309 // STOP_TIMER("encode line") }
310     }
311     return 0;
312 }
313
314 static void write_quant_table(RangeCoder *c, int16_t *quant_table)
315 {
316     int last = 0;
317     int i;
318     uint8_t state[CONTEXT_SIZE];
319     memset(state, 128, sizeof(state));
320
321     for (i = 1; i < 128; i++)
322         if (quant_table[i] != quant_table[i - 1]) {
323             put_symbol(c, state, i - last - 1, 0);
324             last = i;
325         }
326     put_symbol(c, state, i - last - 1, 0);
327 }
328
329 static void write_quant_tables(RangeCoder *c,
330                                int16_t quant_table[MAX_CONTEXT_INPUTS][256])
331 {
332     int i;
333     for (i = 0; i < 5; i++)
334         write_quant_table(c, quant_table[i]);
335 }
336
337 static void write_header(FFV1Context *f)
338 {
339     uint8_t state[CONTEXT_SIZE];
340     int i, j;
341     RangeCoder *const c = &f->slice_context[0]->c;
342
343     memset(state, 128, sizeof(state));
344
345     if (f->version < 2) {
346         put_symbol(c, state, f->version, 0);
347         put_symbol(c, state, f->ac, 0);
348         if (f->ac == AC_RANGE_CUSTOM_TAB) {
349             for (i = 1; i < 256; i++)
350                 put_symbol(c, state,
351                            f->state_transition[i] - c->one_state[i], 1);
352         }
353         put_symbol(c, state, f->colorspace, 0); //YUV cs type
354         if (f->version > 0)
355             put_symbol(c, state, f->bits_per_raw_sample, 0);
356         put_rac(c, state, f->chroma_planes);
357         put_symbol(c, state, f->chroma_h_shift, 0);
358         put_symbol(c, state, f->chroma_v_shift, 0);
359         put_rac(c, state, f->transparency);
360
361         write_quant_tables(c, f->quant_table);
362     } else if (f->version < 3) {
363         put_symbol(c, state, f->slice_count, 0);
364         for (i = 0; i < f->slice_count; i++) {
365             FFV1Context *fs = f->slice_context[i];
366             put_symbol(c, state,
367                        (fs->slice_x      + 1) * f->num_h_slices / f->width, 0);
368             put_symbol(c, state,
369                        (fs->slice_y      + 1) * f->num_v_slices / f->height, 0);
370             put_symbol(c, state,
371                        (fs->slice_width  + 1) * f->num_h_slices / f->width - 1,
372                        0);
373             put_symbol(c, state,
374                        (fs->slice_height + 1) * f->num_v_slices / f->height - 1,
375                        0);
376             for (j = 0; j < f->plane_count; j++) {
377                 put_symbol(c, state, f->plane[j].quant_table_index, 0);
378                 av_assert0(f->plane[j].quant_table_index == f->context_model);
379             }
380         }
381     }
382 }
383
384 static int write_extradata(FFV1Context *f)
385 {
386     RangeCoder *const c = &f->c;
387     uint8_t state[CONTEXT_SIZE];
388     int i, j, k;
389     uint8_t state2[32][CONTEXT_SIZE];
390     unsigned v;
391
392     memset(state2, 128, sizeof(state2));
393     memset(state, 128, sizeof(state));
394
395     f->avctx->extradata_size = 10000 + 4 +
396                                     (11 * 11 * 5 * 5 * 5 + 11 * 11 * 11) * 32;
397     f->avctx->extradata = av_malloc(f->avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
398     if (!f->avctx->extradata)
399         return AVERROR(ENOMEM);
400     ff_init_range_encoder(c, f->avctx->extradata, f->avctx->extradata_size);
401     ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
402
403     put_symbol(c, state, f->version, 0);
404     if (f->version > 2) {
405         if (f->version == 3) {
406             f->micro_version = 4;
407         } else if (f->version == 4)
408             f->micro_version = 2;
409         put_symbol(c, state, f->micro_version, 0);
410     }
411
412     put_symbol(c, state, f->ac, 0);
413     if (f->ac == AC_RANGE_CUSTOM_TAB)
414         for (i = 1; i < 256; i++)
415             put_symbol(c, state, f->state_transition[i] - c->one_state[i], 1);
416
417     put_symbol(c, state, f->colorspace, 0); // YUV cs type
418     put_symbol(c, state, f->bits_per_raw_sample, 0);
419     put_rac(c, state, f->chroma_planes);
420     put_symbol(c, state, f->chroma_h_shift, 0);
421     put_symbol(c, state, f->chroma_v_shift, 0);
422     put_rac(c, state, f->transparency);
423     put_symbol(c, state, f->num_h_slices - 1, 0);
424     put_symbol(c, state, f->num_v_slices - 1, 0);
425
426     put_symbol(c, state, f->quant_table_count, 0);
427     for (i = 0; i < f->quant_table_count; i++)
428         write_quant_tables(c, f->quant_tables[i]);
429
430     for (i = 0; i < f->quant_table_count; i++) {
431         for (j = 0; j < f->context_count[i] * CONTEXT_SIZE; j++)
432             if (f->initial_states[i] && f->initial_states[i][0][j] != 128)
433                 break;
434         if (j < f->context_count[i] * CONTEXT_SIZE) {
435             put_rac(c, state, 1);
436             for (j = 0; j < f->context_count[i]; j++)
437                 for (k = 0; k < CONTEXT_SIZE; k++) {
438                     int pred = j ? f->initial_states[i][j - 1][k] : 128;
439                     put_symbol(c, state2[k],
440                                (int8_t)(f->initial_states[i][j][k] - pred), 1);
441                 }
442         } else {
443             put_rac(c, state, 0);
444         }
445     }
446
447     if (f->version > 2) {
448         put_symbol(c, state, f->ec, 0);
449         put_symbol(c, state, f->intra = (f->avctx->gop_size < 2), 0);
450     }
451
452     f->avctx->extradata_size = ff_rac_terminate(c);
453     v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, f->avctx->extradata, f->avctx->extradata_size);
454     AV_WL32(f->avctx->extradata + f->avctx->extradata_size, v);
455     f->avctx->extradata_size += 4;
456
457     return 0;
458 }
459
460 static int sort_stt(FFV1Context *s, uint8_t stt[256])
461 {
462     int i, i2, changed, print = 0;
463
464     do {
465         changed = 0;
466         for (i = 12; i < 244; i++) {
467             for (i2 = i + 1; i2 < 245 && i2 < i + 4; i2++) {
468
469 #define COST(old, new)                                      \
470     s->rc_stat[old][0] * -log2((256 - (new)) / 256.0) +     \
471     s->rc_stat[old][1] * -log2((new)         / 256.0)
472
473 #define COST2(old, new)                         \
474     COST(old, new) + COST(256 - (old), 256 - (new))
475
476                 double size0 = COST2(i,  i) + COST2(i2, i2);
477                 double sizeX = COST2(i, i2) + COST2(i2, i);
478                 if (size0 - sizeX > size0*(1e-14) && i != 128 && i2 != 128) {
479                     int j;
480                     FFSWAP(int, stt[i], stt[i2]);
481                     FFSWAP(int, s->rc_stat[i][0], s->rc_stat[i2][0]);
482                     FFSWAP(int, s->rc_stat[i][1], s->rc_stat[i2][1]);
483                     if (i != 256 - i2) {
484                         FFSWAP(int, stt[256 - i], stt[256 - i2]);
485                         FFSWAP(int, s->rc_stat[256 - i][0], s->rc_stat[256 - i2][0]);
486                         FFSWAP(int, s->rc_stat[256 - i][1], s->rc_stat[256 - i2][1]);
487                     }
488                     for (j = 1; j < 256; j++) {
489                         if (stt[j] == i)
490                             stt[j] = i2;
491                         else if (stt[j] == i2)
492                             stt[j] = i;
493                         if (i != 256 - i2) {
494                             if (stt[256 - j] == 256 - i)
495                                 stt[256 - j] = 256 - i2;
496                             else if (stt[256 - j] == 256 - i2)
497                                 stt[256 - j] = 256 - i;
498                         }
499                     }
500                     print = changed = 1;
501                 }
502             }
503         }
504     } while (changed);
505     return print;
506 }
507
508 static av_cold int encode_init(AVCodecContext *avctx)
509 {
510     FFV1Context *s = avctx->priv_data;
511     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
512     int i, j, k, m, ret;
513
514     if ((ret = ff_ffv1_common_init(avctx)) < 0)
515         return ret;
516
517     s->version = 0;
518
519     if ((avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) ||
520         avctx->slices > 1)
521         s->version = FFMAX(s->version, 2);
522
523     // Unspecified level & slices, we choose version 1.2+ to ensure multithreaded decodability
524     if (avctx->slices == 0 && avctx->level < 0 && avctx->width * avctx->height > 720*576)
525         s->version = FFMAX(s->version, 2);
526
527     if (avctx->level <= 0 && s->version == 2) {
528         s->version = 3;
529     }
530     if (avctx->level >= 0 && avctx->level <= 4) {
531         if (avctx->level < s->version) {
532             av_log(avctx, AV_LOG_ERROR, "Version %d needed for requested features but %d requested\n", s->version, avctx->level);
533             return AVERROR(EINVAL);
534         }
535         s->version = avctx->level;
536     }
537
538     if (s->ec < 0) {
539         s->ec = (s->version >= 3);
540     }
541
542     if ((s->version == 2 || s->version>3) && avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
543         av_log(avctx, AV_LOG_ERROR, "Version 2 needed for requested features but version 2 is experimental and not enabled\n");
544         return AVERROR_INVALIDDATA;
545     }
546
547 #if FF_API_CODER_TYPE
548 FF_DISABLE_DEPRECATION_WARNINGS
549     if (avctx->coder_type != -1)
550         s->ac = avctx->coder_type > 0 ? AC_RANGE_CUSTOM_TAB : AC_GOLOMB_RICE;
551     else
552 FF_ENABLE_DEPRECATION_WARNINGS
553 #endif
554     if (s->ac == 1) // Compatbility with common command line usage
555         s->ac = AC_RANGE_CUSTOM_TAB;
556     else if (s->ac == AC_RANGE_DEFAULT_TAB_FORCE)
557         s->ac = AC_RANGE_DEFAULT_TAB;
558
559     s->plane_count = 3;
560     switch(avctx->pix_fmt) {
561     case AV_PIX_FMT_YUV444P9:
562     case AV_PIX_FMT_YUV422P9:
563     case AV_PIX_FMT_YUV420P9:
564     case AV_PIX_FMT_YUVA444P9:
565     case AV_PIX_FMT_YUVA422P9:
566     case AV_PIX_FMT_YUVA420P9:
567         if (!avctx->bits_per_raw_sample)
568             s->bits_per_raw_sample = 9;
569     case AV_PIX_FMT_GRAY10:
570     case AV_PIX_FMT_YUV444P10:
571     case AV_PIX_FMT_YUV420P10:
572     case AV_PIX_FMT_YUV422P10:
573     case AV_PIX_FMT_YUVA444P10:
574     case AV_PIX_FMT_YUVA422P10:
575     case AV_PIX_FMT_YUVA420P10:
576         if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
577             s->bits_per_raw_sample = 10;
578     case AV_PIX_FMT_GRAY12:
579     case AV_PIX_FMT_YUV444P12:
580     case AV_PIX_FMT_YUV420P12:
581     case AV_PIX_FMT_YUV422P12:
582         s->packed_at_lsb = 1;
583         if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
584             s->bits_per_raw_sample = 12;
585     case AV_PIX_FMT_GRAY16:
586     case AV_PIX_FMT_YUV444P16:
587     case AV_PIX_FMT_YUV422P16:
588     case AV_PIX_FMT_YUV420P16:
589     case AV_PIX_FMT_YUVA444P16:
590     case AV_PIX_FMT_YUVA422P16:
591     case AV_PIX_FMT_YUVA420P16:
592         if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) {
593             s->bits_per_raw_sample = 16;
594         } else if (!s->bits_per_raw_sample) {
595             s->bits_per_raw_sample = avctx->bits_per_raw_sample;
596         }
597         if (s->bits_per_raw_sample <= 8) {
598             av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");
599             return AVERROR_INVALIDDATA;
600         }
601         s->version = FFMAX(s->version, 1);
602     case AV_PIX_FMT_GRAY8:
603     case AV_PIX_FMT_YA8:
604     case AV_PIX_FMT_YUV444P:
605     case AV_PIX_FMT_YUV440P:
606     case AV_PIX_FMT_YUV422P:
607     case AV_PIX_FMT_YUV420P:
608     case AV_PIX_FMT_YUV411P:
609     case AV_PIX_FMT_YUV410P:
610     case AV_PIX_FMT_YUVA444P:
611     case AV_PIX_FMT_YUVA422P:
612     case AV_PIX_FMT_YUVA420P:
613         s->chroma_planes = desc->nb_components < 3 ? 0 : 1;
614         s->colorspace = 0;
615         s->transparency = desc->nb_components == 4 || desc->nb_components == 2;
616         if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
617             s->bits_per_raw_sample = 8;
618         else if (!s->bits_per_raw_sample)
619             s->bits_per_raw_sample = 8;
620         break;
621     case AV_PIX_FMT_RGB32:
622         s->colorspace = 1;
623         s->transparency = 1;
624         s->chroma_planes = 1;
625         s->bits_per_raw_sample = 8;
626         break;
627     case AV_PIX_FMT_RGB48:
628         s->colorspace = 1;
629         s->chroma_planes = 1;
630         s->bits_per_raw_sample = 16;
631         s->use32bit = 1;
632         s->version = FFMAX(s->version, 1);
633         if (avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
634             av_log(avctx, AV_LOG_ERROR, "16bit RGB is experimental and under development, only use it for experiments\n");
635             return AVERROR_INVALIDDATA;
636         }
637         break;
638     case AV_PIX_FMT_0RGB32:
639         s->colorspace = 1;
640         s->chroma_planes = 1;
641         s->bits_per_raw_sample = 8;
642         break;
643     case AV_PIX_FMT_GBRP9:
644         if (!avctx->bits_per_raw_sample)
645             s->bits_per_raw_sample = 9;
646     case AV_PIX_FMT_GBRP10:
647         if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
648             s->bits_per_raw_sample = 10;
649     case AV_PIX_FMT_GBRP12:
650         if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
651             s->bits_per_raw_sample = 12;
652     case AV_PIX_FMT_GBRP14:
653         if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
654             s->bits_per_raw_sample = 14;
655     case AV_PIX_FMT_GBRP16:
656         if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
657             s->bits_per_raw_sample = 16;
658         else if (!s->bits_per_raw_sample)
659             s->bits_per_raw_sample = avctx->bits_per_raw_sample;
660         s->colorspace = 1;
661         s->chroma_planes = 1;
662         if (s->bits_per_raw_sample >= 16) {
663             s->use32bit = 1;
664             if (avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
665                 av_log(avctx, AV_LOG_ERROR, "16bit RGB is experimental and under development, only use it for experiments\n");
666                 return AVERROR_INVALIDDATA;
667             }
668         }
669         s->version = FFMAX(s->version, 1);
670         break;
671     default:
672         av_log(avctx, AV_LOG_ERROR, "format not supported\n");
673         return AVERROR(ENOSYS);
674     }
675     av_assert0(s->bits_per_raw_sample >= 8);
676
677     if (s->bits_per_raw_sample > 8) {
678         if (s->ac == AC_GOLOMB_RICE) {
679             av_log(avctx, AV_LOG_INFO,
680                     "bits_per_raw_sample > 8, forcing range coder\n");
681             s->ac = AC_RANGE_CUSTOM_TAB;
682         }
683     }
684     if (s->transparency) {
685         av_log(avctx, AV_LOG_WARNING, "Storing alpha plane, this will require a recent FFV1 decoder to playback!\n");
686     }
687 #if FF_API_PRIVATE_OPT
688 FF_DISABLE_DEPRECATION_WARNINGS
689     if (avctx->context_model)
690         s->context_model = avctx->context_model;
691     if (avctx->context_model > 1U) {
692         av_log(avctx, AV_LOG_ERROR, "Invalid context model %d, valid values are 0 and 1\n", avctx->context_model);
693         return AVERROR(EINVAL);
694     }
695 FF_ENABLE_DEPRECATION_WARNINGS
696 #endif
697
698     if (s->ac == AC_RANGE_CUSTOM_TAB) {
699         for (i = 1; i < 256; i++)
700             s->state_transition[i] = ver2_state[i];
701     } else {
702         RangeCoder c;
703         ff_build_rac_states(&c, 0.05 * (1LL << 32), 256 - 8);
704         for (i = 1; i < 256; i++)
705             s->state_transition[i] = c.one_state[i];
706     }
707
708     for (i = 0; i < 256; i++) {
709         s->quant_table_count = 2;
710         if (s->bits_per_raw_sample <= 8) {
711             s->quant_tables[0][0][i]=           quant11[i];
712             s->quant_tables[0][1][i]=        11*quant11[i];
713             s->quant_tables[0][2][i]=     11*11*quant11[i];
714             s->quant_tables[1][0][i]=           quant11[i];
715             s->quant_tables[1][1][i]=        11*quant11[i];
716             s->quant_tables[1][2][i]=     11*11*quant5 [i];
717             s->quant_tables[1][3][i]=   5*11*11*quant5 [i];
718             s->quant_tables[1][4][i]= 5*5*11*11*quant5 [i];
719         } else {
720             s->quant_tables[0][0][i]=           quant9_10bit[i];
721             s->quant_tables[0][1][i]=        11*quant9_10bit[i];
722             s->quant_tables[0][2][i]=     11*11*quant9_10bit[i];
723             s->quant_tables[1][0][i]=           quant9_10bit[i];
724             s->quant_tables[1][1][i]=        11*quant9_10bit[i];
725             s->quant_tables[1][2][i]=     11*11*quant5_10bit[i];
726             s->quant_tables[1][3][i]=   5*11*11*quant5_10bit[i];
727             s->quant_tables[1][4][i]= 5*5*11*11*quant5_10bit[i];
728         }
729     }
730     s->context_count[0] = (11 * 11 * 11        + 1) / 2;
731     s->context_count[1] = (11 * 11 * 5 * 5 * 5 + 1) / 2;
732     memcpy(s->quant_table, s->quant_tables[s->context_model],
733            sizeof(s->quant_table));
734
735     for (i = 0; i < s->plane_count; i++) {
736         PlaneContext *const p = &s->plane[i];
737
738         memcpy(p->quant_table, s->quant_table, sizeof(p->quant_table));
739         p->quant_table_index = s->context_model;
740         p->context_count     = s->context_count[p->quant_table_index];
741     }
742
743     if ((ret = ff_ffv1_allocate_initial_states(s)) < 0)
744         return ret;
745
746 #if FF_API_CODED_FRAME
747 FF_DISABLE_DEPRECATION_WARNINGS
748     avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
749 FF_ENABLE_DEPRECATION_WARNINGS
750 #endif
751
752     if (!s->transparency)
753         s->plane_count = 2;
754     if (!s->chroma_planes && s->version > 3)
755         s->plane_count--;
756
757     avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
758     s->picture_number = 0;
759
760     if (avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) {
761         for (i = 0; i < s->quant_table_count; i++) {
762             s->rc_stat2[i] = av_mallocz(s->context_count[i] *
763                                         sizeof(*s->rc_stat2[i]));
764             if (!s->rc_stat2[i])
765                 return AVERROR(ENOMEM);
766         }
767     }
768     if (avctx->stats_in) {
769         char *p = avctx->stats_in;
770         uint8_t (*best_state)[256] = av_malloc_array(256, 256);
771         int gob_count = 0;
772         char *next;
773         if (!best_state)
774             return AVERROR(ENOMEM);
775
776         av_assert0(s->version >= 2);
777
778         for (;;) {
779             for (j = 0; j < 256; j++)
780                 for (i = 0; i < 2; i++) {
781                     s->rc_stat[j][i] = strtol(p, &next, 0);
782                     if (next == p) {
783                         av_log(avctx, AV_LOG_ERROR,
784                                "2Pass file invalid at %d %d [%s]\n", j, i, p);
785                         av_freep(&best_state);
786                         return AVERROR_INVALIDDATA;
787                     }
788                     p = next;
789                 }
790             for (i = 0; i < s->quant_table_count; i++)
791                 for (j = 0; j < s->context_count[i]; j++) {
792                     for (k = 0; k < 32; k++)
793                         for (m = 0; m < 2; m++) {
794                             s->rc_stat2[i][j][k][m] = strtol(p, &next, 0);
795                             if (next == p) {
796                                 av_log(avctx, AV_LOG_ERROR,
797                                        "2Pass file invalid at %d %d %d %d [%s]\n",
798                                        i, j, k, m, p);
799                                 av_freep(&best_state);
800                                 return AVERROR_INVALIDDATA;
801                             }
802                             p = next;
803                         }
804                 }
805             gob_count = strtol(p, &next, 0);
806             if (next == p || gob_count <= 0) {
807                 av_log(avctx, AV_LOG_ERROR, "2Pass file invalid\n");
808                 av_freep(&best_state);
809                 return AVERROR_INVALIDDATA;
810             }
811             p = next;
812             while (*p == '\n' || *p == ' ')
813                 p++;
814             if (p[0] == 0)
815                 break;
816         }
817         if (s->ac == AC_RANGE_CUSTOM_TAB)
818             sort_stt(s, s->state_transition);
819
820         find_best_state(best_state, s->state_transition);
821
822         for (i = 0; i < s->quant_table_count; i++) {
823             for (k = 0; k < 32; k++) {
824                 double a=0, b=0;
825                 int jp = 0;
826                 for (j = 0; j < s->context_count[i]; j++) {
827                     double p = 128;
828                     if (s->rc_stat2[i][j][k][0] + s->rc_stat2[i][j][k][1] > 200 && j || a+b > 200) {
829                         if (a+b)
830                             p = 256.0 * b / (a + b);
831                         s->initial_states[i][jp][k] =
832                             best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];
833                         for(jp++; jp<j; jp++)
834                             s->initial_states[i][jp][k] = s->initial_states[i][jp-1][k];
835                         a=b=0;
836                     }
837                     a += s->rc_stat2[i][j][k][0];
838                     b += s->rc_stat2[i][j][k][1];
839                     if (a+b) {
840                         p = 256.0 * b / (a + b);
841                     }
842                     s->initial_states[i][j][k] =
843                         best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];
844                 }
845             }
846         }
847         av_freep(&best_state);
848     }
849
850     if (s->version > 1) {
851         int plane_count = 1 + 2*s->chroma_planes + s->transparency;
852         int max_h_slices = AV_CEIL_RSHIFT(avctx->width , s->chroma_h_shift);
853         int max_v_slices = AV_CEIL_RSHIFT(avctx->height, s->chroma_v_shift);
854         s->num_v_slices = (avctx->width > 352 || avctx->height > 288 || !avctx->slices) ? 2 : 1;
855
856         s->num_v_slices = FFMIN(s->num_v_slices, max_v_slices);
857
858         for (; s->num_v_slices < 32; s->num_v_slices++) {
859             for (s->num_h_slices = s->num_v_slices; s->num_h_slices < 2*s->num_v_slices; s->num_h_slices++) {
860                 int maxw = (avctx->width  + s->num_h_slices - 1) / s->num_h_slices;
861                 int maxh = (avctx->height + s->num_v_slices - 1) / s->num_v_slices;
862                 if (s->num_h_slices > max_h_slices || s->num_v_slices > max_v_slices)
863                     continue;
864                 if (maxw * maxh * (int64_t)(s->bits_per_raw_sample+1) * plane_count > 8<<24)
865                     continue;
866                 if (avctx->slices == s->num_h_slices * s->num_v_slices && avctx->slices <= MAX_SLICES || !avctx->slices)
867                     goto slices_ok;
868             }
869         }
870         av_log(avctx, AV_LOG_ERROR,
871                "Unsupported number %d of slices requested, please specify a "
872                "supported number with -slices (ex:4,6,9,12,16, ...)\n",
873                avctx->slices);
874         return AVERROR(ENOSYS);
875 slices_ok:
876         if ((ret = write_extradata(s)) < 0)
877             return ret;
878     }
879
880     if ((ret = ff_ffv1_init_slice_contexts(s)) < 0)
881         return ret;
882     s->slice_count = s->max_slice_count;
883     if ((ret = ff_ffv1_init_slices_state(s)) < 0)
884         return ret;
885
886 #define STATS_OUT_SIZE 1024 * 1024 * 6
887     if (avctx->flags & AV_CODEC_FLAG_PASS1) {
888         avctx->stats_out = av_mallocz(STATS_OUT_SIZE);
889         if (!avctx->stats_out)
890             return AVERROR(ENOMEM);
891         for (i = 0; i < s->quant_table_count; i++)
892             for (j = 0; j < s->max_slice_count; j++) {
893                 FFV1Context *sf = s->slice_context[j];
894                 av_assert0(!sf->rc_stat2[i]);
895                 sf->rc_stat2[i] = av_mallocz(s->context_count[i] *
896                                              sizeof(*sf->rc_stat2[i]));
897                 if (!sf->rc_stat2[i])
898                     return AVERROR(ENOMEM);
899             }
900     }
901
902     return 0;
903 }
904
905 static void encode_slice_header(FFV1Context *f, FFV1Context *fs)
906 {
907     RangeCoder *c = &fs->c;
908     uint8_t state[CONTEXT_SIZE];
909     int j;
910     memset(state, 128, sizeof(state));
911
912     put_symbol(c, state, (fs->slice_x     +1)*f->num_h_slices / f->width   , 0);
913     put_symbol(c, state, (fs->slice_y     +1)*f->num_v_slices / f->height  , 0);
914     put_symbol(c, state, (fs->slice_width +1)*f->num_h_slices / f->width -1, 0);
915     put_symbol(c, state, (fs->slice_height+1)*f->num_v_slices / f->height-1, 0);
916     for (j=0; j<f->plane_count; j++) {
917         put_symbol(c, state, f->plane[j].quant_table_index, 0);
918         av_assert0(f->plane[j].quant_table_index == f->context_model);
919     }
920     if (!f->picture.f->interlaced_frame)
921         put_symbol(c, state, 3, 0);
922     else
923         put_symbol(c, state, 1 + !f->picture.f->top_field_first, 0);
924     put_symbol(c, state, f->picture.f->sample_aspect_ratio.num, 0);
925     put_symbol(c, state, f->picture.f->sample_aspect_ratio.den, 0);
926     if (f->version > 3) {
927         put_rac(c, state, fs->slice_coding_mode == 1);
928         if (fs->slice_coding_mode == 1)
929             ff_ffv1_clear_slice_state(f, fs);
930         put_symbol(c, state, fs->slice_coding_mode, 0);
931         if (fs->slice_coding_mode != 1) {
932             put_symbol(c, state, fs->slice_rct_by_coef, 0);
933             put_symbol(c, state, fs->slice_rct_ry_coef, 0);
934         }
935     }
936 }
937
938 static void choose_rct_params(FFV1Context *fs, const uint8_t *src[3], const int stride[3], int w, int h)
939 {
940 #define NB_Y_COEFF 15
941     static const int rct_y_coeff[15][2] = {
942         {0, 0}, //      4G
943         {1, 1}, //  R + 2G + B
944         {2, 2}, // 2R      + 2B
945         {0, 2}, //      2G + 2B
946         {2, 0}, // 2R + 2G
947         {4, 0}, // 4R
948         {0, 4}, //           4B
949
950         {0, 3}, //      1G + 3B
951         {3, 0}, // 3R + 1G
952         {3, 1}, // 3R      +  B
953         {1, 3}, //  R      + 3B
954         {1, 2}, //  R +  G + 2B
955         {2, 1}, // 2R +  G +  B
956         {0, 1}, //      3G +  B
957         {1, 0}, //  R + 3G
958     };
959
960     int stat[NB_Y_COEFF] = {0};
961     int x, y, i, p, best;
962     int16_t *sample[3];
963     int lbd = fs->bits_per_raw_sample <= 8;
964
965     for (y = 0; y < h; y++) {
966         int lastr=0, lastg=0, lastb=0;
967         for (p = 0; p < 3; p++)
968             sample[p] = fs->sample_buffer + p*w;
969
970         for (x = 0; x < w; x++) {
971             int b, g, r;
972             int ab, ag, ar;
973             if (lbd) {
974                 unsigned v = *((const uint32_t*)(src[0] + x*4 + stride[0]*y));
975                 b =  v        & 0xFF;
976                 g = (v >>  8) & 0xFF;
977                 r = (v >> 16) & 0xFF;
978             } else {
979                 b = *((const uint16_t*)(src[0] + x*2 + stride[0]*y));
980                 g = *((const uint16_t*)(src[1] + x*2 + stride[1]*y));
981                 r = *((const uint16_t*)(src[2] + x*2 + stride[2]*y));
982             }
983
984             ar = r - lastr;
985             ag = g - lastg;
986             ab = b - lastb;
987             if (x && y) {
988                 int bg = ag - sample[0][x];
989                 int bb = ab - sample[1][x];
990                 int br = ar - sample[2][x];
991
992                 br -= bg;
993                 bb -= bg;
994
995                 for (i = 0; i<NB_Y_COEFF; i++) {
996                     stat[i] += FFABS(bg + ((br*rct_y_coeff[i][0] + bb*rct_y_coeff[i][1])>>2));
997                 }
998
999             }
1000             sample[0][x] = ag;
1001             sample[1][x] = ab;
1002             sample[2][x] = ar;
1003
1004             lastr = r;
1005             lastg = g;
1006             lastb = b;
1007         }
1008     }
1009
1010     best = 0;
1011     for (i=1; i<NB_Y_COEFF; i++) {
1012         if (stat[i] < stat[best])
1013             best = i;
1014     }
1015
1016     fs->slice_rct_by_coef = rct_y_coeff[best][1];
1017     fs->slice_rct_ry_coef = rct_y_coeff[best][0];
1018 }
1019
1020 static int encode_slice(AVCodecContext *c, void *arg)
1021 {
1022     FFV1Context *fs  = *(void **)arg;
1023     FFV1Context *f   = fs->avctx->priv_data;
1024     int width        = fs->slice_width;
1025     int height       = fs->slice_height;
1026     int x            = fs->slice_x;
1027     int y            = fs->slice_y;
1028     const AVFrame *const p = f->picture.f;
1029     const int ps     = av_pix_fmt_desc_get(c->pix_fmt)->comp[0].step;
1030     int ret;
1031     RangeCoder c_bak = fs->c;
1032     const uint8_t *planes[3] = {p->data[0] + ps*x + y*p->linesize[0],
1033                                 p->data[1] ? p->data[1] + ps*x + y*p->linesize[1] : NULL,
1034                                 p->data[2] ? p->data[2] + ps*x + y*p->linesize[2] : NULL};
1035
1036     fs->slice_coding_mode = 0;
1037     if (f->version > 3) {
1038         choose_rct_params(fs, planes, p->linesize, width, height);
1039     } else {
1040         fs->slice_rct_by_coef = 1;
1041         fs->slice_rct_ry_coef = 1;
1042     }
1043
1044 retry:
1045     if (f->key_frame)
1046         ff_ffv1_clear_slice_state(f, fs);
1047     if (f->version > 2) {
1048         encode_slice_header(f, fs);
1049     }
1050     if (fs->ac == AC_GOLOMB_RICE) {
1051         if (f->version > 2)
1052             put_rac(&fs->c, (uint8_t[]) { 129 }, 0);
1053         fs->ac_byte_count = f->version > 2 || (!x && !y) ? ff_rac_terminate(&fs->c) : 0;
1054         init_put_bits(&fs->pb,
1055                       fs->c.bytestream_start + fs->ac_byte_count,
1056                       fs->c.bytestream_end - fs->c.bytestream_start - fs->ac_byte_count);
1057     }
1058
1059     if (f->colorspace == 0 && c->pix_fmt != AV_PIX_FMT_YA8) {
1060         const int chroma_width  = AV_CEIL_RSHIFT(width,  f->chroma_h_shift);
1061         const int chroma_height = AV_CEIL_RSHIFT(height, f->chroma_v_shift);
1062         const int cx            = x >> f->chroma_h_shift;
1063         const int cy            = y >> f->chroma_v_shift;
1064
1065         ret = encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 1);
1066
1067         if (f->chroma_planes) {
1068             ret |= encode_plane(fs, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1, 1);
1069             ret |= encode_plane(fs, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1, 1);
1070         }
1071         if (fs->transparency)
1072             ret |= encode_plane(fs, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], 2, 1);
1073     } else if (c->pix_fmt == AV_PIX_FMT_YA8) {
1074         ret  = encode_plane(fs, p->data[0] +     ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 2);
1075         ret |= encode_plane(fs, p->data[0] + 1 + ps*x + y*p->linesize[0], width, height, p->linesize[0], 1, 2);
1076     } else if (f->use32bit) {
1077         ret = encode_rgb_frame32(fs, planes, width, height, p->linesize);
1078     } else {
1079         ret = encode_rgb_frame(fs, planes, width, height, p->linesize);
1080     }
1081     emms_c();
1082
1083     if (ret < 0) {
1084         av_assert0(fs->slice_coding_mode == 0);
1085         if (fs->version < 4 || !fs->ac) {
1086             av_log(c, AV_LOG_ERROR, "Buffer too small\n");
1087             return ret;
1088         }
1089         av_log(c, AV_LOG_DEBUG, "Coding slice as PCM\n");
1090         fs->slice_coding_mode = 1;
1091         fs->c = c_bak;
1092         goto retry;
1093     }
1094
1095     return 0;
1096 }
1097
1098 static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
1099                         const AVFrame *pict, int *got_packet)
1100 {
1101     FFV1Context *f      = avctx->priv_data;
1102     RangeCoder *const c = &f->slice_context[0]->c;
1103     AVFrame *const p    = f->picture.f;
1104     uint8_t keystate    = 128;
1105     uint8_t *buf_p;
1106     int i, ret;
1107     int64_t maxsize =   AV_INPUT_BUFFER_MIN_SIZE
1108                       + avctx->width*avctx->height*37LL*4;
1109
1110     if(!pict) {
1111         if (avctx->flags & AV_CODEC_FLAG_PASS1) {
1112             int j, k, m;
1113             char *p   = avctx->stats_out;
1114             char *end = p + STATS_OUT_SIZE;
1115
1116             memset(f->rc_stat, 0, sizeof(f->rc_stat));
1117             for (i = 0; i < f->quant_table_count; i++)
1118                 memset(f->rc_stat2[i], 0, f->context_count[i] * sizeof(*f->rc_stat2[i]));
1119
1120             av_assert0(f->slice_count == f->max_slice_count);
1121             for (j = 0; j < f->slice_count; j++) {
1122                 FFV1Context *fs = f->slice_context[j];
1123                 for (i = 0; i < 256; i++) {
1124                     f->rc_stat[i][0] += fs->rc_stat[i][0];
1125                     f->rc_stat[i][1] += fs->rc_stat[i][1];
1126                 }
1127                 for (i = 0; i < f->quant_table_count; i++) {
1128                     for (k = 0; k < f->context_count[i]; k++)
1129                         for (m = 0; m < 32; m++) {
1130                             f->rc_stat2[i][k][m][0] += fs->rc_stat2[i][k][m][0];
1131                             f->rc_stat2[i][k][m][1] += fs->rc_stat2[i][k][m][1];
1132                         }
1133                 }
1134             }
1135
1136             for (j = 0; j < 256; j++) {
1137                 snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1138                         f->rc_stat[j][0], f->rc_stat[j][1]);
1139                 p += strlen(p);
1140             }
1141             snprintf(p, end - p, "\n");
1142
1143             for (i = 0; i < f->quant_table_count; i++) {
1144                 for (j = 0; j < f->context_count[i]; j++)
1145                     for (m = 0; m < 32; m++) {
1146                         snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1147                                 f->rc_stat2[i][j][m][0], f->rc_stat2[i][j][m][1]);
1148                         p += strlen(p);
1149                     }
1150             }
1151             snprintf(p, end - p, "%d\n", f->gob_count);
1152         }
1153         return 0;
1154     }
1155
1156     if (f->version > 3)
1157         maxsize = AV_INPUT_BUFFER_MIN_SIZE + avctx->width*avctx->height*3LL*4;
1158
1159     if (maxsize > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE - 32) {
1160         av_log(avctx, AV_LOG_WARNING, "Cannot allocate worst case packet size, the encoding could fail\n");
1161         maxsize = INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE - 32;
1162     }
1163
1164     if ((ret = ff_alloc_packet2(avctx, pkt, maxsize, 0)) < 0)
1165         return ret;
1166
1167     ff_init_range_encoder(c, pkt->data, pkt->size);
1168     ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
1169
1170     av_frame_unref(p);
1171     if ((ret = av_frame_ref(p, pict)) < 0)
1172         return ret;
1173 #if FF_API_CODED_FRAME
1174 FF_DISABLE_DEPRECATION_WARNINGS
1175     avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
1176 FF_ENABLE_DEPRECATION_WARNINGS
1177 #endif
1178
1179     if (avctx->gop_size == 0 || f->picture_number % avctx->gop_size == 0) {
1180         put_rac(c, &keystate, 1);
1181         f->key_frame = 1;
1182         f->gob_count++;
1183         write_header(f);
1184     } else {
1185         put_rac(c, &keystate, 0);
1186         f->key_frame = 0;
1187     }
1188
1189     if (f->ac == AC_RANGE_CUSTOM_TAB) {
1190         int i;
1191         for (i = 1; i < 256; i++) {
1192             c->one_state[i]        = f->state_transition[i];
1193             c->zero_state[256 - i] = 256 - c->one_state[i];
1194         }
1195     }
1196
1197     for (i = 0; i < f->slice_count; i++) {
1198         FFV1Context *fs = f->slice_context[i];
1199         uint8_t *start  = pkt->data + pkt->size * (int64_t)i / f->slice_count;
1200         int len         = pkt->size / f->slice_count;
1201         if (i) {
1202             ff_init_range_encoder(&fs->c, start, len);
1203         } else {
1204             av_assert0(fs->c.bytestream_end >= fs->c.bytestream_start + len);
1205             av_assert0(fs->c.bytestream < fs->c.bytestream_start + len);
1206             fs->c.bytestream_end = fs->c.bytestream_start + len;
1207         }
1208     }
1209     avctx->execute(avctx, encode_slice, &f->slice_context[0], NULL,
1210                    f->slice_count, sizeof(void *));
1211
1212     buf_p = pkt->data;
1213     for (i = 0; i < f->slice_count; i++) {
1214         FFV1Context *fs = f->slice_context[i];
1215         int bytes;
1216
1217         if (fs->ac != AC_GOLOMB_RICE) {
1218             uint8_t state = 129;
1219             put_rac(&fs->c, &state, 0);
1220             bytes = ff_rac_terminate(&fs->c);
1221         } else {
1222             flush_put_bits(&fs->pb); // FIXME: nicer padding
1223             bytes = fs->ac_byte_count + (put_bits_count(&fs->pb) + 7) / 8;
1224         }
1225         if (i > 0 || f->version > 2) {
1226             av_assert0(bytes < pkt->size / f->slice_count);
1227             memmove(buf_p, fs->c.bytestream_start, bytes);
1228             av_assert0(bytes < (1 << 24));
1229             AV_WB24(buf_p + bytes, bytes);
1230             bytes += 3;
1231         }
1232         if (f->ec) {
1233             unsigned v;
1234             buf_p[bytes++] = 0;
1235             v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, buf_p, bytes);
1236             AV_WL32(buf_p + bytes, v);
1237             bytes += 4;
1238         }
1239         buf_p += bytes;
1240     }
1241
1242     if (avctx->flags & AV_CODEC_FLAG_PASS1)
1243         avctx->stats_out[0] = '\0';
1244
1245 #if FF_API_CODED_FRAME
1246 FF_DISABLE_DEPRECATION_WARNINGS
1247     avctx->coded_frame->key_frame = f->key_frame;
1248 FF_ENABLE_DEPRECATION_WARNINGS
1249 #endif
1250
1251     f->picture_number++;
1252     pkt->size   = buf_p - pkt->data;
1253     pkt->pts    =
1254     pkt->dts    = pict->pts;
1255     pkt->flags |= AV_PKT_FLAG_KEY * f->key_frame;
1256     *got_packet = 1;
1257
1258     return 0;
1259 }
1260
1261 static av_cold int encode_close(AVCodecContext *avctx)
1262 {
1263     ff_ffv1_close(avctx);
1264     return 0;
1265 }
1266
1267 #define OFFSET(x) offsetof(FFV1Context, x)
1268 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1269 static const AVOption options[] = {
1270     { "slicecrc", "Protect slices with CRCs", OFFSET(ec), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE },
1271     { "coder", "Coder type", OFFSET(ac), AV_OPT_TYPE_INT,
1272             { .i64 = 0 }, -2, 2, VE, "coder" },
1273         { "rice", "Golomb rice", 0, AV_OPT_TYPE_CONST,
1274             { .i64 = AC_GOLOMB_RICE }, INT_MIN, INT_MAX, VE, "coder" },
1275         { "range_def", "Range with default table", 0, AV_OPT_TYPE_CONST,
1276             { .i64 = AC_RANGE_DEFAULT_TAB_FORCE }, INT_MIN, INT_MAX, VE, "coder" },
1277         { "range_tab", "Range with custom table", 0, AV_OPT_TYPE_CONST,
1278             { .i64 = AC_RANGE_CUSTOM_TAB }, INT_MIN, INT_MAX, VE, "coder" },
1279         { "ac", "Range with custom table (the ac option exists for compatibility and is deprecated)", 0, AV_OPT_TYPE_CONST,
1280             { .i64 = 1 }, INT_MIN, INT_MAX, VE, "coder" },
1281     { "context", "Context model", OFFSET(context_model), AV_OPT_TYPE_INT,
1282             { .i64 = 0 }, 0, 1, VE },
1283
1284     { NULL }
1285 };
1286
1287 static const AVClass ffv1_class = {
1288     .class_name = "ffv1 encoder",
1289     .item_name  = av_default_item_name,
1290     .option     = options,
1291     .version    = LIBAVUTIL_VERSION_INT,
1292 };
1293
1294 #if FF_API_CODER_TYPE
1295 static const AVCodecDefault ffv1_defaults[] = {
1296     { "coder", "-1" },
1297     { NULL },
1298 };
1299 #endif
1300
1301 AVCodec ff_ffv1_encoder = {
1302     .name           = "ffv1",
1303     .long_name      = NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1304     .type           = AVMEDIA_TYPE_VIDEO,
1305     .id             = AV_CODEC_ID_FFV1,
1306     .priv_data_size = sizeof(FFV1Context),
1307     .init           = encode_init,
1308     .encode2        = encode_frame,
1309     .close          = encode_close,
1310     .capabilities   = AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_DELAY,
1311     .pix_fmts       = (const enum AVPixelFormat[]) {
1312         AV_PIX_FMT_YUV420P,   AV_PIX_FMT_YUVA420P,  AV_PIX_FMT_YUVA422P,  AV_PIX_FMT_YUV444P,
1313         AV_PIX_FMT_YUVA444P,  AV_PIX_FMT_YUV440P,   AV_PIX_FMT_YUV422P,   AV_PIX_FMT_YUV411P,
1314         AV_PIX_FMT_YUV410P,   AV_PIX_FMT_0RGB32,    AV_PIX_FMT_RGB32,     AV_PIX_FMT_YUV420P16,
1315         AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16, AV_PIX_FMT_YUV444P9,  AV_PIX_FMT_YUV422P9,
1316         AV_PIX_FMT_YUV420P9,  AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
1317         AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12,
1318         AV_PIX_FMT_YUVA444P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA420P16,
1319         AV_PIX_FMT_YUVA444P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA420P10,
1320         AV_PIX_FMT_YUVA444P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA420P9,
1321         AV_PIX_FMT_GRAY16,    AV_PIX_FMT_GRAY8,     AV_PIX_FMT_GBRP9,     AV_PIX_FMT_GBRP10,
1322         AV_PIX_FMT_GBRP12,    AV_PIX_FMT_GBRP14,
1323         AV_PIX_FMT_YA8,
1324         AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY12,
1325         AV_PIX_FMT_GBRP16, AV_PIX_FMT_RGB48,
1326         AV_PIX_FMT_NONE
1327
1328     },
1329 #if FF_API_CODER_TYPE
1330     .defaults       = ffv1_defaults,
1331 #endif
1332     .priv_class     = &ffv1_class,
1333 };