Merge remote-tracking branch 'origin/dev_pasdk_govind_pasdk53IpDataDebug' into dev_pa...
[processor-sdk/performance-audio-sr.git] / pasdk / test_dsp / framework / audioStreamInpProc.c
2 /*
3 Copyright (c) 2016, 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 "audioStreamProc_common.h"
65 #include "audioStreamProc_master.h"
66 #include "audioStreamInpProc.h"
68 // FL: porting
69 #include "fwkSim.h"
70 //#include "fwkPort.h"
71 // FL: debug
72 #include "dbgCapAf.h"
74 #include "statusOp_common.h"
77 // -----------------------------------------------------------------------------
78 // Debugging Trace Control, local to this file.
79 // 
80 #include "logp.h"
82 #define TRACE_ARC(a)
84 // allows you to set a different trace module in pa.cfg
85 #define TR_MOD  trace
87 // Allow a developer to selectively enable tracing.
88 #define CURRENT_TRACE_MASK      0x21
90 #define TRACE_MASK_TERSE        0x01   // only flag errors and show init
91 #define TRACE_MASK_GENERAL      0x02   // half dozen lines per frame
92 #define TRACE_MASK_VERBOSE      0x04   // trace full operation
93 #define TRACE_MASK_DATA         0x08   // Show data
94 #define TRACE_MASK_TIME         0x10   // Timing related traces
95 #define TRACE_MASK_MSG          0x20   // Message related traces
97 #if !(CURRENT_TRACE_MASK & TRACE_MASK_TERSE)
98     #undef  TRACE_TERSE0
99     #undef  TRACE_TERSE1
100     #undef  TRACE_TERSE2
101     #undef  TRACE_TERSE3
102     #undef  TRACE_TERSE4
103     #define TRACE_TERSE0(a)
104     #define TRACE_TERSE1(a,b)
105     #define TRACE_TERSE2(a,b,c)
106     #define TRACE_TERSE3(a,b,c,d)
107     #define TRACE_TERSE4(a,b,c,d,e)
108 #endif
110 #if !(CURRENT_TRACE_MASK & TRACE_MASK_GENERAL)
111     #undef  TRACE_GEN0
112     #undef  TRACE_GEN1
113     #undef  TRACE_GEN2
114     #undef  TRACE_GEN3
115     #undef  TRACE_GEN4
116     #define TRACE_GEN0(a)
117     #define TRACE_GEN1(a,b)
118     #define TRACE_GEN2(a,b,c)
119     #define TRACE_GEN3(a,b,c,d)
120     #define TRACE_GEN4(a,b,c,d,e)
121 #endif
123 #if (CURRENT_TRACE_MASK & TRACE_MASK_VERBOSE)
124     // consolidate list of processing strings, indexed by PAF_SOURCE
125     static char *procName[] =
126     {
127         "", //PAF_SOURCE_UNKNOWN
128         "", //PAF_SOURCE_NONE
129         "AS%d: Pass processing ...",   //PAF_SOURCE_PASS
130         "AS%d: SNG processing ...",    //PAF_SOURCE_SNG
131         "AS%d: Auto processing ...",   //PAF_SOURCE_AUTO
132         "AS%d: Auto processing ...",   //PAF_SOURCE_BITSTREAM
133         "AS%d: DTS processing ...",    //PAF_SOURCE_DTSALL
134         "AS%d: PCM processing ...",    //PAF_SOURCE_PCMAUTO
135         "AS%d: PCM processing ...",    //PAF_SOURCE_PCM
136         "AS%d: PCN processing ...",    //PAF_SOURCE_PC8
137         "AS%d: AC3 processing ...",    //PAF_SOURCE_AC3
138         "AS%d: DTS processing ...",    //PAF_SOURCE_DTS
139         "AS%d: AAC processing ...",    //PAF_SOURCE_AAC
140         "AS%d: MPG processing ...",    //PAF_SOURCE_MPEG
141         "AS%d: DTS processing ...",    //PAF_SOURCE_DTS12
142         "AS%d: DTS processing ...",    //PAF_SOURCE_DTS13
143         "AS%d: DTS processing ...",    //PAF_SOURCE_DTS14
144         "AS%d: DTS processing ...",    //PAF_SOURCE_DTS16
145         "AS%d: WMP processing ...",    //PAF_SOURCE_WMA9PRO
146         "AS%d: MP3 processing ...",    //PAF_SOURCE_MP3
147         "AS%d: DSD processing ...",    //PAF_SOURCE_DSD1
148         "AS%d: DSD processing ...",    //PAF_SOURCE_DSD2
149         "AS%d: DSD processing ...",    //PAF_SOURCE_DSD3
150         "AS%d: DDP processing ...",    //PAF_SOURCE_DDP
151         "AS%d: DTSHD processing ...",  //PAF_SOURCE_DTSHD
152         "AS%d: THD processing ...",    //PAF_SOURCE_THD
153         "AS%d: DXP processing ...",    //PAF_SOURCE_DXP
154         "AS%d: WMA processing ...",    //PAF_SOURCE_WMA
155     };
157 #else
158     #undef  TRACE_VERBOSE0
159     #undef  TRACE_VERBOSE1
160     #undef  TRACE_VERBOSE2
161     #undef  TRACE_VERBOSE3
162     #undef  TRACE_VERBOSE4
163     #define TRACE_VERBOSE0(a)
164     #define TRACE_VERBOSE1(a,b)
165     #define TRACE_VERBOSE2(a,b,c)
166     #define TRACE_VERBOSE3(a,b,c,d)
167     #define TRACE_VERBOSE4(a,b,c,d,e)
168 #endif
170 #if (CURRENT_TRACE_MASK & TRACE_MASK_DATA)
171     #define TRACE_DATA(a) LOG_printf a
172 #else
173     #define TRACE_DATA(a)
174 #endif
176 #if (CURRENT_TRACE_MASK & TRACE_MASK_TIME)
177     #define TRACE_TIME(a) LOG_printf a
178     #define TIME_MOD  trace // this could be different
179     static Int dtime()
180     {
181          static Int old_time = 0;
182          Int time = TSK_time();
183          Int delta_time = time - old_time;
184          old_time = time;
185          return( delta_time);
186     }
188     static char *stateName[11] =
189     {
190          "INIT",
191          "INFO1",
192          "AGAIN",
193          "INFO2",
194          "CONT",
195          "TIME",
196          "DECODE",
197          "STREAM",
198          "ENCODE",
199          "FINAL",
200          "QUIT"
201     };
203 #else
204     #define TRACE_TIME(a)
205 #endif
207 #if !(CURRENT_TRACE_MASK & TRACE_MASK_MSG)
208     #undef  TRACE_MSG0
209     #undef  TRACE_MSG1
210     #undef  TRACE_MSG2
211     #undef  TRACE_MSG3
212     #undef  TRACE_MSG4
213     #define TRACE_MSG0(a)
214     #define TRACE_MSG1(a,b)
215     #define TRACE_MSG2(a,b,c)
216     #define TRACE_MSG3(a,b,c,d)
217     #define TRACE_MSG4(a,b,c,d,e)
218 #endif
219     
221 // .............................................................................
223 #include <pafsio.h>
224 #include "paferr.h"
226 #include <acp_mds.h>
228 #include <pcm.h>
230 #include <pce.h>
232 #include <doberr.h>
234 #include <diberr.h>
236 #include <stdasp.h>
238 #include "as0.h"
239 #include "asperr.h"
241 #include "audioStreamProc_params.h"
242 #include "audioStreamProc_patchs.h"
243 #include "audioStreamProc_config.h"
244 #include "audioStreamInpProc.h"
246 //
247 // Audio Stream Definitions
248 //
250 // minimum audio frame "length" in samples (must be multiple of PA_MODULO)
251 #define MINFRAMELENGTH 24
252 #define PA_MODULO       8   // also defined independently in ARC2 code, and may be hard coded other places.
255 //
256 // Decoder Definitions
257 //
258 //#define decLinkInit pQ->i_decLinkInit
260 //
261 // Audio Stream Processing Definitions
262 //
263 //#define aspLinkInit pQ->i_aspLinkInit
265 //
266 // Encoder Definitions
267 //
268 #define encLinkInit pQ->i_encLinkInit
270 //
271 // Input, Output Definitions
272 //
273 #define inpLinkInit pP->i_inpLinkInit
274 //#define outLinkInit pP->i_outLinkInit
276 /* ---------------------------------------------------------------- */
277 /*              Parameter macro definitions end here.               */
278 /* ---------------------------------------------------------------- */
280 //
281 // Standardized Definitions
282 //
284 //#define DEC_Handle PCM_Handle /* works for all: SNG, PCM, AC3, DTS, AAC */
285 //#define ENC_Handle PCE_Handle /* works for all: PCE */
287 #define __TASK_NAME__  "TaskAsip"
289 LINNO_DEFN(TaskAsip); /* Line number macros */
290 ERRNO_DEFN(TaskAsip); /* Error number macros */
292 // ASIT configuration
293 #pragma DATA_SECTION(gPAF_ASIT_config, ".globalSectionPafAsitConfig")
294 PAF_ASIT_Config gPAF_ASIT_config = {
295     NULL,               // acp
296     &gPAF_ASPM_config,  // pAspmCfg, shared ASIT/ASOT configuration
297     &gPAF_AST_config    // pAstCfg, shared ASIT/ASOT/ASDT configuration
298 };
300 // Global debug counters */
301 UInt32 gTaskAsipCnt             =0;
302 UInt32 gAsipInitCnt             =0;
303 UInt32 gAsipInfo1Cnt            =0;
304 UInt32 gAsipInfo2Cnt            =0;
305 UInt32 gAsipDecodeCnt           =0;
306 UInt32 gAsipDecodeErrCnt        =0;
307 UInt32 gAsipFinalCnt            =0;
308 UInt32 gAsipQuitCnt             =0;
309 UInt32 gIbReset_cnt             =0;
310 UInt32 gcapIb_cnt               =0;
311 UInt32 gAsipInfo2_PrimaryErrCnt =0;
312 UInt32 gAsipInfo2_ErrCnt        =0;
313 // debug
314 UInt32 gCbErrnoCnt              =0; // decoder circular buffer error count (write on ARM returned to DSP)
316 #include "dbgDib.h" // debug
318 extern struct {
319     Int size;
320     IALG_Status *pStatus[512];
321 } IACP_STD_BETA_TABLE;
323 // FL: debug
324 #include "evmc66x_pinmux.h"
325 #include "evmc66x_gpio_dbg.h"
327 /*
328  *  ======== taskAsipFxn ========
329  *  Audio Stream Input Processing task function
330  */
331 Void taskAsipFxn(
332 //    Int betaPrimeValue, // FL: revisit
333     const PAF_ASIT_Params *pP,
334     const PAF_ASIT_Patchs *pQ
337     PAF_ASIT_Config *pC;            /* Local configuration pointer */
338     PAF_AST_Config *pAstCfg;        /* Common (shared) configuration pointer */
339     Int as;                         /* Audio Stream Number (1, 2, etc.) */
340     Int z;                          /* input/encode/stream/decode/output counter */
341     Int i;                          /* phase */
342     Int errno;                      /* error number */
343     Int zMD, zMI, zMS, zX;
344     Int loopCount = 0;  // used to stop trace to see startup behavior.        
345     UInt32 curTime;
346     Int size;
347     // Messaging
348     ASP_Msg *pAspMsg;              
349     Int status;
350 #ifdef NON_CACHE_STATUS
351     Int8 tempVar8;
352 #endif
354     Log_info0("Enter taskAsipFxn()");
355     
356 #ifdef SIMULATE_SIO
357     /* Start simulation */
358     simStart();
359 #endif // SIMULATE_SIO
361     //
362     // Audio Framework Parameters & Patch (*pP, *pQ)
363     //
364     if (!pP) 
365     {
366         TRACE_TERSE0("TaskAsip: No Parameters defined. Exiting.");
367         LINNO_RPRT(TaskAsip, -1);
368         return;
369     }
371     if (!pQ)
372     {
373         TRACE_TERSE0("TaskAsip: No Patchs defined. Exiting.");
374         LINNO_RPRT(TaskAsip, -1);
375         return;
376     }    
377     
378     //
379     // Audio Framework Configuration (*pC):
380     //
381     pC = &gPAF_ASIT_config;
382     pAstCfg = pC->pAstCfg;
384     /* Set Audio Stream Number (1, 2, etc.) */
385     as = gBetaPrimeValue + 1;
386     pAstCfg->as = as;    
387     TRACE_TERSE1("TaskAsip: Started with AS%d.", as);
389     //
390     // Initialize message log trace and line number reporting
391     //
392     for (z=STREAM1; z < STREAMN; z++)
393     {
394         TRACE_TERSE1("TaskAsip: AS%d: initiated", as+z);
395     }
396     LINNO_RPRT(TaskAsip, -1);
397     
398     //
399     // Determine decoder and stream indices associated with the master input
400     //
401     zMI = pP->zone.master;
402     pAstCfg->masterDec = zMI;
403     pAstCfg->masterStr = zMI;
404     for (zX = DECODE1; zX < DECODEN; zX++)
405     {
406         if (pP->inputsFromDecodes[zX] == zMI)
407         {
408             pAstCfg->masterDec = zX;
409             pAstCfg->masterStr = pP->streamsFromDecodes[zX];
410             break;
411         }
412     }
413     zMD = pAstCfg->masterDec;
414     zMS = pAstCfg->masterStr;
416     // Initialize as per parametrized phases:
417     //
418     //   In standard form these are:
419     //      - Malloc: Memory Allocation
420     //      - Config: Configuration Initialization
421     //      - AcpAlg: ACP Algorithm Initialization and Local Attachment
422     //      - Common: Common Memory Initialization
423     //      - AlgKey: Dec/Enc chain to Array Initialization
424     //      - Device: I/O Device Initialization
425     //      - DecOpCircBuf: Decoder Output Circular Buffer
426     //      - Unused: (available)
427     //
428     LINNO_RPRT(TaskAsip, -2);
429     for (i=0; i < lengthof(pP->fxns->initPhase); i++)
430     {
431         Int linno;
432         if (pP->fxns->initPhase[i])
433         {
434             if (linno = pP->fxns->initPhase[i](pP, pQ, pC)) 
435             {
436                 LINNO_RPRT(TaskAsip, linno);
437                 return;
438             }
439         }
440         else 
441         {
442             TRACE_TERSE1("TaskAsip: AS%d: initialization phase - null", as+zMS);
443         }
444         TRACE_TERSE2("TaskAsip: AS%d: initialization phase - %d completed", as+zMS, i);
445         LINNO_RPRT(TaskAsip, -i-3);
446     }
448     //
449     // End of Initialization -- display memory usage report.
450     //
451     if (pP->fxns->memStatusPrint)
452     {
453         pP->fxns->memStatusPrint(HEAP_INTERNAL, HEAP_INTERNAL1, HEAP_EXTERNAL, HEAP_INTERNAL1_SHM);
454     }
455     
456     // (***) FL: revisit
457     // write back AST shared configuration
458     Cache_wb(pAstCfg, sizeof(PAF_AST_Config), Cache_Type_ALLD, 0);
459     // FL: no need to share this pointer, can be local
460     //Cache_wb(&pC, sizeof(PAF_AST_Config *), Cache_Type_ALLD, 0);
461     Cache_wait();
463     // (***) FL: revisit
464     // write back Dec configuration
465     Cache_wb(&pAstCfg->xDec[0], DECODEN*sizeof(PAF_AST_Decode), Cache_Type_ALLD, 0);
466     Cache_wait();
468     // (***) FL: revisit
469     // write back entire beta table
470     Cache_wb((Ptr)(&IACP_STD_BETA_TABLE.pStatus[0]), 512*sizeof(IALG_Status *), Cache_Type_ALLD, 0);
471     Cache_wait();
472     
473     // FL: send start initialization message to slave
474     pAspMsg = (ASP_Msg *)MessageQ_alloc(hAspMsgMaster->heapId, hAspMsgMaster->msgSize); /* allocate message */
475     MessageQ_setReplyQueue(hAspMsgMaster->masterQue, (MessageQ_Msg)pAspMsg);            /* set the return address in the message header */
476     pAspMsg->cmd = ASP_SLAVE_START;                                                     /* fill in message payload */
477     pAspMsg->procId = hAspMsgMaster->masterProcId;
478     pAspMsg->messageId = hAspMsgMaster->messageId & ~(1<<31);
479     pAspMsg->expectResp = TRUE;
480     TRACE_MSG3("Tx ASP message: procId=%d, cmd=%d, messageId=0x%04x", pAspMsg->procId, pAspMsg->cmd, pAspMsg->messageId);
481     status = MessageQ_put(hAspMsgMaster->slaveQue, (MessageQ_Msg)pAspMsg);              /* send message */
482     if (status != MessageQ_S_SUCCESS)
483     {
484         SW_BREAKPOINT;
485     }
486     // wait for initialization complete message from slave
487     do {
488         //status = MessageQ_get(hAspMsgMaster->masterQue, (MessageQ_Msg *)&pAspMsg, MessageQ_FOREVER);
489         status = MessageQ_get(hAspMsgMaster->masterQue, (MessageQ_Msg *)&pAspMsg, 0); // FL: no other thread is allowed to run until Slave finished startup
490     } while ((status != MessageQ_S_SUCCESS) || (pAspMsg->cmd != ASP_MASTER_START_DONE));
491     if ((pAspMsg->procId != hAspMsgMaster->slaveProcId) ||
492         (pAspMsg->cmd != ASP_MASTER_START_DONE) || 
493         (pAspMsg->messageId != (hAspMsgMaster->messageId | ((UInt32)1<<31))))
494     {
495         TRACE_TERSE3("ERROR: Rx ASP message: procId=%d, cmd=%d, messageId=0x%04x", pAspMsg->procId, pAspMsg->cmd, pAspMsg->messageId);
496         SW_BREAKPOINT;
497     }
498     hAspMsgMaster->messageId = (hAspMsgMaster->messageId + 1) & ~(1<<31);
499     TRACE_MSG3("Rx ASP message: procId=%d, cmd=%d, messageId=0x%04x", pAspMsg->procId, pAspMsg->cmd, pAspMsg->messageId);
500     status = MessageQ_free((MessageQ_Msg)pAspMsg); /* free the message */
501     if (status != MessageQ_S_SUCCESS)
502     {
503         SW_BREAKPOINT;
504     }
506     // (***) FL: revisit
507     // invalidate Status structure addresses for Beta Units initialized on Slave
508     Cache_inv((Ptr)(&IACP_STD_BETA_TABLE.pStatus[STD_BETA_DECODE]), sizeof(IALG_Status *), Cache_Type_ALLD, 0);
509     Cache_inv((Ptr)(&IACP_STD_BETA_TABLE.pStatus[STD_BETA_PCM]), sizeof(IALG_Status *), Cache_Type_ALLD, 0);
510     Cache_inv((Ptr)(&IACP_STD_BETA_TABLE.pStatus[STD_BETA_PCM2]), sizeof(IALG_Status *), Cache_Type_ALLD, 0);
511     Cache_inv((Ptr)(&IACP_STD_BETA_TABLE.pStatus[STD_BETA_DDP]), sizeof(IALG_Status *), Cache_Type_ALLD, 0);
512     Cache_inv((Ptr)(&IACP_STD_BETA_TABLE.pStatus[STD_BETA_DDP2]), sizeof(IALG_Status *), Cache_Type_ALLD, 0);
513     Cache_inv((Ptr)(&IACP_STD_BETA_TABLE.pStatus[STD_BETA_THD]), sizeof(IALG_Status *), Cache_Type_ALLD, 0);
514     Cache_inv((Ptr)(&IACP_STD_BETA_TABLE.pStatus[STD_BETA_THD2]), sizeof(IALG_Status *), Cache_Type_ALLD, 0);
515     Cache_wait();
516     if (!IACP_STD_BETA_TABLE.pStatus[STD_BETA_DECODE]) Log_info0("ERROR: beta unit for Dec==NULL");
517     if (!IACP_STD_BETA_TABLE.pStatus[STD_BETA_PCM]) Log_info0("ERROR: beta unit for Dec==NULL");
518     if (!IACP_STD_BETA_TABLE.pStatus[STD_BETA_PCM2]) Log_info0("ERROR: beta unit for Dec==NULL");
519     if (!IACP_STD_BETA_TABLE.pStatus[STD_BETA_DDP]) Log_info0("ERROR: beta unit for Dec==NULL");
520     if (!IACP_STD_BETA_TABLE.pStatus[STD_BETA_DDP2]) Log_info0("ERROR: beta unit for Dec==NULL");
521     if (!IACP_STD_BETA_TABLE.pStatus[STD_BETA_THD]) Log_info0("ERROR: beta unit for Dec==NULL");
522     if (!IACP_STD_BETA_TABLE.pStatus[STD_BETA_THD2]) Log_info0("ERROR: beta unit for Dec==NULL");
523     
524     // (***) FL: revisit
525     // invalidate Status structures for Beta Units initialized on Slave
526     Cache_inv((Ptr)(IACP_STD_BETA_TABLE.pStatus[STD_BETA_DECODE]), sizeof(Int), Cache_Type_ALLD, 0);
527     size = IACP_STD_BETA_TABLE.pStatus[STD_BETA_DECODE]->size;
528     Cache_inv((Ptr)(IACP_STD_BETA_TABLE.pStatus[STD_BETA_DECODE]), size, Cache_Type_ALLD, 0);
529     Cache_inv((Ptr)(IACP_STD_BETA_TABLE.pStatus[STD_BETA_PCM]), sizeof(Int), Cache_Type_ALLD, 0);
530     size = IACP_STD_BETA_TABLE.pStatus[STD_BETA_PCM]->size;
531     Cache_inv((Ptr)(IACP_STD_BETA_TABLE.pStatus[STD_BETA_PCM]), size, Cache_Type_ALLD, 0);
532     Cache_inv((Ptr)(IACP_STD_BETA_TABLE.pStatus[STD_BETA_PCM2]), sizeof(Int), Cache_Type_ALLD, 0);
533     size = IACP_STD_BETA_TABLE.pStatus[STD_BETA_PCM2]->size;
534     Cache_inv((Ptr)(IACP_STD_BETA_TABLE.pStatus[STD_BETA_PCM2]), size, Cache_Type_ALLD, 0);
535     Cache_inv((Ptr)(IACP_STD_BETA_TABLE.pStatus[STD_BETA_DDP]), sizeof(Int), Cache_Type_ALLD, 0);
536     size = IACP_STD_BETA_TABLE.pStatus[STD_BETA_DDP]->size;
537     Cache_inv((Ptr)(IACP_STD_BETA_TABLE.pStatus[STD_BETA_DDP]), size, Cache_Type_ALLD, 0);
538     Cache_inv((Ptr)(IACP_STD_BETA_TABLE.pStatus[STD_BETA_DDP2]), sizeof(Int), Cache_Type_ALLD, 0);
539     size = IACP_STD_BETA_TABLE.pStatus[STD_BETA_DDP2]->size;
540     Cache_inv((Ptr)(IACP_STD_BETA_TABLE.pStatus[STD_BETA_DDP2]), size, Cache_Type_ALLD, 0);
541     Cache_inv((Ptr)(IACP_STD_BETA_TABLE.pStatus[STD_BETA_THD]), sizeof(Int), Cache_Type_ALLD, 0);
542     size = IACP_STD_BETA_TABLE.pStatus[STD_BETA_THD]->size;
543     Cache_inv((Ptr)(IACP_STD_BETA_TABLE.pStatus[STD_BETA_THD]), size, Cache_Type_ALLD, 0);
544     Cache_inv((Ptr)(IACP_STD_BETA_TABLE.pStatus[STD_BETA_THD2]), sizeof(Int), Cache_Type_ALLD, 0);
545     size = IACP_STD_BETA_TABLE.pStatus[STD_BETA_THD2]->size;
546     Cache_inv((Ptr)(IACP_STD_BETA_TABLE.pStatus[STD_BETA_THD2]), size, Cache_Type_ALLD, 0);
547     Cache_wait();
548     
549 #ifdef NON_CACHE_STATUS
550     // Get the shared status structure GateMP handles. Initialized at slave.
551     if (statusOp_Init(GATEMP_INDEX_DEC) == STATUSOP_INIT_FAIL)
552     {
553         Log_info1("TaskAfp: Gate Index %d:Open status GateMP Fail.", GATEMP_INDEX_DEC);
554     }
555     if (statusOp_Init(GATEMP_INDEX_DDP) == STATUSOP_INIT_FAIL)
556     {
557         Log_info1("TaskAfp: Gate Index %d:Open status GateMP Fail.", GATEMP_INDEX_DDP);
558     }
559     if (statusOp_Init(GATEMP_INDEX_PCM) == STATUSOP_INIT_FAIL)
560     {
561         Log_info1("TaskAfp: Gate Index %d:Open status GateMP Fail.", GATEMP_INDEX_PCM);
562     }
563     if (statusOp_Init(GATEMP_INDEX_THD) == STATUSOP_INIT_FAIL)
564     {
565         Log_info1("TaskAfp: Gate Index %d:Open status GateMP Fail.", GATEMP_INDEX_THD);
566     }
567 #endif
569     // (***) FL: revisit
570     // invalidate Dec configuration
571     Cache_inv(&gPAF_AST_config.xDec[0], DECODEN*sizeof(PAF_AST_Decode), Cache_Type_ALLD, 0);
572     Cache_wait();
573     
574     //
575     // Main processing loop
576     //   
577     for (z=STREAM1; z < STREAMN; z++)
578     {
579         TRACE_VERBOSE1("TaskAsip: AS%d: running", as+z);
580     }
582     TRACE_TERSE0("TaskAsip: Entering Main Loop.");
583     
584     errno = 0;
585     for (;;)
586     {
587         Int sourceSelect;
588         XDAS_Int8 sourceProgram;
590         loopCount++;
592 #if 0   // enable and tune to see startup behavior.
593         // this is an alternative to fixed/circular setting in pa.cfg.
594         // If you are searching for a memory allocation failure, disable on first round.
595         // All allocation has already happened.
596         // This is the outer loop.  This loop count goes up when the stream resets.
597         // If the stream is running without problems, this does not increment.
598         // If the stream is repeatedly resetting, this loop count will go up rapidly.
599         if (loopCount > 10)  // see traces for a few of the passes through the main loop.
600         {
601              TRACE_TERSE1("TaskAsip: Trace stopped at loop %d.", loopCount);
602              LOG_disable(&TR_MOD);  // stop tracing
603         }
604 #endif
606         TRACE_GEN2("TaskAsip (begin Main loop %d) (errno 0x%x)", loopCount, errno);
607         TRACE_TIME((&TIME_MOD, "as1_f2... + %d = %d (begin Main loop)", dtime(), TSK_time()));
608         
609         // since not decoding indicate such
610         pP->fxns->sourceDecode(pP, pQ, pC, PAF_SOURCE_NONE);
612         // any error forces idling of input
613         if (errno) 
614         {
615             for (z=INPUT1; z < INPUTN; z++)
616             {
617                 if (pAstCfg->xInp[z].hRxSio)
618                 {
619                     SIO_idle(pAstCfg->xInp[z].hRxSio);
620                 }
621             }
622         
623             TRACE_TERSE1("TaskAsip: Trace stopped at loop %d.", loopCount);
624             ERRNO_RPRT(TaskAsip, errno);
625         }
626         
627         // Execute a TSK_sleep to ensure that any non-blocking code paths are broken
628         // up to allow lower priority tasks to run. This may seem odd to be at the top
629         // of the state machine but provides for a cleaner flow even though the very
630         // first time we enter we do a sleep which is non-intuitive.
631         TRACE_VERBOSE1("TaskAsip: AS%d: ... sleeping ...", as+zMS);
632         TRACE_TIME((&TIME_MOD, "as1-f2... + %d = %d (begin SLEEP)", dtime(), TSK_time()));
633         Task_sleep(1);
635         TRACE_GEN1("TaskAsip: AS%d: Input device selection ...", as+zMS);
636         if (errno = pP->fxns->selectDevices(pP, pQ, pC))
637         {
638             TRACE_TERSE2("TaskAsip: selectDevices returned errno = 0x%04x at line %d. AS%d", errno, as+zMS);
639             continue;
640         }
642         // if no master input selected then we don't know what may be at the input
643         // so set to unknown and skip any remaining processing
644         if (!pAstCfg->xInp[zMI].hRxSio)
645         {
646 #ifdef NON_CACHE_STATUS
647             tempVar8 = PAF_SOURCE_UNKNOWN;
648             statusOp_write(&(pAstCfg->xDec[zMD].decodeStatus.sourceProgram),
649                            &tempVar8,
650                            sizeof(tempVar8),
651                            GATEMP_INDEX_DEC);
652 #else
653             pAstCfg->xDec[zMD].decodeStatus.sourceProgram = PAF_SOURCE_UNKNOWN;
654 #endif
655             TRACE_VERBOSE1("TaskAsip: AS%d: No input selected...", as+zMS);
656             continue;
657         }
658         
659         // if here then we have a valid input so query its status
660         if (errno = pP->fxns->updateInputStatus(pAstCfg->xInp[zMI].hRxSio, &pAstCfg->xInp[zMI].inpBufStatus, &pAstCfg->xInp[zMI].inpBufConfig))
661         {
662             TRACE_VERBOSE1("TaskAsip: continue as updateInputStatus returns 0x%x", errno);
663             continue;
664         }
665         
666 #ifdef NON_CACHE_STATUS
667         statusOp_read(&tempVar8,
668                       &(pAstCfg->xDec[zMD].decodeStatus.mode),
669                       sizeof(tempVar8),
670                       GATEMP_INDEX_DEC);
671         // If master decoder is not enabled, or the input is unlocked, then do nothing
672         if (!tempVar8 || !pAstCfg->xInp[zMI].inpBufStatus.lock)
673         {
674             TRACE_VERBOSE0("TaskAsip: Not locked, continue");
675             continue;
676         }
677 #else
678         // If master decoder is not enabled, or the input is unlocked, then do nothing
679         if (!pAstCfg->xDec[zMD].decodeStatus.mode || !pAstCfg->xInp[zMI].inpBufStatus.lock)
680         {
681             TRACE_VERBOSE0("TaskAsip: Not locked, continue");
682             continue;
683         }
684 #endif
685         
686 #ifdef NON_CACHE_STATUS
687         statusOp_read(&tempVar8,
688                       &(pAstCfg->xDec[zMD].decodeStatus.sourceSelect),
689                       sizeof(tempVar8),
690                       GATEMP_INDEX_DEC);
691         // If no source selected then do nothing
692         if (tempVar8 == PAF_SOURCE_NONE)
693         {
694             tempVar8 = PAF_SOURCE_NONE;
695             statusOp_write(&(pAstCfg->xDec[zMD].decodeStatus.sourceProgram),
696                            &tempVar8,
697                            sizeof(tempVar8),
698                            GATEMP_INDEX_DEC);
699             TRACE_VERBOSE1("TaskAsip: AS%d: no source selected, continue", as+zMS);
700             continue;
701         }
702 #else
703         // If no source selected then do nothing
704         if (pAstCfg->xDec[zMD].decodeStatus.sourceSelect == PAF_SOURCE_NONE) 
705         {
706             pAstCfg->xDec[zMD].decodeStatus.sourceProgram = PAF_SOURCE_NONE;
707             TRACE_VERBOSE1("TaskAsip: AS%d: no source selected, continue", as+zMS);
708             continue;
709         }
710 #endif
712 #ifdef NON_CACHE_STATUS
713         statusOp_read(&tempVar8,
714                       &(pAstCfg->xDec[zMD].decodeStatus.sourceSelect),
715                       sizeof(tempVar8),
716                       GATEMP_INDEX_DEC);
717         // If we want pass processing then proceed directly
718         if (tempVar8 == PAF_SOURCE_PASS)
719         {
720             TRACE_VERBOSE1("TaskAsip: AS%d: Pass processing ...", as+zMS);
722             tempVar8 = PAF_SOURCE_PASS;
723             statusOp_write(&(pAstCfg->xDec[zMD].decodeStatus.sourceProgram),
724                            &tempVar8,
725                            sizeof(tempVar8),
726                            GATEMP_INDEX_DEC);
727 #else
728         // If we want pass processing then proceed directly
729         if (pAstCfg->xDec[zMD].decodeStatus.sourceSelect == PAF_SOURCE_PASS) 
730         {
731             TRACE_VERBOSE1("TaskAsip: AS%d: Pass processing ...", as+zMS);
732             pAstCfg->xDec[zMD].decodeStatus.sourceProgram = PAF_SOURCE_PASS;
733 #endif
734             pP->fxns->sourceDecode(pP, pQ, pC, PAF_SOURCE_PASS);
735             if (pP->fxns->passProcessing)
736             {
737                 errno = pP->fxns->passProcessing(pP, pQ, pC, NULL);                
738             }
739             else 
740             {
741                 TRACE_TERSE2("TaskAsip: AS%d: Pass Processing not supported, errno 0x%x", as+zMS, ASPERR_PASS);
742                 errno = ASPERR_PASS;
743             }
744             TRACE_VERBOSE0("TaskAsip: continue");
745             continue;
746         }
748 #ifdef NON_CACHE_STATUS
749         statusOp_read(&tempVar8,
750                       &(pAstCfg->xDec[zMD].decodeStatus.sourceSelect),
751                       sizeof(tempVar8),
752                       GATEMP_INDEX_DEC);
753         // .....................................................................
754         // At this point we have an enabled input and want to decode something.
755         // If no decoder selected then do nothing. Need to reset the sourceProgram, since
756         // when no decoder is selected there are no calls to IB
757         //if (errno = pP->fxns->autoProcessing(pP, pQ, pC, pC->xDec[zMD].decodeStatus.sourceSelect, pC->xDec[zMD].decAlg[PAF_SOURCE_PCM]))
758         if (errno = pP->fxns->autoProcessing(pP, pQ, pC, tempVar8, NULL)) // (***) FL: re-visit this, hard-coded to use PCM framelength inside function
759         {
760             TRACE_VERBOSE1("TaskAsip: autoProcessing returns 0x%x, continue", errno);
761             continue;
762         }
763 #else
764         // .....................................................................
765         // At this point we have an enabled input and want to decode something.
766         // If no decoder selected then do nothing. Need to reset the sourceProgram, since
767         // when no decoder is selected there are no calls to IB
768         //if (errno = pP->fxns->autoProcessing(pP, pQ, pC, pC->xDec[zMD].decodeStatus.sourceSelect, pC->xDec[zMD].decAlg[PAF_SOURCE_PCM]))
769         if (errno = pP->fxns->autoProcessing(pP, pQ, pC, pAstCfg->xDec[zMD].decodeStatus.sourceSelect, NULL)) // (***) FL: re-visit this, hard-coded to use PCM framelength inside function
770         {
771             TRACE_VERBOSE1("TaskAsip: autoProcessing returns 0x%x, continue", errno);
772             continue;
773         }
774 #endif
775         
776         // query for input type
777         if (errno = SIO_ctrl(pAstCfg->xInp[zMI].hRxSio, PAF_SIO_CONTROL_GET_SOURCEPROGRAM, (Arg )&sourceProgram))
778         {
779             TRACE_TERSE2("TaskAsip: SIO_ctrl returns 0x%x, then 0x%x, continue", errno, ASPERR_AUTO_PROGRAM);
780             errno = ASPERR_AUTO_PROGRAM;
781             continue;
782         }
783 #ifdef NON_CACHE_STATUS
784         statusOp_write(&(pAstCfg->xDec[zMD].decodeStatus.sourceProgram),
785                       &(sourceProgram),
786                       sizeof(sourceProgram),
787                       GATEMP_INDEX_DEC);
788 #else
789         pAstCfg->xDec[zMD].decodeStatus.sourceProgram = sourceProgram;
790 #endif
792         // if input is unclassifiable then do nothing
793         if (sourceProgram == PAF_SOURCE_UNKNOWN)
794         {
795             TRACE_VERBOSE0("TaskAsip: Source program unknown. continue");
796             continue;
797         }
799         // now that we have some input classification, and possibly an outstanding
800         // input frame, we determine whether or not to call decodeProcessing and with
801         // what decAlg.
802         sourceSelect = PAF_SOURCE_NONE;
803 #ifdef NON_CACHE_STATUS
804         statusOp_read(&tempVar8,
805                       &(pAstCfg->xDec[zMD].decodeStatus.sourceSelect),
806                       sizeof(tempVar8),
807                       GATEMP_INDEX_DEC);
808         switch (tempVar8)
809         {
810 #else
811         switch (pAstCfg->xDec[zMD].decodeStatus.sourceSelect) 
812         {
813 #endif
814             // If autodetecting, decoding everything, and input is something
815             // (i.e. bitstream or PCM) then decode.
816             case PAF_SOURCE_AUTO:
817                 if (sourceProgram >= PAF_SOURCE_PCM)
818                 {
819                     sourceSelect = sourceProgram;                    
820                 }
821                 break;
823             // If autodetecting, decoding only PCM, and input is PCM then decode.
824             case PAF_SOURCE_PCMAUTO:
825                 if (sourceProgram == PAF_SOURCE_PCM)
826                 {
827                     sourceSelect = sourceProgram;                    
828                 }
829                 break;
831             // If autodetecting, decoding only bitstreams, and input is a bitstream then decode.
832             case PAF_SOURCE_BITSTREAM:
833                 if (sourceProgram >= PAF_SOURCE_AC3)
834                 {
835                     sourceSelect = sourceProgram;                    
836                 }
837                 break;
839             // If autodetecting, decoding only DTS, and input is DTS then decode.
840             case PAF_SOURCE_DTSALL:
841                 switch (sourceProgram) 
842                 {
843                     case PAF_SOURCE_DTS11:
844                     case PAF_SOURCE_DTS12:
845                     case PAF_SOURCE_DTS13:
846                     case PAF_SOURCE_DTS14:
847                     case PAF_SOURCE_DTS16:
848                     case PAF_SOURCE_DTSHD:
849                         sourceSelect = sourceProgram;
850                         break;
851                 }
852                 break;
854             // All others, e.g., force modes, fall through to here.
855             // If user made specific selection then program must match select.
856             // (NB: this compare relies on ordering of PAF_SOURCE)
857             default:
858 #ifdef NON_CACHE_STATUS
859                 sourceSelect = 0; // due to size difference
860                 statusOp_read(&sourceSelect,
861                               &(pAstCfg->xDec[zMD].decodeStatus.sourceSelect),
862                               sizeof(Int8),
863                               GATEMP_INDEX_DEC);
864 #else
865                 sourceSelect = pAstCfg->xDec[zMD].decodeStatus.sourceSelect;
866 #endif
867                 if ((sourceSelect >= PAF_SOURCE_PCM) && (sourceSelect <= PAF_SOURCE_N))
868                 {
869                     if (sourceProgram != sourceSelect)
870                     {
871                         sourceSelect = PAF_SOURCE_NONE;                        
872                     }
873                 }
874                 break;
875         }
877         // if we didn't find any matches then skip
878         if (sourceSelect == PAF_SOURCE_NONE)
879         {
880             TRACE_VERBOSE0("TaskAsip: no matching source type, continue");
881             continue;
882         }
884         // FL: debug, reset IB capture buffer
885         capIbReset();
886         gIbReset_cnt++;
887         Log_info0("capIbReset()");
889         // FL: send source select message to slave
890         pAspMsg = (ASP_Msg *)MessageQ_alloc(hAspMsgMaster->heapId, hAspMsgMaster->msgSize); /* allocate message */
891         MessageQ_setReplyQueue(hAspMsgMaster->masterQue, (MessageQ_Msg)pAspMsg);            /* set the return address in the message header */
892         pAspMsg->cmd = ASP_SLAVE_DEC_SOURCE_SELECT;                                         /* fill in message payload */
893         pAspMsg->procId = hAspMsgMaster->masterProcId;
894         pAspMsg->messageId = hAspMsgMaster->messageId & ~(1<<31);
895         pAspMsg->expectResp = TRUE;
896         *(Int32 *)&pAspMsg->buf[0] = sourceSelect;
897         TRACE_MSG3("Tx ASP message: procId=%d, cmd=%d, messageId=0x%04x", pAspMsg->procId, pAspMsg->cmd, pAspMsg->messageId);
898         TRACE_MSG1("sourceSelect=%d", pAspMsg->buf[0]);
899         status = MessageQ_put(hAspMsgMaster->slaveQue, (MessageQ_Msg)pAspMsg);              /* send message */
900         if (status != MessageQ_S_SUCCESS)
901         {
902             SW_BREAKPOINT;
903         }
904         // wait for source select complete message from slave
905         //do {
906         //    status = MessageQ_get(hAspMsgMaster->masterQue, (MessageQ_Msg *)&pAspMsg, MessageQ_FOREVER);
907         //} while (status != MessageQ_S_SUCCESS);
908         status = MessageQ_get(hAspMsgMaster->masterQue, (MessageQ_Msg *)&pAspMsg, MessageQ_FOREVER);
909         if (status != MessageQ_S_SUCCESS)
910         {
911             TRACE_TERSE0("MessageQ_get() failure.");
912             SW_BREAKPOINT; // temporary
913         }
914         if ((pAspMsg->procId != hAspMsgMaster->slaveProcId) ||
915             (pAspMsg->cmd != ASP_MASTER_DEC_SOURCE_SELECT_DONE) ||
916             (pAspMsg->messageId != (hAspMsgMaster->messageId | ((UInt32)1<<31))))
917         {
918             TRACE_TERSE3("ERROR: Rx ASP message: procId=%d, cmd=%d, messageId=0x%04x", pAspMsg->procId, pAspMsg->cmd, pAspMsg->messageId);
919             SW_BREAKPOINT;
920         }
921         hAspMsgMaster->messageId = (hAspMsgMaster->messageId + 1) & ~(1<<31);
922         TRACE_MSG3("Rx ASP message: procId=%d, cmd=%d, messageId=0x%04x", pAspMsg->procId, pAspMsg->cmd, pAspMsg->messageId);
923         status = MessageQ_free((MessageQ_Msg)pAspMsg); /* free the message */
924         if (status != MessageQ_S_SUCCESS)
925         {
926             SW_BREAKPOINT;
927         }
928         
929         // set to unknown so that we can ensure, for IOS purposes, that sourceDecode = NONE
930         // iff we are in this top level state machine and specifically not in decodeProcessing
931         pP->fxns->sourceDecode(pP, pQ, pC, PAF_SOURCE_UNKNOWN);
932         
933         TRACE_VERBOSE1(procName[sourceProgram], as+zMS);
935         TRACE_VERBOSE0("TaskAsip: calling decodeProcessing.");
936         errno = pP->fxns->decodeProcessing(pP, pQ, pC, sourceSelect);
937         if (errno) 
938         {
939             TRACE_TERSE1("TaskAsip: decodeProcessing returns 0x%x, continue", errno);
940         }
941         else
942         {
943             TRACE_VERBOSE0("TaskAsip: decodeProcessing complete with no error.");
944         }        
946         // FL: send dec exit message to slave
947         pAspMsg = (ASP_Msg *)MessageQ_alloc(hAspMsgMaster->heapId, hAspMsgMaster->msgSize); /* allocate message */
948         MessageQ_setReplyQueue(hAspMsgMaster->masterQue, (MessageQ_Msg)pAspMsg);            /* set the return address in the message header */
949         pAspMsg->cmd = ASP_SLAVE_DEC_EXIT;                                                  /* fill in message payload */
950         pAspMsg->procId = hAspMsgMaster->masterProcId;
951         pAspMsg->messageId = hAspMsgMaster->messageId & ~(1<<31);
952         pAspMsg->expectResp = TRUE;
953         TRACE_MSG2("Tx ASP message: procId=%d, cmd=%d.", pAspMsg->procId, pAspMsg->cmd);
954         status = MessageQ_put(hAspMsgMaster->slaveQue, (MessageQ_Msg)pAspMsg);              /* send message */
955         if (status != MessageQ_S_SUCCESS)
956         {
957             SW_BREAKPOINT;
958         }
959         // wait for dec exit complete message from slave
960         //do {
961         //    status = MessageQ_get(hAspMsgMaster->masterQue, (MessageQ_Msg *)&pAspMsg, MessageQ_FOREVER);
962         //} while ((status < 0) || (pAspMsg->cmd != ASP_MASTER_DEC_EXIT_DONE));
963         status = MessageQ_get(hAspMsgMaster->masterQue, (MessageQ_Msg *)&pAspMsg, MessageQ_FOREVER);
964         if (status != MessageQ_S_SUCCESS)
965         {
966             TRACE_TERSE0("MessageQ_get() failure.");
967             SW_BREAKPOINT; // temporary
968         }
969         if ((pAspMsg->procId != hAspMsgMaster->slaveProcId) || 
970             (pAspMsg->cmd != ASP_MASTER_DEC_EXIT_DONE) ||
971             (pAspMsg->messageId != (hAspMsgMaster->messageId | ((UInt32)1<<31))))
972         {
973             TRACE_TERSE3("ERROR: Rx ASP message: procId=%d, cmd=%d, messageId=0x%04x", pAspMsg->procId, pAspMsg->cmd, pAspMsg->messageId);
974             SW_BREAKPOINT;
975         }
976         hAspMsgMaster->messageId = (hAspMsgMaster->messageId + 1) & ~(1<<31);
977         TRACE_MSG3("Rx ASP message: procId=%d, cmd=%d, messageId=0x%04x", pAspMsg->procId, pAspMsg->cmd, pAspMsg->messageId);
978         // free the message
979         status = MessageQ_free((MessageQ_Msg)pAspMsg); /* free the message */
980         if (status != MessageQ_S_SUCCESS)
981         {
982             SW_BREAKPOINT;
983         }
984     } // End of main processing loop for (;;)
985     
986     Log_info0("Exit taskAsipFxn()");
989 // -----------------------------------------------------------------------------
990 // ASIT Initialization Function - Memory Allocation
991 //
992 //   Name:      PAF_ASIT_initPhaseMalloc
993 //   Purpose:   Audio Stream Input Task Function for initialization of data pointers
994 //              by allocation of memory.
995 //   From:      audioStream1Task or equivalent
996 //   Uses:      See code.
997 //   States:    x
998 //   Return:    0 on success.
999 //              Source code line number on MEM_calloc failure.
1000 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
1001 //              * State information as per parent.
1002 //              * Memory allocation errors.
1003 //
1004 Int
1005 PAF_ASIT_initPhaseMalloc(
1006     const PAF_ASIT_Params *pP, 
1007     const PAF_ASIT_Patchs *pQ, 
1008     PAF_ASIT_Config *pC
1011     PAF_AST_Config *pAstCfg;
1012     Int as;                    /* Audio Stream Number (1, 2, etc.) */
1013     Int zMS;
1014     Error_Block    eb;
1016     pAstCfg = pC->pAstCfg; // get pointer to common (shared) configuration
1017     as = pAstCfg->as;
1018     zMS = pAstCfg->masterStr;
1019     
1020     TRACE_TERSE1("PAF_ASIT_initPhaseMalloc: AS%d: initialization phase - memory allocation", as+zMS);
1022     // Initialize error block
1023     Error_init(&eb); 
1025     /* Input memory */
1026     if (!(pAstCfg->xInp = Memory_calloc((IHeap_Handle)HEAP_INTERNAL1_SHM, 
1027         INPUTN * sizeof (*pAstCfg->xInp), 4, &eb)))
1028     {
1029         TRACE_TERSE1("PAF_ASIT_initPhaseMalloc: AS%d: Memory_calloc failed", as+zMS);
1030         SW_BREAKPOINT;
1031         return __LINE__;
1032     }
1033     TRACE_TERSE3("PAF_ASIT_initPhaseMalloc. (pC->xInp) %d bytes from space %d at 0x%x.",
1034         INPUTN * sizeof (*pAstCfg->xInp),
1035         HEAP_ID_INTERNAL1_SHM, (IArg)pAstCfg->xInp);
1037 #ifdef NON_CACHE_STATUS
1038     /* Decode memory */
1039     if (!(pAstCfg->xDec = Memory_calloc((IHeap_Handle)HEAP_EXTERNAL_NONCACHED_SHM,
1040         DECODEN * sizeof (*pAstCfg->xDec), 4, &eb)))
1041     {
1042         TRACE_TERSE1("PAF_ASIT_initPhaseMalloc: AS%d: Memory_calloc failed", as+zMS);
1043         SW_BREAKPOINT;
1044         return __LINE__;
1045     }
1046 #else
1047     /* Decode memory */
1048     if (!(pAstCfg->xDec = Memory_calloc((IHeap_Handle)HEAP_INTERNAL1_SHM, 
1049         DECODEN * sizeof (*pAstCfg->xDec), 4, &eb)))
1050     {
1051         TRACE_TERSE1("PAF_ASIT_initPhaseMalloc: AS%d: Memory_calloc failed", as+zMS);
1052         SW_BREAKPOINT;
1053         return __LINE__;
1054     }
1055 #endif
1056     TRACE_TERSE3("PAF_ASIT_initPhaseMalloc. (pC->xDec) %d bytes from space %d at 0x%x.",
1057         DECODEN * sizeof (*pAstCfg->xDec),
1058         HEAP_ID_INTERNAL1_SHM, (IArg)pAstCfg->xDec);
1059                 
1060     TRACE_TERSE1("PAF_ASIT_initPhaseMalloc: AS%d: initialization phase - memory allocation complete.", as+zMS);
1061     return 0;
1062 } //PAF_ASIT_initPhaseMalloc
1064 // -----------------------------------------------------------------------------
1065 // ASIT Initialization Function - Memory Initialization from Configuration
1066 //
1067 //   Name:      PAF_ASIT_initPhaseConfig
1068 //   Purpose:   Audio Stream Task Function for initialization of data values
1069 //              from parameters.
1070 //   From:      audioStream1Task or equivalent
1071 //   Uses:      See code.
1072 //   States:    x
1073 //   Return:    0 on success.
1074 //              Other as per initFrame0 and initFrame1.
1075 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
1076 //              * State information as per parent.
1077 //
1078 Int
1079 PAF_ASIT_initPhaseConfig(
1080     const PAF_ASIT_Params *pP, 
1081     const PAF_ASIT_Patchs *pQ, 
1082     PAF_ASIT_Config *pC
1085     PAF_AST_Config *pAstCfg;
1086     Int as;                    /* Audio Stream Number (1, 2, etc.) */
1087     Int z;                     /* input/encode/stream/decode/output counter */
1088     Int zMS;
1090     pAstCfg = pC->pAstCfg; // get pointer to common (shared) configuration
1091     as = pAstCfg->as;
1092     zMS = pAstCfg->masterStr;
1093     
1094     TRACE_TERSE1("PAF_ASIT_initPhaseConfig: AS%d: initialization phase - configuration", as+zMS);
1096     //
1097     // Unspecified elements have been initialized to zero during alloc
1098     //
1099     
1100     for (z=INPUT1; z < INPUTN; z++) 
1101     {
1102         pAstCfg->xInp[z].inpBufStatus = *pP->pInpBufStatus;
1103         pAstCfg->xInp[z].inpBufConfig.pBufStatus = &pAstCfg->xInp[z].inpBufStatus;
1104     }
1106     for (z=DECODE1; z < DECODEN; z++) 
1107     {
1108         Int zI = pP->inputsFromDecodes[z];
1109         pAstCfg->xDec[z].decodeControl.size = sizeof(pAstCfg->xDec[z].decodeControl);
1110         pAstCfg->xDec[z].decodeControl.pInpBufConfig = (const PAF_InpBufConfig *)&pAstCfg->xInp[zI].inpBufConfig;
1111         //pC->xDec[z].decodeStatus = *pP->z_pDecodeStatus[z]; // FL: slave
1112     }
1114     TRACE_TERSE1("PAF_ASIT_initPhaseConfig: AS%d: initialization phase - configuration complete.", as+zMS);
1115     return 0;
1116 } //PAF_ASIT_initPhaseConfig
1118 // -----------------------------------------------------------------------------
1119 // ASIT Initialization Function - ACP Algorithm Instantiation
1120 //
1121 //   Name:      PAF_ASIT_initPhaseAcpAlg
1122 //   Purpose:   Audio Stream Input Task Function for initialization of ACP by
1123 //              instantiation of the algorithm.
1124 //   From:      audioStream1Task or equivalent
1125 //   Uses:      See code.
1126 //   States:    x
1127 //   Return:    0 on success.
1128 //              Source code line number on ACP Algorithm creation failure.
1129 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
1130 //              * State information as per parent.
1131 //              * Memory allocation errors.
1132 //
1133 Int
1134 PAF_ASIT_initPhaseAcpAlg(
1135     const PAF_ASIT_Params *pP, 
1136     const PAF_ASIT_Patchs *pQ, 
1137     PAF_ASIT_Config *pC
1140     PAF_AST_Config *pAstCfg;
1141     Int as;                 /* Audio Stream Number (1, 2, etc.) */
1142     Int z;                  /* input/encode/stream/decode/output counter */
1143     Int betaPrimeOffset;
1144     ACP_Handle acp;
1145     Int zMS;
1146     Int zS, zX;
1148     pAstCfg = pC->pAstCfg; // get pointer to common (shared) configuration
1149     as = pAstCfg->as;
1150     zMS = pAstCfg->masterStr;
1151     
1152     TRACE_TERSE1("PAF_ASIT_initPhaseAcpAlg: AS%d: initialization phase - ACP Algorithm", as+zMS);
1154     ACP_MDS_init();
1156     if (!(acp = (ACP_Handle)ACP_MDS_create(NULL))) 
1157     {
1158         TRACE_TERSE1("PAF_ASIT_initPhaseAcpAlg: AS%d: ACP algorithm instance creation failed", as+zMS);
1159         return __LINE__;
1160     }
1161     pC->acp = acp;
1163     ((ALG_Handle)acp)->fxns->algControl((ALG_Handle) acp,
1164         ACP_GETBETAPRIMEOFFSET, (IALG_Status *)&betaPrimeOffset);
1166     for (z=INPUT1; z < INPUTN; z++) 
1167     {
1168         zS = z;
1169         for (zX = DECODE1; zX < DECODEN; zX++) 
1170         {
1171             if (pP->inputsFromDecodes[zX] == z) 
1172             {
1173                 zS = pP->streamsFromDecodes[zX];
1174                 break;
1175             }
1176         }
1177         acp->fxns->attach(acp, ACP_SERIES_STD,
1178             STD_BETA_IB + betaPrimeOffset * (as-1+zS),
1179             (IALG_Status *)&pAstCfg->xInp[z].inpBufStatus);
1180         /* Ignore errors, not reported. */
1181     }
1183     TRACE_TERSE1("PAF_ASIT_initPhaseAcpAlg: AS%d: initialization phase - ACP Algorithm complete.", as+zMS);
1185     return 0;
1186 } //PAF_ASIT_initPhaseAcpAlg
1188 // -----------------------------------------------------------------------------
1189 // ASIT Initialization Function - Common Memory
1190 //
1191 //   Name:      PAF_ASIT_initPhaseCommon
1192 //   Purpose:   Audio Stream Input Task Function for allocation of common memory.
1193 //   From:      audioStream1Task or equivalent
1194 //   Uses:      See code.
1195 //   States:    x
1196 //   Return:    0 on success.
1197 //              Source code line number on PAF_ALG_alloc failure.
1198 //              Source code line number on PAF_ALG_mallocMemory failure.
1199 //              Source code line number on Decode Chain initialization failure.
1200 //              Source code line number on ASP Chain initialization failure.
1201 //              Source code line number on Encode Chain initialization failure.
1202 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
1203 //              * State information as per parent.
1204 //              * Memory allocation errors.
1205 //
1206 Int
1207 PAF_ASIT_initPhaseCommon(
1208     const PAF_ASIT_Params *pP, 
1209     const PAF_ASIT_Patchs *pQ, 
1210     PAF_ASIT_Config *pC
1213     PAF_AST_Config *pAstCfg;
1214     Int as;                     /* Audio Stream Number (1, 2, etc.) */
1215     Int z;                      /* stream counter */
1216     ACP_Handle acp;
1217     PAF_IALG_Config pafAlgConfig;
1218     IALG_MemRec common[3][PAF_IALG_COMMON_MEMN+1];
1219    
1220     acp = pC->acp;
1221     pAstCfg = pC->pAstCfg; // get pointer to common (shared) configuration
1222     as = pAstCfg->as;
1223     
1224     TRACE_TERSE0("PAF_ASIT_initPhaseCommon: initialization phase - Common Memory");
1226     //
1227     // Determine memory needs and instantiate algorithms across audio streams
1228     //
1229     TRACE_TERSE0("PAF_ASIT_initPhaseCommon: calling PAF_ALG_setup.");
1230     PAF_ALG_setup(&pafAlgConfig, 
1231         HEAP_ID_INTERNAL,               HEAP_INTERNAL, 
1232         HEAP_ID_INTERNAL1,              HEAP_INTERNAL1, 
1233         HEAP_ID_EXTERNAL,               HEAP_EXTERNAL, 
1234         HEAP_ID_INTERNAL1_SHM,          HEAP_INTERNAL1_SHM, 
1235         HEAP_ID_EXTERNAL_SHM,           HEAP_EXTERNAL_SHM, 
1236         HEAP_ID_EXTERNAL_NONCACHED_SHM, HEAP_EXTERNAL_NONCACHED_SHM,
1237         HEAP_CLEAR);
1239     if (pP->fxns->headerPrint)
1240     {
1241         pP->fxns->headerPrint();        
1242     }
1244     for (z = STREAM1; z < STREAMN; z++) 
1245     {
1246         TRACE_TERSE1("PAF_ASIT_initPhaseCommon: AS%d: initialization phase - Common Memory", as+z);
1248         //
1249         // Determine common memory for:
1250         //  (1) Logical Input drivers
1251         //
1252         // Decode Algorithms common memory determined in ASP Slave.
1253         //
1254         PAF_ALG_init(common[z], lengthof(common[z]), COMMONSPACE);
1256         //
1257         // Determine common memory needs of Logical Input driver
1258         //
1260         // really need to loop over all inputs for this stream using the tables
1261         // inputsFromDecodes and streamsFromDecodes. But these don't exist for this
1262         // patch, and not needed for FS11, since there is only one input.
1263         if (INPUT1 <= z && z < INPUTN) 
1264         {
1265             TRACE_TERSE2("PAF_ASIT_initPhaseCommon: AS%d: alloc inpLinkInit common[%d]", as+z, z);
1266             if (PAF_ALG_ALLOC(inpLinkInit[z-INPUT1], common[z]))
1267             {
1268                 TRACE_TERSE1("PAF_ASIT_initPhaseCommon: AS%d: PAF_ALG_alloc failed", as+z);
1269                 TRACE_TERSE2("failed to alloc %d bytes from space %d", common[z]->size, (IArg)common[z]->space);
1270                 SW_BREAKPOINT;
1271                 return __LINE__;
1272             }
1273             TRACE_TERSE3("alloced %d bytes from space %d at 0x%x", common[z]->size, common[z]->space, (IArg)common[z]->base);
1274             if (pP->fxns->allocPrint)
1275             {
1276                 pP->fxns->allocPrint((const PAF_ALG_AllocInit *)(inpLinkInit[z-INPUT1]), sizeof (*(inpLinkInit[z-INPUT1])), &pafAlgConfig);
1277             }
1278         }
1279     }
1280     {
1281         // Changes made to share scratch between zones
1282         // Assume maximum 3 zones and scratch common memory is at offset 0;
1283         int max=0;
1284         for (z=STREAM1; z<STREAMN; z++)
1285         {
1286             if (max < common[z][0].size)
1287             {
1288                 max = common[z][0].size;
1289             }
1290         }
1291         common[STREAM1][0].size=max;
1292         for (z=STREAM1+1; z<STREAMN; z++)
1293         {
1294             common[z][0].size = 0;            
1295         }
1296     }
1297         
1298     //
1299     // Allocate common memory for:
1300     //  (1) Logical Input drivers
1301     //
1302     for (z = STREAM1; z < STREAMN; z++) 
1303     {
1304         TRACE_TERSE0("PAF_ASIT_initPhaseCommon: calling PAF_ALG_mallocMemory for common space.");
1305         if (PAF_ALG_mallocMemory(common[z], &pafAlgConfig)) 
1306         {
1307             TRACE_TERSE1("PAF_ASIT_initPhaseCommon: AS%d: PAF_ALG_mallocMemory failed", as+z);
1308             TRACE_TERSE3("AS%d: z: %d.  Size 0x%x", as+z, z, common[z][0].size);
1309             SW_BREAKPOINT;
1310             return __LINE__;
1311         }
1312         TRACE_TERSE3("alloced %d bytes from space %d at 0x%x", common[z]->size, common[z]->space, (IArg)common[z]->base);
1313         // share zone0 scratch with all zones 
1314         common[z][0].base = common[0][0].base;
1315         if (pP->fxns->commonPrint)
1316         {
1317             pP->fxns->commonPrint(common[z], &pafAlgConfig);
1318         }
1320         //
1321         // Allocate non-common memories for Logical IO drivers
1322         //    Since these structures are used at run-time we allocate from external memory
1323         if (INPUT1 <= z && z < INPUTN) 
1324         {
1325             PAF_ASP_Chain *chain;
1326             TRACE_TERSE2("PAF_ASIT_initPhaseCommon: AS%d: non-common input chain init for %d",
1327                            as+z, z);
1328             chain = PAF_ASP_chainInit(&pAstCfg->xInp[z].inpChainData, pP->pChainFxns,
1329                         HEAP_EXTERNAL, as+z, acp, &trace,
1330                         inpLinkInit[z-INPUT1], NULL, common[z], &pafAlgConfig);
1331             if (!chain) 
1332             {
1333                 TRACE_TERSE1("PAF_ASIT_initPhaseCommon: AS%d: Input chain initialization failed", as+z);
1334                 return __LINE__;
1335             }
1336         }
1337     }
1338     TRACE_TERSE1("PAF_ASIT_initPhaseCommon: AS%d: Returning complete.", as+z);
1340     return 0;
1341 } //PAF_ASIT_initPhaseCommon
1343 // (***) FL: candidate for removal
1344 // -----------------------------------------------------------------------------
1345 // ASIT Initialization Function - Algorithm Keys
1346 //
1347 //   Name:      PAF_ASIT_initPhaseAlgKey
1348 //   Purpose:   Audio Stream Input Task Function for initialization of data values
1349 //              from parameters for Algorithm Keys.
1350 //   From:      audioStream1Task or equivalent
1351 //   Uses:      See code.
1352 //   States:    x
1353 //   Return:    0.
1354 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
1355 //              * State information as per parent.
1356 //
1357 // .............................................................................
1358 Int
1359 PAF_ASIT_initPhaseAlgKey(
1360     const PAF_ASIT_Params *pP, 
1361     const PAF_ASIT_Patchs *pQ, 
1362     PAF_ASIT_Config *pC
1365     PAF_AST_Config *pAstCfg;
1366     Int as;                    /* Audio Stream Number (1, 2, etc.) */
1368     
1369     pAstCfg = pC->pAstCfg; // get pointer to common (shared) configuration
1370     as = pAstCfg->as;
1371     (void)as;  // clear compiler warning in case not used with tracing disabled
1373     TRACE_VERBOSE1("PAF_ASIT_initPhaseAlgKey: AS%d: initialization phase - Algorithm Keys", as);
1375 #if 0 // FL: slave    
1376     for (z=DECODE1; z < DECODEN; z++) 
1377     {
1378         for (s=0; s < pP->pDecAlgKey->length; s++) 
1379         {
1380             if ((pP->pDecAlgKey->code[s].full != 0) &&
1381                 (that = PAF_ASP_chainFind (&pC->xDec[z].decChainData, pP->pDecAlgKey->code[s]))) 
1382             {
1383                 pC->xDec[z].decAlg[s] = (ALG_Handle )that->alg;
1384                 /* Cast in interface, for now --Kurt */
1385             }
1386             else
1387             {
1388                 pC->xDec[z].decAlg[s] = NULL;
1389             }
1390         }
1391     }
1392 #endif
1394     return 0;
1395 } //PAF_ASIT_initPhaseAlgKey
1397 // -----------------------------------------------------------------------------
1398 // ASIT Initialization Function - I/O Devices
1399 //
1400 //   Name:      PAF_ASIT_initPhaseDevice
1401 //   Purpose:   Audio Stream Input Task Function for initialization of I/O Devices.
1402 //   From:      audioStream1Task or equivalent
1403 //   Uses:      See code.
1404 //   States:    x
1405 //   Return:    0 on success.
1406 //              Source code line number on device allocation failure.
1407 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
1408 //              * State information as per parent.
1409 //              * Memory allocation errors.
1410 //
1411 Int
1412 PAF_ASIT_initPhaseDevice(
1413     const PAF_ASIT_Params *pP, 
1414     const PAF_ASIT_Patchs *pQ, 
1415     PAF_ASIT_Config *pC
1418     PAF_AST_Config *pAstCfg;
1419     Int as;                             /* Audio Stream Number (1, 2, etc.) */
1420     Int z;                              /* input/output counter */
1421     PAF_SIO_IALG_Obj    *pObj;
1422     PAF_SIO_IALG_Config *pAlgConfig;
1423     PAF_IALG_Config pafAlgConfig;
1426     pAstCfg = pC->pAstCfg; // get pointer to common (shared) configuration
1427     as = pAstCfg->as;
1428     (void)as; // clear compiler warning in case not used with tracing disabled
1430     TRACE_TERSE1("PAF_ASIT_initPhaseDevice: AS%d: initialization phase - I/O Devices", as);
1432     if (pP->fxns->bufMemPrint)
1433     {
1434         PAF_ALG_setup (&pafAlgConfig, 
1435             HEAP_ID_INTERNAL,               HEAP_INTERNAL, 
1436             HEAP_ID_INTERNAL1,              HEAP_INTERNAL1,
1437             HEAP_ID_EXTERNAL,               HEAP_EXTERNAL,
1438             HEAP_ID_INTERNAL1_SHM,          HEAP_INTERNAL1_SHM,
1439             HEAP_ID_EXTERNAL_SHM,           HEAP_EXTERNAL_SHM,
1440             HEAP_ID_EXTERNAL_NONCACHED_SHM, HEAP_EXTERNAL_NONCACHED_SHM,
1441             HEAP_CLEAR);
1442         TRACE_TERSE2("PAF_ASIT_initPhaseDevice: AS%d: calling PAF_ALG_setup with clear at %d.", as, HEAP_CLEAR);
1443     }
1445     for (z=INPUT1; z < INPUTN; z++) 
1446     {
1447         PAF_InpBufConfig *pConfig = &pAstCfg->xInp[z].inpBufConfig;
1449         pObj = (PAF_SIO_IALG_Obj *)pAstCfg->xInp[z].inpChainData.head->alg;
1450         pAlgConfig = &pObj->config;
1452         pAstCfg->xInp[z].hRxSio = NULL;
1454         pConfig->base.pVoid       = pAlgConfig->pMemRec[0].base;
1455         pConfig->pntr.pVoid       = pAlgConfig->pMemRec[0].base;
1456         pConfig->head.pVoid       = pAlgConfig->pMemRec[0].base;
1457         pConfig->futureHead.pVoid = pAlgConfig->pMemRec[0].base;
1458         pConfig->allocation       = pAlgConfig->pMemRec[0].size;
1459         pConfig->sizeofElement    = 2;
1460         pConfig->precision        = 16;
1462         if (pP->fxns->bufMemPrint)
1463         {
1464             pP->fxns->bufMemPrint(z, pAlgConfig->pMemRec[0].size, PAF_ALG_memSpaceToHeapId(&pafAlgConfig,pAlgConfig->pMemRec[0].space), 0);
1465         }
1466     }
1468     TRACE_TERSE1("PAF_ASIT_initPhaseDevice: AS%d: initialization phase - I/O Devices complete.", as);
1470     return 0;
1471 } //PAF_ASIT_initPhaseDevice
1473 // -----------------------------------------------------------------------------
1474 // ASIT Initialization Function - Decoder Output Circular Buffer
1475 //
1476 //   Name:      PAF_ASIT_initPhaseDecOpCircBuf
1477 //   Purpose:   Audio Stream Input Task Function for initialization of Decoder Output Circular Buffer.
1478 //   From:      audioStream1Task or equivalent
1479 //   Uses:      See code.
1480 //   States:    x
1481 //   Return:    0 on success.
1482 //              Source code line number on device allocation failure.
1483 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
1484 //              * State information as per parent.
1485 //              * Memory allocation errors.
1486 //
1487 Int
1488 PAF_ASIT_initPhaseDecOpCircBuf(
1489     const PAF_ASIT_Params *pP, 
1490     const PAF_ASIT_Patchs *pQ, 
1491     PAF_ASIT_Config *pC
1494     PAF_AST_Config *pAstCfg;
1495     PAF_AST_DecOpCircBuf *pCb;          /* Decoder output circular buffer */
1496     Int as;                             /* Audio Stream Number (1, 2, etc.) */
1497     Int zMS;
1498     Int z;                              /* decode counter */
1499     Int errno;                          /* error number */
1500     Error_Block    eb;
1501     Int i;
1503     // FL: (***)revisit
1504     pAstCfg = pC->pAstCfg; // get pointer to common (shared) configuration
1505     as = pAstCfg->as;
1506     zMS = pAstCfg->masterStr;
1508     /* Decode output circular buffer memory */
1509     if (!(pAstCfg->xDecOpCb = Memory_calloc((IHeap_Handle)HEAP_INTERNAL1_SHM, 
1510         DECODEN * sizeof (*pAstCfg->xDecOpCb), 4, &eb)))
1511     {
1512         TRACE_TERSE1("PAF_ASIT_initPhaseDecOpCircBuf: AS%d: Memory_calloc failed", as+zMS);
1513         SW_BREAKPOINT;
1514         return __LINE__;
1515     }
1517     TRACE_TERSE3("PAF_ASIT_initPhaseDecOpCircBuf. (pC->xDecOpCb) %d bytes from space %d at 0x%x.",
1518         DECODEN * sizeof (*pAstCfg->xDecOpCb),
1519         HEAP_ID_INTERNAL1_SHM, (IArg)pAstCfg->xDecOpCb);
1520         
1521     for (z=DECODE1; z < DECODEN; z++)
1522     {
1523         pCb = &pAstCfg->xDecOpCb[z];
1524         
1525         // allocate audio frame circular buffer
1526         if (!(pCb->afCb = Memory_calloc((IHeap_Handle)HEAP_INTERNAL1_SHM, ASP_DECOP_CB_MAX_NUM_AF * sizeof(PAF_AudioFrame), 4, &eb)))
1527         {
1528             TRACE_TERSE1("PAF_ASIT_initPhaseDecOpCircBuf: AS%d: Memory_calloc failed", as+zMS);
1529             SW_BREAKPOINT;
1530         }
1531         // allocate audio frame PCM sample pointer array
1532         for (i = 0; i<ASP_DECOP_CB_MAX_NUM_AF; i++)
1533         {
1534             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)))
1535             {
1536                 TRACE_TERSE1("PAF_ASIT_initPhaseDecOpCircBuf: AS%d: Memory_calloc failed", as+zMS);
1537                 SW_BREAKPOINT;
1538             }
1539             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)))
1540             {
1541                 TRACE_TERSE1("PAF_ASIT_initPhaseDecOpCircBuf: AS%d: Memory_calloc failed", as+zMS);
1542                 SW_BREAKPOINT;
1543             }                
1544         }
1545         // allocate PCM sample buffer
1546         if (!(pCb->pcmBuf = Memory_calloc((IHeap_Handle)HEAP_EXTERNAL_SHM, ASP_DECOP_CB_PCM_BUF_SZ * sizeof(PAF_AudioData), 4, &eb)))
1547         {
1548             TRACE_TERSE1("PAF_ASIT_initPhaseDecOpCircBuf: AS%d: Memory_calloc failed", as+zMS);
1549             SW_BREAKPOINT;
1550         }
1551         pCb->pcmBufEnd = pCb->pcmBuf + ASP_DECOP_CB_PCM_BUF_SZ;
1552         // allocate Metadata buffers //QIN
1553         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)))
1554         {
1555             TRACE_TERSE1("PAF_ASIT_initPhaseDecOpCircBuf: AS%d: Memory_calloc failed", as+zMS);
1556             SW_BREAKPOINT;
1557         }
1558         pCb->metaBufEnd = pCb->metaBuf + (ASP_DECOP_CB_MAX_NUM_AF * PAF_MAX_PRIVATE_MD_SZ * PAF_MAX_NUM_PRIVATE_MD);
1559         // (***) FL: revisit, here PCM is hard-coded for 256 sample dec op frame length        
1560         // Initialize decoder output circular buffer for PCM
1561         errno = cbInit(pCb);
1562         if (errno)
1563         {
1564             SW_BREAKPOINT; // FL: debug
1565             return errno;
1566         }
1567     }
1569     return 0;
1570 } //PAF_ASIT_initPhaseDecOpCircBuf
1573 #if 0
1574 // -----------------------------------------------------------------------------
1575 // AST Processing Function - Pass-Through Processing
1576 //
1577 //   Name:      PAF_AST_passProcessing
1578 //   Purpose:   Audio Stream Task Function for processing audio data as a
1579 //              pass-through from the input driver to the output driver
1580 //              for development and testing.
1581 //   From:      audioStream1Task or equivalent
1582 //   Uses:      See code.
1583 //   States:    x
1584 //   Return:    Error number in standard form (0 on success).
1585 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
1586 //              * State information on initialization.
1587 //              * State information on processing.
1588 //
1590 #pragma CODE_SECTION(PAF_AST_passProcessing,".text:_PAF_AST_passProcessing")
1591 /* Pass Processing is often omitted from builds to save memory, */
1592 /* and CODE_SECTION/clink constructs facilitate this omission.  */
1594 Int
1595 PAF_AST_passProcessing(const PAF_AST_Params *pP, const PAF_AST_Patchs *pQ, PAF_AST_Config *pC, Int hack)
1597     Int z;                              /* input/output counter */
1598     Int errno = 0;                      /* error number */
1599     Int getVal;
1600     Int rxNumChan, txNumChan;
1601     Int first;
1602     Int zMD = pC->masterDec;
1603     Int zMI = pP->zone.master;
1606 #ifndef __TI_EABI__
1607     asm (" .clink"); /* See comment above regarding CODE_SECTION/clink. */
1608 #endif    
1610     TRACE_VERBOSE0("PAF_AST_passProcessing: initializing");
1612     //
1613     // Determine that receive/transmit channels are compatible
1614     //
1616     // Can handle handle only master input
1617     for (z=INPUT1; z < INPUTN; z++) {
1618         if (z != zMI && pC->xInp[z].hRxSio)
1619             return (ASPERR_PASS + 0x01);
1620     }
1622     /* Number of receive/transmit channels */
1624     if (! pC->xInp[zMI].hRxSio)
1625         return (ASPERR_PASS + 0x11);
1626     if (SIO_ctrl (pC->xInp[zMI].hRxSio, PAF_SIO_CONTROL_GET_NUMCHANNELS, (Arg) &rxNumChan))
1627         return (ASPERR_PASS + 0x12);
1628     if (rxNumChan > NUM_TX_CHAN(zMI))
1629         return (ASPERR_PASS + 0x13);
1631     for (z=OUTPUT1; z < OUTPUTN; z++) {
1632         if (! pC->xOut[zMI].hTxSio)
1633             return (ASPERR_PASS + 0x10*(z+2) + 0x01);
1634         if (SIO_ctrl (pC->xOut[z].hTxSio, PAF_SIO_CONTROL_GET_NUMCHANNELS, (Arg) &txNumChan))
1635             return (ASPERR_PASS + 0x10*(z+2) + 0x02);
1636         if (txNumChan > NUM_TX_CHAN(zMI))
1637             return (ASPERR_PASS + 0x10*(z+2) + 0x03);
1638     }
1640     //
1641     // Set up receive/transmit
1642     //
1644     SIO_idle (pC->xInp[zMI].hRxSio);
1645     for (z=OUTPUT1; z < OUTPUTN; z++) {
1646         if(SIO_idle (pC->xOut[z].hTxSio))
1647             return ASPERR_IDLE;
1648     }
1650     if (SIO_ctrl (pC->xInp[zMI].hRxSio, PAF_SIO_CONTROL_SET_SOURCESELECT, PAF_SOURCE_PCM))
1651         return (ASPERR_PASS + 0x14);
1653     if (SIO_ctrl (pC->xInp[zMI].hRxSio, PAF_SIO_CONTROL_SET_PCMFRAMELENGTH, FRAMELENGTH))
1654         return (ASPERR_PASS + 0x15);
1656     for (z=OUTPUT1; z < OUTPUTN; z++)
1657         pC->xOut[z].outBufConfig.lengthofFrame = FRAMELENGTH;
1659     if (SIO_issue (pC->xInp[zMI].hRxSio, &pC->xInp[zMI].inpBufConfig, sizeof (pC->xInp[zMI].inpBufConfig), PAF_SIO_REQUEST_SYNC))
1660         return ASPERR_PASS + 0x16;
1662     if (SIO_reclaim (pC->xInp[zMI].hRxSio, (Ptr)&pC->xInp[zMI].pInpBuf, NULL) != sizeof (PAF_InpBufConfig))
1663         return ASPERR_PASS + 0x17;
1665     //
1666     // Receive and transmit the data in single-frame buffers
1667     //
1669     first = 1;
1670     while (pC->xDec[zMD].decodeStatus.sourceSelect == PAF_SOURCE_PASS) {
1671         PAF_OutBufConfig *pOutBuf;
1672         PAF_InpBufConfig *pInpBuf;
1674         if (first) {
1675             first = 0;
1677             TRACE_VERBOSE0("PAF_AST_passProcessing: starting output");
1679             for (z=OUTPUT1; z < OUTPUTN; z++) {
1680                 getVal = SIO_issue (pC->xOut[z].hTxSio, &pC->xOut[z].outBufConfig, sizeof(pC->xOut[z].outBufConfig), 0);
1681                 if (getVal > 0) {
1682                     errno = ASPERR_ISSUE;
1683                     break;
1684                 }
1685                 else if (getVal < 0) {
1686                     errno = -getVal;
1687                     break;
1688                 }
1690                 if (getVal = SIO_ctrl (pC->xOut[z].hTxSio, PAF_SIO_CONTROL_UNMUTE, 0))
1691                     return (getVal & 0xff) | ASPERR_MUTE;
1692             }
1693             if (errno)
1694                 break;
1696         }
1698         getVal = SIO_issue (pC->xInp[zMI].hRxSio, &pC->xInp[zMI].inpBufConfig, sizeof (pC->xInp[zMI].inpBufConfig), PAF_SIO_REQUEST_NEWFRAME);
1699         if (getVal > 0) {
1700             errno = ASPERR_ISSUE;
1701             break;
1702         }
1704         TRACE_VERBOSE1("PAF_AST_passProcessing: awaiting frame -- input size %d", rxNumChan * FRAMELENGTH);
1706         getVal = SIO_reclaim (pC->xInp[zMI].hRxSio, (Ptr) &pInpBuf, NULL);
1707         if (getVal < 0) {
1708             errno = -getVal;
1709             break;
1710         }
1712         for (z=OUTPUT1; z < OUTPUTN; z++) {
1713             getVal = SIO_reclaim (pC->xOut[z].hTxSio, (Ptr) &pOutBuf, NULL);
1714             if (getVal < 0) {
1715                 errno = -getVal;
1716                 break;
1717             }
1718         }
1719         if( errno )
1720             break;
1722         TRACE_VERBOSE0("PAF_AST_passProcessing: copying frame");
1724         if (errno = pP->fxns->passProcessingCopy (pP, pQ, pC))
1725             break;
1727         for (z=OUTPUT1; z < OUTPUTN; z++) {
1728             getVal = SIO_issue (pC->xOut[z].hTxSio, &pC->xOut[z].outBufConfig, sizeof(pC->xOut[z].outBufConfig), 0);
1729             if (getVal > 0) {
1730                 errno = ASPERR_ISSUE;
1731                 break;
1732             }
1733             else if (getVal < 0) {
1734                 errno = -getVal;
1735                 break;
1736             }
1737         }
1738         if( errno )
1739             break;
1740     }
1742     //
1743     // Close down receive/transmit
1744     //
1746     TRACE_TERSE0("PAF_AST_passProcessing: finalizing"));
1748     for (z=OUTPUT1; z < OUTPUTN; z++) {
1749         if (getVal = SIO_ctrl (pC->xOut[z].hTxSio, PAF_SIO_CONTROL_MUTE, 0)) {
1750             if (! errno)
1751                 errno = (getVal & 0xff) | ASPERR_MUTE;
1752             /* convert to sensical errno */
1753         }
1754     }
1756     SIO_idle (pC->xInp[zMI].hRxSio);
1757     for (z=OUTPUT1; z < OUTPUTN; z++)
1758         SIO_idle (pC->xOut[z].hTxSio);
1760     return errno;
1762 } //PAF_AST_passProcessing
1763 #endif // #if 0
1765 #if 0
1766 // -----------------------------------------------------------------------------
1767 // AST Processing Function Helper - Pass-Through Processing Patch Point
1768 //
1769 //   Name:      PAF_AST_passProcessingCopy
1770 //   Purpose:   Pass-Through Processing Function for copying audio data
1771 //              from the input buffer to the output buffer.
1772 //   From:      AST Parameter Function -> passProcessing
1773 //   Uses:      See code.
1774 //   States:    x
1775 //   Return:    Error number in standard form (0 on success).
1776 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
1777 //              x
1778 //
1780 #pragma CODE_SECTION(PAF_AST_passProcessingCopy,".text:_PAF_AST_passProcessingCopy")
1781 /* Pass Processing is often omitted from builds to save memory, */
1782 /* and CODE_SECTION/clink constructs facilitate this omission.  */
1784 Int
1785 PAF_AST_passProcessingCopy (const PAF_AST_Params *pP, const PAF_AST_Patchs *pQ, PAF_AST_Config *pC)
1787     Int z;                              /* output counter */
1788     Int errno;                          /* error number */
1789     Int i;
1790     Int rxNumChan, txNumChan;
1791     Int zMI = pP->zone.master;
1794     asm (" .clink"); /* See comment above regarding CODE_SECTION/clink. */
1796     // Copy data from input channels to output channels one of two ways:
1798     if (SIO_ctrl (pC->xInp[zMI].hRxSio, PAF_SIO_CONTROL_GET_NUMCHANNELS, (Arg) &rxNumChan))
1799         return (ASPERR_PASS + 0x12);
1801     for (z=OUTPUT1; z < OUTPUTN; z++) {
1802         if (SIO_ctrl (pC->xOut[z].hTxSio, PAF_SIO_CONTROL_GET_NUMCHANNELS, (Arg) &txNumChan))
1803             return (ASPERR_PASS + 0x22);
1805         if( txNumChan <= rxNumChan ) {
1807             // Copy one to one, ignoring later rx channels as needed.
1809             for( i=0; i < txNumChan; i++ ) {
1810                 errno = pP->fxns->copy( i, &pC->xInp[zMI].inpBufConfig, i, &pC->xOut[z].outBufConfig );
1811                 if( errno )
1812                     return errno;
1813             }
1814         }
1815         else {
1817             // Copy one to many, repeating earlier rx channels as needed.
1819             Int from, to;
1821             from = 0;
1822             to   = 0;
1823             while( to < txNumChan ) {
1824                 errno = pP->fxns->copy( from, &pC->xInp[zMI].inpBufConfig, to, &pC->xOut[z].outBufConfig );
1825                 if( errno )
1826                     return errno;
1828                 from++;
1829                 to++;
1830                 if( from == rxNumChan )
1831                     from = 0;
1832             }
1833         }
1834     }
1836     return 0;
1837 } //PAF_AST_passProcessingCopy
1838 #endif // #if 0
1840 // -----------------------------------------------------------------------------
1841 // ASIT Processing Function - Auto Processing
1842 //
1843 //   Name:      PAF_ASIT_autoProcessing
1844 //   Purpose:   Audio Stream Input Task Function for processing audio data to
1845 //              determine the input type without output.
1846 //   From:      audioStream1Task or equivalent
1847 //   Uses:      See code.
1848 //   States:    x
1849 //   Return:    Error number in standard or SIO form (0 on success).
1850 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
1851 //              * State information on initialization.
1852 //
1854 #define DECSIOMAP(X)                                                \
1855     pP->pDecSioMap->map[(X) >= pP->pDecSioMap->length ? 0 : (X)]
1857 Int
1858 PAF_ASIT_autoProcessing(
1859     const PAF_ASIT_Params *pP, 
1860     const PAF_ASIT_Patchs *pQ, 
1861     PAF_ASIT_Config *pC, 
1862     Int inputTypeSelect, 
1863     ALG_Handle pcmAlgMaster
1866     PAF_AST_Config *pAstCfg;
1867     Int as;                 /* Audio Stream Number (1, 2, etc.) */
1868     Int errno = 0;          /* error number */
1869     Int nbytes;
1870     Int frameLength;
1871     Int zMD;
1872     Int zMI;
1873     Int zMS;
1874     
1875     pAstCfg = pC->pAstCfg; // get pointer to common (shared) configuration
1876     as = pAstCfg->as;
1877     zMD = pAstCfg->masterDec;
1878     zMS = pAstCfg->masterStr;    
1879     zMI = pP->zone.master;    
1880     
1881     TRACE_VERBOSE1("PAF_ASIT_autoProcessing: AS%d: PAF_AST_autoProcessing", as+zMS);
1883     if (errno = SIO_ctrl(pAstCfg->xInp[zMI].hRxSio,
1884                          PAF_SIO_CONTROL_SET_SOURCESELECT,
1885                          DECSIOMAP(pAstCfg->xDec[zMD].decodeStatus.sourceSelect)))
1886     {
1887         TRACE_VERBOSE2("PAF_ASIT_autoProcessing: AS%d: source select returns 0x%x", as+zMS, errno);
1888         return errno;
1889     }
1890     //frameLength = pP->fxns->computeFrameLength (pcmAlgMaster, FRAMELENGTH,
1891     //                                            pC->xDec[zMD].decodeStatus.bufferRatio);
1892     frameLength = FRAMELENGTH; // FL: fix PCM frameLength for alpha release.
1894     if (errno = SIO_ctrl(pAstCfg->xInp[zMI].hRxSio,
1895                          PAF_SIO_CONTROL_SET_PCMFRAMELENGTH, frameLength))
1896     {
1897         TRACE_VERBOSE2("PAF_ASIT_autoProcessing: SET_PCMFRAMELENGTH returns 0x%x, returning ASPERR_AUTO_LENGTH, 0x%x",
1898             errno, ASPERR_AUTO_LENGTH);
1899         return ASPERR_AUTO_LENGTH;
1900     }
1902     if (errno = SIO_issue(pAstCfg->xInp[zMI].hRxSio,
1903                           &pAstCfg->xInp[zMI].inpBufConfig, sizeof(pAstCfg->xInp[zMI].inpBufConfig),
1904                           PAF_SIO_REQUEST_SYNC))
1905     {
1906         TRACE_VERBOSE2("PAF_ASIT_autoProcessing: REQUEST_SYNC returns 0x%x, returning ASPERR_ISSUE, 0x%x",
1907             errno, ASPERR_ISSUE);
1908         return ASPERR_ISSUE;
1909     }
1911     TRACE_VERBOSE1("PAF_ASIT_autoProcessing: AS%d: awaiting sync", as+zMS);
1913     // all of the sync scan work is done in this call. If the error returned
1914     // is DIBERR_SYNC then that just means we didn't find a sync, not a real I/O
1915     // error so we mask it off.
1916     nbytes = SIO_reclaim(pAstCfg->xInp[zMI].hRxSio, (Ptr)&pAstCfg->xInp[zMI].pInpBuf, NULL);
1917     if (nbytes == -DIBERR_SYNC)
1918     {
1919         TRACE_TERSE2("PAF_ASIT_autoProcessing: AS%d: SIO_reclaim returned 0x%x, ignoring", as+zMS, nbytes);
1920         return nbytes;
1921     }
1922     if (nbytes != sizeof(PAF_InpBufConfig))
1923     {
1924         TRACE_TERSE3("PAF_ASIT_autoProcessing. SIO_reclaim returned %d, not %d, returning ASPERR_RECLAIM (0x%x)",
1925             nbytes, sizeof(PAF_InpBufConfig), ASPERR_RECLAIM);
1926         return ASPERR_RECLAIM;
1927     }
1928     if (errno)
1929     {
1930         TRACE_TERSE2("PAF_ASIT_autoProcessing: AS%d: returning errno 0x%x", as+zMS, errno);
1931     }
1932     return errno;
1933 } //PAF_ASIT_autoProcessing
1935 UInt32 gProbe1Err=0;
1936 UInt32 gProbe2Err=0;
1937 UInt32 gMajorAuMissed=0;
1939 // -----------------------------------------------------------------------------
1940 // ASIT Processing Function - Decode Processing
1941 //
1942 //   Name:      PAF_ASIT_decodeProcessing
1943 //   Purpose:   Audio Stream Input Task Function for processing audio data.
1944 //   From:      audioStream1Task or equivalent
1945 //   Uses:      See code.
1946 //   States:    x
1947 //   Return:    Error number in standard form (0 on success).
1948 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
1949 //              * State information on initialization (via children).
1950 //              * State information on processing (via children).
1951 //              * Decode warnings.
1952 //
1953 // When "writeDECModeContinuous" is used for zMI input/decode:
1954 // PAF_AST_decodeProcessing() loop may be (is designed to be) exited:
1955 // (a) if "writeDECCommandRestart" is used
1956 //    (or "writeDECCommandAbort", but this performs no cleanup whatsoever, and so its use is discouraged)
1957 // (b) if "writeDECSourceSelectNone" is used
1958 // [ the latter events lead to QUIT state, simply for exiting (errme = errno = ASPERR_QUIT)
1959 // (c) if an error occurs in
1960 //     INIT
1961 //     CONT ("subsequent block state", which "Establish[es] secondary timing")
1962 //         -> PAF_AST_decodeCont(): "Await slave inputs"
1963 //     STREAM (errno |= PAF_COMPONENT_ASP)
1964 //     ENCODE (errno |= PAF_COMPONENT_ENCODE)
1965 // [ the latter errors lead to "switch_break:"
1966 //         -> PAF_AST_decodeComplete(), which always returns 0 (no error) ]
1967 //
1968 // [ Notably, in FINAL ("frame-finalization state")
1969 //         -> PAF_AST_decodeFinalTest() is *not* called,
1970 //   and so any other (asynchronous) changes in pC->xDec[zMD].decodeStatus.sourceSelect are ignored. ]
1971 // [ For completeness, note also: "default" state, internal check (errme = errno = ASPERR_UNKNOWNSTATE) ]
1972 //
1973 // States in which error can't occur:
1974 //     AGAIN ("subsequent initial state")
1975 //
1976 // States in which (some) errors must be handled:
1977 //     INFO1 ("first frame state")
1978 //         -> PAF_AST_decodeInfo(): pass on ASPERR_INFO_RATECHANGE, ASPERR_INFO_PROGRAM ("bad" internal error)
1979 //            -> *DONE* must "catch" ASPERR_RECLAIM from SIO_reclaim (pC->xInp[zMI].hRxSio) -- note zMI only **
1980 //               ?*? but what about ASPERR_RESYNC from same call ?*?
1981 //            -> *for now, at least, pass on error from pP->fxns->updateInputStatus ()*
1982 //            -> *DONE* must "catch" error from (zMI) dec->fxns->info() **
1983 //         -> PAF_AST_decodeInfo1(): pass on any errors which occur here:
1984 //            - pP->fxns->streamChainFunction (... PAF_ASP_CHAINFRAMEFXNS_RESET)
1985 //            - enc->fxns->info()
1986 //            - pP->fxns->setCheckRateX()
1987 //            - pP->fxns->startOutput()
1988 //            - "Start slave inputs if necessary"
1989 //     INFO2 ("subsequent frame state")
1990 //         -> PAF_AST_decodeInfo(): (see above)
1991 //         -> PAF_AST_decodeInfo2(): pass on any errors which occur here:
1992 //            - pP->fxns->setCheckRateX()
1993 //     TIME ("timing state")
1994 //         -> PAF_AST_decodeTime(): "Special timing consideations for AC-3"
1995 //         -> performs SIO_issue (... PAF_SIO_REQUEST_FULLFRAME) & SIO_reclaim() *for zMI only*
1996 //         -> now, DIB_issue [PAF_SIO_REQUEST_FULLFRAME] would only return SYS_EINVAL for "bad" internal error
1997 //            (*OK* don't try to recover from this*)
1998 //         -> much more likely would be SIO_reclaim() error (ASPERR_RECLAIM)
1999 //         -> *DONE* must "catch" (just) ASPERR_RECLAIM error -- note zMI only,
2000 //            possibly in PAF_AST_decodeProcessing() itself **
2001 //     DECODE ("decode state")
2002 //         -> PAF_AST_decodeDecode(): pass on error from
2003 //            - PAF_SIO_CONTROL_GET_NUM_REMAINING ("bad" internal error)
2004 //            - dec->fxns->reset()
2005 //            - PAF_SIO_CONTROL_SET_PCMFRAMELENGTH
2006 //         -> *DONE* must catch error from (zMI) dec->fxns->decode()
2007 //         -> *?* must catch ASPERR_ISSUE from (zMI) SIO_issue()
2008 Int
2009 PAF_ASIT_decodeProcessing(
2010     const PAF_ASIT_Params *pP, 
2011     const PAF_ASIT_Patchs *pQ, 
2012     PAF_ASIT_Config *pC, 
2013     Int sourceSelect
2016     PAF_AST_Config *pAstCfg;
2017     //Int as = pC->as;                    /* Audio Stream Number (1, 2, etc.) */
2018     Int z;                              /* decode counter */
2019     Int errno;                          /* error number */
2020     Int getVal;
2021     enum { INIT, INFO1, INFO2, DECODE, FINAL, QUIT } state;
2022     ALG_Handle alg[DECODEN_MAX];
2023     Int zMD;
2024     Int zMS;
2025     Int size;
2026     //PAF_InpBufConfig *pIpBufConfig;
2027     Int frame; // decoder input frame count
2028     Int block; // (***) FL: formerly  -- decoder output block count / input frame
2029 #ifdef NON_CACHE_STATUS
2030     Int8 tempVar8, temp2Var8;
2031 #endif
2032     
2033     pAstCfg = pC->pAstCfg; // get pointer to common (shared) configuration
2034     zMD = pAstCfg->masterDec;
2035     zMS = pAstCfg->masterStr;
2036         
2037     for (z=DECODE1; z < DECODEN; z++)
2038     {
2039         alg[z] = pAstCfg->xDec[z].decAlg[PAF_SOURCE_PCM];        
2040     }
2041     alg[zMD] = NULL; // decAlgMaster; // FL: alg[] init is on slave
2043     //
2044     // Receive and process the data in single-frame buffers
2045     //
2047     state = INIT;
2048     errno = 0; /* error number */
2050 #ifdef NON_CACHE_STATUS
2051     statusOp_read(&tempVar8,
2052                   &(pAstCfg->xDec[zMD].decodeStatus.sourceSelect),
2053                   sizeof(tempVar8),
2054                   GATEMP_INDEX_DEC);
2055     TRACE_TERSE1("PAF_ASIT_decodeProcessing: sourceSelect is %d", tempVar8);
2057     for (;;) 
2058     {
2059         statusOp_read(&tempVar8,
2060                       &(pAstCfg->xDec[zMD].decodeStatus.sourceSelect),
2061                     sizeof(tempVar8),
2062                     GATEMP_INDEX_DEC);
2063         if (tempVar8 == PAF_SOURCE_NONE)
2064         {
2065 #else
2066     TRACE_TERSE1("PAF_ASIT_decodeProcessing: sourceSelect is %d", pAstCfg->xDec[zMD].decodeStatus.sourceSelect);
2068     for (;;)
2069     {
2070         if (pAstCfg->xDec[zMD].decodeStatus.sourceSelect == PAF_SOURCE_NONE)
2071         {
2072 #endif
2073             TRACE_VERBOSE0("PAF_ASIT_decodeProcessing: sourceSelect == PAF_SOURCE_NONE");
2074             state = QUIT;
2075         }
2077         // Process commands (decode)
2078         if (getVal = pP->fxns->decodeCommand(pP, pQ, pC)) 
2079         {
2080             if (state != INIT)   // no need to restart/abort if not yet started
2081             {
2082                 if (getVal == ASPERR_QUIT)
2083                 {
2084                     state = QUIT;
2085                     TRACE_VERBOSE0("PAF_ASIT_decodeProcessing. %d: state = QUIT");
2086                 }
2087                 else if (getVal == ASPERR_ABORT)
2088                 {
2089                     TRACE_VERBOSE0("PAF_ASIT_decodeProcessing. %d: return getVal");
2090                     return getVal;
2091                 }
2092                 else
2093                 {
2094                     /* ignore */;
2095                 }
2096             }
2097             TRACE_VERBOSE0("PAF_ASIT_decodeProcessing: state == INIT");
2098         }
2100         TRACE_TIME((&TIME_MOD,         "... + %d = %d ->", dtime(), TSK_time()));
2101         TRACE_TIME((&TIME_MOD,         "                 state = %s", stateName[state]));
2103         // Process state (decode)
2104         switch (state) 
2105         {
2106             case INIT: // initial state
2107                 gAsipInitCnt++;
2108                 Log_info0("TaskAsip: state=INIT");
2110 #if 0 // Not necessary since decoder status is in uncached memory
2111                 // status for shared beta units can change (e.g. at-boot or alpha)
2112                 
2113                 // write back Status structures for shared Beta Units
2114                 //size = IACP_STD_BETA_TABLE.pStatus[STD_BETA_DECODE]->size;
2115                 //Cache_wb((Ptr)(IACP_STD_BETA_TABLE.pStatus[STD_BETA_DECODE]), size, Cache_Type_ALLD, 0);
2116                 size = IACP_STD_BETA_TABLE.pStatus[STD_BETA_PCM]->size;
2117                 Cache_wb((Ptr)(IACP_STD_BETA_TABLE.pStatus[STD_BETA_PCM]), size, Cache_Type_ALLD, 0);
2118                 size = IACP_STD_BETA_TABLE.pStatus[STD_BETA_DDP]->size;
2119                 Cache_wb((Ptr)(IACP_STD_BETA_TABLE.pStatus[STD_BETA_DDP]), size, Cache_Type_ALLD, 0);
2120                 size = IACP_STD_BETA_TABLE.pStatus[STD_BETA_THD]->size;
2121                 Cache_wb((Ptr)(IACP_STD_BETA_TABLE.pStatus[STD_BETA_THD]), size, Cache_Type_ALLD, 0);
2122                 Cache_wait();
2123 #endif
2124 #if 0 // Not necessary since decoder status is in uncached memory
2125                 ////size = IACP_STD_BETA_TABLE.pStatus[STD_BETA_DECODE]->size;
2126                 ////Cache_wbInv((Ptr)(IACP_STD_BETA_TABLE.pStatus[STD_BETA_DECODE]), size, Cache_Type_ALLD, 0);
2127                 //size = IACP_STD_BETA_TABLE.pStatus[STD_BETA_PCM]->size;
2128                 //Cache_wbInv((Ptr)(IACP_STD_BETA_TABLE.pStatus[STD_BETA_PCM]), size, Cache_Type_ALLD, 0);
2129                 //size = IACP_STD_BETA_TABLE.pStatus[STD_BETA_DDP]->size;
2130                 //Cache_wbInv((Ptr)(IACP_STD_BETA_TABLE.pStatus[STD_BETA_DDP]), size, Cache_Type_ALLD, 0);
2131                 //Cache_wait();                
2132 #endif                
2133                 
2134                 if (errno = pP->fxns->decodeInit(pP, pQ, pC, sourceSelect))
2135                 {
2136                     TRACE_VERBOSE1("PAF_ASIT_decodeProcessing: INIT, errno 0x%x.  break after decodeInit", errno);
2137                     break;
2138                 }
2139                 
2140                 //
2141                 // Not necessary since decoder status is in uncached memory
2142                 //
2143                
2144 #if 0 // Not necessary since decoder status is in uncached memory
2145                 // invalidate Status structures for shared Beta Units
2146                 //size = IACP_STD_BETA_TABLE.pStatus[STD_BETA_DECODE]->size;
2147                 //Cache_inv((Ptr)(IACP_STD_BETA_TABLE.pStatus[STD_BETA_DECODE]), size, Cache_Type_ALLD, 0);
2148                 size = IACP_STD_BETA_TABLE.pStatus[STD_BETA_PCM]->size;
2149                 Cache_inv((Ptr)(IACP_STD_BETA_TABLE.pStatus[STD_BETA_PCM]), size, Cache_Type_ALLD, 0);
2150                 size = IACP_STD_BETA_TABLE.pStatus[STD_BETA_DDP]->size;
2151                 Cache_inv((Ptr)(IACP_STD_BETA_TABLE.pStatus[STD_BETA_DDP]), size, Cache_Type_ALLD, 0);
2152                 size = IACP_STD_BETA_TABLE.pStatus[STD_BETA_THD]->size;
2153                 Cache_inv((Ptr)(IACP_STD_BETA_TABLE.pStatus[STD_BETA_THD]), size, Cache_Type_ALLD, 0);
2154                 Cache_wait();
2155 #endif
2156                 
2157                 frame = 0;
2158                 block = 0;
2160                 TRACE_VERBOSE0("PAF_ASIT_decodeProcessing: state: INIT->INFO1");
2161                 state = INFO1;
2162                 continue;
2164             case INFO1: // first frame state
2165                 gAsipInfo1Cnt++;
2166                 Log_info0("TaskAsip: state=INFO1");
2167                 
2168 #if 0
2169                 //// (***) FL: revisit
2170                 //// write back Inp configuration
2171                 //Cache_wb(&gPAF_AST_config.xInp[0], INPUTN*sizeof(PAF_AST_InpBuf), Cache_Type_ALLD, 0);
2172                 //// write back input data
2173                 //pIpBufConfig = &gPAF_AST_config.xInp[0].inpBufConfig;
2174                 //size = pIpBufConfig->frameLength * pIpBufConfig->sizeofElement;
2175                 //Cache_wb(pIpBufConfig->pntr.pLgInt, size, Cache_Type_ALLD, 0);
2176                 //// write back Dec configuration
2177                 //Cache_wb(&gPAF_AST_config.xDec[0], DECODEN*sizeof(PAF_AST_Decode), Cache_Type_ALLD, 0);
2178                 //Cache_wait();            
2179 #endif                
2181                 // Establish primary timing
2182                 if (errno = pP->fxns->decodeInfo(pP, pQ, pC, frame, block))
2183                 {
2184                     gProbe1Err++;
2185                     TRACE_TERSE1("INFO1: errno 0x%x after decodeInfo, primary timing", errno);
2186                     break;
2187                 }
2188                 
2189 #if 0
2190                 //// (***) FL: revisit
2191                 //// invalidate Dec configuration
2192                 //Cache_inv(&gPAF_AST_config.xDec[0], DECODEN*sizeof(PAF_AST_Decode), Cache_Type_ALLD, 0);
2193                 //Cache_wait();                            
2194 #endif                
2197 #ifdef NON_CACHE_STATUS
2198                 statusOp_read(&tempVar8,
2199                               &(pAstCfg->xDec[zMD].decodeStatus.sourceDecode),
2200                               sizeof(tempVar8),
2201                               GATEMP_INDEX_DEC);
2202                 statusOp_read(&temp2Var8,
2203                               &(pAstCfg->xDec[zMD].decodeStatus.sampleRate),
2204                               sizeof(tempVar8),
2205                               GATEMP_INDEX_DEC);
2206                 // Don't start decode until major access unit is found.
2207                 if (((tempVar8 == PAF_SOURCE_THD)    ||
2208                      (tempVar8 == PAF_SOURCE_DXP)    ||
2209                      (tempVar8 == PAF_SOURCE_DTSHD)) &&
2210                      (temp2Var8 == PAF_SAMPLERATE_UNKNOWN)) 
2211 #else
2212                 // Don't start decode until major access unit is found.
2213                 if (((pAstCfg->xDec[zMD].decodeStatus.sourceDecode == PAF_SOURCE_THD)    ||
2214                      (pAstCfg->xDec[zMD].decodeStatus.sourceDecode == PAF_SOURCE_DXP)    ||
2215                      (pAstCfg->xDec[zMD].decodeStatus.sourceDecode == PAF_SOURCE_DTSHD)) &&
2216                      (pAstCfg->xDec[zMD].decodeStatus.sampleRate == PAF_SAMPLERATE_UNKNOWN))
2217 #endif
2218                 {
2219                     Int z;
2220                     for (z=DECODE1; z < DECODEN; z++) 
2221                     {
2222                         Int zI = pP->inputsFromDecodes[z];
2223 #ifdef NON_CACHE_STATUS
2224                         statusOp_read(&tempVar8,
2225                                       &(pAstCfg->xDec[z].decodeStatus.mode),
2226                                       sizeof(tempVar8),
2227                                       GATEMP_INDEX_DEC);
2228                         if (pAstCfg->xInp[zI].hRxSio && tempVar8)
2229                         {
2230 #else
2231                         if (pAstCfg->xInp[zI].hRxSio && pAstCfg->xDec[z].decodeStatus.mode)
2232                         {
2233 #endif
2234                             TRACE_VERBOSE0("TaskAsip: PAF_ASIT_decodeProcessing: INFO1, SIO_issue");
2235                             if (SIO_issue(pAstCfg->xInp[zI].hRxSio, &pAstCfg->xInp[zI].inpBufConfig,
2236                                 sizeof(pAstCfg->xInp[zI].inpBufConfig), PAF_SIO_REQUEST_NEWFRAME))
2237                             {
2238                                 gProbe2Err++;
2239                                 TRACE_TERSE0("PAF_ASIT_decodeProcessing. %d: INFO1, return (ASPERR_ISSUE)");
2240                                 return (ASPERR_ISSUE);
2241                             }
2242                         }
2243                     }
2244                     TRACE_VERBOSE1("PAF_ASIT_decodeProcessing: INFO1: frame %d, not major access unit", frame);
2245                     gMajorAuMissed++; // debug
2246                     frame++;
2247                     state = INFO1;
2248                     continue;
2249                 }
2250                 TRACE_VERBOSE1("PAF_ASIT_decodeProcessing: INFO1: frame %d, major access unit found", frame);
2252                 // Establish secondary timing
2253                 if (errno = pP->fxns->decodeInfo1(pP, pQ, pC, frame, block))
2254                 {
2255                     TRACE_VERBOSE1("PAF_ASIT_decodeProcessing: INFO1, errno 0x%x.  break after decodeInfo1", errno);
2256                     break;
2257                 }
2259                 TRACE_VERBOSE0("PAF_ASIT_decodeProcessing: state: INFO1->DECODE");
2260                 state = DECODE;
2261                 continue;
2263             case INFO2: // subsequent frame state
2264                 gAsipInfo2Cnt++;
2265                 Log_info0("TaskAsip: state=INFO2");
2267 #if 0            
2268                 //// (***) FL: revisit
2269                 //// write back Inp configuration
2270                 //Cache_wb(&gPAF_AST_config.xInp[0], INPUTN*sizeof(PAF_AST_InpBuf), Cache_Type_ALLD, 0);
2271                 //// write back input data
2272                 //pIpBufConfig = &gPAF_AST_config.xInp[0].inpBufConfig;
2273                 //size = pIpBufConfig->frameLength * pIpBufConfig->sizeofElement;
2274                 //Cache_wb(pIpBufConfig->pntr.pLgInt, size, Cache_Type_ALLD, 0);
2275                 //// write back Dec configuration
2276                 //Cache_wb(&gPAF_AST_config.xDec[0], DECODEN*sizeof(PAF_AST_Decode), Cache_Type_ALLD, 0);
2277                 //Cache_wait();
2278 #endif                
2280                 // Establish primary timing
2281                 if (errno = pP->fxns->decodeInfo(pP, pQ, pC, frame, block))
2282                 {
2283                     TRACE_TERSE1("PAF_ASIT_decodeProcessing: INFO2 break on decodeInfo. errno 0x%x", errno);
2284                     gAsipInfo2_PrimaryErrCnt++;
2285                     break;
2286                 }
2288 #if 0            
2289                 //// (***) FL: revisit
2290                 //// invalidate Dec configuration
2291                 //Cache_inv(&gPAF_AST_config.xDec[0], DECODEN*sizeof(PAF_AST_Decode), Cache_Type_ALLD, 0);
2292                 //Cache_wait();                                            
2293 #endif                
2294                 
2295                 if (errno = pP->fxns->decodeInfo2(pP, pQ, pC, frame, block))
2296                 {
2297                     TRACE_TERSE1("PAF_ASIT_decodeProcessing. %d: INFO2 break on decodeInfo2. errno 0x%x", errno);
2298                     gAsipInfo2_ErrCnt++;
2299                     break;
2300                 }
2302                 TRACE_VERBOSE0("PAF_ASIT_decodeProcessing: state: INFO2->DECODE");
2303                 state = DECODE;
2304                 continue;
2306             case DECODE: // decode state
2307                 gAsipDecodeCnt++;
2308                 Log_info0("TaskAsip: state=DECODE");
2310 #if 0
2311                 //// (***) FL: revisit
2312                 //// write back Dec configuration
2313                 //Cache_wb(&gPAF_AST_config.xDec[0], DECODEN*sizeof(PAF_AST_Decode), Cache_Type_ALLD, 0);
2314                 //Cache_wait();                        
2315 #endif
2316             
2317                 if (errno = pP->fxns->decodeDecode(pP, pQ, pC, sourceSelect, frame, block))
2318                 {
2319                         gAsipDecodeErrCnt++;
2320                         TRACE_TERSE1("PAF_ASIT_decodeProcessing: state: DECODE.  decodeDecode err 0x%04x", errno);
2321                     break;
2322                 }
2323       
2324 #if 0      
2325                 //// (***) FL: revisit
2326                 //// invalidate Dec configuration
2327                 //Cache_inv(&gPAF_AST_config.xDec[0], DECODEN*sizeof(PAF_AST_Decode), Cache_Type_ALLD, 0);
2328                 //Cache_wait();                                            
2329 #endif                
2330                 
2331                 TRACE_VERBOSE0("PAF_ASIT_decodeProcessing: state: DECODE->FINAL");
2332                 state = FINAL;
2333                 continue;
2335             case FINAL: // frame-finalization state
2336                 gAsipFinalCnt++;
2337                 Log_info0("TaskAsip: state=FINAL");
2339                 // Check for final frame, and if indicated:
2340                 // - Exit state machine to "complete" processing.
2341                 if (pP->fxns->decodeFinalTest(pP, pQ, pC, frame, block)) 
2342                 {
2343                     break;
2344                 }
2346                 frame++;
2347                 TRACE_VERBOSE0("PAF_ASIT_decodeProcessing: state: FINAL->AGAIN");
2348                 state = INFO2;
2349                 continue;
2351             case QUIT: // exit state
2352                 gAsipQuitCnt++;
2353                 Log_info0("TaskAsip: state=QUIT");
2355                 // Quit:
2356                 // - Set error number registers.
2357                 // - Exit state machine to "decode complete" processing.
2358                 TRACE_VERBOSE0("PAF_ASIT_decodeProcessing: state: QUIT");
2359                 errno = ASPERR_QUIT;
2360                 break;
2362             default: // unknown state
2364                 // Unknown:
2365                 // - Set error number registers.
2366                 // - Exit state machine to "decode complete" processing.
2368                 TRACE_TERSE1("PAF_ASIT_decodeProcessing: state: unknown, 0x%x", state);
2369                 errno = ASPERR_UNKNOWNSTATE;
2370                 break;
2372         }  // End of switch (state).
2374         TRACE_VERBOSE0("PAF_ASIT_decodeProcessing: Calling decode complete");
2375         if (pP->fxns->decodeComplete(pP, pQ, pC, alg, frame, block))
2376         {
2377             /* ignored? */;
2378         }
2380         TRACE_TIME((&TIME_MOD, "as1-f2: ... + %d = ?? (final? %d)", dtime(), state == FINAL));
2382         return errno;
2383     }  // End of for (;;) to Receive, process, and transmit the data.
2384 } //PAF_ASIT_decodeProcessing
2386 // -----------------------------------------------------------------------------
2387 // ASIT Decoding Function - Decode Command Processing
2388 //
2389 //   Name:      PAF_ASIT_decodeCommand
2390 //   Purpose:   Decoding Function for processing Decode Commands.
2391 //   From:      AST Parameter Function -> decodeProcessing
2392 //   Uses:      See code.
2393 //   States:    x
2394 //   Return:    Error number in standard form (0 on success).
2395 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
2396 //              * Command execution.
2397 //
2399 Int
2400 PAF_ASIT_decodeCommand(
2401     const PAF_ASIT_Params *pP, 
2402     const PAF_ASIT_Patchs *pQ, 
2403     PAF_ASIT_Config *pC
2406     PAF_AST_Config *pAstCfg;
2407     Int as;                 /* Audio Stream Number (1, 2, etc.) */
2408     Int z;                  /* decode counter */
2409     Int zS;
2410 #ifdef NON_CACHE_STATUS
2411     Int8 tempVar8;
2412 #endif
2414     pAstCfg = pC->pAstCfg; // get pointer to common (shared) configuration
2415     as = pAstCfg->as;
2417     for (z=DECODE1; z < DECODEN; z++) 
2418     {
2419         zS = pP->streamsFromDecodes[z];
2420 #ifdef NON_CACHE_STATUS
2421         statusOp_read(&tempVar8,
2422                       &(pAstCfg->xDec[z].decodeStatus.command2),
2423                       sizeof(tempVar8),
2424                       GATEMP_INDEX_DEC);
2425         if (!(tempVar8 & 0x80))
2426         {
2427             switch (tempVar8)
2428             {
2429                 case 0: // command none - process
2430                     tempVar8 |= 0x80;
2431                     statusOp_write(&(pAstCfg->xDec[z].decodeStatus.command2),
2432                                    &tempVar8,
2433                                    sizeof(tempVar8),
2434                                    GATEMP_INDEX_DEC);
2435                     break;
2436                 case 1: // command abort - leave now
2437                     TRACE_TERSE2("AS%d: PAF_ASIT_decodeCommand: decode command abort (0x%02x)", as+zS, 1);
2438                     tempVar8 |= 0x80;
2439                     statusOp_write(&(pAstCfg->xDec[z].decodeStatus.command2),
2440                                    &tempVar8,
2441                                    sizeof(tempVar8),
2442                                    GATEMP_INDEX_DEC);
2443                     return (ASPERR_ABORT);
2444                 case 2: // command restart - leave later
2445                     TRACE_TERSE2("AS%d: PAF_ASIT_decodeCommand: decode command quit (0x%02x)", as+zS, 2);
2446                     tempVar8 |= 0x80;
2447                     statusOp_write(&(pAstCfg->xDec[z].decodeStatus.command2),
2448                                    &tempVar8,
2449                                    sizeof(tempVar8),
2450                                    GATEMP_INDEX_DEC);
2451                     return (ASPERR_QUIT);
2452                 default: // command unknown - ignore
2453                     break;
2454             }
2455         }
2456 #else
2457         if (!(pAstCfg->xDec[z].decodeStatus.command2 & 0x80))
2458         {
2459             switch (pAstCfg->xDec[z].decodeStatus.command2)
2460             {
2461                 case 0: // command none - process
2462                     pAstCfg->xDec[z].decodeStatus.command2 |= 0x80;
2463                     break;
2464                 case 1: // command abort - leave now
2465                     TRACE_TERSE2("AS%d: PAF_ASIT_decodeCommand: decode command abort (0x%02x)", as+zS, 1);
2466                     pAstCfg->xDec[z].decodeStatus.command2 |= 0x80;
2467                     return (ASPERR_ABORT);
2468                 case 2: // command restart - leave later
2469                     TRACE_TERSE2("AS%d: PAF_ASIT_decodeCommand: decode command quit (0x%02x)", as+zS, 2);
2470                     pAstCfg->xDec[z].decodeStatus.command2 |= 0x80;
2471                     return (ASPERR_QUIT);
2472                 default: // command unknown - ignore
2473                     break;
2474             }
2475         }
2476 #endif
2477     }
2479     return 0;
2480 } //PAF_ASIT_decodeCommand
2482 // -----------------------------------------------------------------------------
2483 // ASIT Decoding Function - Reinitialization of Decode
2484 //
2485 //   Name:      PAF_ASIT_decodeInit
2486 //   Purpose:   Decoding Function for reinitializing the decoding process.
2487 //   From:      AST Parameter Function -> decodeProcessing
2488 //   Uses:      See code.
2489 //   States:    x
2490 //   Return:    Error number in standard or SIO form (0 on success).
2491 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
2492 //              * State information as per parent.
2493 //
2494 Int
2495 PAF_ASIT_decodeInit(
2496     const PAF_ASIT_Params *pP, 
2497     const PAF_ASIT_Patchs *pQ, 
2498     PAF_ASIT_Config *pC, 
2499     Int sourceSelect
2502     PAF_AST_Config *pAstCfg;
2503     PAF_AST_DecOpCircBufCtl *pCbCtl;    /* Decoder output circular buffer control */
2504     Int as;                             /* Audio Stream Number (1, 2, etc.) */
2505     Int z;                              /* decode/encode counter */
2506     Int errno;                          /* error number */
2507     Int zI, zS;
2508     Int zMD;
2509     Int zMI;
2510     ASP_Msg* pAspMsg;                   /* Messaging */
2511     Int argIdx;
2512     Int decErrno;
2513     Int status;
2514 #ifdef NON_CACHE_STATUS
2515     Int8 tempVar8;
2516 #endif
2517     
2518     pAstCfg = pC->pAstCfg; // get pointer to common (shared) configuration
2519     as = pAstCfg->as;
2520     zMD = pAstCfg->masterDec;
2521     zMI = pP->zone.master;
2522     (void)as;  // clear compiler warning in case not used with tracing disabled
2523     
2524     pCbCtl = &pC->pAspmCfg->decOpCircBufCtl; // get pointer to circular buffer control
2526 #ifdef NON_CACHE_STATUS
2527     // reset frameCount
2528     for (z=DECODE1; z < DECODEN; z++)
2529     {
2530         statusOp_read(&tempVar8,
2531                       &(pAstCfg->xDec[z].decodeStatus.mode),
2532                       sizeof(tempVar8),
2533                       GATEMP_INDEX_DEC);
2534         if (tempVar8)
2535         {
2536             tempVar8 = 0;
2537             statusOp_write(&(pAstCfg->xDec[z].decodeStatus.frameCount),
2538                           &tempVar8,
2539                           sizeof(tempVar8),
2540                           GATEMP_INDEX_DEC);
2541         }
2542     }
2544     for (z=DECODE1; z < DECODEN; z++) 
2545     {
2546         zI = pP->inputsFromDecodes[z];
2547         zS = pP->streamsFromDecodes[z];
2548         (void)zS; // clear compiler warning in case not used with tracing disabled
2549         statusOp_read(&tempVar8,
2550                       &(pAstCfg->xDec[z].decodeStatus.mode),
2551                       sizeof(tempVar8),
2552                       GATEMP_INDEX_DEC);
2553         if (pAstCfg->xInp[zI].hRxSio && tempVar8)
2554         {
2555 #else
2556     // reset frameCount
2557     for (z=DECODE1; z < DECODEN; z++)
2558     {
2559         if (pAstCfg->xDec[z].decodeStatus.mode)
2560         {
2561             pAstCfg->xDec[z].decodeStatus.frameCount = 0;
2562         }
2563     }
2565     for (z=DECODE1; z < DECODEN; z++)
2566     {
2567         zI = pP->inputsFromDecodes[z];
2568         zS = pP->streamsFromDecodes[z];
2569         (void)zS; // clear compiler warning in case not used with tracing disabled
2570         if (pAstCfg->xInp[zI].hRxSio && pAstCfg->xDec[z].decodeStatus.mode)
2571         {
2572 #endif
2573             Uns gear;
2574             Int frameLength;
2575             TRACE_VERBOSE1("AS%d: PAF_ASIT_decodeInit: initializing decode", as+zS);
2577             // write back Dec configuration
2578             Cache_wb(&pAstCfg->xDec[z], sizeof(PAF_AST_Decode), Cache_Type_ALLD, 0);
2579             Cache_wait();
2581             // FL: send dec activate message to slave
2582             pAspMsg = (ASP_Msg *)MessageQ_alloc(hAspMsgMaster->heapId, hAspMsgMaster->msgSize);  /* allocate message */
2583             if (pAspMsg == NULL)
2584             {
2585                 TRACE_TERSE0("MessageQ_alloc() failure.");
2586                 SW_BREAKPOINT; // temporary
2587                 return -1; // temporary
2588             }
2589             MessageQ_setReplyQueue(hAspMsgMaster->masterQue, (MessageQ_Msg)pAspMsg);            /* set the return address in the message header */
2590             pAspMsg->cmd = ASP_SLAVE_DEC_ACTIVATE;                                              /* fill in message payload */
2591             pAspMsg->procId = hAspMsgMaster->masterProcId;
2592             pAspMsg->expectResp = TRUE;
2593             pAspMsg->messageId = hAspMsgMaster->messageId & ~(1<<31);
2594             argIdx = 0; // set decIdx (zone index)
2595             *(Int32 *)&pAspMsg->buf[argIdx] = z;
2596             TRACE_MSG3("Tx ASP message: procId=%d, cmd=%d, messageId=0x%04x", pAspMsg->procId, pAspMsg->cmd, pAspMsg->messageId);
2597             TRACE_MSG1("decIdx=%d", pAspMsg->buf[0]);
2598             status = MessageQ_put(hAspMsgMaster->slaveQue, (MessageQ_Msg)pAspMsg);                       /* send message */
2599             if (status != MessageQ_S_SUCCESS)
2600             {
2601                 SW_BREAKPOINT;
2602             }
2603             // wait for dec activate complete message from slave
2604             status = MessageQ_get(hAspMsgMaster->masterQue, (MessageQ_Msg *)&pAspMsg, MessageQ_FOREVER);
2605             if (status != MessageQ_S_SUCCESS)
2606             {
2607                 TRACE_TERSE0("MessageQ_get() failure.");
2608                 SW_BREAKPOINT; // temporary
2609                 return -1; // temporary
2610             }
2611             if ((pAspMsg->procId != hAspMsgMaster->slaveProcId) || 
2612                 (pAspMsg->cmd != ASP_MASTER_DEC_ACTIVATE_DONE) ||
2613                 (pAspMsg->messageId != (hAspMsgMaster->messageId | ((UInt32)1<<31))))
2614             {
2615                 TRACE_TERSE3("ERROR: Rx ASP message: procId=%d, cmd=%d, messageId=0x%04x", pAspMsg->procId, pAspMsg->cmd, pAspMsg->messageId);
2616                 SW_BREAKPOINT; // temporary
2617                 return -1; // temporary
2618             }      
2619             hAspMsgMaster->messageId = (hAspMsgMaster->messageId + 1) & ~(1<<31);
2620             TRACE_MSG3("Rx ASP message: procId=%d, cmd=%d, messageId=0x%04x", pAspMsg->procId, pAspMsg->cmd, pAspMsg->messageId);
2621             // free the message
2622             status = MessageQ_free((MessageQ_Msg)pAspMsg); /* free the message */
2623             if (status != MessageQ_S_SUCCESS)
2624             {
2625                 SW_BREAKPOINT;
2626             }
2627             
2628 #if 0 // FL: decoder activate call, slave
2629             if (decAlg[z]->fxns->algActivate)
2630                 decAlg[z]->fxns->algActivate (decAlg[z]);
2631 #endif
2633             // FL: send dec reset message to slave
2634             pAspMsg = (ASP_Msg *)MessageQ_alloc(hAspMsgMaster->heapId, hAspMsgMaster->msgSize);  /* allocate message */
2635             if (pAspMsg == NULL)
2636             {
2637                 TRACE_TERSE0("MessageQ_alloc() failure.");
2638                 SW_BREAKPOINT; // temporary
2639                 return -1; // temporary
2640             }
2641             MessageQ_setReplyQueue(hAspMsgMaster->masterQue, (MessageQ_Msg)pAspMsg);            /* set the return address in the message header */
2642             pAspMsg->cmd = ASP_SLAVE_DEC_RESET;                                                 /* fill in message payload */
2643             pAspMsg->procId = hAspMsgMaster->masterProcId;
2644             pAspMsg->expectResp = TRUE;
2645             pAspMsg->messageId = hAspMsgMaster->messageId & ~(1<<31);
2646             argIdx = 0; // set decIdx
2647             *(Int32 *)&pAspMsg->buf[argIdx] = z;
2648             TRACE_MSG3("Tx ASP message: procId=%d, cmd=%d, messageId=0x%04x", pAspMsg->procId, pAspMsg->cmd, pAspMsg->messageId);
2649             TRACE_MSG1("decIdx=%d", pAspMsg->buf[0]);
2650             // wait for dec reset complete message from slave
2651             status = MessageQ_put(hAspMsgMaster->slaveQue, (MessageQ_Msg)pAspMsg);              /* send message */
2652             if (status != MessageQ_S_SUCCESS)
2653             {
2654                 SW_BREAKPOINT;
2655             }
2656             status = MessageQ_get(hAspMsgMaster->masterQue, (MessageQ_Msg *)&pAspMsg, MessageQ_FOREVER);
2657             if (status != MessageQ_S_SUCCESS)
2658             {
2659                 TRACE_TERSE0("MessageQ_get() failure.");
2660                 SW_BREAKPOINT; // temporary
2661                 return -1; // temporary
2662             }
2663             if ((pAspMsg->procId == hAspMsgMaster->slaveProcId) &&
2664                 (pAspMsg->cmd == ASP_MASTER_DEC_RESET_DONE) && 
2665                 (pAspMsg->messageId == (hAspMsgMaster->messageId | ((UInt32)1<<31))))
2666             {
2667                 hAspMsgMaster->messageId = (hAspMsgMaster->messageId + 1) & ~(1<<31);
2668                 TRACE_MSG3("Rx ASP message: procId=%d, cmd=%d, messageId=0x%04x", pAspMsg->procId, pAspMsg->cmd, pAspMsg->messageId);
2669                 TRACE_MSG1("decErrno=%d", pAspMsg->buf[0]);
2671                 argIdx = 0; // get decErrno
2672                 decErrno = *(Int32 *)&pAspMsg->buf[argIdx];
2673                 if (decErrno != 0)
2674                 {
2675                     return decErrno;
2676                 }
2677             }
2678             else
2679             {
2680                 TRACE_TERSE3("ERROR: Rx ASP message: procId=%d, cmd=%d, messageId=0x%04x", pAspMsg->procId, pAspMsg->cmd, pAspMsg->messageId);
2681                 SW_BREAKPOINT; // temporary
2682                 return -1; // temporary
2683             }
2684             // free the message
2685             status = MessageQ_free((MessageQ_Msg)pAspMsg); /* free the message */
2686             if (status != MessageQ_S_SUCCESS)
2687             {
2688                 SW_BREAKPOINT;
2689             }
2691             // (***) FL: revisit
2692             // invalidate Dec configuration
2693             Cache_inv(&pAstCfg->xDec[z], sizeof(PAF_AST_Decode), Cache_Type_ALLD, 0);
2694             Cache_wait();
2695             
2696 #if 0 // FL: decoder reset call, slave
2697             if (dec->fxns->reset
2698                 && (errno = dec->fxns->reset (dec, NULL,
2699                                               &pC->xDec[z].decodeControl, &pC->xDec[z].decodeStatus)))
2700                 return errno;
2701 #endif
2702             
2703 #ifdef NON_CACHE_STATUS
2704             gear = 0;  // due to size difference
2705             statusOp_read(&gear,
2706                           &(pAstCfg->xDec[z].decodeStatus.aspGearControl),
2707                           sizeof(Int8),
2708                           GATEMP_INDEX_DEC);
2709             tempVar8 = gear < GEARS ? gear : 0;
2710             statusOp_write(&(pAstCfg->xDec[z].decodeStatus.aspGearStatus),
2711                            &tempVar8,
2712                            sizeof(tempVar8),
2713                            GATEMP_INDEX_DEC);
2714 #else
2715             gear = pAstCfg->xDec[z].decodeStatus.aspGearControl;
2716             pAstCfg->xDec[z].decodeStatus.aspGearStatus = gear < GEARS ? gear : 0;
2717 #endif
2718             
2719 #if 0 // FL: change handle to decIdx (zone index)
2720             frameLength = pP->fxns->computeFrameLength(decAlg[z], 
2721                 FRAMELENGTH,
2722                 pC->xDec[z].decodeStatus.bufferRatio);
2723 #endif
2724 #if 0 // (***) FL: revisit. Bypass computeFrameLength().
2725             frameLength = pP->fxns->computeFrameLength(z, 
2726                 FRAMELENGTH, 
2727                 pC->xDec[z].decodeStatus.bufferRatio);
2728 #else
2729             if (sourceSelect == PAF_SOURCE_PCM)
2730             {
2731                 frameLength = 256;
2732             }
2733             else if ((sourceSelect == PAF_SOURCE_DDP) || (sourceSelect == PAF_SOURCE_AC3))
2734             {
2735                 frameLength = 1536;
2736             }
2737             else if (sourceSelect == PAF_SOURCE_THD)
2738             {
2739                 frameLength = 1536; //QIN FIX ME
2740             }
2741             else
2742             {
2743                 frameLength = 256;
2744             }
2745 #endif    
2746             
2747             pAstCfg->xDec[z].decodeControl.frameLength = frameLength;
2748             pAstCfg->xDec[z].decodeInStruct.sampleCount = frameLength;
2749             pAstCfg->xDec[z].decodeControl.sampleRate = PAF_SAMPLERATE_UNKNOWN;
2750             
2751             // (***) FL: revisit. Count samples for DDP.
2752             // Add framework frame length and running sample count to decoder control.
2753             //pC->xDec[z].decodeControl.pafFrameLength = FRAMELENGTH;
2754             //pC->xDec[z].decodeControl.rdSampleCount = 0;
2756             // Initialize decoder output circular buffer for selected source
2757             errno = cbInitSourceSel(pCbCtl, z, sourceSelect, frameLength, FRAMELENGTH, 0);
2758             if (errno)
2759             {
2760                 SW_BREAKPOINT; // FL: debug
2761                 return errno;
2762             }
2763             // FL: debug
2764             cbLog(pCbCtl, z, 1, "PAF_ASIT_decodeInit:cbInitSourceSel");
2765             
2766             if (z != zMD) 
2767             {
2768                 if (errno = SIO_idle(pAstCfg->xInp[zI].hRxSio))
2769                 {
2770                     return errno;
2771                 }
2772             }
2774 #ifdef NON_CACHE_STATUS
2775             statusOp_read(&tempVar8,
2776                           &(pAstCfg->xDec[z].decodeStatus.sourceSelect),
2777                           sizeof(Int8),
2778                           GATEMP_INDEX_DEC);
2779             if (errno = SIO_ctrl(pAstCfg->xInp[zI].hRxSio, PAF_SIO_CONTROL_SET_SOURCESELECT,
2780                 DECSIOMAP(tempVar8)))
2781             {
2782                 return errno;
2783             }
2784 #else
2785             if (errno = SIO_ctrl(pAstCfg->xInp[zI].hRxSio, PAF_SIO_CONTROL_SET_SOURCESELECT,
2786                 DECSIOMAP(pAstCfg->xDec[z].decodeStatus.sourceSelect)))
2787             {
2788                 return errno;
2789             }
2790 #endif
2791             if (errno = SIO_ctrl(pAstCfg->xInp[zI].hRxSio, PAF_SIO_CONTROL_SET_PCMFRAMELENGTH, 
2792                 frameLength))
2793             {
2794                 return errno;
2795             }
2796             if (errno = pP->fxns->updateInputStatus(pAstCfg->xInp[zI].hRxSio, &pAstCfg->xInp[zI].inpBufStatus, 
2797                 &pAstCfg->xInp[zI].inpBufConfig))
2798             {
2799                 return errno;
2800             }
2801         }
2802     }
2804     if (pAstCfg->xInp[zMI].hRxSio) 
2805     {
2806         errno = SIO_issue(pAstCfg->xInp[zMI].hRxSio, &pAstCfg->xInp[zMI].inpBufConfig,
2807             sizeof(pAstCfg->xInp[zMI].inpBufConfig), PAF_SIO_REQUEST_NEWFRAME);
2808         if (errno)
2809         {
2810             return errno;
2811         }
2812     }
2814     return 0;
2815 } //PAF_AST_decodeInit
2817 // -----------------------------------------------------------------------------
2818 // ASIT Decoding Function - Info Processing, Common
2819 //
2820 //   Name:      PAF_ASIT_decodeInfo
2821 //   Purpose:   Decoding Function for processing information in a manner that
2822 //              is common for both initial and subsequent frames of input data.
2823 //   From:      AST Parameter Function -> decodeProcessing
2824 //   Uses:      See code.
2825 //   States:    x
2826 //   Return:    Error number in standard form (0 on success).
2827 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
2828 //              * State information as per parent.
2829 //
2830 Int
2831 PAF_ASIT_decodeInfo(
2832     const PAF_ASIT_Params *pP, 
2833     const PAF_ASIT_Patchs *pQ, 
2834     PAF_ASIT_Config *pC, 
2835     Int frame, 
2836     Int block
2839     PAF_AST_Config *pAstCfg;
2840     Int as;                    /* Audio Stream Number (1, 2, etc.) */
2841     Int z;                     /* input/decode/stream counter */
2842     Int errno;                 /* error number */
2843     Int sioErr;                /* error number, SIO */
2844     Int zD, zI, zS, zX;
2845     Int zMD;
2846     Int zMI;
2847     Int zMS;
2848     UInt32 curTime;
2849     ASP_Msg *pAspMsg;          /* Messaging */
2850     Int argIdx;
2851     Int status;
2852 #ifdef NON_CACHE_STATUS
2853     Int8 tempVar8;
2854     Int tempVar;
2855 #endif
2856     // FL: revisit
2857     //Int size;
2858     //PAF_InpBufConfig *pIpBufConfig;
2860     pAstCfg = pC->pAstCfg; // get pointer to common (shared) configuration
2861     as = pAstCfg->as;
2862     zMD = pAstCfg->masterDec;
2863     zMS = pAstCfg->masterStr;
2864     zMI = pP->zone.master;
2865     (void)zMS;  (void)as;  // clear compiler warning in case not used with tracing disabled
2866     
2867     // Set decode control: sample rate, emphasis
2868     for (z=INPUT1; z < INPUTN; z++)
2869     {
2870         zD = z;
2871         for (zX = DECODE1; zX < DECODEN; zX++) 
2872         {
2873             if (pP->inputsFromDecodes[zX] == z) 
2874             {
2875                 zD = zX;
2876                 break;
2877             }
2878         }
2880         if (pAstCfg->xInp[z].hRxSio) 
2881         {
2882             //determine associated decoder
2883             if (pAstCfg->xInp[z].inpBufStatus.sampleRateStatus != 
2884                 pAstCfg->xDec[zD].decodeControl.sampleRate) 
2885             {
2886                 if (pAstCfg->xDec[zD].decodeControl.sampleRate == PAF_SAMPLERATE_UNKNOWN) 
2887                 {
2888                     pAstCfg->xDec[zD].decodeControl.sampleRate = 
2889                         pAstCfg->xInp[z].inpBufStatus.sampleRateStatus;
2890                 }
2891                 else
2892                 {
2893                     TRACE_TERSE1("AS%d: return error ASPERR_INFO_RATECHANGE", as+pAstCfg->masterStr);
2894                     TRACE_TERSE2("inpBufStatus.sampleRateStatus: 0x%x, decodeControl.sampleRate: 0x%x",
2895