FFmpeg
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/mem.h"
32 #include "libavutil/opt.h"
33 #include "libavutil/pixdesc.h"
34 
35 #include "avcodec.h"
36 #include "encode.h"
37 #include "codec_internal.h"
38 #include "put_bits.h"
39 #include "put_golomb.h"
40 #include "rangecoder.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  uint32_t l2tab[256];
143 
144  for (i = 1; i < 256; i++)
145  l2tab[i] = -log2(i / 256.0) * ((1U << 31) / 8);
146 
147  for (i = 0; i < 256; i++) {
148  uint64_t best_len[256];
149 
150  for (j = 0; j < 256; j++)
151  best_len[j] = UINT64_MAX;
152 
153  for (j = FFMAX(i - 10, 1); j < FFMIN(i + 11, 256); j++) {
154  uint32_t occ[256] = { 0 };
155  uint64_t len = 0;
156  occ[j] = UINT32_MAX;
157 
158  if (!one_state[j])
159  continue;
160 
161  for (k = 0; k < 256; k++) {
162  uint32_t newocc[256] = { 0 };
163  for (m = 1; m < 256; m++)
164  if (occ[m]) {
165  len += (occ[m]*(( i *(uint64_t)l2tab[ m]
166  + (256-i)*(uint64_t)l2tab[256-m])>>8)) >> 8;
167  }
168  if (len < best_len[k]) {
169  best_len[k] = len;
170  best_state[i][k] = j;
171  }
172  for (m = 1; m < 256; m++)
173  if (occ[m]) {
174  newocc[ one_state[ m]] += occ[m] * (uint64_t) i >> 8;
175  newocc[256 - one_state[256 - m]] += occ[m] * (uint64_t)(256 - i) >> 8;
176  }
177  memcpy(occ, newocc, sizeof(occ));
178  }
179  }
180  }
181 }
182 
183 static av_always_inline av_flatten void put_symbol_inline(RangeCoder *c,
184  uint8_t *state, int v,
185  int is_signed,
186  uint64_t rc_stat[256][2],
187  uint64_t rc_stat2[32][2])
188 {
189  int i;
190 
191 #define put_rac(C, S, B) \
192  do { \
193  if (rc_stat) { \
194  rc_stat[*(S)][B]++; \
195  rc_stat2[(S) - state][B]++; \
196  } \
197  put_rac(C, S, B); \
198  } while (0)
199 
200  if (v) {
201  const int a = FFABS(v);
202  const int e = av_log2(a);
203  put_rac(c, state + 0, 0);
204  if (e <= 9) {
205  for (i = 0; i < e; i++)
206  put_rac(c, state + 1 + i, 1); // 1..10
207  put_rac(c, state + 1 + i, 0);
208 
209  for (i = e - 1; i >= 0; i--)
210  put_rac(c, state + 22 + i, (a >> i) & 1); // 22..31
211 
212  if (is_signed)
213  put_rac(c, state + 11 + e, v < 0); // 11..21
214  } else {
215  for (i = 0; i < e; i++)
216  put_rac(c, state + 1 + FFMIN(i, 9), 1); // 1..10
217  put_rac(c, state + 1 + 9, 0);
218 
219  for (i = e - 1; i >= 0; i--)
220  put_rac(c, state + 22 + FFMIN(i, 9), (a >> i) & 1); // 22..31
221 
222  if (is_signed)
223  put_rac(c, state + 11 + 10, v < 0); // 11..21
224  }
225  } else {
226  put_rac(c, state + 0, 1);
227  }
228 #undef put_rac
229 }
230 
231 static av_noinline void put_symbol(RangeCoder *c, uint8_t *state,
232  int v, int is_signed)
233 {
234  put_symbol_inline(c, state, v, is_signed, NULL, NULL);
235 }
236 
237 
238 static inline void put_vlc_symbol(PutBitContext *pb, VlcState *const state,
239  int v, int bits)
240 {
241  int i, k, code;
242  v = fold(v - state->bias, bits);
243 
244  i = state->count;
245  k = 0;
246  while (i < state->error_sum) { // FIXME: optimize
247  k++;
248  i += i;
249  }
250 
251  av_assert2(k <= 13);
252 
253  code = v ^ ((2 * state->drift + state->count) >> 31);
254 
255  ff_dlog(NULL, "v:%d/%d bias:%d error:%d drift:%d count:%d k:%d\n", v, code,
256  state->bias, state->error_sum, state->drift, state->count, k);
257  set_sr_golomb(pb, code, k, 12, bits);
258 
259  update_vlc_state(state, v);
260 }
261 
262 #define TYPE int16_t
263 #define RENAME(name) name
264 #include "ffv1enc_template.c"
265 #undef TYPE
266 #undef RENAME
267 
268 #define TYPE int32_t
269 #define RENAME(name) name ## 32
270 #include "ffv1enc_template.c"
271 
272 static int encode_plane(FFV1Context *s, const uint8_t *src, int w, int h,
273  int stride, int plane_index, int pixel_stride)
274 {
275  int x, y, i, ret;
276  const int ring_size = s->context_model ? 3 : 2;
277  int16_t *sample[3];
278  s->run_index = 0;
279 
280  memset(s->sample_buffer, 0, ring_size * (w + 6) * sizeof(*s->sample_buffer));
281 
282  for (y = 0; y < h; y++) {
283  for (i = 0; i < ring_size; i++)
284  sample[i] = s->sample_buffer + (w + 6) * ((h + i - y) % ring_size) + 3;
285 
286  sample[0][-1]= sample[1][0 ];
287  sample[1][ w]= sample[1][w-1];
288  if (s->bits_per_raw_sample <= 8) {
289  for (x = 0; x < w; x++)
290  sample[0][x] = src[x * pixel_stride + stride * y];
291  if((ret = encode_line(s, w, sample, plane_index, 8)) < 0)
292  return ret;
293  } else {
294  if (s->packed_at_lsb) {
295  for (x = 0; x < w; x++) {
296  sample[0][x] = ((uint16_t*)(src + stride*y))[x];
297  }
298  } else {
299  for (x = 0; x < w; x++) {
300  sample[0][x] = ((uint16_t*)(src + stride*y))[x] >> (16 - s->bits_per_raw_sample);
301  }
302  }
303  if((ret = encode_line(s, w, sample, plane_index, s->bits_per_raw_sample)) < 0)
304  return ret;
305  }
306  }
307  return 0;
308 }
309 
310 static void write_quant_table(RangeCoder *c, int16_t *quant_table)
311 {
312  int last = 0;
313  int i;
314  uint8_t state[CONTEXT_SIZE];
315  memset(state, 128, sizeof(state));
316 
317  for (i = 1; i < 128; i++)
318  if (quant_table[i] != quant_table[i - 1]) {
319  put_symbol(c, state, i - last - 1, 0);
320  last = i;
321  }
322  put_symbol(c, state, i - last - 1, 0);
323 }
324 
325 static void write_quant_tables(RangeCoder *c,
326  int16_t quant_table[MAX_CONTEXT_INPUTS][256])
327 {
328  int i;
329  for (i = 0; i < 5; i++)
330  write_quant_table(c, quant_table[i]);
331 }
332 
333 static int contains_non_128(uint8_t (*initial_state)[CONTEXT_SIZE],
334  int nb_contexts)
335 {
336  if (!initial_state)
337  return 0;
338  for (int i = 0; i < nb_contexts; i++)
339  for (int j = 0; j < CONTEXT_SIZE; j++)
340  if (initial_state[i][j] != 128)
341  return 1;
342  return 0;
343 }
344 
345 static void write_header(FFV1Context *f)
346 {
347  uint8_t state[CONTEXT_SIZE];
348  int i, j;
349  RangeCoder *const c = &f->slice_context[0]->c;
350 
351  memset(state, 128, sizeof(state));
352 
353  if (f->version < 2) {
354  put_symbol(c, state, f->version, 0);
355  put_symbol(c, state, f->ac, 0);
356  if (f->ac == AC_RANGE_CUSTOM_TAB) {
357  for (i = 1; i < 256; i++)
358  put_symbol(c, state,
359  f->state_transition[i] - c->one_state[i], 1);
360  }
361  put_symbol(c, state, f->colorspace, 0); //YUV cs type
362  if (f->version > 0)
363  put_symbol(c, state, f->bits_per_raw_sample, 0);
364  put_rac(c, state, f->chroma_planes);
365  put_symbol(c, state, f->chroma_h_shift, 0);
366  put_symbol(c, state, f->chroma_v_shift, 0);
367  put_rac(c, state, f->transparency);
368 
369  write_quant_tables(c, f->quant_table);
370  } else if (f->version < 3) {
371  put_symbol(c, state, f->slice_count, 0);
372  for (i = 0; i < f->slice_count; i++) {
373  FFV1Context *fs = f->slice_context[i];
374  put_symbol(c, state,
375  (fs->slice_x + 1) * f->num_h_slices / f->width, 0);
376  put_symbol(c, state,
377  (fs->slice_y + 1) * f->num_v_slices / f->height, 0);
378  put_symbol(c, state,
379  (fs->slice_width + 1) * f->num_h_slices / f->width - 1,
380  0);
381  put_symbol(c, state,
382  (fs->slice_height + 1) * f->num_v_slices / f->height - 1,
383  0);
384  for (j = 0; j < f->plane_count; j++) {
385  put_symbol(c, state, f->plane[j].quant_table_index, 0);
386  av_assert0(f->plane[j].quant_table_index == f->context_model);
387  }
388  }
389  }
390 }
391 
392 static int write_extradata(FFV1Context *f)
393 {
394  RangeCoder *const c = &f->c;
395  uint8_t state[CONTEXT_SIZE];
396  int i, j, k;
397  uint8_t state2[32][CONTEXT_SIZE];
398  unsigned v;
399 
400  memset(state2, 128, sizeof(state2));
401  memset(state, 128, sizeof(state));
402 
403  f->avctx->extradata_size = 10000 + 4 +
404  (11 * 11 * 5 * 5 * 5 + 11 * 11 * 11) * 32;
405  f->avctx->extradata = av_malloc(f->avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
406  if (!f->avctx->extradata)
407  return AVERROR(ENOMEM);
408  ff_init_range_encoder(c, f->avctx->extradata, f->avctx->extradata_size);
409  ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
410 
411  put_symbol(c, state, f->version, 0);
412  if (f->version > 2) {
413  if (f->version == 3) {
414  f->micro_version = 4;
415  } else if (f->version == 4)
416  f->micro_version = 2;
417  put_symbol(c, state, f->micro_version, 0);
418  }
419 
420  put_symbol(c, state, f->ac, 0);
421  if (f->ac == AC_RANGE_CUSTOM_TAB)
422  for (i = 1; i < 256; i++)
423  put_symbol(c, state, f->state_transition[i] - c->one_state[i], 1);
424 
425  put_symbol(c, state, f->colorspace, 0); // YUV cs type
426  put_symbol(c, state, f->bits_per_raw_sample, 0);
427  put_rac(c, state, f->chroma_planes);
428  put_symbol(c, state, f->chroma_h_shift, 0);
429  put_symbol(c, state, f->chroma_v_shift, 0);
430  put_rac(c, state, f->transparency);
431  put_symbol(c, state, f->num_h_slices - 1, 0);
432  put_symbol(c, state, f->num_v_slices - 1, 0);
433 
434  put_symbol(c, state, f->quant_table_count, 0);
435  for (i = 0; i < f->quant_table_count; i++)
436  write_quant_tables(c, f->quant_tables[i]);
437 
438  for (i = 0; i < f->quant_table_count; i++) {
439  if (contains_non_128(f->initial_states[i], f->context_count[i])) {
440  put_rac(c, state, 1);
441  for (j = 0; j < f->context_count[i]; j++)
442  for (k = 0; k < CONTEXT_SIZE; k++) {
443  int pred = j ? f->initial_states[i][j - 1][k] : 128;
444  put_symbol(c, state2[k],
445  (int8_t)(f->initial_states[i][j][k] - pred), 1);
446  }
447  } else {
448  put_rac(c, state, 0);
449  }
450  }
451 
452  if (f->version > 2) {
453  put_symbol(c, state, f->ec, 0);
454  put_symbol(c, state, f->intra = (f->avctx->gop_size < 2), 0);
455  }
456 
457  f->avctx->extradata_size = ff_rac_terminate(c, 0);
458  v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, f->avctx->extradata, f->avctx->extradata_size);
459  AV_WL32(f->avctx->extradata + f->avctx->extradata_size, v);
460  f->avctx->extradata_size += 4;
461 
462  return 0;
463 }
464 
465 static int sort_stt(FFV1Context *s, uint8_t stt[256])
466 {
467  int i, i2, changed, print = 0;
468 
469  do {
470  changed = 0;
471  for (i = 12; i < 244; i++) {
472  for (i2 = i + 1; i2 < 245 && i2 < i + 4; i2++) {
473 
474 #define COST(old, new) \
475  s->rc_stat[old][0] * -log2((256 - (new)) / 256.0) + \
476  s->rc_stat[old][1] * -log2((new) / 256.0)
477 
478 #define COST2(old, new) \
479  COST(old, new) + COST(256 - (old), 256 - (new))
480 
481  double size0 = COST2(i, i) + COST2(i2, i2);
482  double sizeX = COST2(i, i2) + COST2(i2, i);
483  if (size0 - sizeX > size0*(1e-14) && i != 128 && i2 != 128) {
484  int j;
485  FFSWAP(int, stt[i], stt[i2]);
486  FFSWAP(int, s->rc_stat[i][0], s->rc_stat[i2][0]);
487  FFSWAP(int, s->rc_stat[i][1], s->rc_stat[i2][1]);
488  if (i != 256 - i2) {
489  FFSWAP(int, stt[256 - i], stt[256 - i2]);
490  FFSWAP(int, s->rc_stat[256 - i][0], s->rc_stat[256 - i2][0]);
491  FFSWAP(int, s->rc_stat[256 - i][1], s->rc_stat[256 - i2][1]);
492  }
493  for (j = 1; j < 256; j++) {
494  if (stt[j] == i)
495  stt[j] = i2;
496  else if (stt[j] == i2)
497  stt[j] = i;
498  if (i != 256 - i2) {
499  if (stt[256 - j] == 256 - i)
500  stt[256 - j] = 256 - i2;
501  else if (stt[256 - j] == 256 - i2)
502  stt[256 - j] = 256 - i;
503  }
504  }
505  print = changed = 1;
506  }
507  }
508  }
509  } while (changed);
510  return print;
511 }
512 
513 static av_cold int encode_init(AVCodecContext *avctx)
514 {
515  FFV1Context *s = avctx->priv_data;
516  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
517  int i, j, k, m, ret;
518 
519  if ((ret = ff_ffv1_common_init(avctx)) < 0)
520  return ret;
521 
522  s->version = 0;
523 
524  if ((avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) ||
525  avctx->slices > 1)
526  s->version = FFMAX(s->version, 2);
527 
528  // Unspecified level & slices, we choose version 1.2+ to ensure multithreaded decodability
529  if (avctx->slices == 0 && avctx->level < 0 && avctx->width * avctx->height > 720*576)
530  s->version = FFMAX(s->version, 2);
531 
532  if (avctx->level <= 0 && s->version == 2) {
533  s->version = 3;
534  }
535  if (avctx->level >= 0 && avctx->level <= 4) {
536  if (avctx->level < s->version) {
537  av_log(avctx, AV_LOG_ERROR, "Version %d needed for requested features but %d requested\n", s->version, avctx->level);
538  return AVERROR(EINVAL);
539  }
540  s->version = avctx->level;
541  }
542 
543  if (s->ec < 0) {
544  s->ec = (s->version >= 3);
545  }
546 
547  // CRC requires version 3+
548  if (s->ec)
549  s->version = FFMAX(s->version, 3);
550 
551  if ((s->version == 2 || s->version>3) && avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
552  av_log(avctx, AV_LOG_ERROR, "Version 2 needed for requested features but version 2 is experimental and not enabled\n");
553  return AVERROR_INVALIDDATA;
554  }
555 
556  if (s->ac == 1) // Compatbility with common command line usage
557  s->ac = AC_RANGE_CUSTOM_TAB;
558  else if (s->ac == AC_RANGE_DEFAULT_TAB_FORCE)
559  s->ac = AC_RANGE_DEFAULT_TAB;
560 
561  s->plane_count = 3;
562  switch(avctx->pix_fmt) {
563  case AV_PIX_FMT_GRAY9:
564  case AV_PIX_FMT_YUV444P9:
565  case AV_PIX_FMT_YUV422P9:
566  case AV_PIX_FMT_YUV420P9:
567  case AV_PIX_FMT_YUVA444P9:
568  case AV_PIX_FMT_YUVA422P9:
569  case AV_PIX_FMT_YUVA420P9:
570  if (!avctx->bits_per_raw_sample)
571  s->bits_per_raw_sample = 9;
572  case AV_PIX_FMT_GRAY10:
573  case AV_PIX_FMT_YUV444P10:
574  case AV_PIX_FMT_YUV440P10:
575  case AV_PIX_FMT_YUV420P10:
576  case AV_PIX_FMT_YUV422P10:
577  case AV_PIX_FMT_YUVA444P10:
578  case AV_PIX_FMT_YUVA422P10:
579  case AV_PIX_FMT_YUVA420P10:
580  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
581  s->bits_per_raw_sample = 10;
582  case AV_PIX_FMT_GRAY12:
583  case AV_PIX_FMT_YUV444P12:
584  case AV_PIX_FMT_YUV440P12:
585  case AV_PIX_FMT_YUV420P12:
586  case AV_PIX_FMT_YUV422P12:
587  case AV_PIX_FMT_YUVA444P12:
588  case AV_PIX_FMT_YUVA422P12:
589  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
590  s->bits_per_raw_sample = 12;
591  case AV_PIX_FMT_GRAY14:
592  case AV_PIX_FMT_YUV444P14:
593  case AV_PIX_FMT_YUV420P14:
594  case AV_PIX_FMT_YUV422P14:
595  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
596  s->bits_per_raw_sample = 14;
597  s->packed_at_lsb = 1;
598  case AV_PIX_FMT_GRAY16:
599  case AV_PIX_FMT_YUV444P16:
600  case AV_PIX_FMT_YUV422P16:
601  case AV_PIX_FMT_YUV420P16:
602  case AV_PIX_FMT_YUVA444P16:
603  case AV_PIX_FMT_YUVA422P16:
604  case AV_PIX_FMT_YUVA420P16:
605  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) {
606  s->bits_per_raw_sample = 16;
607  } else if (!s->bits_per_raw_sample) {
608  s->bits_per_raw_sample = avctx->bits_per_raw_sample;
609  }
610  if (s->bits_per_raw_sample <= 8) {
611  av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");
612  return AVERROR_INVALIDDATA;
613  }
614  s->version = FFMAX(s->version, 1);
615  case AV_PIX_FMT_GRAY8:
616  case AV_PIX_FMT_YA8:
617  case AV_PIX_FMT_YUV444P:
618  case AV_PIX_FMT_YUV440P:
619  case AV_PIX_FMT_YUV422P:
620  case AV_PIX_FMT_YUV420P:
621  case AV_PIX_FMT_YUV411P:
622  case AV_PIX_FMT_YUV410P:
623  case AV_PIX_FMT_YUVA444P:
624  case AV_PIX_FMT_YUVA422P:
625  case AV_PIX_FMT_YUVA420P:
626  s->chroma_planes = desc->nb_components < 3 ? 0 : 1;
627  s->colorspace = 0;
628  s->transparency = !!(desc->flags & AV_PIX_FMT_FLAG_ALPHA);
629  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
630  s->bits_per_raw_sample = 8;
631  else if (!s->bits_per_raw_sample)
632  s->bits_per_raw_sample = 8;
633  break;
634  case AV_PIX_FMT_RGB32:
635  s->colorspace = 1;
636  s->transparency = 1;
637  s->chroma_planes = 1;
638  s->bits_per_raw_sample = 8;
639  break;
640  case AV_PIX_FMT_RGBA64:
641  s->colorspace = 1;
642  s->transparency = 1;
643  s->chroma_planes = 1;
644  s->bits_per_raw_sample = 16;
645  s->use32bit = 1;
646  s->version = FFMAX(s->version, 1);
647  break;
648  case AV_PIX_FMT_RGB48:
649  s->colorspace = 1;
650  s->chroma_planes = 1;
651  s->bits_per_raw_sample = 16;
652  s->use32bit = 1;
653  s->version = FFMAX(s->version, 1);
654  break;
655  case AV_PIX_FMT_0RGB32:
656  s->colorspace = 1;
657  s->chroma_planes = 1;
658  s->bits_per_raw_sample = 8;
659  break;
660  case AV_PIX_FMT_GBRP9:
661  if (!avctx->bits_per_raw_sample)
662  s->bits_per_raw_sample = 9;
663  case AV_PIX_FMT_GBRP10:
664  case AV_PIX_FMT_GBRAP10:
665  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
666  s->bits_per_raw_sample = 10;
667  case AV_PIX_FMT_GBRP12:
668  case AV_PIX_FMT_GBRAP12:
669  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
670  s->bits_per_raw_sample = 12;
671  case AV_PIX_FMT_GBRP14:
672  case AV_PIX_FMT_GBRAP14:
673  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
674  s->bits_per_raw_sample = 14;
675  case AV_PIX_FMT_GBRP16:
676  case AV_PIX_FMT_GBRAP16:
677  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
678  s->bits_per_raw_sample = 16;
679  else if (!s->bits_per_raw_sample)
680  s->bits_per_raw_sample = avctx->bits_per_raw_sample;
681  s->transparency = !!(desc->flags & AV_PIX_FMT_FLAG_ALPHA);
682  s->colorspace = 1;
683  s->chroma_planes = 1;
684  if (s->bits_per_raw_sample >= 16) {
685  s->use32bit = 1;
686  }
687  s->version = FFMAX(s->version, 1);
688  break;
689  default:
690  av_log(avctx, AV_LOG_ERROR, "format not supported\n");
691  return AVERROR(ENOSYS);
692  }
693  av_assert0(s->bits_per_raw_sample >= 8);
694 
695  if (s->bits_per_raw_sample > 8) {
696  if (s->ac == AC_GOLOMB_RICE) {
697  av_log(avctx, AV_LOG_INFO,
698  "bits_per_raw_sample > 8, forcing range coder\n");
699  s->ac = AC_RANGE_CUSTOM_TAB;
700  }
701  }
702 
703  if (s->ac == AC_RANGE_CUSTOM_TAB) {
704  for (i = 1; i < 256; i++)
705  s->state_transition[i] = ver2_state[i];
706  } else {
707  RangeCoder c;
708  ff_build_rac_states(&c, 0.05 * (1LL << 32), 256 - 8);
709  for (i = 1; i < 256; i++)
710  s->state_transition[i] = c.one_state[i];
711  }
712 
713  for (i = 0; i < 256; i++) {
714  s->quant_table_count = 2;
715  if (s->bits_per_raw_sample <= 8) {
716  s->quant_tables[0][0][i]= quant11[i];
717  s->quant_tables[0][1][i]= 11*quant11[i];
718  s->quant_tables[0][2][i]= 11*11*quant11[i];
719  s->quant_tables[1][0][i]= quant11[i];
720  s->quant_tables[1][1][i]= 11*quant11[i];
721  s->quant_tables[1][2][i]= 11*11*quant5 [i];
722  s->quant_tables[1][3][i]= 5*11*11*quant5 [i];
723  s->quant_tables[1][4][i]= 5*5*11*11*quant5 [i];
724  } else {
725  s->quant_tables[0][0][i]= quant9_10bit[i];
726  s->quant_tables[0][1][i]= 11*quant9_10bit[i];
727  s->quant_tables[0][2][i]= 11*11*quant9_10bit[i];
728  s->quant_tables[1][0][i]= quant9_10bit[i];
729  s->quant_tables[1][1][i]= 11*quant9_10bit[i];
730  s->quant_tables[1][2][i]= 11*11*quant5_10bit[i];
731  s->quant_tables[1][3][i]= 5*11*11*quant5_10bit[i];
732  s->quant_tables[1][4][i]= 5*5*11*11*quant5_10bit[i];
733  }
734  }
735  s->context_count[0] = (11 * 11 * 11 + 1) / 2;
736  s->context_count[1] = (11 * 11 * 5 * 5 * 5 + 1) / 2;
737  memcpy(s->quant_table, s->quant_tables[s->context_model],
738  sizeof(s->quant_table));
739 
740  for (i = 0; i < s->plane_count; i++) {
741  PlaneContext *const p = &s->plane[i];
742 
743  memcpy(p->quant_table, s->quant_table, sizeof(p->quant_table));
744  p->quant_table_index = s->context_model;
745  p->context_count = s->context_count[p->quant_table_index];
746  }
747 
748  if ((ret = ff_ffv1_allocate_initial_states(s)) < 0)
749  return ret;
750 
751  if (!s->transparency)
752  s->plane_count = 2;
753  if (!s->chroma_planes && s->version > 3)
754  s->plane_count--;
755 
756  ret = av_pix_fmt_get_chroma_sub_sample (avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
757  if (ret)
758  return ret;
759 
760  s->picture_number = 0;
761 
762  if (avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) {
763  for (i = 0; i < s->quant_table_count; i++) {
764  s->rc_stat2[i] = av_mallocz(s->context_count[i] *
765  sizeof(*s->rc_stat2[i]));
766  if (!s->rc_stat2[i])
767  return AVERROR(ENOMEM);
768  }
769  }
770  if (avctx->stats_in) {
771  char *p = avctx->stats_in;
772  uint8_t (*best_state)[256] = av_malloc_array(256, 256);
773  int gob_count = 0;
774  char *next;
775  if (!best_state)
776  return AVERROR(ENOMEM);
777 
778  av_assert0(s->version >= 2);
779 
780  for (;;) {
781  for (j = 0; j < 256; j++)
782  for (i = 0; i < 2; i++) {
783  s->rc_stat[j][i] = strtol(p, &next, 0);
784  if (next == p) {
785  av_log(avctx, AV_LOG_ERROR,
786  "2Pass file invalid at %d %d [%s]\n", j, i, p);
787  av_freep(&best_state);
788  return AVERROR_INVALIDDATA;
789  }
790  p = next;
791  }
792  for (i = 0; i < s->quant_table_count; i++)
793  for (j = 0; j < s->context_count[i]; j++) {
794  for (k = 0; k < 32; k++)
795  for (m = 0; m < 2; m++) {
796  s->rc_stat2[i][j][k][m] = strtol(p, &next, 0);
797  if (next == p) {
798  av_log(avctx, AV_LOG_ERROR,
799  "2Pass file invalid at %d %d %d %d [%s]\n",
800  i, j, k, m, p);
801  av_freep(&best_state);
802  return AVERROR_INVALIDDATA;
803  }
804  p = next;
805  }
806  }
807  gob_count = strtol(p, &next, 0);
808  if (next == p || gob_count <= 0) {
809  av_log(avctx, AV_LOG_ERROR, "2Pass file invalid\n");
810  av_freep(&best_state);
811  return AVERROR_INVALIDDATA;
812  }
813  p = next;
814  while (*p == '\n' || *p == ' ')
815  p++;
816  if (p[0] == 0)
817  break;
818  }
819  if (s->ac == AC_RANGE_CUSTOM_TAB)
820  sort_stt(s, s->state_transition);
821 
822  find_best_state(best_state, s->state_transition);
823 
824  for (i = 0; i < s->quant_table_count; i++) {
825  for (k = 0; k < 32; k++) {
826  double a=0, b=0;
827  int jp = 0;
828  for (j = 0; j < s->context_count[i]; j++) {
829  double p = 128;
830  if (s->rc_stat2[i][j][k][0] + s->rc_stat2[i][j][k][1] > 200 && j || a+b > 200) {
831  if (a+b)
832  p = 256.0 * b / (a + b);
833  s->initial_states[i][jp][k] =
834  best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];
835  for(jp++; jp<j; jp++)
836  s->initial_states[i][jp][k] = s->initial_states[i][jp-1][k];
837  a=b=0;
838  }
839  a += s->rc_stat2[i][j][k][0];
840  b += s->rc_stat2[i][j][k][1];
841  if (a+b) {
842  p = 256.0 * b / (a + b);
843  }
844  s->initial_states[i][j][k] =
845  best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];
846  }
847  }
848  }
849  av_freep(&best_state);
850  }
851 
852  if (s->version > 1) {
853  int plane_count = 1 + 2*s->chroma_planes + s->transparency;
854  int max_h_slices = AV_CEIL_RSHIFT(avctx->width , s->chroma_h_shift);
855  int max_v_slices = AV_CEIL_RSHIFT(avctx->height, s->chroma_v_shift);
856  s->num_v_slices = (avctx->width > 352 || avctx->height > 288 || !avctx->slices) ? 2 : 1;
857 
858  s->num_v_slices = FFMIN(s->num_v_slices, max_v_slices);
859 
860  for (; s->num_v_slices < 32; s->num_v_slices++) {
861  for (s->num_h_slices = s->num_v_slices; s->num_h_slices < 2*s->num_v_slices; s->num_h_slices++) {
862  int maxw = (avctx->width + s->num_h_slices - 1) / s->num_h_slices;
863  int maxh = (avctx->height + s->num_v_slices - 1) / s->num_v_slices;
864  if (s->num_h_slices > max_h_slices || s->num_v_slices > max_v_slices)
865  continue;
866  if (maxw * maxh * (int64_t)(s->bits_per_raw_sample+1) * plane_count > 8<<24)
867  continue;
868  if (avctx->slices == s->num_h_slices * s->num_v_slices && avctx->slices <= MAX_SLICES || !avctx->slices)
869  goto slices_ok;
870  }
871  }
872  av_log(avctx, AV_LOG_ERROR,
873  "Unsupported number %d of slices requested, please specify a "
874  "supported number with -slices (ex:4,6,9,12,16, ...)\n",
875  avctx->slices);
876  return AVERROR(ENOSYS);
877 slices_ok:
878  if ((ret = write_extradata(s)) < 0)
879  return ret;
880  }
881 
882  if ((ret = ff_ffv1_init_slice_contexts(s)) < 0)
883  return ret;
884  s->slice_count = s->max_slice_count;
885  if ((ret = ff_ffv1_init_slices_state(s)) < 0)
886  return ret;
887 
888 #define STATS_OUT_SIZE 1024 * 1024 * 6
889  if (avctx->flags & AV_CODEC_FLAG_PASS1) {
890  avctx->stats_out = av_mallocz(STATS_OUT_SIZE);
891  if (!avctx->stats_out)
892  return AVERROR(ENOMEM);
893  for (i = 0; i < s->quant_table_count; i++)
894  for (j = 0; j < s->max_slice_count; j++) {
895  FFV1Context *sf = s->slice_context[j];
896  av_assert0(!sf->rc_stat2[i]);
897  sf->rc_stat2[i] = av_mallocz(s->context_count[i] *
898  sizeof(*sf->rc_stat2[i]));
899  if (!sf->rc_stat2[i])
900  return AVERROR(ENOMEM);
901  }
902  }
903 
904  return 0;
905 }
906 
907 static void encode_slice_header(FFV1Context *f, FFV1Context *fs)
908 {
909  RangeCoder *c = &fs->c;
910  uint8_t state[CONTEXT_SIZE];
911  int j;
912  memset(state, 128, sizeof(state));
913 
914  put_symbol(c, state, (fs->slice_x +1)*f->num_h_slices / f->width , 0);
915  put_symbol(c, state, (fs->slice_y +1)*f->num_v_slices / f->height , 0);
916  put_symbol(c, state, (fs->slice_width +1)*f->num_h_slices / f->width -1, 0);
917  put_symbol(c, state, (fs->slice_height+1)*f->num_v_slices / f->height-1, 0);
918  for (j=0; j<f->plane_count; j++) {
919  put_symbol(c, state, f->plane[j].quant_table_index, 0);
920  av_assert0(f->plane[j].quant_table_index == f->context_model);
921  }
922  if (!(f->cur_enc_frame->flags & AV_FRAME_FLAG_INTERLACED))
923  put_symbol(c, state, 3, 0);
924  else
925  put_symbol(c, state, 1 + !(f->cur_enc_frame->flags & AV_FRAME_FLAG_TOP_FIELD_FIRST), 0);
926  put_symbol(c, state, f->cur_enc_frame->sample_aspect_ratio.num, 0);
927  put_symbol(c, state, f->cur_enc_frame->sample_aspect_ratio.den, 0);
928  if (f->version > 3) {
929  put_rac(c, state, fs->slice_coding_mode == 1);
930  if (fs->slice_coding_mode == 1)
931  ff_ffv1_clear_slice_state(f, fs);
932  put_symbol(c, state, fs->slice_coding_mode, 0);
933  if (fs->slice_coding_mode != 1) {
934  put_symbol(c, state, fs->slice_rct_by_coef, 0);
935  put_symbol(c, state, fs->slice_rct_ry_coef, 0);
936  }
937  }
938 }
939 
940 static void choose_rct_params(FFV1Context *fs, const uint8_t *src[3], const int stride[3], int w, int h)
941 {
942 #define NB_Y_COEFF 15
943  static const int rct_y_coeff[15][2] = {
944  {0, 0}, // 4G
945  {1, 1}, // R + 2G + B
946  {2, 2}, // 2R + 2B
947  {0, 2}, // 2G + 2B
948  {2, 0}, // 2R + 2G
949  {4, 0}, // 4R
950  {0, 4}, // 4B
951 
952  {0, 3}, // 1G + 3B
953  {3, 0}, // 3R + 1G
954  {3, 1}, // 3R + B
955  {1, 3}, // R + 3B
956  {1, 2}, // R + G + 2B
957  {2, 1}, // 2R + G + B
958  {0, 1}, // 3G + B
959  {1, 0}, // R + 3G
960  };
961 
962  int stat[NB_Y_COEFF] = {0};
963  int x, y, i, p, best;
964  int16_t *sample[3];
965  int lbd = fs->bits_per_raw_sample <= 8;
966 
967  for (y = 0; y < h; y++) {
968  int lastr=0, lastg=0, lastb=0;
969  for (p = 0; p < 3; p++)
970  sample[p] = fs->sample_buffer + p*w;
971 
972  for (x = 0; x < w; x++) {
973  int b, g, r;
974  int ab, ag, ar;
975  if (lbd) {
976  unsigned v = *((const uint32_t*)(src[0] + x*4 + stride[0]*y));
977  b = v & 0xFF;
978  g = (v >> 8) & 0xFF;
979  r = (v >> 16) & 0xFF;
980  } else {
981  b = *((const uint16_t*)(src[0] + x*2 + stride[0]*y));
982  g = *((const uint16_t*)(src[1] + x*2 + stride[1]*y));
983  r = *((const uint16_t*)(src[2] + x*2 + stride[2]*y));
984  }
985 
986  ar = r - lastr;
987  ag = g - lastg;
988  ab = b - lastb;
989  if (x && y) {
990  int bg = ag - sample[0][x];
991  int bb = ab - sample[1][x];
992  int br = ar - sample[2][x];
993 
994  br -= bg;
995  bb -= bg;
996 
997  for (i = 0; i<NB_Y_COEFF; i++) {
998  stat[i] += FFABS(bg + ((br*rct_y_coeff[i][0] + bb*rct_y_coeff[i][1])>>2));
999  }
1000 
1001  }
1002  sample[0][x] = ag;
1003  sample[1][x] = ab;
1004  sample[2][x] = ar;
1005 
1006  lastr = r;
1007  lastg = g;
1008  lastb = b;
1009  }
1010  }
1011 
1012  best = 0;
1013  for (i=1; i<NB_Y_COEFF; i++) {
1014  if (stat[i] < stat[best])
1015  best = i;
1016  }
1017 
1018  fs->slice_rct_by_coef = rct_y_coeff[best][1];
1019  fs->slice_rct_ry_coef = rct_y_coeff[best][0];
1020 }
1021 
1022 static int encode_slice(AVCodecContext *c, void *arg)
1023 {
1024  FFV1Context *fs = *(void **)arg;
1025  FFV1Context *f = fs->avctx->priv_data;
1026  int width = fs->slice_width;
1027  int height = fs->slice_height;
1028  int x = fs->slice_x;
1029  int y = fs->slice_y;
1030  const AVFrame *const p = f->cur_enc_frame;
1031  const int ps = av_pix_fmt_desc_get(c->pix_fmt)->comp[0].step;
1032  int ret;
1033  RangeCoder c_bak = fs->c;
1034  const uint8_t *planes[4] = {p->data[0] + ps*x + y*p->linesize[0],
1035  p->data[1] ? p->data[1] + ps*x + y*p->linesize[1] : NULL,
1036  p->data[2] ? p->data[2] + ps*x + y*p->linesize[2] : NULL,
1037  p->data[3] ? p->data[3] + ps*x + y*p->linesize[3] : NULL};
1038 
1039  fs->slice_coding_mode = 0;
1040  if (f->version > 3) {
1041  choose_rct_params(fs, planes, p->linesize, width, height);
1042  } else {
1043  fs->slice_rct_by_coef = 1;
1044  fs->slice_rct_ry_coef = 1;
1045  }
1046 
1047 retry:
1048  if (f->key_frame)
1049  ff_ffv1_clear_slice_state(f, fs);
1050  if (f->version > 2) {
1051  encode_slice_header(f, fs);
1052  }
1053  if (fs->ac == AC_GOLOMB_RICE) {
1054  fs->ac_byte_count = f->version > 2 || (!x && !y) ? ff_rac_terminate(&fs->c, f->version > 2) : 0;
1055  init_put_bits(&fs->pb,
1056  fs->c.bytestream_start + fs->ac_byte_count,
1057  fs->c.bytestream_end - fs->c.bytestream_start - fs->ac_byte_count);
1058  }
1059 
1060  if (f->colorspace == 0 && c->pix_fmt != AV_PIX_FMT_YA8) {
1061  const int chroma_width = AV_CEIL_RSHIFT(width, f->chroma_h_shift);
1062  const int chroma_height = AV_CEIL_RSHIFT(height, f->chroma_v_shift);
1063  const int cx = x >> f->chroma_h_shift;
1064  const int cy = y >> f->chroma_v_shift;
1065 
1066  ret = encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 1);
1067 
1068  if (f->chroma_planes) {
1069  ret |= encode_plane(fs, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1, 1);
1070  ret |= encode_plane(fs, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1, 1);
1071  }
1072  if (fs->transparency)
1073  ret |= encode_plane(fs, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], 2, 1);
1074  } else if (c->pix_fmt == AV_PIX_FMT_YA8) {
1075  ret = encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 2);
1076  ret |= encode_plane(fs, p->data[0] + 1 + ps*x + y*p->linesize[0], width, height, p->linesize[0], 1, 2);
1077  } else if (f->use32bit) {
1078  ret = encode_rgb_frame32(fs, planes, width, height, p->linesize);
1079  } else {
1080  ret = encode_rgb_frame(fs, planes, width, height, p->linesize);
1081  }
1082 
1083  if (ret < 0) {
1084  av_assert0(fs->slice_coding_mode == 0);
1085  if (fs->version < 4 || !fs->ac) {
1086  av_log(c, AV_LOG_ERROR, "Buffer too small\n");
1087  return ret;
1088  }
1089  av_log(c, AV_LOG_DEBUG, "Coding slice as PCM\n");
1090  fs->slice_coding_mode = 1;
1091  fs->c = c_bak;
1092  goto retry;
1093  }
1094 
1095  return 0;
1096 }
1097 
1098 static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
1099  const AVFrame *pict, int *got_packet)
1100 {
1101  FFV1Context *f = avctx->priv_data;
1102  RangeCoder *const c = &f->slice_context[0]->c;
1103  uint8_t keystate = 128;
1104  uint8_t *buf_p;
1105  int i, ret;
1106  int64_t maxsize = FF_INPUT_BUFFER_MIN_SIZE
1107  + avctx->width*avctx->height*37LL*4;
1108 
1109  if(!pict) {
1110  if (avctx->flags & AV_CODEC_FLAG_PASS1) {
1111  int j, k, m;
1112  char *p = avctx->stats_out;
1113  char *end = p + STATS_OUT_SIZE;
1114 
1115  memset(f->rc_stat, 0, sizeof(f->rc_stat));
1116  for (i = 0; i < f->quant_table_count; i++)
1117  memset(f->rc_stat2[i], 0, f->context_count[i] * sizeof(*f->rc_stat2[i]));
1118 
1119  av_assert0(f->slice_count == f->max_slice_count);
1120  for (j = 0; j < f->slice_count; j++) {
1121  FFV1Context *fs = f->slice_context[j];
1122  for (i = 0; i < 256; i++) {
1123  f->rc_stat[i][0] += fs->rc_stat[i][0];
1124  f->rc_stat[i][1] += fs->rc_stat[i][1];
1125  }
1126  for (i = 0; i < f->quant_table_count; i++) {
1127  for (k = 0; k < f->context_count[i]; k++)
1128  for (m = 0; m < 32; m++) {
1129  f->rc_stat2[i][k][m][0] += fs->rc_stat2[i][k][m][0];
1130  f->rc_stat2[i][k][m][1] += fs->rc_stat2[i][k][m][1];
1131  }
1132  }
1133  }
1134 
1135  for (j = 0; j < 256; j++) {
1136  snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1137  f->rc_stat[j][0], f->rc_stat[j][1]);
1138  p += strlen(p);
1139  }
1140  snprintf(p, end - p, "\n");
1141 
1142  for (i = 0; i < f->quant_table_count; i++) {
1143  for (j = 0; j < f->context_count[i]; j++)
1144  for (m = 0; m < 32; m++) {
1145  snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1146  f->rc_stat2[i][j][m][0], f->rc_stat2[i][j][m][1]);
1147  p += strlen(p);
1148  }
1149  }
1150  snprintf(p, end - p, "%d\n", f->gob_count);
1151  }
1152  return 0;
1153  }
1154 
1155  if (f->version > 3)
1156  maxsize = FF_INPUT_BUFFER_MIN_SIZE + avctx->width*avctx->height*3LL*4;
1157 
1158  if (maxsize > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE - 32) {
1159  av_log(avctx, AV_LOG_WARNING, "Cannot allocate worst case packet size, the encoding could fail\n");
1160  maxsize = INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE - 32;
1161  }
1162 
1163  if ((ret = ff_alloc_packet(avctx, pkt, maxsize)) < 0)
1164  return ret;
1165 
1166  ff_init_range_encoder(c, pkt->data, pkt->size);
1167  ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
1168 
1169  f->cur_enc_frame = pict;
1170 
1171  if (avctx->gop_size == 0 || f->picture_number % avctx->gop_size == 0) {
1172  put_rac(c, &keystate, 1);
1173  f->key_frame = 1;
1174  f->gob_count++;
1175  write_header(f);
1176  } else {
1177  put_rac(c, &keystate, 0);
1178  f->key_frame = 0;
1179  }
1180 
1181  if (f->ac == AC_RANGE_CUSTOM_TAB) {
1182  int i;
1183  for (i = 1; i < 256; i++) {
1184  c->one_state[i] = f->state_transition[i];
1185  c->zero_state[256 - i] = 256 - c->one_state[i];
1186  }
1187  }
1188 
1189  for (i = 0; i < f->slice_count; i++) {
1190  FFV1Context *fs = f->slice_context[i];
1191  uint8_t *start = pkt->data + pkt->size * (int64_t)i / f->slice_count;
1192  int len = pkt->size / f->slice_count;
1193  if (i) {
1194  ff_init_range_encoder(&fs->c, start, len);
1195  } else {
1196  av_assert0(fs->c.bytestream_end >= fs->c.bytestream_start + len);
1197  av_assert0(fs->c.bytestream < fs->c.bytestream_start + len);
1198  fs->c.bytestream_end = fs->c.bytestream_start + len;
1199  }
1200  }
1201  avctx->execute(avctx, encode_slice, &f->slice_context[0], NULL,
1202  f->slice_count, sizeof(void *));
1203 
1204  buf_p = pkt->data;
1205  for (i = 0; i < f->slice_count; i++) {
1206  FFV1Context *fs = f->slice_context[i];
1207  int bytes;
1208 
1209  if (fs->ac != AC_GOLOMB_RICE) {
1210  bytes = ff_rac_terminate(&fs->c, 1);
1211  } else {
1212  flush_put_bits(&fs->pb); // FIXME: nicer padding
1213  bytes = fs->ac_byte_count + put_bytes_output(&fs->pb);
1214  }
1215  if (i > 0 || f->version > 2) {
1216  av_assert0(bytes < pkt->size / f->slice_count);
1217  memmove(buf_p, fs->c.bytestream_start, bytes);
1218  av_assert0(bytes < (1 << 24));
1219  AV_WB24(buf_p + bytes, bytes);
1220  bytes += 3;
1221  }
1222  if (f->ec) {
1223  unsigned v;
1224  buf_p[bytes++] = 0;
1225  v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, buf_p, bytes);
1226  AV_WL32(buf_p + bytes, v);
1227  bytes += 4;
1228  }
1229  buf_p += bytes;
1230  }
1231 
1232  if (avctx->flags & AV_CODEC_FLAG_PASS1)
1233  avctx->stats_out[0] = '\0';
1234 
1235  f->picture_number++;
1236  pkt->size = buf_p - pkt->data;
1237  pkt->flags |= AV_PKT_FLAG_KEY * f->key_frame;
1238  *got_packet = 1;
1239 
1240  return 0;
1241 }
1242 
1243 #define OFFSET(x) offsetof(FFV1Context, x)
1244 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1245 static const AVOption options[] = {
1246  { "slicecrc", "Protect slices with CRCs", OFFSET(ec), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE },
1247  { "coder", "Coder type", OFFSET(ac), AV_OPT_TYPE_INT,
1248  { .i64 = 0 }, -2, 2, VE, .unit = "coder" },
1249  { "rice", "Golomb rice", 0, AV_OPT_TYPE_CONST,
1250  { .i64 = AC_GOLOMB_RICE }, INT_MIN, INT_MAX, VE, .unit = "coder" },
1251  { "range_def", "Range with default table", 0, AV_OPT_TYPE_CONST,
1252  { .i64 = AC_RANGE_DEFAULT_TAB_FORCE }, INT_MIN, INT_MAX, VE, .unit = "coder" },
1253  { "range_tab", "Range with custom table", 0, AV_OPT_TYPE_CONST,
1254  { .i64 = AC_RANGE_CUSTOM_TAB }, INT_MIN, INT_MAX, VE, .unit = "coder" },
1255  { "ac", "Range with custom table (the ac option exists for compatibility and is deprecated)", 0, AV_OPT_TYPE_CONST,
1256  { .i64 = 1 }, INT_MIN, INT_MAX, VE, .unit = "coder" },
1257  { "context", "Context model", OFFSET(context_model), AV_OPT_TYPE_INT,
1258  { .i64 = 0 }, 0, 1, VE },
1259 
1260  { NULL }
1261 };
1262 
1263 static const AVClass ffv1_class = {
1264  .class_name = "ffv1 encoder",
1265  .item_name = av_default_item_name,
1266  .option = options,
1267  .version = LIBAVUTIL_VERSION_INT,
1268 };
1269 
1270 const FFCodec ff_ffv1_encoder = {
1271  .p.name = "ffv1",
1272  CODEC_LONG_NAME("FFmpeg video codec #1"),
1273  .p.type = AVMEDIA_TYPE_VIDEO,
1274  .p.id = AV_CODEC_ID_FFV1,
1275  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |
1276  AV_CODEC_CAP_SLICE_THREADS |
1277  AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
1278  .priv_data_size = sizeof(FFV1Context),
1279  .init = encode_init,
1280  FF_CODEC_ENCODE_CB(encode_frame),
1281  .close = ff_ffv1_close,
1282  .p.pix_fmts = (const enum AVPixelFormat[]) {
1283  AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV444P,
1284  AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV411P,
1285  AV_PIX_FMT_YUV410P, AV_PIX_FMT_0RGB32, AV_PIX_FMT_RGB32, AV_PIX_FMT_YUV420P16,
1286  AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16, AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV422P9,
1287  AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
1288  AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12,
1289  AV_PIX_FMT_YUVA444P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA420P16,
1290  AV_PIX_FMT_YUVA444P12, AV_PIX_FMT_YUVA422P12,
1291  AV_PIX_FMT_YUVA444P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA420P10,
1292  AV_PIX_FMT_YUVA444P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA420P9,
1293  AV_PIX_FMT_GRAY16, AV_PIX_FMT_GRAY8, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
1294  AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14, AV_PIX_FMT_GBRAP14,
1295  AV_PIX_FMT_GBRAP10, AV_PIX_FMT_GBRAP12,
1296  AV_PIX_FMT_YA8,
1297  AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY12, AV_PIX_FMT_GRAY14,
1298  AV_PIX_FMT_GBRP16, AV_PIX_FMT_RGB48,
1299  AV_PIX_FMT_GBRAP16, AV_PIX_FMT_RGBA64,
1300  AV_PIX_FMT_GRAY9,
1301  AV_PIX_FMT_YUV420P14, AV_PIX_FMT_YUV422P14, AV_PIX_FMT_YUV444P14,
1302  AV_PIX_FMT_YUV440P10, AV_PIX_FMT_YUV440P12,
1303  AV_PIX_FMT_NONE
1304 
1305  },
1306  .p.priv_class = &ffv1_class,
1307  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP | FF_CODEC_CAP_EOF_FLUSH,
1308 };
encode_slice_header
static void encode_slice_header(FFV1Context *f, FFV1Context *fs)
Definition: ffv1enc.c:907
AV_PIX_FMT_YUVA422P16
#define AV_PIX_FMT_YUVA422P16
Definition: pixfmt.h:522
AV_PIX_FMT_GBRAP16
#define AV_PIX_FMT_GBRAP16
Definition: pixfmt.h:501
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
av_clip
#define av_clip
Definition: common.h:99
update_vlc_state
static void update_vlc_state(VlcState *const state, const int v)
Definition: ffv1.h:156
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: codec_internal.h:42
r
const char * r
Definition: vf_curves.c:127
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
AV_PIX_FMT_YA8
@ AV_PIX_FMT_YA8
8 bits gray, 8 bits alpha
Definition: pixfmt.h:140
AV_WL32
#define AV_WL32(p, v)
Definition: intreadwrite.h:424
put_bytes_output
static int put_bytes_output(const PutBitContext *s)
Definition: put_bits.h:89
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2965
FFV1Context::ec
int ec
Definition: ffv1.h:110
FF_CODEC_CAP_EOF_FLUSH
#define FF_CODEC_CAP_EOF_FLUSH
The encoder has AV_CODEC_CAP_DELAY set, but does not actually have delay - it only wants to be flushe...
Definition: codec_internal.h:89
put_symbol_inline
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:183
init_put_bits
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:62
encode_plane
static int encode_plane(FFV1Context *s, const uint8_t *src, int w, int h, int stride, int plane_index, int pixel_stride)
Definition: ffv1enc.c:272
AV_PIX_FMT_YUVA422P9
#define AV_PIX_FMT_YUVA422P9
Definition: pixfmt.h:514
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:374
pixdesc.h
ff_ffv1_common_init
av_cold int ff_ffv1_common_init(AVCodecContext *avctx)
Definition: ffv1.c:35
AV_PIX_FMT_YUVA420P16
#define AV_PIX_FMT_YUVA420P16
Definition: pixfmt.h:521
w
uint8_t w
Definition: llviddspenc.c:38
AC_RANGE_DEFAULT_TAB_FORCE
#define AC_RANGE_DEFAULT_TAB_FORCE
Definition: ffv1.h:52
AVPacket::data
uint8_t * data
Definition: packet.h:524
AV_PIX_FMT_YUVA420P10
#define AV_PIX_FMT_YUVA420P10
Definition: pixfmt.h:516
AVOption
AVOption.
Definition: opt.h:346
encode.h
b
#define b
Definition: input.c:41
rangecoder.h
AVComponentDescriptor::step
int step
Number of elements between 2 horizontally consecutive pixels.
Definition: pixdesc.h:40
AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:478
FFCodec
Definition: codec_internal.h:126
write_quant_tables
static void write_quant_tables(RangeCoder *c, int16_t quant_table[MAX_CONTEXT_INPUTS][256])
Definition: ffv1enc.c:325
contains_non_128
static int contains_non_128(uint8_t(*initial_state)[CONTEXT_SIZE], int nb_contexts)
Definition: ffv1enc.c:333
AV_PIX_FMT_YUV440P
@ AV_PIX_FMT_YUV440P
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
Definition: pixfmt.h:106
FF_COMPLIANCE_EXPERIMENTAL
#define FF_COMPLIANCE_EXPERIMENTAL
Allow nonstandardized experimental things.
Definition: defs.h:62
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
AC_RANGE_CUSTOM_TAB
#define AC_RANGE_CUSTOM_TAB
Definition: ffv1.h:51
AV_PIX_FMT_YUVA422P10
#define AV_PIX_FMT_YUVA422P10
Definition: pixfmt.h:517
ring_size
static int ring_size(RingBuffer *ring)
Definition: async.c:105
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:579
FF_INPUT_BUFFER_MIN_SIZE
#define FF_INPUT_BUFFER_MIN_SIZE
Used by some encoders as upper bound for the length of headers.
Definition: encode.h:33
put_symbol
static av_noinline void put_symbol(RangeCoder *c, uint8_t *state, int v, int is_signed)
Definition: ffv1enc.c:231
AV_PIX_FMT_GRAY9
#define AV_PIX_FMT_GRAY9
Definition: pixfmt.h:458
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:395
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
AV_FRAME_FLAG_TOP_FIELD_FIRST
#define AV_FRAME_FLAG_TOP_FIELD_FIRST
A flag to mark frames where the top field is displayed first if the content is interlaced.
Definition: frame.h:638
crc.h
ff_ffv1_init_slices_state
av_cold int ff_ffv1_init_slices_state(FFV1Context *f)
Definition: ffv1.c:94
AV_PIX_FMT_YUVA420P9
#define AV_PIX_FMT_YUVA420P9
Definition: pixfmt.h:513
quant11
static const int8_t quant11[256]
Definition: ffv1enc.c:100
encode_init
static av_cold int encode_init(AVCodecContext *avctx)
Definition: ffv1enc.c:513
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:130
AV_PIX_FMT_GBRP14
#define AV_PIX_FMT_GBRP14
Definition: pixfmt.h:496
ff_init_range_encoder
av_cold void ff_init_range_encoder(RangeCoder *c, uint8_t *buf, int buf_size)
Definition: rangecoder.c:42
AV_PIX_FMT_GBRP10
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:494
AV_PIX_FMT_YUVA444P16
#define AV_PIX_FMT_YUVA444P16
Definition: pixfmt.h:523
choose_rct_params
static void choose_rct_params(FFV1Context *fs, const uint8_t *src[3], const int stride[3], int w, int h)
Definition: ffv1enc.c:940
AV_PIX_FMT_YUV422P9
#define AV_PIX_FMT_YUV422P9
Definition: pixfmt.h:476
encode_slice
static int encode_slice(AVCodecContext *c, void *arg)
Definition: ffv1enc.c:1022
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:502
av_pix_fmt_get_chroma_sub_sample
int av_pix_fmt_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: pixdesc.c:2993
av_noinline
#define av_noinline
Definition: attributes.h:72
NB_Y_COEFF
#define NB_Y_COEFF
MAX_SLICES
#define MAX_SLICES
Definition: d3d12va_hevc.c:33
CONTEXT_SIZE
#define CONTEXT_SIZE
Definition: ffv1.h:44
AV_PIX_FMT_GRAY16
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:462
FF_CODEC_ENCODE_CB
#define FF_CODEC_ENCODE_CB(func)
Definition: codec_internal.h:295
PlaneContext::context_count
int context_count
Definition: ffv1.h:64
ff_ffv1_clear_slice_state
void ff_ffv1_clear_slice_state(const FFV1Context *f, FFV1Context *fs)
Definition: ffv1.c:162
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:481
avassert.h
put_golomb.h
exp golomb vlc writing stuff
pkt
AVPacket * pkt
Definition: movenc.c:60
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
av_cold
#define av_cold
Definition: attributes.h:90
AV_PIX_FMT_YUV422P16
#define AV_PIX_FMT_YUV422P16
Definition: pixfmt.h:490
AV_PIX_FMT_GBRAP10
#define AV_PIX_FMT_GBRAP10
Definition: pixfmt.h:498
width
#define width
s
#define s(width, name)
Definition: cbs_vp9.c:198
AVCodecContext::stats_in
char * stats_in
pass2 encoding statistics input buffer Concatenated stuff from stats_out of pass1 should be placed he...
Definition: avcodec.h:1342
AV_PIX_FMT_GBRAP14
#define AV_PIX_FMT_GBRAP14
Definition: pixfmt.h:500
AV_PIX_FMT_GBRAP12
#define AV_PIX_FMT_GBRAP12
Definition: pixfmt.h:499
AV_PIX_FMT_YUVA420P
@ AV_PIX_FMT_YUVA420P
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
Definition: pixfmt.h:108
AV_PIX_FMT_YUV444P16
#define AV_PIX_FMT_YUV444P16
Definition: pixfmt.h:491
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:59
g
const char * g
Definition: vf_curves.c:128
AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE
#define AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE
This encoder can reorder user opaque values from input AVFrames and return them with corresponding ou...
Definition: codec.h:159
bits
uint8_t bits
Definition: vp3data.h:128
AC_RANGE_DEFAULT_TAB
#define AC_RANGE_DEFAULT_TAB
Definition: ffv1.h:50
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
quant5
static const int8_t quant5[256]
Definition: ffv1enc.c:62
FFV1Context::rc_stat
uint64_t rc_stat[256][2]
Definition: ffv1.h:78
AV_PIX_FMT_YUVA444P12
#define AV_PIX_FMT_YUVA444P12
Definition: pixfmt.h:520
AVCodecContext::bits_per_raw_sample
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:1574
AV_PIX_FMT_YUV420P9
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:475
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
AV_PIX_FMT_YUV420P16
#define AV_PIX_FMT_YUV420P16
Definition: pixfmt.h:489
write_extradata
static int write_extradata(FFV1Context *f)
Definition: ffv1enc.c:392
AV_PIX_FMT_FLAG_ALPHA
#define AV_PIX_FMT_FLAG_ALPHA
The pixel format has an alpha channel.
Definition: pixdesc.h:147
AV_PIX_FMT_GRAY14
#define AV_PIX_FMT_GRAY14
Definition: pixfmt.h:461
fold
static av_always_inline int fold(int diff, int bits)
Definition: ffv1.h:145
FFV1Context::ac
int ac
1=range coder <-> 0=golomb rice
Definition: ffv1.h:95
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:73
FFV1Context::plane_count
int plane_count
Definition: ffv1.h:94
PutBitContext
Definition: put_bits.h:50
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:271
sort_stt
static int sort_stt(FFV1Context *s, uint8_t stt[256])
Definition: ffv1enc.c:465
ver2_state
static const uint8_t ver2_state[256]
Definition: ffv1enc.c:119
arg
const char * arg
Definition: jacosubdec.c:67
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:73
AV_PIX_FMT_GRAY10
#define AV_PIX_FMT_GRAY10
Definition: pixfmt.h:459
if
if(ret)
Definition: filter_design.txt:179
encode_frame
static int encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pict, int *got_packet)
Definition: ffv1enc.c:1098
quant_table
static const int16_t quant_table[64]
Definition: intrax8.c:517
AV_PIX_FMT_GBRP16
#define AV_PIX_FMT_GBRP16
Definition: pixfmt.h:497
AV_PIX_FMT_RGBA64
#define AV_PIX_FMT_RGBA64
Definition: pixfmt.h:468
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
NULL
#define NULL
Definition: coverity.c:32
AC_GOLOMB_RICE
#define AC_GOLOMB_RICE
Definition: ffv1.h:49
fs
#define fs(width, name, subs,...)
Definition: cbs_vp9.c:200
state
static struct @414 state
ff_rac_terminate
int ff_rac_terminate(RangeCoder *c, int version)
Terminates the range coder.
Definition: rangecoder.c:109
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
AV_PIX_FMT_YUV440P10
#define AV_PIX_FMT_YUV440P10
Definition: pixfmt.h:480
PlaneContext
Definition: ffv1.h:61
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:479
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:81
AV_PIX_FMT_GBRP9
#define AV_PIX_FMT_GBRP9
Definition: pixfmt.h:493
AVCodecContext::level
int level
Encoding level descriptor.
Definition: avcodec.h:1783
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
VlcState
Definition: ffv1.h:54
VE
#define VE
Definition: ffv1enc.c:1244
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:28
options
static const AVOption options[]
Definition: ffv1enc.c:1245
AVCodecContext::stats_out
char * stats_out
pass1 encoding statistics output buffer
Definition: avcodec.h:1334
AV_CODEC_ID_FFV1
@ AV_CODEC_ID_FFV1
Definition: codec_id.h:85
f
f
Definition: af_crystalizer.c:121
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:366
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
AVPacket::size
int size
Definition: packet.h:525
AVCodecContext::gop_size
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:1031
codec_internal.h
quant9_10bit
static const int8_t quant9_10bit[256]
Definition: ffv1enc.c:81
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:425
print
static void print(AVTreeNode *t, int depth)
Definition: tree.c:45
AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:483
ff_ffv1_close
av_cold int ff_ffv1_close(AVCodecContext *avctx)
Definition: ffv1.c:190
sample
#define sample
Definition: flacdsp_template.c:44
AV_PIX_FMT_RGB48
#define AV_PIX_FMT_RGB48
Definition: pixfmt.h:464
size
int size
Definition: twinvq_data.h:10344
ff_build_rac_states
void ff_build_rac_states(RangeCoder *c, int factor, int max_p)
Definition: rangecoder.c:68
STATS_OUT_SIZE
#define STATS_OUT_SIZE
AV_PIX_FMT_YUV444P12
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:485
encode_line
static av_always_inline int RENAME() encode_line(FFV1Context *s, int w, TYPE *sample[3], int plane_index, int bits)
Definition: ffv1enc_template.c:25
AV_WB24
#define AV_WB24(p, d)
Definition: intreadwrite.h:448
AV_CODEC_FLAG_PASS2
#define AV_CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
Definition: avcodec.h:314
height
#define height
AV_PIX_FMT_RGB32
#define AV_PIX_FMT_RGB32
Definition: pixfmt.h:451
a
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:41
AV_PIX_FMT_YUVA444P
@ AV_PIX_FMT_YUVA444P
planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
Definition: pixfmt.h:174
av_crc_get_table
const AVCRC * av_crc_get_table(AVCRCId crc_id)
Get an initialized standard CRC table.
Definition: crc.c:374
AV_CODEC_CAP_SLICE_THREADS
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: codec.h:114
AV_PIX_FMT_YUVA444P10
#define AV_PIX_FMT_YUVA444P10
Definition: pixfmt.h:518
find_best_state
static void find_best_state(uint8_t best_state[256][256], const uint8_t one_state[256])
Definition: ffv1enc.c:138
attributes.h
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:530
PlaneContext::quant_table_index
int quant_table_index
Definition: ffv1.h:63
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
put_vlc_symbol
static void put_vlc_symbol(PutBitContext *pb, VlcState *const state, int v, int bits)
Definition: ffv1enc.c:238
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:67
FFV1Context::gob_count
int gob_count
Definition: ffv1.h:119
ffv1_class
static const AVClass ffv1_class
Definition: ffv1enc.c:1263
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
planes
static const struct @415 planes[]
code
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
Definition: filter_design.txt:178
round
static av_always_inline av_const double round(double x)
Definition: libm.h:444
av_flatten
#define av_flatten
Definition: attributes.h:96
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:31
AV_PIX_FMT_GBRP12
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:495
av_always_inline
#define av_always_inline
Definition: attributes.h:49
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
ffv1.h
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:256
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
len
int len
Definition: vorbis_enc_data.h:426
AV_CRC_32_IEEE
@ AV_CRC_32_IEEE
Definition: crc.h:52
AVCodecContext::height
int height
Definition: avcodec.h:618
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:657
write_quant_table
static void write_quant_table(RangeCoder *c, int16_t *quant_table)
Definition: ffv1enc.c:310
AV_FRAME_FLAG_INTERLACED
#define AV_FRAME_FLAG_INTERLACED
A flag to mark frames whose content is interlaced.
Definition: frame.h:633
AV_PIX_FMT_YUV444P9
#define AV_PIX_FMT_YUV444P9
Definition: pixfmt.h:477
MAX_CONTEXT_INPUTS
#define MAX_CONTEXT_INPUTS
Definition: ffv1.h:47
log2
#define log2(x)
Definition: libm.h:404
avcodec.h
stride
#define stride
Definition: h264pred_template.c:537
FFV1Context::avctx
AVCodecContext * avctx
Definition: ffv1.h:74
ret
ret
Definition: filter_design.txt:187
pred
static const float pred[4]
Definition: siprdata.h:259
FFSWAP
#define FFSWAP(type, a, b)
Definition: macros.h:52
AVClass::class_name
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:71
AV_PIX_FMT_0RGB32
#define AV_PIX_FMT_0RGB32
Definition: pixfmt.h:455
quant5_10bit
static const int8_t quant5_10bit[256]
Definition: ffv1enc.c:43
AVCodecContext::strict_std_compliance
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
Definition: avcodec.h:1379
AV_PIX_FMT_YUVA444P9
#define AV_PIX_FMT_YUVA444P9
Definition: pixfmt.h:515
set_sr_golomb
static void set_sr_golomb(PutBitContext *pb, int i, int k, int limit, int esc_len)
write signed golomb rice code (ffv1).
Definition: put_golomb.h:143
AV_PIX_FMT_YUV420P12
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:482
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: defs.h:40
put_rac
#define put_rac(C, S, B)
U
#define U(x)
Definition: vpx_arith.h:37
AV_PIX_FMT_YUV422P14
#define AV_PIX_FMT_YUV422P14
Definition: pixfmt.h:487
FFV1Context::rc_stat2
uint64_t(*[MAX_QUANT_TABLES] rc_stat2)[32][2]
Definition: ffv1.h:79
ff_ffv1_allocate_initial_states
int ff_ffv1_allocate_initial_states(FFV1Context *f)
Definition: ffv1.c:147
AVCodecContext
main external API structure.
Definition: avcodec.h:445
AVCodecContext::execute
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:1612
FFV1Context::context_model
int context_model
Definition: ffv1.h:114
FFV1Context::pb
PutBitContext pb
Definition: ffv1.h:77
av_crc
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:392
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
AV_PIX_FMT_YUVA422P12
#define AV_PIX_FMT_YUVA422P12
Definition: pixfmt.h:519
OFFSET
#define OFFSET(x)
Definition: ffv1enc.c:1243
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:235
AVPixFmtDescriptor::comp
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:105
AV_CODEC_CAP_DELAY
#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: codec.h:76
COST2
#define COST2(old, new)
av_clip_uint8
#define av_clip_uint8
Definition: common.h:105
AV_PIX_FMT_YUV444P
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:78
ffv1enc_template.c
desc
const char * desc
Definition: libsvtav1.c:79
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AV_PIX_FMT_YUV422P
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:77
mem.h
flush_put_bits
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:143
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
FFV1Context
Definition: ffv1.h:72
AVCodecContext::slices
int slices
Number of slices.
Definition: avcodec.h:1047
AVPacket
This structure stores compressed data.
Definition: packet.h:501
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:472
encode_rgb_frame
static int RENAME() encode_rgb_frame(FFV1Context *s, const uint8_t *src[4], int w, int h, const int stride[4])
Definition: ffv1enc_template.c:127
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:251
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
AV_PIX_FMT_YUV411P
@ AV_PIX_FMT_YUV411P
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
Definition: pixfmt.h:80
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:618
ff_ffv1_init_slice_contexts
av_cold int ff_ffv1_init_slice_contexts(FFV1Context *f)
Definition: ffv1.c:105
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
Definition: frame.h:419
AV_PIX_FMT_YUV410P
@ AV_PIX_FMT_YUV410P
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
Definition: pixfmt.h:79
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
AV_PIX_FMT_YUV440P12
#define AV_PIX_FMT_YUV440P12
Definition: pixfmt.h:484
h
h
Definition: vp9dsp_template.c:2038
RangeCoder
Definition: mss3.c:63
AV_PIX_FMT_YUV444P14
#define AV_PIX_FMT_YUV444P14
Definition: pixfmt.h:488
ff_ffv1_encoder
const FFCodec ff_ffv1_encoder
Definition: ffv1enc.c:1270
write_header
static void write_header(FFV1Context *f)
Definition: ffv1enc.c:345
AV_PIX_FMT_GRAY12
#define AV_PIX_FMT_GRAY12
Definition: pixfmt.h:460
PlaneContext::quant_table
int16_t quant_table[MAX_CONTEXT_INPUTS][256]
Definition: ffv1.h:62
put_bits.h
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:244
snprintf
#define snprintf
Definition: snprintf.h:34
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
ff_alloc_packet
int ff_alloc_packet(AVCodecContext *avctx, AVPacket *avpkt, int64_t size)
Check AVPacket size and allocate data.
Definition: encode.c:62
AV_PIX_FMT_YUVA422P
@ AV_PIX_FMT_YUVA422P
planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
Definition: pixfmt.h:173
AV_PIX_FMT_YUV420P14
#define AV_PIX_FMT_YUV420P14
Definition: pixfmt.h:486
AV_CODEC_FLAG_PASS1
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
Definition: avcodec.h:310
Generated on Wed Apr 24 2024 19:21:41 for FFmpeg by   doxygen 1.8.17