path: root/cras/src/server/cras_mix_ops.c

/* Copyright (c) 2012 The Chromium OS Authors. All rights reserved.
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */

#include <stdint.h>

#include "cras_system_state.h"
#include "cras_mix_ops.h"

#define MAX_VOLUME_TO_SCALE 0.9999999
#define MIN_VOLUME_TO_SCALE 0.0000001

/* function suffixes for SIMD ops */
#ifdef OPS_SSE42
#define OPS(a) a##_sse42
#elif OPS_AVX
#define OPS(a) a##_avx
#elif OPS_AVX2
#define OPS(a) a##_avx2
#elif OPS_FMA
#define OPS(a) a##_fma
#else
#define OPS(a) a
#endif

/* Checks if the scaler needs a scaling operation.
 * We skip scaling for scaler too close to 1.0.
 * Note that this is not subjected to MAX_VOLUME_TO_SCALE
 * and MIN_VOLUME_TO_SCALE. */
static inline int need_to_scale(float scaler)
{
	return (scaler < 0.99 || scaler > 1.01);
}

/*
 * Signed 16 bit little endian functions.
 */

static void cras_mix_add_clip_s16_le(int16_t *dst, const int16_t *src,
				     size_t count)
{
	int32_t sum;
	size_t i;

	for (i = 0; i < count; i++) {
		sum = dst[i] + src[i];
		if (sum > INT16_MAX)
			sum = INT16_MAX;
		else if (sum < INT16_MIN)
			sum = INT16_MIN;
		dst[i] = sum;
	}
}

/* Adds src into dst, after scaling by vol.
 * Just hard limits to the min and max S16 value, can be improved later. */
static void scale_add_clip_s16_le(int16_t *dst, const int16_t *src,
				  size_t count, float vol)
{
	int32_t sum;
	size_t i;

	if (vol > MAX_VOLUME_TO_SCALE)
		return cras_mix_add_clip_s16_le(dst, src, count);

	for (i = 0; i < count; i++) {
		sum = dst[i] + (int16_t)(src[i] * vol);
		if (sum > INT16_MAX)
			sum = INT16_MAX;
		else if (sum < INT16_MIN)
			sum = INT16_MIN;
		dst[i] = sum;
	}
}

/* Adds the first stream to the mix.  Don't need to mix, just setup to the new
 * values. If volume is 1.0, just memcpy. */
static void copy_scaled_s16_le(int16_t *dst, const int16_t *src, size_t count,
			       float volume_scaler)
{
	int i;

	if (volume_scaler > MAX_VOLUME_TO_SCALE) {
		memcpy(dst, src, count * sizeof(*src));
		return;
	}

	for (i = 0; i < count; i++)
		dst[i] = src[i] * volume_scaler;
}

static void cras_scale_buffer_inc_s16_le(uint8_t *buffer, unsigned int count,
					 float scaler, float increment,
					 float target, int step)
{
	int i = 0, j;
	int16_t *out = (int16_t *)buffer;

	if (scaler < MIN_VOLUME_TO_SCALE && increment < 0) {
		memset(out, 0, count * sizeof(*out));
		return;
	}

	while (i + step <= count) {
		for (j = 0; j < step; j++) {
			float applied_scaler = scaler;

			if ((applied_scaler > target && increment > 0) ||
			    (applied_scaler < target && increment < 0))
				applied_scaler = target;

			if (applied_scaler > MAX_VOLUME_TO_SCALE) {
			} else if (applied_scaler < MIN_VOLUME_TO_SCALE) {
				out[i] = 0;
			} else {
				out[i] *= applied_scaler;
			}
			i++;
		}
		scaler += increment;
	}
}

