source: svn/trunk/newcon3bcm2_21bu/magnum/portinginterface/ape/7552/bape_playback.c

/***************************************************************************
 *     Copyright (c) 2006-2012, Broadcom Corporation
 *     All Rights Reserved
 *     Confidential Property of Broadcom Corporation
 *
 *  THIS SOFTWARE MAY ONLY BE USED SUBJECT TO AN EXECUTED SOFTWARE LICENSE
 *  AGREEMENT  BETWEEN THE USER AND BROADCOM.  YOU HAVE NO RIGHT TO USE OR
 *  EXPLOIT THIS MATERIAL EXCEPT SUBJECT TO THE TERMS OF SUCH AN AGREEMENT.
 *
 * $brcm_Workfile: bape_playback.c $
 * $brcm_Revision: Hydra_Software_Devel/13 $
 * $brcm_Date: 3/5/12 3:52p $
 *
 * Module Description: Audio Decoder Interface
 *
 * Revision History:
 *
 * $brcm_Log: /magnum/portinginterface/ape/7422/bape_playback.c $
 * 
 * Hydra_Software_Devel/13   3/5/12 3:52p jgarrett
 * SW7425-2522: Handling playback watermark size > fifo size
 * 
 * Hydra_Software_Devel/12   2/8/12 11:52a jgarrett
 * SW7346-672: Adding support for changing the playback sample rate on the
 * fly
 * 
 * Hydra_Software_Devel/11   8/25/11 1:51p gskerl
 * SW7425-1119: When trying to stop an already stopped Playback, just
 * return (instead of trying to stop it).
 * 
 * Hydra_Software_Devel/10   7/8/11 4:53p gskerl
 * SW7425-321: Added printing of downstream nodes when an audio path is
 * started (if bape_startprint is enabled)
 * 
 * Hydra_Software_Devel/9   6/16/11 11:01a gskerl
 * SW7425-321: Added call to BAPE_Mixer_P_PrintMixers() just before
 * starting paths
 * 
 * Hydra_Software_Devel/8   5/16/11 5:24p piyushg
 * SW7425-595: Fix bus error while quitting brutus.
 * 
 * Hydra_Software_Devel/7   5/12/11 4:39p piyushg
 * SW7425-401: Added PCM playback support for non-interleaved and
 * multichannel data
 * 
 * Hydra_Software_Devel/6   4/16/11 12:15p jgarrett
 * SW7425-371: Removing tab characters
 * 
 * Hydra_Software_Devel/5   4/6/11 1:23a jgarrett
 * SW35330-35: Merge to main branch
 * 
 * Hydra_Software_Devel/SW35330-35/1   4/5/11 12:49p jgarrett
 * SW35330-35: FMM Abstraction refactoring to support DTV
 * 
 * Hydra_Software_Devel/4   2/28/11 1:28p jgarrett
 * SW7422-146: Filter graph reworked to remove mixer dependencies
 * 
 * Hydra_Software_Devel/3   2/22/11 5:43p jgarrett
 * SW7422-146: Implemented type renaming based on filter graph review
 * comments
 * 
 * Hydra_Software_Devel/2   12/17/10 3:58p jgarrett
 * SW7422-146: Nexus APE integration on 7422
 * 
 * Hydra_Software_Devel/1   12/16/10 4:05p jgarrett
 * SW7422-146: Initial compilable APE for 7422
 * 
 ***************************************************************************/

#include "bstd.h"
#include "bkni.h"
#include "bape.h"
#include "bape_priv.h"
#include "bchp_aud_fmm_bf_ctrl.h"

BDBG_MODULE(bape_playback);

BDBG_OBJECT_ID(BAPE_Playback);

static void BAPE_Playback_P_ReArmWatermark(BAPE_PlaybackHandle handle);
static BERR_Code BAPE_Playback_P_ConfigPathToOutput(BAPE_PathNode *pNode, BAPE_PathConnection *pConnection);
static BERR_Code BAPE_Playback_P_StartPathToOutput(BAPE_PathNode *pNode, BAPE_PathConnection *pConnection);
static void BAPE_Playback_P_StopPathToOutput(BAPE_PathNode *pNode, BAPE_PathConnection *pConnection);

