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 = 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 
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  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 
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 & 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, const 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 * s->slice_rct_by_coef + r * s->slice_rct_ry_coef) >> 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;
473  uint8_t state[CONTEXT_SIZE];
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 
484 static void write_quant_tables(RangeCoder *c,
485  int16_t quant_table[MAX_CONTEXT_INPUTS][256])
486 {
487  int i;
488  for (i = 0; i < 5; i++)
489  write_quant_table(c, quant_table[i]);
490 }
491 
492 static void write_header(FFV1Context *f)
493 {
494  uint8_t state[CONTEXT_SIZE];
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 
516  write_quant_tables(c, f->quant_table);
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);
533  av_assert0(f->plane[j].quant_table_index == f->avctx->context_model);
534  }
535  }
536  }
537 }
538 
539 static int write_extradata(FFV1Context *f)
540 {
541  RangeCoder *const c = &f->c;
542  uint8_t state[CONTEXT_SIZE];
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;
552  f->avctx->extradata = av_malloc(f->avctx->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
553  if (!f->avctx->extradata)
554  return AVERROR(ENOMEM);
555  ff_init_range_encoder(c, f->avctx->extradata, f->avctx->extradata_size);
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  } else if (f->version == 4)
563  f->micro_version = 2;
564  put_symbol(c, state, f->micro_version, 0);
565  }
566 
567  put_symbol(c, state, f->ac, 0);
568  if (f->ac > 1)
569  for (i = 1; i < 256; i++)
570  put_symbol(c, state, f->state_transition[i] - c->one_state[i], 1);
571 
572  put_symbol(c, state, f->colorspace, 0); // YUV cs type
573  put_symbol(c, state, f->bits_per_raw_sample, 0);
574  put_rac(c, state, f->chroma_planes);
575  put_symbol(c, state, f->chroma_h_shift, 0);
576  put_symbol(c, state, f->chroma_v_shift, 0);
577  put_rac(c, state, f->transparency);
578  put_symbol(c, state, f->num_h_slices - 1, 0);
579  put_symbol(c, state, f->num_v_slices - 1, 0);
580 
581  put_symbol(c, state, f->quant_table_count, 0);
582  for (i = 0; i < f->quant_table_count; i++)
583  write_quant_tables(c, f->quant_tables[i]);
584 
585  for (i = 0; i < f->quant_table_count; i++) {
586  for (j = 0; j < f->context_count[i] * CONTEXT_SIZE; j++)
587  if (f->initial_states[i] && f->initial_states[i][0][j] != 128)
588  break;
589  if (j < f->context_count[i] * CONTEXT_SIZE) {
590  put_rac(c, state, 1);
591  for (j = 0; j < f->context_count[i]; j++)
592  for (k = 0; k < CONTEXT_SIZE; k++) {
593  int pred = j ? f->initial_states[i][j - 1][k] : 128;
594  put_symbol(c, state2[k],
595  (int8_t)(f->initial_states[i][j][k] - pred), 1);
596  }
597  } else {
598  put_rac(c, state, 0);
599  }
600  }
601 
602  if (f->version > 2) {
603  put_symbol(c, state, f->ec, 0);
604  put_symbol(c, state, f->intra = (f->avctx->gop_size < 2), 0);
605  }
606 
607  f->avctx->extradata_size = ff_rac_terminate(c);
608  v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, f->avctx->extradata, f->avctx->extradata_size);
609  AV_WL32(f->avctx->extradata + f->avctx->extradata_size, v);
610  f->avctx->extradata_size += 4;
611 
612  return 0;
613 }
614 
615 static int sort_stt(FFV1Context *s, uint8_t stt[256])
616 {
617  int i, i2, changed, print = 0;
618 
619  do {
620  changed = 0;
621  for (i = 12; i < 244; i++) {
622  for (i2 = i + 1; i2 < 245 && i2 < i + 4; i2++) {
623 
624 #define COST(old, new) \
625  s->rc_stat[old][0] * -log2((256 - (new)) / 256.0) + \
626  s->rc_stat[old][1] * -log2((new) / 256.0)
627 
628 #define COST2(old, new) \
629  COST(old, new) + COST(256 - (old), 256 - (new))
630 
631  double size0 = COST2(i, i) + COST2(i2, i2);
632  double sizeX = COST2(i, i2) + COST2(i2, i);
633  if (size0 - sizeX > size0*(1e-14) && i != 128 && i2 != 128) {
634  int j;
635  FFSWAP(int, stt[i], stt[i2]);
636  FFSWAP(int, s->rc_stat[i][0], s->rc_stat[i2][0]);
637  FFSWAP(int, s->rc_stat[i][1], s->rc_stat[i2][1]);
638  if (i != 256 - i2) {
639  FFSWAP(int, stt[256 - i], stt[256 - i2]);
640  FFSWAP(int, s->rc_stat[256 - i][0], s->rc_stat[256 - i2][0]);
641  FFSWAP(int, s->rc_stat[256 - i][1], s->rc_stat[256 - i2][1]);
642  }
643  for (j = 1; j < 256; j++) {
644  if (stt[j] == i)
645  stt[j] = i2;
646  else if (stt[j] == i2)
647  stt[j] = i;
648  if (i != 256 - i2) {
649  if (stt[256 - j] == 256 - i)
650  stt[256 - j] = 256 - i2;
651  else if (stt[256 - j] == 256 - i2)
652  stt[256 - j] = 256 - i;
653  }
654  }
655  print = changed = 1;
656  }
657  }
658  }
659  } while (changed);
660  return print;
661 }
662 
663 static av_cold int encode_init(AVCodecContext *avctx)
664 {
665  FFV1Context *s = avctx->priv_data;
666  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
667  int i, j, k, m, ret;
668 
669  if ((ret = ffv1_common_init(avctx)) < 0)
670  return ret;
671 
672  s->version = 0;
673 
674  if ((avctx->flags & (CODEC_FLAG_PASS1|CODEC_FLAG_PASS2)) || avctx->slices>1)
675  s->version = FFMAX(s->version, 2);
676 
677  // Unspecified level & slices, we choose version 1.2+ to ensure multithreaded decodability
678  if (avctx->slices == 0 && avctx->level < 0 && avctx->width * avctx->height > 720*576)
679  s->version = FFMAX(s->version, 2);
680 
681  if (avctx->level <= 0 && s->version == 2) {
682  s->version = 3;
683  }
684  if (avctx->level >= 0 && avctx->level <= 4)
685  s->version = FFMAX(s->version, avctx->level);
686 
687  if (s->ec < 0) {
688  s->ec = (s->version >= 3);
689  }
690 
691  if ((s->version == 2 || s->version>3) && avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
692  av_log(avctx, AV_LOG_ERROR, "Version 2 needed for requested features but version 2 is experimental and not enabled\n");
693  return AVERROR_INVALIDDATA;
694  }
695 
696  s->ac = avctx->coder_type > 0 ? 2 : 0;
697 
698  s->plane_count = 3;
699  switch(avctx->pix_fmt) {
700  case AV_PIX_FMT_YUV444P9:
701  case AV_PIX_FMT_YUV422P9:
702  case AV_PIX_FMT_YUV420P9:
703  case AV_PIX_FMT_YUVA444P9:
704  case AV_PIX_FMT_YUVA422P9:
705  case AV_PIX_FMT_YUVA420P9:
706  if (!avctx->bits_per_raw_sample)
707  s->bits_per_raw_sample = 9;
708  case AV_PIX_FMT_YUV444P10:
709  case AV_PIX_FMT_YUV420P10:
710  case AV_PIX_FMT_YUV422P10:
711  case AV_PIX_FMT_YUVA444P10:
712  case AV_PIX_FMT_YUVA422P10:
713  case AV_PIX_FMT_YUVA420P10:
714  s->packed_at_lsb = 1;
715  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
716  s->bits_per_raw_sample = 10;
717  case AV_PIX_FMT_GRAY16:
718  case AV_PIX_FMT_YUV444P16:
719  case AV_PIX_FMT_YUV422P16:
720  case AV_PIX_FMT_YUV420P16:
721  case AV_PIX_FMT_YUVA444P16:
722  case AV_PIX_FMT_YUVA422P16:
723  case AV_PIX_FMT_YUVA420P16:
724  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) {
725  s->bits_per_raw_sample = 16;
726  } else if (!s->bits_per_raw_sample) {
727  s->bits_per_raw_sample = avctx->bits_per_raw_sample;
728  }
729  if (s->bits_per_raw_sample <= 8) {
730  av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");
731  return AVERROR_INVALIDDATA;
732  }
733  if (!s->ac && avctx->coder_type == -1) {
734  av_log(avctx, AV_LOG_INFO, "bits_per_raw_sample > 8, forcing coder 1\n");
735  s->ac = 2;
736  }
737  if (!s->ac) {
738  av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample of more than 8 needs -coder 1 currently\n");
739  return AVERROR(ENOSYS);
740  }
741  s->version = FFMAX(s->version, 1);
742  case AV_PIX_FMT_GRAY8:
743  case AV_PIX_FMT_YUV444P:
744  case AV_PIX_FMT_YUV440P:
745  case AV_PIX_FMT_YUV422P:
746  case AV_PIX_FMT_YUV420P:
747  case AV_PIX_FMT_YUV411P:
748  case AV_PIX_FMT_YUV410P:
749  case AV_PIX_FMT_YUVA444P:
750  case AV_PIX_FMT_YUVA422P:
751  case AV_PIX_FMT_YUVA420P:
752  s->chroma_planes = desc->nb_components < 3 ? 0 : 1;
753  s->colorspace = 0;
754  s->transparency = desc->nb_components == 4;
755  break;
756  case AV_PIX_FMT_RGB32:
757  s->colorspace = 1;
758  s->transparency = 1;
759  s->chroma_planes = 1;
760  break;
761  case AV_PIX_FMT_0RGB32:
762  s->colorspace = 1;
763  s->chroma_planes = 1;
764  break;
765  case AV_PIX_FMT_GBRP9:
766  if (!avctx->bits_per_raw_sample)
767  s->bits_per_raw_sample = 9;
768  case AV_PIX_FMT_GBRP10:
769  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
770  s->bits_per_raw_sample = 10;
771  case AV_PIX_FMT_GBRP12:
772  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
773  s->bits_per_raw_sample = 12;
774  case AV_PIX_FMT_GBRP14:
775  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
776  s->bits_per_raw_sample = 14;
777  else if (!s->bits_per_raw_sample)
778  s->bits_per_raw_sample = avctx->bits_per_raw_sample;
779  s->colorspace = 1;
780  s->chroma_planes = 1;
781  s->version = FFMAX(s->version, 1);
782  if (!s->ac) {
783  av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample of more than 8 needs -coder 1 currently\n");
784  return AVERROR(ENOSYS);
785  }
786  break;
787  default:
788  av_log(avctx, AV_LOG_ERROR, "format not supported\n");
789  return AVERROR(ENOSYS);
790  }
791  if (s->transparency) {
792  av_log(avctx, AV_LOG_WARNING, "Storing alpha plane, this will require a recent FFV1 decoder to playback!\n");
793  }
794  if (avctx->context_model > 1U) {
795  av_log(avctx, AV_LOG_ERROR, "Invalid context model %d, valid values are 0 and 1\n", avctx->context_model);
796  return AVERROR(EINVAL);
797  }
798 
799  if (s->ac > 1)
800  for (i = 1; i < 256; i++)
801  s->state_transition[i] = ver2_state[i];
802 
803  for (i = 0; i < 256; i++) {
804  s->quant_table_count = 2;
805  if (s->bits_per_raw_sample <= 8) {
806  s->quant_tables[0][0][i]= quant11[i];
807  s->quant_tables[0][1][i]= 11*quant11[i];
808  s->quant_tables[0][2][i]= 11*11*quant11[i];
809  s->quant_tables[1][0][i]= quant11[i];
810  s->quant_tables[1][1][i]= 11*quant11[i];
811  s->quant_tables[1][2][i]= 11*11*quant5 [i];
812  s->quant_tables[1][3][i]= 5*11*11*quant5 [i];
813  s->quant_tables[1][4][i]= 5*5*11*11*quant5 [i];
814  } else {
815  s->quant_tables[0][0][i]= quant9_10bit[i];
816  s->quant_tables[0][1][i]= 11*quant9_10bit[i];
817  s->quant_tables[0][2][i]= 11*11*quant9_10bit[i];
818  s->quant_tables[1][0][i]= quant9_10bit[i];
819  s->quant_tables[1][1][i]= 11*quant9_10bit[i];
820  s->quant_tables[1][2][i]= 11*11*quant5_10bit[i];
821  s->quant_tables[1][3][i]= 5*11*11*quant5_10bit[i];
822  s->quant_tables[1][4][i]= 5*5*11*11*quant5_10bit[i];
823  }
824  }
825  s->context_count[0] = (11 * 11 * 11 + 1) / 2;
826  s->context_count[1] = (11 * 11 * 5 * 5 * 5 + 1) / 2;
827  memcpy(s->quant_table, s->quant_tables[avctx->context_model],
828  sizeof(s->quant_table));
829 
830  for (i = 0; i < s->plane_count; i++) {
831  PlaneContext *const p = &s->plane[i];
832 
833  memcpy(p->quant_table, s->quant_table, sizeof(p->quant_table));
834  p->quant_table_index = avctx->context_model;
835  p->context_count = s->context_count[p->quant_table_index];
836  }
837 
838  if ((ret = ffv1_allocate_initial_states(s)) < 0)
839  return ret;
840 
841  avctx->coded_frame = av_frame_alloc();
842  if (!avctx->coded_frame)
843  return AVERROR(ENOMEM);
844 
845  avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
846 
847  if (!s->transparency)
848  s->plane_count = 2;
849  if (!s->chroma_planes && s->version > 3)
850  s->plane_count--;
851 
852  avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
853  s->picture_number = 0;
854 
855  if (avctx->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2)) {
856  for (i = 0; i < s->quant_table_count; i++) {
857  s->rc_stat2[i] = av_mallocz(s->context_count[i] *
858  sizeof(*s->rc_stat2[i]));
859  if (!s->rc_stat2[i])
860  return AVERROR(ENOMEM);
861  }
862  }
863  if (avctx->stats_in) {
864  char *p = avctx->stats_in;
865  uint8_t (*best_state)[256] = av_malloc_array(256, 256);
866  int gob_count = 0;
867  char *next;
868  if (!best_state)
869  return AVERROR(ENOMEM);
870 
871  av_assert0(s->version >= 2);
872 
873  for (;;) {
874  for (j = 0; j < 256; j++)
875  for (i = 0; i < 2; i++) {
876  s->rc_stat[j][i] = strtol(p, &next, 0);
877  if (next == p) {
878  av_log(avctx, AV_LOG_ERROR,
879  "2Pass file invalid at %d %d [%s]\n", j, i, p);
880  av_freep(&best_state);
881  return AVERROR_INVALIDDATA;
882  }
883  p = next;
884  }
885  for (i = 0; i < s->quant_table_count; i++)
886  for (j = 0; j < s->context_count[i]; j++) {
887  for (k = 0; k < 32; k++)
888  for (m = 0; m < 2; m++) {
889  s->rc_stat2[i][j][k][m] = strtol(p, &next, 0);
890  if (next == p) {
891  av_log(avctx, AV_LOG_ERROR,
892  "2Pass file invalid at %d %d %d %d [%s]\n",
893  i, j, k, m, p);
894  av_freep(&best_state);
895  return AVERROR_INVALIDDATA;
896  }
897  p = next;
898  }
899  }
900  gob_count = strtol(p, &next, 0);
901  if (next == p || gob_count <= 0) {
902  av_log(avctx, AV_LOG_ERROR, "2Pass file invalid\n");
903  av_freep(&best_state);
904  return AVERROR_INVALIDDATA;
905  }
906  p = next;
907  while (*p == '\n' || *p == ' ')
908  p++;
909  if (p[0] == 0)
910  break;
911  }
912  sort_stt(s, s->state_transition);
913 
914  find_best_state(best_state, s->state_transition);
915 
916  for (i = 0; i < s->quant_table_count; i++) {
917  for (k = 0; k < 32; k++) {
918  double a=0, b=0;
919  int jp = 0;
920  for (j = 0; j < s->context_count[i]; j++) {
921  double p = 128;
922  if (s->rc_stat2[i][j][k][0] + s->rc_stat2[i][j][k][1] > 200 && j || a+b > 200) {
923  if (a+b)
924  p = 256.0 * b / (a + b);
925  s->initial_states[i][jp][k] =
926  best_state[av_clip(round(p), 1, 255)][av_clip((a + b) / gob_count, 0, 255)];
927  for(jp++; jp<j; jp++)
928  s->initial_states[i][jp][k] = s->initial_states[i][jp-1][k];
929  a=b=0;
930  }
931  a += s->rc_stat2[i][j][k][0];
932  b += s->rc_stat2[i][j][k][1];
933  if (a+b) {
934  p = 256.0 * b / (a + b);
935  }
936  s->initial_states[i][j][k] =
937  best_state[av_clip(round(p), 1, 255)][av_clip((a + b) / gob_count, 0, 255)];
938  }
939  }
940  }
941  av_freep(&best_state);
942  }
943 
944  if (s->version > 1) {
945  s->num_v_slices = (avctx->width > 352 || avctx->height > 288 || !avctx->slices) ? 2 : 1;
946  for (; s->num_v_slices < 9; s->num_v_slices++) {
947  for (s->num_h_slices = s->num_v_slices; s->num_h_slices < 2*s->num_v_slices; s->num_h_slices++) {
948  if (avctx->slices == s->num_h_slices * s->num_v_slices && avctx->slices <= 64 || !avctx->slices)
949  goto slices_ok;
950  }
951  }
952  av_log(avctx, AV_LOG_ERROR,
953  "Unsupported number %d of slices requested, please specify a "
954  "supported number with -slices (ex:4,6,9,12,16, ...)\n",
955  avctx->slices);
956  return AVERROR(ENOSYS);
957 slices_ok:
958  if ((ret = write_extradata(s)) < 0)
959  return ret;
960  }
961 
962  if ((ret = ffv1_init_slice_contexts(s)) < 0)
963  return ret;
964  if ((ret = ffv1_init_slices_state(s)) < 0)
965  return ret;
966 
967 #define STATS_OUT_SIZE 1024 * 1024 * 6
968  if (avctx->flags & CODEC_FLAG_PASS1) {
969  avctx->stats_out = av_mallocz(STATS_OUT_SIZE);
970  if (!avctx->stats_out)
971  return AVERROR(ENOMEM);
972  for (i = 0; i < s->quant_table_count; i++)
973  for (j = 0; j < s->slice_count; j++) {
974  FFV1Context *sf = s->slice_context[j];
975  av_assert0(!sf->rc_stat2[i]);
976  sf->rc_stat2[i] = av_mallocz(s->context_count[i] *
977  sizeof(*sf->rc_stat2[i]));
978  if (!sf->rc_stat2[i])
979  return AVERROR(ENOMEM);
980  }
981  }
982 
983  return 0;
984 }
985 
986 static void encode_slice_header(FFV1Context *f, FFV1Context *fs)
987 {
988  RangeCoder *c = &fs->c;
989  uint8_t state[CONTEXT_SIZE];
990  int j;
991  memset(state, 128, sizeof(state));
992 
993  put_symbol(c, state, (fs->slice_x +1)*f->num_h_slices / f->width , 0);
994  put_symbol(c, state, (fs->slice_y +1)*f->num_v_slices / f->height , 0);
995  put_symbol(c, state, (fs->slice_width +1)*f->num_h_slices / f->width -1, 0);
996  put_symbol(c, state, (fs->slice_height+1)*f->num_v_slices / f->height-1, 0);
997  for (j=0; j<f->plane_count; j++) {
998  put_symbol(c, state, f->plane[j].quant_table_index, 0);
999  av_assert0(f->plane[j].quant_table_index == f->avctx->context_model);
1000  }
1001  if (!f->picture.f->interlaced_frame)
1002  put_symbol(c, state, 3, 0);
1003  else
1004  put_symbol(c, state, 1 + !f->picture.f->top_field_first, 0);
1005  put_symbol(c, state, f->picture.f->sample_aspect_ratio.num, 0);
1006  put_symbol(c, state, f->picture.f->sample_aspect_ratio.den, 0);
1007  if (f->version > 3) {
1008  put_rac(c, state, fs->slice_coding_mode == 1);
1009  if (fs->slice_coding_mode == 1)
1010  ffv1_clear_slice_state(f, fs);
1011  put_symbol(c, state, fs->slice_coding_mode, 0);
1012  if (fs->slice_coding_mode != 1) {
1013  put_symbol(c, state, fs->slice_rct_by_coef, 0);
1014  put_symbol(c, state, fs->slice_rct_ry_coef, 0);
1015  }
1016  }
1017 }
1018 
1019 static void choose_rct_params(FFV1Context *fs, uint8_t *src[3], const int stride[3], int w, int h)
1020 {
1021 #define NB_Y_COEFF 15
1022  static const int rct_y_coeff[15][2] = {
1023  {0, 0}, // 4G
1024  {1, 1}, // R + 2G + B
1025  {2, 2}, // 2R + 2B
1026  {0, 2}, // 2G + 2B
1027  {2, 0}, // 2R + 2G
1028  {4, 0}, // 4R
1029  {0, 4}, // 4B
1030 
1031  {0, 3}, // 1G + 3B
1032  {3, 0}, // 3R + 1G
1033  {3, 1}, // 3R + B
1034  {1, 3}, // R + 3B
1035  {1, 2}, // R + G + 2B
1036  {2, 1}, // 2R + G + B
1037  {0, 1}, // 3G + B
1038  {1, 0}, // R + 3G
1039  };
1040 
1041  int stat[NB_Y_COEFF] = {0};
1042  int x, y, i, p, best;
1043  int16_t *sample[3];
1044  int lbd = fs->bits_per_raw_sample <= 8;
1045 
1046  for (y = 0; y < h; y++) {
1047  int lastr=0, lastg=0, lastb=0;
1048  for (p = 0; p < 3; p++)
1049  sample[p] = fs->sample_buffer + p*w;
1050 
1051  for (x = 0; x < w; x++) {
1052  int b, g, r;
1053  int ab, ag, ar;
1054  if (lbd) {
1055  unsigned v = *((uint32_t*)(src[0] + x*4 + stride[0]*y));
1056  b = v & 0xFF;
1057  g = (v >> 8) & 0xFF;
1058  r = (v >> 16) & 0xFF;
1059  } else {
1060  b = *((uint16_t*)(src[0] + x*2 + stride[0]*y));
1061  g = *((uint16_t*)(src[1] + x*2 + stride[1]*y));
1062  r = *((uint16_t*)(src[2] + x*2 + stride[2]*y));
1063  }
1064 
1065  ar = r - lastr;
1066  ag = g - lastg;
1067  ab = b - lastb;
1068  if (x && y) {
1069  int bg = ag - sample[0][x];
1070  int bb = ab - sample[1][x];
1071  int br = ar - sample[2][x];
1072 
1073  br -= bg;
1074  bb -= bg;
1075 
1076  for (i = 0; i<NB_Y_COEFF; i++) {
1077  stat[i] += FFABS(bg + ((br*rct_y_coeff[i][0] + bb*rct_y_coeff[i][1])>>2));
1078  }
1079 
1080  }
1081  sample[0][x] = ag;
1082  sample[1][x] = ab;
1083  sample[2][x] = ar;
1084 
1085  lastr = r;
1086  lastg = g;
1087  lastb = b;
1088  }
1089  }
1090 
1091  best = 0;
1092  for (i=1; i<NB_Y_COEFF; i++) {
1093  if (stat[i] < stat[best])
1094  best = i;
1095  }
1096 
1097  fs->slice_rct_by_coef = rct_y_coeff[best][1];
1098  fs->slice_rct_ry_coef = rct_y_coeff[best][0];
1099 }
1100 
1101 static int encode_slice(AVCodecContext *c, void *arg)
1102 {
1103  FFV1Context *fs = *(void **)arg;
1104  FFV1Context *f = fs->avctx->priv_data;
1105  int width = fs->slice_width;
1106  int height = fs->slice_height;
1107  int x = fs->slice_x;
1108  int y = fs->slice_y;
1109  const AVFrame *const p = f->picture.f;
1110  const int ps = av_pix_fmt_desc_get(c->pix_fmt)->comp[0].step_minus1 + 1;
1111  int ret;
1112  RangeCoder c_bak = fs->c;
1113  uint8_t *planes[3] = {p->data[0] + ps*x + y*p->linesize[0],
1114  p->data[1] + ps*x + y*p->linesize[1],
1115  p->data[2] + ps*x + y*p->linesize[2]};
1116 
1117  fs->slice_coding_mode = 0;
1118  if (f->version > 3) {
1119  choose_rct_params(fs, planes, p->linesize, width, height);
1120  } else {
1121  fs->slice_rct_by_coef = 1;
1122  fs->slice_rct_ry_coef = 1;
1123  }
1124 
1125 retry:
1126  if (c->coded_frame->key_frame)
1127  ffv1_clear_slice_state(f, fs);
1128  if (f->version > 2) {
1129  encode_slice_header(f, fs);
1130  }
1131  if (!fs->ac) {
1132  if (f->version > 2)
1133  put_rac(&fs->c, (uint8_t[]) { 129 }, 0);
1134  fs->ac_byte_count = f->version > 2 || (!x && !y) ? ff_rac_terminate(&fs->c) : 0;
1135  init_put_bits(&fs->pb,
1136  fs->c.bytestream_start + fs->ac_byte_count,
1137  fs->c.bytestream_end - fs->c.bytestream_start - fs->ac_byte_count);
1138  }
1139 
1140  if (f->colorspace == 0) {
1141  const int chroma_width = FF_CEIL_RSHIFT(width, f->chroma_h_shift);
1142  const int chroma_height = FF_CEIL_RSHIFT(height, f->chroma_v_shift);
1143  const int cx = x >> f->chroma_h_shift;
1144  const int cy = y >> f->chroma_v_shift;
1145 
1146  ret = encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0);
1147 
1148  if (f->chroma_planes) {
1149  ret |= encode_plane(fs, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1);
1150  ret |= encode_plane(fs, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1);
1151  }
1152  if (fs->transparency)
1153  ret |= encode_plane(fs, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], 2);
1154  } else {
1155  ret = encode_rgb_frame(fs, planes, width, height, p->linesize);
1156  }
1157  emms_c();
1158 
1159  if (ret < 0) {
1160  av_assert0(fs->slice_coding_mode == 0);
1161  if (fs->version < 4 || !fs->ac) {
1162  av_log(c, AV_LOG_ERROR, "Buffer too small\n");
1163  return ret;
1164  }
1165  av_log(c, AV_LOG_DEBUG, "Coding slice as PCM\n");
1166  fs->slice_coding_mode = 1;
1167  fs->c = c_bak;
1168  goto retry;
1169  }
1170 
1171  return 0;
1172 }
1173 
1174 static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
1175  const AVFrame *pict, int *got_packet)
1176 {
1177  FFV1Context *f = avctx->priv_data;
1178  RangeCoder *const c = &f->slice_context[0]->c;
1179  AVFrame *const p = f->picture.f;
1180  int used_count = 0;
1181  uint8_t keystate = 128;
1182  uint8_t *buf_p;
1183  int i, ret;
1184  int64_t maxsize = FF_MIN_BUFFER_SIZE
1185  + avctx->width*avctx->height*35LL*4;
1186 
1187  if(!pict) {
1188  if (avctx->flags & CODEC_FLAG_PASS1) {
1189  int j, k, m;
1190  char *p = avctx->stats_out;
1191  char *end = p + STATS_OUT_SIZE;
1192 
1193  memset(f->rc_stat, 0, sizeof(f->rc_stat));
1194  for (i = 0; i < f->quant_table_count; i++)
1195  memset(f->rc_stat2[i], 0, f->context_count[i] * sizeof(*f->rc_stat2[i]));
1196 
1197  for (j = 0; j < f->slice_count; j++) {
1198  FFV1Context *fs = f->slice_context[j];
1199  for (i = 0; i < 256; i++) {
1200  f->rc_stat[i][0] += fs->rc_stat[i][0];
1201  f->rc_stat[i][1] += fs->rc_stat[i][1];
1202  }
1203  for (i = 0; i < f->quant_table_count; i++) {
1204  for (k = 0; k < f->context_count[i]; k++)
1205  for (m = 0; m < 32; m++) {
1206  f->rc_stat2[i][k][m][0] += fs->rc_stat2[i][k][m][0];
1207  f->rc_stat2[i][k][m][1] += fs->rc_stat2[i][k][m][1];
1208  }
1209  }
1210  }
1211 
1212  for (j = 0; j < 256; j++) {
1213  snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1214  f->rc_stat[j][0], f->rc_stat[j][1]);
1215  p += strlen(p);
1216  }
1217  snprintf(p, end - p, "\n");
1218 
1219  for (i = 0; i < f->quant_table_count; i++) {
1220  for (j = 0; j < f->context_count[i]; j++)
1221  for (m = 0; m < 32; m++) {
1222  snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1223  f->rc_stat2[i][j][m][0], f->rc_stat2[i][j][m][1]);
1224  p += strlen(p);
1225  }
1226  }
1227  snprintf(p, end - p, "%d\n", f->gob_count);
1228  }
1229  return 0;
1230  }
1231 
1232  if (f->version > 3)
1233  maxsize = FF_MIN_BUFFER_SIZE + avctx->width*avctx->height*3LL*4;
1234 
1235  if ((ret = ff_alloc_packet2(avctx, pkt, maxsize)) < 0)
1236  return ret;
1237 
1238  ff_init_range_encoder(c, pkt->data, pkt->size);
1239  ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
1240 
1241  av_frame_unref(p);
1242  if ((ret = av_frame_ref(p, pict)) < 0)
1243  return ret;
1244  avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
1245 
1246  if (avctx->gop_size == 0 || f->picture_number % avctx->gop_size == 0) {
1247  put_rac(c, &keystate, 1);
1248  avctx->coded_frame->key_frame = 1;
1249  f->gob_count++;
1250  write_header(f);
1251  } else {
1252  put_rac(c, &keystate, 0);
1253  avctx->coded_frame->key_frame = 0;
1254  }
1255 
1256  if (f->ac > 1) {
1257  int i;
1258  for (i = 1; i < 256; i++) {
1259  c->one_state[i] = f->state_transition[i];
1260  c->zero_state[256 - i] = 256 - c->one_state[i];
1261  }
1262  }
1263 
1264  for (i = 1; i < f->slice_count; i++) {
1265  FFV1Context *fs = f->slice_context[i];
1266  uint8_t *start = pkt->data + (pkt->size - used_count) * (int64_t)i / f->slice_count;
1267  int len = pkt->size / f->slice_count;
1268  ff_init_range_encoder(&fs->c, start, len);
1269  }
1270  avctx->execute(avctx, encode_slice, &f->slice_context[0], NULL,
1271  f->slice_count, sizeof(void *));
1272 
1273  buf_p = pkt->data;
1274  for (i = 0; i < f->slice_count; i++) {
1275  FFV1Context *fs = f->slice_context[i];
1276  int bytes;
1277 
1278  if (fs->ac) {
1279  uint8_t state = 129;
1280  put_rac(&fs->c, &state, 0);
1281  bytes = ff_rac_terminate(&fs->c);
1282  } else {
1283  flush_put_bits(&fs->pb); // FIXME: nicer padding
1284  bytes = fs->ac_byte_count + (put_bits_count(&fs->pb) + 7) / 8;
1285  }
1286  if (i > 0 || f->version > 2) {
1287  av_assert0(bytes < pkt->size / f->slice_count);
1288  memmove(buf_p, fs->c.bytestream_start, bytes);
1289  av_assert0(bytes < (1 << 24));
1290  AV_WB24(buf_p + bytes, bytes);
1291  bytes += 3;
1292  }
1293  if (f->ec) {
1294  unsigned v;
1295  buf_p[bytes++] = 0;
1296  v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, buf_p, bytes);
1297  AV_WL32(buf_p + bytes, v);
1298  bytes += 4;
1299  }
1300  buf_p += bytes;
1301  }
1302 
1303  if (avctx->flags & CODEC_FLAG_PASS1)
1304  avctx->stats_out[0] = '\0';
1305 
1306  f->picture_number++;
1307  pkt->size = buf_p - pkt->data;
1308  pkt->pts =
1309  pkt->dts = pict->pts;
1310  pkt->flags |= AV_PKT_FLAG_KEY * avctx->coded_frame->key_frame;
1311  *got_packet = 1;
1312 
1313  return 0;
1314 }
1315 
1316 static av_cold int encode_close(AVCodecContext *avctx)
1317 {
1318  av_frame_free(&avctx->coded_frame);
1319  ffv1_close(avctx);
1320  return 0;
1321 }
1322 
1323 #define OFFSET(x) offsetof(FFV1Context, x)
1324 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1325 static const AVOption options[] = {
1326  { "slicecrc", "Protect slices with CRCs", OFFSET(ec), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1, VE },
1327  { NULL }
1328 };
1329 
1330 static const AVClass ffv1_class = {
1331  .class_name = "ffv1 encoder",
1332  .item_name = av_default_item_name,
1333  .option = options,
1334  .version = LIBAVUTIL_VERSION_INT,
1335 };
1336 
1337 static const AVCodecDefault ffv1_defaults[] = {
1338  { "coder", "-1" },
1339  { NULL },
1340 };
1341 
1342 AVCodec ff_ffv1_encoder = {
1343  .name = "ffv1",
1344  .long_name = NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1345  .type = AVMEDIA_TYPE_VIDEO,
1346  .id = AV_CODEC_ID_FFV1,
1347  .priv_data_size = sizeof(FFV1Context),
1348  .init = encode_init,
1349  .encode2 = encode_frame,
1350  .close = encode_close,
1351  .capabilities = CODEC_CAP_SLICE_THREADS | CODEC_CAP_DELAY,
1352  .pix_fmts = (const enum AVPixelFormat[]) {
1353  AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV444P,
1354  AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV411P,
1355  AV_PIX_FMT_YUV410P, AV_PIX_FMT_0RGB32, AV_PIX_FMT_RGB32, AV_PIX_FMT_YUV420P16,
1356  AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16, AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV422P9,
1357  AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
1358  AV_PIX_FMT_YUVA444P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA420P16,
1359  AV_PIX_FMT_YUVA444P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA420P10,
1360  AV_PIX_FMT_YUVA444P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA420P9,
1361  AV_PIX_FMT_GRAY16, AV_PIX_FMT_GRAY8, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
1362  AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14,
1363  AV_PIX_FMT_NONE
1364 
1365  },
1366  .defaults = ffv1_defaults,
1367  .priv_class = &ffv1_class,
1368 };
Generated on Sun Sep 14 2014 18:55:55 for FFmpeg by   doxygen 1.8.2