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