static void cras_scale_buffer_s16_le(uint8_t *buffer, unsigned int count,
				     float scaler)
{
	int i;
	int16_t *out = (int16_t *)buffer;

	if (scaler > MAX_VOLUME_TO_SCALE)
		return;

	if (scaler < MIN_VOLUME_TO_SCALE) {
		memset(out, 0, count * sizeof(*out));
		return;
	}

	for (i = 0; i < count; i++)
		out[i] *= scaler;
}

static void cras_mix_add_s16_le(uint8_t *dst, uint8_t *src, unsigned int count,
				unsigned int index, int mute, float mix_vol)
{
	int16_t *out = (int16_t *)dst;
	int16_t *in = (int16_t *)src;

	if (mute || (mix_vol < MIN_VOLUME_TO_SCALE)) {
		if (index == 0)
			memset(out, 0, count * sizeof(*out));
		return;
	}

	if (index == 0)
		return copy_scaled_s16_le(out, in, count, mix_vol);

	scale_add_clip_s16_le(out, in, count, mix_vol);
}

static void cras_mix_add_scale_stride_s16_le(uint8_t *dst, uint8_t *src,
					     unsigned int dst_stride,
					     unsigned int src_stride,
					     unsigned int count, float scaler)
{
	unsigned int i;

	/* optimise the loops for vectorization */
	if (dst_stride == src_stride && dst_stride == 2) {
		for (i = 0; i < count; i++) {
			int32_t sum;
			if (need_to_scale(scaler))
				sum = *(int16_t *)dst +
				      *(int16_t *)src * scaler;
			else
				sum = *(int16_t *)dst + *(int16_t *)src;
			if (sum > INT16_MAX)
				sum = INT16_MAX;
			else if (sum < INT16_MIN)
				sum = INT16_MIN;
			*(int16_t *)dst = sum;
			dst += 2;
			src += 2;
		}
	} else if (dst_stride == src_stride && dst_stride == 4) {
		for (i = 0; i < count; i++) {
			int32_t sum;
			if (need_to_scale(scaler))
				sum = *(int16_t *)dst +
				      *(int16_t *)src * scaler;
			else
				sum = *(int16_t *)dst + *(int16_t *)src;
			if (sum > INT16_MAX)
				sum = INT16_MAX;
			else if (sum < INT16_MIN)
				sum = INT16_MIN;
			*(int16_t *)dst = sum;
			dst += 4;
			src += 4;
		}
	} else {
		for (i = 0; i < count; i++) {
			int32_t sum;
			if (need_to_scale(scaler))
				sum = *(int16_t *)dst +
				      *(int16_t *)src * scaler;
			else
				sum = *(int16_t *)dst + *(int16_t *)src;
			if (sum > INT16_MAX)
				sum = INT16_MAX;
			else if (sum < INT16_MIN)
				sum = INT16_MIN;
			*(int16_t *)dst = sum;
			dst += dst_stride;
			src += src_stride;
		}
	}
}

/*
 * Signed 24 bit little endian functions.
 */

static int32_t scale_s24_le(int32_t value, float scaler)
{
	value = ((uint32_t)(value & 0x00ffffff)) << 8;
	value *= scaler;
	return (value >> 8) & 0x00ffffff;
}

static void cras_mix_add_clip_s24_le(int32_t *dst, const int32_t *src,
				     size_t count)
{
	int32_t sum;
	size_t i;

	for (i = 0; i < count; i++) {
		sum = dst[i] + src[i];
		if (sum > 0x007fffff)
			sum = 0x007fffff;
		else if (sum < (int32_t)0xff800000)
			sum = (int32_t)0xff800000;
		dst[i] = sum;
	}
}

/* Adds src into dst, after scaling by vol.
 * Just hard limits to the min and max S24 value, can be improved later. */
static void scale_add_clip_s24_le(int32_t *dst, const int32_t *src,
				  size_t count, float vol)
{
	int32_t sum;
	size_t i;

	if (vol > MAX_VOLUME_TO_SCALE)
		return cras_mix_add_clip_s24_le(dst, src, count);

	for (i = 0; i < count; i++) {
		sum = dst[i] + (int32_t)(src[i] * vol);
		if (sum > 0x007fffff)
			sum = 0x007fffff;
		else if (sum < (int32_t)0xff800000)
			sum = (int32_t)0xff800000;
		dst[i] = sum;
	}
}

