LCOV - code coverage report
Current view: top level - libavfilter - vf_blackframe.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 0 26 0.0 %
Date: 2017-12-14 01:15:32 Functions: 0 2 0.0 %

          Line data    Source code
       1             : /*
       2             :  * Copyright (c) 2010 Stefano Sabatini
       3             :  * Copyright (c) 2006 Ivo van Poorten
       4             :  * Copyright (c) 2006 Julian Hall
       5             :  * Copyright (c) 2002-2003 Brian J. Murrell
       6             :  *
       7             :  * This file is part of FFmpeg.
       8             :  *
       9             :  * FFmpeg is free software; you can redistribute it and/or modify
      10             :  * it under the terms of the GNU General Public License as published by
      11             :  * the Free Software Foundation; either version 2 of the License, or
      12             :  * (at your option) any later version.
      13             :  *
      14             :  * FFmpeg is distributed in the hope that it will be useful,
      15             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      16             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      17             :  * GNU General Public License for more details.
      18             :  *
      19             :  * You should have received a copy of the GNU General Public License along
      20             :  * with FFmpeg; if not, write to the Free Software Foundation, Inc.,
      21             :  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
      22             :  */
      23             : 
      24             : /**
      25             :  * @file
      26             :  * Search for black frames to detect scene transitions.
      27             :  * Ported from MPlayer libmpcodecs/vf_blackframe.c.
      28             :  */
      29             : 
      30             : #include <stdio.h>
      31             : #include <inttypes.h>
      32             : 
      33             : #include "libavutil/internal.h"
      34             : #include "libavutil/opt.h"
      35             : #include "avfilter.h"
      36             : #include "formats.h"
      37             : #include "internal.h"
      38             : #include "video.h"
      39             : 
      40             : typedef struct BlackFrameContext {
      41             :     const AVClass *class;
      42             :     int bamount;          ///< black amount
      43             :     int bthresh;          ///< black threshold
      44             :     unsigned int frame;   ///< frame number
      45             :     unsigned int nblack;  ///< number of black pixels counted so far
      46             :     unsigned int last_keyframe; ///< frame number of the last received key-frame
      47             : } BlackFrameContext;
      48             : 
      49           0 : static int query_formats(AVFilterContext *ctx)
      50             : {
      51             :     static const enum AVPixelFormat pix_fmts[] = {
      52             :         AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV420P, AV_PIX_FMT_GRAY8, AV_PIX_FMT_NV12,
      53             :         AV_PIX_FMT_NV21, AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV411P,
      54             :         AV_PIX_FMT_NONE
      55             :     };
      56             : 
      57           0 :     AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
      58           0 :     if (!fmts_list)
      59           0 :         return AVERROR(ENOMEM);
      60           0 :     return ff_set_common_formats(ctx, fmts_list);
      61             : }
      62             : 
      63             : #define SET_META(key, format, value) \
      64             :     snprintf(buf, sizeof(buf), format, value);  \
      65             :     av_dict_set(metadata, key, buf, 0)
      66             : 
      67           0 : static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
      68             : {
      69           0 :     AVFilterContext *ctx = inlink->dst;
      70           0 :     BlackFrameContext *s = ctx->priv;
      71             :     int x, i;
      72           0 :     int pblack = 0;
      73           0 :     uint8_t *p = frame->data[0];
      74             :     AVDictionary **metadata;
      75             :     char buf[32];
      76             : 
      77           0 :     for (i = 0; i < frame->height; i++) {
      78           0 :         for (x = 0; x < inlink->w; x++)
      79           0 :             s->nblack += p[x] < s->bthresh;
      80           0 :         p += frame->linesize[0];
      81             :     }
      82             : 
      83           0 :     if (frame->key_frame)
      84           0 :         s->last_keyframe = s->frame;
      85             : 
      86           0 :     pblack = s->nblack * 100 / (inlink->w * inlink->h);
      87           0 :     if (pblack >= s->bamount) {
      88           0 :         metadata = &frame->metadata;
      89             : 
      90           0 :         av_log(ctx, AV_LOG_INFO, "frame:%u pblack:%u pts:%"PRId64" t:%f "
      91             :                "type:%c last_keyframe:%d\n",
      92             :                s->frame, pblack, frame->pts,
      93           0 :                frame->pts == AV_NOPTS_VALUE ? -1 : frame->pts * av_q2d(inlink->time_base),
      94           0 :                av_get_picture_type_char(frame->pict_type), s->last_keyframe);
      95             : 
      96           0 :         SET_META("lavfi.blackframe.pblack", "%u", pblack);
      97             :     }
      98             : 
      99           0 :     s->frame++;
     100           0 :     s->nblack = 0;
     101           0 :     return ff_filter_frame(inlink->dst->outputs[0], frame);
     102             : }
     103             : 
     104             : #define OFFSET(x) offsetof(BlackFrameContext, x)
     105             : #define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
     106             : static const AVOption blackframe_options[] = {
     107             :     { "amount", "percentage of the pixels that have to be below the threshold "
     108             :         "for the frame to be considered black",  OFFSET(bamount), AV_OPT_TYPE_INT, { .i64 = 98 }, 0, 100,     FLAGS },
     109             :     { "threshold", "threshold below which a pixel value is considered black",
     110             :                                                  OFFSET(bthresh), AV_OPT_TYPE_INT, { .i64 = 32 }, 0, 255,     FLAGS },
     111             :     { "thresh", "threshold below which a pixel value is considered black",
     112             :                                                  OFFSET(bthresh), AV_OPT_TYPE_INT, { .i64 = 32 }, 0, 255,     FLAGS },
     113             :     { NULL }
     114             : };
     115             : 
     116             : AVFILTER_DEFINE_CLASS(blackframe);
     117             : 
     118             : static const AVFilterPad avfilter_vf_blackframe_inputs[] = {
     119             :     {
     120             :         .name         = "default",
     121             :         .type         = AVMEDIA_TYPE_VIDEO,
     122             :         .filter_frame = filter_frame,
     123             :     },
     124             :     { NULL }
     125             : };
     126             : 
     127             : static const AVFilterPad avfilter_vf_blackframe_outputs[] = {
     128             :     {
     129             :         .name = "default",
     130             :         .type = AVMEDIA_TYPE_VIDEO
     131             :     },
     132             :     { NULL }
     133             : };
     134             : 
     135             : AVFilter ff_vf_blackframe = {
     136             :     .name          = "blackframe",
     137             :     .description   = NULL_IF_CONFIG_SMALL("Detect frames that are (almost) black."),
     138             :     .priv_size     = sizeof(BlackFrameContext),
     139             :     .priv_class    = &blackframe_class,
     140             :     .query_formats = query_formats,
     141             :     .inputs        = avfilter_vf_blackframe_inputs,
     142             :     .outputs       = avfilter_vf_blackframe_outputs,
     143             : };

Generated by: LCOV version 1.13