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