ffv1enc.c
Go to the documentation of this file.
1 /*
2  * FFV1 encoder
3  *
4  * Copyright (c) 2003-2012 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/avassert.h"
29 #include "libavutil/crc.h"
30 #include "libavutil/opt.h"
31 #include "libavutil/imgutils.h"
32 #include "libavutil/pixdesc.h"
33 #include "libavutil/timer.h"
34 #include "avcodec.h"
35 #include "internal.h"
36 #include "put_bits.h"
37 #include "rangecoder.h"
38 #include "golomb.h"
39 #include "mathops.h"
40 #include "ffv1.h"
41 
42 static const int8_t quant5_10bit[256] = {
43  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1,
44  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 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, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
47  2, 2, 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, -1,
56  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -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, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0,
59 };
60 
61 static const int8_t quant5[256] = {
62  0, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
63  2, 2, 2, 2, 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, -1, -1, -1,
78 };
79 
80 static const int8_t quant9_10bit[256] = {
81  0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2,
82  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3,
83  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
84  3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
85  4, 4, 4, 4, 4, 4, 4, 4, 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, -3, -3, -3, -3, -3, -3, -3,
94  -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3,
95  -3, -3, -3, -3, -3, -3, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
96  -2, -2, -2, -2, -1, -1, -1, -1, -1, -1, -1, -1, -0, -0, -0, -0,
97 };
98 
99 static const int8_t quant11[256] = {
100  0, 1, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4,
101  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
102  4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
103  5, 5, 5, 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, -4, -4,
114  -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4,
115  -4, -4, -4, -4, -4, -3, -3, -3, -3, -3, -3, -3, -2, -2, -2, -1,
116 };
117 
118 static const uint8_t ver2_state[256] = {
119  0, 10, 10, 10, 10, 16, 16, 16, 28, 16, 16, 29, 42, 49, 20, 49,
120  59, 25, 26, 26, 27, 31, 33, 33, 33, 34, 34, 37, 67, 38, 39, 39,
121  40, 40, 41, 79, 43, 44, 45, 45, 48, 48, 64, 50, 51, 52, 88, 52,
122  53, 74, 55, 57, 58, 58, 74, 60, 101, 61, 62, 84, 66, 66, 68, 69,
123  87, 82, 71, 97, 73, 73, 82, 75, 111, 77, 94, 78, 87, 81, 83, 97,
124  85, 83, 94, 86, 99, 89, 90, 99, 111, 92, 93, 134, 95, 98, 105, 98,
125  105, 110, 102, 108, 102, 118, 103, 106, 106, 113, 109, 112, 114, 112, 116, 125,
126  115, 116, 117, 117, 126, 119, 125, 121, 121, 123, 145, 124, 126, 131, 127, 129,
127  165, 130, 132, 138, 133, 135, 145, 136, 137, 139, 146, 141, 143, 142, 144, 148,
128  147, 155, 151, 149, 151, 150, 152, 157, 153, 154, 156, 168, 158, 162, 161, 160,
129  172, 163, 169, 164, 166, 184, 167, 170, 177, 174, 171, 173, 182, 176, 180, 178,
130  175, 189, 179, 181, 186, 183, 192, 185, 200, 187, 191, 188, 190, 197, 193, 196,
131  197, 194, 195, 196, 198, 202, 199, 201, 210, 203, 207, 204, 205, 206, 208, 214,
132  209, 211, 221, 212, 213, 215, 224, 216, 217, 218, 219, 220, 222, 228, 223, 225,
133  226, 224, 227, 229, 240, 230, 231, 232, 233, 234, 235, 236, 238, 239, 237, 242,
134  241, 243, 242, 244, 245, 246, 247, 248, 249, 250, 251, 252, 252, 253, 254, 255,
135 };
136 
137 static void find_best_state(uint8_t best_state[256][256],
138  const uint8_t one_state[256])
139 {
140  int i, j, k, m;
141  double l2tab[256];
142 
143  for (i = 1; i < 256; i++)
144  l2tab[i] = log2(i / 256.0);
145 
146  for (i = 0; i < 256; i++) {
147  double best_len[256];
148  double p = i / 256.0;
149 
150  for (j = 0; j < 256; j++)
151  best_len[j] = 1 << 30;
152 
153  for (j = FFMAX(i - 10, 1); j < FFMIN(i + 11, 256); j++) {
154  double occ[256] = { 0 };
155  double len = 0;
156  occ[j] = 1.0;
157  for (k = 0; k < 256; k++) {
158  double newocc[256] = { 0 };
159  for (m = 1; m < 256; m++)
160  if (occ[m]) {
161  len -=occ[m]*( p *l2tab[ m]
162  + (1-p)*l2tab[256-m]);
163  }
164  if (len < best_len[k]) {
165  best_len[k] = len;
166  best_state[i][k] = j;
167  }
168  for (m = 0; m < 256; m++)
169  if (occ[m]) {
170  newocc[ one_state[ m]] += occ[m] * p;
171  newocc[256 - one_state[256 - m]] += occ[m] * (1 - p);
172  }
173  memcpy(occ, newocc, sizeof(occ));
174  }
175  }
176  }
177 }
178 
179 static av_always_inline av_flatten void put_symbol_inline(RangeCoder *c,
180  uint8_t *state, int v,
181  int is_signed,
182  uint64_t rc_stat[256][2],
183  uint64_t rc_stat2[32][2])
184 {
185  int i;
186 
187 #define put_rac(C, S, B) \
188  do { \
189  if (rc_stat) { \
190  rc_stat[*(S)][B]++; \
191  rc_stat2[(S) - state][B]++; \
192  } \
193  put_rac(C, S, B); \
194  } while (0)
195 
196  if (v) {
197  const int a = FFABS(v);
198  const int e = av_log2(a);
199  put_rac(c, state + 0, 0);
200  if (e <= 9) {
201  for (i = 0; i < e; i++)
202  put_rac(c, state + 1 + i, 1); // 1..10
203  put_rac(c, state + 1 + i, 0);
204 
205  for (i = e - 1; i >= 0; i--)
206  put_rac(c, state + 22 + i, (a >> i) & 1); // 22..31
207 
208  if (is_signed)
209  put_rac(c, state + 11 + e, v < 0); // 11..21
210  } else {
211  for (i = 0; i < e; i++)
212  put_rac(c, state + 1 + FFMIN(i, 9), 1); // 1..10
213  put_rac(c, state + 1 + 9, 0);
214 
215  for (i = e - 1; i >= 0; i--)
216  put_rac(c, state + 22 + FFMIN(i, 9), (a >> i) & 1); // 22..31
217 
218  if (is_signed)
219  put_rac(c, state + 11 + 10, v < 0); // 11..21
220  }
221  } else {
222  put_rac(c, state + 0, 1);
223  }
224 #undef put_rac
225 }
226 
227 static av_noinline void put_symbol(RangeCoder *c, uint8_t *state,
228  int v, int is_signed)
229 {
230  put_symbol_inline(c, state, v, is_signed, NULL, NULL);
231 }
232 
233 
234 static inline void put_vlc_symbol(PutBitContext *pb, VlcState *const state,
235  int v, int bits)
236 {
237  int i, k, code;
238  v = fold(v - state->bias, bits);
239 
240  i = state->count;
241  k = 0;
242  while (i < state->error_sum) { // FIXME: optimize
243  k++;
244  i += i;
245  }
246 
247  av_assert2(k <= 13);
248 
249 #if 0 // JPEG LS
250  if (k == 0 && 2 * state->drift <= -state->count)
251  code = v ^ (-1);
252  else
253  code = v;
254 #else
255  code = v ^ ((2 * state->drift + state->count) >> 31);
256 #endif
257 
258  av_dlog(NULL, "v:%d/%d bias:%d error:%d drift:%d count:%d k:%d\n", v, code,
259  state->bias, state->error_sum, state->drift, state->count, k);
260  set_sr_golomb(pb, code, k, 12, bits);
261 
262  update_vlc_state(state, v);
263 }
264 
265 static av_always_inline int encode_line(FFV1Context *s, int w,
266  int16_t *sample[3],
267  int plane_index, int bits)
268 {
269  PlaneContext *const p = &s->plane[plane_index];
270  RangeCoder *const c = &s->c;
271  int x;
272  int run_index = s->run_index;
273  int run_count = 0;
274  int run_mode = 0;
275 
276  if (s->ac) {
277  if (c->bytestream_end - c->bytestream < w * 20) {
278  av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
279  return AVERROR_INVALIDDATA;
280  }
281  } else {
282  if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) < w * 4) {
283  av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
284  return AVERROR_INVALIDDATA;
285  }
286  }
287 
288  for (x = 0; x < w; x++) {
289  int diff, context;
290 
291  context = get_context(p, sample[0] + x, sample[1] + x, sample[2] + x);
292  diff = sample[0][x] - predict(sample[0] + x, sample[1] + x);
293 
294  if (context < 0) {
295  context = -context;
296  diff = -diff;
297  }
298 
299  diff = fold(diff, bits);
300 
301  if (s->ac) {
302  if (s->flags & CODEC_FLAG_PASS1) {
303  put_symbol_inline(c, p->state[context], diff, 1, s->rc_stat,
304  s->rc_stat2[p->quant_table_index][context]);
305  } else {
306  put_symbol_inline(c, p->state[context], diff, 1, NULL, NULL);
307  }
308  } else {
309  if (context == 0)
310  run_mode = 1;
311 
312  if (run_mode) {
313  if (diff) {
314  while (run_count >= 1 << ff_log2_run[run_index]) {
315  run_count -= 1 << ff_log2_run[run_index];
316  run_index++;
317  put_bits(&s->pb, 1, 1);
318  }
319 
320  put_bits(&s->pb, 1 + ff_log2_run[run_index], run_count);
321  if (run_index)
322  run_index--;
323  run_count = 0;
324  run_mode = 0;
325  if (diff > 0)
326  diff--;
327  } else {
328  run_count++;
329  }
330  }
331 
332  av_dlog(s->avctx, "count:%d index:%d, mode:%d, x:%d pos:%d\n",
333  run_count, run_index, run_mode, x,
334  (int)put_bits_count(&s->pb));
335 
336  if (run_mode == 0)
337  put_vlc_symbol(&s->pb, &p->vlc_state[context], diff, bits);
338  }
339  }
340  if (run_mode) {
341  while (run_count >= 1 << ff_log2_run[run_index]) {
342  run_count -= 1 << ff_log2_run[run_index];
343  run_index++;
344  put_bits(&s->pb, 1, 1);
345  }
346 
347  if (run_count)
348  put_bits(&s->pb, 1, 1);
349  }
350  s->run_index = run_index;
351 
352  return 0;
353 }
354 
355 static void encode_plane(FFV1Context *s, uint8_t *src, int w, int h,
356  int stride, int plane_index)
357 {
358  int x, y, i;
359  const int ring_size = s->avctx->context_model ? 3 : 2;
360  int16_t *sample[3];
361  s->run_index = 0;
362 
363  memset(s->sample_buffer, 0, ring_size * (w + 6) * sizeof(*s->sample_buffer));
364 
365  for (y = 0; y < h; y++) {
366  for (i = 0; i < ring_size; i++)
367  sample[i] = s->sample_buffer + (w + 6) * ((h + i - y) % ring_size) + 3;
368 
369  sample[0][-1]= sample[1][0 ];
370  sample[1][ w]= sample[1][w-1];
371 // { START_TIMER
372  if (s->bits_per_raw_sample <= 8) {
373  for (x = 0; x < w; x++)
374  sample[0][x] = src[x + stride * y];
375  encode_line(s, w, sample, plane_index, 8);
376  } else {
377  if (s->packed_at_lsb) {
378  for (x = 0; x < w; x++) {
379  sample[0][x] = ((uint16_t*)(src + stride*y))[x];
380  }
381  } else {
382  for (x = 0; x < w; x++) {
383  sample[0][x] = ((uint16_t*)(src + stride*y))[x] >> (16 - s->bits_per_raw_sample);
384  }
385  }
386  encode_line(s, w, sample, plane_index, s->bits_per_raw_sample);
387  }
388 // STOP_TIMER("encode line") }
389  }
390 }
391 
392 static void encode_rgb_frame(FFV1Context *s, uint8_t *src[3], int w, int h, int stride[3])
393 {
394  int x, y, p, i;
395  const int ring_size = s->avctx->context_model ? 3 : 2;
396  int16_t *sample[4][3];
397  int lbd = s->bits_per_raw_sample <= 8;
398  int bits = s->bits_per_raw_sample > 0 ? s->bits_per_raw_sample : 8;
399  int offset = 1 << bits;
400 
401  s->run_index = 0;
402 
403  memset(s->sample_buffer, 0, ring_size * MAX_PLANES *
404  (w + 6) * sizeof(*s->sample_buffer));
405 
406  for (y = 0; y < h; y++) {
407  for (i = 0; i < ring_size; i++)
408  for (p = 0; p < MAX_PLANES; p++)
409  sample[p][i]= s->sample_buffer + p*ring_size*(w+6) + ((h+i-y)%ring_size)*(w+6) + 3;
410 
411  for (x = 0; x < w; x++) {
412  int b, g, r, av_uninit(a);
413  if (lbd) {
414  unsigned v = *((uint32_t*)(src[0] + x*4 + stride[0]*y));
415  b = v & 0xFF;
416  g = (v >> 8) & 0xFF;
417  r = (v >> 16) & 0xFF;
418  a = v >> 24;
419  } else {
420  b = *((uint16_t*)(src[0] + x*2 + stride[0]*y));
421  g = *((uint16_t*)(src[1] + x*2 + stride[1]*y));
422  r = *((uint16_t*)(src[2] + x*2 + stride[2]*y));
423  }
424 
425  b -= g;
426  r -= g;
427  g += (b + r) >> 2;
428  b += offset;
429  r += offset;
430 
431  sample[0][0][x] = g;
432  sample[1][0][x] = b;
433  sample[2][0][x] = r;
434  sample[3][0][x] = a;
435  }
436  for (p = 0; p < 3 + s->transparency; p++) {
437  sample[p][0][-1] = sample[p][1][0 ];
438  sample[p][1][ w] = sample[p][1][w-1];
439  if (lbd)
440  encode_line(s, w, sample[p], (p + 1) / 2, 9);
441  else
442  encode_line(s, w, sample[p], (p + 1) / 2, bits + 1);
443  }
444  }
445 }
446 
447 static void write_quant_table(RangeCoder *c, int16_t *quant_table)
448 {
449  int last = 0;
450  int i;
451  uint8_t state[CONTEXT_SIZE];
452  memset(state, 128, sizeof(state));
453 
454  for (i = 1; i < 128; i++)
455  if (quant_table[i] != quant_table[i - 1]) {
456  put_symbol(c, state, i - last - 1, 0);
457  last = i;
458  }
459  put_symbol(c, state, i - last - 1, 0);
460 }
461 
462 static void write_quant_tables(RangeCoder *c,
463  int16_t quant_table[MAX_CONTEXT_INPUTS][256])
464 {
465  int i;
466  for (i = 0; i < 5; i++)
467  write_quant_table(c, quant_table[i]);
468 }
469 
470 static void write_header(FFV1Context *f)
471 {
472  uint8_t state[CONTEXT_SIZE];
473  int i, j;
474  RangeCoder *const c = &f->slice_context[0]->c;
475 
476  memset(state, 128, sizeof(state));
477 
478  if (f->version < 2) {
479  put_symbol(c, state, f->version, 0);
480  put_symbol(c, state, f->ac, 0);
481  if (f->ac > 1) {
482  for (i = 1; i < 256; i++)
483  put_symbol(c, state,
484  f->state_transition[i] - c->one_state[i], 1);
485  }
486  put_symbol(c, state, f->colorspace, 0); //YUV cs type
487  if (f->version > 0)
488  put_symbol(c, state, f->bits_per_raw_sample, 0);
489  put_rac(c, state, f->chroma_planes);
490  put_symbol(c, state, f->chroma_h_shift, 0);
491  put_symbol(c, state, f->chroma_v_shift, 0);
492  put_rac(c, state, f->transparency);
493 
494  write_quant_tables(c, f->quant_table);
495  } else if (f->version < 3) {
496  put_symbol(c, state, f->slice_count, 0);
497  for (i = 0; i < f->slice_count; i++) {
498  FFV1Context *fs = f->slice_context[i];
499  put_symbol(c, state,
500  (fs->slice_x + 1) * f->num_h_slices / f->width, 0);
501  put_symbol(c, state,
502  (fs->slice_y + 1) * f->num_v_slices / f->height, 0);
503  put_symbol(c, state,
504  (fs->slice_width + 1) * f->num_h_slices / f->width - 1,
505  0);
506  put_symbol(c, state,
507  (fs->slice_height + 1) * f->num_v_slices / f->height - 1,
508  0);
509  for (j = 0; j < f->plane_count; j++) {
510  put_symbol(c, state, f->plane[j].quant_table_index, 0);
511  av_assert0(f->plane[j].quant_table_index == f->avctx->context_model);
512  }
513  }
514  }
515 }
516 
517 static int write_extradata(FFV1Context *f)
518 {
519  RangeCoder *const c = &f->c;
520  uint8_t state[CONTEXT_SIZE];
521  int i, j, k;
522  uint8_t state2[32][CONTEXT_SIZE];
523  unsigned v;
524 
525  memset(state2, 128, sizeof(state2));
526  memset(state, 128, sizeof(state));
527 
528  f->avctx->extradata_size = 10000 + 4 +
529  (11 * 11 * 5 * 5 * 5 + 11 * 11 * 11) * 32;
530  f->avctx->extradata = av_malloc(f->avctx->extradata_size);
531  ff_init_range_encoder(c, f->avctx->extradata, f->avctx->extradata_size);
532  ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
533 
534  put_symbol(c, state, f->version, 0);
535  if (f->version > 2) {
536  if (f->version == 3)
537  f->minor_version = 2;
538  put_symbol(c, state, f->minor_version, 0);
539  }
540 
541  put_symbol(c, state, f->ac, 0);
542  if (f->ac > 1)
543  for (i = 1; i < 256; i++)
544  put_symbol(c, state, f->state_transition[i] - c->one_state[i], 1);
545 
546  put_symbol(c, state, f->colorspace, 0); // YUV cs type
547  put_symbol(c, state, f->bits_per_raw_sample, 0);
548  put_rac(c, state, f->chroma_planes);
549  put_symbol(c, state, f->chroma_h_shift, 0);
550  put_symbol(c, state, f->chroma_v_shift, 0);
551  put_rac(c, state, f->transparency);
552  put_symbol(c, state, f->num_h_slices - 1, 0);
553  put_symbol(c, state, f->num_v_slices - 1, 0);
554 
555  put_symbol(c, state, f->quant_table_count, 0);
556  for (i = 0; i < f->quant_table_count; i++)
557  write_quant_tables(c, f->quant_tables[i]);
558 
559  for (i = 0; i < f->quant_table_count; i++) {
560  for (j = 0; j < f->context_count[i] * CONTEXT_SIZE; j++)
561  if (f->initial_states[i] && f->initial_states[i][0][j] != 128)
562  break;
563  if (j < f->context_count[i] * CONTEXT_SIZE) {
564  put_rac(c, state, 1);
565  for (j = 0; j < f->context_count[i]; j++)
566  for (k = 0; k < CONTEXT_SIZE; k++) {
567  int pred = j ? f->initial_states[i][j - 1][k] : 128;
568  put_symbol(c, state2[k],
569  (int8_t)(f->initial_states[i][j][k] - pred), 1);
570  }
571  } else {
572  put_rac(c, state, 0);
573  }
574  }
575 
576  if (f->version > 2) {
577  put_symbol(c, state, f->ec, 0);
578  }
579 
580  f->avctx->extradata_size = ff_rac_terminate(c);
581  v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, f->avctx->extradata, f->avctx->extradata_size);
582  AV_WL32(f->avctx->extradata + f->avctx->extradata_size, v);
583  f->avctx->extradata_size += 4;
584 
585  return 0;
586 }
587 
588 static int sort_stt(FFV1Context *s, uint8_t stt[256])
589 {
590  int i, i2, changed, print = 0;
591 
592  do {
593  changed = 0;
594  for (i = 12; i < 244; i++) {
595  for (i2 = i + 1; i2 < 245 && i2 < i + 4; i2++) {
596 
597 #define COST(old, new) \
598  s->rc_stat[old][0] * -log2((256 - (new)) / 256.0) + \
599  s->rc_stat[old][1] * -log2((new) / 256.0)
600 
601 #define COST2(old, new) \
602  COST(old, new) + COST(256 - (old), 256 - (new))
603 
604  double size0 = COST2(i, i) + COST2(i2, i2);
605  double sizeX = COST2(i, i2) + COST2(i2, i);
606  if (size0 - sizeX > size0*(1e-14) && i != 128 && i2 != 128) {
607  int j;
608  FFSWAP(int, stt[i], stt[i2]);
609  FFSWAP(int, s->rc_stat[i][0], s->rc_stat[i2][0]);
610  FFSWAP(int, s->rc_stat[i][1], s->rc_stat[i2][1]);
611  if (i != 256 - i2) {
612  FFSWAP(int, stt[256 - i], stt[256 - i2]);
613  FFSWAP(int, s->rc_stat[256 - i][0], s->rc_stat[256 - i2][0]);
614  FFSWAP(int, s->rc_stat[256 - i][1], s->rc_stat[256 - i2][1]);
615  }
616  for (j = 1; j < 256; j++) {
617  if (stt[j] == i)
618  stt[j] = i2;
619  else if (stt[j] == i2)
620  stt[j] = i;
621  if (i != 256 - i2) {
622  if (stt[256 - j] == 256 - i)
623  stt[256 - j] = 256 - i2;
624  else if (stt[256 - j] == 256 - i2)
625  stt[256 - j] = 256 - i;
626  }
627  }
628  print = changed = 1;
629  }
630  }
631  }
632  } while (changed);
633  return print;
634 }
635 
636 static av_cold int encode_init(AVCodecContext *avctx)
637 {
638  FFV1Context *s = avctx->priv_data;
639  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
640  int i, j, k, m, ret;
641 
642  ffv1_common_init(avctx);
643 
644  s->version = 0;
645 
646  if ((avctx->flags & (CODEC_FLAG_PASS1|CODEC_FLAG_PASS2)) || avctx->slices>1)
647  s->version = FFMAX(s->version, 2);
648 
649  if (avctx->level == 3) {
650  s->version = 3;
651  }
652 
653  if (s->ec < 0) {
654  s->ec = (s->version >= 3);
655  }
656 
657  if (s->version >= 2 && avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
658  av_log(avctx, AV_LOG_ERROR, "Version 2 needed for requested features but version 2 is experimental and not enabled\n");
659  return AVERROR_INVALIDDATA;
660  }
661 
662  s->ac = avctx->coder_type > 0 ? 2 : 0;
663 
664  s->plane_count = 3;
665  switch(avctx->pix_fmt) {
666  case AV_PIX_FMT_YUV444P9:
667  case AV_PIX_FMT_YUV422P9:
668  case AV_PIX_FMT_YUV420P9:
669  if (!avctx->bits_per_raw_sample)
670  s->bits_per_raw_sample = 9;
671  case AV_PIX_FMT_YUV444P10:
672  case AV_PIX_FMT_YUV420P10:
673  case AV_PIX_FMT_YUV422P10:
674  s->packed_at_lsb = 1;
675  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
676  s->bits_per_raw_sample = 10;
677  case AV_PIX_FMT_GRAY16:
678  case AV_PIX_FMT_YUV444P16:
679  case AV_PIX_FMT_YUV422P16:
680  case AV_PIX_FMT_YUV420P16:
681  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) {
682  s->bits_per_raw_sample = 16;
683  } else if (!s->bits_per_raw_sample) {
684  s->bits_per_raw_sample = avctx->bits_per_raw_sample;
685  }
686  if (s->bits_per_raw_sample <= 8) {
687  av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");
688  return AVERROR_INVALIDDATA;
689  }
690  if (!s->ac && avctx->coder_type == -1) {
691  av_log(avctx, AV_LOG_INFO, "bits_per_raw_sample > 8, forcing coder 1\n");
692  s->ac = 2;
693  }
694  if (!s->ac) {
695  av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample of more than 8 needs -coder 1 currently\n");
696  return AVERROR(ENOSYS);
697  }
698  s->version = FFMAX(s->version, 1);
699  case AV_PIX_FMT_GRAY8:
700  case AV_PIX_FMT_YUV444P:
701  case AV_PIX_FMT_YUV440P:
702  case AV_PIX_FMT_YUV422P:
703  case AV_PIX_FMT_YUV420P:
704  case AV_PIX_FMT_YUV411P:
705  case AV_PIX_FMT_YUV410P:
706  s->chroma_planes = desc->nb_components < 3 ? 0 : 1;
707  s->colorspace = 0;
708  break;
709  case AV_PIX_FMT_YUVA444P:
710  case AV_PIX_FMT_YUVA422P:
711  case AV_PIX_FMT_YUVA420P:
712  s->chroma_planes = 1;
713  s->colorspace = 0;
714  s->transparency = 1;
715  break;
716  case AV_PIX_FMT_RGB32:
717  s->colorspace = 1;
718  s->transparency = 1;
719  break;
720  case AV_PIX_FMT_0RGB32:
721  s->colorspace = 1;
722  break;
723  case AV_PIX_FMT_GBRP9:
724  if (!avctx->bits_per_raw_sample)
725  s->bits_per_raw_sample = 9;
726  case AV_PIX_FMT_GBRP10:
727  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
728  s->bits_per_raw_sample = 10;
729  case AV_PIX_FMT_GBRP12:
730  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
731  s->bits_per_raw_sample = 12;
732  case AV_PIX_FMT_GBRP14:
733  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
734  s->bits_per_raw_sample = 14;
735  else if (!s->bits_per_raw_sample)
736  s->bits_per_raw_sample = avctx->bits_per_raw_sample;
737  s->colorspace = 1;
738  s->chroma_planes = 1;
739  s->version = FFMAX(s->version, 1);
740  break;
741  default:
742  av_log(avctx, AV_LOG_ERROR, "format not supported\n");
743  return AVERROR(ENOSYS);
744  }
745  if (s->transparency) {
746  av_log(avctx, AV_LOG_WARNING, "Storing alpha plane, this will require a recent FFV1 decoder to playback!\n");
747  }
748  if (avctx->context_model > 1U) {
749  av_log(avctx, AV_LOG_ERROR, "Invalid context model %d, valid values are 0 and 1\n", avctx->context_model);
750  return AVERROR(EINVAL);
751  }
752 
753  if (s->ac > 1)
754  for (i = 1; i < 256; i++)
755  s->state_transition[i] = ver2_state[i];
756 
757  for (i = 0; i < 256; i++) {
758  s->quant_table_count = 2;
759  if (s->bits_per_raw_sample <= 8) {
760  s->quant_tables[0][0][i]= quant11[i];
761  s->quant_tables[0][1][i]= 11*quant11[i];
762  s->quant_tables[0][2][i]= 11*11*quant11[i];
763  s->quant_tables[1][0][i]= quant11[i];
764  s->quant_tables[1][1][i]= 11*quant11[i];
765  s->quant_tables[1][2][i]= 11*11*quant5 [i];
766  s->quant_tables[1][3][i]= 5*11*11*quant5 [i];
767  s->quant_tables[1][4][i]= 5*5*11*11*quant5 [i];
768  } else {
769  s->quant_tables[0][0][i]= quant9_10bit[i];
770  s->quant_tables[0][1][i]= 11*quant9_10bit[i];
771  s->quant_tables[0][2][i]= 11*11*quant9_10bit[i];
772  s->quant_tables[1][0][i]= quant9_10bit[i];
773  s->quant_tables[1][1][i]= 11*quant9_10bit[i];
774  s->quant_tables[1][2][i]= 11*11*quant5_10bit[i];
775  s->quant_tables[1][3][i]= 5*11*11*quant5_10bit[i];
776  s->quant_tables[1][4][i]= 5*5*11*11*quant5_10bit[i];
777  }
778  }
779  s->context_count[0] = (11 * 11 * 11 + 1) / 2;
780  s->context_count[1] = (11 * 11 * 5 * 5 * 5 + 1) / 2;
781  memcpy(s->quant_table, s->quant_tables[avctx->context_model],
782  sizeof(s->quant_table));
783 
784  for (i = 0; i < s->plane_count; i++) {
785  PlaneContext *const p = &s->plane[i];
786 
787  memcpy(p->quant_table, s->quant_table, sizeof(p->quant_table));
788  p->quant_table_index = avctx->context_model;
789  p->context_count = s->context_count[p->quant_table_index];
790  }
791 
792  if ((ret = ffv1_allocate_initial_states(s)) < 0)
793  return ret;
794 
795  avctx->coded_frame = &s->picture;
796  if (!s->transparency)
797  s->plane_count = 2;
798  avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
799  s->picture_number = 0;
800 
801  if (avctx->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2)) {
802  for (i = 0; i < s->quant_table_count; i++) {
803  s->rc_stat2[i] = av_mallocz(s->context_count[i] *
804  sizeof(*s->rc_stat2[i]));
805  if (!s->rc_stat2[i])
806  return AVERROR(ENOMEM);
807  }
808  }
809  if (avctx->stats_in) {
810  char *p = avctx->stats_in;
811  uint8_t best_state[256][256];
812  int gob_count = 0;
813  char *next;
814 
815  av_assert0(s->version >= 2);
816 
817  for (;;) {
818  for (j = 0; j < 256; j++)
819  for (i = 0; i < 2; i++) {
820  s->rc_stat[j][i] = strtol(p, &next, 0);
821  if (next == p) {
822  av_log(avctx, AV_LOG_ERROR,
823  "2Pass file invalid at %d %d [%s]\n", j, i, p);
824  return AVERROR_INVALIDDATA;
825  }
826  p = next;
827  }
828  for (i = 0; i < s->quant_table_count; i++)
829  for (j = 0; j < s->context_count[i]; j++) {
830  for (k = 0; k < 32; k++)
831  for (m = 0; m < 2; m++) {
832  s->rc_stat2[i][j][k][m] = strtol(p, &next, 0);
833  if (next == p) {
834  av_log(avctx, AV_LOG_ERROR,
835  "2Pass file invalid at %d %d %d %d [%s]\n",
836  i, j, k, m, p);
837  return AVERROR_INVALIDDATA;
838  }
839  p = next;
840  }
841  }
842  gob_count = strtol(p, &next, 0);
843  if (next == p || gob_count <= 0) {
844  av_log(avctx, AV_LOG_ERROR, "2Pass file invalid\n");
845  return AVERROR_INVALIDDATA;
846  }
847  p = next;
848  while (*p == '\n' || *p == ' ')
849  p++;
850  if (p[0] == 0)
851  break;
852  }
853  sort_stt(s, s->state_transition);
854 
855  find_best_state(best_state, s->state_transition);
856 
857  for (i = 0; i < s->quant_table_count; i++) {
858  for (k = 0; k < 32; k++) {
859  double a=0, b=0;
860  int jp = 0;
861  for (j = 0; j < s->context_count[i]; j++) {
862  double p = 128;
863  if (s->rc_stat2[i][j][k][0] + s->rc_stat2[i][j][k][1] > 200 && j || a+b > 200) {
864  if (a+b)
865  p = 256.0 * b / (a + b);
866  s->initial_states[i][jp][k] =
867  best_state[av_clip(round(p), 1, 255)][av_clip((a + b) / gob_count, 0, 255)];
868  for(jp++; jp<j; jp++)
869  s->initial_states[i][jp][k] = s->initial_states[i][jp-1][k];
870  a=b=0;
871  }
872  a += s->rc_stat2[i][j][k][0];
873  b += s->rc_stat2[i][j][k][1];
874  if (a+b) {
875  p = 256.0 * b / (a + b);
876  }
877  s->initial_states[i][j][k] =
878  best_state[av_clip(round(p), 1, 255)][av_clip((a + b) / gob_count, 0, 255)];
879  }
880  }
881  }
882  }
883 
884  if (s->version > 1) {
885  s->num_v_slices = (avctx->width > 352 || avctx->height > 288 || !avctx->slices) ? 2 : 1;
886  for (; s->num_v_slices < 9; s->num_v_slices++) {
887  for (s->num_h_slices = s->num_v_slices; s->num_h_slices < 2*s->num_v_slices; s->num_h_slices++) {
888  if (avctx->slices == s->num_h_slices * s->num_v_slices && avctx->slices <= 64 || !avctx->slices)
889  goto slices_ok;
890  }
891  }
892  av_log(avctx, AV_LOG_ERROR,
893  "Unsupported number %d of slices requested, please specify a "
894  "supported number with -slices (ex:4,6,9,12,16, ...)\n",
895  avctx->slices);
896  return AVERROR(ENOSYS);
897 slices_ok:
898  write_extradata(s);
899  }
900 
901  if ((ret = ffv1_init_slice_contexts(s)) < 0)
902  return ret;
903  if ((ret = ffv1_init_slices_state(s)) < 0)
904  return ret;
905 
906 #define STATS_OUT_SIZE 1024 * 1024 * 6
907  if (avctx->flags & CODEC_FLAG_PASS1) {
908  avctx->stats_out = av_mallocz(STATS_OUT_SIZE);
909  if (!avctx->stats_out)
910  return AVERROR(ENOMEM);
911  for (i = 0; i < s->quant_table_count; i++)
912  for (j = 0; j < s->slice_count; j++) {
913  FFV1Context *sf = s->slice_context[j];
914  av_assert0(!sf->rc_stat2[i]);
915  sf->rc_stat2[i] = av_mallocz(s->context_count[i] *
916  sizeof(*sf->rc_stat2[i]));
917  if (!sf->rc_stat2[i])
918  return AVERROR(ENOMEM);
919  }
920  }
921 
922  return 0;
923 }
924 
925 static void encode_slice_header(FFV1Context *f, FFV1Context *fs)
926 {
927  RangeCoder *c = &fs->c;
928  uint8_t state[CONTEXT_SIZE];
929  int j;
930  memset(state, 128, sizeof(state));
931 
932  put_symbol(c, state, (fs->slice_x +1)*f->num_h_slices / f->width , 0);
933  put_symbol(c, state, (fs->slice_y +1)*f->num_v_slices / f->height , 0);
934  put_symbol(c, state, (fs->slice_width +1)*f->num_h_slices / f->width -1, 0);
935  put_symbol(c, state, (fs->slice_height+1)*f->num_v_slices / f->height-1, 0);
936  for (j=0; j<f->plane_count; j++) {
937  put_symbol(c, state, f->plane[j].quant_table_index, 0);
938  av_assert0(f->plane[j].quant_table_index == f->avctx->context_model);
939  }
940  if (!f->picture.interlaced_frame)
941  put_symbol(c, state, 3, 0);
942  else
943  put_symbol(c, state, 1 + !f->picture.top_field_first, 0);
944  put_symbol(c, state, f->picture.sample_aspect_ratio.num, 0);
945  put_symbol(c, state, f->picture.sample_aspect_ratio.den, 0);
946 }
947 
948 static int encode_slice(AVCodecContext *c, void *arg)
949 {
950  FFV1Context *fs = *(void **)arg;
951  FFV1Context *f = fs->avctx->priv_data;
952  int width = fs->slice_width;
953  int height = fs->slice_height;
954  int x = fs->slice_x;
955  int y = fs->slice_y;
956  AVFrame *const p = &f->picture;
957  const int ps = av_pix_fmt_desc_get(c->pix_fmt)->comp[0].step_minus1 + 1;
958 
959  if (p->key_frame)
960  ffv1_clear_slice_state(f, fs);
961  if (f->version > 2) {
962  encode_slice_header(f, fs);
963  }
964  if (!fs->ac) {
965  if (f->version > 2)
966  put_rac(&fs->c, (uint8_t[]) { 129 }, 0);
967  fs->ac_byte_count = f->version > 2 || (!x && !y) ? ff_rac_terminate(&fs->c) : 0;
968  init_put_bits(&fs->pb,
969  fs->c.bytestream_start + fs->ac_byte_count,
970  fs->c.bytestream_end - fs->c.bytestream_start - fs->ac_byte_count);
971  }
972 
973  if (f->colorspace == 0) {
974  const int chroma_width = -((-width) >> f->chroma_h_shift);
975  const int chroma_height = -((-height) >> f->chroma_v_shift);
976  const int cx = x >> f->chroma_h_shift;
977  const int cy = y >> f->chroma_v_shift;
978 
979  encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0);
980 
981  if (f->chroma_planes) {
982  encode_plane(fs, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1);
983  encode_plane(fs, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1);
984  }
985  if (fs->transparency)
986  encode_plane(fs, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], 2);
987  } else {
988  uint8_t *planes[3] = {p->data[0] + ps*x + y*p->linesize[0],
989  p->data[1] + ps*x + y*p->linesize[1],
990  p->data[2] + ps*x + y*p->linesize[2]};
991  encode_rgb_frame(fs, planes, width, height, p->linesize);
992  }
993  emms_c();
994 
995  return 0;
996 }
997 
998 static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
999  const AVFrame *pict, int *got_packet)
1000 {
1001  FFV1Context *f = avctx->priv_data;
1002  RangeCoder *const c = &f->slice_context[0]->c;
1003  AVFrame *const p = &f->picture;
1004  int used_count = 0;
1005  uint8_t keystate = 128;
1006  uint8_t *buf_p;
1007  int i, ret;
1008 
1009  if ((ret = ff_alloc_packet2(avctx, pkt, avctx->width*avctx->height*((8*2+1+1)*4)/8
1010  + FF_MIN_BUFFER_SIZE)) < 0)
1011  return ret;
1012 
1013  ff_init_range_encoder(c, pkt->data, pkt->size);
1014  ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
1015 
1016  *p = *pict;
1017  p->pict_type = AV_PICTURE_TYPE_I;
1018 
1019  if (avctx->gop_size == 0 || f->picture_number % avctx->gop_size == 0) {
1020  put_rac(c, &keystate, 1);
1021  p->key_frame = 1;
1022  f->gob_count++;
1023  write_header(f);
1024  } else {
1025  put_rac(c, &keystate, 0);
1026  p->key_frame = 0;
1027  }
1028 
1029  if (f->ac > 1) {
1030  int i;
1031  for (i = 1; i < 256; i++) {
1032  c->one_state[i] = f->state_transition[i];
1033  c->zero_state[256 - i] = 256 - c->one_state[i];
1034  }
1035  }
1036 
1037  for (i = 1; i < f->slice_count; i++) {
1038  FFV1Context *fs = f->slice_context[i];
1039  uint8_t *start = pkt->data + (pkt->size - used_count) * (int64_t)i / f->slice_count;
1040  int len = pkt->size / f->slice_count;
1041  ff_init_range_encoder(&fs->c, start, len);
1042  }
1043  avctx->execute(avctx, encode_slice, &f->slice_context[0], NULL,
1044  f->slice_count, sizeof(void *));
1045 
1046  buf_p = pkt->data;
1047  for (i = 0; i < f->slice_count; i++) {
1048  FFV1Context *fs = f->slice_context[i];
1049  int bytes;
1050 
1051  if (fs->ac) {
1052  uint8_t state = 129;
1053  put_rac(&fs->c, &state, 0);
1054  bytes = ff_rac_terminate(&fs->c);
1055  } else {
1056  flush_put_bits(&fs->pb); // FIXME: nicer padding
1057  bytes = fs->ac_byte_count + (put_bits_count(&fs->pb) + 7) / 8;
1058  }
1059  if (i > 0 || f->version > 2) {
1060  av_assert0(bytes < pkt->size / f->slice_count);
1061  memmove(buf_p, fs->c.bytestream_start, bytes);
1062  av_assert0(bytes < (1 << 24));
1063  AV_WB24(buf_p + bytes, bytes);
1064  bytes += 3;
1065  }
1066  if (f->ec) {
1067  unsigned v;
1068  buf_p[bytes++] = 0;
1069  v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, buf_p, bytes);
1070  AV_WL32(buf_p + bytes, v);
1071  bytes += 4;
1072  }
1073  buf_p += bytes;
1074  }
1075 
1076  if ((avctx->flags & CODEC_FLAG_PASS1) && (f->picture_number & 31) == 0) {
1077  int j, k, m;
1078  char *p = avctx->stats_out;
1079  char *end = p + STATS_OUT_SIZE;
1080 
1081  memset(f->rc_stat, 0, sizeof(f->rc_stat));
1082  for (i = 0; i < f->quant_table_count; i++)
1083  memset(f->rc_stat2[i], 0, f->context_count[i] * sizeof(*f->rc_stat2[i]));
1084 
1085  for (j = 0; j < f->slice_count; j++) {
1086  FFV1Context *fs = f->slice_context[j];
1087  for (i = 0; i < 256; i++) {
1088  f->rc_stat[i][0] += fs->rc_stat[i][0];
1089  f->rc_stat[i][1] += fs->rc_stat[i][1];
1090  }
1091  for (i = 0; i < f->quant_table_count; i++) {
1092  for (k = 0; k < f->context_count[i]; k++)
1093  for (m = 0; m < 32; m++) {
1094  f->rc_stat2[i][k][m][0] += fs->rc_stat2[i][k][m][0];
1095  f->rc_stat2[i][k][m][1] += fs->rc_stat2[i][k][m][1];
1096  }
1097  }
1098  }
1099 
1100  for (j = 0; j < 256; j++) {
1101  snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1102  f->rc_stat[j][0], f->rc_stat[j][1]);
1103  p += strlen(p);
1104  }
1105  snprintf(p, end - p, "\n");
1106 
1107  for (i = 0; i < f->quant_table_count; i++) {
1108  for (j = 0; j < f->context_count[i]; j++)
1109  for (m = 0; m < 32; m++) {
1110  snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1111  f->rc_stat2[i][j][m][0], f->rc_stat2[i][j][m][1]);
1112  p += strlen(p);
1113  }
1114  }
1115  snprintf(p, end - p, "%d\n", f->gob_count);
1116  } else if (avctx->flags & CODEC_FLAG_PASS1)
1117  avctx->stats_out[0] = '\0';
1118 
1119  f->picture_number++;
1120  pkt->size = buf_p - pkt->data;
1121  pkt->flags |= AV_PKT_FLAG_KEY * p->key_frame;
1122  *got_packet = 1;
1123 
1124  return 0;
1125 }
1126 
1127 #define OFFSET(x) offsetof(FFV1Context, x)
1128 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1129 static const AVOption options[] = {
1130  { "slicecrc", "Protect slices with CRCs", OFFSET(ec), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1, VE },
1131  { NULL }
1132 };
1133 
1134 static const AVClass class = {
1135  .class_name = "ffv1 encoder",
1136  .item_name = av_default_item_name,
1137  .option = options,
1138  .version = LIBAVUTIL_VERSION_INT,
1139 };
1140 
1141 static const AVCodecDefault ffv1_defaults[] = {
1142  { "coder", "-1" },
1143  { NULL },
1144 };
1145 
1146 AVCodec ff_ffv1_encoder = {
1147  .name = "ffv1",
1148  .type = AVMEDIA_TYPE_VIDEO,
1149  .id = AV_CODEC_ID_FFV1,
1150  .priv_data_size = sizeof(FFV1Context),
1151  .init = encode_init,
1152  .encode2 = encode_frame,
1153  .close = ffv1_close,
1154  .capabilities = CODEC_CAP_SLICE_THREADS,
1155  .pix_fmts = (const enum AVPixelFormat[]) {
1156  AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV444P,
1157  AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV411P,
1158  AV_PIX_FMT_YUV410P, AV_PIX_FMT_0RGB32, AV_PIX_FMT_RGB32, AV_PIX_FMT_YUV420P16,
1159  AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16, AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV422P9,
1160  AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
1161  AV_PIX_FMT_GRAY16, AV_PIX_FMT_GRAY8, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
1162  AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14,
1163  AV_PIX_FMT_NONE
1164 
1165  },
1166  .long_name = NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1167  .defaults = ffv1_defaults,
1168  .priv_class = &class,
1169 };
fold
static av_always_inline int fold(int diff, int bits)
Definition: ffv1.h:138
ffv1_allocate_initial_states
int ffv1_allocate_initial_states(FFV1Context *f)
Definition: ffv1.c:146
start
Definition: start.py:1
av_mallocz
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:205
ff_log2_run
const uint8_t ff_log2_run[41]
Definition: bitstream.c:37
v
float v
Definition: avf_showspectrum.c:88
ffv1_defaults
static const AVCodecDefault ffv1_defaults[]
Definition: ffv1enc.c:1141
s
const char * s
Definition: avisynth_c.h:668
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
encode_plane
static void encode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index)
Definition: ffv1enc.c:355
encode_rgb_frame
static void encode_rgb_frame(FFV1Context *s, uint8_t *src[3], int w, int h, int stride[3])
Definition: ffv1enc.c:392
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:1778
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:76
ff_init_range_encoder
void ff_init_range_encoder(RangeCoder *c, uint8_t *buf, int buf_size)
Definition: rangecoder.c:41
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:275
AVOption
AVOption.
Definition: opt.h:251
encode_slice_header
static void encode_slice_header(FFV1Context *f, FFV1Context *fs)
Definition: ffv1enc.c:925
ffv1_common_init
av_cold int ffv1_common_init(AVCodecContext *avctx)
Definition: ffv1.c:41
CODEC_FLAG_PASS2
#define CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
Definition: libavcodec/avcodec.h:705
FFV1Context::flags
int flags
Definition: ffv1.h:90
av_default_item_name
av_default_item_name
Definition: libvo-amrwbenc.c:49
AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:73
imgutils.h
misc image utilities
PlaneContext::quant_table
int16_t quant_table[MAX_CONTEXT_INPUTS][256]
Definition: ffv1.h:66
FFV1Context::quant_table_count
int quant_table_count
Definition: ffv1.h:116
CODEC_FLAG_PASS1
#define CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
Definition: libavcodec/avcodec.h:704
AVCodecContext::coded_frame
AVFrame * coded_frame
the picture in the bitstream
Definition: libavcodec/avcodec.h:2567
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
AV_OPT_TYPE_INT
Definition: opt.h:222
FFV1Context::slice_height
int slice_height
Definition: ffv1.h:125
MAX_CONTEXT_INPUTS
#define MAX_CONTEXT_INPUTS
Definition: ffv1.h:54
FFV1Context::sample_buffer
int16_t * sample_buffer
Definition: ffv1.h:106
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:154
FFV1Context::version
int version
Definition: ffv1.h:84
RangeCoder::zero_state
uint8_t zero_state[256]
Definition: rangecoder.h:40
rangecoder.h
Range coder.
RangeCoder::bytestream_end
uint8_t * bytestream_end
Definition: rangecoder.h:44
AVRational::num
int num
numerator
Definition: rational.h:44
AV_PIX_FMT_GBRP10
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:295
f
Sinusoidal phase f
Definition: FFT of a Simple Sinusoid.m:8
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: libavcodec/avcodec.h:1330
AVCodecContext::stats_in
char * stats_in
pass2 encoding statistics input buffer Concatenated stuff from stats_out of pass1 should be placed he...
Definition: libavcodec/avcodec.h:2367
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:179
av_dlog
av_dlog(ac->avr,"%d samples - audio_convert: %s to %s (%s)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt), use_generic?ac->func_descr_generic:ac->func_descr)
FFV1Context::rc_stat2
uint64_t(*[MAX_QUANT_TABLES] rc_stat2)[32][2]
Definition: ffv1.h:83
AVCodecContext::bits_per_raw_sample
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: libavcodec/avcodec.h:2553
ffv1.h
FF Video Codec 1 (a lossless codec)
predict
static av_always_inline void predict(PredictorState *ps, float *coef, int output_enable)
Definition: libavcodec/aacdec.c:1611
sample
#define sample
Definition: flacdsp_template.c:44
FFV1Context::height
int height
Definition: ffv1.h:86
stride
int stride
Definition: mace.c:144
RangeCoder::one_state
uint8_t one_state[256]
Definition: rangecoder.h:41
w
output residual component w
Definition: code Kat/hpsmodel.m:23
FFV1Context::plane_count
int plane_count
Definition: ffv1.h:95
ff_rac_terminate
int ff_rac_terminate(RangeCoder *c)
Definition: rangecoder.c:101
write_quant_tables
static void write_quant_tables(RangeCoder *c, int16_t quant_table[MAX_CONTEXT_INPUTS][256])
Definition: ffv1enc.c:462
AV_WL32
#define AV_WL32(p, darg)
Definition: intreadwrite.h:282
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:55
AVCodecContext::context_model
int context_model
context model
Definition: libavcodec/avcodec.h:2252
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
FFV1Context::rc_stat
uint64_t rc_stat[256][2]
Definition: ffv1.h:82
FFV1Context::pb
PutBitContext pb
Definition: ffv1.h:81
AV_PIX_FMT_YUVA420P
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
Definition: pixfmt.h:105
bits
uint8_t bits
Definition: crc.c:216
AVPixFmtDescriptor::comp
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:86
uint8_t
uint8_t
Definition: audio_convert.c:194
av_cold
#define av_cold
Definition: attributes.h:78
put_symbol
static av_noinline void put_symbol(RangeCoder *c, uint8_t *state, int v, int is_signed)
Definition: ffv1enc.c:227
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:63
opt.h
AVOptions.
m
window constants for m
Definition: extra/genbh92lobe.m:9
av_crc_get_table
const AVCRC * av_crc_get_table(AVCRCId crc_id)
Get an initialized standard CRC table.
Definition: crc.c:261
VlcState::bias
int8_t bias
Definition: ffv1.h:61
pkt
static AVPacket pkt
Definition: demuxing.c:56
b
#define b
Definition: input.c:42
FFV1Context::c
RangeCoder c
Definition: ffv1.h:79
end
end end
Definition: extra/f0detection.m:15
emms_c
#define emms_c()
Definition: libavutil/internal.h:48
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: libavcodec/avcodec.h:1242
encode_init
static av_cold int encode_init(AVCodecContext *avctx)
Definition: ffv1enc.c:636
AV_PIX_FMT_GBRP9
#define AV_PIX_FMT_GBRP9
Definition: pixfmt.h:294
quant11
static const int8_t quant11[256]
Definition: ffv1enc.c:99
FFV1Context::slice_y
int slice_y
Definition: ffv1.h:127
FFV1Context::initial_states
uint8_t(*[MAX_QUANT_TABLES] initial_states)[32]
Definition: ffv1.h:103
AVCodecContext::coder_type
int coder_type
coder type
Definition: libavcodec/avcodec.h:2245
AVPacket::data
uint8_t * data
Definition: libavcodec/avcodec.h:1051
VlcState::count
uint8_t count
Definition: ffv1.h:62
encode_slice
static int encode_slice(AVCodecContext *c, void *arg)
Definition: ffv1enc.c:948
AV_PIX_FMT_YUV444P16
#define AV_PIX_FMT_YUV444P16
Definition: pixfmt.h:290
AVFrame::interlaced_frame
int interlaced_frame
The content of the picture is interlaced.
Definition: frame.h:270
PlaneContext::vlc_state
VlcState * vlc_state
Definition: ffv1.h:70
AVCodecContext::stats_out
char * stats_out
pass1 encoding statistics output buffer
Definition: libavcodec/avcodec.h:2359
timer.h
high precision timer, useful to profile code
FFV1Context::minor_version
int minor_version
Definition: ffv1.h:85
FFV1Context
struct FFV1Context FFV1Context
write_extradata
static int write_extradata(FFV1Context *f)
Definition: ffv1enc.c:517
FFV1Context::bits_per_raw_sample
int bits_per_raw_sample
Definition: ffv1.h:112
FFV1Context::slice_width
int slice_width
Definition: ffv1.h:124
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: libavcodec/avcodec.h:1101
ffv1_init_slices_state
int ffv1_init_slices_state(FFV1Context *f)
Definition: ffv1.c:99
x
Discrete Time axis x
Definition: FFT of a Simple Sinusoid.m:10
U
#define U(x)
Definition: arm/vp56_arith.h:37
sort_stt
static int sort_stt(FFV1Context *s, uint8_t stt[256])
Definition: ffv1enc.c:588
ver2_state
static const uint8_t ver2_state[256]
Definition: ffv1enc.c:118
AV_PIX_FMT_YUVA422P
planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
Definition: pixfmt.h:219
FFV1Context::quant_tables
int16_t quant_tables[MAX_QUANT_TABLES][MAX_CONTEXT_INPUTS][256]
Definition: ffv1.h:100
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: libavutil/internal.h:123
r
const char * r
Definition: vf_curves.c:94
PlaneContext::context_count
int context_count
Definition: ffv1.h:68
arg
const char * arg
Definition: libavcodec/jacosubdec.c:69
AVCodecContext::flags
int flags
CODEC_FLAG_*.
Definition: libavcodec/avcodec.h:1222
PutBitContext::buf
uint8_t * buf
Definition: put_bits.h:44
avassert.h
simple assert() macros that are a bit more flexible than ISO C assert().
av_log
void av_log(void *avcl, int level, const char *fmt,...)
Definition: log.c:246
AVCodec::name
const char * name
Name of the codec implementation.
Definition: libavcodec/avcodec.h:2861
round
static av_always_inline av_const double round(double x)
Definition: libm.h:162
quant5
static const int8_t quant5[256]
Definition: ffv1enc.c:61
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:281
offset
static const uint8_t offset[127][2]
Definition: vf_spp.c:70
put_bits
static void put_bits(J2kEncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:160
FFMAX
#define FFMAX(a, b)
Definition: common.h:56
avcodec.h
external API header
size
int size
Definition: twinvq_data.h:11127
RangeCoder::bytestream
uint8_t * bytestream
Definition: rangecoder.h:43
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: libavcodec/avcodec.h:1057
put_bits_count
static int put_bits_count(PutBitContext *s)
Definition: put_bits.h:73
AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:72
encode_line
static av_always_inline int encode_line(FFV1Context *s, int w, int16_t *sample[3], int plane_index, int bits)
Definition: ffv1enc.c:265
FFV1Context::ac
int ac
1=range coder <-> 0=golomb rice
Definition: ffv1.h:96
FFV1Context::quant_table
int16_t quant_table[MAX_CONTEXT_INPUTS][256]
Definition: ffv1.h:99
FFV1Context::run_index
int run_index
Definition: ffv1.h:104
VlcState
Definition: ffv1.h:58
AV_PIX_FMT_YUV422P9
#define AV_PIX_FMT_YUV422P9
Definition: pixfmt.h:277
av_flatten
#define av_flatten
Definition: attributes.h:84
FF_COMPLIANCE_EXPERIMENTAL
#define FF_COMPLIANCE_EXPERIMENTAL
Allow nonstandardized experimental things.
Definition: libavcodec/avcodec.h:2409
encode_frame
static int encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pict, int *got_packet)
Definition: ffv1enc.c:998
FFV1Context::state_transition
uint8_t state_transition[256]
Definition: ffv1.h:102
AVPixFmtDescriptor::nb_components
uint8_t nb_components
The number of components each pixel has, (1-4)
Definition: pixdesc.h:57
g
FFT buffer for g
Definition: stft_peak.m:17
AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:216
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:144
AV_PIX_FMT_GRAY16
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:266
FFMIN
#define FFMIN(a, b)
Definition: common.h:58
FF_MIN_BUFFER_SIZE
#define FF_MIN_BUFFER_SIZE
minimum encoding buffer size Used to avoid some checks during header writing.
Definition: libavcodec/avcodec.h:568
FFV1Context::num_h_slices
int num_h_slices
Definition: ffv1.h:123
ret
ret
Definition: avfilter.c:821
AVCodecContext::width
int width
picture width / height.
Definition: libavcodec/avcodec.h:1302
FFV1Context::colorspace
int colorspace
Definition: ffv1.h:105
quant_table
static float quant_table[96]
Definition: binkaudio.c:43
get_context
static int get_context(PlaneContext *p, int16_t *src, int16_t *last, int16_t *last2)
Definition: ffv1.h:160
MAX_PLANES
#define MAX_PLANES
Definition: ffv1.h:50
update_vlc_state
static void update_vlc_state(VlcState *const state, const int v)
Definition: ffv1.h:182
FFV1Context::slice_count
int slice_count
Definition: ffv1.h:121
AV_WB24
#define AV_WB24(p, d)
Definition: intreadwrite.h:442
ff_ffv1_encoder
AVCodec ff_ffv1_encoder
Definition: ffv1enc.c:1146
ff_build_rac_states
void ff_build_rac_states(RangeCoder *c, int factor, int max_p)
Definition: rangecoder.c:60
FFABS
#define FFABS(a)
Definition: common.h:53
FFV1Context::ac_byte_count
int ac_byte_count
number of bytes used for AC coding
Definition: ffv1.h:97
diff
#define diff(a, as, b, bs)
Definition: vf_phase.c:80
VlcState::drift
int16_t drift
Definition: ffv1.h:59
avcodec_get_chroma_sub_sample
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:65
FFV1Context::packed_at_lsb
int packed_at_lsb
Definition: ffv1.h:113
AV_PIX_FMT_YUV444P9
#define AV_PIX_FMT_YUV444P9
Definition: pixfmt.h:278
AV_PIX_FMT_GBRP14
#define AV_PIX_FMT_GBRP14
Definition: pixfmt.h:297
LIBAVUTIL_VERSION_INT
LIBAVUTIL_VERSION_INT
Definition: eval.c:55
ff_alloc_packet2
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int size)
Check AVPacket size and/or allocate data.
Definition: libavcodec/utils.c:1377
ffv1_init_slice_contexts
av_cold int ffv1_init_slice_contexts(FFV1Context *f)
Definition: ffv1.c:110
VE
#define VE
Definition: ffv1enc.c:1128
options
static const AVOption options[]
Definition: ffv1enc.c:1129
pred
static const float pred[4]
Definition: siprdata.h:259
AV_PIX_FMT_YUV420P16
#define AV_PIX_FMT_YUV420P16
Definition: pixfmt.h:288
k
for k
Definition: genspecsines_sin.m:6
NULL
NULL
Definition: eval.c:55
code
or the Software in violation of any applicable export control laws in any jurisdiction Except as provided by mandatorily applicable UPF has no obligation to provide you with source code to the Software In the event Software contains any source code
Definition: MELODIA - License.txt:24
width
static int width
Definition: tests/utils.c:158
FFV1Context::context_count
int context_count[MAX_QUANT_TABLES]
Definition: ffv1.h:101
quant9_10bit
static const int8_t quant9_10bit[256]
Definition: ffv1enc.c:80
src
AVS_Value src
Definition: avisynth_c.h:523
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:101
STATS_OUT_SIZE
#define STATS_OUT_SIZE
AV_PIX_FMT_YUVA444P
planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
Definition: pixfmt.h:218
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:55
AVCodecContext
main external API structure.
Definition: libavcodec/avcodec.h:1134
close
static void close(AVCodecParserContext *s)
Definition: h264_parser.c:375
AV_PIX_FMT_RGB32
#define AV_PIX_FMT_RGB32
Definition: pixfmt.h:259
AVFrame::sample_aspect_ratio
AVRational sample_aspect_ratio
Sample aspect ratio for the video frame, 0/1 if unknown/unspecified.
Definition: frame.h:154
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:148
PutBitContext::buf_end
uint8_t * buf_end
Definition: put_bits.h:44
find_best_state
static void find_best_state(uint8_t best_state[256][256], const uint8_t one_state[256])
Definition: ffv1enc.c:137
ffv1_clear_slice_state
void ffv1_clear_slice_state(FFV1Context *f, FFV1Context *fs)
Definition: ffv1.c:161
height
BYTE int const BYTE int int int height
Definition: avisynth_c.h:713
AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:279
AV_PIX_FMT_YUV410P
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
Definition: pixfmt.h:74
av_malloc
void * av_malloc(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Definition: mem.c:73
write_quant_table
static void write_quant_table(RangeCoder *c, int16_t *quant_table)
Definition: ffv1enc.c:447
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:50
i
synthesis window for stochastic i
Definition: code Kat/hpsmodel.m:34
put_vlc_symbol
static void put_vlc_symbol(PutBitContext *pb, VlcState *const state, int v, int bits)
Definition: ffv1enc.c:234
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: golomb.h:536
AVComponentDescriptor::step_minus1
uint16_t step_minus1
Number of elements between 2 horizontally consecutive pixels minus 1.
Definition: pixdesc.h:35
FFV1Context::picture
AVFrame picture
Definition: ffv1.h:92
FFV1Context::picture_number
int picture_number
Definition: ffv1.h:91
VlcState::error_sum
uint16_t error_sum
Definition: ffv1.h:60
AV_PIX_FMT_YUV420P9
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:276
snprintf
#define snprintf
Definition: snprintf.h:34
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFilterBuffer 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.Buffer references ownership and permissions
AV_PIX_FMT_GBRP12
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:296
state
static uint32_t state
Definition: trasher.c:27
CONTEXT_SIZE
#define CONTEXT_SIZE
Definition: ffv1.h:51
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:280
FFV1Context::gob_count
int gob_count
Definition: ffv1.h:115
PlaneContext::quant_table_index
int quant_table_index
Definition: ffv1.h:67
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:87
OFFSET
#define OFFSET(x)
Definition: ffv1enc.c:1127
AVCodecContext::gop_size
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: libavcodec/avcodec.h:1321
COST2
#define COST2(old, new)
AV_CODEC_ID_FFV1
Definition: libavcodec/avcodec.h:136
AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:68
AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:76
CODEC_CAP_SLICE_THREADS
#define CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: libavcodec/avcodec.h:814
internal.h
common internal api header.
flush_put_bits
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:81
quant5_10bit
static const int8_t quant5_10bit[256]
Definition: ffv1enc.c:42
c
static double c[64]
Definition: vsrc_mptestsrc.c:88
fs
function fs
Definition: extra/f0detection.m:1
put_rac
#define put_rac(C, S, B)
PlaneContext::state
uint8_t(* state)[CONTEXT_SIZE]
Definition: ffv1.h:69
AV_PIX_FMT_YUV411P
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
Definition: pixfmt.h:75
init_put_bits
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:54
AVRational::den
int den
denominator
Definition: rational.h:45
y
function y
Definition: D.m:1
RangeCoder::bytestream_start
uint8_t * bytestream_start
Definition: rangecoder.h:42
AVCodecContext::slices
int slices
Number of slices.
Definition: libavcodec/avcodec.h:1852
FFV1Context::chroma_h_shift
int chroma_h_shift
Definition: ffv1.h:88
FFV1Context::plane
PlaneContext plane[MAX_PLANES]
Definition: ffv1.h:98
FFV1Context::transparency
int transparency
Definition: ffv1.h:89
FFV1Context::chroma_v_shift
int chroma_v_shift
Definition: ffv1.h:88
AVFrame::top_field_first
int top_field_first
If the content is interlaced, is top field displayed first.
Definition: frame.h:275
len
int len
Definition: vorbis_enc_data.h:452
FFV1Context::chroma_planes
int chroma_planes
Definition: ffv1.h:87
av_log2
#define av_log2
Definition: intmath.h:89
ffv1_close
av_cold int ffv1_close(AVCodecContext *avctx)
Definition: ffv1.c:189
AVFrame::key_frame
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:139
write_header
static void write_header(FFV1Context *f)
Definition: ffv1enc.c:470
FFV1Context::slice_context
struct FFV1Context * slice_context[MAX_SLICES]
Definition: ffv1.h:120
av_uninit
#define av_uninit(x)
Definition: attributes.h:137
AV_LOG_INFO
#define AV_LOG_INFO
Definition: log.h:156
av_noinline
#define av_noinline
Definition: attributes.h:56
AV_PIX_FMT_YUV440P
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
Definition: pixfmt.h:103
AVMEDIA_TYPE_VIDEO
Definition: avutil.h:143
av_always_inline
#define av_always_inline
Definition: attributes.h:41
log2
integer integer log2
Definition: avutil.txt:2
FFSWAP
#define FFSWAP(type, a, b)
Definition: common.h:61
FFV1Context::ec
int ec
Definition: ffv1.h:108
FFV1Context::num_v_slices
int num_v_slices
Definition: ffv1.h:122
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: libavcodec/avcodec.h:2615
golomb.h
exp golomb vlc stuff
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:66
AVPacket
This structure stores compressed data.
Definition: libavcodec/avcodec.h:1028
FFV1Context::avctx
AVCodecContext * avctx
Definition: ffv1.h:78
AVCodecContext::strict_std_compliance
int strict_std_compliance
strictly follow the standard (MPEG4, ...).
Definition: libavcodec/avcodec.h:2404
FFV1Context::slice_x
int slice_x
Definition: ffv1.h:126
AV_PIX_FMT_YUV422P16
#define AV_PIX_FMT_YUV422P16
Definition: pixfmt.h:289
for
for(j=16;j >0;--j)
Definition: h264pred_template.c:467
FFV1Context::width
int width
Definition: ffv1.h:86
AV_PIX_FMT_0RGB32
#define AV_PIX_FMT_0RGB32
Definition: pixfmt.h:263
a
a
Definition: h264pred_template.c:466
put_bits.h
bitstream writer API
Generated on Fri Dec 20 2024 06:56:00 for FFmpeg by   doxygen 1.8.11