mirrors/pipewire
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/pipewire/pipewire.git synced 2025-10-29 05:40:27 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

audioconvert: compile c version separately

Browse source 
Also compile the c versions in a separate module with their own
flags.
This commit is contained in:
Wim Taymans 2019-03-28 21:07:53 +01:00
parent fe6ebd0e8a
commit d260cb19be
14 changed files with 1471 additions and 1255 deletions
Download patch file Download diff file Expand all files Collapse all files

78
spa/plugins/audioconvert/benchmark-fmt-ops.c
View file

@ -105,34 +105,34 @@ static void run_test(const char *name, const char *impl, bool in_packed, bool ou
static void test_f32_u8(void)
{
run_test("test_f32_u8", "c", true, true, conv_f32_to_u8);
run_test("test_f32d_u8", "c", false, true, conv_f32d_to_u8);
run_test("test_f32_u8d", "c", true, false, conv_f32_to_u8d);
run_test("test_f32d_u8d", "c", false, false, conv_f32d_to_u8d);
run_test("test_f32_u8", "c", true, true, conv_f32_to_u8_c);
run_test("test_f32d_u8", "c", false, true, conv_f32d_to_u8_c);
run_test("test_f32_u8d", "c", true, false, conv_f32_to_u8d_c);
run_test("test_f32d_u8d", "c", false, false, conv_f32d_to_u8d_c);
}
static void test_u8_f32(void)
{
run_test("test_u8_f32", "c", true, true, conv_u8_to_f32);
run_test("test_u8d_f32", "c", false, true, conv_u8d_to_f32);
run_test("test_u8_f32d", "c", true, false, conv_u8_to_f32d);
run_test("test_u8_f32", "c", true, true, conv_u8_to_f32_c);
run_test("test_u8d_f32", "c", false, true, conv_u8d_to_f32_c);
run_test("test_u8_f32d", "c", true, false, conv_u8_to_f32d_c);
}
static void test_f32_s16(void)
{
run_test("test_f32_s16", "c", true, true, conv_f32_to_s16);
run_test("test_f32d_s16", "c", false, true, conv_f32d_to_s16);
run_test("test_f32_s16", "c", true, true, conv_f32_to_s16_c);
run_test("test_f32d_s16", "c", false, true, conv_f32d_to_s16_c);
#if defined (HAVE_SSE2)
run_test("test_f32d_s16", "sse2", false, true, conv_f32d_to_s16_sse2);
#endif
run_test("test_f32_s16d", "c", true, false, conv_f32_to_s16d);
run_test("test_f32_s16d", "c", true, false, conv_f32_to_s16d_c);
}
static void test_s16_f32(void)
{
run_test("test_s16_f32", "c", true, true, conv_s16_to_f32);
run_test("test_s16d_f32", "c", false, true, conv_s16d_to_f32);
run_test("test_s16_f32d", "c", true, false, conv_s16_to_f32d);
run_test("test_s16_f32", "c", true, true, conv_s16_to_f32_c);
run_test("test_s16d_f32", "c", false, true, conv_s16d_to_f32_c);
run_test("test_s16_f32d", "c", true, false, conv_s16_to_f32d_c);
#if defined (HAVE_SSE2)
run_test("test_s16_f32d", "sse2", true, false, conv_s16_to_f32d_sse2);
#endif
@ -140,33 +140,33 @@ static void test_s16_f32(void)
static void test_f32_s32(void)
{
run_test("test_f32_s32", "c", true, true, conv_f32_to_s32);
run_test("test_f32d_s32", "c", false, true, conv_f32d_to_s32);
run_test("test_f32_s32", "c", true, true, conv_f32_to_s32_c);
run_test("test_f32d_s32", "c", false, true, conv_f32d_to_s32_c);
#if defined (HAVE_SSE2)
run_test("test_f32d_s32", "sse2", false, true, conv_f32d_to_s32_sse2);
#endif
run_test("test_f32_s32d", "c", true, false, conv_f32_to_s32d);
run_test("test_f32_s32d", "c", true, false, conv_f32_to_s32d_c);
}
static void test_s32_f32(void)
{
run_test("test_s32_f32", "c", true, true, conv_s32_to_f32);
run_test("test_s32d_f32", "c", false, true, conv_s32d_to_f32);
run_test("test_s32_f32d", "c", true, false, conv_s32_to_f32d);
run_test("test_s32_f32", "c", true, true, conv_s32_to_f32_c);
run_test("test_s32d_f32", "c", false, true, conv_s32d_to_f32_c);
run_test("test_s32_f32d", "c", true, false, conv_s32_to_f32d_c);
}
static void test_f32_s24(void)
{
run_test("test_f32_s24", "c", true, true, conv_f32_to_s24);
run_test("test_f32d_s24", "c", false, true, conv_f32d_to_s24);
run_test("test_f32_s24d", "c", true, false, conv_f32_to_s24d);
run_test("test_f32_s24", "c", true, true, conv_f32_to_s24_c);
run_test("test_f32d_s24", "c", false, true, conv_f32d_to_s24_c);
run_test("test_f32_s24d", "c", true, false, conv_f32_to_s24d_c);
}
static void test_s24_f32(void)
{
run_test("test_s24_f32", "c", true, true, conv_s24_to_f32);
run_test("test_s24d_f32", "c", false, true, conv_s24d_to_f32);
run_test("test_s24_f32d", "c", true, false, conv_s24_to_f32d);
run_test("test_s24_f32", "c", true, true, conv_s24_to_f32_c);
run_test("test_s24d_f32", "c", false, true, conv_s24d_to_f32_c);
run_test("test_s24_f32d", "c", true, false, conv_s24_to_f32d_c);
#if defined (HAVE_SSE2)
run_test("test_s24_f32d", "sse2", true, false, conv_s24_to_f32d_sse2);
#endif
@ -180,32 +180,32 @@ static void test_s24_f32(void)
static void test_f32_s24_32(void)
{
run_test("test_f32_s24_32", "c", true, true, conv_f32_to_s24_32);
run_test("test_f32d_s24_32", "c", false, true, conv_f32d_to_s24_32);
run_test("test_f32_s24_32d", "c", true, false, conv_f32_to_s24_32d);
run_test("test_f32_s24_32", "c", true, true, conv_f32_to_s24_32_c);
run_test("test_f32d_s24_32", "c", false, true, conv_f32d_to_s24_32_c);
run_test("test_f32_s24_32d", "c", true, false, conv_f32_to_s24_32d_c);
}
static void test_s24_32_f32(void)
{
run_test("test_s24_32_f32", "c", true, true, conv_s24_32_to_f32);
run_test("test_s24_32d_f32", "c", false, true, conv_s24_32d_to_f32);
run_test("test_s24_32_f32d", "c", true, false, conv_s24_32_to_f32d);
run_test("test_s24_32_f32", "c", true, true, conv_s24_32_to_f32_c);
run_test("test_s24_32d_f32", "c", false, true, conv_s24_32d_to_f32_c);
run_test("test_s24_32_f32d", "c", true, false, conv_s24_32_to_f32d_c);
}
static void test_interleave(void)
{
run_test("test_interleave_8", "c", false, true, interleave_8);
run_test("test_interleave_16", "c", false, true, interleave_16);
run_test("test_interleave_24", "c", false, true, interleave_24);
run_test("test_interleave_32", "c", false, true, interleave_32);
run_test("test_interleave_8", "c", false, true, conv_interleave_8_c);
run_test("test_interleave_16", "c", false, true, conv_interleave_16_c);
run_test("test_interleave_24", "c", false, true, conv_interleave_24_c);
run_test("test_interleave_32", "c", false, true, conv_interleave_32_c);
}
static void test_deinterleave(void)
{
run_test("test_deinterleave_8", "c", true, false, deinterleave_8);
run_test("test_deinterleave_16", "c", true, false, deinterleave_16);
run_test("test_deinterleave_24", "c", true, false, deinterleave_24);
run_test("test_deinterleave_32", "c", true, false, deinterleave_32);
run_test("test_deinterleave_8", "c", true, false, conv_deinterleave_8_c);
run_test("test_deinterleave_16", "c", true, false, conv_deinterleave_16_c);
run_test("test_deinterleave_24", "c", true, false, conv_deinterleave_24_c);
run_test("test_deinterleave_32", "c", true, false, conv_deinterleave_32_c);
}
static int compare_func(const void *_a, const void *_b)

449
spa/plugins/audioconvert/channelmix-ops-c.c Normal file
View file

@ -0,0 +1,449 @@
/* Spa
*
* Copyright © 2018 Wim Taymans
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*/
#include "channelmix-ops.h"
void
channelmix_copy_c(void *data, int n_dst, void * SPA_RESTRICT dst[n_dst],
int n_src, const void * SPA_RESTRICT src[n_src],
const void *matrix, float v, int n_samples)
{
int i, n;
float **d = (float **)dst;
const float **s = (const float **)src;
if (v <= VOLUME_MIN) {
for (i = 0; i < n_dst; i++)
memset(d[i], 0, n_samples * sizeof(float));
}
else if (v == VOLUME_NORM) {
for (i = 0; i < n_dst; i++)
spa_memcpy(d[i], s[i], n_samples * sizeof(float));
}
else {
for (i = 0; i < n_dst; i++)
for (n = 0; n < n_samples; n++)
d[i][n] = s[i][n] * v;
}
}
#define _M(ch) (1UL << SPA_AUDIO_CHANNEL_ ## ch)
void
channelmix_f32_n_m_c(void *data, int n_dst, void * SPA_RESTRICT dst[n_dst],
int n_src, const void * SPA_RESTRICT src[n_src],
const void *matrix, float v, int n_samples)
{
int i, j, n;
float **d = (float **) dst;
const float **s = (const float **) src;
const float *m = matrix;
for (n = 0; n < n_samples; n++) {
for (i = 0; i < n_dst; i++) {
float sum = 0.0f;
for (j = 0; j < n_src; j++)
sum += s[j][n] * m[i * n_src + j];
d[i][n] = sum * v;
}
}
}
#define MASK_MONO _M(FC)|_M(MONO)|_M(UNKNOWN)
#define MASK_STEREO _M(FL)|_M(FR)|_M(UNKNOWN)
void
channelmix_f32_1_2_c(void *data, int n_dst, void * SPA_RESTRICT dst[n_dst],
int n_src, const void * SPA_RESTRICT src[n_src],
const void *matrix, float v, int n_samples)
{
int n;
float **d = (float **)dst;
const float **s = (const float **)src;
if (v <= VOLUME_MIN) {
memset(d[0], 0, n_samples * sizeof(float));
memset(d[1], 0, n_samples * sizeof(float));
}
else if (v == VOLUME_NORM) {
for (n = 0; n < n_samples; n++)
d[0][n] = d[1][n] = s[0][n];
}
else {
for (n = 0; n < n_samples; n++)
d[0][n] = d[1][n] = s[0][n] * v;
}
}
void
channelmix_f32_2_1_c(void *data, int n_dst, void * SPA_RESTRICT dst[n_dst],
int n_src, const void * SPA_RESTRICT src[n_src],
const void *matrix, float v, int n_samples)
{
int n;
float **d = (float **)dst;
const float **s = (const float **)src;
if (v <= VOLUME_MIN) {
memset(d[0], 0, n_samples * sizeof(float));
}
else {
const float f = v * 0.5f;
for (n = 0; n < n_samples; n++)
d[0][n] = (s[0][n] + s[1][n]) * f;
}
}
void
channelmix_f32_4_1_c(void *data, int n_dst, void * SPA_RESTRICT dst[n_dst],
int n_src, const void * SPA_RESTRICT src[n_src],
const void *matrix, float v, int n_samples)
{
int n;
float **d = (float **)dst;
const float **s = (const float **)src;
if (v <= VOLUME_MIN) {
memset(d[0], 0, n_samples * sizeof(float));
}
else {
const float f = v * 0.25f;
for (n = 0; n < n_samples; n++)
d[0][n] = (s[0][n] + s[1][n] + s[2][n] + s[3][n]) * f;
}
}
void
channelmix_f32_3p1_1_c(void *data, int n_dst, void * SPA_RESTRICT dst[n_dst],
int n_src, const void * SPA_RESTRICT src[n_src],
const void *matrix, float v, int n_samples)
{
int n;
float **d = (float **)dst;
const float **s = (const float **)src;
if (v <= VOLUME_MIN) {
memset(d[0], 0, n_samples * sizeof(float));
}
else {
const float f = v * 0.5f;
for (n = 0; n < n_samples; n++)
d[0][n] = (s[0][n] + s[1][n] + s[2][n]) * f;
}
}
#define MASK_QUAD _M(FL)|_M(FR)|_M(RL)|_M(RR)|_M(UNKNOWN)
void
channelmix_f32_2_4_c(void *data, int n_dst, void * SPA_RESTRICT dst[n_dst],
int n_src, const void * SPA_RESTRICT src[n_src],
const void *matrix, float v, int n_samples)
{
int i, n;
float **d = (float **)dst;
const float **s = (const float **)src;
if (v <= VOLUME_MIN) {
for (i = 0; i < n_dst; i++)
memset(d[i], 0, n_samples * sizeof(float));
}
else if (v == VOLUME_NORM) {
for (n = 0; n < n_samples; n++) {
d[0][n] = d[2][n] = s[0][n];
d[1][n] = d[3][n] = s[1][n];
}
}
else {
for (n = 0; n < n_samples; n++) {
d[0][n] = d[2][n] = s[0][n] * v;
d[1][n] = d[3][n] = s[1][n] * v;
}
}
}
#define MASK_3_1 _M(FL)|_M(FR)|_M(FC)|_M(LFE)
void
channelmix_f32_2_3p1_c(void *data, int n_dst, void * SPA_RESTRICT dst[n_dst],
int n_src, const void * SPA_RESTRICT src[n_src],
const void *matrix, float v, int n_samples)
{
int i, n;
float **d = (float **)dst;
const float **s = (const float **)src;
if (v <= VOLUME_MIN) {
for (i = 0; i < n_dst; i++)
memset(d[i], 0, n_samples * sizeof(float));
}
else if (v == VOLUME_NORM) {
for (n = 0; n < n_samples; n++) {
d[0][n] = s[0][n];
d[1][n] = s[1][n];
d[2][n] = (s[0][n] + s[1][n]) * 0.5f;
d[3][n] = 0.0f;
}
}
else {
const float f = 0.5f * v;
for (n = 0; n < n_samples; n++) {
d[0][n] = s[0][n] * v;
d[1][n] = s[1][n] * v;
d[2][n] = (s[0][n] + s[1][n]) * f;
d[3][n] = 0.0f;
}
}
}
#define MASK_5_1 _M(FL)|_M(FR)|_M(FC)|_M(LFE)|_M(SL)|_M(SR)|_M(RL)|_M(RR)
void
channelmix_f32_2_5p1_c(void *data, int n_dst, void * SPA_RESTRICT dst[n_dst],
int n_src, const void * SPA_RESTRICT src[n_src],
const void *matrix, float v, int n_samples)
{
int i, n;
float **d = (float **)dst;
const float **s = (const float **)src;
if (v <= VOLUME_MIN) {
for (i = 0; i < n_dst; i++)
memset(d[i], 0, n_samples * sizeof(float));
}
else if (v == VOLUME_NORM) {
for (n = 0; n < n_samples; n++) {
d[0][n] = d[4][n] = s[0][n];
d[1][n] = d[5][n] = s[1][n];
d[2][n] = (s[0][n] + s[1][n]) * 0.5f;
d[3][n] = 0.0f;
}
}
else {
const float f = 0.5f * v;
for (n = 0; n < n_samples; n++) {
d[0][n] = d[4][n] = s[0][n] * v;
d[1][n] = d[5][n] = s[1][n] * v;
d[2][n] = (s[0][n] + s[1][n]) * f;
d[3][n] = 0.0f;
}
}
}
/* FL+FR+FC+LFE+SL+SR -> FL+FR */
void
channelmix_f32_5p1_2_c(void *data, int n_dst, void * SPA_RESTRICT dst[n_dst],
int n_src, const void * SPA_RESTRICT src[n_src],
const void *matrix, float v, int n_samples)
{
int n;
float **d = (float **) dst;
const float **s = (const float **) src;
const float *m = matrix;
const float clev = m[2];
const float llev = m[3];
const float slev = m[4];
if (v <= VOLUME_MIN) {
memset(d[0], 0, n_samples * sizeof(float));
memset(d[1], 0, n_samples * sizeof(float));
}
else if (v == VOLUME_NORM) {
for (n = 0; n < n_samples; n++) {
const float ctr = clev * s[2][n] + llev * s[3][n];
d[0][n] = s[0][n] + ctr + (slev * s[4][n]);
d[1][n] = s[1][n] + ctr + (slev * s[5][n]);
}
}
else {
for (n = 0; n < n_samples; n++) {
const float ctr = clev * s[2][n] + llev * s[3][n];
d[0][n] = (s[0][n] + ctr + (slev * s[4][n])) * v;
d[1][n] = (s[1][n] + ctr + (slev * s[5][n])) * v;
}
}
}
/* FL+FR+FC+LFE+SL+SR -> FL+FR+FC+LFE*/
void
channelmix_f32_5p1_3p1_c(void *data, int n_dst, void * SPA_RESTRICT dst[n_dst],
int n_src, const void * SPA_RESTRICT src[n_src],
const void *matrix, float v, int n_samples)
{
int i, n;
float **d = (float **) dst;
const float **s = (const float **) src;
if (v <= VOLUME_MIN) {
for (i = 0; i < n_dst; i++)
memset(d[i], 0, n_samples * sizeof(float));
}
else {
const float f1 = 0.5f * v;
for (n = 0; n < n_samples; n++) {
d[0][n] = (s[0][n] + s[4][n]) * f1;
d[1][n] = (s[1][n] + s[5][n]) * f1;
d[2][n] = s[2][n] * v;
d[3][n] = s[3][n] * v;
}
}
}
/* FL+FR+FC+LFE+SL+SR -> FL+FR+RL+RR*/
void
channelmix_f32_5p1_4_c(void *data, int n_dst, void * SPA_RESTRICT dst[n_dst],
int n_src, const void * SPA_RESTRICT src[n_src],
const void *matrix, float v, int n_samples)
{
int i, n;
float **d = (float **) dst;
const float **s = (const float **) src;
const float *m = matrix;
const float clev = m[2];
const float llev = m[3];
if (v <= VOLUME_MIN) {
for (i = 0; i < n_dst; i++)
memset(d[i], 0, n_samples * sizeof(float));
}
else if (v == VOLUME_NORM) {
for (n = 0; n < n_samples; n++) {
const float ctr = s[2][n] * clev + s[3][n] * llev;
d[0][n] = s[0][n] + ctr;
d[1][n] = s[1][n] + ctr;
d[2][n] = s[4][n];
d[3][n] = s[5][n];
}
}
else {
for (n = 0; n < n_samples; n++) {
const float ctr = s[2][n] * clev + s[3][n] * llev;
d[0][n] = (s[0][n] + ctr) * v;
d[1][n] = (s[1][n] + ctr) * v;
d[2][n] = s[4][n] * v;
d[3][n] = s[5][n] * v;
}
}
}
#define MASK_7_1 _M(FL)|_M(FR)|_M(FC)|_M(LFE)|_M(SL)|_M(SR)|_M(RL)|_M(RR)
/* FL+FR+FC+LFE+SL+SR+RL+RR -> FL+FR */
void
channelmix_f32_7p1_2_c(void *data, int n_dst, void * SPA_RESTRICT dst[n_dst],
int n_src, const void * SPA_RESTRICT src[n_src],
const void *matrix, float v, int n_samples)
{
int n;
float **d = (float **) dst;
const float **s = (const float **) src;
const float *m = matrix;
const float clev = m[2];
const float llev = m[3];
const float slev = m[4];
if (v <= VOLUME_MIN) {
memset(d[0], 0, n_samples * sizeof(float));
memset(d[1], 0, n_samples * sizeof(float));
}
else if (v == VOLUME_NORM) {
for (n = 0; n < n_samples; n++) {
const float ctr = clev * s[2][n] + llev * s[3][n];
d[0][n] = s[0][n] + ctr + (slev * (s[4][n] + s[6][n]));
d[1][n] = s[1][n] + ctr + (slev * (s[5][n] + s[7][n]));
}
}
else {
for (n = 0; n < n_samples; n++) {
const float ctr = clev * s[2][n] + llev * s[3][n];
d[0][n] = (s[0][n] + ctr + (slev * (s[4][n] + s[6][n]))) * v;
d[1][n] = (s[1][n] + ctr + (slev * (s[5][n] + s[6][n]))) * v;
}
}
}
/* FL+FR+FC+LFE+SL+SR+RL+RR -> FL+FR+FC+LFE*/
void
channelmix_f32_7p1_3p1_c(void *data, int n_dst, void * SPA_RESTRICT dst[n_dst],
int n_src, const void * SPA_RESTRICT src[n_src],
const void *matrix, float v, int n_samples)
{
int i, n;
float **d = (float **) dst;
const float **s = (const float **) src;
if (v <= VOLUME_MIN) {
for (i = 0; i < n_dst; i++)
memset(d[i], 0, n_samples * sizeof(float));
}
else {
const float f1 = 0.5 * v;
for (n = 0; n < n_samples; n++) {
d[0][n] = s[0][n] + (s[4][n] + s[6][n]) * f1;
d[1][n] = s[1][n] + (s[5][n] + s[7][n]) * f1;
d[2][n] = s[2][n] * v;
d[3][n] = s[3][n] * v;
}
}
}
/* FL+FR+FC+LFE+SL+SR+RL+RR -> FL+FR+RL+RR*/
void
channelmix_f32_7p1_4_c(void *data, int n_dst, void * SPA_RESTRICT dst[n_dst],
int n_src, const void * SPA_RESTRICT src[n_src],
const void *matrix, float v, int n_samples)
{
int i, n;
float **d = (float **) dst;
const float **s = (const float **) src;
const float *m = matrix;
const float clev = m[2];
const float llev = m[3];
const float slev = m[4];
if (v <= VOLUME_MIN) {
for (i = 0; i < n_dst; i++)
memset(d[i], 0, n_samples * sizeof(float));
}
else if (v == VOLUME_NORM) {
for (n = 0; n < n_samples; n++) {
const float ctr = s[2][n] * clev + s[3][n] * llev;
const float sl = s[4][n] * slev;
const float sr = s[5][n] * slev;
d[0][n] = s[0][n] + ctr + sl;
d[1][n] = s[1][n] + ctr + sr;
d[2][n] = s[6][n] + sl;
d[3][n] = s[7][n] + sr;
}
}
else {
for (n = 0; n < n_samples; n++) {
const float ctr = s[2][n] * clev + s[3][n] * llev;
const float sl = s[4][n] * slev;
const float sr = s[5][n] * slev;
d[0][n] = (s[0][n] + ctr + sl) * v;
d[1][n] = (s[1][n] + ctr + sr) * v;
d[2][n] = (s[6][n] + sl) * v;
d[3][n] = (s[7][n] + sr) * v;
}
}
}

12
spa/plugins/audioconvert/channelmix-ops-sse.c
View file

@ -22,9 +22,11 @@
* DEALINGS IN THE SOFTWARE.
*/
#include "channelmix-ops.h"
#include <xmmintrin.h>
static void
void
channelmix_copy_sse(void *data, int n_dst, void * SPA_RESTRICT dst[n_dst],
int n_src, const void * SPA_RESTRICT src[n_src],
const void *matrix, float v, int n_samples)
@ -70,7 +72,7 @@ channelmix_copy_sse(void *data, int n_dst, void * SPA_RESTRICT dst[n_dst],
}
}
static void
void
channelmix_f32_2_4_sse(void *data, int n_dst, void * SPA_RESTRICT dst[n_dst],
int n_src, const void * SPA_RESTRICT src[n_src],
const void *matrix, float v, int n_samples)
@ -136,7 +138,7 @@ channelmix_f32_2_4_sse(void *data, int n_dst, void * SPA_RESTRICT dst[n_dst],
}
/* FL+FR+FC+LFE+SL+SR -> FL+FR */
static void
void
channelmix_f32_5p1_2_sse(void *data, int n_dst, void * SPA_RESTRICT dst[n_dst],
int n_src, const void * SPA_RESTRICT src[n_src],
const void *matrix, float v, int n_samples)
@ -228,7 +230,7 @@ channelmix_f32_5p1_2_sse(void *data, int n_dst, void * SPA_RESTRICT dst[n_dst],
}
/* FL+FR+FC+LFE+SL+SR -> FL+FR+FC+LFE*/
static void
void
channelmix_f32_5p1_3p1_sse(void *data, int n_dst, void * SPA_RESTRICT dst[n_dst],
int n_src, const void * SPA_RESTRICT src[n_src],
const void *matrix, float v, int n_samples)
@ -311,7 +313,7 @@ channelmix_f32_5p1_3p1_sse(void *data, int n_dst, void * SPA_RESTRICT dst[n_dst]
}
/* FL+FR+FC+LFE+SL+SR -> FL+FR+RL+RR*/
static void
void
channelmix_f32_5p1_4_sse(void *data, int n_dst, void * SPA_RESTRICT dst[n_dst],
int n_src, const void * SPA_RESTRICT src[n_src],
const void *matrix, float v, int n_samples)

464
spa/plugins/audioconvert/channelmix-ops.c
View file

@ -31,434 +31,16 @@
#define VOLUME_MIN 0.0f
#define VOLUME_NORM 1.0f
#if defined (__SSE__)
#include "channelmix-ops-sse.c"
#endif
static void
channelmix_copy(void *data, int n_dst, void * SPA_RESTRICT dst[n_dst],
int n_src, const void * SPA_RESTRICT src[n_src],
const void *matrix, float v, int n_samples)
{
int i, n;
float **d = (float **)dst;
const float **s = (const float **)src;
if (v <= VOLUME_MIN) {
for (i = 0; i < n_dst; i++)
memset(d[i], 0, n_samples * sizeof(float));
}
else if (v == VOLUME_NORM) {
for (i = 0; i < n_dst; i++)
spa_memcpy(d[i], s[i], n_samples * sizeof(float));
}
else {
for (i = 0; i < n_dst; i++)
for (n = 0; n < n_samples; n++)
d[i][n] = s[i][n] * v;
}
}
#include "channelmix-ops.h"
#define _M(ch) (1UL << SPA_AUDIO_CHANNEL_ ## ch)
static void
channelmix_f32_n_m(void *data, int n_dst, void * SPA_RESTRICT dst[n_dst],
int n_src, const void * SPA_RESTRICT src[n_src],
const void *matrix, float v, int n_samples)
{
int i, j, n;
float **d = (float **) dst;
const float **s = (const float **) src;
const float *m = matrix;
for (n = 0; n < n_samples; n++) {
for (i = 0; i < n_dst; i++) {
float sum = 0.0f;
for (j = 0; j < n_src; j++)
sum += s[j][n] * m[i * n_src + j];
d[i][n] = sum * v;
}
}
}
#define MASK_MONO _M(FC)|_M(MONO)|_M(UNKNOWN)
#define MASK_STEREO _M(FL)|_M(FR)|_M(UNKNOWN)
static void
channelmix_f32_1_2(void *data, int n_dst, void * SPA_RESTRICT dst[n_dst],
int n_src, const void * SPA_RESTRICT src[n_src],
const void *matrix, float v, int n_samples)
{
int n;
float **d = (float **)dst;
const float **s = (const float **)src;
if (v <= VOLUME_MIN) {
memset(d[0], 0, n_samples * sizeof(float));
memset(d[1], 0, n_samples * sizeof(float));
}
else if (v == VOLUME_NORM) {
for (n = 0; n < n_samples; n++)
d[0][n] = d[1][n] = s[0][n];
}
else {
for (n = 0; n < n_samples; n++)
d[0][n] = d[1][n] = s[0][n] * v;
}
}
static void
channelmix_f32_2_1(void *data, int n_dst, void * SPA_RESTRICT dst[n_dst],
int n_src, const void * SPA_RESTRICT src[n_src],
const void *matrix, float v, int n_samples)
{
int n;
float **d = (float **)dst;
const float **s = (const float **)src;
if (v <= VOLUME_MIN) {
memset(d[0], 0, n_samples * sizeof(float));
}
else {
const float f = v * 0.5f;
for (n = 0; n < n_samples; n++)
d[0][n] = (s[0][n] + s[1][n]) * f;
}
}
static void
channelmix_f32_4_1(void *data, int n_dst, void * SPA_RESTRICT dst[n_dst],
int n_src, const void * SPA_RESTRICT src[n_src],
const void *matrix, float v, int n_samples)
{
int n;
float **d = (float **)dst;
const float **s = (const float **)src;
if (v <= VOLUME_MIN) {
memset(d[0], 0, n_samples * sizeof(float));
}
else {
const float f = v * 0.25f;
for (n = 0; n < n_samples; n++)
d[0][n] = (s[0][n] + s[1][n] + s[2][n] + s[3][n]) * f;
}
}
static void
channelmix_f32_3p1_1(void *data, int n_dst, void * SPA_RESTRICT dst[n_dst],
int n_src, const void * SPA_RESTRICT src[n_src],
const void *matrix, float v, int n_samples)
{
int n;
float **d = (float **)dst;
const float **s = (const float **)src;
if (v <= VOLUME_MIN) {
memset(d[0], 0, n_samples * sizeof(float));
}
else {
const float f = v * 0.5f;
for (n = 0; n < n_samples; n++)
d[0][n] = (s[0][n] + s[1][n] + s[2][n]) * f;
}
}
#define MASK_QUAD _M(FL)|_M(FR)|_M(RL)|_M(RR)|_M(UNKNOWN)
static void
channelmix_f32_2_4(void *data, int n_dst, void * SPA_RESTRICT dst[n_dst],
int n_src, const void * SPA_RESTRICT src[n_src],
const void *matrix, float v, int n_samples)
{
int i, n;
float **d = (float **)dst;
const float **s = (const float **)src;
if (v <= VOLUME_MIN) {
for (i = 0; i < n_dst; i++)
memset(d[i], 0, n_samples * sizeof(float));
}
else if (v == VOLUME_NORM) {
for (n = 0; n < n_samples; n++) {
d[0][n] = d[2][n] = s[0][n];
d[1][n] = d[3][n] = s[1][n];
}
}
else {
for (n = 0; n < n_samples; n++) {
d[0][n] = d[2][n] = s[0][n] * v;
d[1][n] = d[3][n] = s[1][n] * v;
}
}
}
#define MASK_3_1 _M(FL)|_M(FR)|_M(FC)|_M(LFE)
static void
channelmix_f32_2_3p1(void *data, int n_dst, void * SPA_RESTRICT dst[n_dst],
int n_src, const void * SPA_RESTRICT src[n_src],
const void *matrix, float v, int n_samples)
{
int i, n;
float **d = (float **)dst;
const float **s = (const float **)src;
if (v <= VOLUME_MIN) {
for (i = 0; i < n_dst; i++)
memset(d[i], 0, n_samples * sizeof(float));
}
else if (v == VOLUME_NORM) {
for (n = 0; n < n_samples; n++) {
d[0][n] = s[0][n];
d[1][n] = s[1][n];
d[2][n] = (s[0][n] + s[1][n]) * 0.5f;
d[3][n] = 0.0f;
}
}
else {
const float f = 0.5f * v;
for (n = 0; n < n_samples; n++) {
d[0][n] = s[0][n] * v;
d[1][n] = s[1][n] * v;
d[2][n] = (s[0][n] + s[1][n]) * f;
d[3][n] = 0.0f;
}
}
}
#define MASK_5_1 _M(FL)|_M(FR)|_M(FC)|_M(LFE)|_M(SL)|_M(SR)|_M(RL)|_M(RR)
static void
channelmix_f32_2_5p1(void *data, int n_dst, void * SPA_RESTRICT dst[n_dst],
int n_src, const void * SPA_RESTRICT src[n_src],
const void *matrix, float v, int n_samples)
{
int i, n;
float **d = (float **)dst;
const float **s = (const float **)src;
if (v <= VOLUME_MIN) {
for (i = 0; i < n_dst; i++)
memset(d[i], 0, n_samples * sizeof(float));
}
else if (v == VOLUME_NORM) {
for (n = 0; n < n_samples; n++) {
d[0][n] = d[4][n] = s[0][n];
d[1][n] = d[5][n] = s[1][n];
d[2][n] = (s[0][n] + s[1][n]) * 0.5f;
d[3][n] = 0.0f;
}
}
else {
const float f = 0.5f * v;
for (n = 0; n < n_samples; n++) {
d[0][n] = d[4][n] = s[0][n] * v;
d[1][n] = d[5][n] = s[1][n] * v;
d[2][n] = (s[0][n] + s[1][n]) * f;
d[3][n] = 0.0f;
}
}
}
/* FL+FR+FC+LFE+SL+SR -> FL+FR */
static void
channelmix_f32_5p1_2(void *data, int n_dst, void * SPA_RESTRICT dst[n_dst],
int n_src, const void * SPA_RESTRICT src[n_src],
const void *matrix, float v, int n_samples)
{
int n;
float **d = (float **) dst;
const float **s = (const float **) src;
const float *m = matrix;
const float clev = m[2];
const float llev = m[3];
const float slev = m[4];
if (v <= VOLUME_MIN) {
memset(d[0], 0, n_samples * sizeof(float));
memset(d[1], 0, n_samples * sizeof(float));
}
else if (v == VOLUME_NORM) {
for (n = 0; n < n_samples; n++) {
const float ctr = clev * s[2][n] + llev * s[3][n];
d[0][n] = s[0][n] + ctr + (slev * s[4][n]);
d[1][n] = s[1][n] + ctr + (slev * s[5][n]);
}
}
else {
for (n = 0; n < n_samples; n++) {
const float ctr = clev * s[2][n] + llev * s[3][n];
d[0][n] = (s[0][n] + ctr + (slev * s[4][n])) * v;
d[1][n] = (s[1][n] + ctr + (slev * s[5][n])) * v;
}
}
}
/* FL+FR+FC+LFE+SL+SR -> FL+FR+FC+LFE*/
static void
channelmix_f32_5p1_3p1(void *data, int n_dst, void * SPA_RESTRICT dst[n_dst],
int n_src, const void * SPA_RESTRICT src[n_src],
const void *matrix, float v, int n_samples)
{
int i, n;
float **d = (float **) dst;
const float **s = (const float **) src;
if (v <= VOLUME_MIN) {
for (i = 0; i < n_dst; i++)
memset(d[i], 0, n_samples * sizeof(float));
}
else {
const float f1 = 0.5f * v;
for (n = 0; n < n_samples; n++) {
d[0][n] = (s[0][n] + s[4][n]) * f1;
d[1][n] = (s[1][n] + s[5][n]) * f1;
d[2][n] = s[2][n] * v;
d[3][n] = s[3][n] * v;
}
}
}
/* FL+FR+FC+LFE+SL+SR -> FL+FR+RL+RR*/
static void
channelmix_f32_5p1_4(void *data, int n_dst, void * SPA_RESTRICT dst[n_dst],
int n_src, const void * SPA_RESTRICT src[n_src],
const void *matrix, float v, int n_samples)
{
int i, n;
float **d = (float **) dst;
const float **s = (const float **) src;
const float *m = matrix;
const float clev = m[2];
const float llev = m[3];
if (v <= VOLUME_MIN) {
for (i = 0; i < n_dst; i++)
memset(d[i], 0, n_samples * sizeof(float));
}
else if (v == VOLUME_NORM) {
for (n = 0; n < n_samples; n++) {
const float ctr = s[2][n] * clev + s[3][n] * llev;
d[0][n] = s[0][n] + ctr;
d[1][n] = s[1][n] + ctr;
d[2][n] = s[4][n];
d[3][n] = s[5][n];
}
}
else {
for (n = 0; n < n_samples; n++) {
const float ctr = s[2][n] * clev + s[3][n] * llev;
d[0][n] = (s[0][n] + ctr) * v;
d[1][n] = (s[1][n] + ctr) * v;
d[2][n] = s[4][n] * v;
d[3][n] = s[5][n] * v;
}
}
}
#define MASK_7_1 _M(FL)|_M(FR)|_M(FC)|_M(LFE)|_M(SL)|_M(SR)|_M(RL)|_M(RR)
/* FL+FR+FC+LFE+SL+SR+RL+RR -> FL+FR */
static void
channelmix_f32_7p1_2(void *data, int n_dst, void * SPA_RESTRICT dst[n_dst],
int n_src, const void * SPA_RESTRICT src[n_src],
const void *matrix, float v, int n_samples)
{
int n;
float **d = (float **) dst;
const float **s = (const float **) src;
const float *m = matrix;
const float clev = m[2];
const float llev = m[3];
const float slev = m[4];
if (v <= VOLUME_MIN) {
memset(d[0], 0, n_samples * sizeof(float));
memset(d[1], 0, n_samples * sizeof(float));
}
else if (v == VOLUME_NORM) {
for (n = 0; n < n_samples; n++) {
const float ctr = clev * s[2][n] + llev * s[3][n];
d[0][n] = s[0][n] + ctr + (slev * (s[4][n] + s[6][n]));
d[1][n] = s[1][n] + ctr + (slev * (s[5][n] + s[7][n]));
}
}
else {
for (n = 0; n < n_samples; n++) {
const float ctr = clev * s[2][n] + llev * s[3][n];
d[0][n] = (s[0][n] + ctr + (slev * (s[4][n] + s[6][n]))) * v;
d[1][n] = (s[1][n] + ctr + (slev * (s[5][n] + s[6][n]))) * v;
}
}
}
/* FL+FR+FC+LFE+SL+SR+RL+RR -> FL+FR+FC+LFE*/
static void
channelmix_f32_7p1_3p1(void *data, int n_dst, void * SPA_RESTRICT dst[n_dst],
int n_src, const void * SPA_RESTRICT src[n_src],
const void *matrix, float v, int n_samples)
{
int i, n;
float **d = (float **) dst;
const float **s = (const float **) src;
if (v <= VOLUME_MIN) {
for (i = 0; i < n_dst; i++)
memset(d[i], 0, n_samples * sizeof(float));
}
else {
const float f1 = 0.5 * v;
for (n = 0; n < n_samples; n++) {
d[0][n] = s[0][n] + (s[4][n] + s[6][n]) * f1;
d[1][n] = s[1][n] + (s[5][n] + s[7][n]) * f1;
d[2][n] = s[2][n] * v;
d[3][n] = s[3][n] * v;
}
}
}
/* FL+FR+FC+LFE+SL+SR+RL+RR -> FL+FR+RL+RR*/
static void
channelmix_f32_7p1_4(void *data, int n_dst, void * SPA_RESTRICT dst[n_dst],
int n_src, const void * SPA_RESTRICT src[n_src],
const void *matrix, float v, int n_samples)
{
int i, n;
float **d = (float **) dst;
const float **s = (const float **) src;
const float *m = matrix;
const float clev = m[2];
const float llev = m[3];
const float slev = m[4];
if (v <= VOLUME_MIN) {
for (i = 0; i < n_dst; i++)
memset(d[i], 0, n_samples * sizeof(float));
}
else if (v == VOLUME_NORM) {
for (n = 0; n < n_samples; n++) {
const float ctr = s[2][n] * clev + s[3][n] * llev;
const float sl = s[4][n] * slev;
const float sr = s[5][n] * slev;
d[0][n] = s[0][n] + ctr + sl;
d[1][n] = s[1][n] + ctr + sr;
d[2][n] = s[6][n] + sl;
d[3][n] = s[7][n] + sr;
}
}
else {
for (n = 0; n < n_samples; n++) {
const float ctr = s[2][n] * clev + s[3][n] * llev;
const float sl = s[4][n] * slev;
const float sr = s[5][n] * slev;
d[0][n] = (s[0][n] + ctr + sl) * v;
d[1][n] = (s[1][n] + ctr + sr) * v;
d[2][n] = (s[6][n] + sl) * v;
d[3][n] = (s[7][n] + sr) * v;
}
}
}
typedef void (*channelmix_func_t) (void *data, int n_dst, void * SPA_RESTRICT dst[n_dst],
int n_src, const void * SPA_RESTRICT src[n_src],
const void * SPA_RESTRICT matrix, float v, int n_samples);
@ -478,44 +60,44 @@ static const struct channelmix_info {
uint32_t features;
} channelmix_table[] =
{
#if defined (__SSE__)
#if defined (HAVE_SSE)
{ 2, MASK_MONO, 2, MASK_MONO, channelmix_copy_sse, FEATURE_SSE },
{ 2, MASK_STEREO, 2, MASK_STEREO, channelmix_copy_sse, FEATURE_SSE },
{ EQ, 0, EQ, 0, channelmix_copy_sse, FEATURE_SSE },
#endif
{ 2, MASK_MONO, 2, MASK_MONO, channelmix_copy, 0 },
{ 2, MASK_STEREO, 2, MASK_STEREO, channelmix_copy, 0 },
{ EQ, 0, EQ, 0, channelmix_copy, 0 },
{ 2, MASK_MONO, 2, MASK_MONO, channelmix_copy_c, 0 },
{ 2, MASK_STEREO, 2, MASK_STEREO, channelmix_copy_c, 0 },
{ EQ, 0, EQ, 0, channelmix_copy_c, 0 },
{ 1, MASK_MONO, 2, MASK_STEREO, channelmix_f32_1_2, 0 },
{ 2, MASK_STEREO, 1, MASK_MONO, channelmix_f32_2_1, 0 },
{ 4, MASK_QUAD, 1, MASK_MONO, channelmix_f32_4_1, 0 },
{ 4, MASK_3_1, 1, MASK_MONO, channelmix_f32_3p1_1, 0 },
#if defined (__SSE__)
{ 1, MASK_MONO, 2, MASK_STEREO, channelmix_f32_1_2_c, 0 },
{ 2, MASK_STEREO, 1, MASK_MONO, channelmix_f32_2_1_c, 0 },
{ 4, MASK_QUAD, 1, MASK_MONO, channelmix_f32_4_1_c, 0 },
{ 4, MASK_3_1, 1, MASK_MONO, channelmix_f32_3p1_1_c, 0 },
#if defined (HAVE_SSE)
{ 2, MASK_STEREO, 4, MASK_QUAD, channelmix_f32_2_4_sse, FEATURE_SSE },
#endif
{ 2, MASK_STEREO, 4, MASK_QUAD, channelmix_f32_2_4, 0 },
{ 2, MASK_STEREO, 4, MASK_3_1, channelmix_f32_2_3p1, 0 },
{ 2, MASK_STEREO, 6, MASK_5_1, channelmix_f32_2_5p1, 0 },
#if defined (__SSE__)
{ 2, MASK_STEREO, 4, MASK_QUAD, channelmix_f32_2_4_c, 0 },
{ 2, MASK_STEREO, 4, MASK_3_1, channelmix_f32_2_3p1_c, 0 },
{ 2, MASK_STEREO, 6, MASK_5_1, channelmix_f32_2_5p1_c, 0 },
#if defined (HAVE_SSE)
{ 6, MASK_5_1, 2, MASK_STEREO, channelmix_f32_5p1_2_sse, FEATURE_SSE },
#endif
{ 6, MASK_5_1, 2, MASK_STEREO, channelmix_f32_5p1_2, 0 },
#if defined (__SSE__)
{ 6, MASK_5_1, 2, MASK_STEREO, channelmix_f32_5p1_2_c, 0 },
#if defined (HAVE_SSE)
{ 6, MASK_5_1, 4, MASK_QUAD, channelmix_f32_5p1_4_sse, FEATURE_SSE },
#endif
{ 6, MASK_5_1, 4, MASK_QUAD, channelmix_f32_5p1_4, 0 },
{ 6, MASK_5_1, 4, MASK_QUAD, channelmix_f32_5p1_4_c, 0 },
#if defined (__SSE__)
#if defined (HAVE_SSE)
{ 6, MASK_5_1, 4, MASK_3_1, channelmix_f32_5p1_3p1_sse, FEATURE_SSE },
#endif
{ 6, MASK_5_1, 4, MASK_3_1, channelmix_f32_5p1_3p1, 0 },
{ 6, MASK_5_1, 4, MASK_3_1, channelmix_f32_5p1_3p1_c, 0 },
{ 8, MASK_7_1, 2, MASK_STEREO, channelmix_f32_7p1_2, 0 },
{ 8, MASK_7_1, 4, MASK_QUAD, channelmix_f32_7p1_4, 0 },
{ 8, MASK_7_1, 4, MASK_3_1, channelmix_f32_7p1_3p1, 0 },
{ 8, MASK_7_1, 2, MASK_STEREO, channelmix_f32_7p1_2_c, 0 },
{ 8, MASK_7_1, 4, MASK_QUAD, channelmix_f32_7p1_4_c, 0 },
{ 8, MASK_7_1, 4, MASK_3_1, channelmix_f32_7p1_3p1_c, 0 },
{ ANY, 0, ANY, 0, channelmix_f32_n_m, 0 },
{ ANY, 0, ANY, 0, channelmix_f32_n_m_c, 0 },
};
#define MATCH_CHAN(a,b) ((a) == ANY || (a) == (b))

74
spa/plugins/audioconvert/channelmix-ops.h Normal file
View file

@ -0,0 +1,74 @@
/* Spa
*
* Copyright © 2018 Wim Taymans
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*/
#include <string.h>
#include <stdio.h>
#include <spa/utils/defs.h>
#define VOLUME_MIN 0.0f
#define VOLUME_NORM 1.0f
#define _M(ch) (1UL << SPA_AUDIO_CHANNEL_ ## ch)
#define MASK_MONO _M(FC)|_M(MONO)|_M(UNKNOWN)
#define MASK_STEREO _M(FL)|_M(FR)|_M(UNKNOWN)
#define MASK_QUAD _M(FL)|_M(FR)|_M(RL)|_M(RR)|_M(UNKNOWN)
#define MASK_3_1 _M(FL)|_M(FR)|_M(FC)|_M(LFE)
#define MASK_5_1 _M(FL)|_M(FR)|_M(FC)|_M(LFE)|_M(SL)|_M(SR)|_M(RL)|_M(RR)
#define MASK_7_1 _M(FL)|_M(FR)|_M(FC)|_M(LFE)|_M(SL)|_M(SR)|_M(RL)|_M(RR)
typedef void (*channelmix_func_t) (void *data, int n_dst, void * SPA_RESTRICT dst[n_dst],
int n_src, const void * SPA_RESTRICT src[n_src],
const void * SPA_RESTRICT matrix, float v, int n_samples);
#define DEFINE_FUNCTION(name,arch) \
void channelmix_##name##_##arch(void *data, \
int n_dst, void * SPA_RESTRICT dst[n_dst], \
int n_src, const void * SPA_RESTRICT src[n_src], \
const void *matrix, float v, int n_samples);
DEFINE_FUNCTION(copy, c);
DEFINE_FUNCTION(f32_n_m, c);
DEFINE_FUNCTION(f32_1_2, c);
DEFINE_FUNCTION(f32_2_1, c);
DEFINE_FUNCTION(f32_4_1, c);
DEFINE_FUNCTION(f32_3p1_1, c);
DEFINE_FUNCTION(f32_2_4, c);
DEFINE_FUNCTION(f32_2_3p1, c);
DEFINE_FUNCTION(f32_2_5p1, c);
DEFINE_FUNCTION(f32_5p1_2, c);
DEFINE_FUNCTION(f32_5p1_3p1, c);
DEFINE_FUNCTION(f32_5p1_4, c);
DEFINE_FUNCTION(f32_7p1_2, c);
DEFINE_FUNCTION(f32_7p1_3p1, c);
DEFINE_FUNCTION(f32_7p1_4, c);
#if defined (HAVE_SSE)
DEFINE_FUNCTION(copy, sse);
DEFINE_FUNCTION(f32_2_4, sse);
DEFINE_FUNCTION(f32_5p1_2, sse);
DEFINE_FUNCTION(f32_5p1_3p1, sse);
DEFINE_FUNCTION(f32_5p1_4, sse);
DEFINE_FUNCTION(f32_7p1_4, sse);
#endif

670
spa/plugins/audioconvert/fmt-ops-c.c Normal file
View file

@ -0,0 +1,670 @@
/* Spa
*
* Copyright © 2018 Wim Taymans
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*/
#include <string.h>
#include <stdio.h>
#include <math.h>
#include <spa/support/cpu.h>
#include <spa/utils/defs.h>
#include <spa/param/audio/format-utils.h>
#include "fmt-ops.h"
void
conv_copy8d_c(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
uint32_t i;
for (i = 0; i < n_channels; i++)
spa_memcpy(dst[i], src[i], n_samples);
}
void
conv_copy8_c(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
spa_memcpy(dst[0], src[0], n_samples * n_channels);
}
void
conv_copy16d_c(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
uint32_t i;
for (i = 0; i < n_channels; i++)
spa_memcpy(dst[i], src[i], n_samples * sizeof(int16_t));
}
void
conv_copy16_c(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
spa_memcpy(dst[0], src[0], n_samples * sizeof(int16_t) * n_channels);
}
void
conv_copy24d_c(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
uint32_t i;
for (i = 0; i < n_channels; i++)
spa_memcpy(dst[i], src[i], n_samples * 3);
}
void
conv_copy24_c(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
spa_memcpy(dst[0], src[0], n_samples * 3 * n_channels);
}
void
conv_copy32d_c(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
uint32_t i;
for (i = 0; i < n_channels; i++)
spa_memcpy(dst[i], src[i], n_samples * sizeof(int32_t));
}
void
conv_copy32_c(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
spa_memcpy(dst[0], src[0], n_samples * sizeof(int32_t) * n_channels);
}
void
conv_u8d_to_f32d_c(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
uint32_t i, j;
for (i = 0; i < n_channels; i++) {
const uint8_t *s = src[i];
float *d = dst[i];
for (j = 0; j < n_samples; j++)
d[j] = U8_TO_F32(s[j]);
}
}
void
conv_u8_to_f32_c(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
conv_u8d_to_f32d_c(data, dst, src, 1, n_samples * n_channels);
}
void
conv_u8_to_f32d_c(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
const uint8_t *s = src[0];
float **d = (float **) dst;
uint32_t i, j;
for (j = 0; j < n_samples; j++) {
for (i = 0; i < n_channels; i++)
d[i][j] = U8_TO_F32(*s++);
}
}
void
conv_u8d_to_f32_c(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
const uint8_t **s = (const uint8_t **) src;
float *d = dst[0];
uint32_t i, j;
for (j = 0; j < n_samples; j++) {
for (i = 0; i < n_channels; i++)
*d++ = U8_TO_F32(s[i][j]);
}
}
void
conv_s16d_to_f32d_c(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
uint32_t i, j;
for (i = 0; i < n_channels; i++) {
const int16_t *s = src[i];
float *d = dst[i];
for (j = 0; j < n_samples; j++)
d[j] = S16_TO_F32(s[j]);
}
}
void
conv_s16_to_f32_c(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
conv_s16d_to_f32d_c(data, dst, src, 1, n_samples * n_channels);
}
void
conv_s16_to_f32d_c(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
const int16_t *s = src[0];
float **d = (float **) dst;
uint32_t i, j;
for (j = 0; j < n_samples; j++) {
for (i = 0; i < n_channels; i++)
d[i][j] = S16_TO_F32(*s++);
}
}
void
conv_s16d_to_f32_c(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
const int16_t **s = (const int16_t **) src;
float *d = dst[0];
uint32_t i, j;
for (j = 0; j < n_samples; j++) {
for (i = 0; i < n_channels; i++)
*d++ = S16_TO_F32(s[i][j]);
}
}
void
conv_s32d_to_f32d_c(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
uint32_t i, j;
for (i = 0; i < n_channels; i++) {
const int32_t *s = src[i];
float *d = dst[i];
for (j = 0; j < n_samples; j++)
d[j] = S32_TO_F32(s[j]);
}
}
void
conv_s32_to_f32_c(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
conv_s32d_to_f32d_c(data, dst, src, 1, n_samples * n_channels);
}
void
conv_s32_to_f32d_c(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
const int32_t *s = src[0];
float **d = (float **) dst;
uint32_t i, j;
for (j = 0; j < n_samples; j++) {
for (i = 0; i < n_channels; i++)
d[i][j] = S32_TO_F32(*s++);
}
}
void
conv_s32d_to_f32_c(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
const int32_t **s = (const int32_t **) src;
float *d = dst[0];
uint32_t i, j;
for (j = 0; j < n_samples; j++) {
for (i = 0; i < n_channels; i++)
*d++ = S32_TO_F32(s[i][j]);
}
}
void
conv_s24d_to_f32d_c(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
uint32_t i, j;
for (i = 0; i < n_channels; i++) {
const int8_t *s = src[i];
float *d = dst[i];
for (j = 0; j < n_samples; j++) {
d[j] = S24_TO_F32(read_s24(s));
s += 3;
}
}
}
void
conv_s24_to_f32_c(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
conv_s24d_to_f32d_c(data, dst, src, 1, n_samples * n_channels);
}
void
conv_s24_to_f32d_c(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
const uint8_t *s = src[0];
float **d = (float **) dst;
uint32_t i, j;
for (j = 0; j < n_samples; j++) {
for (i = 0; i < n_channels; i++) {
d[i][j] = S24_TO_F32(read_s24(s));
s += 3;
}
}
}
void
conv_s24d_to_f32_c(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
const uint8_t **s = (const uint8_t **) src;
float *d = dst[0];
uint32_t i, j;
for (j = 0; j < n_samples; j++) {
for (i = 0; i < n_channels; i++) {
*d++ = S24_TO_F32(read_s24(&s[i][j*3]));
}
}
}
void
conv_s24_32d_to_f32d_c(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
uint32_t i, j;
for (i = 0; i < n_channels; i++) {
const int32_t *s = src[i];
float *d = dst[i];
for (j = 0; j < n_samples; j++)
d[j] = S24_TO_F32(s[j]);
}
}
void
conv_s24_32_to_f32_c(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
conv_s24_32d_to_f32d_c(data, dst, src, 1, n_samples * n_channels);
}
void
conv_s24_32_to_f32d_c(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
const int32_t *s = src[0];
float **d = (float **) dst;
uint32_t i, j;
for (j = 0; j < n_samples; j++) {
for (i = 0; i < n_channels; i++)
d[i][j] = S24_TO_F32(*s++);
}
}
void
conv_s24_32d_to_f32_c(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
const int32_t **s = (const int32_t **) src;
float *d = dst[0];
uint32_t i, j;
for (j = 0; j < n_samples; j++) {
for (i = 0; i < n_channels; i++)
*d++ = S24_TO_F32(s[i][j]);
}
}
void
conv_f32d_to_u8d_c(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
uint32_t i, j;
for (i = 0; i < n_channels; i++) {
const float *s = src[i];
uint8_t *d = dst[i];
for (j = 0; j < n_samples; j++)
d[j] = F32_TO_U8(s[j]);
}
}
void
conv_f32_to_u8_c(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
conv_f32d_to_u8d_c(data, dst, src, 1, n_samples * n_channels);
}
void
conv_f32_to_u8d_c(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
const float *s = src[0];
uint8_t **d = (uint8_t **) dst;
uint32_t i, j;
for (j = 0; j < n_samples; j++) {
for (i = 0; i < n_channels; i++)
d[i][j] = F32_TO_U8(*s++);
}
}
void
conv_f32d_to_u8_c(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
const float **s = (const float **) src;
uint8_t *d = dst[0];
uint32_t i, j;
for (j = 0; j < n_samples; j++) {
for (i = 0; i < n_channels; i++)
*d++ = F32_TO_U8(s[i][j]);
}
}
void
conv_f32d_to_s16d_c(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
uint32_t i, j;
for (i = 0; i < n_channels; i++) {
const float *s = src[i];
int16_t *d = dst[i];
for (j = 0; j < n_samples; j++)
d[j] = F32_TO_S16(s[j]);
}
}
void
conv_f32_to_s16_c(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
conv_f32d_to_s16d_c(data, dst, src, 1, n_samples * n_channels);
}
void
conv_f32_to_s16d_c(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
const float *s = src[0];
int16_t **d = (int16_t **) dst;
uint32_t i, j;
for (j = 0; j < n_samples; j++) {
for (i = 0; i < n_channels; i++)
d[i][j] = F32_TO_S16(*s++);
}
}
void
conv_f32d_to_s16_c(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
const float **s = (const float **) src;
int16_t *d = dst[0];
uint32_t i, j;
for (j = 0; j < n_samples; j++) {
for (i = 0; i < n_channels; i++)
*d++ = F32_TO_S16(s[i][j]);
}
}
void
conv_f32d_to_s32d_c(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
uint32_t i, j;
for (i = 0; i < n_channels; i++) {
const float *s = src[i];
int32_t *d = dst[i];
for (j = 0; j < n_samples; j++)
d[j] = F32_TO_S32(s[j]);
}
}
void
conv_f32_to_s32_c(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
conv_f32d_to_s32d_c(data, dst, src, 1, n_samples * n_channels);
}
void
conv_f32_to_s32d_c(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
const float *s = src[0];
int32_t **d = (int32_t **) dst;
uint32_t i, j;
for (j = 0; j < n_samples; j++) {
for (i = 0; i < n_channels; i++)
d[i][j] = F32_TO_S32(*s++);
}
}
void
conv_f32d_to_s32_c(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
const float **s = (const float **) src;
int32_t *d = dst[0];
uint32_t i, j;
for (j = 0; j < n_samples; j++) {
for (i = 0; i < n_channels; i++)
*d++ = F32_TO_S32(s[i][j]);
}
}
void
conv_f32d_to_s24d_c(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
uint32_t i, j;
for (i = 0; i < n_channels; i++) {
const float *s = src[i];
uint8_t *d = dst[i];
for (j = 0; j < n_samples; j++) {
write_s24(d, F32_TO_S24(s[j]));
d += 3;
}
}
}
void
conv_f32_to_s24_c(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
conv_f32d_to_s24d_c(data, dst, src, 1, n_samples * n_channels);
}
void
conv_f32_to_s24d_c(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
const float *s = src[0];
uint8_t **d = (uint8_t **) dst;
uint32_t i, j;
for (j = 0; j < n_samples; j++) {
for (i = 0; i < n_channels; i++) {
write_s24(&d[i][j*3], F32_TO_S24(*s++));
}
}
}
void
conv_f32d_to_s24_c(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
const float **s = (const float **) src;
uint8_t *d = dst[0];
uint32_t i, j;
for (j = 0; j < n_samples; j++) {
for (i = 0; i < n_channels; i++) {
write_s24(d, F32_TO_S24(s[i][j]));
d += 3;
}
}
}
void
conv_f32d_to_s24_32d_c(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
uint32_t i, j;
for (i = 0; i < n_channels; i++) {
const float *s = src[i];
int32_t *d = dst[i];
for (j = 0; j < n_samples; j++)
d[j] = F32_TO_S24(s[j]);
}
}
void
conv_f32_to_s24_32_c(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
conv_f32d_to_s24_32d_c(data, dst, src, 1, n_samples * n_channels);
}
void
conv_f32_to_s24_32d_c(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
const float *s = src[0];
int32_t **d = (int32_t **) dst;
uint32_t i, j;
for (j = 0; j < n_samples; j++) {
for (i = 0; i < n_channels; i++)
d[i][j] = F32_TO_S24(*s++);
}
}
void
conv_f32d_to_s24_32_c(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
const float **s = (const float **) src;
int32_t *d = dst[0];
uint32_t i, j;
for (j = 0; j < n_samples; j++) {
for (i = 0; i < n_channels; i++)
*d++ = F32_TO_S24(s[i][j]);
}
}
void
conv_deinterleave_8_c(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
const uint8_t *s = src[0];
uint8_t **d = (uint8_t **) dst;
uint32_t i, j;
for (j = 0; j < n_samples; j++) {
for (i = 0; i < n_channels; i++)
d[i][j] = *s++;
}
}
void
conv_deinterleave_16_c(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
const uint16_t *s = src[0];
uint16_t **d = (uint16_t **) dst;
uint32_t i, j;
for (j = 0; j < n_samples; j++) {
for (i = 0; i < n_channels; i++)
d[i][j] = *s++;
}
}
void
conv_deinterleave_24_c(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
const uint8_t *s = src[0];
uint8_t **d = (uint8_t **) dst;
uint32_t i, j;
for (j = 0; j < n_samples; j++) {
for (i = 0; i < n_channels; i++) {
write_s24(&d[i][j*3], read_s24(s));
s += 3;
}
}
}
void
conv_deinterleave_32_c(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
const uint32_t *s = src[0];
uint32_t **d = (uint32_t **) dst;
uint32_t i, j;
for (j = 0; j < n_samples; j++) {
for (i = 0; i < n_channels; i++)
d[i][j] = *s++;
}
}
void
conv_interleave_8_c(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
const int8_t **s = (const int8_t **) src;
uint8_t *d = dst[0];
uint32_t i, j;
for (j = 0; j < n_samples; j++) {
for (i = 0; i < n_channels; i++)
*d++ = s[i][j];
}
}
void
conv_interleave_16_c(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
const int16_t **s = (const int16_t **) src;
uint16_t *d = dst[0];
uint32_t i, j;
for (j = 0; j < n_samples; j++) {
for (i = 0; i < n_channels; i++)
*d++ = s[i][j];
}
}
void
conv_interleave_24_c(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
const int8_t **s = (const int8_t **) src;
uint8_t *d = dst[0];
uint32_t i, j;
for (j = 0; j < n_samples; j++) {
for (i = 0; i < n_channels; i++) {
write_s24(d, read_s24(&s[i][j*3]));
d += 3;
}
}
}
void
conv_interleave_32_c(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
const int32_t **s = (const int32_t **) src;
uint32_t *d = dst[0];
uint32_t i, j;
for (j = 0; j < n_samples; j++) {
for (i = 0; i < n_channels; i++)
*d++ = s[i][j];
}
}

765
spa/plugins/audioconvert/fmt-ops.c
View file

@ -32,643 +32,6 @@
#include "fmt-ops.h"
static void
conv_copy8d(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
uint32_t i;
for (i = 0; i < n_channels; i++)
spa_memcpy(dst[i], src[i], n_samples);
}
static void
conv_copy8(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
spa_memcpy(dst[0], src[0], n_samples * n_channels);
}
static void
conv_copy16d(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
uint32_t i;
for (i = 0; i < n_channels; i++)
spa_memcpy(dst[i], src[i], n_samples * sizeof(int16_t));
}
static void
conv_copy16(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
spa_memcpy(dst[0], src[0], n_samples * sizeof(int16_t) * n_channels);
}
static void
conv_copy24d(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
uint32_t i;
for (i = 0; i < n_channels; i++)
spa_memcpy(dst[i], src[i], n_samples * 3);
}
static void
conv_copy24(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
spa_memcpy(dst[0], src[0], n_samples * 3 * n_channels);
}
static void
conv_copy32d(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
uint32_t i;
for (i = 0; i < n_channels; i++)
spa_memcpy(dst[i], src[i], n_samples * sizeof(int32_t));
}
static void
conv_copy32(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
spa_memcpy(dst[0], src[0], n_samples * sizeof(int32_t) * n_channels);
}
static void
conv_u8d_to_f32d(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
uint32_t i, j;
for (i = 0; i < n_channels; i++) {
const uint8_t *s = src[i];
float *d = dst[i];
for (j = 0; j < n_samples; j++)
d[j] = U8_TO_F32(s[j]);
}
}
static void
conv_u8_to_f32(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
conv_u8d_to_f32d(data, dst, src, 1, n_samples * n_channels);
}
static void
conv_u8_to_f32d(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
const uint8_t *s = src[0];
float **d = (float **) dst;
uint32_t i, j;
for (j = 0; j < n_samples; j++) {
for (i = 0; i < n_channels; i++)
d[i][j] = U8_TO_F32(*s++);
}
}
static void
conv_u8d_to_f32(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
const uint8_t **s = (const uint8_t **) src;
float *d = dst[0];
uint32_t i, j;
for (j = 0; j < n_samples; j++) {
for (i = 0; i < n_channels; i++)
*d++ = U8_TO_F32(s[i][j]);
}
}
static void
conv_s16d_to_f32d(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
uint32_t i, j;
for (i = 0; i < n_channels; i++) {
const int16_t *s = src[i];
float *d = dst[i];
for (j = 0; j < n_samples; j++)
d[j] = S16_TO_F32(s[j]);
}
}
static void
conv_s16_to_f32(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
conv_s16d_to_f32d(data, dst, src, 1, n_samples * n_channels);
}
static void
conv_s16_to_f32d(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
const int16_t *s = src[0];
float **d = (float **) dst;
uint32_t i, j;
for (j = 0; j < n_samples; j++) {
for (i = 0; i < n_channels; i++)
d[i][j] = S16_TO_F32(*s++);
}
}
static void
conv_s16d_to_f32(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
const int16_t **s = (const int16_t **) src;
float *d = dst[0];
uint32_t i, j;
for (j = 0; j < n_samples; j++) {
for (i = 0; i < n_channels; i++)
*d++ = S16_TO_F32(s[i][j]);
}
}
static void
conv_s32d_to_f32d(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
uint32_t i, j;
for (i = 0; i < n_channels; i++) {
const int32_t *s = src[i];
float *d = dst[i];
for (j = 0; j < n_samples; j++)
d[j] = S32_TO_F32(s[j]);
}
}
static void
conv_s32_to_f32(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
conv_s32d_to_f32d(data, dst, src, 1, n_samples * n_channels);
}
static void
conv_s32_to_f32d(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
const int32_t *s = src[0];
float **d = (float **) dst;
uint32_t i, j;
for (j = 0; j < n_samples; j++) {
for (i = 0; i < n_channels; i++)
d[i][j] = S32_TO_F32(*s++);
}
}
static void
conv_s32d_to_f32(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
const int32_t **s = (const int32_t **) src;
float *d = dst[0];
uint32_t i, j;
for (j = 0; j < n_samples; j++) {
for (i = 0; i < n_channels; i++)
*d++ = S32_TO_F32(s[i][j]);
}
}
static void
conv_s24d_to_f32d(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
uint32_t i, j;
for (i = 0; i < n_channels; i++) {
const int8_t *s = src[i];
float *d = dst[i];
for (j = 0; j < n_samples; j++) {
d[j] = S24_TO_F32(read_s24(s));
s += 3;
}
}
}
static void
conv_s24_to_f32(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
conv_s24d_to_f32d(data, dst, src, 1, n_samples * n_channels);
}
static void
conv_s24_to_f32d(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
const uint8_t *s = src[0];
float **d = (float **) dst;
uint32_t i, j;
for (j = 0; j < n_samples; j++) {
for (i = 0; i < n_channels; i++) {
d[i][j] = S24_TO_F32(read_s24(s));
s += 3;
}
}
}
static void
conv_s24d_to_f32(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
const uint8_t **s = (const uint8_t **) src;
float *d = dst[0];
uint32_t i, j;
for (j = 0; j < n_samples; j++) {
for (i = 0; i < n_channels; i++) {
*d++ = S24_TO_F32(read_s24(&s[i][j*3]));
}
}
}
static void
conv_s24_32d_to_f32d(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
uint32_t i, j;
for (i = 0; i < n_channels; i++) {
const int32_t *s = src[i];
float *d = dst[i];
for (j = 0; j < n_samples; j++)
d[j] = S24_TO_F32(s[j]);
}
}
static void
conv_s24_32_to_f32(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
conv_s24_32d_to_f32d(data, dst, src, 1, n_samples * n_channels);
}
static void
conv_s24_32_to_f32d(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
const int32_t *s = src[0];
float **d = (float **) dst;
uint32_t i, j;
for (j = 0; j < n_samples; j++) {
for (i = 0; i < n_channels; i++)
d[i][j] = S24_TO_F32(*s++);
}
}
static void
conv_s24_32d_to_f32(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
const int32_t **s = (const int32_t **) src;
float *d = dst[0];
uint32_t i, j;
for (j = 0; j < n_samples; j++) {
for (i = 0; i < n_channels; i++)
*d++ = S24_TO_F32(s[i][j]);
}
}
static void
conv_f32d_to_u8d(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
uint32_t i, j;
for (i = 0; i < n_channels; i++) {
const float *s = src[i];
uint8_t *d = dst[i];
for (j = 0; j < n_samples; j++)
d[j] = F32_TO_U8(s[j]);
}
}
static void
conv_f32_to_u8(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
conv_f32d_to_u8d(data, dst, src, 1, n_samples * n_channels);
}
static void
conv_f32_to_u8d(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
const float *s = src[0];
uint8_t **d = (uint8_t **) dst;
uint32_t i, j;
for (j = 0; j < n_samples; j++) {
for (i = 0; i < n_channels; i++)
d[i][j] = F32_TO_U8(*s++);
}
}
static void
conv_f32d_to_u8(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
const float **s = (const float **) src;
uint8_t *d = dst[0];
uint32_t i, j;
for (j = 0; j < n_samples; j++) {
for (i = 0; i < n_channels; i++)
*d++ = F32_TO_U8(s[i][j]);
}
}
static void
conv_f32d_to_s16d(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
uint32_t i, j;
for (i = 0; i < n_channels; i++) {
const float *s = src[i];
int16_t *d = dst[i];
for (j = 0; j < n_samples; j++)
d[j] = F32_TO_S16(s[j]);
}
}
static void
conv_f32_to_s16(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
conv_f32d_to_s16d(data, dst, src, 1, n_samples * n_channels);
}
static void
conv_f32_to_s16d(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
const float *s = src[0];
int16_t **d = (int16_t **) dst;
uint32_t i, j;
for (j = 0; j < n_samples; j++) {
for (i = 0; i < n_channels; i++)
d[i][j] = F32_TO_S16(*s++);
}
}
static void
conv_f32d_to_s16(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
const float **s = (const float **) src;
int16_t *d = dst[0];
uint32_t i, j;
for (j = 0; j < n_samples; j++) {
for (i = 0; i < n_channels; i++)
*d++ = F32_TO_S16(s[i][j]);
}
}
static void
conv_f32d_to_s32d(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
uint32_t i, j;
for (i = 0; i < n_channels; i++) {
const float *s = src[i];
int32_t *d = dst[i];
for (j = 0; j < n_samples; j++)
d[j] = F32_TO_S32(s[j]);
}
}
static void
conv_f32_to_s32(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
conv_f32d_to_s32d(data, dst, src, 1, n_samples * n_channels);
}
static void
conv_f32_to_s32d(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
const float *s = src[0];
int32_t **d = (int32_t **) dst;
uint32_t i, j;
for (j = 0; j < n_samples; j++) {
for (i = 0; i < n_channels; i++)
d[i][j] = F32_TO_S32(*s++);
}
}
static void
conv_f32d_to_s32(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
const float **s = (const float **) src;
int32_t *d = dst[0];
uint32_t i, j;
for (j = 0; j < n_samples; j++) {
for (i = 0; i < n_channels; i++)
*d++ = F32_TO_S32(s[i][j]);
}
}
static void
conv_f32d_to_s24d(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
uint32_t i, j;
for (i = 0; i < n_channels; i++) {
const float *s = src[i];
uint8_t *d = dst[i];
for (j = 0; j < n_samples; j++) {
write_s24(d, F32_TO_S24(s[j]));
d += 3;
}
}
}
static void
conv_f32_to_s24(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
conv_f32d_to_s24d(data, dst, src, 1, n_samples * n_channels);
}
static void
conv_f32_to_s24d(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
const float *s = src[0];
uint8_t **d = (uint8_t **) dst;
uint32_t i, j;
for (j = 0; j < n_samples; j++) {
for (i = 0; i < n_channels; i++) {
write_s24(&d[i][j*3], F32_TO_S24(*s++));
}
}
}
static void
conv_f32d_to_s24(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
const float **s = (const float **) src;
uint8_t *d = dst[0];
uint32_t i, j;
for (j = 0; j < n_samples; j++) {
for (i = 0; i < n_channels; i++) {
write_s24(d, F32_TO_S24(s[i][j]));
d += 3;
}
}
}
static void
conv_f32d_to_s24_32d(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
uint32_t i, j;
for (i = 0; i < n_channels; i++) {
const float *s = src[i];
int32_t *d = dst[i];
for (j = 0; j < n_samples; j++)
d[j] = F32_TO_S24(s[j]);
}
}
static void
conv_f32_to_s24_32(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
conv_f32d_to_s24_32d(data, dst, src, 1, n_samples * n_channels);
}
static void
conv_f32_to_s24_32d(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
const float *s = src[0];
int32_t **d = (int32_t **) dst;
uint32_t i, j;
for (j = 0; j < n_samples; j++) {
for (i = 0; i < n_channels; i++)
d[i][j] = F32_TO_S24(*s++);
}
}
static void
conv_f32d_to_s24_32(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
const float **s = (const float **) src;
int32_t *d = dst[0];
uint32_t i, j;
for (j = 0; j < n_samples; j++) {
for (i = 0; i < n_channels; i++)
*d++ = F32_TO_S24(s[i][j]);
}
}
static void
deinterleave_8(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
const uint8_t *s = src[0];
uint8_t **d = (uint8_t **) dst;
uint32_t i, j;
for (j = 0; j < n_samples; j++) {
for (i = 0; i < n_channels; i++)
d[i][j] = *s++;
}
}
static void
deinterleave_16(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
const uint16_t *s = src[0];
uint16_t **d = (uint16_t **) dst;
uint32_t i, j;
for (j = 0; j < n_samples; j++) {
for (i = 0; i < n_channels; i++)
d[i][j] = *s++;
}
}
static void
deinterleave_24(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
const uint8_t *s = src[0];
uint8_t **d = (uint8_t **) dst;
uint32_t i, j;
for (j = 0; j < n_samples; j++) {
for (i = 0; i < n_channels; i++) {
write_s24(&d[i][j*3], read_s24(s));
s += 3;
}
}
}
static void
deinterleave_32(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
const uint32_t *s = src[0];
uint32_t **d = (uint32_t **) dst;
uint32_t i, j;
for (j = 0; j < n_samples; j++) {
for (i = 0; i < n_channels; i++)
d[i][j] = *s++;
}
}
static void
interleave_8(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
const int8_t **s = (const int8_t **) src;
uint8_t *d = dst[0];
uint32_t i, j;
for (j = 0; j < n_samples; j++) {
for (i = 0; i < n_channels; i++)
*d++ = s[i][j];
}
}
static void
interleave_16(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
const int16_t **s = (const int16_t **) src;
uint16_t *d = dst[0];
uint32_t i, j;
for (j = 0; j < n_samples; j++) {
for (i = 0; i < n_channels; i++)
*d++ = s[i][j];
}
}
static void
interleave_24(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
const int8_t **s = (const int8_t **) src;
uint8_t *d = dst[0];
uint32_t i, j;
for (j = 0; j < n_samples; j++) {
for (i = 0; i < n_channels; i++) {
write_s24(d, read_s24(&s[i][j*3]));
d += 3;
}
}
}
static void
interleave_32(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], uint32_t n_channels, uint32_t n_samples)
{
const int32_t **s = (const int32_t **) src;
uint32_t *d = dst[0];
uint32_t i, j;
for (j = 0; j < n_samples; j++) {
for (i = 0; i < n_channels; i++)
*d++ = s[i][j];
}
}
struct conv_info {
uint32_t src_fmt;
uint32_t dst_fmt;
@ -683,32 +46,32 @@ struct conv_info {
static struct conv_info conv_table[] =
{
/* to f32 */
{ SPA_AUDIO_FORMAT_U8, SPA_AUDIO_FORMAT_F32, 0, conv_u8_to_f32 },
{ SPA_AUDIO_FORMAT_U8P, SPA_AUDIO_FORMAT_F32P, 0, conv_u8d_to_f32d },
{ SPA_AUDIO_FORMAT_U8, SPA_AUDIO_FORMAT_F32P, 0, conv_u8_to_f32d },
{ SPA_AUDIO_FORMAT_U8P, SPA_AUDIO_FORMAT_F32, 0, conv_u8d_to_f32 },
{ SPA_AUDIO_FORMAT_U8, SPA_AUDIO_FORMAT_F32, 0, conv_u8_to_f32_c },
{ SPA_AUDIO_FORMAT_U8P, SPA_AUDIO_FORMAT_F32P, 0, conv_u8d_to_f32d_c },
{ SPA_AUDIO_FORMAT_U8, SPA_AUDIO_FORMAT_F32P, 0, conv_u8_to_f32d_c },
{ SPA_AUDIO_FORMAT_U8P, SPA_AUDIO_FORMAT_F32, 0, conv_u8d_to_f32_c },
{ SPA_AUDIO_FORMAT_S16, SPA_AUDIO_FORMAT_F32, 0, conv_s16_to_f32 },
{ SPA_AUDIO_FORMAT_S16P, SPA_AUDIO_FORMAT_F32P, 0, conv_s16d_to_f32d },
{ SPA_AUDIO_FORMAT_S16, SPA_AUDIO_FORMAT_F32, 0, conv_s16_to_f32_c },
{ SPA_AUDIO_FORMAT_S16P, SPA_AUDIO_FORMAT_F32P, 0, conv_s16d_to_f32d_c },
#if defined (HAVE_SSE2)
{ SPA_AUDIO_FORMAT_S16, SPA_AUDIO_FORMAT_F32P, FEATURE_SSE2, conv_s16_to_f32d_sse2 },
#endif
{ SPA_AUDIO_FORMAT_S16, SPA_AUDIO_FORMAT_F32P, 0, conv_s16_to_f32d },
{ SPA_AUDIO_FORMAT_S16P, SPA_AUDIO_FORMAT_F32, 0, conv_s16d_to_f32 },
{ SPA_AUDIO_FORMAT_S16, SPA_AUDIO_FORMAT_F32P, 0, conv_s16_to_f32d_c },
{ SPA_AUDIO_FORMAT_S16P, SPA_AUDIO_FORMAT_F32, 0, conv_s16d_to_f32_c },
{ SPA_AUDIO_FORMAT_F32, SPA_AUDIO_FORMAT_F32, 0, conv_copy32 },
{ SPA_AUDIO_FORMAT_F32P, SPA_AUDIO_FORMAT_F32P, 0, conv_copy32d },
{ SPA_AUDIO_FORMAT_F32, SPA_AUDIO_FORMAT_F32P, 0, deinterleave_32 },
{ SPA_AUDIO_FORMAT_F32P, SPA_AUDIO_FORMAT_F32, 0, interleave_32 },
{ SPA_AUDIO_FORMAT_F32, SPA_AUDIO_FORMAT_F32, 0, conv_copy32_c },
{ SPA_AUDIO_FORMAT_F32P, SPA_AUDIO_FORMAT_F32P, 0, conv_copy32d_c },
{ SPA_AUDIO_FORMAT_F32, SPA_AUDIO_FORMAT_F32P, 0, conv_deinterleave_32_c },
{ SPA_AUDIO_FORMAT_F32P, SPA_AUDIO_FORMAT_F32, 0, conv_interleave_32_c },
{ SPA_AUDIO_FORMAT_S32, SPA_AUDIO_FORMAT_F32, 0, conv_s32_to_f32 },
{ SPA_AUDIO_FORMAT_S32P, SPA_AUDIO_FORMAT_F32P, 0, conv_s32d_to_f32d },
{ SPA_AUDIO_FORMAT_S32, SPA_AUDIO_FORMAT_F32P, 0, conv_s32_to_f32d },
{ SPA_AUDIO_FORMAT_S32P, SPA_AUDIO_FORMAT_F32, 0, conv_s32d_to_f32 },
{ SPA_AUDIO_FORMAT_S32, SPA_AUDIO_FORMAT_F32, 0, conv_s32_to_f32_c },
{ SPA_AUDIO_FORMAT_S32P, SPA_AUDIO_FORMAT_F32P, 0, conv_s32d_to_f32d_c },
{ SPA_AUDIO_FORMAT_S32, SPA_AUDIO_FORMAT_F32P, 0, conv_s32_to_f32d_c },
{ SPA_AUDIO_FORMAT_S32P, SPA_AUDIO_FORMAT_F32, 0, conv_s32d_to_f32_c },
{ SPA_AUDIO_FORMAT_S24, SPA_AUDIO_FORMAT_F32, 0, conv_s24_to_f32 },
{ SPA_AUDIO_FORMAT_S24P, SPA_AUDIO_FORMAT_F32P, 0, conv_s24d_to_f32d },
{ SPA_AUDIO_FORMAT_S24, SPA_AUDIO_FORMAT_F32, 0, conv_s24_to_f32_c },
{ SPA_AUDIO_FORMAT_S24P, SPA_AUDIO_FORMAT_F32P, 0, conv_s24d_to_f32d_c },
#if defined (HAVE_SSSE3)
// { SPA_AUDIO_FORMAT_S24, SPA_AUDIO_FORMAT_F32P, FEATURE_SSSE3, conv_s24_to_f32d_ssse3 },
#endif
@ -718,75 +81,75 @@ static struct conv_info conv_table[] =
#if defined (HAVE_SSE2)
{ SPA_AUDIO_FORMAT_S24, SPA_AUDIO_FORMAT_F32P, FEATURE_SSE2, conv_s24_to_f32d_sse2 },
#endif
{ SPA_AUDIO_FORMAT_S24, SPA_AUDIO_FORMAT_F32P, 0, conv_s24_to_f32d },
{ SPA_AUDIO_FORMAT_S24P, SPA_AUDIO_FORMAT_F32, 0, conv_s24d_to_f32 },
{ SPA_AUDIO_FORMAT_S24, SPA_AUDIO_FORMAT_F32P, 0, conv_s24_to_f32d_c },
{ SPA_AUDIO_FORMAT_S24P, SPA_AUDIO_FORMAT_F32, 0, conv_s24d_to_f32_c },
{ SPA_AUDIO_FORMAT_S24_32, SPA_AUDIO_FORMAT_F32, 0, conv_s24_32_to_f32 },
{ SPA_AUDIO_FORMAT_S24_32P, SPA_AUDIO_FORMAT_F32P, 0, conv_s24_32d_to_f32d },
{ SPA_AUDIO_FORMAT_S24_32, SPA_AUDIO_FORMAT_F32P, 0, conv_s24_32_to_f32d },
{ SPA_AUDIO_FORMAT_S24_32P, SPA_AUDIO_FORMAT_F32, 0, conv_s24_32d_to_f32 },
{ SPA_AUDIO_FORMAT_S24_32, SPA_AUDIO_FORMAT_F32, 0, conv_s24_32_to_f32_c },
{ SPA_AUDIO_FORMAT_S24_32P, SPA_AUDIO_FORMAT_F32P, 0, conv_s24_32d_to_f32d_c },
{ SPA_AUDIO_FORMAT_S24_32, SPA_AUDIO_FORMAT_F32P, 0, conv_s24_32_to_f32d_c },
{ SPA_AUDIO_FORMAT_S24_32P, SPA_AUDIO_FORMAT_F32, 0, conv_s24_32d_to_f32_c },
/* from f32 */
{ SPA_AUDIO_FORMAT_F32, SPA_AUDIO_FORMAT_U8, 0, conv_f32_to_u8 },
{ SPA_AUDIO_FORMAT_F32P, SPA_AUDIO_FORMAT_U8P, 0, conv_f32d_to_u8d },
{ SPA_AUDIO_FORMAT_F32, SPA_AUDIO_FORMAT_U8P, 0, conv_f32_to_u8d },
{ SPA_AUDIO_FORMAT_F32P, SPA_AUDIO_FORMAT_U8, 0, conv_f32d_to_u8 },
{ SPA_AUDIO_FORMAT_F32, SPA_AUDIO_FORMAT_U8, 0, conv_f32_to_u8_c },
{ SPA_AUDIO_FORMAT_F32P, SPA_AUDIO_FORMAT_U8P, 0, conv_f32d_to_u8d_c },
{ SPA_AUDIO_FORMAT_F32, SPA_AUDIO_FORMAT_U8P, 0, conv_f32_to_u8d_c },
{ SPA_AUDIO_FORMAT_F32P, SPA_AUDIO_FORMAT_U8, 0, conv_f32d_to_u8_c },
{ SPA_AUDIO_FORMAT_F32, SPA_AUDIO_FORMAT_S16, 0, conv_f32_to_s16 },
{ SPA_AUDIO_FORMAT_F32P, SPA_AUDIO_FORMAT_S16P, 0, conv_f32d_to_s16d },
{ SPA_AUDIO_FORMAT_F32, SPA_AUDIO_FORMAT_S16P, 0, conv_f32_to_s16d },
{ SPA_AUDIO_FORMAT_F32, SPA_AUDIO_FORMAT_S16, 0, conv_f32_to_s16_c },
{ SPA_AUDIO_FORMAT_F32P, SPA_AUDIO_FORMAT_S16P, 0, conv_f32d_to_s16d_c },
{ SPA_AUDIO_FORMAT_F32, SPA_AUDIO_FORMAT_S16P, 0, conv_f32_to_s16d_c },
#if defined (HAVE_SSE2)
{ SPA_AUDIO_FORMAT_F32P, SPA_AUDIO_FORMAT_S16, FEATURE_SSE2, conv_f32d_to_s16_sse2 },
#endif
{ SPA_AUDIO_FORMAT_F32P, SPA_AUDIO_FORMAT_S16, 0, conv_f32d_to_s16 },
{ SPA_AUDIO_FORMAT_F32P, SPA_AUDIO_FORMAT_S16, 0, conv_f32d_to_s16_c },
{ SPA_AUDIO_FORMAT_F32, SPA_AUDIO_FORMAT_S32, 0, conv_f32_to_s32 },
{ SPA_AUDIO_FORMAT_F32P, SPA_AUDIO_FORMAT_S32P, 0, conv_f32d_to_s32d },
{ SPA_AUDIO_FORMAT_F32, SPA_AUDIO_FORMAT_S32P, 0, conv_f32_to_s32d },
{ SPA_AUDIO_FORMAT_F32, SPA_AUDIO_FORMAT_S32, 0, conv_f32_to_s32_c },
{ SPA_AUDIO_FORMAT_F32P, SPA_AUDIO_FORMAT_S32P, 0, conv_f32d_to_s32d_c },
{ SPA_AUDIO_FORMAT_F32, SPA_AUDIO_FORMAT_S32P, 0, conv_f32_to_s32d_c },
#if defined (HAVE_SSE2)
{ SPA_AUDIO_FORMAT_F32P, SPA_AUDIO_FORMAT_S32, FEATURE_SSE2, conv_f32d_to_s32_sse2 },
#endif
{ SPA_AUDIO_FORMAT_F32P, SPA_AUDIO_FORMAT_S32, 0, conv_f32d_to_s32 },
{ SPA_AUDIO_FORMAT_F32P, SPA_AUDIO_FORMAT_S32, 0, conv_f32d_to_s32_c },
{ SPA_AUDIO_FORMAT_F32, SPA_AUDIO_FORMAT_S24, 0, conv_f32_to_s24 },
{ SPA_AUDIO_FORMAT_F32P, SPA_AUDIO_FORMAT_S24P, 0, conv_f32d_to_s24d },
{ SPA_AUDIO_FORMAT_F32, SPA_AUDIO_FORMAT_S24P, 0, conv_f32_to_s24d },
{ SPA_AUDIO_FORMAT_F32P, SPA_AUDIO_FORMAT_S24, 0, conv_f32d_to_s24 },
{ SPA_AUDIO_FORMAT_F32, SPA_AUDIO_FORMAT_S24, 0, conv_f32_to_s24_c },
{ SPA_AUDIO_FORMAT_F32P, SPA_AUDIO_FORMAT_S24P, 0, conv_f32d_to_s24d_c },
{ SPA_AUDIO_FORMAT_F32, SPA_AUDIO_FORMAT_S24P, 0, conv_f32_to_s24d_c },
{ SPA_AUDIO_FORMAT_F32P, SPA_AUDIO_FORMAT_S24, 0, conv_f32d_to_s24_c },
{ SPA_AUDIO_FORMAT_F32, SPA_AUDIO_FORMAT_S24_32, 0, conv_f32_to_s24_32 },
{ SPA_AUDIO_FORMAT_F32P, SPA_AUDIO_FORMAT_S24_32P, 0, conv_f32d_to_s24_32d },
{ SPA_AUDIO_FORMAT_F32, SPA_AUDIO_FORMAT_S24_32P, 0, conv_f32_to_s24_32d },
{ SPA_AUDIO_FORMAT_F32P, SPA_AUDIO_FORMAT_S24_32, 0, conv_f32d_to_s24_32 },
{ SPA_AUDIO_FORMAT_F32, SPA_AUDIO_FORMAT_S24_32, 0, conv_f32_to_s24_32_c },
{ SPA_AUDIO_FORMAT_F32P, SPA_AUDIO_FORMAT_S24_32P, 0, conv_f32d_to_s24_32d_c },
{ SPA_AUDIO_FORMAT_F32, SPA_AUDIO_FORMAT_S24_32P, 0, conv_f32_to_s24_32d_c },
{ SPA_AUDIO_FORMAT_F32P, SPA_AUDIO_FORMAT_S24_32, 0, conv_f32d_to_s24_32_c },
/* u8 */
{ SPA_AUDIO_FORMAT_U8, SPA_AUDIO_FORMAT_U8, 0, conv_copy8 },
{ SPA_AUDIO_FORMAT_U8P, SPA_AUDIO_FORMAT_U8P, 0, conv_copy8d },
{ SPA_AUDIO_FORMAT_U8, SPA_AUDIO_FORMAT_U8P, 0, deinterleave_8 },
{ SPA_AUDIO_FORMAT_U8P, SPA_AUDIO_FORMAT_U8, 0, interleave_8 },
{ SPA_AUDIO_FORMAT_U8, SPA_AUDIO_FORMAT_U8, 0, conv_copy8_c },
{ SPA_AUDIO_FORMAT_U8P, SPA_AUDIO_FORMAT_U8P, 0, conv_copy8d_c },
{ SPA_AUDIO_FORMAT_U8, SPA_AUDIO_FORMAT_U8P, 0, conv_deinterleave_8_c },
{ SPA_AUDIO_FORMAT_U8P, SPA_AUDIO_FORMAT_U8, 0, conv_interleave_8_c },
/* s16 */
{ SPA_AUDIO_FORMAT_S16, SPA_AUDIO_FORMAT_S16, 0, conv_copy16 },
{ SPA_AUDIO_FORMAT_S16P, SPA_AUDIO_FORMAT_S16P, 0, conv_copy16d },
{ SPA_AUDIO_FORMAT_S16, SPA_AUDIO_FORMAT_S16P, 0, deinterleave_16 },
{ SPA_AUDIO_FORMAT_S16P, SPA_AUDIO_FORMAT_S16, 0, interleave_16 },
{ SPA_AUDIO_FORMAT_S16, SPA_AUDIO_FORMAT_S16, 0, conv_copy16_c },
{ SPA_AUDIO_FORMAT_S16P, SPA_AUDIO_FORMAT_S16P, 0, conv_copy16d_c },
{ SPA_AUDIO_FORMAT_S16, SPA_AUDIO_FORMAT_S16P, 0, conv_deinterleave_16_c },
{ SPA_AUDIO_FORMAT_S16P, SPA_AUDIO_FORMAT_S16, 0, conv_interleave_16_c },
/* s32 */
{ SPA_AUDIO_FORMAT_S32, SPA_AUDIO_FORMAT_S32, 0, conv_copy32 },
{ SPA_AUDIO_FORMAT_S32P, SPA_AUDIO_FORMAT_S32P, 0, conv_copy32d },
{ SPA_AUDIO_FORMAT_S32, SPA_AUDIO_FORMAT_S32P, 0, deinterleave_32 },
{ SPA_AUDIO_FORMAT_S32P, SPA_AUDIO_FORMAT_S32, 0, interleave_32 },
{ SPA_AUDIO_FORMAT_S32, SPA_AUDIO_FORMAT_S32, 0, conv_copy32_c },
{ SPA_AUDIO_FORMAT_S32P, SPA_AUDIO_FORMAT_S32P, 0, conv_copy32d_c },
{ SPA_AUDIO_FORMAT_S32, SPA_AUDIO_FORMAT_S32P, 0, conv_deinterleave_32_c },
{ SPA_AUDIO_FORMAT_S32P, SPA_AUDIO_FORMAT_S32, 0, conv_interleave_32_c },
/* s24 */
{ SPA_AUDIO_FORMAT_S24, SPA_AUDIO_FORMAT_S24, 0, conv_copy24 },
{ SPA_AUDIO_FORMAT_S24P, SPA_AUDIO_FORMAT_S24P, 0, conv_copy24d },
{ SPA_AUDIO_FORMAT_S24, SPA_AUDIO_FORMAT_S24P, 0, deinterleave_24 },
{ SPA_AUDIO_FORMAT_S24P, SPA_AUDIO_FORMAT_S24, 0, interleave_24 },
{ SPA_AUDIO_FORMAT_S24, SPA_AUDIO_FORMAT_S24, 0, conv_copy24_c },
{ SPA_AUDIO_FORMAT_S24P, SPA_AUDIO_FORMAT_S24P, 0, conv_copy24d_c },
{ SPA_AUDIO_FORMAT_S24, SPA_AUDIO_FORMAT_S24P, 0, conv_deinterleave_24_c },
{ SPA_AUDIO_FORMAT_S24P, SPA_AUDIO_FORMAT_S24, 0, conv_interleave_24_c },
/* s24_32 */
{ SPA_AUDIO_FORMAT_S24_32, SPA_AUDIO_FORMAT_S24_32, 0, conv_copy32 },
{ SPA_AUDIO_FORMAT_S24_32P, SPA_AUDIO_FORMAT_S24_32P, 0, conv_copy32d },
{ SPA_AUDIO_FORMAT_S24_32, SPA_AUDIO_FORMAT_S24_32P, 0, deinterleave_32 },
{ SPA_AUDIO_FORMAT_S24_32P, SPA_AUDIO_FORMAT_S24_32, 0, interleave_32 },
{ SPA_AUDIO_FORMAT_S24_32, SPA_AUDIO_FORMAT_S24_32, 0, conv_copy32_c },
{ SPA_AUDIO_FORMAT_S24_32P, SPA_AUDIO_FORMAT_S24_32P, 0, conv_copy32d_c },
{ SPA_AUDIO_FORMAT_S24_32, SPA_AUDIO_FORMAT_S24_32P, 0, conv_deinterleave_32_c },
{ SPA_AUDIO_FORMAT_S24_32P, SPA_AUDIO_FORMAT_S24_32, 0, conv_interleave_32_c },
};
static const struct conv_info *find_conv_info(uint32_t src_fmt, uint32_t dst_fmt, uint32_t features)

80
spa/plugins/audioconvert/fmt-ops.h
View file

@ -80,22 +80,78 @@ static inline void write_s24(void *dst, int32_t val)
typedef void (*convert_func_t) (void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[],
uint32_t n_channels, uint32_t n_samples);
#define DEFINE_FUNCTION(name,arch) \
void conv_##name##_##arch(void *data, void * SPA_RESTRICT dst[], \
const void * SPA_RESTRICT src[], \
uint32_t n_channels, uint32_t n_samples)
DEFINE_FUNCTION(copy8d, c);
DEFINE_FUNCTION(copy8, c);
DEFINE_FUNCTION(copy16d, c);
DEFINE_FUNCTION(copy16, c);
DEFINE_FUNCTION(copy24d, c);
DEFINE_FUNCTION(copy24, c);
DEFINE_FUNCTION(copy32d, c);
DEFINE_FUNCTION(copy32, c);
DEFINE_FUNCTION(u8d_to_f32d, c);
DEFINE_FUNCTION(u8_to_f32, c);
DEFINE_FUNCTION(u8_to_f32d, c);
DEFINE_FUNCTION(u8d_to_f32, c);
DEFINE_FUNCTION(s16d_to_f32d, c);
DEFINE_FUNCTION(s16_to_f32, c);
DEFINE_FUNCTION(s16_to_f32d, c);
DEFINE_FUNCTION(s16d_to_f32, c);
DEFINE_FUNCTION(s32d_to_f32d, c);
DEFINE_FUNCTION(s32_to_f32, c);
DEFINE_FUNCTION(s32_to_f32d, c);
DEFINE_FUNCTION(s32d_to_f32, c);
DEFINE_FUNCTION(s24d_to_f32d, c);
DEFINE_FUNCTION(s24_to_f32, c);
DEFINE_FUNCTION(s24_to_f32d, c);
DEFINE_FUNCTION(s24d_to_f32, c);
DEFINE_FUNCTION(s24_32d_to_f32d, c);
DEFINE_FUNCTION(s24_32_to_f32, c);
DEFINE_FUNCTION(s24_32_to_f32d, c);
DEFINE_FUNCTION(s24_32d_to_f32, c);
DEFINE_FUNCTION(f32d_to_u8d, c);
DEFINE_FUNCTION(f32_to_u8, c);
DEFINE_FUNCTION(f32_to_u8d, c);
DEFINE_FUNCTION(f32d_to_u8, c);
DEFINE_FUNCTION(f32d_to_s16d, c);
DEFINE_FUNCTION(f32_to_s16, c);
DEFINE_FUNCTION(f32_to_s16d, c);
DEFINE_FUNCTION(f32d_to_s16, c);
DEFINE_FUNCTION(f32d_to_s32d, c);
DEFINE_FUNCTION(f32_to_s32, c);
DEFINE_FUNCTION(f32_to_s32d, c);
DEFINE_FUNCTION(f32d_to_s32, c);
DEFINE_FUNCTION(f32d_to_s24d, c);
DEFINE_FUNCTION(f32_to_s24, c);
DEFINE_FUNCTION(f32_to_s24d, c);
DEFINE_FUNCTION(f32d_to_s24, c);
DEFINE_FUNCTION(f32d_to_s24_32d, c);
DEFINE_FUNCTION(f32_to_s24_32, c);
DEFINE_FUNCTION(f32_to_s24_32d, c);
DEFINE_FUNCTION(f32d_to_s24_32, c);
DEFINE_FUNCTION(deinterleave_8, c);
DEFINE_FUNCTION(deinterleave_16, c);
DEFINE_FUNCTION(deinterleave_24, c);
DEFINE_FUNCTION(deinterleave_32, c);
DEFINE_FUNCTION(interleave_8, c);
DEFINE_FUNCTION(interleave_16, c);
DEFINE_FUNCTION(interleave_24, c);
DEFINE_FUNCTION(interleave_32, c);
#if defined(HAVE_SSE2)
void conv_s16_to_f32d_sse2(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[],
uint32_t n_channels, uint32_t n_samples);
void conv_s24_to_f32d_sse2(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[],
uint32_t n_channels, uint32_t n_samples);
void conv_f32d_to_s32_sse2(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[],
uint32_t n_channels, uint32_t n_samples);
void conv_f32d_to_s16_sse2(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[],
uint32_t n_channels, uint32_t n_samples);
DEFINE_FUNCTION(s16_to_f32d, sse2);
DEFINE_FUNCTION(s24_to_f32d, sse2);
DEFINE_FUNCTION(f32d_to_s32, sse2);
DEFINE_FUNCTION(f32d_to_s16, sse2);
#endif
#if defined(HAVE_SSSE3)
void conv_s24_to_f32d_ssse3(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[],
uint32_t n_channels, uint32_t n_samples);
DEFINE_FUNCTION(s24_to_f32d, ssse3);
#endif
#if defined(HAVE_SSE41)
void conv_s24_to_f32d_sse41(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[],
uint32_t n_channels, uint32_t n_samples);
DEFINE_FUNCTION(s24_to_f32d, sse41);
#endif

26
spa/plugins/audioconvert/meson.build
View file

@ -9,10 +9,21 @@ audioconvert_sources = ['fmtconvert.c',
simd_cargs = []
simd_dependencies = []
audioconvert_c = static_library('audioconvert_c',
['resample-native-c.c',
'channelmix-ops-c.c',
'fmt-ops-c.c' ],
c_args : ['-O3'],
include_directories : [spa_inc],
install : false
)
simd_dependencies += audioconvert_c
if have_sse
audioconvert_sse = static_library('audioconvert_sse',
['resample-native-sse.c'],
c_args : [sse_args],
['resample-native-sse.c',
'channelmix-ops-sse.c' ],
c_args : [sse_args, '-O3'],
include_directories : [spa_inc],
install : false
)
@ -21,8 +32,8 @@ if have_sse
endif
if have_sse2
audioconvert_sse2 = static_library('audioconvert_sse2',
['fmt-ops-sse2.c'],
c_args : [sse2_args],
['fmt-ops-sse2.c' ],
c_args : [sse2_args, '-O3'],
include_directories : [spa_inc],
install : false
)
@ -33,7 +44,7 @@ if have_ssse3
audioconvert_ssse3 = static_library('audioconvert_ssse3',
['fmt-ops-ssse3.c',
'resample-native-ssse3.c' ],
c_args : [ssse3_args],
c_args : [ssse3_args, '-O3'],
include_directories : [spa_inc],
install : false
)
@ -43,7 +54,7 @@ endif
if have_sse41
audioconvert_sse41 = static_library('audioconvert_sse41',
['fmt-ops-sse41.c'],
c_args : [sse41_args],
c_args : [sse41_args, '-O3'],
include_directories : [spa_inc],
install : false
)
@ -53,7 +64,7 @@ endif
if have_avx and have_fma
audioconvert_avx = static_library('audioconvert_avx',
['resample-native-avx.c'],
c_args : [avx2_args, fma_args],
c_args : [avx2_args, fma_args, '-O3'],
include_directories : [spa_inc],
install : false
)
@ -80,6 +91,7 @@ foreach a : test_apps
executable(a, a + '.c',
dependencies : [dl_lib, pthread_lib, mathlib ],
include_directories : [spa_inc ],
link_with : simd_dependencies,
c_args : [ '-D_GNU_SOURCE' ],
install : false),
env : [

7
spa/plugins/audioconvert/resample-native-avx.c
View file

@ -24,6 +24,7 @@
#include "resample-native-impl.h"
#include <assert.h>
#include <immintrin.h>
static void inner_product_avx(float *d, const float * SPA_RESTRICT s,
@ -31,13 +32,15 @@ static void inner_product_avx(float *d, const float * SPA_RESTRICT s,
{
__m256 sy[2] = { _mm256_setzero_ps(), _mm256_setzero_ps() };
__m128 sx[2];
uint32_t i, n_taps4 = n_taps & ~0xf;
uint32_t i = 0;
uint32_t n_taps4 = n_taps & ~0xf;
for (i = 0; i < n_taps4; i += 16) {
for (; i < n_taps4; i += 16) {
sy[0] = _mm256_fmadd_ps(_mm256_loadu_ps(s + i + 0), _mm256_load_ps(taps + i + 0), sy[0]);
sy[1] = _mm256_fmadd_ps(_mm256_loadu_ps(s + i + 8), _mm256_load_ps(taps + i + 8), sy[1]);
}
sy[0] = _mm256_add_ps(sy[0], sy[1]);
sx[0] = _mm256_extractf128_ps(sy[0], 0);
sx[1] = _mm256_extractf128_ps(sy[0], 1);
for (; i < n_taps; i += 8) {

2
spa/plugins/audioconvert/resample-native-c.h → spa/plugins/audioconvert/resample-native-c.c
View file

@ -22,6 +22,8 @@
* DEALINGS IN THE SOFTWARE.
*/
#include "resample-native-impl.h"
static void inner_product_c(float *d, const float * SPA_RESTRICT s,
const float * SPA_RESTRICT taps, uint32_t n_taps)
{

10
spa/plugins/audioconvert/resample-native-impl.h
View file

@ -51,6 +51,11 @@ struct native_data {
float *hist_mem;
};
#define DEFINE_RESAMPLER_COPY(arch) \
void do_resample_copy_##arch(struct resample *r, \
const void * SPA_RESTRICT src[], uint32_t *in_len, \
void * SPA_RESTRICT dst[], uint32_t offs, uint32_t *out_len)
#define DEFINE_RESAMPLER_FULL(arch) \
void do_resample_full_##arch(struct resample *r, \
const void * SPA_RESTRICT src[], uint32_t *in_len, \
@ -62,9 +67,7 @@ void do_resample_inter_##arch(struct resample *r, \
void * SPA_RESTRICT dst[], uint32_t offs, uint32_t *out_len)
#define MAKE_RESAMPLER_COPY(arch) \
static void do_resample_copy_##arch(struct resample *r, \
const void * SPA_RESTRICT src[], uint32_t *in_len, \
void * SPA_RESTRICT dst[], uint32_t offs, uint32_t *out_len) \
DEFINE_RESAMPLER_COPY(arch) \
{ \
struct native_data *data = r->data; \
uint32_t index, n_taps = data->n_taps; \
@ -177,6 +180,7 @@ DEFINE_RESAMPLER_INTER(arch) \
}
DEFINE_RESAMPLER_COPY(c);
DEFINE_RESAMPLER_FULL(c);
DEFINE_RESAMPLER_INTER(c);

1
spa/plugins/audioconvert/resample-native.h
View file

@ -23,7 +23,6 @@
*/
#include "resample-native-impl.h"
#include "resample-native-c.h"
struct quality {
uint32_t n_taps;

88
spa/plugins/audioconvert/test-fmt-ops.c
View file

@ -62,16 +62,16 @@ static void run_test(const char *name,
tp[0] = temp_in;
switch(in_size) {
case 1:
interleave_8(NULL, tp, ip, N_CHANNELS, N_SAMPLES);
conv_interleave_8_c(NULL, tp, ip, N_CHANNELS, N_SAMPLES);
break;
case 2:
interleave_16(NULL, tp, ip, N_CHANNELS, N_SAMPLES);
conv_interleave_16_c(NULL, tp, ip, N_CHANNELS, N_SAMPLES);
break;
case 3:
interleave_24(NULL, tp, ip, N_CHANNELS, N_SAMPLES);
conv_interleave_24_c(NULL, tp, ip, N_CHANNELS, N_SAMPLES);
break;
case 4:
interleave_32(NULL, tp, ip, N_CHANNELS, N_SAMPLES);
conv_interleave_32_c(NULL, tp, ip, N_CHANNELS, N_SAMPLES);
break;
default:
fprintf(stderr, "unknown size %zd\n", in_size);
@ -109,13 +109,13 @@ static void test_f32_u8(void)
uint8_t out[] = { 128, 255, 0, 191, 64, 255, 0, };
run_test("test_f32_u8", in, sizeof(in[0]), out, sizeof(out[0]), SPA_N_ELEMENTS(out),
true, true, conv_f32_to_u8);
true, true, conv_f32_to_u8_c);
run_test("test_f32d_u8", in, sizeof(in[0]), out, sizeof(out[0]), SPA_N_ELEMENTS(out),
false, true, conv_f32d_to_u8);
false, true, conv_f32d_to_u8_c);
run_test("test_f32_u8d", in, sizeof(in[0]), out, sizeof(out[0]), SPA_N_ELEMENTS(out),
true, false, conv_f32_to_u8d);
true, false, conv_f32_to_u8d_c);
run_test("test_f32d_u8d", in, sizeof(in[0]), out, sizeof(out[0]), SPA_N_ELEMENTS(out),
false, false, conv_f32d_to_u8d);
false, false, conv_f32d_to_u8d_c);
}
static void test_u8_f32(void)
@ -124,13 +124,13 @@ static void test_u8_f32(void)
const float out[] = { 0.0f, 0.9921875f, -1.0f, 0.5f, -0.5f, };
run_test("test_u8_f32", in, sizeof(in[0]), out, sizeof(out[0]), SPA_N_ELEMENTS(out),
true, true, conv_u8_to_f32);
true, true, conv_u8_to_f32_c);
run_test("test_u8d_f32", in, sizeof(in[0]), out, sizeof(out[0]), SPA_N_ELEMENTS(out),
false, true, conv_u8d_to_f32);
false, true, conv_u8d_to_f32_c);
run_test("test_u8_f32d", in, sizeof(in[0]), out, sizeof(out[0]), SPA_N_ELEMENTS(out),
true, false, conv_u8_to_f32d);
true, false, conv_u8_to_f32d_c);
run_test("test_u8d_f32d", in, sizeof(in[0]), out, sizeof(out[0]), SPA_N_ELEMENTS(out),
false, false, conv_u8d_to_f32d);
false, false, conv_u8d_to_f32d_c);
}
static void test_f32_s16(void)
@ -139,13 +139,13 @@ static void test_f32_s16(void)
const int16_t out[] = { 0, 32767, -32767, 16383, -16383, 32767, -32767 };
run_test("test_f32_s16", in, sizeof(in[0]), out, sizeof(out[0]), SPA_N_ELEMENTS(out),
true, true, conv_f32_to_s16);
true, true, conv_f32_to_s16_c);
run_test("test_f32d_s16", in, sizeof(in[0]), out, sizeof(out[0]), SPA_N_ELEMENTS(out),
false, true, conv_f32d_to_s16);
false, true, conv_f32d_to_s16_c);
run_test("test_f32_s16d", in, sizeof(in[0]), out, sizeof(out[0]), SPA_N_ELEMENTS(out),
true, false, conv_f32_to_s16d);
true, false, conv_f32_to_s16d_c);
run_test("test_f32d_s16d", in, sizeof(in[0]), out, sizeof(out[0]), SPA_N_ELEMENTS(out),
false, false, conv_f32d_to_s16d);
false, false, conv_f32d_to_s16d_c);
}
static void test_s16_f32(void)
@ -154,13 +154,13 @@ static void test_s16_f32(void)
const float out[] = { 0.0f, 1.0f, -1.0f, 0.4999847412f, -0.4999847412f };
run_test("test_s16_f32d", in, sizeof(in[0]), out, sizeof(out[0]), SPA_N_ELEMENTS(out),
true, false, conv_s16_to_f32d);
true, false, conv_s16_to_f32d_c);
run_test("test_s16d_f32", in, sizeof(in[0]), out, sizeof(out[0]), SPA_N_ELEMENTS(out),
false, true, conv_s16d_to_f32);
false, true, conv_s16d_to_f32_c);
run_test("test_s16_f32", in, sizeof(in[0]), out, sizeof(out[0]), SPA_N_ELEMENTS(out),
true, true, conv_s16_to_f32);
true, true, conv_s16_to_f32_c);
run_test("test_s16d_f32d", in, sizeof(in[0]), out, sizeof(out[0]), SPA_N_ELEMENTS(out),
false, false, conv_s16d_to_f32d);
false, false, conv_s16d_to_f32d_c);
}
static void test_f32_s32(void)
@ -170,13 +170,13 @@ static void test_f32_s32(void)
0x7fffff00, 0x80000100 };
run_test("test_f32_s32", in, sizeof(in[0]), out, sizeof(out[0]), SPA_N_ELEMENTS(out),
true, true, conv_f32_to_s32);
true, true, conv_f32_to_s32_c);
run_test("test_f32d_s32", in, sizeof(in[0]), out, sizeof(out[0]), SPA_N_ELEMENTS(out),
false, true, conv_f32d_to_s32);
false, true, conv_f32d_to_s32_c);
run_test("test_f32_s32d", in, sizeof(in[0]), out, sizeof(out[0]), SPA_N_ELEMENTS(out),
true, false, conv_f32_to_s32d);
true, false, conv_f32_to_s32d_c);
run_test("test_f32d_s32d", in, sizeof(in[0]), out, sizeof(out[0]), SPA_N_ELEMENTS(out),
false, false, conv_f32d_to_s32d);
false, false, conv_f32d_to_s32d_c);
}
static void test_s32_f32(void)
@ -185,13 +185,13 @@ static void test_s32_f32(void)
const float out[] = { 0.0f, 1.0f, -1.0f, 0.4999999404f, -0.4999999404f, };
run_test("test_s32_f32d", in, sizeof(in[0]), out, sizeof(out[0]), SPA_N_ELEMENTS(out),
true, false, conv_s32_to_f32d);
true, false, conv_s32_to_f32d_c);
run_test("test_s32d_f32", in, sizeof(in[0]), out, sizeof(out[0]), SPA_N_ELEMENTS(out),
false, true, conv_s32d_to_f32);
false, true, conv_s32d_to_f32_c);
run_test("test_s32_f32", in, sizeof(in[0]), out, sizeof(out[0]), SPA_N_ELEMENTS(out),
true, true, conv_s32_to_f32);
true, true, conv_s32_to_f32_c);
run_test("test_s32d_f32d", in, sizeof(in[0]), out, sizeof(out[0]), SPA_N_ELEMENTS(out),
false, false, conv_s32d_to_f32d);
false, false, conv_s32d_to_f32d_c);
}
static void test_f32_s24(void)
@ -201,13 +201,13 @@ static void test_f32_s24(void)
0xff, 0xff, 0x3f, 0x01, 0x00, 0xc0, 0xff, 0xff, 0x7f, 0x01, 0x00, 0x80 };
run_test("test_f32_s24", in, sizeof(in[0]), out, 3, SPA_N_ELEMENTS(in),
true, true, conv_f32_to_s24);
true, true, conv_f32_to_s24_c);
run_test("test_f32d_s24", in, sizeof(in[0]), out, 3, SPA_N_ELEMENTS(in),
false, true, conv_f32d_to_s24);
false, true, conv_f32d_to_s24_c);
run_test("test_f32_s24d", in, sizeof(in[0]), out, 3, SPA_N_ELEMENTS(in),
true, false, conv_f32_to_s24d);
true, false, conv_f32_to_s24d_c);
run_test("test_f32d_s24d", in, sizeof(in[0]), out, 3, SPA_N_ELEMENTS(in),
false, false, conv_f32d_to_s24d);
false, false, conv_f32d_to_s24d_c);
}
static void test_s24_f32(void)
@ -217,13 +217,13 @@ static void test_s24_f32(void)
const float out[] = { 0.0f, 1.0f, -1.0f, 0.4999999404f, -0.4999999404f, };
run_test("test_s24_f32d", in, 3, out, sizeof(out[0]), SPA_N_ELEMENTS(out),
true, false, conv_s24_to_f32d);
true, false, conv_s24_to_f32d_c);
run_test("test_s24d_f32", in, 3, out, sizeof(out[0]), SPA_N_ELEMENTS(out),
false, true, conv_s24d_to_f32);
false, true, conv_s24d_to_f32_c);
run_test("test_s24_f32", in, 3, out, sizeof(out[0]), SPA_N_ELEMENTS(out),
true, true, conv_s24_to_f32);
true, true, conv_s24_to_f32_c);
run_test("test_s24d_f32d", in, 3, out, sizeof(out[0]), SPA_N_ELEMENTS(out),
false, false, conv_s24d_to_f32d);
false, false, conv_s24d_to_f32d_c);
}
static void test_f32_s24_32(void)
@ -233,13 +233,13 @@ static void test_f32_s24_32(void)
0x7fffff, 0xff800001 };
run_test("test_f32_s24_32", in, sizeof(in[0]), out, sizeof(out[0]), SPA_N_ELEMENTS(out),
true, true, conv_f32_to_s24_32);
true, true, conv_f32_to_s24_32_c);
run_test("test_f32d_s24_32", in, sizeof(in[0]), out, sizeof(out[0]), SPA_N_ELEMENTS(out),
false, true, conv_f32d_to_s24_32);
false, true, conv_f32d_to_s24_32_c);
run_test("test_f32_s24_32d", in, sizeof(in[0]), out, sizeof(out[0]), SPA_N_ELEMENTS(out),
true, false, conv_f32_to_s24_32d);
true, false, conv_f32_to_s24_32d_c);
run_test("test_f32d_s24_32d", in, sizeof(in[0]), out, sizeof(out[0]), SPA_N_ELEMENTS(out),
false, false, conv_f32d_to_s24_32d);
false, false, conv_f32d_to_s24_32d_c);
}
static void test_s24_32_f32(void)
@ -248,13 +248,13 @@ static void test_s24_32_f32(void)
const float out[] = { 0.0f, 1.0f, -1.0f, 0.4999999404f, -0.4999999404f, };
run_test("test_s24_32_f32d", in, sizeof(in[0]), out, sizeof(out[0]), SPA_N_ELEMENTS(out),
true, false, conv_s24_32_to_f32d);
true, false, conv_s24_32_to_f32d_c);
run_test("test_s24_32d_f32", in, sizeof(in[0]), out, sizeof(out[0]), SPA_N_ELEMENTS(out),
false, true, conv_s24_32d_to_f32);
false, true, conv_s24_32d_to_f32_c);
run_test("test_s24_32_f32", in, sizeof(in[0]), out, sizeof(out[0]), SPA_N_ELEMENTS(out),
true, true, conv_s24_32_to_f32);
true, true, conv_s24_32_to_f32_c);
run_test("test_s24_32d_f32d", in, sizeof(in[0]), out, sizeof(out[0]), SPA_N_ELEMENTS(out),
false, false, conv_s24_32d_to_f32d);
false, false, conv_s24_32d_to_f32d_c);
}
int main(int argc, char *argv[])