FFmpeg coverage

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