FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavcodec/ffv1enc.c
Date: 2026-10-04 16:07:23
Exec Total Coverage
Lines: 621 1191 52.1%
Functions: 21 30 70.0%
Branches: 449 1090 41.2%
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/mem.h"
32 #include "libavutil/opt.h"
33 #include "libavutil/pixdesc.h"
34 #include "libavutil/qsort.h"
35
36 #include "avcodec.h"
37 #include "encode.h"
38 #include "codec_internal.h"
39 #include "put_bits.h"
40 #include "put_golomb.h"
41 #include "rangecoder.h"
42 #include "ffv1.h"
43 #include "ffv1enc.h"
44
45 static const int8_t quant5_10bit[256] = {
46 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
49 1, 1, 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, -2,
58 -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -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, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
61 -1, -1, -1, -1, -1, -1, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0,
62 };
63
64 static const int8_t quant5[256] = {
65 0, 1, 1, 1, 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, -2, -2, -2,
80 -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -1, -1, -1,
81 };
82
83 static const int8_t quant9_10bit[256] = {
84 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2,
85 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3,
86 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
87 3, 3, 3, 3, 3, 3, 3, 3, 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, -4, -4, -4, -4, -4, -4, -4,
96 -4, -4, -4, -4, -4, -4, -4, -4, -4, -3, -3, -3, -3, -3, -3, -3,
97 -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3,
98 -3, -3, -3, -3, -3, -3, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
99 -2, -2, -2, -2, -1, -1, -1, -1, -1, -1, -1, -1, -0, -0, -0, -0,
100 };
101
102 static const int8_t quant11[256] = {
103 0, 1, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4,
104 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
105 4, 4, 4, 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, -5, -5,
116 -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -4, -4,
117 -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4,
118 -4, -4, -4, -4, -4, -3, -3, -3, -3, -3, -3, -3, -2, -2, -2, -1,
119 };
120
121 static const uint8_t ver2_state[256] = {
122 0, 10, 10, 10, 10, 16, 16, 16, 28, 16, 16, 29, 42, 49, 20, 49,
123 59, 25, 26, 26, 27, 31, 33, 33, 33, 34, 34, 37, 67, 38, 39, 39,
124 40, 40, 41, 79, 43, 44, 45, 45, 48, 48, 64, 50, 51, 52, 88, 52,
125 53, 74, 55, 57, 58, 58, 74, 60, 101, 61, 62, 84, 66, 66, 68, 69,
126 87, 82, 71, 97, 73, 73, 82, 75, 111, 77, 94, 78, 87, 81, 83, 97,
127 85, 83, 94, 86, 99, 89, 90, 99, 111, 92, 93, 134, 95, 98, 105, 98,
128 105, 110, 102, 108, 102, 118, 103, 106, 106, 113, 109, 112, 114, 112, 116, 125,
129 115, 116, 117, 117, 126, 119, 125, 121, 121, 123, 145, 124, 126, 131, 127, 129,
130 165, 130, 132, 138, 133, 135, 145, 136, 137, 139, 146, 141, 143, 142, 144, 148,
131 147, 155, 151, 149, 151, 150, 152, 157, 153, 154, 156, 168, 158, 162, 161, 160,
132 172, 163, 169, 164, 166, 184, 167, 170, 177, 174, 171, 173, 182, 176, 180, 178,
133 175, 189, 179, 181, 186, 183, 192, 185, 200, 187, 191, 188, 190, 197, 193, 196,
134 197, 194, 195, 196, 198, 202, 199, 201, 210, 203, 207, 204, 205, 206, 208, 214,
135 209, 211, 221, 212, 213, 215, 224, 216, 217, 218, 219, 220, 222, 228, 223, 225,
136 226, 224, 227, 229, 240, 230, 231, 232, 233, 234, 235, 236, 238, 239, 237, 242,
137 241, 243, 242, 244, 245, 246, 247, 248, 249, 250, 251, 252, 252, 253, 254, 255,
138 };
139
140 8 static void find_best_state(uint8_t best_state[256][256],
141 const uint8_t one_state[256])
142 {
143 int i, j, k, m;
144 uint32_t l2tab[256];
145
146
2/2
✓ Branch 0 taken 2040 times.
✓ Branch 1 taken 8 times.
 2048 for (i = 1; i < 256; i++)
147 2040 l2tab[i] = -log2(i / 256.0) * ((1U << 31) / 8);
148
149
2/2
✓ Branch 0 taken 2048 times.
✓ Branch 1 taken 8 times.
 2056 for (i = 0; i < 256; i++) {
150 uint64_t best_len[256];
151
152
2/2
✓ Branch 0 taken 524288 times.
✓ Branch 1 taken 2048 times.
 526336 for (j = 0; j < 256; j++)
153 524288 best_len[j] = UINT64_MAX;
154
155
2/2
✓ Branch 0 taken 42040 times.
✓ Branch 1 taken 2048 times.
 44088 for (j = FFMAX(i - 10, 1); j < FFMIN(i + 11, 256); j++) {
156 42040 uint32_t occ[256] = { 0 };
157 42040 uint64_t len = 0;
158 42040 occ[j] = UINT32_MAX;
159
160
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 42040 times.
 42040 if (!one_state[j])
161 ✗ continue;
162
163
2/2
✓ Branch 0 taken 10762240 times.
✓ Branch 1 taken 42040 times.
 10804280 for (k = 0; k < 256; k++) {
164 10762240 uint32_t newocc[256] = { 0 };
165
2/2
✓ Branch 0 taken 2744371200 times.
✓ Branch 1 taken 10762240 times.
 2755133440 for (m = 1; m < 256; m++)
166
2/2
✓ Branch 0 taken 861994804 times.
✓ Branch 1 taken 1882376396 times.
 2744371200 if (occ[m]) {
167 861994804 len += (occ[m]*(( i *(uint64_t)l2tab[ m]
168 861994804 + (256-i)*(uint64_t)l2tab[256-m])>>8)) >> 8;
169 }
170
2/2
✓ Branch 0 taken 3100046 times.
✓ Branch 1 taken 7662194 times.
 10762240 if (len < best_len[k]) {
171 3100046 best_len[k] = len;
172 3100046 best_state[i][k] = j;
173 }
174
2/2
✓ Branch 0 taken 2744371200 times.
✓ Branch 1 taken 10762240 times.
 2755133440 for (m = 1; m < 256; m++)
175
2/2
✓ Branch 0 taken 861994804 times.
✓ Branch 1 taken 1882376396 times.
 2744371200 if (occ[m]) {
176 861994804 newocc[ one_state[ m]] += occ[m] * (uint64_t) i >> 8;
177 861994804 newocc[256 - one_state[256 - m]] += occ[m] * (uint64_t)(256 - i) >> 8;
178 }
179 10762240 memcpy(occ, newocc, sizeof(occ));
180 }
181 }
182 }
183 8 }
184
185 239905402 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 150069347 times.
✓ Branch 1 taken 89836055 times.
 239905402 if (v) {
203
2/2
✓ Branch 0 taken 150035433 times.
✓ Branch 1 taken 33914 times.
 150069347 const unsigned a = is_signed ? FFABS(v) : v;
204 150069347 const int e = av_log2(a);
205
2/2
✓ Branch 0 taken 38585298 times.
✓ Branch 1 taken 111484049 times.
 150069347 put_rac(c, state + 0, 0);
206
2/2
✓ Branch 0 taken 125107169 times.
✓ Branch 1 taken 24962178 times.
 150069347 if (e <= 9) {
207
2/2
✓ Branch 0 taken 435122815 times.
✓ Branch 1 taken 125107169 times.
 560229984 for (i = 0; i < e; i++)
208
2/2
✓ Branch 0 taken 102966854 times.
✓ Branch 1 taken 332155961 times.
 435122815 put_rac(c, state + 1 + i, 1); // 1..10
209
2/2
✓ Branch 0 taken 38585298 times.
✓ Branch 1 taken 86521871 times.
 125107169 put_rac(c, state + 1 + i, 0);
210
211
2/2
✓ Branch 0 taken 435122815 times.
✓ Branch 1 taken 125107169 times.
 560229984 for (i = e - 1; i >= 0; i--)
212
2/2
✓ Branch 0 taken 102966854 times.
✓ Branch 1 taken 332155961 times.
 435122815 put_rac(c, state + 22 + i, (a >> i) & 1); // 22..31
213
214
2/2
✓ Branch 0 taken 125073255 times.
✓ Branch 1 taken 33914 times.
 125107169 if (is_signed)
215
2/2
✓ Branch 0 taken 38585298 times.
✓ Branch 1 taken 86487957 times.
 125073255 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
2/2
✓ Branch 0 taken 14846302 times.
✓ Branch 1 taken 74989753 times.
 89836055 put_rac(c, state + 0, 1);
229 }
230 #undef put_rac
231 239905402 }
232
233 1702002 static av_noinline void put_symbol(RangeCoder *c, uint8_t *state,
234 int v, int is_signed)
235 {
236 1702002 put_symbol_inline(c, state, v, is_signed, NULL, NULL);
237 1702002 }
238
239
240 163659991 static inline void put_vlc_symbol(PutBitContext *pb, VlcState *const state,
241 int v, int bits)
242 {
243 int i, k, code;
244 163659991 v = fold(v - state->bias, bits);
245
246 163659991 i = state->count;
247 163659991 k = 0;
248
2/2
✓ Branch 0 taken 272532174 times.
✓ Branch 1 taken 163659991 times.
 436192165 while (i < state->error_sum) { // FIXME: optimize
249 272532174 k++;
250 272532174 i += i;
251 }
252
253 av_assert2(k <= 16);
254
255 163659991 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 163659991 set_sr_golomb(pb, code, k, 12, bits);
260
261 163659991 update_vlc_state(state, v);
262 163659991 }
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 23235 static int encode_plane(FFV1Context *f, FFV1SliceContext *sc,
275 const uint8_t *src, int w, int h,
276 int stride, int plane_index, int remap_index, int pixel_stride, int ac)
277 {
278 int x, y, i, ret;
279 23235 const int pass1 = !!(f->avctx->flags & AV_CODEC_FLAG_PASS1);
280
2/2
✓ Branch 0 taken 9600 times.
✓ Branch 1 taken 13635 times.
 23235 const int ring_size = f->context_model ? 3 : 2;
281 int16_t *sample[3];
282 23235 sc->run_index = 0;
283
284 23235 sample[2] = sc->sample_buffer; // dummy to avoid UB pointer arithmetic
285
286 23235 memset(sc->sample_buffer, 0, ring_size * (w + 6) * sizeof(*sc->sample_buffer));
287
288
2/2
✓ Branch 0 taken 2214000 times.
✓ Branch 1 taken 23235 times.
 2237235 for (y = 0; y < h; y++) {
289
2/2
✓ Branch 0 taken 5326400 times.
✓ Branch 1 taken 2214000 times.
 7540400 for (i = 0; i < ring_size; i++)
290 5326400 sample[i] = sc->sample_buffer + (w + 6) * ((h + i - y) % ring_size) + 3;
291
292 2214000 sample[0][-1]= sample[1][0 ];
293 2214000 sample[1][ w]= sample[1][w-1];
294
295
2/2
✓ Branch 0 taken 1104000 times.
✓ Branch 1 taken 1110000 times.
 2214000 if (f->bits_per_raw_sample <= 8) {
296
2/2
✓ Branch 0 taken 168153700 times.
✓ Branch 1 taken 1104000 times.
 169257700 for (x = 0; x < w; x++)
297 168153700 sample[0][x] = src[x * pixel_stride + stride * y];
298
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1104000 times.
 1104000 if (sc->remap)
299 ✗ for (x = 0; x < w; x++)
300 ✗ sample[0][x] = sc->fltmap[remap_index][ sample[0][x] ];
301
302
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1104000 times.
 1104000 if((ret = encode_line(f, sc, f->avctx, w, sample, plane_index, 8, ac, pass1)) < 0)
303 ✗ return ret;
304 } else {
305
2/2
✓ Branch 0 taken 840600 times.
✓ Branch 1 taken 269400 times.
 1110000 if (f->packed_at_lsb) {
306
2/2
✓ Branch 0 taken 100818600 times.
✓ Branch 1 taken 840600 times.
 101659200 for (x = 0; x < w; x++) {
307 100818600 sample[0][x] = ((uint16_t*)(src + stride*y))[x * pixel_stride];
308 }
309 } else {
310
2/2
✓ Branch 0 taken 45792600 times.
✓ Branch 1 taken 269400 times.
 46062000 for (x = 0; x < w; x++) {
311 45792600 sample[0][x] = ((uint16_t*)(src + stride*y))[x * pixel_stride] >> (16 - f->bits_per_raw_sample);
312 }
313 }
314
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1110000 times.
 1110000 if (sc->remap)
315 ✗ for (x = 0; x < w; x++)
316 ✗ sample[0][x] = sc->fltmap[remap_index][ (uint16_t)sample[0][x] ];
317
318
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1110000 times.
 1110000 if((ret = encode_line(f, sc, f->avctx, w, sample, plane_index, f->bits_per_raw_sample, ac, pass1)) < 0)
319 ✗ return ret;
320 }
321 }
322 23235 return 0;
323 }
324
325 ✗ static void load_plane(FFV1Context *f, FFV1SliceContext *sc,
326 const uint8_t *src, int w, int h,
327 int stride, int remap_index, int pixel_stride)
328 {
329 int x, y;
330
331 ✗ memset(sc->fltmap[remap_index], 0, 65536 * sizeof(*sc->fltmap[remap_index]));
332
333 ✗ for (y = 0; y < h; y++) {
334 ✗ if (f->bits_per_raw_sample <= 8) {
335 ✗ for (x = 0; x < w; x++)
336 ✗ sc->fltmap[remap_index][ src[x * pixel_stride + stride * y] ] = 1;
337 } else {
338 ✗ if (f->packed_at_lsb) {
339 ✗ for (x = 0; x < w; x++)
340 ✗ sc->fltmap[remap_index][ ((uint16_t*)(src + stride*y))[x * pixel_stride] ] = 1;
341 } else {
342 ✗ for (x = 0; x < w; x++)
343 ✗ sc->fltmap[remap_index][ ((uint16_t*)(src + stride*y))[x * pixel_stride] >> (16 - f->bits_per_raw_sample) ] = 1;
344 }
345 }
346 }
347 ✗ }
348
349 570 static void write_quant_table(RangeCoder *c, int16_t *quant_table)
350 {
351 570 int last = 0;
352 int i;
353 uint8_t state[CONTEXT_SIZE];
354 570 memset(state, 128, sizeof(state));
355
356
2/2
✓ Branch 0 taken 72390 times.
✓ Branch 1 taken 570 times.
 72960 for (i = 1; i < MAX_QUANT_TABLE_SIZE/2; i++)
357
2/2
✓ Branch 0 taken 1652 times.
✓ Branch 1 taken 70738 times.
 72390 if (quant_table[i] != quant_table[i - 1]) {
358 1652 put_symbol(c, state, i - last - 1, 0);
359 1652 last = i;
360 }
361 570 put_symbol(c, state, i - last - 1, 0);
362 570 }
363
364 114 static void write_quant_tables(RangeCoder *c,
365 int16_t quant_table[MAX_CONTEXT_INPUTS][MAX_QUANT_TABLE_SIZE])
366 {
367 int i;
368
2/2
✓ Branch 0 taken 570 times.
✓ Branch 1 taken 114 times.
 684 for (i = 0; i < 5; i++)
369 570 write_quant_table(c, quant_table[i]);
370 114 }
371
372 94 static int contains_non_128(uint8_t (*initial_state)[CONTEXT_SIZE],
373 int nb_contexts)
374 {
375
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 94 times.
 94 if (!initial_state)
376 ✗ return 0;
377
2/2
✓ Branch 0 taken 277446 times.
✓ Branch 1 taken 86 times.
 277532 for (int i = 0; i < nb_contexts; i++)
378
2/2
✓ Branch 0 taken 8878024 times.
✓ Branch 1 taken 277438 times.
 9155462 for (int j = 0; j < CONTEXT_SIZE; j++)
379
2/2
✓ Branch 0 taken 8 times.
✓ Branch 1 taken 8878016 times.
 8878024 if (initial_state[i][j] != 128)
380 8 return 1;
381 86 return 0;
382 }
383
384 249 static void write_header(FFV1Context *f)
385 {
386 uint8_t state[CONTEXT_SIZE];
387 int i, j;
388 249 RangeCoder *const c = &f->slices[0].c;
389
390 249 memset(state, 128, sizeof(state));
391
392
2/2
✓ Branch 0 taken 20 times.
✓ Branch 1 taken 229 times.
 249 if (f->version < 2) {
393 20 put_symbol(c, state, f->version, 0);
394 20 put_symbol(c, state, f->ac, 0);
395
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 20 times.
 20 if (f->ac == AC_RANGE_CUSTOM_TAB) {
396 ✗ for (i = 1; i < 256; i++)
397 ✗ put_symbol(c, state,
398 ✗ f->state_transition[i] - c->one_state[i], 1);
399 }
400 20 put_symbol(c, state, f->colorspace, 0); //YUV cs type
401
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 20 times.
 20 if (f->version > 0)
402 ✗ put_symbol(c, state, f->bits_per_raw_sample, 0);
403 20 put_rac(c, state, f->chroma_planes);
404 20 put_symbol(c, state, f->chroma_h_shift, 0);
405 20 put_symbol(c, state, f->chroma_v_shift, 0);
406 20 put_rac(c, state, f->transparency);
407
408 20 write_quant_tables(c, f->quant_tables[f->context_model]);
409
2/2
✓ Branch 0 taken 20 times.
✓ Branch 1 taken 209 times.
 229 } else if (f->version < 3) {
410 20 put_symbol(c, state, f->slice_count, 0);
411
2/2
✓ Branch 0 taken 80 times.
✓ Branch 1 taken 20 times.
 100 for (i = 0; i < f->slice_count; i++) {
412 80 FFV1SliceContext *fs = &f->slices[i];
413 80 put_symbol(c, state,
414 80 (fs->slice_x + 1) * f->num_h_slices / f->width, 0);
415 80 put_symbol(c, state,
416 80 (fs->slice_y + 1) * f->num_v_slices / f->height, 0);
417 80 put_symbol(c, state,
418 80 (fs->slice_width + 1) * f->num_h_slices / f->width - 1,
419 0);
420 80 put_symbol(c, state,
421 80 (fs->slice_height + 1) * f->num_v_slices / f->height - 1,
422 0);
423
2/2
✓ Branch 0 taken 160 times.
✓ Branch 1 taken 80 times.
 240 for (j = 0; j < f->plane_count; j++) {
424 160 put_symbol(c, state, fs->plane[j].quant_table_index, 0);
425
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 160 times.
 160 av_assert0(fs->plane[j].quant_table_index == f->context_model);
426 }
427 }
428 }
429 249 }
430
431 51 static void set_micro_version(FFV1Context *f)
432 {
433 51 f->combined_version = f->version << 16;
434
2/2
✓ Branch 0 taken 43 times.
✓ Branch 1 taken 8 times.
 51 if (f->version > 2) {
435
1/2
✓ Branch 0 taken 43 times.
✗ Branch 1 not taken.
 43 if (f->version == 3) {
436 43 f->micro_version = 4;
437 ✗ } else if (f->version == 4) {
438 ✗ f->micro_version = 10;
439 } else
440 ✗ av_assert0(0);
441
442 43 f->combined_version += f->micro_version;
443 } else
444
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8 times.
 8 av_assert0(f->micro_version == 0);
445 51 }
446
447 47 av_cold int ff_ffv1_write_extradata(AVCodecContext *avctx)
448 {
449 47 FFV1Context *f = avctx->priv_data;
450
451 RangeCoder c;
452 uint8_t state[CONTEXT_SIZE];
453 int i, j, k;
454 uint8_t state2[32][CONTEXT_SIZE];
455 unsigned v;
456
457 47 memset(state2, 128, sizeof(state2));
458 47 memset(state, 128, sizeof(state));
459
460 47 f->avctx->extradata_size = 10000 + 4 +
461 (11 * 11 * 5 * 5 * 5 + 11 * 11 * 11) * 32;
462 47 f->avctx->extradata = av_malloc(f->avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
463
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 47 times.
 47 if (!f->avctx->extradata)
464 ✗ return AVERROR(ENOMEM);
465 47 ff_init_range_encoder(&c, f->avctx->extradata, f->avctx->extradata_size);
466 47 ff_build_rac_states(&c, 0.05 * (1LL << 32), 256 - 8);
467
468 47 put_symbol(&c, state, f->version, 0);
469
2/2
✓ Branch 0 taken 43 times.
✓ Branch 1 taken 4 times.
 47 if (f->version > 2)
470 43 put_symbol(&c, state, f->micro_version, 0);
471
472 47 put_symbol(&c, state, f->ac, 0);
473
2/2
✓ Branch 0 taken 29 times.
✓ Branch 1 taken 18 times.
 47 if (f->ac == AC_RANGE_CUSTOM_TAB)
474
2/2
✓ Branch 0 taken 7395 times.
✓ Branch 1 taken 29 times.
 7424 for (i = 1; i < 256; i++)
475 7395 put_symbol(&c, state, f->state_transition[i] - c.one_state[i], 1);
476
477 47 put_symbol(&c, state, f->colorspace, 0); // YUV cs type
478 47 put_symbol(&c, state, f->bits_per_raw_sample, 0);
479 47 put_rac(&c, state, f->chroma_planes);
480 47 put_symbol(&c, state, f->chroma_h_shift, 0);
481 47 put_symbol(&c, state, f->chroma_v_shift, 0);
482 47 put_rac(&c, state, f->transparency);
483
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 47 times.
 47 if (f->colorspace == 2)
484 ✗ put_symbol(&c, state, f->bayer_order, 0); /* 0 = RGGB */
485 47 put_symbol(&c, state, f->num_h_slices - 1, 0);
486 47 put_symbol(&c, state, f->num_v_slices - 1, 0);
487
488 47 put_symbol(&c, state, f->quant_table_count, 0);
489
2/2
✓ Branch 0 taken 94 times.
✓ Branch 1 taken 47 times.
 141 for (i = 0; i < f->quant_table_count; i++)
490 94 write_quant_tables(&c, f->quant_tables[i]);
491
492
2/2
✓ Branch 0 taken 94 times.
✓ Branch 1 taken 47 times.
 141 for (i = 0; i < f->quant_table_count; i++) {
493
2/2
✓ Branch 1 taken 8 times.
✓ Branch 2 taken 86 times.
 94 if (contains_non_128(f->initial_states[i], f->context_count[i])) {
494 8 put_rac(&c, state, 1);
495
2/2
✓ Branch 0 taken 50504 times.
✓ Branch 1 taken 8 times.
 50512 for (j = 0; j < f->context_count[i]; j++)
496
2/2
✓ Branch 0 taken 1616128 times.
✓ Branch 1 taken 50504 times.
 1666632 for (k = 0; k < CONTEXT_SIZE; k++) {
497
2/2
✓ Branch 0 taken 1615872 times.
✓ Branch 1 taken 256 times.
 1616128 int pred = j ? f->initial_states[i][j - 1][k] : 128;
498 1616128 put_symbol(&c, state2[k],
499 1616128 (int8_t)(f->initial_states[i][j][k] - pred), 1);
500 }
501 } else {
502 86 put_rac(&c, state, 0);
503 }
504 }
505
506
2/2
✓ Branch 0 taken 43 times.
✓ Branch 1 taken 4 times.
 47 if (f->version > 2) {
507 43 put_symbol(&c, state, f->ec, 0);
508 43 put_symbol(&c, state, f->intra = (f->avctx->gop_size < 2), 0);
509
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 43 times.
 43 if (f->combined_version >= 0x40004)
510 ✗ put_symbol(&c, state, f->flt, 0);
511 }
512
513 47 f->avctx->extradata_size = ff_rac_terminate(&c, 0);
514
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 47 times.
 47 v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), f->crcref, f->avctx->extradata, f->avctx->extradata_size) ^ (f->crcref ? 0x8CD88196 : 0);
