PASDK-516:Add ASOT event creation
[processor-sdk/performance-audio-sr.git] / pasdk / test_dsp / framework / audioStreamOutProc.c
2 /*
3 Copyright (c) 2017, Texas Instruments Incorporated - http://www.ti.com/
4 All rights reserved.
6 * Redistribution and use in source and binary forms, with or without 
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 *
13 * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the
16 * distribution.
17 *
18 * Neither the name of Texas Instruments Incorporated nor the names of
19 * its contributors may be used to endorse or promote products derived
20 * from this software without specific prior written permission.
21 *
22 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
23 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
24 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
25 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
26 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
27 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
28 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
29 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
30 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
31 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
32 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33 *
34 */
36 /*
37  *  ======== audioStreamOutProc.c ========
38  */
40 #include <string.h> // for memset
41 #include <xdc/runtime/Log.h>
42 #include <xdc/runtime/Error.h>
43 #include <xdc/runtime/Memory.h>
44 #include <ti/sysbios/knl/Clock.h>
45 #include <ti/sysbios/knl/Task.h>
47 #include "paferr.h"
48 #include <acp_mds.h>
49 #include <pcm.h>
50 #include <pce.h>
51 #include <pafsio_ialg.h>
52 #include <stdasp.h>
53 #include <doberr.h>
54 #include "asperr.h"
56 #include "common.h"
57 #include "aspMsg_common.h"
58 #include "aspMsg_master.h"
59 #include "aspDecOpCircBuf_master.h"
60 #include "aspOutInitSync_master.h"
61 #include "audioStreamProc_common.h"
62 #include "audioStreamOutProc.h"
64 #include "pfp/pfp.h"
65 #include "pfp_app.h"        /* contains all PFP ID's */
66 Int32 gNumPfpAsot1=0; // debug
68 // FL: debug
69 #include "evmc66x_gpio_dbg.h"
70 #include "dbgCapAf.h"
72 #include "ioConfig.h"
74 // -----------------------------------------------------------------------------
75 // Debugging Trace Control, local to this file.
76 // 
77 #include "logp.h"
79 #define TRACE_TIME(a)
81 // Allow a developer to selectively enable tracing.
82 #define CURRENT_TRACE_MASK      0x07
84 #define TRACE_MASK_TERSE        0x01   // only flag errors and show init
85 #define TRACE_MASK_GENERAL      0x02   // half dozen lines per frame
86 #define TRACE_MASK_VERBOSE      0x04   // trace full operation
88 #if !(CURRENT_TRACE_MASK & TRACE_MASK_TERSE)
89     #undef  TRACE_TERSE0
90     #undef  TRACE_TERSE1
91     #undef  TRACE_TERSE2
92     #undef  TRACE_TERSE3
93     #undef  TRACE_TERSE4
94     #define TRACE_TERSE0(a)
95     #define TRACE_TERSE1(a,b)
96     #define TRACE_TERSE2(a,b,c)
97     #define TRACE_TERSE3(a,b,c,d)
98     #define TRACE_TERSE4(a,b,c,d,e)
99 #endif
100     
101 #if !(CURRENT_TRACE_MASK & TRACE_MASK_GENERAL)
102     #undef  TRACE_GEN0
103     #undef  TRACE_GEN1
104     #undef  TRACE_GEN2
105     #undef  TRACE_GEN3
106     #undef  TRACE_GEN4
107     #define TRACE_GEN0(a)
108     #define TRACE_GEN1(a,b)
109     #define TRACE_GEN2(a,b,c)
110     #define TRACE_GEN3(a,b,c,d)
111     #define TRACE_GEN4(a,b,c,d,e)
112 #endif
114 #if !(CURRENT_TRACE_MASK & TRACE_MASK_VERBOSE)
115     #undef  TRACE_VERBOSE0
116     #undef  TRACE_VERBOSE1
117     #undef  TRACE_VERBOSE2
118     #undef  TRACE_VERBOSE3
119     #undef  TRACE_VERBOSE4
120     #define TRACE_VERBOSE0(a)
121     #define TRACE_VERBOSE1(a,b)
122     #define TRACE_VERBOSE2(a,b,c)
123     #define TRACE_VERBOSE3(a,b,c,d)
124     #define TRACE_VERBOSE4(a,b,c,d,e)
125 #endif
127 // .............................................................................
129 //
130 // Audio Stream Definitions
131 //
133 //
134 // Audio Stream Processing Definitions
135 //
136 #define aspLinkInit pQ->i_aspLinkInit
138 //
139 // Encoder Definitions
140 //
141 #define encLinkInit pQ->i_encLinkInit
143 //
144 // Output Definitions
145 //
146 #define outLinkInit pP->i_outLinkInit
148 /* ---------------------------------------------------------------- */
149 /*              Parameter macro definitions end here.               */
150 /* ---------------------------------------------------------------- */
152 //
153 // Standardized Definitions
154 //
156 #define ENC_Handle PCE_Handle /* works for all: PCE */
158 #define __TASK_NAME__  "TaskAsop"
161 //
162 // Audio Stream Output Task definitions
163 //
165 // status codes
166 // Output FSM
167 #define ASOP_INITSYNC_NOTREADY      (  1 )  // ok, init-sync not ready
168 #define ASOP_SOK                    (  0 )  // ok
169 #define ASOP_FORWARD_ERR            ( -1 )  // forward (ASIT) error
170 #define ASOP_ENCRESET_ERR           ( -2 )  // enc reset error
171 #define ASOP_DECINFO1_ERR           ( -3 )  // dec info1 error
172 // Decode Processing
173 #define ASOP_DP_OUT_SIO_UPDATE      (  3 )  // new output selected
174 #define ASOP_DP_CB_DRAINED          (  2 )  // circular buffer drained
175 #define ASOP_DP_SOK                 (  0 )  // ok
176 #define ASOP_DP_FORWARD_ERR         ( -1 )  // forward (ASIT) error
177 #define ASOP_DP_DECINIT_ERR         ( -2 )  // decode init error
178 #define ASOP_DP_DECSTREAM_ERR       ( -3 )  // decode stream error
179 #define ASOP_DP_DECENC_ERR          ( -4 )  // decode encode error
180 #define ASOP_DP_DECINFO2_ERR        ( -5 )  // decode encode error
181 #define ASOP_DP_DECFINALTEST_ERR    ( -6 )  // decode final error
184 /* Check if at least one output selected */
185 static Int checkOutSel(
186     const PAF_ASOT_Params *pP, 
187     PAF_ASOT_Config *pAsotCfg,
188     Int *pOutSel
189 );
191 /* Check if at least one output sio changed */
192 static Int checkOutSio(
193     const PAF_ASOT_Params *pP, 
194     PAF_ASOT_Config *pAsotCfg,
195     Int *pOutSioUpdate
196 );
198 // Initialize Output Processing state function
199 //static Int PAF_ASOT_initOutProc(
200 // used by new OutProc.c, will be changed back to static once refactoring is done
201 Int PAF_ASOT_initOutProc(
202     const PAF_ASOT_Params *pP, 
203     PAF_AST_Stream *xStr
204 );
206 // Initialize Output Processing state function
207 // used by new OutProc.c, will be changed back to static once refactoring is done
208 Int PAF_ASOT_initSyncDecReset(
209     const PAF_ASOT_Params *pP, 
210     const PAF_ASOT_Patchs *pQ, 
211     PAF_ASOT_Config *pAsotCfg,
212     PAF_AudioFrame *pDecResetAf
213 );
215 //   Purpose:   ASOT Function for Output reset
216 static Int PAF_ASOT_outputReset(
217     const PAF_ASOT_Params *pP, 
218     const PAF_ASOT_Patchs *pQ, 
219     PAF_ASOT_Config *pAsotCfg
220 );
222 //   Purpose:   Init-Sync Dec Info1 state function.
223 //              Performes Dec Info1 Init-Sync.
224 Int PAF_ASOT_initSyncDecInfo1(
225     const PAF_ASOT_Params *pP, 
226     const PAF_ASOT_Patchs *pQ, 
227     PAF_ASOT_Config *pAsotCfg,
228     PAF_AudioFrame *pDecInfo1Af
229 );
231 //   Purpose:   ASOT function for ASP chain reset and ENC info
232 static Int PAF_ASOT_outputInfo1(
233     const PAF_ASOT_Params *pP, 
234     const PAF_ASOT_Patchs *pQ, 
235     PAF_ASOT_Config *pAsotCfg
236 );
238 //   Purpose:   Init-Sync Dec Decode1 state function.
239 //              Performes Dec Decode1 Init-Sync.
240 Int PAF_ASOT_initSyncDecDecode1(
241     const PAF_ASOT_Params *pP, 
242     const PAF_ASOT_Patchs *pQ, 
243     PAF_ASOT_Config *pAsotCfg
244 );
246 //   Purpose:   Init-Sync Re-Sync state function.
247 //              Peformed Init-Sync using stored Dec Reset/Info1 AFs.
248 Int PAF_ASOT_initSyncResync(
249     const PAF_ASOT_Params *pP, 
250     const PAF_ASOT_Patchs *pQ, 
251     PAF_ASOT_Config *pAsotCfg,
252     PAF_AudioFrame *pDecResetAf,
253     PAF_AudioFrame *pDecInfo1Af  
254 );
256 #if 0
257 // Init-Sync update audio frame
258 static Int initSyncUpdateAf(
259     PAF_AudioFrame *dstAf, 
260     PAF_AudioFrame *srcAf
261 );
262 #endif
264 // Reset audio frames
265 static Void resetAfs(
266     const PAF_ASOT_Params *pP, 
267     PAF_AST_Stream *xStr
268 );
270 // Reset audio frame pointers to original values
271 static Void resetAfPointers(
272     const PAF_ASOT_Params *pP, 
273     PAF_AST_Stream *xStr
274 );
276 // Reset audio frame meta data elements
277 static Void resetAfMetadata(
278     const PAF_ASOT_Params *pP, 
279     PAF_AST_Stream *xStr
280 );
282 // Create ASOT event
283 static Int asotCreateEvent(void);
286 LINNO_DEFN(TaskAsop); /* Line number macros */
287 ERRNO_DEFN(TaskAsop); /* Error number macros */
289 // ASOT configuration
290 #pragma DATA_SECTION(gPAF_ASOT_config, ".globalSectionPafAsotConfig")
291 PAF_ASOT_Config gPAF_ASOT_config = {
292     NULL,               // taskHandle
293     0,                  // asotState
294     NULL,               // acp
295     0,0,0,              // cbDrainedFlag (size DECODE_MAXN)
296     &gPAF_ASPM_config,  // pAspmCfg
297     &gPAF_AST_config    // pAstCfg
298 };
300 /* Event handle for Tx - to put in structure */
301 Event_Handle asopEvt;
303 // Underflow threshold before circular buffer reset and return error to Top-Level FSM
304 #define DEC_OP_CB_RDAF_UND_THR  ( 80 ) // FL: arbitrary setting
305 UInt32 gCbReadAfErr         =0; // read circular buffer error count, not including underflows
306 UInt32 gDecOpCbRdAfUnd      =0; // decoder output circular buffer underflow count
307 UInt32 gMaxDecOpCbRdAfUnd   =0; // max (consecutive) decoder output circular buffer underflow count
308 UInt32 gMasterCbResetCnt    =0; // master circular buffer reset count
310 // For writeDECCommandRestart
311 extern volatile UInt32 gCommandOutputTask_SYNC;
312 extern volatile UInt32 gCommandOutputTask_ACK;
314 // Global debug counters */
315 UInt32 gAsopTxSioReclaimCnt         =0;
316 UInt32 gAsopInitOutProcCnt          =0;
317 UInt32 gAsopInitSyncDecResetCnt     =0;
318 UInt32 gAsopInitSyncDecInfo1Cnt     =0;
319 UInt32 gAsopInitSyncDecDecode1Cnt   =0;
320 UInt32 gAsopInitSyncResyncCnt       =0;
321 UInt32 gAsopOutProcCnt              =0;
322 UInt32 gAsopInitCnt                 =0;
323 UInt32 gAsopStreamCnt               =0;
324 UInt32 gAsopEncodeCnt               =0;
325 UInt32 gAsopFinalCnt                =0;
326 UInt32 gAsopOutSioUpdateCnt         =0;
327 UInt32 gAsopQuitCnt                 =0;
329 /*
330  *  ======== taskAsopFxnInit ========
331  *  Audio Stream Output Processing initialization function
332  */
333 Void taskAsopFxnInit(
334     const PAF_ASOT_Params *pP,
335     const PAF_ASOT_Patchs *pQ
338     PAF_ASOT_Config *pAsotCfg;      /* ASOT configuration pointer */
339     PAF_AST_Config *pAstCfg;        /* Common (shared) configuration pointer */
340     Int as;                         /* Audio Stream Number (1, 2, etc.) */
341     Int z;                          /* input/encode/stream/decode/output counter */
342     Int i;                          /* phase */
343     Int zMS;
344     Int status;
346     Log_info0("Enter taskAsopFxnInit()");
348     //
349     // Audio Stream Output Task Parameters & Patch (*pP, *pQ)
350     //
351     if (!pP)
352     {
353         TRACE_TERSE0("TaskAsop: No Parameters defined. Exiting.");
354         LINNO_RPRT(TaskAsop, -1);
355         return;
356     }
358     if (!pQ)
359     {
360         TRACE_TERSE0("TaskAsop: No Patchs defined. Exiting.");
361         LINNO_RPRT(TaskAsop, -1);
362         return;
363     }
365     //
366     // Audio Stream Output Task Configuration (*pAsotCfg):
367     //
368     pAsotCfg = &gPAF_ASOT_config;       // initialize pointer to task configuration
369     pAsotCfg->taskHandle = Task_self(); // set task handle
370     pAstCfg = pAsotCfg->pAstCfg;        // get pointer to AST common (shared) configuration
372     // Create ASIT event
373     status = asotCreateEvent();
374     if (status < 0)
375     {
376         TRACE_TERSE0("TaskAsop: unable to initialize event. Exiting.");
377         return;
378     }
379     
380     /* Obtain Audio Stream Number (1, 2, etc.) */
381     as = pAstCfg->as;
382     TRACE_TERSE1("TaskAsop: Started with AS%d.", as);
384     //
385     // Initialize message log trace and line number reporting
386     //
387     for (z=STREAM1; z < STREAMN; z++)
388     {
389         TRACE_TERSE1("TaskAsop: AS%d: initiated", as+z);
390     }
391     LINNO_RPRT(TaskAsop, -1);
393     //
394     // Determine stream index
395     //
396     zMS = pAstCfg->masterStr;
398     // Initialize as per parametrized phases:
399     //
400     //   In standard form these are:
401     //      - Malloc: Memory Allocation
402     //      - Config: Configuration Initialization
403     //      - AcpAlg: ACP Algorithm Initialization and Local Attachment
404     //      - Common: Common Memory Initialization
405     //      - AlgKey: Dec/Enc chain to Array Initialization
406     //      - Device: I/O Device Initialization
407     //      - Unused: (available)
408     //      - Unused: (available)
409     //
410     LINNO_RPRT(TaskAsop, -2);
411     for (i=0; i < lengthof(pP->fxns->initPhase); i++)
412     {
413         Int linno;
414         if (pP->fxns->initPhase[i])
415         {
416             linno = pP->fxns->initPhase[i](pP, pQ, pAsotCfg);
417             if (linno)
418             {
419                 LINNO_RPRT(TaskAsop, linno);
420                 return;
421             }
422         }
423         else
424         {
425             TRACE_TERSE1("TaskAsop: AS%d: initialization phase - null", as+zMS);
426         }
427         TRACE_TERSE2("TaskAsop: AS%d: initialization phase - %d completed", as+zMS, i);
428         LINNO_RPRT(TaskAsop, -i-3);
429     }
431     //
432     // End of Initialization -- display memory usage report.
433     //
434     if (pP->fxns->memStatusPrint)
435     {
436         pP->fxns->memStatusPrint("ASOT MEMSTAT REPORT",
437             HEAP_INTERNAL, HEAP_INTERNAL1, HEAP_EXTERNAL,
438             HEAP_INTERNAL1_SHM, HEAP_EXTERNAL_SHM, HEAP_EXTERNAL_NONCACHED_SHM);
439     }
440 } /* taskAsopFxnInit */
442 /*
443  *  ========asotCreateEvent ========
444  *  Create ASOT event
445  */
446 static Int asotCreateEvent(void)
448     Error_Block eb;
449     
450     Error_init(&eb);
451     
452     // Default instance configuration params
453     asopEvt = Event_create(NULL, &eb);
454     if (asopEvt == NULL) 
455     {
456         return -1; // error code
457     }
458     
459     return 0;
460 } /* asotCreateEvent */
462 /*
463  *  ======== taskAsopFxn ========
464  *  Audio Stream Output Processing task function
465  */
466 #ifdef PASDK_SIO_DEV
467 Void taskAsopFxn(
468 #else
469 #ifndef IO_LOOPBACK_TEST
470 Void taskAsopFxn_NOt_Used(
471 #else
472 Void taskAsopFxn_Not_Used(
473 #endif
474 #endif
475     const PAF_ASOT_Params *pP,
476     const PAF_ASOT_Patchs *pQ
479     PAF_ASOT_Config *pAsotCfg;      /* ASOT configuration pointer */
480     PAF_AST_Config *pAstCfg;        /* Common (shared) configuration pointer */
481     Int as;                         /* Audio Stream Number (1, 2, etc.) */
482     Int z;                          /* input/encode/stream/decode/output counter */
483     Int zMS;
484     Int errno;                      // error number
485     Int8 procSleep;                 // whether to sleep: 0: No, 1: Yes
486     Int8 procOutDevSel;             // whether to perform output device selection: 0: No, 1:Yes
487     Int outSel;                     // whether output device selected
488     enum { INIT_OUT_PROC_STATE, 
489            INITSYNC_DEC_RESET_STATE, INITSYNC_DEC_INFO1_STATE, INITSYNC_DEC_DECODE1_STATE, 
490            INITSYNC_RESYNC_STATE, 
491            OUT_PROC_STATE } state;
492     PAF_AudioFrame decResetAf;
493     PAF_AudioFrame decInfo1Af;
494     Int loopCount = 0;              // used to stop trace to see startup behavior.
496     Log_info0("Enter taskAsopFxn()");
498     taskAsopFxnInit(pP, pQ);    // initialization of output task
500     //
501     // Audio Stream Output Task Configuration (*pAsotCfg):
502     //
503     pAsotCfg = &gPAF_ASOT_config;       // initialize pointer to task configuration
504     pAstCfg = pAsotCfg->pAstCfg;        // get pointer to AST common (shared) configuration
506     /* Obtain Audio Stream Number (1, 2, etc.) */    
507     as = pAstCfg->as;
508     
509     zMS = pAstCfg->masterStr;
511     //
512     // Main processing loop
513     //   
514     for (z=STREAM1; z < STREAMN; z++)
515     {
516         TRACE_VERBOSE1("TaskAsop: AS%d: running", as+z);
517     }
518     
519     errno = 0;                      // init error indicator -- no error
520     procSleep = 1;                  // init sleep flag -- sleep
521     procOutDevSel = 1;              // init device output selection flag -- perform output device selection
522     state = INIT_OUT_PROC_STATE;    // init state
523     for (;;)
524     {
525         loopCount++;
526         TRACE_GEN2("TaskAsop (begin Main loop %d) (errno 0x%x)", loopCount, errno);
528         //
529         // Check forward (ASIT) error here, TBD
530         //
531         
532         // Even if we are not in error state, we check if writeDECCommandRestar issued or not
533         if (gCommandOutputTask_SYNC) {
534             TRACE_TERSE0("TaskAsop: ack for writeDECCommandRestart ... Wait for the command deasserted");
535             gCommandOutputTask_ACK = 1;
536             while (gCommandOutputTask_SYNC) {
537                 Task_sleep(1);
538             }
539             TRACE_TERSE0("TaskAsop: ack for writeDECCommandRestart ... Sync-ed! Startover the process");
540             procSleep = 1;                  // init sleep flag -- sleep
541             procOutDevSel = 1;              // init device output selection flag -- perform output device selection
542             state = INIT_OUT_PROC_STATE;    // init state -- starover
543             errno = ASOP_DP_FORWARD_ERR;    // Override the error -- for flushing SIO output device
544         }
545         
546         // any error forces idling of output
547         if (errno) 
548         {
549             for (z=OUTPUT1; z < OUTPUTN; z++)
550             {
551                 if (pAstCfg->xOut[z].hTxSio)
552                 {
553                     SIO_idle(pAstCfg->xOut[z].hTxSio);
554                 }
555             }
556         
557             TRACE_TERSE1("TaskAsop: Trace stopped at loop %d.", loopCount);
558             ERRNO_RPRT(TaskAsop, errno);
559         }
560         
561         if (procSleep == 1)
562         {
563             TRACE_VERBOSE1("TaskAsop: AS%d: ... sleeping ...", as+zMS);
564             Task_sleep(1);
565         }
567         if (procOutDevSel == 1)
568         {
569             // select output devices
570             TRACE_GEN1("TaskAsop: AS%d: Output device selection ...", as+zMS);
571             errno = pP->fxns->selectDevices(pP, pQ, pAsotCfg);
572             if (errno)
573             {
574                 TRACE_TERSE2("TaskAsop: AS%d: selectDevices returned errno = 0x%04x", as+zMS, errno);
576                 procSleep = 1;
577                 procOutDevSel = 1;
579                 continue;
580             }
582             // if no output selected skip remaining processing
583             errno = checkOutSel(pP, pAsotCfg, &outSel);
584             if (errno < 0)
585             {
586                 TRACE_TERSE2("TaskAsop: AS%d: checkOutSel returned errno = 0x%04x", as+zMS, errno);
588                 procSleep = 1;
589                 procOutDevSel = 1;
591                 continue;
592             }
593             else if (!outSel)
594             {
595                 TRACE_VERBOSE1("TaskAsop: AS%d: No output selected...", as+zMS);
597                 procSleep = 1;
598                 procOutDevSel = 1;
599                 
600                 continue;
601             }
602         }
603         
604         switch (state)
605         {
606             case INIT_OUT_PROC_STATE:
607                 gAsopInitOutProcCnt++;
608                 Log_info0("TaskAsop: state=INIT_OUT_PROC_STATE");
609                 
610                 //
611                 // Output Processing initialization.
612                 //
613                 errno = PAF_ASOT_initOutProc(pP, pAstCfg->xStr);
614                 if (errno < 0)
615                 {
616                     state = INIT_OUT_PROC_STATE;
617                     procSleep = 1;
618                     procOutDevSel = 1;
619                 }
620                 else
621                 {
622                     state = INITSYNC_DEC_RESET_STATE;
623                     procSleep = 0;
624                     procOutDevSel = 0;
625                 }
626             
627                 break;
628                 
629             case INITSYNC_DEC_RESET_STATE:
630                 gAsopInitSyncDecResetCnt++;
631                 Log_info0("TaskAsop: state=INITSYNC_DEC_RESET_STATE");
633                 //
634                 // Dec Reset Init-Sync.
635                 //  
636                 
637                 // Perform Dec Reset init-sync.
638                 // Latch Dec Reset AF.
639                 errno = PAF_ASOT_initSyncDecReset(pP, pQ, pAsotCfg, &decResetAf);
640                 if (errno < 0)
641                 {
642                     Log_info1("TaskAsop: state=INITSYNC_DEC_RESET_STATE errno=%d", errno);
644                     // sync error -- start over
645                     state = INIT_OUT_PROC_STATE;
646                     procSleep = 1;
647                     procOutDevSel = 1;
648                 }
649                 else if (errno == ASOP_INITSYNC_NOTREADY)
650                 {
651                     Log_info1("TaskAsop: state=INITSYNC_DEC_RESET_STATE not sync'd errno=%d", errno);
653                     // sync not ready -- try again
654                     state = INITSYNC_DEC_RESET_STATE;
655                     errno=0; // FL: temp hack
656                     procSleep = 1;
657                     procOutDevSel = 1;
658                 }
659                 else // errno==0
660                 {
661                     Log_info1("TaskAsop: state=INITSYNC_DEC_RESET_STATE sync'd, errno=%d", errno);
663                     // sync'd -- move on
664                     state = INITSYNC_DEC_INFO1_STATE;
665                     procSleep = 0;
666                     procOutDevSel = 0;
667                 }
668                 
669                 break;
670             
671             case INITSYNC_DEC_INFO1_STATE:
672                 gAsopInitSyncDecInfo1Cnt++;
673                 Log_info0("TaskAsop: state=INITSYNC_DEC_INFO1_STATE");
674                 
675                 //
676                 // Dec Info1 Init-Sync.
677                 //
679                 // Perform Dec Info1 init-sync.
680                 // Latch Dec Info1 AF.
681                 errno = PAF_ASOT_initSyncDecInfo1(pP, pQ, pAsotCfg, &decInfo1Af);
682                 if (errno < 0)
683                 {
684                     Log_info1("TaskAsop: state=INITSYNC_DEC_INFO1_STATE errno=%d", errno);
685                     
686                     // sync error -- start over
687                     state = INIT_OUT_PROC_STATE;
688                     procSleep = 1;
689                     procOutDevSel = 1;
690                 }
691                 else if (errno == ASOP_INITSYNC_NOTREADY)
692                 {
693                     Log_info1("TaskAsop: state=INITSYNC_DEC_INFO1_STATE not sync'd errno=%d", errno);
695                     // sync not ready -- try again
696                     state = INITSYNC_DEC_INFO1_STATE;
697                     errno=0; // FL: temp hack
698                     procSleep = 1;
699                     procOutDevSel = 0;
700                 }
701                 else // errno = 0
702                 {
703                     Log_info1("TaskAsop: state=INITSYNC_DEC_INFO1_STATE sync'd errno=%d", errno);
705                     // sync'd -- move on
706                     state = INITSYNC_DEC_DECODE1_STATE;
707                     procSleep = 0;
708                     procOutDevSel = 0;
709                 }
710                 
711                 break;
712             
713             case INITSYNC_DEC_DECODE1_STATE:
714                 gAsopInitSyncDecDecode1Cnt++;
715                 Log_info0("TaskAsop: state=INITSYNC_DEC_DECODE1_STATE");
716                 
717                 //
718                 // Dec Info1 Init-Sync.
719                 //
721                 // Perform Dec Info1 init-sync.
722                 // Latch Dec Info1 AF.
723                 errno = PAF_ASOT_initSyncDecDecode1(pP, pQ, pAsotCfg);
724                 if (errno < 0)
725                 {
726                     Log_info1("TaskAsop: state=INITSYNC_DEC_DECODE1_STATE errno=%d", errno);
728                     // sync error -- start over
729                     state = INIT_OUT_PROC_STATE;
730                     procSleep = 1;
731                     procOutDevSel = 1;
732                 }
733                 else if (errno == ASOP_INITSYNC_NOTREADY)
734                 {
735                     Log_info1("TaskAsop: state=INITSYNC_DEC_DECODE1_STATE not sync'd errno=%d", errno);
737                     // sync not ready -- try again
738                     state = INITSYNC_DEC_DECODE1_STATE;
739                     errno=0; // FL: temp hack
740                     procSleep = 1;
741                     procOutDevSel = 0;
742                 }
743                 else // errno = 0
744                 {
745                     Log_info1("TaskAsop: state=INITSYNC_DEC_DECODE1_STATE sync'd errno=%d", errno);
747                     // sync'd -- move on
748                     state = OUT_PROC_STATE;
749                     procSleep = 0;
750                     procOutDevSel = 0;
751                 }
752                 
753                 break;
754             
755             case INITSYNC_RESYNC_STATE:
756                 gAsopInitSyncResyncCnt++;
757                 Log_info0("TaskAsop: state=INITSYNC_RESYNC_STATE");
759                 //
760                 // Re-Sync.
761                 // Use stored AF info from init-sync.
762                 // This is done in case of local error.
763                 //
764                 
765                 // Perform Dec Info1 init-sync.
766                 errno = PAF_ASOT_initSyncResync(pP, pQ, pAsotCfg, &decResetAf, 
767                     &decInfo1Af);
768                 if (errno < 0)
769                 {
770                     Log_info1("TaskAsop: state=INITSYNC_RESYNC_STATE errno=%d", errno);
772                     // sync error -- start over
773                     state = INIT_OUT_PROC_STATE;
774                     procSleep = 1;
775                     procOutDevSel = 1;
776                 }
777                 else
778                 {
779                     Log_info1("TaskAsop: state=INITSYNC_RESYNC_STATE sync'd errno=%d", errno);
781                     // re-sync'd -- move on
782                     state = OUT_PROC_STATE;
783                     procSleep = 0;
784                     procOutDevSel = 0;
785                 }
786                     
787                 break;
788             
789             case OUT_PROC_STATE:        
790                 gAsopOutProcCnt++;
791                 Log_info0("TaskAsop: state=OUT_PROC_STATE");
792                 
793                 //
794                 // Output Processing.
795                 //
797                 TRACE_VERBOSE0("TaskAsop: calling decodeProcessing.");
798                 errno = pP->fxns->decodeProcessing(pP, pQ, pAsotCfg);
799                 if (errno < 0)
800                 {
801                     Log_info1("TaskAsop: state=OUT_PROC_STATE errno=%d", errno);
802                     
803                     //
804                     // Output Processing exit, due to error
805                     //
806                     
807                     TRACE_TERSE1("TaskAsop: decodeProcessing returns 0x%x, continue", errno);
808                     if (errno == ASOP_DP_FORWARD_ERR)
809                     {
810                         // forward (ASIT) error -- start over
811                         state = INIT_OUT_PROC_STATE;
812                         procSleep = 1;
813                         procOutDevSel = 1;
814                     }
815                     else
816                     {
817                         // local (ASOT) error
818                         state = INITSYNC_RESYNC_STATE;    
819                         procSleep = 1;
820                         procOutDevSel = 0; // disallow device re-select if local error during output processing
821                     }        
822                 }
823                 else if (errno > 0)
824                 {
825                     Log_info1("TaskAsop: state=OUT_PROC_STATE errno=%d", errno);
827                     //
828                     // Output Processing exit, not due to error
829                     //
831                     TRACE_TERSE1("TaskAsop: decodeProcessing returns 0x%x, continue", errno);                    
832                     if (errno == ASOP_DP_OUT_SIO_UPDATE)
833                     {
834                         // skip re-sync
835                         // resume output processing after new output selected
836                         state = OUT_PROC_STATE;
837                         procSleep = 1;
838                         procOutDevSel = 1;
839                     }
840                 }
841                 else
842                 {
843                     Log_info1("TaskAsop: state=OUT_PROC_STATE errno=%d", errno);
845                     //
846                     // Output Processing exit, normal
847                     //
848                     
849                     TRACE_VERBOSE0("TaskAsop: outputProcessing complete with no error.");
850                     
851                     // no error returned if CB drained 
852                     // (i.e. CB drained is normal behavior)
853                     state = INIT_OUT_PROC_STATE;
854                     procSleep = 1;
855                     procOutDevSel = 1;
856                 }
857                 
858                 break;
859             
860             default: // unknown state
861                 TRACE_TERSE2("TaskAsop: AS%d: state: unknown, 0x%x", as+zMS, state);
862                 break;
863         }
864     } // End of main processing loop for (;;)
865     
866     //Log_info0("Exit taskAsopFxn()");
869 Int PAF_ASOT_ioCompCreate(PAF_AST_IoOut *pIoOut, int numOut, IHeap_Handle iHeapHandle)
871     int i, j, num_alloc;
872     lib_mem_rec_t   *mem_rec;
873     ioBuffHandle_t  ioBufHandle;
874     ioPhyHandle_t   ioPhyHandle;
875     Error_Block     eb;
877     for(i=0; i<numOut; i++)
878     {
879         // Create an I/O BUFF instance
880         // Obtain number of memory blocks required by I/O BUFF
881         num_alloc = ioBuffNumAlloc();
883         // Obtain requirements of each memory block
884         mem_rec   = (lib_mem_rec_t *)malloc(sizeof(lib_mem_rec_t)*num_alloc);
885         if(ioBuffAlloc(mem_rec) != IOBUFF_NOERR) {
886             return __LINE__;
887         }
889         /* Allocate memory and create I/O BUFF instance */
890         for(j=0; j<num_alloc; j++) {
891             mem_rec[j].base = Memory_calloc(iHeapHandle, mem_rec[j].size,
892                                             (1<<mem_rec[j].alignment), &eb);
893         }
895         if(ioBuffCreate(&ioBufHandle, mem_rec) != IOBUFF_NOERR) {
896             return __LINE__;
897         }
899         pIoOut[i].hIoBuff = ioBufHandle;
901         free(mem_rec);
903         // Create an I/O PHY instance
904         // Obtain number of memory blocks required by I/O PHY
905         num_alloc = ioPhyNumAlloc();
907         // Obtain requirements of each memory block
908         mem_rec   = (lib_mem_rec_t *)malloc(sizeof(lib_mem_rec_t)*num_alloc);
909         if(ioPhyAlloc(mem_rec) != IOBUFF_NOERR) {
910             return __LINE__;
911         }
913         /* Allocate memory and create I/O PHY instance */
914         for(j=0; j<num_alloc; j++) {
915             mem_rec[j].base = Memory_calloc(iHeapHandle, mem_rec[j].size,
916                                             (1<<mem_rec[j].alignment), &eb);
917         }
919         if(ioPhyCreate(&ioPhyHandle, mem_rec) != IOBUFF_NOERR) {
920             return __LINE__;
921         }
923         pIoOut[i].hIoPhy = ioPhyHandle;
925         free(mem_rec);
927     } // end of for loop
929     return 0;
930 } // PAF_ASOT_ioCompCreate
932 // -----------------------------------------------------------------------------
933 // AST Initialization Function - Memory Allocation
934 //
935 //   Name:      PAF_ASOT_initPhaseMalloc
936 //   Purpose:   Audio Stream Output Task Function for initialization of data pointers
937 //              by allocation of memory.
938 //   From:      audioStream1Task or equivalent
939 //   Uses:      See code.
940 //   States:    x
941 //   Return:    0 on success.
942 //              Source code line number on MEM_calloc failure.
943 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
944 //              * State information as per parent.
945 //              * Memory allocation errors.
946 //
948 Int
949 PAF_ASOT_initPhaseMalloc (
950     const PAF_ASOT_Params *pP, 
951     const PAF_ASOT_Patchs *pQ, 
952     PAF_ASOT_Config *pAsotCfg
955     PAF_AST_Config *pAstCfg;
956     Int as;                     /* Audio Stream Number (1, 2, etc.) */
957     Int zMS, errLineNum;
958     Error_Block    eb;
959     //Int i;
961     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
962     as = pAstCfg->as;
963     zMS = pAstCfg->masterStr;
965     TRACE_TERSE1("PAF_ASOT_initPhaseMalloc: AS%d: initialization phase - memory allocation", as+zMS);
967     // Initialize error block
968     Error_init(&eb); 
970     /* Stream memory */
971     if (!(pAstCfg->xStr = Memory_calloc((IHeap_Handle)HEAP_INTERNAL, STREAMN * sizeof (*pAstCfg->xStr), 4, &eb)))
972     {
973         TRACE_TERSE1("PAF_ASOT_initPhaseMalloc: AS%d: Memory_calloc failed", as+zMS);
974         SW_BREAKPOINT;
975         return __LINE__;
976     }
977     TRACE_TERSE3("PAF_ASOT_initPhaseMalloc. (pAstCfg->xStr) %d bytes from space %d at 0x%x.",
978             STREAMN * sizeof (*pAstCfg->xStr),
979             HEAP_ID_INTERNAL, (IArg)pAstCfg->xStr);
981     {
982         Int z;                          /* stream counter */
984         PAF_AudioFrame *fBuf;
986         if (!(fBuf = (PAF_AudioFrame *)Memory_calloc((IHeap_Handle)HEAP_INTERNAL, STREAMS * sizeof (*fBuf), 4, &eb)))
987         {
988             TRACE_TERSE1("PAF_ASOT_initPhaseMalloc: AS%d: Memory_calloc failed", as+zMS);
989             SW_BREAKPOINT;
990             return __LINE__;
991         }
992         TRACE_TERSE3("PAF_ASOT_initPhaseMalloc. (fBuf) %d bytes from space %d at 0x%x.",
993                 STREAMS * sizeof (*fBuf),
994                 HEAP_ID_INTERNAL, (IArg)fBuf);
996         for (z=STREAM1; z < STREAMN; z++)
997         {
998             pAstCfg->xStr[z].pAudioFrame = &fBuf[z-STREAM1];
999             TRACE_TERSE2("pAstCfg->xStr[%d].pAudioFrame = 0x%x", z, (IArg)pAstCfg->xStr[z].pAudioFrame);
1000         }
1001     }
1003     /* Encode memory */
1004     if (!(pAstCfg->xEnc = Memory_calloc((IHeap_Handle)HEAP_INTERNAL, ENCODEN * sizeof (*pAstCfg->xEnc), 4, &eb)))
1005     {
1006         TRACE_TERSE1("PAF_ASOT_initPhaseMalloc: AS%d: Memory_calloc failed", as+zMS);
1007         SW_BREAKPOINT;
1008         return __LINE__;
1009     }
1010     TRACE_TERSE3("PAF_ASOT_initPhaseMalloc. (pAstCfg->xEnc) %d bytes from space %d at 0x%x.",
1011             ENCODEN * sizeof (*pAstCfg->xEnc),
1012             HEAP_ID_INTERNAL, (IArg)pAstCfg->xEnc);
1014     /* Output memory */
1015     if (!(pAstCfg->xOut = Memory_calloc((IHeap_Handle)HEAP_INTERNAL, OUTPUTN * sizeof (*pAstCfg->xOut), 4, &eb)))
1016     {
1017         TRACE_TERSE1("PAF_ASOT_initPhaseMalloc: AS%d: Memory_calloc failed", as+zMS);
1018         SW_BREAKPOINT;
1019         return __LINE__;
1020     }
1021     TRACE_TERSE3("PAF_ASOT_initPhaseMalloc. (pAstCfg->xOut) %d bytes from space %d at 0x%x.",
1022             OUTPUTN * sizeof (*pAstCfg->xOut),
1023             HEAP_ID_INTERNAL, (IArg)pAstCfg->xOut);
1025     /* Output I/O data structure memory */
1026     if (!(pAsotCfg->pIoOut = Memory_calloc((IHeap_Handle)HEAP_INTERNAL, OUTPUTN * sizeof (*pAsotCfg->pIoOut), 4, &eb)))
1027     {
1028         TRACE_TERSE1("PAF_ASOT_initPhaseMalloc: AS%d: Memory_calloc failed", as+zMS);
1029         SW_BREAKPOINT;
1030         return __LINE__;
1031     }
1032     TRACE_TERSE3("PAF_ASOT_initPhaseMalloc. (pAsotCfg->pIoOut) %d bytes from space %d at 0x%x.",
1033                  OUTPUTN * sizeof (*pAsotCfg->pIoOut),
1034                  HEAP_ID_INTERNAL, (IArg)pAsotCfg->pIoOut);
1036     /* I/O components memory for output */
1037     errLineNum = PAF_ASOT_ioCompCreate(pAsotCfg->pIoOut, OUTPUTN, (IHeap_Handle)HEAP_INTERNAL);
1038     if(errLineNum)
1039     {
1040         SW_BREAKPOINT;
1041         return errLineNum;
1042     }
1043     TRACE_TERSE1("PAF_ASOT_initPhaseMalloc: AS%d: initialization phase - memory allocation complete.", as+zMS);
1044     return 0;
1045 } //PAF_ASOT_initPhaseMalloc
1047 // -----------------------------------------------------------------------------
1048 // ASOT Initialization Function - Memory Initialization from Configuration
1049 //
1050 //   Name:      PAF_ASOT_initPhaseConfig
1051 //   Purpose:   Audio Stream Output Task Function for initialization of data values
1052 //              from parameters.
1053 //   From:      audioStream1Task or equivalent
1054 //   Uses:      See code.
1055 //   States:    x
1056 //   Return:    0 on success.
1057 //              Other as per initFrame0 and initFrame1.
1058 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
1059 //              * State information as per parent.
1060 //
1061 Int
1062 PAF_ASOT_initPhaseConfig(
1063     const PAF_ASOT_Params *pP, 
1064     const PAF_ASOT_Patchs *pQ, 
1065     PAF_ASOT_Config *pAsotCfg
1068     PAF_AST_Config *pAstCfg;
1069     Int as;                     /* Audio Stream Number (1, 2, etc.) */
1070     Int z;                      /* input/encode/stream/decode/output counter */
1071     Int zMS;
1073     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
1074     as = pAstCfg->as;
1075     zMS = pAstCfg->masterStr;
1077     TRACE_TERSE1("PAF_ASOT_initPhaseConfig: AS%d: initialization phase - configuration", as+zMS);
1079     //
1080     // Unspecified elements have been initialized to zero during alloc
1081     //
1083     for (z=STREAM1; z < STREAMN; z++) 
1084     {
1085         Int linno;
1086         if (linno = pP->fxns->initFrame0(pP, pQ, pAsotCfg, z))
1087         {
1088             return linno;           
1089         }
1090         if (linno = pP->fxns->initFrame1(pP, pQ, pAsotCfg, z, -1))
1091         {
1092             return linno;
1093         }
1094     }
1096     for (z=ENCODE1; z < ENCODEN; z++) 
1097     {
1098         Int zO = pP->outputsFromEncodes[z];
1099         Int zS = pP->streamsFromEncodes[z];
1100         pAstCfg->xEnc[z].encodeControl.size = sizeof(pAstCfg->xEnc[z].encodeControl);
1101         pAstCfg->xEnc[z].encodeControl.pAudioFrame = pAstCfg->xStr[zS].pAudioFrame;
1102         pAstCfg->xEnc[z].encodeControl.pVolumeStatus = &pAstCfg->xEnc[z].volumeStatus;
1103         pAstCfg->xEnc[z].encodeControl.pOutBufConfig = &pAstCfg->xOut[zO].outBufConfig;
1104         pAstCfg->xEnc[z].encodeStatus = *pP->z_pEncodeStatus[z];
1105         pAstCfg->xEnc[z].encodeControl.encActive = pAstCfg->xEnc[z].encodeStatus.select;
1106         pAstCfg->xEnc[z].volumeStatus = *pP->pVolumeStatus;
1107         pAstCfg->xEnc[z].encodeInStruct.pAudioFrame = pAstCfg->xStr[zS].pAudioFrame;
1108     }
1110     for (z=OUTPUT1; z < OUTPUTN; z++)
1111     {
1112         pAstCfg->xOut[z].outBufStatus = *pP->pOutBufStatus;
1113     }
1115     TRACE_TERSE1("PAF_ASOT_initPhaseConfig: AS%d: initialization phase - configuration complete.", as+zMS);
1116     return 0;
1117 } //PAF_ASOT_initPhaseConfig
1119 // -----------------------------------------------------------------------------
1120 // ASOT Initialization Function - ACP Algorithm Instantiation
1121 //
1122 //   Name:      PAF_ASOT_initPhaseAcpAlg
1123 //   Purpose:   Audio Stream Input Task Function for initialization of ACP by
1124 //              instantiation of the algorithm.
1125 //   From:      audioStream1Task or equivalent
1126 //   Uses:      See code.
1127 //   States:    x
1128 //   Return:    0 on success.
1129 //              Source code line number on ACP Algorithm creation failure.
1130 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
1131 //              * State information as per parent.
1132 //              * Memory allocation errors.
1133 //
1134 Int
1135 PAF_ASOT_initPhaseAcpAlg(
1136     const PAF_ASOT_Params *pP, 
1137     const PAF_ASOT_Patchs *pQ, 
1138     PAF_ASOT_Config *pAsotCfg
1141     PAF_AST_Config *pAstCfg;
1142     Int as;                     /* Audio Stream Number (1, 2, etc.) */
1143     Int z;                      /* input/encode/stream/decode/output counter */
1144     Int betaPrimeOffset;
1145     ACP_Handle acp;
1146     Int zMS;
1147     Int zS, zX;
1149     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
1150     as = pAstCfg->as;
1151     zMS = pAstCfg->masterStr;
1153     TRACE_TERSE1("PAF_ASOT_initPhaseAcpAlg: AS%d: initialization phase - ACP Algorithm", as+zMS);
1155     ACP_MDS_init();
1157     if (!(acp = (ACP_Handle )ACP_MDS_create(NULL))) 
1158     {
1159         TRACE_TERSE1("PAF_ASOT_initPhaseAcpAlg: AS%d: ACP algorithm instance creation  failed", as+zMS);
1160         return __LINE__;
1161     }
1162     pAsotCfg->acp = acp;
1164     ((ALG_Handle)acp)->fxns->algControl((ALG_Handle) acp,
1165         ACP_GETBETAPRIMEOFFSET, (IALG_Status *)&betaPrimeOffset);
1167     for (z=ENCODE1; z < ENCODEN; z++) 
1168     {
1169         zS = pP->streamsFromEncodes[z];
1170         acp->fxns->attach(acp, ACP_SERIES_STD,
1171             STD_BETA_ENCODE + betaPrimeOffset * (as-1+zS),
1172             (IALG_Status *)&pAstCfg->xEnc[z].encodeStatus);
1173         acp->fxns->attach(acp, ACP_SERIES_STD,
1174             STD_BETA_VOLUME + betaPrimeOffset * (as-1+zS),
1175             (IALG_Status *)&pAstCfg->xEnc[z].volumeStatus);
1176         /* Ignore errors, not reported. */
1177     }
1179     for (z=OUTPUT1; z < OUTPUTN; z++) 
1180     {
1181         zS = z;
1182         for (zX = ENCODE1; zX < ENCODEN; zX++) 
1183         {
1184             if (pP->outputsFromEncodes[zX] == z) 
1185             {
1186                 zS = pP->streamsFromEncodes[zX];
1187                 break;
1188             }
1189         }
1190         acp->fxns->attach(acp, ACP_SERIES_STD,
1191             STD_BETA_OB + betaPrimeOffset * (as-1+zS),
1192             (IALG_Status *)&pAstCfg->xOut[z].outBufStatus);
1193         /* Ignore errors, not reported. */
1194     }
1196     TRACE_TERSE1("PAF_ASOT_initPhaseAcpAlg: AS%d: initialization phase - ACP Algorithm complete.", as+zMS);
1198     return 0;
1199 } //PAF_ASOT_initPhaseAcpAlg
1201 // -----------------------------------------------------------------------------
1202 // ASOT Initialization Function - Common Memory
1203 //
1204 //   Name:      PAF_ASOT_initPhaseCommon
1205 //   Purpose:   Audio Stream Output Task Function for allocation of common memory.
1206 //   From:      audioStream1Task or equivalent
1207 //   Uses:      See code.
1208 //   States:    x
1209 //   Return:    0 on success.
1210 //              Source code line number on PAF_ALG_alloc failure.
1211 //              Source code line number on PAF_ALG_mallocMemory failure.
1212 //              Source code line number on Decode Chain initialization failure.
1213 //              Source code line number on ASP Chain initialization failure.
1214 //              Source code line number on Encode Chain initialization failure.
1215 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
1216 //              * State information as per parent.
1217 //              * Memory allocation errors.
1218 //
1219 Int
1220 PAF_ASOT_initPhaseCommon(
1221     const PAF_ASOT_Params *pP, 
1222     const PAF_ASOT_Patchs *pQ, 
1223     PAF_ASOT_Config *pAsotCfg
1226     PAF_AST_Config *pAstCfg;
1227     Int as;                     /* Audio Stream Number (1, 2, etc.) */
1228     Int z;                      /* stream counter */
1229     Int g;                      /* gear */
1230     ACP_Handle acp;
1231     PAF_IALG_Config pafAlgConfig;
1232     IALG_MemRec common[3][PAF_IALG_COMMON_MEMN+1];
1233    
1234     acp = pAsotCfg->acp;
1235     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
1236     as = pAstCfg->as;
1238     TRACE_TERSE0("PAF_ASOT_initPhaseCommon: initialization phase - Common Memory");
1240     //
1241     // Determine memory needs and instantiate algorithms across audio streams
1242     //
1243     TRACE_TERSE0("PAF_ASOT_initPhaseCommon: calling PAF_ALG_setup.");
1244     PAF_ALG_setup(&pafAlgConfig, 
1245         HEAP_ID_INTERNAL,                 HEAP_INTERNAL, 
1246         HEAP_ID_INTERNAL1,                HEAP_INTERNAL1, 
1247         HEAP_ID_EXTERNAL,                 HEAP_EXTERNAL, 
1248         HEAP_ID_INTERNAL1_SHM,            HEAP_INTERNAL1_SHM, 
1249         HEAP_ID_EXTERNAL_SHM,             HEAP_EXTERNAL_SHM, 
1250         HEAP_ID_EXTERNAL_NONCACHED_SHM,   HEAP_EXTERNAL_NONCACHED_SHM,
1251         HEAP_CLEAR);
1253     if (pP->fxns->headerPrint)
1254     {
1255         pP->fxns->headerPrint();        
1256     }
1258     for (z = STREAM1; z < STREAMN; z++) 
1259     {
1260         //Int zD, zE, zX;
1261         Int zE, zX;
1263         TRACE_TERSE1("PAF_ASOT_initPhaseCommon: AS%d: initialization phase - Common Memory", as+z);
1265         //
1266         // Determine common memory needs for:
1267         //  (1) ASP Algorithms
1268         //  (2) Encode Algorithms
1269         //  (3) Logical Output drivers
1270         //
1271         PAF_ALG_init(common[z], lengthof(common[z]), COMMONSPACE);
1273         zE = -1;
1274         for (zX = ENCODE1; zX < ENCODEN; zX++) 
1275         {
1276             if (pP->streamsFromEncodes[zX] == z) 
1277             {
1278                 zE = zX;
1279                 break;
1280             }
1281         }
1283         TRACE_TERSE1("Calling PAF_ALG_ALLOC for stream common[%d].", z);
1284         if (PAF_ALG_ALLOC(aspLinkInit[z-STREAM1][0], common[z])) 
1285         {
1286             TRACE_TERSE1("PAF_ASOT_initPhaseCommon: AS%d: PAF_ALG_alloc failed", as+z);
1287             TRACE_TERSE2("Failed to alloc %d bytes from space %d ", common[z]->size, common[z]->space);
1288             SW_BREAKPOINT;
1289             return __LINE__;
1290         }
1291         TRACE_TERSE3("alloced %d bytes from space %d at 0x%x", common[z]->size, common[z]->space, (IArg)common[z]->base);
1292         if (pP->fxns->allocPrint)
1293         {
1294             pP->fxns->allocPrint((const PAF_ALG_AllocInit *)(aspLinkInit[z-STREAM1][0]), sizeof (*(aspLinkInit[z-STREAM1][0])), &pafAlgConfig);
1295         }
1297         if (zE >= 0) 
1298         {
1299             TRACE_TERSE1("PAF_ASOT_initPhaseCommon: calling PAF_ALG_ALLOC/ for encoder common[%d].", z);
1300             if (PAF_ALG_ALLOC(encLinkInit[zE-ENCODE1], common[z])) 
1301             {
1302                 TRACE_TERSE1("PAF_ASOT_initPhaseCommon: AS%d: PAF_ALG_alloc failed", as+z);
1303                 SW_BREAKPOINT;
1304                 return __LINE__;
1305             }
1306             TRACE_TERSE3("alloced %d bytes from space %d at 0x%x", common[z]->size, common[z]->space, (IArg)common[z]->base);
1307             if (pP->fxns->allocPrint)
1308             {
1309                 pP->fxns->allocPrint((const PAF_ALG_AllocInit *)(encLinkInit[z-ENCODE1]), sizeof (*(encLinkInit[z-ENCODE1])), &pafAlgConfig);
1310             }
1311         }
1313         //
1314         // Determine common memory needs of Logical IO drivers
1315         //
1317         if (OUTPUT1 <= z && z < OUTPUTN)
1318         {
1319             TRACE_TERSE1("PAF_ASOT_initPhaseCommon: calling PAF_ALG_ALLOC outLinkInit common[%d].", z);
1320             if (PAF_ALG_ALLOC(outLinkInit[z-OUTPUT1], common[z]))
1321             {
1322                 TRACE_TERSE1("PAF_ASOT_initPhaseMalloc: AS%d: PAF_ALG_alloc failed", as+z);
1323                 TRACE_TERSE2("Failed to alloc %d bytes from space %d", common[z]->size, (IArg)common[z]->space);
1324                 SW_BREAKPOINT;
1325                 return __LINE__;
1326             }
1327             TRACE_TERSE3("alloced %d bytes from space %d at 0x%x", common[z]->size, common[z]->space, (IArg)common[z]->base);
1328             if (pP->fxns->allocPrint)
1329             {
1330                 pP->fxns->allocPrint((const PAF_ALG_AllocInit *)(outLinkInit[z-INPUT1]), sizeof (*(outLinkInit[z-INPUT1])), &pafAlgConfig);
1331             }
1332         }
1333     }
1334     {
1335         // Changes made to share scratch between zones
1336         // Assume maximum 3 zones and scratch common memory is at offset 0;
1337         int max=0;
1338         for (z=STREAM1; z<STREAMN; z++)
1339         {
1340             if (max < common[z][0].size)
1341             {
1342                 max = common[z][0].size;
1343             }
1344         }
1345         common[STREAM1][0].size=max;
1346         for (z=STREAM1+1; z<STREAMN; z++)
1347         {
1348             common[z][0].size = 0;            
1349         }
1350     }
1351         
1352     //
1353     // Allocate common memory for:
1354     //  (1) ASP Algorithms
1355     //  (2) Encode Algorithms
1356     //  (3) Logical Output drivers
1357     //
1358     for (z = STREAM1; z < STREAMN; z++) 
1359     {
1360         //Int zD, zE, zX;
1361         Int zE, zX;
1363         TRACE_TERSE0("PAF_ASOT_initPhaseCommon: calling PAF_ALG_mallocMemory for common space.");
1364         if (PAF_ALG_mallocMemory(common[z], &pafAlgConfig)) 
1365         {
1366             TRACE_TERSE1("AS%d: PAF_ALG_mallocMemory failed", as+z);
1367             TRACE_TERSE3("AS%d: z: %d.  Size 0x%x", as+z, z, common[z][0].size);
1368             SW_BREAKPOINT;
1369             return __LINE__;
1370         }
1371         TRACE_TERSE3("alloced %d bytes from space %d at 0x%x", common[z]->size, common[z]->space, (IArg)common[z]->base);
1372         // share zone0 scratch with all zones 
1373         common[z][0].base = common[0][0].base;
1374         if (pP->fxns->commonPrint)
1375         {
1376             pP->fxns->commonPrint(common[z], &pafAlgConfig);
1377         }
1379         zE = -1;
1380         for (zX = ENCODE1; zX < ENCODEN; zX++) 
1381         {
1382             if (pP->streamsFromEncodes[zX] == z) 
1383             {
1384                 zE = zX;
1385                 break;
1386             }
1387         }
1389         pAstCfg->xStr[z].aspChain[0] = NULL;
1390         for (g=0; g < GEARS; g++) 
1391         {
1392             PAF_ASP_Chain *chain;
1393             TRACE_TERSE0("PAF_ASOT_initPhaseCommon: calling PAF_ASP_chainInit for ASPs.");
1394             chain = PAF_ASP_chainInit(&pAstCfg->xStr[z].aspChainData[g], pP->pChainFxns,
1395                 HEAP_INTERNAL, as+z, acp, &trace,
1396                 aspLinkInit[z-STREAM1][g], pAstCfg->xStr[z].aspChain[0], common[z], &pafAlgConfig);
1397             if (!chain) 
1398             {
1399                 TRACE_TERSE2("AS%d: ASP chain %d initialization failed", as+z, g);
1400                 return __LINE__;
1401             }
1402             else
1403             {
1404                 pAstCfg->xStr[z].aspChain[g] = chain;
1405             }
1406         }
1408         if (zE >= 0) 
1409         {
1410             PAF_ASP_Chain *chain;
1411             TRACE_TERSE0("PAF_ASOT_initPhaseCommon: calling PAF_ASP_chainInit for encode.");
1412             chain = PAF_ASP_chainInit(&pAstCfg->xEnc[zE].encChainData, pP->pChainFxns,
1413                 HEAP_INTERNAL, as+z, acp, &trace,
1414                 encLinkInit[zE-ENCODE1], NULL, common[z], &pafAlgConfig);
1415             if (!chain) 
1416             {
1417                 TRACE_TERSE1("AS%d: Encode chain initialization failed", as+z);
1418                 return __LINE__;
1419             }
1420         }
1422         //
1423         // Allocate non-common memories for Logical IO drivers
1424         //    Since these structures are used at run-time we allocate from external memory
1425         if (OUTPUT1 <= z && z < OUTPUTN) 
1426         {
1427             PAF_ASP_Chain *chain;
1428             TRACE_TERSE2("PAF_ASOT_initPhaseMalloc: AS%d: non-common output chain init for %d",
1429                            as+z, z);
1430             chain = PAF_ASP_chainInit (&pAstCfg->xOut[z].outChainData, pP->pChainFxns,
1431                         HEAP_EXTERNAL, as+z, acp, &trace,
1432                         outLinkInit[z-OUTPUT1], NULL, common[z], &pafAlgConfig);
1433             if (!chain) 
1434             {
1435                 TRACE_TERSE1("AS%d: Output chain initialization failed", as+z);
1436                 return __LINE__;
1437             }
1438         }
1439     }
1440     TRACE_TERSE1("AS%d: PAF_ASOT_initPhaseCommon: Returning complete.", as+z);
1442     return 0;
1443 } //PAF_ASOT_initPhaseCommon
1445 // -----------------------------------------------------------------------------
1446 // ASOT Initialization Function - Algorithm Keys
1447 //
1448 //   Name:      PAF_ASOT_initPhaseAlgKey
1449 //   Purpose:   Audio Stream Output Task Function for initialization of data values
1450 //              from parameters for Algorithm Keys.
1451 //   From:      audioStream1Task or equivalent
1452 //   Uses:      See code.
1453 //   States:    x
1454 //   Return:    0.
1455 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
1456 //              * State information as per parent.
1457 //
1458 // .............................................................................
1459 Int
1460 PAF_ASOT_initPhaseAlgKey(
1461     const PAF_ASOT_Params *pP, 
1462     const PAF_ASOT_Patchs *pQ, 
1463     PAF_ASOT_Config *pAsotCfg
1466     PAF_AST_Config *pAstCfg;
1467     Int as;                     /* Audio Stream Number (1, 2, etc.) */
1468     Int z;                      /* decode/encode counter */
1469     Int s;                      /* key number */
1470     PAF_ASP_Link *that;
1472     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
1473     as = pAstCfg->as;
1474     (void)as; // clear compiler warning in case not used with tracing disabled
1476     TRACE_VERBOSE1("PAF_ASOT_initPhaseAlgKey: AS%d: initialization phase - Algorithm Keys", as);
1478     for (z=ENCODE1; z < ENCODEN; z++) 
1479     {
1480         for (s=0; s < pP->pEncAlgKey->length; s++) 
1481         {
1482             if ((pP->pEncAlgKey->code[s].full != 0) && 
1483                 (that = PAF_ASP_chainFind(&pAstCfg->xEnc[z].encChainData, pP->pEncAlgKey->code[s])))
1484             {
1485                 pAstCfg->xEnc[z].encAlg[s] = (ALG_Handle )that->alg;
1486             }
1487             /* Cast in interface, for now --Kurt */
1488             else
1489             {
1490                 pAstCfg->xEnc[z].encAlg[s] = NULL;                
1491             }
1492         }
1493     }
1495     return 0;
1496 } //PAF_ASOT_initPhaseAlgKey
1498 // -----------------------------------------------------------------------------
1499 // ASOT Initialization Function - I/O Devices
1500 //
1501 //   Name:      PAF_ASOT_initPhaseDevice
1502 //   Purpose:   Audio Stream Output Task Function for initialization of I/O Devices.
1503 //   From:      audioStream1Task or equivalent
1504 //   Uses:      See code.
1505 //   States:    x
1506 //   Return:    0 on success.
1507 //              Source code line number on device allocation failure.
1508 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
1509 //              * State information as per parent.
1510 //              * Memory allocation errors.
1511 //
1512 Int
1513 PAF_ASOT_initPhaseDevice(
1514     const PAF_ASOT_Params *pP, 
1515     const PAF_ASOT_Patchs *pQ, 
1516     PAF_ASOT_Config *pAsotCfg
1519     PAF_AST_Config *pAstCfg;
1520     Int as;                     /* Audio Stream Number (1, 2, etc.) */
1521     Int z;                      /* input/output counter */
1522     PAF_SIO_IALG_Obj    *pObj;
1523     PAF_SIO_IALG_Config *pAlgConfig;
1524     PAF_IALG_Config pafAlgConfig;
1526     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
1527     as = pAstCfg->as;
1528     (void)as; // clear compiler warning in case not used with tracing disabled
1530     TRACE_TERSE1("PAF_ASOT_initPhaseDevice: AS%d: initialization phase - I/O Devices", as);
1532     if(pP->fxns->bufMemPrint)
1533     {
1534         PAF_ALG_setup (&pafAlgConfig, 
1535             HEAP_ID_INTERNAL,               HEAP_INTERNAL, 
1536             HEAP_ID_INTERNAL1,              HEAP_INTERNAL1,
1537             HEAP_ID_EXTERNAL,               HEAP_EXTERNAL,
1538             HEAP_ID_INTERNAL1_SHM,          HEAP_INTERNAL1_SHM,
1539             HEAP_ID_EXTERNAL_SHM,           HEAP_EXTERNAL_SHM,
1540             HEAP_ID_EXTERNAL_NONCACHED_SHM, HEAP_EXTERNAL_NONCACHED_SHM,
1541             HEAP_CLEAR);
1542         TRACE_TERSE2("PAF_ASOT_initPhaseDevice: AS%d: calling PAF_ALG_setup with clear at %d.", as, HEAP_CLEAR);
1543     }
1544     
1545     for (z=OUTPUT1; z < OUTPUTN; z++) 
1546     {
1547         PAF_OutBufConfig *pConfig = &pAstCfg->xOut[z].outBufConfig;
1549         pObj = (PAF_SIO_IALG_Obj *)pAstCfg->xOut[z].outChainData.head->alg;
1550         pAlgConfig = &pObj->config;
1552         pAstCfg->xOut[z].hTxSio = NULL;
1553         pConfig->base.pVoid     = pAlgConfig->pMemRec[0].base;
1554         pConfig->pntr.pVoid     = pAlgConfig->pMemRec[0].base;
1555         pConfig->head.pVoid     = pAlgConfig->pMemRec[0].base;
1556         pConfig->allocation     = pAlgConfig->pMemRec[0].size;
1557         pConfig->sizeofElement  = 3;
1558         pConfig->precision      = 24;
1559         if(pP->fxns->bufMemPrint)
1560         {
1561             pP->fxns->bufMemPrint(z,pAlgConfig->pMemRec[0].size,PAF_ALG_memSpaceToHeapId(&pafAlgConfig,pAlgConfig->pMemRec[0].space),1);
1562         }
1563     }
1564     TRACE_TERSE1("PAF_ASOT_initPhaseDevice: AS%d: initialization phase - I/O Devices complete.", as);
1566     return 0;
1567 } //PAF_ASOT_initPhaseDevice
1569 // -----------------------------------------------------------------------------
1570 // ASOT Initialization Function Helper - Initialization of Audio Frame
1571 //
1572 //   Name:      PAF_ASOT_initFrame0
1573 //   Purpose:   Audio Stream Output Task Function for initialization of the Audio
1574 //              Frame(s) by memory allocation and loading of data pointers
1575 //              and values.
1576 //   From:      AST Parameter Function -> decodeInfo
1577 //   Uses:      See code.
1578 //   States:    x
1579 //   Return:    0 on success.
1580 //              Source code line number on MEM_calloc failure.
1581 //              Source code line number on unsupported option.
1582 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
1583 //              * Memory allocation errors.
1584 //              * Unsupported option errors.
1585 //
1587 // MID 314
1588 extern const char AFChanPtrMap[PAF_MAXNUMCHAN+1][PAF_MAXNUMCHAN];
1589 extern PAF_ChannelConfigurationMaskTable PAF_ASP_stdCCMT_patch;
1591 Int
1592 PAF_ASOT_initFrame0(
1593     const PAF_ASOT_Params *pP, 
1594     const PAF_ASOT_Patchs *pQ, 
1595     PAF_ASOT_Config *pAsotCfg, 
1596     Int z
1599     PAF_AST_Config *pAstCfg;
1600     Int as;                     /* Audio Stream Number (1, 2, etc.) */
1601     Int ch;
1602     //Int aLen;
1603     Int aLen_int=0,aLen_ext=0;
1604     Int aSize = sizeof(PAF_AudioData);
1605     Int aAlign = aSize < sizeof (int) ? sizeof (int) : aSize;
1606     Int maxFrameLength = pP->maxFramelength;
1607     Int zX;
1608     PAF_AudioData *aBuf_int=NULL;
1609     PAF_AudioData *aBuf_ext=NULL;
1610     XDAS_UInt8 *metadataBuf;
1611     char i;
1612     Error_Block    eb;
1614     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
1615     as = pAstCfg->as;
1617     // Initialize error block
1618     Error_init(&eb); 
1620     // Compute maximum framelength (needed for ARC support)
1621     maxFrameLength += PA_MODULO - maxFrameLength % PA_MODULO;
1622     //aLen = numchan[z] * maxFrameLength;
1623     for (i=0; i < numchan[z]; i++)
1624     {
1625         if (pP->pAudioFrameBufStatus->space[i] == IALG_SARAM)
1626         {
1627             aLen_int += maxFrameLength;
1628         }
1629         else
1630         {
1631             aLen_ext += maxFrameLength;
1632         }
1633     }
1635     //
1636     // Initialize audio frame elements directly
1637     //
1638     pAstCfg->xStr[z].pAudioFrame->fxns = pP->pAudioFrameFunctions;
1639     pAstCfg->xStr[z].pAudioFrame->data.nChannels = PAF_MAXNUMCHAN; ///
1640 ///    pAstCfg->xStr[z].pAudioFrame->data.nChannels = PAF_MAXNUMCHAN_AF;
1641     pAstCfg->xStr[z].pAudioFrame->data.nSamples = FRAMELENGTH;
1642     pAstCfg->xStr[z].pAudioFrame->data.sample = pAstCfg->xStr[z].audioFrameChannelPointers;
1643     pAstCfg->xStr[z].pAudioFrame->data.samsiz = pAstCfg->xStr[z].audioFrameChannelSizes;
1644     pAstCfg->xStr[z].pAudioFrame->pChannelConfigurationMaskTable = &PAF_ASP_stdCCMT;
1646     //
1647     // Allocate memory for and initialize pointers to audio data buffers
1648     //
1649     //   The NUMCHANMASK is used to identify the channels for which data
1650     //   buffers can be allocated. Using this mask and switch statement
1651     //   rather than some other construct allows efficient code generation,
1652     //   providing just the code necessary (with significant savings).
1653     //
1654     if (pP->fxns->bufMemPrint)
1655     {
1656         pP->fxns->bufMemPrint(z, aLen_int*aSize, HEAP_ID_FRMBUF, 2);
1657         pP->fxns->bufMemPrint(z, aLen_ext*aSize, HEAP_ID_EXTERNAL, 2);
1658     }
1660     TRACE_TERSE1("PAF_ASOT_initFrame0: AS%d: Memory_calloc for audio buffers", as+z);
1661     
1662     if (aLen_int*aSize!=0) // check size != 0, otherwise malloc throws fatal error
1663     {
1664         if (!(aBuf_int = (PAF_AudioData *)Memory_calloc((IHeap_Handle)HEAP_FRMBUF, (aLen_int+(maxFrameLength-FRAMELENGTH))*aSize, aAlign, &eb))) //Qin: Add start offset
1665         {
1666             TRACE_TERSE1("PAF_ASOT_initFrame0: AS%d: Memory_calloc failed", as+z);
1667             TRACE_TERSE2("  maxFrameLength: %d.  aLen_int*aSize: %d", maxFrameLength, (aLen_int+(maxFrameLength-FRAMELENGTH))*aSize);
1668             SW_BREAKPOINT;
1669             return __LINE__;
1670         }
1671     }
1672         
1673     if (aLen_ext*aSize!=0)
1674     {
1675         if (!(aBuf_ext = (PAF_AudioData *)Memory_calloc((IHeap_Handle)HEAP_EXTERNAL, (aLen_ext+(maxFrameLength-FRAMELENGTH))*aSize, aAlign, &eb)))//Qin: Add start offset
1676         {
1677             TRACE_TERSE1("PAF_ASOT_initFrame0: AS%d: Memory_calloc failed", as+z);
1678             TRACE_TERSE2("  maxFrameLength: %d.  aLen_ext*aSize: %d", maxFrameLength, (aLen_ext+(maxFrameLength-FRAMELENGTH))*aSize);
1679             SW_BREAKPOINT;
1680             return __LINE__;
1681         }
1682     }
1683     
1684     TRACE_TERSE3("  maxFrameLength: %d.  aLen_int*aSize: %d.  aBuf_int: 0x%x", maxFrameLength, (aLen_int+(maxFrameLength-FRAMELENGTH))*aSize, (IArg)aBuf_int);
1685     TRACE_TERSE3("  maxFrameLength: %d.  aLen_ext*aSize: %d.  aBuf_ext: 0x%x", maxFrameLength, (aLen_ext+(maxFrameLength-FRAMELENGTH))*aSize, (IArg)aBuf_ext);
1687     TRACE_TERSE1("PAF_ASOT_initFrame0: AS%d: Memory_calloc for metadata buffers", as+z);
1688     if (!(metadataBuf = (XDAS_UInt8 *)Memory_calloc((IHeap_Handle)HEAP_MDBUF, pP->pMetadataBufStatus->bufSize*pP->pMetadataBufStatus->NumBuf, pP->pMetadataBufStatus->alignment, &eb)))
1689     {
1690         TRACE_TERSE1("PAF_ASOT_initFrame0: AS%d: Memory_calloc failed", as+z);
1691         TRACE_TERSE1("  bufSize*NumBuf: %d", pP->pMetadataBufStatus->bufSize*pP->pMetadataBufStatus->NumBuf);
1692         SW_BREAKPOINT;
1693         return __LINE__;
1694     }
1696     {
1697         Int i;
1699 #pragma UNROLL(1)
1700         for (i=0; i < PAF_MAXNUMCHAN_AF; i++)
1701         {
1702             pAstCfg->xStr[z].audioFrameChannelPointers[i] = NULL;
1703         }
1704     }
1706     // MID 314
1707     if((numchan[z] > PAF_MAXNUMCHAN) || (numchan[z] < 1)) 
1708     {
1709         TRACE_TERSE1("PAF_ASOT_initFrame0: AS%d: unsupported option", as+z);
1710         return __LINE__;
1711     }
1712     else 
1713     {
1714         Int j = 0;
1715         Int k = 0;
1716         TRACE_TERSE1("PAF_ASOT_initFrame0: AFChanPtrMap[%d][i]", numchan[z]);
1717         for(i=0;i<numchan[z];i++)
1718         {
1719             char chan = AFChanPtrMap[numchan[z]][i];
1720             if(chan != -1)
1721             {
1722                 if(pP->pAudioFrameBufStatus->space[i] == IALG_SARAM)
1723                 {
1724                     pAstCfg->xStr[z].audioFrameChannelPointers[chan] = aBuf_int + maxFrameLength*(j+1) - FRAMELENGTH;
1725                     j++;
1726                 }
1727                 else
1728                 {        
1729                     pAstCfg->xStr[z].audioFrameChannelPointers[chan] = aBuf_ext + maxFrameLength*(k+1) - FRAMELENGTH;
1730                     k++;
1731                 }    
1732                 TRACE_TERSE3("PAF_ASOT_initFrame0: chan = %d = AFChanPtrMap[%d][%d].", chan, numchan[z], i);
1733                 TRACE_TERSE2("PAF_ASOT_initFrame0: audioFrameChannelPointers[%d]: 0x%x", chan, (IArg)pAstCfg->xStr[z].audioFrameChannelPointers[chan]);
1734             }
1735         }
1736     }
1738     for (ch=PAF_LEFT; ch < PAF_MAXNUMCHAN_AF; ch++) 
1739     {
1740         if (pAstCfg->xStr[z].audioFrameChannelPointers[ch])
1741         {
1742             pAstCfg->xStr[z].origAudioFrameChannelPointers[ch] = pAstCfg->xStr[z].audioFrameChannelPointers[ch];
1743         }
1744     }
1746     //
1747     // Initialize meta data elements
1748     //
1749     pAstCfg->xStr[z].pAudioFrame->pafBsMetadataUpdate = XDAS_FALSE;
1750     pAstCfg->xStr[z].pAudioFrame->numPrivateMetadata = 0;
1751     pAstCfg->xStr[z].pAudioFrame->bsMetadata_offset = 0;
1752     pAstCfg->xStr[z].pAudioFrame->bsMetadata_type = PAF_bsMetadata_channelData;
1753     pAstCfg->xStr[z].pAudioFrame->privateMetadataBufSize = pP->pMetadataBufStatus->bufSize;
1754     for(i=0;i<pP->pMetadataBufStatus->NumBuf;i++)
1755     {
1756         pAstCfg->xStr[z].pAudioFrame->pafPrivateMetadata[i].offset = 0;
1757         pAstCfg->xStr[z].pAudioFrame->pafPrivateMetadata[i].size = 0;
1758         pAstCfg->xStr[z].pAudioFrame->pafPrivateMetadata[i].pMdBuf = metadataBuf + pP->pMetadataBufStatus->bufSize*i;
1759     }
1761     //
1762     // Initialize decoder elements directly
1763     //
1765     for (zX = DECODE1; zX < DECODEN; zX++) 
1766     {
1767         if (pP->streamsFromDecodes[zX] == z) 
1768         {
1769 #ifdef NOAUDIOSHARE
1770             pAstCfg->xDec[zX].decodeInStruct.audioShare.nSamples = 0;
1771             pAstCfg->xDec[zX].decodeInStruct.audioShare.sample = NULL;
1772 #else /* NOAUDIOSHARE */
1773             pAstCfg->xDec[zX].decodeInStruct.audioShare.nSamples = aLen_int;
1774             pAstCfg->xDec[zX].decodeInStruct.audioShare.sample = aBuf_int;
1775 #endif /* NOAUDIOSHARE */
1776         }
1777     }
1779     return 0;
1780 } //PAF_ASOT_initFrame0
1782 // -----------------------------------------------------------------------------
1783 // ASOT Initialization Function Helper - Reinitialization of Audio Frame
1784 // AST Decoding Function              - Reinitialization of Audio Frame
1785 //
1786 //   Name:      PAF_ASOT_initFrame1
1787 //   Purpose:   Audio Stream Task Function for initialization or reinitiali-
1788 //              zation of the Audio Frame(s) by loading of data values of a
1789 //              time-varying nature.
1790 //   From:      audioStream1Task or equivalent
1791 //              AST Parameter Function -> decodeInfo
1792 //              AST Parameter Function -> decodeDecode
1793 //   Uses:      See code.
1794 //   States:    x
1795 //   Return:    0.
1796 //   Trace:     None.
1797 //
1798 Int
1799 PAF_ASOT_initFrame1(
1800     const PAF_ASOT_Params *pP, 
1801     const PAF_ASOT_Patchs *pQ, 
1802     PAF_ASOT_Config *pAsotCfg, 
1803     Int z, 
1804     Int apply
1807     PAF_AST_Config *pAstCfg;
1809     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
1811     //
1812     // Reinitialize audio frame elements:
1813     //
1814     //   Channel Configurations during sys init                 = Unknown
1815     //      "          "        during info or decode           = None
1816     //
1817     //   Sample Rate / Count    during sys init, info or decode = Unknown / 0
1818     //
1820     if (apply < 0) 
1821     {
1822         pAstCfg->xStr[z].pAudioFrame->channelConfigurationRequest.legacy = PAF_CC_UNKNOWN;
1823         pAstCfg->xStr[z].pAudioFrame->channelConfigurationStream.legacy = PAF_CC_UNKNOWN;
1824     }
1825     else 
1826     {
1827         pAstCfg->xStr[z].pAudioFrame->channelConfigurationRequest.legacy = PAF_CC_NONE;
1828         pAstCfg->xStr[z].pAudioFrame->channelConfigurationStream.legacy = PAF_CC_NONE;
1829     }
1831     if (apply < 1) 
1832     {
1833         pAstCfg->xStr[z].pAudioFrame->sampleRate = PAF_SAMPLERATE_UNKNOWN;
1834         pAstCfg->xStr[z].pAudioFrame->sampleCount = 0;
1835     }
1837     return 0;
1838 } //PAF_ASOT_initFrame1
1840 // -----------------------------------------------------------------------------
1841 // ASOT Selection Function - Output Device Selection
1842 //
1843 //   Name:      PAF_ASOT_selectDevices
1844 //   Purpose:   Audio Stream Output Task Function for selecting the devices used
1845 //              for output.
1846 //   From:      audioStream1Task or equivalent
1847 //   Uses:      See code.
1848 //   States:    x
1849 //   Return:    Error number in standard form (0 on success).
1850 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
1851 //              * State information as per parent.
1852 //
1853 Int
1854 PAF_ASOT_selectDevices(
1855     const PAF_ASOT_Params *pP, 
1856     const PAF_ASOT_Patchs *pQ, 
1857     PAF_ASOT_Config *pAsotCfg
1860     PAF_AST_Config *pAstCfg;
1861     Int as;                     /* Audio Stream Number (1, 2, etc.) */
1862     Int z;                      /* input/output counter */
1863     Int errno = 0;              /* error number */
1864     Int errme;                  /* error number, local */
1865     Int device;
1867     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
1868     as = pAstCfg->as;
1869     (void)as;  // clear compiler warning in case not used with tracing disabled
1871     // Select output devices
1872     for (z=OUTPUT1; z < OUTPUTN; z++) 
1873     {
1874         if ((device = pAstCfg->xOut[z].outBufStatus.sioSelect) >= 0) 
1875         {
1876             TRACE_VERBOSE2("PAF_ASOT_selectDevices: AS%d: output device %d selecting ...", as+z, device);
1878             /* check for valid index into device array */
1879             if (device >= pQ->devout->n)
1880             {
1881                 device = 0; /* treat as device None */
1882             }
1884             errme = pP->fxns->deviceSelect(&pAstCfg->xOut[z].hTxSio, SIO_OUTPUT, 
1885                 HEAP_ID_OUTBUF, (Ptr)pQ->devout->x[device]);
1886             if (errme)
1887             {
1888                 TRACE_VERBOSE2("PAF_ASOT_selectDevices: errme 0x%x, errno 0x%x", errme, errno);
1889                 if (!errno)
1890                 {
1891                     errno = ASPERR_DEVOUT + errme;
1892                 }
1893                 pAstCfg->xOut[z].outBufStatus.sioSelect = 0x80;
1894             }
1895             else 
1896             {
1897                 Int zE;
1899                 pAstCfg->xOut[z].outBufStatus.sioSelect = device | 0x80;
1900                 // register outBufStatus and encodeStatus pointers with output devices
1901                 // This enables proper IEC encapsulation.
1902                 if (pAstCfg->xOut[z].hTxSio) 
1903                 {
1904                     // set max # of output buffers (use override if necessary)
1905                     if (pAstCfg->xOut[z].outBufStatus.maxNumBufOverride == 0)
1906                     {
1907                         SIO_ctrl(pAstCfg->xOut[z].hTxSio, PAF_SIO_CONTROL_SET_MAX_NUMBUF,
1908                             (Arg)pP->poutNumBufMap[z]->maxNumBuf);
1909                     }
1910                     else
1911                     {
1912                         SIO_ctrl(pAstCfg->xOut[z].hTxSio, PAF_SIO_CONTROL_SET_MAX_NUMBUF,
1913                             (Arg)pAstCfg->xOut[z].outBufStatus.maxNumBufOverride);
1914                     }
1916                     // register PAF_SIO_IALG object address
1917                     SIO_ctrl(pAstCfg->xOut[z].hTxSio, PAF_SIO_CONTROL_SET_IALGADDR,
1918                         (Arg)pAstCfg->xOut[z].outChainData.head->alg);
1919                     SIO_ctrl(pAstCfg->xOut[z].hTxSio, PAF_SIO_CONTROL_SET_BUFSTATUSADDR, 
1920                         (Arg)&pAstCfg->xOut[z].outBufStatus);
1921                     for (zE=ENCODE1; zE < ENCODEN; zE++) 
1922                     {
1923                         if (pP->outputsFromEncodes[zE] == z) 
1924                         {
1925                             SIO_ctrl(pAstCfg->xOut[z].hTxSio, 
1926                                 PAF_SIO_CONTROL_SET_ENCSTATUSADDR, 
1927                                 (Arg)&pAstCfg->xEnc[zE].encodeStatus);
1928                             break;
1929                         }
1930                     }
1931                 }
1932             }
1933         }
1935 /* No need to start-clocks here, since only selecting the device. */
1936 #if 0
1937         // if device selected and valid then enable stat tracking if
1938         // required and start clocking
1939         if ((pAstCfg->xOut[z].outBufStatus.sioSelect < 0) && (pAstCfg->xOut[z].hTxSio)) 
1940         {
1941             TRACE_VERBOSE0("PAF_ASOT_selectDevices: start SIO clocks");
1942             errme = SIO_ctrl(pAstCfg->xOut[z].hTxSio, PAF_SIO_CONTROL_OUTPUT_START_CLOCKS, 0);
1943             if (errme)
1944             {
1945                 TRACE_VERBOSE2("PAF_ASOT_selectDevices: errme 0x%x, errno 0x%x", errme, errno);
1946                 SIO_idle(pAstCfg->xOut[z].hTxSio);
1947                 if (!errno)
1948                 {
1949                     errno = ASPERR_DEVOUT + errme;
1950                 }
1951             }
1952         }
1953 #endif
1954     }
1956     return errno;
1957 } //PAF_ASOT_selectDevices
1960 // -----------------------------------------------------------------------------
1961 // ASOT Processing Function - Decode Processing
1962 //
1963 //   Name:      PAF_ASOT_decodeProcessing
1964 //   Purpose:   Audio Stream Output Task Function for processing audio data.
1965 //
1966 Int
1967 PAF_ASOT_decodeProcessing(
1968     const PAF_ASOT_Params *pP, 
1969     const PAF_ASOT_Patchs *pQ, 
1970     PAF_ASOT_Config *pAsotCfg 
1973     PAF_AST_Config *pAstCfg;
1974     Int errno;                          /* error number */
1975     Int getVal;
1976     enum { INIT, STREAM, ENCODE, FINAL, QUIT, OUT_SIO_UPDATE } state;
1977     state = INIT;
1978     errno = 0; /* error number */
1979     Int frame; // (***) FL: formerly -- decoder input frame count
1980     Int block; // decoder output block count / input frame
1981     Int outSioUpdate;
1982     
1983     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
1985     for (;;) 
1986     {
1987         //
1988         // Check forward (ASIT) error here, TBD
1989         //
1990         
1991         // If writeDECCommandRestart issued, force exit the statemachine
1992         if (gCommandOutputTask_SYNC) {
1993             TRACE_VERBOSE1("PAF_ASOT_decodeProcessing: writeDECCommandRestart issued in state=0x%x ... exiting core loop", state);
1994             errno = ASOP_DP_FORWARD_ERR;
1995             break;
1996         }
1998         // Check if any change in output SIO, e.g. from Output shortcut.
1999         // Changes will break FSM and allow Output reconfiguration.
2000         errno = checkOutSio(pP, pAsotCfg, &outSioUpdate);
2001         if (errno < 0)
2002         {
2003             TRACE_TERSE1("PAF_ASOT_decodeProcessing: checkOutSio returned errno = 0x%04x", errno);
2004             break;
2005         }
2006         else if (outSioUpdate)
2007         {
2008             TRACE_VERBOSE0("PAF_ASOT_decodeProcessing: Change in Output SIO selection");
2009             state = OUT_SIO_UPDATE;
2010         }
2011         
2012         // Process commands (encode)
2013         getVal = pP->fxns->encodeCommand(pP, pQ, pAsotCfg);
2014         if (getVal) 
2015         {
2016             /* ignore */;
2017         }
2019         // Process state (decode)
2020         switch (state) 
2021         {
2022             case INIT: // initial state
2023                 gAsopInitCnt++;
2024                 Log_info0("TaskAsop: state=INIT");
2025             
2026                 frame = 0;
2027                 block = 0;
2029 #if 0 // FL: moved to PAF_ASOT_initOutProc()
2030                 // Reset audio frame pointers to original values
2031                 // (may be needed if error occurred).
2032                 resetAfPointers(pP, pAstCfg->xStr);
2033                 // Reset audio frame meta data elements
2034                 resetAfMetadata(pP, pAstCfg->xStr);
2035 #endif
2037                 errno = pP->fxns->decodeInit(pP, pQ, pAsotCfg);
2038                 if (errno)
2039                 {
2040                     TRACE_VERBOSE1("PAF_ASOT_decodeProcessing: INIT, errno 0x%x.  break after decodeInit", errno);
2041                     errno = ASOP_DP_DECINIT_ERR;
2042                     break;
2043                 }
2044                 
2045                 //
2046                 // Setup output: setCheckRateX, start output
2047                 //
2048                 // Establish secondary timing
2049                 errno = pP->fxns->decodeInfo1(pP, pQ, pAsotCfg, frame, block);
2050                 if (errno)
2051                 {
2052                     TRACE_VERBOSE1("PAF_ASOT_decodeProcessing: INIT, errno 0x%x.  break after decodeInfo1", errno);
2053                     break;
2054                 }
2055                 
2056                 TRACE_VERBOSE0("PAF_ASOT_decodeProcessing: state: INIT->STREAM");                
2057                 state = STREAM;
2058                 continue;
2059                 
2060             case STREAM: // stream state
2061                 gAsopStreamCnt++;
2062                 Log_info0("TaskAsop: state=STREAM");
2064                 errno = pP->fxns->decodeStream(pP, pQ, pAsotCfg, frame, block);
2065                 if (errno)
2066                 {
2067                     TRACE_TERSE1("PAF_ASOT_decodeProcessing: state: STREAM.  decodeStream err 0x%x", errno);
2068                     errno = ASOP_DP_DECSTREAM_ERR;
2069                     break;
2070                 }
2072                 TRACE_VERBOSE0("PAF_ASOT_decodeProcessing: state: STREAM->ENCODE");
2073                 state = ENCODE;
2074                 continue;
2075                 
2076             case ENCODE: // encode state
2077                 gAsopEncodeCnt++;
2078                 Log_info0("TaskAsop: state=ENCODE");
2080                 errno = pP->fxns->decodeEncode(pP, pQ, pAsotCfg, frame, block);
2081                 if (errno)
2082                 {
2083                     TRACE_TERSE1("PAF_ASOT_decodeProcessing: state: ENCODE.  decodeEncode err 0x%x", errno);
2084                     errno = ASOP_DP_DECENC_ERR;
2085                     break;
2086                 }
2087                 
2088                 // Measure cycles in output processing loop.
2089                 // Only measures cycles spent in loop.
2090                 pfpEnd(PFP_ID_ASOT_1, PFP_FINISH_MEAS);
2091                 gNumPfpAsot1--;
2092                 pfpBegin(PFP_ID_ASOT_1, pAsotCfg->taskHandle);
2093                 gNumPfpAsot1++;
2094                 
2095                 // (***) FL: do we need this? 
2096                 //       AF pointers come from CB read, any resets occur in Decoder AF.
2097                 //
2098                 // Reset audio frame pointers to original values
2099                 // (may have been adjusted by ARC or the like).
2100                 resetAfPointers(pP, pAstCfg->xStr);
2102                 // (***) FL: update output (setCheckRateX)
2103                 //           Contained in INFO2 in combined FSM.
2104                 errno = pP->fxns->decodeInfo2(pP, pQ, pAsotCfg, frame, block);
2105                 if (errno)
2106                 {
2107                     TRACE_TERSE1("PAF_ASOT_decodeProcessing: ENCODE break on decodeInfo2. errno 0x%x", errno);
2108                     errno = ASOP_DP_DECINFO2_ERR;
2109                     break;
2110                 }
2112                 block++;
2113                 TRACE_VERBOSE0("PAF_ASOT_decodeProcessing: state: ENCODE->FINAL");
2114                 state = FINAL;
2115                 continue;
2116                 
2117             case FINAL:
2118                 gAsopFinalCnt++;
2119                 Log_info0("TaskAsop: state=FINAL");
2120                 
2121                 //
2122                 // (***) FL: this needs to be fixed.
2123                 //       (1) Only require selected Output to be in this FSM
2124                 //           => Dec Status checks aren't valid, 
2125                 //              will probably always exit FSM if only Output running
2126                 //       (2) Checking Dec Status info asych to input events (maybe ok)
2127                 //
2128                 // Check for final frame, and if indicated:
2129                 // - Update audio flag to cause output buffer flush rather than
2130                 //   the default truncate in "complete" processing.
2131                 // - Exit state machine to "complete" processing.
2132 #if 0
2133                 if (pP->fxns->decodeFinalTest(pP, pQ, pAsotCfg, frame, block)) 
2134                 {
2135                     for (z=OUTPUT1; z < OUTPUTN; z++)
2136                     {
2137                         if ((pAstCfg->xOut[z].outBufStatus.audio & 0x0f) == PAF_OB_AUDIO_SOUND)
2138                         {
2139                             TRACE_VERBOSE0("PAF_ASOT_outputProcessing: state: FINAL: SOUND -> QUIET");
2140                             pAstCfg->xOut[z].outBufStatus.audio++; // SOUND -> QUIET
2141                         }
2142                     }
2143                     break;
2144                 }
2145 #endif
2146                 errno = pP->fxns->decodeFinalTest(pP, pQ, pAsotCfg, frame, block);
2147                 if (errno < 0)
2148                 {
2149                     TRACE_TERSE1("PAF_ASOT_decodeProcessing: DECODE FINAL break. errno 0x%x", errno);
2150                     errno = ASOP_DP_DECFINALTEST_ERR;
2151                     break;
2152                 }
2153                 else if (errno == ASOP_DP_CB_DRAINED)
2154                 {
2155                     // EOS, exit normally
2156                     TRACE_TERSE1("PAF_ASOT_decodeProcessing: DECODE FINAL normal exit. errno 0x%x", errno);
2157                     errno = ASOP_DP_SOK;
2158                     break;
2159                 }
2161                 TRACE_VERBOSE0("PAF_ASOT_decodeProcessing: state: FINAL->STREAM");
2162                 state = STREAM;
2163                 continue;
2164                 
2165             case OUT_SIO_UPDATE:
2166                 gAsopOutSioUpdateCnt++;
2167                 Log_info0("TaskAsop: state=OUT_SIO_UPDATE");
2169                 TRACE_VERBOSE0("PAF_ASOT_decodeProcessing: state: OUT_SIO_UPDATE");
2170                 errno = ASOP_DP_OUT_SIO_UPDATE;
2171                 break;
2172                 
2173             case QUIT:
2174                 gAsopQuitCnt++;
2175                 Log_info0("TaskAsop: state=QUIT");
2177                 TRACE_VERBOSE0("PAF_ASOT_decodeProcessing: state: QUIT");
2178                 errno = ASPERR_QUIT;
2179                 break;
2181             default: // unknown state
2182                 // Unknown:
2183                 // - Set error number registers.
2184                 // - Exit state machine to "complete" processing.
2186                 TRACE_TERSE1("PAF_ASOT_decodeProcessing: state: unknown, 0x%x", state);
2187                 errno = ASPERR_UNKNOWNSTATE;
2188                 break;
2190         }  // End of switch (state).
2191         
2192         TRACE_VERBOSE0("PAF_ASOT_decodeProcessing: Calling decode complete");
2193         if (pP->fxns->decodeComplete(pP, pQ, pAsotCfg, NULL, frame, block))
2194         {
2195             /* ignored? */;
2196         }
2197         
2198         //pfpEnd(PFP_ID_ASOT_1, PFP_FINISH_MEAS); // PFP end -- outside of PFP for errors, EOS, or Output SIO change
2199         //gNumPfpAsot1--;
2200         
2201         //return errno;
2202         break;        
2203     } // End of for (;;)
2204         
2205     pfpEnd(PFP_ID_ASOT_1, PFP_FINISH_MEAS); // PFP end -- outside of PFP for errors, EOS, or Output SIO change
2206     gNumPfpAsot1--;
2207         
2208     return errno;
2211 // -----------------------------------------------------------------------------
2212 // ASOT Decoding Function - Encode Command Processing
2213 //
2214 //   Name:      PAF_ASOT_encodeCommand
2215 //   Purpose:   Decoding Function for processing Encode Commands.
2216 //   From:      AST Parameter Function -> decodeProcessing
2217 //   Uses:      See code.
2218 //   States:    x
2219 //   Return:    0.
2220 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
2221 //              * Command execution.
2222 //              * SIO control errors.
2223 //              * Error number macros.
2224 //
2225 Int
2226 PAF_ASOT_encodeCommand(
2227     const PAF_ASOT_Params *pP, 
2228     const PAF_ASOT_Patchs *pQ, 
2229     PAF_ASOT_Config *pAsotCfg
2232     PAF_AST_Config *pAstCfg;
2233     Int as;                     /* Audio Stream Number (1, 2, etc.) */
2234     Int z;                      /* encode counter */
2235     Int errno = 0;              /* error number */
2236     Int zO, zS;
2239     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
2240     as = pAstCfg->as;
2242     for (z=ENCODE1; z < ENCODEN; z++) 
2243     {
2244         zO = pP->outputsFromEncodes[z];
2245         zS = pP->streamsFromEncodes[z];
2246         if (! (pAstCfg->xEnc[z].encodeStatus.command2 & 0x80)) 
2247         {
2248             switch (pAstCfg->xEnc[z].encodeStatus.command2) 
2249             {
2250                 case 0: // command none - process
2251                     pAstCfg->xEnc[z].encodeStatus.command2 |= 0x80;
2252                     break;
2253                 case 1: // mute command
2254                     TRACE_VERBOSE2("AS%d: PAF_ASOT_encodeCommand: encode command mute (0x%02x)", as+zS, 1);
2255                     if ((pAstCfg->xOut[zO].outBufStatus.audio & 0x0f) != PAF_OB_AUDIO_QUIET
2256                         && pAstCfg->xOut[zO].hTxSio
2257                         && (errno = SIO_ctrl (pAstCfg->xOut[zO].hTxSio, PAF_SIO_CONTROL_MUTE, 0))) 
2258                     {
2259                         errno = (errno & 0xff) | ASPERR_MUTE;
2260                         /* convert to sensical errno */
2261                         TRACE_TERSE1("AS%d: PAF_ASOT_encodeCommand: SIO control failed (mute)", as+zS);
2262                         TRACE_TERSE2("AS%d: PAF_ASOT_encodeCommand: errno = 0x%04x <ignored>", as+zS, errno);
2263                     }
2264                     else 
2265                     {
2266                         pAstCfg->xOut[zO].outBufStatus.audio |= PAF_OB_AUDIO_MUTED;
2267                     }
2268                     pAstCfg->xEnc[z].encodeStatus.command2 |= 0x80;
2269                     break;
2270                 case 2: // unmute command
2271                     TRACE_VERBOSE2("AS%d: PAF_ASOT_encodeCommand: encode command unmute (0x%02x)", as+zS, 2);
2272                     if ((pAstCfg->xOut[zO].outBufStatus.audio & 0x0f) != PAF_OB_AUDIO_QUIET
2273                         && pAstCfg->xOut[zO].hTxSio
2274                         && (errno = SIO_ctrl (pAstCfg->xOut[zO].hTxSio, PAF_SIO_CONTROL_UNMUTE, 0))) 
2275                     {
2276                         errno = (errno & 0xff) | ASPERR_MUTE;
2277                         /* convert to sensical errno */
2278                         TRACE_TERSE1("AS%d: PAF_ASOT_encodeCommand: SIO control failed (unmute)", as+zS);
2279                         TRACE_TERSE2("AS%d: PAF_ASOT_encodeCommand: errno = 0x%04x <ignored>", as+zS, errno);
2280                     }
2281                     else 
2282                     {
2283                         pAstCfg->xOut[zO].outBufStatus.audio &= ~PAF_OB_AUDIO_MUTED;
2284                     }
2285                     pAstCfg->xEnc[z].encodeStatus.command2 |= 0x80;
2286                     break;
2287                 default: // command unknown - ignore
2288                     break;
2289             }
2290         }
2291     }
2293     ERRNO_RPRT (TaskAsop, errno);
2295     return 0;
2296 } //PAF_ASOT_encodeCommand
2298 //debug -- allow dynamic config
2299 //Int16 gStrFrameLen=DEF_STR_FRAME_LEN; // stream frame length (PCM samples)
2301 //   Purpose:   Decoding Function for reinitializing the decoding process.
2302 Int
2303 PAF_ASOT_decodeInit(
2304     const PAF_ASOT_Params *pP, 
2305     const PAF_ASOT_Patchs *pQ, 
2306     PAF_ASOT_Config *pAsotCfg
2309     //PAF_AST_Config *pAstCfg;
2310     PAF_AST_DecOpCircBufCtl *pCbCtl;    /* Decoder output circular buffer control */
2311     //Int as;                             /* Audio Stream Number (1, 2, etc.) */
2312     Int z;                              /* decode/encode counter */
2313     Int errno;                          /* error number */
2314     //Int zO, zS;
2316     //pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
2317     //as = pAstCfg->as;
2319     pCbCtl = &pAsotCfg->pAspmCfg->decOpCircBufCtl; // get pointer to circular buffer control
2321     for (z=DECODE1; z < DECODEN; z++)
2322     {
2323         // Initialize decoder output circular buffer for stream reads
2324         //errno = cbInitStreamRead(pCbCtl, z, gStrFrameLen);
2325         errno = cbInitStreamRead(pCbCtl, z);
2326         if (errno)
2327         {
2328             TRACE_TERSE1("PAF_ASOT_decodeInit:cbInitStreamRead() error=%d", errno);
2329             SW_BREAKPOINT; // debug
2330             return errno;
2331         }
2332         
2333         // Start decoder output circular buffer reads
2334         errno = cbReadStart(pCbCtl, z);
2335         if (errno)
2336         {
2337             TRACE_TERSE1("PAF_ASOT_decodeInit:cbReadStart() error=%d", errno);
2338             SW_BREAKPOINT; // debug
2339             return errno;
2340         }
2341         
2342         gCbReadAfErr=0;         // reset read circular buffer error count
2343         gDecOpCbRdAfUnd=0;      // reset decoder output circular buffer underflow count
2344         gMaxDecOpCbRdAfUnd=0;   // reset max decoder output circular buffer underflow count
2345         gMasterCbResetCnt=0;    // reset master circular buffer reset count
2347         // FL: debug, log circular buffer control variables
2348         cbLog(pCbCtl, z, 1, "PAF_ASOT_decodeInit:cbReadStart");
2349     }
2350     
2351 #if 0 // moved to PAF_ASOT_outputReset()
2352     // TODO: move this to start of this function so that it doesn't affect IO timing
2353     for (z=ENCODE1; z < ENCODEN; z++) 
2354     {
2355         zO = pP->outputsFromEncodes[z];
2356         zS = pP->streamsFromEncodes[z];
2357         if (pAstCfg->xOut[zO].hTxSio && pAstCfg->xEnc[z].encodeStatus.mode) 
2358         {
2359             Int select = pAstCfg->xEnc[z].encodeStatus.select;
2360             ALG_Handle encAlg = pAstCfg->xEnc[z].encAlg[select];
2361             ENC_Handle enc = (ENC_Handle )encAlg;
2362             TRACE_VERBOSE1("AS%d: PAF_ASOT_decodeInit: initializing encode", as+zS);
2363             if (encAlg->fxns->algActivate)
2364             {
2365                 encAlg->fxns->algActivate (encAlg);
2366             }
2367             if (enc->fxns->reset)
2368             {
2369                 errno = enc->fxns->reset(enc, NULL, 
2370                     &pAstCfg->xEnc[z].encodeControl, &pAstCfg->xEnc[z].encodeStatus);
2371                 if (errno)
2372                 {
2373                     return errno;
2374                 }
2375             }
2376         }
2377     }
2378 #endif
2379     
2380     return 0;
2383 // -----------------------------------------------------------------------------
2384 // ASOT Decoding Function - Info Processing, Initial
2385 //
2386 //   Name:      PAF_ASOT_decodeInfo1
2387 //   Purpose:   Decoding Function for processing information in a manner that
2388 //              is unique to initial frames of input data.
2389 //   From:      AST Parameter Function -> decodeProcessing
2390 //   Uses:      See code.
2391 //   States:    x
2392 //   Return:    Error number in standard or SIO form (0 on success).
2393 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
2394 //              * State information as per parent.
2395 //
2396 Int
2397 PAF_ASOT_decodeInfo1(
2398     const PAF_ASOT_Params *pP, 
2399     const PAF_ASOT_Patchs *pQ, 
2400     PAF_ASOT_Config *pAsotCfg, 
2401     Int frame, 
2402     Int block
2405     //PAF_AST_Config *pAstCfg;
2406     //Int z;                              /* decode/encode counter */
2407     Int errno;                          /* error number */
2409 #if 0 // moved to PAF_ASOT_outputInfo1()
2410     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
2412     // run the chain of ASP's on the stream.
2413     TRACE_VERBOSE0("PAF_ASOT_decodeInfo1: calling streamChainFunction.");
2414     errno = pP->fxns->streamChainFunction(pP, pQ, pAsotCfg, 
2415         PAF_ASP_CHAINFRAMEFXNS_RESET, 1, frame);
2416     if (errno)
2417     {
2418         TRACE_TERSE1("PAF_ASOT_decodeInfo1: streamChainFunction returns errno 0x%x ", errno);
2419         return errno;
2420     }
2422     TRACE_VERBOSE0("PAF_ASOT_decodeInfo1: calling enc->info.");
2423     for (z=ENCODE1; z < ENCODEN; z++) 
2424     {
2425         Int zO = pP->outputsFromEncodes[z];
2426         if (pAstCfg->xOut[zO].hTxSio && pAstCfg->xEnc[z].encodeStatus.mode) 
2427         {
2428             Int select = pAstCfg->xEnc[z].encodeStatus.select;
2429             ALG_Handle encAlg = pAstCfg->xEnc[z].encAlg[select];
2430             ENC_Handle enc = (ENC_Handle )encAlg;
2431             
2432             if (enc->fxns->info)
2433             {
2434                 errno = enc->fxns->info(enc, NULL,
2435                     &pAstCfg->xEnc[z].encodeControl, 
2436                     &pAstCfg->xEnc[z].encodeStatus);
2437                 if (errno)
2438                 {
2439                     TRACE_TERSE1("PAF_ASOT_decodeInfo1: info returns errno 0x%x ", errno);
2440                     return errno;
2441                 }
2442             }
2443         }
2444     }
2445 #endif    
2447     errno = pP->fxns->setCheckRateX(pP, pQ, pAsotCfg, 0);
2448     if (errno)
2449     {
2450         // ignore if rateX has changed since we haven't, but are about to,
2451         // start the output. If we didn't ignore this case then the state machine
2452         // would restart unnecessarily, e.g. in the case of SRC, resulting in
2453         // added latency.
2454         if (errno != ASPERR_INFO_RATECHANGE)
2455         {
2456             TRACE_TERSE1("PAF_ASOT_decodeInfo1: setCheckRateX returns errno 0x%x, not RATECHANGE", errno);
2457             return errno;
2458         }
2459         else
2460         {
2461             TRACE_TERSE0("PAF_ASOT_decodeInfo1: RATECHANGE returns RATECHANGE, ignoring");
2462         }
2463     }
2465     errno = pP->fxns->startOutput(pP, pQ, pAsotCfg);
2466     if (errno) 
2467     {
2468         if (errno == 0x105) 
2469         {
2470             TRACE_TERSE1("PAF_ASOT_decodeInfo1: startOutput returns RING BUFFER FULL (0x%x)", errno);
2471         }
2472         else
2473         {
2474             TRACE_TERSE1("PAF_ASOT_decodeInfo1: startOutput returns errno 0x%x", errno);
2475         }
2476         return errno;
2477     }
2478     
2479     return 0;
2482 // -----------------------------------------------------------------------------
2483 // ASOT Decoding Function - Info Processing, Subsequent
2484 //
2485 //   Name:      PAF_ASOT_decodeInfo2
2486 //   Purpose:   Decoding Function for processing information in a manner that
2487 //              is unique to frames of input data other than the initial one.
2488 //   From:      AST Parameter Function -> decodeProcessing
2489 //   Uses:      See code.
2490 //   States:    x
2491 //   Return:    Error number in standard form (0 on success).
2492 //   Trace:     None.
2493 //
2494 Int
2495 PAF_ASOT_decodeInfo2(
2496     const PAF_ASOT_Params *pP, 
2497     const PAF_ASOT_Patchs *pQ, 
2498     PAF_ASOT_Config *pAsotCfg, 
2499     Int frame, 
2500     Int block
2503     //PAF_AST_Config *pAstCfg;
2504     Int errno;
2506     
2507     //pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
2509     errno = pP->fxns->setCheckRateX (pP, pQ, pAsotCfg, 1);
2510     TRACE_VERBOSE1("PAF_ASOT_decodeInfo2: return 0x%x", errno);
2511     return errno;
2512 } //PAF_ASOT_decodeInfo2
2515 PAF_AST_DecOpCircBufStats gCbStats; // FL: debug
2516 // -----------------------------------------------------------------------------
2517 // ASOT Decoding Function - Stream Processing
2518 //
2519 //   Name:      PAF_ASOT_decodeStream
2520 //   Purpose:   Decoding Function for processing of audio frame data by the
2521 //              ASP Algorithms.
2522 //   From:      AST Parameter Function -> decodeProcessing
2523 //   Uses:      See code.
2524 //   States:    x
2525 //   Return:    Error number in standard form (0 on success).
2526 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
2527 //              * State information as per parent/child.
2528 //
2529 Int
2530 PAF_ASOT_decodeStream(
2531     const PAF_ASOT_Params *pP, 
2532     const PAF_ASOT_Patchs *pQ, 
2533     PAF_ASOT_Config *pAsotCfg, 
2534     Int frame, 
2535     Int block
2538     PAF_AST_Config *pAstCfg;
2539     PAF_AST_DecOpCircBufCtl *pCbCtl;    /* Decoder output circular buffer control */
2540     Int z;                              /* decode/stream counter */
2541     PAF_AudioFrame *pAfRd;
2542     Int cbErrno;
2543     //PAF_AST_DecOpCircBufStats cbStats;  /* circular buffer statistics */
2544     Int errno;
2547     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
2548     
2549     pCbCtl = &pAsotCfg->pAspmCfg->decOpCircBufCtl; // get pointer to circular buffer control
2550     
2551     for (z=DECODE1; z < DECODEN; z++) 
2552     {
2553         Int zS = pP->streamsFromDecodes[z];
2554         
2555         //
2556         // Read decoder output circular buffer
2557         //
2558         pAfRd = pAstCfg->xStr[zS].pAudioFrame;
2559         //GPIOSetOutput(GPIO_PORT_0, GPIO_PIN_106);       // debug
2560         cbErrno = cbReadAf(pCbCtl, z, pAfRd);
2561         //GPIOClearOutput(GPIO_PORT_0, GPIO_PIN_106);     // debug
2562         if ((cbErrno < 0) && 
2563             (cbErrno != ASP_DECOP_CB_AF_READ_UNDERFLOW) && 
2564             (cbErrno != ASP_DECOP_CB_PCM_READ_UNDERFLOW))
2565         {
2566             gCbReadAfErr++;
2567             TRACE_TERSE1("PAF_ASOT_decodeStream:cbReadAf() error=%d", cbErrno);
2568             //SW_BREAKPOINT; // debug
2569             return cbErrno;
2570         }
2572         // Handle underflows
2573         if ((cbErrno == ASP_DECOP_CB_AF_READ_UNDERFLOW) ||
2574             (cbErrno == ASP_DECOP_CB_PCM_READ_UNDERFLOW))
2575         {
2576             // (***) FL: Need to check behavior of cbReset().
2577             // Need to check behavior on exit/re-entry into Output processing.
2578             gDecOpCbRdAfUnd++; // increment circular buffer underflow count
2579             if (gDecOpCbRdAfUnd >= DEC_OP_CB_RDAF_UND_THR) 
2580             {
2581                 // Underflow count above threshold.
2582                 // (1) set max underflow count to threshold
2583                 // (2) reset underflow count
2584                 // (3) reset circular buffer
2585                 
2586                 gMaxDecOpCbRdAfUnd = DEC_OP_CB_RDAF_UND_THR; // update max underflow count
2587                 gDecOpCbRdAfUnd = 0; // reset underflow count
2589                 // Reset circular buffer
2590                 cbReset(pCbCtl, z);
2591                 gMasterCbResetCnt++; // increment master circular buffer reset count
2592                 Log_info0("ASOT:cbReset");
2593             
2594                 return cbErrno;
2595             }
2596         }
2597         else if ((cbErrno == ASP_DECOP_CB_SOK) && (gDecOpCbRdAfUnd > 0))
2598         {
2599             // No underflow detected.
2600             // update max underflow count,
2601             // reset underflow count
2602             
2603             // update max underflow count
2604             if (gDecOpCbRdAfUnd > gMaxDecOpCbRdAfUnd)
2605             {
2606                 gMaxDecOpCbRdAfUnd = gDecOpCbRdAfUnd;
2607             }
2608             gDecOpCbRdAfUnd = 0; // reset circular buffer underflow count
2609         }
2610         //Log_info0("PAF_ASOT_decodeStream:cbReadAf() complete.");
2611         //GPIOClearOutput(GPIO_PORT_0, GPIO_PIN_106);   // debug
2612         Log_info0("PAF_ASOT_decodeStream:cbReadAf() complete.");
2613         
2614 #if 0 // (***) FL: shows timing of CB read
2615             // (***) debug // B8
2616             {
2617                 static Uint8 toggleState = 0;
2618                 if (toggleState == 0)
2619                     GPIOSetOutput(GPIO_PORT_0, GPIO_PIN_106);
2620                 else
2621                     GPIOClearOutput(GPIO_PORT_0, GPIO_PIN_106);
2622                 toggleState = ~(toggleState);
2623             }
2624 #endif
2626         // debug, get circular buffer statistics
2627         //cbGetStats(pCbCtl, z, &cbStats);
2628         cbGetStats(pCbCtl, z, &gCbStats);
2630         // debug
2631         cbLog(pCbCtl, z, 1, "PAF_ASOT_decodeStream:cbReadAf");
2632         
2633 #if 0 // debug, capture audio frame
2634         if (capAfWrite(pAfRd, PAF_LEFT) != CAP_AF_SOK)
2635         {
2636             Log_info0("capAfWrite() error");
2637         }
2638 #endif
2639     }
2640             
2641     TRACE_VERBOSE0("PAF_ASOT_outputStream: calling streamChainFunction.");
2642     errno = pP->fxns->streamChainFunction(pP, pQ, pAsotCfg, 
2643         PAF_ASP_CHAINFRAMEFXNS_APPLY, 1, block);
2644     if (errno)
2645     {
2646         TRACE_TERSE1("PAF_ASOT_outputStream: streamChainFunction returns errno 0x%x ", errno);
2647         return errno;
2648     }
2650     return 0;
2652 } //PAF_ASOT_decodeStream
2654 // -----------------------------------------------------------------------------
2655 // ASOT Decoding Function - Encode Processing
2656 //
2657 //   Name:      PAF_ASOT_decodeEncode
2658 //   Purpose:   Decoding Function for processing of audio frame data by the
2659 //              Encode Algorithm.
2660 //   From:      AST Parameter Function -> decodeProcessing
2661 //   Uses:      See code.
2662 //   States:    x
2663 //   Return:    Error number in standard or SIO form (0 on success).
2664 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
2665 //              * State information as per parent.
2666 //
2667 Int
2668 PAF_ASOT_decodeEncode(
2669     const PAF_ASOT_Params *pP, 
2670     const PAF_ASOT_Patchs *pQ, 
2671     PAF_ASOT_Config *pAsotCfg, 
2672     Int frame, 
2673     Int block
2676     PAF_AST_Config *pAstCfg;
2677     Int as;                     /* Audio Stream Number (1, 2, etc.) */
2678     Int z;                      /* encode/output counter */
2679     Int errno;                  /* error number */
2680     Int zX, zE, zS;
2681     // debug
2682     //UInt32 curTime;
2684     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
2685     as = pAstCfg->as;
2687     // Await output buffers (but not first time)
2688     for (z=OUTPUT1; z < OUTPUTN; z++) 
2689     {
2690         // determine encoder associated with this output
2691         zE = z;
2692         for (zX = ENCODE1; zX < ENCODEN; zX++) 
2693         {
2694             if (pP->outputsFromEncodes[zX] == z) 
2695             {
2696                 zE = zX;
2697                 break;
2698             }
2699         }
2700         zS = pP->streamsFromEncodes[zE];
2702         if (pAstCfg->xOut[z].hTxSio) 
2703         {
2704             // update length (e.g. ARC may have changed)
2705             pAstCfg->xOut[z].outBufConfig.lengthofFrame = 
2706                 pAstCfg->xEnc[zE].encodeInStruct.pAudioFrame->sampleCount;
2707             TRACE_GEN2("PAF_ASOT_decodeEncode: AS%d: processing block %d -- idle", as+zS, block);
2708             //GPIOClearOutput(GPIO_PORT_0, GPIO_PIN_106);   // debug
2709             errno = SIO_reclaim(pAstCfg->xOut[z].hTxSio,(Ptr *) &pAstCfg->xOut[z].pOutBuf, NULL);
2710             //GPIOSetOutput(GPIO_PORT_0, GPIO_PIN_106);     // debug
2711             if (errno < 0)
2712             {
2713                 SIO_idle(pAstCfg->xOut[z].hTxSio);
2714                 TRACE_TERSE2("PAF_ASOT_decodeEncode: AS%d: SIO_reclaim returns error %d", as+zS, -errno);
2715                 return -errno; // SIO negates error codes
2716             }
2717             // TODO: use pC->xOut[z].pOutBuf in following ->encode call
2719 #if 0 // (***) FL: shows timing of Output Tx SIO reclaim
2720             // (***) debug // B8
2721             {
2722                 static Uint8 toggleState = 0;
2723                 if (toggleState == 0)
2724                     GPIOSetOutput(GPIO_PORT_0, GPIO_PIN_106);
2725                 else
2726                     GPIOClearOutput(GPIO_PORT_0, GPIO_PIN_106);
2727                 toggleState = ~(toggleState);
2728             }
2729 #endif            
2731             //
2732             // Simulate Tx SIO_reclaim() pend
2733             //
2734             //Semaphore_pend(semaphoreTxAudio, BIOS_WAIT_FOREVER);
2735             //curTime = Clock_getTicks();
2736             //System_printf("System time in TaskAsopFxn Tx audio = %lu\n", (ULong)curTime);
2737             //Log_info1("outputEncode():Tx SIO reclaim(), system time = %u", curTime);
2738             
2739             gAsopTxSioReclaimCnt++;
2740         }
2741         else 
2742         {
2743             TRACE_VERBOSE2("AS%d: PAF_ASOT_decodeEncode: processing block %d -- idle <ignored>", as+zS, block);
2744         }
2745     }
2747     // Encode data
2748     for (z=ENCODE1; z < ENCODEN; z++) 
2749     {
2750         Int zO = pP->outputsFromEncodes[z];
2751         Int zS = pP->streamsFromEncodes[z];
2752         (void)zS; // clear compiler warning in case not used with tracing disabled
2753         if (pAstCfg->xOut[zO].hTxSio && pAstCfg->xEnc[z].encodeStatus.mode) 
2754         {
2755             Int select = pAstCfg->xEnc[z].encodeStatus.select;
2756             ALG_Handle encAlg = pAstCfg->xEnc[z].encAlg[select];
2757             ENC_Handle enc = (ENC_Handle )encAlg;
2758             if (select != pAstCfg->xEnc[z].encodeControl.encActive)
2759             {
2760                 pAstCfg->xEnc[z].encodeControl.encActive = select;
2761                 TRACE_TERSE0("PAF_ASOT_decodeEncode: return error");
2762                 return (-1);
2763             }
2764             TRACE_GEN2("AS%d: PAF_ASOT_decodeEncode: processing block %d -- encode", as+zS, block);
2766             // (MID 1933) temp. workaround for PCE2
2767             pAstCfg->xEnc[z].encodeInStruct.pAudioFrame->data.nChannels = PAF_MAXNUMCHAN;
2769           /*
2770           #if (CURRENT_TRACE_MASK & TRACE_MASK_DATA)
2771             {
2772                 PAF_AudioFrame *pAudioFrame = pC->xEnc[z].encodeInStruct.pAudioFrame;
2773                 int *wp;
2774                 wp = (int*)pAudioFrame->data.sample[0];
2775                 TRACE_DATA((&TR_MOD, "as1-f2: AS%d PAF_ASOT_outputEncode: encoding from ch 0 0x%x. line %d", z, wp, __LINE__));
2776                 TRACE_DATA((&TR_MOD, "as1-f2: [0]: 0x%x, [16]: 0x%x, [99]: 0x%x (ch0)", wp[0], wp[16], wp[99]));
2777                 wp = (int*)pAudioFrame->data.sample[1];
2778                 TRACE_DATA((&TR_MOD, "as1-f2: PAF_ASOT_outputEncode: encoding from ch 1 0x%x. line %d", wp, __LINE__));
2779                 TRACE_DATA((&TR_MOD, "as1-f2: [0]: 0x%x, [16]: 0x%x, [99]: 0x%x (ch1)", wp[0], wp[16], wp[99]));
2780                 wp = (int*)pAudioFrame->data.sample[2];
2781                 TRACE_DATA((&TR_MOD, "as1-f2: PAF_ASOT_outputEncode: encoding from ch 2 0x%x. line %d", wp, __LINE__));
2782                 TRACE_DATA((&TR_MOD, "as1-f2: [0]: 0x%x, [16]: 0x%x, [99]: 0x%x (ch2)", wp[0], wp[16], wp[99]));
2783             }
2784           #endif
2785           */
2787             if (enc->fxns->encode)
2788             {
2789                 pAstCfg->xEnc[z].encodeOutStruct.bypassFlag =
2790                         pP->z_pEncodeStatus[z]->encBypass;
2791                 errno = enc->fxns->encode(enc, NULL, 
2792                     &pAstCfg->xEnc[z].encodeInStruct, 
2793                     &pAstCfg->xEnc[z].encodeOutStruct);
2794                 if (errno)
2795                 {
2796                     if (errno != PCEERR_OUTPUT_POINTERNULL)
2797                     {
2798                         TRACE_TERSE1("PAF_ASOT_decodeEncode: return error %d line %d", errno);
2799                         return errno;
2800                     }
2801                 }
2802             /*  #if (CURRENT_TRACE_MASK & TRACE_MASK_DATA)
2803                 else
2804                 {
2805                     int *wp = (int*)pC->xOut[z].pOutBuf->pntr.pVoid;
2806                     TRACE_DATA((&TR_MOD, "as1-f2: PAF_ASOT_outputEncode: encoded to 0x%x. line %d", wp, __LINE__));
2807                     TRACE_DATA((&TR_MOD, "as1-f2: [0]: 0x%x, [16]: 0x%x, [99]: 0x%x", wp[0], wp[16], wp[99]));
2808                 }
2809               #endif
2810               */
2811             }
2812         }
2813         else 
2814         {
2815             TRACE_VERBOSE2("PAF_ASOT_decodeEncode: AS%d: processing block %d -- encode <ignored>",
2816                 as+pP->streamsFromEncodes[z], block);
2817         }
2818     }
2820     // Transmit data
2821     for (z=OUTPUT1; z < OUTPUTN; z++) 
2822     {
2823         // determine encoder associated with this output
2824         zE = z;
2825         for (zX = ENCODE1; zX < ENCODEN; zX++) 
2826         {
2827             if (pP->outputsFromEncodes[zX] == z) 
2828             {
2829                 zE = zX;
2830                 break;
2831             }
2832         }
2833         zS = pP->streamsFromEncodes[zE];
2835         if (pAstCfg->xOut[z].hTxSio) 
2836         {
2837             TRACE_GEN2("PAF_ASOT_decodeEncode: AS%d: processing block %d -- output", as+zS, block);
2838             //GPIOSetOutput(GPIO_PORT_0, GPIO_PIN_106);       // debug
2839             errno = SIO_issue(pAstCfg->xOut[z].hTxSio, 
2840                 &pAstCfg->xOut[z].outBufConfig, sizeof (pAstCfg->xOut[z].outBufConfig), 0);
2841             //GPIOClearOutput(GPIO_PORT_0, GPIO_PIN_106);     // debug
2842             if (errno)
2843             {
2844                 SIO_idle(pAstCfg->xOut[z].hTxSio);
2845                 if (errno == 0x105)     // 0x105 == RINGIO_EBUFFULL
2846                 {
2847 //                    statStruct_LogFullRing(STATSTRUCT_AS1_F2);
2848                     TRACE_TERSE1("PAF_ASOT_decodeEncode: SIO_idle returned RINGIO_EBUFFULL (0x%x)", errno);
2849                 }
2850                 if (errno > 0)
2851                 {
2852                     TRACE_TERSE1("PAF_ASOT_decodeEncode: return error 0x%x line %d", errno);
2853                     return (ASPERR_ISSUE + (z << 4));
2854                 }
2855                 else if (errno < 0)
2856                 {
2857                     TRACE_TERSE1("PAF_ASOT_decodeEncode: return neg error 0x%x line %d", -errno);
2858                     return -errno; // SIO negates error codes
2859                 }
2860             }
2861             if (errno > 0)
2862             {
2863                 return (ASPERR_ISSUE + (z << 4));
2864             }
2865             else if (errno < 0)
2866             {
2867                 return -errno; // SIO negates error codes
2868             }
2869         }
2870         else 
2871         {
2872             TRACE_GEN2("PAF_ASOT_decodeEncode: AS%d: processing block %d -- output <ignored>", as+zS, block);
2873         }
2874     }
2876     return 0;
2877 } //PAF_ASOT_decodeEncode
2879 // -----------------------------------------------------------------------------
2880 // ASOT Decoding Function - Stream-Final Processing
2881 //
2882 //   Name:      PAF_ASOT_decodeComplete
2883 //   Purpose:   Decoding Function for terminating the decoding process.
2884 //   From:      AST Parameter Function -> decodeProcessing
2885 //   Uses:      See code.
2886 //   States:    x
2887 //   Return:    0.
2888 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
2889 //              * State information as per parent.
2890 //
2891 Int
2892 PAF_ASOT_decodeComplete(
2893     const PAF_ASOT_Params *pP, 
2894     const PAF_ASOT_Patchs *pQ, 
2895     PAF_ASOT_Config *pAsotCfg, 
2896     ALG_Handle decAlg[], 
2897     Int frame, 
2898     Int block
2901     PAF_AST_Config *pAstCfg;
2902     PAF_AST_DecOpCircBufCtl *pCbCtl;    /* Decoder output circular buffer control */
2903     Int as;                             /* Audio Stream Number (1, 2, etc.) */
2904     Int z;                              /* decode/encode counter */
2905     Int errno;                          /* error number */
2907     
2908     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
2909     as = pAstCfg->as;
2910     (void)as;  // clear compiler warning in case not used with tracing disabled
2912     pCbCtl = &pAsotCfg->pAspmCfg->decOpCircBufCtl; // get pointer to circular buffer control
2913     
2914     for (z=DECODE1; z < DECODEN; z++)
2915     {
2916         // Stop decoder output circular buffer reads
2917         errno = cbReadStop(pCbCtl, z);
2918         if (errno)
2919         {
2920             TRACE_TERSE1("PAF_ASOT_decodeComplete:cbReadStop() error=%d", errno);
2921             SW_BREAKPOINT; // FL: debug
2922             return errno;
2923     &n