sink_buffer: remove unused variables
[ffmpeg.git] / libavfilter / sink_buffer.c
1 /*
2  * Copyright (c) 2011 Stefano Sabatini
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  * buffer sink
24  */
25
26 #include "libavutil/avassert.h"
27 #include "libavutil/channel_layout.h"
28 #include "libavutil/fifo.h"
29 #include "avfilter.h"
30 #include "buffersink.h"
31 #include "audio.h"
32 #include "internal.h"
33
34 #include "libavutil/audio_fifo.h"
35
36 AVBufferSinkParams *av_buffersink_params_alloc(void)
37 {
38     static const int pixel_fmts[] = { AV_PIX_FMT_NONE };
39     AVBufferSinkParams *params = av_malloc(sizeof(AVBufferSinkParams));
40     if (!params)
41         return NULL;
42
43     params->pixel_fmts = pixel_fmts;
44     return params;
45 }
46
47 AVABufferSinkParams *av_abuffersink_params_alloc(void)
48 {
49     AVABufferSinkParams *params = av_mallocz(sizeof(AVABufferSinkParams));
50
51     if (!params)
52         return NULL;
53     return params;
54 }
55
56 typedef struct {
57     AVFifoBuffer *fifo;                      ///< FIFO buffer of video frame references
58     unsigned warning_limit;
59
60     /* only used for video */
61     enum AVPixelFormat *pixel_fmts;           ///< list of accepted pixel formats, must be terminated with -1
62
63     /* only used for audio */
64     enum AVSampleFormat *sample_fmts;       ///< list of accepted sample formats, terminated by AV_SAMPLE_FMT_NONE
65     int64_t *channel_layouts;               ///< list of accepted channel layouts, terminated by -1
66     int all_channel_counts;
67     int *sample_rates;                      ///< list of accepted sample rates, terminated by -1
68 } BufferSinkContext;
69
70 #define FIFO_INIT_SIZE 8
71
72 static av_cold int common_init(AVFilterContext *ctx)
73 {
74     BufferSinkContext *buf = ctx->priv;
75
76     buf->fifo = av_fifo_alloc(FIFO_INIT_SIZE*sizeof(AVFilterBufferRef *));
77     if (!buf->fifo) {
78         av_log(ctx, AV_LOG_ERROR, "Failed to allocate fifo\n");
79         return AVERROR(ENOMEM);
80     }
81     buf->warning_limit = 100;
82     return 0;
83 }
84
85 static av_cold void common_uninit(AVFilterContext *ctx)
86 {
87     BufferSinkContext *buf = ctx->priv;
88     AVFilterBufferRef *picref;
89
90     if (buf->fifo) {
91         while (av_fifo_size(buf->fifo) >= sizeof(AVFilterBufferRef *)) {
92             av_fifo_generic_read(buf->fifo, &picref, sizeof(picref), NULL);
93             av_frame_unref(picref);
94         }
95         av_fifo_free(buf->fifo);
96         buf->fifo = NULL;
97     }
98 }
99
100 static int add_buffer_ref(AVFilterContext *ctx, AVFrame *ref)
101 {
102     BufferSinkContext *buf = ctx->priv;
103
104     if (av_fifo_space(buf->fifo) < sizeof(AVFilterBufferRef *)) {
105         /* realloc fifo size */
106         if (av_fifo_realloc2(buf->fifo, av_fifo_size(buf->fifo) * 2) < 0) {
107             av_log(ctx, AV_LOG_ERROR,
108                    "Cannot buffer more frames. Consume some available frames "
109                    "before adding new ones.\n");
110             return AVERROR(ENOMEM);
111         }
112     }
113
114     /* cache frame */
115     av_fifo_generic_write(buf->fifo, &ref, sizeof(AVFilterBufferRef *), NULL);
116     return 0;
117 }
118
119 static int filter_frame(AVFilterLink *inlink, AVFrame *ref)
120 {
121     AVFilterContext *ctx = inlink->dst;
122     BufferSinkContext *buf = inlink->dst->priv;
123     int ret;
124
125     if ((ret = add_buffer_ref(ctx, ref)) < 0)
126         return ret;
127     if (buf->warning_limit &&
128         av_fifo_size(buf->fifo) / sizeof(AVFilterBufferRef *) >= buf->warning_limit) {
129         av_log(ctx, AV_LOG_WARNING,
130                "%d buffers queued in %s, something may be wrong.\n",
131                buf->warning_limit,
132                (char *)av_x_if_null(ctx->name, ctx->filter->name));
133         buf->warning_limit *= 10;
134     }
135     return 0;
136 }
137
138 void av_buffersink_set_frame_size(AVFilterContext *ctx, unsigned frame_size)
139 {
140     AVFilterLink *inlink = ctx->inputs[0];
141
142     inlink->min_samples = inlink->max_samples =
143     inlink->partial_buf_size = frame_size;
144 }
145
146 int av_buffersink_get_frame_flags(AVFilterContext *ctx, AVFrame *frame, int flags)
147 {
148     BufferSinkContext *buf = ctx->priv;
149     AVFilterLink *inlink = ctx->inputs[0];
150     int ret;
151     AVFrame *cur_frame;
152
153     /* no picref available, fetch it from the filterchain */
154     if (!av_fifo_size(buf->fifo)) {
155         if (flags & AV_BUFFERSINK_FLAG_NO_REQUEST)
156             return AVERROR(EAGAIN);
157         if ((ret = ff_request_frame(inlink)) < 0)
158             return ret;
159     }
160
161     if (!av_fifo_size(buf->fifo))
162         return AVERROR(EINVAL);
163
164     if (flags & AV_BUFFERSINK_FLAG_PEEK) {
165         cur_frame = *((AVFrame **)av_fifo_peek2(buf->fifo, 0));
166         av_frame_ref(frame, cur_frame); /* TODO check failure */
167     } else {
168         av_fifo_generic_read(buf->fifo, &cur_frame, sizeof(cur_frame), NULL);
169         av_frame_move_ref(frame, cur_frame);
170         av_frame_free(&cur_frame);
171     }
172
173     return 0;
174 }
175
176 int av_buffersink_get_frame(AVFilterContext *ctx, AVFrame *frame)
177 {
178     return av_buffersink_get_frame_flags(ctx, frame, 0);
179 }
180
181 int av_buffersink_get_samples(AVFilterContext *ctx, AVFrame *frame, int nb_samples)
182 {
183     av_assert0(!"TODO");
184 }
185
186 #if FF_API_AVFILTERBUFFER
187 static void compat_free_buffer(AVFilterBuffer *buf)
188 {
189     AVFrame *frame = buf->priv;
190     av_frame_free(&frame);
191     av_free(buf);
192 }
193
194 static int compat_read(AVFilterContext *ctx, AVFilterBufferRef **pbuf, int nb_samples, int flags)
195 {
196     AVFilterBufferRef *buf;
197     AVFrame *frame;
198     int ret;
199
200     if (!pbuf)
201         return ff_poll_frame(ctx->inputs[0]);
202
203     frame = av_frame_alloc();
204     if (!frame)
205         return AVERROR(ENOMEM);
206
207     if (!nb_samples)
208         ret = av_buffersink_get_frame_flags(ctx, frame, flags);
209     else
210         ret = av_buffersink_get_samples(ctx, frame, nb_samples);
211
212     if (ret < 0)
213         goto fail;
214
215     if (ctx->inputs[0]->type == AVMEDIA_TYPE_VIDEO) {
216         buf = avfilter_get_video_buffer_ref_from_arrays(frame->data, frame->linesize,
217                                                         AV_PERM_READ,
218                                                         frame->width, frame->height,
219                                                         frame->format);
220     } else {
221         buf = avfilter_get_audio_buffer_ref_from_arrays(frame->extended_data,
222                                                         frame->linesize[0], AV_PERM_READ,
223                                                         frame->nb_samples,
224                                                         frame->format,
225                                                         frame->channel_layout);
226     }
227     if (!buf) {
228         ret = AVERROR(ENOMEM);
229         goto fail;
230     }
231
232     avfilter_copy_frame_props(buf, frame);
233
234     buf->buf->priv = frame;
235     buf->buf->free = compat_free_buffer;
236
237     *pbuf = buf;
238
239     return 0;
240 fail:
241     av_frame_free(&frame);
242     return ret;
243 }
244
245 int av_buffersink_read(AVFilterContext *ctx, AVFilterBufferRef **buf)
246 {
247     return compat_read(ctx, buf, 0, 0);
248 }
249
250 int av_buffersink_read_samples(AVFilterContext *ctx, AVFilterBufferRef **buf,
251                                int nb_samples)
252 {
253     return compat_read(ctx, buf, nb_samples, 0);
254 }
255
256 int av_buffersink_get_buffer_ref(AVFilterContext *ctx,
257                                   AVFilterBufferRef **bufref, int flags)
258 {
259     *bufref = NULL;
260
261     av_assert0(    !strcmp(ctx->filter->name, "buffersink")
262                 || !strcmp(ctx->filter->name, "abuffersink")
263                 || !strcmp(ctx->filter->name, "ffbuffersink")
264                 || !strcmp(ctx->filter->name, "ffabuffersink"));
265
266     return compat_read(ctx, bufref, 0, flags);
267 }
268 #endif
269
270 AVRational av_buffersink_get_frame_rate(AVFilterContext *ctx)
271 {
272     av_assert0(   !strcmp(ctx->filter->name, "buffersink")
273                || !strcmp(ctx->filter->name, "ffbuffersink"));
274
275     return ctx->inputs[0]->frame_rate;
276 }
277
278 int av_buffersink_poll_frame(AVFilterContext *ctx)
279 {
280     BufferSinkContext *buf = ctx->priv;
281     AVFilterLink *inlink = ctx->inputs[0];
282
283     av_assert0(   !strcmp(ctx->filter->name, "buffersink")
284                || !strcmp(ctx->filter->name, "abuffersink")
285                || !strcmp(ctx->filter->name, "ffbuffersink")
286                || !strcmp(ctx->filter->name, "ffabuffersink"));
287
288     return av_fifo_size(buf->fifo)/sizeof(AVFilterBufferRef *) + ff_poll_frame(inlink);
289 }
290
291 static av_cold int vsink_init(AVFilterContext *ctx, const char *args, void *opaque)
292 {
293     BufferSinkContext *buf = ctx->priv;
294     AVBufferSinkParams *params = opaque;
295
296     if (params && params->pixel_fmts) {
297         const int *pixel_fmts = params->pixel_fmts;
298
299         buf->pixel_fmts = ff_copy_int_list(pixel_fmts);
300         if (!buf->pixel_fmts)
301             return AVERROR(ENOMEM);
302     }
303
304     return common_init(ctx);
305 }
306
307 static av_cold void vsink_uninit(AVFilterContext *ctx)
308 {
309     BufferSinkContext *buf = ctx->priv;
310     av_freep(&buf->pixel_fmts);
311     common_uninit(ctx);
312 }
313
314 static int vsink_query_formats(AVFilterContext *ctx)
315 {
316     BufferSinkContext *buf = ctx->priv;
317
318     if (buf->pixel_fmts)
319         ff_set_common_formats(ctx, ff_make_format_list(buf->pixel_fmts));
320     else
321         ff_default_query_formats(ctx);
322
323     return 0;
324 }
325
326 static const AVFilterPad ffbuffersink_inputs[] = {
327     {
328         .name      = "default",
329         .type      = AVMEDIA_TYPE_VIDEO,
330         .filter_frame = filter_frame,
331     },
332     { NULL },
333 };
334
335 AVFilter avfilter_vsink_ffbuffersink = {
336     .name      = "ffbuffersink",
337     .description = NULL_IF_CONFIG_SMALL("Buffer video frames, and make them available to the end of the filter graph."),
338     .priv_size = sizeof(BufferSinkContext),
339     .init_opaque = vsink_init,
340     .uninit    = vsink_uninit,
341
342     .query_formats = vsink_query_formats,
343     .inputs        = ffbuffersink_inputs,
344     .outputs       = NULL,
345 };
346
347 static const AVFilterPad buffersink_inputs[] = {
348     {
349         .name      = "default",
350         .type      = AVMEDIA_TYPE_VIDEO,
351         .filter_frame = filter_frame,
352     },
353     { NULL },
354 };
355
356 AVFilter avfilter_vsink_buffersink = {
357     .name      = "buffersink",
358     .description = NULL_IF_CONFIG_SMALL("Buffer video frames, and make them available to the end of the filter graph."),
359     .priv_size = sizeof(BufferSinkContext),
360     .init_opaque = vsink_init,
361     .uninit    = vsink_uninit,
362
363     .query_formats = vsink_query_formats,
364     .inputs        = buffersink_inputs,
365     .outputs       = NULL,
366 };
367
368 static int64_t *concat_channels_lists(const int64_t *layouts, const int *counts)
369 {
370     int nb_layouts = 0, nb_counts = 0, i;
371     int64_t *list;
372
373     if (layouts)
374         for (; layouts[nb_layouts] != -1; nb_layouts++);
375     if (counts)
376         for (; counts[nb_counts] != -1; nb_counts++);
377     if (nb_counts > INT_MAX - 1 - nb_layouts)
378         return NULL;
379     if (!(list = av_calloc(nb_layouts + nb_counts + 1, sizeof(*list))))
380         return NULL;
381     for (i = 0; i < nb_layouts; i++)
382         list[i] = layouts[i];
383     for (i = 0; i < nb_counts; i++)
384         list[nb_layouts + i] = FF_COUNT2LAYOUT(counts[i]);
385     list[nb_layouts + nb_counts] = -1;
386     return list;
387 }
388
389 static av_cold int asink_init(AVFilterContext *ctx, const char *args, void *opaque)
390 {
391     BufferSinkContext *buf = ctx->priv;
392     AVABufferSinkParams *params = opaque;
393
394     if (params && params->sample_fmts) {
395         buf->sample_fmts = ff_copy_int_list(params->sample_fmts);
396         if (!buf->sample_fmts)
397             return AVERROR(ENOMEM);
398     }
399     if (params && params->sample_rates) {
400         buf->sample_rates = ff_copy_int_list(params->sample_rates);
401         if (!buf->sample_rates)
402             return AVERROR(ENOMEM);
403     }
404     if (params && (params->channel_layouts || params->channel_counts)) {
405         if (params->all_channel_counts) {
406             av_log(ctx, AV_LOG_ERROR,
407                    "Conflicting all_channel_counts and list in parameters\n");
408             return AVERROR(EINVAL);
409         }
410         buf->channel_layouts = concat_channels_lists(params->channel_layouts,
411                                                      params->channel_counts);
412         if (!buf->channel_layouts)
413             return AVERROR(ENOMEM);
414     }
415     if (params)
416         buf->all_channel_counts = params->all_channel_counts;
417     return common_init(ctx);
418 }
419
420 static av_cold void asink_uninit(AVFilterContext *ctx)
421 {
422     BufferSinkContext *buf = ctx->priv;
423
424     av_freep(&buf->sample_fmts);
425     av_freep(&buf->sample_rates);
426     av_freep(&buf->channel_layouts);
427     common_uninit(ctx);
428 }
429
430 static int asink_query_formats(AVFilterContext *ctx)
431 {
432     BufferSinkContext *buf = ctx->priv;
433     AVFilterFormats *formats = NULL;
434     AVFilterChannelLayouts *layouts = NULL;
435
436     if (buf->sample_fmts) {
437         if (!(formats = ff_make_format_list(buf->sample_fmts)))
438             return AVERROR(ENOMEM);
439         ff_set_common_formats(ctx, formats);
440     }
441
442     if (buf->channel_layouts || buf->all_channel_counts) {
443             layouts = buf->all_channel_counts ? ff_all_channel_counts() :
444                       avfilter_make_format64_list(buf->channel_layouts);
445         if (!layouts)
446             return AVERROR(ENOMEM);
447         ff_set_common_channel_layouts(ctx, layouts);
448     }
449
450     if (buf->sample_rates) {
451         formats = ff_make_format_list(buf->sample_rates);
452         if (!formats)
453             return AVERROR(ENOMEM);
454         ff_set_common_samplerates(ctx, formats);
455     }
456
457     return 0;
458 }
459
460 static const AVFilterPad ffabuffersink_inputs[] = {
461     {
462         .name           = "default",
463         .type           = AVMEDIA_TYPE_AUDIO,
464         .filter_frame   = filter_frame,
465     },
466     { NULL },
467 };
468
469 AVFilter avfilter_asink_ffabuffersink = {
470     .name      = "ffabuffersink",
471     .description = NULL_IF_CONFIG_SMALL("Buffer audio frames, and make them available to the end of the filter graph."),
472     .init_opaque = asink_init,
473     .uninit    = asink_uninit,
474     .priv_size = sizeof(BufferSinkContext),
475     .query_formats = asink_query_formats,
476     .inputs        = ffabuffersink_inputs,
477     .outputs       = NULL,
478 };
479
480 static const AVFilterPad abuffersink_inputs[] = {
481     {
482         .name           = "default",
483         .type           = AVMEDIA_TYPE_AUDIO,
484         .filter_frame   = filter_frame,
485     },
486     { NULL },
487 };
488
489 AVFilter avfilter_asink_abuffersink = {
490     .name      = "abuffersink",
491     .description = NULL_IF_CONFIG_SMALL("Buffer audio frames, and make them available to the end of the filter graph."),
492     .init_opaque = asink_init,
493     .uninit    = asink_uninit,
494     .priv_size = sizeof(BufferSinkContext),
495     .query_formats = asink_query_formats,
496     .inputs        = abuffersink_inputs,
497     .outputs       = NULL,
498 };