PASDK-218:Add traces, fix typo in decodeEncode
[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"
72 #define TRACE_TIME(a)
74 //
75 // Audio Stream Definitions
76 //
78 //
79 // Audio Stream Processing Definitions
80 //
81 #define aspLinkInit pQ->i_aspLinkInit
83 //
84 // Encoder Definitions
85 //
86 #define encLinkInit pQ->i_encLinkInit
88 //
89 // Output Definitions
90 //
91 #define outLinkInit pP->i_outLinkInit
93 /* ---------------------------------------------------------------- */
94 /*              Parameter macro definitions end here.               */
95 /* ---------------------------------------------------------------- */
97 //
98 // Standardized Definitions
99 //
101 #define ENC_Handle PCE_Handle /* works for all: PCE */
103 #define __TASK_NAME__  "TaskAsop"
106 //
107 // Audio Stream Output Task definitions
108 //
110 // status codes
111 // Output FSM
112 #define ASOP_INITSYNC_NOTREADY      (  1 )  // ok, init-sync not ready
113 #define ASOP_SOK                    (  0 )  // ok
114 #define ASOP_FORWARD_ERR            ( -1 )  // forward (ASIT) error
115 #define ASOP_ENCRESET_ERR           ( -2 )  // enc reset error
116 #define ASOP_DECINFO1_ERR           ( -3 )  // dec info1 error
117 // Decode Processing
118 #define ASOP_DP_OUT_SIO_UPDATE      (  3 )  // new output selected
119 #define ASOP_DP_CB_DRAINED          (  2 )  // circular buffer drained
120 #define ASOP_DP_SOK                 (  0 )  // ok
121 #define ASOP_DP_FORWARD_ERR         ( -1 )  // forward (ASIT) error
122 #define ASOP_DP_DECINIT_ERR         ( -2 )  // decode init error
123 #define ASOP_DP_DECSTREAM_ERR       ( -3 )  // decode stream error
124 #define ASOP_DP_DECENC_ERR          ( -4 )  // decode encode error
125 #define ASOP_DP_DECINFO2_ERR        ( -5 )  // decode encode error
126 #define ASOP_DP_DECFINALTEST_ERR    ( -6 )  // decode final error
130 /* Check if at least one output selected */
131 static Int checkOutSel(
132     const PAF_ASOT_Params *pP, 
133     PAF_ASOT_Config *pAsotCfg,
134     Int *pOutSel
135 );
137 /* Check if at least one output sio changed */
138 static Int checkOutSio(
139     const PAF_ASOT_Params *pP, 
140     PAF_ASOT_Config *pAsotCfg,
141     Int *pOutSioUpdate
142 );
144 // Initialize Output Processing state function
145 static Int PAF_ASOT_initOutProc(
146     const PAF_ASOT_Params *pP, 
147     PAF_AST_Stream *xStr
148 );
150 // Initialize Output Processing state function
151 static Int PAF_ASOT_initSyncDecReset(
152     const PAF_ASOT_Params *pP, 
153     const PAF_ASOT_Patchs *pQ, 
154     PAF_ASOT_Config *pAsotCfg,
155     PAF_AudioFrame *pDecResetAf
156 );
158 //   Purpose:   ASOT Function for resetting output processing.
159 static Int PAF_ASOT_outputReset(
160     const PAF_ASOT_Params *pP, 
161     const PAF_ASOT_Patchs *pQ, 
162     PAF_ASOT_Config *pAsotCfg
163 );
165 //   Purpose:   Init-Sync Dec Info1 state function.
166 //              Performes Dec Info1 Init-Sync.
167 static Int PAF_ASOT_initSyncDecInfo1(
168     const PAF_ASOT_Params *pP, 
169     const PAF_ASOT_Patchs *pQ, 
170     PAF_ASOT_Config *pAsotCfg,
171     PAF_AudioFrame *pDecInfo1Af
172 );
174 //   Purpose:   Init-Sync Re-Sync state function.
175 //              Peformed Init-Sync using stored Dec Reset/Info1 AFs.
176 static Int PAF_ASOT_initSyncResync(
177     const PAF_ASOT_Params *pP, 
178     const PAF_ASOT_Patchs *pQ, 
179     PAF_ASOT_Config *pAsotCfg,
180     PAF_AudioFrame *pDecResetAf,
181     PAF_AudioFrame *pDecInfo1Af  
182 );
184 // Init-Sync update audio frame
185 static Int initSyncUpdateAf(
186     PAF_AudioFrame *dstAf, 
187     PAF_AudioFrame *srcAf
188 );
190 // Reset audio frames
191 static Void resetAfs(
192     const PAF_ASOT_Params *pP, 
193     PAF_AST_Stream *xStr
194 );
196 // Reset audio frame pointers to original values
197 static Void resetAfPointers(
198     const PAF_ASOT_Params *pP, 
199     PAF_AST_Stream *xStr
200 );
202 // Reset audio frame meta data elements
203 static Void resetAfMetadata(
204     const PAF_ASOT_Params *pP, 
205     PAF_AST_Stream *xStr
206 );
209 LINNO_DEFN(TaskAsop); /* Line number macros */
210 ERRNO_DEFN(TaskAsop); /* Error number macros */
212 // ASOT configuration
213 #pragma DATA_SECTION(gPAF_ASOT_config, ".globalSectionPafAsotConfig")
214 PAF_ASOT_Config gPAF_ASOT_config = {
215     NULL,               // taskHandle
216     NULL,               // acp
217     0,0,0,              // CB drained flags (size DECODE_MAXN)
218     &gPAF_ASPM_config,  // pAspmCfg
219     &gPAF_AST_config    // pAstCfg
220 };
222 // Underflow threshold before circular buffer reset and return error to Top-Level FSM
223 #define DEC_OP_CB_RDAF_UND_THR  ( 80 ) // FL: arbitrary setting
224 UInt32 gCbReadAfErr         =0; // read circular buffer error count, not including underflows
225 UInt32 gDecOpCbRdAfUnd      =0; // decoder output circular buffer underflow count
226 UInt32 gMaxDecOpCbRdAfUnd   =0; // max (consecutive) decoder output circular buffer underflow count
227 UInt32 gMasterCbResetCnt    =0; // master circular buffer reset count
229 // Global debug counters */
230 UInt32 gTaskAsopCnt=0; // debug
231 UInt32 gAsopInitCnt         =0;
232 UInt32 gAsopStreamCnt       =0;
233 UInt32 gAsopEncodeCnt       =0;
234 UInt32 gAsopFinalCnt        =0;
235 UInt32 gAsopQuitCnt         =0;
236 UInt32 gAsopOutSioUpdateCnt =0;
239 /*
240  *  ======== taskAsopFxn ========
241  *  Audio Stream Output Processing task function
242  */
243 Void taskAsopFxn(
244 //    Int betaPrimeValue, // FL: revisit
245     const PAF_ASOT_Params *pP,
246     const PAF_ASOT_Patchs *pQ
249     PAF_ASOT_Config *pAsotCfg;      /* ASOT configuration pointer */
250     PAF_AST_Config *pAstCfg;        /* Common (shared) configuration pointer */
251     Int as;                         /* Audio Stream Number (1, 2, etc.) */
252     Int z;                          /* input/encode/stream/decode/output counter */
253     Int i;                          /* phase */
254     Int errno;                      /* error number */
255     Int zMS;
256     Int loopCount = 0;  // used to stop trace to see startup behavior.        
257     Int outSel;
258     enum { INIT_OUT_PROC_STATE, INITSYNC_DEC_RESET_STATE, INITSYNC_DEC_INFO1_STATE, INITSYNC_RESYNC_STATE, OUT_PROC_STATE } state;
259     PAF_AudioFrame decResetAf;
260     PAF_AudioFrame decInfo1Af;
261     
263     Log_info0("Enter taskAsopFxn()");    
265     //
266     // Audio Stream Output Task Parameters & Patch (*pP, *pQ)
267     //
268     if (!pP) 
269     {
270         TRACE_TERSE0("TaskAsop: No Parameters defined. Exiting.");
271         LINNO_RPRT(TaskAsop, -1);
272         return;
273     }
275     if (!pQ)
276     {
277         TRACE_TERSE0("TaskAsip: No Patchs defined. Exiting.");
278         LINNO_RPRT(TaskAsop, -1);
279         return;
280     }    
282     //
283     // Audio Stream Output Task Configuration (*pAsotCfg):
284     //
285     pAsotCfg = &gPAF_ASOT_config;       // initialize pointer to task configuration
286     pAsotCfg->taskHandle = Task_self(); // set task handle
287     pAstCfg = pAsotCfg->pAstCfg;        // get pointer to AST common (shared) configuration
289     /* Obtain Audio Stream Number (1, 2, etc.) */    
290     as = pAstCfg->as;
291     TRACE_TERSE1("TaskAsop: Started with AS%d.", as);
293     //
294     // Initialize message log trace and line number reporting
295     //
296     for (z=STREAM1; z < STREAMN; z++)
297     {
298         TRACE_TERSE1("TaskAsop: AS%d: initiated", as+z);
299     }
300     LINNO_RPRT(TaskAsop, -1);
301     
302     //
303     // Determine stream index
304     //
305     zMS = pAstCfg->masterStr;
307     // Initialize as per parametrized phases:
308     //
309     //   In standard form these are:
310     //      - Malloc: Memory Allocation
311     //      - Config: Configuration Initialization
312     //      - AcpAlg: ACP Algorithm Initialization and Local Attachment
313     //      - Common: Common Memory Initialization
314     //      - AlgKey: Dec/Enc chain to Array Initialization
315     //      - Device: I/O Device Initialization
316     //      - Unused: (available)
317     //      - Unused: (available)
318     //
319     LINNO_RPRT(TaskAsop, -2);
320     for (i=0; i < lengthof(pP->fxns->initPhase); i++)
321     {
322         Int linno;
323         if (pP->fxns->initPhase[i])
324         {
325             linno = pP->fxns->initPhase[i](pP, pQ, pAsotCfg);
326             if (linno) 
327             {
328                 LINNO_RPRT(TaskAsop, linno);
329                 return;
330             }
331         }
332         else 
333         {
334             TRACE_TERSE1("TaskAsop: AS%d: initialization phase - null", as+zMS);
335         }
336         TRACE_TERSE2("TaskAsop: AS%d: initialization phase - %d completed", as+zMS, i);
337         LINNO_RPRT(TaskAsop, -i-3);
338     }
339   
340     //
341     // End of Initialization -- display memory usage report.
342     //
343     if (pP->fxns->memStatusPrint)
344     {
345         pP->fxns->memStatusPrint("ASOT MEMSTAT REPORT",
346             HEAP_INTERNAL, HEAP_INTERNAL1, HEAP_EXTERNAL, 
347             HEAP_INTERNAL1_SHM, HEAP_EXTERNAL_SHM, HEAP_EXTERNAL_NONCACHED_SHM);
348     }
350     //
351     // Main processing loop
352     //   
353     for (z=STREAM1; z < STREAMN; z++)
354     {
355         TRACE_VERBOSE1("TaskAsip: AS%d: running", as+z);
356     }
357     
358     state = INIT_OUT_PROC_STATE;    // initialize state
359     errno = 0;                      // reset error indicator
360     for (;;)
361     {
362         loopCount++;
363         TRACE_GEN2("TaskAsop (begin Main loop %d) (errno 0x%x)", loopCount, errno);
365         //
366         // Check forward (ASIT) error here, TBD
367         //
368         
369         // any error forces idling of output
370         if (errno) 
371         {
372             for (z=OUTPUT1; z < OUTPUTN; z++)
373             {
374                 if (pAstCfg->xOut[z].hTxSio)
375                 {
376                     SIO_idle(pAstCfg->xOut[z].hTxSio);
377                 }
378             }
379         
380             TRACE_TERSE1("TaskAsop: Trace stopped at loop %d.", loopCount);
381             ERRNO_RPRT(TaskAsop, errno);
382         }        
383         
384         TRACE_VERBOSE1("TaskAsop: AS%d: ... sleeping ...", as+zMS);
385         Task_sleep(1);
387         // select output devices
388         TRACE_GEN1("TaskAsop: AS%d: Output device selection ...", as+zMS);
389         errno = pP->fxns->selectDevices(pP, pQ, pAsotCfg);
390         if (errno)
391         {
392             TRACE_TERSE2("TaskAsop: AS%d: selectDevices returned errno = 0x%04x", as+zMS, errno);
393             continue;
394         }
396         // if no output selected skip remaining processing
397         errno = checkOutSel(pP, pAsotCfg, &outSel);
398         if (errno < 0)
399         {
400             TRACE_TERSE2("TaskAsop: AS%d: checkOutSel returned errno = 0x%04x", as+zMS, errno);
401             continue;
402         }
403         else if (!outSel)
404         {
405             TRACE_VERBOSE1("TaskAsop: AS%d: No output selected...", as+zMS);            
406             continue;
407         }
408         
409         switch (state)
410         {
411             case INIT_OUT_PROC_STATE:
412                 Log_info0("TaskAsop: state=INIT_OUT_PROC_STATE");
413                 
414                 //
415                 // Output Processing initialization.
416                 //
417                 errno = PAF_ASOT_initOutProc(pP, pAstCfg->xStr);
418                 if (errno < 0)
419                 {
420                     state = INIT_OUT_PROC_STATE;
421                 }
422                 else
423                 {
424                     state = INITSYNC_DEC_RESET_STATE;
425                 }
426             
427                 break;
428                 
429             case INITSYNC_DEC_RESET_STATE:
430                 Log_info0("TaskAsop: state=INITSYNC_DEC_RESET_STATE");
432                 //
433                 // Dec Reset Init-Sync.
434                 //  
435                 
436                 // Perform Dec Reset init-sync.
437                 // Latch Dec Reset AF.
438                 errno = PAF_ASOT_initSyncDecReset(pP, pQ, pAsotCfg, &decResetAf);
439                 if (errno < 0)
440                 {
441                     Log_info1("TaskAsop: state=INITSYNC_DEC_RESET_STATE errno=%d", errno);
442                     // sync error -- start over
443                     state = INIT_OUT_PROC_STATE;
444                 }
445                 else if (errno == ASOP_INITSYNC_NOTREADY)
446                 {
447                     Log_info1("TaskAsop: state=INITSYNC_DEC_RESET_STATE not sync'd errno=%d", errno);
448                     // sync not ready -- try again
449                     state = INITSYNC_DEC_RESET_STATE;
450                 }
451                 else // errno==0
452                 {
453                     Log_info1("TaskAsop: state=INITSYNC_DEC_RESET_STATE sync'd, errno=%d", errno);
454                     // sync'd -- move on
455                     state = INITSYNC_DEC_INFO1_STATE;
456                 }
457                 
458                 break;
459             
460             case INITSYNC_DEC_INFO1_STATE:
461                 Log_info0("TaskAsop: state=INITSYNC_DEC_INFO1_STATE");
462                 
463                 //
464                 // Dec Info1 Init-Sync.
465                 //
467                 // Perform Dec Info1 init-sync.
468                 // Latch Dec Info1 AF.
469                 errno = PAF_ASOT_initSyncDecInfo1(pP, pQ, pAsotCfg, &decInfo1Af);
470                 if (errno < 0)
471                 {
472                     Log_info1("TaskAsop: state=INITSYNC_DEC_INFO1_STATE errno=%d", errno);
473                     // sync error -- start over
474                     state = INIT_OUT_PROC_STATE;
475                 }
476                 else if (errno == ASOP_INITSYNC_NOTREADY)
477                 {
478                     Log_info1("TaskAsop: state=INITSYNC_DEC_INFO1_STATE not sync'd errno=%d", errno);
479                     // sync not ready -- try again
480                     state = INITSYNC_DEC_INFO1_STATE;
481                 }
482                 else // errno = 0
483                 {
484                     Log_info1("TaskAsop: state=INITSYNC_DEC_INFO1_STATE sync'd errno=%d", errno);
485                     // sync'd -- move on
486                     state = OUT_PROC_STATE;
487                 }
488                 
489                 break;
490             
491             case INITSYNC_RESYNC_STATE:
492                 Log_info0("TaskAsop: state=INITSYNC_RESYNC_STATE");
494                 //
495                 // Re-Sync.
496                 // Use stored AF info from init-sync.
497                 // This is done in case of local error.
498                 //
499                 
500                 // Perform Dec Info1 init-sync.
501                 errno = PAF_ASOT_initSyncResync(pP, pQ, pAsotCfg, &decResetAf, 
502                     &decInfo1Af);
503                 if (errno < 0)
504                 {
505                     Log_info1("TaskAsop: state=INITSYNC_RESYNC_STATE errno=%d", errno);
506                     // sync error -- start over
507                     state = INIT_OUT_PROC_STATE;
508                 }
509                 else
510                 {
511                     Log_info1("TaskAsop: state=INITSYNC_RESYNC_STATE sync'd errno=%d", errno);
512                     // re-sync'd -- move on
513                     state = OUT_PROC_STATE;
514                 }
515                     
516                 break;
517             
518             case OUT_PROC_STATE:        
519                 Log_info0("TaskAsop: state=OUT_PROC_STATE");
520                 
521                 //
522                 // Output Processing.
523                 //
525                 TRACE_VERBOSE0("TaskAsop: calling decodeProcessing.");
526                 errno = pP->fxns->decodeProcessing(pP, pQ, pAsotCfg);
527                 if (errno < 0)
528                 {
529                     Log_info1("TaskAsop: state=OUT_PROC_STATE errno=%d", errno);
530                     
531                     //
532                     // Output Processing exit, due to error
533                     //
534                     
535                     TRACE_TERSE1("TaskAsop: decodeProcessing returns 0x%x, continue", errno);
536                     if (errno == ASOP_DP_FORWARD_ERR)
537                     {
538                         // forward (ASIT) error -- start over
539                         state = INIT_OUT_PROC_STATE;
540                     }
541                     else
542                     {
543                         // local (ASOT) error
544                         state = INITSYNC_RESYNC_STATE;    
545                     }        
546                 }
547                 else if (errno > 0)
548                 {
549                     Log_info1("TaskAsop: state=OUT_PROC_STATE errno=%d", errno);
551                     //
552                     // Output Processing exit, not due to error
553                     //
555                     TRACE_TERSE1("TaskAsop: decodeProcessing returns 0x%x, continue", errno);                    
556                     if (errno == ASOP_DP_OUT_SIO_UPDATE)
557                     {
558                         // skip re-sync
559                         // resume output processing after new output selected
560                         state = OUT_PROC_STATE;
561                     }
562                 }
563                 else
564                 {
565                     Log_info1("TaskAsop: state=OUT_PROC_STATE errno=%d", errno);
567                     //
568                     // Output Processing exit, normal
569                     //
570                     
571                     TRACE_VERBOSE0("TaskAsop: outputProcessing complete with no error.");
572                     
573                     // no error returned if CB drained 
574                     // (i.e. CB drained is normal behavior)
575                     state = OUT_PROC_STATE;
576                 }
577                 
578                 break;
579             
580             default: // unknown state
581                 TRACE_TERSE2("TaskAsop: AS%d: state: unknown, 0x%x", as+zMS, state);
582                 break;
583         }
584     } // End of main processing loop for (;;)
585     
586     //Log_info0("Exit taskAsopFxn()");
589 // -----------------------------------------------------------------------------
590 // AST Initialization Function - Memory Allocation
591 //
592 //   Name:      PAF_ASOT_initPhaseMalloc
593 //   Purpose:   Audio Stream Output Task Function for initialization of data pointers
594 //              by allocation of memory.
595 //   From:      audioStream1Task or equivalent
596 //   Uses:      See code.
597 //   States:    x
598 //   Return:    0 on success.
599 //              Source code line number on MEM_calloc failure.
600 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
601 //              * State information as per parent.
602 //              * Memory allocation errors.
603 //
605 Int
606 PAF_ASOT_initPhaseMalloc (
607     const PAF_ASOT_Params *pP, 
608     const PAF_ASOT_Patchs *pQ, 
609     PAF_ASOT_Config *pAsotCfg
612     PAF_AST_Config *pAstCfg;
613     Int as;                     /* Audio Stream Number (1, 2, etc.) */
614     Int zMS;
615     Error_Block    eb;
616     //Int i;
618     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
619     as = pAstCfg->as;
620     zMS = pAstCfg->masterStr;
622     TRACE_TERSE1("PAF_ASOT_initPhaseMalloc: AS%d: initialization phase - memory allocation", as+zMS);
624     // Initialize error block
625     Error_init(&eb); 
627     /* Stream memory */
628     if (!(pAstCfg->xStr = Memory_calloc((IHeap_Handle)HEAP_INTERNAL, STREAMN * sizeof (*pAstCfg->xStr), 4, &eb)))
629     {
630         TRACE_TERSE1("PAF_ASOT_initPhaseMalloc: AS%d: Memory_calloc failed", as+zMS);
631         SW_BREAKPOINT;
632         return __LINE__;
633     }
634     TRACE_TERSE3("PAF_ASOT_initPhaseMalloc. (pAstCfg->xStr) %d bytes from space %d at 0x%x.",
635             STREAMN * sizeof (*pAstCfg->xStr),
636             HEAP_ID_INTERNAL, (IArg)pAstCfg->xStr);
638     {
639         Int z;                          /* stream counter */
641         PAF_AudioFrame *fBuf;
643         if (!(fBuf = (PAF_AudioFrame *)Memory_calloc((IHeap_Handle)HEAP_INTERNAL, STREAMS * sizeof (*fBuf), 4, &eb)))
644         {
645             TRACE_TERSE1("PAF_ASOT_initPhaseMalloc: AS%d: Memory_calloc failed", as+zMS);
646             SW_BREAKPOINT;
647             return __LINE__;
648         }
649         TRACE_TERSE3("PAF_ASOT_initPhaseMalloc. (fBuf) %d bytes from space %d at 0x%x.",
650                 STREAMS * sizeof (*fBuf),
651                 HEAP_ID_INTERNAL, (IArg)fBuf);
653         for (z=STREAM1; z < STREAMN; z++)
654         {
655             pAstCfg->xStr[z].pAudioFrame = &fBuf[z-STREAM1];
656             TRACE_TERSE2("pAstCfg->xStr[%d].pAudioFrame = 0x%x", z, (IArg)pAstCfg->xStr[z].pAudioFrame);
657         }
658     }
660     /* Encode memory */
661     if (!(pAstCfg->xEnc = Memory_calloc((IHeap_Handle)HEAP_INTERNAL, ENCODEN * sizeof (*pAstCfg->xEnc), 4, &eb)))
662     {
663         TRACE_TERSE1("PAF_ASOT_initPhaseMalloc: AS%d: Memory_calloc failed", as+zMS);
664         SW_BREAKPOINT;
665         return __LINE__;
666     }
667     TRACE_TERSE3("PAF_ASOT_initPhaseMalloc. (pAstCfg->xEnc) %d bytes from space %d at 0x%x.",
668             ENCODEN * sizeof (*pAstCfg->xEnc),
669             HEAP_ID_INTERNAL, (IArg)pAstCfg->xEnc);
671     /* Output memory */
672     if (!(pAstCfg->xOut = Memory_calloc((IHeap_Handle)HEAP_INTERNAL, OUTPUTN * sizeof (*pAstCfg->xOut), 4, &eb)))
673     {
674         TRACE_TERSE1("PAF_ASOT_initPhaseMalloc: AS%d: Memory_calloc failed", as+zMS);
675         SW_BREAKPOINT;
676         return __LINE__;
677     }
678     TRACE_TERSE3("PAF_ASOT_initPhaseMalloc. (pAstCfg->xOut) %d bytes from space %d at 0x%x.",
679             OUTPUTN * sizeof (*pAstCfg->xOut),
680             HEAP_ID_INTERNAL, (IArg)pAstCfg->xOut);
682     TRACE_TERSE1("PAF_ASOT_initPhaseMalloc: AS%d: initialization phase - memory allocation complete.", as+zMS);
683     return 0;
684 } //PAF_ASOT_initPhaseMalloc
686 // -----------------------------------------------------------------------------
687 // ASOT Initialization Function - Memory Initialization from Configuration
688 //
689 //   Name:      PAF_ASOT_initPhaseConfig
690 //   Purpose:   Audio Stream Output Task Function for initialization of data values
691 //              from parameters.
692 //   From:      audioStream1Task or equivalent
693 //   Uses:      See code.
694 //   States:    x
695 //   Return:    0 on success.
696 //              Other as per initFrame0 and initFrame1.
697 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
698 //              * State information as per parent.
699 //
700 Int
701 PAF_ASOT_initPhaseConfig(
702     const PAF_ASOT_Params *pP, 
703     const PAF_ASOT_Patchs *pQ, 
704     PAF_ASOT_Config *pAsotCfg
707     PAF_AST_Config *pAstCfg;
708     Int as;                     /* Audio Stream Number (1, 2, etc.) */
709     Int z;                      /* input/encode/stream/decode/output counter */
710     Int zMS;
712     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
713     as = pAstCfg->as;
714     zMS = pAstCfg->masterStr;
716     TRACE_TERSE1("PAF_ASOT_initPhaseConfig: AS%d: initialization phase - configuration", as+zMS);
718     //
719     // Unspecified elements have been initialized to zero during alloc
720     //
722     for (z=STREAM1; z < STREAMN; z++) 
723     {
724         Int linno;
725         if (linno = pP->fxns->initFrame0(pP, pQ, pAsotCfg, z))
726         {
727             return linno;           
728         }
729         if (linno = pP->fxns->initFrame1(pP, pQ, pAsotCfg, z, -1))
730         {
731             return linno;
732         }
733     }
735     for (z=ENCODE1; z < ENCODEN; z++) 
736     {
737         Int zO = pP->outputsFromEncodes[z];
738         Int zS = pP->streamsFromEncodes[z];
739         pAstCfg->xEnc[z].encodeControl.size = sizeof(pAstCfg->xEnc[z].encodeControl);
740         pAstCfg->xEnc[z].encodeControl.pAudioFrame = pAstCfg->xStr[zS].pAudioFrame;
741         pAstCfg->xEnc[z].encodeControl.pVolumeStatus = &pAstCfg->xEnc[z].volumeStatus;
742         pAstCfg->xEnc[z].encodeControl.pOutBufConfig = &pAstCfg->xOut[zO].outBufConfig;
743         pAstCfg->xEnc[z].encodeStatus = *pP->z_pEncodeStatus[z];
744         pAstCfg->xEnc[z].encodeControl.encActive = pAstCfg->xEnc[z].encodeStatus.select;
745         pAstCfg->xEnc[z].volumeStatus = *pP->pVolumeStatus;
746         pAstCfg->xEnc[z].encodeInStruct.pAudioFrame = pAstCfg->xStr[zS].pAudioFrame;
747     }
749     for (z=OUTPUT1; z < OUTPUTN; z++)
750     {
751         pAstCfg->xOut[z].outBufStatus = *pP->pOutBufStatus;
752     }
754     TRACE_TERSE1("PAF_ASOT_initPhaseConfig: AS%d: initialization phase - configuration complete.", as+zMS);
755     return 0;
756 } //PAF_ASOT_initPhaseConfig
758 // -----------------------------------------------------------------------------
759 // ASOT Initialization Function - ACP Algorithm Instantiation
760 //
761 //   Name:      PAF_ASOT_initPhaseAcpAlg
762 //   Purpose:   Audio Stream Input Task Function for initialization of ACP by
763 //              instantiation of the algorithm.
764 //   From:      audioStream1Task or equivalent
765 //   Uses:      See code.
766 //   States:    x
767 //   Return:    0 on success.
768 //              Source code line number on ACP Algorithm creation failure.
769 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
770 //              * State information as per parent.
771 //              * Memory allocation errors.
772 //
773 Int
774 PAF_ASOT_initPhaseAcpAlg(
775     const PAF_ASOT_Params *pP, 
776     const PAF_ASOT_Patchs *pQ, 
777     PAF_ASOT_Config *pAsotCfg
780     PAF_AST_Config *pAstCfg;
781     Int as;                     /* Audio Stream Number (1, 2, etc.) */
782     Int z;                      /* input/encode/stream/decode/output counter */
783     Int betaPrimeOffset;
784     ACP_Handle acp;
785     Int zMS;
786     Int zS, zX;
788     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
789     as = pAstCfg->as;
790     zMS = pAstCfg->masterStr;
792     TRACE_TERSE1("PAF_ASOT_initPhaseAcpAlg: AS%d: initialization phase - ACP Algorithm", as+zMS);
794     ACP_MDS_init();
796     if (!(acp = (ACP_Handle )ACP_MDS_create(NULL))) 
797     {
798         TRACE_TERSE1("PAF_ASOT_initPhaseAcpAlg: AS%d: ACP algorithm instance creation  failed", as+zMS);
799         return __LINE__;
800     }
801     pAsotCfg->acp = acp;
803     ((ALG_Handle)acp)->fxns->algControl((ALG_Handle) acp,
804         ACP_GETBETAPRIMEOFFSET, (IALG_Status *)&betaPrimeOffset);
806     for (z=ENCODE1; z < ENCODEN; z++) 
807     {
808         zS = pP->streamsFromEncodes[z];
809         acp->fxns->attach(acp, ACP_SERIES_STD,
810             STD_BETA_ENCODE + betaPrimeOffset * (as-1+zS),
811             (IALG_Status *)&pAstCfg->xEnc[z].encodeStatus);
812         acp->fxns->attach(acp, ACP_SERIES_STD,
813             STD_BETA_VOLUME + betaPrimeOffset * (as-1+zS),
814             (IALG_Status *)&pAstCfg->xEnc[z].volumeStatus);
815         /* Ignore errors, not reported. */
816     }
818     for (z=OUTPUT1; z < OUTPUTN; z++) 
819     {
820         zS = z;
821         for (zX = ENCODE1; zX < ENCODEN; zX++) 
822         {
823             if (pP->outputsFromEncodes[zX] == z) 
824             {
825                 zS = pP->streamsFromEncodes[zX];
826                 break;
827             }
828         }
829         acp->fxns->attach(acp, ACP_SERIES_STD,
830             STD_BETA_OB + betaPrimeOffset * (as-1+zS),
831             (IALG_Status *)&pAstCfg->xOut[z].outBufStatus);
832         /* Ignore errors, not reported. */
833     }
835     TRACE_TERSE1("PAF_ASOT_initPhaseAcpAlg: AS%d: initialization phase - ACP Algorithm complete.", as+zMS);
837     return 0;
838 } //PAF_ASOT_initPhaseAcpAlg
840 // -----------------------------------------------------------------------------
841 // ASOT Initialization Function - Common Memory
842 //
843 //   Name:      PAF_ASOT_initPhaseCommon
844 //   Purpose:   Audio Stream Output Task Function for allocation of common memory.
845 //   From:      audioStream1Task or equivalent
846 //   Uses:      See code.
847 //   States:    x
848 //   Return:    0 on success.
849 //              Source code line number on PAF_ALG_alloc failure.
850 //              Source code line number on PAF_ALG_mallocMemory failure.
851 //              Source code line number on Decode Chain initialization failure.
852 //              Source code line number on ASP Chain initialization failure.
853 //              Source code line number on Encode Chain initialization failure.
854 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
855 //              * State information as per parent.
856 //              * Memory allocation errors.
857 //
858 Int
859 PAF_ASOT_initPhaseCommon(
860     const PAF_ASOT_Params *pP, 
861     const PAF_ASOT_Patchs *pQ, 
862     PAF_ASOT_Config *pAsotCfg
865     PAF_AST_Config *pAstCfg;
866     Int as;                     /* Audio Stream Number (1, 2, etc.) */
867     Int z;                      /* stream counter */
868     Int g;                      /* gear */
869     ACP_Handle acp;
870     PAF_IALG_Config pafAlgConfig;
871     IALG_MemRec common[3][PAF_IALG_COMMON_MEMN+1];
872    
873     acp = pAsotCfg->acp;
874     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
875     as = pAstCfg->as;
877     TRACE_TERSE0("PAF_ASOT_initPhaseCommon: initialization phase - Common Memory");
879     //
880     // Determine memory needs and instantiate algorithms across audio streams
881     //
882     TRACE_TERSE0("PAF_ASOT_initPhaseCommon: calling PAF_ALG_setup.");
883     PAF_ALG_setup(&pafAlgConfig, 
884         HEAP_ID_INTERNAL,                 HEAP_INTERNAL, 
885         HEAP_ID_INTERNAL1,                HEAP_INTERNAL1, 
886         HEAP_ID_EXTERNAL,                 HEAP_EXTERNAL, 
887         HEAP_ID_INTERNAL1_SHM,            HEAP_INTERNAL1_SHM, 
888         HEAP_ID_EXTERNAL_SHM,             HEAP_EXTERNAL_SHM, 
889         HEAP_ID_EXTERNAL_NONCACHED_SHM,   HEAP_EXTERNAL_NONCACHED_SHM,
890         HEAP_CLEAR);
892     if (pP->fxns->headerPrint)
893     {
894         pP->fxns->headerPrint();        
895     }
897     for (z = STREAM1; z < STREAMN; z++) 
898     {
899         //Int zD, zE, zX;
900         Int zE, zX;
902         TRACE_TERSE1("PAF_ASOT_initPhaseCommon: AS%d: initialization phase - Common Memory", as+z);
904         //
905         // Determine common memory needs for:
906         //  (1) ASP Algorithms
907         //  (2) Encode Algorithms
908         //  (3) Logical Output drivers
909         //
910         PAF_ALG_init(common[z], lengthof(common[z]), COMMONSPACE);
912         zE = -1;
913         for (zX = ENCODE1; zX < ENCODEN; zX++) 
914         {
915             if (pP->streamsFromEncodes[zX] == z) 
916             {
917                 zE = zX;
918                 break;
919             }
920         }
922         TRACE_TERSE1("Calling PAF_ALG_ALLOC for stream common[%d].", z);
923         if (PAF_ALG_ALLOC(aspLinkInit[z-STREAM1][0], common[z])) 
924         {
925             TRACE_TERSE1("PAF_ASOT_initPhaseCommon: AS%d: PAF_ALG_alloc failed", as+z);
926             TRACE_TERSE2("Failed to alloc %d bytes from space %d ", common[z]->size, common[z]->space);
927             SW_BREAKPOINT;
928             return __LINE__;
929         }
930         TRACE_TERSE3("alloced %d bytes from space %d at 0x%x", common[z]->size, common[z]->space, (IArg)common[z]->base);
931         if (pP->fxns->allocPrint)
932         {
933             pP->fxns->allocPrint((const PAF_ALG_AllocInit *)(aspLinkInit[z-STREAM1][0]), sizeof (*(aspLinkInit[z-STREAM1][0])), &pafAlgConfig);
934         }
936         if (zE >= 0) 
937         {
938             TRACE_TERSE1("PAF_ASOT_initPhaseCommon: calling PAF_ALG_ALLOC/ for encoder common[%d].", z);
939             if (PAF_ALG_ALLOC(encLinkInit[zE-ENCODE1], common[z])) 
940             {
941                 TRACE_TERSE1("PAF_ASOT_initPhaseCommon: AS%d: PAF_ALG_alloc failed", as+z);
942                 SW_BREAKPOINT;
943                 return __LINE__;
944             }
945             TRACE_TERSE3("alloced %d bytes from space %d at 0x%x", common[z]->size, common[z]->space, (IArg)common[z]->base);
946             if (pP->fxns->allocPrint)
947             {
948                 pP->fxns->allocPrint((const PAF_ALG_AllocInit *)(encLinkInit[z-ENCODE1]), sizeof (*(encLinkInit[z-ENCODE1])), &pafAlgConfig);
949             }
950         }
952         //
953         // Determine common memory needs of Logical IO drivers
954         //
956         if (OUTPUT1 <= z && z < OUTPUTN)
957         {
958             TRACE_TERSE1("PAF_ASOT_initPhaseCommon: calling PAF_ALG_ALLOC outLinkInit common[%d].", z);
959             if (PAF_ALG_ALLOC(outLinkInit[z-OUTPUT1], common[z]))
960             {
961                 TRACE_TERSE1("PAF_ASOT_initPhaseMalloc: AS%d: PAF_ALG_alloc failed", as+z);
962                 TRACE_TERSE2("Failed to alloc %d bytes from space %d", common[z]->size, (IArg)common[z]->space);
963                 SW_BREAKPOINT;
964                 return __LINE__;
965             }
966             TRACE_TERSE3("alloced %d bytes from space %d at 0x%x", common[z]->size, common[z]->space, (IArg)common[z]->base);
967             if (pP->fxns->allocPrint)
968             {
969                 pP->fxns->allocPrint((const PAF_ALG_AllocInit *)(outLinkInit[z-INPUT1]), sizeof (*(outLinkInit[z-INPUT1])), &pafAlgConfig);
970             }
971         }
972     }
973     {
974         // Changes made to share scratch between zones
975         // Assume maximum 3 zones and scratch common memory is at offset 0;
976         int max=0;
977         for (z=STREAM1; z<STREAMN; z++)
978         {
979             if (max < common[z][0].size)
980             {
981                 max = common[z][0].size;
982             }
983         }
984         common[STREAM1][0].size=max;
985         for (z=STREAM1+1; z<STREAMN; z++)
986         {
987             common[z][0].size = 0;            
988         }
989     }
990         
991     //
992     // Allocate common memory for:
993     //  (1) ASP Algorithms
994     //  (2) Encode Algorithms
995     //  (3) Logical Output drivers
996     //
997     for (z = STREAM1; z < STREAMN; z++) 
998     {
999         //Int zD, zE, zX;
1000         Int zE, zX;
1002         TRACE_TERSE0("PAF_ASOT_initPhaseCommon: calling PAF_ALG_mallocMemory for common space.");
1003         if (PAF_ALG_mallocMemory(common[z], &pafAlgConfig)) 
1004         {
1005             TRACE_TERSE1("AS%d: PAF_ALG_mallocMemory failed", as+z);
1006             TRACE_TERSE3("AS%d: z: %d.  Size 0x%x", as+z, z, common[z][0].size);
1007             SW_BREAKPOINT;
1008             return __LINE__;
1009         }
1010         TRACE_TERSE3("alloced %d bytes from space %d at 0x%x", common[z]->size, common[z]->space, (IArg)common[z]->base);
1011         // share zone0 scratch with all zones 
1012         common[z][0].base = common[0][0].base;
1013         if (pP->fxns->commonPrint)
1014         {
1015             pP->fxns->commonPrint(common[z], &pafAlgConfig);
1016         }
1018         zE = -1;
1019         for (zX = ENCODE1; zX < ENCODEN; zX++) 
1020         {
1021             if (pP->streamsFromEncodes[zX] == z) 
1022             {
1023                 zE = zX;
1024                 break;
1025             }
1026         }
1028         pAstCfg->xStr[z].aspChain[0] = NULL;
1029         for (g=0; g < GEARS; g++) 
1030         {
1031             PAF_ASP_Chain *chain;
1032             TRACE_TERSE0("PAF_ASOT_initPhaseCommon: calling PAF_ASP_chainInit for ASPs.");
1033             chain = PAF_ASP_chainInit(&pAstCfg->xStr[z].aspChainData[g], pP->pChainFxns,
1034                 HEAP_INTERNAL, as+z, acp, &trace,
1035                 aspLinkInit[z-STREAM1][g], pAstCfg->xStr[z].aspChain[0], common[z], &pafAlgConfig);
1036             if (!chain) 
1037             {
1038                 TRACE_TERSE2("AS%d: ASP chain %d initialization failed", as+z, g);
1039                 return __LINE__;
1040             }
1041             else
1042             {
1043                 pAstCfg->xStr[z].aspChain[g] = chain;
1044             }
1045         }
1047         if (zE >= 0) 
1048         {
1049             PAF_ASP_Chain *chain;
1050             TRACE_TERSE0("PAF_ASOT_initPhaseCommon: calling PAF_ASP_chainInit for encode.");
1051             chain = PAF_ASP_chainInit(&pAstCfg->xEnc[zE].encChainData, pP->pChainFxns,
1052                 HEAP_INTERNAL, as+z, acp, &trace,
1053                 encLinkInit[zE-ENCODE1], NULL, common[z], &pafAlgConfig);
1054             if (!chain) 
1055             {
1056                 TRACE_TERSE1("AS%d: Encode chain initialization failed", as+z);
1057                 return __LINE__;
1058             }
1059         }
1061         //
1062         // Allocate non-common memories for Logical IO drivers
1063         //    Since these structures are used at run-time we allocate from external memory
1064         if (OUTPUT1 <= z && z < OUTPUTN) 
1065         {
1066             PAF_ASP_Chain *chain;
1067             TRACE_TERSE2("PAF_ASOT_initPhaseMalloc: AS%d: non-common output chain init for %d",
1068                            as+z, z);
1069             chain = PAF_ASP_chainInit (&pAstCfg->xOut[z].outChainData, pP->pChainFxns,
1070                         HEAP_EXTERNAL, as+z, acp, &trace,
1071                         outLinkInit[z-OUTPUT1], NULL, common[z], &pafAlgConfig);
1072             if (!chain) 
1073             {
1074                 TRACE_TERSE1("AS%d: Output chain initialization failed", as+z);
1075                 return __LINE__;
1076             }
1077         }
1078     }
1079     TRACE_TERSE1("AS%d: PAF_ASOT_initPhaseCommon: Returning complete.", as+z);
1081     return 0;
1082 } //PAF_ASOT_initPhaseCommon
1084 // -----------------------------------------------------------------------------
1085 // ASOT Initialization Function - Algorithm Keys
1086 //
1087 //   Name:      PAF_ASOT_initPhaseAlgKey
1088 //   Purpose:   Audio Stream Output Task Function for initialization of data values
1089 //              from parameters for Algorithm Keys.
1090 //   From:      audioStream1Task or equivalent
1091 //   Uses:      See code.
1092 //   States:    x
1093 //   Return:    0.
1094 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
1095 //              * State information as per parent.
1096 //
1097 // .............................................................................
1098 Int
1099 PAF_ASOT_initPhaseAlgKey(
1100     const PAF_ASOT_Params *pP, 
1101     const PAF_ASOT_Patchs *pQ, 
1102     PAF_ASOT_Config *pAsotCfg
1105     PAF_AST_Config *pAstCfg;
1106     Int as;                     /* Audio Stream Number (1, 2, etc.) */
1107     Int z;                      /* decode/encode counter */
1108     Int s;                      /* key number */
1109     PAF_ASP_Link *that;
1111     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
1112     as = pAstCfg->as;
1113     (void)as; // clear compiler warning in case not used with tracing disabled
1115     TRACE_VERBOSE1("PAF_ASOT_initPhaseAlgKey: AS%d: initialization phase - Algorithm Keys", as);
1117     for (z=ENCODE1; z < ENCODEN; z++) 
1118     {
1119         for (s=0; s < pP->pEncAlgKey->length; s++) 
1120         {
1121             if ((pP->pEncAlgKey->code[s].full != 0) && 
1122                 (that = PAF_ASP_chainFind(&pAstCfg->xEnc[z].encChainData, pP->pEncAlgKey->code[s])))
1123             {
1124                 pAstCfg->xEnc[z].encAlg[s] = (ALG_Handle )that->alg;
1125             }
1126             /* Cast in interface, for now --Kurt */
1127             else
1128             {
1129                 pAstCfg->xEnc[z].encAlg[s] = NULL;                
1130             }
1131         }
1132     }
1134     return 0;
1135 } //PAF_ASOT_initPhaseAlgKey
1137 // -----------------------------------------------------------------------------
1138 // ASOT Initialization Function - I/O Devices
1139 //
1140 //   Name:      PAF_ASOT_initPhaseDevice
1141 //   Purpose:   Audio Stream Output Task Function for initialization of I/O Devices.
1142 //   From:      audioStream1Task or equivalent
1143 //   Uses:      See code.
1144 //   States:    x
1145 //   Return:    0 on success.
1146 //              Source code line number on device allocation failure.
1147 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
1148 //              * State information as per parent.
1149 //              * Memory allocation errors.
1150 //
1151 Int
1152 PAF_ASOT_initPhaseDevice(
1153     const PAF_ASOT_Params *pP, 
1154     const PAF_ASOT_Patchs *pQ, 
1155     PAF_ASOT_Config *pAsotCfg
1158     PAF_AST_Config *pAstCfg;
1159     Int as;                     /* Audio Stream Number (1, 2, etc.) */
1160     Int z;                      /* input/output counter */
1161     PAF_SIO_IALG_Obj    *pObj;
1162     PAF_SIO_IALG_Config *pAlgConfig;
1163     PAF_IALG_Config pafAlgConfig;
1165     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
1166     as = pAstCfg->as;
1167     (void)as; // clear compiler warning in case not used with tracing disabled
1169     TRACE_TERSE1("PAF_ASOT_initPhaseDevice: AS%d: initialization phase - I/O Devices", as);
1171     if(pP->fxns->bufMemPrint)
1172     {
1173         PAF_ALG_setup (&pafAlgConfig, 
1174             HEAP_ID_INTERNAL,               HEAP_INTERNAL, 
1175             HEAP_ID_INTERNAL1,              HEAP_INTERNAL1,
1176             HEAP_ID_EXTERNAL,               HEAP_EXTERNAL,
1177             HEAP_ID_INTERNAL1_SHM,          HEAP_INTERNAL1_SHM,
1178             HEAP_ID_EXTERNAL_SHM,           HEAP_EXTERNAL_SHM,
1179             HEAP_ID_EXTERNAL_NONCACHED_SHM, HEAP_EXTERNAL_NONCACHED_SHM,
1180             HEAP_CLEAR);
1181         TRACE_TERSE2("PAF_ASOT_initPhaseDevice: AS%d: calling PAF_ALG_setup with clear at %d.", as, HEAP_CLEAR);
1182     }
1183     
1184     for (z=OUTPUT1; z < OUTPUTN; z++) 
1185     {
1186         PAF_OutBufConfig *pConfig = &pAstCfg->xOut[z].outBufConfig;
1188         pObj = (PAF_SIO_IALG_Obj *)pAstCfg->xOut[z].outChainData.head->alg;
1189         pAlgConfig = &pObj->config;
1191         pAstCfg->xOut[z].hTxSio = NULL;
1192         pConfig->base.pVoid     = pAlgConfig->pMemRec[0].base;
1193         pConfig->pntr.pVoid     = pAlgConfig->pMemRec[0].base;
1194         pConfig->head.pVoid     = pAlgConfig->pMemRec[0].base;
1195         pConfig->allocation     = pAlgConfig->pMemRec[0].size;
1196         pConfig->sizeofElement  = 3;
1197         pConfig->precision      = 24;
1198         if(pP->fxns->bufMemPrint)
1199         {
1200             pP->fxns->bufMemPrint(z,pAlgConfig->pMemRec[0].size,PAF_ALG_memSpaceToHeapId(&pafAlgConfig,pAlgConfig->pMemRec[0].space),1);
1201         }
1202     }
1203     TRACE_TERSE1("PAF_ASOT_initPhaseDevice: AS%d: initialization phase - I/O Devices complete.", as);
1205     return 0;
1206 } //PAF_ASOT_initPhaseDevice
1208 // -----------------------------------------------------------------------------
1209 // ASOT Initialization Function Helper - Initialization of Audio Frame
1210 //
1211 //   Name:      PAF_ASOT_initFrame0
1212 //   Purpose:   Audio Stream Output Task Function for initialization of the Audio
1213 //              Frame(s) by memory allocation and loading of data pointers
1214 //              and values.
1215 //   From:      AST Parameter Function -> decodeInfo
1216 //   Uses:      See code.
1217 //   States:    x
1218 //   Return:    0 on success.
1219 //              Source code line number on MEM_calloc failure.
1220 //              Source code line number on unsupported option.
1221 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
1222 //              * Memory allocation errors.
1223 //              * Unsupported option errors.
1224 //
1226 // MID 314
1227 extern const char AFChanPtrMap[PAF_MAXNUMCHAN+1][PAF_MAXNUMCHAN];
1228 extern PAF_ChannelConfigurationMaskTable PAF_ASP_stdCCMT_patch;
1230 Int
1231 PAF_ASOT_initFrame0(
1232     const PAF_ASOT_Params *pP, 
1233     const PAF_ASOT_Patchs *pQ, 
1234     PAF_ASOT_Config *pAsotCfg, 
1235     Int z
1238     PAF_AST_Config *pAstCfg;
1239     Int as;                     /* Audio Stream Number (1, 2, etc.) */
1240     Int ch;
1241     //Int aLen;
1242     Int aLen_int=0,aLen_ext=0;
1243     Int aSize = sizeof(PAF_AudioData);
1244     Int aAlign = aSize < sizeof (int) ? sizeof (int) : aSize;
1245     Int maxFrameLength = pP->maxFramelength;
1246     Int zX;
1247     PAF_AudioData *aBuf_int=NULL;
1248     PAF_AudioData *aBuf_ext=NULL;
1249     XDAS_UInt8 *metadataBuf;
1250     char i;
1251     Error_Block    eb;
1253     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
1254     as = pAstCfg->as;
1256     // Initialize error block
1257     Error_init(&eb); 
1259     // Compute maximum framelength (needed for ARC support)
1260     maxFrameLength += PA_MODULO - maxFrameLength % PA_MODULO;
1261     //aLen = numchan[z] * maxFrameLength;
1262     for (i=0; i < numchan[z]; i++)
1263     {
1264         if (pP->pAudioFrameBufStatus->space[i] == IALG_SARAM)
1265         {
1266             aLen_int += maxFrameLength;
1267         }
1268         else
1269         {
1270             aLen_ext += maxFrameLength;
1271         }
1272     }
1274     //
1275     // Initialize audio frame elements directly
1276     //
1277     pAstCfg->xStr[z].pAudioFrame->fxns = pP->pAudioFrameFunctions;
1278     pAstCfg->xStr[z].pAudioFrame->data.nChannels = PAF_MAXNUMCHAN; ///
1279 ///    pAstCfg->xStr[z].pAudioFrame->data.nChannels = PAF_MAXNUMCHAN_AF;
1280     pAstCfg->xStr[z].pAudioFrame->data.nSamples = FRAMELENGTH;
1281     pAstCfg->xStr[z].pAudioFrame->data.sample = pAstCfg->xStr[z].audioFrameChannelPointers;
1282     pAstCfg->xStr[z].pAudioFrame->data.samsiz = pAstCfg->xStr[z].audioFrameChannelSizes;
1283     pAstCfg->xStr[z].pAudioFrame->pChannelConfigurationMaskTable = &PAF_ASP_stdCCMT;
1285     //
1286     // Allocate memory for and initialize pointers to audio data buffers
1287     //
1288     //   The NUMCHANMASK is used to identify the channels for which data
1289     //   buffers can be allocated. Using this mask and switch statement
1290     //   rather than some other construct allows efficient code generation,
1291     //   providing just the code necessary (with significant savings).
1292     //
1293     if (pP->fxns->bufMemPrint)
1294     {
1295         pP->fxns->bufMemPrint(z, aLen_int*aSize, HEAP_ID_FRMBUF, 2);
1296         pP->fxns->bufMemPrint(z, aLen_ext*aSize, HEAP_ID_EXTERNAL, 2);
1297     }
1299     TRACE_TERSE1("PAF_ASOT_initFrame0: AS%d: Memory_calloc for audio buffers", as+z);
1300     
1301     if (aLen_int*aSize!=0) // check size != 0, otherwise malloc throws fatal error
1302     {
1303         if (!(aBuf_int = (PAF_AudioData *)Memory_calloc((IHeap_Handle)HEAP_FRMBUF, (aLen_int+(maxFrameLength-FRAMELENGTH))*aSize, aAlign, &eb))) //Qin: Add start offset
1304         {
1305             TRACE_TERSE1("PAF_ASOT_initFrame0: AS%d: Memory_calloc failed", as+z);
1306             TRACE_TERSE2("  maxFrameLength: %d.  aLen_int*aSize: %d", maxFrameLength, (aLen_int+(maxFrameLength-FRAMELENGTH))*aSize);
1307             SW_BREAKPOINT;
1308             return __LINE__;
1309         }
1310     }
1311         
1312     if (aLen_ext*aSize!=0)
1313     {
1314         if (!(aBuf_ext = (PAF_AudioData *)Memory_calloc((IHeap_Handle)HEAP_EXTERNAL, (aLen_ext+(maxFrameLength-FRAMELENGTH))*aSize, aAlign, &eb)))//Qin: Add start offset
1315         {
1316             TRACE_TERSE1("PAF_ASOT_initFrame0: AS%d: Memory_calloc failed", as+z);
1317             TRACE_TERSE2("  maxFrameLength: %d.  aLen_ext*aSize: %d", maxFrameLength, (aLen_ext+(maxFrameLength-FRAMELENGTH))*aSize);
1318             SW_BREAKPOINT;
1319             return __LINE__;
1320         }
1321     }
1322     
1323     TRACE_TERSE3("  maxFrameLength: %d.  aLen_int*aSize: %d.  aBuf_int: 0x%x", maxFrameLength, (aLen_int+(maxFrameLength-FRAMELENGTH))*aSize, (IArg)aBuf_int);
1324     TRACE_TERSE3("  maxFrameLength: %d.  aLen_ext*aSize: %d.  aBuf_ext: 0x%x", maxFrameLength, (aLen_ext+(maxFrameLength-FRAMELENGTH))*aSize, (IArg)aBuf_ext);
1326     TRACE_TERSE1("PAF_ASOT_initFrame0: AS%d: Memory_calloc for metadata buffers", as+z);
1327     if (!(metadataBuf = (XDAS_UInt8 *)Memory_calloc((IHeap_Handle)HEAP_MDBUF, pP->pMetadataBufStatus->bufSize*pP->pMetadataBufStatus->NumBuf, pP->pMetadataBufStatus->alignment, &eb)))
1328     {
1329         TRACE_TERSE1("PAF_ASOT_initFrame0: AS%d: Memory_calloc failed", as+z);
1330         TRACE_TERSE1("  bufSize*NumBuf: %d", pP->pMetadataBufStatus->bufSize*pP->pMetadataBufStatus->NumBuf);
1331         SW_BREAKPOINT;
1332         return __LINE__;
1333     }
1335     {
1336         Int i;
1338 #pragma UNROLL(1)
1339         for (i=0; i < PAF_MAXNUMCHAN_AF; i++)
1340         {
1341             pAstCfg->xStr[z].audioFrameChannelPointers[i] = NULL;
1342         }
1343     }
1345     // MID 314
1346     if((numchan[z] > PAF_MAXNUMCHAN) || (numchan[z] < 1)) 
1347     {
1348         TRACE_TERSE1("PAF_ASOT_initFrame0: AS%d: unsupported option", as+z);
1349         return __LINE__;
1350     }
1351     else 
1352     {
1353         Int j = 0;
1354         Int k = 0;
1355         TRACE_TERSE1("PAF_ASOT_initFrame0: AFChanPtrMap[%d][i]", numchan[z]);
1356         for(i=0;i<numchan[z];i++)
1357         {
1358             char chan = AFChanPtrMap[numchan[z]][i];
1359             if(chan != -1)
1360             {
1361                 if(pP->pAudioFrameBufStatus->space[i] == IALG_SARAM)
1362                 {
1363                     pAstCfg->xStr[z].audioFrameChannelPointers[chan] = aBuf_int + maxFrameLength*(j+1) - FRAMELENGTH;
1364                     j++;
1365                 }
1366                 else
1367                 {        
1368                     pAstCfg->xStr[z].audioFrameChannelPointers[chan] = aBuf_ext + maxFrameLength*(k+1) - FRAMELENGTH;
1369                     k++;
1370                 }    
1371                 TRACE_TERSE3("PAF_ASOT_initFrame0: chan = %d = AFChanPtrMap[%d][%d].", chan, numchan[z], i);
1372                 TRACE_TERSE2("PAF_ASOT_initFrame0: audioFrameChannelPointers[%d]: 0x%x", chan, (IArg)pAstCfg->xStr[z].audioFrameChannelPointers[chan]);
1373             }
1374         }
1375     }
1377     for (ch=PAF_LEFT; ch < PAF_MAXNUMCHAN_AF; ch++) 
1378     {
1379         if (pAstCfg->xStr[z].audioFrameChannelPointers[ch])
1380         {
1381             pAstCfg->xStr[z].origAudioFrameChannelPointers[ch] = pAstCfg->xStr[z].audioFrameChannelPointers[ch];
1382         }
1383     }
1385     //
1386     // Initialize meta data elements
1387     //
1388     pAstCfg->xStr[z].pAudioFrame->pafBsMetadataUpdate = XDAS_FALSE;
1389     pAstCfg->xStr[z].pAudioFrame->numPrivateMetadata = 0;
1390     pAstCfg->xStr[z].pAudioFrame->bsMetadata_offset = 0;
1391     pAstCfg->xStr[z].pAudioFrame->bsMetadata_type = PAF_bsMetadata_channelData;
1392     pAstCfg->xStr[z].pAudioFrame->privateMetadataBufSize = pP->pMetadataBufStatus->bufSize;
1393     for(i=0;i<pP->pMetadataBufStatus->NumBuf;i++)
1394     {
1395         pAstCfg->xStr[z].pAudioFrame->pafPrivateMetadata[i].offset = 0;
1396         pAstCfg->xStr[z].pAudioFrame->pafPrivateMetadata[i].size = 0;
1397         pAstCfg->xStr[z].pAudioFrame->pafPrivateMetadata[i].pMdBuf = metadataBuf + pP->pMetadataBufStatus->bufSize*i;
1398     }
1400     //
1401     // Initialize decoder elements directly
1402     //
1404     for (zX = DECODE1; zX < DECODEN; zX++) 
1405     {
1406         if (pP->streamsFromDecodes[zX] == z) 
1407         {
1408 #ifdef NOAUDIOSHARE
1409             pAstCfg->xDec[zX].decodeInStruct.audioShare.nSamples = 0;
1410             pAstCfg->xDec[zX].decodeInStruct.audioShare.sample = NULL;
1411 #else /* NOAUDIOSHARE */
1412             pAstCfg->xDec[zX].decodeInStruct.audioShare.nSamples = aLen_int;
1413             pAstCfg->xDec[zX].decodeInStruct.audioShare.sample = aBuf_int;
1414 #endif /* NOAUDIOSHARE */
1415         }
1416     }
1418     return 0;
1419 } //PAF_ASOT_initFrame0
1421 // -----------------------------------------------------------------------------
1422 // ASOT Initialization Function Helper - Reinitialization of Audio Frame
1423 // AST Decoding Function              - Reinitialization of Audio Frame
1424 //
1425 //   Name:      PAF_ASOT_initFrame1
1426 //   Purpose:   Audio Stream Task Function for initialization or reinitiali-
1427 //              zation of the Audio Frame(s) by loading of data values of a
1428 //              time-varying nature.
1429 //   From:      audioStream1Task or equivalent
1430 //              AST Parameter Function -> decodeInfo
1431 //              AST Parameter Function -> decodeDecode
1432 //   Uses:      See code.
1433 //   States:    x
1434 //   Return:    0.
1435 //   Trace:     None.
1436 //
1437 Int
1438 PAF_ASOT_initFrame1(
1439     const PAF_ASOT_Params *pP, 
1440     const PAF_ASOT_Patchs *pQ, 
1441     PAF_ASOT_Config *pAsotCfg, 
1442     Int z, 
1443     Int apply
1446     PAF_AST_Config *pAstCfg;
1448     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
1450     //
1451     // Reinitialize audio frame elements:
1452     //
1453     //   Channel Configurations during sys init                 = Unknown
1454     //      "          "        during info or decode           = None
1455     //
1456     //   Sample Rate / Count    during sys init, info or decode = Unknown / 0
1457     //
1459     if (apply < 0) 
1460     {
1461         pAstCfg->xStr[z].pAudioFrame->channelConfigurationRequest.legacy = PAF_CC_UNKNOWN;
1462         pAstCfg->xStr[z].pAudioFrame->channelConfigurationStream.legacy = PAF_CC_UNKNOWN;
1463     }
1464     else 
1465     {
1466         pAstCfg->xStr[z].pAudioFrame->channelConfigurationRequest.legacy = PAF_CC_NONE;
1467         pAstCfg->xStr[z].pAudioFrame->channelConfigurationStream.legacy = PAF_CC_NONE;
1468     }
1470     if (apply < 1) 
1471     {
1472         pAstCfg->xStr[z].pAudioFrame->sampleRate = PAF_SAMPLERATE_UNKNOWN;
1473         pAstCfg->xStr[z].pAudioFrame->sampleCount = 0;
1474     }
1476     return 0;
1477 } //PAF_ASOT_initFrame1
1479 // -----------------------------------------------------------------------------
1480 // ASOT Selection Function - Output Device Selection
1481 //
1482 //   Name:      PAF_ASOT_selectDevices
1483 //   Purpose:   Audio Stream Output Task Function for selecting the devices used
1484 //              for output.
1485 //   From:      audioStream1Task or equivalent
1486 //   Uses:      See code.
1487 //   States:    x
1488 //   Return:    Error number in standard form (0 on success).
1489 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
1490 //              * State information as per parent.
1491 //
1492 Int
1493 PAF_ASOT_selectDevices(
1494     const PAF_ASOT_Params *pP, 
1495     const PAF_ASOT_Patchs *pQ, 
1496     PAF_ASOT_Config *pAsotCfg
1499     PAF_AST_Config *pAstCfg;
1500     Int as;                     /* Audio Stream Number (1, 2, etc.) */
1501     Int z;                      /* input/output counter */
1502     Int errno = 0;              /* error number */
1503     Int errme;                  /* error number, local */
1504     Int device;
1506     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
1507     as = pAstCfg->as;
1508     (void)as;  // clear compiler warning in case not used with tracing disabled
1510     // Select output devices
1511     for (z=OUTPUT1; z < OUTPUTN; z++) 
1512     {
1513         if ((device = pAstCfg->xOut[z].outBufStatus.sioSelect) >= 0) 
1514         {
1515             TRACE_VERBOSE2("PAF_ASOT_selectDevices: AS%d: output device %d selecting ...", as+z, device);
1517             /* check for valid index into device array */
1518             if (device >= pQ->devout->n)
1519             {
1520                 device = 0; /* treat as device None */
1521             }
1523             errme = pP->fxns->deviceSelect(&pAstCfg->xOut[z].hTxSio, SIO_OUTPUT, 
1524                 HEAP_ID_OUTBUF, (Ptr)pQ->devout->x[device]);
1525             if (errme)
1526             {
1527                 TRACE_VERBOSE2("PAF_ASOT_selectDevices: errme 0x%x, errno 0x%x", errme, errno);
1528                 if (!errno)
1529                 {
1530                     errno = ASPERR_DEVOUT + errme;
1531                 }
1532                 pAstCfg->xOut[z].outBufStatus.sioSelect = 0x80;
1533             }
1534             else 
1535             {
1536                 Int zE;
1538                 pAstCfg->xOut[z].outBufStatus.sioSelect = device | 0x80;
1539                 // register outBufStatus and encodeStatus pointers with output devices
1540                 // This enables proper IEC encapsulation.
1541                 if (pAstCfg->xOut[z].hTxSio) 
1542                 {
1543                     // set max # of output buffers (use override if necessary)
1544                     if (pAstCfg->xOut[z].outBufStatus.maxNumBufOverride == 0)
1545                     {
1546                         SIO_ctrl(pAstCfg->xOut[z].hTxSio, PAF_SIO_CONTROL_SET_MAX_NUMBUF,
1547                             (Arg)pP->poutNumBufMap[z]->maxNumBuf);
1548                     }
1549                     else
1550                     {
1551                         SIO_ctrl(pAstCfg->xOut[z].hTxSio, PAF_SIO_CONTROL_SET_MAX_NUMBUF,
1552                             (Arg)pAstCfg->xOut[z].outBufStatus.maxNumBufOverride);
1553                     }
1555                     // register PAF_SIO_IALG object address
1556                     SIO_ctrl(pAstCfg->xOut[z].hTxSio, PAF_SIO_CONTROL_SET_IALGADDR,
1557                         (Arg)pAstCfg->xOut[z].outChainData.head->alg);
1558                     SIO_ctrl(pAstCfg->xOut[z].hTxSio, PAF_SIO_CONTROL_SET_BUFSTATUSADDR, 
1559                         (Arg)&pAstCfg->xOut[z].outBufStatus);
1560                     for (zE=ENCODE1; zE < ENCODEN; zE++) 
1561                     {
1562                         if (pP->outputsFromEncodes[zE] == z) 
1563                         {
1564                             SIO_ctrl(pAstCfg->xOut[z].hTxSio, 
1565                                 PAF_SIO_CONTROL_SET_ENCSTATUSADDR, 
1566                                 (Arg)&pAstCfg->xEnc[zE].encodeStatus);
1567                             break;
1568                         }
1569                     }
1570                 }
1571             }
1572         }
1574         // if device selected and valid then enable stat tracking if
1575         // required and start clocking
1576         if ((pAstCfg->xOut[z].outBufStatus.sioSelect < 0) && (pAstCfg->xOut[z].hTxSio)) 
1577         {
1578             TRACE_VERBOSE0("PAF_ASOT_selectDevices: start SIO clocks");
1579             errme = SIO_ctrl(pAstCfg->xOut[z].hTxSio, PAF_SIO_CONTROL_OUTPUT_START_CLOCKS, 0);
1580             if (errme)
1581             {
1582                 TRACE_VERBOSE2("PAF_ASOT_selectDevices: errme 0x%x, errno 0x%x", errme, errno);
1583                 SIO_idle(pAstCfg->xOut[z].hTxSio);
1584                 if (!errno)
1585                 {
1586                     errno = ASPERR_DEVOUT + errme;
1587                 }
1588             }
1589         }
1590     }
1592     return errno;
1593 } //PAF_ASOT_selectDevices
1596 // -----------------------------------------------------------------------------
1597 // ASOT Processing Function - Decode Processing
1598 //
1599 //   Name:      PAF_ASOT_decodeProcessing
1600 //   Purpose:   Audio Stream Output Task Function for processing audio data.
1601 //
1602 Int
1603 PAF_ASOT_decodeProcessing(
1604     const PAF_ASOT_Params *pP, 
1605     const PAF_ASOT_Patchs *pQ, 
1606     PAF_ASOT_Config *pAsotCfg 
1609     PAF_AST_Config *pAstCfg;
1610     Int errno;                          /* error number */
1611     Int getVal;
1612     enum { INIT, STREAM, ENCODE, FINAL, QUIT, OUT_SIO_UPDATE } state;
1613     state = INIT;
1614     errno = 0; /* error number */
1615     Int frame; // (***) FL: formerly -- decoder input frame count
1616     Int block; // decoder output block count / input frame
1617     Int outSioUpdate;
1618     
1619     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
1621     for (;;) 
1622     {
1623         //
1624         // Check forward (ASIT) error here, TBD
1625         //
1626         
1627         
1628         // Check if any change in output SIO, e.g. from Output shortcut.
1629         // Changes will break FSM and allow Output reconfiguration.
1630         errno = checkOutSio(pP, pAsotCfg, &outSioUpdate);
1631         if (errno < 0)
1632         {
1633             TRACE_TERSE1("PAF_ASOT_decodeProcessing: checkOutSio returned errno = 0x%04x", errno);
1634             break;
1635         }
1636         else if (outSioUpdate)
1637         {
1638             TRACE_VERBOSE0("PAF_ASOT_decodeProcessing: Change in Output SIO selection");
1639             state = OUT_SIO_UPDATE;
1640         }
1641         
1642         // Process commands (encode)
1643         getVal = pP->fxns->encodeCommand(pP, pQ, pAsotCfg);
1644         if (getVal) 
1645         {
1646             /* ignore */;
1647         }
1649         // Process state (decode)
1650         switch (state) 
1651         {
1652             case INIT: // initial state
1653                 gAsopInitCnt++;
1654                 Log_info0("TaskAsop: state=INIT");
1655             
1656                 frame = 0;
1657                 block = 0;
1659 #if 0 // FL: moved to PAF_ASOT_initOutProc()
1660                 // Reset audio frame pointers to original values
1661                 // (may be needed if error occurred).
1662                 resetAfPointers(pP, pAstCfg->xStr);
1663                 // Reset audio frame meta data elements
1664                 resetAfMetadata(pP, pAstCfg->xStr);
1665 #endif
1667                 errno = pP->fxns->decodeInit(pP, pQ, pAsotCfg);
1668                 if (errno)
1669                 {
1670                     TRACE_VERBOSE1("PAF_ASOT_decodeProcessing: INIT, errno 0x%x.  break after decodeInit", errno);
1671                     errno = ASOP_DP_DECINIT_ERR;
1672                     break;
1673                 }
1674                 
1675 #if 0 // FL: moved to PAF_ASOT_initSyncDecInfo1()
1676                 //
1677                 // Setup output: ASP chain reset, ENC reset, setCheckRateX, start output
1678                 //
1679                 // Establish secondary timing
1680                 errno = pP->fxns->decodeInfo1(pP, pQ, pAsotCfg, frame, block);
1681                 if (errno)
1682                 {
1683                     TRACE_VERBOSE1("PAF_ASOT_decodeProcessing: INIT, errno 0x%x.  break after decodeInfo1", errno);
1684                     break;
1685                 }
1686 #endif
1687                 
1688                 TRACE_VERBOSE0("PAF_ASOT_decodeProcessing: state: INIT->STREAM");                
1689                 state = STREAM;
1690                 continue;
1691                 
1692             case STREAM: // stream state
1693                 gAsopStreamCnt++;
1694                 Log_info0("TaskAsop: state=STREAM");
1696                 errno = pP->fxns->decodeStream(pP, pQ, pAsotCfg, frame, block);
1697                 if (errno)
1698                 {
1699                     TRACE_TERSE1("PAF_ASOT_decodeProcessing: state: STREAM.  decodeStream err 0x%x", errno);
1700                     errno = ASOP_DP_DECSTREAM_ERR;
1701                     break;
1702                 }
1704                 TRACE_VERBOSE0("PAF_ASOT_decodeProcessing: state: STREAM->ENCODE");
1705                 state = ENCODE;
1706                 continue;
1707                 
1708             case ENCODE: // encode state
1709                 gAsopEncodeCnt++;
1710                 Log_info0("TaskAsop: state=ENCODE");
1712                 errno = pP->fxns->decodeEncode(pP, pQ, pAsotCfg, frame, block);
1713                 if (errno)
1714                 {
1715                     TRACE_TERSE1("PAF_ASOT_decodeProcessing: state: ENCODE.  decodeEncode err 0x%x", errno);
1716                     errno = ASOP_DP_DECENC_ERR;
1717                     break;
1718                 }
1719                 
1720                 // Measure cycles in output processing loop.
1721                 // Only measures cycles spent in loop.
1722                 pfpEnd(PFP_ID_ASOT_1, PFP_FINISH_MEAS);
1723                 gNumPfpAsot1--;
1724                 pfpBegin(PFP_ID_ASOT_1, pAsotCfg->taskHandle);
1725                 gNumPfpAsot1++;
1726                 
1727                 // (***) FL: do we need this? 
1728                 //       AF pointers come from CB read, any resets occur in Decoder AF.
1729                 //
1730                 // Reset audio frame pointers to original values
1731                 // (may have been adjusted by ARC or the like).
1732                 resetAfPointers(pP, pAstCfg->xStr);
1734                 // (***) FL: update output (setCheckRateX)
1735                 //           Contained in INFO2 in combined FSM.
1736                 errno = pP->fxns->decodeInfo2(pP, pQ, pAsotCfg, frame, block);
1737                 if (errno)
1738                 {
1739                     TRACE_TERSE1("PAF_ASOT_decodeProcessing: ENCODE break on decodeInfo2. errno 0x%x", errno);
1740                     errno = ASOP_DP_DECINFO2_ERR;
1741                     break;
1742                 }
1744                 block++;
1745                 TRACE_VERBOSE0("PAF_ASOT_decodeProcessing: state: ENCODE->FINAL");
1746                 state = FINAL;
1747                 continue;
1748                 
1749             case FINAL:
1750                 gAsopFinalCnt++;
1751                 Log_info0("TaskAsop: state=FINAL");
1752                 
1753                 //
1754                 // (***) FL: this needs to be fixed.
1755                 //       (1) Only require selected Output to be in this FSM
1756                 //           => Dec Status checks aren't valid, 
1757                 //              will probably always exit FSM if only Output running
1758                 //       (2) Checking Dec Status info asych to input events (maybe ok)
1759                 //
1760                 // Check for final frame, and if indicated:
1761                 // - Update audio flag to cause output buffer flush rather than
1762                 //   the default truncate in "complete" processing.
1763                 // - Exit state machine to "complete" processing.
1764 #if 0
1765                 if (pP->fxns->decodeFinalTest(pP, pQ, pAsotCfg, frame, block)) 
1766                 {
1767                     for (z=OUTPUT1; z < OUTPUTN; z++)
1768                     {
1769                         if ((pAstCfg->xOut[z].outBufStatus.audio & 0x0f) == PAF_OB_AUDIO_SOUND)
1770                         {
1771                             TRACE_VERBOSE0("PAF_ASOT_outputProcessing: state: FINAL: SOUND -> QUIET");
1772                             pAstCfg->xOut[z].outBufStatus.audio++; // SOUND -> QUIET
1773                         }
1774                     }
1775                     break;
1776                 }
1777 #endif
1778                 errno = pP->fxns->decodeFinalTest(pP, pQ, pAsotCfg, frame, block);
1779                 if (errno < 0)
1780                 {
1781                     TRACE_TERSE1("PAF_ASOT_decodeProcessing: DECODE FINAL break. errno 0x%x", errno);
1782                     errno = ASOP_DP_DECFINALTEST_ERR;
1783                     break;
1784                 }
1785                 else if (errno == ASOP_DP_CB_DRAINED)
1786                 {
1787                     // EOS, exit normally
1788                     TRACE_TERSE1("PAF_ASOT_decodeProcessing: DECODE FINAL normal exit. errno 0x%x", errno);
1789                     errno = ASOP_DP_SOK;
1790                     break;
1791                 }
1793                 TRACE_VERBOSE0("PAF_ASOT_decodeProcessing: state: FINAL->STREAM");
1794                 state = STREAM;
1795                 continue;
1796                 
1797             case OUT_SIO_UPDATE:
1798                 gAsopOutSioUpdateCnt++;
1799                 Log_info0("TaskAsop: state=OUT_SIO_UPDATE");
1801                 TRACE_VERBOSE0("PAF_ASOT_decodeProcessing: state: OUT_SIO_UPDATE");
1802                 errno = ASOP_DP_OUT_SIO_UPDATE;
1803                 break;
1804                 
1805             case QUIT:
1806                 gAsopQuitCnt++;
1807                 Log_info0("TaskAsop: state=QUIT");
1809                 TRACE_VERBOSE0("PAF_ASOT_decodeProcessing: state: QUIT");
1810                 errno = ASPERR_QUIT;
1811                 break;
1813             default: // unknown state
1814                 // Unknown:
1815                 // - Set error number registers.
1816                 // - Exit state machine to "complete" processing.
1818                 TRACE_TERSE1("PAF_ASOT_decodeProcessing: state: unknown, 0x%x", state);
1819                 errno = ASPERR_UNKNOWNSTATE;
1820                 break;
1822         }  // End of switch (state).
1823         
1824         TRACE_VERBOSE0("PAF_ASOT_decodeProcessing: Calling decode complete");
1825         if (pP->fxns->decodeComplete(pP, pQ, pAsotCfg, NULL, frame, block))
1826         {
1827             /* ignored? */;
1828         }
1829         
1830         //pfpEnd(PFP_ID_ASOT_1, PFP_FINISH_MEAS); // PFP end -- outside of PFP for errors, EOS, or Output SIO change
1831         //gNumPfpAsot1--;
1832         
1833         //return errno;
1834         break;        
1835     } // End of for (;;)
1836         
1837     pfpEnd(PFP_ID_ASOT_1, PFP_FINISH_MEAS); // PFP end -- outside of PFP for errors, EOS, or Output SIO change
1838     gNumPfpAsot1--;
1839         
1840     return errno;
1843 // -----------------------------------------------------------------------------
1844 // ASOT Decoding Function - Encode Command Processing
1845 //
1846 //   Name:      PAF_ASOT_encodeCommand
1847 //   Purpose:   Decoding Function for processing Encode Commands.
1848 //   From:      AST Parameter Function -> decodeProcessing
1849 //   Uses:      See code.
1850 //   States:    x
1851 //   Return:    0.
1852 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
1853 //              * Command execution.
1854 //              * SIO control errors.
1855 //              * Error number macros.
1856 //
1857 Int
1858 PAF_ASOT_encodeCommand(
1859     const PAF_ASOT_Params *pP, 
1860     const PAF_ASOT_Patchs *pQ, 
1861     PAF_ASOT_Config *pAsotCfg
1864     PAF_AST_Config *pAstCfg;
1865     Int as;                     /* Audio Stream Number (1, 2, etc.) */
1866     Int z;                      /* encode counter */
1867     Int errno = 0;              /* error number */
1868     Int zO, zS;
1871     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
1872     as = pAstCfg->as;
1874     for (z=ENCODE1; z < ENCODEN; z++) 
1875     {
1876         zO = pP->outputsFromEncodes[z];
1877         zS = pP->streamsFromEncodes[z];
1878         if (! (pAstCfg->xEnc[z].encodeStatus.command2 & 0x80)) 
1879         {
1880             switch (pAstCfg->xEnc[z].encodeStatus.command2) 
1881             {
1882                 case 0: // command none - process
1883                     pAstCfg->xEnc[z].encodeStatus.command2 |= 0x80;
1884                     break;
1885                 case 1: // mute command
1886                     TRACE_VERBOSE2("AS%d: PAF_ASOT_encodeCommand: encode command mute (0x%02x)", as+zS, 1);
1887                     if ((pAstCfg->xOut[zO].outBufStatus.audio & 0x0f) != PAF_OB_AUDIO_QUIET
1888                         && pAstCfg->xOut[zO].hTxSio
1889                         && (errno = SIO_ctrl (pAstCfg->xOut[zO].hTxSio, PAF_SIO_CONTROL_MUTE, 0))) 
1890                     {
1891                         errno = (errno & 0xff) | ASPERR_MUTE;
1892                         /* convert to sensical errno */
1893                         TRACE_TERSE1("AS%d: PAF_ASOT_encodeCommand: SIO control failed (mute)", as+zS);
1894                         TRACE_TERSE2("AS%d: PAF_ASOT_encodeCommand: errno = 0x%04x <ignored>", as+zS, errno);
1895                     }
1896                     else 
1897                     {
1898                         pAstCfg->xOut[zO].outBufStatus.audio |= PAF_OB_AUDIO_MUTED;
1899                     }
1900                     pAstCfg->xEnc[z].encodeStatus.command2 |= 0x80;
1901                     break;
1902                 case 2: // unmute command
1903                     TRACE_VERBOSE2("AS%d: PAF_ASOT_encodeCommand: encode command unmute (0x%02x)", as+zS, 2);
1904                     if ((pAstCfg->xOut[zO].outBufStatus.audio & 0x0f) != PAF_OB_AUDIO_QUIET
1905                         && pAstCfg->xOut[zO].hTxSio
1906                         && (errno = SIO_ctrl (pAstCfg->xOut[zO].hTxSio, PAF_SIO_CONTROL_UNMUTE, 0))) 
1907                     {
1908                         errno = (errno & 0xff) | ASPERR_MUTE;
1909                         /* convert to sensical errno */
1910                         TRACE_TERSE1("AS%d: PAF_ASOT_encodeCommand: SIO control failed (unmute)", as+zS);
1911                         TRACE_TERSE2("AS%d: PAF_ASOT_encodeCommand: errno = 0x%04x <ignored>", as+zS, errno);
1912                     }
1913                     else 
1914                     {
1915                         pAstCfg->xOut[zO].outBufStatus.audio &= ~PAF_OB_AUDIO_MUTED;
1916                     }
1917                     pAstCfg->xEnc[z].encodeStatus.command2 |= 0x80;
1918                     break;
1919                 default: // command unknown - ignore
1920                     break;
1921             }
1922         }
1923     }
1925     ERRNO_RPRT (TaskAsop, errno);
1927     return 0;
1928 } //PAF_ASOT_encodeCommand
1930 //   Purpose:   Decoding Function for reinitializing the decoding process.
1931 Int
1932 PAF_ASOT_decodeInit(
1933     const PAF_ASOT_Params *pP, 
1934     const PAF_ASOT_Patchs *pQ, 
1935     PAF_ASOT_Config *pAsotCfg
1938     //PAF_AST_Config *pAstCfg;
1939     PAF_AST_DecOpCircBufCtl *pCbCtl;    /* Decoder output circular buffer control */
1940     //Int as;                             /* Audio Stream Number (1, 2, etc.) */
1941     Int z;                              /* decode/encode counter */
1942     Int errno;                          /* error number */
1943     //Int zO, zS;
1945     //pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
1946     //as = pAstCfg->as;
1948     pCbCtl = &pAsotCfg->pAspmCfg->decOpCircBufCtl; // get pointer to circular buffer control
1950     for (z=DECODE1; z < DECODEN; z++)
1951     {
1952         // Start decoder output circular buffer reads
1953         errno = cbReadStart(pCbCtl, z);
1954         if (errno)
1955         {
1956             TRACE_TERSE1("PAF_ASOT_decodeInit:cbReadStart() error=%d", errno);
1957             SW_BREAKPOINT; // debug
1958             return errno;
1959         }
1960         gCbReadAfErr=0;         // reset read circular buffer error count
1961         gDecOpCbRdAfUnd=0;      // reset decoder output circular buffer underflow count
1962         gMaxDecOpCbRdAfUnd=0;   // reset max decoder output circular buffer underflow count
1963         gMasterCbResetCnt=0;    // reset master circular buffer reset count
1965         // FL: debug, log circular buffer control variables
1966         cbLog(pCbCtl, z, 1, "PAF_ASOT_decodeInit:cbReadStart");
1967     }
1968     
1969 #if 0 // moved to PAF_ASOT_outputReset()
1970     // TODO: move this to start of this function so that it doesn't affect IO timing
1971     for (z=ENCODE1; z < ENCODEN; z++) 
1972     {
1973         zO = pP->outputsFromEncodes[z];
1974         zS = pP->streamsFromEncodes[z];
1975         if (pAstCfg->xOut[zO].hTxSio && pAstCfg->xEnc[z].encodeStatus.mode) 
1976         {
1977             Int select = pAstCfg->xEnc[z].encodeStatus.select;
1978             ALG_Handle encAlg = pAstCfg->xEnc[z].encAlg[select];
1979             ENC_Handle enc = (ENC_Handle )encAlg;
1980             TRACE_VERBOSE1("AS%d: PAF_ASOT_decodeInit: initializing encode", as+zS);
1981             if (encAlg->fxns->algActivate)
1982             {
1983                 encAlg->fxns->algActivate (encAlg);
1984             }
1985             if (enc->fxns->reset)
1986             {
1987                 errno = enc->fxns->reset(enc, NULL, 
1988                     &pAstCfg->xEnc[z].encodeControl, &pAstCfg->xEnc[z].encodeStatus);
1989                 if (errno)
1990                 {
1991                     return errno;
1992                 }
1993             }
1994         }
1995     }
1996 #endif
1997     
1998     return 0;
2001 // -----------------------------------------------------------------------------
2002 // ASOT Decoding Function - Info Processing, Initial
2003 //
2004 //   Name:      PAF_ASOT_decodeInfo1
2005 //   Purpose:   Decoding Function for processing information in a manner that
2006 //              is unique to initial frames of input data.
2007 //   From:      AST Parameter Function -> decodeProcessing
2008 //   Uses:      See code.
2009 //   States:    x
2010 //   Return:    Error number in standard or SIO form (0 on success).
2011 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
2012 //              * State information as per parent.
2013 //
2014 Int
2015 PAF_ASOT_decodeInfo1(
2016     const PAF_ASOT_Params *pP, 
2017     const PAF_ASOT_Patchs *pQ, 
2018     PAF_ASOT_Config *pAsotCfg, 
2019     Int frame, 
2020     Int block
2023     PAF_AST_Config *pAstCfg;
2024     Int z;                              /* decode/encode counter */
2025     Int errno;                          /* error number */
2027     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
2029     // run the chain of ASP's on the stream.
2030     TRACE_VERBOSE0("PAF_ASOT_decodeInfo1: calling streamChainFunction.");
2031     errno = pP->fxns->streamChainFunction(pP, pQ, pAsotCfg, 
2032         PAF_ASP_CHAINFRAMEFXNS_RESET, 1, frame);
2033     if (errno)
2034     {
2035         TRACE_TERSE1("PAF_ASOT_decodeInfo1: streamChainFunction returns errno 0x%x ", errno);
2036         return errno;
2037     }
2039     TRACE_VERBOSE0("PAF_ASOT_decodeInfo1: calling enc->info.");
2040     for (z=ENCODE1; z < ENCODEN; z++) 
2041     {
2042         Int zO = pP->outputsFromEncodes[z];
2043         if (pAstCfg->xOut[zO].hTxSio && pAstCfg->xEnc[z].encodeStatus.mode) 
2044         {
2045             Int select = pAstCfg->xEnc[z].encodeStatus.select;
2046             ALG_Handle encAlg = pAstCfg->xEnc[z].encAlg[select];
2047             ENC_Handle enc = (ENC_Handle )encAlg;
2048             
2049             if (enc->fxns->info)
2050             {
2051                 errno = enc->fxns->info(enc, NULL,
2052                     &pAstCfg->xEnc[z].encodeControl, 
2053                     &pAstCfg->xEnc[z].encodeStatus);
2054                 if (errno)
2055                 {
2056                     TRACE_TERSE1("PAF_ASOT_decodeInfo1: info returns errno 0x%x ", errno);
2057                     return errno;
2058                 }
2059             }
2060         }
2061     }
2063     errno = pP->fxns->setCheckRateX(pP, pQ, pAsotCfg, 0);
2064     if (errno)
2065     {
2066         // ignore if rateX has changed since we haven't, but are about to,
2067         // start the output. If we didn't ignore this case then the state machine
2068         // would restart unnecessarily, e.g. in the case of SRC, resulting in
2069         // added latency.
2070         if (errno != ASPERR_INFO_RATECHANGE)
2071         {
2072             TRACE_TERSE1("PAF_ASOT_decodeInfo1: setCheckRateX returns errno 0x%x, not RATECHANGE", errno);
2073             return errno;
2074         }
2075         else
2076         {
2077             TRACE_TERSE0("PAF_ASOT_decodeInfo1: RATECHANGE returns RATECHANGE, ignoring");
2078         }
2079     }
2081     errno = pP->fxns->startOutput(pP, pQ, pAsotCfg);
2082     if (errno) 
2083     {
2084         if (errno == 0x105) 
2085         {
2086             TRACE_TERSE1("PAF_ASOT_decodeInfo1: startOutput returns RING BUFFER FULL (0x%x)", errno);
2087         }
2088         else
2089         {
2090             TRACE_TERSE1("PAF_ASOT_decodeInfo1: startOutput returns errno 0x%x", errno);
2091         }
2092         return errno;
2093     }    
2094     
2095     return 0;
2098 // -----------------------------------------------------------------------------
2099 // ASOT Decoding Function - Info Processing, Subsequent
2100 //
2101 //   Name:      PAF_ASOT_decodeInfo2
2102 //   Purpose:   Decoding Function for processing information in a manner that
2103 //              is unique to frames of input data other than the initial one.
2104 //   From:      AST Parameter Function -> decodeProcessing
2105 //   Uses:      See code.
2106 //   States:    x
2107 //   Return:    Error number in standard form (0 on success).
2108 //   Trace:     None.
2109 //
2110 Int
2111 PAF_ASOT_decodeInfo2(
2112     const PAF_ASOT_Params *pP, 
2113     const PAF_ASOT_Patchs *pQ, 
2114     PAF_ASOT_Config *pAsotCfg, 
2115     Int frame, 
2116     Int block
2119     //PAF_AST_Config *pAstCfg;
2120     Int errno;
2122     
2123     //pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
2125     errno = pP->fxns->setCheckRateX (pP, pQ, pAsotCfg, 1);
2126     TRACE_VERBOSE1("PAF_ASOT_decodeInfo2: return 0x%x", errno);
2127     return errno;
2128 } //PAF_ASOT_decodeInfo2
2131 PAF_AST_DecOpCircBufStats gCbStats; // FL: debug
2132 // -----------------------------------------------------------------------------
2133 // ASOT Decoding Function - Stream Processing
2134 //
2135 //   Name:      PAF_ASOT_decodeStream
2136 //   Purpose:   Decoding Function for processing of audio frame data by the
2137 //              ASP Algorithms.
2138 //   From:      AST Parameter Function -> decodeProcessing
2139 //   Uses:      See code.
2140 //   States:    x
2141 //   Return:    Error number in standard form (0 on success).
2142 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
2143 //              * State information as per parent/child.
2144 //
2145 Int
2146 PAF_ASOT_decodeStream(
2147     const PAF_ASOT_Params *pP, 
2148     const PAF_ASOT_Patchs *pQ, 
2149     PAF_ASOT_Config *pAsotCfg, 
2150     Int frame, 
2151     Int block
2154     PAF_AST_Config *pAstCfg;
2155     PAF_AST_DecOpCircBufCtl *pCbCtl;    /* Decoder output circular buffer control */
2156     Int z;                              /* decode/stream counter */
2157     PAF_AudioFrame *pAfRd;
2158     Int cbErrno;
2159     PAF_AST_DecOpCircBufStats cbStats;  /* circular buffer statistics */
2160     Int errno;
2163     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
2164     
2165     pCbCtl = &pAsotCfg->pAspmCfg->decOpCircBufCtl; // get pointer to circular buffer control
2166     
2167     for (z=DECODE1; z < DECODEN; z++) 
2168     {
2169         Int zS = pP->streamsFromDecodes[z];
2170         
2171         //
2172         // Read decoder output circular buffer
2173         //
2174         pAfRd = pAstCfg->xStr[zS].pAudioFrame;
2175         //GPIOSetOutput(GPIO_PORT_0, GPIO_PIN_106);
2176         cbErrno = cbReadAf(pCbCtl, z, pAfRd);
2177         if ((cbErrno < 0) && (cbErrno != ASP_DECOP_CB_READ_UNDERFLOW))
2178         {
2179             gCbReadAfErr++;
2180             TRACE_TERSE1("PAF_ASOT_decodeStream:cbReadAf() error=%d", cbErrno);
2181             //SW_BREAKPOINT; // FL: debug
2182             return cbErrno;
2183         }
2185         // Handle underflows
2186         if (cbErrno == ASP_DECOP_CB_READ_UNDERFLOW)
2187         {
2188             // FL: some number of underflows alway occur on start of stream when ASOT only depends on configured Output.
2189             //     DDP: ~2 underflows
2190             //     MAT-THD: ~16 underflows
2191             // Need to check behavior of cbReset().
2192             // Need to check behavior on exit/re-entry into Output processing.
2193             
2194             gDecOpCbRdAfUnd++; // increment circular buffer underflow count
2195             if (gDecOpCbRdAfUnd >= DEC_OP_CB_RDAF_UND_THR) 
2196             {
2197                 // Underflow count above threshold.
2198                 // (1) set max underflow count to threshold
2199                 // (2) reset underflow count
2200                 // (3) reset circular buffer
2201                 
2202                 gMaxDecOpCbRdAfUnd = DEC_OP_CB_RDAF_UND_THR; // update max underflow count
2203                 gDecOpCbRdAfUnd = 0; // reset underflow count
2205                 // Reset circular buffer
2206                 cbReset(pCbCtl, z);
2207                 gMasterCbResetCnt++; // increment master circular buffer reset count
2208                 Log_info0("ASOT:cbReset");
2209             
2210                 return cbErrno;
2211             }
2212         }
2213         else if ((cbErrno == ASP_DECOP_CB_SOK) && (gDecOpCbRdAfUnd > 0))
2214         {
2215             // No underflow detected.
2216             // update max underflow count,
2217             // reset underflow count
2218             
2219             // update max underflow count
2220             if (gDecOpCbRdAfUnd > gMaxDecOpCbRdAfUnd)
2221             {
2222                 gMaxDecOpCbRdAfUnd = gDecOpCbRdAfUnd;
2223             }
2224             gDecOpCbRdAfUnd = 0; // reset circular buffer underflow count
2225         }
2226         //Log_info0("PAF_ASOT_decodeStream:cbReadAf() complete.");
2227         //GPIOClearOutput(GPIO_PORT_0, GPIO_PIN_106);
2228         Log_info0("PAF_ASOT_decodeStream:cbReadAf() complete.");
2229         
2230 #if 0 // (***) FL: shows timing of CB read
2231             // (***) debug // B8
2232             {
2233                 static Uint8 toggleState = 0;
2234                 if (toggleState == 0)
2235                     GPIOSetOutput(GPIO_PORT_0, GPIO_PIN_106);
2236                 else
2237                     GPIOClearOutput(GPIO_PORT_0, GPIO_PIN_106);
2238                 toggleState = ~(toggleState);
2239             }
2240 #endif
2242         // FL: debug
2243         // Get circular buffer statistics (debug)
2244         //cbGetStats(pCbCtl, z, &cbStats);
2245         cbGetStats(pCbCtl, z, &gCbStats);
2247         // FL: debug
2248         cbLog(pCbCtl, z, 1, "PAF_ASOT_decodeStream:cbReadAf");
2249         //if (capAfWrite(pAfRd, 0) != CAP_AF_SOK)
2250         //{
2251         //    Log_info0("capAfWrite() error");
2252         //}
2253     }
2254             
2255     TRACE_VERBOSE0("PAF_ASOT_outputStream: calling streamChainFunction.");
2256     errno = pP->fxns->streamChainFunction(pP, pQ, pAsotCfg, 
2257         PAF_ASP_CHAINFRAMEFXNS_APPLY, 1, block);
2258     if (errno)
2259     {
2260         TRACE_TERSE1("PAF_ASOT_outputStream: streamChainFunction returns errno 0x%x ", errno);
2261         return errno;
2262     }
2264     return 0;
2266 } //PAF_ASOT_decodeStream
2268 // -----------------------------------------------------------------------------
2269 // ASOT Decoding Function - Encode Processing
2270 //
2271 //   Name:      PAF_ASOT_decodeEncode
2272 //   Purpose:   Decoding Function for processing of audio frame data by the
2273 //              Encode Algorithm.
2274 //   From:      AST Parameter Function -> decodeProcessing
2275 //   Uses:      See code.
2276 //   States:    x
2277 //   Return:    Error number in standard or SIO form (0 on success).
2278 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
2279 //              * State information as per parent.
2280 //
2281 Int
2282 PAF_ASOT_decodeEncode(
2283     const PAF_ASOT_Params *pP, 
2284     const PAF_ASOT_Patchs *pQ, 
2285     PAF_ASOT_Config *pAsotCfg, 
2286     Int frame, 
2287     Int block
2290     PAF_AST_Config *pAstCfg;
2291     Int as;                     /* Audio Stream Number (1, 2, etc.) */
2292     Int z;                      /* encode/output counter */
2293     Int errno;                  /* error number */
2294     Int zX, zE, zS;
2295     UInt32 curTime;
2297     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
2298     as = pAstCfg->as;
2300     // Await output buffers (but not first time)
2301     for (z=OUTPUT1; z < OUTPUTN; z++) 
2302     {
2303         // determine encoder associated with this output
2304         zE = z;
2305         for (zX = ENCODE1; zX < ENCODEN; zX++) 
2306         {
2307             if (pP->outputsFromEncodes[zX] == z) 
2308             {
2309                 zE = zX;
2310                 break;
2311             }
2312         }
2313         zS = pP->streamsFromEncodes[zE];
2315         if (pAstCfg->xOut[z].hTxSio) 
2316         {
2317             // update length (e.g. ARC may have changed)
2318             pAstCfg->xOut[z].outBufConfig.lengthofFrame = 
2319                 pAstCfg->xEnc[zE].encodeInStruct.pAudioFrame->sampleCount;
2320             TRACE_GEN2("PAF_ASOT_decodeEncode: AS%d: processing block %d -- idle", as+zS, block);
2321             errno = SIO_reclaim(pAstCfg->xOut[z].hTxSio,(Ptr *) &pAstCfg->xOut[z].pOutBuf, NULL);
2322             if (errno < 0)
2323             {
2324                 SIO_idle(pAstCfg->xOut[z].hTxSio);
2325                 TRACE_TERSE2("PAF_ASOT_decodeEncode: AS%d: SIO_reclaim returns error %d", as+zS, -errno);
2326                 return -errno; // SIO negates error codes
2327             }
2328             // TODO: use pC->xOut[z].pOutBuf in following ->encode call
2330 #if 0 // (***) FL: shows timing of Output Rx SIO reclaim
2331             // (***) debug // B8
2332             {
2333                 static Uint8 toggleState = 0;
2334                 if (toggleState == 0)
2335                     GPIOSetOutput(GPIO_PORT_0, GPIO_PIN_106);
2336                 else
2337                     GPIOClearOutput(GPIO_PORT_0, GPIO_PIN_106);
2338                 toggleState = ~(toggleState);
2339             }
2340 #endif            
2342             //
2343             // Simulate Tx SIO_reclaim() pend
2344             //
2345             //Semaphore_pend(semaphoreTxAudio, BIOS_WAIT_FOREVER); 
2346             gTaskAsopCnt++;
2347             curTime = Clock_getTicks();
2348             //System_printf("System time in TaskAsipFxn Tx audio = %lu\n", (ULong)curTime);
2349             //Log_info1("outputEncode():Tx SIO reclaim(), system time = %u", curTime);
2350         }
2351         else 
2352         {
2353             TRACE_VERBOSE2("AS%d: PAF_ASOT_decodeEncode: processing block %d -- idle <ignored>", as+zS, block);
2354         }
2355     }
2357     // Encode data
2358     for (z=ENCODE1; z < ENCODEN; z++) 
2359     {
2360         Int zO = pP->outputsFromEncodes[z];
2361         Int zS = pP->streamsFromEncodes[z];
2362         (void)zS; // clear compiler warning in case not used with tracing disabled
2363         if (pAstCfg->xOut[zO].hTxSio && pAstCfg->xEnc[z].encodeStatus.mode) 
2364         {
2365             Int select = pAstCfg->xEnc[z].encodeStatus.select;
2366             ALG_Handle encAlg = pAstCfg->xEnc[z].encAlg[select];
2367             ENC_Handle enc = (ENC_Handle )encAlg;
2368             if (select != pAstCfg->xEnc[z].encodeControl.encActive)
2369             {
2370                 pAstCfg->xEnc[z].encodeControl.encActive = select;
2371                 TRACE_TERSE0("PAF_ASOT_decodeEncode: return error");
2372                 return (-1);
2373             }
2374             TRACE_GEN2("AS%d: PAF_ASOT_decodeEncode: processing block %d -- encode", as+zS, block);
2376             // (MID 1933) temp. workaround for PCE2
2377             pAstCfg->xEnc[z].encodeInStruct.pAudioFrame->data.nChannels = PAF_MAXNUMCHAN;
2379           /*
2380           #if (CURRENT_TRACE_MASK & TRACE_MASK_DATA)
2381             {
2382                 PAF_AudioFrame *pAudioFrame = pC->xEnc[z].encodeInStruct.pAudioFrame;
2383                 int *wp;
2384                 wp = (int*)pAudioFrame->data.sample[0];
2385                 TRACE_DATA((&TR_MOD, "as1-f2: AS%d PAF_ASOT_outputEncode: encoding from ch 0 0x%x. line %d", z, wp, __LINE__));
2386                 TRACE_DATA((&TR_MOD, "as1-f2: [0]: 0x%x, [16]: 0x%x, [99]: 0x%x (ch0)", wp[0], wp[16], wp[99]));
2387                 wp = (int*)pAudioFrame->data.sample[1];
2388                 TRACE_DATA((&TR_MOD, "as1-f2: PAF_ASOT_outputEncode: encoding from ch 1 0x%x. line %d", wp, __LINE__));
2389                 TRACE_DATA((&TR_MOD, "as1-f2: [0]: 0x%x, [16]: 0x%x, [99]: 0x%x (ch1)", wp[0], wp[16], wp[99]));
2390                 wp = (int*)pAudioFrame->data.sample[2];
2391                 TRACE_DATA((&TR_MOD, "as1-f2: PAF_ASOT_outputEncode: encoding from ch 2 0x%x. line %d", wp, __LINE__));
2392                 TRACE_DATA((&TR_MOD, "as1-f2: [0]: 0x%x, [16]: 0x%x, [99]: 0x%x (ch2)", wp[0], wp[16], wp[99]));
2393             }
2394           #endif
2395           */
2397             if (enc->fxns->encode)
2398             {
2399                 pAstCfg->xEnc[z].encodeOutStruct.bypassFlag =
2400                         pP->z_pEncodeStatus[z]->encBypass;
2401                 errno = enc->fxns->encode(enc, NULL, 
2402                     &pAstCfg->xEnc[z].encodeInStruct, 
2403                     &pAstCfg->xEnc[z].encodeOutStruct);
2404                 if (errno)
2405                 {
2406                     if (errno != PCEERR_OUTPUT_POINTERNULL)
2407                     {
2408                         TRACE_TERSE1("PAF_ASOT_decodeEncode: return error %d line %d", errno);
2409                         return errno;
2410                     }
2411                 }
2412             /*  #if (CURRENT_TRACE_MASK & TRACE_MASK_DATA)
2413                 else
2414                 {
2415                     int *wp = (int*)pC->xOut[z].pOutBuf->pntr.pVoid;
2416                     TRACE_DATA((&TR_MOD, "as1-f2: PAF_ASOT_outputEncode: encoded to 0x%x. line %d", wp, __LINE__));
2417                     TRACE_DATA((&TR_MOD, "as1-f2: [0]: 0x%x, [16]: 0x%x, [99]: 0x%x", wp[0], wp[16], wp[99]));
2418                 }
2419               #endif
2420               */
2421             }
2422         }
2423         else 
2424         {
2425             TRACE_VERBOSE2("PAF_ASOT_decodeEncode: AS%d: processing block %d -- encode <ignored>",
2426                 as+pP->streamsFromEncodes[z], block);
2427         }
2428     }
2430     // Transmit data
2431     for (z=OUTPUT1; z < OUTPUTN; z++) 
2432     {
2433         // determine encoder associated with this output
2434         zE = z;
2435         for (zX = ENCODE1; zX < ENCODEN; zX++) 
2436         {
2437             if (pP->outputsFromEncodes[zX] == z) 
2438             {
2439                 zE = zX;
2440                 break;
2441             }
2442         }
2443         zS = pP->streamsFromEncodes[zE];
2445         if (pAstCfg->xOut[z].hTxSio) 
2446         {
2447             TRACE_GEN2("PAF_ASOT_decodeEncode: AS%d: processing block %d -- output", as+zS, block);
2448             errno = SIO_issue(pAstCfg->xOut[z].hTxSio, 
2449                 &pAstCfg->xOut[z].outBufConfig, sizeof (pAstCfg->xOut[z].outBufConfig), 0);
2450             if (errno)
2451             {
2452                 SIO_idle(pAstCfg->xOut[z].hTxSio);
2453                 if (errno == 0x105)     // 0x105 == RINGIO_EBUFFULL
2454                 {
2455 //                    statStruct_LogFullRing(STATSTRUCT_AS1_F2);
2456                     TRACE_TERSE1("PAF_ASOT_decodeEncode: SIO_idle returned RINGIO_EBUFFULL (0x%x)", errno);
2457                 }
2458                 if (errno > 0)
2459                 {
2460                     TRACE_TERSE1("PAF_ASOT_decodeEncode: return error 0x%x line %d", errno);
2461                     return (ASPERR_ISSUE + (z << 4));
2462                 }
2463                 else if (errno < 0)
2464                 {
2465                     TRACE_TERSE1("PAF_ASOT_decodeEncode: return neg error 0x%x line %d", -errno);
2466                     return -errno; // SIO negates error codes
2467                 }
2468             }
2469             if (errno > 0)
2470             {
2471                 return (ASPERR_ISSUE + (z << 4));
2472             }
2473             else if (errno < 0)
2474             {
2475                 return -errno; // SIO negates error codes
2476             }
2477         }
2478         else 
2479         {
2480             TRACE_GEN2("PAF_ASOT_decodeEncode: AS%d: processing block %d -- output <ignored>", as+zS, block);
2481         }
2482     }
2484     return 0;
2485 } //PAF_ASOT_decodeEncode
2487 // -----------------------------------------------------------------------------
2488 // ASOT Decoding Function - Stream-Final Processing
2489 //
2490 //   Name:      PAF_ASOT_decodeComplete
2491 //   Purpose:   Decoding Function for terminating the decoding process.
2492 //   From:      AST Parameter Function -> decodeProcessing
2493 //   Uses:      See code.
2494 //   States:    x
2495 //   Return:    0.
2496 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
2497 //              * State information as per parent.
2498 //
2499 Int
2500 PAF_ASOT_decodeComplete(
2501     const PAF_ASOT_Params *pP, 
2502     const PAF_ASOT_Patchs *pQ, 
2503     PAF_ASOT_Config *pAsotCfg, 
2504     ALG_Handle decAlg[], 
2505     Int frame, 
2506     Int block
2509     PAF_AST_Config *pAstCfg;
2510     PAF_AST_DecOpCircBufCtl *pCbCtl;    /* Decoder output circular buffer control */
2511     Int as;                             /* Audio Stream Number (1, 2, etc.) */
2512     Int z;                              /* decode/encode counter */
2513     Int errno;                          /* error number */
2515     
2516     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
2517     as = pAstCfg->as;
2518     (void)as;  // clear compiler warning in case not used with tracing disabled
2520     pCbCtl = &pAsotCfg->pAspmCfg->decOpCircBufCtl; // get pointer to circular buffer control
2521     
2522     for (z=DECODE1; z < DECODEN; z++)
2523     {
2524         // Stop decoder output circular buffer reads
2525         errno = cbReadStop(pCbCtl, z);
2526         if (errno)
2527         {
2528             TRACE_TERSE1("PAF_ASOT_decodeComplete:cbReadStop() error=%d", errno);
2529             SW_BREAKPOINT; // FL: debug
2530             return errno;
2531         }
2532         // FL: debug
2533         cbLog(pCbCtl, z, 1, "PAF_ASOT_decodeComplete:cbReadStop");
2534     }
2535     
2536     pP->fxns->streamChainFunction(pP, pQ, pAsotCfg, PAF_ASP_CHAINFRAMEFXNS_FINAL, 0, frame);
2538     for (z=ENCODE1; z < ENCODEN; z++) 
2539     {
2540         Int zO = pP->outputsFromEncodes[z];
2541         if (pAstCfg->xOut[zO].hTxSio && pAstCfg->xEnc[z].encodeStatus.mode) 
2542         {
2543             Int select = pAstCfg->xEnc[z].encodeStatus.select;
2544             ALG_Handle encAlg = pAstCfg->xEnc[z].encAlg[select];
2545 #ifdef PAF_ASP_FINAL
2546             ENC_Handle enc = (ENC_Handle)encAlg;
2547 #endif /* PAF_ASP_FINAL */
2548             TRACE_VERBOSE1("PAF_ASOT_decodeComplete: AS%d: finalizing encode", as+z);
2549 #ifdef PAF_ASP_FINAL
2550             if (enc->fxns->final)
2551                 enc->fxns->final(enc, NULL, &pAstCfg->xEnc[z].encodeControl,
2552                                  &pAstCfg->xEnc[z].encodeStatus);
2553 #endif /* PAF_ASP_FINAL */
2554             if (encAlg->fxns->algDeactivate)
2555             {
2556                 encAlg->fxns->algDeactivate(encAlg);
2557             }
2558         }
2559         else 
2560         {
2561             TRACE_VERBOSE1("PAF_ASOT_decodeComplete: AS%d: finalizing encode <ignored>", as+z);
2562         }
2563     }
2565     // wait for remaining data to be output
2566     pP->fxns->stopOutput(pP, pQ, pAsotCfg);
2568     return 0;
2569 } //PAF_ASOT_decodeComplete
2571 // -----------------------------------------------------------------------------
2572 // ASOT Decoding Function Helper - SIO Driver Start
2573 //
2574 //   Name:      PAF_ASOT_startOutput
2575 //   Purpose:   Decoding Function for initiating output.
2576 //   From:      AST Parameter Function -> decodeInfo1
2577 //   Uses:      See code.
2578 //   States:    x
2579 //   Return:    Error number in standard or SIO form (0 on success).
2580 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
2581 //              * State information as per parent.
2582 //              * SIO control errors.
2583 //
2584 #define DEC_OUTNUMBUF_MAP(X) \
2585       pP->poutNumBufMap[z]->map[(X) >= pP->poutNumBufMap[z]->length ? 0 : (X)]
2587 Int
2588 PAF_ASOT_startOutput(
2589     const PAF_ASOT_Params *pP, 
2590     const PAF_ASOT_Patchs *pQ, 
2591     PAF_ASOT_Config *pAsotCfg
2592
2594     PAF_AST_Config *pAstCfg;
2595     Int as;                     /* Audio Stream Number (1, 2, etc.) */
2596     Int z;                      /* output counter */
2597     Int errno,nbufs;            /* error number */
2598     Int zE, zS, zX;
2599     Int zMD;
2600     PAF_SIO_IALG_Obj    *pObj;
2601     PAF_SIO_IALG_Config *pAlgConfig;
2603     
2604     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
2605     as = pAstCfg->as;
2606     zMD = pAstCfg->masterDec;
2608     for (z=OUTPUT1; z < OUTPUTN; z++) 
2609     {
2610         if (pAstCfg->xOut[z].hTxSio) 
2611         {
2612             // determine associated encoder and stream
2613             zE = z;
2614             zS = z;
2615             for (zX = ENCODE1; zX < ENCODEN; zX++) 
2616             {
2617                 if (pP->outputsFromEncodes[zX] == z) 
2618                 {
2619                     zE = zX;
2620                     zS = pP->streamsFromEncodes[zE];
2621                     break;
2622                 }
2623             }
2625             // Set sample count so that DOB knows how much data to send
2626             pAstCfg->xOut[z].outBufConfig.lengthofFrame =
2627                 pAstCfg->xEnc[zE].encodeInStruct.pAudioFrame->sampleCount;
2629             if (pAstCfg->xOut[z].outBufStatus.markerMode == PAF_OB_MARKER_ENABLED) 
2630             {
2631                 pObj = (PAF_SIO_IALG_Obj *) pAstCfg->xOut[z].outChainData.head->alg;
2632                 pAlgConfig = &pObj->config;
2633                 memset(pAstCfg->xOut[z].outBufConfig.base.pVoid, 0xAA, 
2634                     pAlgConfig->pMemRec[0].size);
2635             }
2637             // The index to DEC_OUTNUMBUF_MAP will always come from the primary/master
2638             // decoder. How should we handle the sourceProgram for multiple decoders?
2639             // Override as needed
2640             nbufs = DEC_OUTNUMBUF_MAP(pAstCfg->xDec[zMD].decodeStatus.sourceProgram);
2641             if (pAstCfg->xOut[z].outBufStatus.numBufOverride[pAstCfg->xDec[zMD].decodeStatus.sourceProgram] > 0)
2642             {
2643                 nbufs = pAstCfg->xOut[z].outBufStatus.numBufOverride[pAstCfg->xDec[zMD].decodeStatus.sourceProgram];
2644             }
2645             SIO_ctrl(pAstCfg->xOut[z].hTxSio, PAF_SIO_CONTROL_SET_NUMBUF, nbufs);
2647             if (errno = SIO_issue(pAstCfg->xOut[z].hTxSio,
2648                 &pAstCfg->xOut[z].outBufConfig, sizeof(pAstCfg->xOut[z].outBufConfig), 0)) 
2649             {
2650                 SIO_idle(pAstCfg->xOut[z].hTxSio);
2651                 TRACE_TERSE2("PAF_ASOT_startOutput: AS%d: SIO_issue failed (0x%x)", as+zS, errno);
2652                 return errno;
2653             }
2655             if (!(pAstCfg->xOut[z].outBufStatus.audio & 0xf0) && 
2656                 (errno =  SIO_ctrl (pAstCfg->xOut[z].hTxSio, PAF_SIO_CONTROL_UNMUTE, 0))) 
2657             {
2658                 errno = (errno & 0xff) | ASPERR_MUTE;
2659                 /* convert to sensical errno */
2660                 TRACE_TERSE2("as1-f2: PAF_ASOT_startOutput: AS%d: SIO control failed (unmute) 0x%x", as+zS, errno);
2661                 return (errno);
2662             }
2663             else
2664             {
2665                 pAstCfg->xOut[z].outBufStatus.audio
2666                     = (pAstCfg->xOut[z].outBufStatus.audio & 0xf0) | PAF_OB_AUDIO_SOUND;                
2667             }
2669             TRACE_VERBOSE1("PAF_ASOT_startOutput: AS%d: output started", as+zS);
2670         }
2671     }
2673     return 0;
2674 } //PAF_ASOT_startOutput
2676 // -----------------------------------------------------------------------------
2677 // ASOT Decoding Function Helper - SIO Driver Stop
2678 //
2679 //   Name:      PAF_ASOT_stopOutput
2680 //   Purpose:   Decoding Function for terminating output.
2681 //   From:      AST Parameter Function -> decodeProcessing
2682 //              AST Parameter Function -> decodeComplete
2683 //   Uses:      See code.
2684 //   States:    x
2685 //   Return:    Error number in standard or SIO form (0 on success).
2686 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
2687 //              * SIO control errors.
2688 //
2689 Int
2690 PAF_ASOT_stopOutput(
2691     const PAF_ASOT_Params *pP, 
2692     const PAF_ASOT_Patchs *pQ, 
2693     PAF_ASOT_Config *pAsotCfg
2696     PAF_AST_Config *pAstCfg;
2697     Int as;                     /* Audio Stream Number (1, 2, etc.) */
2698     Int z;                      /* output counter */
2699     Int errno = 0, getVal;
2700     Int zS, zX;
2701     PAF_SIO_IALG_Obj    *pObj;
2702     PAF_SIO_IALG_Config *pAlgConfig;
2704     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
2705     as = pAstCfg->as;
2706     (void)as;  // clear compiler warning in case not used with tracing disabled
2708     for (z=OUTPUT1; z < OUTPUTN; z++) 
2709     {
2710         if (pAstCfg->xOut[z].hTxSio) 
2711         {
2712             // determine associated encoder and stream
2713             zS = z;
2714             (void)zS;
2715             for (zX = ENCODE1; zX < ENCODEN; zX++) 
2716             {
2717                 if (pP->outputsFromEncodes[zX] == z) 
2718                 {
2719                     zS = pP->streamsFromEncodes[zX];
2720                     break;
2721                 }
2722             }
2724             // Mute output before audio data termination in the usual case,
2725             // where such termination is due to decode error or user command.
2726             // Identification of this as the usual case is provided by the
2727             // "decode processing" state machine.
2728             if (!(pAstCfg->xOut[z].outBufStatus.audio & 0xf0) &&
2729                 ((pAstCfg->xOut[z].outBufStatus.audio & 0x0f) == PAF_OB_AUDIO_SOUND) &&
2730                 (getVal = SIO_ctrl(pAstCfg->xOut[z].hTxSio, PAF_SIO_CONTROL_MUTE, 0))) 
2731             {
2732                 if (!errno) 
2733                 {
2734                     errno = (getVal & 0xff) | ASPERR_MUTE;
2735                     /* convert to sensical errno */
2736                 }
2737                 TRACE_VERBOSE1("PAF_ASOT_stopOutput:  AS%d: SIO control failed (mute)", as+zS);
2738             }
2740             TRACE_TIME((&TIME_MOD, "... + %d = %d (stopOutput -- begin PAF_SIO_CONTROL_IDLE)", dtime(), TSK_time()));
2742             // Terminate audio data output, truncating (ignore) or flushing
2743             // (play out) final samples as per (1) control register set by
2744             // the user and (2) the type of audio data termination:
2746 #if 0
2747             // This form is not used because driver support for truncating
2748             // data is not supported for internal clocks, although it is
2749             // for external clocks.
2750             getVal = SIO_ctrl(pC->xOut[z].hTxSio, PAF_SIO_CONTROL_IDLE,
2751                 pC->xOut[z].outBufStatus.flush
2752                 & (pC->xOut[z].outBufStatus.audio & 0x0f) == PAF_OB_AUDIO_FLUSH
2753                 ? 1 : 0);
2754             /* UNTESTED */
2755 #else
2756             // This form should be used when driver support for truncating
2757             // data is supported for both internal and external clocks.
2758             getVal = SIO_ctrl(pAstCfg->xOut[z].hTxSio, PAF_SIO_CONTROL_IDLE,
2759                 pAstCfg->xOut[z].outBufStatus.flush ? 1 :
2760                 (pAstCfg->xOut[z].outBufStatus.audio & 0x0f) == PAF_OB_AUDIO_FLUSH
2761                 ? 1 : 0);
2762             /* TESTED */
2763 #endif
2765             TRACE_TIME((&TIME_MOD, "... + %d = %d (stopOutput -- after PAF_SIO_CONTROL_IDLE)", dtime(), TSK_time()));
2767             if (!errno)
2768             {
2769                 errno = getVal;
2770             }
2772             // Mute output after audio data termination in a special case,
2773             // where such termination is due to processing of a final frame
2774             // or user command. Identification of this as a special case is
2775             // provided by the "decode processing" state machine.
2776             if (!(pAstCfg->xOut[z].outBufStatus.audio & 0xf0) &&
2777                 ((pAstCfg->xOut[z].outBufStatus.audio & 0x0f) == PAF_OB_AUDIO_FLUSH) &&
2778                 (getVal = SIO_ctrl(pAstCfg->xOut[z].hTxSio, PAF_SIO_CONTROL_MUTE, 0)))
2779             {
2780                 if (!errno) 
2781                 {
2782                     errno = (getVal & 0xff) | ASPERR_MUTE;
2783                     /* convert to sensical errno */
2784                 }
2785                 TRACE_VERBOSE1("as1-f2: PAF_ASOT_stopOutput:  AS%d: SIO control failed (mute)", as+zS);
2786             }
2788             pAstCfg->xOut[z].outBufStatus.audio &= ~0x0f;
2790             // zero output buffers
2791             pObj = (PAF_SIO_IALG_Obj *) pAstCfg->xOut[z].outChainData.head->alg;
2792             pAlgConfig = &pObj->config;
2793             memset (pAstCfg->xOut[z].outBufConfig.base.pVoid, 0, pAlgConfig->pMemRec[0].size);
2794         } //pAstCfg->xOut[z].hTxSio
2795     }//OUTPUT
2797     return errno;
2798 } //PAF_ASOT_stopOutput
2800 // -----------------------------------------------------------------------------
2801 // ASOT Decoding Function Helper - SIO Driver Change
2802 //
2803 //   Name:      PAF_ASOT_setCheckRateX
2804 //   Purpose:   Decoding Function for reinitiating output.
2805 //   From:      AST Parameter Function -> decodeInfo1
2806 //              AST Parameter Function -> decodeInfo2
2807 //   Uses:      See code.
2808 //   States:    x
2809 //   Return:    Error number in standard form (0 on success).
2810 //   Trace:     None.
2811 //
2813 /* 0: set, 1: check, unused for now. --Kurt */
2814 Int
2815 PAF_ASOT_setCheckRateX(
2816     const PAF_ASOT_Params *pP, 
2817     const PAF_ASOT_Patchs *pQ, 
2818     PAF_ASOT_Config *pAsotCfg, 
2819     Int check
2822     PAF_AST_Config *pAstCfg;
2823     float rateX;
2824     PAF_SampleRateHz rateO /* std */, rateI /* inv */;
2825     Int z;                              /* output counter */
2826     Int zx;                             /* output re-counter */
2827     Int getVal;
2828     int inputRate, inputCount, outputRate, outputCount;
2829     Int zMD;
2830     Int zMI;
2831     Int zMS;
2832     Int zE, zX;
2834     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
2835     zMD = pAstCfg->masterDec;
2836     zMS = pAstCfg->masterStr;
2837     zMI = pP->zone.master;
2839     inputRate = pAstCfg->xInp[zMI].inpBufStatus.sampleRateStatus;
2840     inputCount = pAstCfg->xDec[zMD].decodeStatus.frameLength;
2841     rateI = pAstCfg->xStr[zMS].pAudioFrame->fxns->sampleRateHz
2842         (pAstCfg->xStr[zMS].pAudioFrame, inputRate, PAF_SAMPLERATEHZ_INV);
2844     for (z=OUTPUT1; z < OUTPUTN; z++) {
2845         if (pAstCfg->xOut[z].hTxSio && (pAstCfg->xOut[z].outBufStatus.clock & 0x01)) {
2847             // determine associated encoder
2848             zE = z;
2849             for (zX = ENCODE1; zX < ENCODEN; zX++) {
2850                 if (pP->outputsFromEncodes[zX] == z) {
2851                     zE = zX;
2852                     break;
2853                 }
2854             }
2856             outputRate = pAstCfg->xEnc[zE].encodeStatus.sampleRate;
2857             outputCount = pAstCfg->xEnc[zE].encodeStatus.frameLength;
2858             rateO = pAstCfg->xStr[zMS].pAudioFrame->fxns->sampleRateHz
2859                 (pAstCfg->xStr[zMS].pAudioFrame, outputRate, PAF_SAMPLERATEHZ_STD);
2860             if (rateI > 0 && rateO > 0)
2861                 rateX = rateO /* std */ * rateI /* inv */;
2862             else if (inputCount != 0)
2863                 rateX = (float )outputCount / inputCount;
2864             else
2865                 return ( ASPERR_INFO_RATERATIO );
2867             getVal = SIO_ctrl (pAstCfg->xOut[z].hTxSio, PAF_SIO_CONTROL_SET_RATEX, (Arg) &rateX);
2868             if (getVal == DOBERR_RATECHANGE) {
2869                 for (zx=OUTPUT1; zx < OUTPUTN; zx++)
2870                     if (pAstCfg->xOut[zx].hTxSio)
2871                         SIO_idle (pAstCfg->xOut[zx].hTxSio);
2873                 // this forces an exit from the calling state machine which will
2874                 // eventually call startOutput which calls setCheckRateX for all outputs
2875                 // and so it is ok, in the presence of a rate change on any output, to
2876                 // exit this loop /function early.
2877                 return ASPERR_INFO_RATECHANGE;
2878             }
2879             else if( getVal != SYS_OK )
2880                 return ((getVal & 0xff) | ASPERR_RATE_CHECK);
2881         }
2882     }
2884     return 0;
2885 } //PAF_ASOT_setCheckRateX
2887 // -----------------------------------------------------------------------------
2888 // ASOT Decoding Function Helper - Chain Processing
2889 //
2890 //   Name:      PAF_ASOT_streamChainFunction
2891 //   Purpose:   Common Function for processing algorithm chains.
2892 //   From:      AST Parameter Function -> decodeInfo1
2893 //              AST Parameter Function -> decodeStream
2894 //              AST Parameter Function -> decodeComplete
2895 //   Uses:      See code.
2896 //   States:    x
2897 //   Return:    Error number in standard form (0 on success).
2898 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
2899 //              * State information as per parent.
2900 //
2901 Int
2902 PAF_ASOT_streamChainFunction(
2903     const PAF_ASOT_Params *pP, 
2904     const PAF_ASOT_Patchs *pQ, 
2905     PAF_ASOT_Config *pAsotCfg, 
2906     Int iChainFrameFxns, 
2907     Int abortOnError, 
2908     Int logArg
2911     PAF_AST_Config *pAstCfg;