d5538a6465cea7841121891978c76fd0f257396b
[processor-sdk/performance-audio-sr.git] / pasdk / test_dsp / framework / audioStreamOutProc.c
2 /*
3 Copyright (c) 2017, Texas Instruments Incorporated - http://www.ti.com/
4 All rights reserved.
6 * Redistribution and use in source and binary forms, with or without 
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 *
13 * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the
16 * distribution.
17 *
18 * Neither the name of Texas Instruments Incorporated nor the names of
19 * its contributors may be used to endorse or promote products derived
20 * from this software without specific prior written permission.
21 *
22 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
23 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
24 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
25 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
26 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
27 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
28 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
29 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
30 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
31 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
32 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33 *
34 */
36 /*
37  *  ======== audioStreamOutProc.c ========
38  */
40 #include <string.h> // for memset
41 #include <xdc/runtime/Log.h>
42 #include <xdc/runtime/Error.h>
43 #include <xdc/runtime/Memory.h>
44 #include <ti/sysbios/knl/Clock.h>
45 #include <ti/sysbios/knl/Task.h>
47 #include "paferr.h"
48 #include <acp_mds.h>
49 #include <pcm.h>
50 #include <pce.h>
51 #include <pafsio_ialg.h>
52 #include <stdasp.h>
53 #include <doberr.h>
54 #include "asperr.h"
56 #include "common.h"
57 #include "aspMsg_common.h"
58 #include "aspMsg_master.h"
59 #include "aspDecOpCircBuf_master.h"
60 #include "aspOutInitSync_master.h"
61 #include "audioStreamProc_common.h"
62 #include "audioStreamOutProc.h"
64 #include "pfp/pfp.h"
65 #include "pfp_app.h"        /* contains all PFP ID's */
66 Int32 gNumPfpAsot1=0; // debug
68 // FL: debug
69 #include "evmc66x_gpio_dbg.h"
70 #include "dbgCapAf.h"
72 #include "ioConfig.h"
74 // -----------------------------------------------------------------------------
75 // Debugging Trace Control, local to this file.
76 // 
77 #include "logp.h"
79 #define TRACE_TIME(a)
81 // Allow a developer to selectively enable tracing.
82 #define CURRENT_TRACE_MASK      0x07
84 #define TRACE_MASK_TERSE        0x01   // only flag errors and show init
85 #define TRACE_MASK_GENERAL      0x02   // half dozen lines per frame
86 #define TRACE_MASK_VERBOSE      0x04   // trace full operation
88 #if !(CURRENT_TRACE_MASK & TRACE_MASK_TERSE)
89     #undef  TRACE_TERSE0
90     #undef  TRACE_TERSE1
91     #undef  TRACE_TERSE2
92     #undef  TRACE_TERSE3
93     #undef  TRACE_TERSE4
94     #define TRACE_TERSE0(a)
95     #define TRACE_TERSE1(a,b)
96     #define TRACE_TERSE2(a,b,c)
97     #define TRACE_TERSE3(a,b,c,d)
98     #define TRACE_TERSE4(a,b,c,d,e)
99 #endif
100     
101 #if !(CURRENT_TRACE_MASK & TRACE_MASK_GENERAL)
102     #undef  TRACE_GEN0
103     #undef  TRACE_GEN1
104     #undef  TRACE_GEN2
105     #undef  TRACE_GEN3
106     #undef  TRACE_GEN4
107     #define TRACE_GEN0(a)
108     #define TRACE_GEN1(a,b)
109     #define TRACE_GEN2(a,b,c)
110     #define TRACE_GEN3(a,b,c,d)
111     #define TRACE_GEN4(a,b,c,d,e)
112 #endif
114 #if !(CURRENT_TRACE_MASK & TRACE_MASK_VERBOSE)
115     #undef  TRACE_VERBOSE0
116     #undef  TRACE_VERBOSE1
117     #undef  TRACE_VERBOSE2
118     #undef  TRACE_VERBOSE3
119     #undef  TRACE_VERBOSE4
120     #define TRACE_VERBOSE0(a)
121     #define TRACE_VERBOSE1(a,b)
122     #define TRACE_VERBOSE2(a,b,c)
123     #define TRACE_VERBOSE3(a,b,c,d)
124     #define TRACE_VERBOSE4(a,b,c,d,e)
125 #endif
127 // .............................................................................
129 //
130 // Audio Stream Definitions
131 //
133 //
134 // Audio Stream Processing Definitions
135 //
136 #define aspLinkInit pQ->i_aspLinkInit
138 //
139 // Encoder Definitions
140 //
141 #define encLinkInit pQ->i_encLinkInit
143 //
144 // Output Definitions
145 //
146 #define outLinkInit pP->i_outLinkInit
148 /* ---------------------------------------------------------------- */
149 /*              Parameter macro definitions end here.               */
150 /* ---------------------------------------------------------------- */
152 //
153 // Standardized Definitions
154 //
156 #define ENC_Handle PCE_Handle /* works for all: PCE */
158 #define __TASK_NAME__  "TaskAsop"
161 //
162 // Audio Stream Output Task definitions
163 //
165 // status codes
166 // Output FSM
167 #define ASOP_INITSYNC_NOTREADY      (  1 )  // ok, init-sync not ready
168 #define ASOP_SOK                    (  0 )  // ok
169 #define ASOP_FORWARD_ERR            ( -1 )  // forward (ASIT) error
170 #define ASOP_ENCRESET_ERR           ( -2 )  // enc reset error
171 #define ASOP_DECINFO1_ERR           ( -3 )  // dec info1 error
172 // Decode Processing
173 #define ASOP_DP_OUT_SIO_UPDATE      (  3 )  // new output selected
174 #define ASOP_DP_CB_DRAINED          (  2 )  // circular buffer drained
175 #define ASOP_DP_SOK                 (  0 )  // ok
176 #define ASOP_DP_FORWARD_ERR         ( -1 )  // forward (ASIT) error
177 #define ASOP_DP_DECINIT_ERR         ( -2 )  // decode init error
178 #define ASOP_DP_DECSTREAM_ERR       ( -3 )  // decode stream error
179 #define ASOP_DP_DECENC_ERR          ( -4 )  // decode encode error
180 #define ASOP_DP_DECINFO2_ERR        ( -5 )  // decode encode error
181 #define ASOP_DP_DECFINALTEST_ERR    ( -6 )  // decode final error
185 /* Check if at least one output selected */
186 static Int checkOutSel(
187     const PAF_ASOT_Params *pP, 
188     PAF_ASOT_Config *pAsotCfg,
189     Int *pOutSel
190 );
192 /* Check if at least one output sio changed */
193 static Int checkOutSio(
194     const PAF_ASOT_Params *pP, 
195     PAF_ASOT_Config *pAsotCfg,
196     Int *pOutSioUpdate
197 );
199 // Initialize Output Processing state function
200 static Int PAF_ASOT_initOutProc(
201     const PAF_ASOT_Params *pP, 
202     PAF_AST_Stream *xStr
203 );
205 // Initialize Output Processing state function
206 static Int PAF_ASOT_initSyncDecReset(
207     const PAF_ASOT_Params *pP, 
208     const PAF_ASOT_Patchs *pQ, 
209     PAF_ASOT_Config *pAsotCfg,
210     PAF_AudioFrame *pDecResetAf
211 );
213 //   Purpose:   ASOT Function for Output reset
214 static Int PAF_ASOT_outputReset(
215     const PAF_ASOT_Params *pP, 
216     const PAF_ASOT_Patchs *pQ, 
217     PAF_ASOT_Config *pAsotCfg
218 );
220 //   Purpose:   Init-Sync Dec Info1 state function.
221 //              Performes Dec Info1 Init-Sync.
222 static Int PAF_ASOT_initSyncDecInfo1(
223     const PAF_ASOT_Params *pP, 
224     const PAF_ASOT_Patchs *pQ, 
225     PAF_ASOT_Config *pAsotCfg,
226     PAF_AudioFrame *pDecInfo1Af
227 );
229 //   Purpose:   ASOT function for ASP chain reset and ENC info
230 static Int PAF_ASOT_outputInfo1(
231     const PAF_ASOT_Params *pP, 
232     const PAF_ASOT_Patchs *pQ, 
233     PAF_ASOT_Config *pAsotCfg
234 );
236 //   Purpose:   Init-Sync Dec Decode1 state function.
237 //              Performes Dec Decode1 Init-Sync.
238 static Int PAF_ASOT_initSyncDecDecode1(
239     const PAF_ASOT_Params *pP, 
240     const PAF_ASOT_Patchs *pQ, 
241     PAF_ASOT_Config *pAsotCfg
242 );
244 //   Purpose:   Init-Sync Re-Sync state function.
245 //              Peformed Init-Sync using stored Dec Reset/Info1 AFs.
246 static Int PAF_ASOT_initSyncResync(
247     const PAF_ASOT_Params *pP, 
248     const PAF_ASOT_Patchs *pQ, 
249     PAF_ASOT_Config *pAsotCfg,
250     PAF_AudioFrame *pDecResetAf,
251     PAF_AudioFrame *pDecInfo1Af  
252 );
254 #if 0
255 // Init-Sync update audio frame
256 static Int initSyncUpdateAf(
257     PAF_AudioFrame *dstAf, 
258     PAF_AudioFrame *srcAf
259 );
260 #endif
262 // Reset audio frames
263 static Void resetAfs(
264     const PAF_ASOT_Params *pP, 
265     PAF_AST_Stream *xStr
266 );
268 // Reset audio frame pointers to original values
269 static Void resetAfPointers(
270     const PAF_ASOT_Params *pP, 
271     PAF_AST_Stream *xStr
272 );
274 // Reset audio frame meta data elements
275 static Void resetAfMetadata(
276     const PAF_ASOT_Params *pP, 
277     PAF_AST_Stream *xStr
278 );
281 LINNO_DEFN(TaskAsop); /* Line number macros */
282 ERRNO_DEFN(TaskAsop); /* Error number macros */
284 // ASOT configuration
285 #pragma DATA_SECTION(gPAF_ASOT_config, ".globalSectionPafAsotConfig")
286 PAF_ASOT_Config gPAF_ASOT_config = {
287     NULL,               // taskHandle
288     NULL,               // acp
289     0,0,0,              // CB drained flags (size DECODE_MAXN)
290     &gPAF_ASPM_config,  // pAspmCfg
291     &gPAF_AST_config    // pAstCfg
292 };
294 // Underflow threshold before circular buffer reset and return error to Top-Level FSM
295 #define DEC_OP_CB_RDAF_UND_THR  ( 80 ) // FL: arbitrary setting
296 UInt32 gCbReadAfErr         =0; // read circular buffer error count, not including underflows
297 UInt32 gDecOpCbRdAfUnd      =0; // decoder output circular buffer underflow count
298 UInt32 gMaxDecOpCbRdAfUnd   =0; // max (consecutive) decoder output circular buffer underflow count
299 UInt32 gMasterCbResetCnt    =0; // master circular buffer reset count
301 // For writeDECCommandRestart
302 extern volatile UInt32 gCommandOutputTask_SYNC;
303 extern volatile UInt32 gCommandOutputTask_ACK;
305 // Global debug counters */
306 UInt32 gAsopTxSioReclaimCnt         =0;
307 UInt32 gAsopInitOutProcCnt          =0;
308 UInt32 gAsopInitSyncDecResetCnt     =0;
309 UInt32 gAsopInitSyncDecInfo1Cnt     =0;
310 UInt32 gAsopInitSyncDecDecode1Cnt   =0;
311 UInt32 gAsopInitSyncResyncCnt       =0;
312 UInt32 gAsopOutProcCnt              =0;
313 UInt32 gAsopInitCnt                 =0;
314 UInt32 gAsopStreamCnt               =0;
315 UInt32 gAsopEncodeCnt               =0;
316 UInt32 gAsopFinalCnt                =0;
317 UInt32 gAsopOutSioUpdateCnt         =0;
318 UInt32 gAsopQuitCnt                 =0;
320 /*
321  *  ======== taskAsopFxnInit ========
322  *  Audio Stream Output Processing initialization function
323  */
324 Void taskAsopFxnInit(
325     const PAF_ASOT_Params *pP,
326     const PAF_ASOT_Patchs *pQ
329     PAF_ASOT_Config *pAsotCfg;      /* ASOT configuration pointer */
330     PAF_AST_Config *pAstCfg;        /* Common (shared) configuration pointer */
331     Int as;                         /* Audio Stream Number (1, 2, etc.) */
332     Int z;                          /* input/encode/stream/decode/output counter */
333     Int i;                          /* phase */
334     Int zMS;
336     Log_info0("Enter taskAsopFxnInit()");
338     //
339     // Audio Stream Output Task Parameters & Patch (*pP, *pQ)
340     //
341     if (!pP)
342     {
343         TRACE_TERSE0("TaskAsop: No Parameters defined. Exiting.");
344         LINNO_RPRT(TaskAsop, -1);
345         return;
346     }
348     if (!pQ)
349     {
350         TRACE_TERSE0("TaskAsop: No Patchs defined. Exiting.");
351         LINNO_RPRT(TaskAsop, -1);
352         return;
353     }
355     //
356     // Audio Stream Output Task Configuration (*pAsotCfg):
357     //
358     pAsotCfg = &gPAF_ASOT_config;       // initialize pointer to task configuration
359     pAsotCfg->taskHandle = Task_self(); // set task handle
360     pAstCfg = pAsotCfg->pAstCfg;        // get pointer to AST common (shared) configuration
362     /* Obtain Audio Stream Number (1, 2, etc.) */
363     as = pAstCfg->as;
364     TRACE_TERSE1("TaskAsop: Started with AS%d.", as);
366     //
367     // Initialize message log trace and line number reporting
368     //
369     for (z=STREAM1; z < STREAMN; z++)
370     {
371         TRACE_TERSE1("TaskAsop: AS%d: initiated", as+z);
372     }
373     LINNO_RPRT(TaskAsop, -1);
375     //
376     // Determine stream index
377     //
378     zMS = pAstCfg->masterStr;
380     // Initialize as per parametrized phases:
381     //
382     //   In standard form these are:
383     //      - Malloc: Memory Allocation
384     //      - Config: Configuration Initialization
385     //      - AcpAlg: ACP Algorithm Initialization and Local Attachment
386     //      - Common: Common Memory Initialization
387     //      - AlgKey: Dec/Enc chain to Array Initialization
388     //      - Device: I/O Device Initialization
389     //      - Unused: (available)
390     //      - Unused: (available)
391     //
392     LINNO_RPRT(TaskAsop, -2);
393     for (i=0; i < lengthof(pP->fxns->initPhase); i++)
394     {
395         Int linno;
396         if (pP->fxns->initPhase[i])
397         {
398             linno = pP->fxns->initPhase[i](pP, pQ, pAsotCfg);
399             if (linno)
400             {
401                 LINNO_RPRT(TaskAsop, linno);
402                 return;
403             }
404         }
405         else
406         {
407             TRACE_TERSE1("TaskAsop: AS%d: initialization phase - null", as+zMS);
408         }
409         TRACE_TERSE2("TaskAsop: AS%d: initialization phase - %d completed", as+zMS, i);
410         LINNO_RPRT(TaskAsop, -i-3);
411     }
413     //
414     // End of Initialization -- display memory usage report.
415     //
416     if (pP->fxns->memStatusPrint)
417     {
418         pP->fxns->memStatusPrint("ASOT MEMSTAT REPORT",
419             HEAP_INTERNAL, HEAP_INTERNAL1, HEAP_EXTERNAL,
420             HEAP_INTERNAL1_SHM, HEAP_EXTERNAL_SHM, HEAP_EXTERNAL_NONCACHED_SHM);
421     }
422 } /* taskAsopFxnInit */
425 /*
426  *  ======== taskAsopFxn ========
427  *  Audio Stream Output Processing task function
428  */
429 #ifdef PASDK_SIO_DEV
430 Void taskAsopFxn(
431 #else
432 #ifndef IO_LOOPBACK_TEST
433 Void taskAsopFxn(   // still use this for new I/O before it is refactored.
434 #else
435 Void taskAsopFxn_Not_Used(
436 #endif
437 #endif
438     const PAF_ASOT_Params *pP,
439     const PAF_ASOT_Patchs *pQ
442     PAF_ASOT_Config *pAsotCfg;      /* ASOT configuration pointer */
443     PAF_AST_Config *pAstCfg;        /* Common (shared) configuration pointer */
444     Int as;                         /* Audio Stream Number (1, 2, etc.) */
445     Int z;                          /* input/encode/stream/decode/output counter */
446     Int zMS;
447     Int errno;                      // error number
448     Int8 procSleep;                 // whether to sleep: 0: No, 1: Yes
449     Int8 procOutDevSel;             // whether to perform output device selection: 0: No, 1:Yes
450     Int outSel;                     // whether output device selected
451     enum { INIT_OUT_PROC_STATE, 
452            INITSYNC_DEC_RESET_STATE, INITSYNC_DEC_INFO1_STATE, INITSYNC_DEC_DECODE1_STATE, 
453            INITSYNC_RESYNC_STATE, 
454            OUT_PROC_STATE } state;
455     PAF_AudioFrame decResetAf;
456     PAF_AudioFrame decInfo1Af;
457     Int loopCount = 0;              // used to stop trace to see startup behavior.
459     Log_info0("Enter taskAsopFxn()");
461     taskAsopFxnInit(pP, pQ);    // initialization of output task
463     //
464     // Audio Stream Output Task Configuration (*pAsotCfg):
465     //
466     pAsotCfg = &gPAF_ASOT_config;       // initialize pointer to task configuration
467     pAstCfg = pAsotCfg->pAstCfg;        // get pointer to AST common (shared) configuration
469     /* Obtain Audio Stream Number (1, 2, etc.) */    
470     as = pAstCfg->as;
471     
472     zMS = pAstCfg->masterStr;
474     //
475     // Main processing loop
476     //   
477     for (z=STREAM1; z < STREAMN; z++)
478     {
479         TRACE_VERBOSE1("TaskAsop: AS%d: running", as+z);
480     }
481     
482     errno = 0;                      // init error indicator -- no error
483     procSleep = 1;                  // init sleep flag -- sleep
484     procOutDevSel = 1;              // init device output selection flag -- perform output device selection
485     state = INIT_OUT_PROC_STATE;    // init state
486     for (;;)
487     {
488         loopCount++;
489         TRACE_GEN2("TaskAsop (begin Main loop %d) (errno 0x%x)", loopCount, errno);
491         //
492         // Check forward (ASIT) error here, TBD
493         //
494         
495         // Even if we are not in error state, we check if writeDECCommandRestar issued or not
496         if (gCommandOutputTask_SYNC) {
497             TRACE_TERSE0("TaskAsop: ack for writeDECCommandRestart ... Wait for the command deasserted");
498             gCommandOutputTask_ACK = 1;
499             while (gCommandOutputTask_SYNC) {
500                 Task_sleep(1);
501             }
502             TRACE_TERSE0("TaskAsop: ack for writeDECCommandRestart ... Sync-ed! Startover the process");
503             procSleep = 1;                  // init sleep flag -- sleep
504             procOutDevSel = 1;              // init device output selection flag -- perform output device selection
505             state = INIT_OUT_PROC_STATE;    // init state -- starover
506             errno = ASOP_DP_FORWARD_ERR;    // Override the error -- for flushing SIO output device
507         }
508         
509         // any error forces idling of output
510         if (errno) 
511         {
512             for (z=OUTPUT1; z < OUTPUTN; z++)
513             {
514                 if (pAstCfg->xOut[z].hTxSio)
515                 {
516                     SIO_idle(pAstCfg->xOut[z].hTxSio);
517                 }
518             }
519         
520             TRACE_TERSE1("TaskAsop: Trace stopped at loop %d.", loopCount);
521             ERRNO_RPRT(TaskAsop, errno);
522         }
523         
524         if (procSleep == 1)
525         {
526             TRACE_VERBOSE1("TaskAsop: AS%d: ... sleeping ...", as+zMS);
527             Task_sleep(1);
528         }
530         if (procOutDevSel == 1)
531         {
532             // select output devices
533             TRACE_GEN1("TaskAsop: AS%d: Output device selection ...", as+zMS);
534             errno = pP->fxns->selectDevices(pP, pQ, pAsotCfg);
535             if (errno)
536             {
537                 TRACE_TERSE2("TaskAsop: AS%d: selectDevices returned errno = 0x%04x", as+zMS, errno);
539                 procSleep = 1;
540                 procOutDevSel = 1;
542                 continue;
543             }
545             // if no output selected skip remaining processing
546             errno = checkOutSel(pP, pAsotCfg, &outSel);
547             if (errno < 0)
548             {
549                 TRACE_TERSE2("TaskAsop: AS%d: checkOutSel returned errno = 0x%04x", as+zMS, errno);
551                 procSleep = 1;
552                 procOutDevSel = 1;
554                 continue;
555             }
556             else if (!outSel)
557             {
558                 TRACE_VERBOSE1("TaskAsop: AS%d: No output selected...", as+zMS);
560                 procSleep = 1;
561                 procOutDevSel = 1;
562                 
563                 continue;
564             }
565         }
566         
567         switch (state)
568         {
569             case INIT_OUT_PROC_STATE:
570                 gAsopInitOutProcCnt++;
571                 Log_info0("TaskAsop: state=INIT_OUT_PROC_STATE");
572                 
573                 //
574                 // Output Processing initialization.
575                 //
576                 errno = PAF_ASOT_initOutProc(pP, pAstCfg->xStr);
577                 if (errno < 0)
578                 {
579                     state = INIT_OUT_PROC_STATE;
580                     procSleep = 1;
581                     procOutDevSel = 1;
582                 }
583                 else
584                 {
585                     state = INITSYNC_DEC_RESET_STATE;
586                     procSleep = 0;
587                     procOutDevSel = 0;
588                 }
589             
590                 break;
591                 
592             case INITSYNC_DEC_RESET_STATE:
593                 gAsopInitSyncDecResetCnt++;
594                 Log_info0("TaskAsop: state=INITSYNC_DEC_RESET_STATE");
596                 //
597                 // Dec Reset Init-Sync.
598                 //  
599                 
600                 // Perform Dec Reset init-sync.
601                 // Latch Dec Reset AF.
602                 errno = PAF_ASOT_initSyncDecReset(pP, pQ, pAsotCfg, &decResetAf);
603                 if (errno < 0)
604                 {
605                     Log_info1("TaskAsop: state=INITSYNC_DEC_RESET_STATE errno=%d", errno);
607                     // sync error -- start over
608                     state = INIT_OUT_PROC_STATE;
609                     procSleep = 1;
610                     procOutDevSel = 1;
611                 }
612                 else if (errno == ASOP_INITSYNC_NOTREADY)
613                 {
614                     Log_info1("TaskAsop: state=INITSYNC_DEC_RESET_STATE not sync'd errno=%d", errno);
616                     // sync not ready -- try again
617                     state = INITSYNC_DEC_RESET_STATE;
618                     errno=0; // FL: temp hack
619                     procSleep = 1;
620                     procOutDevSel = 1;
621                 }
622                 else // errno==0
623                 {
624                     Log_info1("TaskAsop: state=INITSYNC_DEC_RESET_STATE sync'd, errno=%d", errno);
626                     // sync'd -- move on
627                     state = INITSYNC_DEC_INFO1_STATE;
628                     procSleep = 0;
629                     procOutDevSel = 0;
630                 }
631                 
632                 break;
633             
634             case INITSYNC_DEC_INFO1_STATE:
635                 gAsopInitSyncDecInfo1Cnt++;
636                 Log_info0("TaskAsop: state=INITSYNC_DEC_INFO1_STATE");
637                 
638                 //
639                 // Dec Info1 Init-Sync.
640                 //
642                 // Perform Dec Info1 init-sync.
643                 // Latch Dec Info1 AF.
644                 errno = PAF_ASOT_initSyncDecInfo1(pP, pQ, pAsotCfg, &decInfo1Af);
645                 if (errno < 0)
646                 {
647                     Log_info1("TaskAsop: state=INITSYNC_DEC_INFO1_STATE errno=%d", errno);
648                     
649                     // sync error -- start over
650                     state = INIT_OUT_PROC_STATE;
651                     procSleep = 1;
652                     procOutDevSel = 1;
653                 }
654                 else if (errno == ASOP_INITSYNC_NOTREADY)
655                 {
656                     Log_info1("TaskAsop: state=INITSYNC_DEC_INFO1_STATE not sync'd errno=%d", errno);
658                     // sync not ready -- try again
659                     state = INITSYNC_DEC_INFO1_STATE;
660                     errno=0; // FL: temp hack
661                     procSleep = 1;
662                     procOutDevSel = 0;
663                 }
664                 else // errno = 0
665                 {
666                     Log_info1("TaskAsop: state=INITSYNC_DEC_INFO1_STATE sync'd errno=%d", errno);
668                     // sync'd -- move on
669                     state = INITSYNC_DEC_DECODE1_STATE;
670                     procSleep = 0;
671                     procOutDevSel = 0;
672                 }
673                 
674                 break;
675             
676             case INITSYNC_DEC_DECODE1_STATE:
677                 gAsopInitSyncDecDecode1Cnt++;
678                 Log_info0("TaskAsop: state=INITSYNC_DEC_DECODE1_STATE");
679                 
680                 //
681                 // Dec Info1 Init-Sync.
682                 //
684                 // Perform Dec Info1 init-sync.
685                 // Latch Dec Info1 AF.
686                 errno = PAF_ASOT_initSyncDecDecode1(pP, pQ, pAsotCfg);
687                 if (errno < 0)
688                 {
689                     Log_info1("TaskAsop: state=INITSYNC_DEC_DECODE1_STATE errno=%d", errno);
691                     // sync error -- start over
692                     state = INIT_OUT_PROC_STATE;
693                     procSleep = 1;
694                     procOutDevSel = 1;
695                 }
696                 else if (errno == ASOP_INITSYNC_NOTREADY)
697                 {
698                     Log_info1("TaskAsop: state=INITSYNC_DEC_DECODE1_STATE not sync'd errno=%d", errno);
700                     // sync not ready -- try again
701                     state = INITSYNC_DEC_DECODE1_STATE;
702                     errno=0; // FL: temp hack
703                     procSleep = 1;
704                     procOutDevSel = 0;
705                 }
706                 else // errno = 0
707                 {
708                     Log_info1("TaskAsop: state=INITSYNC_DEC_DECODE1_STATE sync'd errno=%d", errno);
710                     // sync'd -- move on
711                     state = OUT_PROC_STATE;
712                     procSleep = 0;
713                     procOutDevSel = 0;
714                 }
715                 
716                 break;
717             
718             case INITSYNC_RESYNC_STATE:
719                 gAsopInitSyncResyncCnt++;
720                 Log_info0("TaskAsop: state=INITSYNC_RESYNC_STATE");
722                 //
723                 // Re-Sync.
724                 // Use stored AF info from init-sync.
725                 // This is done in case of local error.
726                 //
727                 
728                 // Perform Dec Info1 init-sync.
729                 errno = PAF_ASOT_initSyncResync(pP, pQ, pAsotCfg, &decResetAf, 
730                     &decInfo1Af);
731                 if (errno < 0)
732                 {
733                     Log_info1("TaskAsop: state=INITSYNC_RESYNC_STATE errno=%d", errno);
735                     // sync error -- start over
736                     state = INIT_OUT_PROC_STATE;
737                     procSleep = 1;
738                     procOutDevSel = 1;
739                 }
740                 else
741                 {
742                     Log_info1("TaskAsop: state=INITSYNC_RESYNC_STATE sync'd errno=%d", errno);
744                     // re-sync'd -- move on
745                     state = OUT_PROC_STATE;
746                     procSleep = 0;
747                     procOutDevSel = 0;
748                 }
749                     
750                 break;
751             
752             case OUT_PROC_STATE:        
753                 gAsopOutProcCnt++;
754                 Log_info0("TaskAsop: state=OUT_PROC_STATE");
755                 
756                 //
757                 // Output Processing.
758                 //
760                 TRACE_VERBOSE0("TaskAsop: calling decodeProcessing.");
761                 errno = pP->fxns->decodeProcessing(pP, pQ, pAsotCfg);
762                 if (errno < 0)
763                 {
764                     Log_info1("TaskAsop: state=OUT_PROC_STATE errno=%d", errno);
765                     
766                     //
767                     // Output Processing exit, due to error
768                     //
769                     
770                     TRACE_TERSE1("TaskAsop: decodeProcessing returns 0x%x, continue", errno);
771                     if (errno == ASOP_DP_FORWARD_ERR)
772                     {
773                         // forward (ASIT) error -- start over
774                         state = INIT_OUT_PROC_STATE;
775                         procSleep = 1;
776                         procOutDevSel = 1;
777                     }
778                     else
779                     {
780                         // local (ASOT) error
781                         state = INITSYNC_RESYNC_STATE;    
782                         procSleep = 1;
783                         procOutDevSel = 0; // disallow device re-select if local error during output processing
784                     }        
785                 }
786                 else if (errno > 0)
787                 {
788                     Log_info1("TaskAsop: state=OUT_PROC_STATE errno=%d", errno);
790                     //
791                     // Output Processing exit, not due to error
792                     //
794                     TRACE_TERSE1("TaskAsop: decodeProcessing returns 0x%x, continue", errno);                    
795                     if (errno == ASOP_DP_OUT_SIO_UPDATE)
796                     {
797                         // skip re-sync
798                         // resume output processing after new output selected
799                         state = OUT_PROC_STATE;
800                         procSleep = 1;
801                         procOutDevSel = 1;
802                     }
803                 }
804                 else
805                 {
806                     Log_info1("TaskAsop: state=OUT_PROC_STATE errno=%d", errno);
808                     //
809                     // Output Processing exit, normal
810                     //
811                     
812                     TRACE_VERBOSE0("TaskAsop: outputProcessing complete with no error.");
813                     
814                     // no error returned if CB drained 
815                     // (i.e. CB drained is normal behavior)
816                     state = INIT_OUT_PROC_STATE;
817                     procSleep = 1;
818                     procOutDevSel = 1;
819                 }
820                 
821                 break;
822             
823             default: // unknown state
824                 TRACE_TERSE2("TaskAsop: AS%d: state: unknown, 0x%x", as+zMS, state);
825                 break;
826         }
827     } // End of main processing loop for (;;)
828     
829     //Log_info0("Exit taskAsopFxn()");
832 Int PAF_ASOT_ioCompCreate(PAF_AST_IoOut *pIoOut, int numOut, IHeap_Handle iHeapHandle)
834     int i, j, num_alloc;
835     lib_mem_rec_t   *mem_rec;
836     ioBuffHandle_t  ioBufHandle;
837     ioPhyHandle_t   ioPhyHandle;
838     Error_Block     eb;
840     for(i=0; i<numOut; i++)
841     {
842         // Create an I/O BUFF instance
843         // Obtain number of memory blocks required by I/O BUFF
844         num_alloc = ioBuffNumAlloc();
846         // Obtain requirements of each memory block
847         mem_rec   = (lib_mem_rec_t *)malloc(sizeof(lib_mem_rec_t)*num_alloc);
848         if(ioBuffAlloc(mem_rec) != IOBUFF_NOERR) {
849             return __LINE__;
850         }
852         /* Allocate memory and create I/O BUFF instance */
853         for(j=0; j<num_alloc; j++) {
854             mem_rec[j].base = Memory_calloc(iHeapHandle, mem_rec[j].size,
855                                             (1<<mem_rec[j].alignment), &eb);
856         }
858         if(ioBuffCreate(&ioBufHandle, mem_rec) != IOBUFF_NOERR) {
859             return __LINE__;
860         }
862         pIoOut[i].hIoBuff = ioBufHandle;
864         free(mem_rec);
866         // Create an I/O PHY instance
867         // Obtain number of memory blocks required by I/O PHY
868         num_alloc = ioPhyNumAlloc();
870         // Obtain requirements of each memory block
871         mem_rec   = (lib_mem_rec_t *)malloc(sizeof(lib_mem_rec_t)*num_alloc);
872         if(ioPhyAlloc(mem_rec) != IOBUFF_NOERR) {
873             return __LINE__;
874         }
876         /* Allocate memory and create I/O PHY instance */
877         for(j=0; j<num_alloc; j++) {
878             mem_rec[j].base = Memory_calloc(iHeapHandle, mem_rec[j].size,
879                                             (1<<mem_rec[j].alignment), &eb);
880         }
882         if(ioPhyCreate(&ioPhyHandle, mem_rec) != IOBUFF_NOERR) {
883             return __LINE__;
884         }
886         pIoOut[i].hIoPhy = ioPhyHandle;
888         free(mem_rec);
890     } // end of for loop
892     return 0;
893 } // PAF_ASOT_ioCompCreate
895 // -----------------------------------------------------------------------------
896 // AST Initialization Function - Memory Allocation
897 //
898 //   Name:      PAF_ASOT_initPhaseMalloc
899 //   Purpose:   Audio Stream Output Task Function for initialization of data pointers
900 //              by allocation of memory.
901 //   From:      audioStream1Task or equivalent
902 //   Uses:      See code.
903 //   States:    x
904 //   Return:    0 on success.
905 //              Source code line number on MEM_calloc failure.
906 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
907 //              * State information as per parent.
908 //              * Memory allocation errors.
909 //
911 Int
912 PAF_ASOT_initPhaseMalloc (
913     const PAF_ASOT_Params *pP, 
914     const PAF_ASOT_Patchs *pQ, 
915     PAF_ASOT_Config *pAsotCfg
918     PAF_AST_Config *pAstCfg;
919     Int as;                     /* Audio Stream Number (1, 2, etc.) */
920     Int zMS, errLineNum;
921     Error_Block    eb;
922     //Int i;
924     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
925     as = pAstCfg->as;
926     zMS = pAstCfg->masterStr;
928     TRACE_TERSE1("PAF_ASOT_initPhaseMalloc: AS%d: initialization phase - memory allocation", as+zMS);
930     // Initialize error block
931     Error_init(&eb); 
933     /* Stream memory */
934     if (!(pAstCfg->xStr = Memory_calloc((IHeap_Handle)HEAP_INTERNAL, STREAMN * sizeof (*pAstCfg->xStr), 4, &eb)))
935     {
936         TRACE_TERSE1("PAF_ASOT_initPhaseMalloc: AS%d: Memory_calloc failed", as+zMS);
937         SW_BREAKPOINT;
938         return __LINE__;
939     }
940     TRACE_TERSE3("PAF_ASOT_initPhaseMalloc. (pAstCfg->xStr) %d bytes from space %d at 0x%x.",
941             STREAMN * sizeof (*pAstCfg->xStr),
942             HEAP_ID_INTERNAL, (IArg)pAstCfg->xStr);
944     {
945         Int z;                          /* stream counter */
947         PAF_AudioFrame *fBuf;
949         if (!(fBuf = (PAF_AudioFrame *)Memory_calloc((IHeap_Handle)HEAP_INTERNAL, STREAMS * sizeof (*fBuf), 4, &eb)))
950         {
951             TRACE_TERSE1("PAF_ASOT_initPhaseMalloc: AS%d: Memory_calloc failed", as+zMS);
952             SW_BREAKPOINT;
953             return __LINE__;
954         }
955         TRACE_TERSE3("PAF_ASOT_initPhaseMalloc. (fBuf) %d bytes from space %d at 0x%x.",
956                 STREAMS * sizeof (*fBuf),
957                 HEAP_ID_INTERNAL, (IArg)fBuf);
959         for (z=STREAM1; z < STREAMN; z++)
960         {
961             pAstCfg->xStr[z].pAudioFrame = &fBuf[z-STREAM1];
962             TRACE_TERSE2("pAstCfg->xStr[%d].pAudioFrame = 0x%x", z, (IArg)pAstCfg->xStr[z].pAudioFrame);
963         }
964     }
966     /* Encode memory */
967     if (!(pAstCfg->xEnc = Memory_calloc((IHeap_Handle)HEAP_INTERNAL, ENCODEN * sizeof (*pAstCfg->xEnc), 4, &eb)))
968     {
969         TRACE_TERSE1("PAF_ASOT_initPhaseMalloc: AS%d: Memory_calloc failed", as+zMS);
970         SW_BREAKPOINT;
971         return __LINE__;
972     }
973     TRACE_TERSE3("PAF_ASOT_initPhaseMalloc. (pAstCfg->xEnc) %d bytes from space %d at 0x%x.",
974             ENCODEN * sizeof (*pAstCfg->xEnc),
975             HEAP_ID_INTERNAL, (IArg)pAstCfg->xEnc);
977     /* Output memory */
978     if (!(pAstCfg->xOut = Memory_calloc((IHeap_Handle)HEAP_INTERNAL, OUTPUTN * sizeof (*pAstCfg->xOut), 4, &eb)))
979     {
980         TRACE_TERSE1("PAF_ASOT_initPhaseMalloc: AS%d: Memory_calloc failed", as+zMS);
981         SW_BREAKPOINT;
982         return __LINE__;
983     }
984     TRACE_TERSE3("PAF_ASOT_initPhaseMalloc. (pAstCfg->xOut) %d bytes from space %d at 0x%x.",
985             OUTPUTN * sizeof (*pAstCfg->xOut),
986             HEAP_ID_INTERNAL, (IArg)pAstCfg->xOut);
988     /* Output I/O data structure memory */
989     if (!(pAsotCfg->pIoOut = Memory_calloc((IHeap_Handle)HEAP_INTERNAL, OUTPUTN * sizeof (*pAsotCfg->pIoOut), 4, &eb)))
990     {
991         TRACE_TERSE1("PAF_ASOT_initPhaseMalloc: AS%d: Memory_calloc failed", as+zMS);
992         SW_BREAKPOINT;
993         return __LINE__;
994     }
995     TRACE_TERSE3("PAF_ASOT_initPhaseMalloc. (pAsotCfg->pIoOut) %d bytes from space %d at 0x%x.",
996                  OUTPUTN * sizeof (*pAsotCfg->pIoOut),
997                  HEAP_ID_INTERNAL, (IArg)pAsotCfg->pIoOut);
999     /* I/O components memory for output */
1000     errLineNum = PAF_ASOT_ioCompCreate(pAsotCfg->pIoOut, OUTPUTN, (IHeap_Handle)HEAP_INTERNAL);
1001     if(errLineNum)
1002     {
1003         SW_BREAKPOINT;
1004         return errLineNum;
1005     }
1006     TRACE_TERSE1("PAF_ASOT_initPhaseMalloc: AS%d: initialization phase - memory allocation complete.", as+zMS);
1007     return 0;
1008 } //PAF_ASOT_initPhaseMalloc
1010 // -----------------------------------------------------------------------------
1011 // ASOT Initialization Function - Memory Initialization from Configuration
1012 //
1013 //   Name:      PAF_ASOT_initPhaseConfig
1014 //   Purpose:   Audio Stream Output Task Function for initialization of data values
1015 //              from parameters.
1016 //   From:      audioStream1Task or equivalent
1017 //   Uses:      See code.
1018 //   States:    x
1019 //   Return:    0 on success.
1020 //              Other as per initFrame0 and initFrame1.
1021 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
1022 //              * State information as per parent.
1023 //
1024 Int
1025 PAF_ASOT_initPhaseConfig(
1026     const PAF_ASOT_Params *pP, 
1027     const PAF_ASOT_Patchs *pQ, 
1028     PAF_ASOT_Config *pAsotCfg
1031     PAF_AST_Config *pAstCfg;
1032     Int as;                     /* Audio Stream Number (1, 2, etc.) */
1033     Int z;                      /* input/encode/stream/decode/output counter */
1034     Int zMS;
1036     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
1037     as = pAstCfg->as;
1038     zMS = pAstCfg->masterStr;
1040     TRACE_TERSE1("PAF_ASOT_initPhaseConfig: AS%d: initialization phase - configuration", as+zMS);
1042     //
1043     // Unspecified elements have been initialized to zero during alloc
1044     //
1046     for (z=STREAM1; z < STREAMN; z++) 
1047     {
1048         Int linno;
1049         if (linno = pP->fxns->initFrame0(pP, pQ, pAsotCfg, z))
1050         {
1051             return linno;           
1052         }
1053         if (linno = pP->fxns->initFrame1(pP, pQ, pAsotCfg, z, -1))
1054         {
1055             return linno;
1056         }
1057     }
1059     for (z=ENCODE1; z < ENCODEN; z++) 
1060     {
1061         Int zO = pP->outputsFromEncodes[z];
1062         Int zS = pP->streamsFromEncodes[z];
1063         pAstCfg->xEnc[z].encodeControl.size = sizeof(pAstCfg->xEnc[z].encodeControl);
1064         pAstCfg->xEnc[z].encodeControl.pAudioFrame = pAstCfg->xStr[zS].pAudioFrame;
1065         pAstCfg->xEnc[z].encodeControl.pVolumeStatus = &pAstCfg->xEnc[z].volumeStatus;
1066         pAstCfg->xEnc[z].encodeControl.pOutBufConfig = &pAstCfg->xOut[zO].outBufConfig;
1067         pAstCfg->xEnc[z].encodeStatus = *pP->z_pEncodeStatus[z];
1068         pAstCfg->xEnc[z].encodeControl.encActive = pAstCfg->xEnc[z].encodeStatus.select;
1069         pAstCfg->xEnc[z].volumeStatus = *pP->pVolumeStatus;
1070         pAstCfg->xEnc[z].encodeInStruct.pAudioFrame = pAstCfg->xStr[zS].pAudioFrame;
1071     }
1073     for (z=OUTPUT1; z < OUTPUTN; z++)
1074     {
1075         pAstCfg->xOut[z].outBufStatus = *pP->pOutBufStatus;
1076     }
1078     TRACE_TERSE1("PAF_ASOT_initPhaseConfig: AS%d: initialization phase - configuration complete.", as+zMS);
1079     return 0;
1080 } //PAF_ASOT_initPhaseConfig
1082 // -----------------------------------------------------------------------------
1083 // ASOT Initialization Function - ACP Algorithm Instantiation
1084 //
1085 //   Name:      PAF_ASOT_initPhaseAcpAlg
1086 //   Purpose:   Audio Stream Input Task Function for initialization of ACP by
1087 //              instantiation of the algorithm.
1088 //   From:      audioStream1Task or equivalent
1089 //   Uses:      See code.
1090 //   States:    x
1091 //   Return:    0 on success.
1092 //              Source code line number on ACP Algorithm creation failure.
1093 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
1094 //              * State information as per parent.
1095 //              * Memory allocation errors.
1096 //
1097 Int
1098 PAF_ASOT_initPhaseAcpAlg(
1099     const PAF_ASOT_Params *pP, 
1100     const PAF_ASOT_Patchs *pQ, 
1101     PAF_ASOT_Config *pAsotCfg
1104     PAF_AST_Config *pAstCfg;
1105     Int as;                     /* Audio Stream Number (1, 2, etc.) */
1106     Int z;                      /* input/encode/stream/decode/output counter */
1107     Int betaPrimeOffset;
1108     ACP_Handle acp;
1109     Int zMS;
1110     Int zS, zX;
1112     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
1113     as = pAstCfg->as;
1114     zMS = pAstCfg->masterStr;
1116     TRACE_TERSE1("PAF_ASOT_initPhaseAcpAlg: AS%d: initialization phase - ACP Algorithm", as+zMS);
1118     ACP_MDS_init();
1120     if (!(acp = (ACP_Handle )ACP_MDS_create(NULL))) 
1121     {
1122         TRACE_TERSE1("PAF_ASOT_initPhaseAcpAlg: AS%d: ACP algorithm instance creation  failed", as+zMS);
1123         return __LINE__;
1124     }
1125     pAsotCfg->acp = acp;
1127     ((ALG_Handle)acp)->fxns->algControl((ALG_Handle) acp,
1128         ACP_GETBETAPRIMEOFFSET, (IALG_Status *)&betaPrimeOffset);
1130     for (z=ENCODE1; z < ENCODEN; z++) 
1131     {
1132         zS = pP->streamsFromEncodes[z];
1133         acp->fxns->attach(acp, ACP_SERIES_STD,
1134             STD_BETA_ENCODE + betaPrimeOffset * (as-1+zS),
1135             (IALG_Status *)&pAstCfg->xEnc[z].encodeStatus);
1136         acp->fxns->attach(acp, ACP_SERIES_STD,
1137             STD_BETA_VOLUME + betaPrimeOffset * (as-1+zS),
1138             (IALG_Status *)&pAstCfg->xEnc[z].volumeStatus);
1139         /* Ignore errors, not reported. */
1140     }
1142     for (z=OUTPUT1; z < OUTPUTN; z++) 
1143     {
1144         zS = z;
1145         for (zX = ENCODE1; zX < ENCODEN; zX++) 
1146         {
1147             if (pP->outputsFromEncodes[zX] == z) 
1148             {
1149                 zS = pP->streamsFromEncodes[zX];
1150                 break;
1151             }
1152         }
1153         acp->fxns->attach(acp, ACP_SERIES_STD,
1154             STD_BETA_OB + betaPrimeOffset * (as-1+zS),
1155             (IALG_Status *)&pAstCfg->xOut[z].outBufStatus);
1156         /* Ignore errors, not reported. */
1157     }
1159     TRACE_TERSE1("PAF_ASOT_initPhaseAcpAlg: AS%d: initialization phase - ACP Algorithm complete.", as+zMS);
1161     return 0;
1162 } //PAF_ASOT_initPhaseAcpAlg
1164 // -----------------------------------------------------------------------------
1165 // ASOT Initialization Function - Common Memory
1166 //
1167 //   Name:      PAF_ASOT_initPhaseCommon
1168 //   Purpose:   Audio Stream Output Task Function for allocation of common memory.
1169 //   From:      audioStream1Task or equivalent
1170 //   Uses:      See code.
1171 //   States:    x
1172 //   Return:    0 on success.
1173 //              Source code line number on PAF_ALG_alloc failure.
1174 //              Source code line number on PAF_ALG_mallocMemory failure.
1175 //              Source code line number on Decode Chain initialization failure.
1176 //              Source code line number on ASP Chain initialization failure.
1177 //              Source code line number on Encode Chain initialization failure.
1178 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
1179 //              * State information as per parent.
1180 //              * Memory allocation errors.
1181 //
1182 Int
1183 PAF_ASOT_initPhaseCommon(
1184     const PAF_ASOT_Params *pP, 
1185     const PAF_ASOT_Patchs *pQ, 
1186     PAF_ASOT_Config *pAsotCfg
1189     PAF_AST_Config *pAstCfg;
1190     Int as;                     /* Audio Stream Number (1, 2, etc.) */
1191     Int z;                      /* stream counter */
1192     Int g;                      /* gear */
1193     ACP_Handle acp;
1194     PAF_IALG_Config pafAlgConfig;
1195     IALG_MemRec common[3][PAF_IALG_COMMON_MEMN+1];
1196    
1197     acp = pAsotCfg->acp;
1198     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
1199     as = pAstCfg->as;
1201     TRACE_TERSE0("PAF_ASOT_initPhaseCommon: initialization phase - Common Memory");
1203     //
1204     // Determine memory needs and instantiate algorithms across audio streams
1205     //
1206     TRACE_TERSE0("PAF_ASOT_initPhaseCommon: calling PAF_ALG_setup.");
1207     PAF_ALG_setup(&pafAlgConfig, 
1208         HEAP_ID_INTERNAL,                 HEAP_INTERNAL, 
1209         HEAP_ID_INTERNAL1,                HEAP_INTERNAL1, 
1210         HEAP_ID_EXTERNAL,                 HEAP_EXTERNAL, 
1211         HEAP_ID_INTERNAL1_SHM,            HEAP_INTERNAL1_SHM, 
1212         HEAP_ID_EXTERNAL_SHM,             HEAP_EXTERNAL_SHM, 
1213         HEAP_ID_EXTERNAL_NONCACHED_SHM,   HEAP_EXTERNAL_NONCACHED_SHM,
1214         HEAP_CLEAR);
1216     if (pP->fxns->headerPrint)
1217     {
1218         pP->fxns->headerPrint();        
1219     }
1221     for (z = STREAM1; z < STREAMN; z++) 
1222     {
1223         //Int zD, zE, zX;
1224         Int zE, zX;
1226         TRACE_TERSE1("PAF_ASOT_initPhaseCommon: AS%d: initialization phase - Common Memory", as+z);
1228         //
1229         // Determine common memory needs for:
1230         //  (1) ASP Algorithms
1231         //  (2) Encode Algorithms
1232         //  (3) Logical Output drivers
1233         //
1234         PAF_ALG_init(common[z], lengthof(common[z]), COMMONSPACE);
1236         zE = -1;
1237         for (zX = ENCODE1; zX < ENCODEN; zX++) 
1238         {
1239             if (pP->streamsFromEncodes[zX] == z) 
1240             {
1241                 zE = zX;
1242                 break;
1243             }
1244         }
1246         TRACE_TERSE1("Calling PAF_ALG_ALLOC for stream common[%d].", z);
1247         if (PAF_ALG_ALLOC(aspLinkInit[z-STREAM1][0], common[z])) 
1248         {
1249             TRACE_TERSE1("PAF_ASOT_initPhaseCommon: AS%d: PAF_ALG_alloc failed", as+z);
1250             TRACE_TERSE2("Failed to alloc %d bytes from space %d ", common[z]->size, common[z]->space);
1251             SW_BREAKPOINT;
1252             return __LINE__;
1253         }
1254         TRACE_TERSE3("alloced %d bytes from space %d at 0x%x", common[z]->size, common[z]->space, (IArg)common[z]->base);
1255         if (pP->fxns->allocPrint)
1256         {
1257             pP->fxns->allocPrint((const PAF_ALG_AllocInit *)(aspLinkInit[z-STREAM1][0]), sizeof (*(aspLinkInit[z-STREAM1][0])), &pafAlgConfig);
1258         }
1260         if (zE >= 0) 
1261         {
1262             TRACE_TERSE1("PAF_ASOT_initPhaseCommon: calling PAF_ALG_ALLOC/ for encoder common[%d].", z);
1263             if (PAF_ALG_ALLOC(encLinkInit[zE-ENCODE1], common[z])) 
1264             {
1265                 TRACE_TERSE1("PAF_ASOT_initPhaseCommon: AS%d: PAF_ALG_alloc failed", as+z);
1266                 SW_BREAKPOINT;
1267                 return __LINE__;
1268             }
1269             TRACE_TERSE3("alloced %d bytes from space %d at 0x%x", common[z]->size, common[z]->space, (IArg)common[z]->base);
1270             if (pP->fxns->allocPrint)
1271             {
1272                 pP->fxns->allocPrint((const PAF_ALG_AllocInit *)(encLinkInit[z-ENCODE1]), sizeof (*(encLinkInit[z-ENCODE1])), &pafAlgConfig);
1273             }
1274         }
1276         //
1277         // Determine common memory needs of Logical IO drivers
1278         //
1280         if (OUTPUT1 <= z && z < OUTPUTN)
1281         {
1282             TRACE_TERSE1("PAF_ASOT_initPhaseCommon: calling PAF_ALG_ALLOC outLinkInit common[%d].", z);
1283             if (PAF_ALG_ALLOC(outLinkInit[z-OUTPUT1], common[z]))
1284             {
1285                 TRACE_TERSE1("PAF_ASOT_initPhaseMalloc: AS%d: PAF_ALG_alloc failed", as+z);
1286                 TRACE_TERSE2("Failed to alloc %d bytes from space %d", common[z]->size, (IArg)common[z]->space);
1287                 SW_BREAKPOINT;
1288                 return __LINE__;
1289             }
1290             TRACE_TERSE3("alloced %d bytes from space %d at 0x%x", common[z]->size, common[z]->space, (IArg)common[z]->base);
1291             if (pP->fxns->allocPrint)
1292             {
1293                 pP->fxns->allocPrint((const PAF_ALG_AllocInit *)(outLinkInit[z-INPUT1]), sizeof (*(outLinkInit[z-INPUT1])), &pafAlgConfig);
1294             }
1295         }
1296     }
1297     {
1298         // Changes made to share scratch between zones
1299         // Assume maximum 3 zones and scratch common memory is at offset 0;
1300         int max=0;
1301         for (z=STREAM1; z<STREAMN; z++)
1302         {
1303             if (max < common[z][0].size)
1304             {
1305                 max = common[z][0].size;
1306             }
1307         }
1308         common[STREAM1][0].size=max;
1309         for (z=STREAM1+1; z<STREAMN; z++)
1310         {
1311             common[z][0].size = 0;            
1312         }
1313     }
1314         
1315     //
1316     // Allocate common memory for:
1317     //  (1) ASP Algorithms
1318     //  (2) Encode Algorithms
1319     //  (3) Logical Output drivers
1320     //
1321     for (z = STREAM1; z < STREAMN; z++) 
1322     {
1323         //Int zD, zE, zX;
1324         Int zE, zX;
1326         TRACE_TERSE0("PAF_ASOT_initPhaseCommon: calling PAF_ALG_mallocMemory for common space.");
1327         if (PAF_ALG_mallocMemory(common[z], &pafAlgConfig)) 
1328         {
1329             TRACE_TERSE1("AS%d: PAF_ALG_mallocMemory failed", as+z);
1330             TRACE_TERSE3("AS%d: z: %d.  Size 0x%x", as+z, z, common[z][0].size);
1331             SW_BREAKPOINT;
1332             return __LINE__;
1333         }
1334         TRACE_TERSE3("alloced %d bytes from space %d at 0x%x", common[z]->size, common[z]->space, (IArg)common[z]->base);
1335         // share zone0 scratch with all zones 
1336         common[z][0].base = common[0][0].base;
1337         if (pP->fxns->commonPrint)
1338         {
1339             pP->fxns->commonPrint(common[z], &pafAlgConfig);
1340         }
1342         zE = -1;
1343         for (zX = ENCODE1; zX < ENCODEN; zX++) 
1344         {
1345             if (pP->streamsFromEncodes[zX] == z) 
1346             {
1347                 zE = zX;
1348                 break;
1349             }
1350         }
1352         pAstCfg->xStr[z].aspChain[0] = NULL;
1353         for (g=0; g < GEARS; g++) 
1354         {
1355             PAF_ASP_Chain *chain;
1356             TRACE_TERSE0("PAF_ASOT_initPhaseCommon: calling PAF_ASP_chainInit for ASPs.");
1357             chain = PAF_ASP_chainInit(&pAstCfg->xStr[z].aspChainData[g], pP->pChainFxns,
1358                 HEAP_INTERNAL, as+z, acp, &trace,
1359                 aspLinkInit[z-STREAM1][g], pAstCfg->xStr[z].aspChain[0], common[z], &pafAlgConfig);
1360             if (!chain) 
1361             {
1362                 TRACE_TERSE2("AS%d: ASP chain %d initialization failed", as+z, g);
1363                 return __LINE__;
1364             }
1365             else
1366             {
1367                 pAstCfg->xStr[z].aspChain[g] = chain;
1368             }
1369         }
1371         if (zE >= 0) 
1372         {
1373             PAF_ASP_Chain *chain;
1374             TRACE_TERSE0("PAF_ASOT_initPhaseCommon: calling PAF_ASP_chainInit for encode.");
1375             chain = PAF_ASP_chainInit(&pAstCfg->xEnc[zE].encChainData, pP->pChainFxns,
1376                 HEAP_INTERNAL, as+z, acp, &trace,
1377                 encLinkInit[zE-ENCODE1], NULL, common[z], &pafAlgConfig);
1378             if (!chain) 
1379             {
1380                 TRACE_TERSE1("AS%d: Encode chain initialization failed", as+z);
1381                 return __LINE__;
1382             }
1383         }
1385         //
1386         // Allocate non-common memories for Logical IO drivers
1387         //    Since these structures are used at run-time we allocate from external memory
1388         if (OUTPUT1 <= z && z < OUTPUTN) 
1389         {
1390             PAF_ASP_Chain *chain;
1391             TRACE_TERSE2("PAF_ASOT_initPhaseMalloc: AS%d: non-common output chain init for %d",
1392                            as+z, z);
1393             chain = PAF_ASP_chainInit (&pAstCfg->xOut[z].outChainData, pP->pChainFxns,
1394                         HEAP_EXTERNAL, as+z, acp, &trace,
1395                         outLinkInit[z-OUTPUT1], NULL, common[z], &pafAlgConfig);
1396             if (!chain) 
1397             {
1398                 TRACE_TERSE1("AS%d: Output chain initialization failed", as+z);
1399                 return __LINE__;
1400             }
1401         }
1402     }
1403     TRACE_TERSE1("AS%d: PAF_ASOT_initPhaseCommon: Returning complete.", as+z);
1405     return 0;
1406 } //PAF_ASOT_initPhaseCommon
1408 // -----------------------------------------------------------------------------
1409 // ASOT Initialization Function - Algorithm Keys
1410 //
1411 //   Name:      PAF_ASOT_initPhaseAlgKey
1412 //   Purpose:   Audio Stream Output Task Function for initialization of data values
1413 //              from parameters for Algorithm Keys.
1414 //   From:      audioStream1Task or equivalent
1415 //   Uses:      See code.
1416 //   States:    x
1417 //   Return:    0.
1418 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
1419 //              * State information as per parent.
1420 //
1421 // .............................................................................
1422 Int
1423 PAF_ASOT_initPhaseAlgKey(
1424     const PAF_ASOT_Params *pP, 
1425     const PAF_ASOT_Patchs *pQ, 
1426     PAF_ASOT_Config *pAsotCfg
1429     PAF_AST_Config *pAstCfg;
1430     Int as;                     /* Audio Stream Number (1, 2, etc.) */
1431     Int z;                      /* decode/encode counter */
1432     Int s;                      /* key number */
1433     PAF_ASP_Link *that;
1435     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
1436     as = pAstCfg->as;
1437     (void)as; // clear compiler warning in case not used with tracing disabled
1439     TRACE_VERBOSE1("PAF_ASOT_initPhaseAlgKey: AS%d: initialization phase - Algorithm Keys", as);
1441     for (z=ENCODE1; z < ENCODEN; z++) 
1442     {
1443         for (s=0; s < pP->pEncAlgKey->length; s++) 
1444         {
1445             if ((pP->pEncAlgKey->code[s].full != 0) && 
1446                 (that = PAF_ASP_chainFind(&pAstCfg->xEnc[z].encChainData, pP->pEncAlgKey->code[s])))
1447             {
1448                 pAstCfg->xEnc[z].encAlg[s] = (ALG_Handle )that->alg;
1449             }
1450             /* Cast in interface, for now --Kurt */
1451             else
1452             {
1453                 pAstCfg->xEnc[z].encAlg[s] = NULL;                
1454             }
1455         }
1456     }
1458     return 0;
1459 } //PAF_ASOT_initPhaseAlgKey
1461 // -----------------------------------------------------------------------------
1462 // ASOT Initialization Function - I/O Devices
1463 //
1464 //   Name:      PAF_ASOT_initPhaseDevice
1465 //   Purpose:   Audio Stream Output Task Function for initialization of I/O Devices.
1466 //   From:      audioStream1Task or equivalent
1467 //   Uses:      See code.
1468 //   States:    x
1469 //   Return:    0 on success.
1470 //              Source code line number on device allocation failure.
1471 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
1472 //              * State information as per parent.
1473 //              * Memory allocation errors.
1474 //
1475 Int
1476 PAF_ASOT_initPhaseDevice(
1477     const PAF_ASOT_Params *pP, 
1478     const PAF_ASOT_Patchs *pQ, 
1479     PAF_ASOT_Config *pAsotCfg
1482     PAF_AST_Config *pAstCfg;
1483     Int as;                     /* Audio Stream Number (1, 2, etc.) */
1484     Int z;                      /* input/output counter */
1485     PAF_SIO_IALG_Obj    *pObj;
1486     PAF_SIO_IALG_Config *pAlgConfig;
1487     PAF_IALG_Config pafAlgConfig;
1489     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
1490     as = pAstCfg->as;
1491     (void)as; // clear compiler warning in case not used with tracing disabled
1493     TRACE_TERSE1("PAF_ASOT_initPhaseDevice: AS%d: initialization phase - I/O Devices", as);
1495     if(pP->fxns->bufMemPrint)
1496     {
1497         PAF_ALG_setup (&pafAlgConfig, 
1498             HEAP_ID_INTERNAL,               HEAP_INTERNAL, 
1499             HEAP_ID_INTERNAL1,              HEAP_INTERNAL1,
1500             HEAP_ID_EXTERNAL,               HEAP_EXTERNAL,
1501             HEAP_ID_INTERNAL1_SHM,          HEAP_INTERNAL1_SHM,
1502             HEAP_ID_EXTERNAL_SHM,           HEAP_EXTERNAL_SHM,
1503             HEAP_ID_EXTERNAL_NONCACHED_SHM, HEAP_EXTERNAL_NONCACHED_SHM,
1504             HEAP_CLEAR);
1505         TRACE_TERSE2("PAF_ASOT_initPhaseDevice: AS%d: calling PAF_ALG_setup with clear at %d.", as, HEAP_CLEAR);
1506     }
1507     
1508     for (z=OUTPUT1; z < OUTPUTN; z++) 
1509     {
1510         PAF_OutBufConfig *pConfig = &pAstCfg->xOut[z].outBufConfig;
1512         pObj = (PAF_SIO_IALG_Obj *)pAstCfg->xOut[z].outChainData.head->alg;
1513         pAlgConfig = &pObj->config;
1515         pAstCfg->xOut[z].hTxSio = NULL;
1516         pConfig->base.pVoid     = pAlgConfig->pMemRec[0].base;
1517         pConfig->pntr.pVoid     = pAlgConfig->pMemRec[0].base;
1518         pConfig->head.pVoid     = pAlgConfig->pMemRec[0].base;
1519         pConfig->allocation     = pAlgConfig->pMemRec[0].size;
1520         pConfig->sizeofElement  = 3;
1521         pConfig->precision      = 24;
1522         if(pP->fxns->bufMemPrint)
1523         {
1524             pP->fxns->bufMemPrint(z,pAlgConfig->pMemRec[0].size,PAF_ALG_memSpaceToHeapId(&pafAlgConfig,pAlgConfig->pMemRec[0].space),1);
1525         }
1526     }
1527     TRACE_TERSE1("PAF_ASOT_initPhaseDevice: AS%d: initialization phase - I/O Devices complete.", as);
1529     return 0;
1530 } //PAF_ASOT_initPhaseDevice
1532 // -----------------------------------------------------------------------------
1533 // ASOT Initialization Function Helper - Initialization of Audio Frame
1534 //
1535 //   Name:      PAF_ASOT_initFrame0
1536 //   Purpose:   Audio Stream Output Task Function for initialization of the Audio
1537 //              Frame(s) by memory allocation and loading of data pointers
1538 //              and values.
1539 //   From:      AST Parameter Function -> decodeInfo
1540 //   Uses:      See code.
1541 //   States:    x
1542 //   Return:    0 on success.
1543 //              Source code line number on MEM_calloc failure.
1544 //              Source code line number on unsupported option.
1545 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
1546 //              * Memory allocation errors.
1547 //              * Unsupported option errors.
1548 //
1550 // MID 314
1551 extern const char AFChanPtrMap[PAF_MAXNUMCHAN+1][PAF_MAXNUMCHAN];
1552 extern PAF_ChannelConfigurationMaskTable PAF_ASP_stdCCMT_patch;
1554 Int
1555 PAF_ASOT_initFrame0(
1556     const PAF_ASOT_Params *pP, 
1557     const PAF_ASOT_Patchs *pQ, 
1558     PAF_ASOT_Config *pAsotCfg, 
1559     Int z
1562     PAF_AST_Config *pAstCfg;
1563     Int as;                     /* Audio Stream Number (1, 2, etc.) */
1564     Int ch;
1565     //Int aLen;
1566     Int aLen_int=0,aLen_ext=0;
1567     Int aSize = sizeof(PAF_AudioData);
1568     Int aAlign = aSize < sizeof (int) ? sizeof (int) : aSize;
1569     Int maxFrameLength = pP->maxFramelength;
1570     Int zX;
1571     PAF_AudioData *aBuf_int=NULL;
1572     PAF_AudioData *aBuf_ext=NULL;
1573     XDAS_UInt8 *metadataBuf;
1574     char i;
1575     Error_Block    eb;
1577     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
1578     as = pAstCfg->as;
1580     // Initialize error block
1581     Error_init(&eb); 
1583     // Compute maximum framelength (needed for ARC support)
1584     maxFrameLength += PA_MODULO - maxFrameLength % PA_MODULO;
1585     //aLen = numchan[z] * maxFrameLength;
1586     for (i=0; i < numchan[z]; i++)
1587     {
1588         if (pP->pAudioFrameBufStatus->space[i] == IALG_SARAM)
1589         {
1590             aLen_int += maxFrameLength;
1591         }
1592         else
1593         {
1594             aLen_ext += maxFrameLength;
1595         }
1596     }
1598     //
1599     // Initialize audio frame elements directly
1600     //
1601     pAstCfg->xStr[z].pAudioFrame->fxns = pP->pAudioFrameFunctions;
1602     pAstCfg->xStr[z].pAudioFrame->data.nChannels = PAF_MAXNUMCHAN; ///
1603 ///    pAstCfg->xStr[z].pAudioFrame->data.nChannels = PAF_MAXNUMCHAN_AF;
1604     pAstCfg->xStr[z].pAudioFrame->data.nSamples = FRAMELENGTH;
1605     pAstCfg->xStr[z].pAudioFrame->data.sample = pAstCfg->xStr[z].audioFrameChannelPointers;
1606     pAstCfg->xStr[z].pAudioFrame->data.samsiz = pAstCfg->xStr[z].audioFrameChannelSizes;
1607     pAstCfg->xStr[z].pAudioFrame->pChannelConfigurationMaskTable = &PAF_ASP_stdCCMT;
1609     //
1610     // Allocate memory for and initialize pointers to audio data buffers
1611     //
1612     //   The NUMCHANMASK is used to identify the channels for which data
1613     //   buffers can be allocated. Using this mask and switch statement
1614     //   rather than some other construct allows efficient code generation,
1615     //   providing just the code necessary (with significant savings).
1616     //
1617     if (pP->fxns->bufMemPrint)
1618     {
1619         pP->fxns->bufMemPrint(z, aLen_int*aSize, HEAP_ID_FRMBUF, 2);
1620         pP->fxns->bufMemPrint(z, aLen_ext*aSize, HEAP_ID_EXTERNAL, 2);
1621     }
1623     TRACE_TERSE1("PAF_ASOT_initFrame0: AS%d: Memory_calloc for audio buffers", as+z);
1624     
1625     if (aLen_int*aSize!=0) // check size != 0, otherwise malloc throws fatal error
1626     {
1627         if (!(aBuf_int = (PAF_AudioData *)Memory_calloc((IHeap_Handle)HEAP_FRMBUF, (aLen_int+(maxFrameLength-FRAMELENGTH))*aSize, aAlign, &eb))) //Qin: Add start offset
1628         {
1629             TRACE_TERSE1("PAF_ASOT_initFrame0: AS%d: Memory_calloc failed", as+z);
1630             TRACE_TERSE2("  maxFrameLength: %d.  aLen_int*aSize: %d", maxFrameLength, (aLen_int+(maxFrameLength-FRAMELENGTH))*aSize);
1631             SW_BREAKPOINT;
1632             return __LINE__;
1633         }
1634     }
1635         
1636     if (aLen_ext*aSize!=0)
1637     {
1638         if (!(aBuf_ext = (PAF_AudioData *)Memory_calloc((IHeap_Handle)HEAP_EXTERNAL, (aLen_ext+(maxFrameLength-FRAMELENGTH))*aSize, aAlign, &eb)))//Qin: Add start offset
1639         {
1640             TRACE_TERSE1("PAF_ASOT_initFrame0: AS%d: Memory_calloc failed", as+z);
1641             TRACE_TERSE2("  maxFrameLength: %d.  aLen_ext*aSize: %d", maxFrameLength, (aLen_ext+(maxFrameLength-FRAMELENGTH))*aSize);
1642             SW_BREAKPOINT;
1643             return __LINE__;
1644         }
1645     }
1646     
1647     TRACE_TERSE3("  maxFrameLength: %d.  aLen_int*aSize: %d.  aBuf_int: 0x%x", maxFrameLength, (aLen_int+(maxFrameLength-FRAMELENGTH))*aSize, (IArg)aBuf_int);
1648     TRACE_TERSE3("  maxFrameLength: %d.  aLen_ext*aSize: %d.  aBuf_ext: 0x%x", maxFrameLength, (aLen_ext+(maxFrameLength-FRAMELENGTH))*aSize, (IArg)aBuf_ext);
1650     TRACE_TERSE1("PAF_ASOT_initFrame0: AS%d: Memory_calloc for metadata buffers", as+z);
1651     if (!(metadataBuf = (XDAS_UInt8 *)Memory_calloc((IHeap_Handle)HEAP_MDBUF, pP->pMetadataBufStatus->bufSize*pP->pMetadataBufStatus->NumBuf, pP->pMetadataBufStatus->alignment, &eb)))
1652     {
1653         TRACE_TERSE1("PAF_ASOT_initFrame0: AS%d: Memory_calloc failed", as+z);
1654         TRACE_TERSE1("  bufSize*NumBuf: %d", pP->pMetadataBufStatus->bufSize*pP->pMetadataBufStatus->NumBuf);
1655         SW_BREAKPOINT;
1656         return __LINE__;
1657     }
1659     {
1660         Int i;
1662 #pragma UNROLL(1)
1663         for (i=0; i < PAF_MAXNUMCHAN_AF; i++)
1664         {
1665             pAstCfg->xStr[z].audioFrameChannelPointers[i] = NULL;
1666         }
1667     }
1669     // MID 314
1670     if((numchan[z] > PAF_MAXNUMCHAN) || (numchan[z] < 1)) 
1671     {
1672         TRACE_TERSE1("PAF_ASOT_initFrame0: AS%d: unsupported option", as+z);
1673         return __LINE__;
1674     }
1675     else 
1676     {
1677         Int j = 0;
1678         Int k = 0;
1679         TRACE_TERSE1("PAF_ASOT_initFrame0: AFChanPtrMap[%d][i]", numchan[z]);
1680         for(i=0;i<numchan[z];i++)
1681         {
1682             char chan = AFChanPtrMap[numchan[z]][i];
1683             if(chan != -1)
1684             {
1685                 if(pP->pAudioFrameBufStatus->space[i] == IALG_SARAM)
1686                 {
1687                     pAstCfg->xStr[z].audioFrameChannelPointers[chan] = aBuf_int + maxFrameLength*(j+1) - FRAMELENGTH;
1688                     j++;
1689                 }
1690                 else
1691                 {        
1692                     pAstCfg->xStr[z].audioFrameChannelPointers[chan] = aBuf_ext + maxFrameLength*(k+1) - FRAMELENGTH;
1693                     k++;
1694                 }    
1695                 TRACE_TERSE3("PAF_ASOT_initFrame0: chan = %d = AFChanPtrMap[%d][%d].", chan, numchan[z], i);
1696                 TRACE_TERSE2("PAF_ASOT_initFrame0: audioFrameChannelPointers[%d]: 0x%x", chan, (IArg)pAstCfg->xStr[z].audioFrameChannelPointers[chan]);
1697             }
1698         }
1699     }
1701     for (ch=PAF_LEFT; ch < PAF_MAXNUMCHAN_AF; ch++) 
1702     {
1703         if (pAstCfg->xStr[z].audioFrameChannelPointers[ch])
1704         {
1705             pAstCfg->xStr[z].origAudioFrameChannelPointers[ch] = pAstCfg->xStr[z].audioFrameChannelPointers[ch];
1706         }
1707     }
1709     //
1710     // Initialize meta data elements
1711     //
1712     pAstCfg->xStr[z].pAudioFrame->pafBsMetadataUpdate = XDAS_FALSE;
1713     pAstCfg->xStr[z].pAudioFrame->numPrivateMetadata = 0;
1714     pAstCfg->xStr[z].pAudioFrame->bsMetadata_offset = 0;
1715     pAstCfg->xStr[z].pAudioFrame->bsMetadata_type = PAF_bsMetadata_channelData;
1716     pAstCfg->xStr[z].pAudioFrame->privateMetadataBufSize = pP->pMetadataBufStatus->bufSize;
1717     for(i=0;i<pP->pMetadataBufStatus->NumBuf;i++)
1718     {
1719         pAstCfg->xStr[z].pAudioFrame->pafPrivateMetadata[i].offset = 0;
1720         pAstCfg->xStr[z].pAudioFrame->pafPrivateMetadata[i].size = 0;
1721         pAstCfg->xStr[z].pAudioFrame->pafPrivateMetadata[i].pMdBuf = metadataBuf + pP->pMetadataBufStatus->bufSize*i;
1722     }
1724     //
1725     // Initialize decoder elements directly
1726     //
1728     for (zX = DECODE1; zX < DECODEN; zX++) 
1729     {
1730         if (pP->streamsFromDecodes[zX] == z) 
1731         {
1732 #ifdef NOAUDIOSHARE
1733             pAstCfg->xDec[zX].decodeInStruct.audioShare.nSamples = 0;
1734             pAstCfg->xDec[zX].decodeInStruct.audioShare.sample = NULL;
1735 #else /* NOAUDIOSHARE */
1736             pAstCfg->xDec[zX].decodeInStruct.audioShare.nSamples = aLen_int;
1737             pAstCfg->xDec[zX].decodeInStruct.audioShare.sample = aBuf_int;
1738 #endif /* NOAUDIOSHARE */
1739         }
1740     }
1742     return 0;
1743 } //PAF_ASOT_initFrame0
1745 // -----------------------------------------------------------------------------
1746 // ASOT Initialization Function Helper - Reinitialization of Audio Frame
1747 // AST Decoding Function              - Reinitialization of Audio Frame
1748 //
1749 //   Name:      PAF_ASOT_initFrame1
1750 //   Purpose:   Audio Stream Task Function for initialization or reinitiali-
1751 //              zation of the Audio Frame(s) by loading of data values of a
1752 //              time-varying nature.
1753 //   From:      audioStream1Task or equivalent
1754 //              AST Parameter Function -> decodeInfo
1755 //              AST Parameter Function -> decodeDecode
1756 //   Uses:      See code.
1757 //   States:    x
1758 //   Return:    0.
1759 //   Trace:     None.
1760 //
1761 Int
1762 PAF_ASOT_initFrame1(
1763     const PAF_ASOT_Params *pP, 
1764     const PAF_ASOT_Patchs *pQ, 
1765     PAF_ASOT_Config *pAsotCfg, 
1766     Int z, 
1767     Int apply
1770     PAF_AST_Config *pAstCfg;
1772     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
1774     //
1775     // Reinitialize audio frame elements:
1776     //
1777     //   Channel Configurations during sys init                 = Unknown
1778     //      "          "        during info or decode           = None
1779     //
1780     //   Sample Rate / Count    during sys init, info or decode = Unknown / 0
1781     //
1783     if (apply < 0) 
1784     {
1785         pAstCfg->xStr[z].pAudioFrame->channelConfigurationRequest.legacy = PAF_CC_UNKNOWN;
1786         pAstCfg->xStr[z].pAudioFrame->channelConfigurationStream.legacy = PAF_CC_UNKNOWN;
1787     }
1788     else 
1789     {
1790         pAstCfg->xStr[z].pAudioFrame->channelConfigurationRequest.legacy = PAF_CC_NONE;
1791         pAstCfg->xStr[z].pAudioFrame->channelConfigurationStream.legacy = PAF_CC_NONE;
1792     }
1794     if (apply < 1) 
1795     {
1796         pAstCfg->xStr[z].pAudioFrame->sampleRate = PAF_SAMPLERATE_UNKNOWN;
1797         pAstCfg->xStr[z].pAudioFrame->sampleCount = 0;
1798     }
1800     return 0;
1801 } //PAF_ASOT_initFrame1
1803 // -----------------------------------------------------------------------------
1804 // ASOT Selection Function - Output Device Selection
1805 //
1806 //   Name:      PAF_ASOT_selectDevices
1807 //   Purpose:   Audio Stream Output Task Function for selecting the devices used
1808 //              for output.
1809 //   From:      audioStream1Task or equivalent
1810 //   Uses:      See code.
1811 //   States:    x
1812 //   Return:    Error number in standard form (0 on success).
1813 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
1814 //              * State information as per parent.
1815 //
1816 Int
1817 PAF_ASOT_selectDevices(
1818     const PAF_ASOT_Params *pP, 
1819     const PAF_ASOT_Patchs *pQ, 
1820     PAF_ASOT_Config *pAsotCfg
1823     PAF_AST_Config *pAstCfg;
1824     Int as;                     /* Audio Stream Number (1, 2, etc.) */
1825     Int z;                      /* input/output counter */
1826     Int errno = 0;              /* error number */
1827     Int errme;                  /* error number, local */
1828     Int device;
1830     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
1831     as = pAstCfg->as;
1832     (void)as;  // clear compiler warning in case not used with tracing disabled
1834     // Select output devices
1835     for (z=OUTPUT1; z < OUTPUTN; z++) 
1836     {
1837         if ((device = pAstCfg->xOut[z].outBufStatus.sioSelect) >= 0) 
1838         {
1839             TRACE_VERBOSE2("PAF_ASOT_selectDevices: AS%d: output device %d selecting ...", as+z, device);
1841             /* check for valid index into device array */
1842             if (device >= pQ->devout->n)
1843             {
1844                 device = 0; /* treat as device None */
1845             }
1847             errme = pP->fxns->deviceSelect(&pAstCfg->xOut[z].hTxSio, SIO_OUTPUT, 
1848                 HEAP_ID_OUTBUF, (Ptr)pQ->devout->x[device]);
1849             if (errme)
1850             {
1851                 TRACE_VERBOSE2("PAF_ASOT_selectDevices: errme 0x%x, errno 0x%x", errme, errno);
1852                 if (!errno)
1853                 {
1854                     errno = ASPERR_DEVOUT + errme;
1855                 }
1856                 pAstCfg->xOut[z].outBufStatus.sioSelect = 0x80;
1857             }
1858             else 
1859             {
1860                 Int zE;
1862                 pAstCfg->xOut[z].outBufStatus.sioSelect = device | 0x80;
1863                 // register outBufStatus and encodeStatus pointers with output devices
1864                 // This enables proper IEC encapsulation.
1865                 if (pAstCfg->xOut[z].hTxSio) 
1866                 {
1867                     // set max # of output buffers (use override if necessary)
1868                     if (pAstCfg->xOut[z].outBufStatus.maxNumBufOverride == 0)
1869                     {
1870                         SIO_ctrl(pAstCfg->xOut[z].hTxSio, PAF_SIO_CONTROL_SET_MAX_NUMBUF,
1871                             (Arg)pP->poutNumBufMap[z]->maxNumBuf);
1872                     }
1873                     else
1874                     {
1875                         SIO_ctrl(pAstCfg->xOut[z].hTxSio, PAF_SIO_CONTROL_SET_MAX_NUMBUF,
1876                             (Arg)pAstCfg->xOut[z].outBufStatus.maxNumBufOverride);
1877                     }
1879                     // register PAF_SIO_IALG object address
1880                     SIO_ctrl(pAstCfg->xOut[z].hTxSio, PAF_SIO_CONTROL_SET_IALGADDR,
1881                         (Arg)pAstCfg->xOut[z].outChainData.head->alg);
1882                     SIO_ctrl(pAstCfg->xOut[z].hTxSio, PAF_SIO_CONTROL_SET_BUFSTATUSADDR, 
1883                         (Arg)&pAstCfg->xOut[z].outBufStatus);
1884                     for (zE=ENCODE1; zE < ENCODEN; zE++) 
1885                     {
1886                         if (pP->outputsFromEncodes[zE] == z) 
1887                         {
1888                             SIO_ctrl(pAstCfg->xOut[z].hTxSio, 
1889                                 PAF_SIO_CONTROL_SET_ENCSTATUSADDR, 
1890                                 (Arg)&pAstCfg->xEnc[zE].encodeStatus);
1891                             break;
1892                         }
1893                     }
1894                 }
1895             }
1896         }
1898 /* No need to start-clocks here, since only selecting the device. */
1899 #if 0
1900         // if device selected and valid then enable stat tracking if
1901         // required and start clocking
1902         if ((pAstCfg->xOut[z].outBufStatus.sioSelect < 0) && (pAstCfg->xOut[z].hTxSio)) 
1903         {
1904             TRACE_VERBOSE0("PAF_ASOT_selectDevices: start SIO clocks");
1905             errme = SIO_ctrl(pAstCfg->xOut[z].hTxSio, PAF_SIO_CONTROL_OUTPUT_START_CLOCKS, 0);
1906             if (errme)
1907             {
1908                 TRACE_VERBOSE2("PAF_ASOT_selectDevices: errme 0x%x, errno 0x%x", errme, errno);
1909                 SIO_idle(pAstCfg->xOut[z].hTxSio);
1910                 if (!errno)
1911                 {
1912                     errno = ASPERR_DEVOUT + errme;
1913                 }
1914             }
1915         }
1916 #endif
1917     }
1919     return errno;
1920 } //PAF_ASOT_selectDevices
1923 // -----------------------------------------------------------------------------
1924 // ASOT Processing Function - Decode Processing
1925 //
1926 //   Name:      PAF_ASOT_decodeProcessing
1927 //   Purpose:   Audio Stream Output Task Function for processing audio data.
1928 //
1929 Int
1930 PAF_ASOT_decodeProcessing(
1931     const PAF_ASOT_Params *pP, 
1932     const PAF_ASOT_Patchs *pQ, 
1933     PAF_ASOT_Config *pAsotCfg 
1936     PAF_AST_Config *pAstCfg;
1937     Int errno;                          /* error number */
1938     Int getVal;
1939     enum { INIT, STREAM, ENCODE, FINAL, QUIT, OUT_SIO_UPDATE } state;
1940     state = INIT;
1941     errno = 0; /* error number */
1942     Int frame; // (***) FL: formerly -- decoder input frame count
1943     Int block; // decoder output block count / input frame
1944     Int outSioUpdate;
1945     
1946     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
1948     for (;;) 
1949     {
1950         //
1951         // Check forward (ASIT) error here, TBD
1952         //
1953         
1954         // If writeDECCommandRestart issued, force exit the statemachine
1955         if (gCommandOutputTask_SYNC) {
1956             TRACE_VERBOSE1("PAF_ASOT_decodeProcessing: writeDECCommandRestart issued in state=0x%x ... exiting core loop", state);
1957             errno = ASOP_DP_FORWARD_ERR;
1958             break;
1959         }
1961         // Check if any change in output SIO, e.g. from Output shortcut.
1962         // Changes will break FSM and allow Output reconfiguration.
1963         errno = checkOutSio(pP, pAsotCfg, &outSioUpdate);
1964         if (errno < 0)
1965         {
1966             TRACE_TERSE1("PAF_ASOT_decodeProcessing: checkOutSio returned errno = 0x%04x", errno);
1967             break;
1968         }
1969         else if (outSioUpdate)
1970         {
1971             TRACE_VERBOSE0("PAF_ASOT_decodeProcessing: Change in Output SIO selection");
1972             state = OUT_SIO_UPDATE;
1973         }
1974         
1975         // Process commands (encode)
1976         getVal = pP->fxns->encodeCommand(pP, pQ, pAsotCfg);
1977         if (getVal) 
1978         {
1979             /* ignore */;
1980         }
1982         // Process state (decode)
1983         switch (state) 
1984         {
1985             case INIT: // initial state
1986                 gAsopInitCnt++;
1987                 Log_info0("TaskAsop: state=INIT");
1988             
1989                 frame = 0;
1990                 block = 0;
1992 #if 0 // FL: moved to PAF_ASOT_initOutProc()
1993                 // Reset audio frame pointers to original values
1994                 // (may be needed if error occurred).
1995                 resetAfPointers(pP, pAstCfg->xStr);
1996                 // Reset audio frame meta data elements
1997                 resetAfMetadata(pP, pAstCfg->xStr);
1998 #endif
2000                 errno = pP->fxns->decodeInit(pP, pQ, pAsotCfg);
2001                 if (errno)
2002                 {
2003                     TRACE_VERBOSE1("PAF_ASOT_decodeProcessing: INIT, errno 0x%x.  break after decodeInit", errno);
2004                     errno = ASOP_DP_DECINIT_ERR;
2005                     break;
2006                 }
2007                 
2008                 //
2009                 // Setup output: setCheckRateX, start output
2010                 //
2011                 // Establish secondary timing
2012                 errno = pP->fxns->decodeInfo1(pP, pQ, pAsotCfg, frame, block);
2013                 if (errno)
2014                 {
2015                     TRACE_VERBOSE1("PAF_ASOT_decodeProcessing: INIT, errno 0x%x.  break after decodeInfo1", errno);
2016                     break;
2017                 }
2018                 
2019                 TRACE_VERBOSE0("PAF_ASOT_decodeProcessing: state: INIT->STREAM");                
2020                 state = STREAM;
2021                 continue;
2022                 
2023             case STREAM: // stream state
2024                 gAsopStreamCnt++;
2025                 Log_info0("TaskAsop: state=STREAM");
2027                 errno = pP->fxns->decodeStream(pP, pQ, pAsotCfg, frame, block);
2028                 if (errno)
2029                 {
2030                     TRACE_TERSE1("PAF_ASOT_decodeProcessing: state: STREAM.  decodeStream err 0x%x", errno);
2031                     errno = ASOP_DP_DECSTREAM_ERR;
2032                     break;
2033                 }
2035                 TRACE_VERBOSE0("PAF_ASOT_decodeProcessing: state: STREAM->ENCODE");
2036                 state = ENCODE;
2037                 continue;
2038                 
2039             case ENCODE: // encode state
2040                 gAsopEncodeCnt++;
2041                 Log_info0("TaskAsop: state=ENCODE");
2043                 errno = pP->fxns->decodeEncode(pP, pQ, pAsotCfg, frame, block);
2044                 if (errno)
2045                 {
2046                     TRACE_TERSE1("PAF_ASOT_decodeProcessing: state: ENCODE.  decodeEncode err 0x%x", errno);
2047                     errno = ASOP_DP_DECENC_ERR;
2048                     break;
2049                 }
2050                 
2051                 // Measure cycles in output processing loop.
2052                 // Only measures cycles spent in loop.
2053                 pfpEnd(PFP_ID_ASOT_1, PFP_FINISH_MEAS);
2054                 gNumPfpAsot1--;
2055                 pfpBegin(PFP_ID_ASOT_1, pAsotCfg->taskHandle);
2056                 gNumPfpAsot1++;
2057                 
2058                 // (***) FL: do we need this? 
2059                 //       AF pointers come from CB read, any resets occur in Decoder AF.
2060                 //
2061                 // Reset audio frame pointers to original values
2062                 // (may have been adjusted by ARC or the like).
2063                 resetAfPointers(pP, pAstCfg->xStr);
2065                 // (***) FL: update output (setCheckRateX)
2066                 //           Contained in INFO2 in combined FSM.
2067                 errno = pP->fxns->decodeInfo2(pP, pQ, pAsotCfg, frame, block);
2068                 if (errno)
2069                 {
2070                     TRACE_TERSE1("PAF_ASOT_decodeProcessing: ENCODE break on decodeInfo2. errno 0x%x", errno);
2071                     errno = ASOP_DP_DECINFO2_ERR;
2072                     break;
2073                 }
2075                 block++;
2076                 TRACE_VERBOSE0("PAF_ASOT_decodeProcessing: state: ENCODE->FINAL");
2077                 state = FINAL;
2078                 continue;
2079                 
2080             case FINAL:
2081                 gAsopFinalCnt++;
2082                 Log_info0("TaskAsop: state=FINAL");
2083                 
2084                 //
2085                 // (***) FL: this needs to be fixed.
2086                 //       (1) Only require selected Output to be in this FSM
2087                 //           => Dec Status checks aren't valid, 
2088                 //              will probably always exit FSM if only Output running
2089                 //       (2) Checking Dec Status info asych to input events (maybe ok)
2090                 //
2091                 // Check for final frame, and if indicated:
2092                 // - Update audio flag to cause output buffer flush rather than
2093                 //   the default truncate in "complete" processing.
2094                 // - Exit state machine to "complete" processing.
2095 #if 0
2096                 if (pP->fxns->decodeFinalTest(pP, pQ, pAsotCfg, frame, block)) 
2097                 {
2098                     for (z=OUTPUT1; z < OUTPUTN; z++)
2099                     {
2100                         if ((pAstCfg->xOut[z].outBufStatus.audio & 0x0f) == PAF_OB_AUDIO_SOUND)
2101                         {
2102                             TRACE_VERBOSE0("PAF_ASOT_outputProcessing: state: FINAL: SOUND -> QUIET");
2103                             pAstCfg->xOut[z].outBufStatus.audio++; // SOUND -> QUIET
2104                         }
2105                     }
2106                     break;
2107                 }
2108 #endif
2109                 errno = pP->fxns->decodeFinalTest(pP, pQ, pAsotCfg, frame, block);
2110                 if (errno < 0)
2111                 {
2112                     TRACE_TERSE1("PAF_ASOT_decodeProcessing: DECODE FINAL break. errno 0x%x", errno);
2113                     errno = ASOP_DP_DECFINALTEST_ERR;
2114                     break;
2115                 }
2116                 else if (errno == ASOP_DP_CB_DRAINED)
2117                 {
2118                     // EOS, exit normally
2119                     TRACE_TERSE1("PAF_ASOT_decodeProcessing: DECODE FINAL normal exit. errno 0x%x", errno);
2120                     errno = ASOP_DP_SOK;
2121                     break;
2122                 }
2124                 TRACE_VERBOSE0("PAF_ASOT_decodeProcessing: state: FINAL->STREAM");
2125                 state = STREAM;
2126                 continue;
2127                 
2128             case OUT_SIO_UPDATE:
2129                 gAsopOutSioUpdateCnt++;
2130                 Log_info0("TaskAsop: state=OUT_SIO_UPDATE");
2132                 TRACE_VERBOSE0("PAF_ASOT_decodeProcessing: state: OUT_SIO_UPDATE");
2133                 errno = ASOP_DP_OUT_SIO_UPDATE;
2134                 break;
2135                 
2136             case QUIT:
2137                 gAsopQuitCnt++;
2138                 Log_info0("TaskAsop: state=QUIT");
2140                 TRACE_VERBOSE0("PAF_ASOT_decodeProcessing: state: QUIT");
2141                 errno = ASPERR_QUIT;
2142                 break;
2144             default: // unknown state
2145                 // Unknown:
2146                 // - Set error number registers.
2147                 // - Exit state machine to "complete" processing.
2149                 TRACE_TERSE1("PAF_ASOT_decodeProcessing: state: unknown, 0x%x", state);
2150                 errno = ASPERR_UNKNOWNSTATE;
2151                 break;
2153         }  // End of switch (state).
2154         
2155         TRACE_VERBOSE0("PAF_ASOT_decodeProcessing: Calling decode complete");
2156         if (pP->fxns->decodeComplete(pP, pQ, pAsotCfg, NULL, frame, block))
2157         {
2158             /* ignored? */;
2159         }
2160         
2161         //pfpEnd(PFP_ID_ASOT_1, PFP_FINISH_MEAS); // PFP end -- outside of PFP for errors, EOS, or Output SIO change
2162         //gNumPfpAsot1--;
2163         
2164         //return errno;
2165         break;        
2166     } // End of for (;;)
2167         
2168     pfpEnd(PFP_ID_ASOT_1, PFP_FINISH_MEAS); // PFP end -- outside of PFP for errors, EOS, or Output SIO change
2169     gNumPfpAsot1--;
2170         
2171     return errno;
2174 // -----------------------------------------------------------------------------
2175 // ASOT Decoding Function - Encode Command Processing
2176 //
2177 //   Name:      PAF_ASOT_encodeCommand
2178 //   Purpose:   Decoding Function for processing Encode Commands.
2179 //   From:      AST Parameter Function -> decodeProcessing
2180 //   Uses:      See code.
2181 //   States:    x
2182 //   Return:    0.
2183 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
2184 //              * Command execution.
2185 //              * SIO control errors.
2186 //              * Error number macros.
2187 //
2188 Int
2189 PAF_ASOT_encodeCommand(
2190     const PAF_ASOT_Params *pP, 
2191     const PAF_ASOT_Patchs *pQ, 
2192     PAF_ASOT_Config *pAsotCfg
2195     PAF_AST_Config *pAstCfg;
2196     Int as;                     /* Audio Stream Number (1, 2, etc.) */
2197     Int z;                      /* encode counter */
2198     Int errno = 0;              /* error number */
2199     Int zO, zS;
2202     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
2203     as = pAstCfg->as;
2205     for (z=ENCODE1; z < ENCODEN; z++) 
2206     {
2207         zO = pP->outputsFromEncodes[z];
2208         zS = pP->streamsFromEncodes[z];
2209         if (! (pAstCfg->xEnc[z].encodeStatus.command2 & 0x80)) 
2210         {
2211             switch (pAstCfg->xEnc[z].encodeStatus.command2) 
2212             {
2213                 case 0: // command none - process
2214                     pAstCfg->xEnc[z].encodeStatus.command2 |= 0x80;
2215                     break;
2216                 case 1: // mute command
2217                     TRACE_VERBOSE2("AS%d: PAF_ASOT_encodeCommand: encode command mute (0x%02x)", as+zS, 1);
2218                     if ((pAstCfg->xOut[zO].outBufStatus.audio & 0x0f) != PAF_OB_AUDIO_QUIET
2219                         && pAstCfg->xOut[zO].hTxSio
2220                         && (errno = SIO_ctrl (pAstCfg->xOut[zO].hTxSio, PAF_SIO_CONTROL_MUTE, 0))) 
2221                     {
2222                         errno = (errno & 0xff) | ASPERR_MUTE;
2223                         /* convert to sensical errno */
2224                         TRACE_TERSE1("AS%d: PAF_ASOT_encodeCommand: SIO control failed (mute)", as+zS);
2225                         TRACE_TERSE2("AS%d: PAF_ASOT_encodeCommand: errno = 0x%04x <ignored>", as+zS, errno);
2226                     }
2227                     else 
2228                     {
2229                         pAstCfg->xOut[zO].outBufStatus.audio |= PAF_OB_AUDIO_MUTED;
2230                     }
2231                     pAstCfg->xEnc[z].encodeStatus.command2 |= 0x80;
2232                     break;
2233                 case 2: // unmute command
2234                     TRACE_VERBOSE2("AS%d: PAF_ASOT_encodeCommand: encode command unmute (0x%02x)", as+zS, 2);
2235                     if ((pAstCfg->xOut[zO].outBufStatus.audio & 0x0f) != PAF_OB_AUDIO_QUIET
2236                         && pAstCfg->xOut[zO].hTxSio
2237                         && (errno = SIO_ctrl (pAstCfg->xOut[zO].hTxSio, PAF_SIO_CONTROL_UNMUTE, 0))) 
2238                     {
2239                         errno = (errno & 0xff) | ASPERR_MUTE;
2240                         /* convert to sensical errno */
2241                         TRACE_TERSE1("AS%d: PAF_ASOT_encodeCommand: SIO control failed (unmute)", as+zS);
2242                         TRACE_TERSE2("AS%d: PAF_ASOT_encodeCommand: errno = 0x%04x <ignored>", as+zS, errno);
2243                     }
2244                     else 
2245                     {
2246                         pAstCfg->xOut[zO].outBufStatus.audio &= ~PAF_OB_AUDIO_MUTED;
2247                     }
2248                     pAstCfg->xEnc[z].encodeStatus.command2 |= 0x80;
2249                     break;
2250                 default: // command unknown - ignore
2251                     break;
2252             }
2253         }
2254     }
2256     ERRNO_RPRT (TaskAsop, errno);
2258     return 0;
2259 } //PAF_ASOT_encodeCommand
2261 //debug -- allow dynamic config
2262 //Int16 gStrFrameLen=DEF_STR_FRAME_LEN; // stream frame length (PCM samples)
2264 //   Purpose:   Decoding Function for reinitializing the decoding process.
2265 Int
2266 PAF_ASOT_decodeInit(
2267     const PAF_ASOT_Params *pP, 
2268     const PAF_ASOT_Patchs *pQ, 
2269     PAF_ASOT_Config *pAsotCfg
2272     //PAF_AST_Config *pAstCfg;
2273     PAF_AST_DecOpCircBufCtl *pCbCtl;    /* Decoder output circular buffer control */
2274     //Int as;                             /* Audio Stream Number (1, 2, etc.) */
2275     Int z;                              /* decode/encode counter */
2276     Int errno;                          /* error number */
2277     //Int zO, zS;
2279     //pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
2280     //as = pAstCfg->as;
2282     pCbCtl = &pAsotCfg->pAspmCfg->decOpCircBufCtl; // get pointer to circular buffer control
2284     for (z=DECODE1; z < DECODEN; z++)
2285     {
2286         // Initialize decoder output circular buffer for stream reads
2287         //errno = cbInitStreamRead(pCbCtl, z, gStrFrameLen);
2288         errno = cbInitStreamRead(pCbCtl, z);
2289         if (errno)
2290         {
2291             TRACE_TERSE1("PAF_ASOT_decodeInit:cbInitStreamRead() error=%d", errno);
2292             SW_BREAKPOINT; // debug
2293             return errno;
2294         }
2295         
2296         // Start decoder output circular buffer reads
2297         errno = cbReadStart(pCbCtl, z);
2298         if (errno)
2299         {
2300             TRACE_TERSE1("PAF_ASOT_decodeInit:cbReadStart() error=%d", errno);
2301             SW_BREAKPOINT; // debug
2302             return errno;
2303         }
2304         
2305         gCbReadAfErr=0;         // reset read circular buffer error count
2306         gDecOpCbRdAfUnd=0;      // reset decoder output circular buffer underflow count
2307         gMaxDecOpCbRdAfUnd=0;   // reset max decoder output circular buffer underflow count
2308         gMasterCbResetCnt=0;    // reset master circular buffer reset count
2310         // FL: debug, log circular buffer control variables
2311         cbLog(pCbCtl, z, 1, "PAF_ASOT_decodeInit:cbReadStart");
2312     }
2313     
2314 #if 0 // moved to PAF_ASOT_outputReset()
2315     // TODO: move this to start of this function so that it doesn't affect IO timing
2316     for (z=ENCODE1; z < ENCODEN; z++) 
2317     {
2318         zO = pP->outputsFromEncodes[z];
2319         zS = pP->streamsFromEncodes[z];
2320         if (pAstCfg->xOut[zO].hTxSio && pAstCfg->xEnc[z].encodeStatus.mode) 
2321         {
2322             Int select = pAstCfg->xEnc[z].encodeStatus.select;
2323             ALG_Handle encAlg = pAstCfg->xEnc[z].encAlg[select];
2324             ENC_Handle enc = (ENC_Handle )encAlg;
2325             TRACE_VERBOSE1("AS%d: PAF_ASOT_decodeInit: initializing encode", as+zS);
2326             if (encAlg->fxns->algActivate)
2327             {
2328                 encAlg->fxns->algActivate (encAlg);
2329             }
2330             if (enc->fxns->reset)
2331             {
2332                 errno = enc->fxns->reset(enc, NULL, 
2333                     &pAstCfg->xEnc[z].encodeControl, &pAstCfg->xEnc[z].encodeStatus);
2334                 if (errno)
2335                 {
2336                     return errno;
2337                 }
2338             }
2339         }
2340     }
2341 #endif
2342     
2343     return 0;
2346 // -----------------------------------------------------------------------------
2347 // ASOT Decoding Function - Info Processing, Initial
2348 //
2349 //   Name:      PAF_ASOT_decodeInfo1
2350 //   Purpose:   Decoding Function for processing information in a manner that
2351 //              is unique to initial frames of input data.
2352 //   From:      AST Parameter Function -> decodeProcessing
2353 //   Uses:      See code.
2354 //   States:    x
2355 //   Return:    Error number in standard or SIO form (0 on success).
2356 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
2357 //              * State information as per parent.
2358 //
2359 Int
2360 PAF_ASOT_decodeInfo1(
2361     const PAF_ASOT_Params *pP, 
2362     const PAF_ASOT_Patchs *pQ, 
2363     PAF_ASOT_Config *pAsotCfg, 
2364     Int frame, 
2365     Int block
2368     //PAF_AST_Config *pAstCfg;
2369     //Int z;                              /* decode/encode counter */
2370     Int errno;                          /* error number */
2372 #if 0 // moved to PAF_ASOT_outputInfo1()
2373     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
2375     // run the chain of ASP's on the stream.
2376     TRACE_VERBOSE0("PAF_ASOT_decodeInfo1: calling streamChainFunction.");
2377     errno = pP->fxns->streamChainFunction(pP, pQ, pAsotCfg, 
2378         PAF_ASP_CHAINFRAMEFXNS_RESET, 1, frame);
2379     if (errno)
2380     {
2381         TRACE_TERSE1("PAF_ASOT_decodeInfo1: streamChainFunction returns errno 0x%x ", errno);
2382         return errno;
2383     }
2385     TRACE_VERBOSE0("PAF_ASOT_decodeInfo1: calling enc->info.");
2386     for (z=ENCODE1; z < ENCODEN; z++) 
2387     {
2388         Int zO = pP->outputsFromEncodes[z];
2389         if (pAstCfg->xOut[zO].hTxSio && pAstCfg->xEnc[z].encodeStatus.mode) 
2390         {
2391             Int select = pAstCfg->xEnc[z].encodeStatus.select;
2392             ALG_Handle encAlg = pAstCfg->xEnc[z].encAlg[select];
2393             ENC_Handle enc = (ENC_Handle )encAlg;
2394             
2395             if (enc->fxns->info)
2396             {
2397                 errno = enc->fxns->info(enc, NULL,
2398                     &pAstCfg->xEnc[z].encodeControl, 
2399                     &pAstCfg->xEnc[z].encodeStatus);
2400                 if (errno)
2401                 {
2402                     TRACE_TERSE1("PAF_ASOT_decodeInfo1: info returns errno 0x%x ", errno);
2403                     return errno;
2404                 }
2405             }
2406         }
2407     }
2408 #endif    
2410     errno = pP->fxns->setCheckRateX(pP, pQ, pAsotCfg, 0);
2411     if (errno)
2412     {
2413         // ignore if rateX has changed since we haven't, but are about to,
2414         // start the output. If we didn't ignore this case then the state machine
2415         // would restart unnecessarily, e.g. in the case of SRC, resulting in
2416         // added latency.
2417         if (errno != ASPERR_INFO_RATECHANGE)
2418         {
2419             TRACE_TERSE1("PAF_ASOT_decodeInfo1: setCheckRateX returns errno 0x%x, not RATECHANGE", errno);
2420             return errno;
2421         }
2422         else
2423         {
2424             TRACE_TERSE0("PAF_ASOT_decodeInfo1: RATECHANGE returns RATECHANGE, ignoring");
2425         }
2426     }
2428     errno = pP->fxns->startOutput(pP, pQ, pAsotCfg);
2429     if (errno) 
2430     {
2431         if (errno == 0x105) 
2432         {
2433             TRACE_TERSE1("PAF_ASOT_decodeInfo1: startOutput returns RING BUFFER FULL (0x%x)", errno);
2434         }
2435         else
2436         {
2437             TRACE_TERSE1("PAF_ASOT_decodeInfo1: startOutput returns errno 0x%x", errno);
2438         }
2439         return errno;
2440     }
2441     
2442     return 0;
2445 // -----------------------------------------------------------------------------
2446 // ASOT Decoding Function - Info Processing, Subsequent
2447 //
2448 //   Name:      PAF_ASOT_decodeInfo2
2449 //   Purpose:   Decoding Function for processing information in a manner that
2450 //              is unique to frames of input data other than the initial one.
2451 //   From:      AST Parameter Function -> decodeProcessing
2452 //   Uses:      See code.
2453 //   States:    x
2454 //   Return:    Error number in standard form (0 on success).
2455 //   Trace:     None.
2456 //
2457 Int
2458 PAF_ASOT_decodeInfo2(
2459     const PAF_ASOT_Params *pP, 
2460     const PAF_ASOT_Patchs *pQ, 
2461     PAF_ASOT_Config *pAsotCfg, 
2462     Int frame, 
2463     Int block
2466     //PAF_AST_Config *pAstCfg;
2467     Int errno;
2469     
2470     //pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
2472     errno = pP->fxns->setCheckRateX (pP, pQ, pAsotCfg, 1);
2473     TRACE_VERBOSE1("PAF_ASOT_decodeInfo2: return 0x%x", errno);
2474     return errno;
2475 } //PAF_ASOT_decodeInfo2
2478 PAF_AST_DecOpCircBufStats gCbStats; // FL: debug
2479 // -----------------------------------------------------------------------------
2480 // ASOT Decoding Function - Stream Processing
2481 //
2482 //   Name:      PAF_ASOT_decodeStream
2483 //   Purpose:   Decoding Function for processing of audio frame data by the
2484 //              ASP Algorithms.
2485 //   From:      AST Parameter Function -> decodeProcessing
2486 //   Uses:      See code.
2487 //   States:    x
2488 //   Return:    Error number in standard form (0 on success).
2489 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
2490 //              * State information as per parent/child.
2491 //
2492 Int
2493 PAF_ASOT_decodeStream(
2494     const PAF_ASOT_Params *pP, 
2495     const PAF_ASOT_Patchs *pQ, 
2496     PAF_ASOT_Config *pAsotCfg, 
2497     Int frame, 
2498     Int block
2501     PAF_AST_Config *pAstCfg;
2502     PAF_AST_DecOpCircBufCtl *pCbCtl;    /* Decoder output circular buffer control */
2503     Int z;                              /* decode/stream counter */
2504     PAF_AudioFrame *pAfRd;
2505     Int cbErrno;
2506     //PAF_AST_DecOpCircBufStats cbStats;  /* circular buffer statistics */
2507     Int errno;
2510     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
2511     
2512     pCbCtl = &pAsotCfg->pAspmCfg->decOpCircBufCtl; // get pointer to circular buffer control
2513     
2514     for (z=DECODE1; z < DECODEN; z++) 
2515     {
2516         Int zS = pP->streamsFromDecodes[z];
2517         
2518         //
2519         // Read decoder output circular buffer
2520         //
2521         pAfRd = pAstCfg->xStr[zS].pAudioFrame;
2522         //GPIOSetOutput(GPIO_PORT_0, GPIO_PIN_106);       // debug
2523         cbErrno = cbReadAf(pCbCtl, z, pAfRd);
2524         //GPIOClearOutput(GPIO_PORT_0, GPIO_PIN_106);     // debug
2525         if ((cbErrno < 0) && 
2526             (cbErrno != ASP_DECOP_CB_AF_READ_UNDERFLOW) && 
2527             (cbErrno != ASP_DECOP_CB_PCM_READ_UNDERFLOW))
2528         {
2529             gCbReadAfErr++;
2530             TRACE_TERSE1("PAF_ASOT_decodeStream:cbReadAf() error=%d", cbErrno);
2531             //SW_BREAKPOINT; // debug
2532             return cbErrno;
2533         }
2535         // Handle underflows
2536         if ((cbErrno == ASP_DECOP_CB_AF_READ_UNDERFLOW) ||
2537             (cbErrno == ASP_DECOP_CB_PCM_READ_UNDERFLOW))
2538         {
2539             // (***) FL: Need to check behavior of cbReset().
2540             // Need to check behavior on exit/re-entry into Output processing.
2541             gDecOpCbRdAfUnd++; // increment circular buffer underflow count
2542             if (gDecOpCbRdAfUnd >= DEC_OP_CB_RDAF_UND_THR) 
2543             {
2544                 // Underflow count above threshold.
2545                 // (1) set max underflow count to threshold
2546                 // (2) reset underflow count
2547                 // (3) reset circular buffer
2548                 
2549                 gMaxDecOpCbRdAfUnd = DEC_OP_CB_RDAF_UND_THR; // update max underflow count
2550                 gDecOpCbRdAfUnd = 0; // reset underflow count
2552                 // Reset circular buffer
2553                 cbReset(pCbCtl, z);
2554                 gMasterCbResetCnt++; // increment master circular buffer reset count
2555                 Log_info0("ASOT:cbReset");
2556             
2557                 return cbErrno;
2558             }
2559         }
2560         else if ((cbErrno == ASP_DECOP_CB_SOK) && (gDecOpCbRdAfUnd > 0))
2561         {
2562             // No underflow detected.
2563             // update max underflow count,
2564             // reset underflow count
2565             
2566             // update max underflow count
2567             if (gDecOpCbRdAfUnd > gMaxDecOpCbRdAfUnd)
2568             {
2569                 gMaxDecOpCbRdAfUnd = gDecOpCbRdAfUnd;
2570             }
2571             gDecOpCbRdAfUnd = 0; // reset circular buffer underflow count
2572         }
2573         //Log_info0("PAF_ASOT_decodeStream:cbReadAf() complete.");
2574         //GPIOClearOutput(GPIO_PORT_0, GPIO_PIN_106);   // debug
2575         Log_info0("PAF_ASOT_decodeStream:cbReadAf() complete.");
2576         
2577 #if 0 // (***) FL: shows timing of CB read
2578             // (***) debug // B8
2579             {
2580                 static Uint8 toggleState = 0;
2581                 if (toggleState == 0)
2582                     GPIOSetOutput(GPIO_PORT_0, GPIO_PIN_106);
2583                 else
2584                     GPIOClearOutput(GPIO_PORT_0, GPIO_PIN_106);
2585                 toggleState = ~(toggleState);
2586             }
2587 #endif
2589         // debug, get circular buffer statistics
2590         //cbGetStats(pCbCtl, z, &cbStats);
2591         cbGetStats(pCbCtl, z, &gCbStats);
2593         // debug
2594         cbLog(pCbCtl, z, 1, "PAF_ASOT_decodeStream:cbReadAf");
2595         
2596 #if 0 // debug, capture audio frame
2597         if (capAfWrite(pAfRd, PAF_LEFT) != CAP_AF_SOK)
2598         {
2599             Log_info0("capAfWrite() error");
2600         }
2601 #endif
2602     }
2603             
2604     TRACE_VERBOSE0("PAF_ASOT_outputStream: calling streamChainFunction.");
2605     errno = pP->fxns->streamChainFunction(pP, pQ, pAsotCfg, 
2606         PAF_ASP_CHAINFRAMEFXNS_APPLY, 1, block);
2607     if (errno)
2608     {
2609         TRACE_TERSE1("PAF_ASOT_outputStream: streamChainFunction returns errno 0x%x ", errno);
2610         return errno;
2611     }
2613     return 0;
2615 } //PAF_ASOT_decodeStream
2617 // -----------------------------------------------------------------------------
2618 // ASOT Decoding Function - Encode Processing
2619 //
2620 //   Name:      PAF_ASOT_decodeEncode
2621 //   Purpose:   Decoding Function for processing of audio frame data by the
2622 //              Encode Algorithm.
2623 //   From:      AST Parameter Function -> decodeProcessing
2624 //   Uses:      See code.
2625 //   States:    x
2626 //   Return:    Error number in standard or SIO form (0 on success).
2627 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
2628 //              * State information as per parent.
2629 //
2630 Int
2631 PAF_ASOT_decodeEncode(
2632     const PAF_ASOT_Params *pP, 
2633     const PAF_ASOT_Patchs *pQ, 
2634     PAF_ASOT_Config *pAsotCfg, 
2635     Int frame, 
2636     Int block
2639     PAF_AST_Config *pAstCfg;
2640     Int as;                     /* Audio Stream Number (1, 2, etc.) */
2641     Int z;                      /* encode/output counter */
2642     Int errno;                  /* error number */
2643     Int zX, zE, zS;
2644     // debug
2645     //UInt32 curTime;
2647     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
2648     as = pAstCfg->as;
2650     // Await output buffers (but not first time)
2651     for (z=OUTPUT1; z < OUTPUTN; z++) 
2652     {
2653         // determine encoder associated with this output
2654         zE = z;
2655         for (zX = ENCODE1; zX < ENCODEN; zX++) 
2656         {
2657             if (pP->outputsFromEncodes[zX] == z) 
2658             {
2659                 zE = zX;
2660                 break;
2661             }
2662         }
2663         zS = pP->streamsFromEncodes[zE];
2665         if (pAstCfg->xOut[z].hTxSio) 
2666         {
2667             // update length (e.g. ARC may have changed)
2668             pAstCfg->xOut[z].outBufConfig.lengthofFrame = 
2669                 pAstCfg->xEnc[zE].encodeInStruct.pAudioFrame->sampleCount;
2670             TRACE_GEN2("PAF_ASOT_decodeEncode: AS%d: processing block %d -- idle", as+zS, block);
2671             //GPIOClearOutput(GPIO_PORT_0, GPIO_PIN_106);   // debug
2672             errno = SIO_reclaim(pAstCfg->xOut[z].hTxSio,(Ptr *) &pAstCfg->xOut[z].pOutBuf, NULL);
2673             //GPIOSetOutput(GPIO_PORT_0, GPIO_PIN_106);     // debug
2674             if (errno < 0)
2675             {
2676                 SIO_idle(pAstCfg->xOut[z].hTxSio);
2677                 TRACE_TERSE2("PAF_ASOT_decodeEncode: AS%d: SIO_reclaim returns error %d", as+zS, -errno);
2678                 return -errno; // SIO negates error codes
2679             }
2680             // TODO: use pC->xOut[z].pOutBuf in following ->encode call
2682 #if 0 // (***) FL: shows timing of Output Tx SIO reclaim
2683             // (***) debug // B8
2684             {
2685                 static Uint8 toggleState = 0;
2686                 if (toggleState == 0)
2687                     GPIOSetOutput(GPIO_PORT_0, GPIO_PIN_106);
2688                 else
2689                     GPIOClearOutput(GPIO_PORT_0, GPIO_PIN_106);
2690                 toggleState = ~(toggleState);
2691             }
2692 #endif            
2694             //
2695             // Simulate Tx SIO_reclaim() pend
2696             //
2697             //Semaphore_pend(semaphoreTxAudio, BIOS_WAIT_FOREVER);
2698             //curTime = Clock_getTicks();
2699             //System_printf("System time in TaskAsopFxn Tx audio = %lu\n", (ULong)curTime);
2700             //Log_info1("outputEncode():Tx SIO reclaim(), system time = %u", curTime);
2701             
2702             gAsopTxSioReclaimCnt++;
2703         }
2704         else 
2705         {
2706             TRACE_VERBOSE2("AS%d: PAF_ASOT_decodeEncode: processing block %d -- idle <ignored>", as+zS, block);
2707         }
2708     }
2710     // Encode data
2711     for (z=ENCODE1; z < ENCODEN; z++) 
2712     {
2713         Int zO = pP->outputsFromEncodes[z];
2714         Int zS = pP->streamsFromEncodes[z];
2715         (void)zS; // clear compiler warning in case not used with tracing disabled
2716         if (pAstCfg->xOut[zO].hTxSio && pAstCfg->xEnc[z].encodeStatus.mode) 
2717         {
2718             Int select = pAstCfg->xEnc[z].encodeStatus.select;
2719             ALG_Handle encAlg = pAstCfg->xEnc[z].encAlg[select];
2720             ENC_Handle enc = (ENC_Handle )encAlg;
2721             if (select != pAstCfg->xEnc[z].encodeControl.encActive)
2722             {
2723                 pAstCfg->xEnc[z].encodeControl.encActive = select;
2724                 TRACE_TERSE0("PAF_ASOT_decodeEncode: return error");
2725                 return (-1);
2726             }
2727             TRACE_GEN2("AS%d: PAF_ASOT_decodeEncode: processing block %d -- encode", as+zS, block);
2729             // (MID 1933) temp. workaround for PCE2
2730             pAstCfg->xEnc[z].encodeInStruct.pAudioFrame->data.nChannels = PAF_MAXNUMCHAN;
2732           /*
2733           #if (CURRENT_TRACE_MASK & TRACE_MASK_DATA)
2734             {
2735                 PAF_AudioFrame *pAudioFrame = pC->xEnc[z].encodeInStruct.pAudioFrame;
2736                 int *wp;
2737                 wp = (int*)pAudioFrame->data.sample[0];
2738                 TRACE_DATA((&TR_MOD, "as1-f2: AS%d PAF_ASOT_outputEncode: encoding from ch 0 0x%x. line %d", z, wp, __LINE__));
2739                 TRACE_DATA((&TR_MOD, "as1-f2: [0]: 0x%x, [16]: 0x%x, [99]: 0x%x (ch0)", wp[0], wp[16], wp[99]));
2740                 wp = (int*)pAudioFrame->data.sample[1];
2741                 TRACE_DATA((&TR_MOD, "as1-f2: PAF_ASOT_outputEncode: encoding from ch 1 0x%x. line %d", wp, __LINE__));
2742                 TRACE_DATA((&TR_MOD, "as1-f2: [0]: 0x%x, [16]: 0x%x, [99]: 0x%x (ch1)", wp[0], wp[16], wp[99]));
2743                 wp = (int*)pAudioFrame->data.sample[2];
2744                 TRACE_DATA((&TR_MOD, "as1-f2: PAF_ASOT_outputEncode: encoding from ch 2 0x%x. line %d", wp, __LINE__));
2745                 TRACE_DATA((&TR_MOD, "as1-f2: [0]: 0x%x, [16]: 0x%x, [99]: 0x%x (ch2)", wp[0], wp[16], wp[99]));
2746             }
2747           #endif
2748           */
2750             if (enc->fxns->encode)
2751             {
2752                 pAstCfg->xEnc[z].encodeOutStruct.bypassFlag =
2753                         pP->z_pEncodeStatus[z]->encBypass;
2754                 errno = enc->fxns->encode(enc, NULL, 
2755                     &pAstCfg->xEnc[z].encodeInStruct, 
2756                     &pAstCfg->xEnc[z].encodeOutStruct);
2757                 if (errno)
2758                 {
2759                     if (errno != PCEERR_OUTPUT_POINTERNULL)
2760                     {
2761                         TRACE_TERSE1("PAF_ASOT_decodeEncode: return error %d line %d", errno);
2762                         return errno;
2763                     }
2764                 }
2765             /*  #if (CURRENT_TRACE_MASK & TRACE_MASK_DATA)
2766                 else
2767                 {
2768                     int *wp = (int*)pC->xOut[z].pOutBuf->pntr.pVoid;
2769                     TRACE_DATA((&TR_MOD, "as1-f2: PAF_ASOT_outputEncode: encoded to 0x%x. line %d", wp, __LINE__));
2770                     TRACE_DATA((&TR_MOD, "as1-f2: [0]: 0x%x, [16]: 0x%x, [99]: 0x%x", wp[0], wp[16], wp[99]));
2771                 }
2772               #endif
2773               */
2774             }
2775         }
2776         else 
2777         {
2778             TRACE_VERBOSE2("PAF_ASOT_decodeEncode: AS%d: processing block %d -- encode <ignored>",
2779                 as+pP->streamsFromEncodes[z], block);
2780         }
2781     }
2783     // Transmit data
2784     for (z=OUTPUT1; z < OUTPUTN; z++) 
2785     {
2786         // determine encoder associated with this output
2787         zE = z;
2788         for (zX = ENCODE1; zX < ENCODEN; zX++) 
2789         {
2790             if (pP->outputsFromEncodes[zX] == z) 
2791             {
2792                 zE = zX;
2793                 break;
2794             }
2795         }
2796         zS = pP->streamsFromEncodes[zE];
2798         if (pAstCfg->xOut[z].hTxSio) 
2799         {
2800             TRACE_GEN2("PAF_ASOT_decodeEncode: AS%d: processing block %d -- output", as+zS, block);
2801             //GPIOSetOutput(GPIO_PORT_0, GPIO_PIN_106);       // debug
2802             errno = SIO_issue(pAstCfg->xOut[z].hTxSio, 
2803                 &pAstCfg->xOut[z].outBufConfig, sizeof (pAstCfg->xOut[z].outBufConfig), 0);
2804             //GPIOClearOutput(GPIO_PORT_0, GPIO_PIN_106);     // debug
2805             if (errno)
2806             {
2807                 SIO_idle(pAstCfg->xOut[z].hTxSio);
2808                 if (errno == 0x105)     // 0x105 == RINGIO_EBUFFULL
2809                 {
2810 //                    statStruct_LogFullRing(STATSTRUCT_AS1_F2);
2811                     TRACE_TERSE1("PAF_ASOT_decodeEncode: SIO_idle returned RINGIO_EBUFFULL (0x%x)", errno);
2812                 }
2813                 if (errno > 0)
2814                 {
2815                     TRACE_TERSE1("PAF_ASOT_decodeEncode: return error 0x%x line %d", errno);
2816                     return (ASPERR_ISSUE + (z << 4));
2817                 }
2818                 else if (errno < 0)
2819                 {
2820                     TRACE_TERSE1("PAF_ASOT_decodeEncode: return neg error 0x%x line %d", -errno);
2821                     return -errno; // SIO negates error codes
2822                 }
2823             }
2824             if (errno > 0)
2825             {
2826                 return (ASPERR_ISSUE + (z << 4));
2827             }
2828             else if (errno < 0)
2829             {
2830                 return -errno; // SIO negates error codes
2831             }
2832         }
2833         else 
2834         {
2835             TRACE_GEN2("PAF_ASOT_decodeEncode: AS%d: processing block %d -- output <ignored>", as+zS, block);
2836         }
2837     }
2839     return 0;
2840 } //PAF_ASOT_decodeEncode
2842 // -----------------------------------------------------------------------------
2843 // ASOT Decoding Function - Stream-Final Processing
2844 //
2845 //   Name:      PAF_ASOT_decodeComplete
2846 //   Purpose:   Decoding Function for terminating the decoding process.
2847 //   From:      AST Parameter Function -> decodeProcessing
2848 //   Uses:      See code.
2849 //   States:    x
2850 //   Return:    0.
2851 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
2852 //              * State information as per parent.
2853 //
2854 Int
2855 PAF_ASOT_decodeComplete(
2856     const PAF_ASOT_Params *pP, 
2857     const PAF_ASOT_Patchs *pQ, 
2858     PAF_ASOT_Config *pAsotCfg, 
2859     ALG_Handle decAlg[], 
2860     Int frame, 
2861     Int block
2864     PAF_AST_Config *pAstCfg;
2865     PAF_AST_DecOpCircBufCtl *pCbCtl;    /* Decoder output circular buffer control */
2866     Int as;                             /* Audio Stream Number (1, 2, etc.) */
2867     Int z;                              /* decode/encode counter */
2868     Int errno;                          /* error number */
2870     
2871     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
2872     as = pAstCfg->as;
2873     (void)as;  // clear compiler warning in case not used with tracing disabled
2875     pCbCtl = &pAsotCfg->pAspmCfg->decOpCircBufCtl; // get pointer to circular buffer control
2876     
2877     for (z=DECODE1; z < DECODEN; z++)
2878     {
2879         // Stop decoder output circular buffer reads
2880         errno = cbReadStop(pCbCtl, z);
2881         if (errno)
2882         {
2883             TRACE_TERSE1("PAF_ASOT_decodeComplete:cbReadStop() error=%d", errno);
2884             SW_BREAKPOINT; // FL: debug
2885             return errno;
2886         }
2887         // FL: debug
2888         cbLog(pCbCtl, z, 1, "PAF_ASOT_decodeComplete:cbReadStop");
2889     }
2890     
2891     pP->fxns->streamChainFunction(pP, pQ, pAsotCfg, PAF_ASP_CHAINFRAMEFXNS_FINAL, 0, frame);
2893     for (z=ENCODE1; z < ENCODEN; z++) 
2894     {
2895         Int zO = pP->outputsFromEncodes[z];
2896         if (pAstCfg->xOut[zO].hTxSio && pAstCfg->xEnc[z].encodeStatus.mode) 
2897         {
2898             Int select = pAstCfg->xEnc[z].encodeStatus.select;
2899             ALG_Handle encAlg = pAstCfg->xEnc[z].encAlg[select];
2900 #ifdef PAF_ASP_FINAL
2901             ENC_Handle enc = (ENC_Handle)encAlg;
2902 #endif /* PAF_ASP_FINAL */
2903             TRACE_VERBOSE1("PAF_ASOT_decodeComplete: AS%d: finalizing encode", as+z);
2904 #ifdef PAF_ASP_FINAL
2905             if (enc->fxns->final)
2906                 enc->fxns->final(enc, NULL, &pAstCfg->xEnc[z].encodeControl,
2907                                  &pAstCfg->xEnc[z].encodeStatus);
2908 #endif /* PAF_ASP_FINAL */
2909             if (encAlg->fxns->algDeactivate)
2910             {
2911                 encAlg->fxns->algDeactivate(encAlg);
2912             }
2913         }
2914         else 
2915         {
2916             TRACE_VERBOSE1("PAF_ASOT_decodeComplete: AS%d: finalizing encode <ignored>", as+z);
2917         }
2918     }
2920     // wait for remaining data to be output
2921     pP->fxns->stopOutput(pP, pQ, pAsotCfg);
2923     return 0;
2924 } //PAF_ASOT_decodeComplete
2926 // -----------------------------------------------------------------------------
2927 // ASOT Decoding Function Helper - SIO Driver Start
2928 //
2929 //   Name:      PAF_ASOT_startOutput
2930 //   Purpose:   Decoding Function for initiating output.
2931 //   From:      AST Parameter Function -> decodeInfo1
2932 //   Uses:      See code.
2933 //   States:    x
2934 //   Return:    Error number in standard or SIO form (0 on success).
2935 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
2936 //              * State information as per parent.
2937 //              * SIO control errors.
2938 //
2939 #define DEC_OUTNUMBUF_MAP(X) \
2940       pP->poutNumBufMap[z]->map[(X) >= pP->poutNumBufMap[z]->length ? 0 : (X)]
2942 Int
2943 PAF_ASOT_startOutput(
2944     const PAF_ASOT_Params *pP, 
2945     const PAF_ASOT_Patchs *pQ, 
2946     PAF_ASOT_Config *pAsotCfg
2947
2949     PAF_AST_Config *pAstCfg;
2950     Int as;                     /* Audio Stream Number (1, 2, etc.) */
2951     Int z;                      /* output counter */
2952     Int errno,nbufs, errme;            /* error number */
2953     Int zE, zS, zX;
2954     Int zMD;
2955     PAF_SIO_IALG_Obj    *pObj;
2956     PAF_SIO_IALG_Config *pAlgConfig;
2958     
2959     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
2960     as = pAstCfg->as;
2961     zMD = pAstCfg->masterDec;
2963     for (z=OUTPUT1; z < OUTPUTN; z++) 
2964     {
2965         if (pAstCfg->xOut[z].hTxSio) 
2966         {
2967             // determine associated encoder and stream
2968             zE = z;
2969             zS = z;
2970             for (zX = ENCODE1; zX < ENCODEN; zX++) 
2971             {
2972                 if (pP->outputsFromEncodes[zX] == z) 
2973                 {
2974                     zE = zX;
2975                     zS = pP->streamsFromEncodes[zE];
2976                     break;
2977                 }
2978             }
2980 // Need to Revisit: Starting Clocks here seems logical & also manages the McASP without spurious underruns .
2982 #if 1
2983             // if device selected and valid then enable stat tracking if
2984                         // required and start clocking
2985                         if ((pAstCfg->xOut[z].outBufStatus.sioSelect < 0) && (pAstCfg->xOut[z].hTxSio))
2986                         {
2987                                 TRACE_VERBOSE0("PAF_ASOT_startOutput: start SIO clocks");
2988                                 errme = SIO_ctrl(pAstCfg->xOut[z].hTxSio, PAF_SIO_CONTROL_OUTPUT_START_CLOCKS, 0);
2989                                 if (errno)
2990                                 {
2991                                         TRACE_VERBOSE2("PAF_ASOT_startOutput: errme 0x%x, errno 0x%x", errme, errno);
2992                                         SIO_idle(pAstCfg->xOut[z].hTxSio);
2993                                         if (!errno)
2994                                         {
2995                                                 errno = ASPERR_DEVOUT + errme;
2996                                         }
2997                                 }
2998                         }
2999 #endif
3000             // Set sample count so that DOB knows how much data to send
3001             pAstCfg->xOut[z].outBufConfig.lengthofFrame =
3002                 pAstCfg->xEnc[zE].encodeInStruct.pAudioFrame->sampleCount;
3004             if (pAstCfg->xOut[z].outBufStatus.markerMode == PAF_OB_MARKER_ENABLED) 
3005             {
3006                 pObj = (PAF_SIO_IALG_Obj *) pAstCfg->xOut[z].outChainData.head->alg;
3007                 pAlgConfig = &pObj->config;
3008                 memset(pAstCfg->xOut[z].outBufConfig.base.pVoid, 0xAA, 
3009                     pAlgConfig->pMemRec[0].size);
3010             }
3012             // The index to DEC_OUTNUMBUF_MAP will always come from the primary/master
3013             // decoder. How should we handle the sourceProgram for multiple decoders?
3014             // Override as needed
3015             nbufs = DEC_OUTNUMBUF_MAP(pAstCfg->xDec[zMD].decodeStatus.sourceProgram);
3016             if (pAstCfg->xOut[z].outBufStatus.numBufOverride[pAstCfg->xDec[zMD].decodeStatus.sourceProgram] > 0)
3017             {
3018                 nbufs = pAstCfg->xOut[z].outBufStatus.numBufOverride[pAstCfg->xDec[zMD].decodeStatus.sourceProgram];
3019             }
3020             SIO_ctrl(pAstCfg->xOut[z].hTxSio, PAF_SIO_CONTROL_SET_NUMBUF, nbufs);
3022             if (errno = SIO_issue(pAstCfg->xOut[z].hTxSio,
3023                 &pAstCfg->xOut[z].outBufConfig, sizeof(pAstCfg->xOut[z].outBufConfig), 0)) 
3024             {
3025                 SIO_idle(pAstCfg->xOut[z].hTxSio);
3026                 TRACE_TERSE2("PAF_ASOT_startOutput: AS%d: SIO_issue failed (0x%x)", as+zS, errno);
3027                 return errno;
3028             }
3030             if (!(pAstCfg->xOut[z].outBufStatus.audio & 0xf0) && 
3031                 (errno =  SIO_ctrl (pAstCfg->xOut[z].hTxSio, PAF_SIO_CONTROL_UNMUTE, 0))) 
3032             {
3033                 errno = (errno & 0xff) | ASPERR_MUTE;
3034                 /* convert to sensical errno */
3035                 TRACE_TERSE2("as1-f2: PAF_ASOT_startOutput: AS%d: SIO control failed (unmute) 0x%x", as+zS, errno);
3036                 return (errno);
3037             }
3038             else
3039             {
3040                 pAstCfg->xOut[z].outBufStatus.audio
3041                     = (pAstCfg->xOut[z].outBufStatus.audio & 0xf0) | PAF_OB_AUDIO_SOUND;                
3042             }
3044             TRACE_VERBOSE1("PAF_ASOT_startOutput: AS%d: output started", as+zS);
3045         }
3046     }
3048     return 0;
3049 } //PAF_ASOT_startOutput
3051 // -----------------------------------------------------------------------------
3052 // ASOT Decoding Function Helper - SIO Driver Stop
3053 //
3054 //   Name:      PAF_ASOT_stopOutput
3055 //   Purpose:   Decoding Function for terminating output.
3056 //   From:      AST Parameter Function -> decodeProcessing
3057 //              AST Parameter Function -> decodeComplete
3058 //   Uses:      See code.
3059 //   States:    x
3060 //   Return:    Error number in standard or SIO form (0 on success).
3061 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
3062 //              * SIO control errors.
3063 //
3064 Int
3065 PAF_ASOT_stopOutput(
3066     const PAF_ASOT_Params *pP, 
3067     const PAF_ASOT_Patchs *pQ, 
3068     PAF_ASOT_Config *pAsotCfg
3071     PAF_AST_Config *pAstCfg;
3072     Int as;                     /* Audio Stream Number (1, 2, etc.) */
3073     Int z;                      /* output counter */
3074     Int errno = 0, getVal;
3075     Int zS, zX;
3076     PAF_SIO_IALG_Obj    *pObj;
3077     PAF_SIO_IALG_Config *pAlgConfig;
3079     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
3080     as = pAstCfg->as;
3081     (void)as;  // clear compiler warning in case not used with tracing disabled
3083     for (z=OUTPUT1; z < OUTPUTN; z++) 
3084     {
3085         if (pAstCfg->xOut[z].hTxSio) 
3086         {
3087             // determine associated encoder and stream
3088             zS = z;
3089             (void)zS;
3090             for (zX = ENCODE1; zX < ENCODEN; zX++) 
3091             {
3092                 if (pP->outputsFromEncodes[zX] == z) 
3093                 {
3094                     zS = pP->streamsFromEncodes[zX];
3095                     break;
3096                 }
3097             }
3099             // Mute output before audio data termination in the usual case,
3100             // where such termination is due to decode error or user command.
3101             // Identification of this as the usual case is provided by the
3102             // "decode processing" state machine.
3103             if (!(pAstCfg->xOut[z].outBufStatus.audio & 0xf0) &&
3104                 ((pAstCfg->xOut[z].outBufStatus.audio & 0x0f) == PAF_OB_AUDIO_SOUND) &&
3105                 (getVal = SIO_ctrl(pAstCfg->xOut[z].hTxSio, PAF_SIO_CONTROL_MUTE, 0))) 
3106             {
3107                 if (!errno) 
3108                 {
3109                     errno = (getVal & 0xff) | ASPERR_MUTE;
3110                     /* convert to sensical errno */
3111                 }
3112                 TRACE_VERBOSE1("PAF_ASOT_stopOutput:  AS%d: SIO control failed (mute)", as+zS);
3113             }
3115             TRACE_TIME((&TIME_MOD, "... + %d = %d (stopOutput -- begin PAF_SIO_CONTROL_IDLE)", dtime(), TSK_time()));
3117             // Terminate audio data output, truncating (ignore) or flushing
3118             // (play out) final samples as per (1) control register set by
3119             // the user and (2) the type of audio data termination:
3121 #if 0
3122             // This form is not used because driver support for truncating
3123             // data is not supported for internal clocks, although it is
3124             // for external clocks.
3125             getVal = SIO_ctrl(pC->xOut[z].hTxSio, PAF_SIO_CONTROL_IDLE,
3126                 pC->xOut[z].outBufStatus.flush
3127                 & (pC->xOut[z].outBufStatus.audio & 0x0f) == PAF_OB_AUDIO_FLUSH
3128                 ? 1 : 0);
3129             /* UNTESTED */
3130 #else
3131             // This form should be used when driver support for truncating
3132             // data is supported for both internal and external clocks.
3133             getVal = SIO_ctrl(pAstCfg->xOut[z].hTxSio, PAF_SIO_CONTROL_IDLE,
3134                 pAstCfg->xOut[z].outBufStatus.flush ? 1 :
3135                 (pAstCfg->xOut[z].outBufStatus.audio & 0x0f) == PAF_OB_AUDIO_FLUSH
3136                 ? 1 : 0);
3137             /* TESTED */
3138 #endif
3140             TRACE_TIME((&TIME_MOD, "... + %d = %d (stopOutput -- after PAF_SIO_CONTROL_IDLE)", dtime(), TSK_time()));
3142             if (!errno)
3143             {
3144                 errno = getVal;
3145             }
3147             // Mute output after audio data termination in a special case,
3148             // where such termination is due to processing of a final frame
3149             // or user command. Identification of this as a special case is
3150             // provided by the "decode processing" state machine.
3151             if (!(pAstCfg->xOut[z].outBufStatus.audio & 0xf0) &&
3152                 ((pAstCfg->xOut[z].outBufStatus.audio & 0x0f) == PAF_OB_AUDIO_FLUSH) &&
3153                 (getVal = SIO_ctrl(pAstCfg->xOut[z].hTxSio, PAF_SIO_CONTROL_MUTE, 0)))
3154             {
3155                 if (!errno) 
3156                 {
3157                     errno = (getVal & 0xff) | ASPERR_MUTE;
3158                     /* convert to sensical errno */
3159                 }
3160                 TRACE_VERBOSE1("as1-f2: PAF_ASOT_stopOutput:  AS%d: SIO control failed (mute)", as+zS);
3161             }
3163             pAstCfg->xOut[z].outBufStatus.audio &= ~0x0f;
3165             // zero output buffers
3166             pObj = (PAF_SIO_IALG_Obj *) pAstCfg->xOut[z].outChainData.head->alg;
3167             pAlgConfig = &pObj->config;
3168             memset (pAstCfg->xOut[z].outBufConfig.base.pVoid, 0, pAlgConfig->pMemRec[0].size);
3169         } //pAstCfg->xOut[z].hTxSio
3170     }//OUTPUT
3172     return errno;
3173 } //PAF_ASOT_stopOutput
3176 // -----------------------------------------------------------------------------
3177 // ASOT Decoding Function Helper - SIO Driver Change
3178 //
3179 //   Name:      PAF_ASOT_setCheckRateX
3180 //   Purpose:   Decoding Function for reinitiating output.
3181 //   From:      AST Parameter Function -> decodeInfo1
3182 //              AST Parameter Function -> decodeInfo2
3183 //   Uses:      See code.
3184 //   States:    x
3185 //   Return:    Error number in standard form (0 on success).
3186 //   Trace:     None.
3187 //
3189 /* 0: set, 1: check, unused for now. --Kurt */
3190 Int
3191 PAF_ASOT_setCheckRateX(
3192     const PAF_ASOT_Params *pP, 
3193     const PAF_ASOT_Patchs *pQ, 
3194     PAF_ASOT_Config *pAsotCfg, 
3195     Int check
3198     PAF_AST_Config *pAstCfg;
3199     float rateX;
3200     PAF_SampleRateHz rateO /* std */, rateI /* inv */;
3201     Int z;                              /* output counter */
3202     Int zx;                             /* output re-counter */
3203     Int getVal;
3204     int inputRate, inputCount, outputRate, outputCount;
3205     Int zMD;
3206     Int zMI;
3207     Int zMS;
3208     Int zE, zX;
3210     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
3211     zMD = pAstCfg->masterDec;
3212     zMS = pAstCfg->masterStr;
3213     zMI = pP->zone.master;
3215     inputRate = pAstCfg->xInp[zMI].inpBufStatus.sampleRateStatus;
3216     inputCount = pAstCfg->xDec[zMD].decodeStatus.frameLength;
3217     rateI = pAstCfg->xStr[zMS].pAudioFrame->fxns->sampleRateHz
3218         (pAstCfg->xStr[zMS].pAudioFrame, inputRate, PAF_SAMPLERATEHZ_INV);
3220     for (z=OUTPUT1; z < OUTPUTN; z++) 
3221     {
3222         if (pAstCfg->xOut[z].hTxSio && (pAstCfg->xOut[z].outBufStatus.clock & 0x01)) 
3223         {
3224             // determine associated encoder
3225             zE = z;
3226             for (zX = ENCODE1; zX < ENCODEN; zX++) 
3227             {
3228                 if (pP->outputsFromEncodes[zX] == z) 
3229                 {
3230                     zE = zX;
3231                     break;
3232                 }
3233             }
3235             outputRate = pAstCfg->xEnc[zE].encodeStatus.sampleRate;
3236             outputCount = pAstCfg->xEnc[zE].encodeStatus.frameLength;
3237             rateO = pAstCfg->xStr[zMS].pAudioFrame->fxns->sampleRateHz
3238                 (pAstCfg->xStr[zMS].pAudioFrame, outputRate, PAF_SAMPLERATEHZ_STD);
3239             if ((rateI > 0) && (rateO > 0))
3240             {
3241                 rateX = rateO /* std */ * rateI /* inv */;
3242             }
3243             else if (inputCount != 0)
3244             {
3245                 rateX = (float )outputCount / inputCount;
3246             }
3247             else
3248             {
3249                 return ASPERR_INFO_RATERATIO;
3250             }
3252             getVal = SIO_ctrl(pAstCfg->xOut[z].hTxSio, PAF_SIO_CONTROL_SET_RATEX, (Arg)&rateX);
3253             if (getVal == DOBERR_RATECHANGE) 
3254             {
3255                 for (zx=OUTPUT1; zx < OUTPUTN; zx++)
3256                 {
3257                     if (pAstCfg->xOut[zx].hTxSio)
3258                     {
3259                         SIO_idle (pAstCfg->xOut[zx].hTxSio);
3260                     }
3261                 }
3263                 // this forces an exit from the calling state machine which will
3264                 // eventually call startOutput which calls setCheckRateX for all outputs
3265                 // and so it is ok, in the presence of a rate change on any output, to
3266                 // exit this loop /function early.
3267                 return ASPERR_INFO_RATECHANGE;
3268             }
3269             else if (getVal != SYS_OK)
3270             {
3271                 return ((getVal & 0xff) | ASPERR_RATE_CHECK);
3272             }
3273         }
3274     }
3276     return 0;
3277 } //PAF_ASOT_setCheckRateX
3279 // -----------------------------------------------------------------------------
3280 // ASOT Decoding Function Helper - Chain Processing
3281 //
3282 //   Name:      PAF_ASOT_streamChainFunction
3283 //   Purpose:   Common Function for processing algorithm chains.
3284 //   From:      AST Parameter Function -> decodeInfo1
3285 //              AST Parameter Function -> decodeStream
3286 //              AST Parameter Function -> decodeComplete
3287 //   Uses:      See code.
3288 //   States:    x
3289 //   Return:    Error number in standard form (0 on success).
3290 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
3291 //              * State information as per parent.
3292 //
3293 Int
3294 PAF_ASOT_streamChainFunction(
3295     const PAF_ASOT_Params *pP, 
3296     const PAF_ASOT_Patchs *pQ, 
3297     PAF_ASOT_Config *pAsotCfg, 
3298     Int iChainFrameFxns, 
3299     Int abortOnError, 
3300     Int logArg
3303     PAF_AST_Config *pAstCfg;
3304     Int as;                     /* Audio Stream Number (1, 2, etc.) */
3305     Int z;                      /* stream counter */
3306     Int errno;                  /* error number */
3307     Int dFlag, eFlag, gear;
3308     Int zX;
3309     Int zS;
3311     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
3312     as = pAstCfg->as;
3313     (void)as; // clear compiler warning in case not used with tracing disabled
3315     for (zS = STREAM1; zS < STREAMN; zS++)
3316     {
3317         z = pP->streamOrder[zS];  // Select stream order from streamOrder parameter - MID 788
3319         // apply stream
3320         //      unless the stream is associated with a decoder and it is not running
3321