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