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