/* Adds the first stream to the mix.  Don't need to mix, just setup to the new
 * values. If volume is 1.0, just memcpy. */
static void copy_scaled_s24_le(int32_t *dst, const int32_t *src, size_t count,
			       float volume_scaler)
{
	int i;

	if (volume_scaler > MAX_VOLUME_TO_SCALE) {
		memcpy(dst, src, count * sizeof(*src));
		return;
	}

	for (i = 0; i < count; i++)
		dst[i] = scale_s24_le(src[i], volume_scaler);
}

static void cras_scale_buffer_inc_s24_le(uint8_t *buffer, unsigned int count,
					 float scaler, float increment,
					 float target, int step)
{
	int i = 0, j;
	int32_t *out = (int32_t *)buffer;

	if (scaler < MIN_VOLUME_TO_SCALE && increment < 0) {
		memset(out, 0, count * sizeof(*out));
		return;
	}

	while (i + step <= count) {
		for (j = 0; j < step; j++) {
			float applied_scaler = scaler;

			if ((applied_scaler > target && increment > 0) ||
			    (applied_scaler < target && increment < 0))
				applied_scaler = target;

			if (applied_scaler > MAX_VOLUME_TO_SCALE) {
			} else if (applied_scaler < MIN_VOLUME_TO_SCALE) {
				out[i] = 0;
			} else {
				out[i] = scale_s24_le(out[i], applied_scaler);
			}
			i++;
		}
		scaler += increment;
	}
}

static void cras_scale_buffer_s24_le(uint8_t *buffer, unsigned int count,
				     float scaler)
{
	int i;
	int32_t *out = (int32_t *)buffer;

	if (scaler > MAX_VOLUME_TO_SCALE)
		return;

	if (scaler < MIN_VOLUME_TO_SCALE) {
		memset(out, 0, count * sizeof(*out));
		return;
	}

	for (i = 0; i < count; i++)
		out[i] = scale_s24_le(out[i], scaler);
}

static void cras_mix_add_s24_le(uint8_t *dst, uint8_t *src, unsigned int count,
				unsigned int index, int mute, float mix_vol)
{
	int32_t *out = (int32_t *)dst;
	int32_t *in = (int32_t *)src;

	if (mute || (mix_vol < MIN_VOLUME_TO_SCALE)) {
		if (index == 0)
			memset(out, 0, count * sizeof(*out));
		return;
	}

	if (index == 0)
		return copy_scaled_s24_le(out, in, count, mix_vol);

	scale_add_clip_s24_le(out, in, count, mix_vol);
}

static void cras_mix_add_scale_stride_s24_le(uint8_t *dst, uint8_t *src,
					     unsigned int dst_stride,
					     unsigned int src_stride,
					     unsigned int count, float scaler)
{
	unsigned int i;

	/* optimise the loops for vectorization */
	if (dst_stride == src_stride && dst_stride == 4) {
		for (i = 0; i < count; i++) {
			int32_t sum;
			if (need_to_scale(scaler))
				sum = *(int32_t *)dst +
				      scale_s24_le(*(int32_t *)src, scaler);
			else
				sum = *(int32_t *)dst + *(int32_t *)src;
			if (sum > 0x007fffff)
				sum = 0x007fffff;
			else if (sum < (int32_t)0xff800000)
				sum = (int32_t)0xff800000;
			*(int32_t *)dst = sum;
			dst += 4;
			src += 4;
		}
	} else {
		for (i = 0; i < count; i++) {
			int32_t sum;
			if (need_to_scale(scaler))
				sum = *(int32_t *)dst +
				      scale_s24_le(*(int32_t *)src, scaler);
			else
				sum = *(int32_t *)dst + *(int32_t *)src;
			if (sum > 0x007fffff)
				sum = 0x007fffff;
			else if (sum < (int32_t)0xff800000)
				sum = (int32_t)0xff800000;
			*(int32_t *)dst = sum;
			dst += dst_stride;
			src += src_stride;
		}
	}
}

