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