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