FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavfilter/vf_thumbnail.c
Date: 2026-04-19 20:43:40
Exec Total Coverage
Lines: 134 189 70.9%
Functions: 10 11 90.9%
Branches: 66 104 63.5%
Line Branch Exec Source
1 /*
2 * Copyright (c) 2011 Smartjog S.A.S, Clément Bœsch <clement.boesch@smartjog.com>
3 *
4 * This file is part of FFmpeg.
5 *
6 * FFmpeg is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * FFmpeg is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with FFmpeg; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19 */
20
21 /**
22 * @file
23 * Potential thumbnail lookup filter to reduce the risk of an inappropriate
24 * selection (such as a black frame) we could get with an absolute seek.
25 *
26 * Simplified version of algorithm by Vadim Zaliva <lord@crocodile.org>.
27 * @see http://notbrainsurgery.livejournal.com/29773.html
28 */
29
30 #include "libavutil/intreadwrite.h"
31 #include "libavutil/mem.h"
32 #include "libavutil/opt.h"
33 #include "libavutil/pixdesc.h"
34 #include "avfilter.h"
35 #include "filters.h"
36 #include "formats.h"
37
38 #define HIST_SIZE (3*256)
39
40 struct thumb_frame {
41 AVFrame *buf; ///< cached frame
42 int histogram[HIST_SIZE]; ///< RGB color distribution histogram of the frame
43 };
44
45 typedef struct ThumbContext {
46 const AVClass *class;
47 int n; ///< current frame
48 int loglevel;
49 int n_frames; ///< number of frames for analysis
50 struct thumb_frame *frames; ///< the n_frames frames
51 AVRational tb; ///< copy of the input timebase to ease access
52
53 int nb_threads;
54 int *thread_histogram;
55
56 int planewidth[4];
57 int planeheight[4];
58 int planes;
59 int bitdepth;
60 } ThumbContext;
61
62 #define OFFSET(x) offsetof(ThumbContext, x)
63 #define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
64
65 static const AVOption thumbnail_options[] = {
66 { "n", "set the frames batch size", OFFSET(n_frames), AV_OPT_TYPE_INT, {.i64=100}, 2, INT_MAX, FLAGS },
67 { "log", "force stats logging level", OFFSET(loglevel), AV_OPT_TYPE_INT, {.i64 = AV_LOG_INFO}, INT_MIN, INT_MAX, FLAGS, .unit = "level" },
68 { "quiet", "logging disabled", 0, AV_OPT_TYPE_CONST, {.i64 = AV_LOG_QUIET}, 0, 0, FLAGS, .unit = "level" },
69 { "info", "information logging level", 0, AV_OPT_TYPE_CONST, {.i64 = AV_LOG_INFO}, 0, 0, FLAGS, .unit = "level" },
70 { "verbose", "verbose logging level", 0, AV_OPT_TYPE_CONST, {.i64 = AV_LOG_VERBOSE}, 0, 0, FLAGS, .unit = "level" },
71 { NULL }
72 };
73
74 AVFILTER_DEFINE_CLASS(thumbnail);
75
76 2 static av_cold int init(AVFilterContext *ctx)
77 {
78 2 ThumbContext *s = ctx->priv;
79
80 2 s->frames = av_calloc(s->n_frames, sizeof(*s->frames));
81
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 if (!s->frames) {
82 ✗ av_log(ctx, AV_LOG_ERROR,
83 "Allocation failure, try to lower the number of frames\n");
84 ✗ return AVERROR(ENOMEM);
85 }
86 2 av_log(ctx, AV_LOG_VERBOSE, "batch size: %d frames\n", s->n_frames);
87 2 return 0;
88 }
89
90 /**
91 * @brief Compute Sum-square deviation to estimate "closeness".
92 * @param hist color distribution histogram
93 * @param median average color distribution histogram
94 * @return sum of squared errors
95 */
96 50 static double frame_sum_square_err(const int *hist, const double *median)
97 {
98 int i;
99 50 double err, sum_sq_err = 0;
100
101
2/2
✓ Branch 0 taken 38400 times.
✓ Branch 1 taken 50 times.
 38450 for (i = 0; i < HIST_SIZE; i++) {
102 38400 err = median[i] - (double)hist[i];
103 38400 sum_sq_err += err*err;
104 }
105 50 return sum_sq_err;
106 }
107
108 5 static AVFrame *get_best_frame(AVFilterContext *ctx)
109 {
110 AVFrame *picref;
111 5 ThumbContext *s = ctx->priv;
112 5 int i, j, best_frame_idx = 0;
113 5 int nb_frames = s->n;
114 5 double avg_hist[HIST_SIZE] = {0}, sq_err, min_sq_err = -1;
115
116 // average histogram of the N frames
117
2/2
✓ Branch 0 taken 3840 times.
✓ Branch 1 taken 5 times.
 3845 for (j = 0; j < FF_ARRAY_ELEMS(avg_hist); j++) {
118
2/2
✓ Branch 0 taken 38400 times.
✓ Branch 1 taken 3840 times.
 42240 for (i = 0; i < nb_frames; i++)
119 38400 avg_hist[j] += (double)s->frames[i].histogram[j];
120 3840 avg_hist[j] /= nb_frames;
121 }
122
123 // find the frame closer to the average using the sum of squared errors
124
2/2
✓ Branch 0 taken 50 times.
✓ Branch 1 taken 5 times.
 55 for (i = 0; i < nb_frames; i++) {
125 50 sq_err = frame_sum_square_err(s->frames[i].histogram, avg_hist);
126
4/4
✓ Branch 0 taken 45 times.
✓ Branch 1 taken 5 times.
✓ Branch 2 taken 12 times.
✓ Branch 3 taken 33 times.
 50 if (i == 0 || sq_err < min_sq_err)
127 17 best_frame_idx = i, min_sq_err = sq_err;
128 }
129
130 // free and reset everything (except the best frame buffer)
131
2/2
✓ Branch 0 taken 50 times.
✓ Branch 1 taken 5 times.
 55 for (i = 0; i < nb_frames; i++) {
132 50 memset(s->frames[i].histogram, 0, sizeof(s->frames[i].histogram));
133
2/2
✓ Branch 0 taken 45 times.
✓ Branch 1 taken 5 times.
 50 if (i != best_frame_idx)
134 45 av_frame_free(&s->frames[i].buf);
135 }
136 5 s->n = 0;
137
138 // raise the chosen one
139 5 picref = s->frames[best_frame_idx].buf;
140
1/2
✓ Branch 0 taken 5 times.
✗ Branch 1 not taken.
 5 if (s->loglevel != AV_LOG_QUIET)
141 5 av_log(ctx, s->loglevel, "frame id #%d (pts_time=%f) selected "
142 "from a set of %d images\n", best_frame_idx,
143 5 picref->pts * av_q2d(s->tb), nb_frames);
144 5 s->frames[best_frame_idx].buf = NULL;
145
146 5 return picref;
147 }
148
149 150 static void get_hist8(int *hist, const uint8_t *p, ptrdiff_t stride,
150 ptrdiff_t width, ptrdiff_t height)
151 {
152 150 int shist[4][256] = {0};
153
154 150 const int width4 = width & ~3;
155
2/2
✓ Branch 0 taken 28800 times.
✓ Branch 1 taken 150 times.
 28950 while (height--) {
156
2/2
✓ Branch 0 taken 1900800 times.
✓ Branch 1 taken 28800 times.
 1929600 for (int x = 0; x < width4; x += 4) {
157 1900800 const uint32_t v = AV_RN32(&p[x]);
158 1900800 shist[0][(uint8_t) (v >> 0)]++;
159 1900800 shist[1][(uint8_t) (v >> 8)]++;
160 1900800 shist[2][(uint8_t) (v >> 16)]++;
161 1900800 shist[3][(uint8_t) (v >> 24)]++;
162 }
163 /* handle tail */
164
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 28800 times.
 28800 for (int x = width4; x < width; x++)
165 ✗ hist[p[x]]++;
166 28800 p += stride;
167 }
168
169
2/2
✓ Branch 0 taken 600 times.
✓ Branch 1 taken 150 times.
 750 for (int i = 0; i < 4; i++) {
170
2/2
✓ Branch 0 taken 153600 times.
✓ Branch 1 taken 600 times.
 154200 for (int j = 0; j < 256; j++)
171 153600 hist[j] += shist[i][j];
172 }
173 150 }
174
175 ✗ static void get_hist16(int *hist, const uint8_t *p, ptrdiff_t stride,
176 ptrdiff_t width, ptrdiff_t height, int shift)
177 {
178 ✗ int shist[4][256] = {0};
179
180 ✗ const int width4 = width & ~3;
181 ✗ while (height--) {
182 ✗ const uint16_t *p16 = (const uint16_t *) p;
183 ✗ for (int x = 0; x < width4; x += 4) {
184 ✗ const uint64_t v = AV_RN64(&p16[x]);
185 ✗ shist[0][(uint8_t) (v >> (shift + 0))]++;
186 ✗ shist[1][(uint8_t) (v >> (shift + 16))]++;
187 ✗ shist[2][(uint8_t) (v >> (shift + 32))]++;
188 ✗ shist[3][(uint8_t) (v >> (shift + 48))]++;
189 }
190 /* handle tail */
191 ✗ for (int x = width4; x < width; x++)
192 ✗ hist[(uint8_t) (p16[x] >> shift)]++;
193 ✗ p += stride;
194 }
195
196 ✗ for (int i = 0; i < 4; i++) {
197 ✗ for (int j = 0; j < 256; j++)
198 ✗ hist[j] += shist[i][j];
199 }
200 ✗ }
201
202 50 static int do_slice(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
203 {
204 50 ThumbContext *s = ctx->priv;
205 50 AVFrame *frame = arg;
206 50 int *hist = s->thread_histogram + HIST_SIZE * jobnr;
207 50 const int h = frame->height;
208 50 const int w = frame->width;
209 50 const int slice_start = (h * jobnr) / nb_jobs;
210 50 const int slice_end = (h * (jobnr+1)) / nb_jobs;
211 50 const uint8_t *p = frame->data[0] + slice_start * frame->linesize[0];
212
213 50 memset(hist, 0, sizeof(*hist) * HIST_SIZE);
214
215
1/4
✗ Branch 0 not taken.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 50 times.
 50 switch (frame->format) {
216 ✗ case AV_PIX_FMT_RGB24:
217 case AV_PIX_FMT_BGR24:
218 ✗ for (int j = slice_start; j < slice_end; j++) {
219 ✗ for (int i = 0; i < w; i++) {
220 ✗ hist[0*256 + p[i*3 ]]++;
221 ✗ hist[1*256 + p[i*3 + 1]]++;
222 ✗ hist[2*256 + p[i*3 + 2]]++;
223 }
224 ✗ p += frame->linesize[0];
225 }
226 ✗ break;
227 ✗ case AV_PIX_FMT_RGB0:
228 case AV_PIX_FMT_BGR0:
229 case AV_PIX_FMT_RGBA:
230 case AV_PIX_FMT_BGRA:
231 ✗ for (int j = slice_start; j < slice_end; j++) {
232 ✗ for (int i = 0; i < w; i++) {
233 ✗ hist[0*256 + p[i*4 ]]++;
234 ✗ hist[1*256 + p[i*4 + 1]]++;
235 ✗ hist[2*256 + p[i*4 + 2]]++;
236 }
237 ✗ p += frame->linesize[0];
238 }
239 ✗ break;
240 ✗ case AV_PIX_FMT_0RGB:
241 case AV_PIX_FMT_0BGR:
242 case AV_PIX_FMT_ARGB:
243 case AV_PIX_FMT_ABGR:
244 ✗ for (int j = slice_start; j < slice_end; j++) {
245 ✗ for (int i = 0; i < w; i++) {
246 ✗ hist[0*256 + p[i*4 + 1]]++;
247 ✗ hist[1*256 + p[i*4 + 2]]++;
248 ✗ hist[2*256 + p[i*4 + 3]]++;
249 }
250 ✗ p += frame->linesize[0];
251 }
252 ✗ break;
253 50 default:
254
2/2
✓ Branch 0 taken 150 times.
✓ Branch 1 taken 50 times.
 200 for (int plane = 0; plane < s->planes; plane++) {
255 150 const int slice_start = (s->planeheight[plane] * jobnr) / nb_jobs;
256 150 const int slice_end = (s->planeheight[plane] * (jobnr+1)) / nb_jobs;
257 150 const uint8_t *p = frame->data[plane] + slice_start * frame->linesize[plane];
258 150 const ptrdiff_t linesize = frame->linesize[plane];
259 150 const int planewidth = s->planewidth[plane];
260 150 int *hhist = hist + 256 * plane;
261
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 150 times.
 150 if (s->bitdepth > 8) {
262 ✗ get_hist16(hhist, p, linesize, planewidth, slice_end - slice_start,
263 ✗ s->bitdepth - 8);
264 } else {
265 150 get_hist8(hhist, p, linesize, planewidth, slice_end - slice_start);
266 }
267 }
268 50 break;
269 }
270
271 50 return 0;
272 }
273
274 50 static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
275 {
276 50 AVFilterContext *ctx = inlink->dst;
277 50 ThumbContext *s = ctx->priv;
278 50 AVFilterLink *outlink = ctx->outputs[0];
279 50 int *hist = s->frames[s->n].histogram;
280
281 // keep a reference of each frame
282 50 s->frames[s->n].buf = frame;
283
284 50 ff_filter_execute(ctx, do_slice, frame, NULL,
285 50 FFMIN(frame->height, s->nb_threads));
286
287 // update current frame histogram
288
2/2
✓ Branch 0 taken 50 times.
✓ Branch 1 taken 50 times.
 100 for (int j = 0; j < FFMIN(frame->height, s->nb_threads); j++) {
289 50 int *thread_histogram = s->thread_histogram + HIST_SIZE * j;
290
291
2/2
✓ Branch 0 taken 38400 times.
✓ Branch 1 taken 50 times.
 38450 for (int i = 0; i < HIST_SIZE; i++)
292 38400 hist[i] += thread_histogram[i];
293 }
294
295 // no selection until the buffer of N frames is filled up
296 50 s->n++;
297
2/2
✓ Branch 0 taken 45 times.
✓ Branch 1 taken 5 times.
 50 if (s->n < s->n_frames)
298 45 return 0;
299
300 5 return ff_filter_frame(outlink, get_best_frame(ctx));
301 }
302
303 2 static av_cold void uninit(AVFilterContext *ctx)
304 {
305 int i;
306 2 ThumbContext *s = ctx->priv;
307
3/6
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 2 times.
 2 for (i = 0; i < s->n_frames && s->frames && s->frames[i].buf; i++)
308 ✗ av_frame_free(&s->frames[i].buf);
309 2 av_freep(&s->frames);
310 2 av_freep(&s->thread_histogram);
311 2 }
312
313 95 static int request_frame(AVFilterLink *link)
314 {
315 95 AVFilterContext *ctx = link->src;
316 95 ThumbContext *s = ctx->priv;
317 95 int ret = ff_request_frame(ctx->inputs[0]);
318
319
3/4
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 94 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 1 times.
 95 if (ret == AVERROR_EOF && s->n) {
320 ✗ ret = ff_filter_frame(link, get_best_frame(ctx));
321 ✗ if (ret < 0)
322 ✗ return ret;
323 ✗ ret = AVERROR_EOF;
324 }
325
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 94 times.
 95 if (ret < 0)
326 1 return ret;
327 94 return 0;
328 }
329
330 1 static int config_props(AVFilterLink *inlink)
331 {
332 1 AVFilterContext *ctx = inlink->dst;
333 1 ThumbContext *s = ctx->priv;
334 1 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
335
336 1 s->nb_threads = ff_filter_get_nb_threads(ctx);
337 1 s->thread_histogram = av_calloc(HIST_SIZE, s->nb_threads * sizeof(*s->thread_histogram));
338
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 if (!s->thread_histogram)
339 ✗ return AVERROR(ENOMEM);
340
341 1 s->tb = inlink->time_base;
342 1 s->planewidth[1] = s->planewidth[2] = AV_CEIL_RSHIFT(inlink->w, desc->log2_chroma_w);
343 1 s->planewidth[0] = s->planewidth[3] = inlink->w;
344 1 s->planeheight[1] = s->planeheight[2] = AV_CEIL_RSHIFT(inlink->h, desc->log2_chroma_h);
345 1 s->planeheight[0] = s->planeheight[3] = inlink->h;
346 1 s->planes = av_pix_fmt_count_planes(inlink->format) - !!(desc->flags & AV_PIX_FMT_FLAG_ALPHA);
347 1 s->bitdepth = desc->comp[0].depth;
348
349 1 return 0;
350 }
351
352 static const enum AVPixelFormat packed_rgb_fmts[] = {
353 AV_PIX_FMT_RGB24, AV_PIX_FMT_BGR24,
354 AV_PIX_FMT_RGBA, AV_PIX_FMT_BGRA,
355 AV_PIX_FMT_RGB0, AV_PIX_FMT_BGR0,
356 AV_PIX_FMT_ABGR, AV_PIX_FMT_ARGB,
357 AV_PIX_FMT_0BGR, AV_PIX_FMT_0RGB,
358 AV_PIX_FMT_NONE
359 };
360
361 1 static int query_formats(const AVFilterContext *ctx,
362 AVFilterFormatsConfig **cfg_in,
363 AVFilterFormatsConfig **cfg_out)
364 {
365 1 const AVPixFmtDescriptor *desc = NULL;
366 AVFilterFormats *formats;
367
368 1 formats = ff_make_pixel_format_list(packed_rgb_fmts);
369
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 if (!formats)
370 ✗ return AVERROR(ENOMEM);
371
372
373
2/2
✓ Branch 1 taken 267 times.
✓ Branch 2 taken 1 times.
 268 while ((desc = av_pix_fmt_desc_next(desc))) {
374 267 int color_comps = desc->nb_components - !!(desc->flags & AV_PIX_FMT_FLAG_ALPHA);
375
4/4
✓ Branch 0 taken 241 times.
✓ Branch 1 taken 26 times.
✓ Branch 2 taken 133 times.
✓ Branch 3 taken 108 times.
 267 if ((color_comps == 1 || (desc->flags & AV_PIX_FMT_FLAG_PLANAR)) &&
376
2/2
✓ Branch 0 taken 141 times.
✓ Branch 1 taken 18 times.
 159 !(desc->flags & (AV_PIX_FMT_FLAG_FLOAT | AV_PIX_FMT_FLAG_BITSTREAM)) &&
377
4/4
✓ Branch 0 taken 118 times.
✓ Branch 1 taken 23 times.
✓ Branch 2 taken 59 times.
✓ Branch 3 taken 59 times.
 141 (desc->comp[0].depth <= 8 || HAVE_BIGENDIAN == !!(desc->flags & AV_PIX_FMT_FLAG_BE)) &&
378
4/4
✓ Branch 0 taken 73 times.
✓ Branch 1 taken 9 times.
✓ Branch 2 taken 58 times.
✓ Branch 3 taken 15 times.
 82 (desc->nb_components < 3 || desc->comp[1].plane != desc->comp[2].plane) &&
379
2/2
✓ Branch 0 taken 65 times.
✓ Branch 1 taken 2 times.
 67 desc->comp[0].depth <= 16)
380 {
381 65 int ret = ff_add_format(&formats, av_pix_fmt_desc_get_id(desc));
382
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 65 times.
 65 if (ret < 0)
383 ✗ return ret;
384 }
385 }
386
387 1 return ff_set_common_formats2(ctx, cfg_in, cfg_out, formats);
388 }
389
390 static const AVFilterPad thumbnail_inputs[] = {
391 {
392 .name = "default",
393 .type = AVMEDIA_TYPE_VIDEO,
394 .config_props = config_props,
395 .filter_frame = filter_frame,
396 },
397 };
398
399 static const AVFilterPad thumbnail_outputs[] = {
400 {
401 .name = "default",
402 .type = AVMEDIA_TYPE_VIDEO,
403 .request_frame = request_frame,
404 },
405 };
406
407 const FFFilter ff_vf_thumbnail = {
408 .p.name = "thumbnail",
409 .p.description = NULL_IF_CONFIG_SMALL("Select the most representative frame in a given sequence of consecutive frames."),
410 .p.priv_class = &thumbnail_class,
411 .p.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC |
412 AVFILTER_FLAG_SLICE_THREADS,
413 .priv_size = sizeof(ThumbContext),
414 .init = init,
415 .uninit = uninit,
416 FILTER_INPUTS(thumbnail_inputs),
417 FILTER_OUTPUTS(thumbnail_outputs),
418 FILTER_QUERY_FUNC2(query_formats),
419 };
420