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 "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
find_best_state(uint8_t best_state[256][256],const uint8_t one_state[256])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
159 if (!one_state[j])
160 continue;
161
162 for (k = 0; k < 256; k++) {
163 double newocc[256] = { 0 };
164 for (m = 1; m < 256; m++)
165 if (occ[m]) {
166 len -=occ[m]*( p *l2tab[ m]
167 + (1-p)*l2tab[256-m]);
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] * p;
176 newocc[256 - one_state[256 - m]] += occ[m] * (1 - p);
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 FF_API_CODER_TYPE
558 FF_DISABLE_DEPRECATION_WARNINGS
559 if (avctx->coder_type != -1)
560 s->ac = avctx->coder_type > 0 ? AC_RANGE_CUSTOM_TAB : AC_GOLOMB_RICE;
561 else
562 FF_ENABLE_DEPRECATION_WARNINGS
563 #endif
564 if (s->ac == 1) // Compatbility with common command line usage
565 s->ac = AC_RANGE_CUSTOM_TAB;
566 else if (s->ac == AC_RANGE_DEFAULT_TAB_FORCE)
567 s->ac = AC_RANGE_DEFAULT_TAB;
568
569 s->plane_count = 3;
570 switch(avctx->pix_fmt) {
571 case AV_PIX_FMT_GRAY9:
572 case AV_PIX_FMT_YUV444P9:
573 case AV_PIX_FMT_YUV422P9:
574 case AV_PIX_FMT_YUV420P9:
575 case AV_PIX_FMT_YUVA444P9:
576 case AV_PIX_FMT_YUVA422P9:
577 case AV_PIX_FMT_YUVA420P9:
578 if (!avctx->bits_per_raw_sample)
579 s->bits_per_raw_sample = 9;
580 case AV_PIX_FMT_GRAY10:
581 case AV_PIX_FMT_YUV444P10:
582 case AV_PIX_FMT_YUV440P10:
583 case AV_PIX_FMT_YUV420P10:
584 case AV_PIX_FMT_YUV422P10:
585 case AV_PIX_FMT_YUVA444P10:
586 case AV_PIX_FMT_YUVA422P10:
587 case AV_PIX_FMT_YUVA420P10:
588 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
589 s->bits_per_raw_sample = 10;
590 case AV_PIX_FMT_GRAY12:
591 case AV_PIX_FMT_YUV444P12:
592 case AV_PIX_FMT_YUV440P12:
593 case AV_PIX_FMT_YUV420P12:
594 case AV_PIX_FMT_YUV422P12:
595 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
596 s->bits_per_raw_sample = 12;
597 case AV_PIX_FMT_YUV444P14:
598 case AV_PIX_FMT_YUV420P14:
599 case AV_PIX_FMT_YUV422P14:
600 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
601 s->bits_per_raw_sample = 14;
602 s->packed_at_lsb = 1;
603 case AV_PIX_FMT_GRAY16:
604 case AV_PIX_FMT_YUV444P16:
605 case AV_PIX_FMT_YUV422P16:
606 case AV_PIX_FMT_YUV420P16:
607 case AV_PIX_FMT_YUVA444P16:
608 case AV_PIX_FMT_YUVA422P16:
609 case AV_PIX_FMT_YUVA420P16:
610 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) {
611 s->bits_per_raw_sample = 16;
612 } else if (!s->bits_per_raw_sample) {
613 s->bits_per_raw_sample = avctx->bits_per_raw_sample;
614 }
615 if (s->bits_per_raw_sample <= 8) {
616 av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");
617 return AVERROR_INVALIDDATA;
618 }
619 s->version = FFMAX(s->version, 1);
620 case AV_PIX_FMT_GRAY8:
621 case AV_PIX_FMT_YA8:
622 case AV_PIX_FMT_YUV444P:
623 case AV_PIX_FMT_YUV440P:
624 case AV_PIX_FMT_YUV422P:
625 case AV_PIX_FMT_YUV420P:
626 case AV_PIX_FMT_YUV411P:
627 case AV_PIX_FMT_YUV410P:
628 case AV_PIX_FMT_YUVA444P:
629 case AV_PIX_FMT_YUVA422P:
630 case AV_PIX_FMT_YUVA420P:
631 s->chroma_planes = desc->nb_components < 3 ? 0 : 1;
632 s->colorspace = 0;
633 s->transparency = !!(desc->flags & AV_PIX_FMT_FLAG_ALPHA);
634 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
635 s->bits_per_raw_sample = 8;
636 else if (!s->bits_per_raw_sample)
637 s->bits_per_raw_sample = 8;
638 break;
639 case AV_PIX_FMT_RGB32:
640 s->colorspace = 1;
641 s->transparency = 1;
642 s->chroma_planes = 1;
643 s->bits_per_raw_sample = 8;
644 break;
645 case AV_PIX_FMT_RGBA64:
646 s->colorspace = 1;
647 s->transparency = 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_RGB48:
654 s->colorspace = 1;
655 s->chroma_planes = 1;
656 s->bits_per_raw_sample = 16;
657 s->use32bit = 1;
658 s->version = FFMAX(s->version, 1);
659 break;
660 case AV_PIX_FMT_0RGB32:
661 s->colorspace = 1;
662 s->chroma_planes = 1;
663 s->bits_per_raw_sample = 8;
664 break;
665 case AV_PIX_FMT_GBRP9:
666 if (!avctx->bits_per_raw_sample)
667 s->bits_per_raw_sample = 9;
668 case AV_PIX_FMT_GBRP10:
669 case AV_PIX_FMT_GBRAP10:
670 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
671 s->bits_per_raw_sample = 10;
672 case AV_PIX_FMT_GBRP12:
673 case AV_PIX_FMT_GBRAP12:
674 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
675 s->bits_per_raw_sample = 12;
676 case AV_PIX_FMT_GBRP14:
677 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
678 s->bits_per_raw_sample = 14;
679 case AV_PIX_FMT_GBRP16:
680 case AV_PIX_FMT_GBRAP16:
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 s->transparency = !!(desc->flags & AV_PIX_FMT_FLAG_ALPHA);
686 s->colorspace = 1;
687 s->chroma_planes = 1;
688 if (s->bits_per_raw_sample >= 16) {
689 s->use32bit = 1;
690 }
691 s->version = FFMAX(s->version, 1);
692 break;
693 default:
694 av_log(avctx, AV_LOG_ERROR, "format not supported\n");
695 return AVERROR(ENOSYS);
696 }
697 av_assert0(s->bits_per_raw_sample >= 8);
698
699 if (s->bits_per_raw_sample > 8) {
700 if (s->ac == AC_GOLOMB_RICE) {
701 av_log(avctx, AV_LOG_INFO,
702 "bits_per_raw_sample > 8, forcing range coder\n");
703 s->ac = AC_RANGE_CUSTOM_TAB;
704 }
705 }
706 #if FF_API_PRIVATE_OPT
707 FF_DISABLE_DEPRECATION_WARNINGS
708 if (avctx->context_model)
709 s->context_model = avctx->context_model;
710 if (avctx->context_model > 1U) {
711 av_log(avctx, AV_LOG_ERROR, "Invalid context model %d, valid values are 0 and 1\n", avctx->context_model);
712 return AVERROR(EINVAL);
713 }
714 FF_ENABLE_DEPRECATION_WARNINGS
715 #endif
716
717 if (s->ac == AC_RANGE_CUSTOM_TAB) {
718 for (i = 1; i < 256; i++)
719 s->state_transition[i] = ver2_state[i];
720 } else {
721 RangeCoder c;
722 ff_build_rac_states(&c, 0.05 * (1LL << 32), 256 - 8);
723 for (i = 1; i < 256; i++)
724 s->state_transition[i] = c.one_state[i];
725 }
726
727 for (i = 0; i < 256; i++) {
728 s->quant_table_count = 2;
729 if (s->bits_per_raw_sample <= 8) {
730 s->quant_tables[0][0][i]= quant11[i];
731 s->quant_tables[0][1][i]= 11*quant11[i];
732 s->quant_tables[0][2][i]= 11*11*quant11[i];
733 s->quant_tables[1][0][i]= quant11[i];
734 s->quant_tables[1][1][i]= 11*quant11[i];
735 s->quant_tables[1][2][i]= 11*11*quant5 [i];
736 s->quant_tables[1][3][i]= 5*11*11*quant5 [i];
737 s->quant_tables[1][4][i]= 5*5*11*11*quant5 [i];
738 } else {
739 s->quant_tables[0][0][i]= quant9_10bit[i];
740 s->quant_tables[0][1][i]= 11*quant9_10bit[i];
741 s->quant_tables[0][2][i]= 11*11*quant9_10bit[i];
742 s->quant_tables[1][0][i]= quant9_10bit[i];
743 s->quant_tables[1][1][i]= 11*quant9_10bit[i];
744 s->quant_tables[1][2][i]= 11*11*quant5_10bit[i];
745 s->quant_tables[1][3][i]= 5*11*11*quant5_10bit[i];
746 s->quant_tables[1][4][i]= 5*5*11*11*quant5_10bit[i];
747 }
748 }
749 s->context_count[0] = (11 * 11 * 11 + 1) / 2;
750 s->context_count[1] = (11 * 11 * 5 * 5 * 5 + 1) / 2;
751 memcpy(s->quant_table, s->quant_tables[s->context_model],
752 sizeof(s->quant_table));
753
754 for (i = 0; i < s->plane_count; i++) {
755 PlaneContext *const p = &s->plane[i];
756
757 memcpy(p->quant_table, s->quant_table, sizeof(p->quant_table));
758 p->quant_table_index = s->context_model;
759 p->context_count = s->context_count[p->quant_table_index];
760 }
761
762 if ((ret = ff_ffv1_allocate_initial_states(s)) < 0)
763 return ret;
764
765 #if FF_API_CODED_FRAME
766 FF_DISABLE_DEPRECATION_WARNINGS
767 avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
768 FF_ENABLE_DEPRECATION_WARNINGS
769 #endif
770
771 if (!s->transparency)
772 s->plane_count = 2;
773 if (!s->chroma_planes && s->version > 3)
774 s->plane_count--;
775
776 ret = av_pix_fmt_get_chroma_sub_sample (avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
777 if (ret)
778 return ret;
779
780 s->picture_number = 0;
781
782 if (avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) {
783 for (i = 0; i < s->quant_table_count; i++) {
784 s->rc_stat2[i] = av_mallocz(s->context_count[i] *
785 sizeof(*s->rc_stat2[i]));
786 if (!s->rc_stat2[i])
787 return AVERROR(ENOMEM);
788 }
789 }
790 if (avctx->stats_in) {
791 char *p = avctx->stats_in;
792 uint8_t (*best_state)[256] = av_malloc_array(256, 256);
793 int gob_count = 0;
794 char *next;
795 if (!best_state)
796 return AVERROR(ENOMEM);
797
798 av_assert0(s->version >= 2);
799
800 for (;;) {
801 for (j = 0; j < 256; j++)
802 for (i = 0; i < 2; i++) {
803 s->rc_stat[j][i] = strtol(p, &next, 0);
804 if (next == p) {
805 av_log(avctx, AV_LOG_ERROR,
806 "2Pass file invalid at %d %d [%s]\n", j, i, p);
807 av_freep(&best_state);
808 return AVERROR_INVALIDDATA;
809 }
810 p = next;
811 }
812 for (i = 0; i < s->quant_table_count; i++)
813 for (j = 0; j < s->context_count[i]; j++) {
814 for (k = 0; k < 32; k++)
815 for (m = 0; m < 2; m++) {
816 s->rc_stat2[i][j][k][m] = strtol(p, &next, 0);
817 if (next == p) {
818 av_log(avctx, AV_LOG_ERROR,
819 "2Pass file invalid at %d %d %d %d [%s]\n",
820 i, j, k, m, p);
821 av_freep(&best_state);
822 return AVERROR_INVALIDDATA;
823 }
824 p = next;
825 }
826 }
827 gob_count = strtol(p, &next, 0);
828 if (next == p || gob_count <= 0) {
829 av_log(avctx, AV_LOG_ERROR, "2Pass file invalid\n");
830 av_freep(&best_state);
831 return AVERROR_INVALIDDATA;
832 }
833 p = next;
834 while (*p == '\n' || *p == ' ')
835 p++;
836 if (p[0] == 0)
837 break;
838 }
839 if (s->ac == AC_RANGE_CUSTOM_TAB)
840 sort_stt(s, s->state_transition);
841
842 find_best_state(best_state, s->state_transition);
843
844 for (i = 0; i < s->quant_table_count; i++) {
845 for (k = 0; k < 32; k++) {
846 double a=0, b=0;
847 int jp = 0;
848 for (j = 0; j < s->context_count[i]; j++) {
849 double p = 128;
850 if (s->rc_stat2[i][j][k][0] + s->rc_stat2[i][j][k][1] > 200 && j || a+b > 200) {
851 if (a+b)
852 p = 256.0 * b / (a + b);
853 s->initial_states[i][jp][k] =
854 best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];
855 for(jp++; jp<j; jp++)
856 s->initial_states[i][jp][k] = s->initial_states[i][jp-1][k];
857 a=b=0;
858 }
859 a += s->rc_stat2[i][j][k][0];
860 b += s->rc_stat2[i][j][k][1];
861 if (a+b) {
862 p = 256.0 * b / (a + b);
863 }
864 s->initial_states[i][j][k] =
865 best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];
866 }
867 }
868 }
869 av_freep(&best_state);
870 }
871
872 if (s->version > 1) {
873 int plane_count = 1 + 2*s->chroma_planes + s->transparency;
874 int max_h_slices = AV_CEIL_RSHIFT(avctx->width , s->chroma_h_shift);
875 int max_v_slices = AV_CEIL_RSHIFT(avctx->height, s->chroma_v_shift);
876 s->num_v_slices = (avctx->width > 352 || avctx->height > 288 || !avctx->slices) ? 2 : 1;
877
878 s->num_v_slices = FFMIN(s->num_v_slices, max_v_slices);
879
880 for (; s->num_v_slices < 32; s->num_v_slices++) {
881 for (s->num_h_slices = s->num_v_slices; s->num_h_slices < 2*s->num_v_slices; s->num_h_slices++) {
882 int maxw = (avctx->width + s->num_h_slices - 1) / s->num_h_slices;
883 int maxh = (avctx->height + s->num_v_slices - 1) / s->num_v_slices;
884 if (s->num_h_slices > max_h_slices || s->num_v_slices > max_v_slices)
885 continue;
886 if (maxw * maxh * (int64_t)(s->bits_per_raw_sample+1) * plane_count > 8<<24)
887 continue;
888 if (avctx->slices == s->num_h_slices * s->num_v_slices && avctx->slices <= MAX_SLICES || !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 if ((ret = write_extradata(s)) < 0)
899 return ret;
900 }
901
902 if ((ret = ff_ffv1_init_slice_contexts(s)) < 0)
903 return ret;
904 s->slice_count = s->max_slice_count;
905 if ((ret = ff_ffv1_init_slices_state(s)) < 0)
906 return ret;
907
908 #define STATS_OUT_SIZE 1024 * 1024 * 6
909 if (avctx->flags & AV_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->max_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
encode_slice_header(FFV1Context * f,FFV1Context * fs)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->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 if (f->version > 3) {
949 put_rac(c, state, fs->slice_coding_mode == 1);
950 if (fs->slice_coding_mode == 1)
951 ff_ffv1_clear_slice_state(f, fs);
952 put_symbol(c, state, fs->slice_coding_mode, 0);
953 if (fs->slice_coding_mode != 1) {
954 put_symbol(c, state, fs->slice_rct_by_coef, 0);
955 put_symbol(c, state, fs->slice_rct_ry_coef, 0);
956 }
957 }
958 }
959
choose_rct_params(FFV1Context * fs,const uint8_t * src[3],const int stride[3],int w,int h)960 static void choose_rct_params(FFV1Context *fs, const uint8_t *src[3], const int stride[3], int w, int h)
961 {
962 #define NB_Y_COEFF 15
963 static const int rct_y_coeff[15][2] = {
964 {0, 0}, // 4G
965 {1, 1}, // R + 2G + B
966 {2, 2}, // 2R + 2B
967 {0, 2}, // 2G + 2B
968 {2, 0}, // 2R + 2G
969 {4, 0}, // 4R
970 {0, 4}, // 4B
971
972 {0, 3}, // 1G + 3B
973 {3, 0}, // 3R + 1G
974 {3, 1}, // 3R + B
975 {1, 3}, // R + 3B
976 {1, 2}, // R + G + 2B
977 {2, 1}, // 2R + G + B
978 {0, 1}, // 3G + B
979 {1, 0}, // R + 3G
980 };
981
982 int stat[NB_Y_COEFF] = {0};
983 int x, y, i, p, best;
984 int16_t *sample[3];
985 int lbd = fs->bits_per_raw_sample <= 8;
986
987 for (y = 0; y < h; y++) {
988 int lastr=0, lastg=0, lastb=0;
989 for (p = 0; p < 3; p++)
990 sample[p] = fs->sample_buffer + p*w;
991
992 for (x = 0; x < w; x++) {
993 int b, g, r;
994 int ab, ag, ar;
995 if (lbd) {
996 unsigned v = *((const uint32_t*)(src[0] + x*4 + stride[0]*y));
997 b = v & 0xFF;
998 g = (v >> 8) & 0xFF;
999 r = (v >> 16) & 0xFF;
1000 } else {
1001 b = *((const uint16_t*)(src[0] + x*2 + stride[0]*y));
1002 g = *((const uint16_t*)(src[1] + x*2 + stride[1]*y));
1003 r = *((const uint16_t*)(src[2] + x*2 + stride[2]*y));
1004 }
1005
1006 ar = r - lastr;
1007 ag = g - lastg;
1008 ab = b - lastb;
1009 if (x && y) {
1010 int bg = ag - sample[0][x];
1011 int bb = ab - sample[1][x];
1012 int br = ar - sample[2][x];
1013
1014 br -= bg;
1015 bb -= bg;
1016
1017 for (i = 0; i<NB_Y_COEFF; i++) {
1018 stat[i] += FFABS(bg + ((br*rct_y_coeff[i][0] + bb*rct_y_coeff[i][1])>>2));
1019 }
1020
1021 }
1022 sample[0][x] = ag;
1023 sample[1][x] = ab;
1024 sample[2][x] = ar;
1025
1026 lastr = r;
1027 lastg = g;
1028 lastb = b;
1029 }
1030 }
1031
1032 best = 0;
1033 for (i=1; i<NB_Y_COEFF; i++) {
1034 if (stat[i] < stat[best])
1035 best = i;
1036 }
1037
1038 fs->slice_rct_by_coef = rct_y_coeff[best][1];
1039 fs->slice_rct_ry_coef = rct_y_coeff[best][0];
1040 }
1041
encode_slice(AVCodecContext * c,void * arg)1042 static int encode_slice(AVCodecContext *c, void *arg)
1043 {
1044 FFV1Context *fs = *(void **)arg;
1045 FFV1Context *f = fs->avctx->priv_data;
1046 int width = fs->slice_width;
1047 int height = fs->slice_height;
1048 int x = fs->slice_x;
1049 int y = fs->slice_y;
1050 const AVFrame *const p = f->picture.f;
1051 const int ps = av_pix_fmt_desc_get(c->pix_fmt)->comp[0].step;
1052 int ret;
1053 RangeCoder c_bak = fs->c;
1054 const uint8_t *planes[4] = {p->data[0] + ps*x + y*p->linesize[0],
1055 p->data[1] ? p->data[1] + ps*x + y*p->linesize[1] : NULL,
1056 p->data[2] ? p->data[2] + ps*x + y*p->linesize[2] : NULL,
1057 p->data[3] ? p->data[3] + ps*x + y*p->linesize[3] : NULL};
1058
1059 fs->slice_coding_mode = 0;
1060 if (f->version > 3) {
1061 choose_rct_params(fs, planes, p->linesize, width, height);
1062 } else {
1063 fs->slice_rct_by_coef = 1;
1064 fs->slice_rct_ry_coef = 1;
1065 }
1066
1067 retry:
1068 if (f->key_frame)
1069 ff_ffv1_clear_slice_state(f, fs);
1070 if (f->version > 2) {
1071 encode_slice_header(f, fs);
1072 }
1073 if (fs->ac == AC_GOLOMB_RICE) {
1074 fs->ac_byte_count = f->version > 2 || (!x && !y) ? ff_rac_terminate(&fs->c, f->version > 2) : 0;
1075 init_put_bits(&fs->pb,
1076 fs->c.bytestream_start + fs->ac_byte_count,
1077 fs->c.bytestream_end - fs->c.bytestream_start - fs->ac_byte_count);
1078 }
1079
1080 if (f->colorspace == 0 && c->pix_fmt != AV_PIX_FMT_YA8) {
1081 const int chroma_width = AV_CEIL_RSHIFT(width, f->chroma_h_shift);
1082 const int chroma_height = AV_CEIL_RSHIFT(height, f->chroma_v_shift);
1083 const int cx = x >> f->chroma_h_shift;
1084 const int cy = y >> f->chroma_v_shift;
1085
1086 ret = encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 1);
1087
1088 if (f->chroma_planes) {
1089 ret |= encode_plane(fs, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1, 1);
1090 ret |= encode_plane(fs, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1, 1);
1091 }
1092 if (fs->transparency)
1093 ret |= encode_plane(fs, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], 2, 1);
1094 } else if (c->pix_fmt == AV_PIX_FMT_YA8) {
1095 ret = encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 2);
1096 ret |= encode_plane(fs, p->data[0] + 1 + ps*x + y*p->linesize[0], width, height, p->linesize[0], 1, 2);
1097 } else if (f->use32bit) {
1098 ret = encode_rgb_frame32(fs, planes, width, height, p->linesize);
1099 } else {
1100 ret = encode_rgb_frame(fs, planes, width, height, p->linesize);
1101 }
1102 emms_c();
1103
1104 if (ret < 0) {
1105 av_assert0(fs->slice_coding_mode == 0);
1106 if (fs->version < 4 || !fs->ac) {
1107 av_log(c, AV_LOG_ERROR, "Buffer too small\n");
1108 return ret;
1109 }
1110 av_log(c, AV_LOG_DEBUG, "Coding slice as PCM\n");
1111 fs->slice_coding_mode = 1;
1112 fs->c = c_bak;
1113 goto retry;
1114 }
1115
1116 return 0;
1117 }
1118
encode_frame(AVCodecContext * avctx,AVPacket * pkt,const AVFrame * pict,int * got_packet)1119 static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
1120 const AVFrame *pict, int *got_packet)
1121 {
1122 FFV1Context *f = avctx->priv_data;
1123 RangeCoder *const c = &f->slice_context[0]->c;
1124 AVFrame *const p = f->picture.f;
1125 uint8_t keystate = 128;
1126 uint8_t *buf_p;
1127 int i, ret;
1128 int64_t maxsize = AV_INPUT_BUFFER_MIN_SIZE
1129 + avctx->width*avctx->height*37LL*4;
1130
1131 if(!pict) {
1132 if (avctx->flags & AV_CODEC_FLAG_PASS1) {
1133 int j, k, m;
1134 char *p = avctx->stats_out;
1135 char *end = p + STATS_OUT_SIZE;
1136
1137 memset(f->rc_stat, 0, sizeof(f->rc_stat));
1138 for (i = 0; i < f->quant_table_count; i++)
1139 memset(f->rc_stat2[i], 0, f->context_count[i] * sizeof(*f->rc_stat2[i]));
1140
1141 av_assert0(f->slice_count == f->max_slice_count);
1142 for (j = 0; j < f->slice_count; j++) {
1143 FFV1Context *fs = f->slice_context[j];
1144 for (i = 0; i < 256; i++) {
1145 f->rc_stat[i][0] += fs->rc_stat[i][0];
1146 f->rc_stat[i][1] += fs->rc_stat[i][1];
1147 }
1148 for (i = 0; i < f->quant_table_count; i++) {
1149 for (k = 0; k < f->context_count[i]; k++)
1150 for (m = 0; m < 32; m++) {
1151 f->rc_stat2[i][k][m][0] += fs->rc_stat2[i][k][m][0];
1152 f->rc_stat2[i][k][m][1] += fs->rc_stat2[i][k][m][1];
1153 }
1154 }
1155 }
1156
1157 for (j = 0; j < 256; j++) {
1158 snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1159 f->rc_stat[j][0], f->rc_stat[j][1]);
1160 p += strlen(p);
1161 }
1162 snprintf(p, end - p, "\n");
1163
1164 for (i = 0; i < f->quant_table_count; i++) {
1165 for (j = 0; j < f->context_count[i]; j++)
1166 for (m = 0; m < 32; m++) {
1167 snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1168 f->rc_stat2[i][j][m][0], f->rc_stat2[i][j][m][1]);
1169 p += strlen(p);
1170 }
1171 }
1172 snprintf(p, end - p, "%d\n", f->gob_count);
1173 }
1174 return 0;
1175 }
1176
1177 if (f->version > 3)
1178 maxsize = AV_INPUT_BUFFER_MIN_SIZE + avctx->width*avctx->height*3LL*4;
1179
1180 if (maxsize > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE - 32) {
1181 av_log(avctx, AV_LOG_WARNING, "Cannot allocate worst case packet size, the encoding could fail\n");
1182 maxsize = INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE - 32;
1183 }
1184
1185 if ((ret = ff_alloc_packet2(avctx, pkt, maxsize, 0)) < 0)
1186 return ret;
1187
1188 ff_init_range_encoder(c, pkt->data, pkt->size);
1189 ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
1190
1191 av_frame_unref(p);
1192 if ((ret = av_frame_ref(p, pict)) < 0)
1193 return ret;
1194 #if FF_API_CODED_FRAME
1195 FF_DISABLE_DEPRECATION_WARNINGS
1196 avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
1197 FF_ENABLE_DEPRECATION_WARNINGS
1198 #endif
1199
1200 if (avctx->gop_size == 0 || f->picture_number % avctx->gop_size == 0) {
1201 put_rac(c, &keystate, 1);
1202 f->key_frame = 1;
1203 f->gob_count++;
1204 write_header(f);
1205 } else {
1206 put_rac(c, &keystate, 0);
1207 f->key_frame = 0;
1208 }
1209
1210 if (f->ac == AC_RANGE_CUSTOM_TAB) {
1211 int i;
1212 for (i = 1; i < 256; i++) {
1213 c->one_state[i] = f->state_transition[i];
1214 c->zero_state[256 - i] = 256 - c->one_state[i];
1215 }
1216 }
1217
1218 for (i = 0; i < f->slice_count; i++) {
1219 FFV1Context *fs = f->slice_context[i];
1220 uint8_t *start = pkt->data + pkt->size * (int64_t)i / f->slice_count;
1221 int len = pkt->size / f->slice_count;
1222 if (i) {
1223 ff_init_range_encoder(&fs->c, start, len);
1224 } else {
1225 av_assert0(fs->c.bytestream_end >= fs->c.bytestream_start + len);
1226 av_assert0(fs->c.bytestream < fs->c.bytestream_start + len);
1227 fs->c.bytestream_end = fs->c.bytestream_start + len;
1228 }
1229 }
1230 avctx->execute(avctx, encode_slice, &f->slice_context[0], NULL,
1231 f->slice_count, sizeof(void *));
1232
1233 buf_p = pkt->data;
1234 for (i = 0; i < f->slice_count; i++) {
1235 FFV1Context *fs = f->slice_context[i];
1236 int bytes;
1237
1238 if (fs->ac != AC_GOLOMB_RICE) {
1239 bytes = ff_rac_terminate(&fs->c, 1);
1240 } else {
1241 flush_put_bits(&fs->pb); // FIXME: nicer padding
1242 bytes = fs->ac_byte_count + (put_bits_count(&fs->pb) + 7) / 8;
1243 }
1244 if (i > 0 || f->version > 2) {
1245 av_assert0(bytes < pkt->size / f->slice_count);
1246 memmove(buf_p, fs->c.bytestream_start, bytes);
1247 av_assert0(bytes < (1 << 24));
1248 AV_WB24(buf_p + bytes, bytes);
1249 bytes += 3;
1250 }
1251 if (f->ec) {
1252 unsigned v;
1253 buf_p[bytes++] = 0;
1254 v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, buf_p, bytes);
1255 AV_WL32(buf_p + bytes, v);
1256 bytes += 4;
1257 }
1258 buf_p += bytes;
1259 }
1260
1261 if (avctx->flags & AV_CODEC_FLAG_PASS1)
1262 avctx->stats_out[0] = '\0';
1263
1264 #if FF_API_CODED_FRAME
1265 FF_DISABLE_DEPRECATION_WARNINGS
1266 avctx->coded_frame->key_frame = f->key_frame;
1267 FF_ENABLE_DEPRECATION_WARNINGS
1268 #endif
1269
1270 f->picture_number++;
1271 pkt->size = buf_p - pkt->data;
1272 pkt->pts =
1273 pkt->dts = pict->pts;
1274 pkt->flags |= AV_PKT_FLAG_KEY * f->key_frame;
1275 *got_packet = 1;
1276
1277 return 0;
1278 }
1279
encode_close(AVCodecContext * avctx)1280 static av_cold int encode_close(AVCodecContext *avctx)
1281 {
1282 ff_ffv1_close(avctx);
1283 return 0;
1284 }
1285
1286 #define OFFSET(x) offsetof(FFV1Context, x)
1287 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1288 static const AVOption options[] = {
1289 { "slicecrc", "Protect slices with CRCs", OFFSET(ec), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE },
1290 { "coder", "Coder type", OFFSET(ac), AV_OPT_TYPE_INT,
1291 { .i64 = 0 }, -2, 2, VE, "coder" },
1292 { "rice", "Golomb rice", 0, AV_OPT_TYPE_CONST,
1293 { .i64 = AC_GOLOMB_RICE }, INT_MIN, INT_MAX, VE, "coder" },
1294 { "range_def", "Range with default table", 0, AV_OPT_TYPE_CONST,
1295 { .i64 = AC_RANGE_DEFAULT_TAB_FORCE }, INT_MIN, INT_MAX, VE, "coder" },
1296 { "range_tab", "Range with custom table", 0, AV_OPT_TYPE_CONST,
1297 { .i64 = AC_RANGE_CUSTOM_TAB }, INT_MIN, INT_MAX, VE, "coder" },
1298 { "ac", "Range with custom table (the ac option exists for compatibility and is deprecated)", 0, AV_OPT_TYPE_CONST,
1299 { .i64 = 1 }, INT_MIN, INT_MAX, VE, "coder" },
1300 { "context", "Context model", OFFSET(context_model), AV_OPT_TYPE_INT,
1301 { .i64 = 0 }, 0, 1, VE },
1302
1303 { NULL }
1304 };
1305
1306 static const AVClass ffv1_class = {
1307 .class_name = "ffv1 encoder",
1308 .item_name = av_default_item_name,
1309 .option = options,
1310 .version = LIBAVUTIL_VERSION_INT,
1311 };
1312
1313 #if FF_API_CODER_TYPE
1314 static const AVCodecDefault ffv1_defaults[] = {
1315 { "coder", "-1" },
1316 { NULL },
1317 };
1318 #endif
1319
1320 AVCodec ff_ffv1_encoder = {
1321 .name = "ffv1",
1322 .long_name = NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1323 .type = AVMEDIA_TYPE_VIDEO,
1324 .id = AV_CODEC_ID_FFV1,
1325 .priv_data_size = sizeof(FFV1Context),
1326 .init = encode_init,
1327 .encode2 = encode_frame,
1328 .close = encode_close,
1329 .capabilities = AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_DELAY,
1330 .pix_fmts = (const enum AVPixelFormat[]) {
1331 AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV444P,
1332 AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV411P,
1333 AV_PIX_FMT_YUV410P, AV_PIX_FMT_0RGB32, AV_PIX_FMT_RGB32, AV_PIX_FMT_YUV420P16,
1334 AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16, AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV422P9,
1335 AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
1336 AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12,
1337 AV_PIX_FMT_YUVA444P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA420P16,
1338 AV_PIX_FMT_YUVA444P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA420P10,
1339 AV_PIX_FMT_YUVA444P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA420P9,
1340 AV_PIX_FMT_GRAY16, AV_PIX_FMT_GRAY8, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
1341 AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14,
1342 AV_PIX_FMT_GBRAP10, AV_PIX_FMT_GBRAP12,
1343 AV_PIX_FMT_YA8,
1344 AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY12,
1345 AV_PIX_FMT_GBRP16, AV_PIX_FMT_RGB48,
1346 AV_PIX_FMT_GBRAP16, AV_PIX_FMT_RGBA64,
1347 AV_PIX_FMT_GRAY9,
1348 AV_PIX_FMT_YUV420P14, AV_PIX_FMT_YUV422P14, AV_PIX_FMT_YUV444P14,
1349 AV_PIX_FMT_YUV440P10, AV_PIX_FMT_YUV440P12,
1350 AV_PIX_FMT_NONE
1351
1352 },
1353 #if FF_API_CODER_TYPE
1354 .defaults = ffv1_defaults,
1355 #endif
1356 .priv_class = &ffv1_class,
1357 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1358 };
1359