void BAPE_Playback_GetDefaultOpenSettings(
    BAPE_PlaybackOpenSettings *pSettings
    )
{
    BDBG_ASSERT(NULL != pSettings);
    pSettings->numBuffers = 1;
    pSettings->bufferSize = 128*1024;
    pSettings->watermarkThreshold = 64*1024;
}

BERR_Code BAPE_Playback_Open(
    BAPE_Handle deviceHandle,
    unsigned index,
    const BAPE_PlaybackOpenSettings *pSettings,
    BAPE_PlaybackHandle *pHandle                    /* [out] */
    )
{
    BERR_Code errCode = BERR_SUCCESS;
    BAPE_PlaybackHandle handle;
    BAPE_PlaybackOpenSettings defaultSettings;
    unsigned i;

    BDBG_OBJECT_ASSERT(deviceHandle, BAPE_Device);
    BDBG_ASSERT(NULL != pHandle);
    
    *pHandle = NULL;

    if ( NULL == pSettings )
    {
        BAPE_Playback_GetDefaultOpenSettings(&defaultSettings);
        pSettings = &defaultSettings;
    }

    if ( index >= BAPE_CHIP_MAX_PLAYBACKS )
    {
        BDBG_ERR(("This chip only supports %u playbacks.  Cannot open playback %u", BAPE_CHIP_MAX_PLAYBACKS, index));
        return BERR_TRACE(BERR_INVALID_PARAMETER);
    }

    if ( deviceHandle->playbacks[index] )
    {
        BDBG_ERR(("Playback %d already open", index));
        return BERR_TRACE(BERR_INVALID_PARAMETER);
    }

    /* TODO: Extend for multichannel and non-interleved */
    if ( pSettings->numBuffers > BAPE_Channel_eMax ) 
    {
        BDBG_ERR(("Maximum num of buffers required for multichannel non-interleved audio playback cannot exceed %u. Requested num buffers is %u", BAPE_Channel_eMax, pSettings->numBuffers));
        return BERR_TRACE(BERR_INVALID_PARAMETER);
    }

    handle = BKNI_Malloc(sizeof(BAPE_Playback));
    if ( NULL == handle )
    {
        return BERR_TRACE(BERR_OUT_OF_SYSTEM_MEMORY);
    }
    BKNI_Memset(handle, 0, sizeof(BAPE_Playback));
    handle->deviceHandle = deviceHandle;

    for (i = 0; i < pSettings->numBuffers; i++) 
    {
        handle->pBuffer[i] = BMEM_AllocAligned(deviceHandle->memHandle, pSettings->bufferSize, 5, 0);
        if ( NULL == handle->pBuffer[i] )
        {
            errCode = BERR_TRACE(BERR_OUT_OF_DEVICE_MEMORY);
            goto err_buffer_alloc;
        }
    }

    handle->bufferSize = pSettings->bufferSize;
    if ( pSettings->watermarkThreshold >= pSettings->bufferSize )
    {
        BDBG_WRN(("playback watermark threshold %u is larger than the buffer size %u.  Reducing to %u.", pSettings->watermarkThreshold, pSettings->bufferSize, pSettings->bufferSize / 2));
        handle->threshold = pSettings->bufferSize / 2;
    }
    else
    {
        handle->threshold = pSettings->watermarkThreshold;
    }
    handle->index = index;
    handle->numBuffers = pSettings->numBuffers;
    handle->settings.multichannelFormat = BAPE_MultichannelFormat_e2_0;
    handle->settings.compressedData = false;
    handle->settings.sampleRate = 44100;
    BAPE_P_InitPathNode(&handle->node, BAPE_PathNodeType_ePlayback, 0, 1, deviceHandle, handle);
    BKNI_Snprintf(handle->name, sizeof(handle->name), "Playback %u", index);
    handle->node.pName = handle->name;
    handle->node.paths[0].connector.numChannelPairs = 1;
    handle->node.paths[0].connector.dataSource = BAPE_DataSource_eHostBuffer;
    handle->node.paths[0].connector.sampleRate = 44100;
    /* Init node callbacks */
    handle->node.configPathToOutput = BAPE_Playback_P_ConfigPathToOutput;
    handle->node.startPathToOutput = BAPE_Playback_P_StartPathToOutput;
    handle->node.stopPathToOutput = BAPE_Playback_P_StopPathToOutput;
    BDBG_OBJECT_SET(handle, BAPE_Playback);
    *pHandle = handle;
    deviceHandle->playbacks[index] = handle;

    return errCode;

    err_buffer_alloc:
    for (i = 0; i < pSettings->numBuffers; i++) 
    {
        if ( NULL != handle->pBuffer[i] )
        {
                        BDBG_ERR(("Hello Are you kidding me"));
            BMEM_Free(handle->deviceHandle->memHandle, handle->pBuffer[i]);
        }
    }
    return errCode;
}

