7a1f4f31d8c8e575b677d1d290a62adb3494ebda
[ffmpeg.git] / libavfilter / setpts.c
1 /*
2  * Copyright (c) 2010 Stefano Sabatini
3  * Copyright (c) 2008 Victor Paesa
4  *
5  * This file is part of Libav.
6  *
7  * Libav is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * Libav is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with Libav; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21
22 /**
23  * @file
24  * video presentation timestamp (PTS) modification filter
25  */
26
27 /* #define DEBUG */
28
29 #include "libavutil/eval.h"
30 #include "libavutil/internal.h"
31 #include "libavutil/mathematics.h"
32 #include "libavutil/opt.h"
33 #include "libavutil/time.h"
34
35 #include "audio.h"
36 #include "avfilter.h"
37 #include "internal.h"
38 #include "video.h"
39
40 #include "config.h"
41
42 static const char *const var_names[] = {
43     "E",           ///< Euler number
44     "INTERLACED",  ///< tell if the current frame is interlaced
45     "N",           ///< frame / sample number (starting at zero)
46     "PHI",         ///< golden ratio
47     "PI",          ///< greek pi
48     "PREV_INPTS",  ///< previous  input PTS
49     "PREV_OUTPTS", ///< previous output PTS
50     "PTS",         ///< original pts in the file of the frame
51     "STARTPTS",    ///< PTS at start of movie
52     "TB",          ///< timebase
53     "RTCTIME",     ///< wallclock (RTC) time in micro seconds
54     "RTCSTART",    ///< wallclock (RTC) time at the start of the movie in micro seconds
55     "S",           //   Number of samples in the current frame
56     "SR",          //   Audio sample rate
57     NULL
58 };
59
60 enum var_name {
61     VAR_E,
62     VAR_INTERLACED,
63     VAR_N,
64     VAR_PHI,
65     VAR_PI,
66     VAR_PREV_INPTS,
67     VAR_PREV_OUTPTS,
68     VAR_PTS,
69     VAR_STARTPTS,
70     VAR_TB,
71     VAR_RTCTIME,
72     VAR_RTCSTART,
73     VAR_S,
74     VAR_SR,
75     VAR_VARS_NB
76 };
77
78 typedef struct {
79     const AVClass *class;
80     char *expr_str;
81     AVExpr *expr;
82     double var_values[VAR_VARS_NB];
83 } SetPTSContext;
84
85 static av_cold int init(AVFilterContext *ctx)
86 {
87     SetPTSContext *setpts = ctx->priv;
88     int ret;
89
90     if ((ret = av_expr_parse(&setpts->expr, setpts->expr_str,
91                              var_names, NULL, NULL, NULL, NULL, 0, ctx)) < 0) {
92         av_log(ctx, AV_LOG_ERROR, "Error while parsing expression '%s'\n", setpts->expr_str);
93         return ret;
94     }
95
96     setpts->var_values[VAR_E]           = M_E;
97     setpts->var_values[VAR_N]           = 0.0;
98     setpts->var_values[VAR_S]           = 0.0;
99     setpts->var_values[VAR_PHI]         = M_PHI;
100     setpts->var_values[VAR_PI]          = M_PI;
101     setpts->var_values[VAR_PREV_INPTS]  = NAN;
102     setpts->var_values[VAR_PREV_OUTPTS] = NAN;
103     setpts->var_values[VAR_STARTPTS]    = NAN;
104     return 0;
105 }
106
107 static int config_input(AVFilterLink *inlink)
108 {
109     SetPTSContext *setpts = inlink->dst->priv;
110
111     setpts->var_values[VAR_TB] = av_q2d(inlink->time_base);
112     setpts->var_values[VAR_RTCSTART] = av_gettime();
113
114     if (inlink->type == AVMEDIA_TYPE_AUDIO) {
115         setpts->var_values[VAR_SR] = inlink->sample_rate;
116     }
117
118     av_log(inlink->src, AV_LOG_VERBOSE, "TB:%f\n", setpts->var_values[VAR_TB]);
119     return 0;
120 }
121
122 #define D2TS(d)  (isnan(d) ? AV_NOPTS_VALUE : (int64_t)(d))
123 #define TS2D(ts) ((ts) == AV_NOPTS_VALUE ? NAN : (double)(ts))
124
125 static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
126 {
127     SetPTSContext *setpts = inlink->dst->priv;
128     int64_t in_pts = frame->pts;
129     double d;
130
131     if (isnan(setpts->var_values[VAR_STARTPTS]))
132         setpts->var_values[VAR_STARTPTS] = TS2D(frame->pts);
133
134     setpts->var_values[VAR_PTS       ] = TS2D(frame->pts);
135     setpts->var_values[VAR_RTCTIME   ] = av_gettime();
136
137     if (inlink->type == AVMEDIA_TYPE_VIDEO) {
138         setpts->var_values[VAR_INTERLACED] = frame->interlaced_frame;
139     } else {
140         setpts->var_values[VAR_S] = frame->nb_samples;
141     }
142
143     d = av_expr_eval(setpts->expr, setpts->var_values, NULL);
144     frame->pts = D2TS(d);
145
146 #ifdef DEBUG
147     av_log(inlink->dst, AV_LOG_DEBUG,
148            "n:%"PRId64" interlaced:%d pts:%"PRId64" t:%f -> pts:%"PRId64" t:%f\n",
149            (int64_t)setpts->var_values[VAR_N],
150            (int)setpts->var_values[VAR_INTERLACED],
151            in_pts, in_pts * av_q2d(inlink->time_base),
152            frame->pts, frame->pts * av_q2d(inlink->time_base));
153 #endif
154
155
156     if (inlink->type == AVMEDIA_TYPE_VIDEO) {
157         setpts->var_values[VAR_N] += 1.0;
158     } else {
159         setpts->var_values[VAR_N] += frame->nb_samples;
160     }
161
162     setpts->var_values[VAR_PREV_INPTS ] = TS2D(in_pts);
163     setpts->var_values[VAR_PREV_OUTPTS] = TS2D(frame->pts);
164     return ff_filter_frame(inlink->dst->outputs[0], frame);
165 }
166
167 static av_cold void uninit(AVFilterContext *ctx)
168 {
169     SetPTSContext *setpts = ctx->priv;
170     av_expr_free(setpts->expr);
171     setpts->expr = NULL;
172 }
173
174 #define OFFSET(x) offsetof(SetPTSContext, x)
175 #define FLAGS AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM
176 static const AVOption options[] = {
177     { "expr", "Expression determining the frame timestamp", OFFSET(expr_str), AV_OPT_TYPE_STRING, { .str = "PTS" }, .flags = FLAGS },
178     { NULL },
179 };
180
181 #if CONFIG_SETPTS_FILTER
182 static const AVClass setpts_class = {
183     .class_name = "setpts",
184     .item_name  = av_default_item_name,
185     .option     = options,
186     .version    = LIBAVUTIL_VERSION_INT,
187 };
188
189 static const AVFilterPad avfilter_vf_setpts_inputs[] = {
190     {
191         .name             = "default",
192         .type             = AVMEDIA_TYPE_VIDEO,
193         .get_video_buffer = ff_null_get_video_buffer,
194         .config_props     = config_input,
195         .filter_frame     = filter_frame,
196     },
197     { NULL }
198 };
199
200 static const AVFilterPad avfilter_vf_setpts_outputs[] = {
201     {
202         .name = "default",
203         .type = AVMEDIA_TYPE_VIDEO,
204     },
205     { NULL }
206 };
207
208 AVFilter avfilter_vf_setpts = {
209     .name      = "setpts",
210     .description = NULL_IF_CONFIG_SMALL("Set PTS for the output video frame."),
211     .init      = init,
212     .uninit    = uninit,
213
214     .priv_size = sizeof(SetPTSContext),
215     .priv_class = &setpts_class,
216
217     .inputs    = avfilter_vf_setpts_inputs,
218     .outputs   = avfilter_vf_setpts_outputs,
219 };
220 #endif
221
222 #if CONFIG_ASETPTS_FILTER
223 static const AVClass asetpts_class = {
224     .class_name = "asetpts",
225     .item_name  = av_default_item_name,
226     .option     = options,
227     .version    = LIBAVUTIL_VERSION_INT,
228 };
229
230 static const AVFilterPad asetpts_inputs[] = {
231     {
232         .name             = "default",
233         .type             = AVMEDIA_TYPE_AUDIO,
234         .get_audio_buffer = ff_null_get_audio_buffer,
235         .config_props     = config_input,
236         .filter_frame     = filter_frame,
237     },
238     { NULL }
239 };
240
241 static const AVFilterPad asetpts_outputs[] = {
242     {
243         .name = "default",
244         .type = AVMEDIA_TYPE_AUDIO,
245     },
246     { NULL }
247 };
248
249 AVFilter avfilter_af_asetpts = {
250     .name        = "asetpts",
251     .description = NULL_IF_CONFIG_SMALL("Set PTS for the output audio frame."),
252     .init        = init,
253     .uninit      = uninit,
254
255     .priv_size  = sizeof(SetPTSContext),
256     .priv_class = &asetpts_class,
257
258     .inputs    = asetpts_inputs,
259     .outputs   = asetpts_outputs,
260 };
261 #endif