/*
|
* Copyright (C) 2014 The Android Open Source Project
|
*
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
* you may not use this file except in compliance with the License.
|
* You may obtain a copy of the License at
|
*
|
* http://www.apache.org/licenses/LICENSE-2.0
|
*
|
* Unless required by applicable law or agreed to in writing, software
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
* See the License for the specific language governing permissions and
|
* limitations under the License.
|
*/
|
|
#include <string.h>
|
#include <audio_utils/channels.h>
|
#include "private/private.h"
|
|
/*
|
* Clamps a 24-bit value from a 32-bit sample
|
*/
|
static inline int32_t clamp24(int32_t sample)
|
{
|
if ((sample>>23) ^ (sample>>31)) {
|
sample = 0x007FFFFF ^ (sample>>31);
|
}
|
return sample;
|
}
|
|
/*
|
* Converts a uint8x3_t into an int32_t
|
*/
|
static inline int32_t uint8x3_to_int32(uint8x3_t val) {
|
#if HAVE_BIG_ENDIAN
|
int32_t temp = (val.c[0] << 24 | val.c[1] << 16 | val.c[2] << 8) >> 8;
|
#else
|
int32_t temp = (val.c[2] << 24 | val.c[1] << 16 | val.c[0] << 8) >> 8;
|
#endif
|
return clamp24(temp);
|
}
|
|
/*
|
* Converts an int32_t to a uint8x3_t
|
*/
|
static inline uint8x3_t int32_to_uint8x3(int32_t in) {
|
uint8x3_t out;
|
#if HAVE_BIG_ENDIAN
|
out.c[2] = in;
|
out.c[1] = in >> 8;
|
out.c[0] = in >> 16;
|
#else
|
out.c[0] = in;
|
out.c[1] = in >> 8;
|
out.c[2] = in >> 16;
|
#endif
|
return out;
|
}
|
|
/* This is written as a C macro because it operates on generic types,
|
* which in a C++ file could be alternatively achieved by a "template"
|
* or an "auto" declaration.
|
* TODO: convert this from a C file to a C++ file.
|
*/
|
|
/* Channel expands (adds zeroes to audio frame end) from an input buffer to an output buffer.
|
* See expand_channels() function below for parameter definitions.
|
*
|
* Move from back to front so that the conversion can be done in-place
|
* i.e. in_buff == out_buff
|
* NOTE: num_in_bytes must be a multiple of in_buff_channels * in_buff_sample_size.
|
*
|
* Macro has a return statement.
|
*/
|
#define EXPAND_CHANNELS(in_buff, in_buff_chans, out_buff, out_buff_chans, num_in_bytes, zero) \
|
{ \
|
size_t num_in_samples = (num_in_bytes) / sizeof(*(in_buff)); \
|
size_t num_out_samples = (num_in_samples * (out_buff_chans)) / (in_buff_chans); \
|
typeof(out_buff) dst_ptr = (out_buff) + num_out_samples - 1; \
|
size_t src_index; \
|
typeof(in_buff) src_ptr = (in_buff) + num_in_samples - 1; \
|
size_t num_zero_chans = (out_buff_chans) - (in_buff_chans); \
|
for (src_index = 0; src_index < num_in_samples; src_index += (in_buff_chans)) { \
|
size_t dst_offset; \
|
for (dst_offset = 0; dst_offset < num_zero_chans; dst_offset++) { \
|
*dst_ptr-- = zero; \
|
} \
|
for (; dst_offset < (out_buff_chans); dst_offset++) { \
|
*dst_ptr-- = *src_ptr--; \
|
} \
|
} \
|
/* return number of *bytes* generated */ \
|
return num_out_samples * sizeof(*(out_buff)); \
|
}
|
|
/* Channel expands from an input buffer to an output buffer.
|
* See expand_selected_channels() function below for parameter definitions.
|
* Selected channels are replaced in the output buffer, with any extra channels
|
* per frame left alone.
|
*
|
* Move from back to front so that the conversion can be done in-place
|
* i.e. in_buff == out_buff
|
* NOTE: num_in_bytes must be a multiple of in_buff_channels * in_buff_sample_size.
|
*
|
* Macro has a return statement.
|
*/
|
#define EXPAND_SELECTED_CHANNELS( \
|
in_buff, in_buff_chans, out_buff, out_buff_chans, num_in_bytes) \
|
{ \
|
size_t num_in_samples = (num_in_bytes) / sizeof(*(in_buff)); \
|
size_t num_out_samples = (num_in_samples * (out_buff_chans)) / (in_buff_chans); \
|
typeof(out_buff) dst_ptr = (out_buff) + num_out_samples - 1; \
|
size_t src_index; \
|
typeof(in_buff) src_ptr = (in_buff) + num_in_samples - 1; \
|
size_t num_extra_chans = (out_buff_chans) - (in_buff_chans); \
|
for (src_index = 0; src_index < num_in_samples; src_index += (in_buff_chans)) { \
|
dst_ptr -= num_extra_chans; \
|
for (size_t dst_offset = num_extra_chans; dst_offset < (out_buff_chans); dst_offset++) { \
|
*dst_ptr-- = *src_ptr--; \
|
} \
|
} \
|
/* return number of *bytes* generated */ \
|
return num_out_samples * sizeof(*(out_buff)); \
|
}
|
|
/* Expand number of channels from an input buffer to an output buffer.
|
* See expand_channels_non_destructive() function below for parameter definitions.
|
*
|
* Input channels are copied to the output buffer, with extra output
|
* channels interleaved from back of input buffer.
|
*
|
* So for in_chans = 2, out_chans = 4: [1|2|1|2...|3|4|3|4] => [1|2|3|4|1|2|3|4...]
|
*
|
* NOTE: in_buff must be same size as out_buff and num_in_bytes must
|
* be a multiple of in_buff_channels * in_buff_sample_size.
|
*
|
* Uses a temporary buffer so that the conversion can be done in-place
|
* i.e. in_buff == out_buff
|
*
|
* Macro has a return statement.
|
*/
|
#define EXPAND_CHANNELS_NON_DESTRUCTIVE(in_buff, in_buff_chans, \
|
out_buff, out_buff_chans, num_in_bytes) \
|
{ \
|
size_t num_in_samples = (num_in_bytes) / sizeof(*(in_buff)); \
|
size_t num_out_samples = (num_in_samples * (out_buff_chans)) / (in_buff_chans); \
|
typeof(out_buff) dst_ptr = (out_buff); \
|
typeof(in_buff) src_ptr = (in_buff); \
|
typeof(*out_buff) temp_buff[num_in_samples]; \
|
typeof(out_buff) temp_ptr = temp_buff; \
|
/* if in-place, copy input channels to a temp buffer */ \
|
if ((in_buff) == (out_buff)) { \
|
memcpy(temp_buff, src_ptr, (num_in_bytes)); \
|
src_ptr += num_in_samples; \
|
} else { \
|
temp_ptr = (typeof(out_buff)) src_ptr; \
|
src_ptr += num_in_samples; \
|
} \
|
/* interleave channels from end of source buffer with those from front */ \
|
size_t src_index; \
|
for (src_index = 0; src_index < num_out_samples; src_index += (out_buff_chans)) { \
|
size_t dst_offset; \
|
for (dst_offset = 0; dst_offset < (in_buff_chans); dst_offset++) { \
|
*dst_ptr++ = *temp_ptr++; \
|
} \
|
for (;dst_offset < (out_buff_chans); dst_offset++) { \
|
*dst_ptr++ = *src_ptr++; \
|
} \
|
} \
|
/* return number of *bytes* generated */ \
|
return num_out_samples * sizeof(*(out_buff)); \
|
}
|
|
/* Channel expands from a MONO input buffer to a MULTICHANNEL output buffer by duplicating the
|
* single input channel to the first 2 output channels and 0-filling the remaining.
|
* See expand_channels() function below for parameter definitions.
|
*
|
* in_buff_chans MUST be 1 and out_buff_chans MUST be >= 2
|
*
|
* Move from back to front so that the conversion can be done in-place
|
* i.e. in_buff == out_buff
|
* NOTE: num_in_bytes must be a multiple of in_buff_channels * in_buff_sample_size.
|
*
|
* Macro has a return statement.
|
*/
|
#define EXPAND_MONO_TO_MULTI(in_buff, in_buff_chans, out_buff, out_buff_chans, num_in_bytes, zero) \
|
{ \
|
size_t num_in_samples = (num_in_bytes) / sizeof(*(in_buff)); \
|
size_t num_out_samples = (num_in_samples * (out_buff_chans)) / (in_buff_chans); \
|
typeof(out_buff) dst_ptr = (out_buff) + num_out_samples - 1; \
|
size_t src_index; \
|
typeof(in_buff) src_ptr = (in_buff) + num_in_samples - 1; \
|
size_t num_zero_chans = (out_buff_chans) - (in_buff_chans) - 1; \
|
for (src_index = 0; src_index < num_in_samples; src_index += (in_buff_chans)) { \
|
size_t dst_offset; \
|
for (dst_offset = 0; dst_offset < num_zero_chans; dst_offset++) { \
|
*dst_ptr-- = zero; \
|
} \
|
for (; dst_offset < (out_buff_chans); dst_offset++) { \
|
*dst_ptr-- = *src_ptr; \
|
} \
|
src_ptr--; \
|
} \
|
/* return number of *bytes* generated */ \
|
return num_out_samples * sizeof(*(out_buff)); \
|
}
|
|
/* Channel contracts (removes from audio frame end) from an input buffer to an output buffer.
|
* See contract_channels() function below for parameter definitions.
|
*
|
* Move from front to back so that the conversion can be done in-place
|
* i.e. in_buff == out_buff
|
* NOTE: num_in_bytes must be a multiple of in_buff_channels * in_buff_sample_size.
|
*
|
* Macro has a return statement.
|
*/
|
#define CONTRACT_CHANNELS(in_buff, in_buff_chans, out_buff, out_buff_chans, num_in_bytes) \
|
{ \
|
size_t num_in_samples = (num_in_bytes) / sizeof(*(in_buff)); \
|
size_t num_out_samples = (num_in_samples * (out_buff_chans)) / (in_buff_chans); \
|
size_t num_skip_samples = (in_buff_chans) - (out_buff_chans); \
|
typeof(out_buff) dst_ptr = out_buff; \
|
typeof(in_buff) src_ptr = in_buff; \
|
size_t src_index; \
|
for (src_index = 0; src_index < num_in_samples; src_index += (in_buff_chans)) { \
|
size_t dst_offset; \
|
for (dst_offset = 0; dst_offset < (out_buff_chans); dst_offset++) { \
|
*dst_ptr++ = *src_ptr++; \
|
} \
|
src_ptr += num_skip_samples; \
|
} \
|
/* return number of *bytes* generated */ \
|
return num_out_samples * sizeof(*(out_buff)); \
|
}
|
|
/* Contract number of channels from an input buffer to an output buffer,
|
* storing removed channels at end of buffer.
|
*
|
* See contract_channels_non_destructive() function below for parameter definitions.
|
*
|
* So for in_chans = 4, out_chans = 2: [1|2|3|4|1|2|3|4...] => [1|2|1|2...|3|4|3|4]
|
*
|
* NOTE: in_buff must be same size as out_buff and num_in_bytes must
|
* be a multiple of in_buff_channels * in_buff_sample_size.
|
*
|
* Uses a temporary buffer so that the conversion can be done in-place
|
* i.e. in_buff == out_buff
|
*
|
* Macro has a return statement.
|
*/
|
#define CONTRACT_CHANNELS_NON_DESTRUCTIVE(in_buff, in_buff_chans, out_buff, \
|
out_buff_chans, num_in_bytes) \
|
{ \
|
size_t num_in_samples = (num_in_bytes) / sizeof(*(in_buff)); \
|
size_t num_out_samples = (num_in_samples * (out_buff_chans)) / (in_buff_chans); \
|
typeof(out_buff) dst_ptr = (out_buff); \
|
typeof(in_buff) src_ptr = (in_buff); \
|
size_t num_temp_samples = num_in_samples - num_out_samples; \
|
typeof(*out_buff) temp_buff[num_temp_samples]; \
|
typeof(out_buff) temp_ptr; \
|
/* if in-place, copy input channels to a temp buffer instead of out buffer */ \
|
if ((in_buff) == (out_buff)) { \
|
temp_ptr = temp_buff; \
|
} else { \
|
temp_ptr = dst_ptr + num_out_samples; \
|
} \
|
size_t src_index; \
|
for (src_index = 0; src_index < num_in_samples; src_index += (in_buff_chans)) { \
|
size_t dst_offset; \
|
for (dst_offset = 0; dst_offset < (out_buff_chans); dst_offset++) { \
|
*dst_ptr++ = *src_ptr++; \
|
} \
|
for (;dst_offset < (in_buff_chans); dst_offset++) { \
|
*temp_ptr++ = *src_ptr++; \
|
} \
|
} \
|
/* if in-place, interleave channels from the temp buffer */ \
|
if ((in_buff) == (out_buff)) { \
|
temp_ptr = temp_buff; \
|
memcpy(dst_ptr, temp_ptr, num_temp_samples * sizeof(*(in_buff))); \
|
} \
|
/* return number of *bytes* generated */ \
|
return num_out_samples * sizeof(*(out_buff)); \
|
}
|
|
/* Channel contracts from a MULTICHANNEL input buffer to a MONO output buffer by mixing the
|
* first two input channels into the single output channel (and skipping the rest).
|
* See contract_channels() function below for parameter definitions.
|
*
|
* in_buff_chans MUST be >= 2 and out_buff_chans MUST be 1
|
*
|
* Move from front to back so that the conversion can be done in-place
|
* i.e. in_buff == out_buff
|
* NOTE: num_in_bytes must be a multiple of in_buff_channels * in_buff_sample_size.
|
* NOTE: Overload of the summed channels is avoided by averaging the two input channels.
|
* NOTE: Can not be used for uint8x3_t samples, see CONTRACT_TO_MONO_24() below.
|
*
|
* Macro has a return statement.
|
*/
|
#define CONTRACT_TO_MONO(in_buff, out_buff, num_in_bytes) \
|
{ \
|
size_t num_in_samples = (num_in_bytes) / sizeof(*(in_buff)); \
|
size_t num_out_samples = (num_in_samples * out_buff_chans) / in_buff_chans; \
|
size_t num_skip_samples = in_buff_chans - 2; \
|
typeof(out_buff) dst_ptr = out_buff; \
|
typeof(in_buff) src_ptr = in_buff; \
|
int32_t temp0, temp1; \
|
size_t src_index; \
|
for (src_index = 0; src_index < num_in_samples; src_index += in_buff_chans) { \
|
temp0 = *src_ptr++; \
|
temp1 = *src_ptr++; \
|
/* *dst_ptr++ = temp >> 1; */ \
|
/* This bit of magic adds and normalizes without overflow (or so claims hunga@) */ \
|
/* Bitwise half adder trick, see http://en.wikipedia.org/wiki/Adder_(electronics) */ \
|
/* Hacker's delight, p. 19 http://www.hackersdelight.org/basics2.pdf */ \
|
*dst_ptr++ = (temp0 & temp1) + ((temp0 ^ temp1) >> 1); \
|
src_ptr += num_skip_samples; \
|
} \
|
/* return number of *bytes* generated */ \
|
return num_out_samples * sizeof(*(out_buff)); \
|
}
|
|
/* Channel contracts from a MULTICHANNEL uint8x3_t input buffer to a MONO uint8x3_t output buffer
|
* by mixing the first two input channels into the single output channel (and skipping the rest).
|
* See contract_channels() function below for parameter definitions.
|
*
|
* Move from front to back so that the conversion can be done in-place
|
* i.e. in_buff == out_buff
|
* NOTE: num_in_bytes must be a multiple of in_buff_channels * in_buff_sample_size.
|
* NOTE: Overload of the summed channels is avoided by averaging the two input channels.
|
* NOTE: Can not be used for normal, scalar samples, see CONTRACT_TO_MONO() above.
|
*
|
* Macro has a return statement.
|
*/
|
#define CONTRACT_TO_MONO_24(in_buff, out_buff, num_in_bytes) \
|
{ \
|
size_t num_in_samples = (num_in_bytes) / sizeof(*(in_buff)); \
|
size_t num_out_samples = (num_in_samples * out_buff_chans) / in_buff_chans; \
|
size_t num_skip_samples = in_buff_chans - 2; \
|
typeof(out_buff) dst_ptr = out_buff; \
|
typeof(in_buff) src_ptr = in_buff; \
|
int32_t temp; \
|
size_t src_index; \
|
for (src_index = 0; src_index < num_in_samples; src_index += in_buff_chans) { \
|
temp = uint8x3_to_int32(*src_ptr++); \
|
temp += uint8x3_to_int32(*src_ptr++); \
|
*dst_ptr = int32_to_uint8x3(temp >> 1); \
|
src_ptr += num_skip_samples; \
|
} \
|
/* return number of *bytes* generated */ \
|
return num_out_samples * sizeof(*(out_buff)); \
|
}
|
|
/*
|
* Convert a buffer of N-channel, interleaved samples to M-channel
|
* (where N > M).
|
* in_buff points to the buffer of samples
|
* in_buff_channels Specifies the number of channels in the input buffer.
|
* out_buff points to the buffer to receive converted samples.
|
* out_buff_channels Specifies the number of channels in the output buffer.
|
* sample_size_in_bytes Specifies the number of bytes per sample.
|
* num_in_bytes size of input buffer in BYTES
|
* returns
|
* the number of BYTES of output data.
|
* NOTE
|
* channels > M are thrown away.
|
* The out and sums buffers must either be completely separate (non-overlapping), or
|
* they must both start at the same address. Partially overlapping buffers are not supported.
|
*/
|
static size_t contract_channels(const void* in_buff, size_t in_buff_chans,
|
void* out_buff, size_t out_buff_chans,
|
unsigned sample_size_in_bytes, size_t num_in_bytes)
|
{
|
switch (sample_size_in_bytes) {
|
case 1:
|
if (out_buff_chans == 1) {
|
/* Special case Multi to Mono */
|
CONTRACT_TO_MONO((const uint8_t*)in_buff, (uint8_t*)out_buff, num_in_bytes);
|
// returns in macro
|
} else {
|
CONTRACT_CHANNELS((const uint8_t*)in_buff, in_buff_chans,
|
(uint8_t*)out_buff, out_buff_chans,
|
num_in_bytes);
|
// returns in macro
|
}
|
case 2:
|
if (out_buff_chans == 1) {
|
/* Special case Multi to Mono */
|
CONTRACT_TO_MONO((const int16_t*)in_buff, (int16_t*)out_buff, num_in_bytes);
|
// returns in macro
|
} else {
|
CONTRACT_CHANNELS((const int16_t*)in_buff, in_buff_chans,
|
(int16_t*)out_buff, out_buff_chans,
|
num_in_bytes);
|
// returns in macro
|
}
|
case 3:
|
if (out_buff_chans == 1) {
|
/* Special case Multi to Mono */
|
CONTRACT_TO_MONO_24((const uint8x3_t*)in_buff,
|
(uint8x3_t*)out_buff, num_in_bytes);
|
// returns in macro
|
} else {
|
CONTRACT_CHANNELS((const uint8x3_t*)in_buff, in_buff_chans,
|
(uint8x3_t*)out_buff, out_buff_chans,
|
num_in_bytes);
|
// returns in macro
|
}
|
case 4:
|
if (out_buff_chans == 1) {
|
/* Special case Multi to Mono */
|
CONTRACT_TO_MONO((const int32_t*)in_buff, (int32_t*)out_buff, num_in_bytes);
|
// returns in macro
|
} else {
|
CONTRACT_CHANNELS((const int32_t*)in_buff, in_buff_chans,
|
(int32_t*)out_buff, out_buff_chans,
|
num_in_bytes);
|
// returns in macro
|
}
|
default:
|
return 0;
|
}
|
}
|
|
/*
|
* Convert a buffer of N-channel, interleaved samples to M-channel
|
* (where N > M).
|
* in_buff points to the buffer of samples
|
* in_buff_channels specifies the number of channels in the input buffer.
|
* out_buff points to the buffer to receive converted samples.
|
* out_buff_channels specifies the number of channels in the output buffer.
|
* sample_size_in_bytes specifies the number of bytes per sample.
|
* num_in_bytes size of input buffer in BYTES
|
* returns
|
* the number of BYTES of output data.
|
* NOTE
|
* channels > M are stored at the end of the output buffer.
|
* The output and input buffers must be the same length.
|
* The output and input buffers must either be completely separate (non-overlapping), or
|
* they must both start at the same address. Partially overlapping buffers are not supported.
|
*/
|
static size_t contract_channels_non_destructive(const void* in_buff, size_t in_buff_chans,
|
void* out_buff, size_t out_buff_chans,
|
unsigned sample_size_in_bytes, size_t num_in_bytes)
|
{
|
switch (sample_size_in_bytes) {
|
case 1:
|
CONTRACT_CHANNELS_NON_DESTRUCTIVE((const uint8_t*)in_buff, in_buff_chans,
|
(uint8_t*)out_buff, out_buff_chans,
|
num_in_bytes);
|
// returns in macro
|
case 2:
|
CONTRACT_CHANNELS_NON_DESTRUCTIVE((const int16_t*)in_buff, in_buff_chans,
|
(int16_t*)out_buff, out_buff_chans,
|
num_in_bytes);
|
// returns in macro
|
case 3:
|
CONTRACT_CHANNELS_NON_DESTRUCTIVE((const uint8x3_t*)in_buff, in_buff_chans,
|
(uint8x3_t*)out_buff, out_buff_chans,
|
num_in_bytes);
|
// returns in macro
|
case 4:
|
CONTRACT_CHANNELS_NON_DESTRUCTIVE((const int32_t*)in_buff, in_buff_chans,
|
(int32_t*)out_buff, out_buff_chans,
|
num_in_bytes);
|
// returns in macro
|
default:
|
return 0;
|
}
|
}
|
|
/*
|
* Convert a buffer of N-channel, interleaved samples to M-channel
|
* (where N < M).
|
* in_buff points to the buffer of samples
|
* in_buff_channels Specifies the number of channels in the input buffer.
|
* out_buff points to the buffer to receive converted samples.
|
* out_buff_channels Specifies the number of channels in the output buffer.
|
* sample_size_in_bytes Specifies the number of bytes per sample.
|
* num_in_bytes size of input buffer in BYTES
|
* returns
|
* the number of BYTES of output data.
|
* NOTE
|
* channels > N are filled with silence.
|
* The out and sums buffers must either be completely separate (non-overlapping), or
|
* they must both start at the same address. Partially overlapping buffers are not supported.
|
*/
|
static size_t expand_channels(const void* in_buff, size_t in_buff_chans,
|
void* out_buff, size_t out_buff_chans,
|
unsigned sample_size_in_bytes, size_t num_in_bytes)
|
{
|
static const uint8x3_t packed24_zero; /* zero 24 bit sample */
|
|
switch (sample_size_in_bytes) {
|
case 1:
|
if (in_buff_chans == 1) {
|
/* special case of mono source to multi-channel */
|
EXPAND_MONO_TO_MULTI((const uint8_t*)in_buff, in_buff_chans,
|
(uint8_t*)out_buff, out_buff_chans,
|
num_in_bytes, 0);
|
// returns in macro
|
} else {
|
EXPAND_CHANNELS((const uint8_t*)in_buff, in_buff_chans,
|
(uint8_t*)out_buff, out_buff_chans,
|
num_in_bytes, 0);
|
// returns in macro
|
}
|
case 2:
|
if (in_buff_chans == 1) {
|
/* special case of mono source to multi-channel */
|
EXPAND_MONO_TO_MULTI((const int16_t*)in_buff, in_buff_chans,
|
(int16_t*)out_buff, out_buff_chans,
|
num_in_bytes, 0);
|
// returns in macro
|
} else {
|
EXPAND_CHANNELS((const int16_t*)in_buff, in_buff_chans,
|
(int16_t*)out_buff, out_buff_chans,
|
num_in_bytes, 0);
|
// returns in macro
|
}
|
case 3:
|
if (in_buff_chans == 1) {
|
/* special case of mono source to multi-channel */
|
EXPAND_MONO_TO_MULTI((const uint8x3_t*)in_buff, in_buff_chans,
|
(uint8x3_t*)out_buff, out_buff_chans,
|
num_in_bytes, packed24_zero);
|
// returns in macro
|
} else {
|
EXPAND_CHANNELS((const uint8x3_t*)in_buff, in_buff_chans,
|
(uint8x3_t*)out_buff, out_buff_chans,
|
num_in_bytes, packed24_zero);
|
// returns in macro
|
}
|
case 4:
|
if (in_buff_chans == 1) {
|
/* special case of mono source to multi-channel */
|
EXPAND_MONO_TO_MULTI((const int32_t*)in_buff, in_buff_chans,
|
(int32_t*)out_buff, out_buff_chans,
|
num_in_bytes, 0);
|
// returns in macro
|
} else {
|
EXPAND_CHANNELS((const int32_t*)in_buff, in_buff_chans,
|
(int32_t*)out_buff, out_buff_chans,
|
num_in_bytes, 0);
|
// returns in macro
|
}
|
default:
|
return 0;
|
}
|
}
|
|
/*
|
* Convert a buffer of N-channel, interleaved samples to M-channel
|
* (where N < M).
|
* in_buff points to the buffer of samples
|
* in_buff_channels Specifies the number of channels in the input buffer.
|
* out_buff points to the buffer to receive converted samples.
|
* out_buff_channels Specifies the number of channels in the output buffer.
|
* sample_size_in_bytes Specifies the number of bytes per sample.
|
* num_in_bytes size of input buffer in BYTES
|
* returns
|
* the number of BYTES of output data.
|
* NOTE
|
* channels > N are left alone in out_buff.
|
* The out and in buffers must either be completely separate (non-overlapping), or
|
* they must both start at the same address. Partially overlapping buffers are not supported.
|
*/
|
static size_t expand_selected_channels(const void* in_buff, size_t in_buff_chans,
|
void* out_buff, size_t out_buff_chans,
|
unsigned sample_size_in_bytes, size_t num_in_bytes)
|
{
|
switch (sample_size_in_bytes) {
|
case 1:
|
|
EXPAND_SELECTED_CHANNELS((const uint8_t*)in_buff, in_buff_chans,
|
(uint8_t*)out_buff, out_buff_chans,
|
num_in_bytes);
|
// returns in macro
|
|
case 2:
|
|
EXPAND_SELECTED_CHANNELS((const int16_t*)in_buff, in_buff_chans,
|
(int16_t*)out_buff, out_buff_chans,
|
num_in_bytes);
|
// returns in macro
|
|
case 3:
|
|
EXPAND_SELECTED_CHANNELS((const uint8x3_t*)in_buff, in_buff_chans,
|
(uint8x3_t*)out_buff, out_buff_chans,
|
num_in_bytes);
|
// returns in macro
|
|
case 4:
|
|
EXPAND_SELECTED_CHANNELS((const int32_t*)in_buff, in_buff_chans,
|
(int32_t*)out_buff, out_buff_chans,
|
num_in_bytes);
|
// returns in macro
|
|
default:
|
return 0;
|
}
|
}
|
|
/*
|
* Convert a buffer of N-channel, interleaved samples to M-channel
|
* (where N < M).
|
* in_buff points to the buffer of samples
|
* in_buff_channels Specifies the number of channels in the input buffer.
|
* out_buff points to the buffer to receive converted samples.
|
* out_buff_channels Specifies the number of channels in the output buffer.
|
* sample_size_in_bytes Specifies the number of bytes per sample.
|
* num_in_bytes size of input buffer in BYTES
|
* returns
|
* the number of BYTES of output data.
|
* NOTE
|
* channels > N are interleaved with data from the end of the input buffer.
|
* The output and input buffers must be the same length.
|
* The output and input buffers must either be completely separate (non-overlapping), or
|
* they must both start at the same address. Partially overlapping buffers are not supported.
|
*/
|
static size_t expand_channels_non_destructive(const void* in_buff, size_t in_buff_chans,
|
void* out_buff, size_t out_buff_chans,
|
unsigned sample_size_in_bytes, size_t num_in_bytes)
|
{
|
switch (sample_size_in_bytes) {
|
case 1:
|
|
EXPAND_CHANNELS_NON_DESTRUCTIVE((const uint8_t*)in_buff, in_buff_chans,
|
(uint8_t*)out_buff, out_buff_chans,
|
num_in_bytes);
|
// returns in macro
|
|
case 2:
|
|
EXPAND_CHANNELS_NON_DESTRUCTIVE((const int16_t*)in_buff, in_buff_chans,
|
(int16_t*)out_buff, out_buff_chans,
|
num_in_bytes);
|
// returns in macro
|
|
case 3:
|
|
EXPAND_CHANNELS_NON_DESTRUCTIVE((const uint8x3_t*)in_buff, in_buff_chans,
|
(uint8x3_t*)out_buff, out_buff_chans,
|
num_in_bytes);
|
// returns in macro
|
|
case 4:
|
|
EXPAND_CHANNELS_NON_DESTRUCTIVE((const int32_t*)in_buff, in_buff_chans,
|
(int32_t*)out_buff, out_buff_chans,
|
num_in_bytes);
|
// returns in macro
|
|
default:
|
return 0;
|
}
|
}
|
|
size_t adjust_channels(const void* in_buff, size_t in_buff_chans,
|
void* out_buff, size_t out_buff_chans,
|
unsigned sample_size_in_bytes, size_t num_in_bytes)
|
{
|
if (out_buff_chans > in_buff_chans) {
|
return expand_channels(in_buff, in_buff_chans, out_buff, out_buff_chans,
|
sample_size_in_bytes, num_in_bytes);
|
} else if (out_buff_chans < in_buff_chans) {
|
return contract_channels(in_buff, in_buff_chans, out_buff, out_buff_chans,
|
sample_size_in_bytes, num_in_bytes);
|
} else if (in_buff != out_buff) {
|
memcpy(out_buff, in_buff, num_in_bytes);
|
}
|
|
return num_in_bytes;
|
}
|
|
size_t adjust_selected_channels(const void* in_buff, size_t in_buff_chans,
|
void* out_buff, size_t out_buff_chans,
|
unsigned sample_size_in_bytes, size_t num_in_bytes)
|
{
|
if (out_buff_chans > in_buff_chans) {
|
return expand_selected_channels(in_buff, in_buff_chans, out_buff, out_buff_chans,
|
sample_size_in_bytes, num_in_bytes);
|
} else if (out_buff_chans < in_buff_chans) {
|
return contract_channels(in_buff, in_buff_chans, out_buff, out_buff_chans,
|
sample_size_in_bytes, num_in_bytes);
|
} else if (in_buff != out_buff) {
|
memcpy(out_buff, in_buff, num_in_bytes);
|
}
|
|
return num_in_bytes;
|
}
|
|
size_t adjust_channels_non_destructive(const void* in_buff, size_t in_buff_chans,
|
void* out_buff, size_t out_buff_chans,
|
unsigned sample_size_in_bytes, size_t num_in_bytes)
|
{
|
if (out_buff_chans > in_buff_chans) {
|
return expand_channels_non_destructive(in_buff, in_buff_chans, out_buff, out_buff_chans,
|
sample_size_in_bytes, num_in_bytes);
|
} else if (out_buff_chans < in_buff_chans) {
|
return contract_channels_non_destructive(in_buff, in_buff_chans, out_buff, out_buff_chans,
|
sample_size_in_bytes, num_in_bytes);
|
} else if (in_buff != out_buff) {
|
memcpy(out_buff, in_buff, num_in_bytes);
|
}
|
|
return num_in_bytes;
|
}
|
