af_asyncts: fix request_frame() behavior.
[libav.git] / libavfilter / af_resample.c
CommitLineData
d371e7b9
AK
1/*
2 *
3 * This file is part of Libav.
4 *
5 * Libav is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2.1 of the License, or (at your option) any later version.
9 *
10 * Libav is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
14 *
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with Libav; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
18 */
19
20/**
21 * @file
22 * sample format and channel layout conversion audio filter
23 */
24
25#include "libavutil/avassert.h"
26#include "libavutil/avstring.h"
27#include "libavutil/mathematics.h"
28#include "libavutil/opt.h"
29
30#include "libavresample/avresample.h"
31
32#include "audio.h"
33#include "avfilter.h"
ff1f51a8 34#include "formats.h"
d371e7b9
AK
35#include "internal.h"
36
37typedef struct ResampleContext {
38 AVAudioResampleContext *avr;
39
40 int64_t next_pts;
41} ResampleContext;
42
43static av_cold void uninit(AVFilterContext *ctx)
44{
45 ResampleContext *s = ctx->priv;
46
47 if (s->avr) {
48 avresample_close(s->avr);
49 avresample_free(&s->avr);
50 }
51}
52
53static int query_formats(AVFilterContext *ctx)
54{
55 AVFilterLink *inlink = ctx->inputs[0];
56 AVFilterLink *outlink = ctx->outputs[0];
57
b74a1da4
AK
58 AVFilterFormats *in_formats = ff_all_formats(AVMEDIA_TYPE_AUDIO);
59 AVFilterFormats *out_formats = ff_all_formats(AVMEDIA_TYPE_AUDIO);
ff1f51a8
AK
60 AVFilterFormats *in_samplerates = ff_all_samplerates();
61 AVFilterFormats *out_samplerates = ff_all_samplerates();
62 AVFilterChannelLayouts *in_layouts = ff_all_channel_layouts();
63 AVFilterChannelLayouts *out_layouts = ff_all_channel_layouts();
d371e7b9 64
b74a1da4
AK
65 ff_formats_ref(in_formats, &inlink->out_formats);
66 ff_formats_ref(out_formats, &outlink->in_formats);
d371e7b9 67
b74a1da4
AK
68 ff_formats_ref(in_samplerates, &inlink->out_samplerates);
69 ff_formats_ref(out_samplerates, &outlink->in_samplerates);
ff1f51a8
AK
70
71 ff_channel_layouts_ref(in_layouts, &inlink->out_channel_layouts);
72 ff_channel_layouts_ref(out_layouts, &outlink->in_channel_layouts);
73
d371e7b9
AK
74 return 0;
75}
76
77static int config_output(AVFilterLink *outlink)
78{
79 AVFilterContext *ctx = outlink->src;
80 AVFilterLink *inlink = ctx->inputs[0];
81 ResampleContext *s = ctx->priv;
82 char buf1[64], buf2[64];
83 int ret;
84
85 if (s->avr) {
86 avresample_close(s->avr);
87 avresample_free(&s->avr);
88 }
89
90 if (inlink->channel_layout == outlink->channel_layout &&
91 inlink->sample_rate == outlink->sample_rate &&
92 inlink->format == outlink->format)
93 return 0;
94
95 if (!(s->avr = avresample_alloc_context()))
96 return AVERROR(ENOMEM);
97
98 av_opt_set_int(s->avr, "in_channel_layout", inlink ->channel_layout, 0);
99 av_opt_set_int(s->avr, "out_channel_layout", outlink->channel_layout, 0);
100 av_opt_set_int(s->avr, "in_sample_fmt", inlink ->format, 0);
101 av_opt_set_int(s->avr, "out_sample_fmt", outlink->format, 0);
102 av_opt_set_int(s->avr, "in_sample_rate", inlink ->sample_rate, 0);
103 av_opt_set_int(s->avr, "out_sample_rate", outlink->sample_rate, 0);
104
d371e7b9
AK
105 if ((ret = avresample_open(s->avr)) < 0)
106 return ret;
107
108 outlink->time_base = (AVRational){ 1, outlink->sample_rate };
109 s->next_pts = AV_NOPTS_VALUE;
110
111 av_get_channel_layout_string(buf1, sizeof(buf1),
112 -1, inlink ->channel_layout);
113 av_get_channel_layout_string(buf2, sizeof(buf2),
114 -1, outlink->channel_layout);
115 av_log(ctx, AV_LOG_VERBOSE,
e0d8427d 116 "fmt:%s srate:%d cl:%s -> fmt:%s srate:%d cl:%s\n",
d371e7b9
AK
117 av_get_sample_fmt_name(inlink ->format), inlink ->sample_rate, buf1,
118 av_get_sample_fmt_name(outlink->format), outlink->sample_rate, buf2);
119
120 return 0;
121}
122
123static int request_frame(AVFilterLink *outlink)
124{
125 AVFilterContext *ctx = outlink->src;
126 ResampleContext *s = ctx->priv;
803391f7 127 int ret = ff_request_frame(ctx->inputs[0]);
d371e7b9
AK
128
129 /* flush the lavr delay buffer */
130 if (ret == AVERROR_EOF && s->avr) {
131 AVFilterBufferRef *buf;
132 int nb_samples = av_rescale_rnd(avresample_get_delay(s->avr),
133 outlink->sample_rate,
134 ctx->inputs[0]->sample_rate,
135 AV_ROUND_UP);
136
137 if (!nb_samples)
138 return ret;
139
140 buf = ff_get_audio_buffer(outlink, AV_PERM_WRITE, nb_samples);
141 if (!buf)
142 return AVERROR(ENOMEM);
143
144 ret = avresample_convert(s->avr, (void**)buf->extended_data,
145 buf->linesize[0], nb_samples,
146 NULL, 0, 0);
147 if (ret <= 0) {
148 avfilter_unref_buffer(buf);
149 return (ret == 0) ? AVERROR_EOF : ret;
150 }
151
152 buf->pts = s->next_pts;
153 ff_filter_samples(outlink, buf);
154 return 0;
155 }
156 return ret;
157}
158
159static void filter_samples(AVFilterLink *inlink, AVFilterBufferRef *buf)
160{
161 AVFilterContext *ctx = inlink->dst;
162 ResampleContext *s = ctx->priv;
163 AVFilterLink *outlink = ctx->outputs[0];
164
165 if (s->avr) {
166 AVFilterBufferRef *buf_out;
167 int delay, nb_samples, ret;
168
169 /* maximum possible samples lavr can output */
170 delay = avresample_get_delay(s->avr);
171 nb_samples = av_rescale_rnd(buf->audio->nb_samples + delay,
172 outlink->sample_rate, inlink->sample_rate,
173 AV_ROUND_UP);
174
175 buf_out = ff_get_audio_buffer(outlink, AV_PERM_WRITE, nb_samples);
176 ret = avresample_convert(s->avr, (void**)buf_out->extended_data,
177 buf_out->linesize[0], nb_samples,
178 (void**)buf->extended_data, buf->linesize[0],
179 buf->audio->nb_samples);
180
181 av_assert0(!avresample_available(s->avr));
182
183 if (s->next_pts == AV_NOPTS_VALUE) {
184 if (buf->pts == AV_NOPTS_VALUE) {
185 av_log(ctx, AV_LOG_WARNING, "First timestamp is missing, "
186 "assuming 0.\n");
187 s->next_pts = 0;
188 } else
189 s->next_pts = av_rescale_q(buf->pts, inlink->time_base,
190 outlink->time_base);
191 }
192
193 if (ret > 0) {
194 buf_out->audio->nb_samples = ret;
195 if (buf->pts != AV_NOPTS_VALUE) {
196 buf_out->pts = av_rescale_q(buf->pts, inlink->time_base,
197 outlink->time_base) -
198 av_rescale(delay, outlink->sample_rate,
199 inlink->sample_rate);
200 } else
201 buf_out->pts = s->next_pts;
202
203 s->next_pts = buf_out->pts + buf_out->audio->nb_samples;
204
205 ff_filter_samples(outlink, buf_out);
206 }
207 avfilter_unref_buffer(buf);
208 } else
209 ff_filter_samples(outlink, buf);
210}
211
212AVFilter avfilter_af_resample = {
213 .name = "resample",
214 .description = NULL_IF_CONFIG_SMALL("Audio resampling and conversion."),
215 .priv_size = sizeof(ResampleContext),
216
217 .uninit = uninit,
218 .query_formats = query_formats,
219
220 .inputs = (const AVFilterPad[]) {{ .name = "default",
221 .type = AVMEDIA_TYPE_AUDIO,
222 .filter_samples = filter_samples,
223 .min_perms = AV_PERM_READ },
224 { .name = NULL}},
225 .outputs = (const AVFilterPad[]) {{ .name = "default",
226 .type = AVMEDIA_TYPE_AUDIO,
227 .config_props = config_output,
228 .request_frame = request_frame },
229 { .name = NULL}},
230};