void BAPE_Playback_Close(
    BAPE_PlaybackHandle handle
    )
{
    unsigned i;

    BDBG_OBJECT_ASSERT(handle, BAPE_Playback);
    if ( handle->running )
    {
        BDBG_WRN(("Stopping playback %p (%d) on close", handle, handle->index));
        BAPE_Playback_Stop(handle);
    }

    /* Disconnect from all mixers, post-processors, and groups */
    BAPE_Connector_P_RemoveAllConnections(&handle->node.paths[0].connector);

    for (i = 0; i < handle->numBuffers; i++)
    {
        if (handle->pBuffer[i]) 
        {
            BMEM_Free(handle->deviceHandle->memHandle, handle->pBuffer[i]);
        }
    }

    handle->deviceHandle->playbacks[handle->index] = NULL;
    BDBG_OBJECT_DESTROY(handle, BAPE_Playback);
    BKNI_Free(handle);
}

void BAPE_Playback_GetSettings(
    BAPE_PlaybackHandle handle,
    BAPE_PlaybackSettings *pSettings    /* [out] */
    )
{
    BDBG_OBJECT_ASSERT(handle, BAPE_Playback);
    BDBG_ASSERT(NULL != pSettings);

    *pSettings = handle->settings;
}

BERR_Code BAPE_Playback_SetSettings(
    BAPE_PlaybackHandle handle,
    const BAPE_PlaybackSettings *pSettings
    )
{
    BERR_Code errCode = BERR_SUCCESS;

    BDBG_OBJECT_ASSERT(handle, BAPE_Playback);
    BDBG_ASSERT(NULL != pSettings);

    /* If we're already running, return error */
    if ( handle->running )
    {
        if ( handle->settings.multichannelFormat != pSettings->multichannelFormat ||
             handle->settings.compressedData != handle->settings.compressedData )
        {
            BDBG_ERR(("Playback %p (%d) is already running.  Cannot data format.", handle, handle->index));
            return BERR_TRACE(BERR_NOT_SUPPORTED);
        }
        
        if ( handle->startSettings.sampleRate == 0 && handle->settings.sampleRate != pSettings->sampleRate )        
        {
            if ( pSettings->sampleRate == 0 )
            {
                BDBG_ERR(("Can not use sample rate of 0."));
                return BERR_TRACE(BERR_INVALID_PARAMETER);
            }
            /* Update Sample Rate */
            BKNI_EnterCriticalSection();
            handle->node.paths[0].connector.sampleRate = pSettings->sampleRate;
            BAPE_Connector_P_SampleRateChange_isr(&handle->node.paths[0].connector);
            BKNI_LeaveCriticalSection();
        }
    }
    else
    {
        if ( pSettings->compressedData == true && pSettings->multichannelFormat != BAPE_MultichannelFormat_e2_0 ) 
        {
            return BERR_TRACE(BERR_INVALID_PARAMETER);
        }
    
        switch ( pSettings->multichannelFormat ) 
        {
        case BAPE_MultichannelFormat_e2_0:
            handle->node.paths[0].connector.numChannelPairs = 1;
            break;
        case BAPE_MultichannelFormat_e5_1:
            handle->node.paths[0].connector.numChannelPairs = 3;
            break;
        case BAPE_MultichannelFormat_e7_1:
            handle->node.paths[0].connector.numChannelPairs = 4;
            break;
        default:
            return BERR_TRACE(BERR_INVALID_PARAMETER);
        }
    
        handle->node.paths[0].connector.compressed = pSettings->compressedData;
        errCode = BAPE_Connector_P_FormatChange(&handle->node.paths[BAPE_ConnectorFormat_eStereo].connector);
        if ( errCode )
        {
            errCode = BERR_TRACE(errCode);
        }
    }

    handle->settings = *pSettings;
    return BERR_SUCCESS;
}

