pasdk/test_dsp/framework/audioStreamInpDec.c

   1 /*
   2 Copyright (c) 2016, Texas Instruments Incorporated - http://www.ti.com/
   3 All rights reserved.
   4
   5 * Redistribution and use in source and binary forms, with or without
   6 * modification, are permitted provided that the following conditions
   7 * are met:
   8 *
   9 * Redistributions of source code must retain the above copyright
  10 * notice, this list of conditions and the following disclaimer.
  11 *
  12 * Redistributions in binary form must reproduce the above copyright
  13 * notice, this list of conditions and the following disclaimer in the
  14 * documentation and/or other materials provided with the
  15 * distribution.
  16 *
  17 * Neither the name of Texas Instruments Incorporated nor the names of
  18 * its contributors may be used to endorse or promote products derived
  19 * from this software without specific prior written permission.
  20 *
  21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  22 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  24 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  25 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  26 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  27 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  28 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  29 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  30 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  31 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  32 *
  33 */
  34
  35 /*
  36  *  ======== audioStreamInpDec.c ========
  37  */
  38 #include <ti/sysbios/hal/Cache.h>
  39 #include <xdc/runtime/Log.h>
  40
  41 #include "procsdk_audio_typ.h"
  42 #include "audioStreamInpProc.h"
  43 #include "audioStreamProc_common.h"
  44 #include "aspMsg_common.h"
  45 #include "aspMsg_master.h"
  46 #include "asperr.h"
  47 #include "common.h"
  48 #include "as1-f2.h"
  49
  50 #include "ioConfig.h"    //TODO: remove this header
  51 #include "ioBuff.h"
  52 #include "ioPhy.h"
  53 #include "ioData.h"
  54
  55
  56 extern void asitPostInfoEvent();    // TODO: remove
  57 extern void asitPostDecEvent();     // TODO: remove
  58
  59 enum {
  60     DEC_STATE_INFO_SND,
  61     DEC_STATE_INFO_ACK_DECODE_SND,
  62     DEC_STATE_DECODE_ACK,
  63     DEC_STATE_QUIT
  64 };
  65
  66 static Int decodeInit(const PAF_ASIT_Params *pP, PAF_ASIT_Config *pAsitCfg,
  67                       Int sourceSelect);
  68
  69 static Int decDecodeComplete(const PAF_ASIT_Params *pP,
  70                              PAF_ASIT_Config *pAsitCfg);
  71
  72 static Int decErrorCheck(const PAF_ASIT_Params *pP, const PAF_ASIT_Patchs *pQ,
  73                          PAF_ASIT_Config *pAsitCfg, Int sourceSelect);
  74 static Int decInfoSnd(const PAF_ASIT_Params *pP, const PAF_ASIT_Patchs *pQ,
  75                          PAF_ASIT_Config *pAsitCfg);
  76 static Int decInfoAck(const PAF_ASIT_Params *pP, const PAF_ASIT_Patchs *pQ,
  77                          PAF_ASIT_Config *pAsitCfg);
  78 static Int decDecodeAck(const PAF_ASIT_Params *pP, const PAF_ASIT_Patchs *pQ,
  79                            PAF_ASIT_Config *pAsitCfg);
  80 static Int decDecodeSnd(const PAF_ASIT_Params *pP, const PAF_ASIT_Patchs *pQ,
  81                            PAF_ASIT_Config *pAsitCfg);
  82 static Int decDecodeFinalTest(const PAF_ASIT_Params *pP, const PAF_ASIT_Patchs *pQ,
  83                               PAF_ASIT_Config *pAsitCfg);
  84 Int decCheckMajorAu(PAF_AST_Config *pAstCfg);
  85
  86 extern UInt32 gCbWrtAfErrCnt;
  87
  88
  89 Int decDecodeInit(
  90         const PAF_ASIT_Params *pP,
  91         PAF_ASIT_Config *pAsitCfg,
  92         Int sourceSelect)
  93 {
  94     Int errno;
  95
  96     errno = decodeInit(pP, pAsitCfg, sourceSelect);
  97
  98     if(errno) {
  99         decDecodeComplete(pP, pAsitCfg);
 100
 101         return ASIP_ERR_DECODE_INIT;
 102     }
 103
 104     pAsitCfg->inpDec.majorAuFound = FALSE;
 105
 106     return ASIP_NO_ERR;
 107 }
 108
 109
 110 // -----------------------------------------------------------------------------
 111 // -----------------------------------------------------------------------------
 112 Int decDecodeFsm(
 113         const PAF_ASIT_Params *pP,
 114         const PAF_ASIT_Patchs *pQ,
 115         PAF_ASIT_Config *pAsitCfg,
 116         Int sourceSelect,
 117         UInt decMsg)
 118 {
 119     asipDecProc_t  *pDec;
 120     Int decErr, decDone;
 121
 122     pDec = &pAsitCfg->inpDec;
 123
 124     TRACE_VERBOSE1("Entering decDecodeFsm with decMsg %d.", decMsg);
 125
 126     decErr = decErrorCheck(pP, pQ, pAsitCfg, sourceSelect);
 127     if(decErr == DEC_ERR_ASPERR_ABORT) {
 128         return decErr;
 129     }
 130     else if(decErr != DEC_NO_ERR) {
 131         pDec->state = DEC_STATE_QUIT;
 132     }
 133     else {
 134         ; // No error
 135     }
 136
 137     // It is possible to go through the FSM multiple times:
 138     //    - Multiple messages may be received, INPDATA and DECACK. In this case,
 139     //      the FSM will process DECACK in state DEC_STATE_DECODE_ACK and then
 140     //      INPDATA in state DEC_STATE_INFO_SND.
 141     //    - DECACK is received after INPDATA. In this case, after DECACK is
 142     //      processed, we will spoof decMsg with INPDATA so that FSM will run
 143     //      again and process INPDATA in DEC_STATE_INFO_SND.
 144     do {
 145         switch(pDec->state)
 146         {
 147         case DEC_STATE_INFO_SND:
 148             if(decMsg != DEC_MSGMSK_INPDATA) {
 149                 // Only DEC_MSGMSK_INPDATA is expected in this state
 150                 decErr = DEC_ERR_WRONG_MSG;
 151             }
 152             else {
 153                 decMsg &= ~DEC_MSGMSK_INPDATA;   // clear bit mask
 154
 155                 // Prepare and send INFO to decoder
 156                 decErr = decInfoSnd(pP, pQ, pAsitCfg);
 157                 if(decErr == DEC_NO_ERR) {
 158                     pDec->state = DEC_STATE_INFO_ACK_DECODE_SND;
 159                     TRACE_VERBOSE0("decDecodeFsm: DEC_STATE_INFO_SND done.");
 160                 }
 161             }
 162         break;
 163
 164         case DEC_STATE_INFO_ACK_DECODE_SND:
 165             //if(decMsg != DEC_MSGMSK_INFOACK) {
 166                 // only DEC_MSGMSK_INFOACK is expected in this state
 167             //if((decMsg&DEC_MSGMSK_INFOACK) != DEC_MSGMSK_INFOACK) {
 168             //    // During debugging, it is possible that INPDATA and INFOACK
 169             //    // come at the same time (e.g. due to breaking point).
 170             //    decErr = DEC_ERR_WRONG_MSG;
 171             //}
 172             //else {
 173
 174             if (decMsg & DEC_MSGMSK_RXACK) {
 175                 decMsg &= ~DEC_MSGMSK_RXACK;  // clear the bit mask
 176
 177                 // Process the INFO acknowledgment from decoder
 178                 decErr = decInfoAck(pP, pQ, pAsitCfg);
 179                 if(decErr == DEC_NO_ERR) {
 180                     // Don't start decode until major access unit is found.
 181                     if(!pDec->majorAuFound) {
 182                         // Do we want to still check major AU after it is found?
 183                         // In old code, it was not checked again after it was found.
 184                         pDec->majorAuFound = decCheckMajorAu(pAsitCfg->pAstCfg);
 185                     }
 186
 187                     if(pDec->majorAuFound) {
 188                         // Major access unit is found. Send message to decoder to decode now.
 189                         decErr = decDecodeSnd(pP, pQ, pAsitCfg);
 190                         if(decErr == DEC_NO_ERR) {
 191                             pDec->state = DEC_STATE_DECODE_ACK;
 192
 193                             // Initialize decodeAckDelayed to FALSE - normally
 194                             // DECODE ACK comes after INPDATA.
 195                             pDec->decodeAckDelayed = FALSE;
 196
 197                             TRACE_VERBOSE0("decDecodeFsm: DEC_STATE_INFO_ACK_DECODE_SND done and going to DEC_STATE_DECODE_ACK.");
 198                         }
 199                     }
 200                     else {
 201                         // No major access unit - go back to INFO.
 202                         pDec->frame++;
 203                         pDec->state = DEC_STATE_INFO_SND;
 204                         TRACE_VERBOSE0("decDecodeFsm: DEC_STATE_INFO_ACK_DECODE_SND done and going to DEC_STATE_INFO_SND.");
 205                     }
 206                 }
 207             }
 208
 209             if (decMsg != 0) {
 210                 decErr = DEC_ERR_WRONG_MSG;
 211             }
 212         break;
 213
 214         case DEC_STATE_DECODE_ACK:
 215             // Two different messages may be received: DECACK (decode acknowledgment)
 216             // or INPDATA (input data ready).
 217             //if(decMsg & DEC_MSGMSK_DECACK) {
 218             //    decMsg &= ~DEC_MSGMSK_DECACK;
 219
 220             if (decMsg & DEC_MSGMSK_RXACK)
 221             {
 222                 decMsg &= ~DEC_MSGMSK_RXACK;  // clear the bit mask
 223
 224                 // Process DECODE ACK from decoder
 225                 decErr = decDecodeAck(pP, pQ, pAsitCfg);
 226                 if(decErr == DEC_NO_ERR) {
 227                     // Decode finishes. Conduct final test.
 228                     decErr = decDecodeFinalTest(pP, pQ, pAsitCfg);
 229                     if(decErr == DEC_NO_ERR) {
 230                         pDec->frame++;
 231                         pDec->state = DEC_STATE_INFO_SND;
 232                         TRACE_VERBOSE0("decDecodeFsm: DEC_STATE_DECODE_ACK done and going to DEC_STATE_INFO_SND.");
 233
 234                         // Check if DECACK comes late (after INPDATA)
 235                         if(pDec->decodeAckDelayed) {
 236                             pDec->decodeAckDelayed = FALSE;
 237
 238                             // Need to prepare and send INFO to decoder immediately.
 239                             // Because INPUT_DATA message is already received,
 240                             // we're just spoofing the message with INPDATA to
 241                             // run the FSM one more time.
 242                             decMsg |= DEC_MSGMSK_INPDATA;
 243
 244                             TRACE_VERBOSE0("decDecodeFsm: Info was delayed.");
 245                         }
 246                     }
 247                 }
 248             }
 249
 250             if (decMsg & DEC_MSGMSK_INPDATA) {
 251                 // If we're here, it means decode acknowledgment from decoder
 252                 // is delayed, i.e., a new frame of input data is ready before
 253                 // current frame decoding is finished.
 254                 decMsg &= ~DEC_MSGMSK_INPDATA;
 255
 256                 // Do nothing but set a flag to postpone action.
 257                 pDec->decodeAckDelayed = TRUE;
 258
 259                 TRACE_VERBOSE0("decDecodeFsm: receiving INPDATA in DEC_STATE_DECODE_ACK");
 260             }
 261
 262             if (decMsg != 0) {
 263                 decErr = DEC_ERR_WRONG_MSG;
 264             }
 265         break;
 266
 267         case DEC_STATE_QUIT:
 268             //gAsipQuitCnt++;
 269             TRACE_VERBOSE0("decDecodeFsm: state: DEC_STATE_QUIT");
 270         break;
 271
 272         default:
 273         break;
 274         } /* switch */
 275
 276         // Loop through the FSM one more time if:
 277         //    - there are more real or spoofed messages to process,
 278         //    - and there is no error.
 279         if((decMsg==0) || (decErr!=DEC_NO_ERR)) {
 280             decDone = TRUE;
 281         }
 282         else {
 283             decDone = FALSE;
 284         }
 285     } while(!decDone);
 286
 287     // Error handling - complete decoding
 288     if(decErr != DEC_NO_ERR) {
 289         TRACE_VERBOSE1("decDecodeFsm: decErr %d, calling decDecodeComplete.", decErr);
 290         decDecodeComplete(pP, pAsitCfg);
 291         TRACE_VERBOSE0("decDecodeFsm: decDecodeComplete done.");
 292     }
 293
 294     return decErr;
 295 } /* decDecodeFsm */
 296
 297
 298 Int decErrorCheck(const PAF_ASIT_Params *pP,
 299                   const PAF_ASIT_Patchs *pQ,
 300                   PAF_ASIT_Config *pAsitCfg,
 301                   Int sourceSelect
 302 )
 303 {
 304     Int retVal, getVal, zMD;
 305     Int8 sourceConfig;
 306
 307     retVal = DEC_NO_ERR;
 308
 309     // Check if source has configured to NONE
 310     zMD = pAsitCfg->pAstCfg->masterDec;
 311     sourceConfig = sharedMemReadInt8(&(pAsitCfg->pAstCfg->xDec[zMD].decodeStatus.sourceSelect),
 312                                      GATEMP_INDEX_DEC);
 313     if (sourceConfig == PAF_SOURCE_NONE || sourceSelect == PAF_SOURCE_NONE) {
 314         TRACE_VERBOSE0("decDecodeFsm: sourceSelect == PAF_SOURCE_NONE");
 315         retVal = DEC_ERR_SOURCE_NONE;
 316     }
 317
 318     // Process commands (decode)
 319     getVal = pP->fxns->decodeCommand(pP, pQ, pAsitCfg);
 320     if (getVal == ASPERR_QUIT) {
 321         TRACE_VERBOSE0("decDecodeFsm. %d: state = QUIT");
 322         retVal = DEC_ERR_ASPERR_QUIT;
 323     }
 324     else if (getVal == ASPERR_ABORT) {
 325         TRACE_VERBOSE0("decDecodeFsm. %d: return getVal");
 326
 327         // Return here if ASPERR_ABORT
 328         retVal = DEC_ERR_ASPERR_ABORT;
 329     }
 330     else {
 331         ;  // No error
 332     }
 333
 334     return retVal;
 335 }  /* decErrorCheck */
 336
 337
 338 Int decCheckMajorAu(PAF_AST_Config *pAstCfg)
 339 {
 340     Int8 sourceDecode, sampleRate;
 341     Int zMD;
 342
 343     zMD = pAstCfg->masterDec;
 344
 345     sourceDecode = sharedMemReadInt8(&(pAstCfg->xDec[zMD].decodeStatus.sourceDecode),
 346                                      GATEMP_INDEX_DEC);
 347     sampleRate   = sharedMemReadInt8(&(pAstCfg->xDec[zMD].decodeStatus.sampleRate),
 348                                      GATEMP_INDEX_DEC);
 349     if ( ( (sourceDecode == PAF_SOURCE_THD)     ||
 350            (sourceDecode == PAF_SOURCE_DXP)     ||
 351            (sourceDecode == PAF_SOURCE_DTSHD)
 352          )
 353        &&( sampleRate == PAF_SAMPLERATE_UNKNOWN)
 354        ) {
 355         return FALSE;
 356     }
 357     else {
 358         return TRUE;
 359     }
 360 } /* decCheckMajorAu*/
 361
 362
 363 // -----------------------------------------------------------------------------
 364 // ASIT Decoding Function - Reinitialization of Decode
 365 //
 366 //   Name:      decDecodeInit
 367 //   Purpose:   Decoding Function for reinitializing the decoding process.
 368 //   From:      AST Parameter Function -> decodeProcessing
 369 //   Uses:      See code.
 370 //   States:    x
 371 //   Return:    Error number in standard or SIO form (0 on success).
 372 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
 373 //              * State information as per parent.
 374 //
 375 // -----------------------------------------------------------------------------
 376 static Int decodeInit(
 377         const PAF_ASIT_Params *pP,
 378         PAF_ASIT_Config *pAsitCfg,
 379         Int sourceSelect)
 380 {
 381     PAF_AST_Config *pAstCfg;
 382     PAF_AST_IoInp  *pInp;
 383     AspMsgMaster_Handle hAspMsgMaster;  // ASIT message master handle
 384     //PAF_AST_DecOpCircBufCtl *pCbCtl;    /* Decoder output circular buffer control */
 385     Int as;                             /* Audio Stream Number (1, 2, etc.) */
 386     Int z;                              /* decode/encode counter */
 387     Int errno;                          /* error number */
 388     Int zI, zS;
 389     Int argIdx;
 390     Int8 tempVar8;
 391     char decMsgBuf[ASP_MSG_BUF_LEN];
 392     Int status;
 393
 394     pAstCfg = pAsitCfg->pAstCfg;                // get pointer to AST common (shared) configuration
 395     pInp    = pAsitCfg->pIoInp;                 // get pointer to IO configuration
 396     hAspMsgMaster = pAsitCfg->hAspMsgMaster;    // get message master handle
 397
 398     as = pAstCfg->as;
 399     (void)as;  // clear compiler warning in case not used with tracing disabled
 400
 401     //pCbCtl = &pAsitCfg->pAspmCfg->decOpCircBufCtl; // get pointer to circular buffer control
 402
 403     // reset frameCount
 404     for (z=DECODE1; z < DECODEN; z++)
 405     {
 406         tempVar8 = sharedMemReadInt8(&(pAstCfg->xDec[z].decodeStatus.mode),
 407                                      GATEMP_INDEX_DEC);
 408         if (tempVar8)
 409         {
 410             sharedMemWriteInt(&(pAstCfg->xDec[z].decodeStatus.frameCount),
 411                               (Int)0, GATEMP_INDEX_DEC);
 412         }
 413     }
 414
 415     // loop through all supported inputs
 416     for (z=DECODE1; z < DECODEN; z++)
 417     {
 418         zI = pP->inputsFromDecodes[z];
 419         zS = pP->streamsFromDecodes[z];
 420         (void)zS; // clear compiler warning in case not used with tracing disabled
 421         tempVar8 = sharedMemReadInt8(&(pAstCfg->xDec[z].decodeStatus.mode),
 422                                      GATEMP_INDEX_DEC);
 423         if (pInp[zI].hIoPhy && tempVar8)
 424         {
 425             Uns gear;
 426             TRACE_VERBOSE1("AS%d: PAF_ASIT_decodeInit: initializing decode", as+zS);
 427
 428             // write back Dec configuration
 429             Cache_wb(&pAstCfg->xDec[z], sizeof(PAF_AST_Decode), Cache_Type_ALLD, 0);
 430             Cache_wait();
 431
 432             // send dec activate message to slave
 433             argIdx = 0; // set decIdx (zone index)
 434             *(Int32 *)&decMsgBuf[argIdx] = z;
 435             status = AspMsgSnd(hAspMsgMaster, ASP_SLAVE_DEC_ACTIVATE, decMsgBuf);
 436             if (status != ASP_MSG_NO_ERR)
 437             {
 438                 TRACE_TERSE0("decodeInit: error in sending DEC_ACTIVATE message ");
 439                 SW_BREAKPOINT; // temporary
 440                 return ASIP_ERR_DECODE_MSG; // temporary
 441             }
 442             status = AspMsgRcvAck(hAspMsgMaster, ASP_MASTER_DEC_ACTIVATE_DONE, NULL, TRUE);
 443             if (status != ASP_MSG_NO_ERR)
 444             {
 445                 TRACE_TERSE0("decodeInit: error in receiving DEC_ACTIVATE_DONE ack message ");
 446                 SW_BREAKPOINT; // temporary
 447                 return ASIP_ERR_DECODE_MSG; // temporary
 448             }
 449
 450             // send dec reset message to slave
 451             argIdx = 0; // set decIdx
 452             *(Int32 *)&decMsgBuf[argIdx] = z;
 453             status = AspMsgSnd(hAspMsgMaster, ASP_SLAVE_DEC_RESET, decMsgBuf);
 454             if (status != ASP_MSG_NO_ERR)
 455             {
 456                 TRACE_TERSE0("decodeInit: error in sending DEC_RESET message ");
 457                 SW_BREAKPOINT; // temporary
 458                 return ASIP_ERR_DECODE_MSG; // temporary
 459             }
 460             status = AspMsgRcvAck(hAspMsgMaster, ASP_MASTER_DEC_RESET_DONE, decMsgBuf, TRUE);
 461             if (status != ASP_MSG_NO_ERR)
 462             {
 463                 TRACE_TERSE0("decodeInit: error in sending DEC_RESET message ");
 464                 SW_BREAKPOINT; // temporary
 465                 return ASIP_ERR_DECODE_MSG; // temporary
 466             }
 467             else
 468             {
 469                 argIdx = 0; // get decErrno
 470                 errno = *(Int32 *)&decMsgBuf[argIdx];
 471             }
 472
 473             // invalidate Dec configuration
 474             Cache_inv(&pAstCfg->xDec[z], sizeof(PAF_AST_Decode), Cache_Type_ALLD, 0);
 475             Cache_wait();
 476
 477             if (errno != 0) {
 478                 return ASIP_ERR_DECODE_MSG;
 479             }
 480
 481             gear = (Uns)sharedMemReadInt8(&(pAstCfg->xDec[z].decodeStatus.aspGearControl),
 482                                           GATEMP_INDEX_DEC);
 483             tempVar8 = gear < GEARS ? gear : 0;
 484             sharedMemWriteInt8(&(pAstCfg->xDec[z].decodeStatus.aspGearStatus),
 485                                tempVar8, GATEMP_INDEX_DEC);
 486
 487             // Compute decoder frame length based on source selection
 488             // JXU: what does this function do? why does it only return PCM frame length?
 489             /*frameLength = getFrameLengthSourceSel(pP, sourceSelect);
 490
 491             pAstCfg->xDec[z].decodeControl.frameLength = frameLength;
 492             pAstCfg->xDec[z].decodeInStruct.sampleCount = frameLength;
 493             pAstCfg->xDec[z].decodeControl.sampleRate = PAF_SAMPLERATE_UNKNOWN;*/
 494
 495 /*
 496             if (z != zMD) {    // JXTODO: implement similar thing with new I/O
 497                 if (errno = SIO_idle(pAstCfg->xInp[zI].hRxSio)) {
 498                     return errno;
 499                 }
 500             }
 501 */
 502 /*//JXTODO: find out if frameLength needs to be passed to I/O DATA or I/O PHY.
 503             ioDataCtl.code = IODATA_CTL_SET_PCM_FRAME_LENGTH;
 504             ioDataCtl.param.frameLengthPcm = frameLength;
 505             ioDataControl(pInp[zI].hIoData, &ioDataCtl);
 506 */
 507             //JXTODO: do we need to update input status here again?
 508             if (errno = asitUpdateInputStatus(pInp[zI].pRxParams,
 509                                               &pAstCfg->xInp[zI].inpBufStatus,
 510                                               &pAstCfg->xInp[zI].inpBufConfig)) {
 511                 return ASIP_ERR_INPUT_CFG;
 512             }
 513         } /* end of if(hIoPhy && decodeStatus.mode) */
 514     } /* end of for (z=DECODE1; z < DECODEN; z++) */
 515
 516     pAsitCfg->inpDec.frame = 0;
 517     pAsitCfg->inpDec.block = 0;
 518     pAsitCfg->inpDec.state = DEC_STATE_INFO_SND;
 519
 520     return ASIP_NO_ERR;
 521 }  /* decDecodeInit */
 522
 523
 524
 525 Int decDecodeComplete( const PAF_ASIT_Params *pP,
 526                        PAF_ASIT_Config *pAsitCfg)
 527 {
 528     PAF_AST_Config *pAstCfg;
 529     AspMsgMaster_Handle hAspMsgMaster;  // ASIT message master handle
 530     Int as;                     /* Audio Stream Number (1, 2, etc.) */
 531     Int z;                      /* decode/encode counter */
 532     Int argIdx;
 533     Int8 tempVar8;
 534     char decMsgBuf[ASP_MSG_BUF_LEN];
 535     Int status;
 536
 537     pAstCfg = pAsitCfg->pAstCfg;                // get pointer to AST common (shared) configuration
 538     hAspMsgMaster = pAsitCfg->hAspMsgMaster;    // get message master handle
 539     as = pAstCfg->as;
 540     (void)as;  // clear compiler warning in case not used with tracing disabled
 541
 542     for (z=DECODE1; z < DECODEN; z++)
 543     {
 544         tempVar8 = sharedMemReadInt8(&(pAstCfg->xDec[z].decodeStatus.mode),
 545                                      GATEMP_INDEX_DEC);
 546         if (pAsitCfg->pIoInp[z].hIoPhy && tempVar8)
 547         {
 548             TRACE_VERBOSE1("decDecodeComplete: AS%d: finalizing decode", as+z);
 549
 550             // send dec deactivate message to slave
 551             argIdx = 0; // set decIdx
 552             *(Int32 *)&decMsgBuf[argIdx] = z;
 553             status = AspMsgSnd(hAspMsgMaster, ASP_SLAVE_DEC_DEACTIVATE, decMsgBuf);
 554             if (status != ASP_MSG_NO_ERR)
 555             {
 556                 TRACE_TERSE0("decodeComplete: error in sending DEC_DEACTIVATE message.");
 557                 SW_BREAKPOINT;
 558                 return DEC_ERR_COMPLETE_MSG;
 559             }
 560             status = AspMsgRcvAck(hAspMsgMaster, ASP_MASTER_DEC_DEACTIVATE_DONE, NULL, TRUE);
 561             if (status != ASP_MSG_NO_ERR)
 562             {
 563                 TRACE_TERSE0("decodeComplete: error in sending DEC_DEACTIVATE message.");
 564                 SW_BREAKPOINT;
 565                 return DEC_ERR_COMPLETE_MSG;
 566             }
 567         }
 568         else
 569         {
 570             TRACE_VERBOSE1("decDecodeComplete: AS%d: processing decode <ignored>", as+z);
 571         }
 572     }
 573
 574     return DEC_NO_ERR;
 575 }  /* decDecodeComplete */
 576
 577
 578 // -----------------------------------------------------------------------------
 579 // Decoding Function - Frame-Final Processing
 580 //
 581 //   Name:      decDecodeFinalTest
 582 //   Purpose:   Decoding Function for determining whether processing of the
 583 //              current frame is complete.
 584 //   From:      AST Parameter Function -> decodeProcessing
 585 //   Uses:      See code.
 586 //   States:    x
 587 //   Return:    0 if incomplete, and 1 if complete.
 588 //   Trace:     None.
 589 //
 590
 591 Int
 592 decDecodeFinalTest(
 593     const PAF_ASIT_Params *pP,
 594     const PAF_ASIT_Patchs *pQ,
 595     PAF_ASIT_Config *pAsitCfg
 596 )
 597 {
 598     PAF_AST_Config *pAstCfg;
 599     Int zMD;
 600     Int sourceSelect;
 601     Int sourceProgram;
 602     Int8 tempVar8, temp2Var8;
 603
 604     pAstCfg = pAsitCfg->pAstCfg; // get pointer to AST common (shared) configuration
 605     zMD = pAstCfg->masterDec;
 606
 607     sourceSelect  = (Int)sharedMemReadInt8(&(pAstCfg->xDec[zMD].decodeStatus.sourceSelect),
 608                                            GATEMP_INDEX_DEC);
 609     sourceProgram = (Int)sharedMemReadInt8(&(pAstCfg->xDec[zMD].decodeStatus.sourceProgram),
 610                                            GATEMP_INDEX_DEC);
 611
 612     if ((sourceSelect == PAF_SOURCE_NONE) || (sourceSelect == PAF_SOURCE_PASS))
 613     {
 614         return DEC_ERR_DECODE_FINAL;
 615     }
 616
 617     // The following allows for Force modes to switch without command deferral. This might
 618     // be better suited for inclusion in DIB_requestFrame, but for now will reside here.
 619     if ((sourceSelect == PAF_SOURCE_SNG) || (sourceSelect > PAF_SOURCE_BITSTREAM))
 620     {
 621         if (sourceSelect == PAF_SOURCE_DTSALL)
 622         {
 623             if (sourceProgram != PAF_SOURCE_DTS11 &&
 624                 sourceProgram != PAF_SOURCE_DTS12 &&
 625                 sourceProgram != PAF_SOURCE_DTS13 &&
 626                 sourceProgram != PAF_SOURCE_DTS14 &&
 627                 sourceProgram != PAF_SOURCE_DTS16 &&
 628                 sourceProgram != PAF_SOURCE_DTSHD)
 629             {
 630                 return DEC_ERR_DECODE_FINAL;
 631             }
 632         }
 633         else if (sourceSelect == PAF_SOURCE_PCMAUTO)
 634         {
 635             if (sourceProgram != PAF_SOURCE_PCM)
 636             {
 637                 return DEC_ERR_DECODE_FINAL;
 638             }
 639         }
 640         else
 641         {
 642             tempVar8  = sharedMemReadInt8(&(pAstCfg->xDec[zMD].decodeStatus.sourceDecode),
 643                                           GATEMP_INDEX_DEC);
 644             temp2Var8 = sharedMemReadInt8(&(pAstCfg->xDec[zMD].decodeStatus.sourceSelect),
 645                                           GATEMP_INDEX_DEC);
 646             if (temp2Var8 != tempVar8)
 647             {
 648                 return DEC_ERR_DECODE_FINAL;
 649             }
 650         }
 651     }
 652
 653     return DEC_NO_ERR;
 654 } //decDecodeFinalTest
 655
 656 Int decInfoSnd(
 657         const PAF_ASIT_Params *pP,
 658         const PAF_ASIT_Patchs *pQ,
 659         PAF_ASIT_Config *pAsitCfg
 660 )
 661 {
 662     PAF_AST_Config *pAstCfg;
 663     PAF_AST_IoInp  *pInp;
 664     AspMsgMaster_Handle hAspMsgMaster;  // ASIT message master handle
 665     Int as;                    /* Audio Stream Number (1, 2, etc.) */
 666     Int z;                     /* input/decode/stream counter */
 667     Int errno;                 /* error number */
 668     Int zD, zI, zS, zX;
 669     Int argIdx;
 670     Int8 tempVar8;
 671     char decMsgBuf[ASP_MSG_BUF_LEN];
 672     Int status;
 673
 674     pAstCfg = pAsitCfg->pAstCfg;                // get pointer to common (shared) configuration
 675     pInp    = pAsitCfg->pIoInp;                 // get pointer to IO configuration
 676     hAspMsgMaster = pAsitCfg->hAspMsgMaster;    // get message master handle
 677     as = pAstCfg->as;
 678
 679     // Set decode control: sample rate, emphasis
 680     for (z=INPUT1; z < INPUTN; z++)
 681     {
 682         zD = z;
 683         for (zX = DECODE1; zX < DECODEN; zX++)
 684         {
 685             if (pP->inputsFromDecodes[zX] == z) {
 686                 zD = zX;
 687                 break;
 688             }
 689         }
 690
 691         if (pInp[z].hIoPhy) {
 692             //determine associated decoder
 693             if (pAstCfg->xInp[z].inpBufStatus.sampleRateStatus !=
 694                 pAstCfg->xDec[zD].decodeControl.sampleRate) {
 695                 if (pAstCfg->xDec[zD].decodeControl.sampleRate == PAF_SAMPLERATE_UNKNOWN) {
 696                     pAstCfg->xDec[zD].decodeControl.sampleRate =
 697                         pAstCfg->xInp[z].inpBufStatus.sampleRateStatus;
 698                 }
 699                 else {
 700                     //TRACE_TERSE1("decDecodeInfo: AS%d: return error ASPERR_INFO_RATECHANGE", as+pAstCfg->masterStr);
 701                     TRACE_TERSE2("inpBufStatus.sampleRateStatus: 0x%x, decodeControl.sampleRate: 0x%x",
 702                         pAstCfg->xInp[z].inpBufStatus.sampleRateStatus,
 703                         pAstCfg->xDec[zD].decodeControl.sampleRate);
 704                     // return (ASPERR_INFO_RATECHANGE);
 705                 }
 706             }
 707
 708             tempVar8 = sharedMemReadInt8(&(pAstCfg->xDec[zD].decodeStatus.sourceDecode),
 709                                          GATEMP_INDEX_DEC);
 710             pAstCfg->xDec[zD].decodeControl.emphasis =
 711                 tempVar8 != PAF_SOURCE_PCM
 712                 ? PAF_IEC_PREEMPHASIS_NO // fix for Mantis ID #119
 713                 : pAstCfg->xInp[z].inpBufStatus.emphasisStatus;
 714         }
 715         else {
 716             pAstCfg->xDec[zD].decodeControl.sampleRate = PAF_SAMPLERATE_UNKNOWN;
 717             pAstCfg->xDec[zD].decodeControl.emphasis = PAF_IEC_PREEMPHASIS_UNKNOWN;
 718         }
 719     } /* end of for (z=INPUT1; z < INPUTN; z++) */
 720
 721     // Decode info
 722     for (z=DECODE1; z < DECODEN; z++)
 723     {
 724         zI = pP->inputsFromDecodes[z];
 725         zS = pP->streamsFromDecodes[z];
 726         (void)zS; // clear compiler warning in case not used with tracing disabled
 727
 728         tempVar8 = sharedMemReadInt8(&(pAstCfg->xDec[z].decodeStatus.mode),
 729                                      GATEMP_INDEX_DEC);
 730         if (pInp[zI].hIoPhy  && tempVar8)
 731         {
 732             TRACE_GEN2("PAF_ASIT_decodeInfo: AS%d: processing frame %d -- info", as+zS, pAsitCfg->inpDec.frame);
 733
 734             if (errno = asitUpdateInputStatus(pInp[zI].pRxParams,
 735                                               &pAstCfg->xInp[zI].inpBufStatus,
 736                                               &pAstCfg->xInp[zI].inpBufConfig)) {
 737                 TRACE_TERSE1("asitUpdateInputStatus return error errno 0x%x.", errno);
 738                 return DEC_ERR_INFO_SNDMSG;
 739             }
 740
 741 #if 0 // debug
 742             // capture input buffer
 743             capIb(pAstCfg->xInp[zI].pInpBuf);
 744             gCapIb_cnt++;
 745 #endif
 746
 747             // write back Inp configuration
 748             Cache_wb(&pAstCfg->xInp[zI], sizeof(PAF_AST_InpBuf), Cache_Type_ALLD, 0);
 749             // write back Dec configuration
 750             Cache_wb(&pAstCfg->xDec[z], sizeof(PAF_AST_Decode), Cache_Type_ALLD, 0);
 751             Cache_wait();
 752
 753             // send info message to slave
 754             argIdx = 0; // set decIdx
 755             *(Int32 *)&decMsgBuf[argIdx] = z;
 756             status = AspMsgSnd(hAspMsgMaster, ASP_SLAVE_DEC_INFO, decMsgBuf);
 757             if (status != ASP_MSG_NO_ERR)
 758             {
 759                 TRACE_TERSE0("decodeInfo: error in sending DEC_INFO message ");
 760                 SW_BREAKPOINT; // temporary
 761                 return -1;     // temporary
 762             }
 763 /*            else
 764             {
 765                 argIdx = 0; // get decErrno
 766                 errno = *(Int32 *)&decMsgBuf[argIdx];
 767             }
 768
 769             if (errno) {
 770                 TRACE_TERSE1("decInfoSndMSg return error errno 0x%x.", errno);
 771                 return DEC_ERR_INFO_SNDMSG;
 772             }
 773 */
 774         }
 775     } // z=DECODE1 to DECODEN
 776
 777 //////////////////////////////////////////////////////////////////////////////
 778     //asitPostInfoEvent(); // simulation
 779 //////////////////////////////////////////////////////////////////////////////
 780
 781     return ASIP_NO_ERR;
 782 }  /* decInfoSnd() */
 783
 784
 785 Int decInfoAck(
 786         const PAF_ASIT_Params *pP,
 787         const PAF_ASIT_Patchs *pQ,
 788         PAF_ASIT_Config *pAsitCfg
 789 )
 790 {
 791     PAF_AST_Config *pAstCfg;
 792     PAF_AST_IoInp  *pInp;
 793     AspMsgMaster_Handle hAspMsgMaster;
 794     Int as;                    /* Audio Stream Number (1, 2, etc.) */
 795     Int z;                     /* input/decode/stream counter */
 796     Int errno;                 /* error number */
 797     Int zI, zS;
 798     Int zMD;
 799     Int zMS;
 800     Int argIdx;
 801     Int8 tempVar8;
 802     Int tempVar;
 803     char decMsgBuf[ASP_MSG_BUF_LEN];
 804     Int status;
 805
 806     pAstCfg = pAsitCfg->pAstCfg;                // get pointer to common (shared) configuration
 807     pInp    = pAsitCfg->pIoInp;                 // get pointer to IO configuration
 808     hAspMsgMaster = pAsitCfg->hAspMsgMaster;    // get message master handle
 809     as = pAstCfg->as;
 810     zMD = pAstCfg->masterDec;
 811     zMS = pAstCfg->masterStr;
 812     (void)zMS;  (void)as;  // clear compiler warning in case not used with tracing disabled
 813
 814     // Decode info
 815     for (z=DECODE1; z < DECODEN; z++)
 816     {
 817         zI = pP->inputsFromDecodes[z];
 818         zS = pP->streamsFromDecodes[z];
 819         (void)zS; // clear compiler warning in case not used with tracing disabled
 820
 821         tempVar8 = sharedMemReadInt8(&(pAstCfg->xDec[z].decodeStatus.mode),
 822                                      GATEMP_INDEX_DEC);
 823         if (pInp[zI].hIoPhy  && tempVar8)
 824         {
 825             // acknowledge info message from slave
 826             errno  = 0;
 827             //argIdx = 0; // set decIdx
 828             //*(Int32 *)&decMsgBuf[argIdx] = z;
 829             status = AspMsgRcvAck(hAspMsgMaster, ASP_MASTER_DEC_INFO_DONE, decMsgBuf, FALSE);
 830             if (status != ASP_MSG_NO_ERR)
 831             {
 832                 TRACE_TERSE0("decodeInfo: error in receiving DEC_INFO_DONE ack message ");
 833                 SW_BREAKPOINT; // temporary
 834                 errno = -1;    // temporary error return value
 835                 return errno;     // temporary
 836             }
 837             else
 838             {
 839                 argIdx = 0; // get decErrno
 840                 errno = *(Int32 *)&decMsgBuf[argIdx];
 841             }
 842
 843             // invalidate Dec configuration
 844             Cache_inv(&pAstCfg->xDec[z], sizeof(PAF_AST_Decode), Cache_Type_ALLD, 0);
 845             Cache_wait();
 846
 847             if (errno) {
 848                 TRACE_TERSE1("decInfoAck return error errno 0x%x.", errno);
 849                 return DEC_ERR_INFO_ACKMSG;
 850             }
 851
 852             // increment decoded frame count
 853             tempVar = sharedMemReadInt(&(pAstCfg->xDec[z].decodeStatus.frameCount),
 854                                        GATEMP_INDEX_DEC);
 855             tempVar += 1;
 856             sharedMemWriteInt(&(pAstCfg->xDec[z].decodeStatus.frameCount),
 857                               tempVar, GATEMP_INDEX_DEC);
 858         }
 859     } // z=DECODE1 to DECODEN
 860
 861     // query IB for latest sourceProgram (needed if we started decoding due to a force mode)
 862     tempVar8 = sharedMemReadInt8(&(pAstCfg->xDec[zMD].decodeStatus.mode),
 863                                  GATEMP_INDEX_DEC);
 864     if (tempVar8)
 865     {
 866         sharedMemWriteInt8(&(pAstCfg->xDec[zMD].decodeStatus.sourceProgram),
 867                            pInp[zMD].sourceProgram, GATEMP_INDEX_DEC);
 868     }
 869
 870     // since now decoding update decode status for all enabled decoders
 871     for (z=DECODE1; z < DECODEN; z++)
 872     {
 873         tempVar8 = sharedMemReadInt8(&(pAstCfg->xDec[z].decodeStatus.mode),
 874                                      GATEMP_INDEX_DEC);
 875         if (tempVar8)
 876         {
 877             tempVar8 = sharedMemReadInt8(&(pAstCfg->xDec[z].decodeStatus.sourceProgram),
 878                                          GATEMP_INDEX_DEC);
 879             sharedMemWriteInt8(&(pAstCfg->xDec[z].decodeStatus.sourceDecode),
 880                                tempVar8, GATEMP_INDEX_DEC);
 881
 882             tempVar8 = sharedMemReadInt8(&(pAstCfg->xDec[z].decodeStatus.sourceSelect),
 883                                          GATEMP_INDEX_DEC);
 884             if (tempVar8 == PAF_SOURCE_SNG)
 885             {
 886                 tempVar8 = PAF_SOURCE_SNG;
 887                 sharedMemWriteInt8(&(pAstCfg->xDec[z].decodeStatus.sourceDecode),
 888                                    tempVar8, GATEMP_INDEX_DEC);
 889             }
 890         }
 891     }
 892
 893     return ASIP_NO_ERR;
 894 }
 895
 896
 897 static Int decDecodeSnd(const PAF_ASIT_Params *pP, const PAF_ASIT_Patchs *pQ,
 898                            PAF_ASIT_Config *pAsitCfg)
 899 {
 900     PAF_AST_Config *pAstCfg;
 901     PAF_AST_IoInp  *pInp;
 902     AspMsgMaster_Handle hAspMsgMaster;  // ASIT message master handle
 903     Int as;                     /* Audio Stream Number (1, 2, etc.) */
 904     Int z;                      /* decode/stream counter */
 905     Int argIdx;
 906     Int cbErrno, errno;
 907     char decMsgBuf[ASP_MSG_BUF_LEN];
 908     Int status;
 909
 910     pAstCfg = pAsitCfg->pAstCfg;                // get pointer to common (shared) configuration
 911     pInp    = pAsitCfg->pIoInp;                 // get pointer to IO configuration
 912     hAspMsgMaster = pAsitCfg->hAspMsgMaster;    // get message master handle
 913     as = pAstCfg->as;
 914     (void)as; // clear compiler warning in case not used with tracing disabled
 915
 916     // Decode data
 917     for (z=DECODE1; z < DECODEN; z++)
 918     {
 919         Int zI = pP->inputsFromDecodes[z];
 920         Int zS = pP->streamsFromDecodes[z];
 921         (void)zS; // clear compiler warning in case not used with tracing disabled
 922         if ( pInp[zI].hIoPhy && pAstCfg->xDec[z].decodeStatus.mode )
 923         {
 924             TRACE_GEN2("PAF_ASIT_decodeDecode: AS%d: decodeDecode: processing block %d -- decode", as+zS, pAsitCfg->inpDec.block);
 925
 926             TRACE_VERBOSE3("PAF_ASIT_decodeDecode: AS%d: decodeDecode: decoding from 0x%x (base) 0x%x (ptr)",
 927                     as+zS,
 928                     (IArg)pAstCfg->xInp[z].pInpBuf->base.pVoid,
 929                     (IArg)pAstCfg->xInp[z].pInpBuf->head.pVoid);
 930
 931 #if 0 // debug
 932             // capture input buffer
 933             capIbPcm(pAstCfg->xInp[z].pInpBuf);
 934 #endif
 935
 936             // write back Dec configuration
 937             Cache_wb(&pAstCfg->xDec[z], sizeof(PAF_AST_Decode), Cache_Type_ALLD, 0);
 938             Cache_wait();
 939
 940             // send decode message to slave
 941             errno  = 0;
 942             argIdx = 0; // set decIdx
 943             *(Int32 *)&decMsgBuf[argIdx] = z;
 944             status = AspMsgSnd(hAspMsgMaster, ASP_SLAVE_DEC_DECODE, decMsgBuf);
 945             if (status != ASP_MSG_NO_ERR)
 946             {
 947                 TRACE_TERSE0("decodeDecode: error in sending DEC_DECODE message ");
 948                 SW_BREAKPOINT; // temporary
 949                 return -1;     // temporary
 950             }
 951 /*            else
 952             {
 953                 argIdx = 0; // get decErrno
 954                 errno = *(Int32 *)&decMsgBuf[argIdx];
 955                 argIdx += sizeof(Int32); // get cbErrno
 956                 cbErrno = *(Int32 *)&decMsgBuf[argIdx];
 957                 if (cbErrno != 0)
 958                 {
 959                     gCbWrtAfErrCnt++;
 960                     TRACE_TERSE1("CB write error=%d", cbErrno);
 961                     //SW_BREAKPOINT; // temporary
 962                 }
 963
 964                 if(errno) {
 965                     TRACE_TERSE1("decDecodeSnd return error errno 0x%x.", errno);
 966                     return DEC_ERR_DECODE_SNDMSG;
 967                 }
 968             }*/
 969
 970         } // hIoPhy && decodeStatus.mode
 971         else {
 972             TRACE_VERBOSE2("AS%d: PAF_ASIT_decodeDecode: processing block %d -- decode <ignored>", as+zS, pAsitCfg->inpDec.block);
 973         }
 974     } // z=DECODE1 to DECODEN
 975
 976 //////////////////////////////////////////////////////////////////////////////
 977     //asitPostDecEvent(); // simulation
 978 //////////////////////////////////////////////////////////////////////////////
 979
 980     return ASIP_NO_ERR;
 981 } /* decDecodeSnd() */
 982
 983
 984 static Int decDecodeAck(const PAF_ASIT_Params *pP, const PAF_ASIT_Patchs *pQ,
 985                            PAF_ASIT_Config *pAsitCfg)
 986 {
 987     PAF_AST_Config *pAstCfg;
 988     PAF_AST_IoInp  *pInp;
 989     AspMsgMaster_Handle hAspMsgMaster;  // ASIT message master handle
 990     Int as;                     /* Audio Stream Number (1, 2, etc.) */
 991     Int z;                      /* decode/stream counter */
 992     Int errno;                  /* error number */
 993     Int argIdx;
 994     Int cbErrno;
 995     char decMsgBuf[ASP_MSG_BUF_LEN];
 996     Int status;
 997
 998     pAstCfg = pAsitCfg->pAstCfg;                // get pointer to common (shared) configuration
 999     pInp    = pAsitCfg->pIoInp;                 // get pointer to IO configuration
1000     hAspMsgMaster = pAsitCfg->hAspMsgMaster;    // get message master handle
1001     as = pAstCfg->as;
1002     (void)as; // clear compiler warning in case not used with tracing disabled
1003
1004     // Decode data
1005     for (z=DECODE1; z < DECODEN; z++)
1006     {
1007         Int zI = pP->inputsFromDecodes[z];
1008         Int zS = pP->streamsFromDecodes[z];
1009         (void)zS; // clear compiler warning in case not used with tracing disabled
1010         if ( pInp[zI].hIoPhy && pAstCfg->xDec[z].decodeStatus.mode )
1011         {
1012             // receive decode ack message from slave
1013             errno  = 0;
1014             //argIdx = 0; // set decIdx
1015             //*(Int32 *)&decMsgBuf[argIdx] = z;
1016             status = AspMsgRcvAck(hAspMsgMaster, ASP_MASTER_DEC_DECODE_DONE, decMsgBuf, FALSE);
1017             if (status != ASP_MSG_NO_ERR)
1018             {
1019                 TRACE_TERSE0("decodeDecode: error in receiving DEC_DECODE_DONE ack message ");
1020                 SW_BREAKPOINT; // temporary
1021                 errno = -1; // temporary error return value
1022                 return errno;
1023             }
1024             else
1025             {
1026                 argIdx = 0; // get decErrno
1027                 errno = *(Int32 *)&decMsgBuf[argIdx];
1028                 argIdx += sizeof(Int32); // get cbErrno
1029                 cbErrno = *(Int32 *)&decMsgBuf[argIdx];
1030                 if (cbErrno != 0)
1031                 {
1032                     gCbWrtAfErrCnt++;
1033                     TRACE_TERSE1("CB write error=%d", cbErrno);
1034                     //SW_BREAKPOINT; // temporary
1035                 }
1036             }
1037
1038             // invalidate Dec configuration
1039             Cache_inv(&pAstCfg->xDec[z], sizeof(PAF_AST_Decode), Cache_Type_ALLD, 0);
1040             Cache_wait();
1041
1042             if(errno) {
1043                 TRACE_TERSE1("decDecodeAck return error errno 0x%x.", errno);
1044                 return DEC_ERR_DECODE_ACKMSG;
1045             }
1046
1047 #if (CURRENT_TRACE_MASK & TRACE_MASK_DATA)
1048             as_traceChannels(pAsitCfg, z);
1049 #endif
1050         } // hIoPhy && decodeStatus.mode
1051         else {
1052             TRACE_VERBOSE2("AS%d: PAF_ASIT_decodeDecode: processing block %d -- decode <ignored>", as+zS, pAsitCfg->inpDec.block);
1053         }
1054     } // z=DECODE1 to DECODEN
1055
1056     return ASIP_NO_ERR;
1057 } /* decDecodeAck */
1058
1059
1060 #if 0
1061 Int asipDecodeProcessing(
1062         const PAF_ASIT_Params *pP,
1063         const PAF_ASIT_Patchs *pQ,
1064         PAF_ASIT_Config *pC,
1065         Int sourceSelect)
1066 {
1067     PAF_AST_Config *pAstCfg;
1068     Int errno, retVal;                          /* error number */
1069     Int zMD;
1070
1071     pAstCfg = pC->pAstCfg; // get pointer to common (shared) configuration
1072     zMD = pAstCfg->masterDec;
1073     retVal = ASIP_NO_ERR;
1074
1075     //pAstCfg->xInp[0].inpBufStatus.sampleRateStatus = PAF_SAMPLERATE_192000HZ;  //JXTODO: make this correct
1076     errno = decDecodeInfo(pP, pQ, pC);
1077     if (errno != ASIP_NO_ERR) {
1078         //gAsipInfo1_PrimaryErrCnt++;
1079         TRACE_TERSE1("INFO1: errno 0x%x after decodeInfo, primary timing", errno);
1080         retVal =  ASIP_ERR_DECODE_INFO;
1081     }
1082     else {
1083         // Don't start decode until major access unit is found.
1084         Int8 sourceDecode, sampleRate;
1085         sourceDecode = sharedMemReadInt8(&(pAstCfg->xDec[zMD].decodeStatus.sourceDecode),
1086                                          GATEMP_INDEX_DEC);
1087         sampleRate   = sharedMemReadInt8(&(pAstCfg->xDec[zMD].decodeStatus.sampleRate),
1088                                          GATEMP_INDEX_DEC);
1089         if ( ( (sourceDecode == PAF_SOURCE_THD)     ||
1090                (sourceDecode == PAF_SOURCE_DXP)     ||
1091                (sourceDecode == PAF_SOURCE_DTSHD) ) &&
1092              ( sampleRate == PAF_SAMPLERATE_UNKNOWN) ) {
1093             /* do nothing and return - waiting for major access unit */
1094             pC->inpDec.frame++;
1095             retVal =  ASIP_NO_ERR;
1096         }
1097         else {
1098             errno = decDecodeData(pP, pQ, pC, sourceSelect);
1099             if (errno != ASIP_NO_ERR) {
1100                 //gAsipDecodeErrCnt++;
1101                 TRACE_TERSE1("PAF_ASIT_decodeProcessing: state: DECODE.  decodeDecode err 0x%04x", errno);
1102                 retVal = ASIP_ERR_DECODE_DATA;
1103             }
1104             else {
1105                 errno = pP->fxns->decodeFinalTest(pP, pQ, pC, pC->inpDec.frame, pC->inpDec.block);
1106                 if (errno) {
1107                     retVal = ASIP_ERR_DECODE_FINAL;
1108                 }
1109                 else {
1110                     retVal = ASIP_NO_ERR;
1111                 }
1112             }
1113         }
1114     }
1115
1116     return retVal;
1117 }  /* asipDecodeProcessing */
1118 #endif
1119
1120
1121 #if 0
1122 // -----------------------------------------------------------------------------
1123 // ASIT Processing Function - Decode Processing
1124 //
1125 //   Name:      asipDecodeProcessing
1126 //   Purpose:
1127 //   Return:    Error number in standard form (0 on success).
1128 // -----------------------------------------------------------------------------
1129 Int asipDecodeProcessing(
1130         const PAF_ASIT_Params *pP,
1131         const PAF_ASIT_Patchs *pQ,
1132         PAF_ASIT_Config *pAsitCfg,
1133         Int sourceSelect)
1134 {
1135     PAF_AST_Config *pAstCfg;
1136     asipDecProc_t  *pDec;
1137     Int decError, retVal, getVal;                          /* error number */
1138     Int zMD, decDone;
1139     Int8 tempVar8;
1140
1141     pAstCfg = pAsitCfg->pAstCfg;     // get pointer to common (shared) configuration
1142     zMD = pAstCfg->masterDec;
1143     pDec = &pAsitCfg->inpDec;
1144
1145     retVal = ASIP_NO_ERR;
1146
1147     // Initialization for decode processing
1148     if(!pDec->initDone) {
1149         // Initialize decoder and send message to decoder
1150         retVal = decDecodeInit(pP, pAsitCfg, pAsitCfg->pIoInp[zMD].sourceSelect);
1151         if(retVal != ASIP_NO_ERR) {
1152             decDecodeComplete(pP, pAsitCfg);
1153
1154             return retVal;
1155         }
1156
1157         pDec->initDone = TRUE;
1158     }
1159
1160     // Check if source has configured to NONE
1161     tempVar8 = sharedMemReadInt8(&(pAstCfg->xDec[zMD].decodeStatus.sourceSelect),
1162                                  GATEMP_INDEX_DEC);
1163     if (tempVar8 == PAF_SOURCE_NONE || sourceSelect == PAF_SOURCE_NONE) {
1164         TRACE_VERBOSE0("PAF_ASIT_decodeProcessing: sourceSelect == PAF_SOURCE_NONE");
1165         pAsitCfg->inpDec.state = QUIT;   // skip processing, quit decoding
1166         retVal = ASIP_ERR_DECODE_QUIT;
1167     }
1168
1169     // Process commands (decode)
1170     getVal = pP->fxns->decodeCommand(pP, pQ, pAsitCfg);
1171     if (getVal) {
1172         retVal = ASIP_ERR_DECODE_COMMAND;
1173         if (getVal == ASPERR_QUIT) {
1174             TRACE_VERBOSE0("PAF_ASIT_decodeProcessing. %d: state = QUIT");
1175
1176             // Don't return if ASPERR_QUIT, but skip decode processing and quit
1177             pAsitCfg->inpDec.state = QUIT;
1178         }
1179         else if (getVal == ASPERR_ABORT) {
1180             TRACE_VERBOSE0("PAF_ASIT_decodeProcessing. %d: return getVal");
1181
1182             // Return here if ASPERR_ABORT
1183             return retVal;
1184         }
1185         else {
1186             /* ignore */;
1187         }
1188     }
1189
1190     do {
1191         decDone = TRUE;
1192
1193         switch(pAsitCfg->inpDec.state)
1194         {
1195             case INFO1:
1196                 decError = decDecodeInfo(pP, pQ, pAsitCfg);
1197                 if (decError) {
1198                     //gAsipInfo1_PrimaryErrCnt++;
1199                     TRACE_TERSE1("INFO1: decError 0x%x after decodeInfo, primary timing", decError);
1200                     retVal = ASIP_ERR_DECODE_INFO1;
1201                 }
1202                 else {
1203                     // Don't start decode until major access unit is found.
1204                     Int8 sourceDecode, sampleRate;
1205
1206                     sourceDecode = sharedMemReadInt8(&(pAstCfg->xDec[zMD].decodeStatus.sourceDecode),
1207                                                      GATEMP_INDEX_DEC);
1208                     sampleRate   = sharedMemReadInt8(&(pAstCfg->xDec[zMD].decodeStatus.sampleRate),
1209                                                      GATEMP_INDEX_DEC);
1210                     if ( ( (sourceDecode == PAF_SOURCE_THD)     ||
1211                            (sourceDecode == PAF_SOURCE_DXP)     ||
1212                            (sourceDecode == PAF_SOURCE_DTSHD) ) &&
1213                          ( sampleRate == PAF_SAMPLERATE_UNKNOWN) ) {
1214                         //gMajorAuMissed++; // debug
1215                         pAsitCfg->inpDec.frame++;
1216                         //pAsitCfg->inpDec.state = INFO1;    // stay in this state
1217                     }
1218                     else {
1219                         decError = pP->fxns->decodeInfo1(pP, pQ, pAsitCfg, pAsitCfg->inpDec.frame, pAsitCfg->inpDec.block);
1220                         if(decError) {
1221                             retVal = ASIP_ERR_DECODE_INFO1;
1222                         }
1223                         else {
1224                             pAsitCfg->inpDec.state = DECODE;
1225                             decDone = FALSE;    // go to DECODE state before return
1226                         }
1227                     }
1228                 }
1229                 break;
1230
1231             case INFO2:
1232                 decError = decDecodeInfo(pP, pQ, pAsitCfg);
1233                 if (decError) {
1234                     //gAsipInfo1_PrimaryErrCnt++;
1235                     TRACE_TERSE1("INFO2: decError 0x%x after decodeInfo, primary timing", decError);
1236                     retVal = ASIP_ERR_DECODE_INFO2;
1237                 }
1238                 else {
1239                     pAsitCfg->inpDec.state = DECODE;
1240                     decDone = FALSE;     // go to DECODE state before return
1241                 }
1242                 break;
1243
1244             case DECODE:
1245                 decError = decDecodeData(pP, pQ, pAsitCfg, sourceSelect);
1246                 if (decError) {
1247                     //gAsipDecodeErrCnt++;
1248                     TRACE_TERSE1("PAF_ASIT_decodeProcessing: state: DECODE.  decodeDecode err 0x%04x", decError);
1249                     retVal = ASIP_ERR_DECODE_DATA;
1250                 }
1251                 else {
1252                     decError = pP->fxns->decodeFinalTest(pP, pQ, pAsitCfg, pAsitCfg->inpDec.frame, pAsitCfg->inpDec.block);
1253                     if (decError) {
1254                         retVal = ASIP_ERR_DECODE_FINAL;
1255                     }
1256                     else {
1257                         pAsitCfg->inpDec.frame++;
1258                         pAsitCfg->inpDec.state = INFO2;
1259                     }
1260                 }
1261                 break;
1262
1263             case QUIT:
1264                 //gAsipQuitCnt++;
1265                 Log_info0("TaskAsip: state=QUIT");
1266
1267                 // Quit:
1268                 // - Set error number registers.
1269                 // - Exit state machine to "decode complete" processing.
1270                 TRACE_VERBOSE0("PAF_ASIT_decodeProcessing: state: QUIT");
1271                 break;
1272
1273             default:
1274                 break;
1275
1276         }  /* switch */
1277
1278     } while (!decDone);
1279
1280     if(retVal != ASIP_NO_ERR) {
1281         decDecodeComplete(pP, pAsitCfg);
1282     }
1283
1284     return retVal;
1285 }  /* asipDecodeProcessing */
1286
1287 #endif
1288
1289
1290 /* Nothing past this line */