25 #define TEMPLATE_REMATRIX_FLT 27 #undef TEMPLATE_REMATRIX_FLT 29 #define TEMPLATE_REMATRIX_DBL 31 #undef TEMPLATE_REMATRIX_DBL 33 #define TEMPLATE_REMATRIX_S16 38 #undef TEMPLATE_REMATRIX_S16 40 #define TEMPLATE_REMATRIX_S32 42 #undef TEMPLATE_REMATRIX_S32 46 #define FRONT_CENTER 2 47 #define LOW_FREQUENCY 3 50 #define FRONT_LEFT_OF_CENTER 6 51 #define FRONT_RIGHT_OF_CENTER 7 56 #define TOP_FRONT_LEFT 12 57 #define TOP_FRONT_CENTER 13 58 #define TOP_FRONT_RIGHT 14 59 #define TOP_BACK_LEFT 15 60 #define TOP_BACK_CENTER 16 61 #define TOP_BACK_RIGHT 17 62 #define NUM_NAMED_CHANNELS 18 66 int nb_in, nb_out,
in,
out;
76 for (out = 0; out < nb_out; out++) {
77 for (in = 0; in < nb_in; in++)
87 if(layout&(layout-1))
return 1;
120 double center_mix_level,
double surround_mix_level,
121 double lfe_mix_level,
double maxval,
122 double rematrix_volume,
double *matrix_param,
127 int64_t unaccounted, in_ch_layout, out_ch_layout;
131 in_ch_layout =
clean_layout(log_context, in_ch_layout_param);
132 out_ch_layout =
clean_layout(log_context, out_ch_layout_param);
139 if( in_ch_layout == AV_CH_LAYOUT_STEREO_DOWNMIX
140 && (out_ch_layout & AV_CH_LAYOUT_STEREO_DOWNMIX) == 0
149 "Full-on remixing from 22.2 has not yet been implemented! " 150 "Processing the input as '%s'\n",
156 av_log(log_context,
AV_LOG_ERROR,
"Input channel layout '%s' is not supported\n", buf);
162 av_log(log_context,
AV_LOG_ERROR,
"Output channel layout '%s' is not supported\n", buf);
167 if(in_ch_layout & out_ch_layout & (1ULL<<i))
171 unaccounted= in_ch_layout & ~out_ch_layout;
179 if(in_ch_layout & AV_CH_LAYOUT_STEREO) {
190 if(out_ch_layout & AV_CH_FRONT_CENTER){
193 if(in_ch_layout & AV_CH_FRONT_CENTER)
209 if (unaccounted & (AV_CH_BACK_LEFT | AV_CH_SIDE_LEFT)) {
220 }
else if(out_ch_layout & AV_CH_FRONT_CENTER){
226 if(out_ch_layout & AV_CH_BACK_CENTER){
230 if(in_ch_layout & AV_CH_SIDE_LEFT){
252 }
else if(out_ch_layout & AV_CH_FRONT_CENTER){
260 if(out_ch_layout & AV_CH_BACK_LEFT){
263 if (in_ch_layout & AV_CH_BACK_LEFT) {
270 }
else if(out_ch_layout & AV_CH_BACK_CENTER){
288 }
else if(out_ch_layout & AV_CH_FRONT_CENTER){
299 }
else if(out_ch_layout & AV_CH_FRONT_CENTER){
307 if (out_ch_layout & AV_CH_FRONT_CENTER) {
316 for(out_i=i=0; i<64; i++){
319 if((out_ch_layout & (1ULL<<i)) == 0)
322 if((in_ch_layout & (1ULL<<j)) == 0)
325 matrix_param[stride*out_i + in_i] = matrix[
i][j];
327 matrix_param[stride*out_i + in_i] = i == j && (in_ch_layout & out_ch_layout & (1ULL<<
i));
328 sum +=
fabs(matrix_param[stride*out_i + in_i]);
331 maxcoef=
FFMAX(maxcoef, sum);
334 if(rematrix_volume < 0)
335 maxcoef = -rematrix_volume;
337 if(maxcoef > maxval || rematrix_volume < 0){
341 matrix_param[stride*i + j] /= maxcoef;
345 if(rematrix_volume > 0){
348 matrix_param[stride*i + j] *= rematrix_volume;
413 for (i = 0; i < nb_out; i++) {
417 for (j = 0; j < nb_in; j++) {
418 double target = s->
matrix[
i][j] * 32768 + rem;
423 maxsum =
FFMAX(maxsum, sum);
426 if (maxsum <= 32768) {
440 for (i = 0; i < nb_out; i++)
441 for (j = 0; j < nb_in; j++)
452 for (i = 0; i < nb_out; i++)
453 for (j = 0; j < nb_in; j++)
468 for (i = 0; i < nb_out; i++) {
471 for (j = 0; j < nb_in; j++) {
472 double target = s->
matrix[
i][j] * 32768 + rem;
494 if(HAVE_X86ASM && HAVE_MMX)
508 int out_i, in_i,
i, j;
519 off = len1 * out->
bps;
525 for(out_i=0; out_i<out->
ch_count; out_i++){
533 if(s->
matrix[out_i][in_i]!=1.0){
539 memcpy(out->
ch[out_i], in->
ch[in_i], len*out->
bps);
541 out->
ch[out_i]= in->
ch[in_i];
556 for(i=0; i<
len; i++){
562 ((
float*)out->
ch[out_i])[
i]= v;
565 for(i=0; i<
len; i++){
569 v+= ((
double*)in->
ch[in_i])[
i] * s->
matrix[out_i][in_i];
571 ((
double*)out->
ch[out_i])[
i]= v;
574 for(i=0; i<
len; i++){
578 v+= ((int16_t*)in->
ch[in_i])[
i] * s->
matrix32[out_i][in_i];
580 ((int16_t*)out->
ch[out_i])[
i]= (v + 16384)>>15;
struct AudioConvert * in_convert
input conversion context
enum AVSampleFormat int_sample_fmt
internal sample format (AV_SAMPLE_FMT_FLTP or AV_SAMPLE_FMT_S16P)
Audio buffer used for intermediate storage between conversion phases.
#define FRONT_RIGHT_OF_CENTER
#define AV_LOG_WARNING
Something somehow does not look correct.
#define AV_CH_LAYOUT_SURROUND
int ch_count
number of channels
int rematrix_custom
flag to indicate that a custom matrix has been defined
int swri_rematrix(SwrContext *s, AudioData *out, AudioData *in, int len, int mustcopy)
#define FF_ARRAY_ELEMS(a)
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
#define AV_CH_LAYOUT_STEREO
av_cold int swr_build_matrix(uint64_t in_ch_layout_param, uint64_t out_ch_layout_param, double center_mix_level, double surround_mix_level, double lfe_mix_level, double maxval, double rematrix_volume, double *matrix_param, int stride, enum AVMatrixEncoding matrix_encoding, void *log_context)
Generate a channel mixing matrix.
void( mix_2_1_func_type)(void *out, const void *in1, const void *in2, void *coeffp, integer index1, integer index2, integer len)
void * av_calloc(size_t nmemb, size_t size)
Non-inlined equivalent of av_mallocz_array().
int av_get_channel_layout_nb_channels(uint64_t channel_layout)
Return the number of channels in the channel layout.
#define av_assert0(cond)
assert() equivalent, that is always enabled.
av_cold int swri_rematrix_init(SwrContext *s)
int user_out_ch_count
User set output channel count.
enum AVSampleFormat fmt
sample format
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
AudioData out
converted output audio data
#define AV_CH_LOW_FREQUENCY
uint8_t * native_simd_one
#define AV_LOG_VERBOSE
Detailed information.
enum AVSampleFormat out_sample_fmt
output sample format
#define AV_CH_LAYOUT_22POINT2
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
int matrix_encoding
matrixed stereo encoding
float slev
surround mixing level
static __device__ float fabs(float a)
int64_t user_in_ch_layout
User set input channel layout.
The libswresample context.
int swri_rematrix_init_x86(struct SwrContext *s)
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
float clev
center mixing level
simple assert() macros that are a bit more flexible than ISO C assert().
void( mix_any_func_type)(uint8_t **out, const uint8_t **in1, void *coeffp, integer len)
static int64_t clean_layout(void *s, int64_t layout)
mix_2_1_func_type * mix_2_1_simd
#define NUM_NAMED_CHANNELS
int32_t matrix32[SWR_CH_MAX][SWR_CH_MAX]
17.15 fixed point rematrixing coefficients
AudioData midbuf
intermediate audio data (postin/preout)
audio channel layout utility functions
#define AV_CH_LAYOUT_STEREO_DOWNMIX
#define FRONT_LEFT_OF_CENTER
int swr_set_matrix(struct SwrContext *s, const double *matrix, int stride)
Set a customized remix matrix.
mix_1_1_func_type * mix_1_1_f
mix_1_1_func_type * mix_1_1_simd
int64_t out_ch_layout
output channel layout
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
#define AV_CH_FRONT_LEFT_OF_CENTER
mix_any_func_type * mix_any_f
#define AV_CH_FRONT_CENTER
#define AV_CH_FRONT_RIGHT_OF_CENTER
void av_get_channel_layout_string(char *buf, int buf_size, int nb_channels, uint64_t channel_layout)
Return a description of a channel layout.
int user_in_ch_count
User set input channel count.
static av_cold int auto_matrix(SwrContext *s)
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(const int16_t *) pi >> 8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(const int32_t *) pi >> 24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31))))#define SET_CONV_FUNC_GROUP(ofmt, ifmt) static void set_generic_function(AudioConvert *ac){}void ff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, int sample_rate, int apply_map){AudioConvert *ac;int in_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) return NULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method!=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt) > 2){ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc){av_free(ac);return NULL;}return ac;}in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar){ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar?ac->channels:1;}else if(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;else ac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);return ac;}int ff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){int use_generic=1;int len=in->nb_samples;int p;if(ac->dc){av_log(ac->avr, AV_LOG_TRACE,"%d samples - audio_convert: %s to %s (dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));return ff_convert_dither(ac-> in
#define AV_CH_LAYOUT_7POINT1_WIDE_BACK
float matrix_flt[SWR_CH_MAX][SWR_CH_MAX]
single precision floating point rematrixing coefficients
static int sane_layout(int64_t layout)
#define AV_CH_BACK_CENTER
double matrix[SWR_CH_MAX][SWR_CH_MAX]
floating point rematrixing coefficients
int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)
Return number of bytes per sample.
void( mix_1_1_func_type)(void *out, const void *in, void *coeffp, integer index, integer len)
int64_t in_ch_layout
input channel layout
GLint GLenum GLboolean GLsizei stride
enum AVSampleFormat av_get_packed_sample_fmt(enum AVSampleFormat sample_fmt)
Get the packed alternative form of the given sample format.
uint8_t * native_simd_matrix
uint64_t av_channel_layout_extract_channel(uint64_t channel_layout, int index)
Get the channel with the given index in channel_layout.
float lfe_mix_level
LFE mixing level.
const char * av_get_channel_name(uint64_t channel)
Get the name of a given channel.
av_cold void swri_rematrix_free(SwrContext *s)
float rematrix_maxval
maximum value for rematrixing output
float rematrix_volume
rematrixing volume coefficient
mix_2_1_func_type * mix_2_1_f
#define AV_CH_FRONT_RIGHT
static int even(int64_t layout)
uint8_t matrix_ch[SWR_CH_MAX][SWR_CH_MAX+1]
Lists of input channels per output channel that have non zero rematrixing coefficients.
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
uint8_t * ch[SWR_CH_MAX]
samples buffer per channel
int used_ch_count
number of used input channels (mapped channel count if channel_map, otherwise in.ch_count) ...
int64_t user_out_ch_layout
User set output channel layout.
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 layout