avformat/matroskadec: Add a fate test for CodecPrivate compression
[ffmpeg.git] / libavfilter / framesync.c
1 /*
2  * Copyright (c) 2013 Nicolas George
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 License
8  * 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
14  * GNU Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public License
17  * along with FFmpeg; if not, write to the Free Software Foundation, Inc.,
18  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20
21 #include "libavutil/avassert.h"
22 #include "libavutil/opt.h"
23 #include "avfilter.h"
24 #include "filters.h"
25 #include "framesync.h"
26 #include "internal.h"
27
28 #define OFFSET(member) offsetof(FFFrameSync, member)
29 #define FLAGS AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_FILTERING_PARAM
30
31 static const char *framesync_name(void *ptr)
32 {
33     return "framesync";
34 }
35
36 static const AVOption framesync_options[] = {
37     { "eof_action", "Action to take when encountering EOF from secondary input ",
38         OFFSET(opt_eof_action), AV_OPT_TYPE_INT, { .i64 = EOF_ACTION_REPEAT },
39         EOF_ACTION_REPEAT, EOF_ACTION_PASS, .flags = FLAGS, "eof_action" },
40         { "repeat", "Repeat the previous frame.",   0, AV_OPT_TYPE_CONST, { .i64 = EOF_ACTION_REPEAT }, .flags = FLAGS, "eof_action" },
41         { "endall", "End both streams.",            0, AV_OPT_TYPE_CONST, { .i64 = EOF_ACTION_ENDALL }, .flags = FLAGS, "eof_action" },
42         { "pass",   "Pass through the main input.", 0, AV_OPT_TYPE_CONST, { .i64 = EOF_ACTION_PASS },   .flags = FLAGS, "eof_action" },
43     { "shortest", "force termination when the shortest input terminates", OFFSET(opt_shortest), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS },
44     { "repeatlast", "extend last frame of secondary streams beyond EOF", OFFSET(opt_repeatlast), AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, FLAGS },
45     { NULL }
46 };
47 static const AVClass framesync_class = {
48     .version                   = LIBAVUTIL_VERSION_INT,
49     .class_name                = "framesync",
50     .item_name                 = framesync_name,
51     .category                  = AV_CLASS_CATEGORY_FILTER,
52     .option                    = framesync_options,
53     .parent_log_context_offset = OFFSET(parent),
54 };
55
56 enum {
57     STATE_BOF,
58     STATE_RUN,
59     STATE_EOF,
60 };
61
62 static int consume_from_fifos(FFFrameSync *fs);
63
64 const AVClass *ff_framesync_get_class(void)
65 {
66     return &framesync_class;
67 }
68
69 void ff_framesync_preinit(FFFrameSync *fs)
70 {
71     if (fs->class)
72         return;
73     fs->class  = &framesync_class;
74     av_opt_set_defaults(fs);
75 }
76
77 int ff_framesync_init(FFFrameSync *fs, AVFilterContext *parent, unsigned nb_in)
78 {
79     /* For filters with several outputs, we will not be able to assume which
80        output is relevant for ff_outlink_frame_wanted() and
81        ff_outlink_set_status(). To be designed when needed. */
82     av_assert0(parent->nb_outputs == 1);
83
84     ff_framesync_preinit(fs);
85     fs->parent = parent;
86     fs->nb_in  = nb_in;
87
88     fs->in = av_calloc(nb_in, sizeof(*fs->in));
89     if (!fs->in)
90         return AVERROR(ENOMEM);
91     return 0;
92 }
93
94 static void framesync_eof(FFFrameSync *fs)
95 {
96     fs->eof = 1;
97     fs->frame_ready = 0;
98     ff_outlink_set_status(fs->parent->outputs[0], AVERROR_EOF, AV_NOPTS_VALUE);
99 }
100
101 static void framesync_sync_level_update(FFFrameSync *fs)
102 {
103     unsigned i, level = 0;
104
105     for (i = 0; i < fs->nb_in; i++)
106         if (fs->in[i].state != STATE_EOF)
107             level = FFMAX(level, fs->in[i].sync);
108     av_assert0(level <= fs->sync_level);
109     if (level < fs->sync_level)
110         av_log(fs, AV_LOG_VERBOSE, "Sync level %u\n", level);
111     if (level)
112         fs->sync_level = level;
113     else
114         framesync_eof(fs);
115 }
116
117 int ff_framesync_configure(FFFrameSync *fs)
118 {
119     unsigned i;
120     int64_t gcd, lcm;
121
122     if (!fs->opt_repeatlast || fs->opt_eof_action == EOF_ACTION_PASS) {
123         fs->opt_repeatlast = 0;
124         fs->opt_eof_action = EOF_ACTION_PASS;
125     }
126     if (fs->opt_shortest || fs->opt_eof_action == EOF_ACTION_ENDALL) {
127         fs->opt_shortest = 1;
128         fs->opt_eof_action = EOF_ACTION_ENDALL;
129     }
130     if (!fs->opt_repeatlast) {
131         for (i = 1; i < fs->nb_in; i++) {
132             fs->in[i].after = EXT_NULL;
133             fs->in[i].sync  = 0;
134         }
135     }
136     if (fs->opt_shortest) {
137         for (i = 0; i < fs->nb_in; i++)
138             fs->in[i].after = EXT_STOP;
139     }
140
141     if (!fs->time_base.num) {
142         for (i = 0; i < fs->nb_in; i++) {
143             if (fs->in[i].sync) {
144                 if (fs->time_base.num) {
145                     gcd = av_gcd(fs->time_base.den, fs->in[i].time_base.den);
146                     lcm = (fs->time_base.den / gcd) * fs->in[i].time_base.den;
147                     if (lcm < AV_TIME_BASE / 2) {
148                         fs->time_base.den = lcm;
149                         fs->time_base.num = av_gcd(fs->time_base.num,
150                                                    fs->in[i].time_base.num);
151                     } else {
152                         fs->time_base.num = 1;
153                         fs->time_base.den = AV_TIME_BASE;
154                         break;
155                     }
156                 } else {
157                     fs->time_base = fs->in[i].time_base;
158                 }
159             }
160         }
161         if (!fs->time_base.num) {
162             av_log(fs, AV_LOG_ERROR, "Impossible to set time base\n");
163             return AVERROR(EINVAL);
164         }
165         av_log(fs, AV_LOG_VERBOSE, "Selected %d/%d time base\n",
166                fs->time_base.num, fs->time_base.den);
167     }
168
169     for (i = 0; i < fs->nb_in; i++)
170         fs->in[i].pts = fs->in[i].pts_next = AV_NOPTS_VALUE;
171     fs->sync_level = UINT_MAX;
172     framesync_sync_level_update(fs);
173
174     return 0;
175 }
176
177 static int framesync_advance(FFFrameSync *fs)
178 {
179     unsigned i;
180     int64_t pts;
181     int ret;
182
183     while (!(fs->frame_ready || fs->eof)) {
184         ret = consume_from_fifos(fs);
185         if (ret <= 0)
186             return ret;
187
188         pts = INT64_MAX;
189         for (i = 0; i < fs->nb_in; i++)
190             if (fs->in[i].have_next && fs->in[i].pts_next < pts)
191                 pts = fs->in[i].pts_next;
192         if (pts == INT64_MAX) {
193             framesync_eof(fs);
194             break;
195         }
196         for (i = 0; i < fs->nb_in; i++) {
197             if (fs->in[i].pts_next == pts ||
198                 (fs->in[i].before == EXT_INFINITY &&
199                  fs->in[i].state == STATE_BOF)) {
200                 av_frame_free(&fs->in[i].frame);
201                 fs->in[i].frame      = fs->in[i].frame_next;
202                 fs->in[i].pts        = fs->in[i].pts_next;
203                 fs->in[i].frame_next = NULL;
204                 fs->in[i].pts_next   = AV_NOPTS_VALUE;
205                 fs->in[i].have_next  = 0;
206                 fs->in[i].state      = fs->in[i].frame ? STATE_RUN : STATE_EOF;
207                 if (fs->in[i].sync == fs->sync_level && fs->in[i].frame)
208                     fs->frame_ready = 1;
209                 if (fs->in[i].state == STATE_EOF &&
210                     fs->in[i].after == EXT_STOP)
211                     framesync_eof(fs);
212             }
213         }
214         if (fs->frame_ready)
215             for (i = 0; i < fs->nb_in; i++)
216                 if ((fs->in[i].state == STATE_BOF &&
217                      fs->in[i].before == EXT_STOP))
218                     fs->frame_ready = 0;
219         fs->pts = pts;
220     }
221     return 0;
222 }
223
224 static int64_t framesync_pts_extrapolate(FFFrameSync *fs, unsigned in,
225                                          int64_t pts)
226 {
227     /* Possible enhancement: use the link's frame rate */
228     return pts + 1;
229 }
230
231 static void framesync_inject_frame(FFFrameSync *fs, unsigned in, AVFrame *frame)
232 {
233     int64_t pts;
234
235     av_assert0(!fs->in[in].have_next);
236     av_assert0(frame);
237     pts = av_rescale_q(frame->pts, fs->in[in].time_base, fs->time_base);
238     frame->pts = pts;
239     fs->in[in].frame_next = frame;
240     fs->in[in].pts_next   = pts;
241     fs->in[in].have_next  = 1;
242 }
243
244 static void framesync_inject_status(FFFrameSync *fs, unsigned in, int status, int64_t pts)
245 {
246     av_assert0(!fs->in[in].have_next);
247     pts = fs->in[in].state != STATE_RUN || fs->in[in].after == EXT_INFINITY
248         ? INT64_MAX : framesync_pts_extrapolate(fs, in, fs->in[in].pts);
249     fs->in[in].sync = 0;
250     framesync_sync_level_update(fs);
251     fs->in[in].frame_next = NULL;
252     fs->in[in].pts_next   = pts;
253     fs->in[in].have_next  = 1;
254 }
255
256 int ff_framesync_get_frame(FFFrameSync *fs, unsigned in, AVFrame **rframe,
257                             unsigned get)
258 {
259     AVFrame *frame;
260     unsigned need_copy = 0, i;
261     int64_t pts_next;
262     int ret;
263
264     if (!fs->in[in].frame) {
265         *rframe = NULL;
266         return 0;
267     }
268     frame = fs->in[in].frame;
269     if (get) {
270         /* Find out if we need to copy the frame: is there another sync
271            stream, and do we know if its current frame will outlast this one? */
272         pts_next = fs->in[in].have_next ? fs->in[in].pts_next : INT64_MAX;
273         for (i = 0; i < fs->nb_in && !need_copy; i++)
274             if (i != in && fs->in[i].sync &&
275                 (!fs->in[i].have_next || fs->in[i].pts_next < pts_next))
276                 need_copy = 1;
277         if (need_copy) {
278             if (!(frame = av_frame_clone(frame)))
279                 return AVERROR(ENOMEM);
280             if ((ret = av_frame_make_writable(frame)) < 0) {
281                 av_frame_free(&frame);
282                 return ret;
283             }
284         } else {
285             fs->in[in].frame = NULL;
286         }
287         fs->frame_ready = 0;
288     }
289     *rframe = frame;
290     return 0;
291 }
292
293 void ff_framesync_uninit(FFFrameSync *fs)
294 {
295     unsigned i;
296
297     for (i = 0; i < fs->nb_in; i++) {
298         av_frame_free(&fs->in[i].frame);
299         av_frame_free(&fs->in[i].frame_next);
300     }
301
302     av_freep(&fs->in);
303 }
304
305 static int consume_from_fifos(FFFrameSync *fs)
306 {
307     AVFilterContext *ctx = fs->parent;
308     AVFrame *frame = NULL;
309     int64_t pts;
310     unsigned i, nb_active, nb_miss;
311     int ret, status;
312
313     nb_active = nb_miss = 0;
314     for (i = 0; i < fs->nb_in; i++) {
315         if (fs->in[i].have_next || fs->in[i].state == STATE_EOF)
316             continue;
317         nb_active++;
318         ret = ff_inlink_consume_frame(ctx->inputs[i], &frame);
319         if (ret < 0)
320             return ret;
321         if (ret) {
322             av_assert0(frame);
323             framesync_inject_frame(fs, i, frame);
324         } else {
325             ret = ff_inlink_acknowledge_status(ctx->inputs[i], &status, &pts);
326             if (ret > 0) {
327                 framesync_inject_status(fs, i, status, pts);
328             } else if (!ret) {
329                 nb_miss++;
330             }
331         }
332     }
333     if (nb_miss) {
334         if (nb_miss == nb_active && !ff_outlink_frame_wanted(ctx->outputs[0]))
335             return FFERROR_NOT_READY;
336         for (i = 0; i < fs->nb_in; i++)
337             if (!fs->in[i].have_next && fs->in[i].state != STATE_EOF)
338                 ff_inlink_request_frame(ctx->inputs[i]);
339         return 0;
340     }
341     return 1;
342 }
343
344 int ff_framesync_activate(FFFrameSync *fs)
345 {
346     int ret;
347
348     ret = framesync_advance(fs);
349     if (ret < 0)
350         return ret;
351     if (fs->eof || !fs->frame_ready)
352         return 0;
353     ret = fs->on_event(fs);
354     if (ret < 0)
355         return ret;
356     fs->frame_ready = 0;
357
358     return 0;
359 }
360
361 int ff_framesync_init_dualinput(FFFrameSync *fs, AVFilterContext *parent)
362 {
363     int ret;
364
365     ret = ff_framesync_init(fs, parent, 2);
366     if (ret < 0)
367         return ret;
368     fs->in[0].time_base = parent->inputs[0]->time_base;
369     fs->in[1].time_base = parent->inputs[1]->time_base;
370     fs->in[0].sync   = 2;
371     fs->in[0].before = EXT_STOP;
372     fs->in[0].after  = EXT_INFINITY;
373     fs->in[1].sync   = 1;
374     fs->in[1].before = EXT_NULL;
375     fs->in[1].after  = EXT_INFINITY;
376     return 0;
377 }
378
379 int ff_framesync_dualinput_get(FFFrameSync *fs, AVFrame **f0, AVFrame **f1)
380 {
381     AVFilterContext *ctx = fs->parent;
382     AVFrame *mainpic = NULL, *secondpic = NULL;
383     int ret;
384
385     if ((ret = ff_framesync_get_frame(fs, 0, &mainpic,   1)) < 0 ||
386         (ret = ff_framesync_get_frame(fs, 1, &secondpic, 0)) < 0) {
387         av_frame_free(&mainpic);
388         return ret;
389     }
390     av_assert0(mainpic);
391     mainpic->pts = av_rescale_q(fs->pts, fs->time_base, ctx->outputs[0]->time_base);
392     if (ctx->is_disabled)
393         secondpic = NULL;
394     *f0 = mainpic;
395     *f1 = secondpic;
396     return 0;
397 }
398
399 int ff_framesync_dualinput_get_writable(FFFrameSync *fs, AVFrame **f0, AVFrame **f1)
400 {
401     int ret;
402
403     ret = ff_framesync_dualinput_get(fs, f0, f1);
404     if (ret < 0)
405         return ret;
406     ret = ff_inlink_make_frame_writable(fs->parent->inputs[0], f0);
407     if (ret < 0) {
408         av_frame_free(f0);
409         *f1 = NULL;
410         return ret;
411     }
412     return 0;
413 }