/*
Copyright (c) 2016, Texas Instruments Incorporated - http://www.ti.com/
All rights reserved.

* Redistribution and use in source and binary forms, with or without 
* modification, are permitted provided that the following conditions
* are met:
*
* Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the
* distribution.
*
* Neither the name of Texas Instruments Incorporated nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/

/*
 *  ======== audioStreamOutProc.h ========
 */

#ifndef _ASOP_H_
#define _ASOP_H_
 
#include <xdc/std.h>

#include "audioStreamProc_params.h"
#include "audioStreamProc_patchs.h"
#include "audioStreamProc_config.h"
#include "audioStreamProc_master.h"

// Global debug counter */
extern Uint32 gTaskAsopCnt; // debug counter for ASOP task

struct PAF_ASOT_Params;
struct PAF_ASOT_Patchs;
struct PAF_ASOT_Config;

// Audio Stream Output Task (ASOT) parameters, functions
typedef struct PAF_ASOT_Fxns {
    Int (*initPhase[8]) (const struct PAF_ASOT_Params *, const struct PAF_ASOT_Patchs *, struct PAF_ASOT_Config *);
    Int (*initFrame0) (const struct PAF_ASOT_Params *, const struct PAF_ASOT_Patchs *, struct PAF_ASOT_Config *, Int);
    Int (*initFrame1) (const struct PAF_ASOT_Params *, const struct PAF_ASOT_Patchs *, struct PAF_ASOT_Config *, Int, Int);
    //Int (*passProcessing) (const struct PAF_AST_Params *, const struct PAF_AST_Patchs *, struct PAF_AST_Config *, Int);
    //Int (*passProcessingCopy) (const struct PAF_AST_Params *, const struct PAF_AST_Patchs *, struct PAF_AST_Config *);
    //Int (*autoProcessing) (const struct PAF_AST_Params *, const struct PAF_AST_Patchs *, struct PAF_AST_Config *, Int, ALG_Handle);
    Int (*decodeProcessing) (const struct PAF_ASOT_Params *, const struct PAF_ASOT_Patchs *, struct PAF_ASOT_Config *, Int);    
    //Int (*decodeCommand) (const struct PAF_AST_Params *, const struct PAF_AST_Patchs *, struct PAF_AST_Config *);
    Int (*encodeCommand) (const struct PAF_ASOT_Params *, const struct PAF_ASOT_Patchs *, struct PAF_ASOT_Config *);
    Int (*decodeInit) (const struct PAF_ASOT_Params *, const struct PAF_ASOT_Patchs *, struct PAF_ASOT_Config *, Int);
    //Int (*decodeInfo) (const struct PAF_AST_Params *, const struct PAF_AST_Patchs *, struct PAF_AST_Config *, Int, Int);
    Int (*decodeInfo1) (const struct PAF_ASOT_Params *, const struct PAF_ASOT_Patchs *, struct PAF_ASOT_Config *, Int, Int);
    Int (*decodeInfo2) (const struct PAF_ASOT_Params *, const struct PAF_ASOT_Patchs *, struct PAF_ASOT_Config *, Int, Int);
    //Int (*decodeCont) (const struct PAF_AST_Params *, const struct PAF_AST_Patchs *, struct PAF_AST_Config *, ALG_Handle *, Int, Int);
    //Int (*decodeDecode) (const struct PAF_AST_Params *, const struct PAF_AST_Patchs *, struct PAF_AST_Config *, Int, Int, Int);
    Int (*decodeStream) (const struct PAF_ASOT_Params *, const struct PAF_ASOT_Patchs *, struct PAF_ASOT_Config *, Int, Int);
    Int (*decodeEncode) (const struct PAF_ASOT_Params *, const struct PAF_ASOT_Patchs *, struct PAF_ASOT_Config *, Int, Int);
    //Int (*decodeFinalTest) (const struct PAF_AST_Params *, const struct PAF_AST_Patchs *, struct PAF_AST_Config *, Int, Int);    
    Int (*decodeComplete) (const struct PAF_ASOT_Params *, const struct PAF_ASOT_Patchs *, struct PAF_ASOT_Config *, ALG_Handle *, Int, Int);
    Int (*selectDevices) (const struct PAF_ASOT_Params *, const struct PAF_ASOT_Patchs *, struct PAF_ASOT_Config *);
    //Int (*sourceDecode) (const struct PAF_AST_Params *, const struct PAF_AST_Patchs *, struct PAF_AST_Config *, Int);
    Int (*startOutput) (const struct PAF_ASOT_Params *, const struct PAF_ASOT_Patchs *, struct PAF_ASOT_Config *);
    Int (*stopOutput) (const struct PAF_ASOT_Params *, const struct PAF_ASOT_Patchs *, struct PAF_ASOT_Config *);
    Int (*setCheckRateX) (const struct PAF_ASOT_Params *, const struct PAF_ASOT_Patchs *, struct PAF_ASOT_Config *, Int);
    Int (*streamChainFunction) (const struct PAF_ASOT_Params *, const struct PAF_ASOT_Patchs *, struct PAF_ASOT_Config *, Int, Int, Int);
    Int (*deviceAllocate) (SIO_Handle *, int, int, int, Ptr);
    Int (*deviceSelect) (SIO_Handle *, int, int, Ptr);
    //Int (*computeFrameLength) (Int, Int, Int);
    //Int (*updateInputStatus) (SIO_Handle, PAF_InpBufStatus *, PAF_InpBufConfig *);
    //Int (*copy) (Uns, PAF_InpBufConfig *, Uns, PAF_OutBufConfig *);

    // For RAM_report
    Void (*headerPrint)();
    Int  (*allocPrint)(const PAF_ALG_AllocInit *pInit, Int sizeofInit, PAF_IALG_Config *p);
    Void (*commonPrint)(IALG_MemRec common[], PAF_IALG_Config *p);
    Void (*bufMemPrint)(Int z, Int size, Int heapId, Int bufType);
    Void (*memStatusPrint)(HeapMem_Handle hInternalHeap, HeapMem_Handle hInternal1Heap, HeapMem_Handle hExternalHeap, HeapMem_Handle hInternal1HeapShm);
} PAF_ASOT_Fxns;

