Audio: PCM converter: Add support for A-law sample type

This patch adds to the PCM converter functions
pcm_convert_alaw_to_s32() and pcm_convert_s32_to_alaw().

The function audio_stream_fmt_conversion() is also updated
to check the sample type and depth to set up correctly
conversion for A-law.

Signed-off-by: Seppo Ingalsuo <seppo.ingalsuo@linux.intel.com>

Author: singalsu

src/audio/Kconfig

@@ -180,6 +180,11 @@ config FORMAT_U8
 	help
 	  Support unsigned 8 bit processing data format
 
+config FORMAT_A_LAW
+	bool "Support A-law"
+	help
+	  Support 8 bit A-law processing data format.
+
 config FORMAT_S16LE
 	bool "Support S16LE"
 	default y
@@ -228,6 +233,12 @@ config PCM_CONVERTER_FORMAT_U8
 	help
 	  Support 8 bit processing data format without sign
 
+config PCM_CONVERTER_FORMAT_A_LAW
+	bool "Support A-law"
+	select MATH_A_LAW_CODEC
+	help
+	  Support 8 bit A-law data format.
+
 config PCM_CONVERTER_FORMAT_S16LE
 	bool "Support S16LE"
 	default y

src/audio/pcm_converter/pcm_converter_generic.c

@@ -21,6 +21,7 @@
 
 #include <sof/audio/buffer.h>
 #include <sof/audio/format.h>
+#include <sof/math/a_law.h>
 #include <rtos/bit.h>
 #include <sof/common.h>
 #include <sof/compiler_attributes.h>
@@ -93,6 +94,66 @@ static int pcm_convert_s32_to_u8(const struct audio_stream *source,
 }
 #endif /* CONFIG_PCM_CONVERTER_FORMAT_U8 && CONFIG_PCM_CONVERTER_FORMAT_S32LE */
 