/*
 * Signed 32 bit little endian functions.
 */

static void cras_mix_add_clip_s32_le(int32_t *dst, const int32_t *src,
				     size_t count)
{
	int64_t sum;
	size_t i;

	for (i = 0; i < count; i++) {
		sum = (int64_t)dst[i] + (int64_t)src[i];
		if (sum > INT32_MAX)
			sum = INT32_MAX;
		else if (sum < INT32_MIN)
			sum = INT32_MIN;
		dst[i] = sum;
	}
}

/* Adds src into dst, after scaling by vol.
 * Just hard limits to the min and max S32 value, can be improved later. */
static void scale_add_clip_s32_le(int32_t *dst, const int32_t *src,
				  size_t count, float vol)
{
	int64_t sum;
	size_t i;

	if (vol > MAX_VOLUME_TO_SCALE)
		return cras_mix_add_clip_s32_le(dst, src, count);

	for (i = 0; i < count; i++) {
		sum = (int64_t)dst[i] + (int64_t)(src[i] * vol);
		if (sum > INT32_MAX)
			sum = INT32_MAX;
		else if (sum < INT32_MIN)
			sum = INT32_MIN;
		dst[i] = sum;
	}
}

/* Adds the first stream to the mix.  Don't need to mix, just setup to the new
 * values. If volume is 1.0, just memcpy. */
static void copy_scaled_s32_le(int32_t *dst, const int32_t *src, size_t count,
			       float volume_scaler)
{
	int i;

	if (volume_scaler > MAX_VOLUME_TO_SCALE) {
		memcpy(dst, src, count * sizeof(*src));
		return;
	}

	for (i = 0; i < count; i++)
		dst[i] = src[i] * volume_scaler;
}

static void cras_scale_buffer_inc_s32_le(uint8_t *buffer, unsigned int count,
					 float scaler, float increment,
					 float target, int step)
{
	int i = 0, j;
	int32_t *out = (int32_t *)buffer;

	if (scaler < MIN_VOLUME_TO_SCALE && increment < 0) {
		memset(out, 0, count * sizeof(*out));
		return;
	}

	while (i + step <= count) {
		for (j = 0; j < step; j++) {
			float applied_scaler = scaler;

			if ((applied_scaler > target && increment > 0) ||
			    (applied_scaler < target && increment < 0))
				applied_scaler = target;

			if (applied_scaler > MAX_VOLUME_TO_SCALE) {
			} else if (applied_scaler < MIN_VOLUME_TO_SCALE) {
				out[i] = 0;
			} else {
				out[i] *= applied_scaler;
			}
			i++;
		}
		scaler += increment;
	}
}

static void cras_scale_buffer_s32_le(uint8_t *buffer, unsigned int count,
				     float scaler)
{
	int i;
	int32_t *out = (int32_t *)buffer;

	if (scaler > MAX_VOLUME_TO_SCALE)
		return;

	if (scaler < MIN_VOLUME_TO_SCALE) {
		memset(out, 0, count * sizeof(*out));
		return;
	}

	for (i = 0; i < count; i++)
		out[i] *= scaler;
}

static void cras_mix_add_s32_le(uint8_t *dst, uint8_t *src, unsigned int count,
				unsigned int index, int mute, float mix_vol)
{
	int32_t *out = (int32_t *)dst;
	int32_t *in = (int32_t *)src;

	if (mute || (mix_vol < MIN_VOLUME_TO_SCALE)) {
		if (index == 0)
			memset(out, 0, count * sizeof(*out));
		return;
	}

	if (index == 0)
		return copy_scaled_s32_le(out, in, count, mix_vol);

	scale_add_clip_s32_le(out, in, count, mix_vol);
}

