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