Merge commit 'cebdedca57d95834a8f8098c7b6a322a1163e26b'
[ffmpeg.git] / libavcodec / ffv1enc.c
1 /*
2  * FFV1 encoder
3  *
4  * Copyright (c) 2003-2012 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 = 0; 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     av_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) {
278         if (c->bytestream_end - c->bytestream < w * 20) {
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     for (x = 0; x < w; x++) {
290         int diff, context;
291
292         context = get_context(p, sample[0] + x, sample[1] + x, sample[2] + x);
293         diff    = sample[0][x] - predict(sample[0] + x, sample[1] + x);
294
295         if (context < 0) {
296             context = -context;
297             diff    = -diff;
298         }
299
300         diff = fold(diff, bits);
301
302         if (s->ac) {
303             if (s->flags & CODEC_FLAG_PASS1) {
304                 put_symbol_inline(c, p->state[context], diff, 1, s->rc_stat,
305                                   s->rc_stat2[p->quant_table_index][context]);
306             } else {
307                 put_symbol_inline(c, p->state[context], diff, 1, NULL, NULL);
308             }
309         } else {
310             if (context == 0)
311                 run_mode = 1;
312
313             if (run_mode) {
314                 if (diff) {
315                     while (run_count >= 1 << ff_log2_run[run_index]) {
316                         run_count -= 1 << ff_log2_run[run_index];
317                         run_index++;
318                         put_bits(&s->pb, 1, 1);
319                     }
320
321                     put_bits(&s->pb, 1 + ff_log2_run[run_index], run_count);
322                     if (run_index)
323                         run_index--;
324                     run_count = 0;
325                     run_mode  = 0;
326                     if (diff > 0)
327                         diff--;
328                 } else {
329                     run_count++;
330                 }
331             }
332
333             av_dlog(s->avctx, "count:%d index:%d, mode:%d, x:%d pos:%d\n",
334                     run_count, run_index, run_mode, x,
335                     (int)put_bits_count(&s->pb));
336
337             if (run_mode == 0)
338                 put_vlc_symbol(&s->pb, &p->vlc_state[context], diff, bits);
339         }
340     }
341     if (run_mode) {
342         while (run_count >= 1 << ff_log2_run[run_index]) {
343             run_count -= 1 << ff_log2_run[run_index];
344             run_index++;
345             put_bits(&s->pb, 1, 1);
346         }
347
348         if (run_count)
349             put_bits(&s->pb, 1, 1);
350     }
351     s->run_index = run_index;
352
353     return 0;
354 }
355
356 static void encode_plane(FFV1Context *s, uint8_t *src, int w, int h,
357                          int stride, int plane_index)
358 {
359     int x, y, i;
360     const int ring_size = s->avctx->context_model ? 3 : 2;
361     int16_t *sample[3];
362     s->run_index = 0;
363
364     memset(s->sample_buffer, 0, ring_size * (w + 6) * sizeof(*s->sample_buffer));
365
366     for (y = 0; y < h; y++) {
367         for (i = 0; i < ring_size; i++)
368             sample[i] = s->sample_buffer + (w + 6) * ((h + i - y) % ring_size) + 3;
369
370         sample[0][-1]= sample[1][0  ];
371         sample[1][ w]= sample[1][w-1];
372 // { START_TIMER
373         if (s->bits_per_raw_sample <= 8) {
374             for (x = 0; x < w; x++)
375                 sample[0][x] = src[x + stride * y];
376             encode_line(s, w, sample, plane_index, 8);
377         } else {
378             if (s->packed_at_lsb) {
379                 for (x = 0; x < w; x++) {
380                     sample[0][x] = ((uint16_t*)(src + stride*y))[x];
381                 }
382             } else {
383                 for (x = 0; x < w; x++) {
384                     sample[0][x] = ((uint16_t*)(src + stride*y))[x] >> (16 - s->bits_per_raw_sample);
385                 }
386             }
387             encode_line(s, w, sample, plane_index, s->bits_per_raw_sample);
388         }
389 // STOP_TIMER("encode line") }
390     }
391 }
392
393 static void encode_rgb_frame(FFV1Context *s, uint8_t *src[3], int w, int h, int stride[3])
394 {
395     int x, y, p, i;
396     const int ring_size = s->avctx->context_model ? 3 : 2;
397     int16_t *sample[4][3];
398     int lbd    = s->bits_per_raw_sample <= 8;
399     int bits   = s->bits_per_raw_sample > 0 ? s->bits_per_raw_sample : 8;
400     int offset = 1 << bits;
401
402     s->run_index = 0;
403
404     memset(s->sample_buffer, 0, ring_size * MAX_PLANES *
405                                 (w + 6) * sizeof(*s->sample_buffer));
406
407     for (y = 0; y < h; y++) {
408         for (i = 0; i < ring_size; i++)
409             for (p = 0; p < MAX_PLANES; p++)
410                 sample[p][i]= s->sample_buffer + p*ring_size*(w+6) + ((h+i-y)%ring_size)*(w+6) + 3;
411
412         for (x = 0; x < w; x++) {
413             int b, g, r, av_uninit(a);
414             if (lbd) {
415                 unsigned v = *((uint32_t*)(src[0] + x*4 + stride[0]*y));
416                 b =  v        & 0xFF;
417                 g = (v >>  8) & 0xFF;
418                 r = (v >> 16) & 0xFF;
419                 a =  v >> 24;
420             } else {
421                 b = *((uint16_t*)(src[0] + x*2 + stride[0]*y));
422                 g = *((uint16_t*)(src[1] + x*2 + stride[1]*y));
423                 r = *((uint16_t*)(src[2] + x*2 + stride[2]*y));
424             }
425
426             b -= g;
427             r -= g;
428             g += (b + r) >> 2;
429             b += offset;
430             r += offset;
431
432             sample[0][0][x] = g;
433             sample[1][0][x] = b;
434             sample[2][0][x] = r;
435             sample[3][0][x] = a;
436         }
437         for (p = 0; p < 3 + s->transparency; p++) {
438             sample[p][0][-1] = sample[p][1][0  ];
439             sample[p][1][ w] = sample[p][1][w-1];
440             if (lbd)
441                 encode_line(s, w, sample[p], (p + 1) / 2, 9);
442             else
443                 encode_line(s, w, sample[p], (p + 1) / 2, bits + 1);
444         }
445     }
446 }
447
448 static void write_quant_table(RangeCoder *c, int16_t *quant_table)
449 {
450     int last = 0;
451     int i;
452     uint8_t state[CONTEXT_SIZE];
453     memset(state, 128, sizeof(state));
454
455     for (i = 1; i < 128; i++)
456         if (quant_table[i] != quant_table[i - 1]) {
457             put_symbol(c, state, i - last - 1, 0);
458             last = i;
459         }
460     put_symbol(c, state, i - last - 1, 0);
461 }
462
463 static void write_quant_tables(RangeCoder *c,
464                                int16_t quant_table[MAX_CONTEXT_INPUTS][256])
465 {
466     int i;
467     for (i = 0; i < 5; i++)
468         write_quant_table(c, quant_table[i]);
469 }
470
471 static void write_header(FFV1Context *f)
472 {
473     uint8_t state[CONTEXT_SIZE];
474     int i, j;
475     RangeCoder *const c = &f->slice_context[0]->c;
476
477     memset(state, 128, sizeof(state));
478
479     if (f->version < 2) {
480         put_symbol(c, state, f->version, 0);
481         put_symbol(c, state, f->ac, 0);
482         if (f->ac > 1) {
483             for (i = 1; i < 256; i++)
484                 put_symbol(c, state,
485                            f->state_transition[i] - c->one_state[i], 1);
486         }
487         put_symbol(c, state, f->colorspace, 0); //YUV cs type
488         if (f->version > 0)
489             put_symbol(c, state, f->bits_per_raw_sample, 0);
490         put_rac(c, state, f->chroma_planes);
491         put_symbol(c, state, f->chroma_h_shift, 0);
492         put_symbol(c, state, f->chroma_v_shift, 0);
493         put_rac(c, state, f->transparency);
494
495         write_quant_tables(c, f->quant_table);
496     } else if (f->version < 3) {
497         put_symbol(c, state, f->slice_count, 0);
498         for (i = 0; i < f->slice_count; i++) {
499             FFV1Context *fs = f->slice_context[i];
500             put_symbol(c, state,
501                        (fs->slice_x      + 1) * f->num_h_slices / f->width, 0);
502             put_symbol(c, state,
503                        (fs->slice_y      + 1) * f->num_v_slices / f->height, 0);
504             put_symbol(c, state,
505                        (fs->slice_width  + 1) * f->num_h_slices / f->width - 1,
506                        0);
507             put_symbol(c, state,
508                        (fs->slice_height + 1) * f->num_v_slices / f->height - 1,
509                        0);
510             for (j = 0; j < f->plane_count; j++) {
511                 put_symbol(c, state, f->plane[j].quant_table_index, 0);
512                 av_assert0(f->plane[j].quant_table_index == f->avctx->context_model);
513             }
514         }
515     }
516 }
517
518 static int write_extradata(FFV1Context *f)
519 {
520     RangeCoder *const c = &f->c;
521     uint8_t state[CONTEXT_SIZE];
522     int i, j, k;
523     uint8_t state2[32][CONTEXT_SIZE];
524     unsigned v;
525
526     memset(state2, 128, sizeof(state2));
527     memset(state, 128, sizeof(state));
528
529     f->avctx->extradata_size = 10000 + 4 +
530                                     (11 * 11 * 5 * 5 * 5 + 11 * 11 * 11) * 32;
531     f->avctx->extradata = av_malloc(f->avctx->extradata_size);
532     ff_init_range_encoder(c, f->avctx->extradata, f->avctx->extradata_size);
533     ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
534
535     put_symbol(c, state, f->version, 0);
536     if (f->version > 2) {
537         if (f->version == 3)
538             f->minor_version = 3;
539         put_symbol(c, state, f->minor_version, 0);
540     }
541
542     put_symbol(c, state, f->ac, 0);
543     if (f->ac > 1)
544         for (i = 1; i < 256; i++)
545             put_symbol(c, state, f->state_transition[i] - c->one_state[i], 1);
546
547     put_symbol(c, state, f->colorspace, 0); // YUV cs type
548     put_symbol(c, state, f->bits_per_raw_sample, 0);
549     put_rac(c, state, f->chroma_planes);
550     put_symbol(c, state, f->chroma_h_shift, 0);
551     put_symbol(c, state, f->chroma_v_shift, 0);
552     put_rac(c, state, f->transparency);
553     put_symbol(c, state, f->num_h_slices - 1, 0);
554     put_symbol(c, state, f->num_v_slices - 1, 0);
555
556     put_symbol(c, state, f->quant_table_count, 0);
557     for (i = 0; i < f->quant_table_count; i++)
558         write_quant_tables(c, f->quant_tables[i]);
559
560     for (i = 0; i < f->quant_table_count; i++) {
561         for (j = 0; j < f->context_count[i] * CONTEXT_SIZE; j++)
562             if (f->initial_states[i] && f->initial_states[i][0][j] != 128)
563                 break;
564         if (j < f->context_count[i] * CONTEXT_SIZE) {
565             put_rac(c, state, 1);
566             for (j = 0; j < f->context_count[i]; j++)
567                 for (k = 0; k < CONTEXT_SIZE; k++) {
568                     int pred = j ? f->initial_states[i][j - 1][k] : 128;
569                     put_symbol(c, state2[k],
570                                (int8_t)(f->initial_states[i][j][k] - pred), 1);
571                 }
572         } else {
573             put_rac(c, state, 0);
574         }
575     }
576
577     if (f->version > 2) {
578         put_symbol(c, state, f->ec, 0);
579         put_symbol(c, state, f->intra = (f->avctx->gop_size < 2), 0);
580     }
581
582     f->avctx->extradata_size = ff_rac_terminate(c);
583     v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, f->avctx->extradata, f->avctx->extradata_size);
584     AV_WL32(f->avctx->extradata + f->avctx->extradata_size, v);
585     f->avctx->extradata_size += 4;
586
587     return 0;
588 }
589
590 static int sort_stt(FFV1Context *s, uint8_t stt[256])
591 {
592     int i, i2, changed, print = 0;
593
594     do {
595         changed = 0;
596         for (i = 12; i < 244; i++) {
597             for (i2 = i + 1; i2 < 245 && i2 < i + 4; i2++) {
598
599 #define COST(old, new)                                      \
600     s->rc_stat[old][0] * -log2((256 - (new)) / 256.0) +     \
601     s->rc_stat[old][1] * -log2((new)         / 256.0)
602
603 #define COST2(old, new)                         \
604     COST(old, new) + COST(256 - (old), 256 - (new))
605
606                 double size0 = COST2(i,  i) + COST2(i2, i2);
607                 double sizeX = COST2(i, i2) + COST2(i2, i);
608                 if (size0 - sizeX > size0*(1e-14) && i != 128 && i2 != 128) {
609                     int j;
610                     FFSWAP(int, stt[i], stt[i2]);
611                     FFSWAP(int, s->rc_stat[i][0], s->rc_stat[i2][0]);
612                     FFSWAP(int, s->rc_stat[i][1], s->rc_stat[i2][1]);
613                     if (i != 256 - i2) {
614                         FFSWAP(int, stt[256 - i], stt[256 - i2]);
615                         FFSWAP(int, s->rc_stat[256 - i][0], s->rc_stat[256 - i2][0]);
616                         FFSWAP(int, s->rc_stat[256 - i][1], s->rc_stat[256 - i2][1]);
617                     }
618                     for (j = 1; j < 256; j++) {
619                         if (stt[j] == i)
620                             stt[j] = i2;
621                         else if (stt[j] == i2)
622                             stt[j] = i;
623                         if (i != 256 - i2) {
624                             if (stt[256 - j] == 256 - i)
625                                 stt[256 - j] = 256 - i2;
626                             else if (stt[256 - j] == 256 - i2)
627                                 stt[256 - j] = 256 - i;
628                         }
629                     }
630                     print = changed = 1;
631                 }
632             }
633         }
634     } while (changed);
635     return print;
636 }
637
638 static av_cold int encode_init(AVCodecContext *avctx)
639 {
640     FFV1Context *s = avctx->priv_data;
641     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
642     int i, j, k, m, ret;
643
644     if ((ret = ffv1_common_init(avctx)) < 0)
645         return ret;
646
647     s->version = 0;
648
649     if ((avctx->flags & (CODEC_FLAG_PASS1|CODEC_FLAG_PASS2)) || avctx->slices>1)
650         s->version = FFMAX(s->version, 2);
651
652     if (avctx->level == 3 || (s->version==2 && avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL)) {
653         s->version = 3;
654     }
655
656     if (s->ec < 0) {
657         s->ec = (s->version >= 3);
658     }
659
660     if (s->version >= 2 && avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
661         av_log(avctx, AV_LOG_ERROR, "Version 2 needed for requested features but version 2 is experimental and not enabled\n");
662         return AVERROR_INVALIDDATA;
663     }
664
665     s->ac = avctx->coder_type > 0 ? 2 : 0;
666
667     s->plane_count = 3;
668     switch(avctx->pix_fmt) {
669     case AV_PIX_FMT_YUV444P9:
670     case AV_PIX_FMT_YUV422P9:
671     case AV_PIX_FMT_YUV420P9:
672         if (!avctx->bits_per_raw_sample)
673             s->bits_per_raw_sample = 9;
674     case AV_PIX_FMT_YUV444P10:
675     case AV_PIX_FMT_YUV420P10:
676     case AV_PIX_FMT_YUV422P10:
677         s->packed_at_lsb = 1;
678         if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
679             s->bits_per_raw_sample = 10;
680     case AV_PIX_FMT_GRAY16:
681     case AV_PIX_FMT_YUV444P16:
682     case AV_PIX_FMT_YUV422P16:
683     case AV_PIX_FMT_YUV420P16:
684         if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) {
685             s->bits_per_raw_sample = 16;
686         } else if (!s->bits_per_raw_sample) {
687             s->bits_per_raw_sample = avctx->bits_per_raw_sample;
688         }
689         if (s->bits_per_raw_sample <= 8) {
690             av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");
691             return AVERROR_INVALIDDATA;
692         }
693         if (!s->ac && avctx->coder_type == -1) {
694             av_log(avctx, AV_LOG_INFO, "bits_per_raw_sample > 8, forcing coder 1\n");
695             s->ac = 2;
696         }
697         if (!s->ac) {
698             av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample of more than 8 needs -coder 1 currently\n");
699             return AVERROR(ENOSYS);
700         }
701         s->version = FFMAX(s->version, 1);
702     case AV_PIX_FMT_GRAY8:
703     case AV_PIX_FMT_YUV444P:
704     case AV_PIX_FMT_YUV440P:
705     case AV_PIX_FMT_YUV422P:
706     case AV_PIX_FMT_YUV420P:
707     case AV_PIX_FMT_YUV411P:
708     case AV_PIX_FMT_YUV410P:
709         s->chroma_planes = desc->nb_components < 3 ? 0 : 1;
710         s->colorspace = 0;
711         break;
712     case AV_PIX_FMT_YUVA444P:
713     case AV_PIX_FMT_YUVA422P:
714     case AV_PIX_FMT_YUVA420P:
715         s->chroma_planes = 1;
716         s->colorspace = 0;
717         s->transparency = 1;
718         break;
719     case AV_PIX_FMT_RGB32:
720         s->colorspace = 1;
721         s->transparency = 1;
722         break;
723     case AV_PIX_FMT_0RGB32:
724         s->colorspace = 1;
725         break;
726     case AV_PIX_FMT_GBRP9:
727         if (!avctx->bits_per_raw_sample)
728             s->bits_per_raw_sample = 9;
729     case AV_PIX_FMT_GBRP10:
730         if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
731             s->bits_per_raw_sample = 10;
732     case AV_PIX_FMT_GBRP12:
733         if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
734             s->bits_per_raw_sample = 12;
735     case AV_PIX_FMT_GBRP14:
736         if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
737             s->bits_per_raw_sample = 14;
738         else if (!s->bits_per_raw_sample)
739             s->bits_per_raw_sample = avctx->bits_per_raw_sample;
740         s->colorspace = 1;
741         s->chroma_planes = 1;
742         s->version = FFMAX(s->version, 1);
743         break;
744     default:
745         av_log(avctx, AV_LOG_ERROR, "format not supported\n");
746         return AVERROR(ENOSYS);
747     }
748     if (s->transparency) {
749         av_log(avctx, AV_LOG_WARNING, "Storing alpha plane, this will require a recent FFV1 decoder to playback!\n");
750     }
751     if (avctx->context_model > 1U) {
752         av_log(avctx, AV_LOG_ERROR, "Invalid context model %d, valid values are 0 and 1\n", avctx->context_model);
753         return AVERROR(EINVAL);
754     }
755
756     if (s->ac > 1)
757         for (i = 1; i < 256; i++)
758             s->state_transition[i] = ver2_state[i];
759
760     for (i = 0; i < 256; i++) {
761         s->quant_table_count = 2;
762         if (s->bits_per_raw_sample <= 8) {
763             s->quant_tables[0][0][i]=           quant11[i];
764             s->quant_tables[0][1][i]=        11*quant11[i];
765             s->quant_tables[0][2][i]=     11*11*quant11[i];
766             s->quant_tables[1][0][i]=           quant11[i];
767             s->quant_tables[1][1][i]=        11*quant11[i];
768             s->quant_tables[1][2][i]=     11*11*quant5 [i];
769             s->quant_tables[1][3][i]=   5*11*11*quant5 [i];
770             s->quant_tables[1][4][i]= 5*5*11*11*quant5 [i];
771         } else {
772             s->quant_tables[0][0][i]=           quant9_10bit[i];
773             s->quant_tables[0][1][i]=        11*quant9_10bit[i];
774             s->quant_tables[0][2][i]=     11*11*quant9_10bit[i];
775             s->quant_tables[1][0][i]=           quant9_10bit[i];
776             s->quant_tables[1][1][i]=        11*quant9_10bit[i];
777             s->quant_tables[1][2][i]=     11*11*quant5_10bit[i];
778             s->quant_tables[1][3][i]=   5*11*11*quant5_10bit[i];
779             s->quant_tables[1][4][i]= 5*5*11*11*quant5_10bit[i];
780         }
781     }
782     s->context_count[0] = (11 * 11 * 11        + 1) / 2;
783     s->context_count[1] = (11 * 11 * 5 * 5 * 5 + 1) / 2;
784     memcpy(s->quant_table, s->quant_tables[avctx->context_model],
785            sizeof(s->quant_table));
786
787     for (i = 0; i < s->plane_count; i++) {
788         PlaneContext *const p = &s->plane[i];
789
790         memcpy(p->quant_table, s->quant_table, sizeof(p->quant_table));
791         p->quant_table_index = avctx->context_model;
792         p->context_count     = s->context_count[p->quant_table_index];
793     }
794
795     if ((ret = ffv1_allocate_initial_states(s)) < 0)
796         return ret;
797
798     if (!s->transparency)
799         s->plane_count = 2;
800     avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
801     s->picture_number = 0;
802
803     if (avctx->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2)) {
804         for (i = 0; i < s->quant_table_count; i++) {
805             s->rc_stat2[i] = av_mallocz(s->context_count[i] *
806                                         sizeof(*s->rc_stat2[i]));
807             if (!s->rc_stat2[i])
808                 return AVERROR(ENOMEM);
809         }
810     }
811     if (avctx->stats_in) {
812         char *p = avctx->stats_in;
813         uint8_t best_state[256][256];
814         int gob_count = 0;
815         char *next;
816
817         av_assert0(s->version >= 2);
818
819         for (;;) {
820             for (j = 0; j < 256; j++)
821                 for (i = 0; i < 2; i++) {
822                     s->rc_stat[j][i] = strtol(p, &next, 0);
823                     if (next == p) {
824                         av_log(avctx, AV_LOG_ERROR,
825                                "2Pass file invalid at %d %d [%s]\n", j, i, p);
826                         return AVERROR_INVALIDDATA;
827                     }
828                     p = next;
829                 }
830             for (i = 0; i < s->quant_table_count; i++)
831                 for (j = 0; j < s->context_count[i]; j++) {
832                     for (k = 0; k < 32; k++)
833                         for (m = 0; m < 2; m++) {
834                             s->rc_stat2[i][j][k][m] = strtol(p, &next, 0);
835                             if (next == p) {
836                                 av_log(avctx, AV_LOG_ERROR,
837                                        "2Pass file invalid at %d %d %d %d [%s]\n",
838                                        i, j, k, m, p);
839                                 return AVERROR_INVALIDDATA;
840                             }
841                             p = next;
842                         }
843                 }
844             gob_count = strtol(p, &next, 0);
845             if (next == p || gob_count <= 0) {
846                 av_log(avctx, AV_LOG_ERROR, "2Pass file invalid\n");
847                 return AVERROR_INVALIDDATA;
848             }
849             p = next;
850             while (*p == '\n' || *p == ' ')
851                 p++;
852             if (p[0] == 0)
853                 break;
854         }
855         sort_stt(s, s->state_transition);
856
857         find_best_state(best_state, s->state_transition);
858
859         for (i = 0; i < s->quant_table_count; i++) {
860             for (k = 0; k < 32; k++) {
861                 double a=0, b=0;
862                 int jp = 0;
863                 for (j = 0; j < s->context_count[i]; j++) {
864                     double p = 128;
865                     if (s->rc_stat2[i][j][k][0] + s->rc_stat2[i][j][k][1] > 200 && j || a+b > 200) {
866                         if (a+b)
867                             p = 256.0 * b / (a + b);
868                         s->initial_states[i][jp][k] =
869                             best_state[av_clip(round(p), 1, 255)][av_clip((a + b) / gob_count, 0, 255)];
870                         for(jp++; jp<j; jp++)
871                             s->initial_states[i][jp][k] = s->initial_states[i][jp-1][k];
872                         a=b=0;
873                     }
874                     a += s->rc_stat2[i][j][k][0];
875                     b += s->rc_stat2[i][j][k][1];
876                     if (a+b) {
877                         p = 256.0 * b / (a + b);
878                     }
879                     s->initial_states[i][j][k] =
880                         best_state[av_clip(round(p), 1, 255)][av_clip((a + b) / gob_count, 0, 255)];
881                 }
882             }
883         }
884     }
885
886     if (s->version > 1) {
887         s->num_v_slices = (avctx->width > 352 || avctx->height > 288 || !avctx->slices) ? 2 : 1;
888         for (; s->num_v_slices < 9; s->num_v_slices++) {
889             for (s->num_h_slices = s->num_v_slices; s->num_h_slices < 2*s->num_v_slices; s->num_h_slices++) {
890                 if (avctx->slices == s->num_h_slices * s->num_v_slices && avctx->slices <= 64 || !avctx->slices)
891                     goto slices_ok;
892             }
893         }
894         av_log(avctx, AV_LOG_ERROR,
895                "Unsupported number %d of slices requested, please specify a "
896                "supported number with -slices (ex:4,6,9,12,16, ...)\n",
897                avctx->slices);
898         return AVERROR(ENOSYS);
899 slices_ok:
900         write_extradata(s);
901     }
902
903     if ((ret = ffv1_init_slice_contexts(s)) < 0)
904         return ret;
905     if ((ret = ffv1_init_slices_state(s)) < 0)
906         return ret;
907
908 #define STATS_OUT_SIZE 1024 * 1024 * 6
909     if (avctx->flags & CODEC_FLAG_PASS1) {
910         avctx->stats_out = av_mallocz(STATS_OUT_SIZE);
911         if (!avctx->stats_out)
912             return AVERROR(ENOMEM);
913         for (i = 0; i < s->quant_table_count; i++)
914             for (j = 0; j < s->slice_count; j++) {
915                 FFV1Context *sf = s->slice_context[j];
916                 av_assert0(!sf->rc_stat2[i]);
917                 sf->rc_stat2[i] = av_mallocz(s->context_count[i] *
918                                              sizeof(*sf->rc_stat2[i]));
919                 if (!sf->rc_stat2[i])
920                     return AVERROR(ENOMEM);
921             }
922     }
923
924     return 0;
925 }
926
927 static void encode_slice_header(FFV1Context *f, FFV1Context *fs)
928 {
929     RangeCoder *c = &fs->c;
930     uint8_t state[CONTEXT_SIZE];
931     int j;
932     memset(state, 128, sizeof(state));
933
934     put_symbol(c, state, (fs->slice_x     +1)*f->num_h_slices / f->width   , 0);
935     put_symbol(c, state, (fs->slice_y     +1)*f->num_v_slices / f->height  , 0);
936     put_symbol(c, state, (fs->slice_width +1)*f->num_h_slices / f->width -1, 0);
937     put_symbol(c, state, (fs->slice_height+1)*f->num_v_slices / f->height-1, 0);
938     for (j=0; j<f->plane_count; j++) {
939         put_symbol(c, state, f->plane[j].quant_table_index, 0);
940         av_assert0(f->plane[j].quant_table_index == f->avctx->context_model);
941     }
942     if (!f->picture.f->interlaced_frame)
943         put_symbol(c, state, 3, 0);
944     else
945         put_symbol(c, state, 1 + !f->picture.f->top_field_first, 0);
946     put_symbol(c, state, f->picture.f->sample_aspect_ratio.num, 0);
947     put_symbol(c, state, f->picture.f->sample_aspect_ratio.den, 0);
948 }
949
950 static int encode_slice(AVCodecContext *c, void *arg)
951 {
952     FFV1Context *fs  = *(void **)arg;
953     FFV1Context *f   = fs->avctx->priv_data;
954     int width        = fs->slice_width;
955     int height       = fs->slice_height;
956     int x            = fs->slice_x;
957     int y            = fs->slice_y;
958     AVFrame *const p = f->picture.f;
959     const int ps     = av_pix_fmt_desc_get(c->pix_fmt)->comp[0].step_minus1 + 1;
960
961     if (p->key_frame)
962         ffv1_clear_slice_state(f, fs);
963     if (f->version > 2) {
964         encode_slice_header(f, fs);
965     }
966     if (!fs->ac) {
967         if (f->version > 2)
968             put_rac(&fs->c, (uint8_t[]) { 129 }, 0);
969         fs->ac_byte_count = f->version > 2 || (!x && !y) ? ff_rac_terminate(&fs->c) : 0;
970         init_put_bits(&fs->pb,
971                       fs->c.bytestream_start + fs->ac_byte_count,
972                       fs->c.bytestream_end - fs->c.bytestream_start - fs->ac_byte_count);
973     }
974
975     if (f->colorspace == 0) {
976         const int chroma_width  = FF_CEIL_RSHIFT(width,  f->chroma_h_shift);
977         const int chroma_height = FF_CEIL_RSHIFT(height, f->chroma_v_shift);
978         const int cx            = x >> f->chroma_h_shift;
979         const int cy            = y >> f->chroma_v_shift;
980
981         encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0);
982
983         if (f->chroma_planes) {
984             encode_plane(fs, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1);
985             encode_plane(fs, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1);
986         }
987         if (fs->transparency)
988             encode_plane(fs, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], 2);
989     } else {
990         uint8_t *planes[3] = {p->data[0] + ps*x + y*p->linesize[0],
991                               p->data[1] + ps*x + y*p->linesize[1],
992                               p->data[2] + ps*x + y*p->linesize[2]};
993         encode_rgb_frame(fs, planes, width, height, p->linesize);
994     }
995     emms_c();
996
997     return 0;
998 }
999
1000 static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
1001                         const AVFrame *pict, int *got_packet)
1002 {
1003     FFV1Context *f      = avctx->priv_data;
1004     RangeCoder *const c = &f->slice_context[0]->c;
1005     AVFrame *const p    = f->picture.f;
1006     int used_count      = 0;
1007     uint8_t keystate    = 128;
1008     uint8_t *buf_p;
1009     int i, ret;
1010
1011     if ((ret = ff_alloc_packet2(avctx, pkt, avctx->width*avctx->height*((8*2+1+1)*4)/8
1012                                             + FF_MIN_BUFFER_SIZE)) < 0)
1013         return ret;
1014
1015     ff_init_range_encoder(c, pkt->data, pkt->size);
1016     ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
1017
1018     av_frame_unref(p);
1019     av_frame_ref(p, pict);
1020     p->pict_type = AV_PICTURE_TYPE_I;
1021
1022     if (avctx->gop_size == 0 || f->picture_number % avctx->gop_size == 0) {
1023         put_rac(c, &keystate, 1);
1024         p->key_frame = 1;
1025         f->gob_count++;
1026         write_header(f);
1027     } else {
1028         put_rac(c, &keystate, 0);
1029         p->key_frame = 0;
1030     }
1031
1032     if (f->ac > 1) {
1033         int i;
1034         for (i = 1; i < 256; i++) {
1035             c->one_state[i]        = f->state_transition[i];
1036             c->zero_state[256 - i] = 256 - c->one_state[i];
1037         }
1038     }
1039
1040     for (i = 1; i < f->slice_count; i++) {
1041         FFV1Context *fs = f->slice_context[i];
1042         uint8_t *start  = pkt->data + (pkt->size - used_count) * (int64_t)i / f->slice_count;
1043         int len         = pkt->size / f->slice_count;
1044         ff_init_range_encoder(&fs->c, start, len);
1045     }
1046     avctx->execute(avctx, encode_slice, &f->slice_context[0], NULL,
1047                    f->slice_count, sizeof(void *));
1048
1049     buf_p = pkt->data;
1050     for (i = 0; i < f->slice_count; i++) {
1051         FFV1Context *fs = f->slice_context[i];
1052         int bytes;
1053
1054         if (fs->ac) {
1055             uint8_t state = 129;
1056             put_rac(&fs->c, &state, 0);
1057             bytes = ff_rac_terminate(&fs->c);
1058         } else {
1059             flush_put_bits(&fs->pb); // FIXME: nicer padding
1060             bytes = fs->ac_byte_count + (put_bits_count(&fs->pb) + 7) / 8;
1061         }
1062         if (i > 0 || f->version > 2) {
1063             av_assert0(bytes < pkt->size / f->slice_count);
1064             memmove(buf_p, fs->c.bytestream_start, bytes);
1065             av_assert0(bytes < (1 << 24));
1066             AV_WB24(buf_p + bytes, bytes);
1067             bytes += 3;
1068         }
1069         if (f->ec) {
1070             unsigned v;
1071             buf_p[bytes++] = 0;
1072             v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, buf_p, bytes);
1073             AV_WL32(buf_p + bytes, v);
1074             bytes += 4;
1075         }
1076         buf_p += bytes;
1077     }
1078
1079     if ((avctx->flags & CODEC_FLAG_PASS1) && (f->picture_number & 31) == 0) {
1080         int j, k, m;
1081         char *p   = avctx->stats_out;
1082         char *end = p + STATS_OUT_SIZE;
1083
1084         memset(f->rc_stat, 0, sizeof(f->rc_stat));
1085         for (i = 0; i < f->quant_table_count; i++)
1086             memset(f->rc_stat2[i], 0, f->context_count[i] * sizeof(*f->rc_stat2[i]));
1087
1088         for (j = 0; j < f->slice_count; j++) {
1089             FFV1Context *fs = f->slice_context[j];
1090             for (i = 0; i < 256; i++) {
1091                 f->rc_stat[i][0] += fs->rc_stat[i][0];
1092                 f->rc_stat[i][1] += fs->rc_stat[i][1];
1093             }
1094             for (i = 0; i < f->quant_table_count; i++) {
1095                 for (k = 0; k < f->context_count[i]; k++)
1096                     for (m = 0; m < 32; m++) {
1097                         f->rc_stat2[i][k][m][0] += fs->rc_stat2[i][k][m][0];
1098                         f->rc_stat2[i][k][m][1] += fs->rc_stat2[i][k][m][1];
1099                     }
1100             }
1101         }
1102
1103         for (j = 0; j < 256; j++) {
1104             snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1105                      f->rc_stat[j][0], f->rc_stat[j][1]);
1106             p += strlen(p);
1107         }
1108         snprintf(p, end - p, "\n");
1109
1110         for (i = 0; i < f->quant_table_count; i++) {
1111             for (j = 0; j < f->context_count[i]; j++)
1112                 for (m = 0; m < 32; m++) {
1113                     snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1114                              f->rc_stat2[i][j][m][0], f->rc_stat2[i][j][m][1]);
1115                     p += strlen(p);
1116                 }
1117         }
1118         snprintf(p, end - p, "%d\n", f->gob_count);
1119     } else if (avctx->flags & CODEC_FLAG_PASS1)
1120         avctx->stats_out[0] = '\0';
1121
1122     f->picture_number++;
1123     pkt->size   = buf_p - pkt->data;
1124     pkt->flags |= AV_PKT_FLAG_KEY * p->key_frame;
1125     *got_packet = 1;
1126
1127     return 0;
1128 }
1129
1130 #define OFFSET(x) offsetof(FFV1Context, x)
1131 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1132 static const AVOption options[] = {
1133     { "slicecrc", "Protect slices with CRCs", OFFSET(ec), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1, VE },
1134     { NULL }
1135 };
1136
1137 static const AVClass class = {
1138     .class_name = "ffv1 encoder",
1139     .item_name  = av_default_item_name,
1140     .option     = options,
1141     .version    = LIBAVUTIL_VERSION_INT,
1142 };
1143
1144 static const AVCodecDefault ffv1_defaults[] = {
1145     { "coder", "-1" },
1146     { NULL },
1147 };
1148
1149 AVCodec ff_ffv1_encoder = {
1150     .name           = "ffv1",
1151     .type           = AVMEDIA_TYPE_VIDEO,
1152     .id             = AV_CODEC_ID_FFV1,
1153     .priv_data_size = sizeof(FFV1Context),
1154     .init           = encode_init,
1155     .encode2        = encode_frame,
1156     .close          = ffv1_close,
1157     .capabilities   = CODEC_CAP_SLICE_THREADS,
1158     .pix_fmts       = (const enum AVPixelFormat[]) {
1159         AV_PIX_FMT_YUV420P,   AV_PIX_FMT_YUVA420P,  AV_PIX_FMT_YUVA422P,  AV_PIX_FMT_YUV444P,
1160         AV_PIX_FMT_YUVA444P,  AV_PIX_FMT_YUV440P,   AV_PIX_FMT_YUV422P,   AV_PIX_FMT_YUV411P,
1161         AV_PIX_FMT_YUV410P,   AV_PIX_FMT_0RGB32,    AV_PIX_FMT_RGB32,     AV_PIX_FMT_YUV420P16,
1162         AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16, AV_PIX_FMT_YUV444P9,  AV_PIX_FMT_YUV422P9,
1163         AV_PIX_FMT_YUV420P9,  AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
1164         AV_PIX_FMT_GRAY16,    AV_PIX_FMT_GRAY8,     AV_PIX_FMT_GBRP9,     AV_PIX_FMT_GBRP10,
1165         AV_PIX_FMT_GBRP12,    AV_PIX_FMT_GBRP14,
1166         AV_PIX_FMT_NONE
1167
1168     },
1169     .long_name      = NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1170     .defaults       = ffv1_defaults,
1171     .priv_class     = &class,
1172 };