Merge remote-tracking branch 'qatar/master'
[ffmpeg.git] / libavfilter / vsrc_buffer.c
1 /*
2  * Copyright (c) 2008 Vitor Sessak
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  * memory buffer source filter
24  */
25
26 #include "avfilter.h"
27 #include "internal.h"
28 #include "avcodec.h"
29 #include "buffersrc.h"
30 #include "vsrc_buffer.h"
31 #include "libavutil/fifo.h"
32 #include "libavutil/imgutils.h"
33
34 typedef struct {
35     AVFilterContext  *scale;
36     AVFifoBuffer     *fifo;
37     int               h, w;
38     enum PixelFormat  pix_fmt;
39     AVRational        time_base;     ///< time_base to set in the output link
40     AVRational        sample_aspect_ratio;
41     char              sws_param[256];
42 } BufferSourceContext;
43
44 #define CHECK_PARAM_CHANGE(s, c, width, height, format)\
45     if (c->w != width || c->h != height || c->pix_fmt != format) {\
46         av_log(s, AV_LOG_ERROR, "Changing frame properties on the fly is not supported.\n");\
47         return AVERROR(EINVAL);\
48     }
49
50 int av_vsrc_buffer_add_video_buffer_ref(AVFilterContext *buffer_filter,
51                                         AVFilterBufferRef *picref, int flags)
52 {
53     BufferSourceContext *c = buffer_filter->priv;
54     AVFilterLink *outlink = buffer_filter->outputs[0];
55     AVFilterBufferRef *buf;
56     int ret;
57
58     if (av_fifo_size(c->fifo)) {
59         if (flags & AV_VSRC_BUF_FLAG_OVERWRITE) {
60             //FIXME not implemented
61         }
62     }
63     if (!av_fifo_space(c->fifo) &&
64         (ret = av_fifo_realloc2(c->fifo, av_fifo_size(c->fifo) +
65                                          sizeof(buf))) < 0)
66         return ret;
67
68     if (picref->video->w != c->w || picref->video->h != c->h || picref->format != c->pix_fmt) {
69         AVFilterContext *scale = buffer_filter->outputs[0]->dst;
70         AVFilterLink *link;
71         char scale_param[1024];
72
73         av_log(buffer_filter, AV_LOG_INFO,
74                "Buffer video input changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
75                c->w, c->h, av_pix_fmt_descriptors[c->pix_fmt].name,
76                picref->video->w, picref->video->h, av_pix_fmt_descriptors[picref->format].name);
77
78         if (!scale || strcmp(scale->filter->name, "scale")) {
79             AVFilter *f = avfilter_get_by_name("scale");
80
81             av_log(buffer_filter, AV_LOG_INFO, "Inserting scaler filter\n");
82             if ((ret = avfilter_open(&scale, f, "Input equalizer")) < 0)
83                 return ret;
84
85             c->scale = scale;
86
87             snprintf(scale_param, sizeof(scale_param)-1, "%d:%d:%s", c->w, c->h, c->sws_param);
88             if ((ret = avfilter_init_filter(scale, scale_param, NULL)) < 0) {
89                 return ret;
90             }
91
92             if ((ret = avfilter_insert_filter(buffer_filter->outputs[0], scale, 0, 0)) < 0) {
93                 return ret;
94             }
95             scale->outputs[0]->time_base = scale->inputs[0]->time_base;
96
97             scale->outputs[0]->format= c->pix_fmt;
98         } else if (!strcmp(scale->filter->name, "scale")) {
99             snprintf(scale_param, sizeof(scale_param)-1, "%d:%d:%s",
100                      scale->outputs[0]->w, scale->outputs[0]->h, c->sws_param);
101             scale->filter->init(scale, scale_param, NULL);
102         }
103
104         c->pix_fmt = scale->inputs[0]->format = picref->format;
105         c->w       = scale->inputs[0]->w      = picref->video->w;
106         c->h       = scale->inputs[0]->h      = picref->video->h;
107
108         link = scale->outputs[0];
109         if ((ret =  link->srcpad->config_props(link)) < 0)
110             return ret;
111     }
112
113     buf = avfilter_get_video_buffer(outlink, AV_PERM_WRITE,
114                                     picref->video->w, picref->video->h);
115     av_image_copy(buf->data, buf->linesize,
116                   (void*)picref->data, picref->linesize,
117                   picref->format, picref->video->w, picref->video->h);
118     avfilter_copy_buffer_ref_props(buf, picref);
119
120     if ((ret = av_fifo_generic_write(c->fifo, &buf, sizeof(buf), NULL)) < 0) {
121         avfilter_unref_buffer(buf);
122         return ret;
123     }
124
125     return 0;
126 }
127
128 int av_buffersrc_buffer(AVFilterContext *s, AVFilterBufferRef *buf)
129 {
130     BufferSourceContext *c = s->priv;
131     int ret;
132
133     if (!av_fifo_space(c->fifo) &&
134         (ret = av_fifo_realloc2(c->fifo, av_fifo_size(c->fifo) +
135                                          sizeof(buf))) < 0)
136         return ret;
137
138 //     CHECK_PARAM_CHANGE(s, c, buf->video->w, buf->video->h, buf->format);
139
140     if ((ret = av_fifo_generic_write(c->fifo, &buf, sizeof(buf), NULL)) < 0)
141         return ret;
142
143     return 0;
144 }
145
146 #if CONFIG_AVCODEC
147 #include "avcodec.h"
148
149 int av_vsrc_buffer_add_frame(AVFilterContext *buffer_src,
150                              const AVFrame *frame, int flags)
151 {
152     int ret;
153     AVFilterBufferRef *picref =
154         avfilter_get_video_buffer_ref_from_frame(frame, AV_PERM_WRITE);
155     if (!picref)
156         return AVERROR(ENOMEM);
157     ret = av_vsrc_buffer_add_video_buffer_ref(buffer_src, picref, flags);
158     picref->buf->data[0] = NULL;
159     avfilter_unref_buffer(picref);
160
161     return ret;
162 }
163 #endif
164
165 static av_cold int init(AVFilterContext *ctx, const char *args, void *opaque)
166 {
167     BufferSourceContext *c = ctx->priv;
168     char pix_fmt_str[128];
169     int ret, n = 0;
170     *c->sws_param = 0;
171
172     if (!args ||
173         (n = sscanf(args, "%d:%d:%127[^:]:%d:%d:%d:%d:%255c", &c->w, &c->h, pix_fmt_str,
174                     &c->time_base.num, &c->time_base.den,
175                     &c->sample_aspect_ratio.num, &c->sample_aspect_ratio.den, c->sws_param)) < 7) {
176         av_log(ctx, AV_LOG_ERROR, "Expected at least 7 arguments, but only %d found in '%s'\n", n, args);
177         return AVERROR(EINVAL);
178     }
179
180     if ((ret = ff_parse_pixel_format(&c->pix_fmt, pix_fmt_str, ctx)) < 0)
181         return ret;
182
183     if (!(c->fifo = av_fifo_alloc(sizeof(AVFilterBufferRef*))))
184         return AVERROR(ENOMEM);
185
186     av_log(ctx, AV_LOG_INFO, "w:%d h:%d pixfmt:%s tb:%d/%d sar:%d/%d sws_param:%s\n",
187            c->w, c->h, av_pix_fmt_descriptors[c->pix_fmt].name,
188            c->time_base.num, c->time_base.den,
189            c->sample_aspect_ratio.num, c->sample_aspect_ratio.den, c->sws_param);
190     return 0;
191 }
192
193 static av_cold void uninit(AVFilterContext *ctx)
194 {
195     BufferSourceContext *s = ctx->priv;
196     while (av_fifo_size(s->fifo)) {
197         AVFilterBufferRef *buf;
198         av_fifo_generic_read(s->fifo, &buf, sizeof(buf), NULL);
199         avfilter_unref_buffer(buf);
200     }
201     av_fifo_free(s->fifo);
202     s->fifo = NULL;
203     avfilter_free(s->scale);
204     s->scale = NULL;
205 }
206
207 static int query_formats(AVFilterContext *ctx)
208 {
209     BufferSourceContext *c = ctx->priv;
210     enum PixelFormat pix_fmts[] = { c->pix_fmt, PIX_FMT_NONE };
211
212     avfilter_set_common_pixel_formats(ctx, avfilter_make_format_list(pix_fmts));
213     return 0;
214 }
215
216 static int config_props(AVFilterLink *link)
217 {
218     BufferSourceContext *c = link->src->priv;
219
220     link->w = c->w;
221     link->h = c->h;
222     link->sample_aspect_ratio = c->sample_aspect_ratio;
223     link->time_base = c->time_base;
224
225     return 0;
226 }
227
228 static int request_frame(AVFilterLink *link)
229 {
230     BufferSourceContext *c = link->src->priv;
231     AVFilterBufferRef *buf;
232
233     if (!av_fifo_size(c->fifo)) {
234         av_log(link->src, AV_LOG_WARNING,
235                "request_frame() called with no available frame!\n");
236         return AVERROR(EINVAL);
237     }
238     av_fifo_generic_read(c->fifo, &buf, sizeof(buf), NULL);
239
240     avfilter_start_frame(link, avfilter_ref_buffer(buf, ~0));
241     avfilter_draw_slice(link, 0, link->h, 1);
242     avfilter_end_frame(link);
243     avfilter_unref_buffer(buf);
244
245     return 0;
246 }
247
248 static int poll_frame(AVFilterLink *link)
249 {
250     BufferSourceContext *c = link->src->priv;
251     return !!av_fifo_size(c->fifo);
252 }
253
254 AVFilter avfilter_vsrc_buffer = {
255     .name      = "buffer",
256     .description = NULL_IF_CONFIG_SMALL("Buffer video frames, and make them accessible to the filterchain."),
257     .priv_size = sizeof(BufferSourceContext),
258     .query_formats = query_formats,
259
260     .init      = init,
261     .uninit    = uninit,
262
263     .inputs    = (const AVFilterPad[]) {{ .name = NULL }},
264     .outputs   = (const AVFilterPad[]) {{ .name      = "default",
265                                     .type            = AVMEDIA_TYPE_VIDEO,
266                                     .request_frame   = request_frame,
267                                     .poll_frame      = poll_frame,
268                                     .config_props    = config_props, },
269                                   { .name = NULL}},
270 };