990a758abf82a4eae85f414c1eb6874476a14650
[processor-sdk/performance-audio-sr.git] / pasdk / test_dsp / framework / audioStreamInpProc.c
2 /*
3 Copyright (c) 2017, Texas Instruments Incorporated - http://www.ti.com/
4 All rights reserved.
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 */
36 /*
37  *  ======== audioStreamInpProc.c ========
38  */
40 #include <xdc/std.h>
41 #include <xdc/cfg/global.h>
42 #include <xdc/runtime/Diags.h>
43 #include <xdc/runtime/Error.h>
44 #include <xdc/runtime/Log.h>
45 #include <xdc/runtime/Memory.h>
46 #include <xdc/runtime/System.h>
47 #include <ti/sysbios/BIOS.h>
48 #include <ti/sysbios/hal/Hwi.h>
49 #include <ti/sysbios/hal/Cache.h>
50 #include <ti/sysbios/knl/Clock.h>
51 #include <ti/sysbios/knl/Task.h>
52 #include <ti/ipc/Ipc.h>
53 #include <ti/ipc/MessageQ.h>
54 #include <ti/ipc/MultiProc.h>
56 #include <sio.h>
57 #include <pafsio_ialg.h>
59 #include "common.h"
60 #include "paf_heapMgr.h"
61 #include "aspMsg_common.h"
62 #include "aspMsg_master.h"
63 #include "aspDecOpCircBuf_master.h"
64 #include "aspOutInitSync_master.h"
65 #include "audioStreamProc_common.h"
66 #include "audioStreamProc_master.h"
67 #include "audioStreamInpProc.h"
68 #include "statusOp_common.h"
70 #include "pfp/pfp.h"
71 #include "pfp_app.h"        /* contains all PFP ID's */
72 Int32 gNumPfpAsit1=0; // debug
73 Int32 gNumPfpAsit2=0;
77 // FL: debug
78 #include "dbgCapAf.h"
81 // -----------------------------------------------------------------------------
82 // Debugging Trace Control, local to this file.
83 // 
84 #include "logp.h"
86 #define TRACE_ARC(a)
88 // allows you to set a different trace module in pa.cfg
89 #define TR_MOD  trace
91 // Allow a developer to selectively enable tracing.
92 #define CURRENT_TRACE_MASK      0x27
94 #define TRACE_MASK_TERSE        0x01   // only flag errors and show init
95 #define TRACE_MASK_GENERAL      0x02   // half dozen lines per frame
96 #define TRACE_MASK_VERBOSE      0x04   // trace full operation
97 #define TRACE_MASK_DATA         0x08   // Show data
98 #define TRACE_MASK_TIME         0x10   // Timing related traces
99 #define TRACE_MASK_MSG          0x20   // Message related traces
101 #if !(CURRENT_TRACE_MASK & TRACE_MASK_TERSE)
102     #undef  TRACE_TERSE0
103     #undef  TRACE_TERSE1
104     #undef  TRACE_TERSE2
105     #undef  TRACE_TERSE3
106     #undef  TRACE_TERSE4
107     #define TRACE_TERSE0(a)
108     #define TRACE_TERSE1(a,b)
109     #define TRACE_TERSE2(a,b,c)
110     #define TRACE_TERSE3(a,b,c,d)
111     #define TRACE_TERSE4(a,b,c,d,e)
112 #endif
114 #if !(CURRENT_TRACE_MASK & TRACE_MASK_GENERAL)
115     #undef  TRACE_GEN0
116     #undef  TRACE_GEN1
117     #undef  TRACE_GEN2
118     #undef  TRACE_GEN3
119     #undef  TRACE_GEN4
120     #define TRACE_GEN0(a)
121     #define TRACE_GEN1(a,b)
122     #define TRACE_GEN2(a,b,c)
123     #define TRACE_GEN3(a,b,c,d)
124     #define TRACE_GEN4(a,b,c,d,e)
125 #endif
127 #if (CURRENT_TRACE_MASK & TRACE_MASK_VERBOSE)
128     // consolidate list of processing strings, indexed by PAF_SOURCE
129     static char *procName[] =
130     {
131         "", //PAF_SOURCE_UNKNOWN
132         "", //PAF_SOURCE_NONE
133         "AS%d: Pass processing ...",   //PAF_SOURCE_PASS
134         "AS%d: SNG processing ...",    //PAF_SOURCE_SNG
135         "AS%d: Auto processing ...",   //PAF_SOURCE_AUTO
136         "AS%d: Auto processing ...",   //PAF_SOURCE_BITSTREAM
137         "AS%d: DTS processing ...",    //PAF_SOURCE_DTSALL
138         "AS%d: PCM processing ...",    //PAF_SOURCE_PCMAUTO
139         "AS%d: PCM processing ...",    //PAF_SOURCE_PCM
140         "AS%d: PCN processing ...",    //PAF_SOURCE_PC8
141         "AS%d: AC3 processing ...",    //PAF_SOURCE_AC3
142         "AS%d: DTS processing ...",    //PAF_SOURCE_DTS
143         "AS%d: AAC processing ...",    //PAF_SOURCE_AAC
144         "AS%d: MPG processing ...",    //PAF_SOURCE_MPEG
145         "AS%d: DTS processing ...",    //PAF_SOURCE_DTS12
146         "AS%d: DTS processing ...",    //PAF_SOURCE_DTS13
147         "AS%d: DTS processing ...",    //PAF_SOURCE_DTS14
148         "AS%d: DTS processing ...",    //PAF_SOURCE_DTS16
149         "AS%d: WMP processing ...",    //PAF_SOURCE_WMA9PRO
150         "AS%d: MP3 processing ...",    //PAF_SOURCE_MP3
151         "AS%d: DSD processing ...",    //PAF_SOURCE_DSD1
152         "AS%d: DSD processing ...",    //PAF_SOURCE_DSD2
153         "AS%d: DSD processing ...",    //PAF_SOURCE_DSD3
154         "AS%d: DDP processing ...",    //PAF_SOURCE_DDP
155         "AS%d: DTSHD processing ...",  //PAF_SOURCE_DTSHD
156         "AS%d: THD processing ...",    //PAF_SOURCE_THD
157         "AS%d: DXP processing ...",    //PAF_SOURCE_DXP
158         "AS%d: WMA processing ...",    //PAF_SOURCE_WMA
159     };
161 #else
162     #undef  TRACE_VERBOSE0
163     #undef  TRACE_VERBOSE1
164     #undef  TRACE_VERBOSE2
165     #undef  TRACE_VERBOSE3
166     #undef  TRACE_VERBOSE4
167     #define TRACE_VERBOSE0(a)
168     #define TRACE_VERBOSE1(a,b)
169     #define TRACE_VERBOSE2(a,b,c)
170     #define TRACE_VERBOSE3(a,b,c,d)
171     #define TRACE_VERBOSE4(a,b,c,d,e)
172 #endif
174 #if (CURRENT_TRACE_MASK & TRACE_MASK_DATA)
175     #define TRACE_DATA(a) LOG_printf a
176 #else
177     #define TRACE_DATA(a)
178 #endif
180 #if (CURRENT_TRACE_MASK & TRACE_MASK_TIME)
181     #define TRACE_TIME(a) LOG_printf a
182     #define TIME_MOD  trace // this could be different
183     static Int dtime()
184     {
185          static Int old_time = 0;
186          Int time = TSK_time();
187          Int delta_time = time - old_time;
188          old_time = time;
189          return( delta_time);
190     }
192     static char *stateName[11] =
193     {
194          "INIT",
195          "INFO1",
196          "AGAIN",
197          "INFO2",
198          "CONT",
199          "TIME",
200          "DECODE",
201          "STREAM",
202          "ENCODE",
203          "FINAL",
204          "QUIT"
205     };
207 #else
208     #define TRACE_TIME(a)
209 #endif
211 #if !(CURRENT_TRACE_MASK & TRACE_MASK_MSG)
212     #undef  TRACE_MSG0
213     #undef  TRACE_MSG1
214     #undef  TRACE_MSG2
215     #undef  TRACE_MSG3
216     #undef  TRACE_MSG4
217     #define TRACE_MSG0(a)
218     #define TRACE_MSG1(a,b)
219     #define TRACE_MSG2(a,b,c)
220     #define TRACE_MSG3(a,b,c,d)
221     #define TRACE_MSG4(a,b,c,d,e)
222 #endif
223     
225 // .............................................................................
227 #include <pafsio.h>
228 #include "paferr.h"
230 #include <acp_mds.h>
232 #include <pcm.h>
234 #include <pce.h>
236 #include <doberr.h>
238 #include <diberr.h>
240 #include <stdasp.h>
242 #include "as0.h"
243 #include "asperr.h"
245 #include "audioStreamProc_params.h"
246 #include "audioStreamProc_patchs.h"
247 #include "audioStreamProc_config.h"
248 #include "audioStreamInpProc.h"
251 #include "dbgBenchmark.h" // PCM high-sampling rate + SRC + CAR benchmarking
252 #ifdef _ENABLE_BENCHMARK_PCMHSR_SRC_CAR_
253 //
254 // Performing PCM high-sampling rate + SRC + CAR benchmarking
255 //
257 #define PROFILER
258 #endif
260 #ifdef PROFILER
261 extern UInt32 start_profiling;
262 #endif
264 extern UInt32 gAspProfileEnable;
266 //
267 // Audio Stream Definitions
268 //
270 // minimum audio frame "length" in samples (must be multiple of PA_MODULO)
271 #define MINFRAMELENGTH 24
272 #define PA_MODULO       8   // also defined independently in ARC2 code, and may be hard coded other places.
275 //
276 // Decoder Definitions
277 //
278 //#define decLinkInit pQ->i_decLinkInit
280 //
281 // Audio Stream Processing Definitions
282 //
283 //#define aspLinkInit pQ->i_aspLinkInit
285 //
286 // Encoder Definitions
287 //
288 #define encLinkInit pQ->i_encLinkInit
290 //
291 // Input, Output Definitions
292 //
293 #define inpLinkInit pP->i_inpLinkInit
294 //#define outLinkInit pP->i_outLinkInit
296 /* ---------------------------------------------------------------- */
297 /*              Parameter macro definitions end here.               */
298 /* ---------------------------------------------------------------- */
300 //
301 // Standardized Definitions
302 //
304 //#define DEC_Handle PCM_Handle /* works for all: SNG, PCM, AC3, DTS, AAC */
305 //#define ENC_Handle PCE_Handle /* works for all: PCE */
307 #define __TASK_NAME__  "TaskAsip"
310 //
311 // Audio Stream Input Task definitions
312 //
314 #define ASIP_FRAMELEN_SS_DEFAULT    ( 256 )
315 // FL: pP->frameLength
316 //#define ASIP_FRAMELEN_SS_PCM        ( FRAMELENGTH )
317 // FL: (***) hard-coded
318 #define ASIP_FRAMELEN_SS_DDP_AC3    ( 1536 )
319 // FL: (***) hard-coded
320 #define ASIP_FRAMELEN_SS_THD        ( 1536 )        
322 #define ASIP_FRAMELEN_SS_DTS        ( 512 )         
324 // Compute decoder frame length based on selected source
325 static Int getFrameLengthSourceSel(
326     const PAF_ASIT_Params *pP, 
327     Int8 sourceSelect
328 );
330 LINNO_DEFN(TaskAsip); /* Line number macros */
331 ERRNO_DEFN(TaskAsip); /* Error number macros */
333 // ASIT configuration
334 #pragma DATA_SECTION(gPAF_ASIT_config, ".globalSectionPafAsitConfig")
335 PAF_ASIT_Config gPAF_ASIT_config = {
336     NULL,               // taskHandle
337     NULL,               // acp
338     &gPAF_ASPM_config,  // pAspmCfg, shared ASIT/ASOT configuration
339     &gPAF_AST_config    // pAstCfg, shared ASIT/ASOT/ASDT configuration
340 };
342 // Global debug counters */
343 UInt32 gAsipRxSioReclaimCnt     =0;
344 UInt32 gAsipInitCnt             =0;
345 UInt32 gAsipInfo1Cnt            =0;
346 UInt32 gAsipInfo2Cnt            =0;
347 UInt32 gAsipDecodeCnt           =0;
348 UInt32 gAsipDecodeErrCnt        =0;
349 UInt32 gAsipFinalCnt            =0;
350 UInt32 gAsipQuitCnt             =0;
351 UInt32 gAsipInfo1_PrimaryErrCnt =0;
352 UInt32 gAsipInfo1_ErrCnt        =0;
353 UInt32 gAsipInfo2_PrimaryErrCnt =0;
354 UInt32 gAsipInfo2_ErrCnt        =0;
355 // debug
356 UInt32 gCapIbReset_cnt          =0;
357 UInt32 gCapIb_cnt               =0;
358 UInt32 gCbWrtAfErrCnt           =0; // decoder output circular buffer write error count (returned from ARM to DSP)
359                                    
360 // For writeDECCommandRestart
361 volatile UInt32 gCommandOutputTask_SYNC   =0;
362 volatile UInt32 gCommandOutputTask_ACK    =0;
364 #include "dbgDib.h" // debug
366 extern struct {
367     Int size;
368     IALG_Status *pStatus[512];
369 } IACP_STD_BETA_TABLE;
371 // FL: debug
372 #include "evmc66x_gpio_dbg.h"
374 /*
375  *  ======== taskAsipFxn ========
376  *  Audio Stream Input Processing task function
377  */
378 Void taskAsipFxn(
379 //    Int betaPrimeValue, // FL: revisit
380     const PAF_ASIT_Params *pP,
381     const PAF_ASIT_Patchs *pQ
384     PAF_ASIT_Config *pAsitCfg;      /* ASIT configuration pointer */
385     PAF_AST_Config *pAstCfg;        /* AST Common (shared) configuration pointer */
386     Int as;                         /* Audio Stream Number (1, 2, etc.) */
387     Int z;                          /* input/encode/stream/decode/output counter */
388     Int i;                          /* phase */
389     Int errno;                      /* error number */
390     Int zMD, zMI, zMS, zX;
391     Int loopCount = 0;  // used to stop trace to see startup behavior.        
392     Int size;
393     // Messaging
394     ASP_Msg *pAspMsg;              
395     Int status;
396     Int8 tempVar8;
397     char asipMsgBuf[ASP_MSG_BUF_LEN];
399     Log_info0("Enter taskAsipFxn()");
401     //
402     // Audio Stream Input Task Parameters & Patch (*pP, *pQ)
403     //
404     if (!pP) 
405     {
406         TRACE_TERSE0("TaskAsip: No Parameters defined. Exiting.");
407         LINNO_RPRT(TaskAsip, -1);
408         return;
409     }
411     if (!pQ)
412     {
413         TRACE_TERSE0("TaskAsip: No Patchs defined. Exiting.");
414         LINNO_RPRT(TaskAsip, -1);
415         return;
416     }    
417     
418     //
419     // Audio Stream Input Task Configuration (*pAsitCfg):
420     //
421     pAsitCfg = &gPAF_ASIT_config;       // initialize pointer to task configuration
422     pAsitCfg->taskHandle = Task_self(); // set task handle
423     pAstCfg = pAsitCfg->pAstCfg;        // get pointer to AST common (shared) configuration
425     /* Set Audio Stream Number (1, 2, etc.) */
426     as = gBetaPrimeValue + 1;
427     pAstCfg->as = as;    
428     TRACE_TERSE1("TaskAsip: Started with AS%d.", as);
430     //
431     // Initialize message log trace and line number reporting
432     //
433     for (z=STREAM1; z < STREAMN; z++)
434     {
435         TRACE_TERSE1("TaskAsip: AS%d: initiated", as+z);
436     }
437     LINNO_RPRT(TaskAsip, -1);
438     
439     //
440     // Determine decoder and stream indices associated with the master input
441     //
442     zMI = pP->zone.master;
443     pAstCfg->masterDec = zMI;
444     pAstCfg->masterStr = zMI;
445     for (zX = DECODE1; zX < DECODEN; zX++)
446     {
447         if (pP->inputsFromDecodes[zX] == zMI)
448         {
449             pAstCfg->masterDec = zX;
450             pAstCfg->masterStr = pP->streamsFromDecodes[zX];
451             break;
452         }
453     }
454     zMD = pAstCfg->masterDec;
455     zMS = pAstCfg->masterStr;
457     // Initialize as per parametrized phases:
458     //
459     //   In standard form these are:
460     //      - Malloc: Memory Allocation
461     //      - Config: Configuration Initialization
462     //      - AcpAlg: ACP Algorithm Initialization and Local Attachment
463     //      - Common: Common Memory Initialization
464     //      - AlgKey: Dec/Enc chain to Array Initialization
465     //      - Device: I/O Device Initialization
466     //      - DecOpCircBuf: Decoder Output Circular Buffer
467     //      - OutIS: Output Init-Sync
468     //
469     LINNO_RPRT(TaskAsip, -2);
470     for (i=0; i < lengthof(pP->fxns->initPhase); i++)
471     {
472         Int linno;
473         if (pP->fxns->initPhase[i])
474         {
475             linno = pP->fxns->initPhase[i](pP, pQ, pAsitCfg);
476             if (linno) 
477             {
478                 LINNO_RPRT(TaskAsip, linno);
479                 return;
480             }
481         }
482         else 
483         {
484             TRACE_TERSE1("TaskAsip: AS%d: initialization phase - null", as+zMS);
485         }
486         TRACE_TERSE2("TaskAsip: AS%d: initialization phase - %d completed", as+zMS, i);
487         LINNO_RPRT(TaskAsip, -i-3);
488     }
490     //
491     // End of Initialization -- display memory usage report.
492     //
493     if (pP->fxns->memStatusPrint)
494     {
495         pP->fxns->memStatusPrint("ASIT MEMSTAT REPORT",
496             HEAP_INTERNAL, HEAP_INTERNAL1, HEAP_EXTERNAL, 
497             HEAP_INTERNAL1_SHM, HEAP_EXTERNAL_SHM, HEAP_EXTERNAL_NONCACHED_SHM);
498     }
499     
500     // (***) FL: revisit
501     // write back AST shared configuration
502     Cache_wb(pAstCfg, sizeof(PAF_AST_Config), Cache_Type_ALLD, 0);
503     Cache_wait();
505     // (***) FL: revisit
506     // write back Dec configuration
507     Cache_wb(&pAstCfg->xDec[0], DECODEN*sizeof(PAF_AST_Decode), Cache_Type_ALLD, 0);
508     Cache_wait();
510     // (***) FL: revisit
511     // write back entire beta table
512     Cache_wb((Ptr)(&IACP_STD_BETA_TABLE.pStatus[0]), 512*sizeof(IALG_Status *), Cache_Type_ALLD, 0);
513     Cache_wait();
514     
515     // FL: send start initialization message to slave
516     pAspMsg = (ASP_Msg *)MessageQ_alloc(hAspMsgMaster->heapId, hAspMsgMaster->msgSize); /* allocate message */
517     MessageQ_setReplyQueue(hAspMsgMaster->masterQue, (MessageQ_Msg)pAspMsg);            /* set the return address in the message header */
518     pAspMsg->cmd = ASP_SLAVE_START;                                                     /* fill in message payload */
519     pAspMsg->procId = hAspMsgMaster->masterProcId;
520     pAspMsg->messageId = hAspMsgMaster->messageId & ~(1<<31);
521     pAspMsg->expectResp = TRUE;
522     TRACE_MSG3("Tx ASP message: procId=%d, cmd=%d, messageId=0x%04x", pAspMsg->procId, pAspMsg->cmd, pAspMsg->messageId);
523     status = MessageQ_put(hAspMsgMaster->slaveQue, (MessageQ_Msg)pAspMsg);              /* send message */
524     if (status != MessageQ_S_SUCCESS)
525     {
526         SW_BREAKPOINT;
527     }
528     // wait for initialization complete message from slave
529     do {
530         //status = MessageQ_get(hAspMsgMaster->masterQue, (MessageQ_Msg *)&pAspMsg, MessageQ_FOREVER);
531         status = MessageQ_get(hAspMsgMaster->masterQue, (MessageQ_Msg *)&pAspMsg, 0); // FL: no other thread is allowed to run until Slave finished startup
532     } while ((status != MessageQ_S_SUCCESS) || (pAspMsg->cmd != ASP_MASTER_START_DONE));
533     if ((pAspMsg->procId != hAspMsgMaster->slaveProcId) ||
534         (pAspMsg->cmd != ASP_MASTER_START_DONE) || 
535         (pAspMsg->messageId != (hAspMsgMaster->messageId | ((UInt32)1<<31))))
536     {
537         TRACE_TERSE3("ERROR: Rx ASP message: procId=%d, cmd=%d, messageId=0x%04x", pAspMsg->procId, pAspMsg->cmd, pAspMsg->messageId);
538         SW_BREAKPOINT;
539     }
540     hAspMsgMaster->messageId = (hAspMsgMaster->messageId + 1) & ~(1<<31);
541     TRACE_MSG3("Rx ASP message: procId=%d, cmd=%d, messageId=0x%04x", pAspMsg->procId, pAspMsg->cmd, pAspMsg->messageId);
542     status = MessageQ_free((MessageQ_Msg)pAspMsg); /* free the message */
543     if (status != MessageQ_S_SUCCESS)
544     {
545         SW_BREAKPOINT;
546     }
548     // (***) FL: revisit
549     // invalidate Status structure addresses for Beta Units initialized on Slave
550     Cache_inv((Ptr)(&IACP_STD_BETA_TABLE.pStatus[STD_BETA_DECODE]), sizeof(IALG_Status *), Cache_Type_ALLD, 0);
551     Cache_inv((Ptr)(&IACP_STD_BETA_TABLE.pStatus[STD_BETA_PCM]), sizeof(IALG_Status *), Cache_Type_ALLD, 0);
552     Cache_inv((Ptr)(&IACP_STD_BETA_TABLE.pStatus[STD_BETA_PCM2]), sizeof(IALG_Status *), Cache_Type_ALLD, 0);
553     Cache_inv((Ptr)(&IACP_STD_BETA_TABLE.pStatus[STD_BETA_DDP]), sizeof(IALG_Status *), Cache_Type_ALLD, 0);
554     Cache_inv((Ptr)(&IACP_STD_BETA_TABLE.pStatus[STD_BETA_DDP2]), sizeof(IALG_Status *), Cache_Type_ALLD, 0);
555     Cache_inv((Ptr)(&IACP_STD_BETA_TABLE.pStatus[STD_BETA_THD]), sizeof(IALG_Status *), Cache_Type_ALLD, 0);
556     Cache_inv((Ptr)(&IACP_STD_BETA_TABLE.pStatus[STD_BETA_THD2]), sizeof(IALG_Status *), Cache_Type_ALLD, 0);
557     Cache_inv((Ptr)(&IACP_STD_BETA_TABLE.pStatus[STD_BETA_DTSUHDA]), sizeof(IALG_Status *), Cache_Type_ALLD, 0);
558     Cache_wait();
559     if (!IACP_STD_BETA_TABLE.pStatus[STD_BETA_DECODE]) Log_info0("ERROR: beta unit for Dec==NULL");
560     if (!IACP_STD_BETA_TABLE.pStatus[STD_BETA_PCM]) Log_info0("ERROR: beta unit for Dec==NULL");
561     if (!IACP_STD_BETA_TABLE.pStatus[STD_BETA_PCM2]) Log_info0("ERROR: beta unit for Dec==NULL");
562     if (!IACP_STD_BETA_TABLE.pStatus[STD_BETA_DDP]) Log_info0("ERROR: beta unit for Dec==NULL");
563     if (!IACP_STD_BETA_TABLE.pStatus[STD_BETA_DDP2]) Log_info0("ERROR: beta unit for Dec==NULL");
564     if (!IACP_STD_BETA_TABLE.pStatus[STD_BETA_THD]) Log_info0("ERROR: beta unit for Dec==NULL");
565     if (!IACP_STD_BETA_TABLE.pStatus[STD_BETA_THD2]) Log_info0("ERROR: beta unit for Dec==NULL");
566     if (!IACP_STD_BETA_TABLE.pStatus[STD_BETA_DTSUHDA]) Log_info0("ERROR: beta unit for Dec==NULL");
567     
568     // (***) FL: revisit
569     // invalidate Status structures for Beta Units initialized on Slave
570     Cache_inv((Ptr)(IACP_STD_BETA_TABLE.pStatus[STD_BETA_DECODE]), sizeof(Int), Cache_Type_ALLD, 0);
571     size = IACP_STD_BETA_TABLE.pStatus[STD_BETA_DECODE]->size;
572     Cache_inv((Ptr)(IACP_STD_BETA_TABLE.pStatus[STD_BETA_DECODE]), size, Cache_Type_ALLD, 0);
573     Cache_inv((Ptr)(IACP_STD_BETA_TABLE.pStatus[STD_BETA_PCM]), sizeof(Int), Cache_Type_ALLD, 0);
574     size = IACP_STD_BETA_TABLE.pStatus[STD_BETA_PCM]->size;
575     Cache_inv((Ptr)(IACP_STD_BETA_TABLE.pStatus[STD_BETA_PCM]), size, Cache_Type_ALLD, 0);
576     Cache_inv((Ptr)(IACP_STD_BETA_TABLE.pStatus[STD_BETA_PCM2]), sizeof(Int), Cache_Type_ALLD, 0);
577     size = IACP_STD_BETA_TABLE.pStatus[STD_BETA_PCM2]->size;
578     Cache_inv((Ptr)(IACP_STD_BETA_TABLE.pStatus[STD_BETA_PCM2]), size, Cache_Type_ALLD, 0);
579     Cache_inv((Ptr)(IACP_STD_BETA_TABLE.pStatus[STD_BETA_DDP]), sizeof(Int), Cache_Type_ALLD, 0);
580     size = IACP_STD_BETA_TABLE.pStatus[STD_BETA_DDP]->size;
581     Cache_inv((Ptr)(IACP_STD_BETA_TABLE.pStatus[STD_BETA_DDP]), size, Cache_Type_ALLD, 0);
582     Cache_inv((Ptr)(IACP_STD_BETA_TABLE.pStatus[STD_BETA_DDP2]), sizeof(Int), Cache_Type_ALLD, 0);
583     size = IACP_STD_BETA_TABLE.pStatus[STD_BETA_DDP2]->size;
584     Cache_inv((Ptr)(IACP_STD_BETA_TABLE.pStatus[STD_BETA_DDP2]), size, Cache_Type_ALLD, 0);
585     Cache_inv((Ptr)(IACP_STD_BETA_TABLE.pStatus[STD_BETA_THD]), sizeof(Int), Cache_Type_ALLD, 0);
586     size = IACP_STD_BETA_TABLE.pStatus[STD_BETA_THD]->size;
587     Cache_inv((Ptr)(IACP_STD_BETA_TABLE.pStatus[STD_BETA_THD]), size, Cache_Type_ALLD, 0);
588     Cache_inv((Ptr)(IACP_STD_BETA_TABLE.pStatus[STD_BETA_THD2]), sizeof(Int), Cache_Type_ALLD, 0);
589     size = IACP_STD_BETA_TABLE.pStatus[STD_BETA_THD2]->size;
590     Cache_inv((Ptr)(IACP_STD_BETA_TABLE.pStatus[STD_BETA_THD2]), size, Cache_Type_ALLD, 0);
591     size = IACP_STD_BETA_TABLE.pStatus[STD_BETA_DTSUHDA]->size;
592     Cache_inv((Ptr)(IACP_STD_BETA_TABLE.pStatus[STD_BETA_DTSUHDA]), size, Cache_Type_ALLD, 0);
593     Cache_wait();
594     
595 #ifdef NON_CACHE_STATUS
596     // Get the shared status structure GateMP handles. Initialized at slave.
597     if (statusOp_Init(GATEMP_INDEX_DEC) == STATUSOP_INIT_FAIL)
598     {
599         Log_info1("TaskAfp: Gate Index %d:Open status GateMP Fail.", GATEMP_INDEX_DEC);
600     }
601     if (statusOp_Init(GATEMP_INDEX_DDP) == STATUSOP_INIT_FAIL)
602     {
603         Log_info1("TaskAfp: Gate Index %d:Open status GateMP Fail.", GATEMP_INDEX_DDP);
604     }
605     if (statusOp_Init(GATEMP_INDEX_PCM) == STATUSOP_INIT_FAIL)
606     {
607         Log_info1("TaskAfp: Gate Index %d:Open status GateMP Fail.", GATEMP_INDEX_PCM);
608     }
609     if (statusOp_Init(GATEMP_INDEX_THD) == STATUSOP_INIT_FAIL)
610     {
611         Log_info1("TaskAfp: Gate Index %d:Open status GateMP Fail.", GATEMP_INDEX_THD);
612     }
613     if (statusOp_Init(GATEMP_INDEX_DTS) == STATUSOP_INIT_FAIL)
614     {
615         Log_info1("TaskAfp: Gate Index %d:Open status GateMP Fail.", GATEMP_INDEX_DTS);
616     }
617 #endif
618     // (***) FL: revisit
619     // invalidate Dec configuration
620     Cache_inv(&gPAF_AST_config.xDec[0], DECODEN*sizeof(PAF_AST_Decode), Cache_Type_ALLD, 0);
621     Cache_wait();
622     
623     //
624     // Main processing loop
625     //   
626     for (z=STREAM1; z < STREAMN; z++)
627     {
628         TRACE_VERBOSE1("TaskAsip: AS%d: running", as+z);
629     }
631     TRACE_TERSE0("TaskAsip: Entering Main Loop.");
632     
633     errno = 0;
634     for (;;)
635     {
636         Int sourceSelect;
637         XDAS_Int8 sourceProgram;
639         loopCount++;
641 #if 0   // enable and tune to see startup behavior.
642         // this is an alternative to fixed/circular setting in pa.cfg.
643         // If you are searching for a memory allocation failure, disable on first round.
644         // All allocation has already happened.
645         // This is the outer loop.  This loop count goes up when the stream resets.
646         // If the stream is running without problems, this does not increment.
647         // If the stream is repeatedly resetting, this loop count will go up rapidly.
648         if (loopCount > 10)  // see traces for a few of the passes through the main loop.
649         {
650              TRACE_TERSE1("TaskAsip: Trace stopped at loop %d.", loopCount);
651              LOG_disable(&TR_MOD);  // stop tracing
652         }
653 #endif
655         TRACE_GEN2("TaskAsip (begin Main loop %d) (errno 0x%x)", loopCount, errno);
656         TRACE_TIME((&TIME_MOD, "as1_f2... + %d = %d (begin Main loop)", dtime(), TSK_time()));
657         
658         // since not decoding indicate such
659         pP->fxns->sourceDecode(pP, pQ, pAsitCfg, PAF_SOURCE_NONE);
661         // any error forces idling of input
662         if (errno) 
663         {
664             // If gCommandOutputTask_SYNC invoked by writeDECCommandRestart, wait for output task in sync ...
665             if (gCommandOutputTask_SYNC) {
666                 TRACE_VERBOSE1("TaskAsip: writeDECCommandRestart issued ... Wait for ack from output task side (errno=%d)", errno);
667                 // Wait for ack
668                 while (gCommandOutputTask_ACK == 0) {
669                     Task_sleep(1);
670                 }
671                 TRACE_VERBOSE0("TaskAsip: writeDECCommandRestart issued ... Sync-ed! Startover the process");
672                 gCommandOutputTask_ACK = 0;
673                 gCommandOutputTask_SYNC = 0;
674             }
675             
676             for (z=INPUT1; z < INPUTN; z++)
677             {
678                 if (pAstCfg->xInp[z].hRxSio)
679                 {
680                     SIO_idle(pAstCfg->xInp[z].hRxSio);
681                 }
682             }
683         
684             TRACE_TERSE1("TaskAsip: Trace stopped at loop %d.", loopCount);
685             ERRNO_RPRT(TaskAsip, errno);
686         }
687         
688         // Execute a TSK_sleep to ensure that any non-blocking code paths are broken
689         // up to allow lower priority tasks to run. This may seem odd to be at the top
690         // of the state machine but provides for a cleaner flow even though the very
691         // first time we enter we do a sleep which is non-intuitive.
692         TRACE_VERBOSE1("TaskAsip: AS%d: ... sleeping ...", as+zMS);
693         TRACE_TIME((&TIME_MOD, "as1-f2... + %d = %d (begin SLEEP)", dtime(), TSK_time()));
694         Task_sleep(1);
696         TRACE_GEN1("TaskAsip: AS%d: Input device selection ...", as+zMS);
697         errno = pP->fxns->selectDevices(pP, pQ, pAsitCfg);
698         if (errno)
699         {
700             TRACE_TERSE2("TaskAsip: selectDevices returned errno = 0x%04x at line %d. AS%d", errno, as+zMS);
701             continue;
702         }
704         // if no master input selected then we don't know what may be at the input
705         // so set to unknown and skip any remaining processing
706         if (!pAstCfg->xInp[zMI].hRxSio)
707         {
708             sharedMemWriteInt8(&(pAstCfg->xDec[zMD].decodeStatus.sourceProgram), 
709                                (Int8)PAF_SOURCE_UNKNOWN, GATEMP_INDEX_DEC);
711             TRACE_VERBOSE1("TaskAsip: AS%d: No input selected...", as+zMS);
712             continue;
713         }
714         
715         // if here then we have a valid input so query its status
716         errno = pP->fxns->updateInputStatus(pAstCfg->xInp[zMI].hRxSio, &pAstCfg->xInp[zMI].inpBufStatus, &pAstCfg->xInp[zMI].inpBufConfig);
717         if (errno)
718         {
719             TRACE_VERBOSE1("TaskAsip: continue as updateInputStatus returns 0x%x", errno);
720             continue;
721         }
723         // If master decoder is not enabled, or the input is unlocked, then do nothing
724         tempVar8 = sharedMemReadInt8(&(pAstCfg->xDec[zMD].decodeStatus.mode), 
725                                      GATEMP_INDEX_DEC);
726         if (!tempVar8 || !pAstCfg->xInp[zMI].inpBufStatus.lock)
727         {
728             TRACE_VERBOSE0("TaskAsip: Not locked, continue");
729             continue;
730         }
731         
732         // If no source selected then do nothing
733         tempVar8 = sharedMemReadInt8(&(pAstCfg->xDec[zMD].decodeStatus.sourceSelect), 
734                                      GATEMP_INDEX_DEC);
735         if (tempVar8 == PAF_SOURCE_NONE)
736         {
737             sharedMemWriteInt8(&(pAstCfg->xDec[zMD].decodeStatus.sourceProgram), 
738                                (Int8)PAF_SOURCE_NONE, GATEMP_INDEX_DEC);
739             TRACE_VERBOSE1("TaskAsip: AS%d: no source selected, continue", as+zMS);
740             continue;
741         }
743         // If we want pass processing then proceed directly
744         tempVar8 = sharedMemReadInt8(&(pAstCfg->xDec[zMD].decodeStatus.sourceSelect), 
745                                      GATEMP_INDEX_DEC);
746         if (tempVar8 == PAF_SOURCE_PASS)
747         {
748             TRACE_VERBOSE1("TaskAsip: AS%d: Pass processing ...", as+zMS);
749             sharedMemWriteInt8(&(pAstCfg->xDec[zMD].decodeStatus.sourceProgram), 
750                                (Int8)PAF_SOURCE_PASS, GATEMP_INDEX_DEC);
752             pP->fxns->sourceDecode(pP, pQ, pAsitCfg, PAF_SOURCE_PASS);
753             if (pP->fxns->passProcessing)
754             {
755                 errno = pP->fxns->passProcessing(pP, pQ, pAsitCfg, NULL);                
756             }
757             else 
758             {
759                 TRACE_TERSE2("TaskAsip: AS%d: Pass Processing not supported, errno 0x%x", as+zMS, ASPERR_PASS);
760                 errno = ASPERR_PASS;
761             }
762             TRACE_VERBOSE0("TaskAsip: continue");
763             continue;
764         }
766         // .....................................................................
767         // At this point we have an enabled input and want to decode something.
768         // If no decoder selected then do nothing. Need to reset the sourceProgram, since
769         // when no decoder is selected there are no calls to IB
770         //if (errno = pP->fxns->autoProcessing(pP, pQ, pC, pC->xDec[zMD].decodeStatus.sourceSelect, pC->xDec[zMD].decAlg[PAF_SOURCE_PCM]))
771         tempVar8 = sharedMemReadInt8(&(pAstCfg->xDec[zMD].decodeStatus.sourceSelect), 
772                                      GATEMP_INDEX_DEC);
773         pfpBegin(PFP_ID_ASIT_1, pAsitCfg->taskHandle);  // PFP begin
774         gNumPfpAsit1++;
775         // (***) FL: re-visit, hard-coded to use FRAMELENGTH (pP->frameLength) inside function
776         errno = pP->fxns->autoProcessing(pP, pQ, pAsitCfg, tempVar8, NULL);
777         pfpEnd(PFP_ID_ASIT_1, PFP_FINISH_MEAS);         // PFP end
778         gNumPfpAsit1--;
780         if (errno)
781         {
782             TRACE_VERBOSE1("TaskAsip: autoProcessing returns 0x%x, continue", errno);
783             continue;
784         }
785         
786         // query for input type
787         errno = SIO_ctrl(pAstCfg->xInp[zMI].hRxSio, PAF_SIO_CONTROL_GET_SOURCEPROGRAM, (Arg )&sourceProgram);
788         if (errno)
789         {
790             TRACE_TERSE2("TaskAsip: SIO_ctrl returns 0x%x, then 0x%x, continue", errno, ASPERR_AUTO_PROGRAM);
791             errno = ASPERR_AUTO_PROGRAM;
792             continue;
793         }
795         sharedMemWriteInt8(&(pAstCfg->xDec[zMD].decodeStatus.sourceProgram), 
796                            sourceProgram, GATEMP_INDEX_DEC);
798         // if input is unclassifiable then do nothing
799         if (sourceProgram == PAF_SOURCE_UNKNOWN)
800         {
801             TRACE_VERBOSE0("TaskAsip: Source program unknown. continue");
802             continue;
803         }
805         // now that we have some input classification, and possibly an outstanding
806         // input frame, we determine whether or not to call decodeProcessing and with
807         // what decAlg.
808         sourceSelect = PAF_SOURCE_NONE;
809         tempVar8 = sharedMemReadInt8(&(pAstCfg->xDec[zMD].decodeStatus.sourceSelect), 
810                                      GATEMP_INDEX_DEC);
811         switch (tempVar8)
812         {
813             // If autodetecting, decoding everything, and input is something
814             // (i.e. bitstream or PCM) then decode.
815             case PAF_SOURCE_AUTO:
816                 if (sourceProgram >= PAF_SOURCE_PCM)
817                 {
818                     sourceSelect = sourceProgram;                    
819                 }
820                 break;
822             // If autodetecting, decoding only PCM, and input is PCM then decode.
823             case PAF_SOURCE_PCMAUTO:
824                 if (sourceProgram == PAF_SOURCE_PCM)
825                 {
826                     sourceSelect = sourceProgram;                    
827                 }
828                 break;
830             // If autodetecting, decoding only bitstreams, and input is a bitstream then decode.
831             case PAF_SOURCE_BITSTREAM:
832                 if (sourceProgram >= PAF_SOURCE_AC3)
833                 {
834                     sourceSelect = sourceProgram;                    
835                 }
836                 break;
838             // If autodetecting, decoding only DTS, and input is DTS then decode.
839             case PAF_SOURCE_DTSALL:
840                 switch (sourceProgram) 
841                 {
842                     case PAF_SOURCE_DTS11:
843                     case PAF_SOURCE_DTS12:
844                     case PAF_SOURCE_DTS13:
845                     case PAF_SOURCE_DTS14:
846                     case PAF_SOURCE_DTS16:
847                     case PAF_SOURCE_DTSHD:
848                         sourceSelect = sourceProgram;
849                         break;
850                 }
851                 break;
853             // All others, e.g., force modes, fall through to here.
854             // If user made specific selection then program must match select.
855             // (NB: this compare relies on ordering of PAF_SOURCE)
856             default:
857                 sourceSelect = (Int)sharedMemReadInt8(&(pAstCfg->xDec[zMD].decodeStatus.sourceSelect),
858                                                               GATEMP_INDEX_DEC);
859                 if ((sourceSelect >= PAF_SOURCE_PCM) && (sourceSelect <= PAF_SOURCE_N))
860                 {
861                     if (sourceProgram != sourceSelect)
862                     {
863                         sourceSelect = PAF_SOURCE_NONE;                        
864                     }
865                 }
866                 break;
867         }
869         // if we didn't find any matches then skip
870         if (sourceSelect == PAF_SOURCE_NONE)
871         {
872             TRACE_VERBOSE0("TaskAsip: no matching source type, continue");
873             continue;
874         }
876 #if 0 // debug, reset IB capture buffer
877         capIbReset();
878         gCapIbReset_cnt++;
879         Log_info0("capIbReset()");
880 #endif
882         // send source select message to slave
883         *(Int32 *)&asipMsgBuf[0] = sourceSelect;
884         if(AspMsgSend(ASP_SLAVE_DEC_SOURCE_SELECT, ASP_MASTER_DEC_SOURCE_SELECT_DONE,
885                       asipMsgBuf, NULL) != ASP_MSG_NO_ERR)
886         {
887             TRACE_VERBOSE0("TaskAsip: error in sending SOURCE_SELECT message");
888             SW_BREAKPOINT;
889         }
890         
891         // set to unknown so that we can ensure, for IOS purposes, that sourceDecode = NONE
892         // iff we are in this top level state machine and specifically not in decodeProcessing
893         pP->fxns->sourceDecode(pP, pQ, pAsitCfg, PAF_SOURCE_UNKNOWN);
894         
895         TRACE_VERBOSE1(procName[sourceProgram], as+zMS);
897         // Reduce priority level since autodetection complete
898         Task_setPri(pAsitCfg->taskHandle, Task_getPri(pAsitCfg->taskHandle)-1);
899         
900         gAspProfileEnable=1; // enable ASP profiling
901         
902         TRACE_VERBOSE0("TaskAsip: calling decodeProcessing.");
903         errno = pP->fxns->decodeProcessing(pP, pQ, pAsitCfg, sourceSelect);
904         if (errno) 
905         {
906             TRACE_TERSE1("TaskAsip: decodeProcessing returns 0x%x, continue", errno);
907         }
908         else
909         {
910             TRACE_VERBOSE0("TaskAsip: decodeProcessing complete with no error.");
911         }        
913         gAspProfileEnable=0; // disable ASP profiling
914         
915         // Increase priority level since decoding complete
916         Task_setPri(pAsitCfg->taskHandle, Task_getPri(pAsitCfg->taskHandle)+1);
918         // FL: send dec exit message to slave
919         if( AspMsgSend(ASP_SLAVE_DEC_EXIT, ASP_MASTER_DEC_EXIT_DONE, NULL, NULL)
920             != ASP_MSG_NO_ERR)
921         {
922             TRACE_VERBOSE0("TaskAsip: error in sending DEC_EXIT message");
923             SW_BREAKPOINT;                
924         }
926     } // End of main processing loop for (;;)
927     
928     //Log_info0("Exit taskAsipFxn()");
931 // -----------------------------------------------------------------------------
932 // ASIT Initialization Function - Memory Allocation
933 //
934 //   Name:      PAF_ASIT_initPhaseMalloc
935 //   Purpose:   Audio Stream Input Task Function for initialization of data pointers
936 //              by allocation of memory.
937 //   From:      audioStream1Task or equivalent
938 //   Uses:      See code.
939 //   States:    x
940 //   Return:    0 on success.
941 //              Source code line number on MEM_calloc failure.
942 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
943 //              * State information as per parent.
944 //              * Memory allocation errors.
945 //
946 Int
947 PAF_ASIT_initPhaseMalloc(
948     const PAF_ASIT_Params *pP, 
949     const PAF_ASIT_Patchs *pQ, 
950     PAF_ASIT_Config *pAsitCfg
953     PAF_AST_Config *pAstCfg;
954     Int as;                    /* Audio Stream Number (1, 2, etc.) */
955     Int zMS;
956     Error_Block    eb;
957         IHeap_Handle   decHeapHandle;
959     pAstCfg = pAsitCfg->pAstCfg; // get pointer to AST common (shared) configuration
960     as = pAstCfg->as;
961     zMS = pAstCfg->masterStr;
962     
963     TRACE_TERSE1("PAF_ASIT_initPhaseMalloc: AS%d: initialization phase - memory allocation", as+zMS);
965     // Initialize error block
966     Error_init(&eb); 
968     /* Input memory */
969     if (!(pAstCfg->xInp = Memory_calloc((IHeap_Handle)HEAP_INTERNAL1_SHM, 
970         INPUTN * sizeof (*pAstCfg->xInp), 4, &eb)))
971     {
972         TRACE_TERSE1("PAF_ASIT_initPhaseMalloc: AS%d: Memory_calloc failed", as+zMS);
973         SW_BREAKPOINT;
974         return __LINE__;
975     }
976     TRACE_TERSE3("PAF_ASIT_initPhaseMalloc. (pAstCfg->xInp) %d bytes from space %d at 0x%x.",
977         INPUTN * sizeof (*pAstCfg->xInp),
978         HEAP_ID_INTERNAL1_SHM, (IArg)pAstCfg->xInp);
980     /* Decode memory */
981 #ifdef NON_CACHE_STATUS
982     decHeapHandle = (IHeap_Handle)HEAP_EXTERNAL_NONCACHED_SHM;
983 #else 
984     decHeapHandle = (IHeap_Handle)HEAP_INTERNAL1_SHM;
985 #endif
986     if (!(pAstCfg->xDec = Memory_calloc(decHeapHandle,
987         DECODEN * sizeof (*pAstCfg->xDec), 4, &eb)))
988     {
989         TRACE_TERSE1("PAF_ASIT_initPhaseMalloc: AS%d: Memory_calloc failed", as+zMS);
990         SW_BREAKPOINT;
991         return __LINE__;
992     }
994     TRACE_TERSE3("PAF_ASIT_initPhaseMalloc. (pAstCfg->xDec) %d bytes from space %d at 0x%x.",
995         DECODEN * sizeof (*pAstCfg->xDec),
996         HEAP_ID_INTERNAL1_SHM, (IArg)pAstCfg->xDec);
997                 
998     TRACE_TERSE1("PAF_ASIT_initPhaseMalloc: AS%d: initialization phase - memory allocation complete.", as+zMS);
999     return 0;
1000 } //PAF_ASIT_initPhaseMalloc
1002 // -----------------------------------------------------------------------------
1003 // ASIT Initialization Function - Memory Initialization from Configuration
1004 //
1005 //   Name:      PAF_ASIT_initPhaseConfig
1006 //   Purpose:   Audio Stream Task Function for initialization of data values
1007 //              from parameters.
1008 //   From:      audioStream1Task or equivalent
1009 //   Uses:      See code.
1010 //   States:    x
1011 //   Return:    0 on success.
1012 //              Other as per initFrame0 and initFrame1.
1013 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
1014 //              * State information as per parent.
1015 //
1016 Int
1017 PAF_ASIT_initPhaseConfig(
1018     const PAF_ASIT_Params *pP, 
1019     const PAF_ASIT_Patchs *pQ, 
1020     PAF_ASIT_Config *pAsitCfg
1023     PAF_AST_Config *pAstCfg;
1024     Int as;                    /* Audio Stream Number (1, 2, etc.) */
1025     Int z;                     /* input/encode/stream/decode/output counter */
1026     Int zMS;
1028     pAstCfg = pAsitCfg->pAstCfg; // get pointer to AST common (shared) configuration
1029     as = pAstCfg->as;
1030     zMS = pAstCfg->masterStr;
1031     
1032     TRACE_TERSE1("PAF_ASIT_initPhaseConfig: AS%d: initialization phase - configuration", as+zMS);
1034     //
1035     // Unspecified elements have been initialized to zero during alloc
1036     //
1037     
1038     for (z=INPUT1; z < INPUTN; z++) 
1039     {
1040         pAstCfg->xInp[z].inpBufStatus = *pP->pInpBufStatus;
1041         pAstCfg->xInp[z].inpBufConfig.pBufStatus = &pAstCfg->xInp[z].inpBufStatus;
1042     }
1044     for (z=DECODE1; z < DECODEN; z++) 
1045     {
1046         Int zI = pP->inputsFromDecodes[z];
1047         pAstCfg->xDec[z].decodeControl.size = sizeof(pAstCfg->xDec[z].decodeControl);
1048         pAstCfg->xDec[z].decodeControl.pInpBufConfig = (const PAF_InpBufConfig *)&pAstCfg->xInp[zI].inpBufConfig;
1049         //pC->xDec[z].decodeStatus = *pP->z_pDecodeStatus[z]; // FL: slave
1050     }
1052     TRACE_TERSE1("PAF_ASIT_initPhaseConfig: AS%d: initialization phase - configuration complete.", as+zMS);
1053     return 0;
1054 } //PAF_ASIT_initPhaseConfig
1056 // -----------------------------------------------------------------------------
1057 // ASIT Initialization Function - ACP Algorithm Instantiation
1058 //
1059 //   Name:      PAF_ASIT_initPhaseAcpAlg
1060 //   Purpose:   Audio Stream Input Task Function for initialization of ACP by
1061 //              instantiation of the algorithm.
1062 //   From:      audioStream1Task or equivalent
1063 //   Uses:      See code.
1064 //   States:    x
1065 //   Return:    0 on success.
1066 //              Source code line number on ACP Algorithm creation failure.
1067 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
1068 //              * State information as per parent.
1069 //              * Memory allocation errors.
1070 //
1071 Int
1072 PAF_ASIT_initPhaseAcpAlg(
1073     const PAF_ASIT_Params *pP, 
1074     const PAF_ASIT_Patchs *pQ, 
1075     PAF_ASIT_Config *pAsitCfg
1078     PAF_AST_Config *pAstCfg;
1079     Int as;                 /* Audio Stream Number (1, 2, etc.) */
1080     Int z;                  /* input/encode/stream/decode/output counter */
1081     Int betaPrimeOffset;
1082     ACP_Handle acp;
1083     Int zMS;
1084     Int zS, zX;
1086     pAstCfg = pAsitCfg->pAstCfg; // get pointer to AST common (shared) configuration
1087     as = pAstCfg->as;
1088     zMS = pAstCfg->masterStr;
1089     
1090     TRACE_TERSE1("PAF_ASIT_initPhaseAcpAlg: AS%d: initialization phase - ACP Algorithm", as+zMS);
1092     ACP_MDS_init();
1094     if (!(acp = (ACP_Handle)ACP_MDS_create(NULL))) 
1095     {
1096         TRACE_TERSE1("PAF_ASIT_initPhaseAcpAlg: AS%d: ACP algorithm instance creation failed", as+zMS);
1097         return __LINE__;
1098     }
1099     pAsitCfg->acp = acp;
1101     ((ALG_Handle)acp)->fxns->algControl((ALG_Handle) acp,
1102         ACP_GETBETAPRIMEOFFSET, (IALG_Status *)&betaPrimeOffset);
1104     for (z=INPUT1; z < INPUTN; z++) 
1105     {
1106         zS = z;
1107         for (zX = DECODE1; zX < DECODEN; zX++) 
1108         {
1109             if (pP->inputsFromDecodes[zX] == z) 
1110             {
1111                 zS = pP->streamsFromDecodes[zX];
1112                 break;
1113             }
1114         }
1115         acp->fxns->attach(acp, ACP_SERIES_STD,
1116             STD_BETA_IB + betaPrimeOffset * (as-1+zS),
1117             (IALG_Status *)&pAstCfg->xInp[z].inpBufStatus);
1118         /* Ignore errors, not reported. */
1119     }
1121     TRACE_TERSE1("PAF_ASIT_initPhaseAcpAlg: AS%d: initialization phase - ACP Algorithm complete.", as+zMS);
1123     return 0;
1124 } //PAF_ASIT_initPhaseAcpAlg
1126 // -----------------------------------------------------------------------------
1127 // ASIT Initialization Function - Common Memory
1128 //
1129 //   Name:      PAF_ASIT_initPhaseCommon
1130 //   Purpose:   Audio Stream Input Task Function for allocation of common memory.
1131 //   From:      audioStream1Task or equivalent
1132 //   Uses:      See code.
1133 //   States:    x
1134 //   Return:    0 on success.
1135 //              Source code line number on PAF_ALG_alloc failure.
1136 //              Source code line number on PAF_ALG_mallocMemory failure.
1137 //              Source code line number on Decode Chain initialization failure.
1138 //              Source code line number on ASP Chain initialization failure.
1139 //              Source code line number on Encode Chain initialization failure.
1140 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
1141 //              * State information as per parent.
1142 //              * Memory allocation errors.
1143 //
1144 Int
1145 PAF_ASIT_initPhaseCommon(
1146     const PAF_ASIT_Params *pP, 
1147     const PAF_ASIT_Patchs *pQ, 
1148     PAF_ASIT_Config *pAsitCfg
1151     PAF_AST_Config *pAstCfg;
1152     Int as;                     /* Audio Stream Number (1, 2, etc.) */
1153     Int z;                      /* stream counter */
1154     ACP_Handle acp;
1155     PAF_IALG_Config pafAlgConfig;
1156     IALG_MemRec common[3][PAF_IALG_COMMON_MEMN+1];
1157    
1158     acp = pAsitCfg->acp;
1159     pAstCfg = pAsitCfg->pAstCfg; // get pointer to AST common (shared) configuration
1160     as = pAstCfg->as;
1161     
1162     TRACE_TERSE0("PAF_ASIT_initPhaseCommon: initialization phase - Common Memory");
1164     //
1165     // Determine memory needs and instantiate algorithms across audio streams
1166     //
1167     TRACE_TERSE0("PAF_ASIT_initPhaseCommon: calling PAF_ALG_setup.");
1168     PAF_ALG_setup(&pafAlgConfig, 
1169         HEAP_ID_INTERNAL,               HEAP_INTERNAL, 
1170         HEAP_ID_INTERNAL1,              HEAP_INTERNAL1, 
1171         HEAP_ID_EXTERNAL,               HEAP_EXTERNAL, 
1172         HEAP_ID_INTERNAL1_SHM,          HEAP_INTERNAL1_SHM, 
1173         HEAP_ID_EXTERNAL_SHM,           HEAP_EXTERNAL_SHM, 
1174         HEAP_ID_EXTERNAL_NONCACHED_SHM, HEAP_EXTERNAL_NONCACHED_SHM,
1175         HEAP_CLEAR);
1177     if (pP->fxns->headerPrint)
1178     {
1179         pP->fxns->headerPrint();        
1180     }
1182     for (z = STREAM1; z < STREAMN; z++) 
1183     {
1184         TRACE_TERSE1("PAF_ASIT_initPhaseCommon: AS%d: initialization phase - Common Memory", as+z);
1186         //
1187         // Determine common memory for:
1188         //  (1) Logical Input drivers
1189         //
1190         // Decode Algorithms common memory determined in ASP Slave.
1191         //
1192         PAF_ALG_init(common[z], lengthof(common[z]), COMMONSPACE);
1194         //
1195         // Determine common memory needs of Logical Input driver
1196         //
1198         // really need to loop over all inputs for this stream using the tables
1199         // inputsFromDecodes and streamsFromDecodes. But these don't exist for this
1200         // patch, and not needed for FS11, since there is only one input.
1201         if (INPUT1 <= z && z < INPUTN) 
1202         {
1203             TRACE_TERSE2("PAF_ASIT_initPhaseCommon: AS%d: alloc inpLinkInit common[%d]", as+z, z);
1204             if (PAF_ALG_ALLOC(inpLinkInit[z-INPUT1], common[z]))
1205             {
1206                 TRACE_TERSE1("PAF_ASIT_initPhaseCommon: AS%d: PAF_ALG_alloc failed", as+z);
1207                 TRACE_TERSE2("failed to alloc %d bytes from space %d", common[z]->size, (IArg)common[z]->space);
1208                 SW_BREAKPOINT;
1209                 return __LINE__;
1210             }
1211             TRACE_TERSE3("alloced %d bytes from space %d at 0x%x", common[z]->size, common[z]->space, (IArg)common[z]->base);
1212             if (pP->fxns->allocPrint)
1213             {
1214                 pP->fxns->allocPrint((const PAF_ALG_AllocInit *)(inpLinkInit[z-INPUT1]), sizeof (*(inpLinkInit[z-INPUT1])), &pafAlgConfig);
1215             }
1216         }
1217     }
1218     {
1219         // Changes made to share scratch between zones
1220         // Assume maximum 3 zones and scratch common memory is at offset 0;
1221         int max=0;
1222         for (z=STREAM1; z<STREAMN; z++)
1223         {
1224             if (max < common[z][0].size)
1225             {
1226                 max = common[z][0].size;
1227             }
1228         }
1229         common[STREAM1][0].size=max;
1230         for (z=STREAM1+1; z<STREAMN; z++)
1231         {
1232             common[z][0].size = 0;            
1233         }
1234     }
1235         
1236     //
1237     // Allocate common memory for:
1238     //  (1) Logical Input drivers
1239     //
1240     for (z = STREAM1; z < STREAMN; z++) 
1241     {
1242         TRACE_TERSE0("PAF_ASIT_initPhaseCommon: calling PAF_ALG_mallocMemory for common space.");
1243         if (PAF_ALG_mallocMemory(common[z], &pafAlgConfig)) 
1244         {
1245             TRACE_TERSE1("PAF_ASIT_initPhaseCommon: AS%d: PAF_ALG_mallocMemory failed", as+z);
1246             TRACE_TERSE3("AS%d: z: %d.  Size 0x%x", as+z, z, common[z][0].size);
1247             SW_BREAKPOINT;
1248             return __LINE__;
1249         }
1250         TRACE_TERSE3("alloced %d bytes from space %d at 0x%x", common[z]->size, common[z]->space, (IArg)common[z]->base);
1251         // share zone0 scratch with all zones 
1252         common[z][0].base = common[0][0].base;
1253         if (pP->fxns->commonPrint)
1254         {
1255             pP->fxns->commonPrint(common[z], &pafAlgConfig);
1256         }
1258         //
1259         // Allocate non-common memories for Logical IO drivers
1260         //    Since these structures are used at run-time we allocate from external memory
1261         if (INPUT1 <= z && z < INPUTN) 
1262         {
1263             PAF_ASP_Chain *chain;
1264             TRACE_TERSE2("PAF_ASIT_initPhaseCommon: AS%d: non-common input chain init for %d",
1265                            as+z, z);
1266             chain = PAF_ASP_chainInit(&pAstCfg->xInp[z].inpChainData, pP->pChainFxns,
1267                         HEAP_EXTERNAL, as+z, acp, &trace,
1268                         inpLinkInit[z-INPUT1], NULL, common[z], &pafAlgConfig);
1269             if (!chain) 
1270             {
1271                 TRACE_TERSE1("PAF_ASIT_initPhaseCommon: AS%d: Input chain initialization failed", as+z);
1272                 return __LINE__;
1273             }
1274         }
1275     }
1276     TRACE_TERSE1("PAF_ASIT_initPhaseCommon: AS%d: Returning complete.", as+z);
1278     return 0;
1279 } //PAF_ASIT_initPhaseCommon
1281 // (***) FL: candidate for removal
1282 // -----------------------------------------------------------------------------
1283 // ASIT Initialization Function - Algorithm Keys
1284 //
1285 //   Name:      PAF_ASIT_initPhaseAlgKey
1286 //   Purpose:   Audio Stream Input Task Function for initialization of data values
1287 //              from parameters for Algorithm Keys.
1288 //   From:      audioStream1Task or equivalent
1289 //   Uses:      See code.
1290 //   States:    x
1291 //   Return:    0.
1292 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
1293 //              * State information as per parent.
1294 //
1295 // .............................................................................
1296 Int
1297 PAF_ASIT_initPhaseAlgKey(
1298     const PAF_ASIT_Params *pP, 
1299     const PAF_ASIT_Patchs *pQ, 
1300     PAF_ASIT_Config *pAsitCfg
1303     PAF_AST_Config *pAstCfg;
1304     Int as;                    /* Audio Stream Number (1, 2, etc.) */
1306     
1307     pAstCfg = pAsitCfg->pAstCfg; // get pointer to AST common (shared) configuration
1308     as = pAstCfg->as;
1309     (void)as;  // clear compiler warning in case not used with tracing disabled
1311     TRACE_VERBOSE1("PAF_ASIT_initPhaseAlgKey: AS%d: initialization phase - Algorithm Keys", as);
1313 #if 0 // FL: slave    
1314     for (z=DECODE1; z < DECODEN; z++) 
1315     {
1316         for (s=0; s < pP->pDecAlgKey->length; s++) 
1317         {
1318             if ((pP->pDecAlgKey->code[s].full != 0) &&
1319                 (that = PAF_ASP_chainFind (&pC->xDec[z].decChainData, pP->pDecAlgKey->code[s]))) 
1320             {
1321                 pC->xDec[z].decAlg[s] = (ALG_Handle )that->alg;
1322                 /* Cast in interface, for now --Kurt */
1323             }
1324             else
1325             {
1326                 pC->xDec[z].decAlg[s] = NULL;
1327             }
1328         }
1329     }
1330 #endif
1332     return 0;
1333 } //PAF_ASIT_initPhaseAlgKey
1335 // -----------------------------------------------------------------------------
1336 // ASIT Initialization Function - I/O Devices
1337 //
1338 //   Name:      PAF_ASIT_initPhaseDevice
1339 //   Purpose:   Audio Stream Input Task Function for initialization of I/O Devices.
1340 //   From:      audioStream1Task or equivalent
1341 //   Uses:      See code.
1342 //   States:    x
1343 //   Return:    0 on success.
1344 //              Source code line number on device allocation failure.
1345 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
1346 //              * State information as per parent.
1347 //              * Memory allocation errors.
1348 //
1349 Int
1350 PAF_ASIT_initPhaseDevice(
1351     const PAF_ASIT_Params *pP, 
1352     const PAF_ASIT_Patchs *pQ, 
1353     PAF_ASIT_Config *pAsitCfg
1356     PAF_AST_Config *pAstCfg;
1357     Int as;                             /* Audio Stream Number (1, 2, etc.) */
1358     Int z;                              /* input/output counter */
1359     PAF_SIO_IALG_Obj    *pObj;
1360     PAF_SIO_IALG_Config *pAlgConfig;
1361     PAF_IALG_Config pafAlgConfig;
1364     pAstCfg = pAsitCfg->pAstCfg; // get pointer to AST common (shared) configuration
1365     as = pAstCfg->as;
1366     (void)as; // clear compiler warning in case not used with tracing disabled
1368     TRACE_TERSE1("PAF_ASIT_initPhaseDevice: AS%d: initialization phase - I/O Devices", as);
1370     if (pP->fxns->bufMemPrint)
1371     {
1372         PAF_ALG_setup (&pafAlgConfig, 
1373             HEAP_ID_INTERNAL,               HEAP_INTERNAL, 
1374             HEAP_ID_INTERNAL1,              HEAP_INTERNAL1,
1375             HEAP_ID_EXTERNAL,               HEAP_EXTERNAL,
1376             HEAP_ID_INTERNAL1_SHM,          HEAP_INTERNAL1_SHM,
1377             HEAP_ID_EXTERNAL_SHM,           HEAP_EXTERNAL_SHM,
1378             HEAP_ID_EXTERNAL_NONCACHED_SHM, HEAP_EXTERNAL_NONCACHED_SHM,
1379             HEAP_CLEAR);
1380         TRACE_TERSE2("PAF_ASIT_initPhaseDevice: AS%d: calling PAF_ALG_setup with clear at %d.", as, HEAP_CLEAR);
1381     }
1383     for (z=INPUT1; z < INPUTN; z++) 
1384     {
1385         PAF_InpBufConfig *pConfig = &pAstCfg->xInp[z].inpBufConfig;
1387         pObj = (PAF_SIO_IALG_Obj *)pAstCfg->xInp[z].inpChainData.head->alg;
1388         pAlgConfig = &pObj->config;
1390         pAstCfg->xInp[z].hRxSio = NULL;
1392         pConfig->base.pVoid       = pAlgConfig->pMemRec[0].base;
1393         pConfig->pntr.pVoid       = pAlgConfig->pMemRec[0].base;
1394         pConfig->head.pVoid       = pAlgConfig->pMemRec[0].base;
1395         pConfig->futureHead.pVoid = pAlgConfig->pMemRec[0].base;
1396         pConfig->allocation       = pAlgConfig->pMemRec[0].size;
1397         pConfig->sizeofElement    = 2;
1398         pConfig->precision        = 16;
1400         if (pP->fxns->bufMemPrint)
1401         {
1402             pP->fxns->bufMemPrint(z, pAlgConfig->pMemRec[0].size, PAF_ALG_memSpaceToHeapId(&pafAlgConfig,pAlgConfig->pMemRec[0].space), 0);
1403         }
1404     }
1406     TRACE_TERSE1("PAF_ASIT_initPhaseDevice: AS%d: initialization phase - I/O Devices complete.", as);
1408     return 0;
1409 } //PAF_ASIT_initPhaseDevice
1411 // (***) FL: move to ASOT
1412 // -----------------------------------------------------------------------------
1413 // ASIT Initialization Function - Decoder Output Circular Buffer
1414 //
1415 //   Name:      PAF_ASIT_initPhaseDecOpCircBuf
1416 //   Purpose:   Audio Stream Input Task Function for initialization of Decoder Output Circular Buffer.
1417 //   From:      audioStream1Task or equivalent
1418 //   Uses:      See code.
1419 //   States:    x
1420 //   Return:    0 on success.
1421 //              Source code line number on device allocation failure.
1422 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
1423 //              * State information as per parent.
1424 //              * Memory allocation errors.
1425 //
1426 Int
1427 PAF_ASIT_initPhaseDecOpCircBuf(
1428     const PAF_ASIT_Params *pP, 
1429     const PAF_ASIT_Patchs *pQ, 
1430     PAF_ASIT_Config *pAsitCfg
1433     PAF_AST_Config *pAstCfg;
1434     PAF_AST_DecOpCircBuf *pCb;          /* Decoder output circular buffer */
1435     Int as;                             /* Audio Stream Number (1, 2, etc.) */
1436     Int zMS;
1437     Int z;                              /* decode counter */
1438     Int errno;                          /* error number */
1439     Error_Block    eb;
1440     Int i;
1441     ACP_Handle acp;
1442     Int betaPrimeOffset;
1443     Int zS;
1445     // FL: (***)revisit
1446     pAstCfg = pAsitCfg->pAstCfg; // get pointer to AST common (shared) configuration
1447     as = pAstCfg->as;
1448     zMS = pAstCfg->masterStr;
1450     // Decode output circular buffer memory
1451     if (!(pAstCfg->xDecOpCb = Memory_calloc((IHeap_Handle)HEAP_INTERNAL1_SHM, 
1452         DECODEN * sizeof (*pAstCfg->xDecOpCb), 4, &eb)))
1453     {
1454         TRACE_TERSE1("PAF_ASIT_initPhaseDecOpCircBuf: AS%d: Memory_calloc failed", as+zMS);
1455         SW_BREAKPOINT;
1456         return __LINE__;
1457     }
1459     TRACE_TERSE3("PAF_ASIT_initPhaseDecOpCircBuf. (pAsitCfg->xDecOpCb) %d bytes from space %d at 0x%x.",
1460         DECODEN * sizeof (*pAstCfg->xDecOpCb),
1461         HEAP_ID_INTERNAL1_SHM, (IArg)pAstCfg->xDecOpCb);
1463     for (z=DECODE1; z < DECODEN; z++)
1464     {
1465         pCb = &pAstCfg->xDecOpCb[z];
1466         
1467         // allocate audio frame circular buffer
1468         if (!(pCb->afCb = Memory_calloc((IHeap_Handle)HEAP_INTERNAL1_SHM, ASP_DECOP_CB_MAX_NUM_AF * sizeof(PAF_AudioFrame), 4, &eb)))
1469         {
1470             TRACE_TERSE1("PAF_ASIT_initPhaseDecOpCircBuf: AS%d: Memory_calloc failed", as+zMS);
1471             SW_BREAKPOINT;
1472         }
1473         // allocate audio frame PCM sample pointer array
1474         for (i = 0; i<ASP_DECOP_CB_MAX_NUM_AF; i++)
1475         {
1476             if (!(pCb->afCb[i].data.sample = Memory_calloc((IHeap_Handle)HEAP_INTERNAL1_SHM, ASP_DECOP_CB_MAX_NUM_PCM_CH_MAT * sizeof(PAF_AudioData *), 4, &eb)))
1477             {
1478                 TRACE_TERSE1("PAF_ASIT_initPhaseDecOpCircBuf: AS%d: Memory_calloc failed", as+zMS);
1479                 SW_BREAKPOINT;
1480             }
1481             if (!(pCb->afCb[i].data.samsiz = Memory_calloc((IHeap_Handle)HEAP_INTERNAL1_SHM, ASP_DECOP_CB_MAX_NUM_PCM_CH_MAT * sizeof(PAF_AudioSize), 4, &eb)))
1482             {
1483                 TRACE_TERSE1("PAF_ASIT_initPhaseDecOpCircBuf: AS%d: Memory_calloc failed", as+zMS);
1484                 SW_BREAKPOINT;
1485             }                
1486         }
1487         // allocate PCM sample buffer
1488         if (!(pCb->pcmBuf = Memory_calloc((IHeap_Handle)HEAP_EXTERNAL_SHM, ASP_DECOP_CB_PCM_BUF_SZ * sizeof(PAF_AudioData), 4, &eb)))
1489         {
1490             TRACE_TERSE1("PAF_ASIT_initPhaseDecOpCircBuf: AS%d: Memory_calloc failed", as+zMS);
1491             SW_BREAKPOINT;
1492         }
1493         pCb->pcmBufEnd = pCb->pcmBuf + ASP_DECOP_CB_PCM_BUF_SZ;
1494         // allocate Metadata buffers
1495         if (!(pCb->metaBuf = Memory_calloc((IHeap_Handle)HEAP_EXTERNAL_SHM, ASP_DECOP_CB_MAX_NUM_AF * PAF_MAX_PRIVATE_MD_SZ * PAF_MAX_NUM_PRIVATE_MD * sizeof(Int8), 4, &eb)))
1496         {
1497             TRACE_TERSE1("PAF_ASIT_initPhaseDecOpCircBuf: AS%d: Memory_calloc failed", as+zMS);
1498             SW_BREAKPOINT;
1499         }
1500         pCb->metaBufEnd = pCb->metaBuf + (ASP_DECOP_CB_MAX_NUM_AF * PAF_MAX_PRIVATE_MD_SZ * PAF_MAX_NUM_PRIVATE_MD);
1502         #ifdef CB_RW_OP_CAP_PP // debug
1503         // allocate debug buffer
1504         if (!(pCb->cb_samples_op = Memory_calloc((IHeap_Handle)HEAP_EXTERNAL_NONCACHED_SHM, CB_OP_COUNT_MAX * sizeof(UInt32), 4, &eb)))
1505         {
1506             TRACE_TERSE1("PAF_ASIT_initPhaseDecOpCircBuf: AS%d: Memory_calloc failed", as+zMS);
1507             SW_BREAKPOINT;
1508         }
1510         // allocate debug buffer
1511         if (!(pCb->cb_op_owner = Memory_calloc((IHeap_Handle)HEAP_EXTERNAL_NONCACHED_SHM, CB_OP_COUNT_MAX * sizeof(UInt8), 4, &eb)))
1512         {
1513             TRACE_TERSE1("PAF_ASIT_initPhaseDecOpCircBuf: AS%d: Memory_calloc failed", as+zMS);
1514             SW_BREAKPOINT;
1515         }
1517         // allocate debug buffer
1518         if (!(pCb->cb_afRdIdx = Memory_calloc((IHeap_Handle)HEAP_EXTERNAL_NONCACHED_SHM, CB_OP_COUNT_MAX * sizeof(UInt8), 4, &eb)))
1519         {
1520             TRACE_TERSE1("PAF_ASIT_initPhaseDecOpCircBuf: AS%d: Memory_calloc failed", as+zMS);
1521             SW_BREAKPOINT;
1522         }
1524         // allocate debug buffer
1525         if (!(pCb->cb_afWrtIdx = Memory_calloc((IHeap_Handle)HEAP_EXTERNAL_NONCACHED_SHM, CB_OP_COUNT_MAX * sizeof(UInt8), 4, &eb)))
1526         {
1527             TRACE_TERSE1("PAF_ASIT_initPhaseDecOpCircBuf: AS%d: Memory_calloc failed", as+zMS);
1528             SW_BREAKPOINT;
1529         }
1531         // allocate debug buffer
1532         if (!(pCb->cb_numAfCb = Memory_calloc((IHeap_Handle)HEAP_EXTERNAL_NONCACHED_SHM, CB_OP_COUNT_MAX * sizeof(UInt8), 4, &eb)))
1533         {
1534             TRACE_TERSE1("PAF_ASIT_initPhaseDecOpCircBuf: AS%d: Memory_calloc failed", as+zMS);
1535             SW_BREAKPOINT;
1536         }
1537         #endif
1538     }
1540     for (z = DECODE1; z < DECODEN; z++)
1541     {
1542         //
1543         // Initialize decoder output circular
1544         //
1545         
1546         // Initialize status
1547         pAstCfg->xDecOpCb[z].cbStatus = *pP->z_pDecOpCircBufStatus[z];
1548         
1549         // Default initialization
1550         errno = cbInit(pCb);
1551         if (errno)
1552         {
1553             SW_BREAKPOINT; // FL: debug
1554             return errno;
1555         }
1556     }
1557     
1558     // Get ASIT ACP handle
1559     acp = pAsitCfg->acp;
1560     if (!acp)
1561     {
1562         TRACE_TERSE1("PAF_ASIT_initPhaseDecOpCircBuf: AS%d: ACP algorithm instance creation  failed", as+zMS);
1563         return __LINE__;
1564     }
1565     
1566     // Get Beta Prime offset
1567     ((ALG_Handle)acp)->fxns->algControl((ALG_Handle) acp,
1568         ACP_GETBETAPRIMEOFFSET, (IALG_Status *)&betaPrimeOffset);
1569             
1570     for (z = DECODE1; z < DECODEN; z++)
1571     {
1572         // ACP attach CB
1573         zS = pP->streamsFromDecodes[z];
1574         acp->fxns->attach(acp, ACP_SERIES_STD,
1575             STD_BETA_DECOPCB + betaPrimeOffset * (as-1+zS),
1576             (IALG_Status *)&pAstCfg->xDecOpCb[z].cbStatus);        
1577     }
1578             
1579     return 0;
1580 } //PAF_ASIT_initPhaseDecOpCircBuf
1583 // -----------------------------------------------------------------------------
1584 // ASIT Initialization Function - Output Init-Sync
1585 //
1586 //   Name:      PAF_ASIT_initPhaseOutIS
1587 //   Purpose:   Audio Stream Input Task Function for initialization of Output Init-Sync.
1588 //
1589 Int
1590 PAF_ASIT_initPhaseOutIS(
1591     const PAF_ASIT_Params *pP, 
1592     const PAF_ASIT_Patchs *pQ, 
1593     PAF_ASIT_Config *pAsitCfg
1596     PAF_AST_Config *pAstCfg;
1597     Int as;                             /* Audio Stream Number (1, 2, etc.) */
1598     Int z;                              /* decode counter */
1599     PAF_AST_OutInitSyncInfo *pOutISI;
1600     Error_Block    eb;
1601     Int i;
1604     pAstCfg = pAsitCfg->pAstCfg; // get pointer to AST common (shared) configuration
1605     as = pAstCfg->as;
1606     
1607     /* Output Init-Sync memory */
1608     if (!(pAstCfg->xOutIsi = Memory_calloc((IHeap_Handle)HEAP_EXTERNAL_NONCACHED_SHM, 
1609         DECODEN * sizeof (*pAstCfg->xOutIsi), 4, &eb)))
1610     {
1611         TRACE_TERSE1("PAF_ASIT_initPhaseOutIS: AS%d: Memory_calloc failed", as);
1612         SW_BREAKPOINT;
1613         return __LINE__;
1614     }
1616     // Reset all decoder stage flags
1617     for (z=DECODE1; z < DECODEN; z++)
1618     {
1619         // Get address of Output Init-Sync Info
1620         pOutISI = &pAstCfg->xOutIsi[z];
1621         for (i = 0; i < ASP_OUTIS_NUM_DEC_STAGES; i++)
1622         {
1623             // Reset flag value
1624             pOutISI->decStageOutInitSyncInfo[i].decFlag = 0;
1625         }
1626     }    
1627     
1628     return 0;
1629 } // PAF_ASIT_initPhaseOutIS
1632 #if 0
1633 // -----------------------------------------------------------------------------
1634 // AST Processing Function - Pass-Through Processing
1635 //
1636 //   Name:      PAF_AST_passProcessing
1637 //   Purpose:   Audio Stream Task Function for processing audio data as a
1638 //              pass-through from the input driver to the output driver
1639 //              for development and testing.
1640 //   From:      audioStream1Task or equivalent
1641 //   Uses:      See code.
1642 //   States:    x
1643 //   Return:    Error number in standard form (0 on success).
1644 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
1645 //              * State information on initialization.
1646 //              * State information on processing.
1647 //
1649 #pragma CODE_SECTION(PAF_AST_passProcessing,".text:_PAF_AST_passProcessing")
1650 /* Pass Processing is often omitted from builds to save memory, */
1651 /* and CODE_SECTION/clink constructs facilitate this omission.  */
1653 Int
1654 PAF_AST_passProcessing(const PAF_AST_Params *pP, const PAF_AST_Patchs *pQ, PAF_AST_Config *pC, Int hack)
1656     Int z;                              /* input/output counter */
1657     Int errno = 0;                      /* error number */
1658     Int getVal;
1659     Int rxNumChan, txNumChan;
1660     Int first;
1661     Int zMD = pC->masterDec;
1662     Int zMI = pP->zone.master;
1665 #ifndef __TI_EABI__
1666     asm (" .clink"); /* See comment above regarding CODE_SECTION/clink. */
1667 #endif    
1669     TRACE_VERBOSE0("PAF_AST_passProcessing: initializing");
1671     //
1672     // Determine that receive/transmit channels are compatible
1673     //
1675     // Can handle handle only master input
1676     for (z=INPUT1; z < INPUTN; z++) {
1677         if (z != zMI && pC->xInp[z].hRxSio)
1678             return (ASPERR_PASS + 0x01);
1679     }
1681     /* Number of receive/transmit channels */
1683     if (! pC->xInp[zMI].hRxSio)
1684         return (ASPERR_PASS + 0x11);
1685     if (SIO_ctrl (pC->xInp[zMI].hRxSio, PAF_SIO_CONTROL_GET_NUMCHANNELS, (Arg) &rxNumChan))
1686         return (ASPERR_PASS + 0x12);
1687     if (rxNumChan > NUM_TX_CHAN(zMI))
1688         return (ASPERR_PASS + 0x13);
1690     for (z=OUTPUT1; z < OUTPUTN; z++) {
1691         if (! pC->xOut[zMI].hTxSio)
1692             return (ASPERR_PASS + 0x10*(z+2) + 0x01);
1693         if (SIO_ctrl (pC->xOut[z].hTxSio, PAF_SIO_CONTROL_GET_NUMCHANNELS, (Arg) &txNumChan))
1694             return (ASPERR_PASS + 0x10*(z+2) + 0x02);
1695         if (txNumChan > NUM_TX_CHAN(zMI))
1696             return (ASPERR_PASS + 0x10*(z+2) + 0x03);
1697     }
1699     //
1700     // Set up receive/transmit
1701     //
1703     SIO_idle (pC->xInp[zMI].hRxSio);
1704     for (z=OUTPUT1; z < OUTPUTN; z++) {
1705         if(SIO_idle (pC->xOut[z].hTxSio))
1706             return ASPERR_IDLE;
1707     }
1709     if (SIO_ctrl (pC->xInp[zMI].hRxSio, PAF_SIO_CONTROL_SET_SOURCESELECT, PAF_SOURCE_PCM))
1710         return (ASPERR_PASS + 0x14);
1712     if (SIO_ctrl (pC->xInp[zMI].hRxSio, PAF_SIO_CONTROL_SET_PCMFRAMELENGTH, FRAMELENGTH))
1713         return (ASPERR_PASS + 0x15);
1715     for (z=OUTPUT1; z < OUTPUTN; z++)
1716         pC->xOut[z].outBufConfig.lengthofFrame = FRAMELENGTH;
1718     if (SIO_issue (pC->xInp[zMI].hRxSio, &pC->xInp[zMI].inpBufConfig, sizeof (pC->xInp[zMI].inpBufConfig), PAF_SIO_REQUEST_SYNC))
1719         return ASPERR_PASS + 0x16;
1721     if (SIO_reclaim (pC->xInp[zMI].hRxSio, (Ptr)&pC->xInp[zMI].pInpBuf, NULL) != sizeof (PAF_InpBufConfig))
1722         return ASPERR_PASS + 0x17;
1724     //
1725     // Receive and transmit the data in single-frame buffers
1726     //
1728     first = 1;
1729     while (pC->xDec[zMD].decodeStatus.sourceSelect == PAF_SOURCE_PASS) {
1730         PAF_OutBufConfig *pOutBuf;
1731         PAF_InpBufConfig *pInpBuf;
1733         if (first) {
1734             first = 0;
1736             TRACE_VERBOSE0("PAF_AST_passProcessing: starting output");
1738             for (z=OUTPUT1; z < OUTPUTN; z++) {
1739                 getVal = SIO_issue (pC->xOut[z].hTxSio, &pC->xOut[z].outBufConfig, sizeof(pC->xOut[z].outBufConfig), 0);
1740                 if (getVal > 0) {
1741                     errno = ASPERR_ISSUE;
1742                     break;
1743                 }
1744                 else if (getVal < 0) {
1745                     errno = -getVal;
1746                     break;
1747                 }
1749                 if (getVal = SIO_ctrl (pC->xOut[z].hTxSio, PAF_SIO_CONTROL_UNMUTE, 0))
1750                     return (getVal & 0xff) | ASPERR_MUTE;
1751             }
1752             if (errno)
1753                 break;
1755         }
1757         getVal = SIO_issue (pC->xInp[zMI].hRxSio, &pC->xInp[zMI].inpBufConfig, sizeof (pC->xInp[zMI].inpBufConfig), PAF_SIO_REQUEST_NEWFRAME);
1758         if (getVal > 0) {
1759             errno = ASPERR_ISSUE;
1760             break;
1761         }
1763         TRACE_VERBOSE1("PAF_AST_passProcessing: awaiting frame -- input size %d", rxNumChan * FRAMELENGTH);
1765         getVal = SIO_reclaim (pC->xInp[zMI].hRxSio, (Ptr) &pInpBuf, NULL);
1766         if (getVal < 0) {
1767             errno = -getVal;
1768             break;
1769         }
1771         for (z=OUTPUT1; z < OUTPUTN; z++) {
1772             getVal = SIO_reclaim (pC->xOut[z].hTxSio, (Ptr) &pOutBuf, NULL);
1773             if (getVal < 0) {
1774                 errno = -getVal;
1775                 break;
1776             }
1777         }
1778         if( errno )
1779             break;
1781         TRACE_VERBOSE0("PAF_AST_passProcessing: copying frame");
1783         if (errno = pP->fxns->passProcessingCopy (pP, pQ, pC))
1784             break;
1786         for (z=OUTPUT1; z < OUTPUTN; z++) {
1787             getVal = SIO_issue (pC->xOut[z].hTxSio, &pC->xOut[z].outBufConfig, sizeof(pC->xOut[z].outBufConfig), 0);
1788             if (getVal > 0) {
1789                 errno = ASPERR_ISSUE;
1790                 break;
1791             }
1792             else if (getVal < 0) {
1793                 errno = -getVal;
1794                 break;
1795             }
1796         }
1797         if( errno )
1798             break;
1799     }
1801     //
1802     // Close down receive/transmit
1803     //
1805     TRACE_TERSE0("PAF_AST_passProcessing: finalizing"));
1807     for (z=OUTPUT1; z < OUTPUTN; z++) {
1808         if (getVal = SIO_ctrl (pC->xOut[z].hTxSio, PAF_SIO_CONTROL_MUTE, 0)) {
1809             if (! errno)
1810                 errno = (getVal & 0xff) | ASPERR_MUTE;
1811             /* convert to sensical errno */
1812         }
1813     }
1815     SIO_idle (pC->xInp[zMI].hRxSio);
1816     for (z=OUTPUT1; z < OUTPUTN; z++)
1817         SIO_idle (pC->xOut[z].hTxSio);
1819     return errno;
1821 } //PAF_AST_passProcessing
1822 #endif // #if 0
1824 #if 0
1825 // -----------------------------------------------------------------------------
1826 // AST Processing Function Helper - Pass-Through Processing Patch Point
1827 //
1828 //   Name:      PAF_AST_passProcessingCopy
1829 //   Purpose:   Pass-Through Processing Function for copying audio data
1830 //              from the input buffer to the output buffer.
1831 //   From:      AST Parameter Function -> passProcessing
1832 //   Uses:      See code.
1833 //   States:    x
1834 //   Return:    Error number in standard form (0 on success).
1835 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
1836 //              x
1837 //
1839 #pragma CODE_SECTION(PAF_AST_passProcessingCopy,".text:_PAF_AST_passProcessingCopy")
1840 /* Pass Processing is often omitted from builds to save memory, */
1841 /* and CODE_SECTION/clink constructs facilitate this omission.  */
1843 Int
1844 PAF_AST_passProcessingCopy (const PAF_AST_Params *pP, const PAF_AST_Patchs *pQ, PAF_AST_Config *pC)
1846     Int z;                              /* output counter */
1847     Int errno;                          /* error number */
1848     Int i;
1849     Int rxNumChan, txNumChan;
1850     Int zMI = pP->zone.master;
1853     asm (" .clink"); /* See comment above regarding CODE_SECTION/clink. */
1855     // Copy data from input channels to output channels one of two ways:
1857     if (SIO_ctrl (pC->xInp[zMI].hRxSio, PAF_SIO_CONTROL_GET_NUMCHANNELS, (Arg) &rxNumChan))
1858         return (ASPERR_PASS + 0x12);
1860     for (z=OUTPUT1; z < OUTPUTN; z++) {
1861         if (SIO_ctrl (pC->xOut[z].hTxSio, PAF_SIO_CONTROL_GET_NUMCHANNELS, (Arg) &txNumChan))
1862             return (ASPERR_PASS + 0x22);
1864         if( txNumChan <= rxNumChan ) {
1866             // Copy one to one, ignoring later rx channels as needed.
1868             for( i=0; i < txNumChan; i++ ) {
1869                 errno = pP->fxns->copy( i, &pC->xInp[zMI].inpBufConfig, i, &pC->xOut[z].outBufConfig );
1870                 if( errno )
1871                     return errno;
1872             }
1873         }
1874         else {
1876             // Copy one to many, repeating earlier rx channels as needed.
1878             Int from, to;
1880             from = 0;
1881             to   = 0;
1882             while( to < txNumChan ) {
1883                 errno = pP->fxns->copy( from, &pC->xInp[zMI].inpBufConfig, to, &pC->xOut[z].outBufConfig );
1884                 if( errno )
1885                     return errno;
1887                 from++;
1888                 to++;
1889                 if( from == rxNumChan )
1890                     from = 0;
1891             }
1892         }
1893     }
1895     return 0;
1896 } //PAF_AST_passProcessingCopy
1897 #endif // #if 0
1899 // -----------------------------------------------------------------------------
1900 // ASIT Processing Function - Auto Processing
1901 //
1902 //   Name:      PAF_ASIT_autoProcessing
1903 //   Purpose:   Audio Stream Input Task Function for processing audio data to
1904 //              determine the input type without output.
1905 //   From:      audioStream1Task or equivalent
1906 //   Uses:      See code.
1907 //   States:    x
1908 //   Return:    Error number in standard or SIO form (0 on success).
1909 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
1910 //              * State information on initialization.
1911 //
1913 #define DECSIOMAP(X)                                                \
1914     pP->pDecSioMap->map[(X) >= pP->pDecSioMap->length ? 0 : (X)]
1916 Int
1917 PAF_ASIT_autoProcessing(
1918     const PAF_ASIT_Params *pP, 
1919     const PAF_ASIT_Patchs *pQ, 
1920     PAF_ASIT_Config *pAsitCfg, 
1921     Int inputTypeSelect, 
1922     ALG_Handle pcmAlgMaster
1925     PAF_AST_Config *pAstCfg;
1926     Int as;                 /* Audio Stream Number (1, 2, etc.) */
1927     Int errno = 0;          /* error number */
1928     Int nbytes;
1929     Int frameLength;
1930     Int zMD;
1931     Int zMI;
1932     Int zMS;
1933     
1934     pAstCfg = pAsitCfg->pAstCfg; // get pointer to AST common (shared) configuration
1935     as = pAstCfg->as;
1936     zMD = pAstCfg->masterDec;
1937     zMS = pAstCfg->masterStr;    
1938     zMI = pP->zone.master;    
1939     
1940     TRACE_VERBOSE1("PAF_ASIT_autoProcessing: AS%d: PAF_AST_autoProcessing", as+zMS);
1942     if (errno = SIO_ctrl(pAstCfg->xInp[zMI].hRxSio,
1943                          PAF_SIO_CONTROL_SET_SOURCESELECT,
1944                          DECSIOMAP(pAstCfg->xDec[zMD].decodeStatus.sourceSelect)))
1945     {
1946         TRACE_VERBOSE2("PAF_ASIT_autoProcessing: AS%d: source select returns 0x%x", as+zMS, errno);
1947         return errno;
1948     }
1949     //frameLength = pP->fxns->computeFrameLength (pcmAlgMaster, FRAMELENGTH,
1950     //                                            pC->xDec[zMD].decodeStatus.bufferRatio);
1951     frameLength = FRAMELENGTH; // (***) FL: fix PCM frameLength
1952     
1953     if (errno = SIO_ctrl(pAstCfg->xInp[zMI].hRxSio,
1954                          PAF_SIO_CONTROL_SET_PCMFRAMELENGTH, frameLength))
1955     {
1956         TRACE_VERBOSE2("PAF_ASIT_autoProcessing: SET_PCMFRAMELENGTH returns 0x%x, returning ASPERR_AUTO_LENGTH, 0x%x",
1957             errno, ASPERR_AUTO_LENGTH);
1958         return ASPERR_AUTO_LENGTH;
1959     }
1961     if (errno = SIO_issue(pAstCfg->xInp[zMI].hRxSio,
1962                           &pAstCfg->xInp[zMI].inpBufConfig, sizeof(pAstCfg->xInp[zMI].inpBufConfig),
1963                           PAF_SIO_REQUEST_SYNC))
1964     {
1965         TRACE_VERBOSE2("PAF_ASIT_autoProcessing: REQUEST_SYNC returns 0x%x, returning ASPERR_ISSUE, 0x%x",
1966             errno, ASPERR_ISSUE);
1967         return ASPERR_ISSUE;
1968     }
1970     TRACE_VERBOSE1("PAF_ASIT_autoProcessing: AS%d: awaiting sync", as+zMS);
1972     // all of the sync scan work is done in this call. If the error returned
1973     // is DIBERR_SYNC then that just means we didn't find a sync, not a real I/O
1974     // error so we mask it off.
1975     nbytes = SIO_reclaim(pAstCfg->xInp[zMI].hRxSio, (Ptr)&pAstCfg->xInp[zMI].pInpBuf, NULL);
1976     if (nbytes == -DIBERR_SYNC)
1977     {
1978 #if 0 // (***) FL: shows timing of autosync restart
1979         // (***) debug // B5
1980         {
1981             static Uint8 toggleState = 0;
1982             if (toggleState == 0)
1983                 GPIOSetOutput(GPIO_PORT_0, GPIO_PIN_99);
1984             else
1985                 GPIOClearOutput(GPIO_PORT_0, GPIO_PIN_99);
1986             toggleState = ~(toggleState);
1987         }
1988 #endif                
1989         TRACE_TERSE2("PAF_ASIT_autoProcessing: AS%d: SIO_reclaim returned 0x%x, ignoring", as+zMS, nbytes);
1990         return nbytes;
1991     }
1992     if (nbytes != sizeof(PAF_InpBufConfig))
1993     {
1994         TRACE_TERSE3("PAF_ASIT_autoProcessing. SIO_reclaim returned %d, not %d, returning ASPERR_RECLAIM (0x%x)",
1995             nbytes, sizeof(PAF_InpBufConfig), ASPERR_RECLAIM);
1996         return ASPERR_RECLAIM;
1997     }
1998     if (errno)
1999     {
2000         TRACE_TERSE2("PAF_ASIT_autoProcessing: AS%d: returning errno 0x%x", as+zMS, errno);
2001     }
2002     return errno;
2003 } //PAF_ASIT_autoProcessing
2005 UInt32 gProbe1Err=0;
2006 UInt32 gProbe2Err=0;
2007 UInt32 gMajorAuMissed=0;
2009 // -----------------------------------------------------------------------------
2010 // ASIT Processing Function - Decode Processing
2011 //
2012 //   Name:      PAF_ASIT_decodeProcessing
2013 //   Purpose:   Audio Stream Input Task Function for processing audio data.
2014 //   From:      audioStream1Task or equivalent
2015 //   Uses:      See code.
2016 //   States:    x
2017 //   Return:    Error number in standard form (0 on success).
2018 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
2019 //              * State information on initialization (via children).
2020 //              * State information on processing (via children).
2021 //              * Decode warnings.
2022 //
2023 // When "writeDECModeContinuous" is used for zMI input/decode:
2024 // PAF_AST_decodeProcessing() loop may be (is designed to be) exited:
2025 // (a) if "writeDECCommandRestart" is used
2026 //    (or "writeDECCommandAbort", but this performs no cleanup whatsoever, and so its use is discouraged)
2027 // (b) if "writeDECSourceSelectNone" is used
2028 // [ the latter events lead to QUIT state, simply for exiting (errme = errno = ASPERR_QUIT)
2029 // (c) if an error occurs in
2030 //     INIT
2031 //     CONT ("subsequent block state", which "Establish[es] secondary timing")
2032 //         -> PAF_AST_decodeCont(): "Await slave inputs"
2033 //     STREAM (errno |= PAF_COMPONENT_ASP)
2034 //     ENCODE (errno |= PAF_COMPONENT_ENCODE)
2035 // [ the latter errors lead to "switch_break:"
2036 //         -> PAF_AST_decodeComplete(), which always returns 0 (no error) ]
2037 //
2038 // [ Notably, in FINAL ("frame-finalization state")
2039 //         -> PAF_AST_decodeFinalTest() is *not* called,
2040 //   and so any other (asynchronous) changes in pC->xDec[zMD].decodeStatus.sourceSelect are ignored. ]
2041 // [ For completeness, note also: "default" state, internal check (errme = errno = ASPERR_UNKNOWNSTATE) ]
2042 //
2043 // States in which error can't occur:
2044 //     AGAIN ("subsequent initial state")
2045 //
2046 // States in which (some) errors must be handled:
2047 //     INFO1 ("first frame state")
2048 //         -> PAF_AST_decodeInfo(): pass on ASPERR_INFO_RATECHANGE, ASPERR_INFO_PROGRAM ("bad" internal error)
2049 //            -> *DONE* must "catch" ASPERR_RECLAIM from SIO_reclaim (pC->xInp[zMI].hRxSio) -- note zMI only **
2050 //               ?*? but what about ASPERR_RESYNC from same call ?*?
2051 //            -> *for now, at least, pass on error from pP->fxns->updateInputStatus ()*
2052 //            -> *DONE* must "catch" error from (zMI) dec->fxns->info() **
2053 //         -> PAF_AST_decodeInfo1(): pass on any errors which occur here:
2054 //            - pP->fxns->streamChainFunction (... PAF_ASP_CHAINFRAMEFXNS_RESET)
2055 //            - enc->fxns->info()
2056 //            - pP->fxns->setCheckRateX()
2057 //            - pP->fxns->startOutput()
2058 //            - "Start slave inputs if necessary"
2059 //     INFO2 ("subsequent frame state")
2060 //         -> PAF_AST_decodeInfo(): (see above)
2061 //         -> PAF_AST_decodeInfo2(): pass on any errors which occur here:
2062 //            - pP->fxns->setCheckRateX()
2063 //     TIME ("timing state")
2064 //         -> PAF_AST_decodeTime(): "Special timing consideations for AC-3"
2065 //         -> performs SIO_issue (... PAF_SIO_REQUEST_FULLFRAME) & SIO_reclaim() *for zMI only*
2066 //         -> now, DIB_issue [PAF_SIO_REQUEST_FULLFRAME] would only return SYS_EINVAL for "bad" internal error
2067 //            (*OK* don't try to recover from this*)
2068 //         -> much more likely would be SIO_reclaim() error (ASPERR_RECLAIM)
2069 //         -> *DONE* must "catch" (just) ASPERR_RECLAIM error -- note zMI only,
2070 //            possibly in PAF_AST_decodeProcessing() itself **
2071 //     DECODE ("decode state")
2072 //         -> PAF_AST_decodeDecode(): pass on error from
2073 //            - PAF_SIO_CONTROL_GET_NUM_REMAINING ("bad" internal error)
2074 //            - dec->fxns->reset()
2075 //            - PAF_SIO_CONTROL_SET_PCMFRAMELENGTH
2076 //         -> *DONE* must catch error from (zMI) dec->fxns->decode()
2077 //         -> *?* must catch ASPERR_ISSUE from (zMI) SIO_issue()
2078 Int
2079 PAF_ASIT_decodeProcessing(
2080     const PAF_ASIT_Params *pP, 
2081     const PAF_ASIT_Patchs *pQ, 
2082     PAF_ASIT_Config *pAsitCfg, 
2083     Int sourceSelect
2086     PAF_AST_Config *pAstCfg;
2087     //Int as = pAsitCfg->as;              /* Audio Stream Number (1, 2, etc.) */
2088     Int z;                              /* decode counter */
2089     Int errno;                          /* error number */
2090     Int getVal;
2091     enum { INIT, INFO1, INFO2, DECODE, FINAL, QUIT } state;
2092     ALG_Handle alg[DECODEN_MAX];
2093     Int zMD;
2094     //Int zMS;
2095     Int frame; // decoder input frame count
2096     Int block; // (***) FL: formerly  -- decoder output block count / input frame
2097     Int8 tempVar8, temp2Var8;
2098     
2099     pAstCfg = pAsitCfg->pAstCfg; // get pointer to AST common (shared) configuration
2100     zMD = pAstCfg->masterDec;
2101     //zMS = pAstCfg->masterStr;
2102         
2103     for (z=DECODE1; z < DECODEN; z++)
2104     {
2105         alg[z] = pAstCfg->xDec[z].decAlg[PAF_SOURCE_PCM];        
2106     }
2107     alg[zMD] = NULL; // decAlgMaster; // FL: alg[] init is on slave
2109     //
2110     // Receive and process the data in single-frame buffers
2111     //
2113     state = INIT;
2114     errno = 0; /* error number */
2116     tempVar8 = sharedMemReadInt8(&(pAstCfg->xDec[zMD].decodeStatus.sourceSelect), 
2117                                  GATEMP_INDEX_DEC);
2118     TRACE_TERSE1("PAF_ASIT_decodeProcessing: sourceSelect is %d", tempVar8);
2120     for (;;) 
2121     {
2122         tempVar8 = sharedMemReadInt8(&(pAstCfg->xDec[zMD].decodeStatus.sourceSelect), 
2123                                      GATEMP_INDEX_DEC);
2124         if (tempVar8 == PAF_SOURCE_NONE)
2125         {
2126             TRACE_VERBOSE0("PAF_ASIT_decodeProcessing: sourceSelect == PAF_SOURCE_NONE");
2127             state = QUIT;
2128         }
2130         // Process commands (decode)
2131         getVal = pP->fxns->decodeCommand(pP, pQ, pAsitCfg);
2132         if (getVal) 
2133         {
2134             if (state != INIT)   // no need to restart/abort if not yet started
2135             {
2136                 if (getVal == ASPERR_QUIT)
2137                 {
2138                     state = QUIT;
2139                     TRACE_VERBOSE0("PAF_ASIT_decodeProcessing. %d: state = QUIT");
2140                 }
2141                 else if (getVal == ASPERR_ABORT)
2142                 {
2143                     TRACE_VERBOSE0("PAF_ASIT_decodeProcessing. %d: return getVal");
2144                     
2145                     // PFP end -- outside of PFP for errors, EOS, or Input SIO change
2146                     pfpEnd(PFP_ID_ASIT_2, PFP_FINISH_MEAS);
2147                     gNumPfpAsit2--;
2148                     
2149                     return getVal;
2150                 }
2151                 else
2152                 {
2153                     /* ignore */;
2154                 }
2155             }
2156             TRACE_VERBOSE0("PAF_ASIT_decodeProcessing: state == INIT");
2157         }
2159         TRACE_TIME((&TIME_MOD,         "... + %d = %d ->", dtime(), TSK_time()));
2160         TRACE_TIME((&TIME_MOD,         "                 state = %s", stateName[state]));
2162         // Process state (decode)
2163         switch (state) 
2164         {
2165             case INIT: // initial state
2166                 gAsipInitCnt++;
2167                 Log_info0("TaskAsip: state=INIT");               
2169                 errno = pP->fxns->decodeInit(pP, pQ, pAsitCfg, sourceSelect);
2170                 if (errno)
2171                 {
2172                     TRACE_VERBOSE1("PAF_ASIT_decodeProcessing: INIT, errno 0x%x.  break after decodeInit", errno);
2173                     break;
2174                 }
2175                                
2176                 frame = 0;
2177                 block = 0;
2179                 TRACE_VERBOSE0("PAF_ASIT_decodeProcessing: state: INIT->INFO1");
2180                 state = INFO1;
2181                 continue;
2183             case INFO1: // first frame state
2184                 gAsipInfo1Cnt++;
2185                 Log_info0("TaskAsip: state=INFO1");
2186                 
2187                 // Establish primary timing
2188                 errno = pP->fxns->decodeInfo(pP, pQ, pAsitCfg, frame, block);
2189                 if (errno)
2190                 {
2191                     gAsipInfo1_PrimaryErrCnt++;
2192                     TRACE_TERSE1("INFO1: errno 0x%x after decodeInfo, primary timing", errno);
2193                     break;
2194                 }
2195                 
2196                 tempVar8  = sharedMemReadInt8(&(pAstCfg->xDec[zMD].decodeStatus.sourceDecode),
2197                                               GATEMP_INDEX_DEC);
2198                 temp2Var8 = sharedMemReadInt8(&(pAstCfg->xDec[zMD].decodeStatus.sampleRate), 
2199                                               GATEMP_INDEX_DEC);
2200                 // Don't start decode until major access unit is found.
2201                 if (((tempVar8 == PAF_SOURCE_THD)    ||
2202                      (tempVar8 == PAF_SOURCE_DXP)    ||
2203                      (tempVar8 == PAF_SOURCE_DTSHD)) &&
2204                      (temp2Var8 == PAF_SAMPLERATE_UNKNOWN)) 
2205                 {
2206                     Int z;
2207                     for (z=DECODE1; z < DECODEN; z++) 
2208                     {
2209                         Int zI = pP->inputsFromDecodes[z];
2210                         tempVar8 = sharedMemReadInt8(&(pAstCfg->xDec[z].decodeStatus.mode), 
2211                                                      GATEMP_INDEX_DEC);
2212                         if (pAstCfg->xInp[zI].hRxSio && tempVar8)
2213                         {
2214                             TRACE_VERBOSE0("TaskAsip: PAF_ASIT_decodeProcessing: INFO1, SIO_issue");
2215                             if (SIO_issue(pAstCfg->xInp[zI].hRxSio, &pAstCfg->xInp[zI].inpBufConfig,
2216                                 sizeof(pAstCfg->xInp[zI].inpBufConfig), PAF_SIO_REQUEST_NEWFRAME))
2217                             {
2218                                 gProbe2Err++;
2219                                 TRACE_TERSE0("PAF_ASIT_decodeProcessing. %d: INFO1, return (ASPERR_ISSUE)");
2220                                 
2221                                 // PFP end -- outside of PFP for errors, EOS, or Input SIO change
2222                                 pfpEnd(PFP_ID_ASIT_2, PFP_FINISH_MEAS);
2223                                 gNumPfpAsit2--;
2224                                 
2225                                 return (ASPERR_ISSUE);
2226                             }
2227                         }
2228                     }
2229                     TRACE_VERBOSE1("PAF_ASIT_decodeProcessing: INFO1: frame %d, not major access unit", frame);
2230                     gMajorAuMissed++; // debug
2231                     frame++;
2232                     state = INFO1;
2233                     continue;
2234                 }
2235                 TRACE_VERBOSE1("PAF_ASIT_decodeProcessing: INFO1: frame %d, major access unit found", frame);
2237                 // Establish secondary timing
2238                 errno = pP->fxns->decodeInfo1(pP, pQ, pAsitCfg, frame, block);
2239                 if (errno)
2240                 {
2241                     TRACE_VERBOSE1("PAF_ASIT_decodeProcessing: INFO1, errno 0x%x.  break after decodeInfo1", errno);
2242                     gAsipInfo1_ErrCnt++;
2243                     break;
2244                 }
2246                 TRACE_VERBOSE0("PAF_ASIT_decodeProcessing: state: INFO1->DECODE");
2247                 state = DECODE;
2248                 continue;
2250             case INFO2: // subsequent frame state
2251                 gAsipInfo2Cnt++;
2252                 Log_info0("TaskAsip: state=INFO2");
2254                 // Establish primary timing
2255                 errno = pP->fxns->decodeInfo(pP, pQ, pAsitCfg, frame, block);
2256                 if (errno)
2257                 {
2258                     TRACE_TERSE1("PAF_ASIT_decodeProcessing: INFO2 break on decodeInfo. errno 0x%x", errno);
2259                     gAsipInfo2_PrimaryErrCnt++;
2260                     break;
2261                 }
2262                                 
2263                 // Measure cycles in decode processing loop.
2264                 // Only measures cycles spent in loop.
2265                 pfpEnd(PFP_ID_ASIT_2, PFP_FINISH_MEAS);         // PFP end
2266                 gNumPfpAsit2--;
2267                 pfpBegin(PFP_ID_ASIT_2, pAsitCfg->taskHandle);  // PFP begin
2268                 gNumPfpAsit2++;
2270                 errno = pP->fxns->decodeInfo2(pP, pQ, pAsitCfg, frame, block);
2271                 if (errno)
2272                 {
2273                     TRACE_TERSE1("PAF_ASIT_decodeProcessing. %d: INFO2 break on decodeInfo2. errno 0x%x", errno);
2274                     gAsipInfo2_ErrCnt++;
2275                     break;
2276                 }
2277                
2278                 TRACE_VERBOSE0("PAF_ASIT_decodeProcessing: state: INFO2->DECODE");
2279                 state = DECODE;
2280                 continue;
2282             case DECODE: // decode state
2283                 gAsipDecodeCnt++;
2284                 Log_info0("TaskAsip: state=DECODE");
2286                 errno = pP->fxns->decodeDecode(pP, pQ, pAsitCfg, sourceSelect, frame, block);
2287                 if (errno)
2288                 {
2289                     gAsipDecodeErrCnt++;
2290                     TRACE_TERSE1("PAF_ASIT_decodeProcessing: state: DECODE.  decodeDecode err 0x%04x", errno);
2291                     break;
2292                 }
2293                 
2294                 TRACE_VERBOSE0("PAF_ASIT_decodeProcessing: state: DECODE->FINAL");
2295                 state = FINAL;
2296                 continue;
2298             case FINAL: // frame-finalization state
2299                 gAsipFinalCnt++;
2300                 Log_info0("TaskAsip: state=FINAL");
2302                 // Check for final frame, and if indicated:
2303                 // - Exit state machine to "complete" processing.
2304                 if (pP->fxns->decodeFinalTest(pP, pQ, pAsitCfg, frame, block)) 
2305                 {
2306                     break;
2307                 }
2309                 frame++;
2310                 TRACE_VERBOSE0("PAF_ASIT_decodeProcessing: state: FINAL->AGAIN");
2311                 state = INFO2;
2312                 continue;
2314             case QUIT: // exit state
2315                 gAsipQuitCnt++;
2316                 Log_info0("TaskAsip: state=QUIT");
2318                 // Quit:
2319                 // - Set error number registers.
2320                 // - Exit state machine to "decode complete" processing.
2321                 TRACE_VERBOSE0("PAF_ASIT_decodeProcessing: state: QUIT");
2322                 errno = ASPERR_QUIT;
2323                 break;
2325             default: // unknown state
2327                 // Unknown:
2328                 // - Set error number registers.
2329                 // - Exit state machine to "decode complete" processing.
2331                 TRACE_TERSE1("PAF_ASIT_decodeProcessing: state: unknown, 0x%x", state);
2332                 errno = ASPERR_UNKNOWNSTATE;
2333                 break;
2335         }  // End of switch (state).
2337         TRACE_VERBOSE0("PAF_ASIT_decodeProcessing: Calling decode complete");
2338         if (pP->fxns->decodeComplete(pP, pQ, pAsitCfg, alg, frame, block))
2339         {
2340             /* ignored? */;
2341         }
2342         
2343         TRACE_TIME((&TIME_MOD, "as1-f2: ... + %d = ?? (final? %d)", dtime(), state == FINAL));
2345         // PFP end -- outside of PFP for errors, EOS, or Input SIO change
2346         //pfpEnd(PFP_ID_ASIT_2, PFP_FINISH_MEAS);
2347         //gNumPfpAsit2--;
2348         
2349         //return errno;
2350         break;
2351     }  // End of for (;;) to Receive, process, and transmit the data.
2352     
2353     // PFP end -- outside of PFP for errors, EOS, or Input SIO change
2354     pfpEnd(PFP_ID_ASIT_2, PFP_FINISH_MEAS);
2355     gNumPfpAsit2--;
2356     
2357     return errno;
2358 } //PAF_ASIT_decodeProcessing
2360 // -----------------------------------------------------------------------------
2361 // ASIT Decoding Function - Decode Command Processing
2362 //
2363 //   Name:      PAF_ASIT_decodeCommand
2364 //   Purpose:   Decoding Function for processing Decode Commands.
2365 //   From:      AST Parameter Function -> decodeProcessing
2366 //   Uses:      See code.
2367 //   States:    x
2368 //   Return:    Error number in standard form (0 on success).
2369 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
2370 //              * Command execution.
2371 //
2373 Int
2374 PAF_ASIT_decodeCommand(
2375     const PAF_ASIT_Params *pP, 
2376     const PAF_ASIT_Patchs *pQ, 
2377     PAF_ASIT_Config *pAsitCfg
2380     PAF_AST_Config *pAstCfg;
2381     Int as;                 /* Audio Stream Number (1, 2, etc.) */
2382     Int z;                  /* decode counter */
2383     Int zS;
2384     Int8 tempVar8;
2386     pAstCfg = pAsitCfg->pAstCfg; // get pointer to AST common (shared) configuration
2387     as = pAstCfg->as;
2389     for (z=DECODE1; z < DECODEN; z++) 
2390     {
2391         zS = pP->streamsFromDecodes[z];
2392         tempVar8 = sharedMemReadInt8(&(pAstCfg->xDec[z].decodeStatus.command2), 
2393                                      GATEMP_INDEX_DEC);
2394         if (!(tempVar8 & 0x80))
2395         {
2396             switch (tempVar8)
2397             {
2398                 case 0: // command none - process
2399                     tempVar8 |= 0x80;
2400                     sharedMemWriteInt8(&(pAstCfg->xDec[z].decodeStatus.command2),
2401                                        tempVar8, GATEMP_INDEX_DEC);
2402                     break;
2403                 case 1: // command abort - leave now
2404                     TRACE_TERSE2("AS%d: PAF_ASIT_decodeCommand: decode command abort (0x%02x)", as+zS, 1);
2405                     tempVar8 |= 0x80;
2406                     sharedMemWriteInt8(&(pAstCfg->xDec[z].decodeStatus.command2),
2407                                        tempVar8, GATEMP_INDEX_DEC);
2408                     return (ASPERR_ABORT);
2409                 case 2: // command restart - leave later
2410                     TRACE_TERSE2("AS%d: PAF_ASIT_decodeCommand: decode command quit (0x%02x)", as+zS, 2);
2411                     tempVar8 |= 0x80;
2412                     sharedMemWriteInt8(&(pAstCfg->xDec[z].decodeStatus.command2),
2413                                        tempVar8, GATEMP_INDEX_DEC);
2414                                        
2415                     // Invoke command to output task to break the loop
2416                     gCommandOutputTask_SYNC = 1;
2417                     
2418                     return (ASPERR_QUIT);
2419                 default: // command unknown - ignore
2420                     break;
2421             }
2422         }
2423     }
2425     return 0;
2426 } //PAF_ASIT_decodeCommand
2428 // -----------------------------------------------------------------------------
2429 // ASIT Decoding Function - Reinitialization of Decode
2430 //
2431 //   Name:      PAF_ASIT_decodeInit
2432 //   Purpose:   Decoding Function for reinitializing the decoding process.
2433 //   From:      AST Parameter Function -> decodeProcessing
2434 //   Uses:      See code.
2435 //   States:    x
2436 //   Return:    Error number in standard or SIO form (0 on success).
2437 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
2438 //              * State information as per parent.
2439 //
2440 Int
2441 PAF_ASIT_decodeInit(
2442     const PAF_ASIT_Params *pP, 
2443     const PAF_ASIT_Patchs *pQ, 
2444     PAF_ASIT_Config *pAsitCfg, 
2445     Int sourceSelect
2448     PAF_AST_Config *pAstCfg;
2449     //PAF_AST_DecOpCircBufCtl *pCbCtl;    /* Decoder output circular buffer control */
2450     Int as;                             /* Audio Stream Number (1, 2, etc.) */
2451     Int z;                              /* decode/encode counter */
2452     Int errno;                          /* error number */
2453     Int zI, zS;
2454     Int zMD;
2455     Int zMI;
2456     Int argIdx;
2457     Int8 tempVar8;
2458     char decMsgBuf[ASP_MSG_BUF_LEN];
2459     
2460     pAstCfg = pAsitCfg->pAstCfg; // get pointer to AST common (shared) configuration
2461     as = pAstCfg->as;
2462     zMD = pAstCfg->masterDec;
2463     zMI = pP->zone.master;
2464     (void)as;  // clear compiler warning in case not used with tracing disabled
2465     
2466     //pCbCtl = &pAsitCfg->pAspmCfg->decOpCircBufCtl; // get pointer to circular buffer control
2468     // reset frameCount
2469     for (z=DECODE1; z < DECODEN; z++)
2470     {
2471         tempVar8 = sharedMemReadInt8(&(pAstCfg->xDec[z].decodeStatus.mode),
2472                                      GATEMP_INDEX_DEC);
2473         if (tempVar8)
2474         {
2475             sharedMemWriteInt(&(pAstCfg->xDec[z].decodeStatus.frameCount),
2476                               (Int)0, GATEMP_INDEX_DEC);
2477         }
2478     }
2480     for (z=DECODE1; z < DECODEN; z++) 
2481     {
2482         zI = pP->inputsFromDecodes[z];
2483         zS = pP->streamsFromDecodes[z];
2484         (void)zS; // clear compiler warning in case not used with tracing disabled
2485         tempVar8 = sharedMemReadInt8(&(pAstCfg->xDec[z].decodeStatus.mode), 
2486                                      GATEMP_INDEX_DEC);
2487         if (pAstCfg->xInp[zI].hRxSio && tempVar8)
2488         {
2490             Uns gear;
2491             Int frameLength;
2492             TRACE_VERBOSE1("AS%d: PAF_ASIT_decodeInit: initializing decode", as+zS);
2494             // write back Dec configuration
2495             Cache_wb(&pAstCfg->xDec[z], sizeof(PAF_AST_Decode), Cache_Type_ALLD, 0);
2496             Cache_wait();
2498             // FL: send dec activate message to slave
2499             argIdx = 0; // set decIdx (zone index)
2500             *(Int32 *)&decMsgBuf[argIdx] = z;
2501             if(AspMsgSend(ASP_SLAVE_DEC_ACTIVATE, ASP_MASTER_DEC_ACTIVATE_DONE, 
2502                           decMsgBuf, NULL) != ASP_MSG_NO_ERR)
2503             {
2504                 TRACE_TERSE0("decodeInit: error in sending DEC_ACTIVATE message ");
2505                 SW_BREAKPOINT; // temporary
2506                 return -1; // temporary
2507             }           
2509 #if 0 // FL: decoder activate call, slave
2510             if (decAlg[z]->fxns->algActivate)
2511                 decAlg[z]->fxns->algActivate (decAlg[z]);
2512 #endif
2513             // FL: send dec reset message to slave
2514             argIdx = 0; // set decIdx
2515             *(Int32 *)&decMsgBuf[argIdx] = z;
2516             if(AspMsgSend(ASP_SLAVE_DEC_RESET, ASP_MASTER_DEC_RESET_DONE, 
2517                           decMsgBuf, decMsgBuf) != ASP_MSG_NO_ERR)
2518             {
2519                 TRACE_TERSE0("decodeInit: error in sending DEC_RESET message ");
2520                 SW_BREAKPOINT; // temporary
2521                 return -1; // temporary
2522             }
2523             else
2524             {
2525                 argIdx = 0; // get decErrno
2526                 errno = *(Int32 *)&decMsgBuf[argIdx];                
2527             }   
2529             // (***) FL: revisit
2530             // invalidate Dec configuration
2531             Cache_inv(&pAstCfg->xDec[z], sizeof(PAF_AST_Decode), Cache_Type_ALLD, 0);
2532             Cache_wait();
2533             
2534 #if 0 // FL: decoder reset call, slave
2535             if (dec->fxns->reset
2536                 && (errno = dec->fxns->reset (dec, NULL,
2537                                               &pC->xDec[z].decodeControl, &pC->xDec[z].decodeStatus)))
2538                 return errno;
2539 #endif
2540             if (errno != 0)
2541             {
2542                 return errno;
2543             }
2544             
2545             gear = (Uns)sharedMemReadInt8(&(pAstCfg->xDec[z].decodeStatus.aspGearControl),
2546                                               GATEMP_INDEX_DEC);
2547             tempVar8 = gear < GEARS ? gear : 0;
2548             sharedMemWriteInt8(&(pAstCfg->xDec[z].decodeStatus.aspGearStatus),
2549                                    tempVar8, GATEMP_INDEX_DEC);
2550             
2551 #if 0 // FL: change handle to decIdx (zone index)
2552             frameLength = pP->fxns->computeFrameLength(decAlg[z], 
2553                 FRAMELENGTH,
2554                 pC->xDec[z].decodeStatus.bufferRatio);
2555 #endif
2556 #if 0 // (***) FL: revisit. Bypass decoder computeFrameLength() function.
2557             frameLength = pP->fxns->computeFrameLength(z, 
2558                 FRAMELENGTH, 
2559                 pC->xDec[z].decodeStatus.bufferRatio);
2560 #else
2561             // Compute decoder frame length based on source selection
2562             frameLength = getFrameLengthSourceSel(pP, sourceSelect);
2563 #endif    
2564             
2565             pAstCfg->xDec[z].decodeControl.frameLength = frameLength;
2566             pAstCfg->xDec[z].decodeInStruct.sampleCount = frameLength;
2567             pAstCfg->xDec[z].decodeControl.sampleRate = PAF_SAMPLERATE_UNKNOWN;
2568           
2569 #if 0 // FL: Moved to ARM:ASDT:INFO
2570             // Initialize decoder output circular buffer for selected source
2571             errno = cbInitSourceSel(pCbCtl, z, sourceSelect, frameLength, FRAMELENGTH, 0);
2572             if (errno)
2573             {
2574                 SW_BREAKPOINT; // debug
2575                 return errno;
2576             }
2577             // debug
2578             cbLog(pCbCtl, z, 1, "PAF_ASIT_decodeInit:cbInitSourceSel");
2579 #endif
2580             
2581             if (z != zMD) 
2582             {
2583                 if (errno = SIO_idle(pAstCfg->xInp[zI].hRxSio))
2584                 {
2585                     return errno;
2586                 }
2587             }
2589             tempVar8 = sharedMemReadInt8(&(pAstCfg->xDec[z].decodeStatus.sourceSelect),
2590                                              GATEMP_INDEX_DEC);
2591             if (errno = SIO_ctrl(pAstCfg->xInp[zI].hRxSio, PAF_SIO_CONTROL_SET_SOURCESELECT,
2592                 DECSIOMAP(tempVar8)))
2593             {
2594                 return errno;
2595             }
2597             if (errno = SIO_ctrl(pAstCfg->xInp[zI].hRxSio, PAF_SIO_CONTROL_SET_PCMFRAMELENGTH, 
2598                 frameLength))
2599             {
2600                 return errno;
2601             }
2602             if (errno = pP->fxns->updateInputStatus(pAstCfg->xInp[zI].hRxSio, &pAstCfg->xInp[zI].inpBufStatus, 
2603                 &pAstCfg->xInp[zI].inpBufConfig))
2604             {
2605                 return errno;
2606             }
2607         }
2608     }
2610     if (pAstCfg->xInp[zMI].hRxSio) 
2611     {
2612         errno = SIO_issue(pAstCfg->xInp[zMI].hRxSio, &pAstCfg->xInp[zMI].inpBufConfig,
2613             sizeof(pAstCfg->xInp[zMI].inpBufConfig), PAF_SIO_REQUEST_NEWFRAME);
2614         if (errno)
2615         {
2616             return errno;
2617         }
2618     }
2620     return 0;
2621 } //PAF_AST_decodeInit
2623 // -----------------------------------------------------------------------------
2624 // ASIT Decoding Function - Info Processing, Common
2625 //
2626 //   Name:      PAF_ASIT_decodeInfo
2627 //   Purpose:   Decoding Function for processing information in a manner that
2628 //              is common for both initial and subsequent frames of input data.
2629 //   From:      AST Parameter Function -> decodeProcessing
2630 //   Uses:      See code.
2631 //   States:    x
2632 //   Return:    Error number in standard form (0 on success).
2633 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
2634 //              * State information as per parent.
2635 //
2636 Int
2637 PAF_ASIT_decodeInfo(
2638     const PAF_ASIT_Params *pP, 
2639     const PAF_ASIT_Patchs *pQ, 
2640     PAF_ASIT_Config *pAsitCfg, 
2641     Int frame, 
2642     Int block
2645     PAF_AST_Config *pAstCfg;
2646     Int as;                    /* Audio Stream Number (1, 2, etc.) */
2647     Int z;                     /* input/decode/stream counter */
2648     Int errno;                 /* error number */
2649     Int sioErr;                /* error number, SIO */
2650     Int zD, zI, zS, zX;
2651     Int zMD;
2652     Int zMI;
2653     Int zMS;
2654     Int argIdx;
2655     Int8 tempVar8;
2656     Int tempVar;
2657     char decMsgBuf[ASP_MSG_BUF_LEN];
2658     // FL: revisit
2659     //Int size;
2660     //PAF_InpBufConfig *pIpBufConfig;
2661     // debug
2662     //UInt32 curTime;
2664     pAstCfg = pAsitCfg->pAstCfg; // get pointer to AST common (shared) configuration
2665     as = pAstCfg->as;
2666     zMD = pAstCfg->masterDec;
2667     zMS = pAstCfg->masterStr;
2668     zMI = pP->zone.master;
2669     (void)zMS;  (void)as;  // clear compiler warning in case not used with tracing disabled
2670     
2671     // Set decode control: sample rate, emphasis
2672     for (z=INPUT1; z < INPUTN; z++)
2673     {
2674         zD = z;
2675         for (zX = DECODE1; zX < DECODEN; zX++) 
2676         {
2677             if (pP->inputsFromDecodes[zX] == z) 
2678             {
2679                 zD = zX;
2680                 break;
2681             }
2682         }
2683 #ifdef PROFILER
2684             // modify for different sampling rate
2685             if (pAstCfg->xInp[z].inpBufStatus.sampleRateStatus == PAF_SAMPLERATE_96000HZ)
2686             {
2687                 start_profiling = 1;
2688             }
2689             else
2690             {
2691                 start_profiling = 0;
2692             }
2693 #endif
2694         if (pAstCfg->xInp[z].hRxSio) 
2695         {
2696             //determine associated decoder
2697             if (pAstCfg->xInp[z].inpBufStatus.sampleRateStatus != 
2698                 pAstCfg->xDec[zD].decodeControl.sampleRate) 
2699             {
2700                 if (pAstCfg->xDec[zD].decodeControl.sampleRate == PAF_SAMPLERATE_UNKNOWN) 
2701                 {
2702                     pAstCfg->xDec[zD].decodeControl.sampleRate = 
2703                         pAstCfg->xInp[z].inpBufStatus.sampleRateStatus;
2704                 }
2705                 else
2706                 {
2707                     TRACE_TERSE1("AS%d: return error ASPERR_INFO_RATECHANGE", as+pAstCfg->masterStr);
2708                     TRACE_TERSE2("inpBufStatus.sampleRateStatus: 0x%x, decodeControl.sampleRate: 0x%x",
2709                         pAstCfg->xInp[z].inpBufStatus.sampleRateStatus, 
2710                         pAstCfg->xDec[zD].decodeControl.sampleRate);
2711                     // return (ASPERR_INFO_RATECHANGE);
2712                 }
2713             }
2715             tempVar8 = sharedMemReadInt8(&(pAstCfg->xDec[zD].decodeStatus.sourceDecode),
2716                                              GATEMP_INDEX_DEC);
2717             pAstCfg->xDec[zD].decodeControl.emphasis = 
2718                 tempVar8 != PAF_SOURCE_PCM
2719                 ? PAF_IEC_PREEMPHASIS_NO // fix for Mantis ID #119
2720                 : pAstCfg->xInp[z].inpBufStatus.emphasisStatus;
2721         }
2722         else 
2723         {
2724             pAstCfg->xDec[zD].decodeControl.sampleRate = PAF_SAMPLERATE_UNKNOWN;
2725             pAstCfg->xDec[zD].decodeControl.emphasis = PAF_IEC_PREEMPHASIS_UNKNOWN;
2726         }
2727     }
2729     // Wait for info input
2730     TRACE_VERBOSE2("PAF_ASIT_decodeInfo: AS%d: awaiting frame %d -- sync+info+data", as+zMS, frame);
2731     if (pAstCfg->xInp[zMI].hRxSio) 
2732     {
2733         TRACE_VERBOSE0("PAF_ASIT_decodeInfo: call SIO_reclaim to get input buffer.");
2734         sioErr = SIO_reclaim(pAstCfg->xInp[zMI].hRxSio, (Ptr)&pAstCfg->xInp[zMI].pInpBuf, NULL);
2735         if (sioErr != sizeof(pAstCfg->xInp[zMI].inpBufConfig))
2736         {
2737             TRACE_TERSE1("SIO_reclaim on input returned error ASPERR_RECLAIM.  sioErr: 0x%x", sioErr);
2738             return ASPERR_RECLAIM;
2739         }
2740         
2741 #if 0 // debug, capture input buffer
2742         capIb(pAstCfg->xInp[zMI].pInpBuf);
2743         gCapIb_cnt++;
2744 #endif
2745         
2746 #if 0 // (***) FL: shows timing of Input Rx SIO reclaim after decoding has started (autodet complete)
2747         // (***) debug // B5
2748         {
2749             static Uint8 toggleState = 0;
2750             if (toggleState == 0)
2751                 GPIOSetOutput(GPIO_PORT_0, GPIO_PIN_99);
2752             else
2753                 GPIOClearOutput(GPIO_PORT_0, GPIO_PIN_99);
2754             toggleState = ~(toggleState);
2755         }
2756 #endif
2758         //
2759         // Simulate Rx SIO_reclaim() pend
2760         //
2761         //Semaphore_pend(semaphoreRxAudio, BIOS_WAIT_FOREVER); 
2762         //curTime = Clock_getTicks();
2763         //System_printf("System time in TaskAsipFxn Rx audio = %lu\n", (ULong)curTime);        
2764         //Log_info1("System time in TaskAsipFxn Rx audio = %u", curTime);
2765         //Log_info1("decodeInfo():Rx SIO reclaim(), system time = %u", curTime);
2766         
2767         gAsipRxSioReclaimCnt++;
2768     } //pAstCfg->xInp[zMI].hRxSio
2770     // Decode info
2771     for (z=DECODE1; z < DECODEN; z++) 
2772     {
2773         zI = pP->inputsFromDecodes[z];
2774         zS = pP->streamsFromDecodes[z];
2775         (void)zS; // clear compiler warning in case not used with tracing disabled
2777         tempVar8 = sharedMemReadInt8(&(pAstCfg->xDec[z].decodeStatus.mode),
2778                                      GATEMP_INDEX_DEC);
2779         if (pAstCfg->xInp[zI].hRxSio && tempVar8)
2780         {
2781             TRACE_GEN2("PAF_ASIT_decodeInfo: AS%d: processing frame %d -- info", as+zS, frame);
2783             if (errno = pP->fxns->updateInputStatus(pAstCfg->xInp[zI].hRxSio,
2784                 &pAstCfg->xInp[zI].inpBufStatus, &pAstCfg->xInp[zI].inpBufConfig))
2785             {
2786                 TRACE_TERSE1("return error errno 0x%x.", errno);
2787                 return errno;
2788             }
2790 #if 1
2791             // (***) FL: revisit
2792             // write back Inp configuration
2793             Cache_wb(&pAstCfg->xInp[zI], sizeof(PAF_AST_InpBuf), Cache_Type_ALLD, 0);
2794             // write back Dec configuration
2795             Cache_wb(&pAstCfg->xDec[z], sizeof(PAF_AST_Decode), Cache_Type_ALLD, 0);
2796             Cache_wait();
2797 #endif
2798             
2799             // FL: send info message to slave
2800             argIdx = 0; // set decIdx
2801             *(Int32 *)&decMsgBuf[argIdx] = z;
2802             if(AspMsgSend(ASP_SLAVE_DEC_INFO, ASP_MASTER_DEC_INFO_DONE, 
2803                           decMsgBuf, decMsgBuf) != ASP_MSG_NO_ERR)
2804             {
2805                 TRACE_TERSE0("decodeInfo: error in sending DEC_INFO message ");
2806                 SW_BREAKPOINT; // temporary
2807                 return -1;     // temporary
2808             }
2809             else
2810             {
2811                 argIdx = 0; // get decErrno
2812                 errno = *(Int32 *)&decMsgBuf[argIdx];                
2813             }             
2815 #if 1
2816             // (***) FL: revisit
2817             // invalidate Dec configuration
2818             Cache_inv(&pAstCfg->xDec[z], sizeof(PAF_AST_Decode), Cache_Type_ALLD, 0);
2819             Cache_wait();                            
2820 #endif            
2821             
2822 #if 0 // FL: decoder info call, slave
2823             if (dec->fxns->info
2824                 && (errno = dec->fxns->info (dec, NULL,
2825                                              &pC->xDec[z].decodeControl, &pC->xDec[z].decodeStatus))) 
2826 #endif
2827             if (errno)
2828             {
2829                 TRACE_TERSE1("return error errno 0x%x.", errno);
2830                 return errno;
2831             }
2833             // increment decoded frame count
2834             tempVar = sharedMemReadInt(&(pAstCfg->xDec[z].decodeStatus.frameCount),
2835                                        GATEMP_INDEX_DEC);
2836             tempVar += 1;
2837             sharedMemWriteInt(&(pAstCfg->xDec[z].decodeStatus.frameCount),
2838                               tempVar, GATEMP_INDEX_DEC);
2839         }
2840     } // z=DECODE1 to DECODEN
2842     // query IB for latest sourceProgram (needed if we started decoding due to a force mode)
2843     tempVar8 = sharedMemReadInt8(&(pAstCfg->xDec[zMD].decodeStatus.mode),
2844                                  GATEMP_INDEX_DEC);
2845     if (tempVar8)
2846     {
2847         XDAS_Int8 sourceProgram;
2848         if (errno = SIO_ctrl(pAstCfg->xInp[zMI].hRxSio, PAF_SIO_CONTROL_GET_SOURCEPROGRAM,
2849             (Arg)&sourceProgram))
2850         {
2851             TRACE_TERSE1("return error ASPERR_AUTO_PROGRAM. errno 0x%x.", errno);
2852             return ASPERR_AUTO_PROGRAM;
2853         }
2855         sharedMemWriteInt8(&(pAstCfg->xDec[zMD].decodeStatus.sourceProgram),
2856                            sourceProgram, GATEMP_INDEX_DEC);
2857     }
2859     // since now decoding update decode status for all enabled decoders
2860     for (z=DECODE1; z < DECODEN; z++)
2861     {
2862         tempVar8 = sharedMemReadInt8(&(pAstCfg->xDec[z].decodeStatus.mode),
2863                                      GATEMP_INDEX_DEC);
2864         if (tempVar8)
2865         {
2866             tempVar8 = sharedMemReadInt8(&(pAstCfg->xDec[z].decodeStatus.sourceProgram),
2867                                          GATEMP_INDEX_DEC);
2868             sharedMemWriteInt8(&(pAstCfg->xDec[z].decodeStatus.sourceDecode),
2869                                tempVar8, GATEMP_INDEX_DEC);
2871             tempVar8 = sharedMemReadInt8(&(pAstCfg->xDec[z].decodeStatus.sourceSelect),
2872                                          GATEMP_INDEX_DEC);
2873             if (tempVar8 == PAF_SOURCE_SNG)
2874             {
2875                 tempVar8 = PAF_SOURCE_SNG;
2876                 sharedMemWriteInt8(&(pAstCfg->xDec[z].decodeStatus.sourceDecode),
2877                                    tempVar8, GATEMP_INDEX_DEC);
2878             }
2879         }
2880     }
2882 #if 0 // FL: ASDT (slave)
2883     // TODO: move this to start of this function so that it doesn't affect IO timing
2884     // Initialize audio frame(s)
2885     //    Re-initialize audio frame if there is an associated decode and
2886     //    that decode doesn't have a valid input or is turned off
2887     for (z=STREAM1; z < STREAMN; z++) 
2888     {
2889         Int reset = 0;
2890         for (zX = DECODE1; zX < DECODEN; zX++) 
2891         {
2892             if (pP->streamsFromDecodes[zX] == z) 
2893             {
2894                 zI = pP->inputsFromDecodes[zX];
2895                 if (!pC->xDec[zX].decodeStatus.mode || !pC->xInp[zI].hRxSio)
2896                 {
2897                     reset = 1;
2898                 }
2899             }
2900         }
2901         if (reset) 
2902         {
2903             TRACE_VERBOSE2("PAF_ASIT_decodeInfo: AS%d: initializing block %d -- info", as+z, frame);
2904             pP->fxns->initFrame1 (pP, pQ, pC, z, 0);
2905         }
2906         else
2907         {
2908             TRACE_VERBOSE2("PAF_ASIT_decodeInfo: AS%d: initializing block %d -- info <ignored>", as+z, frame);
2909         }
2910     }
2911 #endif    
2913     return 0;
2914 } //PAF_ASIT_decodeInfo
2916 // -----------------------------------------------------------------------------
2917 // ASIT Decoding Function - Info Processing, Initial
2918 //
2919 //   Name:      PAF_ASIT_decodeInfo1
2920 //   Purpose:   Decoding Function for processing information in a manner that
2921 //              is unique to initial frames of input data.
2922 //   From:      AST Parameter Function -> decodeProcessing
2923 //   Uses:      See code.
2924 //   States:    x
2925 //   Return:    Error number in standard or SIO form (0 on success).
2926 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
2927 //              * State information as per parent.
2928 //
2929 Int
2930 PAF_ASIT_decodeInfo1(
2931     const PAF_ASIT_Params *pP, 
2932     const PAF_ASIT_Patchs *pQ, 
2933     PAF_ASIT_Config *pAsitCfg, 
2934     Int frame, 
2935     Int block
2938     return 0;
2939 } //PAF_ASIT_decodeInfo1
2941 // -----------------------------------------------------------------------------
2942 // AST Decoding Function - Info Processing, Subsequent
2943 //
2944 //   Name:      PAF_AST_decodeInfo2
2945 //   Purpose:   Decoding Function for processing information in a manner that
2946 //              is unique to frames of input data other than the initial one.
2947 //   From:      AST Parameter Function -> decodeProcessing
2948 //   Uses:      See code.
2949 //   States:    x
2950 //   Return:    Error number in standard form (0 on success).
2951 //   Trace:     None.
2952 //
2953 Int
2954 PAF_ASIT_decodeInfo2(
2955     const PAF_ASIT_Params *pP, 
2956     const PAF_ASIT_Patchs *pQ, 
2957     PAF_ASIT_Config *pAsitCfg, 
2958     Int frame, 
2959     Int block
2962     return 0;
2963 } //PAF_ASIT_decodeInfo2
2965 #if 0
2966 // -----------------------------------------------------------------------------
2967 // AST Decoding Function - Continuation Processing
2968 //
2969 //   Name:      PAF_AST_decodeCont
2970 //   Purpose:   Decoding Function for processing that occurs subsequent to
2971 //              information processing but antecedent to timing processing
2972 //              for frames of input data other than the initial one.
2973 //   From:      AST Parameter Function -> decodeProcessing
2974 //   Uses:      See code.
2975 //   States:    x
2976 //   Return:    Error number in standard form (0 on success).
2977 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
2978 //              * State information as per parent.
2979 //
2981 Int
2982 PAF_AST_decodeCont(
2983     const PAF_ASIT_Params *pP, 
2984     const PAF_ASIT_Patchs *pQ, 
2985     PAF_ASIT_Config *pAsitCfg, 
2986     ALG_Handle decAlg[], 
2987     Int frame, 
2988     Int block
2991     PAF_AST_Config *pAstCfg;
2992     Int as;                     /* Audio Stream Number (1, 2, etc.) */
2993     Int z;                      /* decode counter */
2994     Int zI, zS;
2995     Int zMD;
2996     Int8 tempVar8;
2998     
2999     pAstCfg = pAsitCfg->pAstCfg; // get pointer to AST common (shared) configuration
3000     as = pAstCfg->as;
3001     zMD = pAstCfg->masterDec;
3002     (void)as;  // clear compiler warning in case not used with tracing disabled
3003     
3004     // Await slave inputs
3005     for (z=DECODE1; z < DECODEN; z++)
3006     {
3007         zI = pP->inputsFromDecodes[z];
3008         zS = pP->streamsFromDecodes[z];
3009         (void)zS;
3010         tempVar8 = sharedMemReadInt8(&(pAstCfg->xDec[z].decodeStatus.mode),
3011                                      GATEMP_INDEX_DEC);
3012         if (z == zMD
3013             || ! pAstCfg->xInp[zI].hRxSio
3014             || ! tempVar8)
3015             continue;
3016         TRACE_VERBOSE2("PAF_AST_decodeCont: AS%d: awaiting frame %d -- data", as+zS, frame);
3017         if (SIO_reclaim(pAstCfg->xInp[zI].hRxSio, (Ptr)&pAstCfg->xInp[zI].pInpBuf, NULL)
3018             != sizeof (pAstCfg->xInp[zI].inpBufConfig))
3019             return (ASPERR_RECLAIM);
3020     }
3022     return 0;
3023 } //PAF_AST_decodeCont
3024 #endif
3026 // -----------------------------------------------------------------------------
3027 // ASIT Decoding Function - Decode Processing
3028 //
3029 //   Name:      PAF_ASIT_decodeDecode
3030 //   Purpose:   Decoding Function for processing of input data by the
3031 //              Decode Algorithm.
3032 //   From:      AST Parameter Function -> decodeProcessing
3033 //   Uses:      See code.
3034 //   States:    x
3035 //   Return:    Error number in standard form (0 on success).
3036 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
3037 //              * State information as per parent.
3038 //
3039 Int
3040 PAF_ASIT_decodeDecode(
3041     const PAF_ASIT_Params *pP, 
3042     const PAF_ASIT_Patchs *pQ, 
3043     PAF_ASIT_Config *pAsitCfg, 
3044     Int sourceSelect, 
3045     Int frame, 
3046     Int block
3049     PAF_AST_Config *pAstCfg;
3050     Int as;                     /* Audio Stream Number (1, 2, etc.) */
3051     Int z;                      /* decode/stream counter */
3052     Int errno;                  /* error number */
3053     //Int ch;
3054     Int argIdx;
3055     Int cbErrno;
3056     Int frameLength;    
3057     char decMsgBuf[ASP_MSG_BUF_LEN];
3059     pAstCfg = pAsitCfg->pAstCfg; // get pointer to AST common (shared) configuration
3060     as = pAstCfg->as;
3061     (void)as; // clear compiler warning in case not used with tracing disabled
3063 #if 0 // FL: slave
3064     // Clear samsiz for all channels - MID 208.
3065     for (z=STREAM1; z < STREAMN; z++) 
3066     {
3067         for (ch=0; ch < PAF_MAXNUMCHAN_AF; ch++) 
3068         {
3069             pC->xStr[z].pAudioFrame->data.samsiz[ch] = 0;
3070         }
3071     }
3072 #endif    
3074     // Decode data
3075     for (z=DECODE1; z < DECODEN; z++) 
3076     {
3077         Int zI = pP->inputsFromDecodes[z];
3078         Int zS = pP->streamsFromDecodes[z];
3079         (void)zS; // clear compiler warning in case not used with tracing disabled
3080         if (pAstCfg->xInp[zI].hRxSio && pAstCfg->xDec[z].decodeStatus.mode)
3081         {
3082             TRACE_GEN2("PAF_ASIT_decodeDecode: AS%d: decodeDecode: processing block %d -- decode", as+zS, block);
3084             TRACE_VERBOSE3("PAF_ASIT_decodeDecode: AS%d: decodeDecode: decoding from 0x%x (base) 0x%x (ptr)",
3085                     as+zS,
3086                     (IArg)pAstCfg->xInp[z].pInpBuf->base.pVoid,
3087                     (IArg)pAstCfg->xInp[z].pInpBuf->head.pVoid);
3089 #if 0 // debug, capture input buffer
3090             capIbPcm(pAstCfg->xInp[z].pInpBuf);
3091 #endif
3092             
3093             // (***) FL: revisit
3094             // write back Dec configuration
3095             Cache_wb(&pAstCfg->xDec[z], sizeof(PAF_AST_Decode), Cache_Type_ALLD, 0);
3096             Cache_wait();                        
3098             // FL: send decode message to slave
3099             argIdx = 0; // set decIdx
3100             *(Int32 *)&decMsgBuf[argIdx] = z;
3101             if(AspMsgSend(ASP_SLAVE_DEC_DECODE, ASP_MASTER_DEC_DECODE_DONE, 
3102                           decMsgBuf, decMsgBuf) != ASP_MSG_NO_ERR)
3103             {
3104                 TRACE_TERSE0("decodeDecode: error in sending DEC_DECODE message ");
3105                 SW_BREAKPOINT; // temporary
3106                 return -1;     // temporary
3107             }
3108             else 
3109             {
3110                 argIdx = 0; // get decErrno
3111                 errno = *(Int32 *)&decMsgBuf[argIdx];
3112                 argIdx += sizeof(Int32); // get cbErrno
3113                 cbErrno = *(Int32 *)&decMsgBuf[argIdx];
3114                 if (cbErrno != 0)
3115                 {
3116                     gCbWrtAfErrCnt++;
3117                     TRACE_TERSE1("CB write error=%d", cbErrno);
3118                     //SW_BREAKPOINT; // temporary
3119                 }
3120             }           
3122             // (***) FL: revisit
3123             // invalidate Dec configuration
3124             Cache_inv(&pAstCfg->xDec[z], sizeof(PAF_AST_Decode), Cache_Type_ALLD, 0);
3125             Cache_wait();
3127 #if 0 // FL: decoder decode call, slave
3128             if (dec->fxns->decode
3129                 && (errno = dec->fxns->decode (dec, NULL,
3130                                                &pC->xDec[z].decodeInStruct, &pC->xDec[z].decodeOutStruct))) 
3131 #endif
3132             if (errno)
3133             {
3134                 TRACE_VERBOSE1("PAF_ASIT_decodeDecode: fxns->decode returns 0x%x", errno);
3135                 return errno;
3136             }
3138 #if (CURRENT_TRACE_MASK & TRACE_MASK_DATA)
3139             as_traceChannels(pC, z);
3140 #endif
3142 #if 0 // FL: change handle to decIdx (zone index)  
3143             frameLength = pP->fxns->computeFrameLength(decAlg[z],
3144                 FRAMELENGTH, 
3145                 pC->xDec[z].decodeStatus.bufferRatio);
3146 #endif
3147 #if 0 // (***) FL: revisit. Bypass decoder computeFrameLength() function.
3148             frameLength = pP->fxns->computeFrameLength(z, 
3149                 FRAMELENGTH, 
3150                 pC->xDec[z].decodeStatus.bufferRatio);
3151 #else
3152             // Compute decoder frame length based on source selection
3153             frameLength = getFrameLengthSourceSel(pP, sourceSelect);
3154 #endif
3157 //#ifdef PROFILER
3158 //            // modify for different decoders
3159 //            if (sourceSelect == PAF_SOURCE_THD)
3160 //            {
3161 //                start_profiling = 1;
3162 //            }
3163 //            else
3164 //            {
3165 //                start_profiling = 0;
3166 //            }
3167 //#endif
3170 // ............................................................................
3172             pAstCfg->xDec[z].decodeControl.frameLength = frameLength;
3173             pAstCfg->xDec[z].decodeInStruct.sampleCount = frameLength;
3174             if (errno = SIO_ctrl(pAstCfg->xInp[zI].hRxSio,
3175                 PAF_SIO_CONTROL_SET_PCMFRAMELENGTH, frameLength))
3176             {
3177                 TRACE_VERBOSE1("PAF_ASIT_decodeDecode: SIO SET_PCMFRAMELENGTH returns 0x%x", errno);
3178                 return errno;
3179             }
3180                 
3181             TRACE_VERBOSE1("PAF_ASIT_decodeDecode: calling SIO_issue[%d]", zI);
3182             if (errno = SIO_issue(pAstCfg->xInp[zI].hRxSio, &pAstCfg->xInp[zI].inpBufConfig,
3183                 sizeof(pAstCfg->xInp[zI].inpBufConfig),
3184                 PAF_SIO_REQUEST_NEWFRAME))
3185             {
3186                 TRACE_VERBOSE2("PAF_ASIT_decodeDecode: SIO_issue returns 0x%x, we return ASPERR_ISSUE (0x%x)", errno, ASPERR_ISSUE);
3187                 return (ASPERR_ISSUE);
3188             }
3189         } // hRxSio && decodeStatus.mode
3190         else
3191         {
3192             TRACE_VERBOSE2("AS%d: PAF_ASIT_decodeDecode: processing block %d -- decode <ignored>", as+zS, block);
3193         }
3194     } // z=DECODE1 to DECODEN
3196 #if 0 // FL: ASDT (slave)
3197     // Set up audio frames not decoded into
3198     //    Re-initialize audio frame if there is an assocatiated decode and
3199     //    that decode doesn't have a valid input or is turned off
3200     for (z=STREAM1; z < STREAMN; z++) 
3201     {
3202         Int zX;
3203         Int reset = 0;
3204         for (zX = DECODE1; zX < DECODEN; zX++) 
3205         {
3206             if (pP->streamsFromDecodes[zX] == z) 
3207             {
3208                 Int zI = pP->inputsFromDecodes[zX];
3209                 if (!pC->xDec[zX].decodeStatus.mode || !pC->xInp[zI].hRxSio)
3210                     reset = 1;
3211             }
3212         }
3213         if (reset) 
3214         {
3215             TRACE_VERBOSE2("PAF_ASIT_decodeDecode: AS%d: initializing block %d -- decode", as+z, frame);
3216             pP->fxns->initFrame1 (pP, pQ, pC, z, 0);
3217         }
3218         else
3219             TRACE_VERBOSE2("PAF_ASIT_decodeDecode: AS%d: initializing block %d -- decode <ignored>", as+z, frame);
3220     }
3221 #endif
3222     
3223     return 0;
3224 } //PAF_ASIT_decodeDecode
3226 // -----------------------------------------------------------------------------
3227 // ASIT Decoding Function - Frame-Final Processing
3228 //
3229 //   Name:      PAF_ASIT_decodeFinalTest
3230 //   Purpose:   Decoding Function for determining whether processing of the
3231 //              current frame is complete.
3232 //   From:      AST Parameter Function -> decodeProcessing
3233 //   Uses:      See code.
3234 //   States:    x
3235 //   Return:    0 if incomplete, and 1 if complete.
3236 //   Trace:     None.
3237 //
3239 Int
3240 PAF_ASIT_decodeFinalTest(
3241     const PAF_ASIT_Params *pP, 
3242     const PAF_ASIT_Patchs *pQ, 
3243     PAF_ASIT_Config *pAsitCfg, 
3244     Int frame, 
3245     Int block
3248     PAF_AST_Config *pAstCfg;
3249     Int zMD;
3250     Int sourceSelect;
3251     Int sourceProgram;
3252     Int8 tempVar8, temp2Var8;
3254     pAstCfg = pAsitCfg->pAstCfg; // get pointer to AST common (shared) configuration
3255     zMD = pAstCfg->masterDec;
3257     sourceSelect  = (Int)sharedMemReadInt8(&(pAstCfg->xDec[zMD].decodeStatus.sourceSelect),
3258                                            GATEMP_INDEX_DEC);
3259     sourceProgram = (Int)sharedMemReadInt8(&(pAstCfg->xDec[zMD].decodeStatus.sourceProgram),
3260                                            GATEMP_INDEX_DEC);
3262     if ((sourceSelect == PAF_SOURCE_NONE) || (sourceSelect == PAF_SOURCE_PASS))
3263     {
3264         return 1;
3265     }
3267     // The following allows for Force modes to switch without command deferral. This might
3268     // be better suited for inclusion in DIB_requestFrame, but for now will reside here.
3269     if ((sourceSelect == PAF_SOURCE_SNG) || (sourceSelect > PAF_SOURCE_BITSTREAM)) 
3270     {
3271         if (sourceSelect == PAF_SOURCE_DTSALL)
3272         {
3273             if (sourceProgram != PAF_SOURCE_DTS11 &&
3274                 sourceProgram != PAF_SOURCE_DTS12 &&
3275                 sourceProgram != PAF_SOURCE_DTS13 &&
3276                 sourceProgram != PAF_SOURCE_DTS14 &&
3277                 sourceProgram != PAF_SOURCE_DTS16 &&
3278                 sourceProgram != PAF_SOURCE_DTSHD)
3279             {
3280                 return 1;
3281             }
3282         }
3283         else if (sourceSelect == PAF_SOURCE_PCMAUTO) 
3284         {
3285             if (sourceProgram != PAF_SOURCE_PCM)
3286             {
3287                 return 1;
3288             }
3289         }
3290         else 
3291         {
3292             tempVar8  = sharedMemReadInt8(&(pAstCfg->xDec[zMD].decodeStatus.sourceDecode),
3293                                           GATEMP_INDEX_DEC);
3294             temp2Var8 = sharedMemReadInt8(&(pAstCfg->xDec[zMD].decodeStatus.sourceSelect),
3295                                           GATEMP_INDEX_DEC);
3296             if (temp2Var8 != tempVar8)
3297             {
3298                 return 1;
3299             }
3300         }
3301     }
3303     return 0;
3304 } //PAF_ASIT_decodeFinalTest
3306 // -----------------------------------------------------------------------------
3307 // ASIT Decoding Function - Stream-Final Processing
3308 //
3309 //   Name:      PAF_ASIT_decodeComplete
3310 //   Purpose:   Decoding Function for terminating the decoding process.
3311 //   From:      AST Parameter Function -> decodeProcessing
3312 //   Uses:      See code.
3313 //   States:    x
3314 //   Return:    0.
3315 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
3316 //              * State information as per parent.
3317 //
3318 Int
3319 PAF_ASIT_decodeComplete(
3320     const PAF_ASIT_Params *pP, 
3321     const PAF_ASIT_Patchs *pQ, 
3322     PAF_ASIT_Config *pAsitCfg, 
3323     ALG_Handle decAlg[], 
3324     Int frame, 
3325     Int block
3328     PAF_AST_Config *pAstCfg;
3329     Int as;                     /* Audio Stream Number (1, 2, etc.) */
3330     Int z;                      /* decode/encode counter */
3331     Int argIdx;
3332     Int8 tempVar8;
3333     char decMsgBuf[ASP_MSG_BUF_LEN];
3334     
3335     pAstCfg = pAsitCfg->pAstCfg; // get pointer to AST common (shared) configuration
3336     as = pAstCfg->as;
3337     (void)as;  // clear compiler warning in case not used with tracing disabled
3339 #ifdef PAF_ASP_FINAL
3340     /* This material is currently not utilized */
3341 #endif /* PAF_ASP_FINAL */
3342     for (z=DECODE1; z < DECODEN; z++) 
3343     {
3344 #ifdef PAF_ASP_FINAL
3345         DEC_Handle dec = (DEC_Handle )decAlg[z];
3346 #endif /* PAF_ASP_FINAL */
3347         Int zI = pP->inputsFromDecodes[z];
3348         tempVar8 = sharedMemReadInt8(&(pAstCfg->xDec[z].decodeStatus.mode),
3349                                      GATEMP_INDEX_DEC);
3350         if (pAstCfg->xInp[zI].hRxSio && tempVar8)
3351         {
3352             TRACE_VERBOSE1("PAF_ASIT_decodeComplete: AS%d: finalizing decode", as+z);