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