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-2012 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 * 20) {
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  for (x = 0; x < w; x++) {
290  int diff, context;
291 
292  context = get_context(p, sample[0] + x, sample[1] + x, sample[2] + x);
293  diff = sample[0][x] - predict(sample[0] + x, sample[1] + x);
294 
295  if (context < 0) {
296  context = -context;
297  diff = -diff;
298  }
299 
300  diff = fold(diff, bits);
301 
302  if (s->ac) {
303  if (s->flags & CODEC_FLAG_PASS1) {
304  put_symbol_inline(c, p->state[context], diff, 1, s->rc_stat,
305  s->rc_stat2[p->quant_table_index][context]);
306  } else {
307  put_symbol_inline(c, p->state[context], diff, 1, NULL, NULL);
308  }
309  } else {
310  if (context == 0)
311  run_mode = 1;
312 
313  if (run_mode) {
314  if (diff) {
315  while (run_count >= 1 << ff_log2_run[run_index]) {
316  run_count -= 1 << ff_log2_run[run_index];
317  run_index++;
318  put_bits(&s->pb, 1, 1);
319  }
320 
321  put_bits(&s->pb, 1 + ff_log2_run[run_index], run_count);
322  if (run_index)
323  run_index--;
324  run_count = 0;
325  run_mode = 0;
326  if (diff > 0)
327  diff--;
328  } else {
329  run_count++;
330  }
331  }
332 
333  av_dlog(s->avctx, "count:%d index:%d, mode:%d, x:%d pos:%d\n",
334  run_count, run_index, run_mode, x,
335  (int)put_bits_count(&s->pb));
336 
337  if (run_mode == 0)
338  put_vlc_symbol(&s->pb, &p->vlc_state[context], diff, bits);
339  }
340  }
341  if (run_mode) {
342  while (run_count >= 1 << ff_log2_run[run_index]) {
343  run_count -= 1 << ff_log2_run[run_index];
344  run_index++;
345  put_bits(&s->pb, 1, 1);
346  }
347 
348  if (run_count)
349  put_bits(&s->pb, 1, 1);
350  }
351  s->run_index = run_index;
352 
353  return 0;
354 }
355 
356 static void encode_plane(FFV1Context *s, uint8_t *src, int w, int h,
357  int stride, int plane_index)
358 {
359  int x, y, i;
360  const int ring_size = s->avctx->context_model ? 3 : 2;
361  int16_t *sample[3];
362  s->run_index = 0;
363 
364  memset(s->sample_buffer, 0, ring_size * (w + 6) * sizeof(*s->sample_buffer));
365 
366  for (y = 0; y < h; y++) {
367  for (i = 0; i < ring_size; i++)
368  sample[i] = s->sample_buffer + (w + 6) * ((h + i - y) % ring_size) + 3;
369 
370  sample[0][-1]= sample[1][0 ];
371  sample[1][ w]= sample[1][w-1];
372 // { START_TIMER
373  if (s->bits_per_raw_sample <= 8) {
374  for (x = 0; x < w; x++)
375  sample[0][x] = src[x + stride * y];
376  encode_line(s, w, sample, plane_index, 8);
377  } else {
378  if (s->packed_at_lsb) {
379  for (x = 0; x < w; x++) {
380  sample[0][x] = ((uint16_t*)(src + stride*y))[x];
381  }
382  } else {
383  for (x = 0; x < w; x++) {
384  sample[0][x] = ((uint16_t*)(src + stride*y))[x] >> (16 - s->bits_per_raw_sample);
385  }
386  }
387  encode_line(s, w, sample, plane_index, s->bits_per_raw_sample);
388  }
389 // STOP_TIMER("encode line") }
390  }
391 }
392 
393 static void encode_rgb_frame(FFV1Context *s, uint8_t *src[3], int w, int h, int stride[3])
394 {
395  int x, y, p, i;
396  const int ring_size = s->avctx->context_model ? 3 : 2;
397  int16_t *sample[4][3];
398  int lbd = s->bits_per_raw_sample <= 8;
399  int bits = s->bits_per_raw_sample > 0 ? s->bits_per_raw_sample : 8;
400  int offset = 1 << bits;
401 
402  s->run_index = 0;
403 
404  memset(s->sample_buffer, 0, ring_size * MAX_PLANES *
405  (w + 6) * sizeof(*s->sample_buffer));
406 
407  for (y = 0; y < h; y++) {
408  for (i = 0; i < ring_size; i++)
409  for (p = 0; p < MAX_PLANES; p++)
410  sample[p][i]= s->sample_buffer + p*ring_size*(w+6) + ((h+i-y)%ring_size)*(w+6) + 3;
411 
412  for (x = 0; x < w; x++) {
413  int b, g, r, av_uninit(a);
414  if (lbd) {
415  unsigned v = *((uint32_t*)(src[0] + x*4 + stride[0]*y));
416  b = v & 0xFF;
417  g = (v >> 8) & 0xFF;
418  r = (v >> 16) & 0xFF;
419  a = v >> 24;
420  } else {
421  b = *((uint16_t*)(src[0] + x*2 + stride[0]*y));
422  g = *((uint16_t*)(src[1] + x*2 + stride[1]*y));
423  r = *((uint16_t*)(src[2] + x*2 + stride[2]*y));
424  }
425 
426  b -= g;
427  r -= g;
428  g += (b + r) >> 2;
429  b += offset;
430  r += offset;
431 
432  sample[0][0][x] = g;
433  sample[1][0][x] = b;
434  sample[2][0][x] = r;
435  sample[3][0][x] = a;
436  }
437  for (p = 0; p < 3 + s->transparency; p++) {
438  sample[p][0][-1] = sample[p][1][0 ];
439  sample[p][1][ w] = sample[p][1][w-1];
440  if (lbd)
441  encode_line(s, w, sample[p], (p + 1) / 2, 9);
442  else
443  encode_line(s, w, sample[p], (p + 1) / 2, bits + 1);
444  }
445  }
446 }
447 
448 static void write_quant_table(RangeCoder *c, int16_t *quant_table)
449 {
450  int last = 0;
451  int i;
452  uint8_t state[CONTEXT_SIZE];
453  memset(state, 128, sizeof(state));
454 
455  for (i = 1; i < 128; i++)
456  if (quant_table[i] != quant_table[i - 1]) {
457  put_symbol(c, state, i - last - 1, 0);
458  last = i;
459  }
460  put_symbol(c, state, i - last - 1, 0);
461 }
462 
463 static void write_quant_tables(RangeCoder *c,
464  int16_t quant_table[MAX_CONTEXT_INPUTS][256])
465 {
466  int i;
467  for (i = 0; i < 5; i++)
468  write_quant_table(c, quant_table[i]);
469 }
470 
471 static void write_header(FFV1Context *f)
472 {
473  uint8_t state[CONTEXT_SIZE];
474  int i, j;
475  RangeCoder *const c = &f->slice_context[0]->c;
476 
477  memset(state, 128, sizeof(state));
478 
479  if (f->version < 2) {
480  put_symbol(c, state, f->version, 0);
481  put_symbol(c, state, f->ac, 0);
482  if (f->ac > 1) {
483  for (i = 1; i < 256; i++)
484  put_symbol(c, state,
485  f->state_transition[i] - c->one_state[i], 1);
486  }
487  put_symbol(c, state, f->colorspace, 0); //YUV cs type
488  if (f->version > 0)
489  put_symbol(c, state, f->bits_per_raw_sample, 0);
490  put_rac(c, state, f->chroma_planes);
491  put_symbol(c, state, f->chroma_h_shift, 0);
492  put_symbol(c, state, f->chroma_v_shift, 0);
493  put_rac(c, state, f->transparency);
494 
495  write_quant_tables(c, f->quant_table);
496  } else if (f->version < 3) {
497  put_symbol(c, state, f->slice_count, 0);
498  for (i = 0; i < f->slice_count; i++) {
499  FFV1Context *fs = f->slice_context[i];
500  put_symbol(c, state,
501  (fs->slice_x + 1) * f->num_h_slices / f->width, 0);
502  put_symbol(c, state,
503  (fs->slice_y + 1) * f->num_v_slices / f->height, 0);
504  put_symbol(c, state,
505  (fs->slice_width + 1) * f->num_h_slices / f->width - 1,
506  0);
507  put_symbol(c, state,
508  (fs->slice_height + 1) * f->num_v_slices / f->height - 1,
509  0);
510  for (j = 0; j < f->plane_count; j++) {
511  put_symbol(c, state, f->plane[j].quant_table_index, 0);
512  av_assert0(f->plane[j].quant_table_index == f->avctx->context_model);
513  }
514  }
515  }
516 }
517 
518 static int write_extradata(FFV1Context *f)
519 {
520  RangeCoder *const c = &f->c;
521  uint8_t state[CONTEXT_SIZE];
522  int i, j, k;
523  uint8_t state2[32][CONTEXT_SIZE];
524  unsigned v;
525 
526  memset(state2, 128, sizeof(state2));
527  memset(state, 128, sizeof(state));
528 
529  f->avctx->extradata_size = 10000 + 4 +
530  (11 * 11 * 5 * 5 * 5 + 11 * 11 * 11) * 32;
531  f->avctx->extradata = av_malloc(f->avctx->extradata_size);
532  ff_init_range_encoder(c, f->avctx->extradata, f->avctx->extradata_size);
533  ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
534 
535  put_symbol(c, state, f->version, 0);
536  if (f->version > 2) {
537  if (f->version == 3)
538  f->minor_version = 3;
539  put_symbol(c, state, f->minor_version, 0);
540  }
541 
542  put_symbol(c, state, f->ac, 0);
543  if (f->ac > 1)
544  for (i = 1; i < 256; i++)
545  put_symbol(c, state, f->state_transition[i] - c->one_state[i], 1);
546 
547  put_symbol(c, state, f->colorspace, 0); // YUV cs type
548  put_symbol(c, state, f->bits_per_raw_sample, 0);
549  put_rac(c, state, f->chroma_planes);
550  put_symbol(c, state, f->chroma_h_shift, 0);
551  put_symbol(c, state, f->chroma_v_shift, 0);
552  put_rac(c, state, f->transparency);
553  put_symbol(c, state, f->num_h_slices - 1, 0);
554  put_symbol(c, state, f->num_v_slices - 1, 0);
555 
556  put_symbol(c, state, f->quant_table_count, 0);
557  for (i = 0; i < f->quant_table_count; i++)
558  write_quant_tables(c, f->quant_tables[i]);
559 
560  for (i = 0; i < f->quant_table_count; i++) {
561  for (j = 0; j < f->context_count[i] * CONTEXT_SIZE; j++)
562  if (f->initial_states[i] && f->initial_states[i][0][j] != 128)
563  break;
564  if (j < f->context_count[i] * CONTEXT_SIZE) {
565  put_rac(c, state, 1);
566  for (j = 0; j < f->context_count[i]; j++)
567  for (k = 0; k < CONTEXT_SIZE; k++) {
568  int pred = j ? f->initial_states[i][j - 1][k] : 128;
569  put_symbol(c, state2[k],
570  (int8_t)(f->initial_states[i][j][k] - pred), 1);
571  }
572  } else {
573  put_rac(c, state, 0);
574  }
575  }
576 
577  if (f->version > 2) {
578  put_symbol(c, state, f->ec, 0);
579  put_symbol(c, state, f->intra = (f->avctx->gop_size < 2), 0);
580  }
581 
582  f->avctx->extradata_size = ff_rac_terminate(c);
583  v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, f->avctx->extradata, f->avctx->extradata_size);
584  AV_WL32(f->avctx->extradata + f->avctx->extradata_size, v);
585  f->avctx->extradata_size += 4;
586 
587  return 0;
588 }
589 
590 static int sort_stt(FFV1Context *s, uint8_t stt[256])
591 {
592  int i, i2, changed, print = 0;
593 
594  do {
595  changed = 0;
596  for (i = 12; i < 244; i++) {
597  for (i2 = i + 1; i2 < 245 && i2 < i + 4; i2++) {
598 
599 #define COST(old, new) \
600  s->rc_stat[old][0] * -log2((256 - (new)) / 256.0) + \
601  s->rc_stat[old][1] * -log2((new) / 256.0)
602 
603 #define COST2(old, new) \
604  COST(old, new) + COST(256 - (old), 256 - (new))
605 
606  double size0 = COST2(i, i) + COST2(i2, i2);
607  double sizeX = COST2(i, i2) + COST2(i2, i);
608  if (size0 - sizeX > size0*(1e-14) && i != 128 && i2 != 128) {
609  int j;
610  FFSWAP(int, stt[i], stt[i2]);
611  FFSWAP(int, s->rc_stat[i][0], s->rc_stat[i2][0]);
612  FFSWAP(int, s->rc_stat[i][1], s->rc_stat[i2][1]);
613  if (i != 256 - i2) {
614  FFSWAP(int, stt[256 - i], stt[256 - i2]);
615  FFSWAP(int, s->rc_stat[256 - i][0], s->rc_stat[256 - i2][0]);
616  FFSWAP(int, s->rc_stat[256 - i][1], s->rc_stat[256 - i2][1]);
617  }
618  for (j = 1; j < 256; j++) {
619  if (stt[j] == i)
620  stt[j] = i2;
621  else if (stt[j] == i2)
622  stt[j] = i;
623  if (i != 256 - i2) {
624  if (stt[256 - j] == 256 - i)
625  stt[256 - j] = 256 - i2;
626  else if (stt[256 - j] == 256 - i2)
627  stt[256 - j] = 256 - i;
628  }
629  }
630  print = changed = 1;
631  }
632  }
633  }
634  } while (changed);
635  return print;
636 }
637 
638 static av_cold int encode_init(AVCodecContext *avctx)
639 {
640  FFV1Context *s = avctx->priv_data;
641  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
642  int i, j, k, m, ret;
643 
644  if ((ret = ffv1_common_init(avctx)) < 0)
645  return ret;
646 
647  s->version = 0;
648 
649  if ((avctx->flags & (CODEC_FLAG_PASS1|CODEC_FLAG_PASS2)) || avctx->slices>1)
650  s->version = FFMAX(s->version, 2);
651 
652  if (avctx->level == 3 || (s->version==2 && avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL)) {
653  s->version = 3;
654  }
655 
656  if (s->ec < 0) {
657  s->ec = (s->version >= 3);
658  }
659 
660  if (s->version >= 2 && avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
661  av_log(avctx, AV_LOG_ERROR, "Version 2 needed for requested features but version 2 is experimental and not enabled\n");
662  return AVERROR_INVALIDDATA;
663  }
664 
665  s->ac = avctx->coder_type > 0 ? 2 : 0;
666 
667  s->plane_count = 3;
668  switch(avctx->pix_fmt) {
669  case AV_PIX_FMT_YUV444P9:
670  case AV_PIX_FMT_YUV422P9:
671  case AV_PIX_FMT_YUV420P9:
672  if (!avctx->bits_per_raw_sample)
673  s->bits_per_raw_sample = 9;
674  case AV_PIX_FMT_YUV444P10:
675  case AV_PIX_FMT_YUV420P10:
676  case AV_PIX_FMT_YUV422P10:
677  s->packed_at_lsb = 1;
678  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
679  s->bits_per_raw_sample = 10;
680  case AV_PIX_FMT_GRAY16:
681  case AV_PIX_FMT_YUV444P16:
682  case AV_PIX_FMT_YUV422P16:
683  case AV_PIX_FMT_YUV420P16:
684  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) {
685  s->bits_per_raw_sample = 16;
686  } else if (!s->bits_per_raw_sample) {
687  s->bits_per_raw_sample = avctx->bits_per_raw_sample;
688  }
689  if (s->bits_per_raw_sample <= 8) {
690  av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");
691  return AVERROR_INVALIDDATA;
692  }
693  if (!s->ac && avctx->coder_type == -1) {
694  av_log(avctx, AV_LOG_INFO, "bits_per_raw_sample > 8, forcing coder 1\n");
695  s->ac = 2;
696  }
697  if (!s->ac) {
698  av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample of more than 8 needs -coder 1 currently\n");
699  return AVERROR(ENOSYS);
700  }
701  s->version = FFMAX(s->version, 1);
702  case AV_PIX_FMT_GRAY8:
703  case AV_PIX_FMT_YUV444P:
704  case AV_PIX_FMT_YUV440P:
705  case AV_PIX_FMT_YUV422P:
706  case AV_PIX_FMT_YUV420P:
707  case AV_PIX_FMT_YUV411P:
708  case AV_PIX_FMT_YUV410P:
709  s->chroma_planes = desc->nb_components < 3 ? 0 : 1;
710  s->colorspace = 0;
711  break;
712  case AV_PIX_FMT_YUVA444P:
713  case AV_PIX_FMT_YUVA422P:
714  case AV_PIX_FMT_YUVA420P:
715  s->chroma_planes = 1;
716  s->colorspace = 0;
717  s->transparency = 1;
718  break;
719  case AV_PIX_FMT_RGB32:
720  s->colorspace = 1;
721  s->transparency = 1;
722  break;
723  case AV_PIX_FMT_0RGB32:
724  s->colorspace = 1;
725  break;
726  case AV_PIX_FMT_GBRP9:
727  if (!avctx->bits_per_raw_sample)
728  s->bits_per_raw_sample = 9;
729  case AV_PIX_FMT_GBRP10:
730  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
731  s->bits_per_raw_sample = 10;
732  case AV_PIX_FMT_GBRP12:
733  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
734  s->bits_per_raw_sample = 12;
735  case AV_PIX_FMT_GBRP14:
736  if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
737  s->bits_per_raw_sample = 14;
738  else if (!s->bits_per_raw_sample)
739  s->bits_per_raw_sample = avctx->bits_per_raw_sample;
740  s->colorspace = 1;
741  s->chroma_planes = 1;
742  s->version = FFMAX(s->version, 1);
743  break;
744  default:
745  av_log(avctx, AV_LOG_ERROR, "format not supported\n");
746  return AVERROR(ENOSYS);
747  }
748  if (s->transparency) {
749  av_log(avctx, AV_LOG_WARNING, "Storing alpha plane, this will require a recent FFV1 decoder to playback!\n");
750  }
751  if (avctx->context_model > 1U) {
752  av_log(avctx, AV_LOG_ERROR, "Invalid context model %d, valid values are 0 and 1\n", avctx->context_model);
753  return AVERROR(EINVAL);
754  }
755 
756  if (s->ac > 1)
757  for (i = 1; i < 256; i++)
758  s->state_transition[i] = ver2_state[i];
759 
760  for (i = 0; i < 256; i++) {
761  s->quant_table_count = 2;
762  if (s->bits_per_raw_sample <= 8) {
763  s->quant_tables[0][0][i]= quant11[i];
764  s->quant_tables[0][1][i]= 11*quant11[i];
765  s->quant_tables[0][2][i]= 11*11*quant11[i];
766  s->quant_tables[1][0][i]= quant11[i];
767  s->quant_tables[1][1][i]= 11*quant11[i];
768  s->quant_tables[1][2][i]= 11*11*quant5 [i];
769  s->quant_tables[1][3][i]= 5*11*11*quant5 [i];
770  s->quant_tables[1][4][i]= 5*5*11*11*quant5 [i];
771  } else {
772  s->quant_tables[0][0][i]= quant9_10bit[i];
773  s->quant_tables[0][1][i]= 11*quant9_10bit[i];
774  s->quant_tables[0][2][i]= 11*11*quant9_10bit[i];
775  s->quant_tables[1][0][i]= quant9_10bit[i];
776  s->quant_tables[1][1][i]= 11*quant9_10bit[i];
777  s->quant_tables[1][2][i]= 11*11*quant5_10bit[i];
778  s->quant_tables[1][3][i]= 5*11*11*quant5_10bit[i];
779  s->quant_tables[1][4][i]= 5*5*11*11*quant5_10bit[i];
780  }
781  }
782  s->context_count[0] = (11 * 11 * 11 + 1) / 2;
783  s->context_count[1] = (11 * 11 * 5 * 5 * 5 + 1) / 2;
784  memcpy(s->quant_table, s->quant_tables[avctx->context_model],
785  sizeof(s->quant_table));
786 
787  for (i = 0; i < s->plane_count; i++) {
788  PlaneContext *const p = &s->plane[i];
789 
790  memcpy(p->quant_table, s->quant_table, sizeof(p->quant_table));
791  p->quant_table_index = avctx->context_model;
792  p->context_count = s->context_count[p->quant_table_index];
793  }
794 
795  if ((ret = ffv1_allocate_initial_states(s)) < 0)
796  return ret;
797 
798  if (!s->transparency)
799  s->plane_count = 2;
800  avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
801  s->picture_number = 0;
802 
803  if (avctx->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2)) {
804  for (i = 0; i < s->quant_table_count; i++) {
805  s->rc_stat2[i] = av_mallocz(s->context_count[i] *
806  sizeof(*s->rc_stat2[i]));
807  if (!s->rc_stat2[i])
808  return AVERROR(ENOMEM);
809  }
810  }
811  if (avctx->stats_in) {
812  char *p = avctx->stats_in;
813  uint8_t best_state[256][256];
814  int gob_count = 0;
815  char *next;
816 
817  av_assert0(s->version >= 2);
818 
819  for (;;) {
820  for (j = 0; j < 256; j++)
821  for (i = 0; i < 2; i++) {
822  s->rc_stat[j][i] = strtol(p, &next, 0);
823  if (next == p) {
824  av_log(avctx, AV_LOG_ERROR,
825  "2Pass file invalid at %d %d [%s]\n", j, i, p);
826  return AVERROR_INVALIDDATA;
827  }
828  p = next;
829  }
830  for (i = 0; i < s->quant_table_count; i++)
831  for (j = 0; j < s->context_count[i]; j++) {
832  for (k = 0; k < 32; k++)
833  for (m = 0; m < 2; m++) {
834  s->rc_stat2[i][j][k][m] = strtol(p, &next, 0);
835  if (next == p) {
836  av_log(avctx, AV_LOG_ERROR,
837  "2Pass file invalid at %d %d %d %d [%s]\n",
838  i, j, k, m, p);
839  return AVERROR_INVALIDDATA;
840  }
841  p = next;
842  }
843  }
844  gob_count = strtol(p, &next, 0);
845  if (next == p || gob_count <= 0) {
846  av_log(avctx, AV_LOG_ERROR, "2Pass file invalid\n");
847  return AVERROR_INVALIDDATA;
848  }
849  p = next;
850  while (*p == '\n' || *p == ' ')
851  p++;
852  if (p[0] == 0)
853  break;
854  }
855  sort_stt(s, s->state_transition);
856 
857  find_best_state(best_state, s->state_transition);
858 
859  for (i = 0; i < s->quant_table_count; i++) {
860  for (k = 0; k < 32; k++) {
861  double a=0, b=0;
862  int jp = 0;
863  for (j = 0; j < s->context_count[i]; j++) {
864  double p = 128;
865  if (s->rc_stat2[i][j][k][0] + s->rc_stat2[i][j][k][1] > 200 && j || a+b > 200) {
866  if (a+b)
867  p = 256.0 * b / (a + b);
868  s->initial_states[i][jp][k] =
869  best_state[av_clip(round(p), 1, 255)][av_clip((a + b) / gob_count, 0, 255)];
870  for(jp++; jp<j; jp++)
871  s->initial_states[i][jp][k] = s->initial_states[i][jp-1][k];
872  a=b=0;
873  }
874  a += s->rc_stat2[i][j][k][0];
875  b += s->rc_stat2[i][j][k][1];
876  if (a+b) {
877  p = 256.0 * b / (a + b);
878  }
879  s->initial_states[i][j][k] =
880  best_state[av_clip(round(p), 1, 255)][av_clip((a + b) / gob_count, 0, 255)];
881  }
882  }
883  }
884  }
885 
886  if (s->version > 1) {
887  s->num_v_slices = (avctx->width > 352 || avctx->height > 288 || !avctx->slices) ? 2 : 1;
888  for (; s->num_v_slices < 9; s->num_v_slices++) {
889  for (s->num_h_slices = s->num_v_slices; s->num_h_slices < 2*s->num_v_slices; s->num_h_slices++) {
890  if (avctx->slices == s->num_h_slices * s->num_v_slices && avctx->slices <= 64 || !avctx->slices)
891  goto slices_ok;
892  }
893  }
894  av_log(avctx, AV_LOG_ERROR,
895  "Unsupported number %d of slices requested, please specify a "
896  "supported number with -slices (ex:4,6,9,12,16, ...)\n",
897  avctx->slices);
898  return AVERROR(ENOSYS);
899 slices_ok:
900  write_extradata(s);
901  }
902 
903  if ((ret = ffv1_init_slice_contexts(s)) < 0)
904  return ret;
905  if ((ret = ffv1_init_slices_state(s)) < 0)
906  return ret;
907 
908 #define STATS_OUT_SIZE 1024 * 1024 * 6
909  if (avctx->flags & CODEC_FLAG_PASS1) {
910  avctx->stats_out = av_mallocz(STATS_OUT_SIZE);
911  if (!avctx->stats_out)
912  return AVERROR(ENOMEM);
913  for (i = 0; i < s->quant_table_count; i++)
914  for (j = 0; j < s->slice_count; j++) {
915  FFV1Context *sf = s->slice_context[j];
916  av_assert0(!sf->rc_stat2[i]);
917  sf->rc_stat2[i] = av_mallocz(s->context_count[i] *
918  sizeof(*sf->rc_stat2[i]));
919  if (!sf->rc_stat2[i])
920  return AVERROR(ENOMEM);
921  }
922  }
923 
924  return 0;
925 }
926 
927 static void encode_slice_header(FFV1Context *f, FFV1Context *fs)
928 {
929  RangeCoder *c = &fs->c;
930  uint8_t state[CONTEXT_SIZE];
931  int j;
932  memset(state, 128, sizeof(state));
933 
934  put_symbol(c, state, (fs->slice_x +1)*f->num_h_slices / f->width , 0);
935  put_symbol(c, state, (fs->slice_y +1)*f->num_v_slices / f->height , 0);
936  put_symbol(c, state, (fs->slice_width +1)*f->num_h_slices / f->width -1, 0);
937  put_symbol(c, state, (fs->slice_height+1)*f->num_v_slices / f->height-1, 0);
938  for (j=0; j<f->plane_count; j++) {
939  put_symbol(c, state, f->plane[j].quant_table_index, 0);
940  av_assert0(f->plane[j].quant_table_index == f->avctx->context_model);
941  }
942  if (!f->picture.f->interlaced_frame)
943  put_symbol(c, state, 3, 0);
944  else
945  put_symbol(c, state, 1 + !f->picture.f->top_field_first, 0);
946  put_symbol(c, state, f->picture.f->sample_aspect_ratio.num, 0);
947  put_symbol(c, state, f->picture.f->sample_aspect_ratio.den, 0);
948 }
949 
950 static int encode_slice(AVCodecContext *c, void *arg)
951 {
952  FFV1Context *fs = *(void **)arg;
953  FFV1Context *f = fs->avctx->priv_data;
954  int width = fs->slice_width;
955  int height = fs->slice_height;
956  int x = fs->slice_x;
957  int y = fs->slice_y;
958  AVFrame *const p = f->picture.f;
959  const int ps = av_pix_fmt_desc_get(c->pix_fmt)->comp[0].step_minus1 + 1;
960 
961  if (p->key_frame)
962  ffv1_clear_slice_state(f, fs);
963  if (f->version > 2) {
964  encode_slice_header(f, fs);
965  }
966  if (!fs->ac) {
967  if (f->version > 2)
968  put_rac(&fs->c, (uint8_t[]) { 129 }, 0);
969  fs->ac_byte_count = f->version > 2 || (!x && !y) ? ff_rac_terminate(&fs->c) : 0;
970  init_put_bits(&fs->pb,
971  fs->c.bytestream_start + fs->ac_byte_count,
972  fs->c.bytestream_end - fs->c.bytestream_start - fs->ac_byte_count);
973  }
974 
975  if (f->colorspace == 0) {
976  const int chroma_width = FF_CEIL_RSHIFT(width, f->chroma_h_shift);
977  const int chroma_height = FF_CEIL_RSHIFT(height, f->chroma_v_shift);
978  const int cx = x >> f->chroma_h_shift;
979  const int cy = y >> f->chroma_v_shift;
980 
981  encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0);
982 
983  if (f->chroma_planes) {
984  encode_plane(fs, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1);
985  encode_plane(fs, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1);
986  }
987  if (fs->transparency)
988  encode_plane(fs, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], 2);
989  } else {
990  uint8_t *planes[3] = {p->data[0] + ps*x + y*p->linesize[0],
991  p->data[1] + ps*x + y*p->linesize[1],
992  p->data[2] + ps*x + y*p->linesize[2]};
993  encode_rgb_frame(fs, planes, width, height, p->linesize);
994  }
995  emms_c();
996 
997  return 0;
998 }
999 
1000 static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
1001  const AVFrame *pict, int *got_packet)
1002 {
1003  FFV1Context *f = avctx->priv_data;
1004  RangeCoder *const c = &f->slice_context[0]->c;
1005  AVFrame *const p = f->picture.f;
1006  int used_count = 0;
1007  uint8_t keystate = 128;
1008  uint8_t *buf_p;
1009  int i, ret;
1010 
1011  if ((ret = ff_alloc_packet2(avctx, pkt, avctx->width*avctx->height*((8*2+1+1)*4)/8
1012  + FF_MIN_BUFFER_SIZE)) < 0)
1013  return ret;
1014 
1015  ff_init_range_encoder(c, pkt->data, pkt->size);
1016  ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
1017 
1018  av_frame_unref(p);
1019  if ((ret = av_frame_ref(p, pict)) < 0)
1020  return ret;
1021  p->pict_type = AV_PICTURE_TYPE_I;
1022 
1023  if (avctx->gop_size == 0 || f->picture_number % avctx->gop_size == 0) {
1024  put_rac(c, &keystate, 1);
1025  p->key_frame = 1;
1026  f->gob_count++;
1027  write_header(f);
1028  } else {
1029  put_rac(c, &keystate, 0);
1030  p->key_frame = 0;
1031  }
1032 
1033  if (f->ac > 1) {
1034  int i;
1035  for (i = 1; i < 256; i++) {
1036  c->one_state[i] = f->state_transition[i];
1037  c->zero_state[256 - i] = 256 - c->one_state[i];
1038  }
1039  }
1040 
1041  for (i = 1; i < f->slice_count; i++) {
1042  FFV1Context *fs = f->slice_context[i];
1043  uint8_t *start = pkt->data + (pkt->size - used_count) * (int64_t)i / f->slice_count;
1044  int len = pkt->size / f->slice_count;
1045  ff_init_range_encoder(&fs->c, start, len);
1046  }
1047  avctx->execute(avctx, encode_slice, &f->slice_context[0], NULL,
1048  f->slice_count, sizeof(void *));
1049 
1050  buf_p = pkt->data;
1051  for (i = 0; i < f->slice_count; i++) {
1052  FFV1Context *fs = f->slice_context[i];
1053  int bytes;
1054 
1055  if (fs->ac) {
1056  uint8_t state = 129;
1057  put_rac(&fs->c, &state, 0);
1058  bytes = ff_rac_terminate(&fs->c);
1059  } else {
1060  flush_put_bits(&fs->pb); // FIXME: nicer padding
1061  bytes = fs->ac_byte_count + (put_bits_count(&fs->pb) + 7) / 8;
1062  }
1063  if (i > 0 || f->version > 2) {
1064  av_assert0(bytes < pkt->size / f->slice_count);
1065  memmove(buf_p, fs->c.bytestream_start, bytes);
1066  av_assert0(bytes < (1 << 24));
1067  AV_WB24(buf_p + bytes, bytes);
1068  bytes += 3;
1069  }
1070  if (f->ec) {
1071  unsigned v;
1072  buf_p[bytes++] = 0;
1073  v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, buf_p, bytes);
1074  AV_WL32(buf_p + bytes, v);
1075  bytes += 4;
1076  }
1077  buf_p += bytes;
1078  }
1079 
1080  if ((avctx->flags & CODEC_FLAG_PASS1) && (f->picture_number & 31) == 0) {
1081  int j, k, m;
1082  char *p = avctx->stats_out;
1083  char *end = p + STATS_OUT_SIZE;
1084 
1085  memset(f->rc_stat, 0, sizeof(f->rc_stat));
1086  for (i = 0; i < f->quant_table_count; i++)
1087  memset(f->rc_stat2[i], 0, f->context_count[i] * sizeof(*f->rc_stat2[i]));
1088 
1089  for (j = 0; j < f->slice_count; j++) {
1090  FFV1Context *fs = f->slice_context[j];
1091  for (i = 0; i < 256; i++) {
1092  f->rc_stat[i][0] += fs->rc_stat[i][0];
1093  f->rc_stat[i][1] += fs->rc_stat[i][1];
1094  }
1095  for (i = 0; i < f->quant_table_count; i++) {
1096  for (k = 0; k < f->context_count[i]; k++)
1097  for (m = 0; m < 32; m++) {
1098  f->rc_stat2[i][k][m][0] += fs->rc_stat2[i][k][m][0];
1099  f->rc_stat2[i][k][m][1] += fs->rc_stat2[i][k][m][1];
1100  }
1101  }
1102  }
1103 
1104  for (j = 0; j < 256; j++) {
1105  snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1106  f->rc_stat[j][0], f->rc_stat[j][1]);
1107  p += strlen(p);
1108  }
1109  snprintf(p, end - p, "\n");
1110 
1111  for (i = 0; i < f->quant_table_count; i++) {
1112  for (j = 0; j < f->context_count[i]; j++)
1113  for (m = 0; m < 32; m++) {
1114  snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1115  f->rc_stat2[i][j][m][0], f->rc_stat2[i][j][m][1]);
1116  p += strlen(p);
1117  }
1118  }
1119  snprintf(p, end - p, "%d\n", f->gob_count);
1120  } else if (avctx->flags & CODEC_FLAG_PASS1)
1121  avctx->stats_out[0] = '\0';
1122 
1123  f->picture_number++;
1124  pkt->size = buf_p - pkt->data;
1125  pkt->flags |= AV_PKT_FLAG_KEY * p->key_frame;
1126  *got_packet = 1;
1127 
1128  return 0;
1129 }
1130 
1131 #define OFFSET(x) offsetof(FFV1Context, x)
1132 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1133 static const AVOption options[] = {
1134  { "slicecrc", "Protect slices with CRCs", OFFSET(ec), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1, VE },
1135  { NULL }
1136 };
1137 
1138 static const AVClass ffv1_class = {
1139  .class_name = "ffv1 encoder",
1140  .item_name = av_default_item_name,
1141  .option = options,
1142  .version = LIBAVUTIL_VERSION_INT,
1143 };
1144 
1145 static const AVCodecDefault ffv1_defaults[] = {
1146  { "coder", "-1" },
1147  { NULL },
1148 };
1149 
1150 AVCodec ff_ffv1_encoder = {
1151  .name = "ffv1",
1152  .type = AVMEDIA_TYPE_VIDEO,
1153  .id = AV_CODEC_ID_FFV1,
1154  .priv_data_size = sizeof(FFV1Context),
1155  .init = encode_init,
1156  .encode2 = encode_frame,
1157  .close = ffv1_close,
1158  .capabilities = CODEC_CAP_SLICE_THREADS,
1159  .pix_fmts = (const enum AVPixelFormat[]) {
1160  AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV444P,
1161  AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV411P,
1162  AV_PIX_FMT_YUV410P, AV_PIX_FMT_0RGB32, AV_PIX_FMT_RGB32, AV_PIX_FMT_YUV420P16,
1163  AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16, AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV422P9,
1164  AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
1165  AV_PIX_FMT_GRAY16, AV_PIX_FMT_GRAY8, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
1166  AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14,
1167  AV_PIX_FMT_NONE
1168 
1169  },
1170  .long_name = NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1171  .defaults = ffv1_defaults,
1172  .priv_class = &ffv1_class,
1173 };
Generated on Wed Jul 10 2013 23:47:58 for FFmpeg by   doxygen 1.8.2