FFmpeg
 All Data Structures Namespaces 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-2013 Michael Niedermayer <michaelni@gmx.at>
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
23 /**
24  * @file
25  * FF Video Codec 1 (a lossless codec) encoder
26  */
27 
28 #include "libavutil/attributes.h"
29 #include "libavutil/avassert.h"
30 #include "libavutil/crc.h"
31 #include "libavutil/opt.h"
32 #include "libavutil/imgutils.h"
33 #include "libavutil/pixdesc.h"
34 #include "libavutil/timer.h"
35 #include "avcodec.h"
36 #include "internal.h"
37 #include "put_bits.h"
38 #include "rangecoder.h"
39 #include "golomb.h"
40 #include "mathops.h"
41 #include "ffv1.h"
42 
43 static const int8_t quant5_10bit[256] = {
44  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1,
45  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
46  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
47  1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
48  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
49  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
50  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
51  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
52  -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
53  -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
54  -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
55  -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
56  -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -1,
57  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
58  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
59  -1, -1, -1, -1, -1, -1, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0,
60 };
61 
62 static const int8_t quant5[256] = {
63  0, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
64  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
65  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
66  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
67  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
68  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
69  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
70  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
71  -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
72  -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
73  -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
74  -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
75  -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
76  -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
77  -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
78  -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -1, -1, -1,
79 };
80 
81 static const int8_t quant9_10bit[256] = {
82  0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2,
83  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3,
84  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
85  3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
86  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
87  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
88  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
89  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
90  -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4,
91  -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4,
92  -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4,
93  -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4,
94  -4, -4, -4, -4, -4, -4, -4, -4, -4, -3, -3, -3, -3, -3, -3, -3,
95  -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3,
96  -3, -3, -3, -3, -3, -3, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
97  -2, -2, -2, -2, -1, -1, -1, -1, -1, -1, -1, -1, -0, -0, -0, -0,
98 };
99 
100 static const int8_t quant11[256] = {
101  0, 1, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4,
102  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
103  4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
104  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
105  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
106  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
107  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
108  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
109  -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5,
110  -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5,
111  -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5,
112  -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5,
113  -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5,
114  -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -4, -4,
115  -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4,
116  -4, -4, -4, -4, -4, -3, -3, -3, -3, -3, -3, -3, -2, -2, -2, -1,
117 };
118 
119 static const uint8_t ver2_state[256] = {
120  0, 10, 10, 10, 10, 16, 16, 16, 28, 16, 16, 29, 42, 49, 20, 49,
121  59, 25, 26, 26, 27, 31, 33, 33, 33, 34, 34, 37, 67, 38, 39, 39,
122  40, 40, 41, 79, 43, 44, 45, 45, 48, 48, 64, 50, 51, 52, 88, 52,
123  53, 74, 55, 57, 58, 58, 74, 60, 101, 61, 62, 84, 66, 66, 68, 69,
124  87, 82, 71, 97, 73, 73, 82, 75, 111, 77, 94, 78, 87, 81, 83, 97,
125  85, 83, 94, 86, 99, 89, 90, 99, 111, 92, 93, 134, 95, 98, 105, 98,
126  105, 110, 102, 108, 102, 118, 103, 106, 106, 113, 109, 112, 114, 112, 116, 125,
127  115, 116, 117, 117, 126, 119, 125, 121, 121, 123, 145, 124, 126, 131, 127, 129,
128  165, 130, 132, 138, 133, 135, 145, 136, 137, 139, 146, 141, 143, 142, 144, 148,
129  147, 155, 151, 149, 151, 150, 152, 157, 153, 154, 156, 168, 158, 162, 161, 160,
130  172, 163, 169, 164, 166, 184, 167, 170, 177, 174, 171, 173, 182, 176, 180, 178,
131  175, 189, 179, 181, 186, 183, 192, 185, 200, 187, 191, 188, 190, 197, 193, 196,
132  197, 194, 195, 196, 198, 202, 199, 201, 210, 203, 207, 204, 205, 206, 208, 214,
133  209, 211, 221, 212, 213, 215, 224, 216, 217, 218, 219, 220, 222, 228, 223, 225,
134  226, 224, 227, 229, 240, 230, 231, 232, 233, 234, 235, 236, 238, 239, 237, 242,
135  241, 243, 242, 244, 245, 246, 247, 248, 249, 250, 251, 252, 252, 253, 254, 255,
136 };
137 
138 static void find_best_state(uint8_t best_state[256][256],
139  const uint8_t one_state[256])
140 {
141  int i, j, k, m;
142  double l2tab[256];
143 
144  for (i = 1; i < 256; i++)
145  l2tab[i] = log2(i / 256.0);
146 
147  for (i = 0; i < 256; i++) {
148  double best_len[256];
149  double p = i / 256.0;
150 
151  for (j = 0; j < 256; j++)
152  best_len[j] = 1 << 30;
153 
154  for (j = FFMAX(i - 10, 1); j < FFMIN(i + 11, 256); j++) {
155  double occ[256] = { 0 };
156  double len = 0;
157  occ[j] = 1.0;
158 
159  if (!one_state[j])
160  continue;
161 
162  for (k = 0; k < 256; k++) {
163  double newocc[256] = { 0 };
164  for (m = 1; m < 256; m++)
165  if (occ[m]) {
166  len -=occ[m]*( p *l2tab[ m]
167  + (1-p)*l2tab[256-m]);
168  }
169  if (len < best_len[k]) {
170  best_len[k] = len;
171  best_state[i][k] = j;
172  }
173  for (m = 1; m < 256; m++)
174  if (occ[m]) {
175  newocc[ one_state[ m]] += occ[m] * p;
176  newocc[256 - one_state[256 - m]] += occ[m] * (1 - p);
177  }
178  memcpy(occ, newocc, sizeof(occ));
179  }
180  }
181  }
182 }
183 
185  uint8_t *state, int v,
186  int is_signed,
187  uint64_t rc_stat[256][2],
188  uint64_t rc_stat2[32][2])
189 {
190  int i;
191 
192 #define put_rac(C, S, B) \
193  do { \
194  if (rc_stat) { \
195  rc_stat[*(S)][B]++; \
196  rc_stat2[(S) - state][B]++; \
197  } \
198  put_rac(C, S, B); \
199  } while (0)
200 
201  if (v) {
202  const int a = FFABS(v);
203  const int e = av_log2(a);
204  put_rac(c, state + 0, 0);
205  if (e <= 9) {
206  for (i = 0; i < e; i++)
207  put_rac(c, state + 1 + i, 1); // 1..10
208  put_rac(c, state + 1 + i, 0);
209 
210  for (i = e - 1; i >= 0; i--)
211  put_rac(c, state + 22 + i, (a >> i) & 1); // 22..31
212 
213  if (is_signed)
214  put_rac(c, state + 11 + e, v < 0); // 11..21
215  } else {
216  for (i = 0; i < e; i++)
217  put_rac(c, state + 1 + FFMIN(i, 9), 1); // 1..10
218  put_rac(c, state + 1 + 9, 0);
219 
220  for (i = e - 1; i >= 0; i--)
221  put_rac(c, state + 22 + FFMIN(i, 9), (a >> i) & 1); // 22..31
222 
223  if (is_signed)
224  put_rac(c, state + 11 + 10, v < 0); // 11..21
225  }
226  } else {
227  put_rac(c, state + 0, 1);
228  }
229 #undef put_rac
230 }
231 
233  int v, int is_signed)
234 {
235  put_symbol_inline(c, state, v, is_signed, NULL, NULL);
236 }
237 
238 
239 static inline void put_vlc_symbol(PutBitContext *pb, VlcState *const state,
240  int v, int bits)
241 {
242  int i, k, code;
243  v = fold(v - state->bias, bits);
244 
245  i = state->count;
246  k = 0;
247  while (i < state->error_sum) { // FIXME: optimize
248  k++;
249  i += i;
250  }
251 
252  av_assert2(k <= 13);
253 
254 #if 0 // JPEG LS
255  if (k == 0 && 2 * state->drift <= -state->count)
256  code = v ^ (-1);
257  else
258  code = v;
259 #else
260  code = v ^ ((2 * state->drift + state->count) >> 31);
261 #endif
262 
263  ff_dlog(NULL, "v:%d/%d bias:%d error:%d drift:%d count:%d k:%d\n", v, code,
264  state->bias, state->error_sum, state->drift, state->count, k);
265  set_sr_golomb(pb, code, k, 12, bits);
266 
267  update_vlc_state(state, v);
268 }
269 
271  int16_t *sample[3],
272  int plane_index, int bits)
273 {
274  PlaneContext *const p = &s->plane[plane_index];
275  RangeCoder *const c = &s->c;
276  int x;
277  int run_index = s->run_index;
278  int run_count = 0;
279  int run_mode = 0;
280 
281  if (s->ac != AC_GOLOMB_RICE) {
282  if (c->bytestream_end - c->bytestream < w * 35) {
283  av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
284  return AVERROR_INVALIDDATA;
285  }
286  } else {
287  if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) < w * 4) {
288  av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
289  return AVERROR_INVALIDDATA;
290  }
291  }
292 
293  if (s->slice_coding_mode == 1) {
294  for (x = 0; x < w; x++) {
295  int i;
296  int v = sample[0][x];
297  for (i = bits-1; i>=0; i--) {
298  uint8_t state = 128;
299  put_rac(c, &state, (v>>i) & 1);
300  }
301  }
302  return 0;
303  }
304 
305  for (x = 0; x < w; x++) {
306  int diff, context;
307 
308  context = get_context(p, sample[0] + x, sample[1] + x, sample[2] + x);
309  diff = sample[0][x] - predict(sample[0] + x, sample[1] + x);
310 
311  if (context < 0) {
312  context = -context;
313  diff = -diff;
314  }
315 
316  diff = fold(diff, bits);
317 
318  if (s->ac != AC_GOLOMB_RICE) {
319  if (s->flags & AV_CODEC_FLAG_PASS1) {
320  put_symbol_inline(c, p->state[context], diff, 1, s->rc_stat,
321  s->rc_stat2[p->quant_table_index][context]);
322  } else {
323  put_symbol_inline(c, p->state[context], diff, 1, NULL, NULL);
324  }
325  } else {
326  if (context == 0)
327  run_mode = 1;
328 
329  if (run_mode) {
330  if (diff) {
331  while (run_count >= 1 << ff_log2_run[run_index]) {
332  run_count -= 1 << ff_log2_run[run_index];
333  run_index++;
334  put_bits(&s->pb, 1, 1);
335  }
336 
337  put_bits(&s->pb, 1 + ff_log2_run[run_index], run_count);
338  if (run_index)
339  run_index--;
340  run_count = 0;
341  run_mode = 0;
342  if (diff > 0)
343  diff--;
344  } else {
345  run_count++;
346  }
347  }
348 
349  ff_dlog(s->avctx, "count:%d index:%d, mode:%d, x:%d pos:%d\n",
350  run_count, run_index, run_mode, x,
351  (int)put_bits_count(&s->pb));
352 
353  if (run_mode == 0)
354  put_vlc_symbol(&s->pb, &p->vlc_state[context], diff, bits);
355  }
356  }
357  if (run_mode) {
358  while (run_count >= 1 << ff_log2_run[run_index]) {
359  run_count -= 1 << ff_log2_run[run_index];
360  run_index++;
361  put_bits(&s->pb, 1, 1);
362  }
363 
364  if (run_count)
365  put_bits(&s->pb, 1, 1);
366  }
367  s->run_index = run_index;
368 
369  return 0;
370 }
371 
372 static int encode_plane(FFV1Context *s, uint8_t *src, int w, int h,
373  int stride, int plane_index, int pixel_stride)
374 {
375  int x, y, i, ret;
376  const int ring_size = s->context_model ? 3 : 2;
377  int16_t *sample[3];
378  s->run_index = 0;
379 
380  memset(s->sample_buffer, 0, ring_size * (w + 6) * sizeof(*s->sample_buffer));
381 
382  for (y = 0; y < h; y++) {
383  for (i = 0; i < ring_size; i++)
384  sample[i] = s->sample_buffer + (w + 6) * ((h + i - y) % ring_size) + 3;
385 
386  sample[0][-1]= sample[1][0 ];
387  sample[1][ w]= sample[1][w-1];
388 // { START_TIMER
389  if (s->bits_per_raw_sample <= 8) {
390  for (x = 0; x < w; x++)
391  sample[0][x] = src[x * pixel_stride + stride * y];
392  if((ret = encode_line(s, w, sample, plane_index, 8)) < 0)
393  return ret;
394  } else {
395  if (s->packed_at_lsb) {
396  for (x = 0; x < w; x++) {
397  sample[0][x] = ((uint16_t*)(src + stride*y))[x];
398  }
399  } else {
400  for (x = 0; x < w; x++) {
401  sample[0][x] = ((uint16_t*)(src + stride*y))[x] >> (16 - s->bits_per_raw_sample);
402  }
403  }
404  if((ret = encode_line(s, w, sample, plane_index, s->bits_per_raw_sample)) < 0)
405  return ret;
406  }
407 // STOP_TIMER("encode line") }
408  }
409  return 0;
410 }
411 
412 static int encode_rgb_frame(FFV1Context *s, const uint8_t *src[3],
413  int w, int h, const int stride[3])
414 {
415  int x, y, p, i;
416  const int ring_size = s->context_model ? 3 : 2;
417  int16_t *sample[4][3];
418  int lbd = s->bits_per_raw_sample <= 8;
419  int bits = s->bits_per_raw_sample > 0 ? s->bits_per_raw_sample : 8;
420  int offset = 1 << bits;
421 
422  s->run_index = 0;
423 
424  memset(s->sample_buffer, 0, ring_size * MAX_PLANES *
425  (w + 6) * sizeof(*s->sample_buffer));
426 
427  for (y = 0; y < h; y++) {
428  for (i = 0; i < ring_size; i++)
429  for (p = 0; p < MAX_PLANES; p++)
430  sample[p][i]= s->sample_buffer + p*ring_size*(w+6) + ((h+i-y)%ring_size)*(w+6) + 3;
431 
432  for (x = 0; x < w; x++) {
433  int b, g, r, av_uninit(a);
434  if (lbd) {
435  unsigned v = *((const uint32_t*)(src[0] + x*4 + stride[0]*y));
436  b = v & 0xFF;
437  g = (v >> 8) & 0xFF;
438  r = (v >> 16) & 0xFF;
439  a = v >> 24;
440  } else {
441  b = *((const uint16_t *)(src[0] + x*2 + stride[0]*y));
442  g = *((const uint16_t *)(src[1] + x*2 + stride[1]*y));
443  r = *((const uint16_t *)(src[2] + x*2 + stride[2]*y));
444  }
445 
446  if (s->slice_coding_mode != 1) {
447  b -= g;
448  r -= g;
449  g += (b * s->slice_rct_by_coef + r * s->slice_rct_ry_coef) >> 2;
450  b += offset;
451  r += offset;
452  }
453 
454  sample[0][0][x] = g;
455  sample[1][0][x] = b;
456  sample[2][0][x] = r;
457  sample[3][0][x] = a;
458  }
459  for (p = 0; p < 3 + s->transparency; p++) {
460  int ret;
461  sample[p][0][-1] = sample[p][1][0 ];
462  sample[p][1][ w] = sample[p][1][w-1];
463  if (lbd && s->slice_coding_mode == 0)
464  ret = encode_line(s, w, sample[p], (p + 1) / 2, 9);
465  else
466  ret = encode_line(s, w, sample[p], (p + 1) / 2, bits + (s->slice_coding_mode != 1));
467  if (ret < 0)
468  return ret;
469  }
470  }
471  return 0;
472 }
473 
474 static void write_quant_table(RangeCoder *c, int16_t *quant_table)
475 {
476  int last = 0;
477  int i;
479  memset(state, 128, sizeof(state));
480 
481  for (i = 1; i < 128; i++)
482  if (quant_table[i] != quant_table[i - 1]) {
483  put_symbol(c, state, i - last - 1, 0);
484  last = i;
485  }
486  put_symbol(c, state, i - last - 1, 0);
487 }
488 
490  int16_t quant_table[MAX_CONTEXT_INPUTS][256])
491 {
492  int i;
493  for (i = 0; i < 5; i++)
495 }
496 
497 static void write_header(FFV1Context *f)
498 {
500  int i, j;
501  RangeCoder *const c = &f->slice_context[0]->c;
502 
503  memset(state, 128, sizeof(state));
504 
505  if (f->version < 2) {
506  put_symbol(c, state, f->version, 0);
507  put_symbol(c, state, f->ac, 0);
508  if (f->ac == AC_RANGE_CUSTOM_TAB) {
509  for (i = 1; i < 256; i++)
510  put_symbol(c, state,
511  f->state_transition[i] - c->one_state[i], 1);
512  }
513  put_symbol(c, state, f->colorspace, 0); //YUV cs type
514  if (f->version > 0)
515  put_symbol(c, state, f->bits_per_raw_sample, 0);
516  put_rac(c, state, f->chroma_planes);
517  put_symbol(c, state, f->chroma_h_shift, 0);
518  put_symbol(c, state, f->chroma_v_shift, 0);
519  put_rac(c, state, f->transparency);
520 
522  } else if (f->version < 3) {
523  put_symbol(c, state, f->slice_count, 0);
524  for (i = 0; i < f->slice_count; i++) {
525  FFV1Context *fs = f->slice_context[i];
526  put_symbol(c, state,
527  (fs->slice_x + 1) * f->num_h_slices / f->width, 0);
528  put_symbol(c, state,
529  (fs->slice_y + 1) * f->num_v_slices / f->height, 0);
530  put_symbol(c, state,
531  (fs->slice_width + 1) * f->num_h_slices / f->width - 1,
532  0);
533  put_symbol(c, state,
534  (fs->slice_height + 1) * f->num_v_slices / f->height - 1,
535  0);
536  for (j = 0; j < f->plane_count; j++) {
537  put_symbol(c, state, f->plane[j].quant_table_index, 0);
539  }
540  }
541  }
542 }
543 
545 {
546  RangeCoder *const c = &f->c;
548  int i, j, k;
549  uint8_t state2[32][CONTEXT_SIZE];
550  unsigned v;
551 
552  memset(state2, 128, sizeof(state2));
553  memset(state, 128, sizeof(state));
554 
555  f->avctx->extradata_size = 10000 + 4 +
556  (11 * 11 * 5 * 5 * 5 + 11 * 11 * 11) * 32;
558  if (!f->avctx->extradata)
559  return AVERROR(ENOMEM);
561  ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
562 
563  put_symbol(c, state, f->version, 0);
564  if (f->version > 2) {
565  if (f->version == 3) {
566  f->micro_version = 4;
567  } else if (f->version == 4)
568  f->micro_version = 2;
569  put_symbol(c, state, f->micro_version, 0);
570  }
571 
572  put_symbol(c, state, f->ac, 0);
573  if (f->ac == AC_RANGE_CUSTOM_TAB)
574  for (i = 1; i < 256; i++)
575  put_symbol(c, state, f->state_transition[i] - c->one_state[i], 1);
576 
577  put_symbol(c, state, f->colorspace, 0); // YUV cs type
578  put_symbol(c, state, f->bits_per_raw_sample, 0);
579  put_rac(c, state, f->chroma_planes);
580  put_symbol(c, state, f->chroma_h_shift, 0);
581  put_symbol(c, state, f->chroma_v_shift, 0);
582  put_rac(c, state, f->transparency);
583  put_symbol(c, state, f->num_h_slices - 1, 0);
584  put_symbol(c, state, f->num_v_slices - 1, 0);
585 
586  put_symbol(c, state, f->quant_table_count, 0);
587  for (i = 0; i < f->quant_table_count; i++)
589 
590  for (i = 0; i < f->quant_table_count; i++) {
591  for (j = 0; j < f->context_count[i] * CONTEXT_SIZE; j++)
592  if (f->initial_states[i] && f->initial_states[i][0][j] != 128)
593  break;
594  if (j < f->context_count[i] * CONTEXT_SIZE) {
595  put_rac(c, state, 1);
596  for (j = 0; j < f->context_count[i]; j++)
597  for (k = 0; k < CONTEXT_SIZE; k++) {
598  int pred = j ? f->initial_states[i][j - 1][k] : 128;
599  put_symbol(c, state2[k],
600  (int8_t)(f->initial_states[i][j][k] - pred), 1);
601  }
602  } else {
603  put_rac(c, state, 0);
604  }
605  }
606 
607  if (f->version > 2) {
608  put_symbol(c, state, f->ec, 0);
609  put_symbol(c, state, f->intra = (f->avctx->gop_size < 2), 0);
610  }
611 
615  f->avctx->extradata_size += 4;
616 
617  return 0;
618 }
619 
620 static int sort_stt(FFV1Context *s, uint8_t stt[256])
621 {
622  int i, i2, changed, print = 0;
623 
624  do {
625  changed = 0;
626  for (i = 12; i < 244; i++) {
627  for (i2 = i + 1; i2 < 245 && i2 < i + 4; i2++) {
628 
629 #define COST(old, new) \
630  s->rc_stat[old][0] * -log2((256 - (new)) / 256.0) + \
631  s->rc_stat[old][1] * -log2((new) / 256.0)
632 
633 #define COST2(old, new) \
634  COST(old, new) + COST(256 - (old), 256 - (new))
635 
636  double size0 = COST2(i, i) + COST2(i2, i2);
637  double sizeX = COST2(i, i2) + COST2(i2, i);
638  if (size0 - sizeX > size0*(1e-14) && i != 128 && i2 != 128) {
639  int j;
640  FFSWAP(int, stt[i], stt[i2]);
641  FFSWAP(int, s->rc_stat[i][0], s->rc_stat[i2][0]);
642  FFSWAP(int, s->rc_stat[i][1], s->rc_stat[i2][1]);
643  if (i != 256 - i2) {
644  FFSWAP(int, stt[256 - i], stt[256 - i2]);
645  FFSWAP(int, s->rc_stat[256 - i][0], s->rc_stat[256 - i2][0]);
646  FFSWAP(int, s->rc_stat[256 - i][1], s->rc_stat[256 - i2][1]);
647  }
648  for (j = 1; j < 256; j++) {
649  if (stt[j] == i)
650  stt[j] = i2;
651  else if (stt[j] == i2)
652  stt[j] = i;
653  if (i != 256 - i2) {
654  if (stt[256 - j] == 256 - i)
655  stt[256 - j] = 256 - i2;
656  else if (stt[256 - j] == 256 - i2)
657  stt[256 - j] = 256 - i;
658  }
659  }
660  print = changed = 1;
661  }
662  }
663  }
664  } while (changed);
665  return print;
666 }
667 
669 {
670  FFV1Context *s = avctx->priv_data;
672  int i, j, k, m, ret;
673 
674  if ((ret = ff_ffv1_common_init(avctx)) < 0)
675  return ret;
676 
677  s->version = 0;
678 
679  if ((avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) ||
680  avctx->slices > 1)
681  s->version = FFMAX(s->version, 2);
682 
683  // Unspecified level & slices, we choose version 1.2+ to ensure multithreaded decodability
684  if (avctx->slices == 0 && avctx->level < 0 && avctx->width * avctx->height > 720*576)
685  s->version = FFMAX(s->version, 2);
686 
687  if (avctx->level <= 0 && s->version == 2) {
688  s->version = 3;
689  }
690  if (avctx->level >= 0 && avctx->level <= 4) {
691  if (avctx->level < s->version) {
692  av_log(avctx, AV_LOG_ERROR, "Version %d needed for requested features but %d requested\n", s->version, avctx->level);
693  return AVERROR(EINVAL);
694  }
695  s->version = avctx->level;
696  }
697 
698  if (s->ec < 0) {
699  s->ec = (s->version >= 3);
700  }
701 
702  if ((s->version == 2 || s->version>3) && avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
703  av_log(avctx, AV_LOG_ERROR, "Version 2 needed for requested features but version 2 is experimental and not enabled\n");
704  return AVERROR_INVALIDDATA;
705  }
706 
707 #if FF_API_CODER_TYPE
709  if (avctx->coder_type != -1)
710  s->ac = avctx->coder_type > 0 ? AC_RANGE_CUSTOM_TAB : AC_GOLOMB_RICE;
711  else
713 #endif
714  if (s->ac == 1) // Compatbility with common command line usage
715  s->ac = AC_RANGE_CUSTOM_TAB;
716  else if (s->ac == AC_RANGE_DEFAULT_TAB_FORCE)
718 
719  s->plane_count = 3;
720  switch(avctx->pix_fmt) {
721  case AV_PIX_FMT_YUV444P9:
722  case AV_PIX_FMT_YUV422P9:
723  case AV_PIX_FMT_YUV420P9:
727  if (!avctx->bits_per_raw_sample)
728  s->bits_per_raw_sample = 9;
735  s->packed_at_lsb = 1;
736  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
737  s->bits_per_raw_sample = 10;
738  case AV_PIX_FMT_GRAY16:
745  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) {
746  s->bits_per_raw_sample = 16;
747  } else if (!s->bits_per_raw_sample) {
749  }
750  if (s->bits_per_raw_sample <= 8) {
751  av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");
752  return AVERROR_INVALIDDATA;
753  }
754  if (s->ac == AC_GOLOMB_RICE) {
755  av_log(avctx, AV_LOG_INFO,
756  "bits_per_raw_sample > 8, forcing range coder\n");
757  s->ac = AC_RANGE_CUSTOM_TAB;
758  }
759  s->version = FFMAX(s->version, 1);
760  case AV_PIX_FMT_GRAY8:
761  case AV_PIX_FMT_YA8:
762  case AV_PIX_FMT_YUV444P:
763  case AV_PIX_FMT_YUV440P:
764  case AV_PIX_FMT_YUV422P:
765  case AV_PIX_FMT_YUV420P:
766  case AV_PIX_FMT_YUV411P:
767  case AV_PIX_FMT_YUV410P:
768  case AV_PIX_FMT_YUVA444P:
769  case AV_PIX_FMT_YUVA422P:
770  case AV_PIX_FMT_YUVA420P:
771  s->chroma_planes = desc->nb_components < 3 ? 0 : 1;
772  s->colorspace = 0;
773  s->transparency = desc->nb_components == 4 || desc->nb_components == 2;
774  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
775  s->bits_per_raw_sample = 8;
776  else if (!s->bits_per_raw_sample)
777  s->bits_per_raw_sample = 8;
778  break;
779  case AV_PIX_FMT_RGB32:
780  s->colorspace = 1;
781  s->transparency = 1;
782  s->chroma_planes = 1;
783  if (!avctx->bits_per_raw_sample)
784  s->bits_per_raw_sample = 8;
785  break;
786  case AV_PIX_FMT_0RGB32:
787  s->colorspace = 1;
788  s->chroma_planes = 1;
789  if (!avctx->bits_per_raw_sample)
790  s->bits_per_raw_sample = 8;
791  break;
792  case AV_PIX_FMT_GBRP9:
793  if (!avctx->bits_per_raw_sample)
794  s->bits_per_raw_sample = 9;
795  case AV_PIX_FMT_GBRP10:
796  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
797  s->bits_per_raw_sample = 10;
798  case AV_PIX_FMT_GBRP12:
799  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
800  s->bits_per_raw_sample = 12;
801  case AV_PIX_FMT_GBRP14:
802  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
803  s->bits_per_raw_sample = 14;
804  else if (!s->bits_per_raw_sample)
806  s->colorspace = 1;
807  s->chroma_planes = 1;
808  s->version = FFMAX(s->version, 1);
809  if (s->ac == AC_GOLOMB_RICE) {
810  av_log(avctx, AV_LOG_INFO,
811  "bits_per_raw_sample > 8, forcing coder 1\n");
812  s->ac = AC_RANGE_CUSTOM_TAB;
813  }
814  break;
815  default:
816  av_log(avctx, AV_LOG_ERROR, "format not supported\n");
817  return AVERROR(ENOSYS);
818  }
820 
821  if (s->transparency) {
822  av_log(avctx, AV_LOG_WARNING, "Storing alpha plane, this will require a recent FFV1 decoder to playback!\n");
823  }
824 #if FF_API_PRIVATE_OPT
826  if (avctx->context_model)
827  s->context_model = avctx->context_model;
828  if (avctx->context_model > 1U) {
829  av_log(avctx, AV_LOG_ERROR, "Invalid context model %d, valid values are 0 and 1\n", avctx->context_model);
830  return AVERROR(EINVAL);
831  }
833 #endif
834 
835  if (s->ac == AC_RANGE_CUSTOM_TAB) {
836  for (i = 1; i < 256; i++)
837  s->state_transition[i] = ver2_state[i];
838  } else {
839  RangeCoder c;
840  ff_build_rac_states(&c, 0.05 * (1LL << 32), 256 - 8);
841  for (i = 1; i < 256; i++)
842  s->state_transition[i] = c.one_state[i];
843  }
844 
845  for (i = 0; i < 256; i++) {
846  s->quant_table_count = 2;
847  if (s->bits_per_raw_sample <= 8) {
848  s->quant_tables[0][0][i]= quant11[i];
849  s->quant_tables[0][1][i]= 11*quant11[i];
850  s->quant_tables[0][2][i]= 11*11*quant11[i];
851  s->quant_tables[1][0][i]= quant11[i];
852  s->quant_tables[1][1][i]= 11*quant11[i];
853  s->quant_tables[1][2][i]= 11*11*quant5 [i];
854  s->quant_tables[1][3][i]= 5*11*11*quant5 [i];
855  s->quant_tables[1][4][i]= 5*5*11*11*quant5 [i];
856  } else {
857  s->quant_tables[0][0][i]= quant9_10bit[i];
858  s->quant_tables[0][1][i]= 11*quant9_10bit[i];
859  s->quant_tables[0][2][i]= 11*11*quant9_10bit[i];
860  s->quant_tables[1][0][i]= quant9_10bit[i];
861  s->quant_tables[1][1][i]= 11*quant9_10bit[i];
862  s->quant_tables[1][2][i]= 11*11*quant5_10bit[i];
863  s->quant_tables[1][3][i]= 5*11*11*quant5_10bit[i];
864  s->quant_tables[1][4][i]= 5*5*11*11*quant5_10bit[i];
865  }
866  }
867  s->context_count[0] = (11 * 11 * 11 + 1) / 2;
868  s->context_count[1] = (11 * 11 * 5 * 5 * 5 + 1) / 2;
869  memcpy(s->quant_table, s->quant_tables[s->context_model],
870  sizeof(s->quant_table));
871 
872  for (i = 0; i < s->plane_count; i++) {
873  PlaneContext *const p = &s->plane[i];
874 
875  memcpy(p->quant_table, s->quant_table, sizeof(p->quant_table));
878  }
879 
880  if ((ret = ff_ffv1_allocate_initial_states(s)) < 0)
881  return ret;
882 
883 #if FF_API_CODED_FRAME
887 #endif
888 
889  if (!s->transparency)
890  s->plane_count = 2;
891  if (!s->chroma_planes && s->version > 3)
892  s->plane_count--;
893 
895  s->picture_number = 0;
896 
897  if (avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) {
898  for (i = 0; i < s->quant_table_count; i++) {
899  s->rc_stat2[i] = av_mallocz(s->context_count[i] *
900  sizeof(*s->rc_stat2[i]));
901  if (!s->rc_stat2[i])
902  return AVERROR(ENOMEM);
903  }
904  }
905  if (avctx->stats_in) {
906  char *p = avctx->stats_in;
907  uint8_t (*best_state)[256] = av_malloc_array(256, 256);
908  int gob_count = 0;
909  char *next;
910  if (!best_state)
911  return AVERROR(ENOMEM);
912 
913  av_assert0(s->version >= 2);
914 
915  for (;;) {
916  for (j = 0; j < 256; j++)
917  for (i = 0; i < 2; i++) {
918  s->rc_stat[j][i] = strtol(p, &next, 0);
919  if (next == p) {
920  av_log(avctx, AV_LOG_ERROR,
921  "2Pass file invalid at %d %d [%s]\n", j, i, p);
922  av_freep(&best_state);
923  return AVERROR_INVALIDDATA;
924  }
925  p = next;
926  }
927  for (i = 0; i < s->quant_table_count; i++)
928  for (j = 0; j < s->context_count[i]; j++) {
929  for (k = 0; k < 32; k++)
930  for (m = 0; m < 2; m++) {
931  s->rc_stat2[i][j][k][m] = strtol(p, &next, 0);
932  if (next == p) {
933  av_log(avctx, AV_LOG_ERROR,
934  "2Pass file invalid at %d %d %d %d [%s]\n",
935  i, j, k, m, p);
936  av_freep(&best_state);
937  return AVERROR_INVALIDDATA;
938  }
939  p = next;
940  }
941  }
942  gob_count = strtol(p, &next, 0);
943  if (next == p || gob_count <= 0) {
944  av_log(avctx, AV_LOG_ERROR, "2Pass file invalid\n");
945  av_freep(&best_state);
946  return AVERROR_INVALIDDATA;
947  }
948  p = next;
949  while (*p == '\n' || *p == ' ')
950  p++;
951  if (p[0] == 0)
952  break;
953  }
954  if (s->ac == AC_RANGE_CUSTOM_TAB)
955  sort_stt(s, s->state_transition);
956 
957  find_best_state(best_state, s->state_transition);
958 
959  for (i = 0; i < s->quant_table_count; i++) {
960  for (k = 0; k < 32; k++) {
961  double a=0, b=0;
962  int jp = 0;
963  for (j = 0; j < s->context_count[i]; j++) {
964  double p = 128;
965  if (s->rc_stat2[i][j][k][0] + s->rc_stat2[i][j][k][1] > 200 && j || a+b > 200) {
966  if (a+b)
967  p = 256.0 * b / (a + b);
968  s->initial_states[i][jp][k] =
969  best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];
970  for(jp++; jp<j; jp++)
971  s->initial_states[i][jp][k] = s->initial_states[i][jp-1][k];
972  a=b=0;
973  }
974  a += s->rc_stat2[i][j][k][0];
975  b += s->rc_stat2[i][j][k][1];
976  if (a+b) {
977  p = 256.0 * b / (a + b);
978  }
979  s->initial_states[i][j][k] =
980  best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];
981  }
982  }
983  }
984  av_freep(&best_state);
985  }
986 
987  if (s->version > 1) {
988  s->num_v_slices = (avctx->width > 352 || avctx->height > 288 || !avctx->slices) ? 2 : 1;
989  for (; s->num_v_slices < 9; s->num_v_slices++) {
990  for (s->num_h_slices = s->num_v_slices; s->num_h_slices < 2*s->num_v_slices; s->num_h_slices++) {
991  if (avctx->slices == s->num_h_slices * s->num_v_slices && avctx->slices <= 64 || !avctx->slices)
992  goto slices_ok;
993  }
994  }
995  av_log(avctx, AV_LOG_ERROR,
996  "Unsupported number %d of slices requested, please specify a "
997  "supported number with -slices (ex:4,6,9,12,16, ...)\n",
998  avctx->slices);
999  return AVERROR(ENOSYS);
1000 slices_ok:
1001  if ((ret = write_extradata(s)) < 0)
1002  return ret;
1003  }
1004 
1005  if ((ret = ff_ffv1_init_slice_contexts(s)) < 0)
1006  return ret;
1007  s->slice_count = s->max_slice_count;
1008  if ((ret = ff_ffv1_init_slices_state(s)) < 0)
1009  return ret;
1010 
1011 #define STATS_OUT_SIZE 1024 * 1024 * 6
1012  if (avctx->flags & AV_CODEC_FLAG_PASS1) {
1014  if (!avctx->stats_out)
1015  return AVERROR(ENOMEM);
1016  for (i = 0; i < s->quant_table_count; i++)
1017  for (j = 0; j < s->max_slice_count; j++) {
1018  FFV1Context *sf = s->slice_context[j];
1019  av_assert0(!sf->rc_stat2[i]);
1020  sf->rc_stat2[i] = av_mallocz(s->context_count[i] *
1021  sizeof(*sf->rc_stat2[i]));
1022  if (!sf->rc_stat2[i])
1023  return AVERROR(ENOMEM);
1024  }
1025  }
1026 
1027  return 0;
1028 }
1029 
1031 {
1032  RangeCoder *c = &fs->c;
1034  int j;
1035  memset(state, 128, sizeof(state));
1036 
1037  put_symbol(c, state, (fs->slice_x +1)*f->num_h_slices / f->width , 0);
1038  put_symbol(c, state, (fs->slice_y +1)*f->num_v_slices / f->height , 0);
1039  put_symbol(c, state, (fs->slice_width +1)*f->num_h_slices / f->width -1, 0);
1040  put_symbol(c, state, (fs->slice_height+1)*f->num_v_slices / f->height-1, 0);
1041  for (j=0; j<f->plane_count; j++) {
1042  put_symbol(c, state, f->plane[j].quant_table_index, 0);
1044  }
1045  if (!f->picture.f->interlaced_frame)
1046  put_symbol(c, state, 3, 0);
1047  else
1048  put_symbol(c, state, 1 + !f->picture.f->top_field_first, 0);
1049  put_symbol(c, state, f->picture.f->sample_aspect_ratio.num, 0);
1050  put_symbol(c, state, f->picture.f->sample_aspect_ratio.den, 0);
1051  if (f->version > 3) {
1052  put_rac(c, state, fs->slice_coding_mode == 1);
1053  if (fs->slice_coding_mode == 1)
1055  put_symbol(c, state, fs->slice_coding_mode, 0);
1056  if (fs->slice_coding_mode != 1) {
1057  put_symbol(c, state, fs->slice_rct_by_coef, 0);
1058  put_symbol(c, state, fs->slice_rct_ry_coef, 0);
1059  }
1060  }
1061 }
1062 
1063 static void choose_rct_params(FFV1Context *fs, const uint8_t *src[3], const int stride[3], int w, int h)
1064 {
1065 #define NB_Y_COEFF 15
1066  static const int rct_y_coeff[15][2] = {
1067  {0, 0}, // 4G
1068  {1, 1}, // R + 2G + B
1069  {2, 2}, // 2R + 2B
1070  {0, 2}, // 2G + 2B
1071  {2, 0}, // 2R + 2G
1072  {4, 0}, // 4R
1073  {0, 4}, // 4B
1074 
1075  {0, 3}, // 1G + 3B
1076  {3, 0}, // 3R + 1G
1077  {3, 1}, // 3R + B
1078  {1, 3}, // R + 3B
1079  {1, 2}, // R + G + 2B
1080  {2, 1}, // 2R + G + B
1081  {0, 1}, // 3G + B
1082  {1, 0}, // R + 3G
1083  };
1084 
1085  int stat[NB_Y_COEFF] = {0};
1086  int x, y, i, p, best;
1087  int16_t *sample[3];
1088  int lbd = fs->bits_per_raw_sample <= 8;
1089 
1090  for (y = 0; y < h; y++) {
1091  int lastr=0, lastg=0, lastb=0;
1092  for (p = 0; p < 3; p++)
1093  sample[p] = fs->sample_buffer + p*w;
1094 
1095  for (x = 0; x < w; x++) {
1096  int b, g, r;
1097  int ab, ag, ar;
1098  if (lbd) {
1099  unsigned v = *((const uint32_t*)(src[0] + x*4 + stride[0]*y));
1100  b = v & 0xFF;
1101  g = (v >> 8) & 0xFF;
1102  r = (v >> 16) & 0xFF;
1103  } else {
1104  b = *((const uint16_t*)(src[0] + x*2 + stride[0]*y));
1105  g = *((const uint16_t*)(src[1] + x*2 + stride[1]*y));
1106  r = *((const uint16_t*)(src[2] + x*2 + stride[2]*y));
1107  }
1108 
1109  ar = r - lastr;
1110  ag = g - lastg;
1111  ab = b - lastb;
1112  if (x && y) {
1113  int bg = ag - sample[0][x];
1114  int bb = ab - sample[1][x];
1115  int br = ar - sample[2][x];
1116 
1117  br -= bg;
1118  bb -= bg;
1119 
1120  for (i = 0; i<NB_Y_COEFF; i++) {
1121  stat[i] += FFABS(bg + ((br*rct_y_coeff[i][0] + bb*rct_y_coeff[i][1])>>2));
1122  }
1123 
1124  }
1125  sample[0][x] = ag;
1126  sample[1][x] = ab;
1127  sample[2][x] = ar;
1128 
1129  lastr = r;
1130  lastg = g;
1131  lastb = b;
1132  }
1133  }
1134 
1135  best = 0;
1136  for (i=1; i<NB_Y_COEFF; i++) {
1137  if (stat[i] < stat[best])
1138  best = i;
1139  }
1140 
1141  fs->slice_rct_by_coef = rct_y_coeff[best][1];
1142  fs->slice_rct_ry_coef = rct_y_coeff[best][0];
1143 }
1144 
1145 static int encode_slice(AVCodecContext *c, void *arg)
1146 {
1147  FFV1Context *fs = *(void **)arg;
1148  FFV1Context *f = fs->avctx->priv_data;
1149  int width = fs->slice_width;
1150  int height = fs->slice_height;
1151  int x = fs->slice_x;
1152  int y = fs->slice_y;
1153  const AVFrame *const p = f->picture.f;
1154  const int ps = av_pix_fmt_desc_get(c->pix_fmt)->comp[0].step;
1155  int ret;
1156  RangeCoder c_bak = fs->c;
1157  const uint8_t *planes[3] = {p->data[0] + ps*x + y*p->linesize[0],
1158  p->data[1] + ps*x + y*p->linesize[1],
1159  p->data[2] + ps*x + y*p->linesize[2]};
1160 
1161  fs->slice_coding_mode = 0;
1162  if (f->version > 3) {
1163  choose_rct_params(fs, planes, p->linesize, width, height);
1164  } else {
1165  fs->slice_rct_by_coef = 1;
1166  fs->slice_rct_ry_coef = 1;
1167  }
1168 
1169 retry:
1170  if (f->key_frame)
1172  if (f->version > 2) {
1173  encode_slice_header(f, fs);
1174  }
1175  if (fs->ac == AC_GOLOMB_RICE) {
1176  if (f->version > 2)
1177  put_rac(&fs->c, (uint8_t[]) { 129 }, 0);
1178  fs->ac_byte_count = f->version > 2 || (!x && !y) ? ff_rac_terminate(&fs->c) : 0;
1179  init_put_bits(&fs->pb,
1180  fs->c.bytestream_start + fs->ac_byte_count,
1181  fs->c.bytestream_end - fs->c.bytestream_start - fs->ac_byte_count);
1182  }
1183 
1184  if (f->colorspace == 0 && c->pix_fmt != AV_PIX_FMT_YA8) {
1185  const int chroma_width = AV_CEIL_RSHIFT(width, f->chroma_h_shift);
1186  const int chroma_height = AV_CEIL_RSHIFT(height, f->chroma_v_shift);
1187  const int cx = x >> f->chroma_h_shift;
1188  const int cy = y >> f->chroma_v_shift;
1189 
1190  ret = encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 1);
1191 
1192  if (f->chroma_planes) {
1193  ret |= encode_plane(fs, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1, 1);
1194  ret |= encode_plane(fs, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1, 1);
1195  }
1196  if (fs->transparency)
1197  ret |= encode_plane(fs, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], 2, 1);
1198  } else if (c->pix_fmt == AV_PIX_FMT_YA8) {
1199  ret = encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 2);
1200  ret |= encode_plane(fs, p->data[0] + 1 + ps*x + y*p->linesize[0], width, height, p->linesize[0], 1, 2);
1201  } else {
1202  ret = encode_rgb_frame(fs, planes, width, height, p->linesize);
1203  }
1204  emms_c();
1205 
1206  if (ret < 0) {
1207  av_assert0(fs->slice_coding_mode == 0);
1208  if (fs->version < 4 || !fs->ac) {
1209  av_log(c, AV_LOG_ERROR, "Buffer too small\n");
1210  return ret;
1211  }
1212  av_log(c, AV_LOG_DEBUG, "Coding slice as PCM\n");
1213  fs->slice_coding_mode = 1;
1214  fs->c = c_bak;
1215  goto retry;
1216  }
1217 
1218  return 0;
1219 }
1220 
1222  const AVFrame *pict, int *got_packet)
1223 {
1224  FFV1Context *f = avctx->priv_data;
1225  RangeCoder *const c = &f->slice_context[0]->c;
1226  AVFrame *const p = f->picture.f;
1227  int used_count = 0;
1228  uint8_t keystate = 128;
1229  uint8_t *buf_p;
1230  int i, ret;
1231  int64_t maxsize = AV_INPUT_BUFFER_MIN_SIZE
1232  + avctx->width*avctx->height*35LL*4;
1233 
1234  if(!pict) {
1235  if (avctx->flags & AV_CODEC_FLAG_PASS1) {
1236  int j, k, m;
1237  char *p = avctx->stats_out;
1238  char *end = p + STATS_OUT_SIZE;
1239 
1240  memset(f->rc_stat, 0, sizeof(f->rc_stat));
1241  for (i = 0; i < f->quant_table_count; i++)
1242  memset(f->rc_stat2[i], 0, f->context_count[i] * sizeof(*f->rc_stat2[i]));
1243 
1245  for (j = 0; j < f->slice_count; j++) {
1246  FFV1Context *fs = f->slice_context[j];
1247  for (i = 0; i < 256; i++) {
1248  f->rc_stat[i][0] += fs->rc_stat[i][0];
1249  f->rc_stat[i][1] += fs->rc_stat[i][1];
1250  }
1251  for (i = 0; i < f->quant_table_count; i++) {
1252  for (k = 0; k < f->context_count[i]; k++)
1253  for (m = 0; m < 32; m++) {
1254  f->rc_stat2[i][k][m][0] += fs->rc_stat2[i][k][m][0];
1255  f->rc_stat2[i][k][m][1] += fs->rc_stat2[i][k][m][1];
1256  }
1257  }
1258  }
1259 
1260  for (j = 0; j < 256; j++) {
1261  snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1262  f->rc_stat[j][0], f->rc_stat[j][1]);
1263  p += strlen(p);
1264  }
1265  snprintf(p, end - p, "\n");
1266 
1267  for (i = 0; i < f->quant_table_count; i++) {
1268  for (j = 0; j < f->context_count[i]; j++)
1269  for (m = 0; m < 32; m++) {
1270  snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1271  f->rc_stat2[i][j][m][0], f->rc_stat2[i][j][m][1]);
1272  p += strlen(p);
1273  }
1274  }
1275  snprintf(p, end - p, "%d\n", f->gob_count);
1276  }
1277  return 0;
1278  }
1279 
1280  if (f->version > 3)
1281  maxsize = AV_INPUT_BUFFER_MIN_SIZE + avctx->width*avctx->height*3LL*4;
1282 
1283  if ((ret = ff_alloc_packet2(avctx, pkt, maxsize, 0)) < 0)
1284  return ret;
1285 
1286  ff_init_range_encoder(c, pkt->data, pkt->size);
1287  ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
1288 
1289  av_frame_unref(p);
1290  if ((ret = av_frame_ref(p, pict)) < 0)
1291  return ret;
1293 
1294  if (avctx->gop_size == 0 || f->picture_number % avctx->gop_size == 0) {
1295  put_rac(c, &keystate, 1);
1296  f->key_frame = 1;
1297  f->gob_count++;
1298  write_header(f);
1299  } else {
1300  put_rac(c, &keystate, 0);
1301  f->key_frame = 0;
1302  }
1303 
1304  if (f->ac == AC_RANGE_CUSTOM_TAB) {
1305  int i;
1306  for (i = 1; i < 256; i++) {
1307  c->one_state[i] = f->state_transition[i];
1308  c->zero_state[256 - i] = 256 - c->one_state[i];
1309  }
1310  }
1311 
1312  for (i = 1; i < f->slice_count; i++) {
1313  FFV1Context *fs = f->slice_context[i];
1314  uint8_t *start = pkt->data + (pkt->size - used_count) * (int64_t)i / f->slice_count;
1315  int len = pkt->size / f->slice_count;
1316  ff_init_range_encoder(&fs->c, start, len);
1317  }
1318  avctx->execute(avctx, encode_slice, &f->slice_context[0], NULL,
1319  f->slice_count, sizeof(void *));
1320 
1321  buf_p = pkt->data;
1322  for (i = 0; i < f->slice_count; i++) {
1323  FFV1Context *fs = f->slice_context[i];
1324  int bytes;
1325 
1326  if (fs->ac != AC_GOLOMB_RICE) {
1327  uint8_t state = 129;
1328  put_rac(&fs->c, &state, 0);
1329  bytes = ff_rac_terminate(&fs->c);
1330  } else {
1331  flush_put_bits(&fs->pb); // FIXME: nicer padding
1332  bytes = fs->ac_byte_count + (put_bits_count(&fs->pb) + 7) / 8;
1333  }
1334  if (i > 0 || f->version > 2) {
1335  av_assert0(bytes < pkt->size / f->slice_count);
1336  memmove(buf_p, fs->c.bytestream_start, bytes);
1337  av_assert0(bytes < (1 << 24));
1338  AV_WB24(buf_p + bytes, bytes);
1339  bytes += 3;
1340  }
1341  if (f->ec) {
1342  unsigned v;
1343  buf_p[bytes++] = 0;
1344  v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, buf_p, bytes);
1345  AV_WL32(buf_p + bytes, v);
1346  bytes += 4;
1347  }
1348  buf_p += bytes;
1349  }
1350 
1351  if (avctx->flags & AV_CODEC_FLAG_PASS1)
1352  avctx->stats_out[0] = '\0';
1353 
1354 #if FF_API_CODED_FRAME
1356  avctx->coded_frame->key_frame = f->key_frame;
1358 #endif
1359 
1360  f->picture_number++;
1361  pkt->size = buf_p - pkt->data;
1362  pkt->pts =
1363  pkt->dts = pict->pts;
1364  pkt->flags |= AV_PKT_FLAG_KEY * f->key_frame;
1365  *got_packet = 1;
1366 
1367  return 0;
1368 }
1369 
1371 {
1372  ff_ffv1_close(avctx);
1373  return 0;
1374 }
1375 
1376 #define OFFSET(x) offsetof(FFV1Context, x)
1377 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1378 static const AVOption options[] = {
1379  { "slicecrc", "Protect slices with CRCs", OFFSET(ec), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE },
1380  { "coder", "Coder type", OFFSET(ac), AV_OPT_TYPE_INT,
1381  { .i64 = 0 }, -2, 2, VE, "coder" },
1382  { "rice", "Golomb rice", 0, AV_OPT_TYPE_CONST,
1383  { .i64 = AC_GOLOMB_RICE }, INT_MIN, INT_MAX, VE, "coder" },
1384  { "range_def", "Range with default table", 0, AV_OPT_TYPE_CONST,
1385  { .i64 = AC_RANGE_DEFAULT_TAB_FORCE }, INT_MIN, INT_MAX, VE, "coder" },
1386  { "range_tab", "Range with custom table", 0, AV_OPT_TYPE_CONST,
1387  { .i64 = AC_RANGE_CUSTOM_TAB }, INT_MIN, INT_MAX, VE, "coder" },
1388  { "ac", "Range with custom table (the ac option exists for compatibility and is deprecated)", 0, AV_OPT_TYPE_CONST,
1389  { .i64 = 1 }, INT_MIN, INT_MAX, VE, "coder" },
1390  { "context", "Context model", OFFSET(context_model), AV_OPT_TYPE_INT,
1391  { .i64 = 0 }, 0, 1, VE },
1392 
1393  { NULL }
1394 };
1395 
1396 static const AVClass ffv1_class = {
1397  .class_name = "ffv1 encoder",
1398  .item_name = av_default_item_name,
1399  .option = options,
1400  .version = LIBAVUTIL_VERSION_INT,
1401 };
1402 
1403 #if FF_API_CODER_TYPE
1404 static const AVCodecDefault ffv1_defaults[] = {
1405  { "coder", "-1" },
1406  { NULL },
1407 };
1408 #endif
1409 
1411  .name = "ffv1",
1412  .long_name = NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1413  .type = AVMEDIA_TYPE_VIDEO,
1414  .id = AV_CODEC_ID_FFV1,
1415  .priv_data_size = sizeof(FFV1Context),
1416  .init = encode_init,
1417  .encode2 = encode_frame,
1418  .close = encode_close,
1420  .pix_fmts = (const enum AVPixelFormat[]) {
1433 
1434  },
1435 #if FF_API_CODER_TYPE
1436  .defaults = ffv1_defaults,
1437 #endif
1438  .priv_class = &ffv1_class,
1439 };
static av_always_inline int fold(int diff, int bits)
Definition: ffv1.h:148
#define FF_COMPLIANCE_EXPERIMENTAL
Allow nonstandardized experimental things.
Definition: avcodec.h:2864
#define NULL
Definition: coverity.c:32
const uint8_t ff_log2_run[41]
Definition: bitstream.c:40
static const AVCodecDefault ffv1_defaults[]
Definition: ffv1enc.c:1404
#define AV_PIX_FMT_YUVA422P16
Definition: pixfmt.h:374
const char * s
Definition: avisynth_c.h:631
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
#define AV_PIX_FMT_YUVA422P9
Definition: pixfmt.h:368
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2193
This structure describes decoded (raw) audio or video data.
Definition: frame.h:180
AVOption.
Definition: opt.h:245
static void encode_slice_header(FFV1Context *f, FFV1Context *fs)
Definition: ffv1enc.c:1030
#define AV_PIX_FMT_YUVA420P10
Definition: pixfmt.h:370
8bit gray, 8bit alpha
Definition: pixfmt.h:154
int flags
Definition: ffv1.h:93
#define AV_PIX_FMT_YUVA422P10
Definition: pixfmt.h:371
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:67
misc image utilities
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:206
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
AVFrame * f
Definition: thread.h:36
int16_t quant_table[MAX_CONTEXT_INPUTS][256]
Definition: ffv1.h:69
#define LIBAVUTIL_VERSION_INT
Definition: version.h:70
int quant_table_count
Definition: ffv1.h:123
const char * g
Definition: vf_curves.c:108
const char * desc
Definition: nvenc.c:237
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
int slice_height
Definition: ffv1.h:131
#define MAX_CONTEXT_INPUTS
Definition: ffv1.h:54
int16_t * sample_buffer
Definition: ffv1.h:111
int version
Definition: ffv1.h:87
int micro_version
Definition: ffv1.h:88
uint8_t zero_state[256]
Definition: rangecoder.h:40
Range coder.
uint8_t * bytestream_end
Definition: rangecoder.h:44
int num
numerator
Definition: rational.h:44
int size
Definition: avcodec.h:1578
const char * b
Definition: vf_curves.c:109
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:354
int av_log2(unsigned v)
Definition: intmath.c:26
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1870
char * stats_in
pass2 encoding statistics input buffer Concatenated stuff from stats_out of pass1 should be placed he...
Definition: avcodec.h:2818
static av_always_inline av_flatten void put_symbol_inline(RangeCoder *c, uint8_t *state, int v, int is_signed, uint64_t rc_stat[256][2], uint64_t rc_stat2[32][2])
Definition: ffv1enc.c:184
static int ring_size(RingBuffer *ring)
Definition: async.c:105
static AVPacket pkt
uint64_t(*[MAX_QUANT_TABLES] rc_stat2)[32][2]
Definition: ffv1.h:86
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:3042
FF Video Codec 1 (a lossless codec)
static av_always_inline void predict(PredictorState *ps, float *coef, int output_enable)
Definition: aacdec.c:174
static struct @224 state
#define sample
int height
Definition: ffv1.h:89
AVCodec.
Definition: avcodec.h:3535
uint8_t one_state[256]
Definition: rangecoder.h:41
Macro definitions for various function/variable attributes.
int slice_rct_by_coef
Definition: ffv1.h:136
#define log2(x)
Definition: libm.h:404
int plane_count
Definition: ffv1.h:100
int ff_rac_terminate(RangeCoder *c)
Definition: rangecoder.c:104
static void write_quant_tables(RangeCoder *c, int16_t quant_table[MAX_CONTEXT_INPUTS][256])
Definition: ffv1enc.c:489
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:72
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
Definition: avcodec.h:978
ThreadFrame picture
Definition: ffv1.h:96
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
uint64_t rc_stat[256][2]
Definition: ffv1.h:85
PutBitContext pb
Definition: ffv1.h:84
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
Definition: pixfmt.h:102
uint8_t bits
Definition: crc.c:296
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:117
uint8_t
#define av_cold
Definition: attributes.h:82
#define av_malloc(s)
static av_noinline void put_symbol(RangeCoder *c, uint8_t *state, int v, int is_signed)
Definition: ffv1enc.c:232
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:63
AVOptions.
int8_t bias
Definition: ffv1.h:64
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
RangeCoder c
Definition: ffv1.h:82
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
Definition: frame.c:374
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:264
av_cold int ff_ffv1_common_init(AVCodecContext *avctx)
Definition: ffv1.c:42
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1757
static av_cold int encode_init(AVCodecContext *avctx)
Definition: ffv1enc.c:668
#define AV_PIX_FMT_YUVA420P9
Definition: pixfmt.h:367
#define AV_PIX_FMT_GBRP9
Definition: pixfmt.h:353
static const int8_t quant11[256]
Definition: ffv1enc.c:100
int slice_y
Definition: ffv1.h:133
uint8_t(*[MAX_QUANT_TABLES] initial_states)[32]
Definition: ffv1.h:108
av_cold int ff_ffv1_close(AVCodecContext *avctx)
Definition: ffv1.c:205
uint8_t * data
Definition: avcodec.h:1577
attribute_deprecated int context_model
Definition: avcodec.h:2700
uint8_t count
Definition: ffv1.h:65
#define ff_dlog(a,...)
static int encode_slice(AVCodecContext *c, void *arg)
Definition: ffv1enc.c:1145
static void choose_rct_params(FFV1Context *fs, const uint8_t *src[3], const int stride[3], int w, int h)
Definition: ffv1enc.c:1063
#define AV_PIX_FMT_YUV444P16
Definition: pixfmt.h:351
int interlaced_frame
The content of the picture is interlaced.
Definition: frame.h:314
VlcState * vlc_state
Definition: ffv1.h:73
ptrdiff_t size
Definition: opengl_enc.c:101
char * stats_out
pass1 encoding statistics output buffer
Definition: avcodec.h:2810
#define NB_Y_COEFF
#define AV_PIX_FMT_YUVA420P16
Definition: pixfmt.h:373
high precision timer, useful to profile code
#define AV_INPUT_BUFFER_MIN_SIZE
minimum encoding buffer size Used to avoid some checks during header writing.
Definition: avcodec.h:735
#define av_log(a,...)
static int write_extradata(FFV1Context *f)
Definition: ffv1enc.c:544
unsigned m
Definition: audioconvert.c:187
int bits_per_raw_sample
Definition: ffv1.h:119
int slice_width
Definition: ffv1.h:130
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: avcodec.h:1609
#define U(x)
Definition: vp56_arith.h:37
static int sort_stt(FFV1Context *s, uint8_t stt[256])
Definition: ffv1enc.c:620
static const uint8_t ver2_state[256]
Definition: ffv1enc.c:119
planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
Definition: pixfmt.h:187
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
av_cold int ff_ffv1_init_slices_state(FFV1Context *f)
Definition: ffv1.c:106
int16_t quant_tables[MAX_QUANT_TABLES][MAX_CONTEXT_INPUTS][256]
Definition: ffv1.h:105
av_default_item_name
#define AVERROR(e)
Definition: error.h:43
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:176
const char * r
Definition: vf_curves.c:107
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
int context_count
Definition: ffv1.h:71
#define AV_PIX_FMT_YUVA444P16
Definition: pixfmt.h:375
const char * arg
Definition: jacosubdec.c:66
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1737
uint8_t * buf
Definition: put_bits.h:38
simple assert() macros that are a bit more flexible than ISO C assert().
const char * name
Name of the codec implementation.
Definition: avcodec.h:3542
static av_always_inline av_const double round(double x)
Definition: libm.h:444
static const int8_t quant5[256]
Definition: ffv1enc.c:62
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:341
int ff_ffv1_allocate_initial_states(FFV1Context *f)
Definition: ffv1.c:162
static const uint8_t offset[127][2]
Definition: vf_spp.c:92
#define FFMAX(a, b)
Definition: common.h:94
uint8_t * bytestream
Definition: rangecoder.h:43
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:1583
static int put_bits_count(PutBitContext *s)
Definition: put_bits.h:85
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:66
static av_always_inline int encode_line(FFV1Context *s, int w, int16_t *sample[3], int plane_index, int bits)
Definition: ffv1enc.c:270
int ac
1=range coder <-> 0=golomb rice
Definition: ffv1.h:101
int16_t quant_table[MAX_CONTEXT_INPUTS][256]
Definition: ffv1.h:104
#define AC_RANGE_CUSTOM_TAB
Definition: ffv1.h:58
int run_index
Definition: ffv1.h:109
Definition: ffv1.h:61
#define AV_PIX_FMT_YUV422P9
Definition: pixfmt.h:336
#define av_flatten
Definition: attributes.h:88
static int encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pict, int *got_packet)
Definition: ffv1enc.c:1221
static av_cold int encode_close(AVCodecContext *avctx)
Definition: ffv1enc.c:1370
uint8_t state_transition[256]
Definition: ffv1.h:107
uint8_t nb_components
The number of components each pixel has, (1-4)
Definition: pixdesc.h:83
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:254
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:322
int key_frame
Definition: ffv1.h:95
#define FFMIN(a, b)
Definition: common.h:96
int num_h_slices
Definition: ffv1.h:129
int width
picture width / height.
Definition: avcodec.h:1829
int colorspace
Definition: ffv1.h:110
#define width
static float quant_table[96]
Definition: binkaudio.c:41
static int get_context(PlaneContext *p, int16_t *src, int16_t *last, int16_t *last2)
Definition: ffv1.h:170
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
Definition: avcodec.h:843
#define MAX_PLANES
Definition: ffv1.h:50
static void update_vlc_state(VlcState *const state, const int v)
Definition: ffv1.h:192
uint32_t av_crc(const AVCRC *ctx, uint32_t crc, const uint8_t *buffer, size_t length)
Calculate the CRC of a block.
Definition: crc.c:357
int slice_count
Definition: ffv1.h:126
#define AV_WB24(p, d)
Definition: intreadwrite.h:450
AVCodec ff_ffv1_encoder
Definition: ffv1enc.c:1410
int max_slice_count
Definition: ffv1.h:127
void ff_build_rac_states(RangeCoder *c, int factor, int max_p)
Definition: rangecoder.c:63
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
static int encode_rgb_frame(FFV1Context *s, const uint8_t *src[3], int w, int h, const int stride[3])
Definition: ffv1enc.c:412
int level
level
Definition: avcodec.h:3235
av_cold int ff_ffv1_init_slice_contexts(FFV1Context *f)
Definition: ffv1.c:117
#define AV_PIX_FMT_YUVA444P10
Definition: pixfmt.h:372
int ac_byte_count
number of bytes used for AC coding
Definition: ffv1.h:102
int16_t drift
Definition: ffv1.h:62
#define src
Definition: vp9dsp.c:530
void avcodec_get_chroma_sub_sample(enum AVPixelFormat pix_fmt, int *h_shift, int *v_shift)
Utility function to access log2_chroma_w log2_chroma_h from the pixel format AVPixFmtDescriptor.
Definition: imgconvert.c:38
int packed_at_lsb
Definition: ffv1.h:120
#define AV_PIX_FMT_YUV444P9
Definition: pixfmt.h:337
#define AV_PIX_FMT_GBRP14
Definition: pixfmt.h:356
attribute_deprecated int coder_type
Definition: avcodec.h:2694
#define VE
Definition: ffv1enc.c:1377
static const AVOption options[]
Definition: ffv1enc.c:1378
static const float pred[4]
Definition: siprdata.h:259
#define AV_PIX_FMT_YUV420P16
Definition: pixfmt.h:349
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: avcodec.h:1020
static void print(AVTreeNode *t, int depth)
Definition: tree-test.c:44
#define AV_LOG_INFO
Standard information.
Definition: log.h:187
int context_count[MAX_QUANT_TABLES]
Definition: ffv1.h:106
static const int8_t quant9_10bit[256]
Definition: ffv1enc.c:81
Libavcodec external API header.
#define AC_RANGE_DEFAULT_TAB_FORCE
Definition: ffv1.h:59
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:211
#define STATS_OUT_SIZE
planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
Definition: pixfmt.h:188
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:81
main external API structure.
Definition: avcodec.h:1642
#define AV_PIX_FMT_RGB32
Definition: pixfmt.h:315
int intra
Definition: ffv1.h:114
AVRational sample_aspect_ratio
Sample aspect ratio for the video frame, 0/1 if unknown/unspecified.
Definition: frame.h:259
uint8_t * buf_end
Definition: put_bits.h:38
static void find_best_state(uint8_t best_state[256][256], const uint8_t one_state[256])
Definition: ffv1enc.c:138
int extradata_size
Definition: avcodec.h:1758
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:338
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
Definition: pixfmt.h:68
static void write_quant_table(RangeCoder *c, int16_t *quant_table)
Definition: ffv1enc.c:474
Describe the class of an AVClass context structure.
Definition: log.h:67
av_cold void ff_init_range_encoder(RangeCoder *c, uint8_t *buf, int buf_size)
Definition: rangecoder.c:42
#define AC_GOLOMB_RICE
Definition: ffv1.h:56
static void put_vlc_symbol(PutBitContext *pb, VlcState *const state, int v, int bits)
Definition: ffv1enc.c:239
static int encode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index, int pixel_stride)
Definition: ffv1enc.c:372
static void set_sr_golomb(PutBitContext *pb, int i, int k, int limit, int esc_len)
write signed golomb rice code (ffv1).
Definition: golomb.h:560
int picture_number
Definition: ffv1.h:94
uint16_t error_sum
Definition: ffv1.h:63
#define AC_RANGE_DEFAULT_TAB
Definition: ffv1.h:57
static const AVClass ffv1_class
Definition: ffv1enc.c:1396
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:335
#define snprintf
Definition: snprintf.h:34
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)
Check AVPacket size and/or allocate data.
Definition: utils.c:1683
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:262
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:355
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:481
#define CONTEXT_SIZE
Definition: ffv1.h:51
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:339
int gob_count
Definition: ffv1.h:122
int quant_table_index
Definition: ffv1.h:70
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:194
#define OFFSET(x)
Definition: ffv1enc.c:1376
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:1855
const AVCRC * av_crc_get_table(AVCRCId crc_id)
Get an initialized standard CRC table.
Definition: crc.c:343
#define COST2(old, new)
GLint GLenum GLboolean GLsizei stride
Definition: opengl_enc.c:105
int context_model
Definition: ffv1.h:117
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:62
Y , 8bpp.
Definition: pixfmt.h:70
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:80
common internal api header.
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:101
static const int8_t quant5_10bit[256]
Definition: ffv1enc.c:43
static double c[64]
void ff_ffv1_clear_slice_state(FFV1Context *f, FFV1Context *fs)
Definition: ffv1.c:177
#define put_rac(C, S, B)
#define AV_PIX_FMT_YUVA444P9
Definition: pixfmt.h:369
attribute_deprecated AVFrame * coded_frame
the picture in the bitstream
Definition: avcodec.h:3063
uint8_t(* state)[CONTEXT_SIZE]
Definition: ffv1.h:72
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
Definition: pixfmt.h:69
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:48
int den
denominator
Definition: rational.h:45
int slice_coding_mode
Definition: ffv1.h:135
uint8_t * bytestream_start
Definition: rangecoder.h:42
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:728
#define AV_CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
Definition: avcodec.h:847
int slices
Number of slices.
Definition: avcodec.h:2394
void * priv_data
Definition: avcodec.h:1684
int chroma_h_shift
Definition: ffv1.h:91
PlaneContext plane[MAX_PLANES]
Definition: ffv1.h:103
int transparency
Definition: ffv1.h:92
static av_always_inline int diff(const uint32_t a, const uint32_t b)
int(* execute)(struct AVCodecContext *c, int(*func)(struct AVCodecContext *c2, void *arg), void *arg2, int *ret, int count, int size)
The codec may call this to execute several independent things.
Definition: avcodec.h:3112
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:81
int chroma_v_shift
Definition: ffv1.h:91
int top_field_first
If the content is interlaced, is top field displayed first.
Definition: frame.h:319
int len
int chroma_planes
Definition: ffv1.h:90
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:249
static void write_header(FFV1Context *f)
Definition: ffv1enc.c:497
struct FFV1Context * slice_context[MAX_SLICES]
Definition: ffv1.h:125
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: avcodec.h:1576
#define av_uninit(x)
Definition: attributes.h:149
#define av_noinline
Definition: attributes.h:62
#define av_freep(p)
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
Definition: pixfmt.h:100
void INT64 start
Definition: avisynth_c.h:553
#define av_always_inline
Definition: attributes.h:39
#define av_malloc_array(a, b)
#define FFSWAP(type, a, b)
Definition: common.h:99
int ec
Definition: ffv1.h:113
#define height
int num_v_slices
Definition: ffv1.h:128
exp golomb vlc stuff
AVPixelFormat
Pixel format.
Definition: pixfmt.h:60
This structure stores compressed data.
Definition: avcodec.h:1554
AVCodecContext * avctx
Definition: ffv1.h:81
void * av_mallocz(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Definition: mem.c:252
int strict_std_compliance
strictly follow the standard (MPEG4, ...).
Definition: avcodec.h:2859
int slice_x
Definition: ffv1.h:132
#define AV_PIX_FMT_YUV422P16
Definition: pixfmt.h:350
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1570
for(j=16;j >0;--j)
int step
Number of elements between 2 horizontally consecutive pixels.
Definition: pixdesc.h:41
int width
Definition: ffv1.h:89
#define AV_WL32(p, v)
Definition: intreadwrite.h:426
#define AV_PIX_FMT_0RGB32
Definition: pixfmt.h:319
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:58
int slice_rct_ry_coef
Definition: ffv1.h:137
bitstream writer API