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