// Audio Stream Output Task (ASOT) parameters
typedef struct PAF_ASOT_Params {
    const PAF_ASOT_Fxns *fxns;
    struct {
        SmInt master;
        SmInt inputs;
        SmInt input1;
        SmInt inputN;
        SmInt decodes;
        SmInt decode1;
        SmInt decodeN;
        SmInt streams;
        SmInt stream1; /* unused */
        SmInt streamN; /* unused */
        SmInt encodes;
        SmInt encode1;
        SmInt encodeN;
        SmInt outputs;
        SmInt output1;
        SmInt outputN;
    } zone;
    const SmInt *inputsFromDecodes;
    const SmInt *outputsFromEncodes;
    struct {
        int *pHeapIdIntern;   //int *pIntern;
        int *pHeapIdExtern;   //int *pExtern;
        int *pHeapIdInpbuf;   //int *pInpbuf;
        int *pHeapIdOutbuf;   //int *pOutbuf;
        int *pHeapIdFrmbuf;   //int *pFrmbuf;
        int *pHeapIdIntern1;  //int *pIntern1;
        int clear; 
    } heap;
    struct {
        const IALG_MemSpace *space;
    } common;
    const LgInt *z_rx_bufsiz;
    const LgInt *z_tx_bufsiz;
    const SmInt *z_numchan;
    MdInt framelength;
    const PAF_AudioFunctions *pAudioFrameFunctions;
    const struct PAF_ASP_ChainFxns *pChainFxns;
    const PAF_InpBufStatus *pInpBufStatus;
    const PAF_DecodeStatus * const *z_pDecodeStatus;
    const PAF_OutBufStatus *pOutBufStatus;
    const PAF_EncodeStatus * const *z_pEncodeStatus;
    const PAF_VolumeStatus *pVolumeStatus;
    const PAF_ASP_AlgKey *pDecAlgKey;
    const PAF_ASP_AlgKey *pEncAlgKey;
    const PAF_ASP_SioMap *pDecSioMap;
    const SmInt *streamsFromDecodes;
    const SmInt *streamsFromEncodes;
    const MdInt maxFramelength;
    const SmInt *streamOrder;
    const PAF_ASP_LinkInit * const (*i_inpLinkInit);
    const PAF_ASP_LinkInit * const (*i_outLinkInit);
    const PAF_ASP_outNumBufMap *  const (*poutNumBufMap);
    const PAF_MetadataBufStatus *pMetadataBufStatus;
    const PAF_AudioFrameBufStatus *pAudioFrameBufStatus;
} PAF_ASOT_Params;

