FFmpeg
 All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
ffv1enc.c
Go to the documentation of this file.
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 
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 
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 
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->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 
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;
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 
464  int16_t quant_table[MAX_CONTEXT_INPUTS][256])
465 {
466  int i;
467  for (i = 0; i < 5; i++)
469 }
470 
471 static void write_header(FFV1Context *f)
472 {
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 
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);
513  }
514  }
515  }
516 }
517 
519 {
520  RangeCoder *const c = &f->c;
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;
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 = 2;
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++)
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  }
580 
584  f->avctx->extradata_size += 4;
585 
586  return 0;
587 }
588 
589 static int sort_stt(FFV1Context *s, uint8_t stt[256])
590 {
591  int i, i2, changed, print = 0;
592 
593  do {
594  changed = 0;
595  for (i = 12; i < 244; i++) {
596  for (i2 = i + 1; i2 < 245 && i2 < i + 4; i2++) {
597 
598 #define COST(old, new) \
599  s->rc_stat[old][0] * -log2((256 - (new)) / 256.0) + \
600  s->rc_stat[old][1] * -log2((new) / 256.0)
601 
602 #define COST2(old, new) \
603  COST(old, new) + COST(256 - (old), 256 - (new))
604 
605  double size0 = COST2(i, i) + COST2(i2, i2);
606  double sizeX = COST2(i, i2) + COST2(i2, i);
607  if (size0 - sizeX > size0*(1e-14) && i != 128 && i2 != 128) {
608  int j;
609  FFSWAP(int, stt[i], stt[i2]);
610  FFSWAP(int, s->rc_stat[i][0], s->rc_stat[i2][0]);
611  FFSWAP(int, s->rc_stat[i][1], s->rc_stat[i2][1]);
612  if (i != 256 - i2) {
613  FFSWAP(int, stt[256 - i], stt[256 - i2]);
614  FFSWAP(int, s->rc_stat[256 - i][0], s->rc_stat[256 - i2][0]);
615  FFSWAP(int, s->rc_stat[256 - i][1], s->rc_stat[256 - i2][1]);
616  }
617  for (j = 1; j < 256; j++) {
618  if (stt[j] == i)
619  stt[j] = i2;
620  else if (stt[j] == i2)
621  stt[j] = i;
622  if (i != 256 - i2) {
623  if (stt[256 - j] == 256 - i)
624  stt[256 - j] = 256 - i2;
625  else if (stt[256 - j] == 256 - i2)
626  stt[256 - j] = 256 - i;
627  }
628  }
629  print = changed = 1;
630  }
631  }
632  }
633  } while (changed);
634  return print;
635 }
636 
638 {
639  FFV1Context *s = avctx->priv_data;
640  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
641  int i, j, k, m, ret;
642 
643  ffv1_common_init(avctx);
644 
645  s->version = 0;
646 
647  if ((avctx->flags & (CODEC_FLAG_PASS1|CODEC_FLAG_PASS2)) || avctx->slices>1)
648  s->version = FFMAX(s->version, 2);
649 
650  if (avctx->level == 3) {
651  s->version = 3;
652  }
653 
654  if (s->ec < 0) {
655  s->ec = (s->version >= 3);
656  }
657 
658  if (s->version >= 2 && avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
659  av_log(avctx, AV_LOG_ERROR, "Version 2 needed for requested features but version 2 is experimental and not enabled\n");
660  return AVERROR_INVALIDDATA;
661  }
662 
663  s->ac = avctx->coder_type > 0 ? 2 : 0;
664 
665  s->plane_count = 3;
666  switch(avctx->pix_fmt) {
667  case AV_PIX_FMT_YUV444P9:
668  case AV_PIX_FMT_YUV422P9:
669  case AV_PIX_FMT_YUV420P9:
670  if (!avctx->bits_per_raw_sample)
671  s->bits_per_raw_sample = 9;
675  s->packed_at_lsb = 1;
676  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
677  s->bits_per_raw_sample = 10;
678  case AV_PIX_FMT_GRAY16:
682  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) {
683  s->bits_per_raw_sample = 16;
684  } else if (!s->bits_per_raw_sample) {
686  }
687  if (s->bits_per_raw_sample <= 8) {
688  av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");
689  return AVERROR_INVALIDDATA;
690  }
691  if (!s->ac && avctx->coder_type == -1) {
692  av_log(avctx, AV_LOG_INFO, "bits_per_raw_sample > 8, forcing coder 1\n");
693  s->ac = 2;
694  }
695  if (!s->ac) {
696  av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample of more than 8 needs -coder 1 currently\n");
697  return AVERROR(ENOSYS);
698  }
699  s->version = FFMAX(s->version, 1);
700  case AV_PIX_FMT_GRAY8:
701  case AV_PIX_FMT_YUV444P:
702  case AV_PIX_FMT_YUV440P:
703  case AV_PIX_FMT_YUV422P:
704  case AV_PIX_FMT_YUV420P:
705  case AV_PIX_FMT_YUV411P:
706  case AV_PIX_FMT_YUV410P:
707  s->chroma_planes = desc->nb_components < 3 ? 0 : 1;
708  s->colorspace = 0;
709  break;
710  case AV_PIX_FMT_YUVA444P:
711  case AV_PIX_FMT_YUVA422P:
712  case AV_PIX_FMT_YUVA420P:
713  s->chroma_planes = 1;
714  s->colorspace = 0;
715  s->transparency = 1;
716  break;
717  case AV_PIX_FMT_RGB32:
718  s->colorspace = 1;
719  s->transparency = 1;
720  break;
721  case AV_PIX_FMT_0RGB32:
722  s->colorspace = 1;
723  break;
724  case AV_PIX_FMT_GBRP9:
725  if (!avctx->bits_per_raw_sample)
726  s->bits_per_raw_sample = 9;
727  case AV_PIX_FMT_GBRP10:
728  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
729  s->bits_per_raw_sample = 10;
730  case AV_PIX_FMT_GBRP12:
731  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
732  s->bits_per_raw_sample = 12;
733  case AV_PIX_FMT_GBRP14:
734  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
735  s->bits_per_raw_sample = 14;
736  else if (!s->bits_per_raw_sample)
738  s->colorspace = 1;
739  s->chroma_planes = 1;
740  s->version = FFMAX(s->version, 1);
741  break;
742  default:
743  av_log(avctx, AV_LOG_ERROR, "format not supported\n");
744  return AVERROR(ENOSYS);
745  }
746  if (s->transparency) {
747  av_log(avctx, AV_LOG_WARNING, "Storing alpha plane, this will require a recent FFV1 decoder to playback!\n");
748  }
749  if (avctx->context_model > 1U) {
750  av_log(avctx, AV_LOG_ERROR, "Invalid context model %d, valid values are 0 and 1\n", avctx->context_model);
751  return AVERROR(EINVAL);
752  }
753 
754  if (s->ac > 1)
755  for (i = 1; i < 256; i++)
756  s->state_transition[i] = ver2_state[i];
757 
758  for (i = 0; i < 256; i++) {
759  s->quant_table_count = 2;
760  if (s->bits_per_raw_sample <= 8) {
761  s->quant_tables[0][0][i]= quant11[i];
762  s->quant_tables[0][1][i]= 11*quant11[i];
763  s->quant_tables[0][2][i]= 11*11*quant11[i];
764  s->quant_tables[1][0][i]= quant11[i];
765  s->quant_tables[1][1][i]= 11*quant11[i];
766  s->quant_tables[1][2][i]= 11*11*quant5 [i];
767  s->quant_tables[1][3][i]= 5*11*11*quant5 [i];
768  s->quant_tables[1][4][i]= 5*5*11*11*quant5 [i];
769  } else {
770  s->quant_tables[0][0][i]= quant9_10bit[i];
771  s->quant_tables[0][1][i]= 11*quant9_10bit[i];
772  s->quant_tables[0][2][i]= 11*11*quant9_10bit[i];
773  s->quant_tables[1][0][i]= quant9_10bit[i];
774  s->quant_tables[1][1][i]= 11*quant9_10bit[i];
775  s->quant_tables[1][2][i]= 11*11*quant5_10bit[i];
776  s->quant_tables[1][3][i]= 5*11*11*quant5_10bit[i];
777  s->quant_tables[1][4][i]= 5*5*11*11*quant5_10bit[i];
778  }
779  }
780  s->context_count[0] = (11 * 11 * 11 + 1) / 2;
781  s->context_count[1] = (11 * 11 * 5 * 5 * 5 + 1) / 2;
782  memcpy(s->quant_table, s->quant_tables[avctx->context_model],
783  sizeof(s->quant_table));
784 
785  for (i = 0; i < s->plane_count; i++) {
786  PlaneContext *const p = &s->plane[i];
787 
788  memcpy(p->quant_table, s->quant_table, sizeof(p->quant_table));
789  p->quant_table_index = avctx->context_model;
791  }
792 
793  if ((ret = ffv1_allocate_initial_states(s)) < 0)
794  return ret;
795 
796  avctx->coded_frame = &s->picture;
797  if (!s->transparency)
798  s->plane_count = 2;
800  s->picture_number = 0;
801 
802  if (avctx->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2)) {
803  for (i = 0; i < s->quant_table_count; i++) {
804  s->rc_stat2[i] = av_mallocz(s->context_count[i] *
805  sizeof(*s->rc_stat2[i]));
806  if (!s->rc_stat2[i])
807  return AVERROR(ENOMEM);
808  }
809  }
810  if (avctx->stats_in) {
811  char *p = avctx->stats_in;
812  uint8_t best_state[256][256];
813  int gob_count = 0;
814  char *next;
815 
816  av_assert0(s->version >= 2);
817 
818  for (;;) {
819  for (j = 0; j < 256; j++)
820  for (i = 0; i < 2; i++) {
821  s->rc_stat[j][i] = strtol(p, &next, 0);
822  if (next == p) {
823  av_log(avctx, AV_LOG_ERROR,
824  "2Pass file invalid at %d %d [%s]\n", j, i, p);
825  return AVERROR_INVALIDDATA;
826  }
827  p = next;
828  }
829  for (i = 0; i < s->quant_table_count; i++)
830  for (j = 0; j < s->context_count[i]; j++) {
831  for (k = 0; k < 32; k++)
832  for (m = 0; m < 2; m++) {
833  s->rc_stat2[i][j][k][m] = strtol(p, &next, 0);
834  if (next == p) {
835  av_log(avctx, AV_LOG_ERROR,
836  "2Pass file invalid at %d %d %d %d [%s]\n",
837  i, j, k, m, p);
838  return AVERROR_INVALIDDATA;
839  }
840  p = next;
841  }
842  }
843  gob_count = strtol(p, &next, 0);
844  if (next == p || gob_count <= 0) {
845  av_log(avctx, AV_LOG_ERROR, "2Pass file invalid\n");
846  return AVERROR_INVALIDDATA;
847  }
848  p = next;
849  while (*p == '\n' || *p == ' ')
850  p++;
851  if (p[0] == 0)
852  break;
853  }
854  sort_stt(s, s->state_transition);
855 
856  find_best_state(best_state, s->state_transition);
857 
858  for (i = 0; i < s->quant_table_count; i++) {
859  for (j = 0; j < s->context_count[i]; j++)
860  for (k = 0; k < 32; k++) {
861  double p = 128;
862  if (s->rc_stat2[i][j][k][0] + s->rc_stat2[i][j][k][1]) {
863  p = 256.0 * s->rc_stat2[i][j][k][1] /
864  (s->rc_stat2[i][j][k][0] + s->rc_stat2[i][j][k][1]);
865  }
866  s->initial_states[i][j][k] =
867  best_state[av_clip(round(p), 1, 255)][av_clip((s->rc_stat2[i][j][k][0] +
868  s->rc_stat2[i][j][k][1]) /
869  gob_count, 0, 255)];
870  }
871  }
872  }
873 
874  if (s->version > 1) {
875  s->num_v_slices = (avctx->width > 352 || avctx->height > 288 || !avctx->slices) ? 2 : 1;
876  for (; s->num_v_slices < 9; s->num_v_slices++) {
877  for (s->num_h_slices = s->num_v_slices; s->num_h_slices < 2*s->num_v_slices; s->num_h_slices++) {
878  if (avctx->slices == s->num_h_slices * s->num_v_slices && avctx->slices <= 64 || !avctx->slices)
879  goto slices_ok;
880  }
881  }
882  av_log(avctx, AV_LOG_ERROR,
883  "Unsupported number %d of slices requested, please specify a "
884  "supported number with -slices (ex:4,6,9,12,16, ...)\n",
885  avctx->slices);
886  return AVERROR(ENOSYS);
887 slices_ok:
888  write_extradata(s);
889  }
890 
891  if ((ret = ffv1_init_slice_contexts(s)) < 0)
892  return ret;
893  if ((ret = ffv1_init_slices_state(s)) < 0)
894  return ret;
895 
896 #define STATS_OUT_SIZE 1024 * 1024 * 6
897  if (avctx->flags & CODEC_FLAG_PASS1) {
899  for (i = 0; i < s->quant_table_count; i++)
900  for (j = 0; j < s->slice_count; j++) {
901  FFV1Context *sf = s->slice_context[j];
902  av_assert0(!sf->rc_stat2[i]);
903  sf->rc_stat2[i] = av_mallocz(s->context_count[i] *
904  sizeof(*sf->rc_stat2[i]));
905  if (!sf->rc_stat2[i])
906  return AVERROR(ENOMEM);
907  }
908  }
909 
910  return 0;
911 }
912 
914 {
915  RangeCoder *c = &fs->c;
917  int j;
918  memset(state, 128, sizeof(state));
919 
920  put_symbol(c, state, (fs->slice_x +1)*f->num_h_slices / f->width , 0);
921  put_symbol(c, state, (fs->slice_y +1)*f->num_v_slices / f->height , 0);
922  put_symbol(c, state, (fs->slice_width +1)*f->num_h_slices / f->width -1, 0);
923  put_symbol(c, state, (fs->slice_height+1)*f->num_v_slices / f->height-1, 0);
924  for (j=0; j<f->plane_count; j++) {
925  put_symbol(c, state, f->plane[j].quant_table_index, 0);
927  }
928  if (!f->picture.interlaced_frame)
929  put_symbol(c, state, 3, 0);
930  else
931  put_symbol(c, state, 1 + !f->picture.top_field_first, 0);
932  put_symbol(c, state, f->picture.sample_aspect_ratio.num, 0);
933  put_symbol(c, state, f->picture.sample_aspect_ratio.den, 0);
934 }
935 
936 static int encode_slice(AVCodecContext *c, void *arg)
937 {
938  FFV1Context *fs = *(void **)arg;
939  FFV1Context *f = fs->avctx->priv_data;
940  int width = fs->slice_width;
941  int height = fs->slice_height;
942  int x = fs->slice_x;
943  int y = fs->slice_y;
944  AVFrame *const p = &f->picture;
945  const int ps = av_pix_fmt_desc_get(c->pix_fmt)->comp[0].step_minus1 + 1;
946 
947  if (p->key_frame)
948  ffv1_clear_slice_state(f, fs);
949  if (f->version > 2) {
950  encode_slice_header(f, fs);
951  }
952  if (!fs->ac) {
953  if (f->version > 2)
954  put_rac(&fs->c, (uint8_t[]) { 129 }, 0);
955  fs->ac_byte_count = f->version > 2 || (!x && !y) ? ff_rac_terminate(&fs->c) : 0;
956  init_put_bits(&fs->pb,
957  fs->c.bytestream_start + fs->ac_byte_count,
959  }
960 
961  if (f->colorspace == 0) {
962  const int chroma_width = -((-width) >> f->chroma_h_shift);
963  const int chroma_height = -((-height) >> f->chroma_v_shift);
964  const int cx = x >> f->chroma_h_shift;
965  const int cy = y >> f->chroma_v_shift;
966 
967  encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0);
968 
969  if (f->chroma_planes) {
970  encode_plane(fs, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1);
971  encode_plane(fs, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1);
972  }
973  if (fs->transparency)
974  encode_plane(fs, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], 2);
975  } else {
976  uint8_t *planes[3] = {p->data[0] + ps*x + y*p->linesize[0],
977  p->data[1] + ps*x + y*p->linesize[1],
978  p->data[2] + ps*x + y*p->linesize[2]};
979  encode_rgb_frame(fs, planes, width, height, p->linesize);
980  }
981  emms_c();
982 
983  return 0;
984 }
985 
987  const AVFrame *pict, int *got_packet)
988 {
989  FFV1Context *f = avctx->priv_data;
990  RangeCoder *const c = &f->slice_context[0]->c;
991  AVFrame *const p = &f->picture;
992  int used_count = 0;
993  uint8_t keystate = 128;
994  uint8_t *buf_p;
995  int i, ret;
996 
997  if ((ret = ff_alloc_packet2(avctx, pkt, avctx->width*avctx->height*((8*2+1+1)*4)/8
998  + FF_MIN_BUFFER_SIZE)) < 0)
999  return ret;
1000 
1001  ff_init_range_encoder(c, pkt->data, pkt->size);
1002  ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
1003 
1004  *p = *pict;
1006 
1007  if (avctx->gop_size == 0 || f->picture_number % avctx->gop_size == 0) {
1008  put_rac(c, &keystate, 1);
1009  p->key_frame = 1;
1010  f->gob_count++;
1011  write_header(f);
1012  } else {
1013  put_rac(c, &keystate, 0);
1014  p->key_frame = 0;
1015  }
1016 
1017  if (f->ac > 1) {
1018  int i;
1019  for (i = 1; i < 256; i++) {
1020  c->one_state[i] = f->state_transition[i];
1021  c->zero_state[256 - i] = 256 - c->one_state[i];
1022  }
1023  }
1024 
1025  for (i = 1; i < f->slice_count; i++) {
1026  FFV1Context *fs = f->slice_context[i];
1027  uint8_t *start = pkt->data + (pkt->size - used_count) * (int64_t)i / f->slice_count;
1028  int len = pkt->size / f->slice_count;
1029  ff_init_range_encoder(&fs->c, start, len);
1030  }
1031  avctx->execute(avctx, encode_slice, &f->slice_context[0], NULL,
1032  f->slice_count, sizeof(void *));
1033 
1034  buf_p = pkt->data;
1035  for (i = 0; i < f->slice_count; i++) {
1036  FFV1Context *fs = f->slice_context[i];
1037  int bytes;
1038 
1039  if (fs->ac) {
1040  uint8_t state = 129;
1041  put_rac(&fs->c, &state, 0);
1042  bytes = ff_rac_terminate(&fs->c);
1043  } else {
1044  flush_put_bits(&fs->pb); // FIXME: nicer padding
1045  bytes = fs->ac_byte_count + (put_bits_count(&fs->pb) + 7) / 8;
1046  }
1047  if (i > 0 || f->version > 2) {
1048  av_assert0(bytes < pkt->size / f->slice_count);
1049  memmove(buf_p, fs->c.bytestream_start, bytes);
1050  av_assert0(bytes < (1 << 24));
1051  AV_WB24(buf_p + bytes, bytes);
1052  bytes += 3;
1053  }
1054  if (f->ec) {
1055  unsigned v;
1056  buf_p[bytes++] = 0;
1057  v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, buf_p, bytes);
1058  AV_WL32(buf_p + bytes, v);
1059  bytes += 4;
1060  }
1061  buf_p += bytes;
1062  }
1063 
1064  if ((avctx->flags & CODEC_FLAG_PASS1) && (f->picture_number & 31) == 0) {
1065  int j, k, m;
1066  char *p = avctx->stats_out;
1067  char *end = p + STATS_OUT_SIZE;
1068 
1069  memset(f->rc_stat, 0, sizeof(f->rc_stat));
1070  for (i = 0; i < f->quant_table_count; i++)
1071  memset(f->rc_stat2[i], 0, f->context_count[i] * sizeof(*f->rc_stat2[i]));
1072 
1073  for (j = 0; j < f->slice_count; j++) {
1074  FFV1Context *fs = f->slice_context[j];
1075  for (i = 0; i < 256; i++) {
1076  f->rc_stat[i][0] += fs->rc_stat[i][0];
1077  f->rc_stat[i][1] += fs->rc_stat[i][1];
1078  }
1079  for (i = 0; i < f->quant_table_count; i++) {
1080  for (k = 0; k < f->context_count[i]; k++)
1081  for (m = 0; m < 32; m++) {
1082  f->rc_stat2[i][k][m][0] += fs->rc_stat2[i][k][m][0];
1083  f->rc_stat2[i][k][m][1] += fs->rc_stat2[i][k][m][1];
1084  }
1085  }
1086  }
1087 
1088  for (j = 0; j < 256; j++) {
1089  snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1090  f->rc_stat[j][0], f->rc_stat[j][1]);
1091  p += strlen(p);
1092  }
1093  snprintf(p, end - p, "\n");
1094 
1095  for (i = 0; i < f->quant_table_count; i++) {
1096  for (j = 0; j < f->context_count[i]; j++)
1097  for (m = 0; m < 32; m++) {
1098  snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1099  f->rc_stat2[i][j][m][0], f->rc_stat2[i][j][m][1]);
1100  p += strlen(p);
1101  }
1102  }
1103  snprintf(p, end - p, "%d\n", f->gob_count);
1104  } else if (avctx->flags & CODEC_FLAG_PASS1)
1105  avctx->stats_out[0] = '\0';
1106 
1107  f->picture_number++;
1108  pkt->size = buf_p - pkt->data;
1109  pkt->flags |= AV_PKT_FLAG_KEY * p->key_frame;
1110  *got_packet = 1;
1111 
1112  return 0;
1113 }
1114 
1115 #define OFFSET(x) offsetof(FFV1Context, x)
1116 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1117 static const AVOption options[] = {
1118  { "slicecrc", "Protect slices with CRCs", OFFSET(ec), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1, VE },
1119  { NULL }
1120 };
1121 
1122 static const AVClass class = {
1123  .class_name = "ffv1 encoder",
1124  .item_name = av_default_item_name,
1125  .option = options,
1127 };
1128 
1129 static const AVCodecDefault ffv1_defaults[] = {
1130  { "coder", "-1" },
1131  { NULL },
1132 };
1133 
1135  .name = "ffv1",
1136  .type = AVMEDIA_TYPE_VIDEO,
1137  .id = AV_CODEC_ID_FFV1,
1138  .priv_data_size = sizeof(FFV1Context),
1139  .init = encode_init,
1140  .encode2 = encode_frame,
1141  .close = ffv1_close,
1142  .capabilities = CODEC_CAP_SLICE_THREADS,
1143  .pix_fmts = (const enum AVPixelFormat[]) {
1152 
1153  },
1154  .long_name = NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1155  .defaults = ffv1_defaults,
1156  .priv_class = &class,
1157 };