LCOV - code coverage report
Current view: top level - libavfilter - vf_showinfo.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 0 109 0.0 %
Date: 2018-05-20 11:54:08 Functions: 0 7 0.0 %

          Line data    Source code
       1             : /*
       2             :  * Copyright (c) 2011 Stefano Sabatini
       3             :  * This file is part of FFmpeg.
       4             :  *
       5             :  * FFmpeg is free software; you can redistribute it and/or
       6             :  * modify it under the terms of the GNU Lesser General Public
       7             :  * License as published by the Free Software Foundation; either
       8             :  * version 2.1 of the License, or (at your option) any later version.
       9             :  *
      10             :  * FFmpeg is distributed in the hope that it will be useful,
      11             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      12             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      13             :  * Lesser General Public License for more details.
      14             :  *
      15             :  * You should have received a copy of the GNU Lesser General Public
      16             :  * License along with FFmpeg; if not, write to the Free Software
      17             :  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
      18             :  */
      19             : 
      20             : /**
      21             :  * @file
      22             :  * filter for showing textual video frame information
      23             :  */
      24             : 
      25             : #include <inttypes.h>
      26             : 
      27             : #include "libavutil/adler32.h"
      28             : #include "libavutil/display.h"
      29             : #include "libavutil/imgutils.h"
      30             : #include "libavutil/internal.h"
      31             : #include "libavutil/pixdesc.h"
      32             : #include "libavutil/spherical.h"
      33             : #include "libavutil/stereo3d.h"
      34             : #include "libavutil/timestamp.h"
      35             : 
      36             : #include "avfilter.h"
      37             : #include "internal.h"
      38             : #include "video.h"
      39             : 
      40           0 : static void dump_spherical(AVFilterContext *ctx, AVFrame *frame, AVFrameSideData *sd)
      41             : {
      42           0 :     AVSphericalMapping *spherical = (AVSphericalMapping *)sd->data;
      43             :     double yaw, pitch, roll;
      44             : 
      45           0 :     av_log(ctx, AV_LOG_INFO, "spherical information: ");
      46           0 :     if (sd->size < sizeof(*spherical)) {
      47           0 :         av_log(ctx, AV_LOG_INFO, "invalid data");
      48           0 :         return;
      49             :     }
      50             : 
      51           0 :     if (spherical->projection == AV_SPHERICAL_EQUIRECTANGULAR)
      52           0 :         av_log(ctx, AV_LOG_INFO, "equirectangular ");
      53           0 :     else if (spherical->projection == AV_SPHERICAL_CUBEMAP)
      54           0 :         av_log(ctx, AV_LOG_INFO, "cubemap ");
      55           0 :     else if (spherical->projection == AV_SPHERICAL_EQUIRECTANGULAR_TILE)
      56           0 :         av_log(ctx, AV_LOG_INFO, "tiled equirectangular ");
      57             :     else {
      58           0 :         av_log(ctx, AV_LOG_WARNING, "unknown");
      59           0 :         return;
      60             :     }
      61             : 
      62           0 :     yaw = ((double)spherical->yaw) / (1 << 16);
      63           0 :     pitch = ((double)spherical->pitch) / (1 << 16);
      64           0 :     roll = ((double)spherical->roll) / (1 << 16);
      65           0 :     av_log(ctx, AV_LOG_INFO, "(%f/%f/%f) ", yaw, pitch, roll);
      66             : 
      67           0 :     if (spherical->projection == AV_SPHERICAL_EQUIRECTANGULAR_TILE) {
      68             :         size_t l, t, r, b;
      69           0 :         av_spherical_tile_bounds(spherical, frame->width, frame->height,
      70             :                                  &l, &t, &r, &b);
      71           0 :         av_log(ctx, AV_LOG_INFO,
      72             :                "[%"SIZE_SPECIFIER", %"SIZE_SPECIFIER", %"SIZE_SPECIFIER", %"SIZE_SPECIFIER"] ",
      73             :                l, t, r, b);
      74           0 :     } else if (spherical->projection == AV_SPHERICAL_CUBEMAP) {
      75           0 :         av_log(ctx, AV_LOG_INFO, "[pad %"PRIu32"] ", spherical->padding);
      76             :     }
      77             : }
      78             : 
      79           0 : static void dump_stereo3d(AVFilterContext *ctx, AVFrameSideData *sd)
      80             : {
      81             :     AVStereo3D *stereo;
      82             : 
      83           0 :     av_log(ctx, AV_LOG_INFO, "stereoscopic information: ");
      84           0 :     if (sd->size < sizeof(*stereo)) {
      85           0 :         av_log(ctx, AV_LOG_INFO, "invalid data");
      86           0 :         return;
      87             :     }
      88             : 
      89           0 :     stereo = (AVStereo3D *)sd->data;
      90             : 
      91           0 :     av_log(ctx, AV_LOG_INFO, "type - %s", av_stereo3d_type_name(stereo->type));
      92             : 
      93           0 :     if (stereo->flags & AV_STEREO3D_FLAG_INVERT)
      94           0 :         av_log(ctx, AV_LOG_INFO, " (inverted)");
      95             : }
      96             : 
      97           0 : static void update_sample_stats(const uint8_t *src, int len, int64_t *sum, int64_t *sum2)
      98             : {
      99             :     int i;
     100             : 
     101           0 :     for (i = 0; i < len; i++) {
     102           0 :         *sum += src[i];
     103           0 :         *sum2 += src[i] * src[i];
     104             :     }
     105           0 : }
     106             : 
     107           0 : static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
     108             : {
     109           0 :     AVFilterContext *ctx = inlink->dst;
     110           0 :     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
     111           0 :     uint32_t plane_checksum[4] = {0}, checksum = 0;
     112           0 :     int64_t sum[4] = {0}, sum2[4] = {0};
     113           0 :     int32_t pixelcount[4] = {0};
     114           0 :     int i, plane, vsub = desc->log2_chroma_h;
     115             : 
     116           0 :     for (plane = 0; plane < 4 && frame->data[plane] && frame->linesize[plane]; plane++) {
     117           0 :         uint8_t *data = frame->data[plane];
     118           0 :         int h = plane == 1 || plane == 2 ? AV_CEIL_RSHIFT(inlink->h, vsub) : inlink->h;
     119           0 :         int linesize = av_image_get_linesize(frame->format, frame->width, plane);
     120             : 
     121           0 :         if (linesize < 0)
     122           0 :             return linesize;
     123             : 
     124           0 :         for (i = 0; i < h; i++) {
     125           0 :             plane_checksum[plane] = av_adler32_update(plane_checksum[plane], data, linesize);
     126           0 :             checksum = av_adler32_update(checksum, data, linesize);
     127             : 
     128           0 :             update_sample_stats(data, linesize, sum+plane, sum2+plane);
     129           0 :             pixelcount[plane] += linesize;
     130           0 :             data += frame->linesize[plane];
     131             :         }
     132             :     }
     133             : 
     134           0 :     av_log(ctx, AV_LOG_INFO,
     135             :            "n:%4"PRId64" pts:%7s pts_time:%-7s pos:%9"PRId64" "
     136             :            "fmt:%s sar:%d/%d s:%dx%d i:%c iskey:%d type:%c "
     137             :            "checksum:%08"PRIX32" plane_checksum:[%08"PRIX32,
     138             :            inlink->frame_count_out,
     139           0 :            av_ts2str(frame->pts), av_ts2timestr(frame->pts, &inlink->time_base), frame->pkt_pos,
     140             :            desc->name,
     141             :            frame->sample_aspect_ratio.num, frame->sample_aspect_ratio.den,
     142             :            frame->width, frame->height,
     143           0 :            !frame->interlaced_frame ? 'P' :         /* Progressive  */
     144           0 :            frame->top_field_first   ? 'T' : 'B',    /* Top / Bottom */
     145             :            frame->key_frame,
     146           0 :            av_get_picture_type_char(frame->pict_type),
     147             :            checksum, plane_checksum[0]);
     148             : 
     149           0 :     for (plane = 1; plane < 4 && frame->data[plane] && frame->linesize[plane]; plane++)
     150           0 :         av_log(ctx, AV_LOG_INFO, " %08"PRIX32, plane_checksum[plane]);
     151           0 :     av_log(ctx, AV_LOG_INFO, "] mean:[");
     152           0 :     for (plane = 0; plane < 4 && frame->data[plane] && frame->linesize[plane]; plane++)
     153           0 :         av_log(ctx, AV_LOG_INFO, "%"PRId64" ", (sum[plane] + pixelcount[plane]/2) / pixelcount[plane]);
     154           0 :     av_log(ctx, AV_LOG_INFO, "\b] stdev:[");
     155           0 :     for (plane = 0; plane < 4 && frame->data[plane] && frame->linesize[plane]; plane++)
     156           0 :         av_log(ctx, AV_LOG_INFO, "%3.1f ",
     157           0 :                sqrt((sum2[plane] - sum[plane]*(double)sum[plane]/pixelcount[plane])/pixelcount[plane]));
     158           0 :     av_log(ctx, AV_LOG_INFO, "\b]\n");
     159             : 
     160           0 :     for (i = 0; i < frame->nb_side_data; i++) {
     161           0 :         AVFrameSideData *sd = frame->side_data[i];
     162             : 
     163           0 :         av_log(ctx, AV_LOG_INFO, "  side data - ");
     164           0 :         switch (sd->type) {
     165           0 :         case AV_FRAME_DATA_PANSCAN:
     166           0 :             av_log(ctx, AV_LOG_INFO, "pan/scan");
     167           0 :             break;
     168           0 :         case AV_FRAME_DATA_A53_CC:
     169           0 :             av_log(ctx, AV_LOG_INFO, "A/53 closed captions (%d bytes)", sd->size);
     170           0 :             break;
     171           0 :         case AV_FRAME_DATA_SPHERICAL:
     172           0 :             dump_spherical(ctx, frame, sd);
     173           0 :             break;
     174           0 :         case AV_FRAME_DATA_STEREO3D:
     175           0 :             dump_stereo3d(ctx, sd);
     176           0 :             break;
     177           0 :         case AV_FRAME_DATA_DISPLAYMATRIX:
     178           0 :             av_log(ctx, AV_LOG_INFO, "displaymatrix: rotation of %.2f degrees",
     179           0 :                    av_display_rotation_get((int32_t *)sd->data));
     180           0 :             break;
     181           0 :         case AV_FRAME_DATA_AFD:
     182           0 :             av_log(ctx, AV_LOG_INFO, "afd: value of %"PRIu8, sd->data[0]);
     183           0 :             break;
     184           0 :         default:
     185           0 :             av_log(ctx, AV_LOG_WARNING, "unknown side data type %d (%d bytes)",
     186           0 :                    sd->type, sd->size);
     187           0 :             break;
     188             :         }
     189             : 
     190           0 :         av_log(ctx, AV_LOG_INFO, "\n");
     191             :     }
     192             : 
     193           0 :     return ff_filter_frame(inlink->dst->outputs[0], frame);
     194             : }
     195             : 
     196           0 : static int config_props(AVFilterContext *ctx, AVFilterLink *link, int is_out)
     197             : {
     198             : 
     199           0 :     av_log(ctx, AV_LOG_INFO, "config %s time_base: %d/%d, frame_rate: %d/%d\n",
     200             :            is_out ? "out" : "in",
     201             :            link->time_base.num, link->time_base.den,
     202             :            link->frame_rate.num, link->frame_rate.den);
     203             : 
     204           0 :     return 0;
     205             : }
     206             : 
     207           0 : static int config_props_in(AVFilterLink *link)
     208             : {
     209           0 :     AVFilterContext *ctx = link->dst;
     210           0 :     return config_props(ctx, link, 0);
     211             : }
     212             : 
     213           0 : static int config_props_out(AVFilterLink *link)
     214             : {
     215           0 :     AVFilterContext *ctx = link->src;
     216           0 :     return config_props(ctx, link, 1);
     217             : }
     218             : 
     219             : static const AVFilterPad avfilter_vf_showinfo_inputs[] = {
     220             :     {
     221             :         .name             = "default",
     222             :         .type             = AVMEDIA_TYPE_VIDEO,
     223             :         .filter_frame     = filter_frame,
     224             :         .config_props     = config_props_in,
     225             :     },
     226             :     { NULL }
     227             : };
     228             : 
     229             : static const AVFilterPad avfilter_vf_showinfo_outputs[] = {
     230             :     {
     231             :         .name = "default",
     232             :         .type = AVMEDIA_TYPE_VIDEO,
     233             :         .config_props  = config_props_out,
     234             :     },
     235             :     { NULL }
     236             : };
     237             : 
     238             : AVFilter ff_vf_showinfo = {
     239             :     .name        = "showinfo",
     240             :     .description = NULL_IF_CONFIG_SMALL("Show textual information for each video frame."),
     241             :     .inputs      = avfilter_vf_showinfo_inputs,
     242             :     .outputs     = avfilter_vf_showinfo_outputs,
     243             : };

Generated by: LCOV version 1.13