// Audio Stream Output Task (ASOT) patchs
typedef struct PAF_ASOT_Patchs {
    //const PAF_SIO_ParamsN * devinp;
    const PAF_SIO_ParamsN * devout;
    //const PAF_ASP_LinkInit * const (*i_decLinkInit);
    const PAF_ASP_LinkInit * const (*i_aspLinkInit)[GEARS];
    const PAF_ASP_LinkInit * const (*i_encLinkInit);
} PAF_ASOT_Patchs;

// Audio Stream Input Task (ASOT) configuration
typedef struct PAF_ASOT_Config {
    ACP_Handle acp;
    PAF_ASPM_Config *pAspmCfg;  // ASIT/ASOT shared configuration
    PAF_AST_Config *pAstCfg;    // ASIT/ASOT/ASDT shared configuration
} PAF_ASOT_Config;


//   Purpose:   Audio Stream Outpu Task Function for initialization of data pointers
//              by allocation of memory.
Int 
PAF_ASOT_initPhaseMalloc(
    const PAF_ASOT_Params *pP, 
    const PAF_ASOT_Patchs *pQ, 
    PAF_ASOT_Config *pC
);
    
//   Purpose:   Audio Stream Output Task Function for initialization of data values
//              from parameters.
Int
PAF_ASOT_initPhaseConfig(
    const PAF_ASOT_Params *pP, 
    const PAF_ASOT_Patchs *pQ, 
    PAF_ASOT_Config *pC
);

//   Purpose:   Audio Stream Output Task Function for initialization of ACP by
//              instantiation of the algorithm.
Int
PAF_ASOT_initPhaseAcpAlg(
    const PAF_ASOT_Params *pP, 
    const PAF_ASOT_Patchs *pQ, 
    PAF_ASOT_Config *pC
);

//   (***) FL: ASIT/ASOT currently consider common memory independently.
//             Should simultaneously consider all algs in ASIT/ASOT.
//   Purpose:   Audio Stream Output Task Function for allocation of common memory.
Int
PAF_ASOT_initPhaseCommon(
    const PAF_ASOT_Params *pP, 
    const PAF_ASOT_Patchs *pQ, 
    PAF_ASOT_Config *pC
);

//   Purpose:   Audio Stream Output Task Function for initialization of ASP algorithms.
Int
PAF_ASOT_initPhaseAspAlg(
    const PAF_ASOT_Params *pP, 
    const PAF_ASOT_Patchs *pQ, 
    PAF_ASOT_Config *pC
);

//   Purpose:   Audio Stream Output Task Function for initialization of data values
//              from parameters for Algorithm Keys.
Int
PAF_ASOT_initPhaseAlgKey(
    const PAF_ASOT_Params *pP, 
    const PAF_ASOT_Patchs *pQ, 
    PAF_ASOT_Config *pC
);

//   Purpose:   Audio Stream Output Task Function for initialization of Input Devices.
Int
PAF_ASOT_initPhaseDevice(
    const PAF_ASOT_Params *pP, 
    const PAF_ASOT_Patchs *pQ, 
    PAF_ASOT_Config *pC
);

//   Purpose:   Audio Stream Output Task Function for initialization of the Audio
//              Frame(s) by memory allocation and loading of data pointers
//              and values.
Int
PAF_ASOT_initFrame0(
    const PAF_ASOT_Params *pP, 
    const PAF_ASOT_Patchs *pQ, 
    PAF_ASOT_Config *pC, 
    Int z
);

//   Purpose:   Audio Stream Task Function for initialization or reinitiali-
//              zation of the Audio Frame(s) by loading of data values of a
//              time-varying nature.
Int
PAF_ASOT_initFrame1(
    const PAF_ASOT_Params *pP, 
    const PAF_ASOT_Patchs *pQ, 
    PAF_ASOT_Config *pC, 
    Int z, 
    Int apply
);