void BAPE_Playback_GetDefaultStartSettings(
    BAPE_PlaybackStartSettings *pSettings       /* [out] */
    )
{
    BDBG_ASSERT(NULL != pSettings);
    pSettings->sampleRate = 44100;
    pSettings->bitsPerSample = 16;
    pSettings->isStereo = true;
    pSettings->isSigned = true;
    pSettings->reverseEndian = false;
    pSettings->loopEnabled = false;
    pSettings->startThreshold = 0;
    pSettings->interleaved = true;
}

BERR_Code BAPE_Playback_Start(
    BAPE_PlaybackHandle handle,
    const BAPE_PlaybackStartSettings *pSettings
    )
{
    BERR_Code errCode;
    unsigned numBuffers;
    unsigned sampleRate;

    BDBG_OBJECT_ASSERT(handle, BAPE_Playback);
    BDBG_ASSERT(NULL != pSettings);

    /* If we're already running, return error */
    if ( handle->running )
    {
        BDBG_ERR(("Playback %p (%d) is already running.  Can't start.", handle, handle->index));
        return BERR_TRACE(BERR_NOT_SUPPORTED);
    }

    /* Sanity Checks */
    numBuffers = (pSettings->interleaved == true)?handle->node.paths[0].connector.numChannelPairs: 2 * handle->node.paths[0].connector.numChannelPairs;
    if ( numBuffers > handle->numBuffers )
    {
        BDBG_ERR(("%u buffers are required for the current data format but only %u have been allocated", numBuffers, handle->numBuffers));
        return BERR_TRACE(BERR_NOT_SUPPORTED);
    }
    
    if ( 0 == pSettings->sampleRate )
    {
        sampleRate = handle->settings.sampleRate;
        if ( 0 == sampleRate )
        {   
            BDBG_ERR(("To use a variable sample rate, you must specify a valid rate in BAPE_PlaybackSettings.sampleRate."));
            return BERR_TRACE(BERR_INVALID_PARAMETER);
        }
    }
    else
    {
        sampleRate = pSettings->sampleRate;
    }

    switch ( pSettings->bitsPerSample )
    {
    case 8:
    case 16:
    case 32:
        break;
    default:
        BDBG_ERR(("Unsupported bits per sample.  Only 8/16/32 are supported."));
        return BERR_TRACE(BERR_INVALID_PARAMETER);
    }

    BDBG_MSG(("Playback %p (%d) Starting", handle, handle->index));

    /* Save start settings */
    handle->startSettings = *pSettings;

    /* Update data format and sample rate in connector */
    handle->node.paths[0].connector.sampleRate = sampleRate;

    /* Build Paths  */
    errCode = BAPE_PathNode_P_AcquirePathResources(&handle->node);
    if ( errCode )
    {
        errCode = BERR_TRACE(errCode);
        goto err_acquire_resources;
    }

    /* Prepare network to start */
    errCode = BAPE_PathNode_P_ConfigurePathResources(&handle->node);
    if ( errCode )
    {
        errCode = BERR_TRACE(errCode);
        goto err_configure_resources;
    }

    if ( NULL == handle->pMaster )
    {
        BDBG_ERR(("No outputs have been connected to this input capture."));
        goto err_no_master;
    }

    /* Install the interrupt handler */
    if ( handle->interrupts.watermark.pCallback_isr )
    {
        errCode = BAPE_SfifoGroup_P_SetFreemarkInterrupt(handle->pMaster->sfifoGroup,
                                                         handle->interrupts.watermark.pCallback_isr,
                                                         handle->interrupts.watermark.pParam1,
                                                         handle->interrupts.watermark.param2);        
        if ( errCode )
        {
            errCode = BERR_TRACE(errCode);
            goto err_watermark;
        }
    }    

    #if BDBG_DEBUG_BUILD
        BAPE_Mixer_P_PrintMixers(handle->deviceHandle);
    #endif

    /* Start */
    errCode = BAPE_PathNode_P_StartPaths(&handle->node);
    if ( errCode )
    {
        errCode = BERR_TRACE(errCode);
        goto err_start_paths;
    }

    #if BDBG_DEBUG_BUILD
        BAPE_Mixer_P_PrintDownstreamNodes(&handle->node);
    #endif

    /* Success */
    BDBG_MSG(("Playback %p (%d) Start Successful", handle, handle->index));
    handle->running = true;
    BAPE_Playback_P_ReArmWatermark(handle);
    return BERR_SUCCESS;

err_start_paths:
    /* Remove the interrupt handler */
    (void)BAPE_SfifoGroup_P_SetFreemarkInterrupt(handle->pMaster->sfifoGroup, NULL, NULL, 0);
err_watermark:
err_no_master:
    BAPE_PathNode_P_ReleasePathResources(&handle->node);
err_configure_resources:
err_acquire_resources:
    return errCode;
}