515 47 AV_WL32(f->avctx->extradata + f->avctx->extradata_size, v);
516 47 f->avctx->extradata_size += 4;
517
518 47 return 0;
519 }
520
521 8 static int sort_stt(FFV1Context *s, uint8_t stt[256])
522 {
523 8 int i, i2, changed, print = 0;
524
525 do {
526 37 changed = 0;
527
2/2
✓ Branch 0 taken 8584 times.
✓ Branch 1 taken 37 times.
 8621 for (i = 12; i < 244; i++) {
528
4/4
✓ Branch 0 taken 34114 times.
✓ Branch 1 taken 111 times.
✓ Branch 2 taken 25641 times.
✓ Branch 3 taken 8473 times.
 34225 for (i2 = i + 1; i2 < 245 && i2 < i + 4; i2++) {
529
530 #define COST(old, new) \
531 s->rc_stat[old][0] * -log2((256 - (new)) / 256.0) + \
532 s->rc_stat[old][1] * -log2((new) / 256.0)
533
534 #define COST2(old, new) \
535 COST(old, new) + COST(256 - (old), 256 - (new))
536
537 25641 double size0 = COST2(i, i) + COST2(i2, i2);
538 25641 double sizeX = COST2(i, i2) + COST2(i2, i);
539
5/6
✓ Branch 0 taken 5086 times.
✓ Branch 1 taken 20555 times.
✓ Branch 2 taken 5086 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 5085 times.
✓ Branch 5 taken 1 times.
 25641 if (size0 - sizeX > size0*(1e-14) && i != 128 && i2 != 128) {
540 int j;
541 5085 FFSWAP(int, stt[i], stt[i2]);
542 5085 FFSWAP(int, s->rc_stat[i][0], s->rc_stat[i2][0]);
543 5085 FFSWAP(int, s->rc_stat[i][1], s->rc_stat[i2][1]);
544
2/2
✓ Branch 0 taken 5084 times.
✓ Branch 1 taken 1 times.
 5085 if (i != 256 - i2) {
545 5084 FFSWAP(int, stt[256 - i], stt[256 - i2]);
546 5084 FFSWAP(int, s->rc_stat[256 - i][0], s->rc_stat[256 - i2][0]);
547 5084 FFSWAP(int, s->rc_stat[256 - i][1], s->rc_stat[256 - i2][1]);
548 }
549
2/2
✓ Branch 0 taken 1296675 times.
✓ Branch 1 taken 5085 times.
 1301760 for (j = 1; j < 256; j++) {
550
2/2
✓ Branch 0 taken 5094 times.
✓ Branch 1 taken 1291581 times.
 1296675 if (stt[j] == i)
551 5094 stt[j] = i2;
552
2/2
✓ Branch 0 taken 5122 times.
✓ Branch 1 taken 1286459 times.
 1291581 else if (stt[j] == i2)
553 5122 stt[j] = i;
554
2/2
✓ Branch 0 taken 1296420 times.
✓ Branch 1 taken 255 times.
 1296675 if (i != 256 - i2) {
555
2/2
✓ Branch 0 taken 4906 times.
✓ Branch 1 taken 1291514 times.
 1296420 if (stt[256 - j] == 256 - i)
556 4906 stt[256 - j] = 256 - i2;
557
2/2
✓ Branch 0 taken 5124 times.
✓ Branch 1 taken 1286390 times.
 1291514 else if (stt[256 - j] == 256 - i2)
558 5124 stt[256 - j] = 256 - i;
559 }
560 }
561 5085 print = changed = 1;
562 }
563 }
564 }
565
2/2
✓ Branch 0 taken 29 times.
✓ Branch 1 taken 8 times.
 37 } while (changed);
566 8 return print;
567 }
568
569
570 47 int ff_ffv1_encode_determine_slices(AVCodecContext *avctx)
571 {
572 47 FFV1Context *s = avctx->priv_data;
573 47 int plane_count = 1 + 2*s->chroma_planes + s->bayer + s->transparency;
574
1/2
✓ Branch 0 taken 47 times.
✗ Branch 1 not taken.
 47 int max_h_slices = AV_CEIL_RSHIFT(avctx->width , s->bayer ? 1 : s->chroma_h_shift);
575
1/2
✓ Branch 0 taken 47 times.
✗ Branch 1 not taken.
 47 int max_v_slices = AV_CEIL_RSHIFT(avctx->height, s->bayer ? 1 : s->chroma_v_shift);
576
5/6
✓ Branch 0 taken 44 times.
✓ Branch 1 taken 3 times.
✓ Branch 2 taken 44 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 40 times.
✓ Branch 5 taken 4 times.
 47 s->num_v_slices = (avctx->width > 352 || avctx->height > 288 || !avctx->slices) ? 2 : 1;
577 47 s->num_v_slices = FFMIN(s->num_v_slices, max_v_slices);
578
1/2
✓ Branch 0 taken 52 times.
✗ Branch 1 not taken.
 52 for (; s->num_v_slices <= 32; s->num_v_slices++) {
579
2/2
✓ Branch 0 taken 58 times.
✓ Branch 1 taken 5 times.
 63 for (s->num_h_slices = s->num_v_slices; s->num_h_slices <= 2*s->num_v_slices; s->num_h_slices++) {
580 58 int maxw = (avctx->width + s->num_h_slices - 1) / s->num_h_slices;
581 58 int maxh = (avctx->height + s->num_v_slices - 1) / s->num_v_slices;
582
2/4
✓ Branch 0 taken 58 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 58 times.
 58 if (s->num_h_slices > max_h_slices || s->num_v_slices > max_v_slices)
583 ✗ continue;
584
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 58 times.
 58 if (maxw * maxh * (int64_t)(s->bits_per_raw_sample+1) * plane_count > 8<<24)
585 ✗ continue;
586
1/2
✓ Branch 0 taken 58 times.
✗ Branch 1 not taken.
 58 if (s->version < 4)
587
1/2
✓ Branch 1 taken 58 times.
✗ Branch 2 not taken.
 58 if ( ff_need_new_slices(avctx->width , s->num_h_slices, s->chroma_h_shift)
588
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 58 times.
 58 ||ff_need_new_slices(avctx->height, s->num_v_slices, s->chroma_v_shift))
589 ✗ continue;
590
3/4
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 54 times.
✓ Branch 2 taken 4 times.
✗ Branch 3 not taken.
 58 if (avctx->slices == s->num_h_slices * s->num_v_slices && avctx->slices <= MAX_SLICES)
591 4 return 0;
592
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 51 times.
 54 if (maxw*maxh > 360*288)
593 3 continue;
594
2/2
✓ Branch 0 taken 43 times.
✓ Branch 1 taken 8 times.
 51 if (!avctx->slices)
595 43 return 0;
596 }
597 }
598 ✗ av_log(avctx, AV_LOG_ERROR,
599 "Unsupported number %d of slices requested, please specify a "
600 "supported number with -slices (ex:4,6,9,12,16, ...)\n",
601 avctx->slices);
602 ✗ return AVERROR(ENOSYS);
603 }
604
605 51 av_cold int ff_ffv1_encode_init(AVCodecContext *avctx)
606 {
607 51 FFV1Context *s = avctx->priv_data;
608 int i, j, k, m, ret;
609
610
2/2
✓ Branch 0 taken 35 times.
✓ Branch 1 taken 16 times.
 51 if ((avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) ||
611
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 31 times.
 35 avctx->slices > 1)
612 20 s->version = FFMAX(s->version, 2);
613
614
3/4
✓ Branch 0 taken 16 times.
✓ Branch 1 taken 35 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 16 times.
 51 if ((avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) && s->ac == AC_GOLOMB_RICE) {
615 ✗ av_log(avctx, AV_LOG_ERROR, "2 Pass mode is not possible with golomb coding\n");
616 ✗ return AVERROR(EINVAL);
617 }
618
619 // Unspecified level & slices, we choose version 1.2+ to ensure multithreaded decodability
620
6/6
✓ Branch 0 taken 47 times.
✓ Branch 1 taken 4 times.
✓ Branch 2 taken 18 times.
✓ Branch 3 taken 29 times.
✓ Branch 4 taken 1 times.
✓ Branch 5 taken 17 times.
 51 if (avctx->slices == 0 && avctx->level < 0 && avctx->width * avctx->height > 720*576)
621 1 s->version = FFMAX(s->version, 2);
622
623
4/4
✓ Branch 0 taken 26 times.
✓ Branch 1 taken 25 times.
✓ Branch 2 taken 21 times.
✓ Branch 3 taken 5 times.
 51 if (avctx->level <= 0 && s->version == 2) {
624 21 s->version = 3;
625 }
626
3/4
✓ Branch 0 taken 29 times.
✓ Branch 1 taken 22 times.
✓ Branch 2 taken 29 times.
✗ Branch 3 not taken.
 51 if (avctx->level >= 0 && avctx->level <= 4) {
627
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 29 times.
 29 if (avctx->level < s->version) {
628 ✗ av_log(avctx, AV_LOG_ERROR, "Version %d needed for requested features but %d requested\n", s->version, avctx->level);
629 ✗ return AVERROR(EINVAL);
630 }
631 29 s->version = avctx->level;
632
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 21 times.
 22 } else if (s->version < 3)
633 1 s->version = 3;
634
635
1/2
✓ Branch 0 taken 51 times.
✗ Branch 1 not taken.
 51 if (s->ec < 0) {
636
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 51 times.
 51 if (s->version >= 4) {
637 ✗ s->ec = 2;
638
2/2
✓ Branch 0 taken 43 times.
✓ Branch 1 taken 8 times.
 51 } else if (s->version >= 3) {
639 43 s->ec = 1;
640 } else
641 8 s->ec = 0;
642 }
643
644 // CRC requires version 3+
645
2/2
✓ Branch 0 taken 43 times.
✓ Branch 1 taken 8 times.
 51 if (s->ec == 1)
646 43 s->version = FFMAX(s->version, 3);
647
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 51 times.
 51 if (s->ec == 2) {
648 ✗ s->version = FFMAX(s->version, 4);
649 ✗ s->crcref = 0x7a8c4079;
650 }
651
652
4/6
✓ Branch 0 taken 47 times.
✓ Branch 1 taken 4 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 47 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 4 times.
 51 if ((s->version == 2 || s->version>3) && avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
653 ✗ av_log(avctx, AV_LOG_ERROR, "Version 2 or 4 needed for requested features but version 2 or 4 is experimental and not enabled\n");
654 ✗ return AVERROR_INVALIDDATA;
655 }
656
657
2/2
✓ Branch 0 taken 29 times.
✓ Branch 1 taken 22 times.
 51 if (s->ac == AC_RANGE_CUSTOM_TAB) {
658
2/2
✓ Branch 0 taken 7395 times.
✓ Branch 1 taken 29 times.
 7424 for (i = 1; i < 256; i++)
659 7395 s->state_transition[i] = ver2_state[i];
660 } else {
661 RangeCoder c;
662 22 ff_build_rac_states(&c, 0.05 * (1LL << 32), 256 - 8);
663
2/2
✓ Branch 0 taken 5610 times.
✓ Branch 1 taken 22 times.
 5632 for (i = 1; i < 256; i++)
664 5610 s->state_transition[i] = c.one_state[i];
665 }
666
667
2/2
✓ Branch 0 taken 13056 times.
✓ Branch 1 taken 51 times.
 13107 for (i = 0; i < 256; i++) {
668 13056 s->quant_table_count = 2;
669
4/6
✓ Branch 0 taken 13056 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5376 times.
✓ Branch 3 taken 7680 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 5376 times.
 13056 if ((s->qtable == -1 && s->bits_per_raw_sample <= 8) || s->qtable == 1) {
670 7680 s->quant_tables[0][0][i]= quant11[i];
671 7680 s->quant_tables[0][1][i]= 11*quant11[i];
672 7680 s->quant_tables[0][2][i]= 11*11*quant11[i];
673 7680 s->quant_tables[1][0][i]= quant11[i];
674 7680 s->quant_tables[1][1][i]= 11*quant11[i];
675 7680 s->quant_tables[1][2][i]= 11*11*quant5 [i];
676 7680 s->quant_tables[1][3][i]= 5*11*11*quant5 [i];
677 7680 s->quant_tables[1][4][i]= 5*5*11*11*quant5 [i];
678 7680 s->context_count[0] = (11 * 11 * 11 + 1) / 2;
679 7680 s->context_count[1] = (11 * 11 * 5 * 5 * 5 + 1) / 2;
680 } else {
681 5376 s->quant_tables[0][0][i]= quant9_10bit[i];
682 5376 s->quant_tables[0][1][i]= 9*quant9_10bit[i];
683 5376 s->quant_tables[0][2][i]= 9*9*quant9_10bit[i];
684 5376 s->quant_tables[1][0][i]= quant9_10bit[i];
685 5376 s->quant_tables[1][1][i]= 9*quant9_10bit[i];
686 5376 s->quant_tables[1][2][i]= 9*9*quant5_10bit[i];
687 5376 s->quant_tables[1][3][i]= 5*9*9*quant5_10bit[i];
688 5376 s->quant_tables[1][4][i]= 5*5*9*9*quant5_10bit[i];
689 5376 s->context_count[0] = (9 * 9 * 9 + 1) / 2;
690 5376 s->context_count[1] = (9 * 9 * 5 * 5 * 5 + 1) / 2;
691 }
692 }
693
694 /* Small context set: only the two nearest gradients, coarsely quantized.
695 * With many slices there is too little data per slice for large context
696 * sets to adapt, and this codes smaller while using a fraction of the
697 * state. */
698
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 51 times.
 51 if (s->context_model == 2) {
699 ✗ const int8_t *q5 = (s->qtable == -1 && s->bits_per_raw_sample <= 8) || s->qtable == 1 ?
700 ✗ quant5 : quant5_10bit;
701 ✗ s->quant_table_count = 3;
702 ✗ for (i = 0; i < 256; i++) {
703 ✗ s->quant_tables[2][0][i] = q5[i];
704 ✗ s->quant_tables[2][1][i] = 5*q5[i];
705 }
706 ✗ s->context_count[2] = (5 * 5 + 1) / 2;
707 }
708
709
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 51 times.
 51 if ((ret = ff_ffv1_allocate_initial_states(s)) < 0)
710 ✗ return ret;
711
712
1/2
✓ Branch 0 taken 51 times.
✗ Branch 1 not taken.
 51 if (!s->transparency)
713 51 s->plane_count = 2;
714
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 51 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 51 if (!s->chroma_planes && s->version > 3)
715 ✗ s->plane_count--;
716
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 51 times.
 51 if (s->bayer)
717 ✗ s->plane_count = 3;
718
719 51 s->picture_number = 0;
720
721
2/2
✓ Branch 0 taken 16 times.
✓ Branch 1 taken 35 times.
 51 if (avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) {
722
2/2
✓ Branch 0 taken 32 times.
✓ Branch 1 taken 16 times.
 48 for (i = 0; i < s->quant_table_count; i++) {
723 32 s->rc_stat2[i] = av_mallocz(s->context_count[i] *
724 sizeof(*s->rc_stat2[i]));
725
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 32 times.
 32 if (!s->rc_stat2[i])
726 ✗ return AVERROR(ENOMEM);
727 }
728 }
729
2/2
✓ Branch 0 taken 8 times.
✓ Branch 1 taken 43 times.
 51 if (avctx->stats_in) {
730 8 char *p = avctx->stats_in;
731 8 uint8_t (*best_state)[256] = av_malloc_array(256, 256);
732 8 int gob_count = 0;
733 char *next;
734
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8 times.
 8 if (!best_state)
735 ✗ return AVERROR(ENOMEM);
736
737
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8 times.
 8 av_assert0(s->version >= 2);
738
739 for (;;) {
740
2/2
✓ Branch 0 taken 2048 times.
✓ Branch 1 taken 8 times.
 2056 for (j = 0; j < 256; j++)
741
2/2
✓ Branch 0 taken 4096 times.
✓ Branch 1 taken 2048 times.
 6144 for (i = 0; i < 2; i++) {
742 4096 s->rc_stat[j][i] = strtol(p, &next, 0);
743
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4096 times.
 4096 if (next == p) {
744 ✗ av_log(avctx, AV_LOG_ERROR,
745 "2Pass file invalid at %d %d [%s]\n", j, i, p);
746 ✗ av_freep(&best_state);
747 ✗ return AVERROR_INVALIDDATA;
748 }
749 4096 p = next;
750 }
751
2/2
✓ Branch 0 taken 16 times.
✓ Branch 1 taken 8 times.
 24 for (i = 0; i < s->quant_table_count; i++)
752
2/2
✓ Branch 0 taken 54628 times.
✓ Branch 1 taken 16 times.
 54644 for (j = 0; j < s->context_count[i]; j++) {
753
2/2
✓ Branch 0 taken 1748096 times.
✓ Branch 1 taken 54628 times.
 1802724 for (k = 0; k < 32; k++)
754
2/2
✓ Branch 0 taken 3496192 times.
✓ Branch 1 taken 1748096 times.
 5244288 for (m = 0; m < 2; m++) {
755 3496192 s->rc_stat2[i][j][k][m] = strtol(p, &next, 0);
756
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3496192 times.
 3496192 if (next == p) {
757 ✗ av_log(avctx, AV_LOG_ERROR,
758 "2Pass file invalid at %d %d %d %d [%s]\n",
759 i, j, k, m, p);
760 ✗ av_freep(&best_state);
761 ✗ return AVERROR_INVALIDDATA;
762 }
763 3496192 p = next;
764 }
765 }
766 8 gob_count = strtol(p, &next, 0);
767
2/4
✓ Branch 0 taken 8 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 8 times.
 8 if (next == p || gob_count <= 0) {
768 ✗ av_log(avctx, AV_LOG_ERROR, "2Pass file invalid\n");
769 ✗ av_freep(&best_state);
770 ✗ return AVERROR_INVALIDDATA;
771 }
772 8 p = next;
773
3/4
✓ Branch 0 taken 8 times.
✓ Branch 1 taken 8 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 8 times.
 16 while (*p == '\n' || *p == ' ')
774 8 p++;
775
1/2
✓ Branch 0 taken 8 times.
✗ Branch 1 not taken.
 8 if (p[0] == 0)
776 8 break;
777 }
778
1/2
✓ Branch 0 taken 8 times.
✗ Branch 1 not taken.
 8 if (s->ac == AC_RANGE_CUSTOM_TAB)
779 8 sort_stt(s, s->state_transition);
780
781 8 find_best_state(best_state, s->state_transition);
782
783
2/2
✓ Branch 0 taken 16 times.
✓ Branch 1 taken 8 times.
 24 for (i = 0; i < s->quant_table_count; i++) {
784
2/2
✓ Branch 0 taken 512 times.
✓ Branch 1 taken 16 times.
 528 for (k = 0; k < 32; k++) {
785 512 double a=0, b=0;
786 512 int jp = 0;
787
2/2
✓ Branch 0 taken 1748096 times.
✓ Branch 1 taken 512 times.
 1748608 for (j = 0; j < s->context_count[i]; j++) {
788 1748096 double p = 128;
789
6/6
✓ Branch 0 taken 179054 times.
✓ Branch 1 taken 1569042 times.
✓ Branch 2 taken 154 times.
✓ Branch 3 taken 178900 times.
✓ Branch 4 taken 112423 times.
✓ Branch 5 taken 1456773 times.
 1748096 if (s->rc_stat2[i][j][k][0] + s->rc_stat2[i][j][k][1] > 200 && j || a+b > 200) {
790
2/2
✓ Branch 0 taken 291303 times.
✓ Branch 1 taken 20 times.
 291323 if (a+b)
791 291303 p = 256.0 * b / (a + b);
792 291323 s->initial_states[i][jp][k] =
793 291323 best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];
794
2/2
✓ Branch 0 taken 883713 times.
✓ Branch 1 taken 291323 times.
 1175036 for(jp++; jp<j; jp++)
795 883713 s->initial_states[i][jp][k] = s->initial_states[i][jp-1][k];
796 291323 a=b=0;
797 }
798 1748096 a += s->rc_stat2[i][j][k][0];
799 1748096 b += s->rc_stat2[i][j][k][1];
800
2/2
✓ Branch 0 taken 1284515 times.
✓ Branch 1 taken 463581 times.
 1748096 if (a+b) {
801 1284515 p = 256.0 * b / (a + b);
802 }
803 1748096 s->initial_states[i][j][k] =
804 1748096 best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];
805 }
806 }
807 }
808 8 av_freep(&best_state);
809 }
810
811
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 47 times.
 51 if (s->version <= 1) {
812 /* Disable slices when the version doesn't support them */
813 4 s->num_h_slices = 1;
814 4 s->num_v_slices = 1;
815 }
816
817 51 set_micro_version(s);
818
819 51 return 0;
820 }
821
822 51 av_cold int ff_ffv1_encode_setup_plane_info(AVCodecContext *avctx,
823 enum AVPixelFormat pix_fmt)
824 {
825 51 FFV1Context *s = avctx->priv_data;
826 51 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
827
828 51 s->bayer = 0;
829 51 s->plane_count = 3;
830
5/18
✗ Branch 0 not taken.
✓ Branch 1 taken 13 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✓ Branch 4 taken 4 times.
✓ Branch 5 taken 26 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✓ Branch 8 taken 4 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 4 times.
✗ Branch 11 not taken.
✗ Branch 12 not taken.
✗ Branch 13 not taken.
✗ Branch 14 not taken.
✗ Branch 15 not taken.
✗ Branch 16 not taken.
✗ Branch 17 not taken.
 51 switch(pix_fmt) {
831 ✗ case AV_PIX_FMT_GRAY9:
832 case AV_PIX_FMT_YUV444P9:
833 case AV_PIX_FMT_YUV422P9:
834 case AV_PIX_FMT_YUV420P9:
835 case AV_PIX_FMT_YUVA444P9:
836 case AV_PIX_FMT_YUVA422P9:
837 case AV_PIX_FMT_YUVA420P9:
838 ✗ if (!avctx->bits_per_raw_sample)
839 ✗ s->bits_per_raw_sample = 9;
840 av_fallthrough;
841 case AV_PIX_FMT_GRAY10:
842 case AV_PIX_FMT_YUV444P10:
843 case AV_PIX_FMT_YUV440P10:
844 case AV_PIX_FMT_YUV420P10:
845 case AV_PIX_FMT_YUV422P10:
846 case AV_PIX_FMT_YUVA444P10:
847 case AV_PIX_FMT_YUVA422P10:
848 case AV_PIX_FMT_YUVA420P10:
849
3/4
✓ Branch 0 taken 12 times.
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 12 times.
✗ Branch 3 not taken.
 13 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
850 12 s->bits_per_raw_sample = 10;
851 av_fallthrough;
852 case AV_PIX_FMT_GRAY12:
853 case AV_PIX_FMT_YUV444P12:
854 case AV_PIX_FMT_YUV440P12:
855 case AV_PIX_FMT_YUV420P12:
856 case AV_PIX_FMT_YUV422P12:
857 case AV_PIX_FMT_YUVA444P12:
858 case AV_PIX_FMT_YUVA422P12:
859
3/4
✓ Branch 0 taken 12 times.
✓ Branch 1 taken 1 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 12 times.
 13 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
860 ✗ s->bits_per_raw_sample = 12;
861 av_fallthrough;
862 case AV_PIX_FMT_GRAY14:
863 case AV_PIX_FMT_YUV444P14:
864 case AV_PIX_FMT_YUV420P14:
865 case AV_PIX_FMT_YUV422P14:
866
3/4
✓ Branch 0 taken 12 times.
✓ Branch 1 taken 1 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 12 times.
 13 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
867 ✗ s->bits_per_raw_sample = 14;
868 13 s->packed_at_lsb = 1;
869 av_fallthrough;
870 17 case AV_PIX_FMT_GRAY16:
871 case AV_PIX_FMT_P016:
872 case AV_PIX_FMT_P216:
873 case AV_PIX_FMT_P416:
874 case AV_PIX_FMT_YUV444P16:
875 case AV_PIX_FMT_YUV422P16:
876 case AV_PIX_FMT_YUV420P16:
877 case AV_PIX_FMT_YUVA444P16:
878 case AV_PIX_FMT_YUVA422P16:
879 case AV_PIX_FMT_YUVA420P16:
880 case AV_PIX_FMT_GRAYF16:
881 case AV_PIX_FMT_YAF16:
882
4/4
✓ Branch 0 taken 16 times.
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 4 times.
✓ Branch 3 taken 12 times.
 17 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) {
883 4 s->bits_per_raw_sample = 16;
884
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 12 times.
 13 } else if (!s->bits_per_raw_sample) {
885 1 s->bits_per_raw_sample = avctx->bits_per_raw_sample;
886 }
887
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 17 times.
 17 if (s->bits_per_raw_sample <= 8) {
888 ✗ av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");
889 ✗ return AVERROR_INVALIDDATA;
890 }
891 17 s->version = FFMAX(s->version, 1);
892 av_fallthrough;
893 43 case AV_PIX_FMT_GRAY8:
894 case AV_PIX_FMT_YA8:
895 case AV_PIX_FMT_NV12:
896 case AV_PIX_FMT_NV16:
897 case AV_PIX_FMT_NV24:
898 case AV_PIX_FMT_YUV444P:
899 case AV_PIX_FMT_YUV440P:
900 case AV_PIX_FMT_YUV422P:
901 case AV_PIX_FMT_YUV420P:
902 case AV_PIX_FMT_YUV411P:
903 case AV_PIX_FMT_YUV410P:
904 case AV_PIX_FMT_YUVA444P:
905 case AV_PIX_FMT_YUVA422P:
906 case AV_PIX_FMT_YUVA420P:
907 43 s->chroma_planes = desc->nb_components < 3 ? 0 : 1;
908 43 s->colorspace = 0;
909 43 s->transparency = !!(desc->flags & AV_PIX_FMT_FLAG_ALPHA);
910
4/4
✓ Branch 0 taken 42 times.
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 26 times.
✓ Branch 3 taken 16 times.
 43 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
911 26 s->bits_per_raw_sample = 8;
912
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 17 times.
 17 else if (!s->bits_per_raw_sample)
913 ✗ s->bits_per_raw_sample = 8;
914 43 break;
915 ✗ case AV_PIX_FMT_RGB32:
916 ✗ s->colorspace = 1;
917 ✗ s->transparency = 1;
918 ✗ s->chroma_planes = 1;
919 ✗ s->bits_per_raw_sample = 8;
920 ✗ break;
921 ✗ case AV_PIX_FMT_RGBA64:
922 ✗ s->colorspace = 1;
923 ✗ s->transparency = 1;
924 ✗ s->chroma_planes = 1;
925 ✗ s->bits_per_raw_sample = 16;
926 ✗ s->use32bit = 1;
927 ✗ s->version = FFMAX(s->version, 1);
928 ✗ break;
929 4 case AV_PIX_FMT_RGB48:
930 4 s->colorspace = 1;
931 4 s->chroma_planes = 1;
932 4 s->bits_per_raw_sample = 16;
933 4 s->use32bit = 1;
934 4 s->version = FFMAX(s->version, 1);
935 4 break;
936 ✗ case AV_PIX_FMT_BAYER_RGGB16:
937 ✗ s->colorspace = 2;
938 ✗ s->chroma_planes = 1;
939 ✗ s->bits_per_raw_sample = 16;
940 ✗ s->use32bit = 1;
941 ✗ s->version = FFMAX(s->version, 4);
942 ✗ s->bayer = 1;
943 ✗ break;
944 4 case AV_PIX_FMT_GBRP:
945 case AV_PIX_FMT_0RGB32:
946 4 s->colorspace = 1;
947 4 s->chroma_planes = 1;
948 4 s->bits_per_raw_sample = 8;
949 4 break;
950 ✗ case AV_PIX_FMT_GBRP9:
951 ✗ if (!avctx->bits_per_raw_sample)
952 ✗ s->bits_per_raw_sample = 9;
953 av_fallthrough;
954 case AV_PIX_FMT_X2BGR10:
955 case AV_PIX_FMT_X2RGB10:
956 case AV_PIX_FMT_GBRP10:
957 case AV_PIX_FMT_GBRAP10:
958 ✗ if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
959 ✗ s->bits_per_raw_sample = 10;
960 av_fallthrough;
961 case AV_PIX_FMT_GBRP12:
962 case AV_PIX_FMT_GBRAP12:
963 ✗ if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
964 ✗ s->bits_per_raw_sample = 12;
965 av_fallthrough;
966 case AV_PIX_FMT_GBRP14:
967 case AV_PIX_FMT_GBRAP14:
968 ✗ if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
969 ✗ s->bits_per_raw_sample = 14;
970 av_fallthrough;
971 case AV_PIX_FMT_GBRP16:
972 case AV_PIX_FMT_GBRAP16:
973 case AV_PIX_FMT_GBRPF16:
974 case AV_PIX_FMT_GBRAPF16:
975 ✗ if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
976 ✗ s->bits_per_raw_sample = 16;
977 av_fallthrough;
978 case AV_PIX_FMT_GBRPF32:
979 case AV_PIX_FMT_GBRAPF32:
980 ✗ if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
981 ✗ s->bits_per_raw_sample = 32;
982 ✗ else if (!s->bits_per_raw_sample)
983 ✗ s->bits_per_raw_sample = avctx->bits_per_raw_sample;
984 ✗ s->transparency = !!(desc->flags & AV_PIX_FMT_FLAG_ALPHA);
985 ✗ s->colorspace = 1;
986 ✗ s->chroma_planes = 1;
987 ✗ if (s->bits_per_raw_sample >= 16) {
988 ✗ s->use32bit = 1;
989 }
990 ✗ s->version = FFMAX(s->version, 1);
991 ✗ break;
992 ✗ default:
993 ✗ av_log(avctx, AV_LOG_ERROR, "format %s not supported\n",
994 av_get_pix_fmt_name(pix_fmt));
995 ✗ return AVERROR(ENOSYS);
996 }
997 51 s->flt = !!(desc->flags & AV_PIX_FMT_FLAG_FLOAT);
998
2/4
✓ Branch 0 taken 51 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 51 times.
 51 if (s->flt || s->remap_mode > 0)
