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