|
|
|
|
/*
|
|
|
|
|
* Copyright (C) 2011 Michael Niedermayer (michaelni@gmx.at)
|
|
|
|
|
* Copyright (c) 2012 Justin Ruggles <justin.ruggles@gmail.com>
|
|
|
|
|
*
|
|
|
|
|
* This file is part of Libav.
|
|
|
|
|
*
|
|
|
|
|
* Libav 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.
|
|
|
|
|
*
|
|
|
|
|
* Libav 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 Libav; if not, write to the Free Software
|
|
|
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#include <stdint.h>
|
|
|
|
|
|
|
|
|
|
#include "libavutil/libm.h"
|
|
|
|
|
#include "libavutil/samplefmt.h"
|
|
|
|
|
#include "avresample.h"
|
|
|
|
|
#include "internal.h"
|
|
|
|
|
#include "audio_data.h"
|
|
|
|
|
#include "audio_mix.h"
|
|
|
|
|
|
|
|
|
|
/* channel positions */
|
|
|
|
|
#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 STEREO_LEFT 29
|
|
|
|
|
#define STEREO_RIGHT 30
|
|
|
|
|
#define WIDE_LEFT 31
|
|
|
|
|
#define WIDE_RIGHT 32
|
|
|
|
|
#define SURROUND_DIRECT_LEFT 33
|
|
|
|
|
#define SURROUND_DIRECT_RIGHT 34
|
|
|
|
|
|
|
|
|
|
static av_always_inline int even(uint64_t layout)
|
|
|
|
|
{
|
|
|
|
|
return (!layout || (layout & (layout - 1)));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int sane_layout(uint64_t layout)
|
|
|
|
|
{
|
|
|
|
|
/* check that there is at least 1 front speaker */
|
|
|
|
|
if (!(layout & AV_CH_LAYOUT_SURROUND))
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
/* check for left/right symmetry */
|
|
|
|
|
if (!even(layout & (AV_CH_FRONT_LEFT | AV_CH_FRONT_RIGHT)) ||
|
|
|
|
|
!even(layout & (AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT)) ||
|
|
|
|
|
!even(layout & (AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT)) ||
|
|
|
|
|
!even(layout & (AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER)) ||
|
|
|
|
|
!even(layout & (AV_CH_TOP_FRONT_LEFT | AV_CH_TOP_FRONT_RIGHT)) ||
|
|
|
|
|
!even(layout & (AV_CH_TOP_BACK_LEFT | AV_CH_TOP_BACK_RIGHT)) ||
|
|
|
|
|
!even(layout & (AV_CH_STEREO_LEFT | AV_CH_STEREO_RIGHT)) ||
|
|
|
|
|
!even(layout & (AV_CH_WIDE_LEFT | AV_CH_WIDE_RIGHT)) ||
|
|
|
|
|
!even(layout & (AV_CH_SURROUND_DIRECT_LEFT | AV_CH_SURROUND_DIRECT_RIGHT)))
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int avresample_build_matrix(uint64_t in_layout, uint64_t out_layout,
|
|
|
|
|
double center_mix_level, double surround_mix_level,
|
|
|
|
|
double lfe_mix_level, int normalize,
|
|
|
|
|
double *matrix_out, int stride)
|
|
|
|
|
{
|
|
|
|
|
int i, j, out_i, out_j;
|
|
|
|
|
double matrix[64][64] = {{0}};
|
|
|
|
|
int64_t unaccounted = in_layout & ~out_layout;
|
|
|
|
|
double maxcoef = 0;
|
|
|
|
|
int in_channels, out_channels;
|
|
|
|
|
|
|
|
|
|
in_channels = av_get_channel_layout_nb_channels( in_layout);
|
|
|
|
|
out_channels = av_get_channel_layout_nb_channels(out_layout);
|
|
|
|
|
|
|
|
|
|
memset(matrix_out, 0, out_channels * stride * sizeof(*matrix_out));
|
|
|
|
|
|
|
|
|
|
/* check if layouts are supported */
|
|
|
|
|
if (!in_layout || in_channels > AVRESAMPLE_MAX_CHANNELS)
|
|
|
|
|
return AVERROR(EINVAL);
|
|
|
|
|
if (!out_layout || out_channels > AVRESAMPLE_MAX_CHANNELS)
|
|
|
|
|
return AVERROR(EINVAL);
|
|
|
|
|
|
|
|
|
|
/* check if layouts are unbalanced or abnormal */
|
|
|
|
|
if (!sane_layout(in_layout) || !sane_layout(out_layout))
|
|
|
|
|
return AVERROR_PATCHWELCOME;
|
|
|
|
|
|
|
|
|
|
/* route matching input/output channels */
|
|
|
|
|
for (i = 0; i < 64; i++) {
|
|
|
|
|
if (in_layout & out_layout & (1ULL << i))
|
|
|
|
|
matrix[i][i] = 1.0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* mix front center to front left/right */
|
|
|
|
|
if (unaccounted & AV_CH_FRONT_CENTER) {
|
|
|
|
|
if ((out_layout & AV_CH_LAYOUT_STEREO) == AV_CH_LAYOUT_STEREO) {
|
|
|
|
|
matrix[FRONT_LEFT ][FRONT_CENTER] += M_SQRT1_2;
|
|
|
|
|
matrix[FRONT_RIGHT][FRONT_CENTER] += M_SQRT1_2;
|
|
|
|
|
} else
|
|
|
|
|
return AVERROR_PATCHWELCOME;
|
|
|
|
|
}
|
|
|
|
|
/* mix front left/right to center */
|
|
|
|
|
if (unaccounted & AV_CH_LAYOUT_STEREO) {
|
|
|
|
|
if (out_layout & AV_CH_FRONT_CENTER) {
|
|
|
|
|
matrix[FRONT_CENTER][FRONT_LEFT ] += M_SQRT1_2;
|
|
|
|
|
matrix[FRONT_CENTER][FRONT_RIGHT] += M_SQRT1_2;
|
|
|
|
|
/* mix left/right/center to center */
|
|
|
|
|
if (in_layout & AV_CH_FRONT_CENTER)
|
|
|
|
|
matrix[FRONT_CENTER][FRONT_CENTER] = center_mix_level * M_SQRT2;
|
|
|
|
|
} else
|
|
|
|
|
return AVERROR_PATCHWELCOME;
|
|
|
|
|
}
|
|
|
|
|
/* mix back center to back, side, or front */
|
|
|
|
|
if (unaccounted & AV_CH_BACK_CENTER) {
|
|
|
|
|
if (out_layout & AV_CH_BACK_LEFT) {
|
|
|
|
|
matrix[BACK_LEFT ][BACK_CENTER] += M_SQRT1_2;
|
|
|
|
|
matrix[BACK_RIGHT][BACK_CENTER] += M_SQRT1_2;
|
|
|
|
|
} else if (out_layout & AV_CH_SIDE_LEFT) {
|
|
|
|
|
matrix[SIDE_LEFT ][BACK_CENTER] += M_SQRT1_2;
|
|
|
|
|
matrix[SIDE_RIGHT][BACK_CENTER] += M_SQRT1_2;
|
|
|
|
|
} else if (out_layout & AV_CH_FRONT_LEFT) {
|
|
|
|
|
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_layout & AV_CH_FRONT_CENTER) {
|
|
|
|
|
matrix[FRONT_CENTER][BACK_CENTER] += surround_mix_level * M_SQRT1_2;
|
|
|
|
|
} else
|
|
|
|
|
return AVERROR_PATCHWELCOME;
|
|
|
|
|
}
|
|
|
|
|
/* mix back left/right to back center, side, or front */
|
|
|
|
|
if (unaccounted & AV_CH_BACK_LEFT) {
|
|
|
|
|
if (out_layout & AV_CH_BACK_CENTER) {
|
|
|
|
|
matrix[BACK_CENTER][BACK_LEFT ] += M_SQRT1_2;
|
|
|
|
|
matrix[BACK_CENTER][BACK_RIGHT] += M_SQRT1_2;
|
|
|
|
|
} else if (out_layout & AV_CH_SIDE_LEFT) {
|
|
|
|
|
/* if side channels do not exist in the input, just copy back
|
|
|
|
|
channels to side channels, otherwise mix back into side */
|
|
|
|
|
if (in_layout & 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_layout & AV_CH_FRONT_LEFT) {
|
|
|
|
|
matrix[FRONT_LEFT ][BACK_LEFT ] += surround_mix_level;
|
|
|
|
|
matrix[FRONT_RIGHT][BACK_RIGHT] += surround_mix_level;
|
|
|
|
|
} else if (out_layout & 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
|
|
|
|
|
return AVERROR_PATCHWELCOME;
|
|
|
|
|
}
|
|
|
|
|
/* mix side left/right into back or front */
|
|
|
|
|
if (unaccounted & AV_CH_SIDE_LEFT) {
|
|
|
|
|
if (out_layout & 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_layout & 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_layout & AV_CH_BACK_CENTER) {
|
|
|
|
|
matrix[BACK_CENTER][SIDE_LEFT ] += M_SQRT1_2;
|
|
|
|
|
matrix[BACK_CENTER][SIDE_RIGHT] += M_SQRT1_2;
|
|
|
|
|
} else if (out_layout & AV_CH_FRONT_LEFT) {
|
|
|
|
|
matrix[FRONT_LEFT ][SIDE_LEFT ] += surround_mix_level;
|
|
|
|
|
matrix[FRONT_RIGHT][SIDE_RIGHT] += surround_mix_level;
|
|
|
|
|
} else if (out_layout & 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
|
|
|
|
|
return AVERROR_PATCHWELCOME;
|
|
|
|
|
}
|
|
|
|
|
/* mix left-of-center/right-of-center into front left/right or center */
|
|
|
|
|
if (unaccounted & AV_CH_FRONT_LEFT_OF_CENTER) {
|
|
|
|
|
if (out_layout & 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_layout & 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
|
|
|
|
|
return AVERROR_PATCHWELCOME;
|
|
|
|
|
}
|
|
|
|
|
/* mix LFE into front left/right or center */
|
|
|
|
|
if (unaccounted & AV_CH_LOW_FREQUENCY) {
|
|
|
|
|
if (out_layout & AV_CH_FRONT_CENTER) {
|
|
|
|
|
matrix[FRONT_CENTER][LOW_FREQUENCY] += lfe_mix_level;
|
|
|
|
|
} else if (out_layout & 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
|
|
|
|
|
return AVERROR_PATCHWELCOME;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* transfer internal matrix to output matrix and calculate maximum
|
|
|
|
|
per-channel coefficient sum */
|
|
|
|
|
for (out_i = i = 0; out_i < out_channels && i < 64; i++) {
|
|
|
|
|
double sum = 0;
|
|
|
|
|
for (out_j = j = 0; out_j < in_channels && j < 64; j++) {
|
|
|
|
|
matrix_out[out_i * stride + out_j] = matrix[i][j];
|
|
|
|
|
sum += fabs(matrix[i][j]);
|
|
|
|
|
if (in_layout & (1ULL << j))
|
|
|
|
|
out_j++;
|
|
|
|
|
}
|
|
|
|
|
maxcoef = FFMAX(maxcoef, sum);
|
|
|
|
|
if (out_layout & (1ULL << i))
|
|
|
|
|
out_i++;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* normalize */
|
|
|
|
|
if (normalize && maxcoef > 1.0) {
|
|
|
|
|
for (i = 0; i < out_channels; i++)
|
|
|
|
|
for (j = 0; j < in_channels; j++)
|
|
|
|
|
matrix_out[i * stride + j] /= maxcoef;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int avresample_get_matrix(AVAudioResampleContext *avr, double *matrix,
|
|
|
|
|
int stride)
|
|
|
|
|
{
|
|
|
|
|
int in_channels, out_channels, i, o;
|
|
|
|
|
|
|
|
|
|
in_channels = av_get_channel_layout_nb_channels(avr->in_channel_layout);
|
|
|
|
|
out_channels = av_get_channel_layout_nb_channels(avr->out_channel_layout);
|
|
|
|
|
|
|
|
|
|
if ( in_channels < 0 || in_channels > AVRESAMPLE_MAX_CHANNELS ||
|
|
|
|
|
out_channels < 0 || out_channels > AVRESAMPLE_MAX_CHANNELS) {
|
|
|
|
|
av_log(avr, AV_LOG_ERROR, "Invalid channel layouts\n");
|
|
|
|
|
return AVERROR(EINVAL);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
switch (avr->mix_coeff_type) {
|
|
|
|
|
case AV_MIX_COEFF_TYPE_Q8:
|
|
|
|
|
if (!avr->am->matrix_q8[0]) {
|
|
|
|
|
av_log(avr, AV_LOG_ERROR, "matrix is not set\n");
|
|
|
|
|
return AVERROR(EINVAL);
|
|
|
|
|
}
|
|
|
|
|
for (o = 0; o < out_channels; o++)
|
|
|
|
|
for (i = 0; i < in_channels; i++)
|
|
|
|
|
matrix[o * stride + i] = avr->am->matrix_q8[o][i] / 256.0;
|
|
|
|
|
break;
|
|
|
|
|
case AV_MIX_COEFF_TYPE_Q15:
|
|
|
|
|
if (!avr->am->matrix_q15[0]) {
|
|
|
|
|
av_log(avr, AV_LOG_ERROR, "matrix is not set\n");
|
|
|
|
|
return AVERROR(EINVAL);
|
|
|
|
|
}
|
|
|
|
|
for (o = 0; o < out_channels; o++)
|
|
|
|
|
for (i = 0; i < in_channels; i++)
|
|
|
|
|
matrix[o * stride + i] = avr->am->matrix_q15[o][i] / 32768.0;
|
|
|
|
|
break;
|
|
|
|
|
case AV_MIX_COEFF_TYPE_FLT:
|
|
|
|
|
if (!avr->am->matrix_flt[0]) {
|
|
|
|
|
av_log(avr, AV_LOG_ERROR, "matrix is not set\n");
|
|
|
|
|
return AVERROR(EINVAL);
|
|
|
|
|
}
|
|
|
|
|
for (o = 0; o < out_channels; o++)
|
|
|
|
|
for (i = 0; i < in_channels; i++)
|
|
|
|
|
matrix[o * stride + i] = avr->am->matrix_flt[o][i];
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
av_log(avr, AV_LOG_ERROR, "Invalid mix coeff type\n");
|
|
|
|
|
return AVERROR(EINVAL);
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int avresample_set_matrix(AVAudioResampleContext *avr, const double *matrix,
|
|
|
|
|
int stride)
|
|
|
|
|
{
|
|
|
|
|
int in_channels, out_channels, i, o;
|
|
|
|
|
|
|
|
|
|
in_channels = av_get_channel_layout_nb_channels(avr->in_channel_layout);
|
|
|
|
|
out_channels = av_get_channel_layout_nb_channels(avr->out_channel_layout);
|
|
|
|
|
|
|
|
|
|
if ( in_channels < 0 || in_channels > AVRESAMPLE_MAX_CHANNELS ||
|
|
|
|
|
out_channels < 0 || out_channels > AVRESAMPLE_MAX_CHANNELS) {
|
|
|
|
|
av_log(avr, AV_LOG_ERROR, "Invalid channel layouts\n");
|
|
|
|
|
return AVERROR(EINVAL);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (avr->am->matrix)
|
|
|
|
|
av_freep(avr->am->matrix);
|
|
|
|
|
|
|
|
|
|
#define CONVERT_MATRIX(type, expr) \
|
|
|
|
|
avr->am->matrix_## type[0] = av_mallocz(out_channels * in_channels * \
|
|
|
|
|
sizeof(*avr->am->matrix_## type[0])); \
|
|
|
|
|
if (!avr->am->matrix_## type[0]) \
|
|
|
|
|
return AVERROR(ENOMEM); \
|
|
|
|
|
for (o = 0; o < out_channels; o++) { \
|
|
|
|
|
if (o > 0) \
|
|
|
|
|
avr->am->matrix_## type[o] = avr->am->matrix_## type[o - 1] + \
|
|
|
|
|
in_channels; \
|
|
|
|
|
for (i = 0; i < in_channels; i++) { \
|
|
|
|
|
double v = matrix[o * stride + i]; \
|
|
|
|
|
avr->am->matrix_## type[o][i] = expr; \
|
|
|
|
|
} \
|
|
|
|
|
} \
|
|
|
|
|
avr->am->matrix = (void **)avr->am->matrix_## type;
|
|
|
|
|
|
|
|
|
|
switch (avr->mix_coeff_type) {
|
|
|
|
|
case AV_MIX_COEFF_TYPE_Q8:
|
|
|
|
|
CONVERT_MATRIX(q8, av_clip_int16(lrint(256.0 * v)))
|
|
|
|
|
break;
|
|
|
|
|
case AV_MIX_COEFF_TYPE_Q15:
|
|
|
|
|
CONVERT_MATRIX(q15, av_clipl_int32(llrint(32768.0 * v)))
|
|
|
|
|
break;
|
|
|
|
|
case AV_MIX_COEFF_TYPE_FLT:
|
|
|
|
|
CONVERT_MATRIX(flt, v)
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
av_log(avr, AV_LOG_ERROR, "Invalid mix coeff type\n");
|
|
|
|
|
return AVERROR(EINVAL);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* TODO: detect situations where we can just swap around pointers
|
|
|
|
|
instead of doing matrix multiplications with 0.0 and 1.0 */
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
