FFmpeg coverage

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