+#if CONFIG_PCM_CONVERTER_FORMAT_A_LAW && CONFIG_PCM_CONVERTER_FORMAT_S32LE
+static int pcm_convert_alaw_to_s32(const struct audio_stream *source,
+				   uint32_t ioffset, struct audio_stream *sink,
+				   uint32_t ooffset, uint32_t samples, uint32_t chmap)
+{
+	const uint8_t *src = audio_stream_get_rptr(source);
+	int32_t *dst = audio_stream_get_wptr(sink);
+	uint32_t processed;
+	uint32_t nmax, i, n;
+
+	src += ioffset;
+	dst += ooffset;
+	for (processed = 0; processed < samples; processed += n) {
+		src = audio_stream_wrap(source, (void *)src);
+		dst = audio_stream_wrap(sink, dst);
+		n = samples - processed;
+		nmax = audio_stream_bytes_without_wrap(source, src) >> BYTES_TO_U8_SAMPLES;
+		n = MIN(n, nmax);
+		nmax = audio_stream_bytes_without_wrap(sink, dst) >> BYTES_TO_S32_SAMPLES;
+		n = MIN(n, nmax);
+		for (i = 0; i < n; i++) {
+			*dst = sofm_a_law_decode(*src) << 16;
+			src++;
+			dst++;
+		}
+	}
+
+	return samples;
+}
+
+static int pcm_convert_s32_to_alaw(const struct audio_stream *source,
+				   uint32_t ioffset, struct audio_stream *sink,
+				   uint32_t ooffset, uint32_t samples, uint32_t chmap)
+{
+	const int32_t *src = audio_stream_get_rptr(source);
+	uint8_t *dst = audio_stream_get_wptr(sink);
+	uint32_t processed;
+	uint32_t nmax, i, n;
+
+	src += ioffset;
+	dst += ooffset;
+	for (processed = 0; processed < samples; processed += n) {
+		src = audio_stream_wrap(source, (void *)src);
+		dst = audio_stream_wrap(sink, dst);
+		n = samples - processed;
+		nmax = audio_stream_bytes_without_wrap(source, src) >> BYTES_TO_S32_SAMPLES;
+		n = MIN(n, nmax);
+		nmax = audio_stream_bytes_without_wrap(sink, dst) >> BYTES_TO_U8_SAMPLES;
+		n = MIN(n, nmax);
+		for (i = 0; i < n; i++) {
+			*dst = sofm_a_law_encode(*src >> 16);
+			src++;
+			dst++;
+		}
+	}
+
+	return samples;
+}
+#endif /* CONFIG_PCM_CONVERTER_FORMAT_A_LAW && CONFIG_PCM_CONVERTER_FORMAT_S32LE */
+
 #if CONFIG_PCM_CONVERTER_FORMAT_S16LE && CONFIG_PCM_CONVERTER_FORMAT_S24LE
 
 static int pcm_convert_s16_to_s24(const struct audio_stream *source,
@@ -555,6 +616,13 @@ const struct pcm_func_map pcm_func_map[] = {
 	{ SOF_IPC_FRAME_U8, SOF_IPC_FRAME_S32_LE, pcm_convert_u8_to_s32 },
 	{ SOF_IPC_FRAME_S32_LE, SOF_IPC_FRAME_U8, pcm_convert_s32_to_u8 },
 #endif /* CONFIG_PCM_CONVERTER_FORMAT_U8 && CONFIG_PCM_CONVERTER_FORMAT_S32LE */
+#if CONFIG_PCM_CONVERTER_FORMAT_A_LAW
+	{ SOF_IPC_FRAME_A_LAW, SOF_IPC_FRAME_A_LAW, just_copy },
+#endif /* CONFIG_PCM_CONVERTER_FORMAT_A_LAW */
+#if CONFIG_PCM_CONVERTER_FORMAT_A_LAW && CONFIG_PCM_CONVERTER_FORMAT_S32LE
+	{ SOF_IPC_FRAME_A_LAW, SOF_IPC_FRAME_S32_LE, pcm_convert_alaw_to_s32 },
+	{ SOF_IPC_FRAME_S32_LE, SOF_IPC_FRAME_A_LAW, pcm_convert_s32_to_alaw },
+#endif /* CONFIG_PCM_CONVERTER_FORMAT_A_LAW && CONFIG_PCM_CONVERTER_FORMAT_S32LE */
 #if CONFIG_PCM_CONVERTER_FORMAT_S16LE
 	{ SOF_IPC_FRAME_S16_LE, SOF_IPC_FRAME_S16_LE, just_copy },
 #endif /* CONFIG_PCM_CONVERTER_FORMAT_S16LE */

src/include/module/audio/format.h

@@ -22,6 +22,7 @@ static inline uint32_t get_sample_bytes(enum sof_ipc_frame fmt)
 	case SOF_IPC_FRAME_S24_3LE:
 		return 3;
 	case SOF_IPC_FRAME_U8:
+	case SOF_IPC_FRAME_A_LAW:
 		return 1;
 	default:
 		return 4;
@@ -37,6 +38,7 @@ static inline uint32_t get_sample_bitdepth(enum sof_ipc_frame fmt)
 	case SOF_IPC_FRAME_S24_3LE:
 		return 24;
 	case SOF_IPC_FRAME_U8:
+	case SOF_IPC_FRAME_A_LAW:
 		return 8;
 	default:
 		return 32;

src/include/module/ipc/stream.h

@@ -22,7 +22,8 @@ enum sof_ipc_frame {
 	SOF_IPC_FRAME_S24_3LE,
 	SOF_IPC_FRAME_S24_4LE_MSB,
 	SOF_IPC_FRAME_U8,
-	SOF_IPC_FRAME_S16_4LE		/* 16-bit in 32-bit container */
+	SOF_IPC_FRAME_S16_4LE,		/* 16-bit in 32-bit container */
+	SOF_IPC_FRAME_A_LAW,
 };
 
 #endif /* __MODULE_IPC_STREAM_H__ */

src/include/module/ipc4/base-config.h

@@ -97,7 +97,9 @@ enum ipc4_sample_type {
 	IPC4_TYPE_LSB_INTEGER = 1,	/**< integer with Least Significant Byte first */
 	IPC4_TYPE_SIGNED_INTEGER = 2,
 	IPC4_TYPE_UNSIGNED_INTEGER = 3,
-	IPC4_TYPE_FLOAT = 4
+	IPC4_TYPE_FLOAT = 4,
+	IPC4_TYPE_A_LAW = 5,
+	IPC4_TYPE_MU_LAW = 6,
 };
 
 enum ipc4_stream_type {

src/include/sof/audio/audio_stream.h

@@ -1028,6 +1028,13 @@ static inline void audio_stream_fmt_conversion(enum ipc4_bit_depth depth,
 		*valid_fmt = SOF_IPC_FRAME_U8;
 #endif /* CONFIG_FORMAT_U8 */
 
+#ifdef CONFIG_FORMAT_A_LAW
+	if (type == IPC4_TYPE_A_LAW && depth == 8) {
+		*frame_fmt = SOF_IPC_FRAME_A_LAW;
+		*valid_fmt = SOF_IPC_FRAME_A_LAW;
+	}
+#endif
+
 	if (valid == 24) {
 #ifdef CONFIG_FORMAT_S24_3LE
 		if (depth == 24) {