999 ✗ s->version = FFMAX(s->version, 4);
1000
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 51 times.
 51 av_assert0(s->bits_per_raw_sample >= 8);
1001
1002
1/2
✓ Branch 0 taken 51 times.
✗ Branch 1 not taken.
 51 if (s->remap_mode < 0)
1003
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 51 times.
 51 s->remap_mode = s->flt ? 2 : 0;
1004
2/4
✓ Branch 0 taken 51 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 51 times.
 51 if (s->remap_mode == 0 && s->bits_per_raw_sample == 32) {
1005 ✗ av_log(avctx, AV_LOG_ERROR, "32bit requires remap\n");
1006 ✗ return AVERROR(EINVAL);
1007 }
1008
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 51 times.
 51 if (s->remap_mode == 2 &&
1009 ✗ !((s->bits_per_raw_sample == 16 || s->bits_per_raw_sample == 32 || s->bits_per_raw_sample == 64) && s->flt)) {
1010 ✗ av_log(avctx, AV_LOG_ERROR, "remap 2 is for float16/32/64 only\n");
1011 ✗ return AVERROR(EINVAL);
1012 }
1013
1014 51 return av_pix_fmt_get_chroma_sub_sample(pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
1015 }
1016
1017 51 static av_cold int encode_init_internal(AVCodecContext *avctx)
1018 {
1019 int ret;
1020 51 FFV1Context *s = avctx->priv_data;
1021
1022
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 51 times.
 51 if ((ret = ff_ffv1_common_init(avctx, s)) < 0)
1023 ✗ return ret;
1024
1025
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 51 times.
 51 if (s->ac == 1) // Compatibility with common command line usage
1026 ✗ s->ac = AC_RANGE_CUSTOM_TAB;
1027
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 51 times.
 51 else if (s->ac == AC_RANGE_DEFAULT_TAB_FORCE)
1028 ✗ s->ac = AC_RANGE_DEFAULT_TAB;
1029
1030 51 ret = ff_ffv1_encode_setup_plane_info(avctx, avctx->pix_fmt);
1031
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 51 times.
 51 if (ret < 0)
1032 ✗ return ret;
1033
1034
1/6
✗ Branch 0 not taken.
✓ Branch 1 taken 51 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
 51 if (s->bayer && (avctx->width & 1 || avctx->height & 1)) {
1035 ✗ av_log(avctx, AV_LOG_ERROR, "bayer requires even dimensions\n");
1036 ✗ return AVERROR(EINVAL);
1037 }
1038
1039
4/6
✗ Branch 0 not taken.
✓ Branch 1 taken 51 times.
✓ Branch 2 taken 21 times.
✓ Branch 3 taken 30 times.
✓ Branch 4 taken 21 times.
✗ Branch 5 not taken.
 51 if (s->bits_per_raw_sample > (s->version > 3 ? 16 : 8) && !s->remap_mode) {
1040
2/2
✓ Branch 0 taken 13 times.
✓ Branch 1 taken 8 times.
 21 if (s->ac == AC_GOLOMB_RICE) {
1041 13 av_log(avctx, AV_LOG_INFO,
1042 "high bits_per_raw_sample, forcing range coder\n");
1043 13 s->ac = AC_RANGE_CUSTOM_TAB;
1044 }
1045 }
1046
1047
1048 51 ret = ff_ffv1_encode_init(avctx);
1049
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 51 times.
 51 if (ret < 0)
1050 ✗ return ret;
1051
1052
2/2
✓ Branch 0 taken 47 times.
✓ Branch 1 taken 4 times.
 51 if (s->version > 1) {
1053
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 47 times.
 47 if ((ret = ff_ffv1_encode_determine_slices(avctx)) < 0)
1054 ✗ return ret;
1055
1056
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 47 times.
 47 if ((ret = ff_ffv1_write_extradata(avctx)) < 0)
1057 ✗ return ret;
1058 }
1059
1060
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 51 times.
 51 if ((ret = ff_ffv1_init_slice_contexts(s)) < 0)
1061 ✗ return ret;
1062 51 s->slice_count = s->max_slice_count;
1063
1064
2/2
✓ Branch 0 taken 197 times.
✓ Branch 1 taken 51 times.
 248 for (int j = 0; j < s->slice_count; j++) {
1065 197 FFV1SliceContext *sc = &s->slices[j];
1066
1067
2/2
✓ Branch 0 taken 394 times.
✓ Branch 1 taken 197 times.
 591 for (int i = 0; i < s->plane_count; i++) {
1068 394 PlaneContext *const p = &s->slices[j].plane[i];
1069
1070 394 p->quant_table_index = s->context_model;
1071 394 p->context_count = s->context_count[p->quant_table_index];
1072 }
1073
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 197 times.
 197 av_assert0(s->remap_mode >= 0);
1074
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 197 times.
 197 if (s->remap_mode) {
1075 ✗ for (int p = 0; p < 1 + 2*s->chroma_planes + s->transparency ; p++) {
1076 ✗ if (s->bits_per_raw_sample == 32) {
1077 ✗ sc->unit[p] = av_malloc_array(sc->slice_width, sc->slice_height * sizeof(**sc->unit));
1078 ✗ if (!sc->unit[p])
1079 ✗ return AVERROR(ENOMEM);
1080 ✗ sc->bitmap[p] = av_malloc_array(sc->slice_width * sc->slice_height, sizeof(*sc->bitmap[p]));
1081 ✗ if (!sc->bitmap[p])
1082 ✗ return AVERROR(ENOMEM);
1083 } else {
1084 ✗ sc->fltmap[p] = av_malloc_array(65536, sizeof(*sc->fltmap[p]));
1085 ✗ if (!sc->fltmap[p])
1086 ✗ return AVERROR(ENOMEM);
1087 }
1088 }
1089 }
1090
1091 197 ff_build_rac_states(&s->slices[j].c, 0.05 * (1LL << 32), 256 - 8);
1092
1093 197 s->slices[j].remap = s->remap_mode;
1094 }
1095
1096
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 51 times.
 51 if ((ret = ff_ffv1_init_slices_state(s)) < 0)
1097 ✗ return ret;
1098
1099 #define STATS_OUT_SIZE 1024 * 1024 * 6
1100
2/2
✓ Branch 0 taken 8 times.
✓ Branch 1 taken 43 times.
 51 if (avctx->flags & AV_CODEC_FLAG_PASS1) {
1101 8 avctx->stats_out = av_mallocz(STATS_OUT_SIZE);
1102
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8 times.
 8 if (!avctx->stats_out)
1103 ✗ return AVERROR(ENOMEM);
1104
2/2
✓ Branch 0 taken 16 times.
✓ Branch 1 taken 8 times.
 24 for (int i = 0; i < s->quant_table_count; i++)
1105
2/2
✓ Branch 0 taken 64 times.
✓ Branch 1 taken 16 times.
 80 for (int j = 0; j < s->max_slice_count; j++) {
1106 64 FFV1SliceContext *sc = &s->slices[j];
1107
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 64 times.
 64 av_assert0(!sc->rc_stat2[i]);
1108 64 sc->rc_stat2[i] = av_mallocz(s->context_count[i] *
1109 sizeof(*sc->rc_stat2[i]));
1110
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 64 times.
 64 if (!sc->rc_stat2[i])
1111 ✗ return AVERROR(ENOMEM);
1112 }
1113 }
1114
1115 51 return 0;
1116 }
1117
1118 8345 static void encode_slice_header(FFV1Context *f, FFV1SliceContext *sc)
1119 {
1120 8345 RangeCoder *c = &sc->c;
1121 uint8_t state[CONTEXT_SIZE];
1122 int j;
1123 8345 memset(state, 128, sizeof(state));
1124
1125 8345 put_symbol(c, state, sc->sx, 0);
1126 8345 put_symbol(c, state, sc->sy, 0);
1127 8345 put_symbol(c, state, 0, 0);
1128 8345 put_symbol(c, state, 0, 0);
1129
2/2
✓ Branch 0 taken 16690 times.
✓ Branch 1 taken 8345 times.
 25035 for (j=0; j<f->plane_count; j++) {
1130 16690 put_symbol(c, state, sc->plane[j].quant_table_index, 0);
1131
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 16690 times.
 16690 av_assert0(sc->plane[j].quant_table_index == f->context_model);
1132 }
1133
1/2
✓ Branch 0 taken 8345 times.
✗ Branch 1 not taken.
 8345 if (!(f->cur_enc_frame->flags & AV_FRAME_FLAG_INTERLACED))
1134 8345 put_symbol(c, state, 3, 0);
1135 else
1136 ✗ put_symbol(c, state, 1 + !(f->cur_enc_frame->flags & AV_FRAME_FLAG_TOP_FIELD_FIRST), 0);
1137 8345 put_symbol(c, state, f->cur_enc_frame->sample_aspect_ratio.num, 0);
1138 8345 put_symbol(c, state, f->cur_enc_frame->sample_aspect_ratio.den, 0);
1139
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8345 times.
 8345 if (f->version > 3) {
1140 ✗ put_rac(c, state, sc->slice_coding_mode == 1);
1141 ✗ if (sc->slice_coding_mode == 1)
1142 ✗ ff_ffv1_clear_slice_state(f, sc);
1143 ✗ put_symbol(c, state, sc->slice_coding_mode, 0);
1144 ✗ if (sc->slice_coding_mode != 1 && f->colorspace != 0) {
1145 ✗ put_symbol(c, state, sc->slice_rct_by_coef, 0);
1146 ✗ put_symbol(c, state, sc->slice_rct_ry_coef, 0);
1147 }
1148 ✗ put_symbol(c, state, sc->remap, 0);
1149 }
1150 8345 }
1151
1152 ✗ static void choose_rct_params(const FFV1Context *f, FFV1SliceContext *sc,
1153 const uint8_t *src[3], const int stride[3], int w, int h)
1154 {
1155 #define NB_Y_COEFF 15
1156 static const int rct_y_coeff[15][2] = {
1157 {0, 0}, // 4G
1158 {1, 1}, // R + 2G + B
1159 {2, 2}, // 2R + 2B
1160 {0, 2}, // 2G + 2B
1161 {2, 0}, // 2R + 2G
1162 {4, 0}, // 4R
1163 {0, 4}, // 4B
1164
1165 {0, 3}, // 1G + 3B
1166 {3, 0}, // 3R + 1G
1167 {3, 1}, // 3R + B
1168 {1, 3}, // R + 3B
1169 {1, 2}, // R + G + 2B
1170 {2, 1}, // 2R + G + B
1171 {0, 1}, // 3G + B
1172 {1, 0}, // R + 3G
1173 };
1174
1175 ✗ int stat[NB_Y_COEFF] = {0};
1176 int x, y, i, p, best;
1177 int16_t *sample[3];
1178 ✗ int lbd = f->bits_per_raw_sample <= 8;
1179 ✗ int packed = !src[1];
1180 ✗ int transparency = f->transparency;
1181 ✗ int packed_size = (3 + transparency)*2;
1182
1183 ✗ for (y = 0; y < h; y++) {
1184 ✗ int lastr=0, lastg=0, lastb=0;
1185 ✗ for (p = 0; p < 3; p++)
1186 ✗ sample[p] = sc->sample_buffer + p*w;
1187
1188 ✗ for (x = 0; x < w; x++) {
1189 int b, g, r;
1190 int ab, ag, ar;
1191 ✗ if (lbd) {
1192 ✗ unsigned v = *((const uint32_t*)(src[0] + x*4 + stride[0]*y));
1193 ✗ b = v & 0xFF;
1194 ✗ g = (v >> 8) & 0xFF;
1195 ✗ r = (v >> 16) & 0xFF;
1196 ✗ } else if (packed) {
1197 ✗ const uint16_t *p = ((const uint16_t*)(src[0] + x*packed_size + stride[0]*y));
1198 ✗ r = p[0];
1199 ✗ g = p[1];
1200 ✗ b = p[2];
1201 ✗ } else if (f->use32bit || transparency) {
1202 ✗ g = *((const uint16_t *)(src[0] + x*2 + stride[0]*y));
1203 ✗ b = *((const uint16_t *)(src[1] + x*2 + stride[1]*y));
1204 ✗ r = *((const uint16_t *)(src[2] + x*2 + stride[2]*y));
1205 } else {
1206 ✗ b = *((const uint16_t*)(src[0] + x*2 + stride[0]*y));
1207 ✗ g = *((const uint16_t*)(src[1] + x*2 + stride[1]*y));
1208 ✗ r = *((const uint16_t*)(src[2] + x*2 + stride[2]*y));
1209 }
1210
1211 ✗ ar = r - lastr;
1212 ✗ ag = g - lastg;
1213 ✗ ab = b - lastb;
1214 ✗ if (x && y) {
1215 ✗ int bg = ag - sample[0][x];
1216 ✗ int bb = ab - sample[1][x];
1217 ✗ int br = ar - sample[2][x];
1218
1219 ✗ br -= bg;
1220 ✗ bb -= bg;
1221
1222 ✗ for (i = 0; i<NB_Y_COEFF; i++) {
1223 ✗ stat[i] += FFABS(bg + ((br*rct_y_coeff[i][0] + bb*rct_y_coeff[i][1])>>2));
1224 }
1225
1226 }
1227 ✗ sample[0][x] = ag;
1228 ✗ sample[1][x] = ab;
1229 ✗ sample[2][x] = ar;
1230
1231 ✗ lastr = r;
1232 ✗ lastg = g;
1233 ✗ lastb = b;
1234 }
1235 }
1236
1237 ✗ best = 0;
1238 ✗ for (i=1; i<NB_Y_COEFF; i++) {
1239 ✗ if (stat[i] < stat[best])
1240 ✗ best = i;
1241 }
1242
1243 ✗ sc->slice_rct_by_coef = rct_y_coeff[best][1];
1244 ✗ sc->slice_rct_ry_coef = rct_y_coeff[best][0];
1245 ✗ }
1246
1247 ✗ static void choose_rct_params_bayer(const FFV1Context *f, FFV1SliceContext *sc,
1248 const uint8_t *src[4], const int stride[4],
1249 int w, int h)
1250 {
1251 static const int rct_y_coeff[NB_Y_COEFF][2] = {
1252 { 0, 0 }, { 1, 1 }, { 2, 2 }, { 0, 2 }, { 2, 0 }, { 4, 0 }, { 0, 4 }, { 0, 3 },
1253 { 3, 0 }, { 3, 1 }, { 1, 3 }, { 1, 2 }, { 2, 1 }, { 0, 1 }, { 1, 0 },
1254 };
1255 ✗ int stat[NB_Y_COEFF] = {0};
1256 int16_t *sample[3];
1257 int i, best;
1258
1259 /* Walk in 2x2 blocks, build per-block gm/b/r, evaluate prediction-error */
1260 ✗ w >>= 1;
1261 ✗ for (i = 0; i < 3; i++)
1262 ✗ sample[i] = sc->sample_buffer + i*w;
1263
1264 ✗ for (int y = 0; y < h; y += 2) {
1265 ✗ int last_gm = 0, last_b = 0, last_r = 0;
1266 ✗ for (int x = 0; x < w; x++) {
1267 ✗ const uint16_t *l1 = (const uint16_t *)(src[0] + stride[0]*(y + 0) + x*2*2);
1268 ✗ const uint16_t *l2 = (const uint16_t *)(src[0] + stride[0]*(y + 1) + x*2*2);
1269 ✗ int r = l1[0];
1270 ✗ int gr = l1[1];
1271 ✗ int gb = l2[0];
1272 ✗ int b = l2[1];
1273 ✗ int gd = gr - gb;
1274 ✗ int gm = gb + (gd >> 1);
1275
1276 ✗ int agm = gm - last_gm;
1277 ✗ int ab = b - last_b;
1278 ✗ int ar = r - last_r;
1279
1280 ✗ if (x && y) {
1281 ✗ int bgm = agm - sample[0][x];
1282 ✗ int bb = ab - sample[1][x];
1283 ✗ int br = ar - sample[2][x];
1284
1285 ✗ br -= bgm;
1286 ✗ bb -= bgm;
1287
1288 ✗ for (i = 0; i < NB_Y_COEFF; i++)
1289 ✗ stat[i] += FFABS(bgm + ((br*rct_y_coeff[i][0] + bb*rct_y_coeff[i][1]) >> 2));
1290 }
1291 ✗ sample[0][x] = agm;
1292 ✗ sample[1][x] = ab;
1293 ✗ sample[2][x] = ar;
1294
1295 ✗ last_gm = gm;
1296 ✗ last_b = b;
1297 ✗ last_r = r;
1298 }
1299 }
1300
1301 ✗ best = 0;
1302 ✗ for (i = 1; i < NB_Y_COEFF; i++)
1303 ✗ if (stat[i] < stat[best])
1304 ✗ best = i;
1305
1306 ✗ sc->slice_rct_by_coef = rct_y_coeff[best][1];
1307 ✗ sc->slice_rct_ry_coef = rct_y_coeff[best][0];
1308 ✗ }
1309
1310 ✗ static void encode_histogram_remap(FFV1Context *f, FFV1SliceContext *sc)
1311 {
1312 ✗ int len = 1 << f->bits_per_raw_sample;
1313 ✗ int flip = sc->remap == 2 ? 0x7FFF : 0;
1314
1315 ✗ for (int p= 0; p < 1 + 2*f->chroma_planes + f->transparency; p++) {
1316 ✗ int j = 0;
1317 ✗ int lu = 0;
1318 uint8_t state[2][32];
1319 ✗ int run = 0;
1320
1321 ✗ memset(state, 128, sizeof(state));
1322 ✗ put_symbol(&sc->c, state[0], 0, 0);
1323 ✗ memset(state, 128, sizeof(state));
1324 ✗ for (int i= 0; i<len; i++) {
1325 ✗ int ri = i ^ ((i&0x8000) ? 0 : flip);
1326 ✗ int u = sc->fltmap[p][ri];
1327 ✗ sc->fltmap[p][ri] = j;
1328 ✗ j+= u;
1329
1330 ✗ if (lu == u) {
1331 ✗ run ++;
1332 } else {
1333 ✗ put_symbol_inline(&sc->c, state[lu], run, 0, NULL, NULL);
1334 ✗ if (run == 0)
1335 ✗ lu = u;
1336 ✗ run = 0;
1337 }
1338 }
1339 ✗ if (run)
1340 ✗ put_symbol(&sc->c, state[lu], run, 0);
1341 ✗ sc->remap_count[p] = j;
1342 }
1343 ✗ }
1344
1345 ✗ static void load_rgb_float32_frame(FFV1Context *f, FFV1SliceContext *sc,
1346 const uint8_t *src[4],
1347 int w, int h, const int stride[4])
1348 {
1349 int x, y;
1350 ✗ int transparency = f->transparency;
1351 ✗ int i = 0;
1352
1353 ✗ for (y = 0; y < h; y++) {
1354 ✗ for (x = 0; x < w; x++) {
1355 ✗ int b, g, r, av_uninit(a);
1356
1357 ✗ g = *((const uint32_t *)(src[0] + x*4 + stride[0]*y));
1358 ✗ b = *((const uint32_t *)(src[1] + x*4 + stride[1]*y));
1359 ✗ r = *((const uint32_t *)(src[2] + x*4 + stride[2]*y));
1360 ✗ if (transparency)
1361 ✗ a = *((const uint32_t *)(src[3] + x*4 + stride[3]*y));
1362
1363 ✗ if (sc->remap == 2) {
1364 #define FLIP(f) (((f)&0x80000000) ? (f) : (f)^0x7FFFFFFF);
1365 ✗ g = FLIP(g);
1366 ✗ b = FLIP(b);
1367 ✗ r = FLIP(r);
1368 }
1369 // We cannot build a histogram as we do for 16bit, we need a bit of magic here
1370 // Its possible to reduce the memory needed at the cost of more dereferencing
1371 ✗ sc->unit[0][i].val = g;
1372 ✗ sc->unit[0][i].ndx = x + y*w;
1373
1374 ✗ sc->unit[1][i].val = b;
1375 ✗ sc->unit[1][i].ndx = x + y*w;
1376
1377 ✗ sc->unit[2][i].val = r;
1378 ✗ sc->unit[2][i].ndx = x + y*w;
1379
1380 ✗ if (transparency) {
1381 ✗ sc->unit[3][i].val = a;
1382 ✗ sc->unit[3][i].ndx = x + y*w;
1383 }
1384 ✗ i++;
1385 }
1386 }
1387
1388 //TODO switch to radix sort
1389 #define CMP(A,B) ((A)->val - (int64_t)(B)->val)
1390 ✗ AV_QSORT(sc->unit[0], i, struct Unit, CMP);
1391 ✗ AV_QSORT(sc->unit[1], i, struct Unit, CMP);
1392 ✗ AV_QSORT(sc->unit[2], i, struct Unit, CMP);
1393 ✗ if (transparency)
1394 ✗ AV_QSORT(sc->unit[3], i, struct Unit, CMP);
1395 ✗ }
1396
1397 ✗ static int encode_float32_remap_segment(FFV1SliceContext *sc,
1398 int p, int mul_count, int *mul_tab, int update, int final)
1399 {
1400 ✗ const int pixel_num = sc->slice_width * sc->slice_height;
1401 uint8_t state[2][3][32];
1402 int mul[4096+1];
1403 ✗ RangeCoder rc = sc->c;
1404 ✗ int lu = 0;
1405 ✗ int run = 0;
1406 ✗ int64_t last_val = -1;
1407 ✗ int compact_index = -1;
1408 ✗ int i = 0;
1409 ✗ int current_mul_index = -1;
1410 ✗ int run1final = 0;
1411 int run1start_i;
1412 int run1start_last_val;
1413 int run1start_mul_index;
1414
1415 ✗ memcpy(mul, mul_tab, sizeof(*mul_tab)*(mul_count+1));
1416 ✗ memset(state, 128, sizeof(state));
1417 ✗ put_symbol(&rc, state[0][0], mul_count, 0);
1418 ✗ memset(state, 128, sizeof(state));
1419
1420 ✗ for (; i < pixel_num+1; i++) {
1421 ✗ int current_mul = current_mul_index < 0 ? 1 : FFABS(mul[current_mul_index]);
1422 int64_t val;
1423 ✗ if (i == pixel_num) {
1424 ✗ if (last_val == 0xFFFFFFFF && (!run || run1final)) {
1425 break;
1426 } else {
1427 ✗ val = last_val + ((1LL<<32) - last_val + current_mul - 1) / current_mul * current_mul;
1428 av_assert2(val >= (1LL<<32));
1429 ✗ val += lu * current_mul; //ensure a run1 ends
1430 }
1431 } else
1432 ✗ val = sc->unit[p][i].val;
1433
1434 ✗ if (last_val != val) {
1435 ✗ int64_t delta = val - last_val;
1436 ✗ int64_t step = FFMAX(1, (delta + current_mul/2) / current_mul);
1437 av_assert2(last_val < val);
1438 av_assert2(current_mul > 0);
1439
1440 ✗ delta -= step*current_mul;
1441 av_assert2(delta <= current_mul/2);
1442 av_assert2(delta > -current_mul);
1443
1444 av_assert2(step > 0);
1445 ✗ if (lu) {
1446 ✗ if (!run) {
1447 ✗ run1start_i = i - 1;
1448 ✗ run1start_last_val = last_val;
1449 ✗ run1start_mul_index= current_mul_index;
1450 }
1451 ✗ if (step == 1) {
1452 ✗ if (run1final) {
1453 ✗ if (current_mul>1)
1454 ✗ put_symbol_inline(&rc, state[lu][1], delta, 1, NULL, NULL);
1455 }
1456 ✗ run ++;
1457 av_assert2(last_val + current_mul + delta == val);
1458 } else {
1459 ✗ if (run1final) {
1460 ✗ if (run == 0)
1461 ✗ lu ^= 1;
1462 ✗ i--; // we did not encode val so we need to backstep
1463 ✗ last_val += current_mul;
1464 } else {
1465 ✗ put_symbol_inline(&rc, state[lu][0], run, 0, NULL, NULL);
1466 ✗ i = run1start_i;
1467 ✗ last_val = run1start_last_val; // we could compute this instead of storing
1468 ✗ current_mul_index = run1start_mul_index;
1469 }
1470 ✗ run1final ^= 1;
1471
1472 ✗ run = 0;
1473 ✗ continue;
1474 }
1475 } else {
1476 av_assert2(run == 0);
1477 av_assert2(run1final == 0);
1478 ✗ put_symbol_inline(&rc, state[lu][0], step - 1, 0, NULL, NULL);
1479
1480 ✗ if (current_mul > 1)
1481 ✗ put_symbol_inline(&rc, state[lu][1], delta, 1, NULL, NULL);
1482 ✗ if (step == 1)
1483 ✗ lu ^= 1;
1484
1485 av_assert2(last_val + step * current_mul + delta == val);
1486 }
1487 ✗ last_val = val;
1488 ✗ current_mul_index = ((last_val + 1) * mul_count) >> 32;
1489 ✗ if (!run || run1final) {
1490 av_assert2(mul[ current_mul_index ]);
1491 ✗ if (mul[ current_mul_index ] < 0) {
1492 av_assert2(i < pixel_num);
1493 ✗ mul[ current_mul_index ] *= -1;
1494 ✗ put_symbol_inline(&rc, state[0][2], mul[ current_mul_index ], 0, NULL, NULL);
1495 }
1496 ✗ if (i < pixel_num)
1497 ✗ compact_index ++;
1498 }
1499 }
1500 ✗ if (!run || run1final)
1501 ✗ if (final && i < pixel_num)
1502 ✗ sc->bitmap[p][sc->unit[p][i].ndx] = compact_index;
1503 }
1504
1505 ✗ if (update) {
1506 ✗ sc->c = rc;
1507 ✗ sc->remap_count[p] = compact_index + 1;
1508 }
1509 ✗ return get_rac_count(&rc);
1510 }
1511
1512 ✗ static void encode_float32_remap(FFV1Context *f, FFV1SliceContext *sc,
1513 const uint8_t *src[4])
1514 {
1515 ✗ int pixel_num = sc->slice_width * sc->slice_height;
1516 ✗ const int max_log2_mul_count = ((int[]){ 1, 1, 1, 9, 9, 10})[f->remap_optimizer];
1517 ✗ const int log2_mul_count_step = ((int[]){ 1, 1, 1, 9, 9, 1})[f->remap_optimizer];
1518 ✗ const int max_log2_mul = ((int[]){ 1, 8, 8, 9, 22, 22})[f->remap_optimizer];
1519 ✗ const int log2_mul_step = ((int[]){ 1, 8, 1, 1, 1, 1})[f->remap_optimizer];
1520 ✗ const int bruteforce_count = ((int[]){ 0, 0, 0, 1, 1, 1})[f->remap_optimizer];
1521 ✗ const int stair_mode = ((int[]){ 0, 0, 0, 1, 0, 0})[f->remap_optimizer];
1522 ✗ const int magic_log2 = ((int[]){ 1, 1, 1, 1, 0, 0})[f->remap_optimizer];
1523
1524 ✗ for (int p= 0; p < 1 + 2*f->chroma_planes + f->transparency; p++) {
1525 ✗ int best_log2_mul_count = 0;
1526 ✗ float score_sum[11] = {0};
1527 int mul_all[11][1025];
1528
1529 ✗ for (int log2_mul_count= 0; log2_mul_count <= max_log2_mul_count; log2_mul_count += log2_mul_count_step) {
1530 ✗ float score_tab_all[1025][23] = {0};
1531 ✗ int64_t last_val = -1;
1532 ✗ int *mul_tab = mul_all[log2_mul_count];
1533 ✗ int last_mul_index = -1;
1534 ✗ int mul_count = 1 << log2_mul_count;
1535
1536 ✗ score_sum[log2_mul_count] = 2 * log2_mul_count;
1537 ✗ if (magic_log2)
1538 ✗ score_sum[log2_mul_count] = av_float2int((float)mul_count * mul_count);
1539 ✗ for (int i= 0; i<pixel_num; i++) {
1540 ✗ int64_t val = sc->unit[p][i].val;
1541 ✗ int mul_index = (val + 1LL)*mul_count >> 32;
1542 ✗ if (val != last_val) {
1543 ✗ float *score_tab = score_tab_all[(last_val + 1LL)*mul_count >> 32];
1544 av_assert2(last_val < val);
1545 ✗ for(int si= 0; si <= max_log2_mul; si += log2_mul_step) {
1546 ✗ int64_t delta = val - last_val;
1547 int mul;
1548 int64_t cost;
1549
1550 ✗ if (last_val < 0) {
1551 ✗ mul = 1;
1552 ✗ } else if (stair_mode && mul_count == 512 && si == max_log2_mul ) {
1553 ✗ if (mul_index >= 0x378/8 && mul_index <= 23 + 0x378/8) {
1554 ✗ mul = (0x800080 >> (mul_index - 0x378/8));
1555 } else
1556 ✗ mul = 1;
1557 } else {
1558 ✗ mul = (0x10001LL)<<si >> 16;
1559 }
1560
1561 ✗ cost = FFMAX((delta + mul/2) / mul, 1);
1562 ✗ float score = 1;
1563 ✗ if (mul > 1) {
1564 ✗ score *= (FFABS(delta - cost*mul)+1);
1565 ✗ if (mul_count > 1)
1566 ✗ score *= score;
1567 }
1568 ✗ score *= cost;
1569 ✗ score *= score;
1570 ✗ if (mul_index != last_mul_index)
1571 ✗ score *= mul;
1572 ✗ if (magic_log2) {
1573 ✗ score_tab[si] += av_float2int(score);
1574 } else
1575 ✗ score_tab[si] += log2f(score);
1576 }
1577 }
1578 ✗ last_val = val;
1579 ✗ last_mul_index = mul_index;
1580 }
1581 ✗ for(int i= 0; i<mul_count; i++) {
1582 ✗ int best_index = 0;
1583 ✗ float *score_tab = score_tab_all[i];
1584 ✗ for(int si= 0; si <= max_log2_mul; si += log2_mul_step) {
1585 ✗ if (score_tab[si] < score_tab[ best_index ])
1586 ✗ best_index = si;
1587 }
1588 ✗ if (stair_mode && mul_count == 512 && best_index == max_log2_mul ) {
1589 ✗ if (i >= 0x378/8 && i <= 23 + 0x378/8) {
1590 ✗ mul_tab[i] = -(0x800080 >> (i - 0x378/8));
1591 } else
1592 ✗ mul_tab[i] = -1;
1593 } else
1594 ✗ mul_tab[i] = -((0x10001LL)<<best_index >> 16);
1595 ✗ score_sum[log2_mul_count] += score_tab[ best_index ];
1596 }
1597 ✗ mul_tab[mul_count] = 1;
1598
1599 ✗ if (bruteforce_count)
1600 ✗ score_sum[log2_mul_count] = encode_float32_remap_segment(sc, p, mul_count, mul_all[log2_mul_count], 0, 0);
1601
1602 ✗ if (score_sum[log2_mul_count] < score_sum[best_log2_mul_count])
1603 ✗ best_log2_mul_count = log2_mul_count;
1604 }
1605
1606 ✗ encode_float32_remap_segment(sc, p, 1<<best_log2_mul_count, mul_all[best_log2_mul_count], 1, 1);
1607 }
1608 ✗ }
1609
1610 ✗ static int encode_float32_rgb_frame(FFV1Context *f, FFV1SliceContext *sc,
1611 const uint8_t *src[4],
1612 int w, int h, const int stride[4], int ac)
1613 {
1614 int x, y, p, i;
1615 ✗ const int ring_size = f->context_model ? 3 : 2;
1616 int32_t *sample[4][3];
1617 ✗ const int pass1 = !!(f->avctx->flags & AV_CODEC_FLAG_PASS1);
1618 int bits[4], offset;
1619 ✗ int transparency = f->transparency;
1620
1621 ✗ ff_ffv1_compute_bits_per_plane(f, sc, bits, &offset, NULL, f->bits_per_raw_sample);
1622
1623 ✗ sc->run_index = 0;
1624
1625 ✗ for (int p = 0; p < MAX_PLANES; ++p)
1626 ✗ sample[p][2] = sc->sample_buffer32; // dummy to avoid UB pointer arithmetic
1627
1628 ✗ memset(RENAME(sc->sample_buffer), 0, ring_size * MAX_PLANES *
1629 ✗ (w + 6) * sizeof(*RENAME(sc->sample_buffer)));
1630
1631 ✗ for (y = 0; y < h; y++) {
1632 ✗ for (i = 0; i < ring_size; i++)
1633 ✗ for (p = 0; p < MAX_PLANES; p++)
1634 ✗ sample[p][i]= RENAME(sc->sample_buffer) + p*ring_size*(w+6) + ((h+i-y)%ring_size)*(w+6) + 3;
1635
1636 ✗ for (x = 0; x < w; x++) {
1637 ✗ int b, g, r, av_uninit(a);
1638 ✗ g = sc->bitmap[0][x + w*y];
1639 ✗ b = sc->bitmap[1][x + w*y];
1640 ✗ r = sc->bitmap[2][x + w*y];
1641 ✗ if (transparency)
1642 ✗ a = sc->bitmap[3][x + w*y];
1643
1644 ✗ if (sc->slice_coding_mode != 1) {
1645 ✗ b -= g;
1646 ✗ r -= g;
1647 ✗ g += (b * sc->slice_rct_by_coef + r * sc->slice_rct_ry_coef) >> 2;
1648 ✗ b += offset;
1649 ✗ r += offset;
1650 }
1651
1652 ✗ sample[0][0][x] = g;
1653 ✗ sample[1][0][x] = b;
1654 ✗ sample[2][0][x] = r;
1655 ✗ sample[3][0][x] = a;
1656 }
1657 ✗ for (p = 0; p < 3 + transparency; p++) {
1658 int ret;
1659 ✗ sample[p][0][-1] = sample[p][1][0 ];
1660 ✗ sample[p][1][ w] = sample[p][1][w-1];
1661 ✗ ret = encode_line32(f, sc, f->avctx, w, sample[p], (p + 1) / 2,
1662 bits[p], ac, pass1);
1663 ✗ if (ret < 0)
1664 ✗ return ret;
1665 }
1666 }
1667 ✗ return 0;
1668 }
1669
1670 ✗ static int encode_bayer_frame(FFV1Context *f, FFV1SliceContext *sc,
1671 const uint8_t *src[4],
1672 int w, int h, const int stride[4], int ac)
1673 {
1674 ✗ const int pass1 = !!(f->avctx->flags & AV_CODEC_FLAG_PASS1);
1675 ✗ const int ring_size = f->context_model ? 3 : 2;
1676 TYPE *sample[4][3];
1677
1678 int bits[4], offset;
1679 ✗ ff_ffv1_compute_bits_per_plane(f, sc, bits, &offset, NULL, f->bits_per_raw_sample);
1680
1681 ✗ w >>= 1;
1682
1683 ✗ sc->run_index = 0;
1684
1685 ✗ for (int p = 0; p < MAX_PLANES; ++p)
1686 ✗ sample[p][2] = RENAME(sc->sample_buffer);
1687
1688 ✗ memset(RENAME(sc->sample_buffer), 0, ring_size * MAX_PLANES *
1689 ✗ (w + 6) * sizeof(*RENAME(sc->sample_buffer)));
1690
1691 ✗ for (int y = 0; y < h; y += 2) {
1692 ✗ for (int i = 0; i < ring_size; i++)
1693 ✗ for (int p = 0; p < MAX_PLANES; p++)
1694 ✗ sample[p][i] = RENAME(sc->sample_buffer) + p*ring_size*(w+6) +
1695 ✗ ((h+i-y/2) % ring_size)*(w+6) + 3;
1696
1697 ✗ for (int x = 0; x < w; x++) {
1698 ✗ const uint16_t *l1 = ((const uint16_t*)(src[0] + stride[0]*(y + 0) + x*2*2));
1699 ✗ const uint16_t *l2 = ((const uint16_t*)(src[0] + stride[0]*(y + 1) + x*2*2));
1700
1701 int r, gr, gb, b;
1702 ✗ r = l1[0];
1703 ✗ gr = l1[1];
1704 ✗ gb = l2[0];
1705 ✗ b = l2[1];
1706
1707 ✗ if (sc->slice_coding_mode != 1) {
1708 /**
1709 * Bayer 2x2 RCT, based on:
1710 * "Reversible color transform for Bayer color filter array images", S. Poomrittigul et al,
1711 * APSIPA Transactions on Signal and Information Processing (2013) 2 (1): 1-10,
1712 * doi:10.1017/ATSIP.2013.6 */
1713 ✗ int gd = gr - gb;
1714 ✗ int gm = gb + (gd >> 1);
1715
1716 ✗ b -= gm;
1717 ✗ r -= gm;
1718 ✗ gm += (b * sc->slice_rct_by_coef + r * sc->slice_rct_ry_coef) >> 2;
1719 ✗ b += offset;
1720 ✗ r += offset;
1721 ✗ gd += offset;
1722
1723 ✗ gr = gm;
1724 ✗ gb = gd;
1725 }
1726
1727 ✗ sample[0][0][x] = gr;
1728 ✗ sample[1][0][x] = gb;
1729 ✗ sample[2][0][x] = b;
1730 ✗ sample[3][0][x] = r;
1731 }
1732
1733 ✗ for (int p = 0; p < 4; p++) {
1734 int ret;
1735 ✗ sample[p][0][-1] = sample[p][1][0 ];
1736 ✗ sample[p][1][ w] = sample[p][1][w-1];
1737 /* Plane contexts: gm=0 (luma), b-gm/r-gm=1 (chroma diff from
1738 * green), gd=2 (own context - green-green diff has different
1739 * statistics from both luma and chroma). */
1740 ✗ ret = RENAME(encode_line)(f, sc, f->avctx, w, sample[p],
1741 ✗ p == 1 ? 2 : (p > 1),
1742 bits[p], ac, pass1);
1743 ✗ if (ret < 0)
1744 ✗ return ret;
1745 }
1746 }
1747
1748 ✗ return 0;
1749 }
1750
1751 9345 static int encode_slice(AVCodecContext *c, void *arg)
1752 {
1753 9345 FFV1SliceContext *sc = arg;
1754 9345 FFV1Context *f = c->priv_data;
1755 9345 int width = sc->slice_width;
1756 9345 int height = sc->slice_height;
1757 9345 int x = sc->slice_x;
1758 9345 int y = sc->slice_y;
1759 9345 const AVFrame *const p = f->cur_enc_frame;
1760 9345 const int ps = av_pix_fmt_desc_get(c->pix_fmt)->comp[0].step;
1761 int ret;
1762 9345 RangeCoder c_bak = sc->c;
1763 9345 const int chroma_width = AV_CEIL_RSHIFT(width, f->chroma_h_shift);
1764 9345 const int chroma_height = AV_CEIL_RSHIFT(height, f->chroma_v_shift);
1765 37380 const uint8_t *planes[4] = {p->data[0] + ps*x + y*p->linesize[0],
1766
2/2
✓ Branch 0 taken 7745 times.
✓ Branch 1 taken 1600 times.
 9345 p->data[1] ? p->data[1] + ps*x + y*p->linesize[1] : NULL,
1767
2/2
✓ Branch 0 taken 7745 times.
✓ Branch 1 taken 1600 times.
 9345 p->data[2] ? p->data[2] + ps*x + y*p->linesize[2] : NULL,
1768
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 9345 times.
 9345 p->data[3] ? p->data[3] + ps*x + y*p->linesize[3] : NULL};
1769 9345 int ac = f->ac;
1770
1771 9345 sc->slice_coding_mode = 0;
1772
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 9345 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 9345 if (f->version > 3 && f->colorspace == 1) {
1773 ✗ choose_rct_params(f, sc, planes, p->linesize, width, height);
1774
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 9345 times.
 9345 } else if (f->bayer) {
1775 ✗ choose_rct_params_bayer(f, sc, planes, p->linesize, width, height);
1776 } else {
1777 9345 sc->slice_rct_by_coef = 1;
1778 9345 sc->slice_rct_ry_coef = 1;
1779 }
1780
1781 9345 retry:
1782
2/2
✓ Branch 0 taken 941 times.
✓ Branch 1 taken 8404 times.
 9345 if (f->key_frame)
1783 941 ff_ffv1_clear_slice_state(f, sc);
1784
2/2
✓ Branch 0 taken 8345 times.
✓ Branch 1 taken 1000 times.
 9345 if (f->version > 2) {
1785 8345 encode_slice_header(f, sc);
1786 }
1787
1788
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 9345 times.
 9345 if (sc->remap) {
1789 //Both the 16bit and 32bit remap do exactly the same thing but with 16bits we can
1790 //Implement this using a "histogram" while for 32bit that would be gb sized, thus a more
1791 //complex implementation sorting pairs is used.
1792 ✗ if (f->bits_per_raw_sample != 32) {
1793 ✗ if (f->colorspace == 0 && c->pix_fmt != AV_PIX_FMT_YA8 && c->pix_fmt != AV_PIX_FMT_YAF16) {
1794 ✗ const int cx = x >> f->chroma_h_shift;
1795 ✗ const int cy = y >> f->chroma_v_shift;
1796
1797 //TODO decide on the order for the encoded remaps and loads. with golomb rice it
1798 // easier to have all range coded ones together, otherwise it may be nicer to handle each plane as a whole?
1799
1800 ✗ load_plane(f, sc, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 1);
1801
1802 ✗ if (f->chroma_planes) {
1803 ✗ load_plane(f, sc, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1, 1);
1804 ✗ load_plane(f, sc, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 2, 1);
1805 }
1806 ✗ if (f->transparency)
1807 ✗ load_plane(f, sc, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], 3, 1);
1808 ✗ } else if (c->pix_fmt == AV_PIX_FMT_YA8 || c->pix_fmt == AV_PIX_FMT_YAF16) {
1809 ✗ load_plane(f, sc, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 2);
1810 ✗ load_plane(f, sc, p->data[0] + (ps>>1) + ps*x + y*p->linesize[0], width, height, p->linesize[0], 1, 2);
1811 ✗ } else if (f->use32bit) {
1812 ✗ load_rgb_frame32(f, sc, planes, width, height, p->linesize);
1813 } else
1814 ✗ load_rgb_frame (f, sc, planes, width, height, p->linesize);
1815
1816 ✗ encode_histogram_remap(f, sc);
1817 } else {
1818 ✗ load_rgb_float32_frame(f, sc, planes, width, height, p->linesize);
1819 ✗ encode_float32_remap(f, sc, planes);
1820 }
1821 }
1822
1823
2/2
✓ Branch 0 taken 3700 times.
✓ Branch 1 taken 5645 times.
 9345 if (ac == AC_GOLOMB_RICE) {
1824
6/6
✓ Branch 0 taken 1000 times.
✓ Branch 1 taken 2700 times.
✓ Branch 2 taken 600 times.
✓ Branch 3 taken 400 times.
✓ Branch 4 taken 400 times.
✓ Branch 5 taken 200 times.
 3700 sc->ac_byte_count = f->version > 2 || (!x && !y) ? ff_rac_terminate(&sc->c, f->version > 2) : 0;
1825 3700 init_put_bits(&sc->pb,
1826 3700 sc->c.bytestream_start + sc->ac_byte_count,
1827 3700 sc->c.bytestream_end - sc->c.bytestream_start - sc->ac_byte_count);
1828 }
1829
1830
4/6
✓ Branch 0 taken 7745 times.
✓ Branch 1 taken 1600 times.
✓ Branch 2 taken 7745 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 7745 times.
✗ Branch 5 not taken.
 17090 if (f->colorspace == 0 && c->pix_fmt != AV_PIX_FMT_YA8 && c->pix_fmt != AV_PIX_FMT_YAF16) {
1831 7745 const int cx = x >> f->chroma_h_shift;
1832 7745 const int cy = y >> f->chroma_v_shift;
1833
1834 7745 ret = encode_plane(f, sc, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 0, 1, ac);
1835
1836
1/2
✓ Branch 0 taken 7745 times.
✗ Branch 1 not taken.
 7745 if (f->chroma_planes) {
1837 7745 ret |= encode_plane(f, sc, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1, 1, 1, ac);
1838 7745 ret |= encode_plane(f, sc, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1, 2, 1, ac);
1839 }
1840
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 7745 times.
 7745 if (f->transparency)
1841 ✗ ret |= encode_plane(f, sc, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], 2, 3, 1, ac);
1842
2/4
✓ Branch 0 taken 1600 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 1600 times.
 1600 } else if (c->pix_fmt == AV_PIX_FMT_YA8 || c->pix_fmt == AV_PIX_FMT_YAF16) {
1843 ✗ ret = encode_plane(f, sc, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 0, 2, ac);
1844 ✗ ret |= encode_plane(f, sc, p->data[0] + (ps>>1) + ps*x + y*p->linesize[0], width, height, p->linesize[0], 1, 1, 2, ac);
1845
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1600 times.
 1600 } else if (f->bits_per_raw_sample == 32) {
1846 ✗ ret = encode_float32_rgb_frame(f, sc, planes, width, height, p->linesize, ac);
1847
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1600 times.
 1600 } else if (f->bayer) {
1848 ✗ ret = encode_bayer_frame(f, sc, planes, width, height, p->linesize, ac);
1849
2/2
✓ Branch 0 taken 800 times.
✓ Branch 1 taken 800 times.
 1600 } else if (f->use32bit) {
1850 800 ret = encode_rgb_frame32(f, sc, planes, width, height, p->linesize, ac);
1851 } else {
1852 800 ret = encode_rgb_frame(f, sc, planes, width, height, p->linesize, ac);
1853 }
1854
1855
2/2
✓ Branch 0 taken 5645 times.
✓ Branch 1 taken 3700 times.
 9345 if (ac != AC_GOLOMB_RICE) {
1856 5645 sc->ac_byte_count = ff_rac_terminate(&sc->c, 1);
1857 } else {
1858 3700 flush_put_bits(&sc->pb); // FIXME: nicer padding
1859 3700 sc->ac_byte_count += put_bytes_output(&sc->pb);
1860 }
1861
1862
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 9345 times.
 9345 if (ret < 0) {
1863 ✗ av_assert0(sc->slice_coding_mode == 0);
1864 ✗ if (f->version < 4) {
1865 ✗ av_log(c, AV_LOG_ERROR, "Buffer too small\n");
1866 ✗ return ret;
1867 }
1868 ✗ av_log(c, AV_LOG_DEBUG, "Coding slice as PCM\n");
1869 ✗ ac = 1;
1870 ✗ sc->slice_coding_mode = 1;
1871 ✗ sc->c = c_bak;
1872 ✗ goto retry;
1873 }
1874
1875 9345 return 0;
1876 }
1877
1878 2480 size_t ff_ffv1_encode_buffer_size(AVCodecContext *avctx)
1879 {
1880 2480 FFV1Context *f = avctx->priv_data;
1881
1882 2480 int w = avctx->width + f->num_h_slices;
1883 2480 int h = avctx->height + f->num_v_slices;
1884 2480 size_t maxsize = w*h * (1 + f->transparency);
1885
1/2
✓ Branch 0 taken 2480 times.
✗ Branch 1 not taken.
 2480 if (f->chroma_planes)
1886 2480 maxsize += AV_CEIL_RSHIFT(w, f->chroma_h_shift) * AV_CEIL_RSHIFT(h, f->chroma_v_shift) * 2;
1887 2480 maxsize += f->slice_count * 800; //for slice header
1888
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2480 times.
 2480 if (f->version > 3) {
1889 ✗ maxsize *= f->bits_per_raw_sample + 1;
1890 ✗ if (f->remap_mode)
1891 ✗ maxsize += f->slice_count * 70000 * (1 + 2*f->chroma_planes + f->bayer + f->transparency);
1892 } else {
1893 2480 maxsize += f->slice_count * 2 * (avctx->width + avctx->height); //for bug with slices that code some pixels more than once
1894 2480 maxsize *= 8*(2*f->bits_per_raw_sample + 5);
1895 }
1896 2480 maxsize >>= 3;
1897 2480 maxsize += FF_INPUT_BUFFER_MIN_SIZE;
1898
1899 2480 return maxsize;
1900 }
1901
1902 2531 static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
1903 const AVFrame *pict, int *got_packet)
1904 {
1905 2531 FFV1Context *f = avctx->priv_data;
1906 2531 RangeCoder *const c = &f->slices[0].c;
1907 2531 uint8_t keystate = 128;
1908 uint8_t *buf_p;
1909 int i, ret;
1910 int64_t maxsize;
1911
1912
2/2
✓ Branch 0 taken 51 times.
✓ Branch 1 taken 2480 times.
 2531 if(!pict) {
1913
2/2
✓ Branch 0 taken 8 times.
✓ Branch 1 taken 43 times.
 51 if (avctx->flags & AV_CODEC_FLAG_PASS1) {
1914 int j, k, m;
1915 8 char *p = avctx->stats_out;
1916 8 char *end = p + STATS_OUT_SIZE;
1917
1918 8 memset(f->rc_stat, 0, sizeof(f->rc_stat));
1919
2/2
✓ Branch 0 taken 16 times.
✓ Branch 1 taken 8 times.
 24 for (i = 0; i < f->quant_table_count; i++)
1920 16 memset(f->rc_stat2[i], 0, f->context_count[i] * sizeof(*f->rc_stat2[i]));
1921
1922
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8 times.
 8 av_assert0(f->slice_count == f->max_slice_count);
1923
2/2
✓ Branch 0 taken 32 times.
✓ Branch 1 taken 8 times.
 40 for (j = 0; j < f->slice_count; j++) {
1924 32 const FFV1SliceContext *sc = &f->slices[j];
1925
2/2
✓ Branch 0 taken 8192 times.
✓ Branch 1 taken 32 times.
 8224 for (i = 0; i < 256; i++) {
1926 8192 f->rc_stat[i][0] += sc->rc_stat[i][0];
1927 8192 f->rc_stat[i][1] += sc->rc_stat[i][1];
1928 }
1929
2/2
✓ Branch 0 taken 64 times.
✓ Branch 1 taken 32 times.
 96 for (i = 0; i < f->quant_table_count; i++) {
1930
2/2
✓ Branch 0 taken 218512 times.
✓ Branch 1 taken 64 times.
 218576 for (k = 0; k < f->context_count[i]; k++)
1931
2/2
✓ Branch 0 taken 6992384 times.
✓ Branch 1 taken 218512 times.
 7210896 for (m = 0; m < 32; m++) {
1932 6992384 f->rc_stat2[i][k][m][0] += sc->rc_stat2[i][k][m][0];
1933 6992384 f->rc_stat2[i][k][m][1] += sc->rc_stat2[i][k][m][1];
1934 }
1935 }
1936 }
1937
1938
2/2
✓ Branch 0 taken 2048 times.
✓ Branch 1 taken 8 times.
 2056 for (j = 0; j < 256; j++) {
1939 2048 snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1940 f->rc_stat[j][0], f->rc_stat[j][1]);
1941 2048 p += strlen(p);
1942 }
1943 8 snprintf(p, end - p, "\n");
1944
1945
2/2
✓ Branch 0 taken 16 times.
✓ Branch 1 taken 8 times.
 24 for (i = 0; i < f->quant_table_count; i++) {
1946
2/2
✓ Branch 0 taken 54628 times.
✓ Branch 1 taken 16 times.
 54644 for (j = 0; j < f->context_count[i]; j++)
1947
2/2
✓ Branch 0 taken 1748096 times.
✓ Branch 1 taken 54628 times.
 1802724 for (m = 0; m < 32; m++) {
1948 1748096 snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",
1949 1748096 f->rc_stat2[i][j][m][0], f->rc_stat2[i][j][m][1]);
1950 1748096 p += strlen(p);
1951 }
1952 }
1953 8 snprintf(p, end - p, "%d\n", f->gob_count);
1954 }
1955 51 return 0;
1956 }
1957
1958 /* Maximum packet size */
1959 2480 maxsize = ff_ffv1_encode_buffer_size(avctx);
1960
1961
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2480 times.
 2480 if (maxsize > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE - 32) {
1962 ✗ FFV1Context *f = avctx->priv_data;
1963 ✗ if (!f->maxsize_warned) {
1964 ✗ av_log(avctx, AV_LOG_WARNING, "Cannot allocate worst case packet size, the encoding could fail\n");
1965 ✗ f->maxsize_warned++;
1966 }
1967 ✗ maxsize = INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE - 32;
1968 }
1969
1970
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2480 times.
 2480 if ((ret = ff_alloc_packet(avctx, pkt, maxsize)) < 0)