//   Purpose:   Audio Stream Output Task Function for selecting the devices used
//              for output.
Int
PAF_ASOT_selectDevices(
    const PAF_ASOT_Params *pP, 
    const PAF_ASOT_Patchs *pQ, 
    PAF_ASOT_Config *pC
);

//   Purpose:   Audio Stream Output Task Function for processing audio data.
//
Int
PAF_ASOT_decodeProcessing(
    const PAF_ASOT_Params *pP, 
    const PAF_ASOT_Patchs *pQ, 
    PAF_ASOT_Config *pC, 
    Int sourceSelect
);

//   Purpose:   Decoding Function for processing Encode Commands.
Int
PAF_ASOT_encodeCommand(
    const PAF_ASOT_Params *pP, 
    const PAF_ASOT_Patchs *pQ, 
    PAF_ASOT_Config *pC
);

//   Purpose:   Decoding Function for reinitializing the decoding process.
Int
PAF_ASOT_decodeInit(
    const PAF_ASOT_Params *pP, 
    const PAF_ASOT_Patchs *pQ, 
    PAF_ASOT_Config *pC, 
    Int sourceSelect
);

//   Purpose:   Decoding Function for processing information in a manner that
//              is unique to initial frames of input data.
Int
PAF_ASOT_decodeInfo(
    const PAF_ASOT_Params *pP, 
    const PAF_ASOT_Patchs *pQ, 
    PAF_ASOT_Config *pC, 
    Int frame, 
    Int block
);

//   Purpose:   Decoding Function for processing information in a manner that
//              is unique to initial frames of input data.
Int
PAF_ASOT_decodeInfo1(
    const PAF_ASOT_Params *pP, 
    const PAF_ASOT_Patchs *pQ, 
    PAF_ASOT_Config *pC, 
    Int frame, 
    Int block
);

//   Purpose:   Decoding Function for processing information in a manner that
//              is unique to frames of input data other than the initial one.
Int
PAF_ASOT_decodeInfo2(
    const PAF_ASOT_Params *pP, 
    const PAF_ASOT_Patchs *pQ, 
    PAF_ASOT_Config *pC, 
    Int frame, 
    Int block
);

//   Purpose:   Decoding Function for processing of audio frame data by the
//              ASP Algorithms.
Int
PAF_ASOT_decodeStream(
    const PAF_ASOT_Params *pP, 
    const PAF_ASOT_Patchs *pQ, 
    PAF_ASOT_Config *pC, 
    Int frame, 
    Int block
);

//   Purpose:   Decoding Function for processing of audio frame data by the
//              Encode Algorithm.
Int
PAF_ASOT_decodeEncode(
    const PAF_ASOT_Params *pP, 
    const PAF_ASOT_Patchs *pQ, 
    PAF_ASOT_Config *pC, 
    Int frame, 
    Int block
);

//   Purpose:   Decoding Function for terminating the decoding process.
Int
PAF_ASOT_decodeComplete(
    const PAF_ASOT_Params *pP, 
    const PAF_ASOT_Patchs *pQ, 
    PAF_ASOT_Config *pC, 
    ALG_Handle decAlg[], 
    Int frame, 
    Int block
);

//   Purpose:   Decoding Function for initiating output.
Int
PAF_ASOT_startOutput(
    const PAF_ASOT_Params *pP, 
    const PAF_ASOT_Patchs *pQ, 
    PAF_ASOT_Config *pC
);

//   Purpose:   Decoding Function for terminating output.
Int
PAF_ASOT_stopOutput(
    const PAF_ASOT_Params *pP, 
    const PAF_ASOT_Patchs *pQ, 
    PAF_ASOT_Config *pC
);

//   Purpose:   Decoding Function for re-initiating output.
Int
PAF_ASOT_setCheckRateX(
    const PAF_ASOT_Params *pP, 
    const PAF_ASOT_Patchs *pQ, 
    PAF_ASOT_Config *pC, 
    Int check
);

//   Purpose:   Common Function for processing algorithm chains.
Int
PAF_ASOT_streamChainFunction(
    const PAF_ASOT_Params *pP, 
    const PAF_ASOT_Patchs *pQ, 
    PAF_ASOT_Config *pC, 
    Int iChainFrameFxns, 
    Int abortOnError, 
    Int logArg
);

#endif /* _ASOP_H_ */