summaryrefslogtreecommitdiff
path: root/hifi/xaf/hifi-dpf/plugins/cadence
diff options
context:
space:
mode:
Diffstat (limited to 'hifi/xaf/hifi-dpf/plugins/cadence')
-rw-r--r--hifi/xaf/hifi-dpf/plugins/cadence/mixer/xa-mixer.c669
-rw-r--r--hifi/xaf/hifi-dpf/plugins/cadence/pcm_proc/xa-pcm-api.h145
-rw-r--r--hifi/xaf/hifi-dpf/plugins/cadence/pcm_proc/xa-pcm.c841
-rw-r--r--hifi/xaf/hifi-dpf/plugins/cadence/vorbis_dec/lib/hifi3/xa_vorbis_dec.abin0 -> 124410 bytes
-rw-r--r--hifi/xaf/hifi-dpf/plugins/cadence/vorbis_dec/xa-vorbis-decoder.c84
-rw-r--r--hifi/xaf/hifi-dpf/plugins/cadence/vorbis_dec/xa_vorbis_dec_api.h121
6 files changed, 1860 insertions, 0 deletions
diff --git a/hifi/xaf/hifi-dpf/plugins/cadence/mixer/xa-mixer.c b/hifi/xaf/hifi-dpf/plugins/cadence/mixer/xa-mixer.c
new file mode 100644
index 00000000..2191239b
--- /dev/null
+++ b/hifi/xaf/hifi-dpf/plugins/cadence/mixer/xa-mixer.c
@@ -0,0 +1,669 @@
+/*******************************************************************************
+* Copyright (C) 2018 Cadence Design Systems, Inc.
+*
+* Permission is hereby granted, free of charge, to any person obtaining
+* a copy of this software and associated documentation files (the
+* "Software"), to use this Software with Cadence processor cores only and
+* not with any other processors and platforms, subject to
+* the following conditions:
+*
+* The above copyright notice and this permission notice 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.
+
+******************************************************************************/
+
+/*******************************************************************************
+ * xa-mixer.c
+ *
+ * Sample mixer plugin
+ *
+ ******************************************************************************/
+
+#define MODULE_TAG MIXER
+
+/*******************************************************************************
+ * Includes
+ ******************************************************************************/
+
+#include "xf-plugin.h"
+#include "audio/xa-mixer-api.h"
+
+/*******************************************************************************
+ * Tracing configuration
+ ******************************************************************************/
+
+TRACE_TAG(INIT, 1);
+TRACE_TAG(PROCESS, 1);
+
+/*******************************************************************************
+ * Internal functions definitions
+ ******************************************************************************/
+
+/* ...API structure */
+typedef struct XAPcmMixer
+{
+ /* ...mixer state */
+ u32 state;
+
+ /* ...number of samples in a frame */
+ u32 frame_size;
+
+ /* ...number of channels (channel mask?) */
+ u32 channels;
+
+ /* ...PCM sample width */
+ u32 pcm_width;
+
+ /* ...sampling rate */
+ u32 sample_rate;
+
+ /* ...number of bytes in input/output buffer */
+ u32 buffer_size;
+
+ /* ...main volume and individual track volumes*/
+ u32 volume[XA_MIXER_MAX_TRACK_NUMBER + 1];
+
+ /* ...input buffers */
+ void *input[XA_MIXER_MAX_TRACK_NUMBER];
+
+ /* ...number of samples in individual buffers */
+ u32 input_length[XA_MIXER_MAX_TRACK_NUMBER];
+
+ /* ...output buffer */
+ void *output;
+
+ /* ...number of produced bytes - do I need that? have buffer-size already - tbd */
+ u32 produced;
+
+ /* ...scratch buffer pointer */
+ void *scratch;
+
+} XAPcmMixer;
+
+/*******************************************************************************
+ * Mixer state flags
+ ******************************************************************************/
+
+#define XA_MIXER_FLAG_PREINIT_DONE (1 << 0)
+#define XA_MIXER_FLAG_POSTINIT_DONE (1 << 1)
+#define XA_MIXER_FLAG_RUNNING (1 << 2)
+#define XA_MIXER_FLAG_OUTPUT (1 << 3)
+#define XA_MIXER_FLAG_COMPLETE (1 << 4)
+
+/*******************************************************************************
+ * DSP functions
+ ******************************************************************************/
+
+#define DSP_SATURATE_S16(s32) \
+ (s16)((s32) > 0x7fff ? 0x7fff : ((s32) < -0x8000 ? -0x8000 : (s32)))
+
+/* ...mixer preinitialization (default parameters) */
+static inline void xa_mixer_preinit(XAPcmMixer *d)
+{
+ u32 i;
+
+ /* ...pre-configuration initialization; reset internal data */
+ memset(d, 0, sizeof(*d));
+
+ /* ...set default parameters */
+ d->pcm_width = 16, d->channels = 2, d->frame_size = 512;
+
+ /* ...set default volumes (last index is a main volume)*/
+ for (i = 0; i <= XA_MIXER_MAX_TRACK_NUMBER; i++)
+ {
+ d->volume[i] = ((1 << 12) << 16) | (1 << 12);
+ }
+}
+
+/* ...do mixing of stereo PCM-16 streams */
+static XA_ERRORCODE xa_mixer_do_execute_stereo_16bit(XAPcmMixer *d)
+{
+ s16 *output = d->output;
+ s16 *b[XA_MIXER_MAX_TRACK_NUMBER];
+ u16 v_l[XA_MIXER_MAX_TRACK_NUMBER];
+ u16 v_r[XA_MIXER_MAX_TRACK_NUMBER];
+ u16 w_l, w_r;
+ u32 t32;
+ u32 i, j;
+
+ /* ...retrieve main volume - assume up to 24dB amplifying (4 bits) */
+ t32 = d->volume[XA_MIXER_MAX_TRACK_NUMBER];
+ w_l = (u16)(t32 & 0xFFFF), w_r = (u16)(t32 >> 16);
+
+ /* ...prepare individual tracks */
+ for (j = 0; j < XA_MIXER_MAX_TRACK_NUMBER; j++)
+ {
+ u32 n = d->input_length[j];
+
+ /* ...check if we have input buffer available */
+ if (n == 0)
+ {
+ /* ...output silence (multiply garbage in the scratch buffer by 0) */
+ b[j] = d->scratch;
+ v_l[j] = v_r[j] = 0;
+ }
+ else
+ {
+ s32 k = (s32)(d->buffer_size - n);
+
+ /* ...put input buffer */
+ XF_CHK_ERR(b[j] = d->input[j], XA_MIXER_EXEC_FATAL_INPUT);
+
+ /* ...if length is not sufficient, pad buffer remainder */
+ (k > 0 ? memset((void *)b[j] + n, 0x00, k) : 0);
+
+ /* ...set individual track volume/balance */
+ t32 = d->volume[j];
+ v_l[j] = (u16)(t32 & 0xFFFF), v_r[j] = (u16)(t32 >> 16);
+ }
+
+ TRACE(PROCESS, _b("b[%u] = %p%s"), j, b[j], (n == 0 ? " - scratch" : ""));
+ }
+
+ /* ...process all tracks */
+ for (i = 0; i < d->frame_size; i++)
+ {
+ s32 l32 = 0, r32 = 0;
+
+ /* ...fill-in every channel in our map (unrolls loop here) */
+ for (j = 0; j < XA_MIXER_MAX_TRACK_NUMBER; j++)
+ {
+ /* ...left channel processing (no saturation here yet) */
+ l32 += *b[j]++ * v_l[j];
+
+ /* ...right channel processing */
+ r32 += *b[j]++ * v_r[j];
+ }
+
+ /* ...normalize (truncate towards -inf) and multiply by main volume */
+ l32 = ((l32 >> 12) * w_l) >> 12;
+ r32 = ((r32 >> 12) * w_r) >> 12;
+
+ /* ...saturate and store in buffer */
+ *output++ = DSP_SATURATE_S16(l32);
+ *output++ = DSP_SATURATE_S16(r32);
+ }
+
+ /* ...save total number of produced bytes */
+ d->produced = (u32)((void *)output - d->output);
+
+ /* ...put flag saying we have output buffer */
+ d->state |= XA_MIXER_FLAG_OUTPUT;
+
+ TRACE(PROCESS, _b("produced: %u bytes (%u samples)"), d->produced, d->frame_size);
+
+ /* ...reset input buffer length? */
+ //memset(d->input_length, 0, sizeof(d->input_length));
+
+ /* ...return success result code */
+ return XA_NO_ERROR;
+}
+
+/* ...runtime reset */
+static XA_ERRORCODE xa_mixer_do_runtime_init(XAPcmMixer *d)
+{
+ /* ...no special processing is needed here */
+ return XA_NO_ERROR;
+}
+
+/*******************************************************************************
+ * Commands processing
+ ******************************************************************************/
+
+/* ...codec API size query */
+static XA_ERRORCODE xa_mixer_get_api_size(XAPcmMixer *d, WORD32 i_idx, pVOID pv_value)
+{
+ /* ...check parameters are valid */
+ XF_CHK_ERR(pv_value, XA_API_FATAL_INVALID_CMD_TYPE);
+
+ /* ...retrieve API structure size */
+ *(WORD32 *)pv_value = sizeof(*d);
+
+ return XA_NO_ERROR;
+}
+
+/* ...standard codec initialization routine */
+static XA_ERRORCODE xa_mixer_init(XAPcmMixer *d, WORD32 i_idx, pVOID pv_value)
+{
+ /* ...validity check - mixer must be valid */
+ XF_CHK_ERR(d, XA_API_FATAL_INVALID_CMD_TYPE);
+
+ /* ...process particular initialization type */
+ switch (i_idx)
+ {
+ case XA_CMD_TYPE_INIT_API_PRE_CONFIG_PARAMS:
+ {
+ /* ...pre-configuration initialization; reset internal data */
+ xa_mixer_preinit(d);
+
+ /* ...and mark mixer has been created */
+ d->state = XA_MIXER_FLAG_PREINIT_DONE;
+
+ return XA_NO_ERROR;
+ }
+
+ case XA_CMD_TYPE_INIT_API_POST_CONFIG_PARAMS:
+ {
+ /* ...post-configuration initialization (all parameters are set) */
+ XF_CHK_ERR(d->state & XA_MIXER_FLAG_PREINIT_DONE, XA_API_FATAL_INVALID_CMD_TYPE);
+
+ /* ...calculate input/output buffer size in bytes */
+ d->buffer_size = d->channels * d->frame_size * (d->pcm_width == 16 ? sizeof(s16) : sizeof(s32));
+
+ /* ...mark post-initialization is complete */
+ d->state |= XA_MIXER_FLAG_POSTINIT_DONE;
+
+ return XA_NO_ERROR;
+ }
+
+ case XA_CMD_TYPE_INIT_PROCESS:
+ {
+ /* ...kick run-time initialization process; make sure mixer is setup */
+ XF_CHK_ERR(d->state & XA_MIXER_FLAG_POSTINIT_DONE, XA_API_FATAL_INVALID_CMD_TYPE);
+
+ /* ...enter into execution stage */
+ d->state |= XA_MIXER_FLAG_RUNNING;
+
+ return XA_NO_ERROR;
+ }
+
+ case XA_CMD_TYPE_INIT_DONE_QUERY:
+ {
+ /* ...check if initialization is done; make sure pointer is valid */
+ XF_CHK_ERR(pv_value, XA_API_FATAL_INVALID_CMD_TYPE);
+
+ /* ...put current status */
+ *(WORD32 *)pv_value = (d->state & XA_MIXER_FLAG_RUNNING ? 1 : 0);
+
+ return XA_NO_ERROR;
+ }
+
+ default:
+ /* ...unrecognized command type */
+ TRACE(ERROR, _x("Unrecognized command type: %X"), i_idx);
+ return XA_API_FATAL_INVALID_CMD_TYPE;
+ }
+}
+
+/* ...set mixer configuration parameter */
+static XA_ERRORCODE xa_mixer_set_config_param(XAPcmMixer *d, WORD32 i_idx, pVOID pv_value)
+{
+ u32 i_value;
+
+ /* ...validity check - mixer pointer must be valid */
+ XF_CHK_ERR(d && pv_value, XA_API_FATAL_INVALID_CMD_TYPE);
+
+ /* ...pre-initialization must be completed, mixer must be idle */
+ XF_CHK_ERR(d->state & XA_MIXER_FLAG_PREINIT_DONE, XA_API_FATAL_INVALID_CMD_TYPE);
+
+ /* ...get parameter value */
+ i_value = (u32) *(WORD32 *)pv_value;
+
+ /* ...process individual configuration parameter */
+ switch (i_idx)
+ {
+ case XA_MIXER_CONFIG_PARAM_PCM_WIDTH:
+ /* ...check value is permitted (16 bits only) */
+ XF_CHK_ERR(i_value == 16, XA_MIXER_CONFIG_NONFATAL_RANGE);
+ d->pcm_width = (u32)i_value;
+ return XA_NO_ERROR;
+
+ case XA_MIXER_CONFIG_PARAM_CHANNELS:
+ /* ...allow stereo only */
+ XF_CHK_ERR(i_value == 2, XA_MIXER_CONFIG_NONFATAL_RANGE);
+ d->channels = (u32)i_value;
+ return XA_NO_ERROR;
+
+ case XA_MIXER_CONFIG_PARAM_SAMPLE_RATE:
+ /* ...set mixer sample rate */
+ d->sample_rate = (u32)i_value;
+ return XA_NO_ERROR;
+
+ default:
+ TRACE(ERROR, _x("Invalid parameter: %X"), i_idx);
+ return XA_API_FATAL_INVALID_CMD_TYPE;
+ }
+}
+
+/* ...retrieve configuration parameter */
+static XA_ERRORCODE xa_mixer_get_config_param(XAPcmMixer *d, WORD32 i_idx, pVOID pv_value)
+{
+ /* ...validity check - mixer must be initialized */
+ XF_CHK_ERR(d && pv_value, XA_API_FATAL_INVALID_CMD_TYPE);
+
+ /* ...make sure pre-initialization is completed */
+ XF_CHK_ERR(d->state & XA_MIXER_FLAG_PREINIT_DONE, XA_API_FATAL_INVALID_CMD_TYPE);
+
+ /* ...process individual configuration parameter */
+ switch (i_idx)
+ {
+ case XA_MIXER_CONFIG_PARAM_INPUT_TRACKS:
+ /* ...return maximal number of input tracks supported */
+ *(WORD32 *)pv_value = XA_MIXER_MAX_TRACK_NUMBER;
+ return XA_NO_ERROR;
+
+ case XA_MIXER_CONFIG_PARAM_SAMPLE_RATE:
+ /* ...return mixer sample rate */
+ *(WORD32 *)pv_value = d->sample_rate;
+ return XA_NO_ERROR;
+
+ case XA_MIXER_CONFIG_PARAM_PCM_WIDTH:
+ /* ...return current PCM width */
+ *(WORD32 *)pv_value = d->pcm_width;
+ return XA_NO_ERROR;
+
+ case XA_MIXER_CONFIG_PARAM_CHANNELS:
+ /* ...return current channel number */
+ *(WORD32 *)pv_value = d->channels;
+ return XA_NO_ERROR;
+
+ case XA_MIXER_CONFIG_PARAM_FRAME_SIZE:
+ /* ...return current in/out frame length (in samples) */
+ *(WORD32 *)pv_value = d->frame_size;
+ return XA_NO_ERROR;
+
+ case XA_MIXER_CONFIG_PARAM_BUFFER_SIZE:
+ /* ...return current in/out frame length (in bytes) */
+ *(WORD32 *)pv_value = d->buffer_size;
+ return XA_NO_ERROR;
+
+ default:
+ TRACE(ERROR, _x("Invalid parameter: %X"), i_idx);
+ return XA_API_FATAL_INVALID_CMD_TYPE;
+ }
+}
+
+/* ...execution command */
+static XA_ERRORCODE xa_mixer_execute(XAPcmMixer *d, WORD32 i_idx, pVOID pv_value)
+{
+ /* ...validity check - mixer must be valid */
+ XF_CHK_ERR(d, XA_API_FATAL_INVALID_CMD_TYPE);
+
+ /* ...mixer must be in running state */
+ XF_CHK_ERR(d->state & XA_MIXER_FLAG_RUNNING, XA_API_FATAL_INVALID_CMD_TYPE);
+
+ /* ...process individual command type */
+ switch (i_idx)
+ {
+ case XA_CMD_TYPE_DO_EXECUTE:
+ /* ...perform mixing of the channels */
+ return xa_mixer_do_execute_stereo_16bit(d);
+
+ case XA_CMD_TYPE_DONE_QUERY:
+ /* ...check if processing is complete */
+ XF_CHK_ERR(pv_value, XA_API_FATAL_INVALID_CMD_TYPE);
+ *(WORD32 *)pv_value = (d->state & XA_MIXER_FLAG_COMPLETE ? 1 : 0);
+ return XA_NO_ERROR;
+
+ case XA_CMD_TYPE_DO_RUNTIME_INIT:
+ /* ...reset mixer operation */
+ return xa_mixer_do_runtime_init(d);
+
+ default:
+ /* ...unrecognized command */
+ TRACE(ERROR, _x("Invalid index: %X"), i_idx);
+ return XA_API_FATAL_INVALID_CMD_TYPE;
+ }
+}
+
+/* ...set number of input bytes */
+static XA_ERRORCODE xa_mixer_set_input_bytes(XAPcmMixer *d, WORD32 i_idx, pVOID pv_value)
+{
+ u32 size;
+
+ /* ...validity check - check parameters */
+ XF_CHK_ERR(d && pv_value, XA_API_FATAL_INVALID_CMD_TYPE);
+
+ /* ...track index must be valid */
+ XF_CHK_ERR(i_idx >= 0 && i_idx < XA_MIXER_MAX_TRACK_NUMBER, XA_API_FATAL_INVALID_CMD_TYPE);
+
+ /* ...mixer must be initialized */
+ XF_CHK_ERR(d->state & XA_MIXER_FLAG_POSTINIT_DONE, XA_API_FATAL_INVALID_CMD_TYPE);
+
+ /* ...input buffer must exist */
+ XF_CHK_ERR(d->input[i_idx], XA_API_FATAL_INVALID_CMD_TYPE);
+
+ /* ...input frame length should not be zero (in bytes) */
+ XF_CHK_ERR((size = (u32)*(WORD32 *)pv_value) > 0, XA_MIXER_EXEC_NONFATAL_INPUT);
+
+ /* ...all is correct; set input buffer length in bytes */
+ d->input_length[i_idx] = size;
+
+ return XA_NO_ERROR;
+}
+
+/* ...get number of output bytes */
+static XA_ERRORCODE xa_mixer_get_output_bytes(XAPcmMixer *d, WORD32 i_idx, pVOID pv_value)
+{
+ /* ...validity check - check parameters */
+ XF_CHK_ERR(d && pv_value, XA_API_FATAL_INVALID_CMD_TYPE);
+
+ /* ...track index must be zero */
+ XF_CHK_ERR(i_idx == XA_MIXER_MAX_TRACK_NUMBER, XA_API_FATAL_INVALID_CMD_TYPE);
+
+ /* ...mixer must be running */
+ XF_CHK_ERR(d->state & XA_MIXER_FLAG_RUNNING, XA_API_FATAL_INVALID_CMD_TYPE);
+
+ /* ...output buffer must exist */
+ XF_CHK_ERR(d->output, XA_MIXER_EXEC_NONFATAL_OUTPUT);
+
+ /* ...return number of produced bytes */
+ *(WORD32 *)pv_value = (d->state & XA_MIXER_FLAG_OUTPUT ? d->buffer_size : 0);
+
+ return XA_NO_ERROR;
+}
+
+/* ...get number of consumed bytes */
+static XA_ERRORCODE xa_mixer_get_curidx_input_buf(XAPcmMixer *d, WORD32 i_idx, pVOID pv_value)
+{
+ /* ...validity check - check parameters */
+ XF_CHK_ERR(d && pv_value, XA_API_FATAL_INVALID_CMD_TYPE);
+
+ /* ...track index must be valid */
+ XF_CHK_ERR(i_idx >= 0 && i_idx < XA_MIXER_MAX_TRACK_NUMBER, XA_API_FATAL_INVALID_CMD_TYPE);
+
+ /* ...mixer must be running */
+ XF_CHK_ERR(d->state & XA_MIXER_FLAG_RUNNING, XA_MIXER_EXEC_FATAL_STATE);
+
+ /* ...input buffer must exist */
+ XF_CHK_ERR(d->input[i_idx], XA_MIXER_EXEC_FATAL_INPUT);
+
+ /* ...return number of bytes consumed (always consume fixed-length chunk) */
+ *(WORD32 *)pv_value = d->input_length[i_idx], d->input_length[i_idx] = 0;
+
+ return XA_NO_ERROR;
+}
+
+/*******************************************************************************
+ * Memory information API
+ ******************************************************************************/
+
+/* ..get total amount of data for memory tables */
+static XA_ERRORCODE xa_mixer_get_memtabs_size(XAPcmMixer *d, WORD32 i_idx, pVOID pv_value)
+{
+ /* ...basic validity checks */
+ XF_CHK_ERR(d && pv_value, XA_API_FATAL_INVALID_CMD_TYPE);
+
+ /* ...check mixer is pre-initialized */
+ XF_CHK_ERR(d->state & XA_MIXER_FLAG_PREINIT_DONE, XA_API_FATAL_INVALID_CMD_TYPE);
+
+ /* ...we have all our tables inside API structure - good? tbd */
+ *(WORD32 *)pv_value = 0;
+
+ return XA_NO_ERROR;
+}
+
+/* ..set memory tables pointer */
+static XA_ERRORCODE xa_mixer_set_memtabs_ptr(XAPcmMixer *d, WORD32 i_idx, pVOID pv_value)
+{
+ /* ...basic validity checks */
+ XF_CHK_ERR(d && pv_value, XA_API_FATAL_INVALID_CMD_TYPE);
+
+ /* ...check mixer is pre-initialized */
+ XF_CHK_ERR(d->state & XA_MIXER_FLAG_PREINIT_DONE, XA_API_FATAL_INVALID_CMD_TYPE);
+
+ /* ...do not do anything; just return success - tbd */
+ return XA_NO_ERROR;
+}
+
+/* ...return total amount of memory buffers */
+static XA_ERRORCODE xa_mixer_get_n_memtabs(XAPcmMixer *d, WORD32 i_idx, pVOID pv_value)
+{
+ /* ...basic validity checks */
+ XF_CHK_ERR(d && pv_value, XA_API_FATAL_INVALID_CMD_TYPE);
+
+ /* ...we have N input buffers, 1 output buffer and 1 scratch buffer */
+ *(WORD32 *)pv_value = XA_MIXER_MAX_TRACK_NUMBER + 1 + 1;
+
+ return XA_NO_ERROR;
+}
+
+/* ...return memory buffer data */
+static XA_ERRORCODE xa_mixer_get_mem_info_size(XAPcmMixer *d, WORD32 i_idx, pVOID pv_value)
+{
+ /* ...basic validity check */
+ XF_CHK_ERR(d && pv_value, XA_API_FATAL_INVALID_CMD_TYPE);
+
+ /* ...return frame buffer minimal size only after post-initialization is done */
+ XF_CHK_ERR(d->state & XA_MIXER_FLAG_POSTINIT_DONE, XA_API_FATAL_INVALID_CMD_TYPE);
+
+ /* ...all buffers are of the same length */
+ *(WORD32 *)pv_value = (WORD32) d->buffer_size;
+
+ return XA_NO_ERROR;
+}
+
+/* ...return memory alignment data */
+static XA_ERRORCODE xa_mixer_get_mem_info_alignment(XAPcmMixer *d, WORD32 i_idx, pVOID pv_value)
+{
+ /* ...basic validity check */
+ XF_CHK_ERR(d && pv_value, XA_API_FATAL_INVALID_CMD_TYPE);
+
+ /* ...return frame buffer minimal size only after post-initialization is done */
+ XF_CHK_ERR(d->state & XA_MIXER_FLAG_POSTINIT_DONE, XA_API_FATAL_INVALID_CMD_TYPE);
+
+ /* ...all buffers are 4-bytes aligned */
+ *(WORD32 *)pv_value = 4;
+
+ return XA_NO_ERROR;
+}
+
+/* ...return memory type data */
+static XA_ERRORCODE xa_mixer_get_mem_info_type(XAPcmMixer *d, WORD32 i_idx, pVOID pv_value)
+{
+ /* ...basic validity check */
+ XF_CHK_ERR(d && pv_value, XA_API_FATAL_INVALID_CMD_TYPE);
+
+ /* ...return frame buffer minimal size only after post-initialization is done */
+ XF_CHK_ERR(d->state & XA_MIXER_FLAG_POSTINIT_DONE, XA_API_FATAL_INVALID_CMD_TYPE);
+
+ switch (i_idx)
+ {
+ case 0 ... XA_MIXER_MAX_TRACK_NUMBER - 1:
+ /* ...input buffers */
+ *(WORD32 *)pv_value = XA_MEMTYPE_INPUT;
+ return XA_NO_ERROR;
+
+ case XA_MIXER_MAX_TRACK_NUMBER:
+ /* ...output buffer */
+ *(WORD32 *)pv_value = XA_MEMTYPE_OUTPUT;
+ return XA_NO_ERROR;
+
+ case XA_MIXER_MAX_TRACK_NUMBER + 1:
+ /* ...scratch buffer */
+ *(WORD32 *)pv_value = XA_MEMTYPE_SCRATCH;
+ return XA_NO_ERROR;
+
+ default:
+ /* ...invalid index */
+ return XF_CHK_ERR(0, XA_API_FATAL_INVALID_CMD_TYPE);
+ }
+}
+
+/* ...set memory pointer */
+static XA_ERRORCODE xa_mixer_set_mem_ptr(XAPcmMixer *d, WORD32 i_idx, pVOID pv_value)
+{
+ /* ...basic validity check */
+ XF_CHK_ERR(d && pv_value, XA_API_FATAL_INVALID_CMD_TYPE);
+
+ /* ...codec must be initialized */
+ XF_CHK_ERR(d->state & XA_MIXER_FLAG_POSTINIT_DONE, XA_API_FATAL_INVALID_CMD_TYPE);
+
+ /* ...select memory buffer */
+ switch (i_idx)
+ {
+ case 0 ... XA_MIXER_MAX_TRACK_NUMBER - 1:
+ /* ...input buffers */
+ d->input[i_idx] = pv_value;
+ return XA_NO_ERROR;
+
+ case XA_MIXER_MAX_TRACK_NUMBER:
+ /* ...output buffer */
+ d->output = pv_value;
+ return XA_NO_ERROR;
+
+ case XA_MIXER_MAX_TRACK_NUMBER + 1:
+ /* ...scratch buffer */
+ d->scratch = pv_value;
+ return XA_NO_ERROR;
+
+ default:
+ /* ...invalid index */
+ return XF_CHK_ERR(0, XA_API_FATAL_INVALID_CMD_TYPE);
+ }
+}
+
+/*******************************************************************************
+ * API command hooks
+ ******************************************************************************/
+
+static XA_ERRORCODE (* const xa_mixer_api[])(XAPcmMixer *, WORD32, pVOID) =
+{
+ [XA_API_CMD_GET_API_SIZE] = xa_mixer_get_api_size,
+
+ [XA_API_CMD_INIT] = xa_mixer_init,
+ [XA_API_CMD_SET_CONFIG_PARAM] = xa_mixer_set_config_param,
+ [XA_API_CMD_GET_CONFIG_PARAM] = xa_mixer_get_config_param,
+
+ [XA_API_CMD_EXECUTE] = xa_mixer_execute,
+ [XA_API_CMD_SET_INPUT_BYTES] = xa_mixer_set_input_bytes,
+ [XA_API_CMD_GET_OUTPUT_BYTES] = xa_mixer_get_output_bytes,
+ [XA_API_CMD_GET_CURIDX_INPUT_BUF] = xa_mixer_get_curidx_input_buf,
+
+ [XA_API_CMD_GET_MEMTABS_SIZE] = xa_mixer_get_memtabs_size,
+ [XA_API_CMD_SET_MEMTABS_PTR] = xa_mixer_set_memtabs_ptr,
+ [XA_API_CMD_GET_N_MEMTABS] = xa_mixer_get_n_memtabs,
+ [XA_API_CMD_GET_MEM_INFO_SIZE] = xa_mixer_get_mem_info_size,
+ [XA_API_CMD_GET_MEM_INFO_ALIGNMENT] = xa_mixer_get_mem_info_alignment,
+ [XA_API_CMD_GET_MEM_INFO_TYPE] = xa_mixer_get_mem_info_type,
+ [XA_API_CMD_SET_MEM_PTR] = xa_mixer_set_mem_ptr,
+};
+
+/* ...total numer of commands supported */
+#define XA_MIXER_API_COMMANDS_NUM (sizeof(xa_mixer_api) / sizeof(xa_mixer_api[0]))
+
+/*******************************************************************************
+ * API entry point
+ ******************************************************************************/
+
+XA_ERRORCODE xa_mixer(xa_codec_handle_t p_xa_module_obj, WORD32 i_cmd, WORD32 i_idx, pVOID pv_value)
+{
+ XAPcmMixer *d = (XAPcmMixer *) p_xa_module_obj;
+
+ /* ...check if command index is valid */
+ XF_CHK_ERR(i_cmd < XA_MIXER_API_COMMANDS_NUM, XA_API_FATAL_INVALID_CMD);
+
+ /* ...see if command is defined */
+ XF_CHK_ERR(xa_mixer_api[i_cmd], XA_API_FATAL_INVALID_CMD);
+
+ /* ...execute requested command */
+ return xa_mixer_api[i_cmd](d, i_idx, pv_value);
+}
diff --git a/hifi/xaf/hifi-dpf/plugins/cadence/pcm_proc/xa-pcm-api.h b/hifi/xaf/hifi-dpf/plugins/cadence/pcm_proc/xa-pcm-api.h
new file mode 100644
index 00000000..cb14dad0
--- /dev/null
+++ b/hifi/xaf/hifi-dpf/plugins/cadence/pcm_proc/xa-pcm-api.h
@@ -0,0 +1,145 @@
+/*******************************************************************************
+* Copyright (C) 2018 Cadence Design Systems, Inc.
+*
+* Permission is hereby granted, free of charge, to any person obtaining
+* a copy of this software and associated documentation files (the
+* "Software"), to use this Software with Cadence processor cores only and
+* not with any other processors and platforms, subject to
+* the following conditions:
+*
+* The above copyright notice and this permission notice 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.
+
+******************************************************************************/
+
+/*******************************************************************************
+ * xa-pcm-api.h
+ *
+ * Generic PCM format converter API
+ *
+ ******************************************************************************/
+
+#ifndef __XA_PCM_API_H__
+#define __XA_PCM_API_H__
+
+/*******************************************************************************
+ * Includes
+ ******************************************************************************/
+
+#include "xa_type_def.h"
+#include "xa_error_standards.h"
+#include "xa_apicmd_standards.h"
+#include "xa_memory_standards.h"
+
+/*******************************************************************************
+ * Constants definitions
+ ******************************************************************************/
+
+/* ...codec-specific configuration parameters */
+enum xa_config_param_pcm {
+ XA_PCM_CONFIG_PARAM_SAMPLE_RATE = 0,
+ XA_PCM_CONFIG_PARAM_IN_PCM_WIDTH = 1,
+ XA_PCM_CONFIG_PARAM_IN_CHANNELS = 2,
+ XA_PCM_CONFIG_PARAM_OUT_PCM_WIDTH = 3,
+ XA_PCM_CONFIG_PARAM_OUT_CHANNELS = 4,
+ XA_PCM_CONFIG_PARAM_CHANROUTING = 5,
+ XA_PCM_CONFIG_PARAM_NUM = 6,
+};
+
+/* ...component identifier (informative) */
+#define XA_CODEC_PCM 16
+
+/*******************************************************************************
+ * Class 0: API Errors
+ ******************************************************************************/
+
+#define XA_PCM_API_NONFATAL(e) \
+ XA_ERROR_CODE(xa_severity_nonfatal, xa_class_api, XA_CODEC_PCM, (e))
+
+#define XA_PCM_API_FATAL(e) \
+ XA_ERROR_CODE(xa_severity_fatal, xa_class_api, XA_CODEC_PCM, (e))
+
+enum xa_error_nonfatal_api_pcm {
+ XA_PCM_API_NONFATAL_MAX = XA_PCM_API_NONFATAL(0)
+};
+
+enum xa_error_fatal_api_pcm {
+ XA_PCM_API_FATAL_MAX = XA_PCM_API_FATAL(0)
+};
+
+/*******************************************************************************
+ * Class 1: Configuration Errors
+ ******************************************************************************/
+
+#define XA_PCM_CONFIG_NONFATAL(e) \
+ XA_ERROR_CODE(xa_severity_nonfatal, xa_class_config, XA_CODEC_PCM, (e))
+
+#define XA_PCM_CONFIG_FATAL(e) \
+ XA_ERROR_CODE(xa_severity_fatal, xa_class_config, XA_CODEC_PCM, (e))
+
+enum xa_error_nonfatal_config_pcm {
+ XA_PCM_CONFIG_NONFATAL_RANGE = XA_PCM_CONFIG_NONFATAL(0),
+ XA_PCM_CONFIG_NONFATAL_STATE = XA_PCM_CONFIG_NONFATAL(1),
+ XA_PCM_CONFIG_NONFATAL_MAX = XA_PCM_CONFIG_NONFATAL(2)
+};
+
+enum xa_error_fatal_config_pcm {
+ XA_PCM_CONFIG_FATAL_RANGE = XA_PCM_CONFIG_FATAL(0),
+ XA_PCM_CONFIG_FATAL_MAX = XA_PCM_CONFIG_FATAL(1)
+};
+
+/*******************************************************************************
+ * Class 2: Execution Class Errors
+ ******************************************************************************/
+
+#define XA_PCM_EXEC_NONFATAL(e) \
+ XA_ERROR_CODE(xa_severity_nonfatal, xa_class_execute, XA_CODEC_PCM, (e))
+
+#define XA_PCM_EXEC_FATAL(e) \
+ XA_ERROR_CODE(xa_severity_fatal, xa_class_execute, XA_CODEC_PCM, (e))
+
+enum xa_error_nonfatal_execute_pcm {
+ XA_PCM_EXEC_NONFATAL_STATE = XA_PCM_EXEC_NONFATAL(0),
+ XA_PCM_EXEC_NONFATAL_NO_DATA = XA_PCM_EXEC_NONFATAL(1),
+ XA_PCM_EXEC_NONFATAL_INPUT = XA_PCM_EXEC_NONFATAL(2),
+ XA_PCM_EXEC_NONFATAL_OUTPUT = XA_PCM_EXEC_NONFATAL(3),
+ XA_PCM_EXEC_NONFATAL_MAX = XA_PCM_EXEC_NONFATAL(4)
+};
+
+enum xa_error_fatal_execute_pcm {
+ XA_PCM_EXEC_FATAL_STATE = XA_PCM_EXEC_FATAL(0),
+ XA_PCM_EXEC_FATAL_INPUT = XA_PCM_EXEC_FATAL(1),
+ XA_PCM_EXEC_FATAL_OUTPUT = XA_PCM_EXEC_FATAL(2),
+ XA_PCM_EXEC_FATAL_MAX = XA_PCM_EXEC_FATAL(3)
+};
+
+/*******************************************************************************
+ * API function definition
+ ******************************************************************************/
+
+#if defined(USE_DLL) && defined(_WIN32)
+#define DLL_SHARED __declspec(dllimport)
+#elif defined (_WINDLL)
+#define DLL_SHARED __declspec(dllexport)
+#else
+#define DLL_SHARED
+#endif
+
+#if defined(__cplusplus)
+extern "C" {
+#endif /* __cplusplus */
+DLL_SHARED xa_codec_func_t xa_pcm_codec;
+#if defined(__cplusplus)
+}
+#endif /* __cplusplus */
+
+#endif /* __XA_PCM_API_H__ */
+
diff --git a/hifi/xaf/hifi-dpf/plugins/cadence/pcm_proc/xa-pcm.c b/hifi/xaf/hifi-dpf/plugins/cadence/pcm_proc/xa-pcm.c
new file mode 100644
index 00000000..cca97ef9
--- /dev/null
+++ b/hifi/xaf/hifi-dpf/plugins/cadence/pcm_proc/xa-pcm.c
@@ -0,0 +1,841 @@
+/*******************************************************************************
+* Copyright (C) 2018 Cadence Design Systems, Inc.
+*
+* Permission is hereby granted, free of charge, to any person obtaining
+* a copy of this software and associated documentation files (the
+* "Software"), to use this Software with Cadence processor cores only and
+* not with any other processors and platforms, subject to
+* the following conditions:
+*
+* The above copyright notice and this permission notice 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.
+
+******************************************************************************/
+
+/*******************************************************************************
+ * xa-pcm.c
+ *
+ * PCM format converter plugin
+ *
+ ******************************************************************************/
+
+#define MODULE_TAG PCM
+
+/*******************************************************************************
+ * Includes
+ ******************************************************************************/
+
+#include "xf-plugin.h"
+#include "xa-audio-decoder-api.h"
+#include "xa-pcm-api.h"
+
+#include <fcntl.h>
+
+/*******************************************************************************
+ * Tracing configuration
+ ******************************************************************************/
+
+TRACE_TAG(INIT, 1);
+TRACE_TAG(PROCESS, 0);
+
+/*******************************************************************************
+ * Local typedefs
+ ******************************************************************************/
+
+/* ...API structure */
+typedef struct XAPcmCodec
+{
+ /* ...codec state */
+ u32 state;
+
+ /* ...sampling rate of input/output signal (informative only) */
+ u32 sample_rate;
+
+ /* ...number of input/output channels */
+ u8 in_channels, out_channels;
+
+ /* ...PCM sample width of input/output streams */
+ u8 in_pcm_width, out_pcm_width;
+
+ /* ...input/output stride size */
+ u8 in_stride, out_stride;
+
+ /* ...channel routing map between input and output */
+ u32 chan_routing;
+
+ /* ...data processing hook */
+ XA_ERRORCODE (*process)(struct XAPcmCodec *);
+
+ /* ...number of samples in input/output buffers */
+ u32 insize, outsize;
+
+ /* ...input/output memory indices */
+ u32 input_idx, output_idx;
+
+ /* ...input/output buffers passed from/to caller */
+ void *input, *output;
+
+ /* ...number of input bytes consumed/produced */
+ u32 consumed, produced;
+
+ /* ...debug - file handles */
+ int f_input, f_output;
+
+} XAPcmCodec;
+
+/*******************************************************************************
+ * Local execution flags
+ ******************************************************************************/
+
+#define XA_PCM_FLAG_PREINIT_DONE (1 << 0)
+#define XA_PCM_FLAG_POSTINIT_DONE (1 << 1)
+#define XA_PCM_FLAG_RUNNING (1 << 2)
+#define XA_PCM_FLAG_EOS (1 << 3)
+#define XA_PCM_FLAG_COMPLETE (1 << 4)
+
+/*******************************************************************************
+ * Local constants definitions
+ ******************************************************************************/
+
+/* ...process at most 1024 samples per call */
+#define XA_PCM_MAX_SAMPLES 1024
+
+/*******************************************************************************
+ * Internal processing functions
+ ******************************************************************************/
+
+/* ...identity translation of PCM16/24 */
+static XA_ERRORCODE xa_pcm_do_execute_copy(XAPcmCodec *d)
+{
+ u32 n = d->insize;
+ u8 k = d->in_channels;
+ u32 length = n * k * (d->in_pcm_width == 16 ? 2 : 4);
+ s16 *input = d->input, *output = d->output;
+
+ TRACE(PROCESS, _b("Copy PCM%d %p to %p (%u samples)"), d->in_pcm_width, input, output, n);
+
+ /* ...check if we have all data setup */
+ XF_CHK_ERR(input && n && output, XA_PCM_EXEC_FATAL_STATE);
+
+ /* ...copy the samples without any processing */
+ memcpy(output, input, length);
+
+ /* ...set number of consumed/produced bytes */
+ d->consumed = length;
+ d->produced = length;
+
+ /* ...reset input buffer length */
+ d->insize = 0;
+
+ /* ...copy input to output */
+ return XA_NO_ERROR;
+}
+
+/* ...data processing for PCM16, channel mapping case */
+static XA_ERRORCODE xa_pcm_do_execute_pcm16_chmap(XAPcmCodec *d)
+{
+ u32 n = d->insize, i;
+ u8 k = d->in_channels, j;
+ u32 chmap = d->chan_routing, map;
+ s16 *input = d->input, *output = d->output;
+ u32 length = n * k * (d->in_pcm_width == 16 ? 2 : 4);
+
+ TRACE(PROCESS, _b("Map PCM16 %p to %p (%u samples, map: %X)"), input, output, n, chmap);
+
+ /* ...check if we have all data setup */
+ XF_CHK_ERR(input && n && output, XA_PCM_EXEC_FATAL_STATE);
+
+#if 0
+ /* ...convert individual samples (that function could be CPU-optimized - tbd) */
+ for (i = 0; i < n; i++, input += k)
+ {
+ /* ...process individual channels in a sample */
+ for (j = 0, map = chmap; j < k; j++, map >>= 4)
+ {
+ u8 m = map & 0xF;
+
+ /* ...fill output channel (zero unused channel) */
+ *output++ = (m < 8 ? input[m] : 0);
+ }
+ }
+
+ /* ...set number of consumed/produced bytes */
+ d->consumed = (u32)((u8 *)input - (u8 *)d->input);
+ d->produced = (u32)((u8 *)output - (u8 *)d->output);
+#else
+ memcpy(output, input, length);
+ /* ...set number of consumed/produced bytes */
+ d->consumed = length;
+ d->produced = length;
+#endif
+ /* ...reset input buffer length */
+ d->insize = 0;
+
+ /* ...copy input to output */
+ return XA_NO_ERROR;
+}
+
+/* ...data processing for PCM24/PCM32, channel mapping case */
+static XA_ERRORCODE xa_pcm_do_execute_pcm24_chmap(XAPcmCodec *d)
+{
+ u32 n = d->insize, i;
+ u8 k = d->in_channels, j;
+ u32 chmap = d->chan_routing, map;
+ s32 *input = d->input, *output = d->output;
+
+ TRACE(PROCESS, _b("Map PCM24 %p to %p (%u samples, map: %X)"), input, output, n, chmap);
+
+ /* ...check if we have all data setup */
+ XF_CHK_ERR(input && n && output, XA_PCM_EXEC_FATAL_STATE);
+
+ /* ...convert individual samples (that function could be CPU-optimized - tbd) */
+ for (i = 0; i < n; i++, input += k)
+ {
+ /* ...process individual channels in a sample */
+ for (j = 0, map = chmap; j < k; j++, map >>= 4)
+ {
+ u8 m = map & 0xF;
+
+ /* ...fill output channel (zero unused channel) */
+ *output++ = (m < 8 ? input[m] : 0);
+ }
+ }
+
+ /* ...set number of consumed/produced bytes */
+ d->consumed = (u32)((u8 *)input - (u8 *)d->input);
+ d->produced = (u32)((u8 *)output - (u8 *)d->output);
+
+ /* ...reset input buffer length */
+ d->insize = 0;
+
+ /* ...copy input to output */
+ return XA_NO_ERROR;
+}
+
+/* ...convert multichannel 24-bit PCM to 16-bit PCM with channel mapping */
+static XA_ERRORCODE xa_pcm_do_execute_pcm24_to_pcm16(XAPcmCodec *d)
+{
+ u32 n = d->insize, i;
+ u8 k = d->in_channels, j;
+ u32 chmap = d->chan_routing, map;
+ s32 *input = d->input;
+ s16 *output = d->output;
+
+ TRACE(PROCESS, _b("Convert PCM24 %p to PCM16 %p (%u samples, map: %X)"), input, output, n, chmap);
+
+ /* ...check if we have all data setup */
+ XF_CHK_ERR(input && n && output, XA_PCM_EXEC_FATAL_STATE);
+
+ /* ...convert individual samples (that function could be CPU-optimized - tbd) */
+ for (i = 0; i < n; i++, input += k)
+ {
+ /* ...process individual channels in a sample */
+ for (j = 0, map = chmap; j < k; j++, map >>= 4)
+ {
+ u8 m = map & 0xF;
+
+ /* ...convert and zero out unused channels */
+ *output++ = (m < 8 ? input[m] >> 16 : 0);
+ }
+ }
+
+ /* ...set number of consumed/produced bytes */
+ d->consumed = (u32)((u8 *)input - (u8 *)d->input);
+ d->produced = (u32)((u8 *)output - (u8 *)d->output);
+
+ /* ...dump output data */
+ //BUG(write(d->f_input, d->input, d->consumed) != d->consumed, _x("%m"));
+ //BUG(write(d->f_output, d->output, d->produced) != d->produced, _x("%m"));
+
+ /* ...reset input buffer length (tbd - need that?) */
+ d->insize = 0;
+
+ /* ...copy input to output */
+ return XA_NO_ERROR;
+}
+
+/* ...convert multichannel 16-bit PCM to 24-bit PCM with channel mapping */
+static XA_ERRORCODE xa_pcm_do_execute_pcm16_to_pcm24(XAPcmCodec *d)
+{
+ u32 n = d->insize, i;
+ u8 k = d->in_channels, j;
+ u32 chmap = d->chan_routing, map;
+ s16 *input = d->input;
+ s32 *output = d->output;
+
+ TRACE(PROCESS, _b("Convert PCM16 %p to PCM24 %p (%u samples, map: %X)"), input, output, n, chmap);
+
+ /* ...check if we have all data setup */
+ XF_CHK_ERR(input && n && output, XA_PCM_EXEC_FATAL_STATE);
+
+ /* ...convert individual samples (that function could be CPU-optimized - tbd) */
+ for (i = 0; i < n; i++, input += k)
+ {
+ /* ...process individual channels in a sample */
+ for (j = 0, map = chmap; j < k; j++, map >>= 4)
+ {
+ u8 m = map & 0xF;
+
+ /* ...convert and zero out unused channels */
+ *output++ = (m < 8 ? input[m] << 16 : 0);
+ }
+ }
+
+ /* ...set number of consumed/produced bytes */
+ d->consumed = (u32)((u8 *)input - (u8 *)d->input);
+ d->produced = (u32)((u8 *)output - (u8 *)d->output);
+
+ /* ...reset input buffer length (tbd - need that?) */
+ d->insize = 0;
+
+ /* ...copy input to output */
+ return XA_NO_ERROR;
+}
+
+/* ...determine if we need to do a channel routing */
+static inline int xa_pcm_is_identity_mapping(u32 chmap, u8 k)
+{
+ u8 j;
+
+ for (j = 0; j < k; j++, chmap >>= 4)
+ if ((chmap & 0xF) != j)
+ return 0;
+
+ return 1;
+}
+
+/* ...runtime initialization */
+static inline XA_ERRORCODE xa_pcm_do_runtime_init(XAPcmCodec *d)
+{
+ u8 in_width = d->in_pcm_width, out_width = d->out_pcm_width;
+ u8 in_ch = d->in_channels, out_ch = d->out_channels;
+ u32 chmap = d->chan_routing;
+
+ /* ...check for supported processing schemes */
+ if (in_width == out_width)
+ {
+ /* ...check if we need to do a channel mapping */
+ if (in_ch != out_ch || !xa_pcm_is_identity_mapping(chmap, in_ch))
+ {
+ /* ...mapping is needed */
+ d->process = (in_width == 16 ? xa_pcm_do_execute_pcm16_chmap : xa_pcm_do_execute_pcm24_chmap);
+ }
+ else
+ {
+ /* ...setup identity translation */
+ d->process = xa_pcm_do_execute_copy;
+ }
+ }
+ else
+ {
+ /* ...samples converion is required */
+ d->process = (in_width == 16 ? xa_pcm_do_execute_pcm16_to_pcm24 : xa_pcm_do_execute_pcm24_to_pcm16);
+ }
+
+ /* ...mark the runtime initialization is completed */
+ d->state = XA_PCM_FLAG_PREINIT_DONE | XA_PCM_FLAG_POSTINIT_DONE | XA_PCM_FLAG_RUNNING;
+
+ TRACE(INIT, _b("PCM format converter initialized: PCM%u -> PCM%u, ich=%u, och=%u, map=%X"), in_width, out_width, in_ch, out_ch, chmap);
+
+ return XA_NO_ERROR;
+}
+
+/*******************************************************************************
+ * Commands processing
+ ******************************************************************************/
+
+/* ...standard codec initialization routine */
+static XA_ERRORCODE xa_pcm_get_api_size(XAPcmCodec *d, WORD32 i_idx, pVOID pv_value)
+{
+ /* ...return API structure size */
+ *(WORD32 *)pv_value = sizeof(*d);
+
+ return XA_NO_ERROR;
+}
+
+/* ...standard codec initialization routine */
+static XA_ERRORCODE xa_pcm_init(XAPcmCodec *d, WORD32 i_idx, pVOID pv_value)
+{
+ /* ...validity check */
+ XF_CHK_ERR(d, XA_API_FATAL_INVALID_CMD_TYPE);
+
+ /* ...process particular initialization type */
+ switch (i_idx)
+ {
+ case XA_CMD_TYPE_INIT_API_PRE_CONFIG_PARAMS:
+ {
+ /* ...pre-configuration initialization; reset internal data */
+ memset(d, 0, sizeof(*d));
+
+ /* ...set default parameters */
+ d->in_pcm_width = d->out_pcm_width = 16;
+ d->in_channels = d->out_channels = 2;
+ d->chan_routing = (0 << 0) | (1 << 1);
+ d->sample_rate = 48000;
+
+ /* ...open debug files */
+ //BUG((d->f_input = open("pcm-in.dat", O_WRONLY | O_CREAT, 0664)) < 0, _x("%m"));
+ //BUG((d->f_output = open("pcm-out.dat", O_WRONLY | O_CREAT, 0664)) < 0, _x("%m"));
+
+ /* ...mark pre-initialization is done */
+ d->state = XA_PCM_FLAG_PREINIT_DONE;
+
+ return XA_NO_ERROR;
+ }
+
+ case XA_CMD_TYPE_INIT_API_POST_CONFIG_PARAMS:
+ {
+ /* ...post-configuration initialization (all parameters are set) */
+ XF_CHK_ERR(d->state & XA_PCM_FLAG_PREINIT_DONE, XA_API_FATAL_INVALID_CMD_TYPE);
+
+ /* ...calculate input sample stride size */
+ d->in_stride = d->in_channels * (d->in_pcm_width == 16 ? 2 : 4);
+ d->out_stride = d->out_channels * (d->out_pcm_width == 16 ? 2 : 4);
+
+ /* ...mark post-initialization is complete */
+ d->state |= XA_PCM_FLAG_POSTINIT_DONE;
+
+ return XA_NO_ERROR;
+ }
+
+ case XA_CMD_TYPE_INIT_PROCESS:
+ {
+ /* ...run-time initialization process; make sure post-init is complete */
+ XF_CHK_ERR(d->state & XA_PCM_FLAG_POSTINIT_DONE, XA_API_FATAL_INVALID_CMD_TYPE);
+
+ /* ...initialize runtime for specified transformation function */
+ return xa_pcm_do_runtime_init(d);
+ }
+
+ case XA_CMD_TYPE_INIT_DONE_QUERY:
+ {
+ /* ...check for runtime initialization completion; maske usre post-init is complete */
+ XF_CHK_ERR(d->state & XA_PCM_FLAG_POSTINIT_DONE, XA_API_FATAL_INVALID_CMD_TYPE);
+
+ /* ...put current status */
+ *(WORD32 *)pv_value = (d->state & XA_PCM_FLAG_RUNNING ? 1 : 0);
+
+ return XA_NO_ERROR;
+ }
+
+ default:
+ /* ...unrecognized command */
+ return XF_CHK_ERR(0, XA_API_FATAL_INVALID_CMD_TYPE);
+ }
+}
+
+/* ...set configuration parameter */
+static XA_ERRORCODE xa_pcm_set_config_param(XAPcmCodec *d, WORD32 i_idx, pVOID pv_value)
+{
+ WORD32 i_value;
+
+ /* ...validity check */
+ XF_CHK_ERR(d && pv_value, XA_API_FATAL_INVALID_CMD_TYPE);
+
+ /* ...configuration is allowed only in PRE-CONFIG state */
+ XF_CHK_ERR(d->state == XA_PCM_FLAG_PREINIT_DONE, XA_PCM_CONFIG_NONFATAL_STATE);
+
+ /* ...get integer parameter value */
+ i_value = *(WORD32 *)pv_value;
+
+ /* ...process individual configuration parameter */
+ switch (i_idx)
+ {
+ case XA_CODEC_CONFIG_PARAM_SAMPLE_RATE:
+ case XA_PCM_CONFIG_PARAM_SAMPLE_RATE:
+ /* ...accept any sampling rate */
+ d->sample_rate = (u32)i_value;
+ return XA_NO_ERROR;
+
+ case XA_PCM_CONFIG_PARAM_IN_PCM_WIDTH:
+ /* ...return input sample bit-width */
+ XF_CHK_ERR(i_value == 16 || i_value == 24, XA_PCM_CONFIG_NONFATAL_RANGE);
+ d->in_pcm_width = (u8)i_value;
+ return XA_NO_ERROR;
+
+ case XA_PCM_CONFIG_PARAM_IN_CHANNELS:
+ /* ...support at most 8-channels stream */
+ XF_CHK_ERR(i_value > 0 && i_value <= 8, XA_PCM_CONFIG_NONFATAL_RANGE);
+ d->in_channels = (u8)i_value;
+ return XA_NO_ERROR;
+
+ case XA_CODEC_CONFIG_PARAM_PCM_WIDTH:
+ case XA_PCM_CONFIG_PARAM_OUT_PCM_WIDTH:
+ /* ...we only support PCM16 and PCM24 */
+ XF_CHK_ERR(i_value == 16 || i_value == 24, XA_PCM_CONFIG_NONFATAL_RANGE);
+ d->out_pcm_width = (u8)i_value;
+ return XA_NO_ERROR;
+
+ case XA_CODEC_CONFIG_PARAM_CHANNELS:
+ case XA_PCM_CONFIG_PARAM_OUT_CHANNELS:
+ /* ...support at most 8-channels stream */
+ XF_CHK_ERR(i_value > 0 && i_value <= 8, XA_API_FATAL_INVALID_CMD_TYPE);
+ d->out_channels = (u8)i_value;
+ return XA_NO_ERROR;
+
+ case XA_PCM_CONFIG_PARAM_CHANROUTING:
+ /* ...accept any channel routing mask */
+ d->chan_routing = (u32)i_value;
+ return XA_NO_ERROR;
+
+ default:
+ /* ...unrecognized parameter */
+ return XF_CHK_ERR(0, XA_API_FATAL_INVALID_CMD_TYPE);
+ }
+}
+
+/* ...retrieve configuration parameter */
+static XA_ERRORCODE xa_pcm_get_config_param(XAPcmCodec *d, WORD32 i_idx, pVOID pv_value)
+{
+ /* ...validity check */
+ XF_CHK_ERR(d && pv_value, XA_API_FATAL_INVALID_CMD_TYPE);
+
+ /* ...make sure pre-configuration is completed */
+ XF_CHK_ERR(d->state & XA_PCM_FLAG_PREINIT_DONE, XA_PCM_CONFIG_NONFATAL_STATE);
+
+ /* ...process individual parameter */
+ switch (i_idx)
+ {
+ case XA_CODEC_CONFIG_PARAM_SAMPLE_RATE:
+ case XA_PCM_CONFIG_PARAM_SAMPLE_RATE:
+ /* ...return output sampling frequency */
+ *(WORD32 *)pv_value = d->sample_rate;
+ return XA_NO_ERROR;
+
+ case XA_PCM_CONFIG_PARAM_IN_PCM_WIDTH:
+ /* ...return input sample bit-width */
+ *(WORD32 *)pv_value = d->in_pcm_width;
+ return XA_NO_ERROR;
+
+ case XA_PCM_CONFIG_PARAM_IN_CHANNELS:
+ /* ...return number of input channels */
+ *(WORD32 *)pv_value = d->in_channels;
+ return XA_NO_ERROR;
+
+ case XA_CODEC_CONFIG_PARAM_PCM_WIDTH:
+ case XA_PCM_CONFIG_PARAM_OUT_PCM_WIDTH:
+ /* ...return output sample bit-width */
+ *(WORD32 *)pv_value = d->out_pcm_width;
+ return XA_NO_ERROR;
+
+ case XA_CODEC_CONFIG_PARAM_CHANNELS:
+ case XA_PCM_CONFIG_PARAM_OUT_CHANNELS:
+ /* ...return number of output channels */
+ *(WORD32 *)pv_value = d->out_channels;
+ return XA_NO_ERROR;
+
+ case XA_PCM_CONFIG_PARAM_CHANROUTING:
+ /* ...return current channel routing mask */
+ *(WORD32 *)pv_value = d->chan_routing;
+ return XA_NO_ERROR;
+
+ default:
+ /* ...unrecognized parameter */
+ return XF_CHK_ERR(0, XA_API_FATAL_INVALID_CMD_TYPE);
+ }
+}
+
+/* ...execution command */
+static XA_ERRORCODE xa_pcm_execute(XAPcmCodec *d, WORD32 i_idx, pVOID pv_value)
+{
+ /* ...basic validity check */
+ XF_CHK_ERR(d, XA_API_FATAL_INVALID_CMD_TYPE);
+
+ /* ...codec must be in running state */
+ XF_CHK_ERR(d->state & XA_PCM_FLAG_RUNNING, XA_API_FATAL_INVALID_CMD_TYPE);
+
+ /* ...process individual command type */
+ switch (i_idx)
+ {
+ case XA_CMD_TYPE_DO_EXECUTE:
+ /* ...do data processing (tbd - result code is bad) */
+ if (d->insize != 0)
+ {
+ XF_CHK_ERR(!XA_ERROR_SEVERITY(d->process(d)), XA_PCM_EXEC_FATAL_STATE);
+ }
+
+ /* ...process end-of-stream condition */
+ (d->state & XA_PCM_FLAG_EOS ? d->state ^= XA_PCM_FLAG_EOS | XA_PCM_FLAG_COMPLETE : 0);
+
+ return XA_NO_ERROR;
+
+ case XA_CMD_TYPE_DONE_QUERY:
+ /* ...check if processing is complete */
+ XF_CHK_ERR(pv_value, XA_API_FATAL_INVALID_CMD_TYPE);
+
+ /* ...return completion status */
+ *(WORD32 *)pv_value = (d->state & XA_PCM_FLAG_COMPLETE ? 1 : 0);
+
+ return XA_NO_ERROR;
+
+ case XA_CMD_TYPE_DO_RUNTIME_INIT:
+ /* ...reset codec operation */
+ return xa_pcm_do_runtime_init(d);
+
+ default:
+ /* ...unrecognized command */
+ return XF_CHK_ERR(0, XA_API_FATAL_INVALID_CMD_TYPE);
+ }
+}
+
+/* ...set number of input bytes */
+static XA_ERRORCODE xa_pcm_set_input_bytes(XAPcmCodec *d, WORD32 i_idx, pVOID pv_value)
+{
+ u32 in_stride = d->in_stride;
+ u32 insize;
+
+ /* ...validity check */
+ XF_CHK_ERR(d && pv_value, XA_API_FATAL_INVALID_CMD_TYPE);
+
+ /* ...track index must be valid */
+ XF_CHK_ERR(i_idx == 0, XA_API_FATAL_INVALID_CMD_TYPE);
+
+ /* ...component must be initialized */
+ XF_CHK_ERR(d->state & XA_PCM_FLAG_POSTINIT_DONE, XA_API_FATAL_INVALID_CMD_TYPE);
+
+ /* ...input buffer must exist */
+ XF_CHK_ERR(d->input, XA_API_FATAL_INVALID_CMD_TYPE);
+
+ /* ...convert bytes into samples (don't like division, but still...) */
+ insize = *(WORD32 *)pv_value / in_stride;
+
+ /* ...make sure we have integral amount of samples */
+ XF_CHK_ERR(*(WORD32 *)pv_value == insize * in_stride, XA_API_FATAL_INVALID_CMD_TYPE);
+
+ /* ...limit input buffer size to maximal value*/
+ d->insize = (insize > XA_PCM_MAX_SAMPLES ? XA_PCM_MAX_SAMPLES : insize);
+
+ return XA_NO_ERROR;
+}
+
+/* ...get number of output bytes produced */
+static XA_ERRORCODE xa_pcm_get_output_bytes(XAPcmCodec *d, WORD32 i_idx, pVOID pv_value)
+{
+ /* ...validity check */
+ XF_CHK_ERR(d && pv_value, XA_API_FATAL_INVALID_CMD_TYPE);
+
+ /* ...buffer index must be valid */
+ XF_CHK_ERR(i_idx == 1, XA_API_FATAL_INVALID_CMD_TYPE);
+
+ /* ...component must be initialized */
+ XF_CHK_ERR(d->state & XA_PCM_FLAG_POSTINIT_DONE, XA_API_FATAL_INVALID_CMD_TYPE);
+
+ /* ...output buffer must exist */
+ XF_CHK_ERR(d->output, XA_API_FATAL_INVALID_CMD_TYPE);
+
+ /* ...return number of produced bytes (and reset instantly? - tbd) */
+ *(WORD32 *)pv_value = d->produced;
+
+ return XA_NO_ERROR;
+}
+
+/* ...get number of consumed bytes */
+static XA_ERRORCODE xa_pcm_get_curidx_input_buf(XAPcmCodec *d, WORD32 i_idx, pVOID pv_value)
+{
+ /* ...validity check */
+ XF_CHK_ERR(d && pv_value, XA_API_FATAL_INVALID_CMD_TYPE);
+
+ /* ...index must be valid */
+ XF_CHK_ERR(i_idx == 0, XA_API_FATAL_INVALID_CMD_TYPE);
+
+ /* ...input buffer must exist */
+ XF_CHK_ERR(d->input, XA_PCM_EXEC_NONFATAL_INPUT);
+
+ /* ...return number of bytes consumed */
+ *(WORD32 *)pv_value = d->consumed;
+
+ return XA_NO_ERROR;
+}
+
+/* ...end-of-stream processing */
+static XA_ERRORCODE xa_pcm_input_over(XAPcmCodec *d, WORD32 i_idx, pVOID pv_value)
+{
+ /* ...validity check */
+ XF_CHK_ERR(d, XA_API_FATAL_INVALID_CMD_TYPE);
+
+ /* ...put end-of-stream flag */
+ d->state |= XA_PCM_FLAG_EOS;
+
+ TRACE(PROCESS, _b("Input-over-condition signalled"));
+
+ return XA_NO_ERROR;
+}
+
+/* ..get total amount of data for memory tables */
+static XA_ERRORCODE xa_pcm_get_memtabs_size(XAPcmCodec *d, WORD32 i_idx, pVOID pv_value)
+{
+ /* ...basic validity checks */
+ XF_CHK_ERR(d && pv_value, XA_API_FATAL_INVALID_CMD_TYPE);
+
+ /* ...check mixer is pre-initialized */
+ XF_CHK_ERR(d->state & XA_PCM_FLAG_PREINIT_DONE, XA_API_FATAL_INVALID_CMD_TYPE);
+
+ /* ...we have all our tables inside API structure */
+ *(WORD32 *)pv_value = 0;
+
+ return XA_NO_ERROR;
+}
+
+/* ...return total amount of memory buffers */
+static XA_ERRORCODE xa_pcm_get_n_memtabs(XAPcmCodec *d, WORD32 i_idx, pVOID pv_value)
+{
+ /* ...basic validity checks */
+ XF_CHK_ERR(d && pv_value, XA_API_FATAL_INVALID_CMD_TYPE);
+
+ /* ...we have 1 input buffer and 1 output buffer */
+ *(WORD32 *)pv_value = 1 + 1;
+
+ return XA_NO_ERROR;
+}
+
+/* ...return memory type data */
+static XA_ERRORCODE xa_pcm_get_mem_info_type(XAPcmCodec *d, WORD32 i_idx, pVOID pv_value)
+{
+ /* ...basic validity check */
+ XF_CHK_ERR(d && pv_value, XA_API_FATAL_INVALID_CMD_TYPE);
+
+ /* ...codec must be in post-init state */
+ XF_CHK_ERR(d->state & XA_PCM_FLAG_POSTINIT_DONE, XA_API_FATAL_INVALID_CMD_TYPE);
+
+ /* ...check buffer type */
+ switch (i_idx)
+ {
+ case 0:
+ *(WORD32 *)pv_value = XA_MEMTYPE_INPUT;
+ return XA_NO_ERROR;
+
+ case 1:
+ *(WORD32 *)pv_value = XA_MEMTYPE_OUTPUT;
+ return XA_NO_ERROR;
+
+ default:
+ return XF_CHK_ERR(0, XA_API_FATAL_INVALID_CMD_TYPE);
+ }
+}
+
+/* ...return memory buffer size */
+static XA_ERRORCODE xa_pcm_get_mem_info_size(XAPcmCodec *d, WORD32 i_idx, pVOID pv_value)
+{
+ /* ...basic validity check */
+ XF_CHK_ERR(d && pv_value, XA_API_FATAL_INVALID_CMD_TYPE);
+
+ /* ...codec must be in post-init state */
+ XF_CHK_ERR(d->state & XA_PCM_FLAG_POSTINIT_DONE, XA_API_FATAL_INVALID_CMD_TYPE);
+
+ /* ...determine particular buffer */
+ switch (i_idx)
+ {
+ case 0:
+ /* ...input buffer size can be any */
+ *(WORD32 *)pv_value = 0;
+ return XA_NO_ERROR;
+
+ case 1:
+ /* ...output buffer size is dependent on stride */
+ *(WORD32 *)pv_value = XA_PCM_MAX_SAMPLES * d->out_stride;
+ return XA_NO_ERROR;
+
+ default:
+ /* ...invalid buffer index */
+ return XF_CHK_ERR(0, XA_API_FATAL_INVALID_CMD_TYPE);
+ }
+}
+
+/* ...return memory alignment data */
+static XA_ERRORCODE xa_pcm_get_mem_info_alignment(XAPcmCodec *d, WORD32 i_idx, pVOID pv_value)
+{
+ /* ...basic validity check */
+ XF_CHK_ERR(d && pv_value, XA_API_FATAL_INVALID_CMD_TYPE);
+
+ /* ...codec must be in post-initialization state */
+ XF_CHK_ERR(d->state & XA_PCM_FLAG_POSTINIT_DONE, XA_API_FATAL_INVALID_CMD_TYPE);
+
+ /* ...all buffers are 4-bytes aligned */
+ *(WORD32 *)pv_value = 4;
+
+ return XA_NO_ERROR;
+}
+
+/* ...set memory pointer */
+static XA_ERRORCODE xa_pcm_set_mem_ptr(XAPcmCodec *d, WORD32 i_idx, pVOID pv_value)
+{
+ /* ...basic validity check */
+ XF_CHK_ERR(d, XA_API_FATAL_INVALID_CMD_TYPE);
+ XF_CHK_ERR(pv_value, XA_API_FATAL_INVALID_CMD_TYPE);
+
+ /* ...codec must be in post-initialized state */
+ XF_CHK_ERR(d->state & XA_PCM_FLAG_POSTINIT_DONE, XA_API_FATAL_INVALID_CMD_TYPE);
+
+ /* ...select memory buffer */
+ switch (i_idx)
+ {
+ case 0:
+ /* ...input buffer */
+ d->input = pv_value;
+ return XA_NO_ERROR;
+
+ case 1:
+ /* ...output buffer */
+ d->output = pv_value;
+ return XA_NO_ERROR;
+
+ default:
+ /* ...invalid index */
+ return XF_CHK_ERR(0, XA_API_FATAL_INVALID_CMD_TYPE);
+ }
+}
+
+/*******************************************************************************
+ * API command hooks
+ ******************************************************************************/
+
+static XA_ERRORCODE (* const xa_pcm_api[])(XAPcmCodec *, WORD32, pVOID) =
+{
+ [XA_API_CMD_GET_API_SIZE] = xa_pcm_get_api_size,
+
+ [XA_API_CMD_INIT] = xa_pcm_init,
+ [XA_API_CMD_SET_CONFIG_PARAM] = xa_pcm_set_config_param,
+ [XA_API_CMD_GET_CONFIG_PARAM] = xa_pcm_get_config_param,
+
+ [XA_API_CMD_EXECUTE] = xa_pcm_execute,
+ [XA_API_CMD_SET_INPUT_BYTES] = xa_pcm_set_input_bytes,
+ [XA_API_CMD_GET_OUTPUT_BYTES] = xa_pcm_get_output_bytes,
+ [XA_API_CMD_GET_CURIDX_INPUT_BUF] = xa_pcm_get_curidx_input_buf,
+ [XA_API_CMD_INPUT_OVER] = xa_pcm_input_over,
+
+ [XA_API_CMD_GET_MEMTABS_SIZE] = xa_pcm_get_memtabs_size,
+ [XA_API_CMD_GET_N_MEMTABS] = xa_pcm_get_n_memtabs,
+ [XA_API_CMD_GET_MEM_INFO_TYPE] = xa_pcm_get_mem_info_type,
+ [XA_API_CMD_GET_MEM_INFO_SIZE] = xa_pcm_get_mem_info_size,
+ [XA_API_CMD_GET_MEM_INFO_ALIGNMENT] = xa_pcm_get_mem_info_alignment,
+ [XA_API_CMD_SET_MEM_PTR] = xa_pcm_set_mem_ptr,
+};
+
+/* ...total numer of commands supported */
+#define XA_PCM_API_COMMANDS_NUM (sizeof(xa_pcm_api) / sizeof(xa_pcm_api[0]))
+
+/*******************************************************************************
+ * API entry point
+ ******************************************************************************/
+
+XA_ERRORCODE xa_pcm_codec(xa_codec_handle_t p_xa_module_obj, WORD32 i_cmd, WORD32 i_idx, pVOID pv_value)
+{
+ XAPcmCodec *d = (XAPcmCodec *) p_xa_module_obj;
+
+ /* ...check if command index is valid */
+ XF_CHK_ERR(i_cmd < XA_PCM_API_COMMANDS_NUM, XA_API_FATAL_INVALID_CMD);
+
+ /* ...see if command is defined */
+ XF_CHK_ERR(xa_pcm_api[i_cmd], XA_API_FATAL_INVALID_CMD);
+
+ /* ...execute requested command */
+ return xa_pcm_api[i_cmd](d, i_idx, pv_value);
+}
diff --git a/hifi/xaf/hifi-dpf/plugins/cadence/vorbis_dec/lib/hifi3/xa_vorbis_dec.a b/hifi/xaf/hifi-dpf/plugins/cadence/vorbis_dec/lib/hifi3/xa_vorbis_dec.a
new file mode 100644
index 00000000..cb284459
--- /dev/null
+++ b/hifi/xaf/hifi-dpf/plugins/cadence/vorbis_dec/lib/hifi3/xa_vorbis_dec.a
Binary files differ
diff --git a/hifi/xaf/hifi-dpf/plugins/cadence/vorbis_dec/xa-vorbis-decoder.c b/hifi/xaf/hifi-dpf/plugins/cadence/vorbis_dec/xa-vorbis-decoder.c
new file mode 100644
index 00000000..43220ef3
--- /dev/null
+++ b/hifi/xaf/hifi-dpf/plugins/cadence/vorbis_dec/xa-vorbis-decoder.c
@@ -0,0 +1,84 @@
+/*******************************************************************************
+* Copyright (C) 2018 Cadence Design Systems, Inc.
+*
+* Permission is hereby granted, free of charge, to any person obtaining
+* a copy of this software and associated documentation files (the
+* "Software"), to use this Software with Cadence processor cores only and
+* not with any other processors and platforms, subject to
+* the following conditions:
+*
+* The above copyright notice and this permission notice 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.
+
+******************************************************************************/
+
+/*******************************************************************************
+ * xa-vorbis-decoder.c
+ *
+ * VORBIS decoder plugin - thin wrapper around VORBISDEC library
+ *
+ ******************************************************************************/
+
+#define MODULE_TAG VORBISDEC
+
+/*******************************************************************************
+ * Includes
+ ******************************************************************************/
+
+#include "xf-plugin.h"
+#include "audio/xa-audio-decoder-api.h"
+#include "xa_vorbis_dec_api.h"
+
+/*******************************************************************************
+ * Override GET-CONFIG-PARAM function
+ ******************************************************************************/
+
+static inline XA_ERRORCODE xa_vorbis_get_config_param(xa_codec_handle_t handle, WORD32 i_idx, pVOID pv_value)
+{
+ /* ...translate "standard" parameter index into internal value */
+ switch (i_idx)
+ {
+ case XA_CODEC_CONFIG_PARAM_CHANNELS:
+ /* ...return number of output channels */
+ i_idx = XA_VORBISDEC_CONFIG_PARAM_NUM_CHANNELS;
+ break;
+
+ case XA_CODEC_CONFIG_PARAM_SAMPLE_RATE:
+ /* ...return output sampling frequency */
+ i_idx = XA_VORBISDEC_CONFIG_PARAM_SAMP_FREQ;
+ break;
+
+ case XA_CODEC_CONFIG_PARAM_PCM_WIDTH:
+ /* ...return sample bit-width */
+ i_idx = XA_VORBISDEC_CONFIG_PARAM_PCM_WDSZ;
+ break;
+ }
+
+ /* ...pass to library */
+ return xa_vorbis_dec(handle, XA_API_CMD_GET_CONFIG_PARAM, i_idx, pv_value);
+}
+
+/*******************************************************************************
+ * API entry point
+ ******************************************************************************/
+
+XA_ERRORCODE xa_vorbis_decoder(xa_codec_handle_t p_xa_module_obj, WORD32 i_cmd, WORD32 i_idx, pVOID pv_value)
+{
+ /* ...process common audio-decoder commands */
+ if (i_cmd == XA_API_CMD_GET_CONFIG_PARAM)
+ {
+ return xa_vorbis_get_config_param(p_xa_module_obj, i_idx, pv_value);
+ }
+ else
+ {
+ return xa_vorbis_dec(p_xa_module_obj, i_cmd, i_idx, pv_value);
+ }
+}
diff --git a/hifi/xaf/hifi-dpf/plugins/cadence/vorbis_dec/xa_vorbis_dec_api.h b/hifi/xaf/hifi-dpf/plugins/cadence/vorbis_dec/xa_vorbis_dec_api.h
new file mode 100644
index 00000000..f99660f8
--- /dev/null
+++ b/hifi/xaf/hifi-dpf/plugins/cadence/vorbis_dec/xa_vorbis_dec_api.h
@@ -0,0 +1,121 @@
+/*******************************************************************************
+* Copyright (C) 2018 Cadence Design Systems, Inc.
+*
+* Permission is hereby granted, free of charge, to any person obtaining
+* a copy of this software and associated documentation files (the
+* "Software"), to use this Software with Cadence processor cores only and
+* not with any other processors and platforms, subject to
+* the following conditions:
+*
+* The above copyright notice and this permission notice 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.
+
+******************************************************************************/
+/*******************************************************************************
+*
+* NOTE, ANY CHANGES TO THIS FILE MAY AFFECT UNDERLYING AUDIO / SPEECH CODEC
+* LIBRARY COMPONENT FROM CADENCE DESIGN SYSTEMS, INC.
+*
+******************************************************************************/
+
+
+
+#ifndef __XA_VORBIS_DEC_API_H__
+#define __XA_VORBIS_DEC_API_H__
+
+#include <xa_memory_standards.h>
+
+/* vorbis_dec-specific configuration parameters */
+enum xa_config_param_vorbis_dec
+{
+ XA_VORBISDEC_CONFIG_PARAM_SAMP_FREQ = 0,
+ XA_VORBISDEC_CONFIG_PARAM_NUM_CHANNELS = 1,
+ XA_VORBISDEC_CONFIG_PARAM_PCM_WDSZ = 2,
+ XA_VORBISDEC_CONFIG_PARAM_COMMENT_MEM_PTR = 3,
+ XA_VORBISDEC_CONFIG_PARAM_COMMENT_MEM_SIZE = 4,
+ XA_VORBISDEC_CONFIG_PARAM_GET_CUR_BITRATE = 5,
+ XA_VORBISDEC_CONFIG_PARAM_RAW_VORBIS_FILE_MODE = 6,
+ XA_VORBISDEC_CONFIG_PARAM_RAW_VORBIS_LAST_PKT_GRANULE_POS = 7,
+ XA_VORBISDEC_CONFIG_PARAM_OGG_MAX_PAGE_SIZE = 8,
+ XA_VORBISDEC_CONFIG_PARAM_RUNTIME_MEM = 9
+};
+
+/* commands */
+#include <xa_apicmd_standards.h>
+
+/* vorbis_dec-specific command types */
+/* (none) */
+
+/* error codes */
+#include <xa_error_standards.h>
+#define XA_CODEC_VORBIS_DEC 7
+
+/* vorbis_dec-specific error codes */
+
+/*****************************************************************************/
+/* Class 1: Configuration Errors */
+/*****************************************************************************/
+/* Nonfatal Errors */
+enum xa_error_nonfatal_config_vorbis_dec
+{
+ XA_VORBISDEC_CONFIG_NONFATAL_GROUPED_STREAM = XA_ERROR_CODE(xa_severity_nonfatal, xa_class_config, XA_CODEC_VORBIS_DEC, 0),
+ XA_VORBISDEC_CONFIG_NONFATAL_BAD_PARAM = XA_ERROR_CODE(xa_severity_nonfatal, xa_class_config, XA_CODEC_VORBIS_DEC, 1)
+};
+
+/* Fatal Errors */
+enum xa_error_fatal_config_vorbis_dec
+{
+ XA_VORBISDEC_CONFIG_FATAL_BADHDR = XA_ERROR_CODE(xa_severity_fatal, xa_class_config, XA_CODEC_VORBIS_DEC, 0),
+ XA_VORBISDEC_CONFIG_FATAL_NOTVORBIS = XA_ERROR_CODE(xa_severity_fatal, xa_class_config, XA_CODEC_VORBIS_DEC, 1),
+ XA_VORBISDEC_CONFIG_FATAL_BADINFO = XA_ERROR_CODE(xa_severity_fatal, xa_class_config, XA_CODEC_VORBIS_DEC, 2),
+ XA_VORBISDEC_CONFIG_FATAL_BADVERSION = XA_ERROR_CODE(xa_severity_fatal, xa_class_config, XA_CODEC_VORBIS_DEC, 3),
+ XA_VORBISDEC_CONFIG_FATAL_BADBOOKS = XA_ERROR_CODE(xa_severity_fatal, xa_class_config, XA_CODEC_VORBIS_DEC, 4),
+ XA_VORBISDEC_CONFIG_FATAL_CODEBOOK_DECODE = XA_ERROR_CODE(xa_severity_fatal, xa_class_config, XA_CODEC_VORBIS_DEC, 5),
+ XA_VORBISDEC_CONFIG_FATAL_INVALID_PARAM = XA_ERROR_CODE(xa_severity_fatal, xa_class_config, XA_CODEC_VORBIS_DEC, 6)
+};
+
+/*****************************************************************************/
+/* Class 2: Execution Errors */
+/*****************************************************************************/
+/* Nonfatal Errors */
+enum xa_error_nonfatal_execute_vorbis_dec
+{
+ XA_VORBISDEC_EXECUTE_NONFATAL_OV_HOLE = XA_ERROR_CODE(xa_severity_nonfatal, xa_class_execute, XA_CODEC_VORBIS_DEC, 0),
+ XA_VORBISDEC_EXECUTE_NONFATAL_OV_NOTAUDIO = XA_ERROR_CODE(xa_severity_nonfatal, xa_class_execute, XA_CODEC_VORBIS_DEC, 1),
+ XA_VORBISDEC_EXECUTE_NONFATAL_OV_BADPACKET = XA_ERROR_CODE(xa_severity_nonfatal, xa_class_execute, XA_CODEC_VORBIS_DEC, 2),
+ XA_VORBISDEC_EXECUTE_NONFATAL_OV_RUNTIME_DECODE_FLUSH_IN_PROGRESS = XA_ERROR_CODE(xa_severity_nonfatal, xa_class_execute, XA_CODEC_VORBIS_DEC, 3),
+ XA_VORBISDEC_EXECUTE_NONFATAL_OV_INVALID_STRM_POS = XA_ERROR_CODE(xa_severity_nonfatal, xa_class_execute, XA_CODEC_VORBIS_DEC, 4),
+ XA_VORBISDEC_EXECUTE_NONFATAL_OV_INSUFFICIENT_DATA = XA_ERROR_CODE(xa_severity_nonfatal, xa_class_execute, XA_CODEC_VORBIS_DEC, 5),
+ XA_VORBISDEC_EXECUTE_NONFATAL_OV_UNEXPECTED_IDENT_PKT_RECEIVED = XA_ERROR_CODE(xa_severity_nonfatal, xa_class_execute, XA_CODEC_VORBIS_DEC, 6),
+ XA_VORBISDEC_EXECUTE_NONFATAL_OV_UNEXPECTED_HEADER_PKT_RECEIVED = XA_ERROR_CODE(xa_severity_nonfatal, xa_class_execute, XA_CODEC_VORBIS_DEC, 7)
+};
+/* Fatal Errors */
+enum xa_error_fatal_execute_vorbis_dec
+{
+ XA_VORBISDEC_EXECUTE_FATAL_PERSIST_ALLOC = XA_ERROR_CODE(xa_severity_fatal, xa_class_execute, XA_CODEC_VORBIS_DEC, 0),
+ XA_VORBISDEC_EXECUTE_FATAL_SCRATCH_ALLOC = XA_ERROR_CODE(xa_severity_fatal, xa_class_execute, XA_CODEC_VORBIS_DEC, 1),
+ XA_VORBISDEC_EXECUTE_FATAL_CORRUPT_STREAM = XA_ERROR_CODE(xa_severity_fatal, xa_class_execute, XA_CODEC_VORBIS_DEC, 2),
+ XA_VORBISDEC_EXECUTE_FATAL_INSUFFICIENT_INP_BUF_SIZE = XA_ERROR_CODE(xa_severity_fatal, xa_class_execute, XA_CODEC_VORBIS_DEC, 3)
+};
+
+#include "xa_type_def.h"
+
+#ifdef __cplusplus
+ extern "C" {
+#endif /* __cplusplus */
+
+ xa_codec_func_t xa_vorbis_dec;
+
+#ifdef __cplusplus
+ }
+#endif /* __cplusplus */
+
+#endif /* __XA_VORBIS_DEC_API_H__ */
generated by cgit v1.2.3 (git 2.25.1) at 2024-06-23 16:52:57 +0000