mirrors/ffmpeg
0
0 Fork 0
mirror of https://git.ffmpeg.org/ffmpeg.git synced 2026-10-28 18:15:24 +08:00
Code Activity
Files
master
ffmpeg/libswresample/rematrix.c
T
Kacper Michajłow 09f879b074 swresample: keep integer samples if channels are only copied 
With a matrix, samples of more than 16 bits are mixed in floating
point, which takes the lowest bits of s32. A matrix that only copies
channels computes nothing, so select the internal format like without
a matrix. Layouts that differ in the order of their channels or in
unused ones get such a matrix.

The matrix is built before the format is selected for this. The limit
for its coefficients no longer looks at the selected format. For
mixing that is an integer format only if the output has one or if it
was set, which is what the limit looks at now.

s64 still goes through double, the matrix has no functions for it.

Bump the micro version, as this and the previous commits change which
custom layouts can be used.

Signed-off-by: Kacper Michajłow <kasper93@gmail.com>
2026-09-29 22:16:46 +02:00

947 lines
38 KiB
C
Raw Permalink Blame History

/*
* Copyright (C) 2011-2012 Michael Niedermayer (michaelni@gmx.at)
*
* This file is part of libswresample
*
* libswresample is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* libswresample is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with libswresample; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "swresample_internal.h"
#include "libavutil/avassert.h"
#include "libavutil/channel_layout.h"
#include "libavutil/mem.h"
#define TEMPLATE_REMATRIX_FLT
#include "rematrix_template.c"
#undef TEMPLATE_REMATRIX_FLT
#define TEMPLATE_REMATRIX_DBL
#include "rematrix_template.c"
#undef TEMPLATE_REMATRIX_DBL
#define TEMPLATE_REMATRIX_S16
#include "rematrix_template.c"
#define TEMPLATE_CLIP
#include "rematrix_template.c"
#undef TEMPLATE_CLIP
#undef TEMPLATE_REMATRIX_S16
#define TEMPLATE_REMATRIX_S32
#include "rematrix_template.c"
#undef TEMPLATE_REMATRIX_S32
#define FRONT_LEFT 0
#define FRONT_RIGHT 1
#define FRONT_CENTER 2
#define LOW_FREQUENCY 3
#define BACK_LEFT 4
#define BACK_RIGHT 5
#define FRONT_LEFT_OF_CENTER 6
#define FRONT_RIGHT_OF_CENTER 7
#define BACK_CENTER 8
#define SIDE_LEFT 9
#define SIDE_RIGHT 10
#define TOP_CENTER 11
#define TOP_FRONT_LEFT 12
#define TOP_FRONT_CENTER 13
#define TOP_FRONT_RIGHT 14
#define TOP_BACK_LEFT 15
#define TOP_BACK_CENTER 16
#define TOP_BACK_RIGHT 17
#define LOW_FREQUENCY_2 35
#define TOP_SIDE_LEFT 36
#define TOP_SIDE_RIGHT 37
#define BOTTOM_FRONT_CENTER 38
#define BOTTOM_FRONT_LEFT 39
#define BOTTOM_FRONT_RIGHT 40
#define NUM_NAMED_CHANNELS 41
int swr_set_matrix(struct SwrContext *s, const double *matrix, int stride)
{
int nb_in, nb_out, in, out;
if (!s || s->in_convert || // s needs to be allocated but not initialized
swri_check_chlayout(s, &s->user_in_chlayout , "input") ||
swri_check_chlayout(s, &s->user_out_chlayout, "output")
)
return AVERROR(EINVAL);
memset(s->matrix, 0, sizeof(s->matrix));
nb_in = s->user_in_chlayout.nb_channels;
nb_out = s->user_out_chlayout.nb_channels;
for (out = 0; out < nb_out; out++) {
for (in = 0; in < nb_in; in++)
s->matrix[out][in] = matrix[in];
matrix += stride;
}
s->rematrix_custom = 1;
return 0;
}
static int even(int64_t layout){
if(!layout) return 1;
if(layout&(layout-1)) return 1;
return 0;
}
static int clean_layout(AVChannelLayout *out, const AVChannelLayout *in, void *s)
{
int used = in->nb_channels, idx = 0;
if (in->order == AV_CHANNEL_ORDER_CUSTOM && in->nb_channels > 1) {
used = 0;
for (int i = 0; i < in->nb_channels; i++) {
if (in->u.map[i].id != AV_CHAN_UNUSED) {
idx = i;
used++;
}
}
}
if (used != 1 ||
av_channel_layout_channel_from_index(in, idx) == AV_CHAN_FRONT_CENTER)
return av_channel_layout_copy(out, in);
char buf[128];
av_channel_layout_describe(in, buf, sizeof(buf));
av_log(s, AV_LOG_VERBOSE, "Treating %s as mono\n", buf);
if (in->nb_channels == 1) {
*out = (AVChannelLayout)AV_CHANNEL_LAYOUT_MONO;
return 0;
}
/* the channel keeps its place among the unused ones */
int ret = av_channel_layout_copy(out, in);
if (ret < 0)
return ret;
out->u.map[idx].id = AV_CHAN_FRONT_CENTER;
return 0;
}
/**
* Stereo downmix channels are mixed like stereo, unless the other layout has
* such channels as well. The channels keep their places.
*/
static void clean_downmix(AVChannelLayout *ch_layout, const AVChannelLayout *other)
{
if (av_channel_layout_subset(ch_layout, ~(uint64_t)0) != AV_CH_LAYOUT_STEREO_DOWNMIX ||
av_channel_layout_subset(other, AV_CH_LAYOUT_STEREO_DOWNMIX))
return;
if (ch_layout->order == AV_CHANNEL_ORDER_NATIVE) {
ch_layout->u.mask = AV_CH_LAYOUT_STEREO;
} else if (ch_layout->order == AV_CHANNEL_ORDER_CUSTOM) {
for (int i = 0; i < ch_layout->nb_channels; i++) {
if (ch_layout->u.map[i].id == AV_CHAN_STEREO_LEFT)
ch_layout->u.map[i].id = AV_CHAN_FRONT_LEFT;
else if (ch_layout->u.map[i].id == AV_CHAN_STEREO_RIGHT)
ch_layout->u.map[i].id = AV_CHAN_FRONT_RIGHT;
}
}
}
static int sane_layout(const AVChannelLayout *ch_layout, int mixed) {
if(ch_layout->nb_channels > SWR_CH_MAX)
return 0;
if(ch_layout->order == AV_CHANNEL_ORDER_CUSTOM)
for (int i = 0; i < ch_layout->nb_channels; i++) {
enum AVChannel id = ch_layout->u.map[i].id;
if (id == AV_CHAN_UNUSED)
continue;
if (id >= 64)
return 0;
}
else if (ch_layout->order != AV_CHANNEL_ORDER_NATIVE)
return 0;
if (!mixed)
return 1;
uint64_t mask = av_channel_layout_subset(ch_layout, ~(uint64_t)0);
if(!(mask & AV_CH_LAYOUT_SURROUND)) // at least 1 front speaker
return 0;
if (!even(mask & (AV_CH_FRONT_LEFT | AV_CH_FRONT_RIGHT))) // no asymmetric front
return 0;
if (!even(mask & (AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT))) // no asymmetric side
return 0;
if (!even(mask & (AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT)))
return 0;
if (!even(mask & (AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER)))
return 0;
if (!even(mask & (AV_CH_TOP_FRONT_LEFT | AV_CH_TOP_FRONT_RIGHT)))
return 0;
if (!even(mask & (AV_CH_TOP_BACK_LEFT | AV_CH_TOP_BACK_RIGHT)))
return 0;
if (!even(mask & (AV_CH_TOP_SIDE_LEFT | AV_CH_TOP_SIDE_RIGHT)))
return 0;
if (!even(mask & (AV_CH_BOTTOM_FRONT_LEFT | AV_CH_BOTTOM_FRONT_RIGHT)))
return 0;
return 1;
}
static void build_matrix(const AVChannelLayout *in_ch_layout, const AVChannelLayout *out_ch_layout,
double center_mix_level, double surround_mix_level,
double lfe_mix_level, double maxval, double rematrix_volume, double *matrix_param,
ptrdiff_t stride, enum AVMatrixEncoding matrix_encoding)
{
double matrix[NUM_NAMED_CHANNELS][NUM_NAMED_CHANNELS]={{0}};
uint64_t in_mask = av_channel_layout_subset(in_ch_layout, ~(uint64_t)0);
uint64_t out_mask = av_channel_layout_subset(out_ch_layout, ~(uint64_t)0);
uint64_t unaccounted = in_mask & ~out_mask;
double maxcoef=0;
int i, j;
if (in_ch_layout->order == AV_CHANNEL_ORDER_CUSTOM) {
for (j = 0; j < in_ch_layout->nb_channels; j++) {
if (in_ch_layout->u.map[j].id == AV_CHAN_UNUSED) {
/* the named-channel loop below cannot visit AV_CHAN_UNUSED.
* explicitly clear its column so callers may reuse a matrix. */
for (i = 0; i < out_ch_layout->nb_channels; i++)
matrix_param[stride * i + j] = 0.0;
}
}
}
if (out_ch_layout->order == AV_CHANNEL_ORDER_CUSTOM) {
for (i = 0; i < out_ch_layout->nb_channels; i++) {
if (out_ch_layout->u.map[i].id == AV_CHAN_UNUSED) {
/* the named-channel loop below cannot visit AV_CHAN_UNUSED.
* explicitly clear its row so callers may reuse a matrix. */
for (j = 0; j < in_ch_layout->nb_channels; j++)
matrix_param[stride * i + j] = 0.0;
}
}
}
for(i=0; i<FF_ARRAY_ELEMS(matrix); i++){
if (in_mask & out_mask & (1ULL << i))
matrix[i][i]= 1.0;
}
//FIXME implement dolby surround
//FIXME implement full ac3
if(unaccounted & AV_CH_FRONT_CENTER){
if ((out_mask & AV_CH_LAYOUT_STEREO) == AV_CH_LAYOUT_STEREO) {
if (in_mask & AV_CH_LAYOUT_STEREO) {
matrix[ FRONT_LEFT][FRONT_CENTER]+= center_mix_level;
matrix[FRONT_RIGHT][FRONT_CENTER]+= center_mix_level;
} else {
matrix[ FRONT_LEFT][FRONT_CENTER]+= M_SQRT1_2;
matrix[FRONT_RIGHT][FRONT_CENTER]+= M_SQRT1_2;
}
}else
av_assert0(0);
}
if(unaccounted & AV_CH_LAYOUT_STEREO){
if (out_mask & AV_CH_FRONT_CENTER) {
matrix[FRONT_CENTER][ FRONT_LEFT]+= M_SQRT1_2;
matrix[FRONT_CENTER][FRONT_RIGHT]+= M_SQRT1_2;
if (in_mask & AV_CH_FRONT_CENTER)
matrix[FRONT_CENTER][ FRONT_CENTER] = center_mix_level*sqrt(2);
}else
av_assert0(0);
}
if(unaccounted & AV_CH_BACK_CENTER){
if (out_mask & AV_CH_BACK_LEFT) {
matrix[ BACK_LEFT][BACK_CENTER]+= M_SQRT1_2;
matrix[BACK_RIGHT][BACK_CENTER]+= M_SQRT1_2;
} else if (out_mask & AV_CH_SIDE_LEFT) {
matrix[ SIDE_LEFT][BACK_CENTER]+= M_SQRT1_2;
matrix[SIDE_RIGHT][BACK_CENTER]+= M_SQRT1_2;
} else if (out_mask & AV_CH_FRONT_LEFT) {
if (matrix_encoding == AV_MATRIX_ENCODING_DOLBY ||
matrix_encoding == AV_MATRIX_ENCODING_DPLII) {
if (unaccounted & (AV_CH_BACK_LEFT | AV_CH_SIDE_LEFT)) {
matrix[FRONT_LEFT ][BACK_CENTER] -= surround_mix_level * M_SQRT1_2;
matrix[FRONT_RIGHT][BACK_CENTER] += surround_mix_level * M_SQRT1_2;
} else {
matrix[FRONT_LEFT ][BACK_CENTER] -= surround_mix_level;
matrix[FRONT_RIGHT][BACK_CENTER] += surround_mix_level;
}
} else {
matrix[ FRONT_LEFT][BACK_CENTER]+= surround_mix_level * M_SQRT1_2;
matrix[FRONT_RIGHT][BACK_CENTER]+= surround_mix_level * M_SQRT1_2;
}
} else if (out_mask & AV_CH_FRONT_CENTER) {
matrix[ FRONT_CENTER][BACK_CENTER]+= surround_mix_level * M_SQRT1_2;
}else
av_assert0(0);
}
if(unaccounted & AV_CH_BACK_LEFT){
if (out_mask & AV_CH_BACK_CENTER) {
matrix[BACK_CENTER][ BACK_LEFT]+= M_SQRT1_2;
matrix[BACK_CENTER][BACK_RIGHT]+= M_SQRT1_2;
} else if (out_mask & AV_CH_SIDE_LEFT) {
if (in_mask & AV_CH_SIDE_LEFT) {
matrix[ SIDE_LEFT][ BACK_LEFT]+= M_SQRT1_2;
matrix[SIDE_RIGHT][BACK_RIGHT]+= M_SQRT1_2;
}else{
matrix[ SIDE_LEFT][ BACK_LEFT]+= 1.0;
matrix[SIDE_RIGHT][BACK_RIGHT]+= 1.0;
}
} else if (out_mask & AV_CH_FRONT_LEFT) {
if (matrix_encoding == AV_MATRIX_ENCODING_DOLBY) {
matrix[FRONT_LEFT ][BACK_LEFT ] -= surround_mix_level * M_SQRT1_2;
matrix[FRONT_LEFT ][BACK_RIGHT] -= surround_mix_level * M_SQRT1_2;
matrix[FRONT_RIGHT][BACK_LEFT ] += surround_mix_level * M_SQRT1_2;
matrix[FRONT_RIGHT][BACK_RIGHT] += surround_mix_level * M_SQRT1_2;
} else if (matrix_encoding == AV_MATRIX_ENCODING_DPLII) {
matrix[FRONT_LEFT ][BACK_LEFT ] -= surround_mix_level * SQRT3_2;
matrix[FRONT_LEFT ][BACK_RIGHT] -= surround_mix_level * M_SQRT1_2;
matrix[FRONT_RIGHT][BACK_LEFT ] += surround_mix_level * M_SQRT1_2;
matrix[FRONT_RIGHT][BACK_RIGHT] += surround_mix_level * SQRT3_2;
} else {
matrix[ FRONT_LEFT][ BACK_LEFT] += surround_mix_level;
matrix[FRONT_RIGHT][BACK_RIGHT] += surround_mix_level;
}
} else if (out_mask & AV_CH_FRONT_CENTER) {
matrix[ FRONT_CENTER][BACK_LEFT ]+= surround_mix_level*M_SQRT1_2;
matrix[ FRONT_CENTER][BACK_RIGHT]+= surround_mix_level*M_SQRT1_2;
}else
av_assert0(0);
}
if(unaccounted & AV_CH_SIDE_LEFT){
if (out_mask & AV_CH_BACK_LEFT) {
/* if back channels do not exist in the input, just copy side
channels to back channels, otherwise mix side into back */
if (in_mask & AV_CH_BACK_LEFT) {
matrix[BACK_LEFT ][SIDE_LEFT ] += M_SQRT1_2;
matrix[BACK_RIGHT][SIDE_RIGHT] += M_SQRT1_2;
} else {
matrix[BACK_LEFT ][SIDE_LEFT ] += 1.0;
matrix[BACK_RIGHT][SIDE_RIGHT] += 1.0;
}
} else if (out_mask & AV_CH_BACK_CENTER) {
matrix[BACK_CENTER][ SIDE_LEFT]+= M_SQRT1_2;
matrix[BACK_CENTER][SIDE_RIGHT]+= M_SQRT1_2;
} else if (out_mask & AV_CH_FRONT_LEFT) {
if (matrix_encoding == AV_MATRIX_ENCODING_DOLBY) {
matrix[FRONT_LEFT ][SIDE_LEFT ] -= surround_mix_level * M_SQRT1_2;
matrix[FRONT_LEFT ][SIDE_RIGHT] -= surround_mix_level * M_SQRT1_2;
matrix[FRONT_RIGHT][SIDE_LEFT ] += surround_mix_level * M_SQRT1_2;
matrix[FRONT_RIGHT][SIDE_RIGHT] += surround_mix_level * M_SQRT1_2;
} else if (matrix_encoding == AV_MATRIX_ENCODING_DPLII) {
matrix[FRONT_LEFT ][SIDE_LEFT ] -= surround_mix_level * SQRT3_2;
matrix[FRONT_LEFT ][SIDE_RIGHT] -= surround_mix_level * M_SQRT1_2;
matrix[FRONT_RIGHT][SIDE_LEFT ] += surround_mix_level * M_SQRT1_2;
matrix[FRONT_RIGHT][SIDE_RIGHT] += surround_mix_level * SQRT3_2;
} else {
matrix[ FRONT_LEFT][ SIDE_LEFT] += surround_mix_level;
matrix[FRONT_RIGHT][SIDE_RIGHT] += surround_mix_level;
}
} else if (out_mask & AV_CH_FRONT_CENTER) {
matrix[ FRONT_CENTER][SIDE_LEFT ]+= surround_mix_level * M_SQRT1_2;
matrix[ FRONT_CENTER][SIDE_RIGHT]+= surround_mix_level * M_SQRT1_2;
}else
av_assert0(0);
}
if(unaccounted & AV_CH_FRONT_LEFT_OF_CENTER){
if (out_mask & AV_CH_FRONT_LEFT) {
matrix[ FRONT_LEFT][ FRONT_LEFT_OF_CENTER]+= 1.0;
matrix[FRONT_RIGHT][FRONT_RIGHT_OF_CENTER]+= 1.0;
} else if (out_mask & AV_CH_FRONT_CENTER) {
matrix[ FRONT_CENTER][ FRONT_LEFT_OF_CENTER]+= M_SQRT1_2;
matrix[ FRONT_CENTER][FRONT_RIGHT_OF_CENTER]+= M_SQRT1_2;
}else
av_assert0(0);
}
if (unaccounted & AV_CH_TOP_FRONT_LEFT) {
if (out_mask & AV_CH_TOP_FRONT_CENTER) {
matrix[TOP_FRONT_CENTER][TOP_FRONT_LEFT ] += M_SQRT1_2;
matrix[TOP_FRONT_CENTER][TOP_FRONT_RIGHT] += M_SQRT1_2;
if (in_mask & AV_CH_TOP_FRONT_CENTER)
matrix[TOP_FRONT_CENTER][TOP_FRONT_CENTER] = center_mix_level * sqrt(2);
} else if (out_mask & AV_CH_FRONT_LEFT) {
/* U+030 -> M+030 in ITU-R BS.2127-1, Table 16. */
matrix[FRONT_LEFT ][TOP_FRONT_LEFT ] += 1.0;
matrix[FRONT_RIGHT][TOP_FRONT_RIGHT] += 1.0;
} else if (out_mask & AV_CH_FRONT_CENTER) {
matrix[FRONT_CENTER][TOP_FRONT_LEFT ] += M_SQRT1_2;
matrix[FRONT_CENTER][TOP_FRONT_RIGHT] += M_SQRT1_2;
} else
av_assert0(0);
}
if (unaccounted & AV_CH_TOP_FRONT_CENTER) {
if (out_mask & AV_CH_TOP_FRONT_LEFT) {
/* U+030 = U-030 = sqrt(1/2) */
matrix[TOP_FRONT_LEFT ][TOP_FRONT_CENTER]+= M_SQRT1_2;
matrix[TOP_FRONT_RIGHT][TOP_FRONT_CENTER]+= M_SQRT1_2;
} else if (out_mask & AV_CH_FRONT_CENTER) {
/* M+000 = 1 */
matrix[FRONT_CENTER][TOP_FRONT_CENTER] += 1.0;
} else if (out_mask & AV_CH_FRONT_LEFT) {
/* M+030 = M-030 = sqrt(1/2) */
matrix[FRONT_LEFT ][TOP_FRONT_CENTER] += center_mix_level;
matrix[FRONT_RIGHT][TOP_FRONT_CENTER] += center_mix_level;
} else
av_assert0(0);
}
if (unaccounted & AV_CH_TOP_BACK_LEFT) {
if (out_mask & AV_CH_TOP_BACK_CENTER) {
matrix[TOP_BACK_CENTER][TOP_BACK_LEFT ] += M_SQRT1_2;
matrix[TOP_BACK_CENTER][TOP_BACK_RIGHT] += M_SQRT1_2;
} else if (out_mask & AV_CH_TOP_FRONT_LEFT) {
/* IAMF v1.1.0, Section 7.3.2.1.1. */
matrix[TOP_FRONT_LEFT ][TOP_BACK_LEFT ] += M_SQRT1_2;
matrix[TOP_FRONT_RIGHT][TOP_BACK_RIGHT] += M_SQRT1_2;
} else if (out_mask & AV_CH_BACK_LEFT) {
matrix[BACK_LEFT ][TOP_BACK_LEFT ] += 1.0;
matrix[BACK_RIGHT][TOP_BACK_RIGHT] += 1.0;
} else if (out_mask & AV_CH_SIDE_LEFT) {
matrix[SIDE_LEFT ][TOP_BACK_LEFT ] += 1.0;
matrix[SIDE_RIGHT][TOP_BACK_RIGHT] += 1.0;
} else if (out_mask & AV_CH_FRONT_LEFT) {
matrix[FRONT_LEFT ][TOP_BACK_LEFT ] += surround_mix_level;
matrix[FRONT_RIGHT][TOP_BACK_RIGHT] += surround_mix_level;
} else if (out_mask & AV_CH_FRONT_CENTER) {
matrix[FRONT_CENTER][TOP_BACK_LEFT ] += surround_mix_level*M_SQRT1_2;
matrix[FRONT_CENTER][TOP_BACK_RIGHT] += surround_mix_level*M_SQRT1_2;
} else
av_assert0(0);
}
/* BS.2127-1 maps U+180 to rear outputs before front outputs. */
if (unaccounted & AV_CH_TOP_BACK_CENTER) {
if (out_mask & AV_CH_TOP_BACK_LEFT) {
matrix[TOP_BACK_LEFT ][TOP_BACK_CENTER] += M_SQRT1_2;
matrix[TOP_BACK_RIGHT][TOP_BACK_CENTER] += M_SQRT1_2;
} else if (out_mask & AV_CH_BACK_LEFT) {
matrix[BACK_LEFT ][TOP_BACK_CENTER] += M_SQRT1_2;
matrix[BACK_RIGHT][TOP_BACK_CENTER] += M_SQRT1_2;
} else if (out_mask & AV_CH_SIDE_LEFT) {
matrix[SIDE_LEFT ][TOP_BACK_CENTER] += M_SQRT1_2;
matrix[SIDE_RIGHT][TOP_BACK_CENTER] += M_SQRT1_2;
} else if (out_mask & AV_CH_FRONT_LEFT) {
matrix[FRONT_LEFT ][TOP_BACK_CENTER] += 0.5;
matrix[FRONT_RIGHT][TOP_BACK_CENTER] += 0.5;
} else if (out_mask & AV_CH_FRONT_CENTER)
matrix[FRONT_CENTER][TOP_BACK_CENTER] += 0.5;
else
av_assert0(0);
}
if (unaccounted & AV_CH_TOP_SIDE_LEFT) {
if ((out_mask & (AV_CH_TOP_FRONT_LEFT|AV_CH_TOP_BACK_CENTER)) ==
(AV_CH_TOP_FRONT_LEFT|AV_CH_TOP_BACK_CENTER)) {
/* UH+180 = sqrt(1/3); U±045 = sqrt(2/3)*/
matrix[TOP_FRONT_LEFT ][TOP_SIDE_LEFT ] += SQRT2_3;
matrix[TOP_FRONT_RIGHT][TOP_SIDE_RIGHT] += SQRT2_3;
matrix[TOP_BACK_CENTER][TOP_SIDE_LEFT ] += SQRT1_3;
matrix[TOP_BACK_CENTER][TOP_SIDE_RIGHT] += SQRT1_3;
} else if ((out_mask & (AV_CH_TOP_FRONT_LEFT|AV_CH_TOP_BACK_LEFT)) ==
(AV_CH_TOP_FRONT_LEFT|AV_CH_TOP_BACK_LEFT)) {
/* U±030 = U±110 = sqrt(1/2) */
matrix[TOP_FRONT_LEFT ][TOP_SIDE_LEFT ] += M_SQRT1_2;
matrix[TOP_FRONT_RIGHT][TOP_SIDE_RIGHT] += M_SQRT1_2;
matrix[TOP_BACK_LEFT ][TOP_SIDE_LEFT ] += M_SQRT1_2;
matrix[TOP_BACK_RIGHT][TOP_SIDE_RIGHT] += M_SQRT1_2;
} else if (out_mask & AV_CH_TOP_FRONT_LEFT &&
(out_mask & (AV_CH_BACK_LEFT|AV_CH_SIDE_LEFT))) {
/* U±030 = M±110 = sqrt(1/2) */
matrix[TOP_FRONT_LEFT ][TOP_SIDE_LEFT] += M_SQRT1_2;
matrix[TOP_FRONT_RIGHT][TOP_SIDE_RIGHT] += M_SQRT1_2;
if (out_mask & AV_CH_BACK_LEFT) {
matrix[BACK_LEFT ][TOP_SIDE_LEFT] += M_SQRT1_2;
matrix[BACK_RIGHT][TOP_SIDE_RIGHT] += M_SQRT1_2;
} else if (out_mask & AV_CH_SIDE_LEFT) {
matrix[SIDE_LEFT ][TOP_SIDE_LEFT] += M_SQRT1_2;
matrix[SIDE_RIGHT][TOP_SIDE_RIGHT] += M_SQRT1_2;
}
} else if (out_mask & AV_CH_SIDE_LEFT) {
/* M±090 = 1 */
matrix[SIDE_LEFT ][TOP_SIDE_LEFT ] += 1.0;
matrix[SIDE_RIGHT][TOP_SIDE_RIGHT] += 1.0;
} else if (out_mask & AV_CH_FRONT_LEFT) {
/* M±030 = M±110 = sqrt(1/2) */
matrix[FRONT_LEFT ][TOP_SIDE_LEFT ] += surround_mix_level;
matrix[FRONT_RIGHT][TOP_SIDE_RIGHT] += surround_mix_level;
if (out_mask & AV_CH_BACK_LEFT) {
matrix[BACK_LEFT ][TOP_SIDE_LEFT ] += M_SQRT1_2;
matrix[BACK_RIGHT][TOP_SIDE_RIGHT] += M_SQRT1_2;
}
} else if (out_mask & AV_CH_FRONT_CENTER) {
matrix[FRONT_CENTER][TOP_SIDE_LEFT ] += surround_mix_level*M_SQRT1_2;
matrix[FRONT_CENTER][TOP_SIDE_RIGHT] += surround_mix_level*M_SQRT1_2;
} else
av_assert0(0);
}
if (unaccounted & AV_CH_TOP_CENTER) {
if ((out_mask & (AV_CH_TOP_FRONT_LEFT|AV_CH_TOP_BACK_LEFT)) ==
(AV_CH_TOP_FRONT_LEFT|AV_CH_TOP_BACK_LEFT)) {
/* U+045 = U-045 = U+135 = U-135 = sqrt(1/4) */
matrix[TOP_FRONT_LEFT ][TOP_CENTER] += 0.5;
matrix[TOP_FRONT_RIGHT][TOP_CENTER] += 0.5;
matrix[TOP_BACK_LEFT ][TOP_CENTER] += 0.5;
matrix[TOP_BACK_RIGHT][TOP_CENTER] += 0.5;
} else if ((out_mask & (AV_CH_TOP_FRONT_LEFT|AV_CH_TOP_BACK_CENTER)) ==
(AV_CH_TOP_FRONT_LEFT|AV_CH_TOP_BACK_CENTER)) {
/* U+045 = U-045 = UH+180 = sqrt(1/3) */
matrix[TOP_FRONT_LEFT ][TOP_CENTER] += SQRT1_3;
matrix[TOP_FRONT_RIGHT][TOP_CENTER] += SQRT1_3;
matrix[TOP_BACK_CENTER][TOP_CENTER] += SQRT1_3;
} else if (out_mask & AV_CH_TOP_FRONT_LEFT &&
out_mask & (AV_CH_BACK_LEFT|AV_CH_SIDE_LEFT)) {
/* U+045 = U-045 = M+135 = M-135 = sqrt(1/4) *
* U+030 = U-030 = M+110 = M-110 = sqrt(1/4) */
matrix[TOP_FRONT_LEFT ][TOP_CENTER] += 0.5;
matrix[TOP_FRONT_RIGHT][TOP_CENTER] += 0.5;
if (out_mask & AV_CH_BACK_LEFT) {
matrix[BACK_LEFT ][TOP_CENTER] += 0.5;
matrix[BACK_RIGHT][TOP_CENTER] += 0.5;
} else if (out_mask & AV_CH_SIDE_LEFT) {
matrix[SIDE_LEFT ][TOP_CENTER] += 0.5;
matrix[SIDE_RIGHT][TOP_CENTER] += 0.5;
}
} else if (out_mask & AV_CH_FRONT_LEFT) {
/* M+030 = M-030 = M+135 = M-135 = sqrt(1/4) */
/* M+030 = M-030 = sqrt(1/4) */
matrix[FRONT_LEFT ][TOP_CENTER] += 0.5;
matrix[FRONT_RIGHT][TOP_CENTER] += 0.5;
if (out_mask & AV_CH_BACK_LEFT) {
matrix[BACK_LEFT ][TOP_CENTER] += 0.5;
matrix[BACK_RIGHT][TOP_CENTER] += 0.5;
} else if (out_mask & AV_CH_SIDE_LEFT) {
matrix[SIDE_LEFT ][TOP_CENTER] += 0.5;
matrix[SIDE_RIGHT][TOP_CENTER] += 0.5;
}
} else if (out_mask & AV_CH_FRONT_CENTER) {
matrix[FRONT_CENTER][TOP_CENTER] += 0.5;
} else
av_assert0(0);
}
if (unaccounted & AV_CH_BOTTOM_FRONT_CENTER) {
if (out_mask & AV_CH_FRONT_CENTER) {
matrix[FRONT_CENTER][BOTTOM_FRONT_CENTER] += 1.0;
} else if (out_mask & AV_CH_FRONT_LEFT) {
matrix[FRONT_LEFT ][BOTTOM_FRONT_CENTER] += center_mix_level;
matrix[FRONT_RIGHT][BOTTOM_FRONT_CENTER] += center_mix_level;
} else
av_assert0(0);
}
if (unaccounted & AV_CH_BOTTOM_FRONT_LEFT) {
if (out_mask & AV_CH_BOTTOM_FRONT_CENTER) {
matrix[BOTTOM_FRONT_CENTER][BOTTOM_FRONT_LEFT ] += M_SQRT1_2;
matrix[BOTTOM_FRONT_CENTER][BOTTOM_FRONT_RIGHT] += M_SQRT1_2;
if (in_mask & AV_CH_BOTTOM_FRONT_CENTER)
matrix[BOTTOM_FRONT_CENTER][BOTTOM_FRONT_CENTER] = center_mix_level * sqrt(2);
} else if (out_mask & AV_CH_FRONT_LEFT) {
/* M±030 = 1 */
matrix[FRONT_LEFT ][BOTTOM_FRONT_LEFT ] += 1.0;
matrix[FRONT_RIGHT][BOTTOM_FRONT_RIGHT] += 1.0;
} else if (out_mask & AV_CH_FRONT_CENTER) {
matrix[FRONT_CENTER][BOTTOM_FRONT_LEFT ] += M_SQRT1_2;
matrix[FRONT_CENTER][BOTTOM_FRONT_RIGHT] += M_SQRT1_2;
} else
av_assert0(0);
}
/* mix LFE into front left/right or center */
if (unaccounted & AV_CH_LOW_FREQUENCY) {
if (out_mask & AV_CH_FRONT_CENTER) {
matrix[FRONT_CENTER][LOW_FREQUENCY] += lfe_mix_level;
} else if (out_mask & AV_CH_FRONT_LEFT) {
matrix[FRONT_LEFT ][LOW_FREQUENCY] += lfe_mix_level * M_SQRT1_2;
matrix[FRONT_RIGHT][LOW_FREQUENCY] += lfe_mix_level * M_SQRT1_2;
} else
av_assert0(0);
}
/* mix LFE2 into LFE, front left/right or center */
if (unaccounted & AV_CH_LOW_FREQUENCY_2) {
if (out_mask & AV_CH_LOW_FREQUENCY) {
matrix[LOW_FREQUENCY][LOW_FREQUENCY_2] += M_SQRT1_2;
} else if (out_mask & AV_CH_FRONT_CENTER) {
matrix[FRONT_CENTER][LOW_FREQUENCY_2] += lfe_mix_level;
} else if (out_mask & AV_CH_FRONT_LEFT) {
matrix[FRONT_LEFT ][LOW_FREQUENCY_2] += lfe_mix_level * M_SQRT1_2;
matrix[FRONT_RIGHT][LOW_FREQUENCY_2] += lfe_mix_level * M_SQRT1_2;
} else
av_assert0(0);
}
for (i = 0; i < 64; i++) {
double sum=0;
int out_i = av_channel_layout_index_from_channel(out_ch_layout, i);
if (out_i < 0)
continue;
for(j=0; j<64; j++){
int in_i = av_channel_layout_index_from_channel(in_ch_layout, j);
if (in_i < 0)
continue;
if (i < FF_ARRAY_ELEMS(matrix) && j < FF_ARRAY_ELEMS(matrix[0]))
matrix_param[stride*out_i + in_i] = matrix[i][j];
else
matrix_param[stride*out_i + in_i] = i == j && (in_mask & out_mask & (1ULL << i));
sum += fabs(matrix_param[stride*out_i + in_i]);
}
maxcoef= FFMAX(maxcoef, sum);
}
if(rematrix_volume < 0)
maxcoef = -rematrix_volume;
if(maxcoef > maxval || rematrix_volume < 0){
maxcoef /= maxval;
for(i=0; i<SWR_CH_MAX; i++)
for(j=0; j<SWR_CH_MAX; j++){
matrix_param[stride*i + j] /= maxcoef;
}
}
}
av_cold int swr_build_matrix2(const AVChannelLayout *in_layout, const AVChannelLayout *out_layout,
double center_mix_level, double surround_mix_level,
double lfe_mix_level, double maxval,
double rematrix_volume, double *matrix_param,
ptrdiff_t stride, enum AVMatrixEncoding matrix_encoding, void *log_context)
{
int i, j, ret, mixed;
AVChannelLayout in_ch_layout = { 0 }, out_ch_layout = { 0 };
char buf[128];
ret = clean_layout(&in_ch_layout, in_layout, log_context);
ret |= clean_layout(&out_ch_layout, out_layout, log_context);
if (ret < 0)
goto fail;
clean_downmix(&out_ch_layout, &in_ch_layout);
clean_downmix(&in_ch_layout, &out_ch_layout);
/* the same channels on both sides change their places at most */
mixed = av_channel_layout_subset(&in_ch_layout, ~(uint64_t)0) !=
av_channel_layout_subset(&out_ch_layout, ~(uint64_t)0);
if(!av_channel_layout_check(&in_ch_layout)) {
av_log(log_context, AV_LOG_ERROR, "Input channel layout is invalid\n");
ret = AVERROR(EINVAL);
goto fail;
}
if(!sane_layout(&in_ch_layout, mixed)) {
av_channel_layout_describe(&in_ch_layout, buf, sizeof(buf));
av_log(log_context, AV_LOG_ERROR, "Input channel layout '%s' is not supported\n", buf);
ret = AVERROR(EINVAL);
goto fail;
}
if(!av_channel_layout_check(&out_ch_layout)) {
av_log(log_context, AV_LOG_ERROR, "Output channel layout is invalid\n");
ret = AVERROR(EINVAL);
goto fail;
}
if(!sane_layout(&out_ch_layout, mixed)) {
av_channel_layout_describe(&out_ch_layout, buf, sizeof(buf));
av_log(log_context, AV_LOG_ERROR, "Output channel layout '%s' is not supported\n", buf);
ret = AVERROR(EINVAL);
goto fail;
}
build_matrix(&in_ch_layout, &out_ch_layout, center_mix_level,
surround_mix_level, lfe_mix_level, maxval, rematrix_volume,
matrix_param, stride, matrix_encoding);
if(rematrix_volume > 0){
for(i=0; i<SWR_CH_MAX; i++)
for(j=0; j<SWR_CH_MAX; j++){
matrix_param[stride*i + j] *= rematrix_volume;
}
}
av_log(log_context, AV_LOG_DEBUG, "Matrix coefficients:\n");
for (i = 0; i < out_ch_layout.nb_channels; i++){
av_channel_name(buf, sizeof(buf), av_channel_layout_channel_from_index(&out_ch_layout, i));
av_log(log_context, AV_LOG_DEBUG, "%s: ", buf);
for (j = 0; j < in_ch_layout.nb_channels; j++){
av_channel_name(buf, sizeof(buf), av_channel_layout_channel_from_index(&in_ch_layout, j));
av_log(log_context, AV_LOG_DEBUG, "%s:%f ", buf, matrix_param[stride*i + j]);
}
av_log(log_context, AV_LOG_DEBUG, "\n");
}
ret = 0;
fail:
av_channel_layout_uninit(&in_ch_layout);
av_channel_layout_uninit(&out_ch_layout);
return ret;
}
av_cold static int auto_matrix(SwrContext *s)
{
double maxval;
if (s->rematrix_maxval > 0) {
maxval = s->rematrix_maxval;
} else if ( av_get_packed_sample_fmt(s->out_sample_fmt) < AV_SAMPLE_FMT_FLT
|| (s->user_int_sample_fmt != AV_SAMPLE_FMT_NONE &&
av_get_packed_sample_fmt(s->user_int_sample_fmt) < AV_SAMPLE_FMT_FLT)) {
maxval = 1.0;
} else
maxval = INT_MAX;
memset(s->matrix, 0, sizeof(s->matrix));
return swr_build_matrix2(&s->in_ch_layout, &s->out_ch_layout,
s->clev, s->slev, s->lfe_mix_level,
maxval, s->rematrix_volume, (double*)s->matrix,
s->matrix[1] - s->matrix[0], s->matrix_encoding, s);
}
av_cold int swri_rematrix_build(SwrContext *s)
{
int i, j;
int nb_in = s->used_ch_layout.nb_channels;
int nb_out = s->out.ch_count;
if (!s->rematrix_custom) {
int r = auto_matrix(s);
if (r)
return r;
} else {
char buf[128];
av_log(s, AV_LOG_DEBUG, "Custom matrix coefficients:\n");
double *matrix_param = (double*)s->matrix;
ptrdiff_t stride = s->matrix[1] - s->matrix[0];
for (i = 0; i < s->out_ch_layout.nb_channels; i++) {
av_channel_name(buf, sizeof(buf), av_channel_layout_channel_from_index(&s->out_ch_layout, i));
av_log(s, AV_LOG_DEBUG, "%s: ", buf);
for (j = 0; j < s->in_ch_layout.nb_channels; j++){
av_channel_name(buf, sizeof(buf), av_channel_layout_channel_from_index(&s->in_ch_layout, j));
av_log(s, AV_LOG_DEBUG, "%s:%f ", buf, matrix_param[stride*i + j]);
}
av_log(s, AV_LOG_DEBUG, "\n");
}
}
/* a channel that is one channel of the input, or silent, is not mixed */
for (i = 0; i < nb_out; i++) {
int sources = 0;
for (j = 0; j < nb_in; j++) {
if (s->matrix[i][j] == 0.0)
continue;
if (s->matrix[i][j] != 1.0 || sources++)
return 1;
}
}
return 0;
}
av_cold int swri_rematrix_init(SwrContext *s){
int i, j;
int nb_in = s->used_ch_layout.nb_channels;
int nb_out = s->out.ch_count;
s->mix_any_f = NULL;
/* a matrix that is applied was built by swri_rematrix_build() */
if (!s->rematrix) {
int r = auto_matrix(s);
if (r)
return r;
}
if (s->midbuf.fmt == AV_SAMPLE_FMT_S16P){
int maxsum = 0;
s->native_matrix = av_calloc(nb_in * nb_out, sizeof(int));
if (!s->native_matrix)
return AVERROR(ENOMEM);
for (i = 0; i < nb_out; i++) {
double rem = 0;
int sum = 0;
for (j = 0; j < nb_in; j++) {
double target = s->matrix[i][j] * 32768 + rem;
((int*)s->native_matrix)[i * nb_in + j] = lrintf(target);
rem += target - ((int*)s->native_matrix)[i * nb_in + j];
sum += FFABS(((int*)s->native_matrix)[i * nb_in + j]);
}
maxsum = FFMAX(maxsum, sum);
}
s->native_one.i = 32768;
if (maxsum <= 32768) {
s->mix_1_1_f = copy_s16;
s->mix_2_1_f = sum2_s16;
s->mix_any_f = get_mix_any_func_s16(s);
} else {
s->mix_1_1_f = copy_clip_s16;
s->mix_2_1_f = sum2_clip_s16;
s->mix_any_f = get_mix_any_func_clip_s16(s);
}
}else if(s->midbuf.fmt == AV_SAMPLE_FMT_FLTP){
s->native_matrix = av_calloc(nb_in * nb_out, sizeof(float));
if (!s->native_matrix)
return AVERROR(ENOMEM);
for (i = 0; i < nb_out; i++)
for (j = 0; j < nb_in; j++)
((float*)s->native_matrix)[i * nb_in + j] = s->matrix[i][j];
s->native_one.f = 1.0;
s->mix_1_1_f = copy_float;
s->mix_2_1_f = sum2_float;
s->mix_any_f = get_mix_any_func_float(s);
}else if(s->midbuf.fmt == AV_SAMPLE_FMT_DBLP){
s->native_matrix = av_calloc(nb_in * nb_out, sizeof(double));
if (!s->native_matrix)
return AVERROR(ENOMEM);
for (i = 0; i < nb_out; i++)
for (j = 0; j < nb_in; j++)
((double*)s->native_matrix)[i * nb_in + j] = s->matrix[i][j];
s->native_one.d = 1.0;
s->mix_1_1_f = copy_double;
s->mix_2_1_f = sum2_double;
s->mix_any_f = get_mix_any_func_double(s);
}else if(s->midbuf.fmt == AV_SAMPLE_FMT_S32P){
s->native_matrix = av_calloc(nb_in * nb_out, sizeof(int));
if (!s->native_matrix)
return AVERROR(ENOMEM);
for (i = 0; i < nb_out; i++) {
double rem = 0;
for (j = 0; j < nb_in; j++) {
double target = s->matrix[i][j] * 32768 + rem;
((int*)s->native_matrix)[i * nb_in + j] = lrintf(target);
rem += target - ((int*)s->native_matrix)[i * nb_in + j];
}
}
s->native_one.i = 32768;
s->mix_1_1_f = copy_s32;
s->mix_2_1_f = sum2_s32;
s->mix_any_f = get_mix_any_func_s32(s);
}else
av_assert0(0);
//FIXME quantize for integeres
for (i = 0; i < SWR_CH_MAX; i++) {
int ch_in=0;
for (j = 0; j < SWR_CH_MAX; j++) {
const double coeff = s->matrix[i][j];
if (coeff)
s->matrix_ch[i][++ch_in]= j;
switch (s->int_sample_fmt) {
case AV_SAMPLE_FMT_FLTP:
s->matrix_flt[i][j] = coeff;
break;
case AV_SAMPLE_FMT_DBLP:
break;
default:
s->matrix32[i][j] = lrintf(coeff * 32768);
break;
}
}
s->matrix_ch[i][0]= ch_in;
}
#if ARCH_X86 && HAVE_X86ASM
return swri_rematrix_init_x86(s);
#endif
return 0;
}
av_cold void swri_rematrix_free(SwrContext *s){
av_freep(&s->native_matrix);
av_freep(&s->native_simd_matrix);
}
int swri_rematrix(SwrContext *s, AudioData *out, AudioData *in, int len, int mustcopy){
int out_i, in_i, i, j;
int len1 = 0;
int off = 0;
if(s->mix_any_f) {
s->mix_any_f(out->ch, (const uint8_t *const *)in->ch, s->native_matrix, len);
return 0;
}
if(s->mix_2_1_simd || s->mix_1_1_simd){
len1= len&~15;
off = len1 * out->bps;
}
av_assert0(s->out_ch_layout.order == AV_CHANNEL_ORDER_UNSPEC || out->ch_count == s->out_ch_layout.nb_channels);
av_assert0(s-> in_ch_layout.order == AV_CHANNEL_ORDER_UNSPEC || in ->ch_count == s->in_ch_layout.nb_channels);
for(out_i=0; out_i<out->ch_count; out_i++){
switch(s->matrix_ch[out_i][0]){
case 0:
if(mustcopy)
memset(out->ch[out_i], 0, len * av_get_bytes_per_sample(s->int_sample_fmt));
break;
case 1:
in_i= s->matrix_ch[out_i][1];
if(s->matrix[out_i][in_i]!=1.0){
if(s->mix_1_1_simd && len1)
s->mix_1_1_simd(out->ch[out_i] , in->ch[in_i] , s->native_simd_matrix, in->ch_count*out_i + in_i, len1);
if(len != len1)
s->mix_1_1_f (out->ch[out_i]+off, in->ch[in_i]+off, s->native_matrix, in->ch_count*out_i + in_i, len-len1);
}else if(mustcopy){
memcpy(out->ch[out_i], in->ch[in_i], len*out->bps);
}else{
out->ch[out_i]= in->ch[in_i];
}
break;
case 2: {
int in_i1 = s->matrix_ch[out_i][1];
int in_i2 = s->matrix_ch[out_i][2];
if(s->mix_2_1_simd && len1)
s->mix_2_1_simd(out->ch[out_i] , in->ch[in_i1] , in->ch[in_i2] , s->native_simd_matrix, in->ch_count*out_i + in_i1, in->ch_count*out_i + in_i2, len1);
else
s->mix_2_1_f (out->ch[out_i] , in->ch[in_i1] , in->ch[in_i2] , s->native_matrix, in->ch_count*out_i + in_i1, in->ch_count*out_i + in_i2, len1);
if(len != len1)
s->mix_2_1_f (out->ch[out_i]+off, in->ch[in_i1]+off, in->ch[in_i2]+off, s->native_matrix, in->ch_count*out_i + in_i1, in->ch_count*out_i + in_i2, len-len1);
break;}
default:
if(s->int_sample_fmt == AV_SAMPLE_FMT_FLTP){
for(i=0; i<len; i++){
float v=0;
for(j=0; j<s->matrix_ch[out_i][0]; j++){
in_i= s->matrix_ch[out_i][1+j];
v+= ((float*)in->ch[in_i])[i] * s->matrix_flt[out_i][in_i];
}
((float*)out->ch[out_i])[i]= v;
}
}else if(s->int_sample_fmt == AV_SAMPLE_FMT_DBLP){
for(i=0; i<len; i++){
double v=0;
for(j=0; j<s->matrix_ch[out_i][0]; j++){
in_i= s->matrix_ch[out_i][1+j];
v+= ((double*)in->ch[in_i])[i] * s->matrix[out_i][in_i];
}
((double*)out->ch[out_i])[i]= v;
}
}else{
for(i=0; i<len; i++){
int v=0;
for(j=0; j<s->matrix_ch[out_i][0]; j++){
in_i= s->matrix_ch[out_i][1+j];
v+= ((int16_t*)in->ch[in_i])[i] * s->matrix32[out_i][in_i];
}
((int16_t*)out->ch[out_i])[i]= (v + 16384)>>15;
}
}
}
}
return 0;
}
View Git Blame Copy Permalink