diff options
Diffstat (limited to 'media/libcubeb/src/cubeb_mixer.cpp')
| -rw-r--r-- | media/libcubeb/src/cubeb_mixer.cpp | 663 |
1 files changed, 0 insertions, 663 deletions
diff --git a/media/libcubeb/src/cubeb_mixer.cpp b/media/libcubeb/src/cubeb_mixer.cpp deleted file mode 100644 index 2ab7f673a..000000000 --- a/media/libcubeb/src/cubeb_mixer.cpp +++ /dev/null @@ -1,663 +0,0 @@ -/* - * Copyright © 2016 Mozilla Foundation - * - * This program is made available under an ISC-style license. See the - * accompanying file LICENSE for details. - * - * Adapted from code based on libswresample's rematrix.c - */ - -#define NOMINMAX - -#include <algorithm> -#include <cassert> -#include <climits> -#include <cmath> -#include <cstdlib> -#include <memory> -#include <type_traits> -#include "cubeb-internal.h" -#include "cubeb_mixer.h" -#include "cubeb_utils.h" - -#ifndef FF_ARRAY_ELEMS -#define FF_ARRAY_ELEMS(a) (sizeof(a) / sizeof((a)[0])) -#endif - -#define CHANNELS_MAX 32 -#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 NUM_NAMED_CHANNELS 18 - -#ifndef M_SQRT1_2 -#define M_SQRT1_2 0.70710678118654752440 /* 1/sqrt(2) */ -#endif -#ifndef M_SQRT2 -#define M_SQRT2 1.41421356237309504880 /* sqrt(2) */ -#endif -#define SQRT3_2 1.22474487139158904909 /* sqrt(3/2) */ - -#define C30DB M_SQRT2 -#define C15DB 1.189207115 -#define C__0DB 1.0 -#define C_15DB 0.840896415 -#define C_30DB M_SQRT1_2 -#define C_45DB 0.594603558 -#define C_60DB 0.5 - -static cubeb_channel_layout -cubeb_channel_layout_check(cubeb_channel_layout l, uint32_t c) -{ - if (l == CUBEB_LAYOUT_UNDEFINED) { - switch (c) { - case 1: return CUBEB_LAYOUT_MONO; - case 2: return CUBEB_LAYOUT_STEREO; - } - } - return l; -} - -unsigned int cubeb_channel_layout_nb_channels(cubeb_channel_layout x) -{ -#if __GNUC__ || __clang__ - return __builtin_popcount (x); -#else - x -= (x >> 1) & 0x55555555; - x = (x & 0x33333333) + ((x >> 2) & 0x33333333); - x = (x + (x >> 4)) & 0x0F0F0F0F; - x += x >> 8; - return (x + (x >> 16)) & 0x3F; -#endif -} - -struct MixerContext { - MixerContext(cubeb_sample_format f, - uint32_t in_channels, - cubeb_channel_layout in, - uint32_t out_channels, - cubeb_channel_layout out) - : _format(f) - , _in_ch_layout(cubeb_channel_layout_check(in, in_channels)) - , _out_ch_layout(cubeb_channel_layout_check(out, out_channels)) - , _in_ch_count(in_channels) - , _out_ch_count(out_channels) - { - if (in_channels != cubeb_channel_layout_nb_channels(in) || - out_channels != cubeb_channel_layout_nb_channels(out)) { - // Mismatch between channels and layout, aborting. - return; - } - _valid = init() >= 0; - } - - static bool even(cubeb_channel_layout layout) - { - if (!layout) { - return true; - } - if (layout & (layout - 1)) { - return true; - } - return false; - } - - // Ensure that the layout is sane (that is have symmetrical left/right - // channels), if not, layout will be treated as mono. - static cubeb_channel_layout clean_layout(cubeb_channel_layout layout) - { - if (layout && layout != CHANNEL_FRONT_LEFT && !(layout & (layout - 1))) { - LOG("Treating layout as mono"); - return CHANNEL_FRONT_CENTER; - } - - return layout; - } - - static bool sane_layout(cubeb_channel_layout layout) - { - if (!(layout & CUBEB_LAYOUT_3F)) { // at least 1 front speaker - return false; - } - if (!even(layout & (CHANNEL_FRONT_LEFT | - CHANNEL_FRONT_RIGHT))) { // no asymetric front - return false; - } - if (!even(layout & - (CHANNEL_SIDE_LEFT | CHANNEL_SIDE_RIGHT))) { // no asymetric side - return false; - } - if (!even(layout & (CHANNEL_BACK_LEFT | CHANNEL_BACK_RIGHT))) { - return false; - } - if (!even(layout & - (CHANNEL_FRONT_LEFT_OF_CENTER | CHANNEL_FRONT_RIGHT_OF_CENTER))) { - return false; - } - if (cubeb_channel_layout_nb_channels(layout) >= CHANNELS_MAX) { - return false; - } - return true; - } - - int auto_matrix(); - int init(); - - const cubeb_sample_format _format; - const cubeb_channel_layout _in_ch_layout; ///< input channel layout - const cubeb_channel_layout _out_ch_layout; ///< output channel layout - const uint32_t _in_ch_count; ///< input channel count - const uint32_t _out_ch_count; ///< output channel count - const float _surround_mix_level = C_30DB; ///< surround mixing level - const float _center_mix_level = C_30DB; ///< center mixing level - const float _lfe_mix_level = 1; ///< LFE mixing level - double _matrix[CHANNELS_MAX][CHANNELS_MAX] = {{ 0 }}; ///< floating point rematrixing coefficients - float _matrix_flt[CHANNELS_MAX][CHANNELS_MAX] = {{ 0 }}; ///< single precision floating point rematrixing coefficients - int32_t _matrix32[CHANNELS_MAX][CHANNELS_MAX] = {{ 0 }}; ///< 17.15 fixed point rematrixing coefficients - uint8_t _matrix_ch[CHANNELS_MAX][CHANNELS_MAX+1] = {{ 0 }}; ///< Lists of input channels per output channel that have non zero rematrixing coefficients - bool _clipping = false; ///< Set to true if clipping detection is required - bool _valid = false; ///< Set to true if context is valid. -}; - -int MixerContext::auto_matrix() -{ - double matrix[NUM_NAMED_CHANNELS][NUM_NAMED_CHANNELS] = { { 0 } }; - double maxcoef = 0; - float maxval; - - cubeb_channel_layout in_ch_layout = clean_layout(_in_ch_layout); - cubeb_channel_layout out_ch_layout = clean_layout(_out_ch_layout); - - if (!sane_layout(in_ch_layout)) { - // Channel Not Supported - LOG("Input Layout %x is not supported", _in_ch_layout); - return -1; - } - - if (!sane_layout(out_ch_layout)) { - LOG("Output Layout %x is not supported", _out_ch_layout); - return -1; - } - - for (uint32_t i = 0; i < FF_ARRAY_ELEMS(matrix); i++) { - if (in_ch_layout & out_ch_layout & (1U << i)) { - matrix[i][i] = 1.0; - } - } - - cubeb_channel_layout unaccounted = in_ch_layout & ~out_ch_layout; - - // Rematrixing is done via a matrix of coefficient that should be applied to - // all channels. Channels are treated as pair and must be symmetrical (if a - // left channel exists, the corresponding right should exist too) unless the - // output layout has similar layout. Channels are then mixed toward the front - // center or back center if they exist with a slight bias toward the front. - - if (unaccounted & CHANNEL_FRONT_CENTER) { - if ((out_ch_layout & CUBEB_LAYOUT_STEREO) == CUBEB_LAYOUT_STEREO) { - if (in_ch_layout & CUBEB_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; - } - } - } - if (unaccounted & CUBEB_LAYOUT_STEREO) { - if (out_ch_layout & CHANNEL_FRONT_CENTER) { - matrix[FRONT_CENTER][FRONT_LEFT] += M_SQRT1_2; - matrix[FRONT_CENTER][FRONT_RIGHT] += M_SQRT1_2; - if (in_ch_layout & CHANNEL_FRONT_CENTER) - matrix[FRONT_CENTER][FRONT_CENTER] = _center_mix_level * M_SQRT2; - } - } - - if (unaccounted & CHANNEL_BACK_CENTER) { - if (out_ch_layout & CHANNEL_BACK_LEFT) { - matrix[BACK_LEFT][BACK_CENTER] += M_SQRT1_2; - matrix[BACK_RIGHT][BACK_CENTER] += M_SQRT1_2; - } else if (out_ch_layout & CHANNEL_SIDE_LEFT) { - matrix[SIDE_LEFT][BACK_CENTER] += M_SQRT1_2; - matrix[SIDE_RIGHT][BACK_CENTER] += M_SQRT1_2; - } else if (out_ch_layout & CHANNEL_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_ch_layout & CHANNEL_FRONT_CENTER) { - matrix[FRONT_CENTER][BACK_CENTER] += - _surround_mix_level * M_SQRT1_2; - } - } - if (unaccounted & CHANNEL_BACK_LEFT) { - if (out_ch_layout & CHANNEL_BACK_CENTER) { - matrix[BACK_CENTER][BACK_LEFT] += M_SQRT1_2; - matrix[BACK_CENTER][BACK_RIGHT] += M_SQRT1_2; - } else if (out_ch_layout & CHANNEL_SIDE_LEFT) { - if (in_ch_layout & CHANNEL_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_ch_layout & CHANNEL_FRONT_LEFT) { - matrix[FRONT_LEFT][BACK_LEFT] += _surround_mix_level; - matrix[FRONT_RIGHT][BACK_RIGHT] += _surround_mix_level; - } else if (out_ch_layout & CHANNEL_FRONT_CENTER) { - matrix[FRONT_CENTER][BACK_LEFT] += _surround_mix_level * M_SQRT1_2; - matrix[FRONT_CENTER][BACK_RIGHT] += _surround_mix_level * M_SQRT1_2; - } - } - - if (unaccounted & CHANNEL_SIDE_LEFT) { - if (out_ch_layout & CHANNEL_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_ch_layout & CHANNEL_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_ch_layout & CHANNEL_BACK_CENTER) { - matrix[BACK_CENTER][SIDE_LEFT] += M_SQRT1_2; - matrix[BACK_CENTER][SIDE_RIGHT] += M_SQRT1_2; - } else if (out_ch_layout & CHANNEL_FRONT_LEFT) { - matrix[FRONT_LEFT][SIDE_LEFT] += _surround_mix_level; - matrix[FRONT_RIGHT][SIDE_RIGHT] += _surround_mix_level; - } else if (out_ch_layout & CHANNEL_FRONT_CENTER) { - matrix[FRONT_CENTER][SIDE_LEFT] += _surround_mix_level * M_SQRT1_2; - matrix[FRONT_CENTER][SIDE_RIGHT] += _surround_mix_level * M_SQRT1_2; - } - } - - if (unaccounted & CHANNEL_FRONT_LEFT_OF_CENTER) { - if (out_ch_layout & CHANNEL_FRONT_LEFT) { - matrix[FRONT_LEFT][FRONT_LEFT_OF_CENTER] += 1.0; - matrix[FRONT_RIGHT][FRONT_RIGHT_OF_CENTER] += 1.0; - } else if (out_ch_layout & CHANNEL_FRONT_CENTER) { - matrix[FRONT_CENTER][FRONT_LEFT_OF_CENTER] += M_SQRT1_2; - matrix[FRONT_CENTER][FRONT_RIGHT_OF_CENTER] += M_SQRT1_2; - } - } - /* mix LFE into front left/right or center */ - if (unaccounted & CHANNEL_LOW_FREQUENCY) { - if (out_ch_layout & CHANNEL_FRONT_CENTER) { - matrix[FRONT_CENTER][LOW_FREQUENCY] += _lfe_mix_level; - } else if (out_ch_layout & CHANNEL_FRONT_LEFT) { - matrix[FRONT_LEFT][LOW_FREQUENCY] += _lfe_mix_level * M_SQRT1_2; - matrix[FRONT_RIGHT][LOW_FREQUENCY] += _lfe_mix_level * M_SQRT1_2; - } - } - - // Normalize the conversion matrix. - for (uint32_t out_i = 0, i = 0; i < CHANNELS_MAX; i++) { - double sum = 0; - int in_i = 0; - if ((out_ch_layout & (1U << i)) == 0) { - continue; - } - for (uint32_t j = 0; j < CHANNELS_MAX; j++) { - if ((in_ch_layout & (1U << j)) == 0) { - continue; - } - if (i < FF_ARRAY_ELEMS(matrix) && j < FF_ARRAY_ELEMS(matrix[0])) { - _matrix[out_i][in_i] = matrix[i][j]; - } else { - _matrix[out_i][in_i] = - i == j && (in_ch_layout & out_ch_layout & (1U << i)); - } - sum += fabs(_matrix[out_i][in_i]); - in_i++; - } - maxcoef = std::max(maxcoef, sum); - out_i++; - } - - if (_format == CUBEB_SAMPLE_S16NE) { - maxval = 1.0; - } else { - maxval = INT_MAX; - } - - // Normalize matrix if needed. - if (maxcoef > maxval) { - maxcoef /= maxval; - for (uint32_t i = 0; i < CHANNELS_MAX; i++) - for (uint32_t j = 0; j < CHANNELS_MAX; j++) { - _matrix[i][j] /= maxcoef; - } - } - - if (_format == CUBEB_SAMPLE_FLOAT32NE) { - for (uint32_t i = 0; i < FF_ARRAY_ELEMS(_matrix); i++) { - for (uint32_t j = 0; j < FF_ARRAY_ELEMS(_matrix[0]); j++) { - _matrix_flt[i][j] = _matrix[i][j]; - } - } - } - - return 0; -} - -int MixerContext::init() -{ - int r = auto_matrix(); - if (r) { - return r; - } - - // Determine if matrix operation would overflow - if (_format == CUBEB_SAMPLE_S16NE) { - int maxsum = 0; - for (uint32_t i = 0; i < _out_ch_count; i++) { - double rem = 0; - int sum = 0; - - for (uint32_t j = 0; j < _in_ch_count; j++) { - double target = _matrix[i][j] * 32768 + rem; - int value = lrintf(target); - rem += target - value; - sum += std::abs(value); - } - maxsum = std::max(maxsum, sum); - } - if (maxsum > 32768) { - _clipping = true; - } - } - - // FIXME quantize for integers - for (uint32_t i = 0; i < CHANNELS_MAX; i++) { - int ch_in = 0; - for (uint32_t j = 0; j < CHANNELS_MAX; j++) { - _matrix32[i][j] = lrintf(_matrix[i][j] * 32768); - if (_matrix[i][j]) { - _matrix_ch[i][++ch_in] = j; - } - } - _matrix_ch[i][0] = ch_in; - } - - return 0; -} - -template<typename TYPE_SAMPLE, typename TYPE_COEFF, typename F> -void -sum2(TYPE_SAMPLE * out, - uint32_t stride_out, - const TYPE_SAMPLE * in1, - const TYPE_SAMPLE * in2, - uint32_t stride_in, - TYPE_COEFF coeff1, - TYPE_COEFF coeff2, - F&& operand, - uint32_t frames) -{ - static_assert( - std::is_same<TYPE_COEFF, - typename std::result_of<F(TYPE_COEFF)>::type>::value, - "function must return the same type as used by matrix_coeff"); - for (uint32_t i = 0; i < frames; i++) { - *out = operand(coeff1 * *in1 + coeff2 * *in2); - out += stride_out; - in1 += stride_in; - in2 += stride_in; - } -} - -template<typename TYPE_SAMPLE, typename TYPE_COEFF, typename F> -void -copy(TYPE_SAMPLE * out, - uint32_t stride_out, - const TYPE_SAMPLE * in, - uint32_t stride_in, - TYPE_COEFF coeff, - F&& operand, - uint32_t frames) -{ - static_assert( - std::is_same<TYPE_COEFF, - typename std::result_of<F(TYPE_COEFF)>::type>::value, - "function must return the same type as used by matrix_coeff"); - for (uint32_t i = 0; i < frames; i++) { - *out = operand(coeff * *in); - out += stride_out; - in += stride_in; - } -} - -template <typename TYPE, typename TYPE_COEFF, size_t COLS, typename F> -static int rematrix(const MixerContext * s, TYPE * aOut, const TYPE * aIn, - const TYPE_COEFF (&matrix_coeff)[COLS][COLS], - F&& aF, uint32_t frames) -{ - static_assert( - std::is_same<TYPE_COEFF, - typename std::result_of<F(TYPE_COEFF)>::type>::value, - "function must return the same type as used by matrix_coeff"); - - for (uint32_t out_i = 0; out_i < s->_out_ch_count; out_i++) { - TYPE* out = aOut + out_i; - switch (s->_matrix_ch[out_i][0]) { - case 0: - for (uint32_t i = 0; i < frames; i++) { - out[i * s->_out_ch_count] = 0; - } - break; - case 1: { - int in_i = s->_matrix_ch[out_i][1]; - copy(out, - s->_out_ch_count, - aIn + in_i, - s->_in_ch_count, - matrix_coeff[out_i][in_i], - aF, - frames); - } break; - case 2: - sum2(out, - s->_out_ch_count, - aIn + s->_matrix_ch[out_i][1], - aIn + s->_matrix_ch[out_i][2], - s->_in_ch_count, - matrix_coeff[out_i][s->_matrix_ch[out_i][1]], - matrix_coeff[out_i][s->_matrix_ch[out_i][2]], - aF, - frames); - break; - default: - for (uint32_t i = 0; i < frames; i++) { - TYPE_COEFF v = 0; - for (uint32_t j = 0; j < s->_matrix_ch[out_i][0]; j++) { - uint32_t in_i = s->_matrix_ch[out_i][1 + j]; - v += - *(aIn + in_i + i * s->_in_ch_count) * matrix_coeff[out_i][in_i]; - } - out[i * s->_out_ch_count] = aF(v); - } - break; - } - } - return 0; -} - -struct cubeb_mixer -{ - cubeb_mixer(cubeb_sample_format format, - uint32_t in_channels, - cubeb_channel_layout in_layout, - uint32_t out_channels, - cubeb_channel_layout out_layout) - : _context(format, in_channels, in_layout, out_channels, out_layout) - { - } - - template<typename T> - void copy_and_trunc(size_t frames, - const T * input_buffer, - T * output_buffer) const - { - if (_context._in_ch_count <= _context._out_ch_count) { - // Not enough channels to copy, fill the gaps with silence. - if (_context._in_ch_count == 1 && _context._out_ch_count >= 2) { - // Special case for upmixing mono input to stereo and more. We will - // duplicate the mono channel to the first two channels. On most system, - // the first two channels are for left and right. It is commonly - // expected that mono will on both left+right channels - for (uint32_t i = 0; i < frames; i++) { - output_buffer[0] = output_buffer[1] = *input_buffer; - PodZero(output_buffer + 2, _context._out_ch_count - 2); - output_buffer += _context._out_ch_count; - input_buffer++; - } - return; - } - for (uint32_t i = 0; i < frames; i++) { - PodCopy(output_buffer, input_buffer, _context._in_ch_count); - output_buffer += _context._in_ch_count; - input_buffer += _context._in_ch_count; - PodZero(output_buffer, _context._out_ch_count - _context._in_ch_count); - output_buffer += _context._out_ch_count - _context._in_ch_count; - } - } else { - for (uint32_t i = 0; i < frames; i++) { - PodCopy(output_buffer, input_buffer, _context._out_ch_count); - output_buffer += _context._out_ch_count; - input_buffer += _context._in_ch_count; - } - } - } - - int mix(size_t frames, - const void * input_buffer, - size_t input_buffer_size, - void * output_buffer, - size_t output_buffer_size) const - { - if (frames <= 0 || _context._out_ch_count == 0) { - return 0; - } - - // Check if output buffer is of sufficient size. - size_t size_read_needed = - frames * _context._in_ch_count * cubeb_sample_size(_context._format); - if (input_buffer_size < size_read_needed) { - // We don't have enough data to read! - return -1; - } - if (output_buffer_size * _context._in_ch_count < - size_read_needed * _context._out_ch_count) { - return -1; - } - - if (!valid()) { - // The channel layouts were invalid or unsupported, instead we will simply - // either drop the extra channels, or fill with silence the missing ones - if (_context._format == CUBEB_SAMPLE_FLOAT32NE) { - copy_and_trunc(frames, - static_cast<const float*>(input_buffer), - static_cast<float*>(output_buffer)); - } else { - assert(_context._format == CUBEB_SAMPLE_S16NE); - copy_and_trunc(frames, - static_cast<const int16_t*>(input_buffer), - reinterpret_cast<int16_t*>(output_buffer)); - } - return 0; - } - - switch (_context._format) - { - case CUBEB_SAMPLE_FLOAT32NE: { - auto f = [](float x) { return x; }; - return rematrix(&_context, - static_cast<float*>(output_buffer), - static_cast<const float*>(input_buffer), - _context._matrix_flt, - f, - frames); - } - case CUBEB_SAMPLE_S16NE: - if (_context._clipping) { - auto f = [](int x) { - int y = (x + 16384) >> 15; - // clip the signed integer value into the -32768,32767 range. - if ((y + 0x8000U) & ~0xFFFF) { - return (y >> 31) ^ 0x7FFF; - } - return y; - }; - return rematrix(&_context, - static_cast<int16_t*>(output_buffer), - static_cast<const int16_t*>(input_buffer), - _context._matrix32, - f, - frames); - } else { - auto f = [](int x) { return (x + 16384) >> 15; }; - return rematrix(&_context, - static_cast<int16_t*>(output_buffer), - static_cast<const int16_t*>(input_buffer), - _context._matrix32, - f, - frames); - } - break; - default: - assert(false); - break; - } - - return -1; - } - - // Return false if any of the input or ouput layout were invalid. - bool valid() const { return _context._valid; } - - virtual ~cubeb_mixer(){}; - - MixerContext _context; -}; - -cubeb_mixer* cubeb_mixer_create(cubeb_sample_format format, - uint32_t in_channels, - cubeb_channel_layout in_layout, - uint32_t out_channels, - cubeb_channel_layout out_layout) -{ - return new cubeb_mixer( - format, in_channels, in_layout, out_channels, out_layout); -} - -void cubeb_mixer_destroy(cubeb_mixer * mixer) -{ - delete mixer; -} - -int cubeb_mixer_mix(cubeb_mixer * mixer, - size_t frames, - const void * input_buffer, - size_t input_buffer_size, - void * output_buffer, - size_t output_buffer_size) -{ - return mixer->mix( - frames, input_buffer, input_buffer_size, output_buffer, output_buffer_size); -} |