Go to the documentation of this file.
33 if(!
s ||
s->in_convert)
39 #if FF_API_OLD_CHANNEL_LAYOUT
48 s->log_level_offset= log_offset;
88 int log_offset,
void *
log_ctx) {
97 s->log_level_offset = log_offset;
120 #if FF_API_OLD_CHANNEL_LAYOUT
139 if (
a->ch_count == 1)
145 memset(
a, 0,
sizeof(*
a));
149 s->in_buffer_index= 0;
150 s->in_buffer_count= 0;
151 s->resample_in_constraint= 0;
152 memset(
s->in.ch, 0,
sizeof(
s->in.ch));
153 memset(
s->out.ch, 0,
sizeof(
s->out.ch));
170 s->delayed_samples_fixup = 0;
183 s->resampler->free(&
s->resample);
195 char l1[1024], l2[1024];
212 if(
s->out_sample_rate <= 0){
216 #if FF_API_OLD_CHANNEL_LAYOUT
217 s->out.ch_count =
s-> user_out_ch_count;
221 if (
s->user_used_ch_count &&
s->user_used_ch_count !=
s->user_used_chlayout.nb_channels) {
224 s->used_ch_layout.nb_channels =
s->user_used_ch_count;
230 if ((
s->user_in_ch_count &&
s->user_in_ch_count !=
s->user_in_chlayout.nb_channels) ||
232 s->user_in_chlayout.u.mask !=
s->user_in_ch_layout))) {
234 if (
s->user_in_ch_layout)
238 s->in_ch_layout.nb_channels =
s->user_in_ch_count;
243 if ((
s->user_out_ch_count &&
s->user_out_ch_count !=
s->user_out_chlayout.nb_channels) ||
245 s->user_out_chlayout.u.mask !=
s->user_out_ch_layout))) {
247 if (
s->user_out_ch_layout)
251 s->out_ch_layout.nb_channels =
s->user_out_ch_count;
256 if (!
s->out.ch_count)
257 s->out.ch_count =
s->out_ch_layout.nb_channels;
299 s->int_sample_fmt=
s->user_int_sample_fmt;
301 s->dither.method =
s->user_dither_method;
316 if (
s->used_ch_layout.nb_channels !=
s->in_ch_layout.nb_channels)
330 s->rematrix_volume!=1.0 ||
339 &&
s->out_sample_rate==
s->in_sample_rate
345 &&
s->out_sample_rate ==
s->in_sample_rate
370 if (!
s->async &&
s->min_compensation >= FLT_MAX/2)
373 s->outpts =
s->firstpts_in_samples *
s->out_sample_rate;
378 if (
s->min_compensation >= FLT_MAX/2)
379 s->min_compensation = 0.001;
380 if (
s->async > 1.0001) {
381 s->max_soft_compensation =
s->async / (
double)
s->in_sample_rate;
386 s->resample =
s->resampler->init(
s->resample,
s->out_sample_rate,
s->in_sample_rate,
s->filter_size,
s->phase_shift,
s->linear_interp,
s->cutoff,
s->int_sample_fmt,
s->filter_type,
s->kaiser_beta,
s->precision,
s->cheby,
s->exact_rational);
392 s->resampler->free(&
s->resample);
403 #define RSC 1 //FIXME finetune
409 s->out.ch_count =
s->out_ch_layout.nb_channels;
419 #if FF_API_OLD_CHANNEL_LAYOUT
421 av_log(
s,
AV_LOG_ERROR,
"Output channel layout %s mismatches specified channel count %d\n", l2,
s->out.ch_count);
428 av_log(
s,
AV_LOG_ERROR,
"Input channel layout %s mismatches specified channel count %d\n", l1,
s->used_ch_layout.nb_channels);
436 "but there is not enough information to do it\n", l1, l2);
447 s->drop_temp=
s->out;
452 if(!
s->resample && !
s->rematrix && !
s->channel_map && !
s->dither.method){
461 s->int_sample_fmt,
s->out.ch_count,
NULL, 0);
463 if (!
s->in_convert || !
s->out_convert) {
474 s->midbuf.ch_count=
s->used_ch_layout.nb_channels;
476 s->in_buffer.ch_count=
s->used_ch_layout.nb_channels;
478 if(!
s->resample_first){
479 s->midbuf.ch_count=
s->out.ch_count;
481 s->in_buffer.ch_count =
s->out.ch_count;
493 s->dither.noise =
s->preout;
494 s->dither.temp =
s->preout;
496 s->dither.noise.bps = 4;
498 s->dither.noise_scale = 1;
501 if(
s->rematrix ||
s->dither.method) {
518 if(count < 0 || count > INT_MAX/2/
a->bps/
a->ch_count)
521 if(
a->count >= count)
535 for(
i=0;
i<
a->ch_count;
i++){
536 a->ch[
i]=
a->data +
i*(
a->planar ? countb :
a->bps);
537 if(
a->count &&
a->planar) memcpy(
a->ch[
i], old.
ch[
i],
a->count*
a->bps);
539 if(
a->count && !
a->planar) memcpy(
a->ch[0], old.
ch[0],
a->count*
a->ch_count*
a->bps);
553 for(ch=0; ch<
out->ch_count; ch++)
554 memcpy(
out->ch[ch],
in->
ch[ch], count*
out->bps);
562 memset(
out->ch, 0,
sizeof(
out->ch));
563 }
else if(
out->planar){
564 for(
i=0;
i<
out->ch_count;
i++)
565 out->ch[
i]= in_arg[
i];
567 for(
i=0;
i<
out->ch_count;
i++)
575 for(
i=0;
i<
out->ch_count;
i++)
576 in_arg[
i]=
out->ch[
i];
578 in_arg[0]=
out->ch[0];
589 for(ch=0; ch<
out->ch_count; ch++)
592 for(ch=
out->ch_count-1; ch>=0; ch--)
593 out->ch[ch]=
in->
ch[0] + (ch + count*
out->ch_count) *
out->bps;
602 const AudioData * in_param,
int in_count){
615 border =
s->resampler->invert_initial_buffer(
s->resample, &
s->in_buffer,
616 &
in, in_count, &
s->in_buffer_index, &
s->in_buffer_count);
617 if (border == INT_MAX) {
619 }
else if (border < 0) {
624 s->resample_in_constraint = 0;
629 if(!
s->resample_in_constraint &&
s->in_buffer_count){
631 ret=
s->resampler->multiple_resample(
s->resample, &
out, out_count, &
tmp,
s->in_buffer_count, &consumed);
635 s->in_buffer_count -= consumed;
636 s->in_buffer_index += consumed;
640 if(
s->in_buffer_count <= border){
642 in_count +=
s->in_buffer_count;
643 s->in_buffer_count=0;
644 s->in_buffer_index=0;
649 if((
s->flushed || in_count > padless) && !
s->in_buffer_count){
650 s->in_buffer_index=0;
651 ret=
s->resampler->multiple_resample(
s->resample, &
out, out_count, &
in,
FFMAX(in_count-padless, 0), &consumed);
655 in_count -= consumed;
660 size=
s->in_buffer_index +
s->in_buffer_count + in_count;
661 if(
size >
s->in_buffer.count
664 copy(&
s->in_buffer, &
tmp,
s->in_buffer_count);
665 s->in_buffer_index=0;
672 if(
s->in_buffer_count &&
s->in_buffer_count+2 < count && out_count) count=
s->in_buffer_count+2;
674 buf_set(&
tmp, &
s->in_buffer,
s->in_buffer_index +
s->in_buffer_count);
676 s->in_buffer_count += count;
680 s->resample_in_constraint= 0;
681 if(
s->in_buffer_count != count || in_count)
691 s->resample_in_constraint= !!out_count;
713 if(
s->resample_first){
714 av_assert0(
s->midbuf.ch_count ==
s->used_ch_layout.nb_channels);
727 midbuf_tmp=
s->midbuf;
729 preout_tmp=
s->preout;
735 if(
s->resample_first ? !
s->resample : !
s->rematrix)
738 if(
s->resample_first ? !
s->rematrix : !
s->resample)
741 if(
s->int_sample_fmt ==
s->out_sample_fmt &&
s->out.planar
744 out_count=
FFMIN(out_count, in_count);
758 if(
s->resample_first){
774 if(
s->dither.method){
776 int dither_count=
FFMAX(out_count, 1<<16);
779 conv_src = &
s->dither.temp;
787 for(ch=0; ch<
s->dither.noise.ch_count; ch++)
788 if((
ret=
swri_get_dither(
s,
s->dither.noise.ch[ch],
s->dither.noise.count, (12345678913579ULL*ch + 3141592) % 2718281828
U,
s->dither.noise.fmt))<0)
792 if(
s->dither.noise_pos + out_count >
s->dither.noise.count)
793 s->dither.noise_pos = 0;
796 if (
s->mix_2_1_simd) {
797 int len1= out_count&~15;
802 s->mix_2_1_simd(conv_src->
ch[ch],
preout->
ch[ch],
s->dither.noise.ch[ch] +
s->dither.noise.bps *
s->dither.noise_pos,
s->native_simd_one, 0, 0, len1);
803 if(out_count != len1)
805 s->mix_2_1_f(conv_src->
ch[ch] + off,
preout->
ch[ch] + off,
s->dither.noise.ch[ch] +
s->dither.noise.bps *
s->dither.noise_pos + off,
s->native_one, 0, 0, out_count - len1);
808 s->mix_2_1_f(conv_src->
ch[ch],
preout->
ch[ch],
s->dither.noise.ch[ch] +
s->dither.noise.bps *
s->dither.noise_pos,
s->native_one, 0, 0, out_count);
811 switch(
s->int_sample_fmt) {
818 s->dither.noise_pos += out_count;
827 return !!
s->in_buffer.ch_count;
831 uint8_t **out_arg,
int out_count,
832 const uint8_t **in_arg,
int in_count)
842 #if defined(ASSERT_LEVEL) && ASSERT_LEVEL >1
846 while(
s->drop_output > 0){
849 #define MAX_DROP_STEP 16384
854 s->drop_output *= -1;
856 s->drop_output *= -1;
859 s->drop_output -=
ret;
860 if (!
s->drop_output && !out_arg)
872 s->resampler->flush(
s);
873 s->resample_in_constraint = 0;
875 }
else if(!
s->in_buffer_count){
885 if(
ret>0 && !
s->drop_output)
886 s->outpts +=
ret * (int64_t)
s->in_sample_rate;
902 s->in_buffer_count -=
ret;
903 s->in_buffer_index +=
ret;
906 if(!
s->in_buffer_count)
907 s->in_buffer_index = 0;
911 size=
s->in_buffer_index +
s->in_buffer_count + in_count - out_count;
913 if(in_count > out_count) {
914 if(
size >
s->in_buffer.count
917 copy(&
s->in_buffer, &
tmp,
s->in_buffer_count);
918 s->in_buffer_index=0;
934 buf_set(&
tmp, &
s->in_buffer,
s->in_buffer_index +
s->in_buffer_count);
936 s->in_buffer_count += in_count;
939 if(ret2>0 && !
s->drop_output)
940 s->outpts += ret2 * (int64_t)
s->in_sample_rate;
941 av_assert2(max_output < 0 || ret2 < 0 || ret2 <= max_output);
948 s->drop_output += count;
950 if(
s->drop_output <= 0)
964 #define MAX_SILENCE_STEP 16384
974 if(
s->silence.planar)
for(
i=0;
i<
s->silence.ch_count;
i++) {
975 memset(
s->silence.ch[
i],
s->silence.bps==1 ? 0x80 : 0, count*
s->silence.bps);
977 memset(
s->silence.ch[0],
s->silence.bps==1 ? 0x80 : 0, count*
s->silence.bps*
s->silence.ch_count);
986 if (
s->resampler &&
s->resample){
987 return s->resampler->get_delay(
s,
base);
989 return (
s->in_buffer_count*
base + (
s->in_sample_rate>>1))/
s->in_sample_rate;
1000 if (
s->resampler &&
s->resample) {
1001 if (!
s->resampler->get_out_samples)
1003 out_samples =
s->resampler->get_out_samples(
s, in_samples);
1005 out_samples =
s->in_buffer_count + in_samples;
1009 if (out_samples > INT_MAX)
1018 if (!
s || compensation_distance < 0)
1020 if (!compensation_distance && sample_delta)
1028 if (!
s->resampler->set_compensation){
1031 return s->resampler->set_compensation(
s->resample, sample_delta, compensation_distance);
1036 if(
pts == INT64_MIN)
1040 s->outpts =
s->firstpts =
pts;
1042 if(
s->min_compensation >= FLT_MAX) {
1045 int64_t
delta =
pts -
swr_get_delay(
s,
s->in_sample_rate * (int64_t)
s->out_sample_rate) -
s->outpts +
s->drop_output*(int64_t)
s->in_sample_rate;
1046 double fdelta =
delta /(
double)(
s->in_sample_rate * (int64_t)
s->out_sample_rate);
1048 if(
fabs(fdelta) >
s->min_compensation) {
1049 if(
s->outpts ==
s->firstpts ||
fabs(fdelta) >
s->min_hard_compensation){
1056 }
else if(
s->soft_compensation_duration &&
s->max_soft_compensation) {
1057 int duration =
s->out_sample_rate *
s->soft_compensation_duration;
#define FF_ENABLE_DEPRECATION_WARNINGS
@ AV_SAMPLE_FMT_FLTP
float, planar
#define AV_LOG_WARNING
Something somehow does not look correct.
static int swr_convert_internal(struct SwrContext *s, AudioData *out, int out_count, AudioData *in, int in_count)
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
static void fill_audiodata(AudioData *out, uint8_t *in_arg[SWR_CH_MAX])
void swri_noise_shaping_int16(SwrContext *s, AudioData *dsts, const AudioData *srcs, const AudioData *noises, int count)
int in_sample_rate
input sample rate
static void free_temp(AudioData *a)
static void comp(unsigned char *dst, ptrdiff_t dst_stride, unsigned char *src, ptrdiff_t src_stride, int add)
int swr_set_compensation(struct SwrContext *s, int sample_delta, int compensation_distance)
Activate resampling compensation ("soft" compensation).
int out_sample_rate
output sample rate
@ AV_SAMPLE_FMT_S32P
signed 32 bits, planar
AVChannelLayout out_ch_layout
output channel layout
AVChannelLayout user_in_chlayout
User set input channel layout.
#define AV_LOG_VERBOSE
Detailed information.
int swr_set_channel_mapping(struct SwrContext *s, const int *channel_map)
Set a customized input channel mapping.
enum AVChannelOrder order
Channel order used in this layout.
static void copy(AudioData *out, AudioData *in, int count)
int av_get_channel_layout_nb_channels(uint64_t channel_layout)
Return the number of channels in the channel layout.
int nb_channels
Number of channels in this layout.
int in_buffer_index
cached buffer position
void swri_noise_shaping_float(SwrContext *s, AudioData *dsts, const AudioData *srcs, const AudioData *noises, int count)
@ SWR_ENGINE_SOXR
SoX Resampler.
static void buf_set(AudioData *out, AudioData *in, int count)
out may be equal in.
enum AVSampleFormat out_sample_fmt
output sample format
int swri_realloc_audio(AudioData *a, int count)
int swr_is_initialized(struct SwrContext *s)
Check whether an swr context has been initialized or not.
@ AV_SAMPLE_FMT_S64P
signed 64 bits, planar
#define ss(width, name, subs,...)
int64_t swr_next_pts(struct SwrContext *s, int64_t pts)
Convert the next timestamp from input to output timestamps are in 1/(in_sample_rate * out_sample_rate...
int64_t swr_get_delay(struct SwrContext *s, int64_t base)
Gets the delay the next input sample will experience relative to the next output sample.
enum AVSampleFormat av_get_planar_sample_fmt(enum AVSampleFormat sample_fmt)
Get the planar alternative form of the given sample format.
AudioData postin
post-input audio data: used for rematrix/resample
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
int swr_inject_silence(struct SwrContext *s, int count)
Injects the specified number of silence samples.
av_cold int swr_init(struct SwrContext *s)
Initialize context after user parameters have been set.
int av_channel_layout_describe(const AVChannelLayout *channel_layout, char *buf, size_t buf_size)
Get a human-readable string describing the channel layout properties.
AVChannelLayout user_out_chlayout
User set output channel layout.
@ AV_CHANNEL_ORDER_UNSPEC
Only the channel count is specified, without any further information about the channel order.
FF_ENABLE_DEPRECATION_WARNINGS int av_channel_layout_from_mask(AVChannelLayout *channel_layout, uint64_t mask)
Initialize a native channel layout from a bitmask indicating which channels are present.
av_cold struct SwrContext * swr_alloc(void)
Allocate SwrContext.
#define av_assert0(cond)
assert() equivalent, that is always enabled.
int av_sample_fmt_is_planar(enum AVSampleFormat sample_fmt)
Check if the sample format is planar.
int swri_rematrix(SwrContext *s, AudioData *out, AudioData *in, int len, int mustcopy)
@ SWR_DITHER_NS
not part of API/ABI
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
int planar
1 if planar audio, 0 otherwise
struct AudioConvert * in_convert
input conversion context
static const uint8_t channel_map[8][8]
int swri_audio_convert(AudioConvert *ctx, AudioData *out, AudioData *in, int len)
Convert between audio sample formats.
const char * av_get_sample_fmt_name(enum AVSampleFormat sample_fmt)
Return the name of sample_fmt, or NULL if sample_fmt is not recognized.
The libswresample context.
uint8_t * data
samples buffer
uint8_t * ch[SWR_CH_MAX]
samples buffer per channel
AVChannelLayout in_ch_layout
input channel layout
void swri_noise_shaping_int32(SwrContext *s, AudioData *dsts, const AudioData *srcs, const AudioData *noises, int count)
AudioData midbuf
intermediate audio data (postin/preout)
static __device__ float fabs(float a)
static void reversefill_audiodata(AudioData *out, uint8_t *in_arg[SWR_CH_MAX])
void * log_ctx
parent logging context
static int resample(SwrContext *s, AudioData *out_param, int out_count, const AudioData *in_param, int in_count)
struct Resampler const swri_soxr_resampler
int av_opt_set_int(void *obj, const char *name, int64_t val, int search_flags)
int ch_count
number of channels
int swr_alloc_set_opts2(struct SwrContext **ps, const AVChannelLayout *out_ch_layout, enum AVSampleFormat out_sample_fmt, int out_sample_rate, const AVChannelLayout *in_ch_layout, enum AVSampleFormat in_sample_fmt, int in_sample_rate, int log_offset, void *log_ctx)
Allocate SwrContext if needed and set/reset common parameters.
@ AV_SAMPLE_FMT_NB
Number of sample formats. DO NOT USE if linking dynamically.
An AVChannelLayout holds information about the channel layout of audio data.
AudioData preout
pre-output audio data: used for rematrix/resample
int av_opt_set_chlayout(void *obj, const char *name, const AVChannelLayout *channel_layout, int search_flags)
#define SWR_FLAG_RESAMPLE
Force resampling even if equal sample rate.
int swr_drop_output(struct SwrContext *s, int count)
Drops the specified number of output samples.
#define AV_NOPTS_VALUE
Undefined timestamp value.
av_cold void swr_free(SwrContext **ss)
Free the given SwrContext and set the pointer to NULL.
int attribute_align_arg swr_convert(struct SwrContext *s, uint8_t **out_arg, int out_count, const uint8_t **in_arg, int in_count)
Convert audio.
av_cold void swri_rematrix_free(SwrContext *s)
@ SWR_ENGINE_SWR
SW Resampler.
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
AudioConvert * swri_audio_convert_alloc(enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, const int *ch_map, int flags)
Create an audio sample format converter context.
@ AV_CHANNEL_ORDER_NATIVE
The native channel order, i.e.
@ AV_SAMPLE_FMT_S16P
signed 16 bits, planar
int av_channel_layout_compare(const AVChannelLayout *chl, const AVChannelLayout *chl1)
Check whether two channel layouts are semantically the same, i.e.
void av_channel_layout_default(AVChannelLayout *ch_layout, int nb_channels)
Get the default channel layout for a given number of channels.
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
#define i(width, name, range_min, range_max)
int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)
Return number of bytes per sample.
int swri_get_dither(SwrContext *s, void *dst, int len, unsigned seed, enum AVSampleFormat noise_fmt)
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
AVSampleFormat
Audio sample formats.
float max_soft_compensation
swr maximum soft compensation in seconds over soft_compensation_duration
av_cold int swri_dither_init(SwrContext *s, enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt)
void swri_noise_shaping_double(SwrContext *s, AudioData *dsts, const AudioData *srcs, const AudioData *noises, int count)
static void clear_context(SwrContext *s)
void * av_calloc(size_t nmemb, size_t size)
enum AVSampleFormat in_sample_fmt
input sample format
static void set_audiodata_fmt(AudioData *a, enum AVSampleFormat fmt)
int av_channel_layout_check(const AVChannelLayout *channel_layout)
Check whether a channel layout is valid, i.e.
enum AVSampleFormat fmt
sample format
void av_channel_layout_uninit(AVChannelLayout *channel_layout)
Free any allocated data in the channel layout and reset the channel count to 0.
void swri_audio_convert_free(AudioConvert **ctx)
Free audio sample format converter context.
@ AV_SAMPLE_FMT_DBLP
double, planar
av_cold int swri_rematrix_init(SwrContext *s)
int av_channel_layout_copy(AVChannelLayout *dst, const AVChannelLayout *src)
Make a copy of a channel layout.
#define FF_DISABLE_DEPRECATION_WARNINGS
int swr_get_out_samples(struct SwrContext *s, int in_samples)
Find an upper bound on the number of samples that the next swr_convert call will output,...
AudioData in
input audio data
av_cold void swr_close(SwrContext *s)
Closes the context so that swr_is_initialized() returns 0.
struct Resampler const swri_resampler