static void cras_mix_add_scale_stride_s32_le(uint8_t *dst, uint8_t *src,
					     unsigned int dst_stride,
					     unsigned int src_stride,
					     unsigned int count, float scaler)
{
	unsigned int i;

	/* optimise the loops for vectorization */
	if (dst_stride == src_stride && dst_stride == 4) {
		for (i = 0; i < count; i++) {
			int64_t sum;
			if (need_to_scale(scaler))
				sum = *(int32_t *)dst +
				      *(int32_t *)src * scaler;
			else
				sum = *(int32_t *)dst + *(int32_t *)src;
			if (sum > INT32_MAX)
				sum = INT32_MAX;
			else if (sum < INT32_MIN)
				sum = INT32_MIN;
			*(int32_t *)dst = sum;
			dst += 4;
			src += 4;
		}
	} else {
		for (i = 0; i < count; i++) {
			int64_t sum;
			if (need_to_scale(scaler))
				sum = *(int32_t *)dst +
				      *(int32_t *)src * scaler;
			else
				sum = *(int32_t *)dst + *(int32_t *)src;
			if (sum > INT32_MAX)
				sum = INT32_MAX;
			else if (sum < INT32_MIN)
				sum = INT32_MIN;
			*(int32_t *)dst = sum;
			dst += dst_stride;
			src += src_stride;
		}
	}
}

/*
 * Signed 24 bit little endian in three bytes functions.
 */

/* Convert 3bytes Signed 24bit integer to a Signed 32bit integer.
 * Just a helper function. */
static inline void convert_single_s243le_to_s32le(int32_t *dst,
						  const uint8_t *src)
{
	*dst = 0;
	memcpy((uint8_t *)dst + 1, src, 3);
}

static inline void convert_single_s32le_to_s243le(uint8_t *dst,
						  const int32_t *src)
{
	memcpy(dst, (uint8_t *)src + 1, 3);
}

static void cras_mix_add_clip_s24_3le(uint8_t *dst, const uint8_t *src,
				      size_t count)
{
	int64_t sum;
	int32_t dst_frame;
	int32_t src_frame;
	size_t i;

	for (i = 0; i < count; i++, dst += 3, src += 3) {
		convert_single_s243le_to_s32le(&dst_frame, dst);
		convert_single_s243le_to_s32le(&src_frame, src);
		sum = (int64_t)dst_frame + (int64_t)src_frame;
		if (sum > INT32_MAX)
			sum = INT32_MAX;
		else if (sum < INT32_MIN)
			sum = INT32_MIN;
		dst_frame = (int32_t)sum;
		convert_single_s32le_to_s243le(dst, &dst_frame);
	}
}

/* Adds src into dst, after scaling by vol.
 * Just hard limits to the min and max S24 value, can be improved later. */
static void scale_add_clip_s24_3le(uint8_t *dst, const uint8_t *src,
				   size_t count, float vol)
{
	int64_t sum;
	int32_t dst_frame;
	int32_t src_frame;
	size_t i;

	if (vol > MAX_VOLUME_TO_SCALE)
		return cras_mix_add_clip_s24_3le(dst, src, count);

	for (i = 0; i < count; i++, dst += 3, src += 3) {
		convert_single_s243le_to_s32le(&dst_frame, dst);
		convert_single_s243le_to_s32le(&src_frame, src);
		sum = (int64_t)dst_frame + (int64_t)(src_frame * vol);
		if (sum > INT32_MAX)
			sum = INT32_MAX;
		else if (sum < INT32_MIN)
			sum = INT32_MIN;
		dst_frame = (int32_t)sum;
		convert_single_s32le_to_s243le(dst, &dst_frame);
	}
}

