LCOV - code coverage report
Current view: top level - libavfilter - vf_thumbnail.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 74 82 90.2 %
Date: 2017-12-12 11:08:38 Functions: 8 8 100.0 %

          Line data    Source code
       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/opt.h"
      31             : #include "avfilter.h"
      32             : #include "internal.h"
      33             : 
      34             : #define HIST_SIZE (3*256)
      35             : 
      36             : struct thumb_frame {
      37             :     AVFrame *buf;               ///< cached frame
      38             :     int histogram[HIST_SIZE];   ///< RGB color distribution histogram of the frame
      39             : };
      40             : 
      41             : typedef struct ThumbContext {
      42             :     const AVClass *class;
      43             :     int n;                      ///< current frame
      44             :     int n_frames;               ///< number of frames for analysis
      45             :     struct thumb_frame *frames; ///< the n_frames frames
      46             :     AVRational tb;              ///< copy of the input timebase to ease access
      47             : } ThumbContext;
      48             : 
      49             : #define OFFSET(x) offsetof(ThumbContext, x)
      50             : #define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
      51             : 
      52             : static const AVOption thumbnail_options[] = {
      53             :     { "n", "set the frames batch size", OFFSET(n_frames), AV_OPT_TYPE_INT, {.i64=100}, 2, INT_MAX, FLAGS },
      54             :     { NULL }
      55             : };
      56             : 
      57             : AVFILTER_DEFINE_CLASS(thumbnail);
      58             : 
      59           1 : static av_cold int init(AVFilterContext *ctx)
      60             : {
      61           1 :     ThumbContext *s = ctx->priv;
      62             : 
      63           1 :     s->frames = av_calloc(s->n_frames, sizeof(*s->frames));
      64           1 :     if (!s->frames) {
      65           0 :         av_log(ctx, AV_LOG_ERROR,
      66             :                "Allocation failure, try to lower the number of frames\n");
      67           0 :         return AVERROR(ENOMEM);
      68             :     }
      69           1 :     av_log(ctx, AV_LOG_VERBOSE, "batch size: %d frames\n", s->n_frames);
      70           1 :     return 0;
      71             : }
      72             : 
      73             : /**
      74             :  * @brief        Compute Sum-square deviation to estimate "closeness".
      75             :  * @param hist   color distribution histogram
      76             :  * @param median average color distribution histogram
      77             :  * @return       sum of squared errors
      78             :  */
      79          50 : static double frame_sum_square_err(const int *hist, const double *median)
      80             : {
      81             :     int i;
      82          50 :     double err, sum_sq_err = 0;
      83             : 
      84       38450 :     for (i = 0; i < HIST_SIZE; i++) {
      85       38400 :         err = median[i] - (double)hist[i];
      86       38400 :         sum_sq_err += err*err;
      87             :     }
      88          50 :     return sum_sq_err;
      89             : }
      90             : 
      91           5 : static AVFrame *get_best_frame(AVFilterContext *ctx)
      92             : {
      93             :     AVFrame *picref;
      94           5 :     ThumbContext *s = ctx->priv;
      95           5 :     int i, j, best_frame_idx = 0;
      96           5 :     int nb_frames = s->n;
      97           5 :     double avg_hist[HIST_SIZE] = {0}, sq_err, min_sq_err = -1;
      98             : 
      99             :     // average histogram of the N frames
     100        3845 :     for (j = 0; j < FF_ARRAY_ELEMS(avg_hist); j++) {
     101       42240 :         for (i = 0; i < nb_frames; i++)
     102       38400 :             avg_hist[j] += (double)s->frames[i].histogram[j];
     103        3840 :         avg_hist[j] /= nb_frames;
     104             :     }
     105             : 
     106             :     // find the frame closer to the average using the sum of squared errors
     107          55 :     for (i = 0; i < nb_frames; i++) {
     108          50 :         sq_err = frame_sum_square_err(s->frames[i].histogram, avg_hist);
     109          50 :         if (i == 0 || sq_err < min_sq_err)
     110          11 :             best_frame_idx = i, min_sq_err = sq_err;
     111             :     }
     112             : 
     113             :     // free and reset everything (except the best frame buffer)
     114          55 :     for (i = 0; i < nb_frames; i++) {
     115          50 :         memset(s->frames[i].histogram, 0, sizeof(s->frames[i].histogram));
     116          50 :         if (i != best_frame_idx)
     117          45 :             av_frame_free(&s->frames[i].buf);
     118             :     }
     119           5 :     s->n = 0;
     120             : 
     121             :     // raise the chosen one
     122           5 :     picref = s->frames[best_frame_idx].buf;
     123          10 :     av_log(ctx, AV_LOG_INFO, "frame id #%d (pts_time=%f) selected "
     124             :            "from a set of %d images\n", best_frame_idx,
     125          10 :            picref->pts * av_q2d(s->tb), nb_frames);
     126           5 :     s->frames[best_frame_idx].buf = NULL;
     127             : 
     128           5 :     return picref;
     129             : }
     130             : 
     131          50 : static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
     132             : {
     133             :     int i, j;
     134          50 :     AVFilterContext *ctx  = inlink->dst;
     135          50 :     ThumbContext *s   = ctx->priv;
     136          50 :     AVFilterLink *outlink = ctx->outputs[0];
     137          50 :     int *hist = s->frames[s->n].histogram;
     138          50 :     const uint8_t *p = frame->data[0];
     139             : 
     140             :     // keep a reference of each frame
     141          50 :     s->frames[s->n].buf = frame;
     142             : 
     143             :     // update current frame RGB histogram
     144       14450 :     for (j = 0; j < inlink->h; j++) {
     145     5083200 :         for (i = 0; i < inlink->w; i++) {
     146     5068800 :             hist[0*256 + p[i*3    ]]++;
     147     5068800 :             hist[1*256 + p[i*3 + 1]]++;
     148     5068800 :             hist[2*256 + p[i*3 + 2]]++;
     149             :         }
     150       14400 :         p += frame->linesize[0];
     151             :     }
     152             : 
     153             :     // no selection until the buffer of N frames is filled up
     154          50 :     s->n++;
     155          50 :     if (s->n < s->n_frames)
     156          45 :         return 0;
     157             : 
     158           5 :     return ff_filter_frame(outlink, get_best_frame(ctx));
     159             : }
     160             : 
     161           1 : static av_cold void uninit(AVFilterContext *ctx)
     162             : {
     163             :     int i;
     164           1 :     ThumbContext *s = ctx->priv;
     165           1 :     for (i = 0; i < s->n_frames && s->frames[i].buf; i++)
     166           0 :         av_frame_free(&s->frames[i].buf);
     167           1 :     av_freep(&s->frames);
     168           1 : }
     169             : 
     170          50 : static int request_frame(AVFilterLink *link)
     171             : {
     172          50 :     AVFilterContext *ctx = link->src;
     173          50 :     ThumbContext *s = ctx->priv;
     174          50 :     int ret = ff_request_frame(ctx->inputs[0]);
     175             : 
     176          50 :     if (ret == AVERROR_EOF && s->n) {
     177           0 :         ret = ff_filter_frame(link, get_best_frame(ctx));
     178           0 :         if (ret < 0)
     179           0 :             return ret;
     180           0 :         ret = AVERROR_EOF;
     181             :     }
     182          50 :     if (ret < 0)
     183           1 :         return ret;
     184          49 :     return 0;
     185             : }
     186             : 
     187           1 : static int config_props(AVFilterLink *inlink)
     188             : {
     189           1 :     AVFilterContext *ctx = inlink->dst;
     190           1 :     ThumbContext *s = ctx->priv;
     191             : 
     192           1 :     s->tb = inlink->time_base;
     193           1 :     return 0;
     194             : }
     195             : 
     196           1 : static int query_formats(AVFilterContext *ctx)
     197             : {
     198             :     static const enum AVPixelFormat pix_fmts[] = {
     199             :         AV_PIX_FMT_RGB24, AV_PIX_FMT_BGR24,
     200             :         AV_PIX_FMT_NONE
     201             :     };
     202           1 :     AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
     203           1 :     if (!fmts_list)
     204           0 :         return AVERROR(ENOMEM);
     205           1 :     return ff_set_common_formats(ctx, fmts_list);
     206             : }
     207             : 
     208             : static const AVFilterPad thumbnail_inputs[] = {
     209             :     {
     210             :         .name         = "default",
     211             :         .type         = AVMEDIA_TYPE_VIDEO,
     212             :         .config_props = config_props,
     213             :         .filter_frame = filter_frame,
     214             :     },
     215             :     { NULL }
     216             : };
     217             : 
     218             : static const AVFilterPad thumbnail_outputs[] = {
     219             :     {
     220             :         .name          = "default",
     221             :         .type          = AVMEDIA_TYPE_VIDEO,
     222             :         .request_frame = request_frame,
     223             :     },
     224             :     { NULL }
     225             : };
     226             : 
     227             : AVFilter ff_vf_thumbnail = {
     228             :     .name          = "thumbnail",
     229             :     .description   = NULL_IF_CONFIG_SMALL("Select the most representative frame in a given sequence of consecutive frames."),
     230             :     .priv_size     = sizeof(ThumbContext),
     231             :     .init          = init,
     232             :     .uninit        = uninit,
     233             :     .query_formats = query_formats,
     234             :     .inputs        = thumbnail_inputs,
     235             :     .outputs       = thumbnail_outputs,
     236             :     .priv_class    = &thumbnail_class,
     237             : };

Generated by: LCOV version 1.13