void BAPE_Playback_Stop(
    BAPE_PlaybackHandle handle
    )
{
    BDBG_OBJECT_ASSERT(handle, BAPE_Playback);
    
    if ( !handle->running )
    {
        BDBG_MSG(("Playback %p (%d) already stopped.", handle, handle->index));
        return;
    }

    /* Stop Paths Downstream */
    BAPE_PathNode_P_StopPaths(&handle->node);
    
    /* Remove the interrupt handler */    
    if ( handle->pMaster && handle->interrupts.watermark.pCallback_isr )
    {
        (void)BAPE_SfifoGroup_P_SetFreemarkInterrupt(handle->pMaster->sfifoGroup, NULL, NULL, 0);
    }

    /* Clear the started flag and flush the buffer */
    handle->running = false;
    handle->bufferDepth = 0;
    handle->pMaster = NULL;
}

void BAPE_Playback_Flush(
    BAPE_PlaybackHandle handle
    )
{
    BDBG_OBJECT_ASSERT(handle, BAPE_Playback);

    if ( handle->running )
    {
        BDBG_ASSERT(NULL != handle->pMaster);
        BAPE_SfifoGroup_P_Flush(handle->pMaster->sfifoGroup);
    }

    handle->bufferDepth = 0;
}

BERR_Code BAPE_Playback_GetBuffer(
    BAPE_PlaybackHandle handle,
    BAPE_BufferDescriptor *pBuffers      /* [out] */
    )
{   
    BERR_Code errCode = BERR_SUCCESS;
    unsigned i;

    BDBG_OBJECT_ASSERT(handle, BAPE_Playback);
    BDBG_ASSERT(NULL != pBuffers);

    BDBG_MSG(("Playback %p (%d) GetBuffer", handle, handle->index));

    BKNI_Memset(pBuffers, 0, sizeof(BAPE_BufferDescriptor));
    
    if ( handle->running && !handle->startSettings.loopEnabled )
    {
        BDBG_ASSERT(NULL != handle->pMaster);
        BAPE_SfifoGroup_P_GetBuffer(handle->pMaster->sfifoGroup, pBuffers);
    }
    else
    {
        /* TODO: Handle non-interleaved and multichannel */
        pBuffers->numBuffers = handle->node.paths[0].connector.numChannelPairs * 2;
        pBuffers->interleaved = handle->startSettings.interleaved;
        pBuffers->bufferSize = handle->bufferSize - handle->bufferDepth;

        if ( pBuffers->bufferSize )
        {
            if ( pBuffers->interleaved ) 
            {
                for ( i = 0; i < handle->node.paths[0].connector.numChannelPairs; i++) 
                {
                    pBuffers->buffers[i*2].pBuffer = (void *)((unsigned)handle->pBuffer[i] + handle->bufferDepth);
                }
            }
            else
            {
                for ( i = 0; i < handle->node.paths[0].connector.numChannelPairs; i++) 
                {
                    pBuffers->buffers[i*2].pBuffer = (void *)((unsigned)handle->pBuffer[i] + handle->bufferDepth);
                    pBuffers->buffers[i*2 + 1].pBuffer = (void *)((unsigned)handle->pBuffer[i] + handle->bufferDepth);
                }
            }
        }
    }

    if ( errCode )
    {
        return BERR_TRACE(errCode);
    }

    return errCode;
}

