pasdk/test_dsp/framework/aspDecOpCircBuf_master.c

   1
   2 /*
   3 Copyright (c) 2016, Texas Instruments Incorporated - http://www.ti.com/
   4 All rights reserved.
   5
   6 * Redistribution and use in source and binary forms, with or without
   7 * modification, are permitted provided that the following conditions
   8 * are met:
   9 *
  10 * Redistributions of source code must retain the above copyright
  11 * notice, this list of conditions and the following disclaimer.
  12 *
  13 * Redistributions in binary form must reproduce the above copyright
  14 * notice, this list of conditions and the following disclaimer in the
  15 * documentation and/or other materials provided with the
  16 * distribution.
  17 *
  18 * Neither the name of Texas Instruments Incorporated nor the names of
  19 * its contributors may be used to endorse or promote products derived
  20 * from this software without specific prior written permission.
  21 *
  22 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  23 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  24 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  25 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  26 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  27 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  28 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  29 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  30 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  31 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  32 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  33 *
  34 */
  35
  36 #include <string.h> // for memset()
  37 #include <xdc/std.h>
  38 #include <xdc/runtime/Log.h>
  39 #include <ti/sysbios/hal/Cache.h>
  40 #include <ti/uia/events/UIAEvt.h>
  41 #include <ti/ipc/GateMP.h>
  42
  43 #include "common.h"
  44 #include "paftyp.h"
  45 #include "pafdec.h"
  46 #include "aspDecOpCircBuf_master.h"
  47
  48 #define DEF_SOURCE_SEL          ( PAF_SOURCE_PCM ) // default source select
  49 #define DEF_DEC_OP_FRAME_LEN    ( 256 )     // default decoder output frame length
  50 #define DEF_STR_FRAME_LEN       ( 256 )     // default stream frame length
  51
  52 // Generate mute AF on circular buffer read
  53 static Void cbReadAfMute(
  54     PAF_AudioFrame *pAfRd,      // audio frame into which to read
  55     Int16 strFrameLen           // stream frame length (output transaction size)
  56 );
  57
  58 // Init last audio frame configuration info
  59 static Void cbInitLastAfInfo(
  60     PAF_AudioFrame *pAfRd      // last audio frame stored in CB instance
  61 );
  62
  63 // Generate mute AF on circular buffer read using the last AF configuration info
  64 static Void cbReadMuteWithLastAfInfo (
  65     PAF_AST_DecOpCircBuf *pCb,    // decoder output circular buffer control
  66     PAF_AudioFrame *pAfRd         // audio frame into which to read
  67 );
  68
  69 // Initialize circular buffer control
  70 Int cbCtlInit(
  71     PAF_AST_DecOpCircBufCtl *pCbCtl,    // decoder output circular buffer control
  72     PAF_AST_DecOpCircBuf **pXDecOpCb    // address of decoder output circular buffer base pointer
  73 )
  74 {
  75     GateMP_Params gateParams;
  76     GateMP_Handle gateHandle;
  77
  78     GateMP_Params_init(&gateParams);
  79     gateParams.localProtect = GateMP_LocalProtect_THREAD;
  80     gateParams.remoteProtect = GateMP_RemoteProtect_SYSTEM;
  81     gateParams.name = ASP_DECODE_CB_GATE_NAME;
  82     gateParams.regionId = ASP_DECODE_CB_GATE_REGION_ID;
  83     gateHandle = GateMP_create(&gateParams);
  84     if (gateHandle != NULL)
  85     {
  86         pCbCtl->gateHandle = gateHandle;
  87     }
  88     else
  89     {
  90         pCbCtl->gateHandle = NULL;
  91         return ASP_DECOP_CB_CTL_INIT_INV_GATE;
  92     }
  93
  94     pCbCtl->pXDecOpCb = pXDecOpCb;
  95
  96     return ASP_DECOP_CB_SOK;
  97
  98 }
  99
 100 // Initialize circular buffer
 101 Int cbInit(
 102     PAF_AST_DecOpCircBuf *pCb
 103 )
 104 {
 105     PAF_AudioFrame *pAfCb;
 106     PAF_AudioData *pPcmBuf;
 107     UInt8 *pMetaBuf;
 108     Int8 n;
 109     Int8 i;
 110
 111     // set source select
 112     pCb->sourceSel = DEF_SOURCE_SEL;
 113
 114     // set input frame length
 115     pCb->decOpFrameLen = DEF_DEC_OP_FRAME_LEN;
 116
 117     // set output frame length
 118     pCb->strFrameLen = DEF_STR_FRAME_LEN;
 119
 120     // initialize circular buffer maximum number of audio frames
 121     pCb->maxNumAfCb = ASP_DECOP_CB_MAX_NUM_AF_THD;//ASP_DECOP_CB_MAX_NUM_AF_PCM;
 122     pCb->afWrtIdx = ASP_DECOP_CB_INIT_LAG_PCM;
 123     pCb->afRdIdx = 0;
 124     pCb->pcmRdIdx = 0; // 2*256 in behind
 125
 126     // set default value to PCM configuration
 127     pCb->maxAFChanNum   = ASP_DECOP_CB_MAX_NUM_PCM_CH;
 128     pCb->maxAFSampCount = DEF_DEC_OP_FRAME_LEN;
 129     // initialize audio frames
 130     for (n=0; n<pCb->maxNumAfCb; n++)
 131     {
 132         pAfCb = &pCb->afCb[n];
 133         pAfCb->sampleDecode = PAF_SOURCE_PCM;
 134         PAF_PROCESS_ZERO(pAfCb->sampleProcess);
 135         pAfCb->sampleRate = PAF_SAMPLERATE_48000HZ;
 136         pAfCb->sampleCount = DEF_DEC_OP_FRAME_LEN;
 137         pAfCb->channelConfigurationRequest.full = 0;
 138         pAfCb->channelConfigurationRequest.part.sat = PAF_CC_SAT_SURROUND4;
 139         pAfCb->channelConfigurationRequest.part.sub = PAF_CC_SUB_ONE;
 140         pAfCb->channelConfigurationStream.full = 0;
 141         pAfCb->channelConfigurationStream.part.sat = PAF_CC_SAT_SURROUND4;
 142         pAfCb->channelConfigurationStream.part.sub = PAF_CC_SUB_ONE;
 143     }
 144
 145     // initialize circular buffer current number of frames
 146     pCb->numAfCb = pCb->afWrtIdx - pCb->afRdIdx;
 147
 148     // initialize audio frame PCM buffers
 149     pPcmBuf = pCb->pcmBuf;
 150     pMetaBuf = pCb->metaBuf; //QIN
 151     for (n=0; n<pCb->maxNumAfCb; n++)
 152     {
 153         pAfCb = &pCb->afCb[n];
 154         pAfCb->data.nChannels = ASP_DECOP_CB_MAX_NUM_PCM_CH;
 155         pAfCb->data.nSamples = DEF_DEC_OP_FRAME_LEN;
 156         for (i=0; i<ASP_DECOP_CB_MAX_NUM_PCM_CH; i++)
 157         {
 158             pAfCb->data.sample[i] = pPcmBuf;
 159             memset(pAfCb->data.sample[i], DEF_DEC_OP_FRAME_LEN, 0);
 160             pPcmBuf += DEF_DEC_OP_FRAME_LEN;
 161
 162             pAfCb->data.samsiz[i] = 0;
 163         }
 164
 165         // write metadata information updated by decoder
 166         pAfCb->bsMetadata_type     = PAF_bsMetadata_channelData;    /* non zero if metadata is attached. */
 167         pAfCb->pafBsMetadataUpdate = 0;                             /* indicates whether bit-stream metadata update */
 168         pAfCb->numPrivateMetadata  = 0;                             /* number of valid private metadata (0 or 1 if metadata filtering enabled) */
 169         pAfCb->bsMetadata_offset   = 0;                             /* offset into audio frame for change in bsMetadata_type field */
 170
 171         // Initialize metadata buffers //QIN
 172         for (i=0; i<PAF_MAX_NUM_PRIVATE_MD; i++)
 173         {
 174             pAfCb->pafPrivateMetadata[i].offset = 0;
 175             pAfCb->pafPrivateMetadata[i].size   = 0;
 176             pAfCb->pafPrivateMetadata[i].pMdBuf = pMetaBuf;
 177             pMetaBuf += PAF_MAX_PRIVATE_MD_SZ;
 178         }
 179     }
 180
 181     // reset read/write flags
 182     pCb->writerActiveFlag = 0;
 183     pCb->readerActiveFlag = 0;
 184     pCb->emptyFlag = 0;
 185
 186     // reset error counts
 187     pCb->errUndCnt = 0;
 188     pCb->errOvrCnt = 0;
 189
 190     cbInitLastAfInfo(&pCb->lastAf);
 191
 192     // (***) FL: revisit
 193     // Write back circular buffer configuration
 194     Cache_wb(pCb, sizeof(PAF_AST_DecOpCircBuf), Cache_Type_ALLD, 0);
 195     // Write back AF circular buffer
 196     Cache_wb(pCb->afCb, pCb->maxNumAfCb*sizeof(PAF_AudioFrame), Cache_Type_ALLD, 0);
 197     // Write back PCM data
 198     for (n=0; n<pCb->maxNumAfCb; n++)
 199     {
 200         pAfCb = &pCb->afCb[n];
 201         Cache_wb(pAfCb->data.samsiz, ASP_DECOP_CB_MAX_NUM_PCM_CH*sizeof(PAF_AudioSize), Cache_Type_ALLD, 0);
 202         Cache_wb(pAfCb->data.sample, ASP_DECOP_CB_MAX_NUM_PCM_CH*sizeof(PAF_AudioData *), Cache_Type_ALLD, 0);
 203         for (i=0; i<ASP_DECOP_CB_MAX_NUM_PCM_CH; i++)
 204         {
 205             Cache_wb(pAfCb->data.sample[i], DEF_DEC_OP_FRAME_LEN*sizeof(PAF_AudioData), Cache_Type_ALLD, 0);
 206         }
 207         // FL: unnecessary since part of AF
 208         //for (i=0; i<PAF_MAX_NUM_PRIVATE_MD; i++)     // Write back metadata //QIN
 209         //{
 210         //    Cache_wb(&pAfCb->pafPrivateMetadata[i], sizeof(PAF_PrivateMetadata), Cache_Type_ALLD, 0);
 211         //}
 212     }
 213     Cache_wait();
 214
 215     return ASP_DECOP_CB_SOK;
 216 }
 217
 218 // Initialize circular buffer based on selected source
 219 Int cbInitSourceSel(
 220     PAF_AST_DecOpCircBufCtl *pCbCtl,    // decoder output circular buffer control
 221     Int8 cbIdx,                         // decoder output circular buffer index
 222     Int8 sourceSelect,                  // source select (PCM, DDP, etc.)
 223     Int16 decOpFrameLen,                // decoder output frame length (PCM samples)
 224     Int16 strFrameLen,                  // stream frame length (PCM samples)
 225     Int8 resetRwFlags                   // whether to reset reader, writer, and empty flags
 226 )
 227 {
 228     IArg key;
 229     GateMP_Handle gateHandle;
 230     PAF_AST_DecOpCircBuf *pCb;
 231     PAF_AudioFrame *pAfCb;
 232     PAF_AudioData *pPcmBuf;
 233     UInt8 *pMetaBuf; //QIN
 234     Int8 n;
 235     Int8 i;
 236
 237     // Get gate handle
 238     gateHandle = pCbCtl->gateHandle;
 239     // Enter gate
 240     key = GateMP_enter(gateHandle);
 241
 242     // Get circular buffer base pointer
 243     pCb = &((*pCbCtl->pXDecOpCb)[cbIdx]);
 244
 245     // Invalidate circular buffer configuration
 246     Cache_inv(pCb, sizeof(PAF_AST_DecOpCircBuf), Cache_Type_ALLD, 0);
 247     Cache_wait();
 248
 249     //Log_info1("cbInitSourceSel:afCb=0x%04x", (IArg)pCb->afCb); // FL: debug
 250
 251     // set source select
 252     pCb->sourceSel = sourceSelect;
 253
 254     // set input frame length
 255     pCb->decOpFrameLen = decOpFrameLen;
 256
 257     // set output frame length
 258     pCb->strFrameLen = strFrameLen;
 259
 260     // initialize circular buffer maximum number of audio frames
 261     if (sourceSelect == PAF_SOURCE_PCM)
 262     {
 263         pCb->maxNumAfCb = ASP_DECOP_CB_MAX_NUM_AF_PCM;
 264         // 2*256 in behind
 265         pCb->afWrtIdx = ASP_DECOP_CB_INIT_WRTIDX_PCM;
 266         pCb->afRdIdx = ASP_DECOP_CB_INIT_RDIDX_PCM;
 267         pCb->pcmRdIdx = 0;
 268         pCb->maxAFChanNum = ASP_DECOP_CB_MAX_NUM_PCM_CH;
 269         pCb->maxAFSampCount = DEF_DEC_OP_FRAME_LEN;
 270
 271         // initialize audio frames
 272         for (n=0; n<pCb->maxNumAfCb; n++)
 273         {
 274             pAfCb = &pCb->afCb[n];
 275             pAfCb->sampleDecode = sourceSelect;
 276             PAF_PROCESS_ZERO(pAfCb->sampleProcess);
 277             pAfCb->sampleRate = PAF_SAMPLERATE_48000HZ;
 278             pAfCb->sampleCount = decOpFrameLen;
 279             pAfCb->channelConfigurationRequest.full = 0;
 280             pAfCb->channelConfigurationRequest.part.sat = PAF_CC_SAT_SURROUND4;
 281             pAfCb->channelConfigurationRequest.part.sub = PAF_CC_SUB_ONE;
 282             pAfCb->channelConfigurationStream.full = 0;
 283             pAfCb->channelConfigurationStream.part.sat = PAF_CC_SAT_SURROUND4;
 284             pAfCb->channelConfigurationStream.part.sub = PAF_CC_SUB_ONE;
 285
 286             // write metadata information updated by decoder
 287             pAfCb->bsMetadata_type     = PAF_bsMetadata_channelData;    /* non zero if metadata is attached. */
 288             pAfCb->pafBsMetadataUpdate = 0;                             /* indicates whether bit-stream metadata update */
 289             pAfCb->numPrivateMetadata  = 0;                             /* number of valid private metadata (0 or 1 if metadata filtering enabled) */
 290             pAfCb->bsMetadata_offset   = 0;                             /* offset into audio frame for change in bsMetadata_type field */
 291         }
 292     }
 293     else if ((sourceSelect == PAF_SOURCE_DDP) || (sourceSelect == PAF_SOURCE_AC3))
 294     {
 295         pCb->maxNumAfCb = ASP_DECOP_CB_MAX_NUM_AF_DDP;
 296         // 4*256 in behind
 297         pCb->afWrtIdx = ASP_DECOP_CB_INIT_WRTIDX_DDP;
 298         pCb->afRdIdx = ASP_DECOP_CB_INIT_RDIDX_DDP;
 299         pCb->pcmRdIdx = decOpFrameLen - ASP_DECOP_CB_INIT_LAG_DDP*strFrameLen; // 4*256 behind
 300         pCb->maxAFChanNum = ASP_DECOP_CB_MAX_NUM_PCM_CH_DDP;
 301         pCb->maxAFSampCount = ASP_DECOP_CB_MAX_PCM_FRAME_LEN_48kDDP;
 302
 303         // initialize audio frames
 304         for (n=0; n<pCb->maxNumAfCb; n++)
 305         {
 306             pAfCb = &pCb->afCb[n];
 307             pAfCb->sampleDecode = sourceSelect;
 308             PAF_PROCESS_ZERO(pAfCb->sampleProcess);
 309             pAfCb->sampleRate = PAF_SAMPLERATE_48000HZ;
 310             pAfCb->sampleCount = decOpFrameLen;
 311             pAfCb->channelConfigurationRequest.full = 0;
 312             pAfCb->channelConfigurationRequest.part.sat = PAF_CC_SAT_SURROUND4;
 313             pAfCb->channelConfigurationRequest.part.sub = PAF_CC_SUB_ONE;
 314             pAfCb->channelConfigurationStream.full = 0;
 315             pAfCb->channelConfigurationStream.part.sat = PAF_CC_SAT_SURROUND4;
 316             pAfCb->channelConfigurationStream.part.sub = PAF_CC_SUB_ONE;
 317
 318             // write metadata information updated by decoder
 319             pAfCb->bsMetadata_type     = PAF_bsMetadata_channelData;    /* non zero if metadata is attached. */
 320             pAfCb->pafBsMetadataUpdate = 0;                             /* indicates whether bit-stream metadata update */
 321             pAfCb->numPrivateMetadata  = 0;                             /* number of valid private metadata (0 or 1 if metadata filtering enabled) */
 322             pAfCb->bsMetadata_offset   = 0;                             /* offset into audio frame for change in bsMetadata_type field */
 323         }
 324     }
 325     else if (sourceSelect == PAF_SOURCE_THD)
 326     {
 327         pCb->maxNumAfCb = ASP_DECOP_CB_MAX_NUM_AF_THD;
 328         // 0 in behind
 329         pCb->afWrtIdx = ASP_DECOP_CB_INIT_WRTIDX_THD;
 330         pCb->afRdIdx = ASP_DECOP_CB_INIT_RDIDX_THD;
 331         pCb->pcmRdIdx = 0;
 332         pCb->maxAFChanNum = ASP_DECOP_CB_MAX_NUM_PCM_CH_MAT;
 333         pCb->maxAFSampCount = ASP_DECOP_CB_MAX_PCM_FRAME_LEN_48kMAT;
 334
 335         // initialize audio frames
 336         for (n=0; n<pCb->maxNumAfCb; n++)
 337         {
 338             pAfCb = &pCb->afCb[n];
 339             pAfCb->sampleDecode = sourceSelect;
 340             PAF_PROCESS_ZERO(pAfCb->sampleProcess);
 341             pAfCb->sampleRate = PAF_SAMPLERATE_48000HZ;
 342             pAfCb->sampleCount = decOpFrameLen;
 343             pAfCb->channelConfigurationRequest.full = 0;
 344             pAfCb->channelConfigurationRequest.part.sat = PAF_CC_SAT_SURROUND4;
 345             pAfCb->channelConfigurationRequest.part.sub = PAF_CC_SUB_ONE;
 346             pAfCb->channelConfigurationStream.full = 0;
 347             pAfCb->channelConfigurationStream.part.sat = PAF_CC_SAT_SURROUND4;
 348             pAfCb->channelConfigurationStream.part.sub = PAF_CC_SUB_ONE;
 349
 350             // write metadata information updated by decoder
 351             pAfCb->bsMetadata_type     = PAF_bsMetadata_channelData;    /* non zero if metadata is attached. */
 352             pAfCb->pafBsMetadataUpdate = 0;                             /* indicates whether bit-stream metadata update */
 353             pAfCb->numPrivateMetadata  = 0;                             /* number of valid private metadata (0 or 1 if metadata filtering enabled) */
 354             pAfCb->bsMetadata_offset   = 0;                             /* offset into audio frame for change in bsMetadata_type field */
 355         }
 356     }
 357     else if ((sourceSelect == PAF_SOURCE_DTS)   ||
 358              (sourceSelect == PAF_SOURCE_DTSHD) ||
 359              (sourceSelect == PAF_SOURCE_DTS12) ||
 360              (sourceSelect == PAF_SOURCE_DTS13) ||
 361              (sourceSelect == PAF_SOURCE_DTS14) ||
 362              (sourceSelect == PAF_SOURCE_DTS16) ||
 363              (sourceSelect == PAF_SOURCE_DTSALL)
 364             )
 365     {
 366         pCb->maxNumAfCb = ASP_DECOP_CB_MAX_NUM_AF_DTS;
 367                 // 0 in behind
 368         pCb->afWrtIdx = ASP_DECOP_CB_INIT_WRTIDX_DTS;
 369         pCb->afRdIdx = ASP_DECOP_CB_INIT_RDIDX_DTS;
 370         pCb->pcmRdIdx = 0;
 371         pCb->maxAFChanNum = ASP_DECOP_CB_MAX_NUM_PCM_CH;
 372         pCb->maxAFSampCount = ASP_DECOP_CB_MAX_PCM_FRAME_LEN_48kDTS;
 373
 374         // initialize audio frames
 375         for (n=0; n<pCb->maxNumAfCb; n++)
 376         {
 377             pAfCb = &pCb->afCb[n];
 378             pAfCb->sampleDecode = sourceSelect;
 379             PAF_PROCESS_ZERO(pAfCb->sampleProcess);
 380             pAfCb->sampleRate = PAF_SAMPLERATE_48000HZ;
 381             pAfCb->sampleCount = decOpFrameLen;
 382             pAfCb->channelConfigurationRequest.full = 0;
 383             pAfCb->channelConfigurationRequest.part.sat = PAF_CC_SAT_SURROUND4;
 384             pAfCb->channelConfigurationRequest.part.sub = PAF_CC_SUB_ONE;
 385             pAfCb->channelConfigurationStream.full = 0;
 386             pAfCb->channelConfigurationStream.part.sat = PAF_CC_SAT_SURROUND4;
 387             pAfCb->channelConfigurationStream.part.sub = PAF_CC_SUB_ONE;
 388
 389             // write metadata information updated by decoder
 390             pAfCb->bsMetadata_type     = PAF_bsMetadata_channelData;    /* non zero if metadata is attached. */
 391             pAfCb->pafBsMetadataUpdate = 0;                             /* indicates whether bit-stream metadata update */
 392             pAfCb->numPrivateMetadata  = 0;                             /* number of valid private metadata (0 or 1 if metadata filtering enabled) */
 393             pAfCb->bsMetadata_offset   = 0;                             /* offset into audio frame for change in bsMetadata_type field */
 394         }
 395     }
 396     else
 397     {
 398         SW_BREAKPOINT;
 399
 400         // Leave the gate
 401         GateMP_leave(gateHandle, key);
 402
 403         return ASP_DECOP_CB_INIT_INV_SOURCE_SEL;
 404     }
 405
 406     // initialize circular buffer current number of frames
 407     pCb->numAfCb = pCb->afWrtIdx - pCb->afRdIdx;
 408
 409     // initialize audio frame PCM buffers
 410     pPcmBuf = pCb->pcmBuf;
 411     pMetaBuf = pCb->metaBuf; //QIN
 412     for (n=0; n<pCb->maxNumAfCb; n++)
 413     {
 414         pAfCb = &pCb->afCb[n];
 415         pAfCb->data.nChannels = pCb->maxAFChanNum;
 416         pAfCb->data.nSamples = decOpFrameLen;
 417         for (i=0; i<pCb->maxAFChanNum; i++)
 418         {
 419             pAfCb->data.sample[i] = pPcmBuf;
 420             memset(pAfCb->data.sample[i], pCb->maxAFSampCount, 0);
 421             pPcmBuf += pCb->maxAFSampCount;
 422
 423             pAfCb->data.samsiz[i] = 0;
 424         }
 425
 426         // Initialize metadata buffers //QIN
 427         for (i=0; i<PAF_MAX_NUM_PRIVATE_MD; i++)
 428         {
 429             pAfCb->pafPrivateMetadata[i].offset = 0;
 430             pAfCb->pafPrivateMetadata[i].size   = 0;
 431             pAfCb->pafPrivateMetadata[i].pMdBuf = pMetaBuf;
 432             pMetaBuf += PAF_MAX_PRIVATE_MD_SZ;
 433         }
 434     }
 435
 436     // reset read/write flags
 437     if (resetRwFlags)
 438     {
 439         pCb->writerActiveFlag = 0;
 440         pCb->readerActiveFlag = 0;
 441         pCb->emptyFlag = 0;
 442     }
 443
 444     // reset error counts
 445     pCb->errUndCnt = 0;
 446     pCb->errOvrCnt = 0;
 447
 448     // (***) FL: revisit
 449     // Write back circular buffer configuration
 450     Cache_wb(pCb, sizeof(PAF_AST_DecOpCircBuf), Cache_Type_ALLD, 0);
 451     // Write back AF circular buffer
 452     Cache_wb(pCb->afCb, pCb->maxNumAfCb*sizeof(PAF_AudioFrame), Cache_Type_ALLD, 0);
 453     // Write back PCM data
 454     for (n=0; n<pCb->maxNumAfCb; n++)
 455     {
 456         pAfCb = &pCb->afCb[n];
 457         Cache_wb(pAfCb->data.samsiz, pCb->maxAFChanNum*sizeof(PAF_AudioSize), Cache_Type_ALLD, 0);
 458         Cache_wb(pAfCb->data.sample, pCb->maxAFChanNum*sizeof(PAF_AudioData *), Cache_Type_ALLD, 0);
 459         for (i=0; i<pCb->maxAFChanNum; i++)
 460         {
 461             Cache_wb(pAfCb->data.sample[i], pCb->maxAFSampCount*sizeof(PAF_AudioData), Cache_Type_ALLD, 0);
 462         }
 463     }
 464     Cache_wait();
 465
 466     // Leave the gate
 467     GateMP_leave(gateHandle, key);
 468
 469     return ASP_DECOP_CB_SOK;
 470 }
 471
 472 // Start reads from circular buffer
 473 Int cbReadStart(
 474     PAF_AST_DecOpCircBufCtl *pCbCtl,    // decoder output circular buffer control
 475     Int8 cbIdx                          // decoder output circular buffer index
 476 )
 477 {
 478     IArg key;
 479     GateMP_Handle gateHandle;
 480     PAF_AST_DecOpCircBuf *pCb;
 481
 482     // Get gate handle
 483     gateHandle = pCbCtl->gateHandle;
 484     // Enter gate
 485     key = GateMP_enter(gateHandle);
 486
 487     // Get circular buffer base pointer
 488     pCb = &((*pCbCtl->pXDecOpCb)[cbIdx]);
 489
 490     // Invalidate circular buffer configuration
 491     Cache_inv(pCb, sizeof(PAF_AST_DecOpCircBuf), Cache_Type_ALLD, 0);
 492     Cache_wait();
 493
 494     //Log_info1("cbReadStart:afCb=0x%04x", (IArg)pCb->afCb); // FL: debug
 495
 496     // update flags
 497     pCb->readerActiveFlag = 1;
 498
 499     // (***) FL: revisit
 500     // Write back circular buffer configuration
 501     Cache_wb(pCb, sizeof(PAF_AST_DecOpCircBuf), Cache_Type_ALLD, 0);
 502     Cache_wait();
 503
 504     // Leave the gate
 505     GateMP_leave(gateHandle, key);
 506
 507     return ASP_DECOP_CB_SOK;
 508 }
 509
 510 // Stop reads from circular buffer
 511 Int cbReadStop(
 512     PAF_AST_DecOpCircBufCtl *pCbCtl,    // decoder output circular buffer control
 513     Int8 cbIdx                          // decoder output circular buffer index
 514 )
 515 {
 516     IArg key;
 517     GateMP_Handle gateHandle;
 518     PAF_AST_DecOpCircBuf *pCb;
 519
 520     // Get gate handle
 521     gateHandle = pCbCtl->gateHandle;
 522     // Enter gate
 523     key = GateMP_enter(gateHandle);
 524
 525     // Get circular buffer base pointer
 526     pCb = &((*pCbCtl->pXDecOpCb)[cbIdx]);
 527
 528     // Invalidate circular buffer configuration
 529     Cache_inv(pCb, sizeof(PAF_AST_DecOpCircBuf), Cache_Type_ALLD, 0);
 530     Cache_wait();
 531
 532     //Log_info1("cbReadStop:afCb=0x%04x", (IArg)pCb->afCb); // FL: debug
 533
 534     // update flags
 535     pCb->readerActiveFlag = 0;
 536
 537     // (***) FL: revisit
 538     // Write back circular buffer configuration
 539     Cache_wb(pCb, sizeof(PAF_AST_DecOpCircBuf), Cache_Type_ALLD, 0);
 540     Cache_wait();
 541
 542     // Leave the gate
 543     GateMP_leave(gateHandle, key);
 544
 545     return ASP_DECOP_CB_SOK;
 546 }
 547
 548 // Read audio frame from circular buffer
 549 Int cbReadAf(
 550     PAF_AST_DecOpCircBufCtl *pCbCtl,    // decoder output circular buffer control
 551     Int8 cbIdx,                         // decoder output circular buffer index
 552     PAF_AudioFrame *pAfRd               // audio frame into which to read
 553 )
 554 {
 555     IArg key;
 556     GateMP_Handle gateHandle;
 557     PAF_AST_DecOpCircBuf *pCb;
 558     PAF_AudioFrame *pAfCb;
 559     PAF_ChannelMask_HD streamMask;
 560     Int8 i;
 561     Int16 j;
 562     Int8 numMetadata = 0;
 563
 564     // Get gate handle
 565     gateHandle = pCbCtl->gateHandle;
 566     // Enter gate
 567     key = GateMP_enter(gateHandle);
 568
 569     // Get circular buffer base pointer
 570     pCb = &((*pCbCtl->pXDecOpCb)[cbIdx]);
 571
 572     // (***) FL: revisit
 573     // Invalidate circular buffer configuration.
 574     Cache_inv(pCb, sizeof(PAF_AST_DecOpCircBuf), Cache_Type_ALLD, 0);
 575     Cache_wait();
 576
 577     //Log_info1("cbReadAf:afCb=0x%04x", (IArg)pCb->afCb); // FL: debug
 578
 579     if ((pCb->writerActiveFlag == 1) && (pCb->emptyFlag == 1))
 580     {
 581         // This shouldn't occur:
 582         //  writer is active AND draining circular buffer
 583         //Log_info2("cbReadAf: ERROR: writerActiveFlag=%d, emptyFlag=%d", pCb->writerActiveFlag, pCb->emptyFlag); // FL: debug
 584         SW_BREAKPOINT; // FL: debug
 585
 586         // Leave the gate
 587         GateMP_leave(gateHandle, key);
 588
 589         return ASP_DECOP_CB_READ_INVSTATE;
 590     }
 591
 592     if ((pCb->writerActiveFlag == 0) && (pCb->emptyFlag == 0))
 593     {
 594         //
 595         // No active writer, not draining circular buffer.
 596         // Skip UNDerflow check, mute output.
 597         //
 598         //cbReadAfMute(pAfRd, pCb->strFrameLen);
 599         cbReadMuteWithLastAfInfo(pCb, pAfRd);
 600
 601         // Leave the gate
 602         GateMP_leave(gateHandle, key);
 603
 604         return ASP_DECOP_CB_SOK;
 605     }
 606
 607     // (writerActiveFlag,emptyFlag)=(1,0) and (0,1) are left
 608     // Here we are checking (1,0) state here
 609     if ((pCb->writerActiveFlag == 1))
 610     {
 611         // check underflow
 612         if (pCb->numAfCb <= 0)
 613         {
 614             //
 615             // Increment underflow count.
 616             // Mute output on underflow.
 617             //
 618             pCb->errUndCnt++;
 619             //cbReadAfMute(pAfRd, pCb->strFrameLen);
 620             cbReadMuteWithLastAfInfo(pCb, pAfRd);
 621             //SW_BREAKPOINT; // FL: debug
 622
 623             // Write back circular buffer configuration.
 624             Cache_wb(pCb, sizeof(PAF_AST_DecOpCircBuf), Cache_Type_ALLD, 0);
 625             Cache_wait();
 626
 627             // Leave the gate
 628             GateMP_leave(gateHandle, key);
 629
 630             return ASP_DECOP_CB_READ_UNDERFLOW;
 631         }
 632     }
 633
 634     if ((pCb->writerActiveFlag == 1) || (pCb->emptyFlag == 1))
 635     {
 636         //
 637         // Writer active or draining remaining frames in circular buffer.
 638         // Get next output audio frame.
 639         //
 640
 641         // get pointer to current audio frame in circular buffer
 642         pAfCb = &pCb->afCb[pCb->afRdIdx];
 643
 644         // (***) FL: revisit
 645         // Invalidate audio frame
 646         Cache_inv(pAfCb, sizeof(PAF_AudioFrame), Cache_Type_ALLD, 0);
 647         Cache_inv(pAfCb->data.samsiz, pCb->maxAFChanNum*sizeof(PAF_AudioSize), Cache_Type_ALLD, 0);
 648         for (i=0; i<pAfCb->numPrivateMetadata; i++) //QIN // FL: only invalidate numPrivateMetadata
 649         {
 650             Cache_inv(pAfCb->pafPrivateMetadata[i].pMdBuf, pAfCb->pafPrivateMetadata[i].size, Cache_Type_ALLD, 0); // FL: only update metadata package size
 651         }
 652         Cache_wait();
 653
 654         // compute stream mask
 655         streamMask = pAfRd->fxns->channelMask(pAfRd, pAfCb->channelConfigurationStream);
 656
 657         // Invalidate PCM data
 658         for (i = 0; i < pCb->maxAFChanNum; i++)
 659         {
 660             if ((streamMask >> i) & 0x1)
 661             {
 662                 Cache_inv(&pAfCb->data.sample[i][pCb->pcmRdIdx], pCb->strFrameLen*sizeof(PAF_AudioData), Cache_Type_ALLD, 0);
 663             }
 664         }
 665         Cache_wait();
 666
 667         // read audio frame information updated by decoder
 668         pAfRd->sampleDecode = pAfCb->sampleDecode;
 669         PAF_PROCESS_COPY(pAfRd->sampleProcess, pAfCb->sampleProcess);
 670         pAfRd->sampleRate = pAfCb->sampleRate;
 671         pAfRd->sampleCount = pCb->strFrameLen;
 672         pAfRd->channelConfigurationRequest = pAfCb->channelConfigurationRequest;
 673         pAfRd->channelConfigurationStream = pAfCb->channelConfigurationStream;
 674
 675         // read metadata information updated by decoder //QIN
 676         pAfRd->bsMetadata_type     = pAfCb->bsMetadata_type;        /* non zero if metadata is attached. */
 677         pAfRd->pafBsMetadataUpdate = pAfCb->pafBsMetadataUpdate;    /* indicates whether bit-stream metadata update */
 678         pAfRd->numPrivateMetadata  = pAfCb->numPrivateMetadata;     /* number of valid private metadata (0 or 1 if metadata filtering enabled) */
 679         pAfRd->bsMetadata_offset   = pAfCb->bsMetadata_offset;      /* offset into audio frame for change in bsMetadata_type field */
 680
 681         // read PCM samples
 682         for (i = 0; i < pCb->maxAFChanNum; i++)
 683         {
 684             if ((streamMask >> i) & 0x1)
 685             {
 686                 for (j = 0; j < pCb->strFrameLen; j++)
 687                 {
 688                     pAfRd->data.sample[i][j] = pAfCb->data.sample[i][pCb->pcmRdIdx+j];
 689                 }
 690
 691                 pAfRd->data.samsiz[i] = pAfCb->data.samsiz[i];
 692             }
 693         }
 694
 695         for (i = 0; i < PAF_MAX_NUM_PRIVATE_MD; i++)
 696         {
 697             pAfRd->pafPrivateMetadata[i].offset = 0;
 698             pAfRd->pafPrivateMetadata[i].size   = 0;
 699         }
 700
 701         // read metadata //QIN
 702         for (i = 0; i < pAfCb->numPrivateMetadata; i++) // FL: only read numPrivateMetadata
 703         {
 704             // FL: this is done above
 705             ////Invalidate metadata data
 706             //Cache_inv(&pAfCb->pafPrivateMetadata[i], sizeof(PAF_PrivateMetadata), Cache_Type_ALLD, 0);
 707             //Cache_wait();
 708
 709             if ((pAfCb->pafPrivateMetadata[i].offset >= pCb->pcmRdIdx)
 710                  &&(pAfCb->pafPrivateMetadata[i].offset < (pCb->pcmRdIdx + pCb->strFrameLen))
 711                  &&(pAfCb->pafPrivateMetadata[i].size))
 712             {
 713                 // FL: this is done above
 714                 ////Invalidate metadata data
 715                 //Cache_inv(pAfCb->pafPrivateMetadata[i].pMdBuf, pAfCb->pafPrivateMetadata[i].size, Cache_Type_ALLD, 0);
 716                 //Cache_wait();
 717
 718                 // the offset is adjusted for segment [pCb->pcmRdIdx, (pCb->pcmRdIdx + pCb->pafFrameLen)]
 719                 pAfRd->pafPrivateMetadata[numMetadata].offset = pAfCb->pafPrivateMetadata[i].offset - pCb->pcmRdIdx;
 720                 pAfRd->pafPrivateMetadata[numMetadata].size   = pAfCb->pafPrivateMetadata[i].size;
 721                 memcpy(pAfRd->pafPrivateMetadata[numMetadata].pMdBuf, pAfCb->pafPrivateMetadata[i].pMdBuf, pAfCb->pafPrivateMetadata[i].size);
 722                 numMetadata++; //number of metadata associated with current 256 segment of audio samples
 723             }
 724             else //reset un-used buf
 725             {
 726                 pAfRd->pafPrivateMetadata[i].offset = 0;
 727                 pAfRd->pafPrivateMetadata[i].size   = 0;
 728             }
 729
 730         }
 731         pAfRd->numPrivateMetadata = numMetadata; //number of metadata associated with current 256 segment of audio samples
 732
 733         pCb->pcmRdIdx += pCb->strFrameLen; // update PCM read index
 734         if (pCb->pcmRdIdx >= pAfCb->sampleCount)
 735         {
 736             // update audio frame read index
 737             pCb->afRdIdx++;
 738             if (pCb->afRdIdx >= pCb->maxNumAfCb)
 739             {
 740                 pCb->afRdIdx = 0;
 741             }
 742
 743             // update PCM read index
 744             pCb->pcmRdIdx = 0;
 745
 746             // update number of audio frames in circular buffer
 747             pCb->numAfCb--;
 748         }
 749         memcpy (&pCb->lastAf, pAfRd, sizeof(PAF_AudioFrame));
 750     }
 751
 752     if (pCb->emptyFlag == 1)
 753     {
 754         //
 755         // Writer inactive, but remaining frames in circular buffer.
 756         // Update empty flag.
 757         //
 758         if (pCb->numAfCb <= 0)
 759         {
 760             pCb->emptyFlag = 0;
 761         }
 762     }
 763
 764     // (***) FL: revisit
 765     // Write back circular buffer configuration.
 766     // NOTE: Probably only a subset of this information needs to be updated.
 767     Cache_wb(pCb, sizeof(PAF_AST_DecOpCircBuf), Cache_Type_ALLD, 0);
 768     Cache_wait();
 769
 770     // Leave the gate
 771     GateMP_leave(gateHandle, key);
 772
 773     return ASP_DECOP_CB_SOK;
 774 }
 775
 776 // Generate mute AF on circular buffer read
 777 static Void cbReadAfMute(
 778     PAF_AudioFrame *pAfRd,      // audio frame into which to read
 779     Int16 strFrameLen           // stream frame length (output transaction size)
 780 )
 781 {
 782     PAF_ChannelMask_HD streamMask;
 783     Int8 i;
 784
 785     pAfRd->sampleDecode = PAF_SOURCE_PCM;
 786     PAF_PROCESS_ZERO(pAfRd->sampleProcess);
 787     pAfRd->sampleRate = PAF_SAMPLERATE_48000HZ;
 788     pAfRd->sampleCount = strFrameLen;
 789     pAfRd->channelConfigurationRequest.full = 0;
 790     pAfRd->channelConfigurationRequest.part.sat = PAF_CC_SAT_SURROUND4;
 791     pAfRd->channelConfigurationRequest.part.sub = PAF_CC_SUB_ONE;
 792     pAfRd->channelConfigurationStream.full = 0;
 793     pAfRd->channelConfigurationStream.part.sat = PAF_CC_SAT_SURROUND4;
 794     pAfRd->channelConfigurationStream.part.sub = PAF_CC_SUB_ONE;
 795
 796     // compute stream mask
 797     streamMask = pAfRd->fxns->channelMask(pAfRd, pAfRd->channelConfigurationStream);
 798     // Clear PCM data
 799     for (i = 0; i < ASP_DECOP_CB_MAX_NUM_PCM_CH; i++)
 800     {
 801         if ((streamMask >> i) & 0x1)
 802         {
 803             memset(pAfRd->data.sample[i], 0, strFrameLen*sizeof(PAF_AudioData));
 804         }
 805         pAfRd->data.samsiz[i] = 0;
 806     }
 807     // write metadata information updated by decoder
 808     pAfRd->bsMetadata_type     = PAF_bsMetadata_channelData;    /* non zero if metadata is attached. */
 809     pAfRd->pafBsMetadataUpdate = 0;                             /* indicates whether bit-stream metadata update */
 810     pAfRd->numPrivateMetadata  = 0;                             /* number of valid private metadata (0 or 1 if metadata filtering enabled) */
 811     pAfRd->bsMetadata_offset   = 0;                             /* offset into audio frame for change in bsMetadata_type field */
 812 }
 813 // Init last audio frame configuration info
 814 static Void cbInitLastAfInfo(
 815     PAF_AudioFrame *pAfRd      // last audio frame stored in CB instance
 816 )
 817 {
 818     pAfRd->sampleDecode = PAF_SOURCE_PCM;
 819     PAF_PROCESS_ZERO(pAfRd->sampleProcess);
 820     pAfRd->sampleRate = PAF_SAMPLERATE_48000HZ;
 821     pAfRd->sampleCount = DEF_DEC_OP_FRAME_LEN;
 822     pAfRd->channelConfigurationRequest.full = 0;
 823     pAfRd->channelConfigurationRequest.part.sat = PAF_CC_SAT_SURROUND4;
 824     pAfRd->channelConfigurationRequest.part.sub = PAF_CC_SUB_ONE;
 825     pAfRd->channelConfigurationStream.full = 0;
 826     pAfRd->channelConfigurationStream.part.sat = PAF_CC_SAT_SURROUND4;
 827     pAfRd->channelConfigurationStream.part.sub = PAF_CC_SUB_ONE;
 828
 829     pAfRd->bsMetadata_type     = PAF_bsMetadata_none;           /* non zero if metadata is attached. */
 830     pAfRd->pafBsMetadataUpdate = 0;                             /* indicates whether bit-stream metadata update */
 831     pAfRd->numPrivateMetadata  = 0;                             /* number of valid private metadata (0 or 1 if metadata filtering enabled) */
 832     pAfRd->bsMetadata_offset   = 0;                             /* offset into audio frame for change in bsMetadata_type field */
 833 }
 834
 835 // Generate mute AF on circular buffer read using the last AF configuration info
 836 static Void cbReadMuteWithLastAfInfo (
 837     PAF_AST_DecOpCircBuf *pCb,    // decoder output circular buffer control
 838     PAF_AudioFrame *pAfRd         // audio frame into which to read
 839 )
 840 {
 841     PAF_ChannelMask_HD streamMask;
 842     Int8 i;
 843
 844     pAfRd->sampleDecode = pCb->lastAf.sampleDecode;
 845     PAF_PROCESS_ZERO(pAfRd->sampleProcess);
 846     pAfRd->sampleRate  = pCb->lastAf.sampleRate;
 847     pAfRd->sampleCount = pCb->strFrameLen;
 848     pAfRd->channelConfigurationRequest.full     = pCb->lastAf.channelConfigurationRequest.full;
 849     pAfRd->channelConfigurationRequest.part.sat = pCb->lastAf.channelConfigurationRequest.part.sat;
 850     pAfRd->channelConfigurationRequest.part.sub = pCb->lastAf.channelConfigurationRequest.part.sub;
 851     pAfRd->channelConfigurationStream.full      = pCb->lastAf.channelConfigurationStream.full;
 852     pAfRd->channelConfigurationStream.part.sat  = pCb->lastAf.channelConfigurationStream.part.sat;
 853     pAfRd->channelConfigurationStream.part.sub  = pCb->lastAf.channelConfigurationStream.part.sub;
 854
 855     // compute stream mask
 856     streamMask = pAfRd->fxns->channelMask(pAfRd, pAfRd->channelConfigurationStream);
 857     // Clear PCM data
 858     for (i = 0; i < ASP_DECOP_CB_MAX_NUM_PCM_CH; i++)
 859     {
 860         if ((streamMask >> i) & 0x1)
 861         {
 862             memset(pAfRd->data.sample[i], 0, pAfRd->sampleCount*sizeof(PAF_AudioData));
 863         }
 864         pAfRd->data.samsiz[i] = 0;
 865     }
 866     pAfRd->bsMetadata_type     = PAF_bsMetadata_none;           /* non zero if metadata is attached. */
 867     pAfRd->pafBsMetadataUpdate = 0;                             /* indicates whether bit-stream metadata update */
 868     pAfRd->numPrivateMetadata  = 0;                             /* number of valid private metadata (0 or 1 if metadata filtering enabled) */
 869     pAfRd->bsMetadata_offset   = 0;                             /* offset into audio frame for change in bsMetadata_type field */
 870 }
 871