1971 ✗ return ret;
1972
1973 2480 ff_init_range_encoder(c, pkt->data, pkt->size);
1974 2480 ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
1975
1976 2480 f->cur_enc_frame = pict;
1977
1978
3/4
✓ Branch 0 taken 2480 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 249 times.
✓ Branch 3 taken 2231 times.
 2480 if (avctx->gop_size == 0 || f->picture_number % avctx->gop_size == 0) {
1979 249 put_rac(c, &keystate, 1);
1980 249 f->key_frame = 1;
1981 249 f->gob_count++;
1982 249 write_header(f);
1983 } else {
1984 2231 put_rac(c, &keystate, 0);
1985 2231 f->key_frame = 0;
1986 }
1987
1988
2/2
✓ Branch 0 taken 1405 times.
✓ Branch 1 taken 1075 times.
 2480 if (f->ac == AC_RANGE_CUSTOM_TAB) {
1989 int i;
1990
2/2
✓ Branch 0 taken 358275 times.
✓ Branch 1 taken 1405 times.
 359680 for (i = 1; i < 256; i++) {
1991 358275 c->one_state[i] = f->state_transition[i];
1992 358275 c->zero_state[256 - i] = 256 - c->one_state[i];
1993 }
1994 }
1995
1996
2/2
✓ Branch 0 taken 9345 times.
✓ Branch 1 taken 2480 times.
 11825 for (i = 0; i < f->slice_count; i++) {
1997 9345 FFV1SliceContext *sc = &f->slices[i];
1998 9345 uint8_t *start = pkt->data + pkt->size * (int64_t)i / f->slice_count;
1999 9345 int len = pkt->size / f->slice_count;
2000
2/2
✓ Branch 0 taken 6865 times.
✓ Branch 1 taken 2480 times.
 9345 if (i) {
2001 6865 ff_init_range_encoder(&sc->c, start, len);
2002 } else {
2003
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2480 times.
 2480 av_assert0(sc->c.bytestream_end >= sc->c.bytestream_start + len);
2004
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2480 times.
 2480 av_assert0(sc->c.bytestream < sc->c.bytestream_start + len);
2005 2480 sc->c.bytestream_end = sc->c.bytestream_start + len;
2006 }
2007 }
2008 2480 avctx->execute(avctx, encode_slice, f->slices, NULL,
2009 f->slice_count, sizeof(*f->slices));
2010
2011 2480 buf_p = pkt->data;
2012
2/2
✓ Branch 0 taken 9345 times.
✓ Branch 1 taken 2480 times.
 11825 for (i = 0; i < f->slice_count; i++) {
2013 9345 FFV1SliceContext *sc = &f->slices[i];
2014 9345 int bytes = sc->ac_byte_count;
2015
4/4
✓ Branch 0 taken 2480 times.
✓ Branch 1 taken 6865 times.
✓ Branch 2 taken 2080 times.
✓ Branch 3 taken 400 times.
 9345 if (i > 0 || f->version > 2) {
2016
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8945 times.
 8945 av_assert0(bytes < pkt->size / f->slice_count);
2017 8945 memmove(buf_p, sc->c.bytestream_start, bytes);
2018
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8945 times.
 8945 av_assert0(bytes < (1 << 24));
2019 8945 AV_WB24(buf_p + bytes, bytes);
2020 8945 bytes += 3;
2021 }
2022
2/2
✓ Branch 0 taken 8345 times.
✓ Branch 1 taken 1000 times.
 9345 if (f->ec) {
2023 unsigned v;
2024 8345 buf_p[bytes++] = 0;
2025
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 8345 times.
 8345 v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), f->crcref, buf_p, bytes) ^ (f->crcref ? 0x8CD88196 : 0);
