blob: ca55ff1f668a248dcf0255df3e1c6b19fe8c6b9c
1 | /* |
2 | * Copyright (c) 2011 Mark Himsley |
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 | * video field order filter, heavily influenced by vf_pad.c |
24 | */ |
25 | |
26 | #include "libavutil/imgutils.h" |
27 | #include "libavutil/internal.h" |
28 | #include "libavutil/opt.h" |
29 | #include "libavutil/pixdesc.h" |
30 | #include "avfilter.h" |
31 | #include "formats.h" |
32 | #include "internal.h" |
33 | #include "video.h" |
34 | |
35 | typedef struct FieldOrderContext { |
36 | const AVClass *class; |
37 | int dst_tff; ///< output bff/tff |
38 | int line_size[4]; ///< bytes of pixel data per line for each plane |
39 | } FieldOrderContext; |
40 | |
41 | static int query_formats(AVFilterContext *ctx) |
42 | { |
43 | AVFilterFormats *formats; |
44 | enum AVPixelFormat pix_fmt; |
45 | int ret; |
46 | |
47 | /** accept any input pixel format that is not hardware accelerated, not |
48 | * a bitstream format, and does not have vertically sub-sampled chroma */ |
49 | if (ctx->inputs[0]) { |
50 | const AVPixFmtDescriptor *desc = NULL; |
51 | formats = NULL; |
52 | while ((desc = av_pix_fmt_desc_next(desc))) { |
53 | pix_fmt = av_pix_fmt_desc_get_id(desc); |
54 | if (!(desc->flags & AV_PIX_FMT_FLAG_HWACCEL || |
55 | desc->flags & AV_PIX_FMT_FLAG_PAL || |
56 | desc->flags & AV_PIX_FMT_FLAG_BITSTREAM) && |
57 | desc->nb_components && !desc->log2_chroma_h && |
58 | (ret = ff_add_format(&formats, pix_fmt)) < 0) |
59 | return ret; |
60 | } |
61 | if ((ret = ff_formats_ref(formats, &ctx->inputs[0]->out_formats)) < 0 || |
62 | (ret = ff_formats_ref(formats, &ctx->outputs[0]->in_formats)) < 0) |
63 | return ret; |
64 | } |
65 | |
66 | return 0; |
67 | } |
68 | |
69 | static int config_input(AVFilterLink *inlink) |
70 | { |
71 | AVFilterContext *ctx = inlink->dst; |
72 | FieldOrderContext *s = ctx->priv; |
73 | |
74 | return av_image_fill_linesizes(s->line_size, inlink->format, inlink->w); |
75 | } |
76 | |
77 | static int filter_frame(AVFilterLink *inlink, AVFrame *frame) |
78 | { |
79 | AVFilterContext *ctx = inlink->dst; |
80 | FieldOrderContext *s = ctx->priv; |
81 | AVFilterLink *outlink = ctx->outputs[0]; |
82 | int h, plane, src_line_step, dst_line_step, line_size, line; |
83 | uint8_t *dst, *src; |
84 | AVFrame *out; |
85 | |
86 | if (!frame->interlaced_frame || |
87 | frame->top_field_first == s->dst_tff) { |
88 | av_log(ctx, AV_LOG_VERBOSE, |
89 | "Skipping %s.\n", |
90 | frame->interlaced_frame ? |
91 | "frame with same field order" : "progressive frame"); |
92 | return ff_filter_frame(outlink, frame); |
93 | } |
94 | |
95 | if (av_frame_is_writable(frame)) { |
96 | out = frame; |
97 | } else { |
98 | out = ff_get_video_buffer(outlink, outlink->w, outlink->h); |
99 | if (!out) { |
100 | av_frame_free(&frame); |
101 | return AVERROR(ENOMEM); |
102 | } |
103 | av_frame_copy_props(out, frame); |
104 | } |
105 | |
106 | av_log(ctx, AV_LOG_TRACE, |
107 | "picture will move %s one line\n", |
108 | s->dst_tff ? "up" : "down"); |
109 | h = frame->height; |
110 | for (plane = 0; plane < 4 && frame->data[plane] && frame->linesize[plane]; plane++) { |
111 | dst_line_step = out->linesize[plane]; |
112 | src_line_step = frame->linesize[plane]; |
113 | line_size = s->line_size[plane]; |
114 | dst = out->data[plane]; |
115 | src = frame->data[plane]; |
116 | if (s->dst_tff) { |
117 | /** Move every line up one line, working from |
118 | * the top to the bottom of the frame. |
119 | * The original top line is lost. |
120 | * The new last line is created as a copy of the |
121 | * penultimate line from that field. */ |
122 | for (line = 0; line < h; line++) { |
123 | if (1 + line < frame->height) { |
124 | memcpy(dst, src + src_line_step, line_size); |
125 | } else { |
126 | memcpy(dst, src - 2 * src_line_step, line_size); |
127 | } |
128 | dst += dst_line_step; |
129 | src += src_line_step; |
130 | } |
131 | } else { |
132 | /** Move every line down one line, working from |
133 | * the bottom to the top of the frame. |
134 | * The original bottom line is lost. |
135 | * The new first line is created as a copy of the |
136 | * second line from that field. */ |
137 | dst += (h - 1) * dst_line_step; |
138 | src += (h - 1) * src_line_step; |
139 | for (line = h - 1; line >= 0 ; line--) { |
140 | if (line > 0) { |
141 | memcpy(dst, src - src_line_step, line_size); |
142 | } else { |
143 | memcpy(dst, src + 2 * src_line_step, line_size); |
144 | } |
145 | dst -= dst_line_step; |
146 | src -= src_line_step; |
147 | } |
148 | } |
149 | } |
150 | out->top_field_first = s->dst_tff; |
151 | |
152 | if (frame != out) |
153 | av_frame_free(&frame); |
154 | return ff_filter_frame(outlink, out); |
155 | } |
156 | |
157 | #define OFFSET(x) offsetof(FieldOrderContext, x) |
158 | #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM |
159 | |
160 | static const AVOption fieldorder_options[] = { |
161 | { "order", "output field order", OFFSET(dst_tff), AV_OPT_TYPE_INT, { .i64 = 1 }, 0, 1, FLAGS, "order" }, |
162 | { "bff", "bottom field first", 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, .flags=FLAGS, .unit = "order" }, |
163 | { "tff", "top field first", 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, .flags=FLAGS, .unit = "order" }, |
164 | { NULL } |
165 | }; |
166 | |
167 | AVFILTER_DEFINE_CLASS(fieldorder); |
168 | |
169 | static const AVFilterPad avfilter_vf_fieldorder_inputs[] = { |
170 | { |
171 | .name = "default", |
172 | .type = AVMEDIA_TYPE_VIDEO, |
173 | .config_props = config_input, |
174 | .filter_frame = filter_frame, |
175 | }, |
176 | { NULL } |
177 | }; |
178 | |
179 | static const AVFilterPad avfilter_vf_fieldorder_outputs[] = { |
180 | { |
181 | .name = "default", |
182 | .type = AVMEDIA_TYPE_VIDEO, |
183 | }, |
184 | { NULL } |
185 | }; |
186 | |
187 | AVFilter ff_vf_fieldorder = { |
188 | .name = "fieldorder", |
189 | .description = NULL_IF_CONFIG_SMALL("Set the field order."), |
190 | .priv_size = sizeof(FieldOrderContext), |
191 | .priv_class = &fieldorder_class, |
192 | .query_formats = query_formats, |
193 | .inputs = avfilter_vf_fieldorder_inputs, |
194 | .outputs = avfilter_vf_fieldorder_outputs, |
195 | .flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC, |
196 | }; |
197 |