Updated setup_env.bat to upgrade for PRSDK 5.1
[processor-sdk/performance-audio-sr.git] / pasrc / test_dsp / framework / audioStreamOutProc.c
2 /*
3 Copyright (c) 2018, 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 <xdc/runtime/Log.h>
41 #include <ti/sysbios/BIOS.h>
43 #include "aspOutInitSync_master.h"
44 #include "aspDecOpCircBuf_master.h"
45 #include "audioStreamProc_common.h"
46 #include "audioStreamOutProc.h"
47 #include "audioStreamOutInit.h"
48 #include "audioStreamOutDec.h"
49 #include "audioStreamOutIo.h"
50 #include "common.h"
52 //#include "pfp/pfp.h"
53 //#include "pfp_app.h"        /* contains all PFP ID's */
54 //Int32 gNumPfpAsot1=0; // debug
56 // debug
57 #include "evmc66x_gpio_dbg.h"
59 //#include "ioConfig.h"
61 // -----------------------------------------------------------------------------
62 // Debugging Trace Control, local to this file.
63 // 
64 #include "logp.h"
66 // Allow a developer to selectively enable tracing.
67 #define CURRENT_TRACE_MASK      0x07
69 #define TRACE_MASK_TERSE        0x01   // only flag errors and show init
70 #define TRACE_MASK_GENERAL      0x02   // half dozen lines per frame
71 #define TRACE_MASK_VERBOSE      0x04   // trace full operation
73 #if !(CURRENT_TRACE_MASK & TRACE_MASK_TERSE)
74     #undef  TRACE_TERSE0
75     #undef  TRACE_TERSE1
76     #undef  TRACE_TERSE2
77     #undef  TRACE_TERSE3
78     #undef  TRACE_TERSE4
79     #define TRACE_TERSE0(a)
80     #define TRACE_TERSE1(a,b)
81     #define TRACE_TERSE2(a,b,c)
82     #define TRACE_TERSE3(a,b,c,d)
83     #define TRACE_TERSE4(a,b,c,d,e)
84 #endif
85     
86 #if !(CURRENT_TRACE_MASK & TRACE_MASK_GENERAL)
87     #undef  TRACE_GEN0
88     #undef  TRACE_GEN1
89     #undef  TRACE_GEN2
90     #undef  TRACE_GEN3
91     #undef  TRACE_GEN4
92     #define TRACE_GEN0(a)
93     #define TRACE_GEN1(a,b)
94     #define TRACE_GEN2(a,b,c)
95     #define TRACE_GEN3(a,b,c,d)
96     #define TRACE_GEN4(a,b,c,d,e)
97 #endif
99 #if !(CURRENT_TRACE_MASK & TRACE_MASK_VERBOSE)
100     #undef  TRACE_VERBOSE0
101     #undef  TRACE_VERBOSE1
102     #undef  TRACE_VERBOSE2
103     #undef  TRACE_VERBOSE3
104     #undef  TRACE_VERBOSE4
105     #define TRACE_VERBOSE0(a)
106     #define TRACE_VERBOSE1(a,b)
107     #define TRACE_VERBOSE2(a,b,c)
108     #define TRACE_VERBOSE3(a,b,c,d)
109     #define TRACE_VERBOSE4(a,b,c,d,e)
110 #endif
112 // -----------------------------------------------------------------------------
113 //
114 // Audio Stream Output Task definitions
115 //
117 #define __TASK_NAME__  "TaskAsop"
119 // status codes
120 // ASOT FSM
121 #define ASOP_SOK_INITSYNC_NOTREADY              (   1 ) // ok, init-sync not ready
122 #define ASOP_SOK                                (   0 ) // ok
123 #define ASOP_ERR_FORWARD_ERR                    (  -1 ) // error, forward (ASIT) error
124 #define ASOP_ERR_RESETOUTPROC_NOOUTDEVSEL       (  -2 ) // error, reset dec out proc, no output device selected
125 #define ASOP_ERR_PROCDECOUT_OUTDEVSELUPD        (  -3 ) // error, proc dec out, output device select updated
126 #define ASOP_ERR_PROCDECOUT_IOPHYXFERCOMPLETE   (  -4 ) // error, proc dec out, io phy transfer complete
127 #define ASOP_ERR_PROCDECOUT_CHKOUTDEVSELUPD     (  -5 ) // error, proc dec out, check output device select update
129 // -----------------------------------------------------------------------------
131 // ASOT FSM states 
132 enum 
133
134     ASOT_STATE_SEL_OUT_DEV, 
135     ASOT_STATE_RESET_OUT_PROC, 
136     ASOT_STATE_INITSYNC_DEC_INFO1, 
137     ASOT_STATE_INITSYNC_DEC_DECODE1, 
138     ASOT_STATE_PROC_DEC_OUT,
139     ASOT_STATE_RESEL_OUT_DEV,
140     ASOT_STATE_INITSYNC_RESYNC
141 };
143 // Check if Output device selected
144 static Int checkOutDevSel(
145     PAF_AST_IoOut *pOut,
146     Bool *pOutDevSel);
147     
148 // Check if any Output device selected
149 static Int checkAnyOutDevSel(
150     const PAF_ASOT_Params *pP,
151     PAF_AST_IoOut *pOut,
152     Bool *pOutDevSel);
154 // ASOT SM function
155 //   Purpose:   Audio Stream Output Task Function for selecting the devices used
156 //              for output.
157 static Int PAF_ASOT_selectDevices(
158     const PAF_ASOT_Params *pP, 
159     const PAF_ASOT_Patchs *pQ, 
160     PAF_ASOT_Config *pAsotCfg,
161     Bool *pOutDevSel
162 );
164 // Reset audio frame pointers to original values
165 static Void resetAfPointers(
166     const PAF_ASOT_Params *pP, 
167     PAF_AST_Stream *xStr
168 );
170 // Reset audio frame meta data elements
171 static Void resetAfMetadata(
172     const PAF_ASOT_Params *pP, 
173     PAF_AST_Stream *xStr
174 );
176 // Reset audio frames
177 static Void resetAfs(
178     const PAF_ASOT_Params *pP, 
179     PAF_AST_Stream *xStr
180 );
182 // used by new OutProc.c, will be changed back to static once refactoring is done
183 //   Purpose:   Init-Sync Dec Reset state function.
184 //              Performs Dec Reset Init-Sync.
185 static Int PAF_ASOT_initSyncDecReset(
186     const PAF_ASOT_Params *pP, 
187     const PAF_ASOT_Patchs *pQ, 
188     PAF_ASOT_Config *pAsotCfg,
189     PAF_AudioFrame *pDecResetAf,
190     Int frame
191 );
193 // ASOT SM function
194 // Reset Decoder Output processing
195 static Int PAF_ASOT_resetDecOutProc(
196     const PAF_ASOT_Params *pP, 
197     const PAF_ASOT_Patchs *pQ, 
198     PAF_ASOT_Config *pAsotCfg,
199     PAF_AudioFrame *pDecResetAf,
200     Bool outDevSel,
201     Int frame
202 );
204 // ASOT SM function
205 //   Purpose:   Init-Sync Dec Info1 state function.
206 //              Performs Dec Info1 Init-Sync.
207 static Int PAF_ASOT_initSyncDecInfo1(
208     const PAF_ASOT_Params *pP, 
209     const PAF_ASOT_Patchs *pQ, 
210     PAF_ASOT_Config *pAsotCfg,
211     PAF_AudioFrame *pDecInfo1Af, 
212     Int frame
213 );
215 // ASOT SM function
216 //   Purpose:   Init-Sync Dec Decode1 state function.
217 //              Performs Dec Decode1 Init-Sync.
218 static Int PAF_ASOT_initSyncDecDecode1(
219     const PAF_ASOT_Params *pP, 
220     const PAF_ASOT_Patchs *pQ, 
221     PAF_ASOT_Config *pAsotCfg, 
222     PAF_AudioFrame *pDecDecode1Af, 
223     Int frame
224 );
226 // ASOT SM function
227 // Process Decoder output audio data
228 static Int PAF_ASOT_procDecOut(
229     const PAF_ASOT_Params *pP, 
230     const PAF_ASOT_Patchs *pQ, 
231     PAF_ASOT_Config *pAsotCfg, 
232     Bool *pFirstTime, 
233     Int frame
234 );
236 // ASOT SM function
237 //   Purpose:   Init-Sync Re-Sync state function.
238 //              Performs Init-Sync using stored Init-Sync AFs.
239 static Int PAF_ASOT_initSyncResync(
240     const PAF_ASOT_Params *pP, 
241     const PAF_ASOT_Patchs *pQ, 
242     PAF_ASOT_Config *pAsotCfg,
243     PAF_AudioFrame *pDecResetAf,
244     PAF_AudioFrame *pDecInfo1Af, 
245     PAF_AudioFrame *pDecDecode1Af, 
246     Int frame
247 );
249 // Encode function which handles encoding to two output buffers
250 static Int asopDecOutProcEncodeWrap(
251     const PAF_ASOT_Params *pP,
252     const PAF_ASOT_Patchs *pQ,
253     PAF_ASOT_Config *pAsotCfg,
254     Int frame,
255     Int zO
256 );
258 // ASOT SM function
259 //   Purpose:   Re-select devices used for Output.
260 //              Performs Init-Sync using stored Init-Sync AFs.
261 static Int PAF_ASOT_reselectDevices(
262     const PAF_ASOT_Params *pP, 
263     const PAF_ASOT_Patchs *pQ, 
264     PAF_ASOT_Config *pAsotCfg,
265     PAF_AudioFrame *pDecResetAf,
266     PAF_AudioFrame *pDecInfo1Af,
267     PAF_AudioFrame *pDecDecode1Af, 
268     Int frame, 
269     Bool *pOutDevSel
270 );
271    
273 // FL: debug, allow modification of Output frame length via JTAG.
274 //Int16 gOutFrameLen=PAF_ASOT_FRAMELENGTH; // output frame length (PCM samples)
276 // ASOT configuration
277 #pragma DATA_SECTION(gPAF_ASOT_config, ".globalSectionPafAsotConfig")
278 PAF_ASOT_Config gPAF_ASOT_config = {
279     NULL,               // taskHandle
280     0,                  // asotState
281     NULL,               // acp
282     0,0,0,              // cbDrainedFlag (size DECODE_MAXN)
283     &gPAF_ASPM_config,  // pAspmCfg
284     &gPAF_AST_config    // pAstCfg
285 };
287 // ASOT event handle - to put in structure
288 Event_Handle gAsotEvtHandle;
290 extern Int d10Initialized;
292 // For writeDECCommandRestart
293 extern volatile UInt32 gCommandOutputTask_SYNC;
294 extern volatile UInt32 gCommandOutputTask_ACK;
296 LINNO_DEFN(TaskAsop); // Line number macros
297 ERRNO_DEFN(TaskAsop); // Error number macros
299 #define ASOP_DEBUG
300 #ifdef ASOP_DEBUG
301 Int asopLoopCount;
302 #endif
304 // Debug event-in-state counters
305 UInt32 gSelOutDevState_EvtWakeTimer_cnt                 = 0; // Select Output state, Wake Timer event count
306 UInt32 gSelOutDevState_EvtTxMcaspEdma_invCnt            = 0; // Select Output state, invalid Tx McASP EDMA event count
307 UInt32 gSelOutDevState_Evt_invCnt                       = 0; // Select Output state, invalid other event count
308 UInt32 gResetOutProcState_EvtWakeTimer_cnt              = 0; // Select Output state, Wake Timer event count
309 UInt32 gResetOutProcState_EvtTxMcaspEdma_invCnt         = 0; // Reset Output Processing state, invalid Tx McASP EDMA event count
310 UInt32 gResetOutProcState_Evt_invCnt                    = 0; // Reset Output Processing state, invalid other event count
311 UInt32 gInitSyncDecInfo1State_EvtWakeTimer_cnt          = 0; // Init-Sync Dec Info1 state, Wake Timer event count
312 UInt32 gInitSyncDecInfo1State_EvtTxMcaspEdma_invCnt     = 0; // Init-Sync Dec Info1 state, invalid Tx McASP EDMA event count
313 UInt32 gInitSyncDecInfo1State_Evt_invCnt                = 0; // Init-Sync Dec Info1 state, invalid other event count
314 UInt32 gInitSyncDecDecode1State_EvtWakeTimer_cnt        = 0; // Init-Sync Dec Decode1 state, Wake Timer event count
315 UInt32 gInitSyncDecDecode1State_EvtTxMcaspEdma_invCnt   = 0; // Init-Sync Dec Decode1 state, invalid Tx McASP EDMA event count
316 UInt32 gInitSyncDecDecode1State_Evt_invCnt              = 0; // Init-Sync Dec Decode1 state, invalid other event count
317 UInt32 gProcDecOutState_EvtWakeTimer_cnt                = 0; // Process Output state, Wake Timer event count 
318 UInt32 gProcDecOutState_EvtTxMcaspEdma_cnt              = 0; // Process Output state, Tx McASP EDMA event count
319 UInt32 gProcDecOutState_Evt_invCnt                      = 0; // Process Output state, invalid other event count
320 UInt32 gReselOutDevState_EvtWakeTimer_cnt               = 0; // Process Output state, Wake Timer event count 
321 UInt32 gReselOutDevState_EvtTxMcaspEdma_invCnt          = 0; // Re-select Output state, invalid other event count
322 UInt32 gReselOutDevState_Evt_invCnt                     = 0; // Re-select Output state, invalid other event count
323 // Debug state counters
324 UInt32 gAsotInitSyncResyncState_Cnt                     = 0; // Init-Sync Re-sync (Local error) state execution count
325 UInt32 gAsotInvState_Cnt                                = 0; // invalid state count
328 /*
329  *  ======== taskAsopFxn ========
330  *  Audio Stream Output Processing task function
331  */
332 Void taskAsopFxn(
333     const PAF_ASOT_Params *pP,
334     const PAF_ASOT_Patchs *pQ
337     PAF_ASOT_Config *pAsotCfg;      // ASOT configuration pointer
338     PAF_AST_Config *pAstCfg;        // Common (shared) configuration pointer
339     Int as;                         // Audio Stream Number (1, 2, etc.)
340     Int z;                          // input/encode/stream/decode/output counter
341     Bool outDevSel;                 // whether output device selected
342     PAF_AudioFrame decResetAf;
343     PAF_AudioFrame decInfo1Af;
344     PAF_AudioFrame decDecode1Af;
345     UInt events;                    // latched event flags
346     Bool procEvents;                // process events flags
347     Bool procOutFirstTime;          // first time process output flag
348     Int asopFrameCount;             // frame counter
349     Int status;                     // status code
350 #ifndef ASOP_DEBUG
351     Int asopLoopCount;              // debug, ASOT loop counter
352 #endif
354     Log_info0("Enter taskAsopFxn()");
356     taskAsopFxnInit(pP, pQ);    // initialization of output task
357     
358     //
359     // Audio Stream Output Task Configuration (*pAsotCfg):
360     //
361     pAsotCfg = &gPAF_ASOT_config;       // initialize pointer to task configuration
362     pAstCfg = pAsotCfg->pAstCfg;        // get pointer to AST common (shared) configuration
363     as = pAstCfg->as;                   // obtain Audio Stream Number (1, 2, etc.)
365     //
366     // Main processing loop
367     //
368     for (z=STREAM1; z < STREAMN; z++)
369     {
370         TRACE_VERBOSE1("TaskAsop: AS%d: running", as+z);
371     }
373     pAsotCfg->state = ASOT_STATE_SEL_OUT_DEV;   // init state
374     procEvents = TRUE;                          // init proc events flag
375     procOutFirstTime = TRUE;                    // init first time process output flag
376     asopFrameCount = 0;                         // init frame counter TBD
377     asopLoopCount = 0;                          // loop counter
378     for (;;)
379     {
380         // Pend for next event
381         //  Evt_Id_AsotWakeTimer    : Wakeup timer (poll for Output device selection)
382         //  Evt_Id_AsotTxMcaspEdma  : Tx McASP EDMA completion
383         if (procEvents == TRUE)
384         {
385             events = Event_pend(gAsotEvtHandle, Event_Id_NONE, (Evt_Id_AsotWakeTimer + Evt_Id_AsotTxMcaspEdma), BIOS_WAIT_FOREVER);
386         }
388         asopLoopCount++;
389         //TRACE_GEN1("TaskAsop (begin Main loop %d)", asopLoopCount);
391         switch (pAsotCfg->state)
392         {
393             //
394             //  Select Output Device state
395             //
396             case ASOT_STATE_SEL_OUT_DEV:
397                 if (events & Evt_Id_AsotWakeTimer)
398                 {
399                     gSelOutDevState_EvtWakeTimer_cnt++;
400                     events &= ~Evt_Id_AsotWakeTimer; // clear event
401                     
402                     // Select Output devices
403                     //  outDevSel==TRUE if Output device selection successful
404                     status = PAF_ASOT_selectDevices(pP, pQ, pAsotCfg, &outDevSel);
405                     if (status < 0)
406                     {
407                         // FL, New IO: 
408                         //Tx status==error message to ASIT;   // ASOT initiated message to ASIT, "backward" error
409                         
410                         // No explicit handling of Select Output Device error, so stay in state and try again
411                         pAsotCfg->state = ASOT_STATE_SEL_OUT_DEV;
412                         break;
413                     }
414                     else if (outDevSel == TRUE)
415                     {
416                         // Select successful
417                         pAsotCfg->state = ASOT_STATE_RESET_OUT_PROC;
418                     }
419                     else
420                     {
421                         // No output device selected (outDevSel == FALSE).
422                         // Remain in current state.
423                         ;
424                     }
425                 }
426                 
427                 // Check for unexpected Tx McASP EDMA event
428                 if (events & Evt_Id_AsotTxMcaspEdma)
429                 {
430                     gSelOutDevState_EvtTxMcaspEdma_invCnt++; // log invalid event count in state
431                     TRACE_TERSE2("TaskAsop: invalid Tx McASP EDMA event, state=%u, events=%u", pAsotCfg->state, events);
432                     events &= ~Evt_Id_AsotTxMcaspEdma; // clear event
433                 }
435                 // Check for any other unexpected events
436                 if (events != 0)
437                 {
438                     gSelOutDevState_Evt_invCnt++; // log invalid event count in state
439                     TRACE_TERSE2("TaskAsop: invalid events, state=%u, events=%u", pAsotCfg->state, events);
440                     events &= ~events; // clear events
441                 }
442                 
443                 break;
444                 
445             // FL, New IO: currently using timer event
446             //
447             //  Reset Output Processing state
448             //
449             case ASOT_STATE_RESET_OUT_PROC:
450                 if (events & Evt_Id_AsotWakeTimer)
451                 {
452                     gResetOutProcState_EvtWakeTimer_cnt++;
453                     events &= ~Evt_Id_AsotWakeTimer; // clear event
454                     
455                     //
456                     // Allow Output device re-selection prior to Output processing.
457                     //  Output device selection has already been performed in state==ASOT_STATE_SEL_OUT_DEV.
458                     //  Output device can be re-selected via alpha commands before streaming is initiated.
459                     //  Here check whether this has occurred.
460                     //
461                     
462                     // Select Output devices
463                     //  outDevSel==TRUE if Output device selection successful
464                     status = PAF_ASOT_selectDevices(pP, pQ, pAsotCfg, &outDevSel);
465                     if (status < 0)
466                     {
467                         // FL, New IO: 
468                         //Tx status==error message to ASIT;   // ASOT initiated message to ASIT, "backward" error
469                         
470                         // Starting over with Output device selection in case of error                        
471                         pAsotCfg->state = ASOT_STATE_SEL_OUT_DEV;
472                         break;
473                     }
474                     else if (outDevSel == FALSE)
475                     {
476                         // No device selected
477                         pAsotCfg->state = ASOT_STATE_SEL_OUT_DEV;
478                         break;
479                     }
480                     
481                     // Reset Output processing
482                     status = PAF_ASOT_resetDecOutProc(pP, pQ, pAsotCfg, &decResetAf, outDevSel, asopFrameCount);
483                     if (status < 0)
484                     {
485                         // FL, New IO: 
486                         //Tx status==error message to ASDT; // feedback message ASOT -> ASDT
487                         
488                         pAsotCfg->state = ASOT_STATE_SEL_OUT_DEV;   // starting over with Output device selection in case of error
489                         break;
490                     }
491                     else if (status == ASOP_SOK_INITSYNC_NOTREADY)
492                     {
493                         // FL, New IO: this is only necessary for Wake Timer, POLLING Init-Sync
494                         // FL, New IO: can be removed once Rx ASDT messages are implemented for Init-Sync
495                         
496                         // Dec Reset Init-Sync not ready.
497                         // Remain in current state.
498                         ;
499                     }
500                     else
501                     {
502                         // FL, New IO: 
503                         //Tx status==ok message to ASDT; // feedback message ASOT -> ASDT
504                         
505                         pAsotCfg->state = ASOT_STATE_INITSYNC_DEC_INFO1;
506                     }
507                 }
508                 
509                 // Check for unexpected Tx McASP EDMA event
510                 if (events & Evt_Id_AsotTxMcaspEdma)
511                 {
512                     gResetOutProcState_EvtTxMcaspEdma_invCnt++; // log invalid event count in state
513                     TRACE_TERSE2("TaskAsop: Tx McASP EDMA event, state=%u, events=%u", pAsotCfg->state, events);
514                     events &= ~Evt_Id_AsotTxMcaspEdma; // clear event
515                 }
517                 // Check for any other unexpected events
518                 if (events != 0)
519                 {
520                     gResetOutProcState_Evt_invCnt++; // log invalid event count in state
521                     TRACE_TERSE2("TaskAsop: invalid events, state=%u, events=%u", pAsotCfg->state, events);
522                     events &= ~events; // clear events
523                 }
524                 
525                 break;
526                 
527             // FL, New IO: currently using timer event
528             //
529             //  Init-Sync Info1 state
530             //
531             case ASOT_STATE_INITSYNC_DEC_INFO1:
532                 if (events & Evt_Id_AsotWakeTimer)
533                 {
534                     gInitSyncDecInfo1State_EvtWakeTimer_cnt++;
535                     events &= ~Evt_Id_AsotWakeTimer; // clear event
536                     
537                     status = PAF_ASOT_initSyncDecInfo1(pP, pQ, pAsotCfg, &decInfo1Af, asopFrameCount);
538                     if (status < 0)
539                     {
540                         // FL, New IO: 
541                         //Tx status==error message to ASDT;   // feedback message ASOT -> ASDT
542                         
543                         pAsotCfg->state = ASOT_STATE_SEL_OUT_DEV;          // starting over with Output device selection in case of error
544                         break;
545                     }
546                     else if (status == ASOP_SOK_INITSYNC_NOTREADY)
547                     {
548                         // FL, New IO: this is only necessary for Wake Timer, POLLING Init-Sync
549                         // FL, New IO: can be removed once Rx ASDT messages are implemented for Init-Sync
550                         
551                         // Dec Reset Init-Sync not ready.
552                         // Remain in current state.
553                         ;
554                     }
555                     else
556                     {
557                         // FL, New IO: 
558                         //Tx status==ok message to ASDT;      // feedback message ASOT -> ASDT
559                         
560                         pAsotCfg->state = ASOT_STATE_INITSYNC_DEC_DECODE1;
561                     }
562                 }
564                 // Check for unexpected Tx McASP EDMA event
565                 if (events & Evt_Id_AsotTxMcaspEdma)
566                 {
567                     gInitSyncDecInfo1State_EvtTxMcaspEdma_invCnt++; // log invalid event count in state
568                     TRACE_TERSE2("TaskAsop: Tx McASP EDMA event, state=%u, events=%u", pAsotCfg->state, events);
569                     events &= ~Evt_Id_AsotTxMcaspEdma; // clear event
570                 }
572                 // Check for any other unexpected events
573                 if (events != 0)
574                 {
575                     gInitSyncDecInfo1State_Evt_invCnt++; // log invalid event count in state
576                     TRACE_TERSE2("TaskAsop: invalid events, state=%u, events=%u", pAsotCfg->state, events);
577                     events &= ~events; // clear events
578                 }
579                 
580                 break;
581             
582             // FL, New IO: currently using timer event
583             //
584             //  Init-Sync Decode1 state
585             //
586             case ASOT_STATE_INITSYNC_DEC_DECODE1:
587                 if (events & Evt_Id_AsotWakeTimer)
588                 {
589                     gInitSyncDecDecode1State_EvtWakeTimer_cnt++;
590                     events &= ~Evt_Id_AsotWakeTimer; // clear event
591                     
592                     status = PAF_ASOT_initSyncDecDecode1(pP, pQ, pAsotCfg, &decDecode1Af, asopFrameCount);
593                     if (status < 0)
594                     {
595                         // FL, New IO: 
596                         //Tx status==error message to ASDT;   // feedback message ASOT -> ASDT
597                         
598                         pAsotCfg->state = ASOT_STATE_SEL_OUT_DEV;          // starting over with Output device selection in case of error
599                         break;
600                     }
601                     else if (status == ASOP_SOK_INITSYNC_NOTREADY)
602                     {
603                         // FL, New IO: this is only necessary for Wake Timer, POLLING Init-Sync
604                         // FL, New IO: can be removed once Rx ASDT messages are implemented for Init-Sync
605                         
606                         // Dec Reset Init-Sync not ready.
607                         // Remain in current state.
608                         ;
609                     }
610                     else
611                     {
612                         // FL, New IO: 
613                         //Tx status==ok message to ASDT;      // feedback message ASOT -> ASDT
614                         
615                         pAsotCfg->state = ASOT_STATE_PROC_DEC_OUT;
616                         procOutFirstTime = TRUE;
617                     }
618                 }
619             
620                 // Check for unexpected Tx McASP EDMA event
621                 if (events & Evt_Id_AsotTxMcaspEdma)
622                 {
623                     gInitSyncDecDecode1State_EvtTxMcaspEdma_invCnt++; // log invalid event count in state
624                     TRACE_TERSE2("TaskAsop: Tx McASP EDMA event, state=%u, events=%u", pAsotCfg->state, events);
625                     events &= ~Evt_Id_AsotTxMcaspEdma; // clear event
626                 }
628                 // Check for any other unexpected events
629                 if (events != 0)
630                 {
631                     gInitSyncDecDecode1State_Evt_invCnt++; // log invalid event count in state
632                     TRACE_TERSE2("TaskAsop: invalid events, state=%u, events=%u", pAsotCfg->state, events);
633                     events &= ~events; // clear events
634                 }
635                 
636                 break;
637                 
638             //
639             //  Process Decoder Output state
640             //
641             case ASOT_STATE_PROC_DEC_OUT:
642                 if (events & Evt_Id_AsotTxMcaspEdma)
643                 {
644                     gProcDecOutState_EvtTxMcaspEdma_cnt++;
645                     events &= ~Evt_Id_AsotTxMcaspEdma; // clear event
646                     
647 #if 1 // (***) FL: shows timing of Output (Tx McASP EDMA)
648                     // (***) debug // B8
649                     {
650                         static Uint8 toggleState = 0;
651                         if (toggleState == 0)
652                             GPIOSetOutput(GPIO_PORT_0, GPIO_PIN_106);
653                         else
654                             GPIOClearOutput(GPIO_PORT_0, GPIO_PIN_106);
655                         toggleState = ~(toggleState);
656                     }
657 #endif                                 
658                     
659                     // Process Output
660                     status = PAF_ASOT_procDecOut(pP, pQ, pAsotCfg, &procOutFirstTime, asopFrameCount);
661                     if (status < 0)
662                     {
663                         if (status == ASOP_DOP_ERR_FINALTEST_CBDRAINED)
664                         {
665                             // normal completion, CB drained @ EOS
666                             pAsotCfg->state = ASOT_STATE_SEL_OUT_DEV;
667                             break;
668                             
669                         }
670                         else if (status == ASOP_ERR_PROCDECOUT_OUTDEVSELUPD)
671                         {
672                             // Output re-select
673                             pAsotCfg->state = ASOT_STATE_RESEL_OUT_DEV;
674                             break;
675                         }
676                         // FL, New IO: "backward" error handling.
677                         // Currently all errors handled locally.
678                         else
679                         {
680                             // Handle ASOT "local" errors
681                             pAsotCfg->state = ASOT_STATE_INITSYNC_RESYNC;
682                             procEvents = FALSE;
683                             break;
684                         }
685                     }
686                 }
687             
688                 // Check for Wakeup Timer event.
689                 //  Wakeup Timer events are allowed to occur, but no processing is 
690                 //  performed in response to such an event.
691                 if (events & Evt_Id_AsotWakeTimer)
692                 {
693                     events &= ~Evt_Id_AsotWakeTimer; // clear event
694                     gProcDecOutState_EvtWakeTimer_cnt++; // log event count in state
695                 }
696             
697                 // Check for any other unexpected events
698                 if (events != 0)
699                 {
700                     gProcDecOutState_Evt_invCnt++; // log invalid event count in state
701                     TRACE_TERSE2("TaskAsop: invalid events, state=%u, events=%u", pAsotCfg->state, events);
702                     events &= ~events; // clear events
703                 }
704             
705                 break;
706                 
707             //
708             //  Re-Select Output Device state
709             //
710             case ASOT_STATE_RESEL_OUT_DEV:
711                 if (events & Evt_Id_AsotWakeTimer)
712                 {
713                     gReselOutDevState_EvtWakeTimer_cnt++;
714                     events &= ~Evt_Id_AsotWakeTimer; // clear event
715                     
716                     status = PAF_ASOT_reselectDevices(pP, pQ, pAsotCfg, &decResetAf, &decInfo1Af, &decDecode1Af, asopFrameCount, &outDevSel);
717                     if (status < 0)
718                     {
719                         // FL, New IO: 
720                         //Tx status==error message to ASIT;       // ASOT initiated message to ASIT, "backward" error
721                         
722                         pAsotCfg->state = ASOT_STATE_SEL_OUT_DEV;   // starting over with Output device selection in case of error
723                         break;
724                     }
725                     else if (outDevSel == TRUE)
726                     {
727                         // Re-select successful
728                         pAsotCfg->state = ASOT_STATE_PROC_DEC_OUT;
729                         procOutFirstTime = TRUE;
730                     }
731                     else
732                     {
733                         // No output device selected (outDevSel == FALSE).
734                         // Remain in current state.
735                         ;                
736                     }
737                 }
738             
739                 // Check for unexpected Tx McASP EDMA event
740                 if (events & Evt_Id_AsotTxMcaspEdma)
741                 {
742                     events &= ~Evt_Id_AsotTxMcaspEdma; // clear event
743                     gReselOutDevState_EvtTxMcaspEdma_invCnt++; // log invalid event count in state
744                 }
746                 // Check for any other unexpected events
747                 if (events != 0)
748                 {
749                     gReselOutDevState_Evt_invCnt++; // log invalid event count in state
750                     TRACE_TERSE2("TaskAsop: invalid events, state=%u, events=%u", pAsotCfg->state, events);
751                     events &= ~events; // clear events
752                 }
753             
754                 break;
755                 
756             //
757             //   Init-Sync Re-sync (Process Output Local Error) state
758             //
759             case ASOT_STATE_INITSYNC_RESYNC: // not event driven state
760                 gAsotInitSyncResyncState_Cnt++;
761                 
762                 status = PAF_ASOT_initSyncResync(pP, pQ, pAsotCfg, &decResetAf, &decInfo1Af, &decDecode1Af, asopFrameCount);
763                 if (status < 0)
764                 {
765                     // FL, New IO: 
766                     //Tx status==error message to ASIT;   // ASIT initiated message to ASOT, "backward" error
767                     
768                     pAsotCfg->state = ASOT_STATE_SEL_OUT_DEV;     // starting over with Output device selection in case of error
769                     procEvents = TRUE;
770                     break;
771                 }
772                 else
773                 {
774                     pAsotCfg->state = ASOT_STATE_PROC_DEC_OUT;
775                     procEvents = TRUE;
776                     procOutFirstTime = TRUE;
777                 }
778             
779                 break;
780                 
781             default: 
782                 gAsotInvState_Cnt++;
783                 TRACE_TERSE1("TaskAsop: invalid state, state=%u", pAsotCfg->state);
784             
785                 break;
786         }
788         // FL, New IO: handle ASIT messages separately in each state
789         // FL, New IO: proper SM clean up can be skipped if forward error / DEC restart is handled in this way
790         
791         //
792         // Check forward (ASIT) error, TBD
793         //
794         
795         // Check writeDECCommandRestart, TBD
796         if (gCommandOutputTask_SYNC) 
797         {
798             TRACE_TERSE0("TaskAsop: ack writeDECCommandRestart ... Wait for command de-assert");
799             gCommandOutputTask_ACK = 1;
800             while (gCommandOutputTask_SYNC) 
801             {
802                 Event_pend(gAsotEvtHandle, Event_Id_NONE, Evt_Id_AsotWakeTimer, BIOS_WAIT_FOREVER);
803             }
804             TRACE_TERSE0("TaskAsop: ack for writeDECCommandRestart ... Sync-ed! Re-start the process");
805             pAsotCfg->state = ASOT_STATE_SEL_OUT_DEV;   // init state -- start over
806             status = ASOP_ERR_FORWARD_ERR;              // set status -- force flushing of output device
807         }
809         // any error forces idling of output
810         if (status < 0)
811         {
812             for (z=OUTPUT1; z < OUTPUTN; z++)
813             {
814                 //if (pAstCfg->xOut[z].hTxSio)
815                 if (pAsotCfg->pIoOut[z].hIoPhy)
816                 {
817                     //SIO_idle(pAstCfg->xOut[z].hTxSio);  JX TO DO: implement proper error handling
818                 }
819             }
821             TRACE_TERSE1("TaskAsop: Trace stopped at loop %d.", asopLoopCount);
822             //ERRNO_RPRT(TaskAsop, errno);
823         }
824     } // End of main processing loop for (;;)
825 } /* taskAsopFxn */
827 // ASOT wake timer (clock) function
828 Void clkAsotFxn(Void)
830     Event_post(gAsotEvtHandle, Evt_Id_AsotWakeTimer);
833 void asopMcaspCallback(void* arg, MCASP_Packet *mcasp_packet)
835     /* post semaphore */
836     if(mcasp_packet->arg == IOPHY_XFER_FINAL) {
837         //Semaphore_post(asopSemTx);
838         Event_post(gAsotEvtHandle, Evt_Id_AsotTxMcaspEdma);
839     } else {
840         ;    // intermediate packet due to buffer wrapping around
841     }
844 // Reset audio frame pointers to original values
845 static Void resetAfPointers(
846     const PAF_ASOT_Params *pP, 
847     PAF_AST_Stream *xStr
850     Int z;
851     Int ch;
853     // Reset audio frame pointers to original values
854     for (z = STREAM1; z < STREAMN; z++) 
855     {
856         for (ch = PAF_LEFT; ch < PAF_MAXNUMCHAN_AF; ch++) 
857         {
858             if (xStr[z].audioFrameChannelPointers[ch])
859             {
860                 xStr[z].audioFrameChannelPointers[ch] = 
861                     xStr[z].origAudioFrameChannelPointers[ch];
862             }
863         }
864     }
867 // Check if Output device selected
868 static Int checkOutDevSel(
869     PAF_AST_IoOut *pOut,
870     Bool *pOutDevSel
873     *pOutDevSel = (Bool)(pOut->hMcaspChan != NULL);
874     
875     return ASOP_SOK;
878 // Check if any Output device selected
879 static Int checkAnyOutDevSel(
880     const PAF_ASOT_Params *pP,
881     PAF_AST_IoOut *pOut, 
882     Bool *pOutDevSel
885     Bool outDevSel;
886     Int z;
888     outDevSel = FALSE;
889     for (z=OUTPUT1; z < OUTPUTN; z++)
890     {
891         if (pOut[z].hMcaspChan)
892         {
893             outDevSel = TRUE;
894             break;
895         }
896     }
898     *pOutDevSel = outDevSel;
900     return ASOP_SOK;
903 // ASOT SM function
904 // -----------------------------------------------------------------------------
905 // ASOT Selection Function - Output Device Selection
906 //
907 //   Name:      PAF_ASOT_selectDevices
908 //   Purpose:   Audio Stream Output Task Function for selecting the devices used
909 //              for output.
910 //
911 static Int PAF_ASOT_selectDevices(
912     const PAF_ASOT_Params *pP, 
913     const PAF_ASOT_Patchs *pQ, 
914     PAF_ASOT_Config *pAsotCfg,
915     Bool *pOutDevSel
918     PAF_AST_Config *pAstCfg;        // Common (shared) configuration pointer
919     Int z;
920     Int zS, zO;
921     Int device;
922     Int status;
923     Bool ioPhyInit;
924     
925     pAstCfg = pAsotCfg->pAstCfg;        // get pointer to AST common (shared) configuration
927     // Find first Output associated with Master Stream
928     zO = OUTPUT1;
929     for (z=ENCODE1; z < ENCODEN; z++)
930     {
931         zS = pP->streamsFromEncodes[z]; // get Stream associated with Encoder
932         if (zS == pAstCfg->masterStr)
933         {
934             // This Encoder is associated with Master Stream.
935             // Note other Encoder can also be associated with Master Stream.
936             zO = pP->outputsFromEncodes[z]; // get Output associated with Encoder
937         }
938     }
939     
940     ioPhyInit = asopIoPhyCheckInit(); // check if IO Phy is initialized
941     device = pAstCfg->xOut[zO].outBufStatus.sioSelect; // obtain SIO select for Output
942     if ((ioPhyInit == TRUE) && (device >= 0))
943     {
944         // check for valid index into device array
945         if (device >= pQ->devout->n)    // DEVOUT_N
946         {
947             device = 0; // treat as device OutNone
948         }
949         
950         // Select Output Devices
951         //  FL, New IO: API for single Output
952         status = asopSelectDevices(pQ->devout->x[device], &pAsotCfg->pIoOut[zO]);
953         if (status < 0)
954         {
955             pAstCfg->xOut[zO].outBufStatus.sioSelect = 0x80;
956             *pOutDevSel = FALSE;
957             return status;
958         }
960 #if 0
961         // Reset IO Buff & IO Phy
962         //  FL, New IO: API for single Output
963         status = asopIoCompsInit(&pAstCfg->xOut[zO], &pAsotCfg->pIoOut[zO]);
964         if (status < 0)
965         {
966             pAstCfg->xOut[zO].outBufStatus.sioSelect = 0x80;
967             *pOutDevSel = FALSE;
968             return status;
969         }
970 #endif        
972         // indicate SIO update request processed
973         pAstCfg->xOut[zO].outBufStatus.sioSelect = device | 0x80;
974     }
975     
976     // Check if Output device selected
977     //  FL, New IO: API for single Output
978     status = checkOutDevSel(&pAsotCfg->pIoOut[zO], pOutDevSel);
979     if (status < 0)
980     {
981         *pOutDevSel = FALSE;
982         return status;
983     }
984     
985     return ASOP_SOK;
988 // ASOT SM function
989 //  Wake Timer + *POLLING* version.
990 //  No explicit Rx ASDT message event from ASDT.
991 //  ASOT wakes on Wake Timer event and polls for flag set.
992 // Reset Decoder Output processing
993 static Int PAF_ASOT_resetDecOutProc(
994     const PAF_ASOT_Params *pP, 
995     const PAF_ASOT_Patchs *pQ, 
996     PAF_ASOT_Config *pAsotCfg,
997     PAF_AudioFrame *pDecResetAf,
998     Bool outDevSel,
999     Int frame
1002     Int status;
1003     
1004     if (outDevSel == FALSE)
1005     {
1006         // 
1007         // Rx Dec Out-IS message before Output selected.
1008         // Decoder is producing output, but no Output selected.
1009         //
1010         return ASOP_ERR_RESETOUTPROC_NOOUTDEVSEL;
1011     }
1012     
1013     // Perform Dec Reset Init-Sync
1014     status = PAF_ASOT_initSyncDecReset(pP, pQ, pAsotCfg, pDecResetAf, frame);
1015     
1016     return status;
1020 // Reset audio frame meta data elements
1021 static Void resetAfMetadata(
1022     const PAF_ASOT_Params *pP, 
1023     PAF_AST_Stream *xStr
1026     Int z;
1027     Int i;
1029     for (z = STREAM1; z < STREAMN; z++) 
1030     {
1031         xStr[z].pAudioFrame->pafBsMetadataUpdate = XDAS_FALSE;
1032         xStr[z].pAudioFrame->numPrivateMetadata = 0;
1033         xStr[z].pAudioFrame->bsMetadata_offset = 0;
1034         xStr[z].pAudioFrame->bsMetadata_type = PAF_bsMetadata_channelData;
1036         for (i = 0; i < pP->pMetadataBufStatus->NumBuf; i++)
1037         {
1038             xStr[z].pAudioFrame->pafPrivateMetadata[i].offset = 0;
1039             xStr[z].pAudioFrame->pafPrivateMetadata[i].size = 0;
1040         }
1041     }
1044 // Reset audio frames
1045 static Void resetAfs(
1046     const PAF_ASOT_Params *pP, 
1047     PAF_AST_Stream *xStr
1050     // Reset audio frame pointers to original values
1051     // (may be needed if error occurred).
1052     resetAfPointers(pP, xStr);
1053     // Reset audio frame meta data elements
1054     resetAfMetadata(pP, xStr);
1057 //   Purpose:   Performs Dec Reset Init-Sync.
1058 //static Int PAF_ASOT_initSyncDecReset(
1059 // used by new OutProc.c, will be changed back to static once refactoring is done
1060 static Int PAF_ASOT_initSyncDecReset(
1061     const PAF_ASOT_Params *pP, 
1062     const PAF_ASOT_Patchs *pQ, 
1063     PAF_ASOT_Config *pAsotCfg,
1064     PAF_AudioFrame *pDecResetAf,
1065     Int frame
1068     PAF_AST_Config *pAstCfg;            // ASIT/ASOT/ASDT shared configuration
1069     Int zMD;                            // Dec Master index
1070     Int zMS;                            // Stream Master index
1071     PAF_AudioFrame *pStrAf;             // stream audio frame
1072     PAF_AST_OutInitSyncCtl *pOutIsCtl;  // Output Init-Sync control
1073     Int8 decFlag;                       // dec stage flag
1074     Int status;                         // status code
1075    
1076     pAstCfg = pAsotCfg->pAstCfg;
1077     zMD = pAstCfg->masterDec;
1078     pOutIsCtl = &pAsotCfg->pAspmCfg->outIsCtl;
1079     
1080     // check for Dec Reset
1081     // store dec reset AF
1082     status = outIsReadDecStageFlagAndAf(pOutIsCtl, zMD,
1083         ASP_OUTIS_DEC_STAGE_RESET_IDX, &decFlag, pDecResetAf);
1084     if (status < 0)
1085     {
1086         return status;
1087     }
1088     
1089     if (decFlag == 0)
1090     {
1091         return ASOP_SOK_INITSYNC_NOTREADY;
1092     }
1093     else
1094     {
1095         zMS = pAstCfg->masterStr;
1096         pStrAf = pAstCfg->xStr[zMS].pAudioFrame;
1097         
1098         // Reset audio frames
1099         // FL, New IO: API for multiple streams.
1100         resetAfs(pP, pAstCfg->xStr);
1101     
1102         // Update Stream Audio Frame.
1103         // Copy Dec Reset AF to Stream AF.
1104         // FL, New IO: Only Master zone (single) stream handled.
1105         outIsCpyAf(pDecResetAf, pStrAf);
1106         
1107         // Enc activate
1108         // Enc reset
1109         status = asopDecOutProcReset(pP, pQ, pAsotCfg, frame);
1110         if (status < 0)
1111         {
1112             return status;
1113         }
1114         
1115         return ASOP_SOK;
1116     }
1119 // ASOT SM function
1120 //   Purpose:   Init-Sync Dec Info1 state function.
1121 //      Wake Timer + *POLLING* version.
1122 //      No explicit Rx ASDT message event from ASDT.
1123 //      ASOT wakes on Wake Timer event and polls for flag set.
1124 static Int PAF_ASOT_initSyncDecInfo1(
1125     const PAF_ASOT_Params *pP, 
1126     const PAF_ASOT_Patchs *pQ, 
1127     PAF_ASOT_Config *pAsotCfg,
1128     PAF_AudioFrame *pDecInfo1Af,
1129     Int frame
1132     PAF_AST_Config *pAstCfg;            // ASIT/ASOT/ASDT shared configuration
1133     Int zMD;                            // Dec Master index
1134     //Int zMS;                            // Stream Master index
1135     //PAF_AudioFrame *pStrAf;             // stream audio frame
1136     PAF_AST_OutInitSyncCtl *pOutIsCtl;  // Output Init-Sync control
1137     Int8 decFlag;                       // dec stage flag
1138     Int status;                         // status code
1139     //PAF_AST_DecOpCircBufCtl *pCbCtl;    // Decoder output circular buffer control
1140     
1141     pAstCfg = pAsotCfg->pAstCfg;
1142     zMD = pAstCfg->masterDec;
1143     pOutIsCtl = &pAsotCfg->pAspmCfg->outIsCtl;
1144     
1145     // Check for Dec Info1, 
1146     // Store Dec Info1 AF
1147     status = outIsReadDecStageFlagAndAf(pOutIsCtl, zMD,
1148         ASP_OUTIS_DEC_STAGE_INFO1_IDX, &decFlag, pDecInfo1Af);
1149     if (status < 0)
1150     {
1151         return status;
1152     }
1153     
1154     if (decFlag == 0)
1155     {
1156         return ASOP_SOK_INITSYNC_NOTREADY;
1157     }
1158     else
1159     {
1160 // FL: moved to PAF_ASOT_initSyncDecDecode1(), content of asopDecOutProcInfo1() moved to asopDecOutProcDec1().
1161 // Decode parameters necessary for CB stream FL auto config are known at that time.
1162 // CB stream FL used to configure Stream AF sample count.
1163 // ASP chain reset can adjust Stream AF sample count, depending on whether SRC enabled & decimation factor.
1164 #if 0 
1165         // Get pointer to circular buffer control
1166         pCbCtl = &pAsotCfg->pAspmCfg->decOpCircBufCtl;
1168         // Initialize decoder output circular buffer for stream reads
1169         cbInitStreamRead(pCbCtl, zMD);
1171         // Get pointer to stream audio frame
1172         zMS = pAstCfg->masterStr;
1173         pStrAf = pAstCfg->xStr[zMS].pAudioFrame;
1174         
1175         // Set ASOT output frame length
1176         //pDecInfo1Af->sampleCount = gOutFrameLen;    // !!!! GJ: Revisit !!!!
1177         cbReadStrFrameLen(pCbCtl, zMD, &pDecInfo1Af->sampleCount);
1179         // Update Stream Audio Frame.
1180         // Copy Dec Info1 AF to Stream AF.
1181         outIsCpyAf(pDecInfo1Af, pStrAf);
1183         // outputInfo1():
1184         //      - ASP chain reset,
1185         //      - Enc Info,
1186         //      - Start Output
1187         status = asopDecOutProcInfo1(pP, pQ, pAsotCfg, frame);
1189         if (status < 0)
1190         {
1191             return status;
1192         }
1193 #endif
1194         
1195         return ASOP_SOK;
1196     }
1199 // ASOT SM function
1200 //   Purpose:   Init-Sync Dec Decode1 state function.
1201 //      Wake Timer + *POLLING* version.
1202 //      No explicit Rx ASDT message event from ASDT.
1203 //      ASOT wakes on Wake Timer event and polls for flag set.
1204 static Int PAF_ASOT_initSyncDecDecode1(
1205     const PAF_ASOT_Params *pP, 
1206     const PAF_ASOT_Patchs *pQ, 
1207     PAF_ASOT_Config *pAsotCfg, 
1208     PAF_AudioFrame *pDecDecode1Af, 
1209     Int frame
1212     PAF_AST_Config *pAstCfg;            // ASIT/ASOT/ASDT shared configuration
1213     Int zMD;                            // Dec Master index
1214     Int zMS;                            // Stream Master index
1215     PAF_AudioFrame *pStrAf;             // stream audio frame
1216     PAF_AST_OutInitSyncCtl *pOutIsCtl;  // Output Init-Sync control
1217     Int8 decFlag;                       // dec stage flag
1218     Int z;
1219     Int zS, zO;
1220     Int status;                         // status code
1221     PAF_AST_DecOpCircBufCtl *pCbCtl;    // Decoder output circular buffer control
1223     pAstCfg = pAsotCfg->pAstCfg;
1224     zMD = pAstCfg->masterDec;
1225     pOutIsCtl = &pAsotCfg->pAspmCfg->outIsCtl;      // get pointer to output init-sync control
1227     
1228     // Check for Dec Decode1, 
1229     // Store Dec Decode1 AF
1230     status = outIsReadDecStageFlagAndAf(pOutIsCtl, zMD,
1231         ASP_OUTIS_DEC_STAGE_DECODE1_IDX, &decFlag, pDecDecode1Af);
1232     if (status < 0)
1233     {
1234         return status;
1235     }
1236     
1237     if (decFlag == 0)
1238     {
1239         return ASOP_SOK_INITSYNC_NOTREADY;
1240     }
1241     else
1242     {
1243 // FL: moved from PAF_ASOT_initSyncDecInfo1()        
1244 #if 1
1245         // Get pointer to circular buffer control
1246         pCbCtl = &pAsotCfg->pAspmCfg->decOpCircBufCtl;
1247         
1248         // Initialize decoder output circular buffer for stream reads
1249         cbInitStreamRead(pCbCtl, zMD);
1250         
1251         // Get pointer to stream audio frame
1252         zMS = pAstCfg->masterStr;
1253         pStrAf = pAstCfg->xStr[zMS].pAudioFrame;
1254         
1255         // Set ASOT output frame length.
1256         //  Frame length is initialized to CB stream (read) frame length.
1257         //  CB stream frame length modified via SRC reset in ASP chain reset if SRC enabled.
1258         //pDecDecode1Af->sampleCount = 256;     //  48/96/192 kHz pass through
1259         //pDecDecode1Af->sampleCount = 512;     //  96 kHz, SRC DF=2
1260         //pDecDecode1Af->sampleCount = 1024;    // 192 kHz, SRC DF=4
1261         //pDecDecode1Af->sampleCount = gOutFrameLen;    // !!!! GJ: Revisit !!!!
1262         cbReadStrFrameLen(pCbCtl, zMD, &pDecDecode1Af->sampleCount);
1264         // Update Stream Audio Frame.
1265         // Copy Dec Reset AF to Stream AF.
1266         outIsCpyAf(pDecDecode1Af, pStrAf);
1268         // outputInfo1():
1269         //      - ASP chain reset,
1270         //      - Enc Info,
1271         //      - Start Output
1272         status = asopDecOutProcDec1(pP, pQ, pAsotCfg, frame);
1273         if (status < 0)
1274         {
1275             return status;
1276         }
1277 #endif
1278         
1279         // Find first Output associated with Master Stream
1280         zO = OUTPUT1;
1281         for (z=ENCODE1; z < ENCODEN; z++)
1282         {
1283             zS = pP->streamsFromEncodes[z]; // get Stream associated with Encoder
1284             if (zS == pAstCfg->masterStr)
1285             {
1286                 // This Encoder is associated with Master Stream.
1287                 // Note other Encoder can also be associated with Master Stream.
1288                 zO = pP->outputsFromEncodes[z]; // get Output associated with Encoder
1289             }
1290         }
1292         //  FL, New IO: API for single Output
1293         // Reset IO Buff & IO Phy
1294         status = asopIoCompsInit(pStrAf->sampleCount, &pAstCfg->xOut[zO], &pAsotCfg->pIoOut[zO]);
1295         if (status < 0)
1296         {
1297             return status;
1298         }
1300         // Initialize Output buffer configuration
1301         status = asopInitOutBufConfig(&pAstCfg->xOut[zO], &pAsotCfg->pIoOut[zO]);
1302         if (status)
1303         {
1304             TRACE_TERSE1("PAF_ASOT_initSyncDecDecode1: asopInitOutBufConfig returns errno 0x%x ", status);
1305             return status;
1306         }
1307         
1308         // FL, New IO: assumption here is Tx McASP clock dividers &
1309         //  Output frame size are set correctly before IO prime, 
1310         //  i.e. IO prime is not using defaults
1311         // FL, New IO: API for single Output
1312         // I/O physical layer prime operation required by McASP LLD
1313         asopIoPhyPrime(&pAsotCfg->pIoOut[zO]);
1314         TRACE_VERBOSE0("PAF_ASOT_initSyncDecDecode1: ASOP McASP LLD primed.");
1315         
1316         return ASOP_SOK;
1317     }
1320 // ASOT SM function
1321 // Process Decoder output audio data
1322 static Int PAF_ASOT_procDecOut(
1323     const PAF_ASOT_Params *pP, 
1324     const PAF_ASOT_Patchs *pQ, 
1325     PAF_ASOT_Config *pAsotCfg, 
1326     Bool *pFirstTime, 
1327     Int frame
1330     PAF_AST_Config *pAstCfg;    // ASIT/ASOT/ASDT shared configuration
1331     Bool outDevSioSelUpdate;    // indicates whether Output SIO selection has changed
1332     Int zO, zS;
1333     Int z;                      // decode/encode counter
1334     Int errno;                  // error number
1335     Int status;                 // status code
1336     
1337     status = ASOP_SOK;
1338     pAstCfg = pAsotCfg->pAstCfg;
1340     if (*pFirstTime == TRUE)
1341     {
1342         // Initialize Decoder output processing
1343         errno = asopDecOutProcInit(pP, pQ, pAsotCfg, frame);
1344         if (errno < 0)
1345         {
1346             status = errno;
1347         }
1348         else
1349         {
1350             *pFirstTime = FALSE;
1351         }
1352     }
1353     
1354     if (status == ASOP_SOK)
1355     {
1356         // Find first Output associated with Master Stream
1357         zO = OUTPUT1;
1358         for (z=ENCODE1; z < ENCODEN; z++)
1359         {
1360             zS = pP->streamsFromEncodes[z]; // get Stream associated with Encoder
1361             if (zS == pAstCfg->masterStr)
1362             {
1363                 // This Encoder is associated with Master Stream.
1364                 // Note other Encoder can also be associated with Master Stream.
1365                 zO = pP->outputsFromEncodes[z]; // get Output associated with Encoder
1366             }
1367         }    
1368         
1369         // Mark Output transfer complete
1370         errno = ioPhyXferComplete(pAsotCfg->pIoOut[zO].hIoPhy, FALSE);
1371         if (errno)
1372         {
1373             status = ASOP_ERR_PROCDECOUT_IOPHYXFERCOMPLETE;
1374         }
1375     }
1376     
1377     if (status == ASOP_SOK)
1378     {
1379         // Check if Output device SIO selection changed
1380         errno = checkOutDevSioSelUpdate(pP, pAsotCfg, zO, &outDevSioSelUpdate);
1381         if (errno)
1382         {
1383             status = ASOP_ERR_PROCDECOUT_CHKOUTDEVSELUPD;
1384         }
1385         else if (outDevSioSelUpdate == TRUE)
1386         {
1387             status = ASOP_ERR_PROCDECOUT_OUTDEVSELUPD;
1388         }
1389     }
1391     if (status == ASOP_SOK)
1392     {
1393         // Process encoder command
1394         errno = asopDecOutProcEncodeCommand(pP, pQ, pAsotCfg);
1395         if (errno < 0)
1396         {
1397             status = errno;
1398         }
1399     }
1401     if (status == ASOP_SOK)
1402     {
1403         // Read CB, execute ASP chain
1404         errno = asopDecOutProcStream(pP, pQ, pAsotCfg, frame);
1405         if (errno < 0)
1406         {
1407             status = errno;
1408         }
1409     }
1411     if (status == ASOP_SOK)
1412     {
1413         size_t totalOutputSize;
1415         // Calculate the total size that encoder will write to output buffer
1416         totalOutputSize = pAstCfg->xEnc[zO].encodeInStruct.pAudioFrame->sampleCount
1417                           * pAstCfg->xOut[zO].outBufConfig.stride
1418                           * pAstCfg->xOut[zO].outBufConfig.sizeofElement;
1420         // Get output buffer pointers for encoder to write. Pointers are stored in pAsotCfg->pIoOut[zO]
1421         asopGetOutBufPtrs(&pAsotCfg->pIoOut[zO], totalOutputSize);
1423         // Invoke the encoder
1424         errno = asopDecOutProcEncodeWrap(pP, pQ, pAsotCfg, frame, zO);
1425         if (errno < 0)
1426         {
1427             status = errno;
1428         }
1430         // Mark Output buffers write complete
1431         asopMarkOutBuffsWriteComplete(&pAstCfg->xOut[zO], &pAsotCfg->pIoOut[zO]);
1432     }
1434     // Audio frame pointers need to be reset because DTS PARMA modifies them!!
1435     resetAfPointers(pP, pAstCfg->xStr);
1437     if (status == ASOP_SOK)
1438     {
1439         // Execute Info2
1440         errno = asopDecOutProcInfo2(pP, pQ, pAsotCfg, frame);
1441         if (errno < 0)
1442         {
1443             status = errno;
1444         }
1445     }
1447     if (status == ASOP_SOK)
1448     {
1449         errno = asopDecOutProcFinalTest(pP, pQ, pAsotCfg, frame);
1450         if (errno < 0)
1451         {
1452             status = errno;
1453         }
1454     }
1456     if (status != ASOP_SOK)    
1457     {
1458         // Complete Output Processing
1459         errno = asopDecOutProcComplete(pP, pQ, pAsotCfg, frame);
1460         if (errno < 0)
1461         {
1462             status = errno;
1463         }
1464     }
1465     
1466     return status;
1469 // Encode function which handles encoding to two output buffers
1470 static Int asopDecOutProcEncodeWrap(
1471     const PAF_ASOT_Params *pP,
1472     const PAF_ASOT_Patchs *pQ,
1473     PAF_ASOT_Config *pAsotCfg,
1474     Int frame,
1475     Int zO
1478     PAF_AST_Config *pAstCfg;    // ASIT/ASOT/ASDT shared configuration
1479     Int errno;                  // error number
1480     Int status;                 // status code
1481     PAF_OutBufConfig *pOutBufCfg;
1482     PAF_AudioFrame * pAf;
1484     status = ASOP_SOK;
1485     pAstCfg = pAsotCfg->pAstCfg;
1486     pOutBufCfg = &(pAstCfg->xOut[zO].outBufConfig);
1487     pAf = pAstCfg->xEnc[zO].encodeInStruct.pAudioFrame;
1489     if (pAsotCfg->pIoOut[zO].buff2 == NULL)
1490     {
1491         // Output buffer won't wrap around - to invoke the encoder once
1492         pOutBufCfg->lengthofFrame = pAf->sampleCount;
1493         pOutBufCfg->pntr.pLgInt   = pAsotCfg->pIoOut[zO].buff1;
1495         // Execute encode
1496         errno = asopDecOutProcEncode(pP, pQ, pAsotCfg, frame);
1497         if (errno < 0)
1498         {
1499             status = errno;
1500         }
1501     }
1502     else
1503     {
1504         //
1505         // Not expected to occur since output buffer is allocated
1506         // to be a multiple of Stream AF sample count x stride x size of element.
1507         // See asopIoCompsInit().
1508         //
1509         SW_BREAKPOINT;
1510      
1511 #if 0
1512         // Output buffer will wrap around - to invoke the encoder twice
1513         XDAS_Int16 sampleCountSave;
1514         PAF_AudioData *afDataAddrSave[PAF_MAXNUMCHAN_AF];
1515         PAF_AudioData **afDataAddr;
1516         int i, ch;
1518         sampleCountSave = pAf->sampleCount;  // save sample count for restoring later
1520         // Invoke the encoder to write data to the end of output buffer
1521         pOutBufCfg->lengthofFrame = pAsotCfg->pIoOut[zO].size1 / (pOutBufCfg->stride * pOutBufCfg->sizeofElement);
1522         pAf->sampleCount = pOutBufCfg->lengthofFrame;
1523         pOutBufCfg->pntr.pLgInt   = pAsotCfg->pIoOut[zO].buff1;
1525         // Execute encode
1526         errno = asopDecOutProcEncode(pP, pQ, pAsotCfg, frame);
1527         if (errno < 0)
1528         {
1529             status = errno;
1530         }
1532         // Adjust audio frame buffer addresses for second invoking of the encoder
1533         afDataAddr = pAf->data.sample;
1534         for(i=0; i<pOutBufCfg->stride; i++)
1535         {
1536             ch = pAstCfg->xEnc[zO].encodeStatus.channelMap.from[i];
1537             if (ch >= 0)
1538             {
1539                 afDataAddrSave[i] = afDataAddr[ch];   // save audio frame buffer addresses
1540                 afDataAddr[ch] = &afDataAddr[ch][pOutBufCfg->lengthofFrame];
1541             }
1542         }
1544         // Invoke the encoder to write data to the beginning of output buffer (wrapping around)
1545         pOutBufCfg->lengthofFrame = pAsotCfg->pIoOut[zO].size2 / (pOutBufCfg->stride * pOutBufCfg->sizeofElement);
1546         pAf->sampleCount = pOutBufCfg->lengthofFrame;
1547         pOutBufCfg->pntr.pLgInt   = pAsotCfg->pIoOut[zO].buff2;
1549         // Execute encode
1550         errno = asopDecOutProcEncode(pP, pQ, pAsotCfg, frame);
1551         if (errno < 0)
1552         {
1553             status = errno;
1554         }
1556         // Restore sample count and audio frame buffer addresses
1557         pAf->sampleCount = sampleCountSave;
1558         for(i=0; i<pOutBufCfg->stride; i++)
1559         {
1560             ch = pAstCfg->xEnc[zO].encodeStatus.channelMap.from[i];
1561             if (ch >= 0)
1562             {
1563                 afDataAddr[ch] = afDataAddrSave[i];
1564             }
1565         }
1567         pAsotCfg->pIoOut[zO].ioBuffBuf2AllocCnt++; // debug
1568 #endif        
1569     }
1571     return status;
1574 // ASOT SM function
1575 //   Purpose:   Init-Sync Re-Sync state function.
1576 //              Performs Init-Sync using stored Init-Sync AFs.
1577 static Int PAF_ASOT_initSyncResync(
1578     const PAF_ASOT_Params *pP, 
1579     const PAF_ASOT_Patchs *pQ, 
1580     PAF_ASOT_Config *pAsotCfg,
1581     PAF_AudioFrame *pDecResetAf,
1582     PAF_AudioFrame *pDecInfo1Af,
1583     PAF_AudioFrame *pDecDecode1Af, 
1584     Int frame
1587     PAF_AST_Config *pAstCfg;            // ASIT/ASOT/ASDT shared configuration
1588     Int zMD;                            // Dec Master index
1589     Int zMS;                            // Stream Master index
1590     PAF_AudioFrame *pStrAf;             // stream audio frame
1591     Int status;                         // status code
1592     PAF_AST_DecOpCircBufCtl *pCbCtl;    // Decoder output circular buffer control
1594     pAstCfg = pAsotCfg->pAstCfg;
1595     zMD = pAstCfg->masterDec;
1596     zMS = pAstCfg->masterStr;
1597     pStrAf = pAstCfg->xStr[zMS].pAudioFrame;
1598         
1599     // Reset audio frames
1600     resetAfs(pP, pAstCfg->xStr);
1601     
1602     //
1603     // Dec Reset re-sync using stored Dec Reset AF
1604     //
1605     
1606     // Update Stream Audio Frame.
1607     // Copy Dec Reset AF to Stream AF.
1608     outIsCpyAf(pDecResetAf, pStrAf);
1609     
1610     // Enc activate,
1611     // Enc reset
1612     status = asopDecOutProcReset(pP, pQ, pAsotCfg, frame);
1613     if (status < 0)
1614     {
1615         return status;
1616     }
1617     
1618     //
1619     // Dec Info1 re-sync using stored Dec Info1 AF
1620     //
1621     
1622 #if 0
1623     // Update Stream Audio Frame.
1624     // Copy Dec Info1 AF to Stream AF.
1625     outIsCpyAf(pDecInfo1Af, pStrAf);
1626     
1627     // outputInfo1():
1628     //      - ASP chain reset,
1629     //      - Enc Info,
1630     //      - Start Output
1631     status = asopDecOutProcInfo1(pP, pQ, pAsotCfg, frame);
1632     if (status < 0)
1633     {
1634         return status;
1635     }
1636 #endif
1638     //
1639     // Dec Decode1 re-sync using stored Dec Decode1 AF
1640     //
1642     // Get pointer to circular buffer control
1643     pCbCtl = &pAsotCfg->pAspmCfg->decOpCircBufCtl;
1645     // Initialize decoder output circular buffer for stream reads
1646     cbInitStreamRead(pCbCtl, zMD);
1648     // Set ASOT output frame length.
1649     //  Frame length is initialized to CB stream (read) frame length.
1650     //  CB stream frame length modified via SRC reset in ASP chain reset if SRC enabled.
1651     cbReadStrFrameLen(pCbCtl, zMD, &pDecDecode1Af->sampleCount);
1652     
1653     // Update Stream Audio Frame.
1654     // Copy Dec Info1 AF to Stream AF.
1655     outIsCpyAf(pDecInfo1Af, pStrAf);
1656     
1657     // outputInfo1():
1658     //      - ASP chain reset,
1659     //      - Enc Info,
1660     //      - Start Output
1661     status = asopDecOutProcInfo1(pP, pQ, pAsotCfg, frame);
1662     if (status < 0)
1663     {
1664         return status;
1665     }
1666     
1667     return ASOP_SOK;
1670 // ASOT SM function
1671 //   Purpose:   Re-select devices used for Output.
1672 //              Performs Init-Sync using stored Init-Sync AFs.
1673 static Int PAF_ASOT_reselectDevices(
1674     const PAF_ASOT_Params *pP, 
1675     const PAF_ASOT_Patchs *pQ, 
1676     PAF_ASOT_Config *pAsotCfg,
1677     PAF_AudioFrame *pDecResetAf,
1678     PAF_AudioFrame *pDecInfo1Af,
1679     PAF_AudioFrame *pDecDecode1Af, 
1680     Int frame, 
1681     Bool *pOutDevSel
1684     Bool outDevSel;
1685     Int status;
1686     
1687     // Re-select Output devices
1688     status = PAF_ASOT_selectDevices(pP, pQ, pAsotCfg, &outDevSel);
1689     if (status < 0)
1690     {
1691         *pOutDevSel = outDevSel;
1692         return status;
1693     }
1694     else if (outDevSel == FALSE)
1695     {
1696         *pOutDevSel = outDevSel;
1697         return status;
1698     }
1699     else
1700     {
1701         // Init-Sync Resync
1702         status = PAF_ASOT_initSyncResync(pP, pQ, pAsotCfg, pDecResetAf, pDecInfo1Af, pDecDecode1Af, frame);
1703         if (status < 0)
1704         {
1705             outDevSel = FALSE;
1706             *pOutDevSel = outDevSel;
1707             return status;
1708         }
1709     }
1710     
1711     *pOutDevSel = outDevSel;
1712     return status;