FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavcodec/ffv1enc_template.c
Date: 2026-01-16 07:34:38
Exec Total Coverage
Lines: 101 154 65.6%
Functions: 2 4 50.0%
Branches: 34 58 58.6%
Line Branch Exec Source
1 /*
2 * FFV1 encoder template
3 *
4 * Copyright (c) 2003-2016 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 #include "ffv1_template.c"
24
25 static av_always_inline int
26 5505600 RENAME(encode_line)(FFV1Context *f, FFV1SliceContext *sc,
27 void *logctx,
28 int w, TYPE *const sample[3], int plane_index, int bits,
29 int ac, int pass1)
30 {
31 5505600 PlaneContext *const p = &sc->plane[plane_index];
32 5505600 RangeCoder *const c = &sc->c;
33 int x;
34 5505600 int run_index = sc->run_index;
35 5505600 int run_count = 0;
36 5505600 int run_mode = 0;
37
38
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2752800 times.
 5505600 if (bits == 0)
39 ✗ return 0;
40
41
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2752800 times.
 5505600 if (sc->slice_coding_mode == 1) {
42 ✗ av_assert0(ac != AC_GOLOMB_RICE);
43 ✗ if (c->bytestream_end - c->bytestream < (w * bits + 7LL)>>3) {
44 ✗ av_log(logctx, AV_LOG_ERROR, "encoded Range Coder frame too large\n");
45 ✗ return AVERROR_INVALIDDATA;
46 }
47
48 ✗ for (x = 0; x < w; x++) {
49 int i;
50 ✗ int v = sample[0][x];
51 ✗ for (i = bits-1; i>=0; i--) {
52 ✗ uint8_t state = 128;
53 ✗ put_rac(c, &state, (v>>i) & 1);
54 }
55 }
56 ✗ return 0;
57 }
58
59
2/2
✓ Branch 0 taken 1739000 times.
✓ Branch 1 taken 1013800 times.
 5505600 if (ac != AC_GOLOMB_RICE) {
60
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1739000 times.
 3478000 if (c->bytestream_end - c->bytestream < w * 35) {
61 ✗ av_log(logctx, AV_LOG_ERROR, "encoded Range Coder frame too large\n");
62 ✗ return AVERROR_INVALIDDATA;
63 }
64 } else {
65
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1013800 times.
 2027600 if (put_bytes_left(&sc->pb, 0) < w * 4) {
66 ✗ av_log(logctx, AV_LOG_ERROR, "encoded Golomb Rice frame too large\n");
67 ✗ return AVERROR_INVALIDDATA;
68 }
69 }
70
71
2/2
✓ Branch 0 taken 406350100 times.
✓ Branch 1 taken 2752800 times.
 818205800 for (x = 0; x < w; x++) {
72 int diff, context;
73
74 812700200 context = RENAME(get_context)(f->quant_tables[p->quant_table_index],
75 812700200 sample[0] + x, sample[1] + x, sample[2] + x);
76 812700200 diff = sample[0][x] - RENAME(predict)(sample[0] + x, sample[1] + x);
77
78
2/2
✓ Branch 0 taken 184040154 times.
✓ Branch 1 taken 222309946 times.
 812700200 if (context < 0) {
79 368080308 context = -context;
80 368080308 diff = -diff;
81 }
82
83 812700200 diff = fold(diff, bits);
84
85
2/2
✓ Branch 0 taken 238203400 times.
✓ Branch 1 taken 168146700 times.
 812700200 if (ac != AC_GOLOMB_RICE) {
86
2/2
✓ Branch 0 taken 53431600 times.
✓ Branch 1 taken 184771800 times.
 476406800 if (pass1) {
87 106863200 put_symbol_inline(c, p->state[context], diff, 1, sc->rc_stat,
88 106863200 sc->rc_stat2[p->quant_table_index][context]);
89 } else {
90 369543600 put_symbol_inline(c, p->state[context], diff, 1, NULL, NULL);
91 }
92 } else {
93
2/2
✓ Branch 0 taken 3890915 times.
✓ Branch 1 taken 164255785 times.
 336293400 if (context == 0)
94 7781830 run_mode = 1;
95
96
2/2
✓ Branch 0 taken 6062596 times.
✓ Branch 1 taken 162084104 times.
 336293400 if (run_mode) {
97
2/2
✓ Branch 0 taken 1575887 times.
✓ Branch 1 taken 4486709 times.
 12125192 if (diff) {
98
2/2
✓ Branch 0 taken 1413677 times.
✓ Branch 1 taken 1575887 times.
 5979128 while (run_count >= 1 << ff_log2_run[run_index]) {
99 2827354 run_count -= 1 << ff_log2_run[run_index];
100 2827354 run_index++;
101 2827354 put_bits(&sc->pb, 1, 1);
102 }
103
104 3151774 put_bits(&sc->pb, 1 + ff_log2_run[run_index], run_count);
105
2/2
✓ Branch 0 taken 1439479 times.
✓ Branch 1 taken 136408 times.
 3151774 if (run_index)
106 2878958 run_index--;
107 3151774 run_count = 0;
108 3151774 run_mode = 0;
109
2/2
✓ Branch 0 taken 740677 times.
✓ Branch 1 taken 835210 times.
 3151774 if (diff > 0)
110 1481354 diff--;
111 } else {
112 8973418 run_count++;
113 }
114 }
115
116 ff_dlog(logctx, "count:%d index:%d, mode:%d, x:%d pos:%d\n",
117 run_count, run_index, run_mode, x,
118 (int)put_bits_count(&sc->pb));
119
120
2/2
✓ Branch 0 taken 163659991 times.
✓ Branch 1 taken 4486709 times.
 336293400 if (run_mode == 0)
121 327319982 put_vlc_symbol(&sc->pb, &p->vlc_state[context], diff, bits);
122 }
123 }
124
2/2
✓ Branch 0 taken 57502 times.
✓ Branch 1 taken 2695298 times.
 5505600 if (run_mode) {
125
2/2
✓ Branch 0 taken 43475 times.
✓ Branch 1 taken 57502 times.
 201954 while (run_count >= 1 << ff_log2_run[run_index]) {
126 86950 run_count -= 1 << ff_log2_run[run_index];
127 86950 run_index++;
128 86950 put_bits(&sc->pb, 1, 1);
129 }
130
131
2/2
✓ Branch 0 taken 37708 times.
✓ Branch 1 taken 19794 times.
 115004 if (run_count)
132 75416 put_bits(&sc->pb, 1, 1);
133 }
134 5505600 sc->run_index = run_index;
135
136 5505600 return 0;
137 }
138
139 ✗ static void RENAME(load_rgb_frame)(FFV1Context *f, FFV1SliceContext *sc,
140 const uint8_t *src[4],
141 int w, int h, const int stride[4])
142 {
143 int x, y;
144 ✗ int transparency = f->transparency;
145
146 ✗ for (int p = 0; p<3 + transparency; p++)
147 ✗ memset(sc->fltmap[p], 0, 65536 * sizeof(**sc->fltmap));
148
149 ✗ for (y = 0; y < h; y++) {
150 ✗ for (x = 0; x < w; x++) {
151 ✗ int b, g, r, av_uninit(a);
152
153 ✗ if (sizeof(TYPE) == 4 || transparency) {
154 ✗ g = *((const uint16_t *)(src[0] + x*2 + stride[0]*y));
155 ✗ b = *((const uint16_t *)(src[1] + x*2 + stride[1]*y));
156 ✗ r = *((const uint16_t *)(src[2] + x*2 + stride[2]*y));
157 ✗ if (transparency)
158 ✗ a = *((const uint16_t *)(src[3] + x*2 + stride[3]*y));
159 } else {
160 ✗ b = *((const uint16_t *)(src[0] + x*2 + stride[0]*y));
161 ✗ g = *((const uint16_t *)(src[1] + x*2 + stride[1]*y));
162 ✗ r = *((const uint16_t *)(src[2] + x*2 + stride[2]*y));
163 }
164
165 ✗ sc->fltmap[0][g] = 1;
166 ✗ sc->fltmap[1][b] = 1;
167 ✗ sc->fltmap[2][r] = 1;
168 ✗ if (transparency)
169 ✗ sc->fltmap[3][a] = 1;
170 }
171 }
172 ✗ }
173
174 1600 static int RENAME(encode_rgb_frame)(FFV1Context *f, FFV1SliceContext *sc,
175 const uint8_t *src[4],
176 int w, int h, const int stride[4], int ac)
177 {
178 int x, y, p, i;
179 1600 const int ring_size = f->context_model ? 3 : 2;
180 TYPE *sample[4][3];
181 1600 const int pass1 = !!(f->avctx->flags & AV_CODEC_FLAG_PASS1);
182 1600 int lbd = f->bits_per_raw_sample <= 8;
183 1600 int packed = !src[1];
184 int bits[4], offset;
185 1600 int transparency = f->transparency;
186 1600 int packed_size = (3 + transparency)*2;
187
188 1600 ff_ffv1_compute_bits_per_plane(f, sc, bits, &offset, NULL, f->bits_per_raw_sample);
189
190 1600 sc->run_index = 0;
191
192 8000 for (int p = 0; p < MAX_PLANES; ++p)
193 6400 sample[p][2] = RENAME(sc->sample_buffer);
194
195 1600 memset(RENAME(sc->sample_buffer), 0, ring_size * MAX_PLANES *
196 1600 (w + 6) * sizeof(*RENAME(sc->sample_buffer)));
197
198 181200 for (y = 0; y < h; y++) {
199 538800 for (i = 0; i < ring_size; i++)
200 1796000 for (p = 0; p < MAX_PLANES; p++)
201 1436800 sample[p][i]= RENAME(sc->sample_buffer) + p*ring_size*(w+6) + ((h+i-y)%ring_size)*(w+6) + 3;
202
203 30708000 for (x = 0; x < w; x++) {
204 30528400 int b, g, r, av_uninit(a);
205 30528400 if (lbd) {
206 15264200 unsigned v = *((const uint32_t*)(src[0] + x*4 + stride[0]*y));
207 15264200 b = v & 0xFF;
208 15264200 g = (v >> 8) & 0xFF;
209 15264200 r = (v >> 16) & 0xFF;
210 15264200 a = v >> 24;
211 15264200 } else if (packed) {
212 15264200 const uint16_t *p = ((const uint16_t*)(src[0] + x*packed_size + stride[0]*y));
213 15264200 r = p[0];
214 15264200 g = p[1];
215 15264200 b = p[2];
216 15264200 if (transparency)
217 ✗ a = p[3];
218 ✗ } else if (sizeof(TYPE) == 4 || transparency) {
219 ✗ g = *((const uint16_t *)(src[0] + x*2 + stride[0]*y));
220 ✗ b = *((const uint16_t *)(src[1] + x*2 + stride[1]*y));
221 ✗ r = *((const uint16_t *)(src[2] + x*2 + stride[2]*y));
222 ✗ if (transparency)
223 ✗ a = *((const uint16_t *)(src[3] + x*2 + stride[3]*y));
224 } else {
225 ✗ b = *((const uint16_t *)(src[0] + x*2 + stride[0]*y));
226 ✗ g = *((const uint16_t *)(src[1] + x*2 + stride[1]*y));
227 ✗ r = *((const uint16_t *)(src[2] + x*2 + stride[2]*y));
228 }
229
230 30528400 if (sc->remap) {
231 ✗ g = sc->fltmap[0][g];
232 ✗ b = sc->fltmap[1][b];
233 ✗ r = sc->fltmap[2][r];
234 ✗ if (transparency)
235 ✗ a = sc->fltmap[3][a];
236 }
237
238 30528400 if (sc->slice_coding_mode != 1) {
239 30528400 b -= g;
240 30528400 r -= g;
241 30528400 g += (b * sc->slice_rct_by_coef + r * sc->slice_rct_ry_coef) >> 2;
242 30528400 b += offset;
243 30528400 r += offset;
244 }
245
246 30528400 sample[0][0][x] = g;
247 30528400 sample[1][0][x] = b;
248 30528400 sample[2][0][x] = r;
249 30528400 sample[3][0][x] = a;
250 }
251 718400 for (p = 0; p < 3 + transparency; p++) {
252 int ret;
253 538800 sample[p][0][-1] = sample[p][1][0 ];
254 538800 sample[p][1][ w] = sample[p][1][w-1];
255 538800 if (bits[p] == 9)
256 269400 ret = RENAME(encode_line)(f, sc, f->avctx, w, sample[p], (p + 1) / 2, 9, ac, pass1);
257 else
258 269400 ret = RENAME(encode_line)(f, sc, f->avctx, w, sample[p], (p + 1) / 2,
259 bits[p], ac, pass1);
260 538800 if (ret < 0)
261 ✗ return ret;
262 }
263 }
264 1600 return 0;
265 }
266