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