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