/* Adds the first stream to the mix.  Don't need to mix, just setup to the new
 * values. If volume is 1.0, just memcpy. */
static void copy_scaled_s24_3le(uint8_t *dst, const uint8_t *src, size_t count,
				float volume_scaler)
{
	int32_t frame;
	size_t i;

	if (volume_scaler > MAX_VOLUME_TO_SCALE) {
		memcpy(dst, src, 3 * count * sizeof(*src));
		return;
	}

	for (i = 0; i < count; i++, dst += 3, src += 3) {
		convert_single_s243le_to_s32le(&frame, src);
		frame *= volume_scaler;
		convert_single_s32le_to_s243le(dst, &frame);
	}
}

static void cras_scale_buffer_inc_s24_3le(uint8_t *buffer, unsigned int count,
					  float scaler, float increment,
					  float target, int step)
{
	int32_t frame;
	int i = 0, j;

	if (scaler < MIN_VOLUME_TO_SCALE && increment < 0) {
		memset(buffer, 0, 3 * count * sizeof(*buffer));
		return;
	}

	while (i + step <= count) {
		for (j = 0; j < step; j++) {
			float applied_scaler = scaler;

			if ((applied_scaler > target && increment > 0) ||
			    (applied_scaler < target && increment < 0))
				applied_scaler = target;

			convert_single_s243le_to_s32le(&frame, buffer);

			if (applied_scaler > MAX_VOLUME_TO_SCALE) {
			} else if (applied_scaler < MIN_VOLUME_TO_SCALE) {
				frame = 0;
			} else {
				frame *= applied_scaler;
			}

			convert_single_s32le_to_s243le(buffer, &frame);

			i++;
			buffer += 3;
		}
		scaler += increment;
	}
}

static void cras_scale_buffer_s24_3le(uint8_t *buffer, unsigned int count,
				      float scaler)
{
	int32_t frame;
	int i;

	if (scaler > MAX_VOLUME_TO_SCALE)
		return;

	if (scaler < MIN_VOLUME_TO_SCALE) {
		memset(buffer, 0, 3 * count * sizeof(*buffer));
		return;
	}

	for (i = 0; i < count; i++, buffer += 3) {
		convert_single_s243le_to_s32le(&frame, buffer);
		frame *= scaler;
		convert_single_s32le_to_s243le(buffer, &frame);
	}
}

static void cras_mix_add_s24_3le(uint8_t *dst, uint8_t *src, unsigned int count,
				 unsigned int index, int mute, float mix_vol)
{
	uint8_t *out = dst;
	uint8_t *in = src;

	if (mute || (mix_vol < MIN_VOLUME_TO_SCALE)) {
		if (index == 0)
			memset(out, 0, 3 * count * sizeof(*out));
		return;
	}

	if (index == 0)
		return copy_scaled_s24_3le(out, in, count, mix_vol);

	scale_add_clip_s24_3le(out, in, count, mix_vol);
}

static void cras_mix_add_scale_stride_s24_3le(uint8_t *dst, uint8_t *src,
					      unsigned int dst_stride,
					      unsigned int src_stride,
					      unsigned int count, float scaler)
{
	unsigned int i;
	int64_t sum;
	int32_t dst_frame;
	int32_t src_frame;

	for (i = 0; i < count; i++) {
		convert_single_s243le_to_s32le(&dst_frame, dst);
		convert_single_s243le_to_s32le(&src_frame, src);
		if (need_to_scale(scaler))
			sum = (int64_t)dst_frame + (int64_t)src_frame * scaler;
		else
			sum = (int64_t)dst_frame + (int64_t)src_frame;
		if (sum > INT32_MAX)
			sum = INT32_MAX;
		else if (sum < INT32_MIN)
			sum = INT32_MIN;
		dst_frame = (int32_t)sum;
		convert_single_s32le_to_s243le(dst, &dst_frame);
		dst += dst_stride;
		src += src_stride;
	}
}

