FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
vf_cropdetect.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2002 A'rpi
3  * This file is part of FFmpeg.
4  *
5  * FFmpeg is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation; either version 2 of the License, or
8  * (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
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License along
16  * with FFmpeg; if not, write to the Free Software Foundation, Inc.,
17  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18  */
19 
20 /**
21  * @file
22  * border detection filter
23  * Ported from MPlayer libmpcodecs/vf_cropdetect.c.
24  */
25 
26 #include "libavutil/imgutils.h"
27 #include "libavutil/internal.h"
28 #include "libavutil/opt.h"
29 
30 #include "avfilter.h"
31 #include "formats.h"
32 #include "internal.h"
33 #include "video.h"
34 
35 typedef struct CropDetectContext {
36  const AVClass *class;
37  int x1, y1, x2, y2;
38  int limit;
39  int round;
41  int frame_nb;
42  int max_pixsteps[4];
44 
46 {
47  static const enum AVPixelFormat pix_fmts[] = {
54  };
55 
57  return 0;
58 }
59 
60 static int checkline(void *ctx, const unsigned char *src, int stride, int len, int bpp)
61 {
62  int total = 0;
63  int div = len;
64 
65  switch (bpp) {
66  case 1:
67  while (--len >= 0) {
68  total += src[0];
69  src += stride;
70  }
71  break;
72  case 3:
73  case 4:
74  while (--len >= 0) {
75  total += src[0] + src[1] + src[2];
76  src += stride;
77  }
78  div *= 3;
79  break;
80  }
81  total /= div;
82 
83  av_log(ctx, AV_LOG_DEBUG, "total:%d\n", total);
84  return total;
85 }
86 
87 static av_cold int init(AVFilterContext *ctx)
88 {
89  CropDetectContext *s = ctx->priv;
90 
91  s->frame_nb = -2;
92 
93  av_log(ctx, AV_LOG_VERBOSE, "limit:%d round:%d reset_count:%d\n",
94  s->limit, s->round, s->reset_count);
95 
96  return 0;
97 }
98 
99 static int config_input(AVFilterLink *inlink)
100 {
101  AVFilterContext *ctx = inlink->dst;
102  CropDetectContext *s = ctx->priv;
103 
105  av_pix_fmt_desc_get(inlink->format));
106 
107  s->x1 = inlink->w - 1;
108  s->y1 = inlink->h - 1;
109  s->x2 = 0;
110  s->y2 = 0;
111 
112  return 0;
113 }
114 
115 #define SET_META(key, value) \
116  av_dict_set_int(metadata, key, value, 0)
117 
118 static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
119 {
120  AVFilterContext *ctx = inlink->dst;
121  CropDetectContext *s = ctx->priv;
122  int bpp = s->max_pixsteps[0];
123  int w, h, x, y, shrink_by;
124  AVDictionary **metadata;
125 
126  // ignore first 2 frames - they may be empty
127  if (++s->frame_nb > 0) {
128  metadata = avpriv_frame_get_metadatap(frame);
129 
130  // Reset the crop area every reset_count frames, if reset_count is > 0
131  if (s->reset_count > 0 && s->frame_nb > s->reset_count) {
132  s->x1 = frame->width - 1;
133  s->y1 = frame->height - 1;
134  s->x2 = 0;
135  s->y2 = 0;
136  s->frame_nb = 1;
137  }
138 
139  for (y = 0; y < s->y1; y++) {
140  if (checkline(ctx, frame->data[0] + frame->linesize[0] * y, bpp, frame->width, bpp) > s->limit) {
141  s->y1 = y;
142  break;
143  }
144  }
145 
146  for (y = frame->height - 1; y > s->y2; y--) {
147  if (checkline(ctx, frame->data[0] + frame->linesize[0] * y, bpp, frame->width, bpp) > s->limit) {
148  s->y2 = y;
149  break;
150  }
151  }
152 
153  for (y = 0; y < s->x1; y++) {
154  if (checkline(ctx, frame->data[0] + bpp*y, frame->linesize[0], frame->height, bpp) > s->limit) {
155  s->x1 = y;
156  break;
157  }
158  }
159 
160  for (y = frame->width - 1; y > s->x2; y--) {
161  if (checkline(ctx, frame->data[0] + bpp*y, frame->linesize[0], frame->height, bpp) > s->limit) {
162  s->x2 = y;
163  break;
164  }
165  }
166 
167  // round x and y (up), important for yuv colorspaces
168  // make sure they stay rounded!
169  x = (s->x1+1) & ~1;
170  y = (s->y1+1) & ~1;
171 
172  w = s->x2 - x + 1;
173  h = s->y2 - y + 1;
174 
175  // w and h must be divisible by 2 as well because of yuv
176  // colorspace problems.
177  if (s->round <= 1)
178  s->round = 16;
179  if (s->round % 2)
180  s->round *= 2;
181 
182  shrink_by = w % s->round;
183  w -= shrink_by;
184  x += (shrink_by/2 + 1) & ~1;
185 
186  shrink_by = h % s->round;
187  h -= shrink_by;
188  y += (shrink_by/2 + 1) & ~1;
189 
190  SET_META("lavfi.cropdetect.x1", s->x1);
191  SET_META("lavfi.cropdetect.x2", s->x2);
192  SET_META("lavfi.cropdetect.y1", s->y1);
193  SET_META("lavfi.cropdetect.y2", s->y2);
194  SET_META("lavfi.cropdetect.w", w);
195  SET_META("lavfi.cropdetect.h", h);
196  SET_META("lavfi.cropdetect.x", x);
197  SET_META("lavfi.cropdetect.y", y);
198 
199  av_log(ctx, AV_LOG_INFO,
200  "x1:%d x2:%d y1:%d y2:%d w:%d h:%d x:%d y:%d pts:%"PRId64" t:%f crop=%d:%d:%d:%d\n",
201  s->x1, s->x2, s->y1, s->y2, w, h, x, y, frame->pts,
202  frame->pts == AV_NOPTS_VALUE ? -1 : frame->pts * av_q2d(inlink->time_base),
203  w, h, x, y);
204  }
205 
206  return ff_filter_frame(inlink->dst->outputs[0], frame);
207 }
208 
209 #define OFFSET(x) offsetof(CropDetectContext, x)
210 #define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
211 
212 static const AVOption cropdetect_options[] = {
213  { "limit", "Threshold below which the pixel is considered black", OFFSET(limit), AV_OPT_TYPE_INT, { .i64 = 24 }, 0, 255, FLAGS },
214  { "round", "Value by which the width/height should be divisible", OFFSET(round), AV_OPT_TYPE_INT, { .i64 = 16 }, 0, INT_MAX, FLAGS },
215  { "reset", "Recalculate the crop area after this many frames", OFFSET(reset_count), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, FLAGS },
216  { "reset_count", "Recalculate the crop area after this many frames",OFFSET(reset_count),AV_OPT_TYPE_INT,{ .i64 = 0 }, 0, INT_MAX, FLAGS },
217  { NULL }
218 };
219 
220 AVFILTER_DEFINE_CLASS(cropdetect);
221 
223  {
224  .name = "default",
225  .type = AVMEDIA_TYPE_VIDEO,
226  .config_props = config_input,
227  .filter_frame = filter_frame,
228  },
229  { NULL }
230 };
231 
233  {
234  .name = "default",
235  .type = AVMEDIA_TYPE_VIDEO
236  },
237  { NULL }
238 };
239 
241  .name = "cropdetect",
242  .description = NULL_IF_CONFIG_SMALL("Auto-detect crop size."),
243  .priv_size = sizeof(CropDetectContext),
244  .priv_class = &cropdetect_class,
245  .init = init,
247  .inputs = avfilter_vf_cropdetect_inputs,
248  .outputs = avfilter_vf_cropdetect_outputs,
250 };