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