2026 8345 AV_WL32(buf_p + bytes, v);
2027 8345 bytes += 4;
2028 }
2029 9345 buf_p += bytes;
2030 }
2031
2032
2/2
✓ Branch 0 taken 400 times.
✓ Branch 1 taken 2080 times.
 2480 if (avctx->flags & AV_CODEC_FLAG_PASS1)
2033 400 avctx->stats_out[0] = '\0';
2034
2035 2480 f->picture_number++;
2036 2480 pkt->size = buf_p - pkt->data;
2037 2480 pkt->flags |= AV_PKT_FLAG_KEY * f->key_frame;
2038 2480 *got_packet = 1;
2039
2040 2480 return 0;
2041 }
2042
2043 51 static av_cold int encode_close(AVCodecContext *avctx)
2044 {
2045 51 FFV1Context *const s = avctx->priv_data;
2046
2047
2/2
✓ Branch 0 taken 197 times.
✓ Branch 1 taken 51 times.
 248 for (int j = 0; j < s->max_slice_count; j++) {
2048 197 FFV1SliceContext *sc = &s->slices[j];
2049
2050
2/2
✓ Branch 0 taken 788 times.
✓ Branch 1 taken 197 times.
 985 for(int p = 0; p<4; p++) {
2051 788 av_freep(&sc->unit[p]);
2052 788 av_freep(&sc->bitmap[p]);
2053 }
2054 }
2055
2056 51 av_freep(&avctx->stats_out);
2057 51 ff_ffv1_close(s);
2058
2059 51 return 0;
2060 }
2061
2062 #define OFFSET(x) offsetof(FFV1Context, x)
2063 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
2064 static const AVOption options[] = {
2065 { "slicecrc", "Protect slices with CRCs", OFFSET(ec), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 2, VE },
2066 { "coder", "Coder type", OFFSET(ac), AV_OPT_TYPE_INT,
2067 { .i64 = 0 }, -2, 2, VE, .unit = "coder" },
2068 { "rice", "Golomb rice", 0, AV_OPT_TYPE_CONST,
2069 { .i64 = AC_GOLOMB_RICE }, INT_MIN, INT_MAX, VE, .unit = "coder" },
2070 { "range_def", "Range with default table", 0, AV_OPT_TYPE_CONST,
2071 { .i64 = AC_RANGE_DEFAULT_TAB_FORCE }, INT_MIN, INT_MAX, VE, .unit = "coder" },
2072 { "range_tab", "Range with custom table", 0, AV_OPT_TYPE_CONST,
2073 { .i64 = AC_RANGE_CUSTOM_TAB }, INT_MIN, INT_MAX, VE, .unit = "coder" },
2074 { "ac", "Range with custom table (the ac option exists for compatibility and is deprecated)", 0, AV_OPT_TYPE_CONST,
2075 { .i64 = 1 }, INT_MIN, INT_MAX, VE, .unit = "coder" },
2076 { "context", "Context model", OFFSET(context_model), AV_OPT_TYPE_INT,
2077 { .i64 = 0 }, 0, 2, VE },
2078 { "qtable", "Quantization table", OFFSET(qtable), AV_OPT_TYPE_INT,
2079 { .i64 = -1 }, -1, 2, VE , .unit = "qtable"},
2080 { "default", NULL, 0, AV_OPT_TYPE_CONST,
2081 { .i64 = QTABLE_DEFAULT }, INT_MIN, INT_MAX, VE, .unit = "qtable" },
2082 { "8bit", NULL, 0, AV_OPT_TYPE_CONST,
2083 { .i64 = QTABLE_8BIT }, INT_MIN, INT_MAX, VE, .unit = "qtable" },
2084 { "greater8bit", NULL, 0, AV_OPT_TYPE_CONST,
2085 { .i64 = QTABLE_GT8BIT }, INT_MIN, INT_MAX, VE, .unit = "qtable" },
2086 { "remap_mode", "Remap Mode", OFFSET(remap_mode), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 2, VE, .unit = "remap_mode" },
2087 { "auto", "Automatic", 0, AV_OPT_TYPE_CONST,
2088 { .i64 = -1 }, INT_MIN, INT_MAX, VE, .unit = "remap_mode" },
2089 { "off", "Disabled", 0, AV_OPT_TYPE_CONST,
2090 { .i64 = 0 }, INT_MIN, INT_MAX, VE, .unit = "remap_mode" },
2091 { "dualrle", "Dual RLE", 0, AV_OPT_TYPE_CONST,
2092 { .i64 = 1 }, INT_MIN, INT_MAX, VE, .unit = "remap_mode" },
2093 { "flipdualrle", "Dual RLE", 0, AV_OPT_TYPE_CONST,
2094 { .i64 = 2 }, INT_MIN, INT_MAX, VE, .unit = "remap_mode" },
2095 { "remap_optimizer", "Remap Optimizer", OFFSET(remap_optimizer), AV_OPT_TYPE_INT, { .i64 = 3 }, 0, 5, VE, .unit = "remap_optimizer" },
2096
2097 { NULL }
2098 };
2099
2100 static const AVClass ffv1_class = {
2101 .class_name = "ffv1 encoder",
2102 .item_name = av_default_item_name,
2103 .option = options,
2104 .version = LIBAVUTIL_VERSION_INT,
2105 };
2106
2107 const FFCodec ff_ffv1_encoder = {
2108 .p.name = "ffv1",
2109 CODEC_LONG_NAME("FFmpeg video codec #1"),
2110 .p.type = AVMEDIA_TYPE_VIDEO,
2111 .p.id = AV_CODEC_ID_FFV1,
2112 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |
2113 AV_CODEC_CAP_SLICE_THREADS |
2114 AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
2115 .priv_data_size = sizeof(FFV1Context),
2116 .init = encode_init_internal,
2117 FF_CODEC_ENCODE_CB(encode_frame),
2118 .close = encode_close,
2119 CODEC_PIXFMTS(
2120 AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV444P,
2121 AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV411P,
2122 AV_PIX_FMT_YUV410P, AV_PIX_FMT_0RGB32, AV_PIX_FMT_RGB32, AV_PIX_FMT_YUV420P16,
2123 AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16, AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV422P9,
2124 AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
2125 AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12,
2126 AV_PIX_FMT_YUVA444P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA420P16,
2127 AV_PIX_FMT_YUVA444P12, AV_PIX_FMT_YUVA422P12,
2128 AV_PIX_FMT_YUVA444P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA420P10,
2129 AV_PIX_FMT_YUVA444P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA420P9,
2130 AV_PIX_FMT_GRAY16, AV_PIX_FMT_GRAY8, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
2131 AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14, AV_PIX_FMT_GBRAP14,
2132 AV_PIX_FMT_GBRAP10, AV_PIX_FMT_GBRAP12,
2133 AV_PIX_FMT_YA8,
2134 AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY12, AV_PIX_FMT_GRAY14,
2135 AV_PIX_FMT_GBRP16, AV_PIX_FMT_RGB48,
2136 AV_PIX_FMT_GBRAP16, AV_PIX_FMT_RGBA64,
2137 AV_PIX_FMT_GRAY9,
2138 AV_PIX_FMT_YUV420P14, AV_PIX_FMT_YUV422P14, AV_PIX_FMT_YUV444P14,
2139 AV_PIX_FMT_YUV440P10, AV_PIX_FMT_YUV440P12,
2140 AV_PIX_FMT_YAF16,
2141 AV_PIX_FMT_GRAYF16,
2142 AV_PIX_FMT_GBRPF16, AV_PIX_FMT_GBRPF32,
2143 AV_PIX_FMT_BAYER_RGGB16),
2144 .color_ranges = AVCOL_RANGE_MPEG,
2145 .p.priv_class = &ffv1_class,
2146 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP | FF_CODEC_CAP_EOF_FLUSH,
2147 };
2148