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 
36 #include "avcodec.h"
37 #include "internal.h"
38 #include "put_bits.h"
39 #include "rangecoder.h"
40 #include "golomb.h"
41 #include "mathops.h"
42 #include "ffv1.h"
43 
44 static const int8_t quant5_10bit[256] = {
45  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
48  1, 1, 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, -2,
57  -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -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, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
60  -1, -1, -1, -1, -1, -1, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0,
61 };
62 
63 static const int8_t quant5[256] = {
64  0, 1, 1, 1, 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, -2, -2, -2,
79  -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -1, -1, -1,
80 };
81 
82 static const int8_t quant9_10bit[256] = {
83  0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2,
84  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3,
85  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
86  3, 3, 3, 3, 3, 3, 3, 3, 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, -4, -4, -4, -4, -4, -4, -4,
95  -4, -4, -4, -4, -4, -4, -4, -4, -4, -3, -3, -3, -3, -3, -3, -3,
96  -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3,
97  -3, -3, -3, -3, -3, -3, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
98  -2, -2, -2, -2, -1, -1, -1, -1, -1, -1, -1, -1, -0, -0, -0, -0,
99 };
100 
101 static const int8_t quant11[256] = {
102  0, 1, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4,
103  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
104  4, 4, 4, 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, -5, -5,
115  -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -4, -4,
116  -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4,
117  -4, -4, -4, -4, -4, -3, -3, -3, -3, -3, -3, -3, -2, -2, -2, -1,
118 };
119 
120 static const uint8_t ver2_state[256] = {
121  0, 10, 10, 10, 10, 16, 16, 16, 28, 16, 16, 29, 42, 49, 20, 49,
122  59, 25, 26, 26, 27, 31, 33, 33, 33, 34, 34, 37, 67, 38, 39, 39,
123  40, 40, 41, 79, 43, 44, 45, 45, 48, 48, 64, 50, 51, 52, 88, 52,
124  53, 74, 55, 57, 58, 58, 74, 60, 101, 61, 62, 84, 66, 66, 68, 69,
125  87, 82, 71, 97, 73, 73, 82, 75, 111, 77, 94, 78, 87, 81, 83, 97,
126  85, 83, 94, 86, 99, 89, 90, 99, 111, 92, 93, 134, 95, 98, 105, 98,
127  105, 110, 102, 108, 102, 118, 103, 106, 106, 113, 109, 112, 114, 112, 116, 125,
128  115, 116, 117, 117, 126, 119, 125, 121, 121, 123, 145, 124, 126, 131, 127, 129,
129  165, 130, 132, 138, 133, 135, 145, 136, 137, 139, 146, 141, 143, 142, 144, 148,
130  147, 155, 151, 149, 151, 150, 152, 157, 153, 154, 156, 168, 158, 162, 161, 160,
131  172, 163, 169, 164, 166, 184, 167, 170, 177, 174, 171, 173, 182, 176, 180, 178,
132  175, 189, 179, 181, 186, 183, 192, 185, 200, 187, 191, 188, 190, 197, 193, 196,
133  197, 194, 195, 196, 198, 202, 199, 201, 210, 203, 207, 204, 205, 206, 208, 214,
134  209, 211, 221, 212, 213, 215, 224, 216, 217, 218, 219, 220, 222, 228, 223, 225,
135  226, 224, 227, 229, 240, 230, 231, 232, 233, 234, 235, 236, 238, 239, 237, 242,
136  241, 243, 242, 244, 245, 246, 247, 248, 249, 250, 251, 252, 252, 253, 254, 255,
137 };
138 
139 static void find_best_state(uint8_t best_state[256][256],
140  const uint8_t one_state[256])
141 {
142  int i, j, k, m;
143  double l2tab[256];
144 
145  for (i = 1; i < 256; i++)
146  l2tab[i] = log2(i / 256.0);
147 
148  for (i = 0; i < 256; i++) {
149  double best_len[256];
150  double p = i / 256.0;
151 
152  for (j = 0; j < 256; j++)
153  best_len[j] = 1 << 30;
154 
155  for (j = FFMAX(i - 10, 1); j < FFMIN(i + 11, 256); j++) {
156  double occ[256] = { 0 };
157  double len = 0;
158  occ[j] = 1.0;
159 
160  if (!one_state[j])
161  continue;
162 
163  for (k = 0; k < 256; k++) {
164  double newocc[256] = { 0 };
165  for (m = 1; m < 256; m++)
166  if (occ[m]) {
167  len -=occ[m]*( p *l2tab[ m]
168  + (1-p)*l2tab[256-m]);
169  }
170  if (len < best_len[k]) {
171  best_len[k] = len;
172  best_state[i][k] = j;
173  }
174  for (m = 1; m < 256; m++)
175  if (occ[m]) {
176  newocc[ one_state[ m]] += occ[m] * p;
177  newocc[256 - one_state[256 - m]] += occ[m] * (1 - p);
178  }
179  memcpy(occ, newocc, sizeof(occ));
180  }
181  }
182  }
183 }
184 
186  uint8_t *state, int v,
187  int is_signed,
188  uint64_t rc_stat[256][2],
189  uint64_t rc_stat2[32][2])
190 {
191  int i;
192 
193 #define put_rac(C, S, B) \
194  do { \
195  if (rc_stat) { \
196  rc_stat[*(S)][B]++; \
197  rc_stat2[(S) - state][B]++; \
198  } \
199  put_rac(C, S, B); \
200  } while (0)
201 
202  if (v) {
203  const int a = FFABS(v);
204  const int e = av_log2(a);
205  put_rac(c, state + 0, 0);
206  if (e <= 9) {
207  for (i = 0; i < e; i++)
208  put_rac(c, state + 1 + i, 1); // 1..10
209  put_rac(c, state + 1 + i, 0);
210 
211  for (i = e - 1; i >= 0; i--)
212  put_rac(c, state + 22 + i, (a >> i) & 1); // 22..31
213 
214  if (is_signed)
215  put_rac(c, state + 11 + e, v < 0); // 11..21
216  } else {
217  for (i = 0; i < e; i++)
218  put_rac(c, state + 1 + FFMIN(i, 9), 1); // 1..10
219  put_rac(c, state + 1 + 9, 0);
220 
221  for (i = e - 1; i >= 0; i--)
222  put_rac(c, state + 22 + FFMIN(i, 9), (a >> i) & 1); // 22..31
223 
224  if (is_signed)
225  put_rac(c, state + 11 + 10, v < 0); // 11..21
226  }
227  } else {
228  put_rac(c, state + 0, 1);
229  }
230 #undef put_rac
231 }
232 
234  int v, int is_signed)
235 {
236  put_symbol_inline(c, state, v, is_signed, NULL, NULL);
237 }
238 
239 
240 static inline void put_vlc_symbol(PutBitContext *pb, VlcState *const state,
241  int v, int bits)
242 {
243  int i, k, code;
244  v = fold(v - state->bias, bits);
245 
246  i = state->count;
247  k = 0;
248  while (i < state->error_sum) { // FIXME: optimize
249  k++;
250  i += i;
251  }
252 
253  av_assert2(k <= 13);
254 
255 #if 0 // JPEG LS
256  if (k == 0 && 2 * state->drift <= -state->count)
257  code = v ^ (-1);
258  else
259  code = v;
260 #else
261  code = v ^ ((2 * state->drift + state->count) >> 31);
262 #endif
263 
264  ff_dlog(NULL, "v:%d/%d bias:%d error:%d drift:%d count:%d k:%d\n", v, code,
265  state->bias, state->error_sum, state->drift, state->count, k);
266  set_sr_golomb(pb, code, k, 12, bits);
267 
268  update_vlc_state(state, v);
269 }
270 
272  int16_t *sample[3],
273  int plane_index, int bits)
274 {
275  PlaneContext *const p = &s->plane[plane_index];
276  RangeCoder *const c = &s->c;
277  int x;
278  int run_index = s->run_index;
279  int run_count = 0;
280  int run_mode = 0;
281 
282  if (s->ac != AC_GOLOMB_RICE) {
283  if (c->bytestream_end - c->bytestream < w * 35) {
284  av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
285  return AVERROR_INVALIDDATA;
286  }
287  } else {
288  if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) < w * 4) {
289  av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
290  return AVERROR_INVALIDDATA;
291  }
292  }
293 
294  if (s->slice_coding_mode == 1) {
295  for (x = 0; x < w; x++) {
296  int i;
297  int v = sample[0][x];
298  for (i = bits-1; i>=0; i--) {
299  uint8_t state = 128;
300  put_rac(c, &state, (v>>i) & 1);
301  }
302  }
303  return 0;
304  }
305 
306  for (x = 0; x < w; x++) {
307  int diff, context;
308 
309  context = get_context(p, sample[0] + x, sample[1] + x, sample[2] + x);
310  diff = sample[0][x] - predict(sample[0] + x, sample[1] + x);
311 
312  if (context < 0) {
313  context = -context;
314  diff = -diff;
315  }
316 
317  diff = fold(diff, bits);
318 
319  if (s->ac != AC_GOLOMB_RICE) {
320  if (s->flags & AV_CODEC_FLAG_PASS1) {
321  put_symbol_inline(c, p->state[context], diff, 1, s->rc_stat,
322  s->rc_stat2[p->quant_table_index][context]);
323  } else {
324  put_symbol_inline(c, p->state[context], diff, 1, NULL, NULL);
325  }
326  } else {
327  if (context == 0)
328  run_mode = 1;
329 
330  if (run_mode) {
331  if (diff) {
332  while (run_count >= 1 << ff_log2_run[run_index]) {
333  run_count -= 1 << ff_log2_run[run_index];
334  run_index++;
335  put_bits(&s->pb, 1, 1);
336  }
337 
338  put_bits(&s->pb, 1 + ff_log2_run[run_index], run_count);
339  if (run_index)
340  run_index--;
341  run_count = 0;
342  run_mode = 0;
343  if (diff > 0)
344  diff--;
345  } else {
346  run_count++;
347  }
348  }
349 
350  ff_dlog(s->avctx, "count:%d index:%d, mode:%d, x:%d pos:%d\n",
351  run_count, run_index, run_mode, x,
352  (int)put_bits_count(&s->pb));
353 
354  if (run_mode == 0)
355  put_vlc_symbol(&s->pb, &p->vlc_state[context], diff, bits);
356  }
357  }
358  if (run_mode) {
359  while (run_count >= 1 << ff_log2_run[run_index]) {
360  run_count -= 1 << ff_log2_run[run_index];
361  run_index++;
362  put_bits(&s->pb, 1, 1);
363  }
364 
365  if (run_count)
366  put_bits(&s->pb, 1, 1);
367  }
368  s->run_index = run_index;
369 
370  return 0;
371 }
372 
373 static int encode_plane(FFV1Context *s, uint8_t *src, int w, int h,
374  int stride, int plane_index, int pixel_stride)
375 {
376  int x, y, i, ret;
377  const int ring_size = s->context_model ? 3 : 2;
378  int16_t *sample[3];
379  s->run_index = 0;
380 
381  memset(s->sample_buffer, 0, ring_size * (w + 6) * sizeof(*s->sample_buffer));
382 
383  for (y = 0; y < h; y++) {
384  for (i = 0; i < ring_size; i++)
385  sample[i] = s->sample_buffer + (w + 6) * ((h + i - y) % ring_size) + 3;
386 
387  sample[0][-1]= sample[1][0 ];
388  sample[1][ w]= sample[1][w-1];
389 // { START_TIMER
390  if (s->bits_per_raw_sample <= 8) {
391  for (x = 0; x < w; x++)
392  sample[0][x] = src[x * pixel_stride + stride * y];
393  if((ret = encode_line(s, w, sample, plane_index, 8)) < 0)
394  return ret;
395  } else {
396  if (s->packed_at_lsb) {
397  for (x = 0; x < w; x++) {
398  sample[0][x] = ((uint16_t*)(src + stride*y))[x];
399  }
400  } else {
401  for (x = 0; x < w; x++) {
402  sample[0][x] = ((uint16_t*)(src + stride*y))[x] >> (16 - s->bits_per_raw_sample);
403  }
404  }
405  if((ret = encode_line(s, w, sample, plane_index, s->bits_per_raw_sample)) < 0)
406  return ret;
407  }
408 // STOP_TIMER("encode line") }
409  }
410  return 0;
411 }
412 
413 static int encode_rgb_frame(FFV1Context *s, const uint8_t *src[3],
414  int w, int h, const int stride[3])
415 {
416  int x, y, p, i;
417  const int ring_size = s->context_model ? 3 : 2;
418  int16_t *sample[4][3];
419  int lbd = s->bits_per_raw_sample <= 8;
420  int bits = s->bits_per_raw_sample > 0 ? s->bits_per_raw_sample : 8;
421  int offset = 1 << bits;
422 
423  s->run_index = 0;
424 
425  memset(s->sample_buffer, 0, ring_size * MAX_PLANES *
426  (w + 6) * sizeof(*s->sample_buffer));
427 
428  for (y = 0; y < h; y++) {
429  for (i = 0; i < ring_size; i++)
430  for (p = 0; p < MAX_PLANES; p++)
431  sample[p][i]= s->sample_buffer + p*ring_size*(w+6) + ((h+i-y)%ring_size)*(w+6) + 3;
432 
433  for (x = 0; x < w; x++) {
434  int b, g, r, av_uninit(a);
435  if (lbd) {
436  unsigned v = *((const uint32_t*)(src[0] + x*4 + stride[0]*y));
437  b = v & 0xFF;
438  g = (v >> 8) & 0xFF;
439  r = (v >> 16) & 0xFF;
440  a = v >> 24;
441  } else {
442  b = *((const uint16_t *)(src[0] + x*2 + stride[0]*y));
443  g = *((const uint16_t *)(src[1] + x*2 + stride[1]*y));
444  r = *((const uint16_t *)(src[2] + x*2 + stride[2]*y));
445  }
446 
447  if (s->slice_coding_mode != 1) {
448  b -= g;
449  r -= g;
450  g += (b * s->slice_rct_by_coef + r * s->slice_rct_ry_coef) >> 2;
451  b += offset;
452  r += offset;
453  }
454 
455  sample[0][0][x] = g;
456  sample[1][0][x] = b;
457  sample[2][0][x] = r;
458  sample[3][0][x] = a;
459  }
460  for (p = 0; p < 3 + s->transparency; p++) {
461  int ret;
462  sample[p][0][-1] = sample[p][1][0 ];
463  sample[p][1][ w] = sample[p][1][w-1];
464  if (lbd && s->slice_coding_mode == 0)
465  ret = encode_line(s, w, sample[p], (p + 1) / 2, 9);
466  else
467  ret = encode_line(s, w, sample[p], (p + 1) / 2, bits + (s->slice_coding_mode != 1));
468  if (ret < 0)
469  return ret;
470  }
471  }
472  return 0;
473 }
474 
475 static void write_quant_table(RangeCoder *c, int16_t *quant_table)
476 {
477  int last = 0;
478  int i;
480  memset(state, 128, sizeof(state));
481 
482  for (i = 1; i < 128; i++)
483  if (quant_table[i] != quant_table[i - 1]) {
484  put_symbol(c, state, i - last - 1, 0);
485  last = i;
486  }
487  put_symbol(c, state, i - last - 1, 0);
488 }
489 
491  int16_t quant_table[MAX_CONTEXT_INPUTS][256])
492 {
493  int i;
494  for (i = 0; i < 5; i++)
496 }
497 
498 static void write_header(FFV1Context *f)
499 {
501  int i, j;
502  RangeCoder *const c = &f->slice_context[0]->c;
503 
504  memset(state, 128, sizeof(state));
505 
506  if (f->version < 2) {
507  put_symbol(c, state, f->version, 0);
508  put_symbol(c, state, f->ac, 0);
509  if (f->ac == AC_RANGE_CUSTOM_TAB) {
510  for (i = 1; i < 256; i++)
511  put_symbol(c, state,
512  f->state_transition[i] - c->one_state[i], 1);
513  }
514  put_symbol(c, state, f->colorspace, 0); //YUV cs type
515  if (f->version > 0)
516  put_symbol(c, state, f->bits_per_raw_sample, 0);
517  put_rac(c, state, f->chroma_planes);
518  put_symbol(c, state, f->chroma_h_shift, 0);
519  put_symbol(c, state, f->chroma_v_shift, 0);
520  put_rac(c, state, f->transparency);
521 
523  } else if (f->version < 3) {
524  put_symbol(c, state, f->slice_count, 0);
525  for (i = 0; i < f->slice_count; i++) {
526  FFV1Context *fs = f->slice_context[i];
527  put_symbol(c, state,
528  (fs->slice_x + 1) * f->num_h_slices / f->width, 0);
529  put_symbol(c, state,
530  (fs->slice_y + 1) * f->num_v_slices / f->height, 0);
531  put_symbol(c, state,
532  (fs->slice_width + 1) * f->num_h_slices / f->width - 1,
533  0);
534  put_symbol(c, state,
535  (fs->slice_height + 1) * f->num_v_slices / f->height - 1,
536  0);
537  for (j = 0; j < f->plane_count; j++) {
538  put_symbol(c, state, f->plane[j].quant_table_index, 0);
540  }
541  }
542  }
543 }
544 
546 {
547  RangeCoder *const c = &f->c;
549  int i, j, k;
550  uint8_t state2[32][CONTEXT_SIZE];
551  unsigned v;
552 
553  memset(state2, 128, sizeof(state2));
554  memset(state, 128, sizeof(state));
555 
556  f->avctx->extradata_size = 10000 + 4 +
557  (11 * 11 * 5 * 5 * 5 + 11 * 11 * 11) * 32;
559  if (!f->avctx->extradata)
560  return AVERROR(ENOMEM);
562  ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
563 
564  put_symbol(c, state, f->version, 0);
565  if (f->version > 2) {
566  if (f->version == 3) {
567  f->micro_version = 4;
568  } else if (f->version == 4)
569  f->micro_version = 2;
570  put_symbol(c, state, f->micro_version, 0);
571  }
572 
573  put_symbol(c, state, f->ac, 0);
574  if (f->ac == AC_RANGE_CUSTOM_TAB)
575  for (i = 1; i < 256; i++)
576  put_symbol(c, state, f->state_transition[i] - c->one_state[i], 1);
577 
578  put_symbol(c, state, f->colorspace, 0); // YUV cs type
579  put_symbol(c, state, f->bits_per_raw_sample, 0);
580  put_rac(c, state, f->chroma_planes);
581  put_symbol(c, state, f->chroma_h_shift, 0);
582  put_symbol(c, state, f->chroma_v_shift, 0);
583  put_rac(c, state, f->transparency);
584  put_symbol(c, state, f->num_h_slices - 1, 0);
585  put_symbol(c, state, f->num_v_slices - 1, 0);
586 
587  put_symbol(c, state, f->quant_table_count, 0);
588  for (i = 0; i < f->quant_table_count; i++)
590 
591  for (i = 0; i < f->quant_table_count; i++) {
592  for (j = 0; j < f->context_count[i] * CONTEXT_SIZE; j++)
593  if (f->initial_states[i] && f->initial_states[i][0][j] != 128)
594  break;
595  if (j < f->context_count[i] * CONTEXT_SIZE) {
596  put_rac(c, state, 1);
597  for (j = 0; j < f->context_count[i]; j++)
598  for (k = 0; k < CONTEXT_SIZE; k++) {
599  int pred = j ? f->initial_states[i][j - 1][k] : 128;
600  put_symbol(c, state2[k],
601  (int8_t)(f->initial_states[i][j][k] - pred), 1);
602  }
603  } else {
604  put_rac(c, state, 0);
605  }
606  }
607 
608  if (f->version > 2) {
609  put_symbol(c, state, f->ec, 0);
610  put_symbol(c, state, f->intra = (f->avctx->gop_size < 2), 0);
611  }
612 
616  f->avctx->extradata_size += 4;
617 
618  return 0;
619 }
620 
621 static int sort_stt(FFV1Context *s, uint8_t stt[256])
622 {
623  int i, i2, changed, print = 0;
624 
625  do {
626  changed = 0;
627  for (i = 12; i < 244; i++) {
628  for (i2 = i + 1; i2 < 245 && i2 < i + 4; i2++) {
629 
630 #define COST(old, new) \
631  s->rc_stat[old][0] * -log2((256 - (new)) / 256.0) + \
632  s->rc_stat[old][1] * -log2((new) / 256.0)
633 
634 #define COST2(old, new) \
635  COST(old, new) + COST(256 - (old), 256 - (new))
636 
637  double size0 = COST2(i, i) + COST2(i2, i2);
638  double sizeX = COST2(i, i2) + COST2(i2, i);
639  if (size0 - sizeX > size0*(1e-14) && i != 128 && i2 != 128) {
640  int j;
641  FFSWAP(int, stt[i], stt[i2]);
642  FFSWAP(int, s->rc_stat[i][0], s->rc_stat[i2][0]);
643  FFSWAP(int, s->rc_stat[i][1], s->rc_stat[i2][1]);
644  if (i != 256 - i2) {
645  FFSWAP(int, stt[256 - i], stt[256 - i2]);
646  FFSWAP(int, s->rc_stat[256 - i][0], s->rc_stat[256 - i2][0]);
647  FFSWAP(int, s->rc_stat[256 - i][1], s->rc_stat[256 - i2][1]);
648  }
649  for (j = 1; j < 256; j++) {
650  if (stt[j] == i)
651  stt[j] = i2;
652  else if (stt[j] == i2)
653  stt[j] = i;
654  if (i != 256 - i2) {
655  if (stt[256 - j] == 256 - i)
656  stt[256 - j] = 256 - i2;
657  else if (stt[256 - j] == 256 - i2)
658  stt[256 - j] = 256 - i;
659  }
660  }
661  print = changed = 1;
662  }
663  }
664  }
665  } while (changed);
666  return print;
667 }
668 
670 {
671  FFV1Context *s = avctx->priv_data;
673  int i, j, k, m, ret;
674 
675  if ((ret = ff_ffv1_common_init(avctx)) < 0)
676  return ret;
677 
678  s->version = 0;
679 
680  if ((avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) ||
681  avctx->slices > 1)
682  s->version = FFMAX(s->version, 2);
683 
684  // Unspecified level & slices, we choose version 1.2+ to ensure multithreaded decodability
685  if (avctx->slices == 0 && avctx->level < 0 && avctx->width * avctx->height > 720*576)
686  s->version = FFMAX(s->version, 2);
687 
688  if (avctx->level <= 0 && s->version == 2) {
689  s->version = 3;
690  }
691  if (avctx->level >= 0 && avctx->level <= 4) {
692  if (avctx->level < s->version) {
693  av_log(avctx, AV_LOG_ERROR, "Version %d needed for requested features but %d requested\n", s->version, avctx->level);
694  return AVERROR(EINVAL);
695  }
696  s->version = avctx->level;
697  }
698 
699  if (s->ec < 0) {
700  s->ec = (s->version >= 3);
701  }
702 
703  if ((s->version == 2 || s->version>3) && avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
704  av_log(avctx, AV_LOG_ERROR, "Version 2 needed for requested features but version 2 is experimental and not enabled\n");
705  return AVERROR_INVALIDDATA;
706  }
707 
708 #if FF_API_CODER_TYPE
710  if (avctx->coder_type != -1)
711  s->ac = avctx->coder_type > 0 ? AC_RANGE_CUSTOM_TAB : AC_GOLOMB_RICE;
712  else
714 #endif
715  if (s->ac == 1) // Compatbility with common command line usage
716  s->ac = AC_RANGE_CUSTOM_TAB;
717  else if (s->ac == AC_RANGE_DEFAULT_TAB_FORCE)
719 
720  s->plane_count = 3;
721  switch(avctx->pix_fmt) {
722  case AV_PIX_FMT_YUV444P9:
723  case AV_PIX_FMT_YUV422P9:
724  case AV_PIX_FMT_YUV420P9:
728  if (!avctx->bits_per_raw_sample)
729  s->bits_per_raw_sample = 9;
736  s->packed_at_lsb = 1;
737  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
738  s->bits_per_raw_sample = 10;
739  case AV_PIX_FMT_GRAY16:
746  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) {
747  s->bits_per_raw_sample = 16;
748  } else if (!s->bits_per_raw_sample) {
750  }
751  if (s->bits_per_raw_sample <= 8) {
752  av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");
753  return AVERROR_INVALIDDATA;
754  }
755  if (s->ac == AC_GOLOMB_RICE) {
756  av_log(avctx, AV_LOG_INFO,
757  "bits_per_raw_sample > 8, forcing range coder\n");
758  s->ac = AC_RANGE_CUSTOM_TAB;
759  }
760  s->version = FFMAX(s->version, 1);
761  case AV_PIX_FMT_GRAY8:
762  case AV_PIX_FMT_YA8:
763  case AV_PIX_FMT_YUV444P:
764  case AV_PIX_FMT_YUV440P:
765  case AV_PIX_FMT_YUV422P:
766  case AV_PIX_FMT_YUV420P:
767  case AV_PIX_FMT_YUV411P:
768  case AV_PIX_FMT_YUV410P:
769  case AV_PIX_FMT_YUVA444P:
770  case AV_PIX_FMT_YUVA422P:
771  case AV_PIX_FMT_YUVA420P:
772  s->chroma_planes = desc->nb_components < 3 ? 0 : 1;
773  s->colorspace = 0;
774  s->transparency = desc->nb_components == 4 || desc->nb_components == 2;
775  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
776  s->bits_per_raw_sample = 8;
777  else if (!s->bits_per_raw_sample)
778  s->bits_per_raw_sample = 8;
779  break;
780  case AV_PIX_FMT_RGB32:
781  s->colorspace = 1;
782  s->transparency = 1;
783  s->chroma_planes = 1;
784  if (!avctx->bits_per_raw_sample)
785  s->bits_per_raw_sample = 8;
786  break;
787  case AV_PIX_FMT_0RGB32:
788  s->colorspace = 1;
789  s->chroma_planes = 1;
790  if (!avctx->bits_per_raw_sample)
791  s->bits_per_raw_sample = 8;
792  break;
793  case AV_PIX_FMT_GBRP9:
794  if (!avctx->bits_per_raw_sample)
795  s->bits_per_raw_sample = 9;
796  case AV_PIX_FMT_GBRP10:
797  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
798  s->bits_per_raw_sample = 10;
799  case AV_PIX_FMT_GBRP12:
800  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
801  s->bits_per_raw_sample = 12;
802  case AV_PIX_FMT_GBRP14:
803  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
804  s->bits_per_raw_sample = 14;
805  else if (!s->bits_per_raw_sample)
807  s->colorspace = 1;
808  s->chroma_planes = 1;
809  s->version = FFMAX(s->version, 1);
810  if (s->ac == AC_GOLOMB_RICE) {
811  av_log(avctx, AV_LOG_INFO,
812  "bits_per_raw_sample > 8, forcing coder 1\n");
813  s->ac = AC_RANGE_CUSTOM_TAB;
814  }
815  break;
816  default:
817  av_log(avctx, AV_LOG_ERROR, "format not supported\n");
818  return AVERROR(ENOSYS);
819  }
821 
822  if (s->transparency) {
823  av_log(avctx, AV_LOG_WARNING, "Storing alpha plane, this will require a recent FFV1 decoder to playback!\n");
824  }
825 #if FF_API_PRIVATE_OPT
827  if (avctx->context_model)
828  s->context_model = avctx->context_model;
829  if (avctx->context_model > 1U) {
830  av_log(avctx, AV_LOG_ERROR, "Invalid context model %d, valid values are 0 and 1\n", avctx->context_model);
831  return AVERROR(EINVAL);
832  }
834 #endif
835 
836  if (s->ac == AC_RANGE_CUSTOM_TAB) {
837  for (i = 1; i < 256; i++)
838  s->state_transition[i] = ver2_state[i];
839  } else {
840  RangeCoder c;
841  ff_build_rac_states(&c, 0.05 * (1LL << 32), 256 - 8);
842  for (i = 1; i < 256; i++)
843  s->state_transition[i] = c.one_state[i];
844  }
845 
846  for (i = 0; i < 256; i++) {
847  s->quant_table_count = 2;
848  if (s->bits_per_raw_sample <= 8) {
849  s->quant_tables[0][0][i]= quant11[i];
850  s->quant_tables[0][1][i]= 11*quant11[i];
851  s->quant_tables[0][2][i]= 11*11*quant11[i];
852  s->quant_tables[1][0][i]= quant11[i];
853  s->quant_tables[1][1][i]= 11*quant11[i];
854  s->quant_tables[1][2][i]= 11*11*quant5 [i];
855  s->quant_tables[1][3][i]= 5*11*11*quant5 [i];
856  s->quant_tables[1][4][i]= 5*5*11*11*quant5 [i];
857  } else {
858  s->quant_tables[0][0][i]= quant9_10bit[i];
859  s->quant_tables[0][1][i]= 11*quant9_10bit[i];
860  s->quant_tables[0][2][i]= 11*11*quant9_10bit[i];
861  s->quant_tables[1][0][i]= quant9_10bit[i];
862  s->quant_tables[1][1][i]= 11*quant9_10bit[i];
863  s->quant_tables[1][2][i]= 11*11*quant5_10bit[i];
864  s->quant_tables[1][3][i]= 5*11*11*quant5_10bit[i];
865  s->quant_tables[1][4][i]= 5*5*11*11*quant5_10bit[i];
866  }
867  }
868  s->context_count[0] = (11 * 11 * 11 + 1) / 2;
869  s->context_count[1] = (11 * 11 * 5 * 5 * 5 + 1) / 2;
870  memcpy(s->quant_table, s->quant_tables[s->context_model],
871  sizeof(s->quant_table));
872 
873  for (i = 0; i < s->plane_count; i++) {
874  PlaneContext *const p = &s->plane[i];
875 
876  memcpy(p->quant_table, s->quant_table, sizeof(p->quant_table));
879  }
880 
881  if ((ret = ff_ffv1_allocate_initial_states(s)) < 0)
882  return ret;
883 
884 #if FF_API_CODED_FRAME
888 #endif
889 
890  if (!s->transparency)
891  s->plane_count = 2;
892  if (!s->chroma_planes && s->version > 3)
893  s->plane_count--;
894 
896  s->picture_number = 0;
897 
898  if (avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) {
899  for (i = 0; i < s->quant_table_count; i++) {
900  s->rc_stat2[i] = av_mallocz(s->context_count[i] *
901  sizeof(*s->rc_stat2[i]));
902  if (!s->rc_stat2[i])
903  return AVERROR(ENOMEM);
904  }
905  }
906  if (avctx->stats_in) {
907  char *p = avctx->stats_in;
908  uint8_t (*best_state)[256] = av_malloc_array(256, 256);
909  int gob_count = 0;
910  char *next;
911  if (!best_state)
912  return AVERROR(ENOMEM);
913 
914  av_assert0(s->version >= 2);
915 
916  for (;;) {
917  for (j = 0; j < 256; j++)
918  for (i = 0; i < 2; i++) {
919  s->rc_stat[j][i] = strtol(p, &next, 0);
920  if (next == p) {
921  av_log(avctx, AV_LOG_ERROR,
922  "2Pass file invalid at %d %d [%s]\n", j, i, p);
923  av_freep(&best_state);
924  return AVERROR_INVALIDDATA;
925  }
926  p = next;
927  }
928  for (i = 0; i < s->quant_table_count; i++)
929  for (j = 0; j < s->context_count[i]; j++) {
930  for (k = 0; k < 32; k++)
931  for (m = 0; m < 2; m++) {
932  s->rc_stat2[i][j][k][m] = strtol(p, &next, 0);
933  if (next == p) {
934  av_log(avctx, AV_LOG_ERROR,
935  "2Pass file invalid at %d %d %d %d [%s]\n",
936  i, j, k, m, p);
937  av_freep(&best_state);
938  return AVERROR_INVALIDDATA;
939  }
940  p = next;
941  }
942  }
943  gob_count = strtol(p, &next, 0);
944  if (next == p || gob_count <= 0) {
945  av_log(avctx, AV_LOG_ERROR, "2Pass file invalid\n");
946  av_freep(&best_state);
947  return AVERROR_INVALIDDATA;
948  }
949  p = next;
950  while (*p == '\n' || *p == ' ')
951  p++;
952  if (p[0] == 0)
953  break;
954  }
955  if (s->ac == AC_RANGE_CUSTOM_TAB)
956  sort_stt(s, s->state_transition);
957 
958  find_best_state(best_state, s->state_transition);
959 
960  for (i = 0; i < s->quant_table_count; i++) {
961  for (k = 0; k < 32; k++) {
962  double a=0, b=0;
963  int jp = 0;
964  for (j = 0; j < s->context_count[i]; j++) {
965  double p = 128;
966  if (s->rc_stat2[i][j][k][0] + s->rc_stat2[i][j][k][1] > 200 && j || a+b > 200) {
967  if (a+b)
968  p = 256.0 * b / (a + b);
969  s->initial_states[i][jp][k] =
970  best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];
971  for(jp++; jp<j; jp++)
972  s->initial_states[i][jp][k] = s->initial_states[i][jp-1][k];
973  a=b=0;
974  }
975  a += s->rc_stat2[i][j][k][0];
976  b += s->rc_stat2[i][j][k][1];
977  if (a+b) {
978  p = 256.0 * b / (a + b);
979  }
980  s->initial_states[i][j][k] =
981  best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];
982  }
983  }
984  }
985  av_freep(&best_state);
986  }
987 
988  if (s->version > 1) {
989  s->num_v_slices = (avctx->width > 352 || avctx->height > 288 || !avctx->slices) ? 2 : 1;
990  for (; s->num_v_slices < 9; s->num_v_slices++) {
991  for (s->num_h_slices = s->num_v_slices; s->num_h_slices < 2*s->num_v_slices; s->num_h_slices++) {
992  if (avctx->slices == s->num_h_slices * s->num_v_slices && avctx->slices <= 64 || !avctx->slices)
993  goto slices_ok;
994  }
995  }
996  av_log(avctx, AV_LOG_ERROR,
997  "Unsupported number %d of slices requested, please specify a "
998  "supported number with -slices (ex:4,6,9,12,16, ...)\n",
999  avctx->slices);
1000  return AVERROR(ENOSYS);
1001 slices_ok:
1002  if ((ret = write_extradata(s)) < 0)
1003  return ret;
1004  }
1005 
1006  if ((ret = ff_ffv1_init_slice_contexts(s)) < 0)
1007  return ret;
1008  s->slice_count = s->max_slice_count;
1009  if ((ret = ff_ffv1_init_slices_state(s)) < 0)
1010  return ret;
1011 
1012 #define STATS_OUT_SIZE 1024 * 1024 * 6
1013  if (avctx->flags & AV_CODEC_FLAG_PASS1) {
1015  if (!avctx->stats_out)
1016  return AVERROR(ENOMEM);
1017  for (i = 0; i < s->quant_table_count; i++)
1018  for (j = 0; j < s->max_slice_count; j++) {
1019  FFV1Context *sf = s->slice_context[j];
1020  av_assert0(!sf->rc_stat2[i]);
1021  sf->rc_stat2[i] = av_mallocz(s->context_count[i] *
1022  sizeof(*sf->rc_stat2[i]));
1023  if (!sf->rc_stat2[i])
1024  return AVERROR(ENOMEM);
1025  }
1026  }
1027 
1028  return 0;
1029 }
1030 
1032 {
1033  RangeCoder *c = &fs->c;
1035  int j;
1036  memset(state, 128, sizeof(state));
1037 
1038  put_symbol(c, state, (fs->slice_x +1)*f->num_h_slices / f->width , 0);
1039  put_symbol(c, state, (fs->slice_y +1)*f->num_v_slices / f->height , 0);
1040  put_symbol(c, state, (fs->slice_width +1)*f->num_h_slices / f->width -1, 0);
1041  put_symbol(c, state, (fs->slice_height+1)*f->num_v_slices / f->height-1, 0);
1042  for (j=0; j<f->plane_count; j++) {
1043  put_symbol(c, state, f->plane[j].quant_table_index, 0);
1045  }
1046  if (!f->picture.f->interlaced_frame)
1047  put_symbol(c, state, 3, 0);
1048  else
1049  put_symbol(c, state, 1 + !f->picture.f->top_field_first, 0);
1050  put_symbol(c, state, f->picture.f->sample_aspect_ratio.num, 0);
1051  put_symbol(c, state, f->picture.f->sample_aspect_ratio.den, 0);
1052  if (f->version > 3) {
1053  put_rac(c, state, fs->slice_coding_mode == 1);
1054  if (fs->slice_coding_mode == 1)
1056  put_symbol(c, state, fs->slice_coding_mode, 0);
1057  if (fs->slice_coding_mode != 1) {
1058  put_symbol(c, state, fs->slice_rct_by_coef, 0);
1059  put_symbol(c, state, fs->slice_rct_ry_coef, 0);
1060  }
1061  }
1062 }
1063 
1064 static void choose_rct_params(FFV1Context *fs, const uint8_t *src[3], const int stride[3], int w, int h)
1065 {
1066 #define NB_Y_COEFF 15
1067  static const int rct_y_coeff[15][2] = {
1068  {0, 0}, // 4G
1069  {1, 1}, // R + 2G + B
1070  {2, 2}, // 2R + 2B
1071  {0, 2}, // 2G + 2B
1072  {2, 0}, // 2R + 2G
1073  {4, 0}, // 4R
1074  {0, 4}, // 4B
1075 
1076  {0, 3}, // 1G + 3B
1077  {3, 0}, // 3R + 1G
1078  {3, 1}, // 3R + B
1079  {1, 3}, // R + 3B
1080  {1, 2}, // R + G + 2B
1081  {2, 1}, // 2R + G + B
1082  {0, 1}, // 3G + B
1083  {1, 0}, // R + 3G
1084  };
1085 
1086  int stat[NB_Y_COEFF] = {0};
1087  int x, y, i, p, best;
1088  int16_t *sample[3];
1089  int lbd = fs->bits_per_raw_sample <= 8;
1090 
1091  for (y = 0; y < h; y++) {
1092  int lastr=0, lastg=0, lastb=0;
1093  for (p = 0; p < 3; p++)
1094  sample[p] = fs->sample_buffer + p*w;
1095 
1096  for (x = 0; x < w; x++) {
1097  int b, g, r;
1098  int ab, ag, ar;
1099  if (lbd) {
1100  unsigned v = *((const uint32_t*)(src[0] + x*4 + stride[0]*y));
1101  b = v & 0xFF;
1102  g = (v >> 8) & 0xFF;
1103  r = (v >> 16) & 0xFF;
1104  } else {
1105  b = *((const uint16_t*)(src[0] + x*2 + stride[0]*y));
1106  g = *((const uint16_t*)(src[1] + x*2 + stride[1]*y));
1107  r = *((const uint16_t*)(src[2] + x*2 + stride[2]*y));
1108  }
1109 
1110  ar = r - lastr;
1111  ag = g - lastg;
1112  ab = b - lastb;
1113  if (x && y) {
1114  int bg = ag - sample[0][x];
1115  int bb = ab - sample[1][x];
1116  int br = ar - sample[2][x];
1117 
1118  br -= bg;
1119  bb -= bg;
1120 
1121  for (i = 0; i<NB_Y_COEFF; i++) {
1122  stat[i] += FFABS(bg + ((br*rct_y_coeff[i][0] + bb*rct_y_coeff[i][1])>>2));
1123  }
1124 
1125  }
1126  sample[0][x] = ag;
1127  sample[1][x] = ab;
1128  sample[2][x] = ar;
1129 
1130  lastr = r;
1131  lastg = g;
1132  lastb = b;
1133  }
1134  }
1135 
1136  best = 0;
1137  for (i=1; i<NB_Y_COEFF; i++) {
1138  if (stat[i] < stat[best])
1139  best = i;
1140  }
1141 
1142  fs->slice_rct_by_coef = rct_y_coeff[best][1];
1143  fs->slice_rct_ry_coef = rct_y_coeff[best][0];
1144 }
1145 
1146 static int encode_slice(AVCodecContext *c, void *arg)
1147 {
1148  FFV1Context *fs = *(void **)arg;
1149  FFV1Context *f = fs->avctx->priv_data;
1150  int width = fs->slice_width;
1151  int height = fs->slice_height;
1152  int x = fs->slice_x;
1153  int y = fs->slice_y;
1154  const AVFrame *const p = f->picture.f;
1155  const int ps = av_pix_fmt_desc_get(c->pix_fmt)->comp[0].step;
1156  int ret;
1157  RangeCoder c_bak = fs->c;
1158  const uint8_t *planes[3] = {p->data[0] + ps*x + y*p->linesize[0],
1159  p->data[1] + ps*x + y*p->linesize[1],
1160  p->data[2] + ps*x + y*p->linesize[2]};
1161 
1162  fs->slice_coding_mode = 0;
1163  if (f->version > 3) {
1164  choose_rct_params(fs, planes, p->linesize, width, height);
1165  } else {
1166  fs->slice_rct_by_coef = 1;
1167  fs->slice_rct_ry_coef = 1;
1168  }
1169 
1170 retry:
1171  if (f->key_frame)
1173  if (f->version > 2) {
1174  encode_slice_header(f, fs);
1175  }
1176  if (fs->ac == AC_GOLOMB_RICE) {
1177  if (f->version > 2)
1178  put_rac(&fs->c, (uint8_t[]) { 129 }, 0);
1179  fs->ac_byte_count = f->version > 2 || (!x && !y) ? ff_rac_terminate(&fs->c) : 0;
1180  init_put_bits(&fs->pb,
1181  fs->c.bytestream_start + fs->ac_byte_count,
1182  fs->c.bytestream_end - fs->c.bytestream_start - fs->ac_byte_count);
1183  }
1184 
1185  if (f->colorspace == 0 && c->pix_fmt != AV_PIX_FMT_YA8) {
1186  const int chroma_width = AV_CEIL_RSHIFT(width, f->chroma_h_shift);
1187  const int chroma_height = AV_CEIL_RSHIFT(height, f->chroma_v_shift);
1188  const int cx = x >> f->chroma_h_shift;
1189  const int cy = y >> f->chroma_v_shift;
1190 
1191  ret = encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 1);
1192 
1193  if (f->chroma_planes) {
1194  ret |= encode_plane(fs, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1, 1);
1195  ret |= encode_plane(fs, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1, 1);
1196  }
1197  if (fs->transparency)
1198  ret |= encode_plane(fs, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], 2, 1);
1199  } else if (c->pix_fmt == AV_PIX_FMT_YA8) {
1200  ret = encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 2);
1201  ret |= encode_plane(fs, p->data[0] + 1 + ps*x + y*p->linesize[0], width, height, p->linesize[0], 1, 2);
1202  } else {
1203  ret = encode_rgb_frame(fs, planes, width, height, p->linesize);
1204  }
1205  emms_c();
1206 
1207  if (ret < 0) {
1208  av_assert0(fs->slice_coding_mode == 0);
1209  if (fs->version < 4 || !fs->ac) {
1210  av_log(c, AV_LOG_ERROR, "Buffer too small\n");
1211  return ret;
1212  }
1213  av_log(c, AV_LOG_DEBUG, "Coding slice as PCM\n");
1214  fs->slice_coding_mode = 1;
1215  fs->c = c_bak;
1216  goto retry;
1217  }
1218 
1219  return 0;
1220 }
1221 
1223  const AVFrame *pict, int *got_packet)
1224 {
1225  FFV1Context *f = avctx->priv_data;
1226  RangeCoder *const c = &f->slice_context[0]->c;
1227  AVFrame *const p = f->picture.f;
1228  int used_count = 0;
1229  uint8_t keystate = 128;
1230  uint8_t *buf_p;
1231  int i, ret;
1232  int64_t maxsize = AV_INPUT_BUFFER_MIN_SIZE
1233  + avctx->width*avctx->height*35LL*4;
1234 
1235  if(!pict) {
1236  if (avctx->flags & AV_CODEC_FLAG_PASS1) {
1237  int j, k, m;
1238  char *p = avctx->stats_out;
1239  char *end = p + STATS_OUT_SIZE;
1240 
1241  memset(f->rc_stat, 0, sizeof(f->rc_stat));
1242  for (i = 0; i < f->quant_table_count; i++)
1243  memset(f->rc_stat2[i], 0, f->context_count[i] * sizeof(*f->rc_stat2[i]));
1244 
1246  for (j = 0; j < f->slice_count; j++) {
1247  FFV1Context *fs = f->slice_context[j];
1248  for (i = 0; i < 256; i++) {
1249  f->rc_stat[i][0] += fs->rc_stat[i][0];
1250  f->rc_stat[i][1] += fs->rc_stat[i][1];
1251  }
1252  for (i = 0; i < f->quant_table_count; i++) {
1253  for (k = 0; k < f->context_count[i]; k++)
1254  for (m = 0; m < 32; m++) {
1255  f->rc_stat2[i][k][m][0] += fs->rc_stat2[i][k][m][0];
1256  f->rc_stat2[i][k][m][1] += fs->rc_stat2[i][k][m][1];
1257  }
1258  }
1259  }
1260 
1261  for (j = 0; j < 256; j++) {
1262  snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1263  f->rc_stat[j][0], f->rc_stat[j][1]);
1264  p += strlen(p);
1265  }
1266  snprintf(p, end - p, "\n");
1267 
1268  for (i = 0; i < f->quant_table_count; i++) {
1269  for (j = 0; j < f->context_count[i]; j++)
1270  for (m = 0; m < 32; m++) {
1271  snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1272  f->rc_stat2[i][j][m][0], f->rc_stat2[i][j][m][1]);
1273  p += strlen(p);
1274  }
1275  }
1276  snprintf(p, end - p, "%d\n", f->gob_count);
1277  }
1278  return 0;
1279  }
1280 
1281  if (f->version > 3)
1282  maxsize = AV_INPUT_BUFFER_MIN_SIZE + avctx->width*avctx->height*3LL*4;
1283 
1284  if ((ret = ff_alloc_packet2(avctx, pkt, maxsize, 0)) < 0)
1285  return ret;
1286 
1287  ff_init_range_encoder(c, pkt->data, pkt->size);
1288  ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
1289 
1290  av_frame_unref(p);
1291  if ((ret = av_frame_ref(p, pict)) < 0)
1292  return ret;
1293 #if FF_API_CODED_FRAME
1297 #endif
1298 
1299  if (avctx->gop_size == 0 || f->picture_number % avctx->gop_size == 0) {
1300  put_rac(c, &keystate, 1);
1301  f->key_frame = 1;
1302  f->gob_count++;
1303  write_header(f);
1304  } else {
1305  put_rac(c, &keystate, 0);
1306  f->key_frame = 0;
1307  }
1308 
1309  if (f->ac == AC_RANGE_CUSTOM_TAB) {
1310  int i;
1311  for (i = 1; i < 256; i++) {
1312  c->one_state[i] = f->state_transition[i];
1313  c->zero_state[256 - i] = 256 - c->one_state[i];
1314  }
1315  }
1316 
1317  for (i = 1; i < f->slice_count; i++) {
1318  FFV1Context *fs = f->slice_context[i];
1319  uint8_t *start = pkt->data + (pkt->size - used_count) * (int64_t)i / f->slice_count;
1320  int len = pkt->size / f->slice_count;
1321  ff_init_range_encoder(&fs->c, start, len);
1322  }
1323  avctx->execute(avctx, encode_slice, &f->slice_context[0], NULL,
1324  f->slice_count, sizeof(void *));
1325 
1326  buf_p = pkt->data;
1327  for (i = 0; i < f->slice_count; i++) {
1328  FFV1Context *fs = f->slice_context[i];
1329  int bytes;
1330 
1331  if (fs->ac != AC_GOLOMB_RICE) {
1332  uint8_t state = 129;
1333  put_rac(&fs->c, &state, 0);
1334  bytes = ff_rac_terminate(&fs->c);
1335  } else {
1336  flush_put_bits(&fs->pb); // FIXME: nicer padding
1337  bytes = fs->ac_byte_count + (put_bits_count(&fs->pb) + 7) / 8;
1338  }
1339  if (i > 0 || f->version > 2) {
1340  av_assert0(bytes < pkt->size / f->slice_count);
1341  memmove(buf_p, fs->c.bytestream_start, bytes);
1342  av_assert0(bytes < (1 << 24));
1343  AV_WB24(buf_p + bytes, bytes);
1344  bytes += 3;
1345  }
1346  if (f->ec) {
1347  unsigned v;
1348  buf_p[bytes++] = 0;
1349  v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, buf_p, bytes);
1350  AV_WL32(buf_p + bytes, v);
1351  bytes += 4;
1352  }
1353  buf_p += bytes;
1354  }
1355 
1356  if (avctx->flags & AV_CODEC_FLAG_PASS1)
1357  avctx->stats_out[0] = '\0';
1358 
1359 #if FF_API_CODED_FRAME
1361  avctx->coded_frame->key_frame = f->key_frame;
1363 #endif
1364 
1365  f->picture_number++;
1366  pkt->size = buf_p - pkt->data;
1367  pkt->pts =
1368  pkt->dts = pict->pts;
1369  pkt->flags |= AV_PKT_FLAG_KEY * f->key_frame;
1370  *got_packet = 1;
1371 
1372  return 0;
1373 }
1374 
1376 {
1377  ff_ffv1_close(avctx);
1378  return 0;
1379 }
1380 
1381 #define OFFSET(x) offsetof(FFV1Context, x)
1382 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1383 static const AVOption options[] = {
1384  { "slicecrc", "Protect slices with CRCs", OFFSET(ec), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE },
1385  { "coder", "Coder type", OFFSET(ac), AV_OPT_TYPE_INT,
1386  { .i64 = 0 }, -2, 2, VE, "coder" },
1387  { "rice", "Golomb rice", 0, AV_OPT_TYPE_CONST,
1388  { .i64 = AC_GOLOMB_RICE }, INT_MIN, INT_MAX, VE, "coder" },
1389  { "range_def", "Range with default table", 0, AV_OPT_TYPE_CONST,
1390  { .i64 = AC_RANGE_DEFAULT_TAB_FORCE }, INT_MIN, INT_MAX, VE, "coder" },
1391  { "range_tab", "Range with custom table", 0, AV_OPT_TYPE_CONST,
1392  { .i64 = AC_RANGE_CUSTOM_TAB }, INT_MIN, INT_MAX, VE, "coder" },
1393  { "ac", "Range with custom table (the ac option exists for compatibility and is deprecated)", 0, AV_OPT_TYPE_CONST,
1394  { .i64 = 1 }, INT_MIN, INT_MAX, VE, "coder" },
1395  { "context", "Context model", OFFSET(context_model), AV_OPT_TYPE_INT,
1396  { .i64 = 0 }, 0, 1, VE },
1397 
1398  { NULL }
1399 };
1400 
1401 static const AVClass ffv1_class = {
1402  .class_name = "ffv1 encoder",
1403  .item_name = av_default_item_name,
1404  .option = options,
1405  .version = LIBAVUTIL_VERSION_INT,
1406 };
1407 
1408 #if FF_API_CODER_TYPE
1409 static const AVCodecDefault ffv1_defaults[] = {
1410  { "coder", "-1" },
1411  { NULL },
1412 };
1413 #endif
1414 
1416  .name = "ffv1",
1417  .long_name = NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1418  .type = AVMEDIA_TYPE_VIDEO,
1419  .id = AV_CODEC_ID_FFV1,
1420  .priv_data_size = sizeof(FFV1Context),
1421  .init = encode_init,
1422  .encode2 = encode_frame,
1423  .close = encode_close,
1425  .pix_fmts = (const enum AVPixelFormat[]) {
1438 
1439  },
1440 #if FF_API_CODER_TYPE
1441  .defaults = ffv1_defaults,
1442 #endif
1443  .priv_class = &ffv1_class,
1444 };
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:2879
#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:1409
#define AV_PIX_FMT_YUVA422P16
Definition: pixfmt.h:380
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:374
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2263
This structure describes decoded (raw) audio or video data.
Definition: frame.h:184
AVOption.
Definition: opt.h:245
static void encode_slice_header(FFV1Context *f, FFV1Context *fs)
Definition: ffv1enc.c:1031
#define AV_PIX_FMT_YUVA420P10
Definition: pixfmt.h:376
8 bits gray, 8 bits alpha
Definition: pixfmt.h:154
int flags
Definition: ffv1.h:93
#define AV_PIX_FMT_YUVA422P10
Definition: pixfmt.h:377
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:112
const char * desc
Definition: nvenc.c:89
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:1589
const char * b
Definition: vf_curves.c:113
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:359
int av_log2(unsigned v)
Definition: intmath.c:26
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1885
char * stats_in
pass2 encoding statistics input buffer Concatenated stuff from stats_out of pass1 should be placed he...
Definition: avcodec.h:2833
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:185
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:3057
FF Video Codec 1 (a lossless codec)
static av_always_inline void predict(PredictorState *ps, float *coef, int output_enable)
Definition: aacdec.c:174
#define sample
int height
Definition: ffv1.h:89
AVCodec.
Definition: avcodec.h:3559
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:490
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:981
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:233
#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:268
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:1772
static av_cold int encode_init(AVCodecContext *avctx)
Definition: ffv1enc.c:669
#define AV_PIX_FMT_YUVA420P9
Definition: pixfmt.h:373
#define AV_PIX_FMT_GBRP9
Definition: pixfmt.h:358
static const int8_t quant11[256]
Definition: ffv1enc.c:101
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
#define height
uint8_t * data
Definition: avcodec.h:1588
attribute_deprecated int context_model
Definition: avcodec.h:2715
uint8_t count
Definition: ffv1.h:65
#define ff_dlog(a,...)
static int encode_slice(AVCodecContext *c, void *arg)
Definition: ffv1enc.c:1146
static void choose_rct_params(FFV1Context *fs, const uint8_t *src[3], const int stride[3], int w, int h)
Definition: ffv1enc.c:1064
#define AV_PIX_FMT_YUV444P16
Definition: pixfmt.h:356
int interlaced_frame
The content of the picture is interlaced.
Definition: frame.h:318
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:2825
#define NB_Y_COEFF
#define AV_PIX_FMT_YUVA420P16
Definition: pixfmt.h:379
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:738
#define av_log(a,...)
static int write_extradata(FFV1Context *f)
Definition: ffv1enc.c:545
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:1620
#define U(x)
Definition: vp56_arith.h:37
static int sort_stt(FFV1Context *s, uint8_t stt[256])
Definition: ffv1enc.c:621
static const uint8_t ver2_state[256]
Definition: ffv1enc.c:120
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:111
#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:381
const char * arg
Definition: jacosubdec.c:66
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1752
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:3566
static av_always_inline av_const double round(double x)
Definition: libm.h:444
static const int8_t quant5[256]
Definition: ffv1enc.c:63
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:346
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:1594
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:271
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:341
#define av_flatten
Definition: attributes.h:88
static int encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pict, int *got_packet)
Definition: ffv1enc.c:1222
static av_cold int encode_close(AVCodecContext *avctx)
Definition: ffv1enc.c:1375
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:258
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:327
int key_frame
Definition: ffv1.h:95
#define FFMIN(a, b)
Definition: common.h:96
int num_h_slices
Definition: ffv1.h:129
#define width
int width
picture width / height.
Definition: avcodec.h:1844
int colorspace
Definition: ffv1.h:110
static float quant_table[96]
Definition: binkaudio.c:42
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:846
#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:1415
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:413
int level
level
Definition: avcodec.h:3259
av_cold int ff_ffv1_init_slice_contexts(FFV1Context *f)
Definition: ffv1.c:117
#define AV_PIX_FMT_YUVA444P10
Definition: pixfmt.h:378
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:342
#define AV_PIX_FMT_GBRP14
Definition: pixfmt.h:361
attribute_deprecated int coder_type
Definition: avcodec.h:2709
#define VE
Definition: ffv1enc.c:1382
static const AVOption options[]
Definition: ffv1enc.c:1383
static const float pred[4]
Definition: siprdata.h:259
#define AV_PIX_FMT_YUV420P16
Definition: pixfmt.h:354
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: avcodec.h:1023
#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:82
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:215
#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:1657
#define AV_PIX_FMT_RGB32
Definition: pixfmt.h:320
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:263
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:139
int extradata_size
Definition: avcodec.h:1773
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:343
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:475
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:240
static int encode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index, int pixel_stride)
Definition: ffv1enc.c:373
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:554
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:1401
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:340
#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:1690
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:262
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:360
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:484
#define CONTEXT_SIZE
Definition: ffv1.h:51
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:344
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:198
#define OFFSET(x)
Definition: ffv1enc.c:1381
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:1870
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:44
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:375
attribute_deprecated AVFrame * coded_frame
the picture in the bitstream
Definition: avcodec.h:3078
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:731
#define AV_CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
Definition: avcodec.h:850
int slices
Number of slices.
Definition: avcodec.h:2409
void * priv_data
Definition: avcodec.h:1699
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:3127
#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:323
int len
int chroma_planes
Definition: ffv1.h:90
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:253
static void write_header(FFV1Context *f)
Definition: ffv1enc.c:498
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:1587
#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
static struct @230 state
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:1565
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 (MPEG-4, ...).
Definition: avcodec.h:2874
static void print(AVTreeNode *t, int depth)
Definition: tree.c:44
int slice_x
Definition: ffv1.h:132
#define AV_PIX_FMT_YUV422P16
Definition: pixfmt.h:355
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1581
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:324
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:58
int slice_rct_ry_coef
Definition: ffv1.h:137
bitstream writer API