hikey960: Remove hifi dsp support.

The hifi dsp support wasn't frequently used nor enabled by
default. Since we are moving binary firmware objects to the
vendor package, just remove the hifi dsp logic and firmware
all together.

This patch reapplies the reverted patch of the same name,
as issues were seen when the vendor package was missing.

Signed-off-by: John Stultz <john.stultz@linaro.org>
Change-Id: I6d72e5ca52a4b1b0ca460e0c4613c09175dba02d

1 files changed, 0 insertions, 870 deletions

diff --git a/hifi/xaf/hifi-dpf/audio/xa-class-mixer.c b/hifi/xaf/hifi-dpf/audio/xa-class-mixer.c
deleted file mode 100644
index 47b47406..00000000
--- a/hifi/xaf/hifi-dpf/audio/xa-class-mixer.c
+++ /dev/null
@@ -1,870 +0,0 @@
-/*******************************************************************************
-* 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-class-mixer.c
- *
- * Generic mixer component class
- *
- ******************************************************************************/
-
-#define MODULE_TAG                      MIXER
-
-/*******************************************************************************
- * Includes
- ******************************************************************************/
-
-#include "xf.h"
-#include "xa-class-base.h"
-#include "audio/xa-mixer-api.h"
-
-/*******************************************************************************
- * Tracing tags
- ******************************************************************************/
-
-TRACE_TAG(INIT, 1);
-TRACE_TAG(WARNING, 1);
-TRACE_TAG(INFO, 1);
-TRACE_TAG(INPUT, 1);
-TRACE_TAG(OUTPUT, 1);
-
-/*******************************************************************************
- * Data structures
- ******************************************************************************/
-
-/* ...mixed source - input data */
-typedef struct XATrack
-{
-    /* ...input port data */
-    xf_input_port_t     input;
-
-    /* ...current presentation timestamp (in samples; local to a mixer state) */
-    u32                 pts;
-
-    /* ...total amount of decoded frames since last synchronization point */
-    u32                 decoded;
-
-    /* ...total amount of rendered frames (consumed) since last synchronization point */
-    u32                 rendered;
-
-}   XATrack;
-
-/*******************************************************************************
- * Helpers
- ******************************************************************************/
-
-static inline u32 xa_track_test_flags(XATrack *track, u32 flags)
-{
-    return (track->input.flags & flags);
-}
-
-static inline u32 xa_track_set_flags(XATrack *track, u32 flags)
-{
-    return (track->input.flags |= flags);
-}
-
-static inline u32 xa_track_clear_flags(XATrack *track, u32 flags)
-{
-    return (track->input.flags &= ~flags);
-}
-
-static inline u32 xa_track_toggle_flags(XATrack *track, u32 flags)
-{
-    return (track->input.flags ^= flags);
-}
-
-/*******************************************************************************
- * Mixer data definitions
- ******************************************************************************/
-
-/* ...mixer data */
-typedef struct XAMixer
-{
-    /***************************************************************************
-     * Control data
-     **************************************************************************/
-
-    /* ...generic audio codec data */
-    XACodecBase         base;
-
-    /* ...input tracks */
-    XATrack             track[XA_MIXER_MAX_TRACK_NUMBER];
-    
-    /* ...output port */
-    xf_output_port_t    output;
-
-    /***************************************************************************
-     * Run-time configuration parameters
-     **************************************************************************/
-
-    /* ...audio frame size in samples */
-    u32                 frame_size;
-
-    /* ...audio frame duration */
-    u32                 frame_duration;
-    
-    /* ...presentation timestamp (in samples; local mixer scope) */
-    u32                 pts;
-    
-}   XAMixer;
-
-/*******************************************************************************
- * Mixer flags
- ******************************************************************************/
-
-/* ...output port setup completed */
-#define XA_MIXER_FLAG_OUTPUT_SETUP      __XA_BASE_FLAG(1 << 0)
-
-/*******************************************************************************
- * Track state flags
- ******************************************************************************/
-
-/* ...track is idle (will autostart as soon as input data received) */
-#define XA_TRACK_FLAG_IDLE              __XF_INPUT_FLAG(1 << 0)
-
-/* ...track is rendered */
-#define XA_TRACK_FLAG_ACTIVE            __XF_INPUT_FLAG(1 << 1)
-
-/* ...track is paused */
-#define XA_TRACK_FLAG_PAUSED            __XF_INPUT_FLAG(1 << 2)
-
-/* ...track input port is setup */
-#define XA_TRACK_FLAG_INPUT_SETUP       __XF_INPUT_FLAG(1 << 3)
-
-/* ...track has received data */
-#define XA_TRACK_FLAG_RECVD_DATA        __XF_INPUT_FLAG(1 << 4)
-
-/*******************************************************************************
- * Helper functions
- ******************************************************************************/
-/* ...Count the tracks that have received data or are active*/
-static inline UWORD32 xa_mixer_check_active(XAMixer *mixer)
-{
-    XATrack        *track;
-    UWORD32            i;
-    UWORD32            cnt = 0;
-    
-    for (track = &mixer->track[i = 0]; i < XA_MIXER_MAX_TRACK_NUMBER; i++, track++)
-    {
-        if (xa_track_test_flags(track, XA_TRACK_FLAG_RECVD_DATA | XA_TRACK_FLAG_ACTIVE))
-            cnt++;
-    }
-    return cnt;
-}
-
-/* ...prepare mixer for steady operation */
-static inline XA_ERRORCODE xa_mixer_prepare_runtime(XAMixer *mixer)
-{
-    XACodecBase    *base = (XACodecBase *) mixer;
-    xf_message_t   *m = xf_msg_dequeue(&mixer->output.queue);
-    xf_start_msg_t *msg = m->buffer;
-    u32             frame_size;
-    u32             factor;
-    
-    /* ...query mixer parameters */
-    XA_API(base, XA_API_CMD_GET_CONFIG_PARAM, XA_MIXER_CONFIG_PARAM_SAMPLE_RATE, &msg->sample_rate);
-    XA_API(base, XA_API_CMD_GET_CONFIG_PARAM, XA_MIXER_CONFIG_PARAM_CHANNELS, &msg->channels);
-    XA_API(base, XA_API_CMD_GET_CONFIG_PARAM, XA_MIXER_CONFIG_PARAM_PCM_WIDTH, &msg->pcm_width);
-    XA_API(base, XA_API_CMD_GET_MEM_INFO_SIZE, 0, &msg->input_length);
-    XA_API(base, XA_API_CMD_GET_MEM_INFO_SIZE, XA_MIXER_MAX_TRACK_NUMBER, &msg->output_length);
-    XA_API(base, XA_API_CMD_GET_CONFIG_PARAM, XA_MIXER_CONFIG_PARAM_FRAME_SIZE, &frame_size);
-
-    /* ...calculate mixer frame duration; get upsample factor */
-    XF_CHK_ERR(factor = xf_timebase_factor(msg->sample_rate), XA_MIXER_CONFIG_FATAL_RANGE);
-
-    /* ...set mixer frame duration */
-    mixer->frame_duration = frame_size * factor;
-    
-    /* ...pass response to caller */
-    xf_response_data(m, sizeof(*msg));
-
-    return XA_NO_ERROR;
-}
-
-/*******************************************************************************
- * Commands handlers
- ******************************************************************************/
-
-/* ...EMPTY-THIS-BUFFER command processing */
-static XA_ERRORCODE xa_mixer_empty_this_buffer(XACodecBase *base, xf_message_t *m)
-{
-    XAMixer    *mixer = (XAMixer *) base;
-    u32         i = XF_MSG_DST_PORT(m->id);
-    XATrack    *track = &mixer->track[i];
-
-    /* ...make sure the port is valid */
-    XF_CHK_ERR(i < XA_MIXER_MAX_TRACK_NUMBER, XA_API_FATAL_INVALID_CMD_TYPE);
-    
-    /* ...command is allowed only in "postinit" state */
-    XF_CHK_ERR(base->state & XA_BASE_FLAG_POSTINIT, XA_API_FATAL_INVALID_CMD);
-
-    TRACE(INPUT, _b("track-%u: received buffer [%p]:%u"), i, m->buffer, m->length);
-
-    /* ...update received data for the track */
-    if (m->length)
-        xa_track_set_flags(track, XA_TRACK_FLAG_RECVD_DATA);
-    else
-        xa_track_clear_flags(track, XA_TRACK_FLAG_RECVD_DATA);
-    
-    /* ...place received message into track input port */
-    if (xf_input_port_put(&track->input, m))
-    {
-        /* ...process track autostart if needed */
-        if (xa_track_test_flags(track, XA_TRACK_FLAG_IDLE))
-        {
-            /* ...put track into active state */
-            xa_track_toggle_flags(track, XA_TRACK_FLAG_IDLE | XA_TRACK_FLAG_ACTIVE);
-            
-            /* ...save track presentation timestamp */
-            track->pts = mixer->pts;
-
-            TRACE(INFO, _b("track-%u started (pts=%x)"), i, track->pts);
-        }
-        
-        /* ...schedule data processing if there is output port available */
-        if (xf_output_port_ready(&mixer->output))
-        {
-            /* ...force data processing */
-            xa_base_schedule(base, 0);
-        }
-    }
-    
-    return XA_NO_ERROR;
-}
-
-/* ...FILL-THIS-BUFFER command processing */
-static XA_ERRORCODE xa_mixer_fill_this_buffer(XACodecBase *base, xf_message_t *m)
-{
-    XAMixer    *mixer = (XAMixer *) base;
-    u32         i = XF_MSG_DST_PORT(m->id);
-    
-    /* ...make sure the port is valid */
-    XF_CHK_ERR(i == XA_MIXER_MAX_TRACK_NUMBER, XA_API_FATAL_INVALID_CMD_TYPE);
-    
-    /* ...command is allowed only in "postinit" state */
-    XF_CHK_ERR(base->state & XA_BASE_FLAG_POSTINIT, XA_API_FATAL_INVALID_CMD);
-
-    /* ...process runtime initialization explicitly */
-    if (base->state & XA_BASE_FLAG_RUNTIME_INIT)
-    {
-        /* ...message must be zero-length */
-        XF_CHK_ERR(m->length == 0, XA_MIXER_EXEC_FATAL_STATE);
-    }
-    else if (m->length != 0) /* ...EOS response */
-    {
-        /* ...message must have exactly expected size (there is no ordered abortion) */
-        XF_CHK_ERR(m->length == mixer->output.length, XA_MIXER_EXEC_FATAL_STATE);
-    }
-
-    TRACE(OUTPUT, _b("received output buffer [%p]:%u"), m->buffer, m->length);
-    
-    /* ...put message into output port */
-    if (xf_output_port_put(&mixer->output, m))
-    {
-        /* ...force data processing */
-        xa_base_schedule(base, 0);
-    }
-
-    return XA_NO_ERROR;
-}
-
-/* ...output port routing */
-static XA_ERRORCODE xa_mixer_port_route(XACodecBase *base, xf_message_t *m)
-{
-    XAMixer                *mixer = (XAMixer *) base;
-    xf_route_port_msg_t    *cmd = m->buffer;
-    xf_output_port_t       *port = &mixer->output;
-    u32                     src = XF_MSG_DST(m->id);
-    u32                     dst = cmd->dst;
-    
-    /* ...command is allowed only in "postinit" state */
-    XF_CHK_ERR(base->state & XA_BASE_FLAG_POSTINIT, XA_API_FATAL_INVALID_CMD);
-
-    /* ...make sure output port is addressed */
-    XF_CHK_ERR(XF_MSG_DST_PORT(m->id) == XA_MIXER_MAX_TRACK_NUMBER, XA_API_FATAL_INVALID_CMD_TYPE);
-
-    /* ...make sure port is not routed yet */
-    XF_CHK_ERR(!xf_output_port_routed(port), XA_API_FATAL_INVALID_CMD_TYPE);
-
-    /* ...route output port - allocate queue */
-    XF_CHK_ERR(xf_output_port_route(port, __XF_MSG_ID(dst, src), cmd->alloc_number, cmd->alloc_size, cmd->alloc_align) == 0, XA_API_FATAL_MEM_ALLOC);
-
-    /* ...schedule processing instantly - tbd - check if we have anything pending on input */
-    xa_base_schedule(base, 0);
-    
-    /* ...pass success result to caller */
-    xf_response_ok(m);
-    
-    return XA_NO_ERROR;
-}
-
-/* ...port unroute command */
-static XA_ERRORCODE xa_mixer_port_unroute(XACodecBase *base, xf_message_t *m)
-{
-    XAMixer            *mixer = (XAMixer *) base;
-    xf_output_port_t   *port = &mixer->output;
-    
-    /* ...command is allowed only in "postinit" state */
-    XF_CHK_ERR(base->state & XA_BASE_FLAG_POSTINIT, XA_API_FATAL_INVALID_CMD);
-
-    /* ...make sure output port is addressed */
-    XF_CHK_ERR(XF_MSG_DST_PORT(m->id) == XA_MIXER_MAX_TRACK_NUMBER, XA_API_FATAL_INVALID_CMD_TYPE);
-
-    /* ...cancel any pending processing */
-    xa_base_cancel(base);
-
-    /* ...clear output-port-setup condition */
-    base->state &= ~XA_MIXER_FLAG_OUTPUT_SETUP;
-
-    /* ...pass flush command down the graph */
-    if (xf_output_port_flush(port, XF_FLUSH))
-    {
-        TRACE(INFO, _b("port is idle; instantly unroute"));
-
-        /* ...flushing sequence is not needed; command may be satisfied instantly */
-        xf_output_port_unroute(port);
-
-        /* ...pass response to the proxy */
-        xf_response_ok(m);
-    }
-    else
-    {
-        TRACE(INFO, _b("port is busy; propagate unroute command"));
-
-        /* ...flushing sequence is started; save flow-control message */
-        xf_output_port_unroute_start(port, m);
-    }
-
-    return XA_NO_ERROR;
-}
-
-/* ...PAUSE message processing */
-static XA_ERRORCODE xa_mixer_pause(XACodecBase *base, xf_message_t *m)
-{
-    XAMixer    *mixer = (XAMixer *) base;
-    u32         i = XF_MSG_DST_PORT(m->id);
-    XATrack    *track = &mixer->track[i];
-    
-    /* ...make sure the buffer is empty */
-    XF_CHK_ERR(m->length == 0, XA_API_FATAL_INVALID_CMD_TYPE);
-    
-    /* ...check destination port is valid */
-    XF_CHK_ERR(i < XA_MIXER_MAX_TRACK_NUMBER, XA_API_FATAL_INVALID_CMD_TYPE);
-
-    /* ...check for actual track flags */
-    if (xa_track_test_flags(track, XA_TRACK_FLAG_ACTIVE))
-    {
-        /* ...switch to paused state */
-        xa_track_toggle_flags(track, XA_TRACK_FLAG_ACTIVE | XA_TRACK_FLAG_PAUSED);
-
-        /* ...other tracks may be waiting for this one, so force data processing */
-        if (xf_output_port_ready(&mixer->output))
-        {
-            xa_base_schedule(base, 0);
-        }
-
-        TRACE(INFO, _b("mixer[%p]::track[%u] paused"), mixer, i);
-    }
-    else
-    {
-        /* ...track is in idle state and pausing here means suspending */
-        TRACE(INFO, _b("mixer[%p]::track[%u] is not active"), mixer, i);
-    }
-
-    /* ...complete message immediately */
-    xf_response(m);
-    
-    return XA_NO_ERROR;
-}
-
-/* ...RESUME command processing */
-static XA_ERRORCODE xa_mixer_resume(XACodecBase *base, xf_message_t *m)
-{
-    XAMixer    *mixer = (XAMixer *) base;
-    u32         i = XF_MSG_DST_PORT(m->id);
-    XATrack    *track = &mixer->track[i];
-    
-    /* ...make sure the buffer is empty */
-    XF_CHK_ERR(m->length == 0, XA_API_FATAL_INVALID_CMD_TYPE);
-    
-    /* ...check destination port is valid */
-    XF_CHK_ERR(i < XA_MIXER_MAX_TRACK_NUMBER, XA_API_FATAL_INVALID_CMD_TYPE);
-    
-    /* ...check for actual track state */
-    if (xa_track_test_flags(track, XA_TRACK_FLAG_PAUSED))
-    {
-        /* ...switch track to active state */
-        xa_track_toggle_flags(track, XA_TRACK_FLAG_ACTIVE | XA_TRACK_FLAG_PAUSED);
-
-        /* ...reset track presentation timestamp - tbd */
-        track->pts = mixer->pts;
-
-        /* ...force data processing if there is an output buffer */
-        if (xf_output_port_ready(&mixer->output))
-        {
-            xa_base_schedule(base, 0);
-        }
-
-        TRACE(INFO, _b("mixer[%p]::track[%u] resumed"), mixer, i);
-    }
-    else
-    {
-        /* ...track is in idle state; do nothing */
-        TRACE(INFO, _b("mixer[%p]::track[%u] is not paused"), mixer, i);
-    }
-    
-    /* ...complete message */
-    xf_response(m);
-    
-    return XA_NO_ERROR;
-}
-
-/* ...FLUSH command processing */
-static XA_ERRORCODE xa_mixer_flush(XACodecBase *base, xf_message_t *m)
-{
-    XAMixer    *mixer = (XAMixer *) base;
-    u32         i = XF_MSG_DST_PORT(m->id);
-    XATrack    *track = &mixer->track[i];
-
-    /* ...make sure the buffer is empty */
-    XF_CHK_ERR(m->length == 0, XA_API_FATAL_INVALID_CMD_TYPE);
-
-    /* ...check destination port index */
-    if (i == XA_MIXER_MAX_TRACK_NUMBER)
-    {
-        /* ...flushing response received; that is a port unrouting sequence */
-        XF_CHK_ERR(xf_output_port_unrouting(&mixer->output), XA_API_FATAL_INVALID_CMD_TYPE);
-        
-        /* ...complete unroute sequence */
-        xf_output_port_unroute_done(&mixer->output);
-
-        TRACE(INFO, _b("port is unrouted"));
-
-        return XA_NO_ERROR;
-    }
-
-    /* ...check destination port index is valid */
-    XF_CHK_ERR(i < XA_MIXER_MAX_TRACK_NUMBER, XA_API_FATAL_INVALID_CMD_TYPE);
-
-    /* ...input port flushing; check the track state is valid */
-    if (xa_track_test_flags(track, XA_TRACK_FLAG_ACTIVE | XA_TRACK_FLAG_PAUSED))
-    {
-        /* ...purge input port */
-        xf_input_port_purge(&track->input);
-
-        /* ...force clearing of ACTIVE and INPUT_SETUP condition */
-        xa_track_clear_flags(track, XA_TRACK_FLAG_ACTIVE | XA_TRACK_FLAG_PAUSED | XA_TRACK_FLAG_INPUT_SETUP);
-
-        /* ...and enter into idle state */
-        xa_track_set_flags(track, XA_TRACK_FLAG_IDLE);
-
-        /* ...other tracks may be waiting for this track, so force data processing */
-        if (xf_output_port_ready(&mixer->output))
-        {
-            xa_base_schedule(base, 0);
-        }
-
-        TRACE(INFO, _b("mixer[%p]::track[%u] flushed"), mixer, i);
-    }
-
-    /* ...complete message instantly (no propagation to output port) */
-    xf_response(m);
-
-    return XA_NO_ERROR;
-}
-
-/*******************************************************************************
- * Codec API implementation
- ******************************************************************************/
-
-/* ...buffers handling */
-static XA_ERRORCODE xa_mixer_memtab(XACodecBase *base, WORD32 idx, WORD32 type, WORD32 size, WORD32 align, u32 core)
-{
-    XAMixer    *mixer = (XAMixer *)base;
-    
-    if (type == XA_MEMTYPE_INPUT)
-    {
-        XATrack    *track = &mixer->track[idx];
-
-        /* ...input buffer allocation; check track number is valid */
-        XF_CHK_ERR(idx < XA_MIXER_MAX_TRACK_NUMBER, XA_API_FATAL_INVALID_CMD_TYPE);
-
-        /* ...create input port for a track */
-        XF_CHK_ERR(xf_input_port_init(&track->input, size, align, core) == 0, XA_API_FATAL_MEM_ALLOC);
-
-        /* ...set input port buffer */
-        XA_API(base, XA_API_CMD_SET_MEM_PTR, idx, track->input.buffer);
-
-        /* ...put track into idle state (will start as soon as we receive data) */
-        xa_track_set_flags(track, XA_TRACK_FLAG_IDLE);
-        
-        TRACE(INIT, _b("mixer[%p]::track[%u] input port created - size=%u"), mixer, idx, size);
-    }
-    else
-    {
-        /* ...output buffer allocation */
-        XF_CHK_ERR(type == XA_MEMTYPE_OUTPUT, XA_API_FATAL_INVALID_CMD_TYPE);
-
-        /* ...check port number is what we expect */
-        XF_CHK_ERR(idx == XA_MIXER_MAX_TRACK_NUMBER, XA_API_FATAL_INVALID_CMD_TYPE);
-
-        /* ...set mixer frame-size (in samples - for timestamp tracking) */
-        XA_API(base, XA_API_CMD_GET_CONFIG_PARAM, XA_MIXER_CONFIG_PARAM_FRAME_SIZE, &mixer->frame_size);
-        
-        /* ...create output port for a track */
-        XF_CHK_ERR(xf_output_port_init(&mixer->output, size) == 0, XA_API_FATAL_MEM_ALLOC);
-        
-        TRACE(INIT, _b("mixer[%p] output port created; size=%u"), mixer, size);
-    }
-
-    return XA_NO_ERROR;
-}
-
-/* ...preprocessing function */
-static XA_ERRORCODE xa_mixer_preprocess(XACodecBase *base)
-{
-    XAMixer        *mixer = (XAMixer *) base;
-    XATrack        *track;
-    u8              i;
-    XA_ERRORCODE    e = XA_MIXER_EXEC_NONFATAL_NO_DATA;
-
-    /* ...prepare output buffer */
-    if (!(base->state & XA_MIXER_FLAG_OUTPUT_SETUP))
-    {
-        void   *output;
-
-        /* ...set output buffer pointer */
-        if (base->state & XA_BASE_FLAG_RUNTIME_INIT)
-        {
-            /* ...no actual data processing during initialization */
-            return XA_NO_ERROR;
-        }
-        else if ((output = xf_output_port_data(&mixer->output)) == NULL)
-        {
-            /* ...no output buffer available */
-            return e;
-        }
-            
-        /* ...set output buffer pointer */
-        XA_API(base, XA_API_CMD_SET_MEM_PTR, XA_MIXER_MAX_TRACK_NUMBER, output);
-
-        /* ...mark output port is setup */
-        base->state ^= XA_MIXER_FLAG_OUTPUT_SETUP;
-    }
-    
-    /* ...check EOS */
-    if (!xa_mixer_check_active(mixer))
-    {
-        /* ...push EOS to output port */
-        xf_output_port_produce(&mixer->output, 0);
-        TRACE(INFO, _b("mixer[%p]::EOS generated"), mixer);
-    }
-
-    /* ...setup input buffer pointers and length */
-    for (track = &mixer->track[i = 0]; i < XA_MIXER_MAX_TRACK_NUMBER; i++, track++)
-    {
-        /* ...skip tracks that are not played */
-        if (!xa_track_test_flags(track, XA_TRACK_FLAG_ACTIVE))  continue;
-
-        /* ...set temporary mixing request */
-        e = XA_NO_ERROR;
-
-        /* ...skip the tracks that has been setup already */
-        if (xa_track_test_flags(track, XA_TRACK_FLAG_INPUT_SETUP))  continue;
-
-        /* ...found active track that hasn't been setup yet */
-        TRACE(INPUT, _b("track-%u: ts=%x vs mts=%x"), i, track->pts, mixer->pts);
-
-        /* ...if track presentation timestamp is in the future, do nothing yet really */
-        if (!xf_time_after(track->pts, mixer->pts))
-        {
-            u32     filled;
-            
-            /* ...take actual data from input port (mixer is always using internal buffer) */
-            if (!xf_input_port_fill(&track->input))
-            {
-                /* ...failed to prefill input buffer - no sufficient data yet */
-                return XA_MIXER_EXEC_NONFATAL_NO_DATA;
-            }
-            else
-            {
-                /* ...retrieve number of bytes available */
-                filled = xf_input_port_level(&track->input);
-            }
-
-            /* ...set total number of bytes we have in buffer */
-            XA_API(base, XA_API_CMD_SET_INPUT_BYTES, i, &filled);
-
-            /* ...actual data is to be played */
-            TRACE(INPUT, _b("track-%u: filled %u bytes"), i, filled);
-        }
-        
-        /* ...mark the track input is setup (emit silence or actual data) */
-        xa_track_set_flags(track, XA_TRACK_FLAG_INPUT_SETUP);
-    }
-
-    /* ...do mixing operation only when all active tracks are setup */
-    return e;
-}
-
-/* ...postprocessing function */
-static XA_ERRORCODE xa_mixer_postprocess(XACodecBase *base, int done)
-{
-    XAMixer        *mixer = (XAMixer *) base;
-    XATrack        *track;
-    u32             produced;
-    u32             consumed;
-    u8              i;
-
-    /* ...process execution stage transitions */
-    if (done)
-    {
-        if (base->state & XA_BASE_FLAG_RUNTIME_INIT)
-        {
-            /* ...failed to initialize runtime (can't be? - tbd)*/
-            BUG(1, _x("breakpoint"));
-        }
-        else if (base->state & XA_BASE_FLAG_EXECUTION)
-        {
-            /* ...enter into execution state; initialize runtime */
-            return XA_CHK(xa_mixer_prepare_runtime(mixer));
-        }
-        else
-        {
-            /* ...mixer operation is over (can't be? - tbd) */
-            BUG(1, _x("breakpoint"));
-        }
-    }
-
-    /* ...input ports maintenance; process all tracks */
-    for (track = &mixer->track[i = 0]; i < XA_MIXER_MAX_TRACK_NUMBER; i++, track++)
-    {
-        /* ...skip the tracks that are not runing */
-        if (!xa_track_test_flags(track, XA_TRACK_FLAG_ACTIVE))  continue;
-
-        /* ...clear input setup flag */
-        xa_track_clear_flags(track, XA_TRACK_FLAG_INPUT_SETUP);
-        
-        /* ...advance track presentation timestamp */
-        track->pts += mixer->frame_size;
-        
-        /* ...get total amount of consumed bytes */
-        XA_API(base, XA_API_CMD_GET_CURIDX_INPUT_BUF, i, &consumed);
-
-        TRACE(INPUT, _b("track-%u::postprocess(c=%u, ts=%x)"), i, consumed, track->pts);
-
-        /* ...consume that amount from input port (may be zero) */
-        xf_input_port_consume(&track->input, consumed);
-        
-        /* ...check if input port is done */
-        if (xf_input_port_done(&track->input))
-        {
-            /* ...input stream is over; return zero-length input back to caller */
-            xf_input_port_purge(&track->input);
-
-            /* ...switch to idle state */
-            xa_track_toggle_flags(track, XA_TRACK_FLAG_ACTIVE | XA_TRACK_FLAG_IDLE);
-
-            TRACE(INFO, _b("mixer[%p]::track[%u] completed"), mixer, i);
-        }
-    }
-
-    /* ...check if we have produced anything */
-    XA_API(base, XA_API_CMD_GET_OUTPUT_BYTES, XA_MIXER_MAX_TRACK_NUMBER, &produced);
-
-    TRACE(OUTPUT, _b("mixer[%p]::postprocess(p=%u, ts=%x, done=%u)"), mixer, produced, mixer->pts, done);
-
-    /* ...output port maintenance */
-    if (produced)
-    {
-        /* ...make sure we have produced exactly single frame */
-        BUG(produced != mixer->output.length, _x("Invalid length: %u != %u"), produced, mixer->output.length);
-        
-        /* ...steady mixing process; advance mixer presentation timestamp */
-        mixer->pts += mixer->frame_size;
-
-        /* ...push data from output port */
-        xf_output_port_produce(&mixer->output, produced);
-
-        /* ...clear output-setup condition */
-        base->state &= ~XA_MIXER_FLAG_OUTPUT_SETUP;
-    }    
-    
-    /* ...reschedule data processing if there is a pending output message */
-    if (xf_output_port_ready(&mixer->output))
-    {
-        /* ...schedule execution with respect to urgency */
-        xa_base_schedule(base, (produced ? mixer->frame_duration : 0));
-    }
-
-    return XA_NO_ERROR;
-}
-
-/*******************************************************************************
- * Command-processing function
- ******************************************************************************/
-
-/* ...command hooks */
-static XA_ERRORCODE (* const xa_mixer_cmd[])(XACodecBase *, xf_message_t *) =
-{
-    /* ...set-parameter - actually, same as in generic case */
-    [XF_OPCODE_TYPE(XF_SET_PARAM)] = xa_base_set_param,
-    [XF_OPCODE_TYPE(XF_GET_PARAM)] = xa_base_get_param,
-
-    /* ...output port routing/unrouting */
-    [XF_OPCODE_TYPE(XF_ROUTE)] = xa_mixer_port_route,
-    [XF_OPCODE_TYPE(XF_UNROUTE)] = xa_mixer_port_unroute,
-
-    /* ...input/output buffers processing */
-    [XF_OPCODE_TYPE(XF_EMPTY_THIS_BUFFER)] = xa_mixer_empty_this_buffer,
-    [XF_OPCODE_TYPE(XF_FILL_THIS_BUFFER)] = xa_mixer_fill_this_buffer,
-    [XF_OPCODE_TYPE(XF_FLUSH)] = xa_mixer_flush,
-
-    /* ...track control */
-    [XF_OPCODE_TYPE(XF_PAUSE)] = xa_mixer_pause,
-    [XF_OPCODE_TYPE(XF_RESUME)] = xa_mixer_resume,
-};
-
-/* ...total number of commands supported */
-#define XA_MIXER_CMD_NUM        (sizeof(xa_mixer_cmd) / sizeof(xa_mixer_cmd[0]))
-
-/*******************************************************************************
- * Entry points
- ******************************************************************************/
-
-/* ...mixer termination-state command processor */
-static int xa_mixer_terminate(xf_component_t *component, xf_message_t *m)
-{
-    XAMixer    *mixer = (XAMixer *) component;
-    u32         opcode = m->opcode;
-    
-    if (m == xf_output_port_control_msg(&mixer->output))
-    {
-        /* ...output port flushing complete; mark port is idle and terminate */
-        xf_output_port_flush_done(&mixer->output);
-        return -1;
-    }
-    else if (opcode == XF_FILL_THIS_BUFFER && xf_output_port_routed(&mixer->output))
-    {
-        /* ...output buffer returned by the sink component; ignore and keep waiting */
-        TRACE(OUTPUT, _b("collect output buffer"));
-        return 0;
-    }
-    else if (opcode == XF_UNREGISTER)
-    {
-        /* ...ignore subsequent unregister command/response */
-        return 0;
-    }
-    else
-    {
-        /* ...everything else is responded with generic failure */
-        xf_response_err(m);
-        return 0;
-    }
-}
-
-/* ...mixer class destructor */
-static int xa_mixer_destroy(xf_component_t *component, xf_message_t *m)
-{
-    XAMixer    *mixer = (XAMixer *) component;
-    u32         core = xf_component_core(component);
-    u32         i;
-    
-    /* ...destroy all inputs */
-    for (i = 0; i < XA_MIXER_MAX_TRACK_NUMBER; i++)
-    {
-        xf_input_port_destroy(&mixer->track[i].input, core);
-    }
-
-    /* ...destroy output port */
-    xf_output_port_destroy(&mixer->output, core);
-
-    /* ...destroy base object */
-    xa_base_destroy(&mixer->base, XF_MM(sizeof(*mixer)), core);
-
-    TRACE(INIT, _b("mixer[%p] destroyed"), mixer);
-
-    return 0;
-}
-
-/* ...mixer class first-stage destructor */
-static int xa_mixer_cleanup(xf_component_t *component, xf_message_t *m)
-{
-    XAMixer    *mixer = (XAMixer *) component;
-    u32         i;
-
-    /* ...complete message with error result code */
-    xf_response_err(m);
-    
-    /* ...cancel internal scheduling message if needed */
-    xa_base_cancel(&mixer->base);    
-    
-    /* ...purge all input ports (specify "unregister"? - don't know yet - tbd) */
-    for (i = 0; i < XA_MIXER_MAX_TRACK_NUMBER; i++)
-    {
-        xf_input_port_purge(&mixer->track[i].input);
-    }
-
-    /* ...flush output port */
-    if (xf_output_port_flush(&mixer->output, XF_FLUSH))
-    {
-        /* ...flushing sequence is not needed; destroy mixer */
-        return xa_mixer_destroy(component, NULL);
-    }
-    else
-    {
-        /* ...wait until output port is cleaned; adjust component hooks */
-        component->entry = xa_mixer_terminate;
-        component->exit = xa_mixer_destroy;
-        
-        TRACE(INIT, _b("mixer[%p] cleanup sequence started"), mixer);
-
-        /* ...indicate that second stage is required */
-        return 1;
-    }
-}
-
-/* ...mixer class factory */
-xf_component_t * xa_mixer_factory(u32 core, xa_codec_func_t process)
-{
-    XAMixer    *mixer;
-
-    /* ...construct generic audio component */
-    XF_CHK_ERR(mixer = (XAMixer *)xa_base_factory(core, XF_MM(sizeof(*mixer)), process), NULL);
-
-    /* ...set generic codec API */
-    mixer->base.memtab = xa_mixer_memtab;
-    mixer->base.preprocess = xa_mixer_preprocess;
-    mixer->base.postprocess = xa_mixer_postprocess;
-
-    /* ...set message-processing table */
-    mixer->base.command = xa_mixer_cmd;
-    mixer->base.command_num = XA_MIXER_CMD_NUM;
-
-    /* ...set component destructor hook */
-    mixer->base.component.exit = xa_mixer_cleanup;
-    
-    TRACE(INIT, _b("Mixer[%p] created"), mixer);
-
-    /* ...return handle to component */
-    return (xf_component_t *) mixer;
-}