21cc1172655204b3d7993027b4a3e28ba5b28234
[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 Output reset
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:   ASOT function for ASP chain reset and ENC info
175 static Int PAF_ASOT_outputInfo1(
176     const PAF_ASOT_Params *pP, 
177     const PAF_ASOT_Patchs *pQ, 
178     PAF_ASOT_Config *pAsotCfg
179 );
181 //   Purpose:   Init-Sync Dec Decode1 state function.
182 //              Performes Dec Decode1 Init-Sync.
183 static Int PAF_ASOT_initSyncDecDecode1(
184     const PAF_ASOT_Params *pP, 
185     const PAF_ASOT_Patchs *pQ, 
186     PAF_ASOT_Config *pAsotCfg
187 );
189 //   Purpose:   Init-Sync Re-Sync state function.
190 //              Peformed Init-Sync using stored Dec Reset/Info1 AFs.
191 static Int PAF_ASOT_initSyncResync(
192     const PAF_ASOT_Params *pP, 
193     const PAF_ASOT_Patchs *pQ, 
194     PAF_ASOT_Config *pAsotCfg,
195     PAF_AudioFrame *pDecResetAf,
196     PAF_AudioFrame *pDecInfo1Af  
197 );
199 #if 0
200 // Init-Sync update audio frame
201 static Int initSyncUpdateAf(
202     PAF_AudioFrame *dstAf, 
203     PAF_AudioFrame *srcAf
204 );
205 #endif
207 // Reset audio frames
208 static Void resetAfs(
209     const PAF_ASOT_Params *pP, 
210     PAF_AST_Stream *xStr
211 );
213 // Reset audio frame pointers to original values
214 static Void resetAfPointers(
215     const PAF_ASOT_Params *pP, 
216     PAF_AST_Stream *xStr
217 );
219 // Reset audio frame meta data elements
220 static Void resetAfMetadata(
221     const PAF_ASOT_Params *pP, 
222     PAF_AST_Stream *xStr
223 );
226 LINNO_DEFN(TaskAsop); /* Line number macros */
227 ERRNO_DEFN(TaskAsop); /* Error number macros */
229 // ASOT configuration
230 #pragma DATA_SECTION(gPAF_ASOT_config, ".globalSectionPafAsotConfig")
231 PAF_ASOT_Config gPAF_ASOT_config = {
232     NULL,               // taskHandle
233     NULL,               // acp
234     0,0,0,              // CB drained flags (size DECODE_MAXN)
235     &gPAF_ASPM_config,  // pAspmCfg
236     &gPAF_AST_config    // pAstCfg
237 };
239 // Underflow threshold before circular buffer reset and return error to Top-Level FSM
240 #define DEC_OP_CB_RDAF_UND_THR  ( 80 ) // FL: arbitrary setting
241 UInt32 gCbReadAfErr         =0; // read circular buffer error count, not including underflows
242 UInt32 gDecOpCbRdAfUnd      =0; // decoder output circular buffer underflow count
243 UInt32 gMaxDecOpCbRdAfUnd   =0; // max (consecutive) decoder output circular buffer underflow count
244 UInt32 gMasterCbResetCnt    =0; // master circular buffer reset count
246 // Global debug counters */
247 UInt32 gAsopInitOutProcCnt          =0;
248 UInt32 gAsopInitSyncDecResetCnt     =0;
249 UInt32 gAsopInitSyncDecInfo1Cnt     =0;
250 UInt32 gAsopInitSyncDecDecode1Cnt   =0;
251 UInt32 gAsopInitSyncResyncCnt       =0;
252 UInt32 gAsopOutProcCnt              =0;
253 UInt32 gAsopInitCnt                 =0;
254 UInt32 gAsopStreamCnt               =0;
255 UInt32 gAsopEncodeCnt               =0;
256 UInt32 gAsopFinalCnt                =0;
257 UInt32 gAsopOutSioUpdateCnt         =0;
258 UInt32 gAsopQuitCnt                 =0;
259 UInt32 gAsopTxSioReclaimCnt         =0;
262 /*
263  *  ======== taskAsopFxn ========
264  *  Audio Stream Output Processing task function
265  */
266 Void taskAsopFxn(
267 //    Int betaPrimeValue, // FL: revisit
268     const PAF_ASOT_Params *pP,
269     const PAF_ASOT_Patchs *pQ
272     PAF_ASOT_Config *pAsotCfg;      /* ASOT configuration pointer */
273     PAF_AST_Config *pAstCfg;        /* Common (shared) configuration pointer */
274     Int as;                         /* Audio Stream Number (1, 2, etc.) */
275     Int z;                          /* input/encode/stream/decode/output counter */
276     Int i;                          /* phase */
277     Int errno;                      /* error number */
278     Int zMS;
279     Int loopCount = 0;  // used to stop trace to see startup behavior.        
280     Int outSel;
281     enum { INIT_OUT_PROC_STATE, 
282            INITSYNC_DEC_RESET_STATE, INITSYNC_DEC_INFO1_STATE, INITSYNC_DEC_DECODE1_STATE, 
283            INITSYNC_RESYNC_STATE, 
284            OUT_PROC_STATE } state;
285     PAF_AudioFrame decResetAf;
286     PAF_AudioFrame decInfo1Af;
287     
289     Log_info0("Enter taskAsopFxn()");    
291     //
292     // Audio Stream Output Task Parameters & Patch (*pP, *pQ)
293     //
294     if (!pP) 
295     {
296         TRACE_TERSE0("TaskAsop: No Parameters defined. Exiting.");
297         LINNO_RPRT(TaskAsop, -1);
298         return;
299     }
301     if (!pQ)
302     {
303         TRACE_TERSE0("TaskAsip: No Patchs defined. Exiting.");
304         LINNO_RPRT(TaskAsop, -1);
305         return;
306     }    
308     //
309     // Audio Stream Output Task Configuration (*pAsotCfg):
310     //
311     pAsotCfg = &gPAF_ASOT_config;       // initialize pointer to task configuration
312     pAsotCfg->taskHandle = Task_self(); // set task handle
313     pAstCfg = pAsotCfg->pAstCfg;        // get pointer to AST common (shared) configuration
315     /* Obtain Audio Stream Number (1, 2, etc.) */    
316     as = pAstCfg->as;
317     TRACE_TERSE1("TaskAsop: Started with AS%d.", as);
319     //
320     // Initialize message log trace and line number reporting
321     //
322     for (z=STREAM1; z < STREAMN; z++)
323     {
324         TRACE_TERSE1("TaskAsop: AS%d: initiated", as+z);
325     }
326     LINNO_RPRT(TaskAsop, -1);
327     
328     //
329     // Determine stream index
330     //
331     zMS = pAstCfg->masterStr;
333     // Initialize as per parametrized phases:
334     //
335     //   In standard form these are:
336     //      - Malloc: Memory Allocation
337     //      - Config: Configuration Initialization
338     //      - AcpAlg: ACP Algorithm Initialization and Local Attachment
339     //      - Common: Common Memory Initialization
340     //      - AlgKey: Dec/Enc chain to Array Initialization
341     //      - Device: I/O Device Initialization
342     //      - Unused: (available)
343     //      - Unused: (available)
344     //
345     LINNO_RPRT(TaskAsop, -2);
346     for (i=0; i < lengthof(pP->fxns->initPhase); i++)
347     {
348         Int linno;
349         if (pP->fxns->initPhase[i])
350         {
351             linno = pP->fxns->initPhase[i](pP, pQ, pAsotCfg);
352             if (linno) 
353             {
354                 LINNO_RPRT(TaskAsop, linno);
355                 return;
356             }
357         }
358         else 
359         {
360             TRACE_TERSE1("TaskAsop: AS%d: initialization phase - null", as+zMS);
361         }
362         TRACE_TERSE2("TaskAsop: AS%d: initialization phase - %d completed", as+zMS, i);
363         LINNO_RPRT(TaskAsop, -i-3);
364     }
365   
366     //
367     // End of Initialization -- display memory usage report.
368     //
369     if (pP->fxns->memStatusPrint)
370     {
371         pP->fxns->memStatusPrint("ASOT MEMSTAT REPORT",
372             HEAP_INTERNAL, HEAP_INTERNAL1, HEAP_EXTERNAL, 
373             HEAP_INTERNAL1_SHM, HEAP_EXTERNAL_SHM, HEAP_EXTERNAL_NONCACHED_SHM);
374     }
376     //
377     // Main processing loop
378     //   
379     for (z=STREAM1; z < STREAMN; z++)
380     {
381         TRACE_VERBOSE1("TaskAsip: AS%d: running", as+z);
382     }
383     
384     state = INIT_OUT_PROC_STATE;    // initialize state
385     errno = 0;                      // reset error indicator
386     for (;;)
387     {
388         loopCount++;
389         TRACE_GEN2("TaskAsop (begin Main loop %d) (errno 0x%x)", loopCount, errno);
391         //
392         // Check forward (ASIT) error here, TBD
393         //
394         
395         // any error forces idling of output
396         if (errno) 
397         {
398             for (z=OUTPUT1; z < OUTPUTN; z++)
399             {
400                 if (pAstCfg->xOut[z].hTxSio)
401                 {
402                     SIO_idle(pAstCfg->xOut[z].hTxSio);
403                 }
404             }
405         
406             TRACE_TERSE1("TaskAsop: Trace stopped at loop %d.", loopCount);
407             ERRNO_RPRT(TaskAsop, errno);
408         }        
409         
410         TRACE_VERBOSE1("TaskAsop: AS%d: ... sleeping ...", as+zMS);
411         Task_sleep(1);
413         // select output devices
414         TRACE_GEN1("TaskAsop: AS%d: Output device selection ...", as+zMS);
415         errno = pP->fxns->selectDevices(pP, pQ, pAsotCfg);
416         if (errno)
417         {
418             TRACE_TERSE2("TaskAsop: AS%d: selectDevices returned errno = 0x%04x", as+zMS, errno);
419             continue;
420         }
422         // if no output selected skip remaining processing
423         errno = checkOutSel(pP, pAsotCfg, &outSel);
424         if (errno < 0)
425         {
426             TRACE_TERSE2("TaskAsop: AS%d: checkOutSel returned errno = 0x%04x", as+zMS, errno);
427             continue;
428         }
429         else if (!outSel)
430         {
431             TRACE_VERBOSE1("TaskAsop: AS%d: No output selected...", as+zMS);            
432             continue;
433         }
434         
435         switch (state)
436         {
437             case INIT_OUT_PROC_STATE:
438                 gAsopInitOutProcCnt++;
439                 Log_info0("TaskAsop: state=INIT_OUT_PROC_STATE");
440                 
441                 //
442                 // Output Processing initialization.
443                 //
444                 errno = PAF_ASOT_initOutProc(pP, pAstCfg->xStr);
445                 if (errno < 0)
446                 {
447                     state = INIT_OUT_PROC_STATE;
448                 }
449                 else
450                 {
451                     state = INITSYNC_DEC_RESET_STATE;
452                 }
453             
454                 break;
455                 
456             case INITSYNC_DEC_RESET_STATE:
457                 gAsopInitSyncDecResetCnt++;
458                 Log_info0("TaskAsop: state=INITSYNC_DEC_RESET_STATE");
460                 //
461                 // Dec Reset Init-Sync.
462                 //  
463                 
464                 // Perform Dec Reset init-sync.
465                 // Latch Dec Reset AF.
466                 errno = PAF_ASOT_initSyncDecReset(pP, pQ, pAsotCfg, &decResetAf);
467                 if (errno < 0)
468                 {
469                     Log_info1("TaskAsop: state=INITSYNC_DEC_RESET_STATE errno=%d", errno);
470                     // sync error -- start over
471                     state = INIT_OUT_PROC_STATE;
472                 }
473                 else if (errno == ASOP_INITSYNC_NOTREADY)
474                 {
475                     Log_info1("TaskAsop: state=INITSYNC_DEC_RESET_STATE not sync'd errno=%d", errno);
476                     // sync not ready -- try again
477                     state = INITSYNC_DEC_RESET_STATE;
478                     errno=0; // FL: temp hack
479                 }
480                 else // errno==0
481                 {
482                     Log_info1("TaskAsop: state=INITSYNC_DEC_RESET_STATE sync'd, errno=%d", errno);
483                     // sync'd -- move on
484                     state = INITSYNC_DEC_INFO1_STATE;
485                 }
486                 
487                 break;
488             
489             case INITSYNC_DEC_INFO1_STATE:
490                 gAsopInitSyncDecInfo1Cnt++;
491                 Log_info0("TaskAsop: state=INITSYNC_DEC_INFO1_STATE");
492                 
493                 //
494                 // Dec Info1 Init-Sync.
495                 //
497                 // Perform Dec Info1 init-sync.
498                 // Latch Dec Info1 AF.
499                 errno = PAF_ASOT_initSyncDecInfo1(pP, pQ, pAsotCfg, &decInfo1Af);
500                 if (errno < 0)
501                 {
502                     Log_info1("TaskAsop: state=INITSYNC_DEC_INFO1_STATE errno=%d", errno);
503                     // sync error -- start over
504                     state = INIT_OUT_PROC_STATE;
505                 }
506                 else if (errno == ASOP_INITSYNC_NOTREADY)
507                 {
508                     Log_info1("TaskAsop: state=INITSYNC_DEC_INFO1_STATE not sync'd errno=%d", errno);
509                     // sync not ready -- try again
510                     state = INITSYNC_DEC_INFO1_STATE;
511                     errno=0; // FL: temp hack
512                 }
513                 else // errno = 0
514                 {
515                     Log_info1("TaskAsop: state=INITSYNC_DEC_INFO1_STATE sync'd errno=%d", errno);
516                     // sync'd -- move on
517                     state = INITSYNC_DEC_DECODE1_STATE;
518                 }
519                 
520                 break;
521             
522             case INITSYNC_DEC_DECODE1_STATE:
523                 gAsopInitSyncDecDecode1Cnt++;
524                 Log_info0("TaskAsop: state=INITSYNC_DEC_DECODE1_STATE");
525                 
526                 //
527                 // Dec Info1 Init-Sync.
528                 //
530                 // Perform Dec Info1 init-sync.
531                 // Latch Dec Info1 AF.
532                 errno = PAF_ASOT_initSyncDecDecode1(pP, pQ, pAsotCfg);
533                 if (errno < 0)
534                 {
535                     Log_info1("TaskAsop: state=INITSYNC_DEC_DECODE1_STATE errno=%d", errno);
536                     // sync error -- start over
537                     state = INIT_OUT_PROC_STATE;
538                 }
539                 else if (errno == ASOP_INITSYNC_NOTREADY)
540                 {
541                     Log_info1("TaskAsop: state=INITSYNC_DEC_DECODE1_STATE not sync'd errno=%d", errno);
542                     // sync not ready -- try again
543                     state = INITSYNC_DEC_DECODE1_STATE;
544                     errno=0; // FL: temp hack
545                 }
546                 else // errno = 0
547                 {
548                     Log_info1("TaskAsop: state=INITSYNC_DEC_DECODE1_STATE sync'd errno=%d", errno);
549                     // sync'd -- move on
550                     state = OUT_PROC_STATE;
551                 }
552                 
553                 break;
554             
555             case INITSYNC_RESYNC_STATE:
556                 gAsopInitSyncResyncCnt++;
557                 Log_info0("TaskAsop: state=INITSYNC_RESYNC_STATE");
559                 //
560                 // Re-Sync.
561                 // Use stored AF info from init-sync.
562                 // This is done in case of local error.
563                 //
564                 
565                 // Perform Dec Info1 init-sync.
566                 errno = PAF_ASOT_initSyncResync(pP, pQ, pAsotCfg, &decResetAf, 
567                     &decInfo1Af);
568                 if (errno < 0)
569                 {
570                     Log_info1("TaskAsop: state=INITSYNC_RESYNC_STATE errno=%d", errno);
571                     // sync error -- start over
572                     state = INIT_OUT_PROC_STATE;
573                 }
574                 else
575                 {
576                     Log_info1("TaskAsop: state=INITSYNC_RESYNC_STATE sync'd errno=%d", errno);
577                     // re-sync'd -- move on
578                     state = OUT_PROC_STATE;
579                 }
580                     
581                 break;
582             
583             case OUT_PROC_STATE:        
584                 gAsopOutProcCnt++;
585                 Log_info0("TaskAsop: state=OUT_PROC_STATE");
586                 
587                 //
588                 // Output Processing.
589                 //
591                 TRACE_VERBOSE0("TaskAsop: calling decodeProcessing.");
592                 errno = pP->fxns->decodeProcessing(pP, pQ, pAsotCfg);
593                 if (errno < 0)
594                 {
595                     Log_info1("TaskAsop: state=OUT_PROC_STATE errno=%d", errno);
596                     
597                     //
598                     // Output Processing exit, due to error
599                     //
600                     
601                     TRACE_TERSE1("TaskAsop: decodeProcessing returns 0x%x, continue", errno);
602                     if (errno == ASOP_DP_FORWARD_ERR)
603                     {
604                         // forward (ASIT) error -- start over
605                         state = INIT_OUT_PROC_STATE;
606                     }
607                     else
608                     {
609                         // local (ASOT) error
610                         state = INITSYNC_RESYNC_STATE;    
611                     }        
612                 }
613                 else if (errno > 0)
614                 {
615                     Log_info1("TaskAsop: state=OUT_PROC_STATE errno=%d", errno);
617                     //
618                     // Output Processing exit, not due to error
619                     //
621                     TRACE_TERSE1("TaskAsop: decodeProcessing returns 0x%x, continue", errno);                    
622                     if (errno == ASOP_DP_OUT_SIO_UPDATE)
623                     {
624                         // skip re-sync
625                         // resume output processing after new output selected
626                         state = OUT_PROC_STATE;
627                     }
628                 }
629                 else
630                 {
631                     Log_info1("TaskAsop: state=OUT_PROC_STATE errno=%d", errno);
633                     //
634                     // Output Processing exit, normal
635                     //
636                     
637                     TRACE_VERBOSE0("TaskAsop: outputProcessing complete with no error.");
638                     
639                     // no error returned if CB drained 
640                     // (i.e. CB drained is normal behavior)
641                     state = INIT_OUT_PROC_STATE;
642                 }
643                 
644                 break;
645             
646             default: // unknown state
647                 TRACE_TERSE2("TaskAsop: AS%d: state: unknown, 0x%x", as+zMS, state);
648                 break;
649         }
650     } // End of main processing loop for (;;)
651     
652     //Log_info0("Exit taskAsopFxn()");
655 // -----------------------------------------------------------------------------
656 // AST Initialization Function - Memory Allocation
657 //
658 //   Name:      PAF_ASOT_initPhaseMalloc
659 //   Purpose:   Audio Stream Output Task Function for initialization of data pointers
660 //              by allocation of memory.
661 //   From:      audioStream1Task or equivalent
662 //   Uses:      See code.
663 //   States:    x
664 //   Return:    0 on success.
665 //              Source code line number on MEM_calloc failure.
666 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
667 //              * State information as per parent.
668 //              * Memory allocation errors.
669 //
671 Int
672 PAF_ASOT_initPhaseMalloc (
673     const PAF_ASOT_Params *pP, 
674     const PAF_ASOT_Patchs *pQ, 
675     PAF_ASOT_Config *pAsotCfg
678     PAF_AST_Config *pAstCfg;
679     Int as;                     /* Audio Stream Number (1, 2, etc.) */
680     Int zMS;
681     Error_Block    eb;
682     //Int i;
684     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
685     as = pAstCfg->as;
686     zMS = pAstCfg->masterStr;
688     TRACE_TERSE1("PAF_ASOT_initPhaseMalloc: AS%d: initialization phase - memory allocation", as+zMS);
690     // Initialize error block
691     Error_init(&eb); 
693     /* Stream memory */
694     if (!(pAstCfg->xStr = Memory_calloc((IHeap_Handle)HEAP_INTERNAL, STREAMN * sizeof (*pAstCfg->xStr), 4, &eb)))
695     {
696         TRACE_TERSE1("PAF_ASOT_initPhaseMalloc: AS%d: Memory_calloc failed", as+zMS);
697         SW_BREAKPOINT;
698         return __LINE__;
699     }
700     TRACE_TERSE3("PAF_ASOT_initPhaseMalloc. (pAstCfg->xStr) %d bytes from space %d at 0x%x.",
701             STREAMN * sizeof (*pAstCfg->xStr),
702             HEAP_ID_INTERNAL, (IArg)pAstCfg->xStr);
704     {
705         Int z;                          /* stream counter */
707         PAF_AudioFrame *fBuf;
709         if (!(fBuf = (PAF_AudioFrame *)Memory_calloc((IHeap_Handle)HEAP_INTERNAL, STREAMS * sizeof (*fBuf), 4, &eb)))
710         {
711             TRACE_TERSE1("PAF_ASOT_initPhaseMalloc: AS%d: Memory_calloc failed", as+zMS);
712             SW_BREAKPOINT;
713             return __LINE__;
714         }
715         TRACE_TERSE3("PAF_ASOT_initPhaseMalloc. (fBuf) %d bytes from space %d at 0x%x.",
716                 STREAMS * sizeof (*fBuf),
717                 HEAP_ID_INTERNAL, (IArg)fBuf);
719         for (z=STREAM1; z < STREAMN; z++)
720         {
721             pAstCfg->xStr[z].pAudioFrame = &fBuf[z-STREAM1];
722             TRACE_TERSE2("pAstCfg->xStr[%d].pAudioFrame = 0x%x", z, (IArg)pAstCfg->xStr[z].pAudioFrame);
723         }
724     }
726     /* Encode memory */
727     if (!(pAstCfg->xEnc = Memory_calloc((IHeap_Handle)HEAP_INTERNAL, ENCODEN * sizeof (*pAstCfg->xEnc), 4, &eb)))
728     {
729         TRACE_TERSE1("PAF_ASOT_initPhaseMalloc: AS%d: Memory_calloc failed", as+zMS);
730         SW_BREAKPOINT;
731         return __LINE__;
732     }
733     TRACE_TERSE3("PAF_ASOT_initPhaseMalloc. (pAstCfg->xEnc) %d bytes from space %d at 0x%x.",
734             ENCODEN * sizeof (*pAstCfg->xEnc),
735             HEAP_ID_INTERNAL, (IArg)pAstCfg->xEnc);
737     /* Output memory */
738     if (!(pAstCfg->xOut = Memory_calloc((IHeap_Handle)HEAP_INTERNAL, OUTPUTN * sizeof (*pAstCfg->xOut), 4, &eb)))
739     {
740         TRACE_TERSE1("PAF_ASOT_initPhaseMalloc: AS%d: Memory_calloc failed", as+zMS);
741         SW_BREAKPOINT;
742         return __LINE__;
743     }
744     TRACE_TERSE3("PAF_ASOT_initPhaseMalloc. (pAstCfg->xOut) %d bytes from space %d at 0x%x.",
745             OUTPUTN * sizeof (*pAstCfg->xOut),
746             HEAP_ID_INTERNAL, (IArg)pAstCfg->xOut);
748     TRACE_TERSE1("PAF_ASOT_initPhaseMalloc: AS%d: initialization phase - memory allocation complete.", as+zMS);
749     return 0;
750 } //PAF_ASOT_initPhaseMalloc
752 // -----------------------------------------------------------------------------
753 // ASOT Initialization Function - Memory Initialization from Configuration
754 //
755 //   Name:      PAF_ASOT_initPhaseConfig
756 //   Purpose:   Audio Stream Output Task Function for initialization of data values
757 //              from parameters.
758 //   From:      audioStream1Task or equivalent
759 //   Uses:      See code.
760 //   States:    x
761 //   Return:    0 on success.
762 //              Other as per initFrame0 and initFrame1.
763 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
764 //              * State information as per parent.
765 //
766 Int
767 PAF_ASOT_initPhaseConfig(
768     const PAF_ASOT_Params *pP, 
769     const PAF_ASOT_Patchs *pQ, 
770     PAF_ASOT_Config *pAsotCfg
773     PAF_AST_Config *pAstCfg;
774     Int as;                     /* Audio Stream Number (1, 2, etc.) */
775     Int z;                      /* input/encode/stream/decode/output counter */
776     Int zMS;
778     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
779     as = pAstCfg->as;
780     zMS = pAstCfg->masterStr;
782     TRACE_TERSE1("PAF_ASOT_initPhaseConfig: AS%d: initialization phase - configuration", as+zMS);
784     //
785     // Unspecified elements have been initialized to zero during alloc
786     //
788     for (z=STREAM1; z < STREAMN; z++) 
789     {
790         Int linno;
791         if (linno = pP->fxns->initFrame0(pP, pQ, pAsotCfg, z))
792         {
793             return linno;           
794         }
795         if (linno = pP->fxns->initFrame1(pP, pQ, pAsotCfg, z, -1))
796         {
797             return linno;
798         }
799     }
801     for (z=ENCODE1; z < ENCODEN; z++) 
802     {
803         Int zO = pP->outputsFromEncodes[z];
804         Int zS = pP->streamsFromEncodes[z];
805         pAstCfg->xEnc[z].encodeControl.size = sizeof(pAstCfg->xEnc[z].encodeControl);
806         pAstCfg->xEnc[z].encodeControl.pAudioFrame = pAstCfg->xStr[zS].pAudioFrame;
807         pAstCfg->xEnc[z].encodeControl.pVolumeStatus = &pAstCfg->xEnc[z].volumeStatus;
808         pAstCfg->xEnc[z].encodeControl.pOutBufConfig = &pAstCfg->xOut[zO].outBufConfig;
809         pAstCfg->xEnc[z].encodeStatus = *pP->z_pEncodeStatus[z];
810         pAstCfg->xEnc[z].encodeControl.encActive = pAstCfg->xEnc[z].encodeStatus.select;
811         pAstCfg->xEnc[z].volumeStatus = *pP->pVolumeStatus;
812         pAstCfg->xEnc[z].encodeInStruct.pAudioFrame = pAstCfg->xStr[zS].pAudioFrame;
813     }
815     for (z=OUTPUT1; z < OUTPUTN; z++)
816     {
817         pAstCfg->xOut[z].outBufStatus = *pP->pOutBufStatus;
818     }
820     TRACE_TERSE1("PAF_ASOT_initPhaseConfig: AS%d: initialization phase - configuration complete.", as+zMS);
821     return 0;
822 } //PAF_ASOT_initPhaseConfig
824 // -----------------------------------------------------------------------------
825 // ASOT Initialization Function - ACP Algorithm Instantiation
826 //
827 //   Name:      PAF_ASOT_initPhaseAcpAlg
828 //   Purpose:   Audio Stream Input Task Function for initialization of ACP by
829 //              instantiation of the algorithm.
830 //   From:      audioStream1Task or equivalent
831 //   Uses:      See code.
832 //   States:    x
833 //   Return:    0 on success.
834 //              Source code line number on ACP Algorithm creation failure.
835 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
836 //              * State information as per parent.
837 //              * Memory allocation errors.
838 //
839 Int
840 PAF_ASOT_initPhaseAcpAlg(
841     const PAF_ASOT_Params *pP, 
842     const PAF_ASOT_Patchs *pQ, 
843     PAF_ASOT_Config *pAsotCfg
846     PAF_AST_Config *pAstCfg;
847     Int as;                     /* Audio Stream Number (1, 2, etc.) */
848     Int z;                      /* input/encode/stream/decode/output counter */
849     Int betaPrimeOffset;
850     ACP_Handle acp;
851     Int zMS;
852     Int zS, zX;
854     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
855     as = pAstCfg->as;
856     zMS = pAstCfg->masterStr;
858     TRACE_TERSE1("PAF_ASOT_initPhaseAcpAlg: AS%d: initialization phase - ACP Algorithm", as+zMS);
860     ACP_MDS_init();
862     if (!(acp = (ACP_Handle )ACP_MDS_create(NULL))) 
863     {
864         TRACE_TERSE1("PAF_ASOT_initPhaseAcpAlg: AS%d: ACP algorithm instance creation  failed", as+zMS);
865         return __LINE__;
866     }
867     pAsotCfg->acp = acp;
869     ((ALG_Handle)acp)->fxns->algControl((ALG_Handle) acp,
870         ACP_GETBETAPRIMEOFFSET, (IALG_Status *)&betaPrimeOffset);
872     for (z=ENCODE1; z < ENCODEN; z++) 
873     {
874         zS = pP->streamsFromEncodes[z];
875         acp->fxns->attach(acp, ACP_SERIES_STD,
876             STD_BETA_ENCODE + betaPrimeOffset * (as-1+zS),
877             (IALG_Status *)&pAstCfg->xEnc[z].encodeStatus);
878         acp->fxns->attach(acp, ACP_SERIES_STD,
879             STD_BETA_VOLUME + betaPrimeOffset * (as-1+zS),
880             (IALG_Status *)&pAstCfg->xEnc[z].volumeStatus);
881         /* Ignore errors, not reported. */
882     }
884     for (z=OUTPUT1; z < OUTPUTN; z++) 
885     {
886         zS = z;
887         for (zX = ENCODE1; zX < ENCODEN; zX++) 
888         {
889             if (pP->outputsFromEncodes[zX] == z) 
890             {
891                 zS = pP->streamsFromEncodes[zX];
892                 break;
893             }
894         }
895         acp->fxns->attach(acp, ACP_SERIES_STD,
896             STD_BETA_OB + betaPrimeOffset * (as-1+zS),
897             (IALG_Status *)&pAstCfg->xOut[z].outBufStatus);
898         /* Ignore errors, not reported. */
899     }
901     TRACE_TERSE1("PAF_ASOT_initPhaseAcpAlg: AS%d: initialization phase - ACP Algorithm complete.", as+zMS);
903     return 0;
904 } //PAF_ASOT_initPhaseAcpAlg
906 // -----------------------------------------------------------------------------
907 // ASOT Initialization Function - Common Memory
908 //
909 //   Name:      PAF_ASOT_initPhaseCommon
910 //   Purpose:   Audio Stream Output Task Function for allocation of common memory.
911 //   From:      audioStream1Task or equivalent
912 //   Uses:      See code.
913 //   States:    x
914 //   Return:    0 on success.
915 //              Source code line number on PAF_ALG_alloc failure.
916 //              Source code line number on PAF_ALG_mallocMemory failure.
917 //              Source code line number on Decode Chain initialization failure.
918 //              Source code line number on ASP Chain initialization failure.
919 //              Source code line number on Encode Chain initialization failure.
920 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
921 //              * State information as per parent.
922 //              * Memory allocation errors.
923 //
924 Int
925 PAF_ASOT_initPhaseCommon(
926     const PAF_ASOT_Params *pP, 
927     const PAF_ASOT_Patchs *pQ, 
928     PAF_ASOT_Config *pAsotCfg
931     PAF_AST_Config *pAstCfg;
932     Int as;                     /* Audio Stream Number (1, 2, etc.) */
933     Int z;                      /* stream counter */
934     Int g;                      /* gear */
935     ACP_Handle acp;
936     PAF_IALG_Config pafAlgConfig;
937     IALG_MemRec common[3][PAF_IALG_COMMON_MEMN+1];
938    
939     acp = pAsotCfg->acp;
940     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
941     as = pAstCfg->as;
943     TRACE_TERSE0("PAF_ASOT_initPhaseCommon: initialization phase - Common Memory");
945     //
946     // Determine memory needs and instantiate algorithms across audio streams
947     //
948     TRACE_TERSE0("PAF_ASOT_initPhaseCommon: calling PAF_ALG_setup.");
949     PAF_ALG_setup(&pafAlgConfig, 
950         HEAP_ID_INTERNAL,                 HEAP_INTERNAL, 
951         HEAP_ID_INTERNAL1,                HEAP_INTERNAL1, 
952         HEAP_ID_EXTERNAL,                 HEAP_EXTERNAL, 
953         HEAP_ID_INTERNAL1_SHM,            HEAP_INTERNAL1_SHM, 
954         HEAP_ID_EXTERNAL_SHM,             HEAP_EXTERNAL_SHM, 
955         HEAP_ID_EXTERNAL_NONCACHED_SHM,   HEAP_EXTERNAL_NONCACHED_SHM,
956         HEAP_CLEAR);
958     if (pP->fxns->headerPrint)
959     {
960         pP->fxns->headerPrint();        
961     }
963     for (z = STREAM1; z < STREAMN; z++) 
964     {
965         //Int zD, zE, zX;
966         Int zE, zX;
968         TRACE_TERSE1("PAF_ASOT_initPhaseCommon: AS%d: initialization phase - Common Memory", as+z);
970         //
971         // Determine common memory needs for:
972         //  (1) ASP Algorithms
973         //  (2) Encode Algorithms
974         //  (3) Logical Output drivers
975         //
976         PAF_ALG_init(common[z], lengthof(common[z]), COMMONSPACE);
978         zE = -1;
979         for (zX = ENCODE1; zX < ENCODEN; zX++) 
980         {
981             if (pP->streamsFromEncodes[zX] == z) 
982             {
983                 zE = zX;
984                 break;
985             }
986         }
988         TRACE_TERSE1("Calling PAF_ALG_ALLOC for stream common[%d].", z);
989         if (PAF_ALG_ALLOC(aspLinkInit[z-STREAM1][0], common[z])) 
990         {
991             TRACE_TERSE1("PAF_ASOT_initPhaseCommon: AS%d: PAF_ALG_alloc failed", as+z);
992             TRACE_TERSE2("Failed to alloc %d bytes from space %d ", common[z]->size, common[z]->space);
993             SW_BREAKPOINT;
994             return __LINE__;
995         }
996         TRACE_TERSE3("alloced %d bytes from space %d at 0x%x", common[z]->size, common[z]->space, (IArg)common[z]->base);
997         if (pP->fxns->allocPrint)
998         {
999             pP->fxns->allocPrint((const PAF_ALG_AllocInit *)(aspLinkInit[z-STREAM1][0]), sizeof (*(aspLinkInit[z-STREAM1][0])), &pafAlgConfig);
1000         }
1002         if (zE >= 0) 
1003         {
1004             TRACE_TERSE1("PAF_ASOT_initPhaseCommon: calling PAF_ALG_ALLOC/ for encoder common[%d].", z);
1005             if (PAF_ALG_ALLOC(encLinkInit[zE-ENCODE1], common[z])) 
1006             {
1007                 TRACE_TERSE1("PAF_ASOT_initPhaseCommon: AS%d: PAF_ALG_alloc failed", as+z);
1008                 SW_BREAKPOINT;
1009                 return __LINE__;
1010             }
1011             TRACE_TERSE3("alloced %d bytes from space %d at 0x%x", common[z]->size, common[z]->space, (IArg)common[z]->base);
1012             if (pP->fxns->allocPrint)
1013             {
1014                 pP->fxns->allocPrint((const PAF_ALG_AllocInit *)(encLinkInit[z-ENCODE1]), sizeof (*(encLinkInit[z-ENCODE1])), &pafAlgConfig);
1015             }
1016         }
1018         //
1019         // Determine common memory needs of Logical IO drivers
1020         //
1022         if (OUTPUT1 <= z && z < OUTPUTN)
1023         {
1024             TRACE_TERSE1("PAF_ASOT_initPhaseCommon: calling PAF_ALG_ALLOC outLinkInit common[%d].", z);
1025             if (PAF_ALG_ALLOC(outLinkInit[z-OUTPUT1], common[z]))
1026             {
1027                 TRACE_TERSE1("PAF_ASOT_initPhaseMalloc: AS%d: PAF_ALG_alloc failed", as+z);
1028                 TRACE_TERSE2("Failed to alloc %d bytes from space %d", common[z]->size, (IArg)common[z]->space);
1029                 SW_BREAKPOINT;
1030                 return __LINE__;
1031             }
1032             TRACE_TERSE3("alloced %d bytes from space %d at 0x%x", common[z]->size, common[z]->space, (IArg)common[z]->base);
1033             if (pP->fxns->allocPrint)
1034             {
1035                 pP->fxns->allocPrint((const PAF_ALG_AllocInit *)(outLinkInit[z-INPUT1]), sizeof (*(outLinkInit[z-INPUT1])), &pafAlgConfig);
1036             }
1037         }
1038     }
1039     {
1040         // Changes made to share scratch between zones
1041         // Assume maximum 3 zones and scratch common memory is at offset 0;
1042         int max=0;
1043         for (z=STREAM1; z<STREAMN; z++)
1044         {
1045             if (max < common[z][0].size)
1046             {
1047                 max = common[z][0].size;
1048             }
1049         }
1050         common[STREAM1][0].size=max;
1051         for (z=STREAM1+1; z<STREAMN; z++)
1052         {
1053             common[z][0].size = 0;            
1054         }
1055     }
1056         
1057     //
1058     // Allocate common memory for:
1059     //  (1) ASP Algorithms
1060     //  (2) Encode Algorithms
1061     //  (3) Logical Output drivers
1062     //
1063     for (z = STREAM1; z < STREAMN; z++) 
1064     {
1065         //Int zD, zE, zX;
1066         Int zE, zX;
1068         TRACE_TERSE0("PAF_ASOT_initPhaseCommon: calling PAF_ALG_mallocMemory for common space.");
1069         if (PAF_ALG_mallocMemory(common[z], &pafAlgConfig)) 
1070         {
1071             TRACE_TERSE1("AS%d: PAF_ALG_mallocMemory failed", as+z);
1072             TRACE_TERSE3("AS%d: z: %d.  Size 0x%x", as+z, z, common[z][0].size);
1073             SW_BREAKPOINT;
1074             return __LINE__;
1075         }
1076         TRACE_TERSE3("alloced %d bytes from space %d at 0x%x", common[z]->size, common[z]->space, (IArg)common[z]->base);
1077         // share zone0 scratch with all zones 
1078         common[z][0].base = common[0][0].base;
1079         if (pP->fxns->commonPrint)
1080         {
1081             pP->fxns->commonPrint(common[z], &pafAlgConfig);
1082         }
1084         zE = -1;
1085         for (zX = ENCODE1; zX < ENCODEN; zX++) 
1086         {
1087             if (pP->streamsFromEncodes[zX] == z) 
1088             {
1089                 zE = zX;
1090                 break;
1091             }
1092         }
1094         pAstCfg->xStr[z].aspChain[0] = NULL;
1095         for (g=0; g < GEARS; g++) 
1096         {
1097             PAF_ASP_Chain *chain;
1098             TRACE_TERSE0("PAF_ASOT_initPhaseCommon: calling PAF_ASP_chainInit for ASPs.");
1099             chain = PAF_ASP_chainInit(&pAstCfg->xStr[z].aspChainData[g], pP->pChainFxns,
1100                 HEAP_INTERNAL, as+z, acp, &trace,
1101                 aspLinkInit[z-STREAM1][g], pAstCfg->xStr[z].aspChain[0], common[z], &pafAlgConfig);
1102             if (!chain) 
1103             {
1104                 TRACE_TERSE2("AS%d: ASP chain %d initialization failed", as+z, g);
1105                 return __LINE__;
1106             }
1107             else
1108             {
1109                 pAstCfg->xStr[z].aspChain[g] = chain;
1110             }
1111         }
1113         if (zE >= 0) 
1114         {
1115             PAF_ASP_Chain *chain;
1116             TRACE_TERSE0("PAF_ASOT_initPhaseCommon: calling PAF_ASP_chainInit for encode.");
1117             chain = PAF_ASP_chainInit(&pAstCfg->xEnc[zE].encChainData, pP->pChainFxns,
1118                 HEAP_INTERNAL, as+z, acp, &trace,
1119                 encLinkInit[zE-ENCODE1], NULL, common[z], &pafAlgConfig);
1120             if (!chain) 
1121             {
1122                 TRACE_TERSE1("AS%d: Encode chain initialization failed", as+z);
1123                 return __LINE__;
1124             }
1125         }
1127         //
1128         // Allocate non-common memories for Logical IO drivers
1129         //    Since these structures are used at run-time we allocate from external memory
1130         if (OUTPUT1 <= z && z < OUTPUTN) 
1131         {
1132             PAF_ASP_Chain *chain;
1133             TRACE_TERSE2("PAF_ASOT_initPhaseMalloc: AS%d: non-common output chain init for %d",
1134                            as+z, z);
1135             chain = PAF_ASP_chainInit (&pAstCfg->xOut[z].outChainData, pP->pChainFxns,
1136                         HEAP_EXTERNAL, as+z, acp, &trace,
1137                         outLinkInit[z-OUTPUT1], NULL, common[z], &pafAlgConfig);
1138             if (!chain) 
1139             {
1140                 TRACE_TERSE1("AS%d: Output chain initialization failed", as+z);
1141                 return __LINE__;
1142             }
1143         }
1144     }
1145     TRACE_TERSE1("AS%d: PAF_ASOT_initPhaseCommon: Returning complete.", as+z);
1147     return 0;
1148 } //PAF_ASOT_initPhaseCommon
1150 // -----------------------------------------------------------------------------
1151 // ASOT Initialization Function - Algorithm Keys
1152 //
1153 //   Name:      PAF_ASOT_initPhaseAlgKey
1154 //   Purpose:   Audio Stream Output Task Function for initialization of data values
1155 //              from parameters for Algorithm Keys.
1156 //   From:      audioStream1Task or equivalent
1157 //   Uses:      See code.
1158 //   States:    x
1159 //   Return:    0.
1160 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
1161 //              * State information as per parent.
1162 //
1163 // .............................................................................
1164 Int
1165 PAF_ASOT_initPhaseAlgKey(
1166     const PAF_ASOT_Params *pP, 
1167     const PAF_ASOT_Patchs *pQ, 
1168     PAF_ASOT_Config *pAsotCfg
1171     PAF_AST_Config *pAstCfg;
1172     Int as;                     /* Audio Stream Number (1, 2, etc.) */
1173     Int z;                      /* decode/encode counter */
1174     Int s;                      /* key number */
1175     PAF_ASP_Link *that;
1177     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
1178     as = pAstCfg->as;
1179     (void)as; // clear compiler warning in case not used with tracing disabled
1181     TRACE_VERBOSE1("PAF_ASOT_initPhaseAlgKey: AS%d: initialization phase - Algorithm Keys", as);
1183     for (z=ENCODE1; z < ENCODEN; z++) 
1184     {
1185         for (s=0; s < pP->pEncAlgKey->length; s++) 
1186         {
1187             if ((pP->pEncAlgKey->code[s].full != 0) && 
1188                 (that = PAF_ASP_chainFind(&pAstCfg->xEnc[z].encChainData, pP->pEncAlgKey->code[s])))
1189             {
1190                 pAstCfg->xEnc[z].encAlg[s] = (ALG_Handle )that->alg;
1191             }
1192             /* Cast in interface, for now --Kurt */
1193             else
1194             {
1195                 pAstCfg->xEnc[z].encAlg[s] = NULL;                
1196             }
1197         }
1198     }
1200     return 0;
1201 } //PAF_ASOT_initPhaseAlgKey
1203 // -----------------------------------------------------------------------------
1204 // ASOT Initialization Function - I/O Devices
1205 //
1206 //   Name:      PAF_ASOT_initPhaseDevice
1207 //   Purpose:   Audio Stream Output Task Function for initialization of I/O Devices.
1208 //   From:      audioStream1Task or equivalent
1209 //   Uses:      See code.
1210 //   States:    x
1211 //   Return:    0 on success.
1212 //              Source code line number on device allocation failure.
1213 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
1214 //              * State information as per parent.
1215 //              * Memory allocation errors.
1216 //
1217 Int
1218 PAF_ASOT_initPhaseDevice(
1219     const PAF_ASOT_Params *pP, 
1220     const PAF_ASOT_Patchs *pQ, 
1221     PAF_ASOT_Config *pAsotCfg
1224     PAF_AST_Config *pAstCfg;
1225     Int as;                     /* Audio Stream Number (1, 2, etc.) */
1226     Int z;                      /* input/output counter */
1227     PAF_SIO_IALG_Obj    *pObj;
1228     PAF_SIO_IALG_Config *pAlgConfig;
1229     PAF_IALG_Config pafAlgConfig;
1231     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
1232     as = pAstCfg->as;
1233     (void)as; // clear compiler warning in case not used with tracing disabled
1235     TRACE_TERSE1("PAF_ASOT_initPhaseDevice: AS%d: initialization phase - I/O Devices", as);
1237     if(pP->fxns->bufMemPrint)
1238     {
1239         PAF_ALG_setup (&pafAlgConfig, 
1240             HEAP_ID_INTERNAL,               HEAP_INTERNAL, 
1241             HEAP_ID_INTERNAL1,              HEAP_INTERNAL1,
1242             HEAP_ID_EXTERNAL,               HEAP_EXTERNAL,
1243             HEAP_ID_INTERNAL1_SHM,          HEAP_INTERNAL1_SHM,
1244             HEAP_ID_EXTERNAL_SHM,           HEAP_EXTERNAL_SHM,
1245             HEAP_ID_EXTERNAL_NONCACHED_SHM, HEAP_EXTERNAL_NONCACHED_SHM,
1246             HEAP_CLEAR);
1247         TRACE_TERSE2("PAF_ASOT_initPhaseDevice: AS%d: calling PAF_ALG_setup with clear at %d.", as, HEAP_CLEAR);
1248     }
1249     
1250     for (z=OUTPUT1; z < OUTPUTN; z++) 
1251     {
1252         PAF_OutBufConfig *pConfig = &pAstCfg->xOut[z].outBufConfig;
1254         pObj = (PAF_SIO_IALG_Obj *)pAstCfg->xOut[z].outChainData.head->alg;
1255         pAlgConfig = &pObj->config;
1257         pAstCfg->xOut[z].hTxSio = NULL;
1258         pConfig->base.pVoid     = pAlgConfig->pMemRec[0].base;
1259         pConfig->pntr.pVoid     = pAlgConfig->pMemRec[0].base;
1260         pConfig->head.pVoid     = pAlgConfig->pMemRec[0].base;
1261         pConfig->allocation     = pAlgConfig->pMemRec[0].size;
1262         pConfig->sizeofElement  = 3;
1263         pConfig->precision      = 24;
1264         if(pP->fxns->bufMemPrint)
1265         {
1266             pP->fxns->bufMemPrint(z,pAlgConfig->pMemRec[0].size,PAF_ALG_memSpaceToHeapId(&pafAlgConfig,pAlgConfig->pMemRec[0].space),1);
1267         }
1268     }
1269     TRACE_TERSE1("PAF_ASOT_initPhaseDevice: AS%d: initialization phase - I/O Devices complete.", as);
1271     return 0;
1272 } //PAF_ASOT_initPhaseDevice
1274 // -----------------------------------------------------------------------------
1275 // ASOT Initialization Function Helper - Initialization of Audio Frame
1276 //
1277 //   Name:      PAF_ASOT_initFrame0
1278 //   Purpose:   Audio Stream Output Task Function for initialization of the Audio
1279 //              Frame(s) by memory allocation and loading of data pointers
1280 //              and values.
1281 //   From:      AST Parameter Function -> decodeInfo
1282 //   Uses:      See code.
1283 //   States:    x
1284 //   Return:    0 on success.
1285 //              Source code line number on MEM_calloc failure.
1286 //              Source code line number on unsupported option.
1287 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
1288 //              * Memory allocation errors.
1289 //              * Unsupported option errors.
1290 //
1292 // MID 314
1293 extern const char AFChanPtrMap[PAF_MAXNUMCHAN+1][PAF_MAXNUMCHAN];
1294 extern PAF_ChannelConfigurationMaskTable PAF_ASP_stdCCMT_patch;
1296 Int
1297 PAF_ASOT_initFrame0(
1298     const PAF_ASOT_Params *pP, 
1299     const PAF_ASOT_Patchs *pQ, 
1300     PAF_ASOT_Config *pAsotCfg, 
1301     Int z
1304     PAF_AST_Config *pAstCfg;
1305     Int as;                     /* Audio Stream Number (1, 2, etc.) */
1306     Int ch;
1307     //Int aLen;
1308     Int aLen_int=0,aLen_ext=0;
1309     Int aSize = sizeof(PAF_AudioData);
1310     Int aAlign = aSize < sizeof (int) ? sizeof (int) : aSize;
1311     Int maxFrameLength = pP->maxFramelength;
1312     Int zX;
1313     PAF_AudioData *aBuf_int=NULL;
1314     PAF_AudioData *aBuf_ext=NULL;
1315     XDAS_UInt8 *metadataBuf;
1316     char i;
1317     Error_Block    eb;
1319     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
1320     as = pAstCfg->as;
1322     // Initialize error block
1323     Error_init(&eb); 
1325     // Compute maximum framelength (needed for ARC support)
1326     maxFrameLength += PA_MODULO - maxFrameLength % PA_MODULO;
1327     //aLen = numchan[z] * maxFrameLength;
1328     for (i=0; i < numchan[z]; i++)
1329     {
1330         if (pP->pAudioFrameBufStatus->space[i] == IALG_SARAM)
1331         {
1332             aLen_int += maxFrameLength;
1333         }
1334         else
1335         {
1336             aLen_ext += maxFrameLength;
1337         }
1338     }
1340     //
1341     // Initialize audio frame elements directly
1342     //
1343     pAstCfg->xStr[z].pAudioFrame->fxns = pP->pAudioFrameFunctions;
1344     pAstCfg->xStr[z].pAudioFrame->data.nChannels = PAF_MAXNUMCHAN; ///
1345 ///    pAstCfg->xStr[z].pAudioFrame->data.nChannels = PAF_MAXNUMCHAN_AF;
1346     pAstCfg->xStr[z].pAudioFrame->data.nSamples = FRAMELENGTH;
1347     pAstCfg->xStr[z].pAudioFrame->data.sample = pAstCfg->xStr[z].audioFrameChannelPointers;
1348     pAstCfg->xStr[z].pAudioFrame->data.samsiz = pAstCfg->xStr[z].audioFrameChannelSizes;
1349     pAstCfg->xStr[z].pAudioFrame->pChannelConfigurationMaskTable = &PAF_ASP_stdCCMT;
1351     //
1352     // Allocate memory for and initialize pointers to audio data buffers
1353     //
1354     //   The NUMCHANMASK is used to identify the channels for which data
1355     //   buffers can be allocated. Using this mask and switch statement
1356     //   rather than some other construct allows efficient code generation,
1357     //   providing just the code necessary (with significant savings).
1358     //
1359     if (pP->fxns->bufMemPrint)
1360     {
1361         pP->fxns->bufMemPrint(z, aLen_int*aSize, HEAP_ID_FRMBUF, 2);
1362         pP->fxns->bufMemPrint(z, aLen_ext*aSize, HEAP_ID_EXTERNAL, 2);
1363     }
1365     TRACE_TERSE1("PAF_ASOT_initFrame0: AS%d: Memory_calloc for audio buffers", as+z);
1366     
1367     if (aLen_int*aSize!=0) // check size != 0, otherwise malloc throws fatal error
1368     {
1369         if (!(aBuf_int = (PAF_AudioData *)Memory_calloc((IHeap_Handle)HEAP_FRMBUF, (aLen_int+(maxFrameLength-FRAMELENGTH))*aSize, aAlign, &eb))) //Qin: Add start offset
1370         {
1371             TRACE_TERSE1("PAF_ASOT_initFrame0: AS%d: Memory_calloc failed", as+z);
1372             TRACE_TERSE2("  maxFrameLength: %d.  aLen_int*aSize: %d", maxFrameLength, (aLen_int+(maxFrameLength-FRAMELENGTH))*aSize);
1373             SW_BREAKPOINT;
1374             return __LINE__;
1375         }
1376     }
1377         
1378     if (aLen_ext*aSize!=0)
1379     {
1380         if (!(aBuf_ext = (PAF_AudioData *)Memory_calloc((IHeap_Handle)HEAP_EXTERNAL, (aLen_ext+(maxFrameLength-FRAMELENGTH))*aSize, aAlign, &eb)))//Qin: Add start offset
1381         {
1382             TRACE_TERSE1("PAF_ASOT_initFrame0: AS%d: Memory_calloc failed", as+z);
1383             TRACE_TERSE2("  maxFrameLength: %d.  aLen_ext*aSize: %d", maxFrameLength, (aLen_ext+(maxFrameLength-FRAMELENGTH))*aSize);
1384             SW_BREAKPOINT;
1385             return __LINE__;
1386         }
1387     }
1388     
1389     TRACE_TERSE3("  maxFrameLength: %d.  aLen_int*aSize: %d.  aBuf_int: 0x%x", maxFrameLength, (aLen_int+(maxFrameLength-FRAMELENGTH))*aSize, (IArg)aBuf_int);
1390     TRACE_TERSE3("  maxFrameLength: %d.  aLen_ext*aSize: %d.  aBuf_ext: 0x%x", maxFrameLength, (aLen_ext+(maxFrameLength-FRAMELENGTH))*aSize, (IArg)aBuf_ext);
1392     TRACE_TERSE1("PAF_ASOT_initFrame0: AS%d: Memory_calloc for metadata buffers", as+z);
1393     if (!(metadataBuf = (XDAS_UInt8 *)Memory_calloc((IHeap_Handle)HEAP_MDBUF, pP->pMetadataBufStatus->bufSize*pP->pMetadataBufStatus->NumBuf, pP->pMetadataBufStatus->alignment, &eb)))
1394     {
1395         TRACE_TERSE1("PAF_ASOT_initFrame0: AS%d: Memory_calloc failed", as+z);
1396         TRACE_TERSE1("  bufSize*NumBuf: %d", pP->pMetadataBufStatus->bufSize*pP->pMetadataBufStatus->NumBuf);
1397         SW_BREAKPOINT;
1398         return __LINE__;
1399     }
1401     {
1402         Int i;
1404 #pragma UNROLL(1)
1405         for (i=0; i < PAF_MAXNUMCHAN_AF; i++)
1406         {
1407             pAstCfg->xStr[z].audioFrameChannelPointers[i] = NULL;
1408         }
1409     }
1411     // MID 314
1412     if((numchan[z] > PAF_MAXNUMCHAN) || (numchan[z] < 1)) 
1413     {
1414         TRACE_TERSE1("PAF_ASOT_initFrame0: AS%d: unsupported option", as+z);
1415         return __LINE__;
1416     }
1417     else 
1418     {
1419         Int j = 0;
1420         Int k = 0;
1421         TRACE_TERSE1("PAF_ASOT_initFrame0: AFChanPtrMap[%d][i]", numchan[z]);
1422         for(i=0;i<numchan[z];i++)
1423         {
1424             char chan = AFChanPtrMap[numchan[z]][i];
1425             if(chan != -1)
1426             {
1427                 if(pP->pAudioFrameBufStatus->space[i] == IALG_SARAM)
1428                 {
1429                     pAstCfg->xStr[z].audioFrameChannelPointers[chan] = aBuf_int + maxFrameLength*(j+1) - FRAMELENGTH;
1430                     j++;
1431                 }
1432                 else
1433                 {        
1434                     pAstCfg->xStr[z].audioFrameChannelPointers[chan] = aBuf_ext + maxFrameLength*(k+1) - FRAMELENGTH;
1435                     k++;
1436                 }    
1437                 TRACE_TERSE3("PAF_ASOT_initFrame0: chan = %d = AFChanPtrMap[%d][%d].", chan, numchan[z], i);
1438                 TRACE_TERSE2("PAF_ASOT_initFrame0: audioFrameChannelPointers[%d]: 0x%x", chan, (IArg)pAstCfg->xStr[z].audioFrameChannelPointers[chan]);
1439             }
1440         }
1441     }
1443     for (ch=PAF_LEFT; ch < PAF_MAXNUMCHAN_AF; ch++) 
1444     {
1445         if (pAstCfg->xStr[z].audioFrameChannelPointers[ch])
1446         {
1447             pAstCfg->xStr[z].origAudioFrameChannelPointers[ch] = pAstCfg->xStr[z].audioFrameChannelPointers[ch];
1448         }
1449     }
1451     //
1452     // Initialize meta data elements
1453     //
1454     pAstCfg->xStr[z].pAudioFrame->pafBsMetadataUpdate = XDAS_FALSE;
1455     pAstCfg->xStr[z].pAudioFrame->numPrivateMetadata = 0;
1456     pAstCfg->xStr[z].pAudioFrame->bsMetadata_offset = 0;
1457     pAstCfg->xStr[z].pAudioFrame->bsMetadata_type = PAF_bsMetadata_channelData;
1458     pAstCfg->xStr[z].pAudioFrame->privateMetadataBufSize = pP->pMetadataBufStatus->bufSize;
1459     for(i=0;i<pP->pMetadataBufStatus->NumBuf;i++)
1460     {
1461         pAstCfg->xStr[z].pAudioFrame->pafPrivateMetadata[i].offset = 0;
1462         pAstCfg->xStr[z].pAudioFrame->pafPrivateMetadata[i].size = 0;
1463         pAstCfg->xStr[z].pAudioFrame->pafPrivateMetadata[i].pMdBuf = metadataBuf + pP->pMetadataBufStatus->bufSize*i;
1464     }
1466     //
1467     // Initialize decoder elements directly
1468     //
1470     for (zX = DECODE1; zX < DECODEN; zX++) 
1471     {
1472         if (pP->streamsFromDecodes[zX] == z) 
1473         {
1474 #ifdef NOAUDIOSHARE
1475             pAstCfg->xDec[zX].decodeInStruct.audioShare.nSamples = 0;
1476             pAstCfg->xDec[zX].decodeInStruct.audioShare.sample = NULL;
1477 #else /* NOAUDIOSHARE */
1478             pAstCfg->xDec[zX].decodeInStruct.audioShare.nSamples = aLen_int;
1479             pAstCfg->xDec[zX].decodeInStruct.audioShare.sample = aBuf_int;
1480 #endif /* NOAUDIOSHARE */
1481         }
1482     }
1484     return 0;
1485 } //PAF_ASOT_initFrame0
1487 // -----------------------------------------------------------------------------
1488 // ASOT Initialization Function Helper - Reinitialization of Audio Frame
1489 // AST Decoding Function              - Reinitialization of Audio Frame
1490 //
1491 //   Name:      PAF_ASOT_initFrame1
1492 //   Purpose:   Audio Stream Task Function for initialization or reinitiali-
1493 //              zation of the Audio Frame(s) by loading of data values of a
1494 //              time-varying nature.
1495 //   From:      audioStream1Task or equivalent
1496 //              AST Parameter Function -> decodeInfo
1497 //              AST Parameter Function -> decodeDecode
1498 //   Uses:      See code.
1499 //   States:    x
1500 //   Return:    0.
1501 //   Trace:     None.
1502 //
1503 Int
1504 PAF_ASOT_initFrame1(
1505     const PAF_ASOT_Params *pP, 
1506     const PAF_ASOT_Patchs *pQ, 
1507     PAF_ASOT_Config *pAsotCfg, 
1508     Int z, 
1509     Int apply
1512     PAF_AST_Config *pAstCfg;
1514     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
1516     //
1517     // Reinitialize audio frame elements:
1518     //
1519     //   Channel Configurations during sys init                 = Unknown
1520     //      "          "        during info or decode           = None
1521     //
1522     //   Sample Rate / Count    during sys init, info or decode = Unknown / 0
1523     //
1525     if (apply < 0) 
1526     {
1527         pAstCfg->xStr[z].pAudioFrame->channelConfigurationRequest.legacy = PAF_CC_UNKNOWN;
1528         pAstCfg->xStr[z].pAudioFrame->channelConfigurationStream.legacy = PAF_CC_UNKNOWN;
1529     }
1530     else 
1531     {
1532         pAstCfg->xStr[z].pAudioFrame->channelConfigurationRequest.legacy = PAF_CC_NONE;
1533         pAstCfg->xStr[z].pAudioFrame->channelConfigurationStream.legacy = PAF_CC_NONE;
1534     }
1536     if (apply < 1) 
1537     {
1538         pAstCfg->xStr[z].pAudioFrame->sampleRate = PAF_SAMPLERATE_UNKNOWN;
1539         pAstCfg->xStr[z].pAudioFrame->sampleCount = 0;
1540     }
1542     return 0;
1543 } //PAF_ASOT_initFrame1
1545 // -----------------------------------------------------------------------------
1546 // ASOT Selection Function - Output Device Selection
1547 //
1548 //   Name:      PAF_ASOT_selectDevices
1549 //   Purpose:   Audio Stream Output Task Function for selecting the devices used
1550 //              for output.
1551 //   From:      audioStream1Task or equivalent
1552 //   Uses:      See code.
1553 //   States:    x
1554 //   Return:    Error number in standard form (0 on success).
1555 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
1556 //              * State information as per parent.
1557 //
1558 Int
1559 PAF_ASOT_selectDevices(
1560     const PAF_ASOT_Params *pP, 
1561     const PAF_ASOT_Patchs *pQ, 
1562     PAF_ASOT_Config *pAsotCfg
1565     PAF_AST_Config *pAstCfg;
1566     Int as;                     /* Audio Stream Number (1, 2, etc.) */
1567     Int z;                      /* input/output counter */
1568     Int errno = 0;              /* error number */
1569     Int errme;                  /* error number, local */
1570     Int device;
1572     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
1573     as = pAstCfg->as;
1574     (void)as;  // clear compiler warning in case not used with tracing disabled
1576     // Select output devices
1577     for (z=OUTPUT1; z < OUTPUTN; z++) 
1578     {
1579         if ((device = pAstCfg->xOut[z].outBufStatus.sioSelect) >= 0) 
1580         {
1581             TRACE_VERBOSE2("PAF_ASOT_selectDevices: AS%d: output device %d selecting ...", as+z, device);
1583             /* check for valid index into device array */
1584             if (device >= pQ->devout->n)
1585             {
1586                 device = 0; /* treat as device None */
1587             }
1589             errme = pP->fxns->deviceSelect(&pAstCfg->xOut[z].hTxSio, SIO_OUTPUT, 
1590                 HEAP_ID_OUTBUF, (Ptr)pQ->devout->x[device]);
1591             if (errme)
1592             {
1593                 TRACE_VERBOSE2("PAF_ASOT_selectDevices: errme 0x%x, errno 0x%x", errme, errno);
1594                 if (!errno)
1595                 {
1596                     errno = ASPERR_DEVOUT + errme;
1597                 }
1598                 pAstCfg->xOut[z].outBufStatus.sioSelect = 0x80;
1599             }
1600             else 
1601             {
1602                 Int zE;
1604                 pAstCfg->xOut[z].outBufStatus.sioSelect = device | 0x80;
1605                 // register outBufStatus and encodeStatus pointers with output devices
1606                 // This enables proper IEC encapsulation.
1607                 if (pAstCfg->xOut[z].hTxSio) 
1608                 {
1609                     // set max # of output buffers (use override if necessary)
1610                     if (pAstCfg->xOut[z].outBufStatus.maxNumBufOverride == 0)
1611                     {
1612                         SIO_ctrl(pAstCfg->xOut[z].hTxSio, PAF_SIO_CONTROL_SET_MAX_NUMBUF,
1613                             (Arg)pP->poutNumBufMap[z]->maxNumBuf);
1614                     }
1615                     else
1616                     {
1617                         SIO_ctrl(pAstCfg->xOut[z].hTxSio, PAF_SIO_CONTROL_SET_MAX_NUMBUF,
1618                             (Arg)pAstCfg->xOut[z].outBufStatus.maxNumBufOverride);
1619                     }
1621                     // register PAF_SIO_IALG object address
1622                     SIO_ctrl(pAstCfg->xOut[z].hTxSio, PAF_SIO_CONTROL_SET_IALGADDR,
1623                         (Arg)pAstCfg->xOut[z].outChainData.head->alg);
1624                     SIO_ctrl(pAstCfg->xOut[z].hTxSio, PAF_SIO_CONTROL_SET_BUFSTATUSADDR, 
1625                         (Arg)&pAstCfg->xOut[z].outBufStatus);
1626                     for (zE=ENCODE1; zE < ENCODEN; zE++) 
1627                     {
1628                         if (pP->outputsFromEncodes[zE] == z) 
1629                         {
1630                             SIO_ctrl(pAstCfg->xOut[z].hTxSio, 
1631                                 PAF_SIO_CONTROL_SET_ENCSTATUSADDR, 
1632                                 (Arg)&pAstCfg->xEnc[zE].encodeStatus);
1633                             break;
1634                         }
1635                     }
1636                 }
1637             }
1638         }
1640         // if device selected and valid then enable stat tracking if
1641         // required and start clocking
1642         if ((pAstCfg->xOut[z].outBufStatus.sioSelect < 0) && (pAstCfg->xOut[z].hTxSio)) 
1643         {
1644             TRACE_VERBOSE0("PAF_ASOT_selectDevices: start SIO clocks");
1645             errme = SIO_ctrl(pAstCfg->xOut[z].hTxSio, PAF_SIO_CONTROL_OUTPUT_START_CLOCKS, 0);
1646             if (errme)
1647             {
1648                 TRACE_VERBOSE2("PAF_ASOT_selectDevices: errme 0x%x, errno 0x%x", errme, errno);
1649                 SIO_idle(pAstCfg->xOut[z].hTxSio);
1650                 if (!errno)
1651                 {
1652                     errno = ASPERR_DEVOUT + errme;
1653                 }
1654             }
1655         }
1656     }
1658     return errno;
1659 } //PAF_ASOT_selectDevices
1662 // -----------------------------------------------------------------------------
1663 // ASOT Processing Function - Decode Processing
1664 //
1665 //   Name:      PAF_ASOT_decodeProcessing
1666 //   Purpose:   Audio Stream Output Task Function for processing audio data.
1667 //
1668 Int
1669 PAF_ASOT_decodeProcessing(
1670     const PAF_ASOT_Params *pP, 
1671     const PAF_ASOT_Patchs *pQ, 
1672     PAF_ASOT_Config *pAsotCfg 
1675     PAF_AST_Config *pAstCfg;
1676     Int errno;                          /* error number */
1677     Int getVal;
1678     enum { INIT, STREAM, ENCODE, FINAL, QUIT, OUT_SIO_UPDATE } state;
1679     state = INIT;
1680     errno = 0; /* error number */
1681     Int frame; // (***) FL: formerly -- decoder input frame count
1682     Int block; // decoder output block count / input frame
1683     Int outSioUpdate;
1684     
1685     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
1687     for (;;) 
1688     {
1689         //
1690         // Check forward (ASIT) error here, TBD
1691         //
1692         
1693         
1694         // Check if any change in output SIO, e.g. from Output shortcut.
1695         // Changes will break FSM and allow Output reconfiguration.
1696         errno = checkOutSio(pP, pAsotCfg, &outSioUpdate);
1697         if (errno < 0)
1698         {
1699             TRACE_TERSE1("PAF_ASOT_decodeProcessing: checkOutSio returned errno = 0x%04x", errno);
1700             break;
1701         }
1702         else if (outSioUpdate)
1703         {
1704             TRACE_VERBOSE0("PAF_ASOT_decodeProcessing: Change in Output SIO selection");
1705             state = OUT_SIO_UPDATE;
1706         }
1707         
1708         // Process commands (encode)
1709         getVal = pP->fxns->encodeCommand(pP, pQ, pAsotCfg);
1710         if (getVal) 
1711         {
1712             /* ignore */;
1713         }
1715         // Process state (decode)
1716         switch (state) 
1717         {
1718             case INIT: // initial state
1719                 gAsopInitCnt++;
1720                 Log_info0("TaskAsop: state=INIT");
1721             
1722                 frame = 0;
1723                 block = 0;
1725 #if 0 // FL: moved to PAF_ASOT_initOutProc()
1726                 // Reset audio frame pointers to original values
1727                 // (may be needed if error occurred).
1728                 resetAfPointers(pP, pAstCfg->xStr);
1729                 // Reset audio frame meta data elements
1730                 resetAfMetadata(pP, pAstCfg->xStr);
1731 #endif
1733                 errno = pP->fxns->decodeInit(pP, pQ, pAsotCfg);
1734                 if (errno)
1735                 {
1736                     TRACE_VERBOSE1("PAF_ASOT_decodeProcessing: INIT, errno 0x%x.  break after decodeInit", errno);
1737                     errno = ASOP_DP_DECINIT_ERR;
1738                     break;
1739                 }
1740                 
1741                 //
1742                 // Setup output: setCheckRateX, start output
1743                 //
1744                 // Establish secondary timing
1745                 errno = pP->fxns->decodeInfo1(pP, pQ, pAsotCfg, frame, block);
1746                 if (errno)
1747                 {
1748                     TRACE_VERBOSE1("PAF_ASOT_decodeProcessing: INIT, errno 0x%x.  break after decodeInfo1", errno);
1749                     break;
1750                 }
1751                 
1752                 TRACE_VERBOSE0("PAF_ASOT_decodeProcessing: state: INIT->STREAM");                
1753                 state = STREAM;
1754                 continue;
1755                 
1756             case STREAM: // stream state
1757                 gAsopStreamCnt++;
1758                 Log_info0("TaskAsop: state=STREAM");
1760                 errno = pP->fxns->decodeStream(pP, pQ, pAsotCfg, frame, block);
1761                 if (errno)
1762                 {
1763                     TRACE_TERSE1("PAF_ASOT_decodeProcessing: state: STREAM.  decodeStream err 0x%x", errno);
1764                     errno = ASOP_DP_DECSTREAM_ERR;
1765                     break;
1766                 }
1768                 TRACE_VERBOSE0("PAF_ASOT_decodeProcessing: state: STREAM->ENCODE");
1769                 state = ENCODE;
1770                 continue;
1771                 
1772             case ENCODE: // encode state
1773                 gAsopEncodeCnt++;
1774                 Log_info0("TaskAsop: state=ENCODE");
1776                 errno = pP->fxns->decodeEncode(pP, pQ, pAsotCfg, frame, block);
1777                 if (errno)
1778                 {
1779                     TRACE_TERSE1("PAF_ASOT_decodeProcessing: state: ENCODE.  decodeEncode err 0x%x", errno);
1780                     errno = ASOP_DP_DECENC_ERR;
1781                     break;
1782                 }
1783                 
1784                 // Measure cycles in output processing loop.
1785                 // Only measures cycles spent in loop.
1786                 pfpEnd(PFP_ID_ASOT_1, PFP_FINISH_MEAS);
1787                 gNumPfpAsot1--;
1788                 pfpBegin(PFP_ID_ASOT_1, pAsotCfg->taskHandle);
1789                 gNumPfpAsot1++;
1790                 
1791                 // (***) FL: do we need this? 
1792                 //       AF pointers come from CB read, any resets occur in Decoder AF.
1793                 //
1794                 // Reset audio frame pointers to original values
1795                 // (may have been adjusted by ARC or the like).
1796                 resetAfPointers(pP, pAstCfg->xStr);
1798                 // (***) FL: update output (setCheckRateX)
1799                 //           Contained in INFO2 in combined FSM.
1800                 errno = pP->fxns->decodeInfo2(pP, pQ, pAsotCfg, frame, block);
1801                 if (errno)
1802                 {
1803                     TRACE_TERSE1("PAF_ASOT_decodeProcessing: ENCODE break on decodeInfo2. errno 0x%x", errno);
1804                     errno = ASOP_DP_DECINFO2_ERR;
1805                     break;
1806                 }
1808                 block++;
1809                 TRACE_VERBOSE0("PAF_ASOT_decodeProcessing: state: ENCODE->FINAL");
1810                 state = FINAL;
1811                 continue;
1812                 
1813             case FINAL:
1814                 gAsopFinalCnt++;
1815                 Log_info0("TaskAsop: state=FINAL");
1816                 
1817                 //
1818                 // (***) FL: this needs to be fixed.
1819                 //       (1) Only require selected Output to be in this FSM
1820                 //           => Dec Status checks aren't valid, 
1821                 //              will probably always exit FSM if only Output running
1822                 //       (2) Checking Dec Status info asych to input events (maybe ok)
1823                 //
1824                 // Check for final frame, and if indicated:
1825                 // - Update audio flag to cause output buffer flush rather than
1826                 //   the default truncate in "complete" processing.
1827                 // - Exit state machine to "complete" processing.
1828 #if 0
1829                 if (pP->fxns->decodeFinalTest(pP, pQ, pAsotCfg, frame, block)) 
1830                 {
1831                     for (z=OUTPUT1; z < OUTPUTN; z++)
1832                     {
1833                         if ((pAstCfg->xOut[z].outBufStatus.audio & 0x0f) == PAF_OB_AUDIO_SOUND)
1834                         {
1835                             TRACE_VERBOSE0("PAF_ASOT_outputProcessing: state: FINAL: SOUND -> QUIET");
1836                             pAstCfg->xOut[z].outBufStatus.audio++; // SOUND -> QUIET
1837                         }
1838                     }
1839                     break;
1840                 }
1841 #endif
1842                 errno = pP->fxns->decodeFinalTest(pP, pQ, pAsotCfg, frame, block);
1843                 if (errno < 0)
1844                 {
1845                     TRACE_TERSE1("PAF_ASOT_decodeProcessing: DECODE FINAL break. errno 0x%x", errno);
1846                     errno = ASOP_DP_DECFINALTEST_ERR;
1847                     break;
1848                 }
1849                 else if (errno == ASOP_DP_CB_DRAINED)
1850                 {
1851                     // EOS, exit normally
1852                     TRACE_TERSE1("PAF_ASOT_decodeProcessing: DECODE FINAL normal exit. errno 0x%x", errno);
1853                     errno = ASOP_DP_SOK;
1854                     break;
1855                 }
1857                 TRACE_VERBOSE0("PAF_ASOT_decodeProcessing: state: FINAL->STREAM");
1858                 state = STREAM;
1859                 continue;
1860                 
1861             case OUT_SIO_UPDATE:
1862                 gAsopOutSioUpdateCnt++;
1863                 Log_info0("TaskAsop: state=OUT_SIO_UPDATE");
1865                 TRACE_VERBOSE0("PAF_ASOT_decodeProcessing: state: OUT_SIO_UPDATE");
1866                 errno = ASOP_DP_OUT_SIO_UPDATE;
1867                 break;
1868                 
1869             case QUIT:
1870                 gAsopQuitCnt++;
1871                 Log_info0("TaskAsop: state=QUIT");
1873                 TRACE_VERBOSE0("PAF_ASOT_decodeProcessing: state: QUIT");
1874                 errno = ASPERR_QUIT;
1875                 break;
1877             default: // unknown state
1878                 // Unknown:
1879                 // - Set error number registers.
1880                 // - Exit state machine to "complete" processing.
1882                 TRACE_TERSE1("PAF_ASOT_decodeProcessing: state: unknown, 0x%x", state);
1883                 errno = ASPERR_UNKNOWNSTATE;
1884                 break;
1886         }  // End of switch (state).
1887         
1888         TRACE_VERBOSE0("PAF_ASOT_decodeProcessing: Calling decode complete");
1889         if (pP->fxns->decodeComplete(pP, pQ, pAsotCfg, NULL, frame, block))
1890         {
1891             /* ignored? */;
1892         }
1893         
1894         //pfpEnd(PFP_ID_ASOT_1, PFP_FINISH_MEAS); // PFP end -- outside of PFP for errors, EOS, or Output SIO change
1895         //gNumPfpAsot1--;
1896         
1897         //return errno;
1898         break;        
1899     } // End of for (;;)
1900         
1901     pfpEnd(PFP_ID_ASOT_1, PFP_FINISH_MEAS); // PFP end -- outside of PFP for errors, EOS, or Output SIO change
1902     gNumPfpAsot1--;
1903         
1904     return errno;
1907 // -----------------------------------------------------------------------------
1908 // ASOT Decoding Function - Encode Command Processing
1909 //
1910 //   Name:      PAF_ASOT_encodeCommand
1911 //   Purpose:   Decoding Function for processing Encode Commands.
1912 //   From:      AST Parameter Function -> decodeProcessing
1913 //   Uses:      See code.
1914 //   States:    x
1915 //   Return:    0.
1916 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
1917 //              * Command execution.
1918 //              * SIO control errors.
1919 //              * Error number macros.
1920 //
1921 Int
1922 PAF_ASOT_encodeCommand(
1923     const PAF_ASOT_Params *pP, 
1924     const PAF_ASOT_Patchs *pQ, 
1925     PAF_ASOT_Config *pAsotCfg
1928     PAF_AST_Config *pAstCfg;
1929     Int as;                     /* Audio Stream Number (1, 2, etc.) */
1930     Int z;                      /* encode counter */
1931     Int errno = 0;              /* error number */
1932     Int zO, zS;
1935     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
1936     as = pAstCfg->as;
1938     for (z=ENCODE1; z < ENCODEN; z++) 
1939     {
1940         zO = pP->outputsFromEncodes[z];
1941         zS = pP->streamsFromEncodes[z];
1942         if (! (pAstCfg->xEnc[z].encodeStatus.command2 & 0x80)) 
1943         {
1944             switch (pAstCfg->xEnc[z].encodeStatus.command2) 
1945             {
1946                 case 0: // command none - process
1947                     pAstCfg->xEnc[z].encodeStatus.command2 |= 0x80;
1948                     break;
1949                 case 1: // mute command
1950                     TRACE_VERBOSE2("AS%d: PAF_ASOT_encodeCommand: encode command mute (0x%02x)", as+zS, 1);
1951                     if ((pAstCfg->xOut[zO].outBufStatus.audio & 0x0f) != PAF_OB_AUDIO_QUIET
1952                         && pAstCfg->xOut[zO].hTxSio
1953                         && (errno = SIO_ctrl (pAstCfg->xOut[zO].hTxSio, PAF_SIO_CONTROL_MUTE, 0))) 
1954                     {
1955                         errno = (errno & 0xff) | ASPERR_MUTE;
1956                         /* convert to sensical errno */
1957                         TRACE_TERSE1("AS%d: PAF_ASOT_encodeCommand: SIO control failed (mute)", as+zS);
1958                         TRACE_TERSE2("AS%d: PAF_ASOT_encodeCommand: errno = 0x%04x <ignored>", as+zS, errno);
1959                     }
1960                     else 
1961                     {
1962                         pAstCfg->xOut[zO].outBufStatus.audio |= PAF_OB_AUDIO_MUTED;
1963                     }
1964                     pAstCfg->xEnc[z].encodeStatus.command2 |= 0x80;
1965                     break;
1966                 case 2: // unmute command
1967                     TRACE_VERBOSE2("AS%d: PAF_ASOT_encodeCommand: encode command unmute (0x%02x)", as+zS, 2);
1968                     if ((pAstCfg->xOut[zO].outBufStatus.audio & 0x0f) != PAF_OB_AUDIO_QUIET
1969                         && pAstCfg->xOut[zO].hTxSio
1970                         && (errno = SIO_ctrl (pAstCfg->xOut[zO].hTxSio, PAF_SIO_CONTROL_UNMUTE, 0))) 
1971                     {
1972                         errno = (errno & 0xff) | ASPERR_MUTE;
1973                         /* convert to sensical errno */
1974                         TRACE_TERSE1("AS%d: PAF_ASOT_encodeCommand: SIO control failed (unmute)", as+zS);
1975                         TRACE_TERSE2("AS%d: PAF_ASOT_encodeCommand: errno = 0x%04x <ignored>", as+zS, errno);
1976                     }
1977                     else 
1978                     {
1979                         pAstCfg->xOut[zO].outBufStatus.audio &= ~PAF_OB_AUDIO_MUTED;
1980                     }
1981                     pAstCfg->xEnc[z].encodeStatus.command2 |= 0x80;
1982                     break;
1983                 default: // command unknown - ignore
1984                     break;
1985             }
1986         }
1987     }
1989     ERRNO_RPRT (TaskAsop, errno);
1991     return 0;
1992 } //PAF_ASOT_encodeCommand
1994 //   Purpose:   Decoding Function for reinitializing the decoding process.
1995 Int
1996 PAF_ASOT_decodeInit(
1997     const PAF_ASOT_Params *pP, 
1998     const PAF_ASOT_Patchs *pQ, 
1999     PAF_ASOT_Config *pAsotCfg
2002     //PAF_AST_Config *pAstCfg;
2003     PAF_AST_DecOpCircBufCtl *pCbCtl;    /* Decoder output circular buffer control */
2004     //Int as;                             /* Audio Stream Number (1, 2, etc.) */
2005     Int z;                              /* decode/encode counter */
2006     Int errno;                          /* error number */
2007     //Int zO, zS;
2009     //pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
2010     //as = pAstCfg->as;
2012     pCbCtl = &pAsotCfg->pAspmCfg->decOpCircBufCtl; // get pointer to circular buffer control
2014     for (z=DECODE1; z < DECODEN; z++)
2015     {
2016         // Start decoder output circular buffer reads
2017         errno = cbReadStart(pCbCtl, z);
2018         if (errno)
2019         {
2020             TRACE_TERSE1("PAF_ASOT_decodeInit:cbReadStart() error=%d", errno);
2021             SW_BREAKPOINT; // debug
2022             return errno;
2023         }
2024         gCbReadAfErr=0;         // reset read circular buffer error count
2025         gDecOpCbRdAfUnd=0;      // reset decoder output circular buffer underflow count
2026         gMaxDecOpCbRdAfUnd=0;   // reset max decoder output circular buffer underflow count
2027         gMasterCbResetCnt=0;    // reset master circular buffer reset count
2029         // FL: debug, log circular buffer control variables
2030         cbLog(pCbCtl, z, 1, "PAF_ASOT_decodeInit:cbReadStart");
2031     }
2032     
2033 #if 0 // moved to PAF_ASOT_outputReset()
2034     // TODO: move this to start of this function so that it doesn't affect IO timing
2035     for (z=ENCODE1; z < ENCODEN; z++) 
2036     {
2037         zO = pP->outputsFromEncodes[z];
2038         zS = pP->streamsFromEncodes[z];
2039         if (pAstCfg->xOut[zO].hTxSio && pAstCfg->xEnc[z].encodeStatus.mode) 
2040         {
2041             Int select = pAstCfg->xEnc[z].encodeStatus.select;
2042             ALG_Handle encAlg = pAstCfg->xEnc[z].encAlg[select];
2043             ENC_Handle enc = (ENC_Handle )encAlg;
2044             TRACE_VERBOSE1("AS%d: PAF_ASOT_decodeInit: initializing encode", as+zS);
2045             if (encAlg->fxns->algActivate)
2046             {
2047                 encAlg->fxns->algActivate (encAlg);
2048             }
2049             if (enc->fxns->reset)
2050             {
2051                 errno = enc->fxns->reset(enc, NULL, 
2052                     &pAstCfg->xEnc[z].encodeControl, &pAstCfg->xEnc[z].encodeStatus);
2053                 if (errno)
2054                 {
2055                     return errno;
2056                 }
2057             }
2058         }
2059     }
2060 #endif
2061     
2062     return 0;
2065 // -----------------------------------------------------------------------------
2066 // ASOT Decoding Function - Info Processing, Initial
2067 //
2068 //   Name:      PAF_ASOT_decodeInfo1
2069 //   Purpose:   Decoding Function for processing information in a manner that
2070 //              is unique to initial frames of input data.
2071 //   From:      AST Parameter Function -> decodeProcessing
2072 //   Uses:      See code.
2073 //   States:    x
2074 //   Return:    Error number in standard or SIO form (0 on success).
2075 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
2076 //              * State information as per parent.
2077 //
2078 Int
2079 PAF_ASOT_decodeInfo1(
2080     const PAF_ASOT_Params *pP, 
2081     const PAF_ASOT_Patchs *pQ, 
2082     PAF_ASOT_Config *pAsotCfg, 
2083     Int frame, 
2084     Int block
2087     //PAF_AST_Config *pAstCfg;
2088     //Int z;                              /* decode/encode counter */
2089     Int errno;                          /* error number */
2091 #if 0 // moved to PAF_ASOT_outputInfo1()
2092     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
2094     // run the chain of ASP's on the stream.
2095     TRACE_VERBOSE0("PAF_ASOT_decodeInfo1: calling streamChainFunction.");
2096     errno = pP->fxns->streamChainFunction(pP, pQ, pAsotCfg, 
2097         PAF_ASP_CHAINFRAMEFXNS_RESET, 1, frame);
2098     if (errno)
2099     {
2100         TRACE_TERSE1("PAF_ASOT_decodeInfo1: streamChainFunction returns errno 0x%x ", errno);
2101         return errno;
2102     }
2104     TRACE_VERBOSE0("PAF_ASOT_decodeInfo1: calling enc->info.");
2105     for (z=ENCODE1; z < ENCODEN; z++) 
2106     {
2107         Int zO = pP->outputsFromEncodes[z];
2108         if (pAstCfg->xOut[zO].hTxSio && pAstCfg->xEnc[z].encodeStatus.mode) 
2109         {
2110             Int select = pAstCfg->xEnc[z].encodeStatus.select;
2111             ALG_Handle encAlg = pAstCfg->xEnc[z].encAlg[select];
2112             ENC_Handle enc = (ENC_Handle )encAlg;
2113             
2114             if (enc->fxns->info)
2115             {
2116                 errno = enc->fxns->info(enc, NULL,
2117                     &pAstCfg->xEnc[z].encodeControl, 
2118                     &pAstCfg->xEnc[z].encodeStatus);
2119                 if (errno)
2120                 {
2121                     TRACE_TERSE1("PAF_ASOT_decodeInfo1: info returns errno 0x%x ", errno);
2122                     return errno;
2123                 }
2124             }
2125         }
2126     }
2127 #endif    
2129     errno = pP->fxns->setCheckRateX(pP, pQ, pAsotCfg, 0);
2130     if (errno)
2131     {
2132         // ignore if rateX has changed since we haven't, but are about to,
2133         // start the output. If we didn't ignore this case then the state machine
2134         // would restart unnecessarily, e.g. in the case of SRC, resulting in
2135         // added latency.
2136         if (errno != ASPERR_INFO_RATECHANGE)
2137         {
2138             TRACE_TERSE1("PAF_ASOT_decodeInfo1: setCheckRateX returns errno 0x%x, not RATECHANGE", errno);
2139             return errno;
2140         }
2141         else
2142         {
2143             TRACE_TERSE0("PAF_ASOT_decodeInfo1: RATECHANGE returns RATECHANGE, ignoring");
2144         }
2145     }
2147     errno = pP->fxns->startOutput(pP, pQ, pAsotCfg);
2148     if (errno) 
2149     {
2150         if (errno == 0x105) 
2151         {
2152             TRACE_TERSE1("PAF_ASOT_decodeInfo1: startOutput returns RING BUFFER FULL (0x%x)", errno);
2153         }
2154         else
2155         {
2156             TRACE_TERSE1("PAF_ASOT_decodeInfo1: startOutput returns errno 0x%x", errno);
2157         }
2158         return errno;
2159     }
2160     
2161     return 0;
2164 // -----------------------------------------------------------------------------
2165 // ASOT Decoding Function - Info Processing, Subsequent
2166 //
2167 //   Name:      PAF_ASOT_decodeInfo2
2168 //   Purpose:   Decoding Function for processing information in a manner that
2169 //              is unique to frames of input data other than the initial one.
2170 //   From:      AST Parameter Function -> decodeProcessing
2171 //   Uses:      See code.
2172 //   States:    x
2173 //   Return:    Error number in standard form (0 on success).
2174 //   Trace:     None.
2175 //
2176 Int
2177 PAF_ASOT_decodeInfo2(
2178     const PAF_ASOT_Params *pP, 
2179     const PAF_ASOT_Patchs *pQ, 
2180     PAF_ASOT_Config *pAsotCfg, 
2181     Int frame, 
2182     Int block
2185     //PAF_AST_Config *pAstCfg;
2186     Int errno;
2188     
2189     //pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
2191     errno = pP->fxns->setCheckRateX (pP, pQ, pAsotCfg, 1);
2192     TRACE_VERBOSE1("PAF_ASOT_decodeInfo2: return 0x%x", errno);
2193     return errno;
2194 } //PAF_ASOT_decodeInfo2
2197 PAF_AST_DecOpCircBufStats gCbStats; // FL: debug
2198 // -----------------------------------------------------------------------------
2199 // ASOT Decoding Function - Stream Processing
2200 //
2201 //   Name:      PAF_ASOT_decodeStream
2202 //   Purpose:   Decoding Function for processing of audio frame data by the
2203 //              ASP Algorithms.
2204 //   From:      AST Parameter Function -> decodeProcessing
2205 //   Uses:      See code.
2206 //   States:    x
2207 //   Return:    Error number in standard form (0 on success).
2208 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
2209 //              * State information as per parent/child.
2210 //
2211 Int
2212 PAF_ASOT_decodeStream(
2213     const PAF_ASOT_Params *pP, 
2214     const PAF_ASOT_Patchs *pQ, 
2215     PAF_ASOT_Config *pAsotCfg, 
2216     Int frame, 
2217     Int block
2220     PAF_AST_Config *pAstCfg;
2221     PAF_AST_DecOpCircBufCtl *pCbCtl;    /* Decoder output circular buffer control */
2222     Int z;                              /* decode/stream counter */
2223     PAF_AudioFrame *pAfRd;
2224     Int cbErrno;
2225     PAF_AST_DecOpCircBufStats cbStats;  /* circular buffer statistics */
2226     Int errno;
2229     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
2230     
2231     pCbCtl = &pAsotCfg->pAspmCfg->decOpCircBufCtl; // get pointer to circular buffer control
2232     
2233     for (z=DECODE1; z < DECODEN; z++) 
2234     {
2235         Int zS = pP->streamsFromDecodes[z];
2236         
2237         //
2238         // Read decoder output circular buffer
2239         //
2240         pAfRd = pAstCfg->xStr[zS].pAudioFrame;
2241         //GPIOSetOutput(GPIO_PORT_0, GPIO_PIN_106);
2242         cbErrno = cbReadAf(pCbCtl, z, pAfRd);
2243         if ((cbErrno < 0) && (cbErrno != ASP_DECOP_CB_READ_UNDERFLOW))
2244         {
2245             gCbReadAfErr++;
2246             TRACE_TERSE1("PAF_ASOT_decodeStream:cbReadAf() error=%d", cbErrno);
2247             //SW_BREAKPOINT; // FL: debug
2248             return cbErrno;
2249         }
2251         // Handle underflows
2252         if (cbErrno == ASP_DECOP_CB_READ_UNDERFLOW)
2253         {
2254             // FL: some number of underflows alway occur on start of stream when ASOT only depends on configured Output.
2255             //     DDP: ~2 underflows
2256             //     MAT-THD: ~16 underflows
2257             // Need to check behavior of cbReset().
2258             // Need to check behavior on exit/re-entry into Output processing.
2259             
2260             gDecOpCbRdAfUnd++; // increment circular buffer underflow count
2261             if (gDecOpCbRdAfUnd >= DEC_OP_CB_RDAF_UND_THR) 
2262             {
2263                 // Underflow count above threshold.
2264                 // (1) set max underflow count to threshold
2265                 // (2) reset underflow count
2266                 // (3) reset circular buffer
2267                 
2268                 gMaxDecOpCbRdAfUnd = DEC_OP_CB_RDAF_UND_THR; // update max underflow count
2269                 gDecOpCbRdAfUnd = 0; // reset underflow count
2271                 // Reset circular buffer
2272                 cbReset(pCbCtl, z);
2273                 gMasterCbResetCnt++; // increment master circular buffer reset count
2274                 Log_info0("ASOT:cbReset");
2275             
2276                 return cbErrno;
2277             }
2278         }
2279         else if ((cbErrno == ASP_DECOP_CB_SOK) && (gDecOpCbRdAfUnd > 0))
2280         {
2281             // No underflow detected.
2282             // update max underflow count,
2283             // reset underflow count
2284             
2285             // update max underflow count
2286             if (gDecOpCbRdAfUnd > gMaxDecOpCbRdAfUnd)
2287             {
2288                 gMaxDecOpCbRdAfUnd = gDecOpCbRdAfUnd;
2289             }
2290             gDecOpCbRdAfUnd = 0; // reset circular buffer underflow count
2291         }
2292         //Log_info0("PAF_ASOT_decodeStream:cbReadAf() complete.");
2293         //GPIOClearOutput(GPIO_PORT_0, GPIO_PIN_106);
2294         Log_info0("PAF_ASOT_decodeStream:cbReadAf() complete.");
2295         
2296 #if 0 // (***) FL: shows timing of CB read
2297             // (***) debug // B8
2298             {
2299                 static Uint8 toggleState = 0;
2300                 if (toggleState == 0)
2301                     GPIOSetOutput(GPIO_PORT_0, GPIO_PIN_106);
2302                 else
2303                     GPIOClearOutput(GPIO_PORT_0, GPIO_PIN_106);
2304                 toggleState = ~(toggleState);
2305             }
2306 #endif
2308         // FL: debug
2309         // Get circular buffer statistics (debug)
2310         //cbGetStats(pCbCtl, z, &cbStats);
2311         cbGetStats(pCbCtl, z, &gCbStats);
2313         // FL: debug
2314         cbLog(pCbCtl, z, 1, "PAF_ASOT_decodeStream:cbReadAf");
2315         //if (capAfWrite(pAfRd, 0) != CAP_AF_SOK)
2316         //{
2317         //    Log_info0("capAfWrite() error");
2318         //}
2319     }
2320             
2321     TRACE_VERBOSE0("PAF_ASOT_outputStream: calling streamChainFunction.");
2322     errno = pP->fxns->streamChainFunction(pP, pQ, pAsotCfg, 
2323         PAF_ASP_CHAINFRAMEFXNS_APPLY, 1, block);
2324     if (errno)
2325     {
2326         TRACE_TERSE1("PAF_ASOT_outputStream: streamChainFunction returns errno 0x%x ", errno);
2327         return errno;
2328     }
2330     return 0;
2332 } //PAF_ASOT_decodeStream
2334 // -----------------------------------------------------------------------------
2335 // ASOT Decoding Function - Encode Processing
2336 //
2337 //   Name:      PAF_ASOT_decodeEncode
2338 //   Purpose:   Decoding Function for processing of audio frame data by the
2339 //              Encode Algorithm.
2340 //   From:      AST Parameter Function -> decodeProcessing
2341 //   Uses:      See code.
2342 //   States:    x
2343 //   Return:    Error number in standard or SIO form (0 on success).
2344 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
2345 //              * State information as per parent.
2346 //
2347 Int
2348 PAF_ASOT_decodeEncode(
2349     const PAF_ASOT_Params *pP, 
2350     const PAF_ASOT_Patchs *pQ, 
2351     PAF_ASOT_Config *pAsotCfg, 
2352     Int frame, 
2353     Int block
2356     PAF_AST_Config *pAstCfg;
2357     Int as;                     /* Audio Stream Number (1, 2, etc.) */
2358     Int z;                      /* encode/output counter */
2359     Int errno;                  /* error number */
2360     Int zX, zE, zS;
2361     UInt32 curTime;
2363     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
2364     as = pAstCfg->as;
2366     // Await output buffers (but not first time)
2367     for (z=OUTPUT1; z < OUTPUTN; z++) 
2368     {
2369         // determine encoder associated with this output
2370         zE = z;
2371         for (zX = ENCODE1; zX < ENCODEN; zX++) 
2372         {
2373             if (pP->outputsFromEncodes[zX] == z) 
2374             {
2375                 zE = zX;
2376                 break;
2377             }
2378         }
2379         zS = pP->streamsFromEncodes[zE];
2381         if (pAstCfg->xOut[z].hTxSio) 
2382         {
2383             // update length (e.g. ARC may have changed)
2384             pAstCfg->xOut[z].outBufConfig.lengthofFrame = 
2385                 pAstCfg->xEnc[zE].encodeInStruct.pAudioFrame->sampleCount;
2386             TRACE_GEN2("PAF_ASOT_decodeEncode: AS%d: processing block %d -- idle", as+zS, block);
2387             errno = SIO_reclaim(pAstCfg->xOut[z].hTxSio,(Ptr *) &pAstCfg->xOut[z].pOutBuf, NULL);
2388             if (errno < 0)
2389             {
2390                 SIO_idle(pAstCfg->xOut[z].hTxSio);
2391                 TRACE_TERSE2("PAF_ASOT_decodeEncode: AS%d: SIO_reclaim returns error %d", as+zS, -errno);
2392                 return -errno; // SIO negates error codes
2393             }
2394             // TODO: use pC->xOut[z].pOutBuf in following ->encode call
2396 #if 0 // (***) FL: shows timing of Output Rx SIO reclaim
2397             // (***) debug // B8
2398             {
2399                 static Uint8 toggleState = 0;
2400                 if (toggleState == 0)
2401                     GPIOSetOutput(GPIO_PORT_0, GPIO_PIN_106);
2402                 else
2403                     GPIOClearOutput(GPIO_PORT_0, GPIO_PIN_106);
2404                 toggleState = ~(toggleState);
2405             }
2406 #endif            
2408             gAsopTxSioReclaimCnt++;
2410             //
2411             // Simulate Tx SIO_reclaim() pend
2412             //
2413             //Semaphore_pend(semaphoreTxAudio, BIOS_WAIT_FOREVER);
2414             curTime = Clock_getTicks();
2415             //System_printf("System time in TaskAsipFxn Tx audio = %lu\n", (ULong)curTime);
2416             //Log_info1("outputEncode():Tx SIO reclaim(), system time = %u", curTime);
2417         }
2418         else 
2419         {
2420             TRACE_VERBOSE2("AS%d: PAF_ASOT_decodeEncode: processing block %d -- idle <ignored>", as+zS, block);
2421         }
2422     }
2424     // Encode data
2425     for (z=ENCODE1; z < ENCODEN; z++) 
2426     {
2427         Int zO = pP->outputsFromEncodes[z];
2428         Int zS = pP->streamsFromEncodes[z];
2429         (void)zS; // clear compiler warning in case not used with tracing disabled
2430         if (pAstCfg->xOut[zO].hTxSio && pAstCfg->xEnc[z].encodeStatus.mode) 
2431         {
2432             Int select = pAstCfg->xEnc[z].encodeStatus.select;
2433             ALG_Handle encAlg = pAstCfg->xEnc[z].encAlg[select];
2434             ENC_Handle enc = (ENC_Handle )encAlg;
2435             if (select != pAstCfg->xEnc[z].encodeControl.encActive)
2436             {
2437                 pAstCfg->xEnc[z].encodeControl.encActive = select;
2438                 TRACE_TERSE0("PAF_ASOT_decodeEncode: return error");
2439                 return (-1);
2440             }
2441             TRACE_GEN2("AS%d: PAF_ASOT_decodeEncode: processing block %d -- encode", as+zS, block);
2443             // (MID 1933) temp. workaround for PCE2
2444             pAstCfg->xEnc[z].encodeInStruct.pAudioFrame->data.nChannels = PAF_MAXNUMCHAN;
2446           /*
2447           #if (CURRENT_TRACE_MASK & TRACE_MASK_DATA)
2448             {
2449                 PAF_AudioFrame *pAudioFrame = pC->xEnc[z].encodeInStruct.pAudioFrame;
2450                 int *wp;
2451                 wp = (int*)pAudioFrame->data.sample[0];
2452                 TRACE_DATA((&TR_MOD, "as1-f2: AS%d PAF_ASOT_outputEncode: encoding from ch 0 0x%x. line %d", z, wp, __LINE__));
2453                 TRACE_DATA((&TR_MOD, "as1-f2: [0]: 0x%x, [16]: 0x%x, [99]: 0x%x (ch0)", wp[0], wp[16], wp[99]));
2454                 wp = (int*)pAudioFrame->data.sample[1];
2455                 TRACE_DATA((&TR_MOD, "as1-f2: PAF_ASOT_outputEncode: encoding from ch 1 0x%x. line %d", wp, __LINE__));
2456                 TRACE_DATA((&TR_MOD, "as1-f2: [0]: 0x%x, [16]: 0x%x, [99]: 0x%x (ch1)", wp[0], wp[16], wp[99]));
2457                 wp = (int*)pAudioFrame->data.sample[2];
2458                 TRACE_DATA((&TR_MOD, "as1-f2: PAF_ASOT_outputEncode: encoding from ch 2 0x%x. line %d", wp, __LINE__));
2459                 TRACE_DATA((&TR_MOD, "as1-f2: [0]: 0x%x, [16]: 0x%x, [99]: 0x%x (ch2)", wp[0], wp[16], wp[99]));
2460             }
2461           #endif
2462           */
2464             if (enc->fxns->encode)
2465             {
2466                 pAstCfg->xEnc[z].encodeOutStruct.bypassFlag =
2467                         pP->z_pEncodeStatus[z]->encBypass;
2468                 errno = enc->fxns->encode(enc, NULL, 
2469                     &pAstCfg->xEnc[z].encodeInStruct, 
2470                     &pAstCfg->xEnc[z].encodeOutStruct);
2471                 if (errno)
2472                 {
2473                     if (errno != PCEERR_OUTPUT_POINTERNULL)
2474                     {
2475                         TRACE_TERSE1("PAF_ASOT_decodeEncode: return error %d line %d", errno);
2476                         return errno;
2477                     }
2478                 }
2479             /*  #if (CURRENT_TRACE_MASK & TRACE_MASK_DATA)
2480                 else
2481                 {
2482                     int *wp = (int*)pC->xOut[z].pOutBuf->pntr.pVoid;
2483                     TRACE_DATA((&TR_MOD, "as1-f2: PAF_ASOT_outputEncode: encoded to 0x%x. line %d", wp, __LINE__));
2484                     TRACE_DATA((&TR_MOD, "as1-f2: [0]: 0x%x, [16]: 0x%x, [99]: 0x%x", wp[0], wp[16], wp[99]));
2485                 }
2486               #endif
2487               */
2488             }
2489         }
2490         else 
2491         {
2492             TRACE_VERBOSE2("PAF_ASOT_decodeEncode: AS%d: processing block %d -- encode <ignored>",
2493                 as+pP->streamsFromEncodes[z], block);
2494         }
2495     }
2497     // Transmit data
2498     for (z=OUTPUT1; z < OUTPUTN; z++) 
2499     {
2500         // determine encoder associated with this output
2501         zE = z;
2502         for (zX = ENCODE1; zX < ENCODEN; zX++) 
2503         {
2504             if (pP->outputsFromEncodes[zX] == z) 
2505             {
2506                 zE = zX;
2507                 break;
2508             }
2509         }
2510         zS = pP->streamsFromEncodes[zE];
2512         if (pAstCfg->xOut[z].hTxSio) 
2513         {
2514             TRACE_GEN2("PAF_ASOT_decodeEncode: AS%d: processing block %d -- output", as+zS, block);
2515             errno = SIO_issue(pAstCfg->xOut[z].hTxSio, 
2516                 &pAstCfg->xOut[z].outBufConfig, sizeof (pAstCfg->xOut[z].outBufConfig), 0);
2517             if (errno)
2518             {
2519                 SIO_idle(pAstCfg->xOut[z].hTxSio);
2520                 if (errno == 0x105)     // 0x105 == RINGIO_EBUFFULL
2521                 {
2522 //                    statStruct_LogFullRing(STATSTRUCT_AS1_F2);
2523                     TRACE_TERSE1("PAF_ASOT_decodeEncode: SIO_idle returned RINGIO_EBUFFULL (0x%x)", errno);
2524                 }
2525                 if (errno > 0)
2526                 {
2527                     TRACE_TERSE1("PAF_ASOT_decodeEncode: return error 0x%x line %d", errno);
2528                     return (ASPERR_ISSUE + (z << 4));
2529                 }
2530                 else if (errno < 0)
2531                 {
2532                     TRACE_TERSE1("PAF_ASOT_decodeEncode: return neg error 0x%x line %d", -errno);
2533                     return -errno; // SIO negates error codes
2534                 }
2535             }
2536             if (errno > 0)
2537             {
2538                 return (ASPERR_ISSUE + (z << 4));
2539             }
2540             else if (errno < 0)
2541             {
2542                 return -errno; // SIO negates error codes
2543             }
2544         }
2545         else 
2546         {
2547             TRACE_GEN2("PAF_ASOT_decodeEncode: AS%d: processing block %d -- output <ignored>", as+zS, block);
2548         }
2549     }
2551     return 0;
2552 } //PAF_ASOT_decodeEncode
2554 // -----------------------------------------------------------------------------
2555 // ASOT Decoding Function - Stream-Final Processing
2556 //
2557 //   Name:      PAF_ASOT_decodeComplete
2558 //   Purpose:   Decoding Function for terminating the decoding process.
2559 //   From:      AST Parameter Function -> decodeProcessing
2560 //   Uses:      See code.
2561 //   States:    x
2562 //   Return:    0.
2563 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
2564 //              * State information as per parent.
2565 //
2566 Int
2567 PAF_ASOT_decodeComplete(
2568     const PAF_ASOT_Params *pP, 
2569     const PAF_ASOT_Patchs *pQ, 
2570     PAF_ASOT_Config *pAsotCfg, 
2571     ALG_Handle decAlg[], 
2572     Int frame, 
2573     Int block
2576     PAF_AST_Config *pAstCfg;
2577     PAF_AST_DecOpCircBufCtl *pCbCtl;    /* Decoder output circular buffer control */
2578     Int as;                             /* Audio Stream Number (1, 2, etc.) */
2579     Int z;                              /* decode/encode counter */
2580     Int errno;                          /* error number */
2582     
2583     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
2584     as = pAstCfg->as;
2585     (void)as;  // clear compiler warning in case not used with tracing disabled
2587     pCbCtl = &pAsotCfg->pAspmCfg->decOpCircBufCtl; // get pointer to circular buffer control
2588     
2589     for (z=DECODE1; z < DECODEN; z++)
2590     {
2591         // Stop decoder output circular buffer reads
2592         errno = cbReadStop(pCbCtl, z);
2593         if (errno)
2594         {
2595             TRACE_TERSE1("PAF_ASOT_decodeComplete:cbReadStop() error=%d", errno);
2596             SW_BREAKPOINT; // FL: debug
2597             return errno;
2598         }
2599         // FL: debug
2600         cbLog(pCbCtl, z, 1, "PAF_ASOT_decodeComplete:cbReadStop");
2601     }
2602     
2603     pP->fxns->streamChainFunction(pP, pQ, pAsotCfg, PAF_ASP_CHAINFRAMEFXNS_FINAL, 0, frame);
2605     for (z=ENCODE1; z < ENCODEN; z++) 
2606     {
2607         Int zO = pP->outputsFromEncodes[z];
2608         if (pAstCfg->xOut[zO].hTxSio && pAstCfg->xEnc[z].encodeStatus.mode) 
2609         {
2610             Int select = pAstCfg->xEnc[z].encodeStatus.select;
2611             ALG_Handle encAlg = pAstCfg->xEnc[z].encAlg[select];
2612 #ifdef PAF_ASP_FINAL
2613             ENC_Handle enc = (ENC_Handle)encAlg;
2614 #endif /* PAF_ASP_FINAL */
2615             TRACE_VERBOSE1("PAF_ASOT_decodeComplete: AS%d: finalizing encode", as+z);
2616 #ifdef PAF_ASP_FINAL
2617             if (enc->fxns->final)
2618                 enc->fxns->final(enc, NULL, &pAstCfg->xEnc[z].encodeControl,
2619                                  &pAstCfg->xEnc[z].encodeStatus);
2620 #endif /* PAF_ASP_FINAL */
2621             if (encAlg->fxns->algDeactivate)
2622             {
2623                 encAlg->fxns->algDeactivate(encAlg);
2624             }
2625         }
2626         else 
2627         {
2628             TRACE_VERBOSE1("PAF_ASOT_decodeComplete: AS%d: finalizing encode <ignored>", as+z);
2629         }
2630     }
2632     // wait for remaining data to be output
2633     pP->fxns->stopOutput(pP, pQ, pAsotCfg);
2635     return 0;
2636 } //PAF_ASOT_decodeComplete
2638 // -----------------------------------------------------------------------------
2639 // ASOT Decoding Function Helper - SIO Driver Start
2640 //
2641 //   Name:      PAF_ASOT_startOutput
2642 //   Purpose:   Decoding Function for initiating output.
2643 //   From:      AST Parameter Function -> decodeInfo1
2644 //   Uses:      See code.
2645 //   States:    x
2646 //   Return:    Error number in standard or SIO form (0 on success).
2647 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
2648 //              * State information as per parent.
2649 //              * SIO control errors.
2650 //
2651 #define DEC_OUTNUMBUF_MAP(X) \
2652       pP->poutNumBufMap[z]->map[(X) >= pP->poutNumBufMap[z]->length ? 0 : (X)]
2654 Int
2655 PAF_ASOT_startOutput(
2656     const PAF_ASOT_Params *pP, 
2657     const PAF_ASOT_Patchs *pQ, 
2658     PAF_ASOT_Config *pAsotCfg
2659
2661     PAF_AST_Config *pAstCfg;
2662     Int as;                     /* Audio Stream Number (1, 2, etc.) */
2663     Int z;                      /* output counter */
2664     Int errno,nbufs;            /* error number */
2665     Int zE, zS, zX;
2666     Int zMD;
2667     PAF_SIO_IALG_Obj    *pObj;
2668     PAF_SIO_IALG_Config *pAlgConfig;
2670     
2671     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
2672     as = pAstCfg->as;
2673     zMD = pAstCfg->masterDec;
2675     for (z=OUTPUT1; z < OUTPUTN; z++) 
2676     {
2677         if (pAstCfg->xOut[z].hTxSio) 
2678         {
2679             // determine associated encoder and stream
2680             zE = z;
2681             zS = z;
2682             for (zX = ENCODE1; zX < ENCODEN; zX++) 
2683             {
2684                 if (pP->outputsFromEncodes[zX] == z) 
2685                 {
2686                     zE = zX;
2687                     zS = pP->streamsFromEncodes[zE];
2688                     break;
2689                 }
2690             }
2692             // Set sample count so that DOB knows how much data to send
2693             pAstCfg->xOut[z].outBufConfig.lengthofFrame =
2694                 pAstCfg->xEnc[zE].encodeInStruct.pAudioFrame->sampleCount;
2696             if (pAstCfg->xOut[z].outBufStatus.markerMode == PAF_OB_MARKER_ENABLED) 
2697             {
2698                 pObj = (PAF_SIO_IALG_Obj *) pAstCfg->xOut[z].outChainData.head->alg;
2699                 pAlgConfig = &pObj->config;
2700                 memset(pAstCfg->xOut[z].outBufConfig.base.pVoid, 0xAA, 
2701                     pAlgConfig->pMemRec[0].size);
2702             }
2704             // The index to DEC_OUTNUMBUF_MAP will always come from the primary/master
2705             // decoder. How should we handle the sourceProgram for multiple decoders?
2706             // Override as needed
2707             nbufs = DEC_OUTNUMBUF_MAP(pAstCfg->xDec[zMD].decodeStatus.sourceProgram);
2708             if (pAstCfg->xOut[z].outBufStatus.numBufOverride[pAstCfg->xDec[zMD].decodeStatus.sourceProgram] > 0)
2709             {
2710                 nbufs = pAstCfg->xOut[z].outBufStatus.numBufOverride[pAstCfg->xDec[zMD].decodeStatus.sourceProgram];
2711             }
2712             SIO_ctrl(pAstCfg->xOut[z].hTxSio, PAF_SIO_CONTROL_SET_NUMBUF, nbufs);
2714             if (errno = SIO_issue(pAstCfg->xOut[z].hTxSio,
2715                 &pAstCfg->xOut[z].outBufConfig, sizeof(pAstCfg->xOut[z].outBufConfig), 0)) 
2716             {
2717                 SIO_idle(pAstCfg->xOut[z].hTxSio);
2718                 TRACE_TERSE2("PAF_ASOT_startOutput: AS%d: SIO_issue failed (0x%x)", as+zS, errno);
2719                 return errno;
2720             }
2722             if (!(pAstCfg->xOut[z].outBufStatus.audio & 0xf0) && 
2723                 (errno =  SIO_ctrl (pAstCfg->xOut[z].hTxSio, PAF_SIO_CONTROL_UNMUTE, 0))) 
2724             {
2725                 errno = (errno & 0xff) | ASPERR_MUTE;
2726                 /* convert to sensical errno */
2727                 TRACE_TERSE2("as1-f2: PAF_ASOT_startOutput: AS%d: SIO control failed (unmute) 0x%x", as+zS, errno);
2728                 return (errno);
2729             }
2730             else
2731             {
2732                 pAstCfg->xOut[z].outBufStatus.audio
2733                     = (pAstCfg->xOut[z].outBufStatus.audio & 0xf0) | PAF_OB_AUDIO_SOUND;                
2734             }
2736             TRACE_VERBOSE1("PAF_ASOT_startOutput: AS%d: output started", as+zS);
2737         }
2738     }
2740     return 0;
2741 } //PAF_ASOT_startOutput
2743 // -----------------------------------------------------------------------------
2744 // ASOT Decoding Function Helper - SIO Driver Stop
2745 //
2746 //   Name:      PAF_ASOT_stopOutput
2747 //   Purpose:   Decoding Function for terminating output.
2748 //   From:      AST Parameter Function -> decodeProcessing
2749 //              AST Parameter Function -> decodeComplete
2750 //   Uses:      See code.
2751 //   States:    x
2752 //   Return:    Error number in standard or SIO form (0 on success).
2753 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
2754 //              * SIO control errors.
2755 //
2756 Int
2757 PAF_ASOT_stopOutput(
2758     const PAF_ASOT_Params *pP, 
2759     const PAF_ASOT_Patchs *pQ, 
2760     PAF_ASOT_Config *pAsotCfg
2763     PAF_AST_Config *pAstCfg;
2764     Int as;                     /* Audio Stream Number (1, 2, etc.) */
2765     Int z;                      /* output counter */
2766     Int errno = 0, getVal;
2767     Int zS, zX;
2768     PAF_SIO_IALG_Obj    *pObj;
2769     PAF_SIO_IALG_Config *pAlgConfig;
2771     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
2772     as = pAstCfg->as;
2773     (void)as;  // clear compiler warning in case not used with tracing disabled
2775     for (z=OUTPUT1; z < OUTPUTN; z++) 
2776     {
2777         if (pAstCfg->xOut[z].hTxSio) 
2778         {
2779             // determine associated encoder and stream
2780             zS = z;
2781             (void)zS;
2782             for (zX = ENCODE1; zX < ENCODEN; zX++) 
2783             {
2784                 if (pP->outputsFromEncodes[zX] == z) 
2785                 {
2786                     zS = pP->streamsFromEncodes[zX];
2787                     break;
2788                 }
2789             }
2791             // Mute output before audio data termination in the usual case,
2792             // where such termination is due to decode error or user command.
2793             // Identification of this as the usual case is provided by the
2794             // "decode processing" state machine.
2795             if (!(pAstCfg->xOut[z].outBufStatus.audio & 0xf0) &&
2796                 ((pAstCfg->xOut[z].outBufStatus.audio & 0x0f) == PAF_OB_AUDIO_SOUND) &&
2797                 (getVal = SIO_ctrl(pAstCfg->xOut[z].hTxSio, PAF_SIO_CONTROL_MUTE, 0))) 
2798             {
2799                 if (!errno) 
2800                 {
2801                     errno = (getVal & 0xff) | ASPERR_MUTE;
2802                     /* convert to sensical errno */
2803                 }
2804                 TRACE_VERBOSE1("PAF_ASOT_stopOutput:  AS%d: SIO control failed (mute)", as+zS);
2805             }
2807             TRACE_TIME((&TIME_MOD, "... + %d = %d (stopOutput -- begin PAF_SIO_CONTROL_IDLE)", dtime(), TSK_time()));
2809             // Terminate audio data output, truncating (ignore) or flushing
2810             // (play out) final samples as per (1) control register set by
2811             // the user and (2) the type of audio data termination:
2813 #if 0
2814             // This form is not used because driver support for truncating
2815             // data is not supported for internal clocks, although it is
2816             // for external clocks.
2817             getVal = SIO_ctrl(pC->xOut[z].hTxSio, PAF_SIO_CONTROL_IDLE,
2818                 pC->xOut[z].outBufStatus.flush
2819                 & (pC->xOut[z].outBufStatus.audio & 0x0f) == PAF_OB_AUDIO_FLUSH
2820                 ? 1 : 0);
2821             /* UNTESTED */
2822 #else
2823             // This form should be used when driver support for truncating
2824             // data is supported for both internal and external clocks.
2825             getVal = SIO_ctrl(pAstCfg->xOut[z].hTxSio, PAF_SIO_CONTROL_IDLE,
2826                 pAstCfg->xOut[z].outBufStatus.flush ? 1 :
2827                 (pAstCfg->xOut[z].outBufStatus.audio & 0x0f) == PAF_OB_AUDIO_FLUSH
2828                 ? 1 : 0);
2829             /* TESTED */
2830 #endif
2832             TRACE_TIME((&TIME_MOD, "... + %d = %d (stopOutput -- after PAF_SIO_CONTROL_IDLE)", dtime(), TSK_time()));
2834             if (!errno)
2835             {
2836                 errno = getVal;
2837             }
2839             // Mute output after audio data termination in a special case,
2840             // where such termination is due to processing of a final frame
2841             // or user command. Identification of this as a special case is
2842             // provided by the "decode processing" state machine.
2843             if (!(pAstCfg->xOut[z].outBufStatus.audio & 0xf0) &&
2844                 ((pAstCfg->xOut[z].outBufStatus.audio & 0x0f) == PAF_OB_AUDIO_FLUSH) &&
2845                 (getVal = SIO_ctrl(pAstCfg->xOut[z].hTxSio, PAF_SIO_CONTROL_MUTE, 0)))
2846             {
2847                 if (!errno) 
2848                 {
2849                     errno = (getVal & 0xff) | ASPERR_MUTE;
2850                     /* convert to sensical errno */
2851                 }
2852                 TRACE_VERBOSE1("as1-f2: PAF_ASOT_stopOutput:  AS%d: SIO control failed (mute)", as+zS);
2853             }
2855             pAstCfg->xOut[z].outBufStatus.audio &= ~0x0f;
2857             // zero output buffers
2858             pObj = (PAF_SIO_IALG_Obj *) pAstCfg->xOut[z].outChainData.head->alg;
2859             pAlgConfig = &pObj->config;
2860             memset (pAstCfg->xOut[z].outBufConfig.base.pVoid, 0, pAlgConfig->pMemRec[0].size);
2861         } //pAstCfg->xOut[z].hTxSio
2862     }//OUTPUT
2864     return errno;
2865 } //PAF_ASOT_stopOutput
2867 // -----------------------------------------------------------------------------
2868 // ASOT Decoding Function Helper - SIO Driver Change
2869 //
2870 //   Name:      PAF_ASOT_setCheckRateX
2871 //   Purpose:   Decoding Function for reinitiating output.
2872 //   From:      AST Parameter Function -> decodeInfo1
2873 //              AST Parameter Function -> decodeInfo2
2874 //   Uses:      See code.
2875 //   States:    x
2876 //   Return:    Error number in standard form (0 on success).
2877 //   Trace:     None.
2878 //
2880 /* 0: set, 1: check, unused for now. --Kurt */
2881 Int
2882 PAF_ASOT_setCheckRateX(
2883     const PAF_ASOT_Params *pP, 
2884     const PAF_ASOT_Patchs *pQ, 
2885     PAF_ASOT_Config *pAsotCfg, 
2886     Int check
2889     PAF_AST_Config *pAstCfg;
2890     float rateX;
2891     PAF_SampleRateHz rateO /* std */, rateI /* inv */;
2892     Int z;                              /* output counter */
2893     Int zx;                             /* output re-counter */
2894     Int getVal;
2895     int inputRate, inputCount, outputRate, outputCount;
2896     Int zMD;
2897     Int zMI;
2898     Int zMS;
2899     Int zE, zX;
2901     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
2902     zMD = pAstCfg->masterDec;
2903     zMS = pAstCfg->masterStr;
2904     zMI = pP->zone.master;
2906     inputRate = pAstCfg->xInp[zMI].inpBufStatus.sampleRateStatus;
2907     inputCount = pAstCfg->xDec[zMD].decodeStatus.frameLength;
2908     rateI = pAstCfg->xStr[zMS].pAudioFrame->fxns->sampleRateHz
2909         (pAstCfg->xStr[zMS].pAudioFrame, inputRate, PAF_SAMPLERATEHZ_INV);
2911     for (z=OUTPUT1; z < OUTPUTN; z++) 
2912     {
2913         if (pAstCfg->xOut[z].hTxSio && (pAstCfg->xOut[z].outBufStatus.clock & 0x01)) 
2914         {
2916             // determine associated encoder
2917             zE = z;
2918             for (zX = ENCODE1; zX < ENCODEN; zX++) 
2919             {
2920                 if (pP->outputsFromEncodes[zX] == z) 
2921                 {
2922                     zE = zX;
2923                     break;
2924                 }
2925             }
2927             outputRate = pAstCfg->xEnc[zE].encodeStatus.sampleRate;
2928             outputCount = pAstCfg->xEnc[zE].encodeStatus.frameLength;
2929             rateO = pAstCfg->xStr[zMS].pAudioFrame->fxns->sampleRateHz
2930                 (pAstCfg->xStr[zMS].pAudioFrame, outputRate, PAF_SAMPLERATEHZ_STD);
2931             if ((rateI > 0) && (rateO > 0))
2932             {
2933                 rateX = rateO /* std */ * rateI /* inv */;
2934             }
2935             else if (inputCount != 0)
2936             {
2937                 rateX = (float )outputCount / inputCount;
2938             }
2939             else
2940             {
2941                 return ( ASPERR_INFO_RATERATIO );
2942             }
2944             getVal = SIO_ctrl (pAstCfg->xOut[z].hTxSio, PAF_SIO_CONTROL_SET_RATEX, (Arg) &rateX);
2945             if (getVal == DOBERR_RATECHANGE) 
2946             {
2947                 for (zx=OUTPUT1; zx < OUTPUTN; zx++)
2948                 {
2949                     if (pAstCfg->xOut[zx].hTxSio)
2950                     {
2951                         SIO_idle (pAstCfg->xOut[zx].hTxSio);
2952                     }
2953                 }
2955                 // this forces an exit from the calling state machine which will
2956                 // eventually call startOutput which calls setCheckRateX for all outputs
2957                 // and so it is ok, in the presence of a rate change on any output, to
2958                 // exit this loop /function early.
2959                 return ASPERR_INFO_RATECHANGE;
2960             }
2961             else if( getVal != SYS_OK )
2962             {
2963                 return ((getVal & 0xff) | ASPERR_RATE_CHECK);
2964             }
2965         }
2966     }
2968     return 0;
2969 } //PAF_ASOT_setCheckRateX
2971 // -----------------------------------------------------------------------------
2972 // ASOT Decoding Function Helper - Chain Processing
2973 //
2974 //   Name:      PAF_ASOT_streamChainFunction
2975 //   Purpose:   Common Function for processing algorithm chains.
2976 //   From:      AST Parameter Function -> decodeInfo1
2977 //              AST Parameter Function -> decodeStream
2978 //              AST Parameter Function -> decodeComplete
2979 //   Uses:      See code.
2980 //   States:    x
2981 //   Return:    Error number in standard form (0 on success).
2982 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
2983 //              * State information as per parent.
2984 //
2985 Int
2986 PAF_ASOT_streamChainFunction(
2987     const PAF_ASOT_Params *pP, 
2988     const PAF_ASOT_Patchs *pQ, 
2989     PAF_ASOT_Config *pAsotCfg, 
2990     Int iChainFrameFxns, 
2991     Int abortOnError, 
2992     Int logArg
2995     PAF_AST_Config *pAstCfg;
2996     Int as;                     /* Audio Stream Number (1, 2, etc.) */
2997     Int z;                      /* stream counter */
2998     Int errno;                  /* error number */
2999     Int dFlag, eFlag, gear;
3000     Int zX;
3001     Int zS;
3003     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
3004     as = pAstCfg->as;
3005     (void)as; // clear compiler warning in case not used with tracing disabled
3007     for (zS = STREAM1; zS < STREAMN; zS++)
3008     {
3009         z = pP->streamOrder[zS];  // Select stream order from streamOrder parameter - MID 788
3011         // apply stream
3012         //      unless the stream is associated with a decoder and it is not running
3013         // or
3014         //      unless the stream is associated with an encoder and it is not running
3015         // Also gear control only works for streams with an associated decoder
3016         // if no such association exists then gear 0 (All) is used
3017         dFlag = 1;
3018         gear = 0;
3019         for (zX = DECODE1; zX < DECODEN; zX++) {
3020             if (pP->streamsFromDecodes[zX] == z) {
3021                 dFlag = pAstCfg->xDec[zX].decodeStatus.mode;
3022                 gear = pAstCfg->xDec[zX].decodeStatus.aspGearStatus;
3023                 break;
3024             }
3025         }
3026         eFlag = 1;
3027         for (zX = ENCODE1; zX < ENCODEN; zX++) {
3028             if (pP->streamsFromEncodes[zX] == z) {
3029                 eFlag = pAstCfg->xEnc[zX].encodeStatus.mode;
3030                 break;
3031             }
3032         }
3034         if (dFlag && eFlag) {
3035             PAF_ASP_Chain *chain = pAstCfg->xStr[z].aspChain[gear];
3036             PAF_AudioFrame *frame = pAstCfg->xStr[z].pAudioFrame;
3037             Int (*func) (PAF_ASP_Chain *, PAF_AudioFrame *) =
3038                 chain->fxns->chainFrameFunction[iChainFrameFxns];
3040             TRACE_GEN2(iChainFrameFxns == PAF_ASP_CHAINFRAMEFXNS_RESET
3041                        ? "PAF_ASOT_streamChainFunction: AS%d: processing frame %d -- audio stream (reset)"
3042                        : iChainFrameFxns == PAF_ASP_CHAINFRAMEFXNS_APPLY
3043                        ? "PAF_ASOT_streamChainFunction: AS%d: processing block %d -- audio stream (apply)"
3044                        : iChainFrameFxns == PAF_ASP_CHAINFRAMEFXNS_FINAL
3045                        ? "PAF_ASOT_streamChainFunction: AS%d: processing frame %d -- audio stream (final)"
3046                        : "PAF_ASOT_streamChainFunction: AS%d: processing frame %d -- audio stream (?????)",
3047                        as+z, logArg);
3048             errno = (*func) (chain, frame);
3049             TRACE_VERBOSE2("PAF_ASOT_streamChainFunction: AS%d: errno 0x%x.",
3050                 as+z, errno);
3052             if (errno && abortOnError)
3053                 return errno;
3054         }
3055         else {
3056             TRACE_GEN2(iChainFrameFxns == PAF_ASP_CHAINFRAMEFXNS_RESET
3057                        ? "PAF_ASOT_streamChainFunction: AS%d: processing frame %d -- audio stream (reset) <ignored>"
3058                        : iChainFrameFxns == PAF_ASP_CHAINFRAMEFXNS_APPLY
3059                        ? "PAF_ASOT_streamChainFunction: AS%d: processing block %d -- audio stream (apply) <ignored>"
3060                        : iChainFrameFxns == PAF_ASP_CHAINFRAMEFXNS_FINAL
3061                        ? "PAF_ASOT_streamChainFunction: AS%d: processing frame %d -- audio stream (final) <ignored>"
3062                        : "PAF_ASOT_streamChainFunction: AS%d: processing frame %d -- audio stream (?????) <ignored>",
3063                        as+z, logArg);
3064         }
3066         /*
3067         {
3068             void dp_tracePAF_Data(float *lBuf, float *rBuf, int count);
3069             PAF_AudioFrameData *afd;
3070             float ** afPtr;
3072             afd = &(pC->xStr->pAudioFrame->data);
3073             afPtr = (float**)afd->sample;
3074             dp_tracePAF_Data(afPtr[4], afPtr[5], 256);
3076         }
3077         */
3079     }
3081     return 0;
3082 } //PAF_ASOT_streamChainFunction
3084 /* Check if at least one output selected */
3085 static Int checkOutSel(
3086     const PAF_ASOT_Params *pP, 
3087     PAF_ASOT_Config *pAsotCfg,
3088     Int *pOutSel
3091     PAF_AST_Config *pAstCfg;
3092     Int outSel;
3093     Int z;
3094     
3095     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
3097     outSel = 0;
3098     for (z=OUTPUT1; z < OUTPUTN; z++) 
3099     {
3100         if (pAstCfg->xOut[z].hTxSio)
3101         {
3102             outSel = 1;
3103             break;
3104         }
3105     }
3106     
3107     *pOutSel = outSel;
3109     return ASOP_SOK;
3112 /* Check if at least one output sio changed */
3113 static Int checkOutSio(
3114     const PAF_ASOT_Params *pP, 
3115     PAF_ASOT_Config *pAsotCfg,
3116     Int *pOutSioUpdate
3119     PAF_AST_Config *pAstCfg;
3120     Int outSioUpdate;
3121     Int z;
3122     
3123     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
3125     outSioUpdate = 0;
3126     for (z=OUTPUT1; z < OUTPUTN; z++) 
3127     {
3128         if (pAstCfg->xOut[z].outBufStatus.sioSelect >= 0)
3129         {
3130             outSioUpdate = 1;
3131             break;
3132         }
3133     }
3134     
3135     *pOutSioUpdate = outSioUpdate;
3137     return ASOP_SOK;
3140 // Reset audio frames
3141 static Void resetAfs(
3142     const PAF_ASOT_Params *pP, 
3143     PAF_AST_Stream *xStr
3146     // Reset audio frame pointers to original values
3147     // (may be needed if error occurred).
3148     resetAfPointers(pP, xStr);
3149     // Reset audio frame meta data elements
3150     resetAfMetadata(pP, xStr);
3153 // Reset audio frame pointers to original values
3154 static Void resetAfPointers(
3155     const PAF_ASOT_Params *pP, 
3156     PAF_AST_Stream *xStr
3159     Int z;
3160     Int ch;
3162     // Reset audio frame pointers to original values
3163     for (z = STREAM1; z < STREAMN; z++) 
3164     {
3165         for (ch = PAF_LEFT; ch < PAF_MAXNUMCHAN_AF; ch++) 
3166         {
3167             if (xStr[z].audioFrameChannelPointers[ch])
3168             {
3169                 xStr[z].audioFrameChannelPointers[ch] = 
3170                     xStr[z].origAudioFrameChannelPointers[ch];
3171             }
3172         }
3173     }
3176 // Reset audio frame meta data elements
3177 static Void resetAfMetadata(
3178     const PAF_ASOT_Params *pP, 
3179     PAF_AST_Stream *xStr
3182     Int z;
3183     Int i;
3185     for (z = STREAM1; z < STREAMN; z++) 
3186     {
3187         xStr[z].pAudioFrame->pafBsMetadataUpdate = XDAS_FALSE;
3188         xStr[z].pAudioFrame->numPrivateMetadata = 0;
3189         xStr[z].pAudioFrame->bsMetadata_offset = 0;
3190         xStr[z].pAudioFrame->bsMetadata_type = PAF_bsMetadata_channelData;
3192         for (i = 0; i < pP->pMetadataBufStatus->NumBuf; i++)
3193         {
3194             xStr[z].pAudioFrame->pafPrivateMetadata[i].offset = 0;
3195             xStr[z].pAudioFrame->pafPrivateMetadata[i].size = 0;
3196         }
3197     }
3200 // Initialize Output Processing state function
3201 static Int PAF_ASOT_initOutProc(
3202     const PAF_ASOT_Params *pP, 
3203     PAF_AST_Stream *xStr
3206     // Reset audio frames
3207     resetAfs(pP, xStr);
3208     
3209     return ASOP_SOK;
3212 #if 0
3213 // Init-Sync update audio frame
3214 static Int initSyncUpdateAf(
3215     PAF_AudioFrame *dstAf, 
3216     PAF_AudioFrame *srcAf
3219     memcpy(dstAf, srcAf, sizeof(PAF_AudioFrame));
3220     
3221     return ASOP_SOK;
3223 #endif
3225 //   Purpose:   Init-Sync Dec Reset state function.
3226 //              Performes Dec Reset Init-Sync.
3227 static Int PAF_ASOT_initSyncDecReset(
3228     const PAF_ASOT_Params *pP, 
3229     const PAF_ASOT_Patchs *pQ, 
3230     PAF_ASOT_Config *pAsotCfg,
3231     PAF_AudioFrame *pDecResetAf
3234     PAF_AST_Config *pAstCfg;            // ASIT/ASOT/ASDT shared configuration
3235     Int zMD, zMS;                       // Dec and Stream Master indices
3236     PAF_AudioFrame *pStrAf;             // stream audio frame
3237     PAF_AST_OutInitSyncCtl *pOutIsCtl;  // Output Init-Sync control
3238     Int8 decFlag;                       // dec stage flag
3239     Int errno;                          // error number
3241     
3242     pAstCfg = pAsotCfg->pAstCfg;
3243     zMD = pAstCfg->masterDec;
3244     pOutIsCtl = &pAsotCfg->pAspmCfg->outIsCtl;
3245     
3246     // check for Dec Reset
3247     // store dec reset AF
3248     errno = outIsReadDecStageFlagAndAf(pOutIsCtl, zMD,
3249         ASP_OUTIS_DEC_STAGE_RESET_IDX, &decFlag, pDecResetAf);
3250     if (errno < 0)
3251     {
3252         return errno;
3253     }
3254     
3255     if (decFlag == 0)
3256     {
3257         return ASOP_INITSYNC_NOTREADY;
3258     }
3259     else
3260     {
3261         zMS = pAstCfg->masterStr;
3262         pStrAf = pAstCfg->xStr[zMS].pAudioFrame;
3263         
3264         // Update Stream Audio Frame.
3265         // Copy Dec Reset AF to Stream AF.
3266         //errno = initSyncUpdateAf(pStrAf, pDecResetAf);
3267         //if (errno < 0)
3268         //{
3269         //    return errno;
3270         //}
3271         outIsCpyAf(pDecResetAf, pStrAf);
3272         
3273         // Enc activate
3274         // Enc reset
3275         errno = PAF_ASOT_outputReset(pP, pQ, pAsotCfg);
3276         if (errno < 0)
3277         {
3278             return errno;
3279         }
3280         
3281         return ASOP_SOK;
3282     }
3285 //   Purpose:   ASOT Function for Output reset
3286 static Int PAF_ASOT_outputReset(
3287     const PAF_ASOT_Params *pP, 
3288     const PAF_ASOT_Patchs *pQ, 
3289     PAF_ASOT_Config *pAsotCfg
3292     PAF_AST_Config *pAstCfg;    // ASIT/ASOT/ASDT shared configuration
3293     Int as;                     // Audio Stream Number (1, 2, etc.) */
3294     Int z;                      // encode counter
3295     Int errno;                  // error number
3296     Int zO, zS;
3299     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
3300     as = pAstCfg->as;
3302     for (z=ENCODE1; z < ENCODEN; z++) 
3303     {
3304         zO = pP->outputsFromEncodes[z];
3305         zS = pP->streamsFromEncodes[z];
3306         if (pAstCfg->xOut[zO].hTxSio && pAstCfg->xEnc[z].encodeStatus.mode) 
3307         {
3308             Int select = pAstCfg->xEnc[z].encodeStatus.select;
3309             ALG_Handle encAlg = pAstCfg->xEnc[z].encAlg[select];
3310             ENC_Handle enc = (ENC_Handle )encAlg;
3312             TRACE_VERBOSE1("AS%d: PAF_ASOT_outputReset: initializing encode", as+zS);
3314             if (encAlg->fxns->algActivate)
3315             {
3316                 encAlg->fxns->algActivate(encAlg);
3317             }
3318             
3319             if (enc->fxns->reset)
3320             {
3321                 errno = enc->fxns->reset(enc, NULL, 
3322                     &pAstCfg->xEnc[z].encodeControl, 
3323                     &pAstCfg->xEnc[z].encodeStatus);
3324                 if (errno)
3325                 {
3326                     return ASOP_ENCRESET_ERR;
3327                 }
3328             }
3329         }
3330     }    
3331     
3332     return ASOP_SOK;
3335 //   Purpose:   Init-Sync Dec Info1 state function.
3336 //              Performes Dec Info1 Init-Sync.
3337 static Int PAF_ASOT_initSyncDecInfo1(
3338     const PAF_ASOT_Params *pP, 
3339     const PAF_ASOT_Patchs *pQ, 
3340     PAF_ASOT_Config *pAsotCfg,