ffv1enc.c
Go to the documentation of this file.
1 /*
2  * FFV1 encoder for libavcodec
3  *
4  * Copyright (c) 2003-2012 Michael Niedermayer <michaelni@gmx.at>
5  *
6  * This file is part of Libav.
7  *
8  * Libav 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  * Libav 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 Libav; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
28 #include "libavutil/avassert.h"
29 #include "libavutil/pixdesc.h"
30 #include "libavutil/crc.h"
31 #include "libavutil/opt.h"
32 #include "libavutil/imgutils.h"
33 #include "avcodec.h"
34 #include "internal.h"
35 #include "get_bits.h"
36 #include "put_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 void find_best_state(uint8_t best_state[256][256],
44  const uint8_t one_state[256])
45 {
46  int i, j, k, m;
47  double l2tab[256];
48 
49  for (i = 1; i < 256; i++)
50  l2tab[i] = log2(i / 256.0);
51 
52  for (i = 0; i < 256; i++) {
53  double best_len[256];
54  double p = i / 256.0;
55 
56  for (j = 0; j < 256; j++)
57  best_len[j] = 1 << 30;
58 
59  for (j = FFMAX(i - 10, 1); j < FFMIN(i + 11, 256); j++) {
60  double occ[256] = { 0 };
61  double len = 0;
62  occ[j] = 1.0;
63  for (k = 0; k < 256; k++) {
64  double newocc[256] = { 0 };
65  for (m = 1; m < 256; m++)
66  if (occ[m]) {
67  len -= occ[m] * (p * l2tab[m] +
68  (1 - p) * l2tab[256 - m]);
69  }
70  if (len < best_len[k]) {
71  best_len[k] = len;
72  best_state[i][k] = j;
73  }
74  for (m = 0; m < 256; m++)
75  if (occ[m]) {
76  newocc[one_state[m]] += occ[m] * p;
77  newocc[256 - one_state[256 - m]] += occ[m] * (1 - p);
78  }
79  memcpy(occ, newocc, sizeof(occ));
80  }
81  }
82  }
83 }
84 
86  uint8_t *state, int v,
87  int is_signed,
88  uint64_t rc_stat[256][2],
89  uint64_t rc_stat2[32][2])
90 {
91  int i;
92 
93 #define put_rac(C, S, B) \
94  do { \
95  if (rc_stat) { \
96  rc_stat[*(S)][B]++; \
97  rc_stat2[(S) - state][B]++; \
98  } \
99  put_rac(C, S, B); \
100  } while (0)
101 
102  if (v) {
103  const int a = FFABS(v);
104  const int e = av_log2(a);
105  put_rac(c, state + 0, 0);
106  if (e <= 9) {
107  for (i = 0; i < e; i++)
108  put_rac(c, state + 1 + i, 1); // 1..10
109  put_rac(c, state + 1 + i, 0);
110 
111  for (i = e - 1; i >= 0; i--)
112  put_rac(c, state + 22 + i, (a >> i) & 1); // 22..31
113 
114  if (is_signed)
115  put_rac(c, state + 11 + e, v < 0); // 11..21
116  } else {
117  for (i = 0; i < e; i++)
118  put_rac(c, state + 1 + FFMIN(i, 9), 1); // 1..10
119  put_rac(c, state + 1 + 9, 0);
120 
121  for (i = e - 1; i >= 0; i--)
122  put_rac(c, state + 22 + FFMIN(i, 9), (a >> i) & 1); // 22..31
123 
124  if (is_signed)
125  put_rac(c, state + 11 + 10, v < 0); // 11..21
126  }
127  } else {
128  put_rac(c, state + 0, 1);
129  }
130 #undef put_rac
131 }
132 
134  int v, int is_signed)
135 {
136  put_symbol_inline(c, state, v, is_signed, NULL, NULL);
137 }
138 
139 static inline void put_vlc_symbol(PutBitContext *pb, VlcState *const state,
140  int v, int bits)
141 {
142  int i, k, code;
143  v = fold(v - state->bias, bits);
144 
145  i = state->count;
146  k = 0;
147  while (i < state->error_sum) { // FIXME: optimize
148  k++;
149  i += i;
150  }
151 
152  assert(k <= 13);
153 
154 #if 0 // JPEG LS
155  if (k == 0 && 2 * state->drift <= -state->count)
156  code = v ^ (-1);
157  else
158  code = v;
159 #else
160  code = v ^ ((2 * state->drift + state->count) >> 31);
161 #endif
162 
163  av_dlog(NULL, "v:%d/%d bias:%d error:%d drift:%d count:%d k:%d\n", v, code,
164  state->bias, state->error_sum, state->drift, state->count, k);
165  set_sr_golomb(pb, code, k, 12, bits);
166 
167  update_vlc_state(state, v);
168 }
169 
171  int16_t *sample[3],
172  int plane_index, int bits)
173 {
174  PlaneContext *const p = &s->plane[plane_index];
175  RangeCoder *const c = &s->c;
176  int x;
177  int run_index = s->run_index;
178  int run_count = 0;
179  int run_mode = 0;
180 
181  if (s->ac) {
182  if (c->bytestream_end - c->bytestream < w * 20) {
183  av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
184  return AVERROR_INVALIDDATA;
185  }
186  } else {
187  if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) < w * 4) {
188  av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
189  return AVERROR_INVALIDDATA;
190  }
191  }
192 
193  for (x = 0; x < w; x++) {
194  int diff, context;
195 
196  context = get_context(p, sample[0] + x, sample[1] + x, sample[2] + x);
197  diff = sample[0][x] - predict(sample[0] + x, sample[1] + x);
198 
199  if (context < 0) {
200  context = -context;
201  diff = -diff;
202  }
203 
204  diff = fold(diff, bits);
205 
206  if (s->ac) {
207  if (s->flags & CODEC_FLAG_PASS1) {
208  put_symbol_inline(c, p->state[context], diff, 1, s->rc_stat,
209  s->rc_stat2[p->quant_table_index][context]);
210  } else {
211  put_symbol_inline(c, p->state[context], diff, 1, NULL, NULL);
212  }
213  } else {
214  if (context == 0)
215  run_mode = 1;
216 
217  if (run_mode) {
218  if (diff) {
219  while (run_count >= 1 << ff_log2_run[run_index]) {
220  run_count -= 1 << ff_log2_run[run_index];
221  run_index++;
222  put_bits(&s->pb, 1, 1);
223  }
224 
225  put_bits(&s->pb, 1 + ff_log2_run[run_index], run_count);
226  if (run_index)
227  run_index--;
228  run_count = 0;
229  run_mode = 0;
230  if (diff > 0)
231  diff--;
232  } else {
233  run_count++;
234  }
235  }
236 
237  av_dlog(s->avctx, "count:%d index:%d, mode:%d, x:%d pos:%d\n",
238  run_count, run_index, run_mode, x,
239  (int)put_bits_count(&s->pb));
240 
241  if (run_mode == 0)
242  put_vlc_symbol(&s->pb, &p->vlc_state[context], diff, bits);
243  }
244  }
245  if (run_mode) {
246  while (run_count >= 1 << ff_log2_run[run_index]) {
247  run_count -= 1 << ff_log2_run[run_index];
248  run_index++;
249  put_bits(&s->pb, 1, 1);
250  }
251 
252  if (run_count)
253  put_bits(&s->pb, 1, 1);
254  }
255  s->run_index = run_index;
256 
257  return 0;
258 }
259 
260 static void encode_plane(FFV1Context *s, uint8_t *src, int w, int h,
261  int stride, int plane_index)
262 {
263  int x, y, i;
264  const int ring_size = s->avctx->context_model ? 3 : 2;
265  int16_t *sample[3];
266  s->run_index = 0;
267 
268  memset(s->sample_buffer, 0, ring_size * (w + 6) * sizeof(*s->sample_buffer));
269 
270  for (y = 0; y < h; y++) {
271  for (i = 0; i < ring_size; i++)
272  sample[i] = s->sample_buffer + (w + 6) * ((h + i - y) % ring_size) + 3;
273 
274  sample[0][-1] = sample[1][0];
275  sample[1][w] = sample[1][w - 1];
276 // { START_TIMER
277  if (s->bits_per_raw_sample <= 8) {
278  for (x = 0; x < w; x++)
279  sample[0][x] = src[x + stride * y];
280  encode_line(s, w, sample, plane_index, 8);
281  } else {
282  if (s->packed_at_lsb) {
283  for (x = 0; x < w; x++)
284  sample[0][x] = ((uint16_t *)(src + stride * y))[x];
285  } else {
286  for (x = 0; x < w; x++)
287  sample[0][x] =
288  ((uint16_t *)(src + stride * y))[x] >> (16 - s->bits_per_raw_sample);
289  }
290  encode_line(s, w, sample, plane_index, s->bits_per_raw_sample);
291  }
292 // STOP_TIMER("encode line") }
293  }
294 }
295 
296 static void encode_rgb_frame(FFV1Context *s, uint8_t *src[3], int w, int h,
297  int stride[3])
298 {
299  int x, y, p, i;
300  const int ring_size = s->avctx->context_model ? 3 : 2;
301  int16_t *sample[MAX_PLANES][3];
302  int lbd = s->avctx->bits_per_raw_sample <= 8;
303  int bits = s->avctx->bits_per_raw_sample > 0
305  : 8;
306  int offset = 1 << bits;
307 
308  s->run_index = 0;
309 
310  memset(s->sample_buffer, 0, ring_size * MAX_PLANES *
311  (w + 6) * sizeof(*s->sample_buffer));
312 
313  for (y = 0; y < h; y++) {
314  for (i = 0; i < ring_size; i++)
315  for (p = 0; p < MAX_PLANES; p++)
316  sample[p][i] = s->sample_buffer + p * ring_size *
317  (w + 6) +
318  ((h + i - y) % ring_size) * (w + 6) + 3;
319 
320  for (x = 0; x < w; x++) {
321  int b, g, r, av_uninit(a);
322  if (lbd) {
323  unsigned v = *((uint32_t *)(src[0] + x * 4 + stride[0] * y));
324  b = v & 0xFF;
325  g = (v >> 8) & 0xFF;
326  r = (v >> 16) & 0xFF;
327  a = v >> 24;
328  } else {
329  b = *((uint16_t *)(src[0] + x * 2 + stride[0] * y));
330  g = *((uint16_t *)(src[1] + x * 2 + stride[1] * y));
331  r = *((uint16_t *)(src[2] + x * 2 + stride[2] * y));
332  }
333 
334  b -= g;
335  r -= g;
336  g += (b + r) >> 2;
337  b += offset;
338  r += offset;
339 
340  sample[0][0][x] = g;
341  sample[1][0][x] = b;
342  sample[2][0][x] = r;
343  sample[3][0][x] = a;
344  }
345  for (p = 0; p < 3 + s->transparency; p++) {
346  sample[p][0][-1] = sample[p][1][0];
347  sample[p][1][w] = sample[p][1][w - 1];
348  if (lbd)
349  encode_line(s, w, sample[p], (p + 1) / 2, 9);
350  else
351  encode_line(s, w, sample[p], (p + 1) / 2, bits + 1);
352  }
353  }
354 }
355 
356 
357 static void write_quant_table(RangeCoder *c, int16_t *quant_table)
358 {
359  int last = 0;
360  int i;
362  memset(state, 128, sizeof(state));
363 
364  for (i = 1; i < 128; i++)
365  if (quant_table[i] != quant_table[i - 1]) {
366  put_symbol(c, state, i - last - 1, 0);
367  last = i;
368  }
369  put_symbol(c, state, i - last - 1, 0);
370 }
371 
373  int16_t quant_table[MAX_CONTEXT_INPUTS][256])
374 {
375  int i;
376  for (i = 0; i < 5; i++)
378 }
379 
380 static void write_header(FFV1Context *f)
381 {
383  int i, j;
384  RangeCoder *const c = &f->slice_context[0]->c;
385 
386  memset(state, 128, sizeof(state));
387 
388  if (f->version < 2) {
389  put_symbol(c, state, f->version, 0);
390  put_symbol(c, state, f->ac, 0);
391  if (f->ac > 1) {
392  for (i = 1; i < 256; i++)
393  put_symbol(c, state,
394  f->state_transition[i] - c->one_state[i], 1);
395  }
396  put_symbol(c, state, f->colorspace, 0); // YUV cs type
397  if (f->version > 0)
398  put_symbol(c, state, f->bits_per_raw_sample, 0);
399  put_rac(c, state, f->chroma_planes);
400  put_symbol(c, state, f->chroma_h_shift, 0);
401  put_symbol(c, state, f->chroma_v_shift, 0);
402  put_rac(c, state, f->transparency);
403 
405  } else if (f->version < 3) {
406  put_symbol(c, state, f->slice_count, 0);
407  for (i = 0; i < f->slice_count; i++) {
408  FFV1Context *fs = f->slice_context[i];
409  put_symbol(c, state,
410  (fs->slice_x + 1) * f->num_h_slices / f->width, 0);
411  put_symbol(c, state,
412  (fs->slice_y + 1) * f->num_v_slices / f->height, 0);
413  put_symbol(c, state,
414  (fs->slice_width + 1) * f->num_h_slices / f->width - 1,
415  0);
416  put_symbol(c, state,
417  (fs->slice_height + 1) * f->num_v_slices / f->height - 1,
418  0);
419  for (j = 0; j < f->plane_count; j++) {
420  put_symbol(c, state, f->plane[j].quant_table_index, 0);
422  }
423  }
424  }
425 }
426 
428 {
429  RangeCoder *const c = &f->c;
431  int i, j, k;
432  uint8_t state2[32][CONTEXT_SIZE];
433  unsigned v;
434 
435  memset(state2, 128, sizeof(state2));
436  memset(state, 128, sizeof(state));
437 
438  f->avctx->extradata_size = 10000 + 4 +
439  (11 * 11 * 5 * 5 * 5 + 11 * 11 * 11) * 32;
442  ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
443 
444  put_symbol(c, state, f->version, 0);
445  if (f->version > 2) {
446  if (f->version == 3)
447  f->minor_version = 2;
448  put_symbol(c, state, f->minor_version, 0);
449  }
450 
451  put_symbol(c, state, f->ac, 0);
452  if (f->ac > 1)
453  for (i = 1; i < 256; i++)
454  put_symbol(c, state, f->state_transition[i] - c->one_state[i], 1);
455 
456  put_symbol(c, state, f->colorspace, 0); // YUV cs type
457  put_symbol(c, state, f->bits_per_raw_sample, 0);
458  put_rac(c, state, f->chroma_planes);
459  put_symbol(c, state, f->chroma_h_shift, 0);
460  put_symbol(c, state, f->chroma_v_shift, 0);
461  put_rac(c, state, f->transparency);
462  put_symbol(c, state, f->num_h_slices - 1, 0);
463  put_symbol(c, state, f->num_v_slices - 1, 0);
464 
465  put_symbol(c, state, f->quant_table_count, 0);
466  for (i = 0; i < f->quant_table_count; i++)
468 
469  for (i = 0; i < f->quant_table_count; i++) {
470  for (j = 0; j < f->context_count[i] * CONTEXT_SIZE; j++)
471  if (f->initial_states[i] && f->initial_states[i][0][j] != 128)
472  break;
473  if (j < f->context_count[i] * CONTEXT_SIZE) {
474  put_rac(c, state, 1);
475  for (j = 0; j < f->context_count[i]; j++)
476  for (k = 0; k < CONTEXT_SIZE; k++) {
477  int pred = j ? f->initial_states[i][j - 1][k] : 128;
478  put_symbol(c, state2[k],
479  (int8_t)(f->initial_states[i][j][k] - pred), 1);
480  }
481  } else {
482  put_rac(c, state, 0);
483  }
484  }
485 
486  if (f->version > 2) {
487  put_symbol(c, state, f->ec, 0);
488  }
489 
491 
495  f->avctx->extradata_size += 4;
496 
497  return 0;
498 }
499 
500 static int sort_stt(FFV1Context *s, uint8_t stt[256])
501 {
502  int i, i2, changed, print = 0;
503 
504  do {
505  changed = 0;
506  for (i = 12; i < 244; i++) {
507  for (i2 = i + 1; i2 < 245 && i2 < i + 4; i2++) {
508 
509 #define COST(old, new) \
510  s->rc_stat[old][0] * -log2((256 - (new)) / 256.0) + \
511  s->rc_stat[old][1] * -log2((new) / 256.0)
512 
513 #define COST2(old, new) \
514  COST(old, new) + COST(256 - (old), 256 - (new))
515 
516  double size0 = COST2(i, i) + COST2(i2, i2);
517  double sizeX = COST2(i, i2) + COST2(i2, i);
518  if (sizeX < size0 && i != 128 && i2 != 128) {
519  int j;
520  FFSWAP(int, stt[i], stt[i2]);
521  FFSWAP(int, s->rc_stat[i][0], s->rc_stat[i2][0]);
522  FFSWAP(int, s->rc_stat[i][1], s->rc_stat[i2][1]);
523  if (i != 256 - i2) {
524  FFSWAP(int, stt[256 - i], stt[256 - i2]);
525  FFSWAP(int, s->rc_stat[256 - i][0], s->rc_stat[256 - i2][0]);
526  FFSWAP(int, s->rc_stat[256 - i][1], s->rc_stat[256 - i2][1]);
527  }
528  for (j = 1; j < 256; j++) {
529  if (stt[j] == i)
530  stt[j] = i2;
531  else if (stt[j] == i2)
532  stt[j] = i;
533  if (i != 256 - i2) {
534  if (stt[256 - j] == 256 - i)
535  stt[256 - j] = 256 - i2;
536  else if (stt[256 - j] == 256 - i2)
537  stt[256 - j] = 256 - i;
538  }
539  }
540  print = changed = 1;
541  }
542  }
543  }
544  } while (changed);
545  return print;
546 }
547 
549 {
550  int i, ret;
551  for (i = 0; i < f->slice_count; i++) {
552  FFV1Context *fs = f->slice_context[i];
553  if ((ret = ffv1_init_slice_state(f, fs)) < 0)
554  return AVERROR(ENOMEM);
555  }
556  return 0;
557 }
558 
560 {
561  FFV1Context *s = avctx->priv_data;
562  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
563  int i, j, k, m, ret;
564 
565  ffv1_common_init(avctx);
566 
567  s->version = 0;
568 
569  if ((avctx->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2)) ||
570  avctx->slices > 1)
571  s->version = FFMAX(s->version, 2);
572 
573  if (avctx->level == 3) {
574  s->version = 3;
575  }
576 
577  if (s->ec < 0) {
578  s->ec = (s->version >= 3);
579  }
580 
581  if (s->version >= 2 &&
583  av_log(avctx, AV_LOG_ERROR,
584  "Version %d requested, please set -strict experimental in "
585  "order to enable it\n",
586  s->version);
587  return AVERROR(ENOSYS);
588  }
589 
590  s->ac = avctx->coder_type > 0 ? 2 : 0;
591 
592  s->plane_count = 3;
593  switch (avctx->pix_fmt) {
594  case AV_PIX_FMT_YUV444P9:
595  case AV_PIX_FMT_YUV422P9:
596  case AV_PIX_FMT_YUV420P9:
597  if (!avctx->bits_per_raw_sample)
598  s->bits_per_raw_sample = 9;
602  s->packed_at_lsb = 1;
603  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
604  s->bits_per_raw_sample = 10;
605  case AV_PIX_FMT_GRAY16:
609  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) {
610  s->bits_per_raw_sample = 16;
611  } else if (!s->bits_per_raw_sample) {
613  }
614  if (s->bits_per_raw_sample <= 8) {
615  av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");
616  return AVERROR_INVALIDDATA;
617  }
618  if (!s->ac && avctx->coder_type == -1) {
619  av_log(avctx, AV_LOG_INFO,
620  "bits_per_raw_sample > 8, forcing coder 1\n");
621  s->ac = 2;
622  }
623  if (!s->ac) {
624  av_log(
625  avctx, AV_LOG_ERROR,
626  "bits_per_raw_sample of more than 8 needs -coder 1 currently\n");
627  return AVERROR_INVALIDDATA;
628  }
629  s->version = FFMAX(s->version, 1);
630  case AV_PIX_FMT_GRAY8:
631  case AV_PIX_FMT_YUV444P:
632  case AV_PIX_FMT_YUV440P:
633  case AV_PIX_FMT_YUV422P:
634  case AV_PIX_FMT_YUV420P:
635  case AV_PIX_FMT_YUV411P:
636  case AV_PIX_FMT_YUV410P:
637  s->chroma_planes = desc->nb_components < 3 ? 0 : 1;
638  s->colorspace = 0;
639  break;
640  case AV_PIX_FMT_YUVA444P:
641  case AV_PIX_FMT_YUVA422P:
642  case AV_PIX_FMT_YUVA420P:
643  s->chroma_planes = 1;
644  s->colorspace = 0;
645  s->transparency = 1;
646  break;
647  case AV_PIX_FMT_RGB32:
648  s->colorspace = 1;
649  s->transparency = 1;
650  break;
651  case AV_PIX_FMT_GBRP9:
652  if (!avctx->bits_per_raw_sample)
653  s->bits_per_raw_sample = 9;
654  case AV_PIX_FMT_GBRP10:
655  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
656  s->bits_per_raw_sample = 10;
657  case AV_PIX_FMT_GBRP16:
658  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
659  s->bits_per_raw_sample = 16;
660  else if (!s->bits_per_raw_sample)
662  s->colorspace = 1;
663  s->chroma_planes = 1;
664  s->version = FFMAX(s->version, 1);
665  break;
666  default:
667  av_log(avctx, AV_LOG_ERROR, "format not supported\n");
668  return AVERROR_INVALIDDATA;
669  }
670  if (s->transparency) {
671  av_log(
672  avctx, AV_LOG_WARNING,
673  "Storing alpha plane, this will require a recent FFV1 decoder to playback!\n");
674  }
675  if (avctx->context_model > 1U) {
676  av_log(avctx, AV_LOG_ERROR,
677  "Invalid context model %d, valid values are 0 and 1\n",
678  avctx->context_model);
679  return AVERROR(EINVAL);
680  }
681 
682  if (s->ac > 1)
683  for (i = 1; i < 256; i++)
685 
686  for (i = 0; i < 256; i++) {
687  s->quant_table_count = 2;
688  if (s->bits_per_raw_sample <= 8) {
689  s->quant_tables[0][0][i] = ffv1_quant11[i];
690  s->quant_tables[0][1][i] = ffv1_quant11[i] * 11;
691  s->quant_tables[0][2][i] = ffv1_quant11[i] * 11 * 11;
692  s->quant_tables[1][0][i] = ffv1_quant11[i];
693  s->quant_tables[1][1][i] = ffv1_quant11[i] * 11;
694  s->quant_tables[1][2][i] = ffv1_quant5[i] * 11 * 11;
695  s->quant_tables[1][3][i] = ffv1_quant5[i] * 5 * 11 * 11;
696  s->quant_tables[1][4][i] = ffv1_quant5[i] * 5 * 5 * 11 * 11;
697  } else {
698  s->quant_tables[0][0][i] = ffv1_quant9_10bit[i];
699  s->quant_tables[0][1][i] = ffv1_quant9_10bit[i] * 11;
700  s->quant_tables[0][2][i] = ffv1_quant9_10bit[i] * 11 * 11;
701  s->quant_tables[1][0][i] = ffv1_quant9_10bit[i];
702  s->quant_tables[1][1][i] = ffv1_quant9_10bit[i] * 11;
703  s->quant_tables[1][2][i] = ffv1_quant5_10bit[i] * 11 * 11;
704  s->quant_tables[1][3][i] = ffv1_quant5_10bit[i] * 5 * 11 * 11;
705  s->quant_tables[1][4][i] = ffv1_quant5_10bit[i] * 5 * 5 * 11 * 11;
706  }
707  }
708  s->context_count[0] = (11 * 11 * 11 + 1) / 2;
709  s->context_count[1] = (11 * 11 * 5 * 5 * 5 + 1) / 2;
710  memcpy(s->quant_table, s->quant_tables[avctx->context_model],
711  sizeof(s->quant_table));
712 
713  for (i = 0; i < s->plane_count; i++) {
714  PlaneContext *const p = &s->plane[i];
715 
716  memcpy(p->quant_table, s->quant_table, sizeof(p->quant_table));
717  p->quant_table_index = avctx->context_model;
719  }
720 
721  if ((ret = ffv1_allocate_initial_states(s)) < 0)
722  return ret;
723 
724  avctx->coded_frame = &s->picture;
725  if (!s->transparency)
726  s->plane_count = 2;
727 
729  &s->chroma_v_shift);
730 
731  s->picture_number = 0;
732 
733  if (avctx->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2)) {
734  for (i = 0; i < s->quant_table_count; i++) {
735  s->rc_stat2[i] = av_mallocz(s->context_count[i] *
736  sizeof(*s->rc_stat2[i]));
737  if (!s->rc_stat2[i])
738  return AVERROR(ENOMEM);
739  }
740  }
741  if (avctx->stats_in) {
742  char *p = avctx->stats_in;
743  uint8_t best_state[256][256];
744  int gob_count = 0;
745  char *next;
746 
747  av_assert0(s->version >= 2);
748 
749  for (;; ) {
750  for (j = 0; j < 256; j++)
751  for (i = 0; i < 2; i++) {
752  s->rc_stat[j][i] = strtol(p, &next, 0);
753  if (next == p) {
754  av_log(avctx, AV_LOG_ERROR,
755  "2Pass file invalid at %d %d [%s]\n", j, i, p);
756  return AVERROR_INVALIDDATA;
757  }
758  p = next;
759  }
760  for (i = 0; i < s->quant_table_count; i++)
761  for (j = 0; j < s->context_count[i]; j++) {
762  for (k = 0; k < 32; k++)
763  for (m = 0; m < 2; m++) {
764  s->rc_stat2[i][j][k][m] = strtol(p, &next, 0);
765  if (next == p) {
766  av_log(avctx, AV_LOG_ERROR,
767  "2Pass file invalid at %d %d %d %d [%s]\n",
768  i, j, k, m, p);
769  return AVERROR_INVALIDDATA;
770  }
771  p = next;
772  }
773  }
774  gob_count = strtol(p, &next, 0);
775  if (next == p || gob_count <= 0) {
776  av_log(avctx, AV_LOG_ERROR, "2Pass file invalid\n");
777  return AVERROR_INVALIDDATA;
778  }
779  p = next;
780  while (*p == '\n' || *p == ' ')
781  p++;
782  if (p[0] == 0)
783  break;
784  }
785  sort_stt(s, s->state_transition);
786 
787  find_best_state(best_state, s->state_transition);
788 
789  for (i = 0; i < s->quant_table_count; i++) {
790  for (j = 0; j < s->context_count[i]; j++)
791  for (k = 0; k < 32; k++) {
792  double p = 128;
793  if (s->rc_stat2[i][j][k][0] + s->rc_stat2[i][j][k][1]) {
794  p = 256.0 * s->rc_stat2[i][j][k][1] /
795  (s->rc_stat2[i][j][k][0] + s->rc_stat2[i][j][k][1]);
796  }
797  s->initial_states[i][j][k] =
798  best_state[av_clip(round(p), 1, 255)][av_clip((s->rc_stat2[i][j][k][0] +
799  s->rc_stat2[i][j][k][1]) /
800  gob_count, 0, 255)];
801  }
802  }
803  }
804 
805  if (s->version > 1) {
806  for (s->num_v_slices = 2; s->num_v_slices < 9; s->num_v_slices++)
807  for (s->num_h_slices = s->num_v_slices;
808  s->num_h_slices < 2 * s->num_v_slices; s->num_h_slices++)
809  if (avctx->slices == s->num_h_slices * s->num_v_slices &&
810  avctx->slices <= 64 || !avctx->slices)
811  goto slices_ok;
812  av_log(avctx, AV_LOG_ERROR,
813  "Unsupported number %d of slices requested, please specify a "
814  "supported number with -slices (ex:4,6,9,12,16, ...)\n",
815  avctx->slices);
816  return AVERROR(ENOSYS);
817 slices_ok:
818  write_extradata(s);
819  }
820 
821  if ((ret = ffv1_init_slice_contexts(s)) < 0)
822  return ret;
823  if ((ret = init_slices_state(s)) < 0)
824  return ret;
825 
826 #define STATS_OUT_SIZE 1024 * 1024 * 6
827  if (avctx->flags & CODEC_FLAG_PASS1) {
829  for (i = 0; i < s->quant_table_count; i++)
830  for (j = 0; j < s->slice_count; j++) {
831  FFV1Context *sf = s->slice_context[j];
832  av_assert0(!sf->rc_stat2[i]);
833  sf->rc_stat2[i] = av_mallocz(s->context_count[i] *
834  sizeof(*sf->rc_stat2[i]));
835  if (!sf->rc_stat2[i])
836  return AVERROR(ENOMEM);
837  }
838  }
839 
840  return 0;
841 }
842 
844 {
845  RangeCoder *c = &fs->c;
847  int j;
848  memset(state, 128, sizeof(state));
849 
850  put_symbol(c, state, (fs->slice_x + 1) * f->num_h_slices / f->width, 0);
851  put_symbol(c, state, (fs->slice_y + 1) * f->num_v_slices / f->height, 0);
852  put_symbol(c, state, (fs->slice_width + 1) * f->num_h_slices / f->width - 1,
853  0);
854  put_symbol(c, state,
855  (fs->slice_height + 1) * f->num_v_slices / f->height - 1,
856  0);
857  for (j = 0; j < f->plane_count; j++) {
858  put_symbol(c, state, f->plane[j].quant_table_index, 0);
860  }
861  if (!f->picture.interlaced_frame)
862  put_symbol(c, state, 3, 0);
863  else
864  put_symbol(c, state, 1 + !f->picture.top_field_first, 0);
865  put_symbol(c, state, f->picture.sample_aspect_ratio.num, 0);
866  put_symbol(c, state, f->picture.sample_aspect_ratio.den, 0);
867 }
868 
869 static int encode_slice(AVCodecContext *c, void *arg)
870 {
871  FFV1Context *fs = *(void **)arg;
872  FFV1Context *f = fs->avctx->priv_data;
873  int width = fs->slice_width;
874  int height = fs->slice_height;
875  int x = fs->slice_x;
876  int y = fs->slice_y;
877  AVFrame *const p = &f->picture;
878  const int ps = (av_pix_fmt_desc_get(c->pix_fmt)->flags & PIX_FMT_PLANAR)
879  ? (f->bits_per_raw_sample > 8) + 1
880  : 4;
881 
882  if (p->key_frame)
883  ffv1_clear_slice_state(f, fs);
884  if (f->version > 2) {
885  encode_slice_header(f, fs);
886  }
887  if (!fs->ac) {
888  if (f->version > 2)
889  put_rac(&fs->c, (uint8_t[]) { 129 }, 0);
890  fs->ac_byte_count = f->version > 2 || (!x && !y) ? ff_rac_terminate( &fs->c) : 0;
893  }
894 
895  if (f->colorspace == 0) {
896  const int chroma_width = -((-width) >> f->chroma_h_shift);
897  const int chroma_height = -((-height) >> f->chroma_v_shift);
898  const int cx = x >> f->chroma_h_shift;
899  const int cy = y >> f->chroma_v_shift;
900 
901  encode_plane(fs, p->data[0] + ps * x + y * p->linesize[0],
902  width, height, p->linesize[0], 0);
903 
904  if (f->chroma_planes) {
905  encode_plane(fs, p->data[1] + ps * cx + cy * p->linesize[1],
906  chroma_width, chroma_height, p->linesize[1], 1);
907  encode_plane(fs, p->data[2] + ps * cx + cy * p->linesize[2],
908  chroma_width, chroma_height, p->linesize[2], 1);
909  }
910  if (fs->transparency)
911  encode_plane(fs, p->data[3] + ps * x + y * p->linesize[3], width,
912  height, p->linesize[3], 2);
913  } else {
914  uint8_t *planes[3] = { p->data[0] + ps * x + y * p->linesize[0],
915  p->data[1] + ps * x + y * p->linesize[1],
916  p->data[2] + ps * x + y * p->linesize[2] };
917  encode_rgb_frame(fs, planes, width, height, p->linesize);
918  }
919  emms_c();
920 
921  return 0;
922 }
923 
925  const AVFrame *pict, int *got_packet)
926 {
927  FFV1Context *f = avctx->priv_data;
928  RangeCoder *const c = &f->slice_context[0]->c;
929  AVFrame *const p = &f->picture;
930  int used_count = 0;
931  uint8_t keystate = 128;
932  uint8_t *buf_p;
933  int i, ret;
934 
935  if ((ret = ff_alloc_packet(pkt, avctx->width * avctx->height *
936  ((8 * 2 + 1 + 1) * 4) / 8 +
937  FF_MIN_BUFFER_SIZE)) < 0) {
938  av_log(avctx, AV_LOG_ERROR, "Error getting output packet.\n");
939  return ret;
940  }
941 
942  ff_init_range_encoder(c, pkt->data, pkt->size);
943  ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
944 
945  *p = *pict;
947 
948  if (avctx->gop_size == 0 || f->picture_number % avctx->gop_size == 0) {
949  put_rac(c, &keystate, 1);
950  p->key_frame = 1;
951  f->gob_count++;
952  write_header(f);
953  } else {
954  put_rac(c, &keystate, 0);
955  p->key_frame = 0;
956  }
957 
958  if (f->ac > 1) {
959  int i;
960  for (i = 1; i < 256; i++) {
961  c->one_state[i] = f->state_transition[i];
962  c->zero_state[256 - i] = 256 - c->one_state[i];
963  }
964  }
965 
966  for (i = 1; i < f->slice_count; i++) {
967  FFV1Context *fs = f->slice_context[i];
968  uint8_t *start = pkt->data +
969  (pkt->size - used_count) * (int64_t)i / f->slice_count;
970  int len = pkt->size / f->slice_count;
971  ff_init_range_encoder(&fs->c, start, len);
972  }
973  avctx->execute(avctx, encode_slice, &f->slice_context[0], NULL,
974  f->slice_count, sizeof(void *));
975 
976  buf_p = pkt->data;
977  for (i = 0; i < f->slice_count; i++) {
978  FFV1Context *fs = f->slice_context[i];
979  int bytes;
980 
981  if (fs->ac) {
982  uint8_t state = 129;
983  put_rac(&fs->c, &state, 0);
984  bytes = ff_rac_terminate(&fs->c);
985  } else {
986  flush_put_bits(&fs->pb); // FIXME: nicer padding
987  bytes = fs->ac_byte_count + (put_bits_count(&fs->pb) + 7) / 8;
988  }
989  if (i > 0 || f->version > 2) {
990  av_assert0(bytes < pkt->size / f->slice_count);
991  memmove(buf_p, fs->c.bytestream_start, bytes);
992  av_assert0(bytes < (1 << 24));
993  AV_WB24(buf_p + bytes, bytes);
994  bytes += 3;
995  }
996  if (f->ec) {
997  unsigned v;
998  buf_p[bytes++] = 0;
999  v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, buf_p, bytes);
1000  AV_WL32(buf_p + bytes, v);
1001  bytes += 4;
1002  }
1003  buf_p += bytes;
1004  }
1005 
1006  if ((avctx->flags & CODEC_FLAG_PASS1) && (f->picture_number & 31) == 0) {
1007  int j, k, m;
1008  char *p = avctx->stats_out;
1009  char *end = p + STATS_OUT_SIZE;
1010 
1011  memset(f->rc_stat, 0, sizeof(f->rc_stat));
1012  for (i = 0; i < f->quant_table_count; i++)
1013  memset(f->rc_stat2[i], 0, f->context_count[i] * sizeof(*f->rc_stat2[i]));
1014 
1015  for (j = 0; j < f->slice_count; j++) {
1016  FFV1Context *fs = f->slice_context[j];
1017  for (i = 0; i < 256; i++) {
1018  f->rc_stat[i][0] += fs->rc_stat[i][0];
1019  f->rc_stat[i][1] += fs->rc_stat[i][1];
1020  }
1021  for (i = 0; i < f->quant_table_count; i++) {
1022  for (k = 0; k < f->context_count[i]; k++)
1023  for (m = 0; m < 32; m++) {
1024  f->rc_stat2[i][k][m][0] += fs->rc_stat2[i][k][m][0];
1025  f->rc_stat2[i][k][m][1] += fs->rc_stat2[i][k][m][1];
1026  }
1027  }
1028  }
1029 
1030  for (j = 0; j < 256; j++) {
1031  snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1032  f->rc_stat[j][0], f->rc_stat[j][1]);
1033  p += strlen(p);
1034  }
1035  snprintf(p, end - p, "\n");
1036 
1037  for (i = 0; i < f->quant_table_count; i++) {
1038  for (j = 0; j < f->context_count[i]; j++)
1039  for (m = 0; m < 32; m++) {
1040  snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1041  f->rc_stat2[i][j][m][0], f->rc_stat2[i][j][m][1]);
1042  p += strlen(p);
1043  }
1044  }
1045  snprintf(p, end - p, "%d\n", f->gob_count);
1046  } else if (avctx->flags & CODEC_FLAG_PASS1)
1047  avctx->stats_out[0] = '\0';
1048 
1049  f->picture_number++;
1050  pkt->size = buf_p - pkt->data;
1051  pkt->flags |= AV_PKT_FLAG_KEY * p->key_frame;
1052  *got_packet = 1;
1053 
1054  return 0;
1055 }
1056 
1057 #define OFFSET(x) offsetof(FFV1Context, x)
1058 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1059 static const AVOption options[] = {
1060  { "slicecrc", "Protect slices with CRCs", OFFSET(ec), AV_OPT_TYPE_INT,
1061  { .i64 = -1 }, -1, 1, VE },
1062  { NULL }
1063 };
1064 
1065 static const AVClass class = {
1066  .class_name = "ffv1 encoder",
1067  .item_name = av_default_item_name,
1068  .option = options,
1070 };
1071 
1072 static const AVCodecDefault ffv1_defaults[] = {
1073  { "coder", "-1" },
1074  { NULL },
1075 };
1076 
1078  .name = "ffv1",
1079  .type = AVMEDIA_TYPE_VIDEO,
1080  .id = AV_CODEC_ID_FFV1,
1081  .priv_data_size = sizeof(FFV1Context),
1083  .encode2 = ffv1_encode_frame,
1084  .close = ffv1_close,
1085  .capabilities = CODEC_CAP_SLICE_THREADS,
1086  .pix_fmts = (const enum AVPixelFormat[]) {
1097 
1098  },
1099  .long_name = NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1100  .defaults = ffv1_defaults,
1101  .priv_class = &class,
1102 };