BERR_Code BAPE_Playback_CommitData(
    BAPE_PlaybackHandle handle,
    unsigned numBytes                   /* Number of bytes written into the buffer */
    )
{
    BERR_Code errCode;

    BDBG_OBJECT_ASSERT(handle, BAPE_Playback);
    
    if ( handle->running )
    {
        BDBG_ASSERT(NULL != handle->pMaster);
        errCode = BAPE_SfifoGroup_P_CommitData(handle->pMaster->sfifoGroup, numBytes);
        if ( errCode )
        {
            return BERR_TRACE(errCode);
        }
    }
    else
    {
        if ( numBytes + handle->bufferDepth > handle->bufferSize )
        {
            BDBG_ERR(("Invalid number of bytes passed."));
            return BERR_TRACE(BERR_INVALID_PARAMETER);
        }
        handle->bufferDepth += numBytes;
    }

    if ( handle->pMaster )
    {
        BAPE_SfifoGroup_P_RearmFreemarkInterrupt(handle->pMaster->sfifoGroup);
    }

    return BERR_SUCCESS;
}

void BAPE_Playback_GetStatus(
    BAPE_PlaybackHandle handle,
    BAPE_PlaybackStatus *pStatus    /* [out] */
    )
{
    BERR_Code errCode;
    
    BDBG_OBJECT_ASSERT(handle, BAPE_Playback);
    BDBG_ASSERT(NULL != pStatus);
    
    BKNI_Memset(pStatus, 0, sizeof(*pStatus));
    pStatus->fifoSize = handle->bufferSize;
    
    if ( !handle->running )
    {
        return;
    }
    
    /* If running, query the SFIFO */
    BDBG_ASSERT(NULL != handle->pMaster);
    errCode = BAPE_SfifoGroup_P_GetQueuedBytes(handle->pMaster->sfifoGroup, &pStatus->queuedBytes);
    if ( errCode )
    {
        (void)BERR_TRACE(errCode);
        return;
    }
}

void BAPE_Playback_GetConnector(
    BAPE_PlaybackHandle handle,
    BAPE_Connector *pConnector /* [out] */
    )
{
    BDBG_OBJECT_ASSERT(handle, BAPE_Playback);
    *pConnector = &handle->node.paths[0].connector;
}

void BAPE_Playback_GetInterruptHandlers(
    BAPE_PlaybackHandle handle,
    BAPE_PlaybackInterruptHandlers *pInterrupts     /* [out] */
    )
{
    BDBG_OBJECT_ASSERT(handle, BAPE_Playback);
    BDBG_ASSERT(NULL != pInterrupts);
    *pInterrupts = handle->interrupts;
}

BERR_Code BAPE_Playback_SetInterruptHandlers(
    BAPE_PlaybackHandle handle,
    const BAPE_PlaybackInterruptHandlers *pInterrupts
    )
{
    BERR_Code errCode;
    BDBG_OBJECT_ASSERT(handle, BAPE_Playback);
    BDBG_ASSERT(NULL != pInterrupts);

    if ( handle->running )
    {
        errCode = BAPE_SfifoGroup_P_SetFreemarkInterrupt(handle->pMaster->sfifoGroup,
                                                         pInterrupts->watermark.pCallback_isr,
                                                         pInterrupts->watermark.pParam1,
                                                         pInterrupts->watermark.param2);
        if ( errCode )
        {
            return BERR_TRACE(errCode);
        }
    }

    /* These aren't actually used by the interrupt directly, so no need for critical section here. */
    handle->interrupts = *pInterrupts;

    return BERR_SUCCESS;
}

