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