af_compand: make sure request_frame always outputs at least one frame
[ffmpeg.git] / libavfilter / vf_cropdetect.c
1 /*
2  * Copyright (c) 2002 A'rpi
3  * This file is part of Libav.
4  *
5  * Libav 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  * Libav 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 Libav; 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 <stdio.h>
27
28 #include "libavutil/imgutils.h"
29 #include "libavutil/internal.h"
30 #include "libavutil/opt.h"
31
32 #include "avfilter.h"
33 #include "formats.h"
34 #include "internal.h"
35 #include "video.h"
36
37 typedef struct CropDetectContext {
38     const AVClass *class;
39     int x1, y1, x2, y2;
40     int limit;
41     int round;
42     int reset_count;
43     int frame_nb;
44     int max_pixsteps[4];
45 } CropDetectContext;
46
47 static int query_formats(AVFilterContext *ctx)
48 {
49     static const enum AVPixelFormat pix_fmts[] = {
50         AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVJ420P,
51         AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVJ422P,
52         AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUVJ444P,
53         AV_PIX_FMT_YUV411P, AV_PIX_FMT_GRAY8,
54         AV_PIX_FMT_NV12,    AV_PIX_FMT_NV21,
55         AV_PIX_FMT_NONE
56     };
57
58     ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
59     return 0;
60 }
61
62 static int checkline(void *ctx, const unsigned char *src, int stride, int len, int bpp)
63 {
64     int total = 0;
65     int div = len;
66
67     switch (bpp) {
68     case 1:
69         while (--len >= 0) {
70             total += src[0];
71             src += stride;
72         }
73         break;
74     case 3:
75     case 4:
76         while (--len >= 0) {
77             total += src[0] + src[1] + src[2];
78             src += stride;
79         }
80         div *= 3;
81         break;
82     }
83     total /= div;
84
85     av_log(ctx, AV_LOG_DEBUG, "total:%d\n", total);
86     return total;
87 }
88
89 static av_cold int init(AVFilterContext *ctx)
90 {
91     CropDetectContext *s = ctx->priv;
92
93     s->frame_nb = -2;
94
95     av_log(ctx, AV_LOG_VERBOSE, "limit:%d round:%d reset_count:%d\n",
96            s->limit, s->round, s->reset_count);
97
98     return 0;
99 }
100
101 static int config_input(AVFilterLink *inlink)
102 {
103     AVFilterContext *ctx = inlink->dst;
104     CropDetectContext *s = ctx->priv;
105
106     av_image_fill_max_pixsteps(s->max_pixsteps, NULL,
107                                av_pix_fmt_desc_get(inlink->format));
108
109     s->x1 = inlink->w - 1;
110     s->y1 = inlink->h - 1;
111     s->x2 = 0;
112     s->y2 = 0;
113
114     return 0;
115 }
116
117 static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
118 {
119     AVFilterContext *ctx = inlink->dst;
120     CropDetectContext *s = ctx->priv;
121     int bpp = s->max_pixsteps[0];
122     int w, h, x, y, shrink_by;
123
124     // ignore first 2 frames - they may be empty
125     if (++s->frame_nb > 0) {
126         // Reset the crop area every reset_count frames, if reset_count is > 0
127         if (s->reset_count > 0 && s->frame_nb > s->reset_count) {
128             s->x1 = frame->width  - 1;
129             s->y1 = frame->height - 1;
130             s->x2 = 0;
131             s->y2 = 0;
132             s->frame_nb = 1;
133         }
134
135         for (y = 0; y < s->y1; y++) {
136             if (checkline(ctx, frame->data[0] + frame->linesize[0] * y, bpp, frame->width, bpp) > s->limit) {
137                 s->y1 = y;
138                 break;
139             }
140         }
141
142         for (y = frame->height - 1; y > s->y2; y--) {
143             if (checkline(ctx, frame->data[0] + frame->linesize[0] * y, bpp, frame->width, bpp) > s->limit) {
144                 s->y2 = y;
145                 break;
146             }
147         }
148
149         for (y = 0; y < s->x1; y++) {
150             if (checkline(ctx, frame->data[0] + bpp*y, frame->linesize[0], frame->height, bpp) > s->limit) {
151                 s->x1 = y;
152                 break;
153             }
154         }
155
156         for (y = frame->width - 1; y > s->x2; y--) {
157             if (checkline(ctx, frame->data[0] + bpp*y, frame->linesize[0], frame->height, bpp) > s->limit) {
158                 s->x2 = y;
159                 break;
160             }
161         }
162
163         // round x and y (up), important for yuv colorspaces
164         // make sure they stay rounded!
165         x = (s->x1+1) & ~1;
166         y = (s->y1+1) & ~1;
167
168         w = s->x2 - x + 1;
169         h = s->y2 - y + 1;
170
171         // w and h must be divisible by 2 as well because of yuv
172         // colorspace problems.
173         if (s->round <= 1)
174             s->round = 16;
175         if (s->round % 2)
176             s->round *= 2;
177
178         shrink_by = w % s->round;
179         w -= shrink_by;
180         x += (shrink_by/2 + 1) & ~1;
181
182         shrink_by = h % s->round;
183         h -= shrink_by;
184         y += (shrink_by/2 + 1) & ~1;
185
186         av_log(ctx, AV_LOG_INFO,
187                "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",
188                s->x1, s->x2, s->y1, s->y2, w, h, x, y, frame->pts,
189                frame->pts == AV_NOPTS_VALUE ? -1 : frame->pts * av_q2d(inlink->time_base),
190                w, h, x, y);
191     }
192
193     return ff_filter_frame(inlink->dst->outputs[0], frame);
194 }
195
196 #define OFFSET(x) offsetof(CropDetectContext, x)
197 #define FLAGS AV_OPT_FLAG_VIDEO_PARAM
198 static const AVOption options[] = {
199     { "limit", "Threshold below which the pixel is considered black", OFFSET(limit),       AV_OPT_TYPE_INT, { .i64 = 24 }, 0, INT_MAX, FLAGS },
200     { "round", "Value by which the width/height should be divisible", OFFSET(round),       AV_OPT_TYPE_INT, { .i64 = 0  }, 0, INT_MAX, FLAGS },
201     { "reset", "Recalculate the crop area after this many frames",    OFFSET(reset_count), AV_OPT_TYPE_INT, { .i64 = 0 },  0, INT_MAX, FLAGS },
202     { NULL },
203 };
204
205 static const AVClass cropdetect_class = {
206     .class_name = "cropdetect",
207     .item_name  = av_default_item_name,
208     .option     = options,
209     .version    = LIBAVUTIL_VERSION_INT,
210 };
211
212 static const AVFilterPad avfilter_vf_cropdetect_inputs[] = {
213     {
214         .name             = "default",
215         .type             = AVMEDIA_TYPE_VIDEO,
216         .config_props     = config_input,
217         .get_video_buffer = ff_null_get_video_buffer,
218         .filter_frame     = filter_frame,
219     },
220     { NULL }
221 };
222
223 static const AVFilterPad avfilter_vf_cropdetect_outputs[] = {
224     {
225         .name = "default",
226         .type = AVMEDIA_TYPE_VIDEO
227     },
228     { NULL }
229 };
230
231 AVFilter ff_vf_cropdetect = {
232     .name        = "cropdetect",
233     .description = NULL_IF_CONFIG_SMALL("Auto-detect crop size."),
234
235     .priv_size = sizeof(CropDetectContext),
236     .priv_class = &cropdetect_class,
237     .init      = init,
238
239     .query_formats = query_formats,
240
241     .inputs    = avfilter_vf_cropdetect_inputs,
242
243     .outputs   = avfilter_vf_cropdetect_outputs,
244 };