/*******************************************************************************
* 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 sane */
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;
}