static void scale_buffer_increment(snd_pcm_format_t fmt, uint8_t *buff,
				   unsigned int count, float scaler,
				   float increment, float target, int step)
{
	switch (fmt) {
	case SND_PCM_FORMAT_S16_LE:
		return cras_scale_buffer_inc_s16_le(buff, count, scaler,
						    increment, target, step);
	case SND_PCM_FORMAT_S24_LE:
		return cras_scale_buffer_inc_s24_le(buff, count, scaler,
						    increment, target, step);
	case SND_PCM_FORMAT_S32_LE:
		return cras_scale_buffer_inc_s32_le(buff, count, scaler,
						    increment, target, step);
	case SND_PCM_FORMAT_S24_3LE:
		return cras_scale_buffer_inc_s24_3le(buff, count, scaler,
						     increment, target, step);
	default:
		break;
	}
}

static void scale_buffer(snd_pcm_format_t fmt, uint8_t *buff,
			 unsigned int count, float scaler)
{
	switch (fmt) {
	case SND_PCM_FORMAT_S16_LE:
		return cras_scale_buffer_s16_le(buff, count, scaler);
	case SND_PCM_FORMAT_S24_LE:
		return cras_scale_buffer_s24_le(buff, count, scaler);
	case SND_PCM_FORMAT_S32_LE:
		return cras_scale_buffer_s32_le(buff, count, scaler);
	case SND_PCM_FORMAT_S24_3LE:
		return cras_scale_buffer_s24_3le(buff, count, scaler);
	default:
		break;
	}
}

static void mix_add(snd_pcm_format_t fmt, uint8_t *dst, uint8_t *src,
		    unsigned int count, unsigned int index, int mute,
		    float mix_vol)
{
	switch (fmt) {
	case SND_PCM_FORMAT_S16_LE:
		return cras_mix_add_s16_le(dst, src, count, index, mute,
					   mix_vol);
	case SND_PCM_FORMAT_S24_LE:
		return cras_mix_add_s24_le(dst, src, count, index, mute,
					   mix_vol);
	case SND_PCM_FORMAT_S32_LE:
		return cras_mix_add_s32_le(dst, src, count, index, mute,
					   mix_vol);
	case SND_PCM_FORMAT_S24_3LE:
		return cras_mix_add_s24_3le(dst, src, count, index, mute,
					    mix_vol);
	default:
		break;
	}
}

static void mix_add_scale_stride(snd_pcm_format_t fmt, uint8_t *dst,
				 uint8_t *src, unsigned int count,
				 unsigned int dst_stride,
				 unsigned int src_stride, float scaler)
{
	switch (fmt) {
	case SND_PCM_FORMAT_S16_LE:
		return cras_mix_add_scale_stride_s16_le(
			dst, src, dst_stride, src_stride, count, scaler);
	case SND_PCM_FORMAT_S24_LE:
		return cras_mix_add_scale_stride_s24_le(
			dst, src, dst_stride, src_stride, count, scaler);
	case SND_PCM_FORMAT_S32_LE:
		return cras_mix_add_scale_stride_s32_le(
			dst, src, dst_stride, src_stride, count, scaler);
	case SND_PCM_FORMAT_S24_3LE:
		return cras_mix_add_scale_stride_s24_3le(
			dst, src, dst_stride, src_stride, count, scaler);
	default:
		break;
	}
}

static size_t mix_mute_buffer(uint8_t *dst, size_t frame_bytes, size_t count)
{
	memset(dst, 0, count * frame_bytes);
	return count;
}

const struct cras_mix_ops OPS(mixer_ops) = {
	.scale_buffer = scale_buffer,
	.scale_buffer_increment = scale_buffer_increment,
	.add = mix_add,
	.add_scale_stride = mix_add_scale_stride,
	.mute_buffer = mix_mute_buffer,
};