FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavcodec/ffv1enc.c
Date: 2021-09-24 20:55:06
Exec Total Coverage
Lines: 384 696 55.2%
Branches: 236 544 43.4%

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