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
35 #include "avcodec.h"
36 #include "encode.h"
37 #include "codec_internal.h"
38 #include "put_bits.h"
39 #include "put_golomb.h"
40 #include "rangecoder.h"
41 #include "mathops.h"
42 #include "ffv1.h"
43
44 static const int8_t quant5_10bit[256] = {
45 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
48 1, 1, 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, -2,
57 -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -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, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
60 -1, -1, -1, -1, -1, -1, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0,
61 };
62
63 static const int8_t quant5[256] = {
64 0, 1, 1, 1, 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, -2, -2, -2,
79 -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -1, -1, -1,
80 };
81
82 static const int8_t quant9_10bit[256] = {
83 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2,
84 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3,
85 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
86 3, 3, 3, 3, 3, 3, 3, 3, 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, -4, -4, -4, -4, -4, -4, -4,
95 -4, -4, -4, -4, -4, -4, -4, -4, -4, -3, -3, -3, -3, -3, -3, -3,
96 -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3,
97 -3, -3, -3, -3, -3, -3, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
98 -2, -2, -2, -2, -1, -1, -1, -1, -1, -1, -1, -1, -0, -0, -0, -0,
99 };
100
101 static const int8_t quant11[256] = {
102 0, 1, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4,
103 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
104 4, 4, 4, 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, -5, -5,
115 -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -4, -4,
116 -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4,
117 -4, -4, -4, -4, -4, -3, -3, -3, -3, -3, -3, -3, -2, -2, -2, -1,
118 };
119
120 static const uint8_t ver2_state[256] = {
121 0, 10, 10, 10, 10, 16, 16, 16, 28, 16, 16, 29, 42, 49, 20, 49,
122 59, 25, 26, 26, 27, 31, 33, 33, 33, 34, 34, 37, 67, 38, 39, 39,
123 40, 40, 41, 79, 43, 44, 45, 45, 48, 48, 64, 50, 51, 52, 88, 52,
124 53, 74, 55, 57, 58, 58, 74, 60, 101, 61, 62, 84, 66, 66, 68, 69,
125 87, 82, 71, 97, 73, 73, 82, 75, 111, 77, 94, 78, 87, 81, 83, 97,
126 85, 83, 94, 86, 99, 89, 90, 99, 111, 92, 93, 134, 95, 98, 105, 98,
127 105, 110, 102, 108, 102, 118, 103, 106, 106, 113, 109, 112, 114, 112, 116, 125,
128 115, 116, 117, 117, 126, 119, 125, 121, 121, 123, 145, 124, 126, 131, 127, 129,
129 165, 130, 132, 138, 133, 135, 145, 136, 137, 139, 146, 141, 143, 142, 144, 148,
130 147, 155, 151, 149, 151, 150, 152, 157, 153, 154, 156, 168, 158, 162, 161, 160,
131 172, 163, 169, 164, 166, 184, 167, 170, 177, 174, 171, 173, 182, 176, 180, 178,
132 175, 189, 179, 181, 186, 183, 192, 185, 200, 187, 191, 188, 190, 197, 193, 196,
133 197, 194, 195, 196, 198, 202, 199, 201, 210, 203, 207, 204, 205, 206, 208, 214,
134 209, 211, 221, 212, 213, 215, 224, 216, 217, 218, 219, 220, 222, 228, 223, 225,
135 226, 224, 227, 229, 240, 230, 231, 232, 233, 234, 235, 236, 238, 239, 237, 242,
136 241, 243, 242, 244, 245, 246, 247, 248, 249, 250, 251, 252, 252, 253, 254, 255,
137 };
138
find_best_state(uint8_t best_state[256][256],const uint8_t one_state[256])139 static void find_best_state(uint8_t best_state[256][256],
140 const uint8_t one_state[256])
141 {
142 int i, j, k, m;
143 uint32_t l2tab[256];
144
145 for (i = 1; i < 256; i++)
146 l2tab[i] = -log2(i / 256.0) * ((1U << 31) / 8);
147
148 for (i = 0; i < 256; i++) {
149 uint64_t best_len[256];
150
151 for (j = 0; j < 256; j++)
152 best_len[j] = UINT64_MAX;
153
154 for (j = FFMAX(i - 10, 1); j < FFMIN(i + 11, 256); j++) {
155 uint32_t occ[256] = { 0 };
156 uint64_t len = 0;
157 occ[j] = UINT32_MAX;
158
159 if (!one_state[j])
160 continue;
161
162 for (k = 0; k < 256; k++) {
163 uint32_t newocc[256] = { 0 };
164 for (m = 1; m < 256; m++)
165 if (occ[m]) {
166 len += (occ[m]*(( i *(uint64_t)l2tab[ m]
167 + (256-i)*(uint64_t)l2tab[256-m])>>8)) >> 8;
168 }
169 if (len < best_len[k]) {
170 best_len[k] = len;
171 best_state[i][k] = j;
172 }
173 for (m = 1; m < 256; m++)
174 if (occ[m]) {
175 newocc[ one_state[ m]] += occ[m] * (uint64_t) i >> 8;
176 newocc[256 - one_state[256 - m]] += occ[m] * (uint64_t)(256 - i) >> 8;
177 }
178 memcpy(occ, newocc, sizeof(occ));
179 }
180 }
181 }
182 }
183
put_symbol_inline(RangeCoder * c,uint8_t * state,int v,int is_signed,uint64_t rc_stat[256][2],uint64_t rc_stat2[32][2])184 static av_always_inline av_flatten void put_symbol_inline(RangeCoder *c,
185 uint8_t *state, int v,
186 int is_signed,
187 uint64_t rc_stat[256][2],
188 uint64_t rc_stat2[32][2])
189 {
190 int i;
191
192 #define put_rac(C, S, B) \
193 do { \
194 if (rc_stat) { \
195 rc_stat[*(S)][B]++; \
196 rc_stat2[(S) - state][B]++; \
197 } \
198 put_rac(C, S, B); \
199 } while (0)
200
201 if (v) {
202 const int a = FFABS(v);
203 const int e = av_log2(a);
204 put_rac(c, state + 0, 0);
205 if (e <= 9) {
206 for (i = 0; i < e; i++)
207 put_rac(c, state + 1 + i, 1); // 1..10
208 put_rac(c, state + 1 + i, 0);
209
210 for (i = e - 1; i >= 0; i--)
211 put_rac(c, state + 22 + i, (a >> i) & 1); // 22..31
212
213 if (is_signed)
214 put_rac(c, state + 11 + e, v < 0); // 11..21
215 } else {
216 for (i = 0; i < e; i++)
217 put_rac(c, state + 1 + FFMIN(i, 9), 1); // 1..10
218 put_rac(c, state + 1 + 9, 0);
219
220 for (i = e - 1; i >= 0; i--)
221 put_rac(c, state + 22 + FFMIN(i, 9), (a >> i) & 1); // 22..31
222
223 if (is_signed)
224 put_rac(c, state + 11 + 10, v < 0); // 11..21
225 }
226 } else {
227 put_rac(c, state + 0, 1);
228 }
229 #undef put_rac
230 }
231
put_symbol(RangeCoder * c,uint8_t * state,int v,int is_signed)232 static av_noinline void put_symbol(RangeCoder *c, uint8_t *state,
233 int v, int is_signed)
234 {
235 put_symbol_inline(c, state, v, is_signed, NULL, NULL);
236 }
237
238
put_vlc_symbol(PutBitContext * pb,VlcState * const state,int v,int bits)239 static inline void put_vlc_symbol(PutBitContext *pb, VlcState *const state,
240 int v, int bits)
241 {
242 int i, k, code;
243 v = fold(v - state->bias, bits);
244
245 i = state->count;
246 k = 0;
247 while (i < state->error_sum) { // FIXME: optimize
248 k++;
249 i += i;
250 }
251
252 av_assert2(k <= 13);
253
254 code = v ^ ((2 * state->drift + state->count) >> 31);
255
256 ff_dlog(NULL, "v:%d/%d bias:%d error:%d drift:%d count:%d k:%d\n", v, code,
257 state->bias, state->error_sum, state->drift, state->count, k);
258 set_sr_golomb(pb, code, k, 12, bits);
259
260 update_vlc_state(state, v);
261 }
262
263 #define TYPE int16_t
264 #define RENAME(name) name
265 #include "ffv1enc_template.c"
266 #undef TYPE
267 #undef RENAME
268
269 #define TYPE int32_t
270 #define RENAME(name) name ## 32
271 #include "ffv1enc_template.c"
272
encode_plane(FFV1Context * s,uint8_t * src,int w,int h,int stride,int plane_index,int pixel_stride)273 static int encode_plane(FFV1Context *s, uint8_t *src, int w, int h,
274 int stride, int plane_index, int pixel_stride)
275 {
276 int x, y, i, ret;
277 const int ring_size = s->context_model ? 3 : 2;
278 int16_t *sample[3];
279 s->run_index = 0;
280
281 memset(s->sample_buffer, 0, ring_size * (w + 6) * sizeof(*s->sample_buffer));
282
283 for (y = 0; y < h; y++) {
284 for (i = 0; i < ring_size; i++)
285 sample[i] = s->sample_buffer + (w + 6) * ((h + i - y) % ring_size) + 3;
286
287 sample[0][-1]= sample[1][0 ];
288 sample[1][ w]= sample[1][w-1];
289 if (s->bits_per_raw_sample <= 8) {
290 for (x = 0; x < w; x++)
291 sample[0][x] = src[x * pixel_stride + stride * y];
292 if((ret = encode_line(s, w, sample, plane_index, 8)) < 0)
293 return ret;
294 } else {
295 if (s->packed_at_lsb) {
296 for (x = 0; x < w; x++) {
297 sample[0][x] = ((uint16_t*)(src + stride*y))[x];
298 }
299 } else {
300 for (x = 0; x < w; x++) {
301 sample[0][x] = ((uint16_t*)(src + stride*y))[x] >> (16 - s->bits_per_raw_sample);
302 }
303 }
304 if((ret = encode_line(s, w, sample, plane_index, s->bits_per_raw_sample)) < 0)
305 return ret;
306 }
307 }
308 return 0;
309 }
310
write_quant_table(RangeCoder * c,int16_t * quant_table)311 static void write_quant_table(RangeCoder *c, int16_t *quant_table)
312 {
313 int last = 0;
314 int i;
315 uint8_t state[CONTEXT_SIZE];
316 memset(state, 128, sizeof(state));
317
318 for (i = 1; i < 128; i++)
319 if (quant_table[i] != quant_table[i - 1]) {
320 put_symbol(c, state, i - last - 1, 0);
321 last = i;
322 }
323 put_symbol(c, state, i - last - 1, 0);
324 }
325
write_quant_tables(RangeCoder * c,int16_t quant_table[MAX_CONTEXT_INPUTS][256])326 static void write_quant_tables(RangeCoder *c,
327 int16_t quant_table[MAX_CONTEXT_INPUTS][256])
328 {
329 int i;
330 for (i = 0; i < 5; i++)
331 write_quant_table(c, quant_table[i]);
332 }
333
contains_non_128(uint8_t (* initial_state)[CONTEXT_SIZE],int nb_contexts)334 static int contains_non_128(uint8_t (*initial_state)[CONTEXT_SIZE],
335 int nb_contexts)
336 {
337 if (!initial_state)
338 return 0;
339 for (int i = 0; i < nb_contexts; i++)
340 for (int j = 0; j < CONTEXT_SIZE; j++)
341 if (initial_state[i][j] != 128)
342 return 1;
343 return 0;
344 }
345
write_header(FFV1Context * f)346 static void write_header(FFV1Context *f)
347 {
348 uint8_t state[CONTEXT_SIZE];
349 int i, j;
350 RangeCoder *const c = &f->slice_context[0]->c;
351
352 memset(state, 128, sizeof(state));
353
354 if (f->version < 2) {
355 put_symbol(c, state, f->version, 0);
356 put_symbol(c, state, f->ac, 0);
357 if (f->ac == AC_RANGE_CUSTOM_TAB) {
358 for (i = 1; i < 256; i++)
359 put_symbol(c, state,
360 f->state_transition[i] - c->one_state[i], 1);
361 }
362 put_symbol(c, state, f->colorspace, 0); //YUV cs type
363 if (f->version > 0)
364 put_symbol(c, state, f->bits_per_raw_sample, 0);
365 put_rac(c, state, f->chroma_planes);
366 put_symbol(c, state, f->chroma_h_shift, 0);
367 put_symbol(c, state, f->chroma_v_shift, 0);
368 put_rac(c, state, f->transparency);
369
370 write_quant_tables(c, f->quant_table);
371 } else if (f->version < 3) {
372 put_symbol(c, state, f->slice_count, 0);
373 for (i = 0; i < f->slice_count; i++) {
374 FFV1Context *fs = f->slice_context[i];
375 put_symbol(c, state,
376 (fs->slice_x + 1) * f->num_h_slices / f->width, 0);
377 put_symbol(c, state,
378 (fs->slice_y + 1) * f->num_v_slices / f->height, 0);
379 put_symbol(c, state,
380 (fs->slice_width + 1) * f->num_h_slices / f->width - 1,
381 0);
382 put_symbol(c, state,
383 (fs->slice_height + 1) * f->num_v_slices / f->height - 1,
384 0);
385 for (j = 0; j < f->plane_count; j++) {
386 put_symbol(c, state, f->plane[j].quant_table_index, 0);
387 av_assert0(f->plane[j].quant_table_index == f->context_model);
388 }
389 }
390 }
391 }
392
write_extradata(FFV1Context * f)393 static int write_extradata(FFV1Context *f)
394 {
395 RangeCoder *const c = &f->c;
396 uint8_t state[CONTEXT_SIZE];
397 int i, j, k;
398 uint8_t state2[32][CONTEXT_SIZE];
399 unsigned v;
400
401 memset(state2, 128, sizeof(state2));
402 memset(state, 128, sizeof(state));
403
404 f->avctx->extradata_size = 10000 + 4 +
405 (11 * 11 * 5 * 5 * 5 + 11 * 11 * 11) * 32;
406 f->avctx->extradata = av_malloc(f->avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
407 if (!f->avctx->extradata)
408 return AVERROR(ENOMEM);
409 ff_init_range_encoder(c, f->avctx->extradata, f->avctx->extradata_size);
410 ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
411
412 put_symbol(c, state, f->version, 0);
413 if (f->version > 2) {
414 if (f->version == 3) {
415 f->micro_version = 4;
416 } else if (f->version == 4)
417 f->micro_version = 2;
418 put_symbol(c, state, f->micro_version, 0);
419 }
420
421 put_symbol(c, state, f->ac, 0);
422 if (f->ac == AC_RANGE_CUSTOM_TAB)
423 for (i = 1; i < 256; i++)
424 put_symbol(c, state, f->state_transition[i] - c->one_state[i], 1);
425
426 put_symbol(c, state, f->colorspace, 0); // YUV cs type
427 put_symbol(c, state, f->bits_per_raw_sample, 0);
428 put_rac(c, state, f->chroma_planes);
429 put_symbol(c, state, f->chroma_h_shift, 0);
430 put_symbol(c, state, f->chroma_v_shift, 0);
431 put_rac(c, state, f->transparency);
432 put_symbol(c, state, f->num_h_slices - 1, 0);
433 put_symbol(c, state, f->num_v_slices - 1, 0);
434
435 put_symbol(c, state, f->quant_table_count, 0);
436 for (i = 0; i < f->quant_table_count; i++)
437 write_quant_tables(c, f->quant_tables[i]);
438
439 for (i = 0; i < f->quant_table_count; i++) {
440 if (contains_non_128(f->initial_states[i], f->context_count[i])) {
441 put_rac(c, state, 1);
442 for (j = 0; j < f->context_count[i]; j++)
443 for (k = 0; k < CONTEXT_SIZE; k++) {
444 int pred = j ? f->initial_states[i][j - 1][k] : 128;
445 put_symbol(c, state2[k],
446 (int8_t)(f->initial_states[i][j][k] - pred), 1);
447 }
448 } else {
449 put_rac(c, state, 0);
450 }
451 }
452
453 if (f->version > 2) {
454 put_symbol(c, state, f->ec, 0);
455 put_symbol(c, state, f->intra = (f->avctx->gop_size < 2), 0);
456 }
457
458 f->avctx->extradata_size = ff_rac_terminate(c, 0);
459 v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, f->avctx->extradata, f->avctx->extradata_size);
460 AV_WL32(f->avctx->extradata + f->avctx->extradata_size, v);
461 f->avctx->extradata_size += 4;
462
463 return 0;
464 }
465
sort_stt(FFV1Context * s,uint8_t stt[256])466 static int sort_stt(FFV1Context *s, uint8_t stt[256])
467 {
468 int i, i2, changed, print = 0;
469
470 do {
471 changed = 0;
472 for (i = 12; i < 244; i++) {
473 for (i2 = i + 1; i2 < 245 && i2 < i + 4; i2++) {
474
475 #define COST(old, new) \
476 s->rc_stat[old][0] * -log2((256 - (new)) / 256.0) + \
477 s->rc_stat[old][1] * -log2((new) / 256.0)
478
479 #define COST2(old, new) \
480 COST(old, new) + COST(256 - (old), 256 - (new))
481
482 double size0 = COST2(i, i) + COST2(i2, i2);
483 double sizeX = COST2(i, i2) + COST2(i2, i);
484 if (size0 - sizeX > size0*(1e-14) && i != 128 && i2 != 128) {
485 int j;
486 FFSWAP(int, stt[i], stt[i2]);
487 FFSWAP(int, s->rc_stat[i][0], s->rc_stat[i2][0]);
488 FFSWAP(int, s->rc_stat[i][1], s->rc_stat[i2][1]);
489 if (i != 256 - i2) {
490 FFSWAP(int, stt[256 - i], stt[256 - i2]);
491 FFSWAP(int, s->rc_stat[256 - i][0], s->rc_stat[256 - i2][0]);
492 FFSWAP(int, s->rc_stat[256 - i][1], s->rc_stat[256 - i2][1]);
493 }
494 for (j = 1; j < 256; j++) {
495 if (stt[j] == i)
496 stt[j] = i2;
497 else if (stt[j] == i2)
498 stt[j] = i;
499 if (i != 256 - i2) {
500 if (stt[256 - j] == 256 - i)
501 stt[256 - j] = 256 - i2;
502 else if (stt[256 - j] == 256 - i2)
503 stt[256 - j] = 256 - i;
504 }
505 }
506 print = changed = 1;
507 }
508 }
509 }
510 } while (changed);
511 return print;
512 }
513
encode_init(AVCodecContext * avctx)514 static av_cold int encode_init(AVCodecContext *avctx)
515 {
516 FFV1Context *s = avctx->priv_data;
517 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
518 int i, j, k, m, ret;
519
520 if ((ret = ff_ffv1_common_init(avctx)) < 0)
521 return ret;
522
523 s->version = 0;
524
525 if ((avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) ||
526 avctx->slices > 1)
527 s->version = FFMAX(s->version, 2);
528
529 // Unspecified level & slices, we choose version 1.2+ to ensure multithreaded decodability
530 if (avctx->slices == 0 && avctx->level < 0 && avctx->width * avctx->height > 720*576)
531 s->version = FFMAX(s->version, 2);
532
533 if (avctx->level <= 0 && s->version == 2) {
534 s->version = 3;
535 }
536 if (avctx->level >= 0 && avctx->level <= 4) {
537 if (avctx->level < s->version) {
538 av_log(avctx, AV_LOG_ERROR, "Version %d needed for requested features but %d requested\n", s->version, avctx->level);
539 return AVERROR(EINVAL);
540 }
541 s->version = avctx->level;
542 }
543
544 if (s->ec < 0) {
545 s->ec = (s->version >= 3);
546 }
547
548 // CRC requires version 3+
549 if (s->ec)
550 s->version = FFMAX(s->version, 3);
551
552 if ((s->version == 2 || s->version>3) && avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
553 av_log(avctx, AV_LOG_ERROR, "Version 2 needed for requested features but version 2 is experimental and not enabled\n");
554 return AVERROR_INVALIDDATA;
555 }
556
557 if (s->ac == 1) // Compatbility with common command line usage
558 s->ac = AC_RANGE_CUSTOM_TAB;
559 else if (s->ac == AC_RANGE_DEFAULT_TAB_FORCE)
560 s->ac = AC_RANGE_DEFAULT_TAB;
561
562 s->plane_count = 3;
563 switch(avctx->pix_fmt) {
564 case AV_PIX_FMT_GRAY9:
565 case AV_PIX_FMT_YUV444P9:
566 case AV_PIX_FMT_YUV422P9:
567 case AV_PIX_FMT_YUV420P9:
568 case AV_PIX_FMT_YUVA444P9:
569 case AV_PIX_FMT_YUVA422P9:
570 case AV_PIX_FMT_YUVA420P9:
571 if (!avctx->bits_per_raw_sample)
572 s->bits_per_raw_sample = 9;
573 case AV_PIX_FMT_GRAY10:
574 case AV_PIX_FMT_YUV444P10:
575 case AV_PIX_FMT_YUV440P10:
576 case AV_PIX_FMT_YUV420P10:
577 case AV_PIX_FMT_YUV422P10:
578 case AV_PIX_FMT_YUVA444P10:
579 case AV_PIX_FMT_YUVA422P10:
580 case AV_PIX_FMT_YUVA420P10:
581 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
582 s->bits_per_raw_sample = 10;
583 case AV_PIX_FMT_GRAY12:
584 case AV_PIX_FMT_YUV444P12:
585 case AV_PIX_FMT_YUV440P12:
586 case AV_PIX_FMT_YUV420P12:
587 case AV_PIX_FMT_YUV422P12:
588 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
589 s->bits_per_raw_sample = 12;
590 case AV_PIX_FMT_YUV444P14:
591 case AV_PIX_FMT_YUV420P14:
592 case AV_PIX_FMT_YUV422P14:
593 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
594 s->bits_per_raw_sample = 14;
595 s->packed_at_lsb = 1;
596 case AV_PIX_FMT_GRAY16:
597 case AV_PIX_FMT_YUV444P16:
598 case AV_PIX_FMT_YUV422P16:
599 case AV_PIX_FMT_YUV420P16:
600 case AV_PIX_FMT_YUVA444P16:
601 case AV_PIX_FMT_YUVA422P16:
602 case AV_PIX_FMT_YUVA420P16:
603 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) {
604 s->bits_per_raw_sample = 16;
605 } else if (!s->bits_per_raw_sample) {
606 s->bits_per_raw_sample = avctx->bits_per_raw_sample;
607 }
608 if (s->bits_per_raw_sample <= 8) {
609 av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");
610 return AVERROR_INVALIDDATA;
611 }
612 s->version = FFMAX(s->version, 1);
613 case AV_PIX_FMT_GRAY8:
614 case AV_PIX_FMT_YA8:
615 case AV_PIX_FMT_YUV444P:
616 case AV_PIX_FMT_YUV440P:
617 case AV_PIX_FMT_YUV422P:
618 case AV_PIX_FMT_YUV420P:
619 case AV_PIX_FMT_YUV411P:
620 case AV_PIX_FMT_YUV410P:
621 case AV_PIX_FMT_YUVA444P:
622 case AV_PIX_FMT_YUVA422P:
623 case AV_PIX_FMT_YUVA420P:
624 s->chroma_planes = desc->nb_components < 3 ? 0 : 1;
625 s->colorspace = 0;
626 s->transparency = !!(desc->flags & AV_PIX_FMT_FLAG_ALPHA);
627 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
628 s->bits_per_raw_sample = 8;
629 else if (!s->bits_per_raw_sample)
630 s->bits_per_raw_sample = 8;
631 break;
632 case AV_PIX_FMT_RGB32:
633 s->colorspace = 1;
634 s->transparency = 1;
635 s->chroma_planes = 1;
636 s->bits_per_raw_sample = 8;
637 break;
638 case AV_PIX_FMT_RGBA64:
639 s->colorspace = 1;
640 s->transparency = 1;
641 s->chroma_planes = 1;
642 s->bits_per_raw_sample = 16;
643 s->use32bit = 1;
644 s->version = FFMAX(s->version, 1);
645 break;
646 case AV_PIX_FMT_RGB48:
647 s->colorspace = 1;
648 s->chroma_planes = 1;
649 s->bits_per_raw_sample = 16;
650 s->use32bit = 1;
651 s->version = FFMAX(s->version, 1);
652 break;
653 case AV_PIX_FMT_0RGB32:
654 s->colorspace = 1;
655 s->chroma_planes = 1;
656 s->bits_per_raw_sample = 8;
657 break;
658 case AV_PIX_FMT_GBRP9:
659 if (!avctx->bits_per_raw_sample)
660 s->bits_per_raw_sample = 9;
661 case AV_PIX_FMT_GBRP10:
662 case AV_PIX_FMT_GBRAP10:
663 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
664 s->bits_per_raw_sample = 10;
665 case AV_PIX_FMT_GBRP12:
666 case AV_PIX_FMT_GBRAP12:
667 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
668 s->bits_per_raw_sample = 12;
669 case AV_PIX_FMT_GBRP14:
670 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
671 s->bits_per_raw_sample = 14;
672 case AV_PIX_FMT_GBRP16:
673 case AV_PIX_FMT_GBRAP16:
674 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
675 s->bits_per_raw_sample = 16;
676 else if (!s->bits_per_raw_sample)
677 s->bits_per_raw_sample = avctx->bits_per_raw_sample;
678 s->transparency = !!(desc->flags & AV_PIX_FMT_FLAG_ALPHA);
679 s->colorspace = 1;
680 s->chroma_planes = 1;
681 if (s->bits_per_raw_sample >= 16) {
682 s->use32bit = 1;
683 }
684 s->version = FFMAX(s->version, 1);
685 break;
686 default:
687 av_log(avctx, AV_LOG_ERROR, "format not supported\n");
688 return AVERROR(ENOSYS);
689 }
690 av_assert0(s->bits_per_raw_sample >= 8);
691
692 if (s->bits_per_raw_sample > 8) {
693 if (s->ac == AC_GOLOMB_RICE) {
694 av_log(avctx, AV_LOG_INFO,
695 "bits_per_raw_sample > 8, forcing range coder\n");
696 s->ac = AC_RANGE_CUSTOM_TAB;
697 }
698 }
699
700 if (s->ac == AC_RANGE_CUSTOM_TAB) {
701 for (i = 1; i < 256; i++)
702 s->state_transition[i] = ver2_state[i];
703 } else {
704 RangeCoder c;
705 ff_build_rac_states(&c, 0.05 * (1LL << 32), 256 - 8);
706 for (i = 1; i < 256; i++)
707 s->state_transition[i] = c.one_state[i];
708 }
709
710 for (i = 0; i < 256; i++) {
711 s->quant_table_count = 2;
712 if (s->bits_per_raw_sample <= 8) {
713 s->quant_tables[0][0][i]= quant11[i];
714 s->quant_tables[0][1][i]= 11*quant11[i];
715 s->quant_tables[0][2][i]= 11*11*quant11[i];
716 s->quant_tables[1][0][i]= quant11[i];
717 s->quant_tables[1][1][i]= 11*quant11[i];
718 s->quant_tables[1][2][i]= 11*11*quant5 [i];
719 s->quant_tables[1][3][i]= 5*11*11*quant5 [i];
720 s->quant_tables[1][4][i]= 5*5*11*11*quant5 [i];
721 } else {
722 s->quant_tables[0][0][i]= quant9_10bit[i];
723 s->quant_tables[0][1][i]= 11*quant9_10bit[i];
724 s->quant_tables[0][2][i]= 11*11*quant9_10bit[i];
725 s->quant_tables[1][0][i]= quant9_10bit[i];
726 s->quant_tables[1][1][i]= 11*quant9_10bit[i];
727 s->quant_tables[1][2][i]= 11*11*quant5_10bit[i];
728 s->quant_tables[1][3][i]= 5*11*11*quant5_10bit[i];
729 s->quant_tables[1][4][i]= 5*5*11*11*quant5_10bit[i];
730 }
731 }
732 s->context_count[0] = (11 * 11 * 11 + 1) / 2;
733 s->context_count[1] = (11 * 11 * 5 * 5 * 5 + 1) / 2;
734 memcpy(s->quant_table, s->quant_tables[s->context_model],
735 sizeof(s->quant_table));
736
737 for (i = 0; i < s->plane_count; i++) {
738 PlaneContext *const p = &s->plane[i];
739
740 memcpy(p->quant_table, s->quant_table, sizeof(p->quant_table));
741 p->quant_table_index = s->context_model;
742 p->context_count = s->context_count[p->quant_table_index];
743 }
744
745 if ((ret = ff_ffv1_allocate_initial_states(s)) < 0)
746 return ret;
747
748 if (!s->transparency)
749 s->plane_count = 2;
750 if (!s->chroma_planes && s->version > 3)
751 s->plane_count--;
752
753 ret = av_pix_fmt_get_chroma_sub_sample (avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
754 if (ret)
755 return ret;
756
757 s->picture_number = 0;
758
759 if (avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) {
760 for (i = 0; i < s->quant_table_count; i++) {
761 s->rc_stat2[i] = av_mallocz(s->context_count[i] *
762 sizeof(*s->rc_stat2[i]));
763 if (!s->rc_stat2[i])
764 return AVERROR(ENOMEM);
765 }
766 }
767 if (avctx->stats_in) {
768 char *p = avctx->stats_in;
769 uint8_t (*best_state)[256] = av_malloc_array(256, 256);
770 int gob_count = 0;
771 char *next;
772 if (!best_state)
773 return AVERROR(ENOMEM);
774
775 av_assert0(s->version >= 2);
776
777 for (;;) {
778 for (j = 0; j < 256; j++)
779 for (i = 0; i < 2; i++) {
780 s->rc_stat[j][i] = strtol(p, &next, 0);
781 if (next == p) {
782 av_log(avctx, AV_LOG_ERROR,
783 "2Pass file invalid at %d %d [%s]\n", j, i, p);
784 av_freep(&best_state);
785 return AVERROR_INVALIDDATA;
786 }
787 p = next;
788 }
789 for (i = 0; i < s->quant_table_count; i++)
790 for (j = 0; j < s->context_count[i]; j++) {
791 for (k = 0; k < 32; k++)
792 for (m = 0; m < 2; m++) {
793 s->rc_stat2[i][j][k][m] = strtol(p, &next, 0);
794 if (next == p) {
795 av_log(avctx, AV_LOG_ERROR,
796 "2Pass file invalid at %d %d %d %d [%s]\n",
797 i, j, k, m, p);
798 av_freep(&best_state);
799 return AVERROR_INVALIDDATA;
800 }
801 p = next;
802 }
803 }
804 gob_count = strtol(p, &next, 0);
805 if (next == p || gob_count <= 0) {
806 av_log(avctx, AV_LOG_ERROR, "2Pass file invalid\n");
807 av_freep(&best_state);
808 return AVERROR_INVALIDDATA;
809 }
810 p = next;
811 while (*p == '\n' || *p == ' ')
812 p++;
813 if (p[0] == 0)
814 break;
815 }
816 if (s->ac == AC_RANGE_CUSTOM_TAB)
817 sort_stt(s, s->state_transition);
818
819 find_best_state(best_state, s->state_transition);
820
821 for (i = 0; i < s->quant_table_count; i++) {
822 for (k = 0; k < 32; k++) {
823 double a=0, b=0;
824 int jp = 0;
825 for (j = 0; j < s->context_count[i]; j++) {
826 double p = 128;
827 if (s->rc_stat2[i][j][k][0] + s->rc_stat2[i][j][k][1] > 200 && j || a+b > 200) {
828 if (a+b)
829 p = 256.0 * b / (a + b);
830 s->initial_states[i][jp][k] =
831 best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];
832 for(jp++; jp<j; jp++)
833 s->initial_states[i][jp][k] = s->initial_states[i][jp-1][k];
834 a=b=0;
835 }
836 a += s->rc_stat2[i][j][k][0];
837 b += s->rc_stat2[i][j][k][1];
838 if (a+b) {
839 p = 256.0 * b / (a + b);
840 }
841 s->initial_states[i][j][k] =
842 best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];
843 }
844 }
845 }
846 av_freep(&best_state);
847 }
848
849 if (s->version > 1) {
850 int plane_count = 1 + 2*s->chroma_planes + s->transparency;
851 int max_h_slices = AV_CEIL_RSHIFT(avctx->width , s->chroma_h_shift);
852 int max_v_slices = AV_CEIL_RSHIFT(avctx->height, s->chroma_v_shift);
853 s->num_v_slices = (avctx->width > 352 || avctx->height > 288 || !avctx->slices) ? 2 : 1;
854
855 s->num_v_slices = FFMIN(s->num_v_slices, max_v_slices);
856
857 for (; s->num_v_slices < 32; s->num_v_slices++) {
858 for (s->num_h_slices = s->num_v_slices; s->num_h_slices < 2*s->num_v_slices; s->num_h_slices++) {
859 int maxw = (avctx->width + s->num_h_slices - 1) / s->num_h_slices;
860 int maxh = (avctx->height + s->num_v_slices - 1) / s->num_v_slices;
861 if (s->num_h_slices > max_h_slices || s->num_v_slices > max_v_slices)
862 continue;
863 if (maxw * maxh * (int64_t)(s->bits_per_raw_sample+1) * plane_count > 8<<24)
864 continue;
865 if (avctx->slices == s->num_h_slices * s->num_v_slices && avctx->slices <= MAX_SLICES || !avctx->slices)
866 goto slices_ok;
867 }
868 }
869 av_log(avctx, AV_LOG_ERROR,
870 "Unsupported number %d of slices requested, please specify a "
871 "supported number with -slices (ex:4,6,9,12,16, ...)\n",
872 avctx->slices);
873 return AVERROR(ENOSYS);
874 slices_ok:
875 if ((ret = write_extradata(s)) < 0)
876 return ret;
877 }
878
879 if ((ret = ff_ffv1_init_slice_contexts(s)) < 0)
880 return ret;
881 s->slice_count = s->max_slice_count;
882 if ((ret = ff_ffv1_init_slices_state(s)) < 0)
883 return ret;
884
885 #define STATS_OUT_SIZE 1024 * 1024 * 6
886 if (avctx->flags & AV_CODEC_FLAG_PASS1) {
887 avctx->stats_out = av_mallocz(STATS_OUT_SIZE);
888 if (!avctx->stats_out)
889 return AVERROR(ENOMEM);
890 for (i = 0; i < s->quant_table_count; i++)
891 for (j = 0; j < s->max_slice_count; j++) {
892 FFV1Context *sf = s->slice_context[j];
893 av_assert0(!sf->rc_stat2[i]);
894 sf->rc_stat2[i] = av_mallocz(s->context_count[i] *
895 sizeof(*sf->rc_stat2[i]));
896 if (!sf->rc_stat2[i])
897 return AVERROR(ENOMEM);
898 }
899 }
900
901 return 0;
902 }
903
encode_slice_header(FFV1Context * f,FFV1Context * fs)904 static void encode_slice_header(FFV1Context *f, FFV1Context *fs)
905 {
906 RangeCoder *c = &fs->c;
907 uint8_t state[CONTEXT_SIZE];
908 int j;
909 memset(state, 128, sizeof(state));
910
911 put_symbol(c, state, (fs->slice_x +1)*f->num_h_slices / f->width , 0);
912 put_symbol(c, state, (fs->slice_y +1)*f->num_v_slices / f->height , 0);
913 put_symbol(c, state, (fs->slice_width +1)*f->num_h_slices / f->width -1, 0);
914 put_symbol(c, state, (fs->slice_height+1)*f->num_v_slices / f->height-1, 0);
915 for (j=0; j<f->plane_count; j++) {
916 put_symbol(c, state, f->plane[j].quant_table_index, 0);
917 av_assert0(f->plane[j].quant_table_index == f->context_model);
918 }
919 if (!f->picture.f->interlaced_frame)
920 put_symbol(c, state, 3, 0);
921 else
922 put_symbol(c, state, 1 + !f->picture.f->top_field_first, 0);
923 put_symbol(c, state, f->picture.f->sample_aspect_ratio.num, 0);
924 put_symbol(c, state, f->picture.f->sample_aspect_ratio.den, 0);
925 if (f->version > 3) {
926 put_rac(c, state, fs->slice_coding_mode == 1);
927 if (fs->slice_coding_mode == 1)
928 ff_ffv1_clear_slice_state(f, fs);
929 put_symbol(c, state, fs->slice_coding_mode, 0);
930 if (fs->slice_coding_mode != 1) {
931 put_symbol(c, state, fs->slice_rct_by_coef, 0);
932 put_symbol(c, state, fs->slice_rct_ry_coef, 0);
933 }
934 }
935 }
936
choose_rct_params(FFV1Context * fs,const uint8_t * src[3],const int stride[3],int w,int h)937 static void choose_rct_params(FFV1Context *fs, const uint8_t *src[3], const int stride[3], int w, int h)
938 {
939 #define NB_Y_COEFF 15
940 static const int rct_y_coeff[15][2] = {
941 {0, 0}, // 4G
942 {1, 1}, // R + 2G + B
943 {2, 2}, // 2R + 2B
944 {0, 2}, // 2G + 2B
945 {2, 0}, // 2R + 2G
946 {4, 0}, // 4R
947 {0, 4}, // 4B
948
949 {0, 3}, // 1G + 3B
950 {3, 0}, // 3R + 1G
951 {3, 1}, // 3R + B
952 {1, 3}, // R + 3B
953 {1, 2}, // R + G + 2B
954 {2, 1}, // 2R + G + B
955 {0, 1}, // 3G + B
956 {1, 0}, // R + 3G
957 };
958
959 int stat[NB_Y_COEFF] = {0};
960 int x, y, i, p, best;
961 int16_t *sample[3];
962 int lbd = fs->bits_per_raw_sample <= 8;
963
964 for (y = 0; y < h; y++) {
965 int lastr=0, lastg=0, lastb=0;
966 for (p = 0; p < 3; p++)
967 sample[p] = fs->sample_buffer + p*w;
968
969 for (x = 0; x < w; x++) {
970 int b, g, r;
971 int ab, ag, ar;
972 if (lbd) {
973 unsigned v = *((const uint32_t*)(src[0] + x*4 + stride[0]*y));
974 b = v & 0xFF;
975 g = (v >> 8) & 0xFF;
976 r = (v >> 16) & 0xFF;
977 } else {
978 b = *((const uint16_t*)(src[0] + x*2 + stride[0]*y));
979 g = *((const uint16_t*)(src[1] + x*2 + stride[1]*y));
980 r = *((const uint16_t*)(src[2] + x*2 + stride[2]*y));
981 }
982
983 ar = r - lastr;
984 ag = g - lastg;
985 ab = b - lastb;
986 if (x && y) {
987 int bg = ag - sample[0][x];
988 int bb = ab - sample[1][x];
989 int br = ar - sample[2][x];
990
991 br -= bg;
992 bb -= bg;
993
994 for (i = 0; i<NB_Y_COEFF; i++) {
995 stat[i] += FFABS(bg + ((br*rct_y_coeff[i][0] + bb*rct_y_coeff[i][1])>>2));
996 }
997
998 }
999 sample[0][x] = ag;
1000 sample[1][x] = ab;
1001 sample[2][x] = ar;
1002
1003 lastr = r;
1004 lastg = g;
1005 lastb = b;
1006 }
1007 }
1008
1009 best = 0;
1010 for (i=1; i<NB_Y_COEFF; i++) {
1011 if (stat[i] < stat[best])
1012 best = i;
1013 }
1014
1015 fs->slice_rct_by_coef = rct_y_coeff[best][1];
1016 fs->slice_rct_ry_coef = rct_y_coeff[best][0];
1017 }
1018
encode_slice(AVCodecContext * c,void * arg)1019 static int encode_slice(AVCodecContext *c, void *arg)
1020 {
1021 FFV1Context *fs = *(void **)arg;
1022 FFV1Context *f = fs->avctx->priv_data;
1023 int width = fs->slice_width;
1024 int height = fs->slice_height;
1025 int x = fs->slice_x;
1026 int y = fs->slice_y;
1027 const AVFrame *const p = f->picture.f;
1028 const int ps = av_pix_fmt_desc_get(c->pix_fmt)->comp[0].step;
1029 int ret;
1030 RangeCoder c_bak = fs->c;
1031 const uint8_t *planes[4] = {p->data[0] + ps*x + y*p->linesize[0],
1032 p->data[1] ? p->data[1] + ps*x + y*p->linesize[1] : NULL,
1033 p->data[2] ? p->data[2] + ps*x + y*p->linesize[2] : NULL,
1034 p->data[3] ? p->data[3] + ps*x + y*p->linesize[3] : NULL};
1035
1036 fs->slice_coding_mode = 0;
1037 if (f->version > 3) {
1038 choose_rct_params(fs, planes, p->linesize, width, height);
1039 } else {
1040 fs->slice_rct_by_coef = 1;
1041 fs->slice_rct_ry_coef = 1;
1042 }
1043
1044 retry:
1045 if (f->key_frame)
1046 ff_ffv1_clear_slice_state(f, fs);
1047 if (f->version > 2) {
1048 encode_slice_header(f, fs);
1049 }
1050 if (fs->ac == AC_GOLOMB_RICE) {
1051 fs->ac_byte_count = f->version > 2 || (!x && !y) ? ff_rac_terminate(&fs->c, f->version > 2) : 0;
1052 init_put_bits(&fs->pb,
1053 fs->c.bytestream_start + fs->ac_byte_count,
1054 fs->c.bytestream_end - fs->c.bytestream_start - fs->ac_byte_count);
1055 }
1056
1057 if (f->colorspace == 0 && c->pix_fmt != AV_PIX_FMT_YA8) {
1058 const int chroma_width = AV_CEIL_RSHIFT(width, f->chroma_h_shift);
1059 const int chroma_height = AV_CEIL_RSHIFT(height, f->chroma_v_shift);
1060 const int cx = x >> f->chroma_h_shift;
1061 const int cy = y >> f->chroma_v_shift;
1062
1063 ret = encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 1);
1064
1065 if (f->chroma_planes) {
1066 ret |= encode_plane(fs, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1, 1);
1067 ret |= encode_plane(fs, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1, 1);
1068 }
1069 if (fs->transparency)
1070 ret |= encode_plane(fs, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], 2, 1);
1071 } else if (c->pix_fmt == AV_PIX_FMT_YA8) {
1072 ret = encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 2);
1073 ret |= encode_plane(fs, p->data[0] + 1 + ps*x + y*p->linesize[0], width, height, p->linesize[0], 1, 2);
1074 } else if (f->use32bit) {
1075 ret = encode_rgb_frame32(fs, planes, width, height, p->linesize);
1076 } else {
1077 ret = encode_rgb_frame(fs, planes, width, height, p->linesize);
1078 }
1079 emms_c();
1080
1081 if (ret < 0) {
1082 av_assert0(fs->slice_coding_mode == 0);
1083 if (fs->version < 4 || !fs->ac) {
1084 av_log(c, AV_LOG_ERROR, "Buffer too small\n");
1085 return ret;
1086 }
1087 av_log(c, AV_LOG_DEBUG, "Coding slice as PCM\n");
1088 fs->slice_coding_mode = 1;
1089 fs->c = c_bak;
1090 goto retry;
1091 }
1092
1093 return 0;
1094 }
1095
encode_frame(AVCodecContext * avctx,AVPacket * pkt,const AVFrame * pict,int * got_packet)1096 static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
1097 const AVFrame *pict, int *got_packet)
1098 {
1099 FFV1Context *f = avctx->priv_data;
1100 RangeCoder *const c = &f->slice_context[0]->c;
1101 AVFrame *const p = f->picture.f;
1102 uint8_t keystate = 128;
1103 uint8_t *buf_p;
1104 int i, ret;
1105 int64_t maxsize = AV_INPUT_BUFFER_MIN_SIZE
1106 + avctx->width*avctx->height*37LL*4;
1107
1108 if(!pict) {
1109 if (avctx->flags & AV_CODEC_FLAG_PASS1) {
1110 int j, k, m;
1111 char *p = avctx->stats_out;
1112 char *end = p + STATS_OUT_SIZE;
1113
1114 memset(f->rc_stat, 0, sizeof(f->rc_stat));
1115 for (i = 0; i < f->quant_table_count; i++)
1116 memset(f->rc_stat2[i], 0, f->context_count[i] * sizeof(*f->rc_stat2[i]));
1117
1118 av_assert0(f->slice_count == f->max_slice_count);
1119 for (j = 0; j < f->slice_count; j++) {
1120 FFV1Context *fs = f->slice_context[j];
1121 for (i = 0; i < 256; i++) {
1122 f->rc_stat[i][0] += fs->rc_stat[i][0];
1123 f->rc_stat[i][1] += fs->rc_stat[i][1];
1124 }
1125 for (i = 0; i < f->quant_table_count; i++) {
1126 for (k = 0; k < f->context_count[i]; k++)
1127 for (m = 0; m < 32; m++) {
1128 f->rc_stat2[i][k][m][0] += fs->rc_stat2[i][k][m][0];
1129 f->rc_stat2[i][k][m][1] += fs->rc_stat2[i][k][m][1];
1130 }
1131 }
1132 }
1133
1134 for (j = 0; j < 256; j++) {
1135 snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1136 f->rc_stat[j][0], f->rc_stat[j][1]);
1137 p += strlen(p);
1138 }
1139 snprintf(p, end - p, "\n");
1140
1141 for (i = 0; i < f->quant_table_count; i++) {
1142 for (j = 0; j < f->context_count[i]; j++)
1143 for (m = 0; m < 32; m++) {
1144 snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1145 f->rc_stat2[i][j][m][0], f->rc_stat2[i][j][m][1]);
1146 p += strlen(p);
1147 }
1148 }
1149 snprintf(p, end - p, "%d\n", f->gob_count);
1150 }
1151 return 0;
1152 }
1153
1154 if (f->version > 3)
1155 maxsize = AV_INPUT_BUFFER_MIN_SIZE + avctx->width*avctx->height*3LL*4;
1156
1157 if (maxsize > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE - 32) {
1158 av_log(avctx, AV_LOG_WARNING, "Cannot allocate worst case packet size, the encoding could fail\n");
1159 maxsize = INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE - 32;
1160 }
1161
1162 if ((ret = ff_alloc_packet(avctx, pkt, maxsize)) < 0)
1163 return ret;
1164
1165 ff_init_range_encoder(c, pkt->data, pkt->size);
1166 ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
1167
1168 av_frame_unref(p);
1169 if ((ret = av_frame_ref(p, pict)) < 0)
1170 return ret;
1171
1172 if (avctx->gop_size == 0 || f->picture_number % avctx->gop_size == 0) {
1173 put_rac(c, &keystate, 1);
1174 f->key_frame = 1;
1175 f->gob_count++;
1176 write_header(f);
1177 } else {
1178 put_rac(c, &keystate, 0);
1179 f->key_frame = 0;
1180 }
1181
1182 if (f->ac == AC_RANGE_CUSTOM_TAB) {
1183 int i;
1184 for (i = 1; i < 256; i++) {
1185 c->one_state[i] = f->state_transition[i];
1186 c->zero_state[256 - i] = 256 - c->one_state[i];
1187 }
1188 }
1189
1190 for (i = 0; i < f->slice_count; i++) {
1191 FFV1Context *fs = f->slice_context[i];
1192 uint8_t *start = pkt->data + pkt->size * (int64_t)i / f->slice_count;
1193 int len = pkt->size / f->slice_count;
1194 if (i) {
1195 ff_init_range_encoder(&fs->c, start, len);
1196 } else {
1197 av_assert0(fs->c.bytestream_end >= fs->c.bytestream_start + len);
1198 av_assert0(fs->c.bytestream < fs->c.bytestream_start + len);
1199 fs->c.bytestream_end = fs->c.bytestream_start + len;
1200 }
1201 }
1202 avctx->execute(avctx, encode_slice, &f->slice_context[0], NULL,
1203 f->slice_count, sizeof(void *));
1204
1205 buf_p = pkt->data;
1206 for (i = 0; i < f->slice_count; i++) {
1207 FFV1Context *fs = f->slice_context[i];
1208 int bytes;
1209
1210 if (fs->ac != AC_GOLOMB_RICE) {
1211 bytes = ff_rac_terminate(&fs->c, 1);
1212 } else {
1213 flush_put_bits(&fs->pb); // FIXME: nicer padding
1214 bytes = fs->ac_byte_count + put_bytes_output(&fs->pb);
1215 }
1216 if (i > 0 || f->version > 2) {
1217 av_assert0(bytes < pkt->size / f->slice_count);
1218 memmove(buf_p, fs->c.bytestream_start, bytes);
1219 av_assert0(bytes < (1 << 24));
1220 AV_WB24(buf_p + bytes, bytes);
1221 bytes += 3;
1222 }
1223 if (f->ec) {
1224 unsigned v;
1225 buf_p[bytes++] = 0;
1226 v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, buf_p, bytes);
1227 AV_WL32(buf_p + bytes, v);
1228 bytes += 4;
1229 }
1230 buf_p += bytes;
1231 }
1232
1233 if (avctx->flags & AV_CODEC_FLAG_PASS1)
1234 avctx->stats_out[0] = '\0';
1235
1236 f->picture_number++;
1237 pkt->size = buf_p - pkt->data;
1238 pkt->pts =
1239 pkt->dts = pict->pts;
1240 pkt->flags |= AV_PKT_FLAG_KEY * f->key_frame;
1241 *got_packet = 1;
1242
1243 return 0;
1244 }
1245
encode_close(AVCodecContext * avctx)1246 static av_cold int encode_close(AVCodecContext *avctx)
1247 {
1248 ff_ffv1_close(avctx);
1249 return 0;
1250 }
1251
1252 #define OFFSET(x) offsetof(FFV1Context, x)
1253 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1254 static const AVOption options[] = {
1255 { "slicecrc", "Protect slices with CRCs", OFFSET(ec), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE },
1256 { "coder", "Coder type", OFFSET(ac), AV_OPT_TYPE_INT,
1257 { .i64 = 0 }, -2, 2, VE, "coder" },
1258 { "rice", "Golomb rice", 0, AV_OPT_TYPE_CONST,
1259 { .i64 = AC_GOLOMB_RICE }, INT_MIN, INT_MAX, VE, "coder" },
1260 { "range_def", "Range with default table", 0, AV_OPT_TYPE_CONST,
1261 { .i64 = AC_RANGE_DEFAULT_TAB_FORCE }, INT_MIN, INT_MAX, VE, "coder" },
1262 { "range_tab", "Range with custom table", 0, AV_OPT_TYPE_CONST,
1263 { .i64 = AC_RANGE_CUSTOM_TAB }, INT_MIN, INT_MAX, VE, "coder" },
1264 { "ac", "Range with custom table (the ac option exists for compatibility and is deprecated)", 0, AV_OPT_TYPE_CONST,
1265 { .i64 = 1 }, INT_MIN, INT_MAX, VE, "coder" },
1266 { "context", "Context model", OFFSET(context_model), AV_OPT_TYPE_INT,
1267 { .i64 = 0 }, 0, 1, VE },
1268
1269 { NULL }
1270 };
1271
1272 static const AVClass ffv1_class = {
1273 .class_name = "ffv1 encoder",
1274 .item_name = av_default_item_name,
1275 .option = options,
1276 .version = LIBAVUTIL_VERSION_INT,
1277 };
1278
1279 const FFCodec ff_ffv1_encoder = {
1280 .p.name = "ffv1",
1281 .p.long_name = NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1282 .p.type = AVMEDIA_TYPE_VIDEO,
1283 .p.id = AV_CODEC_ID_FFV1,
1284 .priv_data_size = sizeof(FFV1Context),
1285 .init = encode_init,
1286 FF_CODEC_ENCODE_CB(encode_frame),
1287 .close = encode_close,
1288 .p.capabilities = AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_DELAY,
1289 .p.pix_fmts = (const enum AVPixelFormat[]) {
1290 AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV444P,
1291 AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV411P,
1292 AV_PIX_FMT_YUV410P, AV_PIX_FMT_0RGB32, AV_PIX_FMT_RGB32, AV_PIX_FMT_YUV420P16,
1293 AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16, AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV422P9,
1294 AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
1295 AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12,
1296 AV_PIX_FMT_YUVA444P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA420P16,
1297 AV_PIX_FMT_YUVA444P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA420P10,
1298 AV_PIX_FMT_YUVA444P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA420P9,
1299 AV_PIX_FMT_GRAY16, AV_PIX_FMT_GRAY8, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
1300 AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14,
1301 AV_PIX_FMT_GBRAP10, AV_PIX_FMT_GBRAP12,
1302 AV_PIX_FMT_YA8,
1303 AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY12,
1304 AV_PIX_FMT_GBRP16, AV_PIX_FMT_RGB48,
1305 AV_PIX_FMT_GBRAP16, AV_PIX_FMT_RGBA64,
1306 AV_PIX_FMT_GRAY9,
1307 AV_PIX_FMT_YUV420P14, AV_PIX_FMT_YUV422P14, AV_PIX_FMT_YUV444P14,
1308 AV_PIX_FMT_YUV440P10, AV_PIX_FMT_YUV440P12,
1309 AV_PIX_FMT_NONE
1310
1311 },
1312 .p.priv_class = &ffv1_class,
1313 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,
1314 };
1315