FFmpeg
af_rubberband.c
Go to the documentation of this file.
1 /*
2  * This file is part of FFmpeg.
3  *
4  * FFmpeg is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2.1 of the License, or (at your option) any later version.
8  *
9  * FFmpeg is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with FFmpeg; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17  */
18 
19 #include <rubberband/rubberband-c.h>
20 
22 #include "libavutil/common.h"
23 #include "libavutil/opt.h"
24 
25 #include "audio.h"
26 #include "avfilter.h"
27 #include "filters.h"
28 #include "internal.h"
29 
30 typedef struct RubberBandContext {
31  const AVClass *class;
32  RubberBandState rbs;
33 
34  double tempo, pitch;
37  int64_t nb_samples_out;
38  int64_t nb_samples_in;
39  int64_t first_pts;
40  int64_t last_pts;
42  int eof;
44 
45 #define OFFSET(x) offsetof(RubberBandContext, x)
46 #define A AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
47 #define AT AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
48 
49 static const AVOption rubberband_options[] = {
50  { "tempo", "set tempo scale factor", OFFSET(tempo), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0.01, 100, AT },
51  { "pitch", "set pitch scale factor", OFFSET(pitch), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0.01, 100, AT },
52  { "transients", "set transients", OFFSET(transients), AV_OPT_TYPE_INT, {.i64=0}, 0, INT_MAX, A, .unit = "transients" },
53  { "crisp", 0, 0, AV_OPT_TYPE_CONST, {.i64=RubberBandOptionTransientsCrisp}, 0, 0, A, .unit = "transients" },
54  { "mixed", 0, 0, AV_OPT_TYPE_CONST, {.i64=RubberBandOptionTransientsMixed}, 0, 0, A, .unit = "transients" },
55  { "smooth", 0, 0, AV_OPT_TYPE_CONST, {.i64=RubberBandOptionTransientsSmooth}, 0, 0, A, .unit = "transients" },
56  { "detector", "set detector", OFFSET(detector), AV_OPT_TYPE_INT, {.i64=0}, 0, INT_MAX, A, .unit = "detector" },
57  { "compound", 0, 0, AV_OPT_TYPE_CONST, {.i64=RubberBandOptionDetectorCompound}, 0, 0, A, .unit = "detector" },
58  { "percussive", 0, 0, AV_OPT_TYPE_CONST, {.i64=RubberBandOptionDetectorPercussive}, 0, 0, A, .unit = "detector" },
59  { "soft", 0, 0, AV_OPT_TYPE_CONST, {.i64=RubberBandOptionDetectorSoft}, 0, 0, A, .unit = "detector" },
60  { "phase", "set phase", OFFSET(phase), AV_OPT_TYPE_INT, {.i64=0}, 0, INT_MAX, A, .unit = "phase" },
61  { "laminar", 0, 0, AV_OPT_TYPE_CONST, {.i64=RubberBandOptionPhaseLaminar}, 0, 0, A, .unit = "phase" },
62  { "independent", 0, 0, AV_OPT_TYPE_CONST, {.i64=RubberBandOptionPhaseIndependent}, 0, 0, A, .unit = "phase" },
63  { "window", "set window", OFFSET(window), AV_OPT_TYPE_INT, {.i64=0}, 0, INT_MAX, A, .unit = "window" },
64  { "standard", 0, 0, AV_OPT_TYPE_CONST, {.i64=RubberBandOptionWindowStandard}, 0, 0, A, .unit = "window" },
65  { "short", 0, 0, AV_OPT_TYPE_CONST, {.i64=RubberBandOptionWindowShort}, 0, 0, A, .unit = "window" },
66  { "long", 0, 0, AV_OPT_TYPE_CONST, {.i64=RubberBandOptionWindowLong}, 0, 0, A, .unit = "window" },
67  { "smoothing", "set smoothing", OFFSET(smoothing), AV_OPT_TYPE_INT, {.i64=0}, 0, INT_MAX, A, .unit = "smoothing" },
68  { "off", 0, 0, AV_OPT_TYPE_CONST, {.i64=RubberBandOptionSmoothingOff}, 0, 0, A, .unit = "smoothing" },
69  { "on", 0, 0, AV_OPT_TYPE_CONST, {.i64=RubberBandOptionSmoothingOn}, 0, 0, A, .unit = "smoothing" },
70  { "formant", "set formant", OFFSET(formant), AV_OPT_TYPE_INT, {.i64=0}, 0, INT_MAX, A, .unit = "formant" },
71  { "shifted", 0, 0, AV_OPT_TYPE_CONST, {.i64=RubberBandOptionFormantShifted}, 0, 0, A, .unit = "formant" },
72  { "preserved", 0, 0, AV_OPT_TYPE_CONST, {.i64=RubberBandOptionFormantPreserved}, 0, 0, A, .unit = "formant" },
73  { "pitchq", "set pitch quality", OFFSET(opitch), AV_OPT_TYPE_INT, {.i64=0}, 0, INT_MAX, A, .unit = "pitch" },
74  { "quality", 0, 0, AV_OPT_TYPE_CONST, {.i64=RubberBandOptionPitchHighQuality}, 0, 0, A, .unit = "pitch" },
75  { "speed", 0, 0, AV_OPT_TYPE_CONST, {.i64=RubberBandOptionPitchHighSpeed}, 0, 0, A, .unit = "pitch" },
76  { "consistency", 0, 0, AV_OPT_TYPE_CONST, {.i64=RubberBandOptionPitchHighConsistency}, 0, 0, A, .unit = "pitch" },
77  { "channels", "set channels", OFFSET(channels), AV_OPT_TYPE_INT, {.i64=0}, 0, INT_MAX, A, .unit = "channels" },
78  { "apart", 0, 0, AV_OPT_TYPE_CONST, {.i64=RubberBandOptionChannelsApart}, 0, 0, A, .unit = "channels" },
79  { "together", 0, 0, AV_OPT_TYPE_CONST, {.i64=RubberBandOptionChannelsTogether}, 0, 0, A, .unit = "channels" },
80  { NULL },
81 };
82 
83 AVFILTER_DEFINE_CLASS(rubberband);
84 
86 {
87  RubberBandContext *s = ctx->priv;
88 
89  if (s->rbs)
90  rubberband_delete(s->rbs);
91 }
92 
94 {
95  AVFilterContext *ctx = inlink->dst;
96  RubberBandContext *s = ctx->priv;
97  AVFilterLink *outlink = ctx->outputs[0];
98  AVFrame *out;
99  int ret = 0, nb_samples;
100 
101  if (s->first_pts == AV_NOPTS_VALUE)
102  s->first_pts = in->pts;
103 
104  rubberband_process(s->rbs, (const float *const *)in->extended_data, in->nb_samples, s->eof);
105  s->nb_samples_in += in->nb_samples;
106 
107  nb_samples = rubberband_available(s->rbs);
108  if (nb_samples > 0) {
109  out = ff_get_audio_buffer(outlink, nb_samples);
110  if (!out) {
111  av_frame_free(&in);
112  return AVERROR(ENOMEM);
113  }
114  out->pts = s->first_pts + av_rescale_q(s->nb_samples_out,
115  (AVRational){ 1, outlink->sample_rate },
116  outlink->time_base);
117  s->last_pts = out->pts;
118  nb_samples = rubberband_retrieve(s->rbs, (float *const *)out->extended_data, nb_samples);
119  out->nb_samples = nb_samples;
120  ret = ff_filter_frame(outlink, out);
121  s->nb_samples_out += nb_samples;
122  }
123 
124  av_frame_free(&in);
125  if (ff_inlink_queued_samples(inlink) >= s->nb_samples)
126  ff_filter_set_ready(ctx, 100);
127  return ret < 0 ? ret : nb_samples;
128 }
129 
131 {
132  AVFilterContext *ctx = inlink->dst;
133  RubberBandContext *s = ctx->priv;
134  int opts = s->transients|s->detector|s->phase|s->window|
135  s->smoothing|s->formant|s->opitch|s->channels|
136  RubberBandOptionProcessRealTime;
137 
138  if (s->rbs)
139  rubberband_delete(s->rbs);
140  s->rbs = rubberband_new(inlink->sample_rate, inlink->ch_layout.nb_channels, opts, 1. / s->tempo, s->pitch);
141  if (!s->rbs)
142  return AVERROR(ENOMEM);
143 
144  s->nb_samples = rubberband_get_samples_required(s->rbs);
145  s->first_pts = AV_NOPTS_VALUE;
146 
147  return 0;
148 }
149 
151 {
152  AVFilterLink *inlink = ctx->inputs[0];
153  AVFilterLink *outlink = ctx->outputs[0];
154  RubberBandContext *s = ctx->priv;
155  AVFrame *in = NULL;
156  int64_t pts;
157  int status, ret;
158 
160 
161  ret = ff_inlink_consume_samples(inlink, s->nb_samples, s->nb_samples, &in);
162 
164  s->eof |= status == AVERROR_EOF;
165 
166  if (ret < 0)
167  return ret;
168  if (ret > 0) {
169  ret = filter_frame(inlink, in);
170  if (ret != 0)
171  return ret;
172  }
173 
174  if (s->eof) {
175  ff_outlink_set_status(outlink, AVERROR_EOF, s->last_pts);
176  return 0;
177  }
178 
180 
181  return FFERROR_NOT_READY;
182 }
183 
184 static int process_command(AVFilterContext *ctx, const char *cmd, const char *args,
185  char *res, int res_len, int flags)
186 {
187  RubberBandContext *s = ctx->priv;
188  int ret;
189 
190  ret = ff_filter_process_command(ctx, cmd, args, res, res_len, flags);
191  if (ret < 0)
192  return ret;
193 
194  rubberband_set_time_ratio(s->rbs, 1. / s->tempo);
195  rubberband_set_pitch_scale(s->rbs, s->pitch);
196  s->nb_samples = rubberband_get_samples_required(s->rbs);
197 
198  return 0;
199 }
200 
201 static const AVFilterPad rubberband_inputs[] = {
202  {
203  .name = "default",
204  .type = AVMEDIA_TYPE_AUDIO,
205  .config_props = config_input,
206  },
207 };
208 
210  .name = "rubberband",
211  .description = NULL_IF_CONFIG_SMALL("Apply time-stretching and pitch-shifting."),
212  .priv_size = sizeof(RubberBandContext),
213  .priv_class = &rubberband_class,
214  .uninit = uninit,
215  .activate = activate,
219  .process_command = process_command,
220 };
ff_get_audio_buffer
AVFrame * ff_get_audio_buffer(AVFilterLink *link, int nb_samples)
Request an audio samples buffer with a specific set of permissions.
Definition: audio.c:109
AV_SAMPLE_FMT_FLTP
@ AV_SAMPLE_FMT_FLTP
float, planar
Definition: samplefmt.h:66
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
RubberBandContext::last_pts
int64_t last_pts
Definition: af_rubberband.c:40
out
FILE * out
Definition: movenc.c:54
RubberBandContext::nb_samples
int nb_samples
Definition: af_rubberband.c:41
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1007
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
FFERROR_NOT_READY
return FFERROR_NOT_READY
Definition: filter_design.txt:204
ff_af_rubberband
const AVFilter ff_af_rubberband
Definition: af_rubberband.c:209
FILTER_SINGLE_SAMPLEFMT
#define FILTER_SINGLE_SAMPLEFMT(sample_fmt_)
Definition: internal.h:175
filter_frame
static int filter_frame(AVFilterLink *inlink, AVFrame *in)
Definition: af_rubberband.c:93
config_input
static int config_input(AVFilterLink *inlink)
Definition: af_rubberband.c:130
inlink
The exact code depends on how similar the blocks are and how related they are to the and needs to apply these operations to the correct inlink or outlink if there are several Macros are available to factor that when no extra processing is inlink
Definition: filter_design.txt:212
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:100
RubberBandContext::transients
int transients
Definition: af_rubberband.c:35
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:340
AVFrame::pts
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:452
AVOption
AVOption.
Definition: opt.h:294
rubberband_options
static const AVOption rubberband_options[]
Definition: af_rubberband.c:49
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:170
FF_FILTER_FORWARD_STATUS_BACK
#define FF_FILTER_FORWARD_STATUS_BACK(outlink, inlink)
Forward the status on an output link to an input link.
Definition: filters.h:199
window
static SDL_Window * window
Definition: ffplay.c:364
process_command
static int process_command(AVFilterContext *ctx, const char *cmd, const char *args, char *res, int res_len, int flags)
Definition: af_rubberband.c:184
OFFSET
#define OFFSET(x)
Definition: af_rubberband.c:45
pts
static int64_t pts
Definition: transcode_aac.c:643
RubberBandContext
Definition: af_rubberband.c:30
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:33
rubberband_inputs
static const AVFilterPad rubberband_inputs[]
Definition: af_rubberband.c:201
av_cold
#define av_cold
Definition: attributes.h:90
ff_outlink_set_status
static void ff_outlink_set_status(AVFilterLink *link, int status, int64_t pts)
Set the status field of a link from the source filter.
Definition: filters.h:189
activate
static int activate(AVFilterContext *ctx)
Definition: af_rubberband.c:150
s
#define s(width, name)
Definition: cbs_vp9.c:198
AV_OPT_TYPE_DOUBLE
@ AV_OPT_TYPE_DOUBLE
Definition: opt.h:227
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
filters.h
ctx
AVFormatContext * ctx
Definition: movenc.c:48
channels
channels
Definition: aptx.h:31
av_rescale_q
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
FILTER_INPUTS
#define FILTER_INPUTS(array)
Definition: internal.h:182
opts
AVDictionary * opts
Definition: movenc.c:50
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
ff_inlink_consume_samples
int ff_inlink_consume_samples(AVFilterLink *link, unsigned min, unsigned max, AVFrame **rframe)
Take samples from the link's FIFO and update the link's stats.
Definition: avfilter.c:1458
NULL
#define NULL
Definition: coverity.c:32
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
RubberBandContext::window
int window
Definition: af_rubberband.c:35
ff_audio_default_filterpad
const AVFilterPad ff_audio_default_filterpad[1]
An AVFilterPad array whose only entry has name "default" and is of type AVMEDIA_TYPE_AUDIO.
Definition: audio.c:33
ff_inlink_acknowledge_status
int ff_inlink_acknowledge_status(AVFilterLink *link, int *rstatus, int64_t *rpts)
Test and acknowledge the change of status on the link.
Definition: avfilter.c:1386
A
#define A
Definition: af_rubberband.c:46
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:106
RubberBandContext::opitch
int opitch
Definition: af_rubberband.c:36
RubberBandContext::smoothing
int smoothing
Definition: af_rubberband.c:36
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
ff_filter_process_command
int ff_filter_process_command(AVFilterContext *ctx, const char *cmd, const char *arg, char *res, int res_len, int flags)
Generic processing of user supplied commands that are set in the same way as the filter options.
Definition: avfilter.c:879
RubberBandContext::channels
int channels
Definition: af_rubberband.c:36
RubberBandContext::pitch
double pitch
Definition: af_rubberband.c:34
FF_FILTER_FORWARD_WANTED
FF_FILTER_FORWARD_WANTED(outlink, inlink)
internal.h
AVFrame::nb_samples
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:420
AVFrame::extended_data
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:401
common.h
RubberBandContext::rbs
RubberBandState rbs
Definition: af_rubberband.c:32
RubberBandContext::eof
int eof
Definition: af_rubberband.c:42
AVFilterPad::name
const char * name
Pad name.
Definition: internal.h:39
ff_inlink_queued_samples
int ff_inlink_queued_samples(AVFilterLink *link)
Definition: avfilter.c:1414
RubberBandContext::phase
int phase
Definition: af_rubberband.c:35
AVFilter
Filter definition.
Definition: avfilter.h:166
ret
ret
Definition: filter_design.txt:187
status
ov_status_e status
Definition: dnn_backend_openvino.c:120
channel_layout.h
AVFILTER_DEFINE_CLASS
AVFILTER_DEFINE_CLASS(rubberband)
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:225
avfilter.h
RubberBandContext::nb_samples_in
int64_t nb_samples_in
Definition: af_rubberband.c:38
AVFilterContext
An instance of a filter.
Definition: avfilter.h:409
RubberBandContext::first_pts
int64_t first_pts
Definition: af_rubberband.c:39
audio.h
uninit
static av_cold void uninit(AVFilterContext *ctx)
Definition: af_rubberband.c:85
RubberBandContext::nb_samples_out
int64_t nb_samples_out
Definition: af_rubberband.c:37
FILTER_OUTPUTS
#define FILTER_OUTPUTS(array)
Definition: internal.h:183
RubberBandContext::formant
int formant
Definition: af_rubberband.c:36
RubberBandContext::tempo
double tempo
Definition: af_rubberband.c:34
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:474
AT
#define AT
Definition: af_rubberband.c:47
RubberBandContext::detector
int detector
Definition: af_rubberband.c:35
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:234
ff_filter_set_ready
void ff_filter_set_ready(AVFilterContext *filter, unsigned priority)
Mark a filter ready and schedule it for activation.
Definition: avfilter.c:223