static void BAPE_Playback_P_ReArmWatermark(BAPE_PlaybackHandle handle)
{
    BDBG_OBJECT_ASSERT(handle, BAPE_Playback);

    if ( handle->running )
    {
        BDBG_ASSERT(NULL != handle->pMaster);
        BAPE_SfifoGroup_P_RearmFreemarkInterrupt(handle->pMaster->sfifoGroup);
    }
}

static BERR_Code BAPE_Playback_P_ConfigPathToOutput(BAPE_PathNode *pNode, BAPE_PathConnection *pConnection)
{
    BAPE_PathConnector *pSource;
    BAPE_PlaybackHandle handle;
    BAPE_PathNode *pSink;
    BERR_Code errCode;
    unsigned offset;
    unsigned chPairs;
    unsigned i;

    BDBG_OBJECT_ASSERT(pNode, BAPE_PathNode);
    BDBG_OBJECT_ASSERT(pConnection, BAPE_PathConnection);
    BDBG_OBJECT_ASSERT(pConnection->pSource, BAPE_PathConnector);
    BDBG_OBJECT_ASSERT(pConnection->pSink, BAPE_PathNode);

    handle = pNode->pHandle;
    BDBG_OBJECT_ASSERT(handle, BAPE_Playback);

    pSource = pConnection->pSource;
    pSink = pConnection->pSink;

    if ( pConnection->sfifoGroup )
    {
        BAPE_SfifoGroupSettings sfifoSettings;

        /* Dropping into the FMM - Configure the SFIFO(s) */
        if ( NULL == handle->pMaster )
        {
            handle->pMaster = pConnection;
        }

        BAPE_SfifoGroup_P_GetSettings(pConnection->sfifoGroup, &sfifoSettings);
        sfifoSettings.highPriority = (handle->node.paths[0].connector.sampleRate >= 96000)?1:0;
        sfifoSettings.dataWidth = handle->startSettings.bitsPerSample;
        sfifoSettings.reverseEndian = handle->startSettings.reverseEndian;
        sfifoSettings.sampleRepeatEnabled = handle->node.paths[0].connector.compressed?false:true;       /* TODO: Set to false if compressed */
        sfifoSettings.loopAround = handle->startSettings.loopEnabled;
        sfifoSettings.wrpointEnabled = false;
        if ( handle->startSettings.startThreshold > 0 )
        {
            if ( handle->startSettings.loopEnabled )
            {
                BDBG_WRN(("Playback start threshold is not compatible with the loop setting.  Disabling startThreshold."));
            }
            else
            {
                sfifoSettings.wrpointEnabled = true;
            }
        }
        /* TODO: Add support for non-interleaved */
        sfifoSettings.interleaveData = handle->startSettings.interleaved;
        sfifoSettings.stereoData = handle->startSettings.isStereo;
        sfifoSettings.signedData = handle->startSettings.isSigned;
        if ( pConnection != handle->pMaster )
        {
            BDBG_MSG(("Linking playback source channel group %#x to master %#x", pConnection->sfifoGroup, handle->pMaster->sfifoGroup));
            sfifoSettings.master = handle->pMaster->sfifoGroup;
        }
        else
        {
            sfifoSettings.master = NULL;
        }

        chPairs = handle->node.paths[0].connector.numChannelPairs;
        /* Setup Buffers */
        for ( i = 0; i < chPairs; i++) 
        {
            if ( sfifoSettings.interleaveData) 
            {
                errCode = BMEM_ConvertAddressToOffset(handle->deviceHandle->memHandle, handle->pBuffer[i*2], &offset);
                BDBG_ASSERT(BERR_SUCCESS == errCode);
                sfifoSettings.bufferInfo[i].base = offset;
                sfifoSettings.bufferInfo[i].writeOffset = handle->bufferDepth;
                sfifoSettings.bufferInfo[i].length = handle->bufferSize;
                sfifoSettings.bufferInfo[i].watermark = handle->threshold;
                if ( handle->startSettings.startThreshold > handle->bufferSize )
                {
                    BDBG_WRN(("Start threshold is too large.  Starting with buffer full."));
                    sfifoSettings.bufferInfo[i].wrpoint = offset + handle->bufferSize - 1;
                }
                else if ( handle->startSettings.startThreshold > 0 )
                {
                    sfifoSettings.bufferInfo[i].wrpoint = offset + handle->startSettings.startThreshold-1;
                }
                else
                {
                    sfifoSettings.bufferInfo[i].wrpoint = 0;
                }
            }
            else
            {
                errCode = BMEM_ConvertAddressToOffset(handle->deviceHandle->memHandle, handle->pBuffer[i*2], &offset);
                BDBG_ASSERT(BERR_SUCCESS == errCode);
                sfifoSettings.bufferInfo[i*2].base = offset;
                sfifoSettings.bufferInfo[i*2].writeOffset = handle->bufferDepth;
                sfifoSettings.bufferInfo[i*2].length = handle->bufferSize;
                sfifoSettings.bufferInfo[i*2].watermark = handle->threshold;
                if ( handle->startSettings.startThreshold > handle->bufferSize )
                {
                    BDBG_WRN(("Start threshold is too large.  Starting with buffer full."));
                    sfifoSettings.bufferInfo[i*2].wrpoint = offset + handle->bufferSize - 1;
                }
                else if ( handle->startSettings.startThreshold > 0 )
                {
                    sfifoSettings.bufferInfo[i*2].wrpoint = offset + handle->startSettings.startThreshold-1;
                }
                else
                {
                    sfifoSettings.bufferInfo[i*2].wrpoint = 0;
                }

                errCode = BMEM_ConvertAddressToOffset(handle->deviceHandle->memHandle, handle->pBuffer[(i*2) + 1], &offset);
                BDBG_ASSERT(BERR_SUCCESS == errCode);
                sfifoSettings.bufferInfo[i*2 + 1].base = offset;
                sfifoSettings.bufferInfo[i*2 + 1].writeOffset = handle->bufferDepth;
                sfifoSettings.bufferInfo[i*2 + 1].length = handle->bufferSize;
                sfifoSettings.bufferInfo[i*2 + 1].watermark = handle->threshold;
                if ( handle->startSettings.startThreshold > handle->bufferSize )
                {
                    BDBG_WRN(("Start threshold is too large.  Starting with buffer full."));
                    sfifoSettings.bufferInfo[i*2 + 1].wrpoint = offset + handle->bufferSize - 1;
                }
                else if ( handle->startSettings.startThreshold > 0 )
                {
                    sfifoSettings.bufferInfo[i*2 + 1].wrpoint = offset + handle->startSettings.startThreshold-1;
                }
                else
                {
                    sfifoSettings.bufferInfo[i*2 + 1].wrpoint = 0;
                }
            }
        }
        BAPE_SfifoGroup_P_SetSettings(pConnection->sfifoGroup, &sfifoSettings);
    }
    /* Other nodes don't require anything done here */

    return BERR_SUCCESS;    
}

static BERR_Code BAPE_Playback_P_StartPathToOutput(BAPE_PathNode *pNode, BAPE_PathConnection *pConnection)
{
    BERR_Code errCode;
    BDBG_OBJECT_ASSERT(pNode, BAPE_PathNode);
    BDBG_OBJECT_ASSERT(pConnection, BAPE_PathConnection);
    if ( pConnection->sfifoGroup )
    {
        errCode = BAPE_SfifoGroup_P_Start(pConnection->sfifoGroup, false);
        if ( errCode )
        {
            return BERR_TRACE(errCode);
        }
    }
    return BERR_SUCCESS;
}

static void BAPE_Playback_P_StopPathToOutput(BAPE_PathNode *pNode, BAPE_PathConnection *pConnection)
{
    BSTD_UNUSED(pNode);
    if ( pConnection->sfifoGroup )
    {
        BAPE_SfifoGroup_P_Stop(pConnection->sfifoGroup);
    }
}