b3b4319996b455e72be6ee5b876f23b07f3a2d73
[processor-sdk/performance-audio-sr.git] / pasdk / 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 "audioStreamProc_common.h"
45 #include "audioStreamOutProc.h"
46 #include "audioStreamOutInit.h"
47 #include "audioStreamOutDec.h"
48 #include "audioStreamOutIo.h"
50 //#include "pfp/pfp.h"
51 //#include "pfp_app.h"        /* contains all PFP ID's */
52 //Int32 gNumPfpAsot1=0; // debug
54 // debug
55 //#include "evmc66x_gpio_dbg.h"
57 //#include "ioConfig.h"
59 // -----------------------------------------------------------------------------
60 // Debugging Trace Control, local to this file.
61 // 
62 #include "logp.h"
64 // Allow a developer to selectively enable tracing.
65 #define CURRENT_TRACE_MASK      0x07
67 #define TRACE_MASK_TERSE        0x01   // only flag errors and show init
68 #define TRACE_MASK_GENERAL      0x02   // half dozen lines per frame
69 #define TRACE_MASK_VERBOSE      0x04   // trace full operation
71 #if !(CURRENT_TRACE_MASK & TRACE_MASK_TERSE)
72     #undef  TRACE_TERSE0
73     #undef  TRACE_TERSE1
74     #undef  TRACE_TERSE2
75     #undef  TRACE_TERSE3
76     #undef  TRACE_TERSE4
77     #define TRACE_TERSE0(a)
78     #define TRACE_TERSE1(a,b)
79     #define TRACE_TERSE2(a,b,c)
80     #define TRACE_TERSE3(a,b,c,d)
81     #define TRACE_TERSE4(a,b,c,d,e)
82 #endif
83     
84 #if !(CURRENT_TRACE_MASK & TRACE_MASK_GENERAL)
85     #undef  TRACE_GEN0
86     #undef  TRACE_GEN1
87     #undef  TRACE_GEN2
88     #undef  TRACE_GEN3
89     #undef  TRACE_GEN4
90     #define TRACE_GEN0(a)
91     #define TRACE_GEN1(a,b)
92     #define TRACE_GEN2(a,b,c)
93     #define TRACE_GEN3(a,b,c,d)
94     #define TRACE_GEN4(a,b,c,d,e)
95 #endif
97 #if !(CURRENT_TRACE_MASK & TRACE_MASK_VERBOSE)
98     #undef  TRACE_VERBOSE0
99     #undef  TRACE_VERBOSE1
100     #undef  TRACE_VERBOSE2
101     #undef  TRACE_VERBOSE3
102     #undef  TRACE_VERBOSE4
103     #define TRACE_VERBOSE0(a)
104     #define TRACE_VERBOSE1(a,b)
105     #define TRACE_VERBOSE2(a,b,c)
106     #define TRACE_VERBOSE3(a,b,c,d)
107     #define TRACE_VERBOSE4(a,b,c,d,e)
108 #endif
110 // -----------------------------------------------------------------------------
111 //
112 // Audio Stream Output Task definitions
113 //
115 #define __TASK_NAME__  "TaskAsop"
117 // status codes
118 // ASOT FSM
119 #define ASOP_SOK_INITSYNC_NOTREADY              (   1 ) // ok, init-sync not ready
120 #define ASOP_SOK                                (   0 ) // ok
121 #define ASOP_ERR_FORWARD_ERR                    (  -1 ) // error, forward (ASIT) error
122 #define ASOP_ERR_RESETOUTPROC_NOOUTDEVSEL       (  -2 ) // error, reset dec out proc, no output device selected
123 #define ASOP_ERR_PROCDECOUT_OUTDEVSELUPD        (  -3 ) // error, proc dec out, output device select updated
124 #define ASOP_ERR_PROCDECOUT_IOPHYXFERCOMPLETE   (  -4 ) // error, proc dec out, io phy transfer complete
125 #define ASOP_ERR_PROCDECOUT_CHKOUTDEVSELUPD     (  -5 ) // error, proc dec out, check output device select update
127 // -----------------------------------------------------------------------------
129 // ASOT FSM states 
130 enum 
131
132     ASOT_STATE_SEL_OUT_DEV, 
133     ASOT_STATE_RESET_OUT_PROC, 
134     ASOT_STATE_INITSYNC_DEC_INFO1, 
135     ASOT_STATE_INITSYNC_DEC_DECODE1, 
136     ASOT_STATE_PROC_DEC_OUT,
137     ASOT_STATE_RESEL_OUT_DEV,
138     ASOT_STATE_INITSYNC_RESYNC
139 };
141 // Check if Output device selected
142 static Int checkOutDevSel(
143     PAF_AST_IoOut *pOut,
144     Bool *pOutDevSel);
145     
146 // Check if any Output device selected
147 static Int checkAnyOutDevSel(
148     const PAF_ASOT_Params *pP,
149     PAF_AST_IoOut *pOut,
150     Bool *pOutDevSel);
152 // ASOT SM function
153 //   Purpose:   Audio Stream Output Task Function for selecting the devices used
154 //              for output.
155 static Int PAF_ASOT_selectDevices(
156     const PAF_ASOT_Params *pP, 
157     const PAF_ASOT_Patchs *pQ, 
158     PAF_ASOT_Config *pAsotCfg,
159     Bool *pOutDevSel
160 );
162 // Reset audio frame pointers to original values
163 static Void resetAfPointers(
164     const PAF_ASOT_Params *pP, 
165     PAF_AST_Stream *xStr
166 );
168 // Reset audio frame meta data elements
169 static Void resetAfMetadata(
170     const PAF_ASOT_Params *pP, 
171     PAF_AST_Stream *xStr
172 );
174 // Reset audio frames
175 static Void resetAfs(
176     const PAF_ASOT_Params *pP, 
177     PAF_AST_Stream *xStr
178 );
180 // used by new OutProc.c, will be changed back to static once refactoring is done
181 //   Purpose:   Init-Sync Dec Reset state function.
182 //              Performs Dec Reset Init-Sync.
183 static Int PAF_ASOT_initSyncDecReset(
184     const PAF_ASOT_Params *pP, 
185     const PAF_ASOT_Patchs *pQ, 
186     PAF_ASOT_Config *pAsotCfg,
187     PAF_AudioFrame *pDecResetAf,
188     Int frame
189 );
191 // ASOT SM function
192 // Reset Decoder Output processing
193 static Int PAF_ASOT_resetDecOutProc(
194     const PAF_ASOT_Params *pP, 
195     const PAF_ASOT_Patchs *pQ, 
196     PAF_ASOT_Config *pAsotCfg,
197     PAF_AudioFrame *pDecResetAf,
198     Bool outDevSel,
199     Int frame
200 );
202 // ASOT SM function
203 //   Purpose:   Init-Sync Dec Info1 state function.
204 //              Performs Dec Info1 Init-Sync.
205 static Int PAF_ASOT_initSyncDecInfo1(
206     const PAF_ASOT_Params *pP, 
207     const PAF_ASOT_Patchs *pQ, 
208     PAF_ASOT_Config *pAsotCfg,
209     PAF_AudioFrame *pDecInfo1Af, 
210     Int frame
211 );
213 // ASOT SM function
214 //   Purpose:   Init-Sync Dec Decode1 state function.
215 //              Performs Dec Decode1 Init-Sync.
216 static Int PAF_ASOT_initSyncDecDecode1(
217     const PAF_ASOT_Params *pP, 
218     const PAF_ASOT_Patchs *pQ, 
219     PAF_ASOT_Config *pAsotCfg, 
220     Int frame
221 );
223 // ASOT SM function
224 // Process Decoder output audio data
225 static Int PAF_ASOT_procDecOut(
226     const PAF_ASOT_Params *pP, 
227     const PAF_ASOT_Patchs *pQ, 
228     PAF_ASOT_Config *pAsotCfg, 
229     Bool *pFirstTime, 
230     Int frame
231 );
233 // ASOT SM function
234 //   Purpose:   Init-Sync Re-Sync state function.
235 //              Performs Init-Sync using stored Dec Reset/Info1 AFs.
236 static Int PAF_ASOT_initSyncResync(
237     const PAF_ASOT_Params *pP, 
238     const PAF_ASOT_Patchs *pQ, 
239     PAF_ASOT_Config *pAsotCfg,
240     PAF_AudioFrame *pDecResetAf,
241     PAF_AudioFrame *pDecInfo1Af, 
242     Int frame
243 );
245 // ASOT SM function
246 //   Purpose:   Re-select devices used for Output.
247 //              Performs Init-Sync using stored Dec Reset/Info1 AFs.
248 static Int PAF_ASOT_reselectDevices(
249     const PAF_ASOT_Params *pP, 
250     const PAF_ASOT_Patchs *pQ, 
251     PAF_ASOT_Config *pAsotCfg,
252     PAF_AudioFrame *pDecResetAf,
253     PAF_AudioFrame *pDecInfo1Af,
254     Int frame, 
255     Bool *pOutDevSel
256 );
257    
259 // FL: debug, allow modification of Output frame length via JTAG.
260 Int16 gOutFrameLen=PAF_ASOT_FRAMELENGTH; // output frame length (PCM samples)
262 // ASOT configuration
263 #pragma DATA_SECTION(gPAF_ASOT_config, ".globalSectionPafAsotConfig")
264 PAF_ASOT_Config gPAF_ASOT_config = {
265     NULL,               // taskHandle
266     0,                  // asotState
267     NULL,               // acp
268     0,0,0,              // cbDrainedFlag (size DECODE_MAXN)
269     &gPAF_ASPM_config,  // pAspmCfg
270     &gPAF_AST_config    // pAstCfg
271 };
273 /* ASOT event handle - to put in structure */
274 Event_Handle asotEvt;
276 extern Int d10Initialized;
278 // For writeDECCommandRestart
279 extern volatile UInt32 gCommandOutputTask_SYNC;
280 extern volatile UInt32 gCommandOutputTask_ACK;
282 LINNO_DEFN(TaskAsop); // Line number macros
283 ERRNO_DEFN(TaskAsop); // Error number macros
285 #define ASOP_DEBUG
286 #ifdef ASOP_DEBUG
287 Int asopLoopCount;
288 #endif
290 // Debug event-in-state counters
291 UInt32 gSelOutDevState_EvtWakeTimer_cnt                 = 0; // Select Output state, Wake Timer event count
292 UInt32 gSelOutDevState_EvtTxMcaspEdma_invCnt            = 0; // Select Output state, invalid Tx McASP EDMA event count
293 UInt32 gSelOutDevState_Evt_invCnt                       = 0; // Select Output state, invalid other event count
294 UInt32 gResetOutProcState_EvtWakeTimer_cnt              = 0; // Select Output state, Wake Timer event count
295 UInt32 gResetOutProcState_EvtTxMcaspEdma_invCnt         = 0; // Reset Output Processing state, invalid Tx McASP EDMA event count
296 UInt32 gResetOutProcState_Evt_invCnt                    = 0; // Reset Output Processing state, invalid other event count
297 UInt32 gInitSyncDecInfo1State_EvtWakeTimer_cnt          = 0; // Init-Sync Dec Info1 state, Wake Timer event count
298 UInt32 gInitSyncDecInfo1State_EvtTxMcaspEdma_invCnt     = 0; // Init-Sync Dec Info1 state, invalid Tx McASP EDMA event count
299 UInt32 gInitSyncDecInfo1State_Evt_invCnt                = 0; // Init-Sync Dec Info1 state, invalid other event count
300 UInt32 gInitSyncDecDecode1State_EvtWakeTimer_cnt        = 0; // Init-Sync Dec Decode1 state, Wake Timer event count
301 UInt32 gInitSyncDecDecode1State_EvtTxMcaspEdma_invCnt   = 0; // Init-Sync Dec Decode1 state, invalid Tx McASP EDMA event count
302 UInt32 gInitSyncDecDecode1State_Evt_invCnt              = 0; // Init-Sync Dec Decode1 state, invalid other event count
303 UInt32 gProcDecOutState_EvtWakeTimer_cnt                = 0; // Process Output state, Wake Timer event count 
304 UInt32 gProcDecOutState_EvtTxMcaspEdma_cnt              = 0; // Process Output state, Tx McASP EDMA event count
305 UInt32 gProcDecOutState_Evt_invCnt                      = 0; // Process Output state, invalid other event count
306 UInt32 gReselOutDevState_EvtWakeTimer_cnt               = 0; // Process Output state, Wake Timer event count 
307 UInt32 gReselOutDevState_EvtTxMcaspEdma_invCnt          = 0; // Re-select Output state, invalid other event count
308 UInt32 gReselOutDevState_Evt_invCnt                     = 0; // Re-select Output state, invalid other event count
309 // Debug state counters
310 UInt32 gAsotInitSyncResyncState_Cnt                     = 0; // Init-Sync Re-sync (Local error) state execution count
311 UInt32 gAsotInvState_Cnt                                = 0; // invalid state count
314 /*
315  *  ======== taskAsopFxn ========
316  *  Audio Stream Output Processing task function
317  */
318 Void taskAsopFxn(
319     const PAF_ASOT_Params *pP,
320     const PAF_ASOT_Patchs *pQ
323     PAF_ASOT_Config *pAsotCfg;      // ASOT configuration pointer
324     PAF_AST_Config *pAstCfg;        // Common (shared) configuration pointer
325     Int as;                         // Audio Stream Number (1, 2, etc.)
326     Int z;                          // input/encode/stream/decode/output counter
327     Bool outDevSel;                 // whether output device selected
328     PAF_AudioFrame decResetAf;
329     PAF_AudioFrame decInfo1Af;
330     UInt events;                    // latched event flags
331     Bool procEvents;                // process events flags
332     Bool procOutFirstTime;          // first time process output flag
333     Int asopFrameCount;             // frame counter
334     Int status;                     // status code
335 #ifndef ASOP_DEBUG
336     Int asopLoopCount;              // debug, ASOT loop counter
337 #endif
339     Log_info0("Enter taskAsopFxn()");
341     taskAsopFxnInit(pP, pQ);    // initialization of output task
342     
343     //
344     // Audio Stream Output Task Configuration (*pAsotCfg):
345     //
346     pAsotCfg = &gPAF_ASOT_config;       // initialize pointer to task configuration
347     pAstCfg = pAsotCfg->pAstCfg;        // get pointer to AST common (shared) configuration
348     as = pAstCfg->as;                   // obtain Audio Stream Number (1, 2, etc.)
350     //
351     // Main processing loop
352     //
353     for (z=STREAM1; z < STREAMN; z++)
354     {
355         TRACE_VERBOSE1("TaskAsop: AS%d: running", as+z);
356     }
358     pAsotCfg->state = ASOT_STATE_SEL_OUT_DEV;   // init state
359     procEvents = TRUE;                          // init proc events flag
360     procOutFirstTime = TRUE;                    // init first time process output flag
361     asopFrameCount = 0;                         // init frame counter TBD
362     asopLoopCount = 0;                          // loop counter
363     for (;;)
364     {
365         // Pend for next event
366         //  Evt_Id_AsotWakeTimer    : Wakeup timer (poll for Output device selection)
367         //  Evt_Id_AsotTxMcaspEdma  : Tx McASP EDMA completion
368         if (procEvents == TRUE)
369         {
370             events = Event_pend(asotEvt, Event_Id_NONE, (Evt_Id_AsotWakeTimer + Evt_Id_AsotTxMcaspEdma), BIOS_WAIT_FOREVER);
371         }
373         asopLoopCount++;
374         TRACE_GEN1("TaskAsop (begin Main loop %d)", asopLoopCount);
376         switch (pAsotCfg->state)
377         {
378             //
379             //  Select Output Device state
380             //
381             case ASOT_STATE_SEL_OUT_DEV:
382                 if (events & Evt_Id_AsotWakeTimer)
383                 {
384                     gSelOutDevState_EvtWakeTimer_cnt++;
385                     events &= ~Evt_Id_AsotWakeTimer; // clear event
386                     
387                     // Select Output devices
388                     //  outDevSel==TRUE if Output device selection successful
389                     status = PAF_ASOT_selectDevices(pP, pQ, pAsotCfg, &outDevSel);
390                     if (status < 0)
391                     {
392                         // FL, New IO: 
393                         //Tx status==error message to ASIT;   // ASOT initiated message to ASIT, "backward" error
394                         
395                         // No explicit handling of Select Output Device error, so stay in state and try again
396                         pAsotCfg->state = ASOT_STATE_SEL_OUT_DEV;
397                         break;
398                     }
399                     else if (outDevSel == TRUE)
400                     {
401                         // Select successful
402                         pAsotCfg->state = ASOT_STATE_RESET_OUT_PROC;
403                     }
404                     else
405                     {
406                         // No output device selected (outDevSel == FALSE).
407                         // Remain in current state.
408                         ;
409                     }
410                 }
411                 
412                 // Check for unexpected Tx McASP EDMA event
413                 if (events & Evt_Id_AsotTxMcaspEdma)
414                 {
415                     gSelOutDevState_EvtTxMcaspEdma_invCnt++; // log invalid event count in state
416                     TRACE_TERSE2("TaskAsop: invalid Tx McASP EDMA event, state=%u, events=%u", pAsotCfg->state, events);
417                     events &= ~Evt_Id_AsotTxMcaspEdma; // clear event
418                 }
420                 // Check for any other unexpected events
421                 if (events != 0)
422                 {
423                     gSelOutDevState_Evt_invCnt++; // log invalid event count in state
424                     TRACE_TERSE2("TaskAsop: invalid events, state=%u, events=%u", pAsotCfg->state, events);
425                     events &= ~events; // clear events
426                 }
427                 
428                 break;
429                 
430             // FL, New IO: currently using timer event
431             //
432             //  Reset Output Processing state
433             //
434             case ASOT_STATE_RESET_OUT_PROC:
435                 if (events & Evt_Id_AsotWakeTimer)
436                 {
437                     gResetOutProcState_EvtWakeTimer_cnt++;
438                     events &= ~Evt_Id_AsotWakeTimer; // clear event
439                     
440                     //
441                     // Allow Output device re-selection prior to Output processing.
442                     //  Output device selection has already been performed in state==ASOT_STATE_SEL_OUT_DEV.
443                     //  Output device can be re-selected via alpha commands before streaming is initiated.
444                     //  Here check whether this has occurred.
445                     //
446                     
447                     // Select Output devices
448                     //  outDevSel==TRUE if Output device selection successful
449                     status = PAF_ASOT_selectDevices(pP, pQ, pAsotCfg, &outDevSel);
450                     if (status < 0)
451                     {
452                         // FL, New IO: 
453                         //Tx status==error message to ASIT;   // ASOT initiated message to ASIT, "backward" error
454                         
455                         // Starting over with Output device selection in case of error                        
456                         pAsotCfg->state = ASOT_STATE_SEL_OUT_DEV;
457                         break;
458                     }
459                     
460                     // Reset Output processing
461                     status = PAF_ASOT_resetDecOutProc(pP, pQ, pAsotCfg, &decResetAf, outDevSel, asopFrameCount);
462                     if (status < 0)
463                     {
464                         // FL, New IO: 
465                         //Tx status==error message to ASDT; // feedback message ASOT -> ASDT
466                         
467                         pAsotCfg->state = ASOT_STATE_SEL_OUT_DEV;   // starting over with Output device selection in case of error
468                         break;
469                     }
470                     else if (status == ASOP_SOK_INITSYNC_NOTREADY)
471                     {
472                         // FL, New IO: this is only necessary for Wake Timer, POLLING Init-Sync
473                         // FL, New IO: can be removed once Rx ASDT messages are implemented for Init-Sync
474                         
475                         // Dec Reset Init-Sync not ready.
476                         // Remain in current state.
477                         ;
478                     }
479                     else
480                     {
481                         // FL, New IO: 
482                         //Tx status==ok message to ASDT; // feedback message ASOT -> ASDT
483                         
484                         pAsotCfg->state = ASOT_STATE_INITSYNC_DEC_INFO1;
485                     }
486                 }
487                 
488                 // Check for unexpected Tx McASP EDMA event
489                 if (events & Evt_Id_AsotTxMcaspEdma)
490                 {
491                     gResetOutProcState_EvtTxMcaspEdma_invCnt++; // log invalid event count in state
492                     TRACE_TERSE2("TaskAsop: Tx McASP EDMA event, state=%u, events=%u", pAsotCfg->state, events);
493                     events &= ~Evt_Id_AsotTxMcaspEdma; // clear event
494                 }
496                 // Check for any other unexpected events
497                 if (events != 0)
498                 {
499                     gResetOutProcState_Evt_invCnt++; // log invalid event count in state
500                     TRACE_TERSE2("TaskAsop: invalid events, state=%u, events=%u", pAsotCfg->state, events);
501                     events &= ~events; // clear events
502                 }
503                 
504                 break;
505                 
506             // FL, New IO: currently using timer event
507             //
508             //  Init-Sync Info1 state
509             //
510             case ASOT_STATE_INITSYNC_DEC_INFO1:
511                 if (events & Evt_Id_AsotWakeTimer)
512                 {
513                     gInitSyncDecInfo1State_EvtWakeTimer_cnt++;
514                     events &= ~Evt_Id_AsotWakeTimer; // clear event
515                     
516                     status = PAF_ASOT_initSyncDecInfo1(pP, pQ, pAsotCfg, &decInfo1Af, asopFrameCount);
517                     if (status < 0)
518                     {
519                         // FL, New IO: 
520                         //Tx status==error message to ASDT;   // feedback message ASOT -> ASDT
521                         
522                         pAsotCfg->state = ASOT_STATE_SEL_OUT_DEV;          // starting over with Output device selection in case of error
523                         break;
524                     }
525                     else if (status == ASOP_SOK_INITSYNC_NOTREADY)
526                     {
527                         // FL, New IO: this is only necessary for Wake Timer, POLLING Init-Sync
528                         // FL, New IO: can be removed once Rx ASDT messages are implemented for Init-Sync
529                         
530                         // Dec Reset Init-Sync not ready.
531                         // Remain in current state.
532                         ;
533                     }
534                     else
535                     {
536                         // FL, New IO: 
537                         //Tx status==ok message to ASDT;      // feedback message ASOT -> ASDT
538                         
539                         pAsotCfg->state = ASOT_STATE_INITSYNC_DEC_DECODE1;
540                     }
541                 }
543                 // Check for unexpected Tx McASP EDMA event
544                 if (events & Evt_Id_AsotTxMcaspEdma)
545                 {
546                     gInitSyncDecInfo1State_EvtTxMcaspEdma_invCnt++; // log invalid event count in state
547                     TRACE_TERSE2("TaskAsop: Tx McASP EDMA event, state=%u, events=%u", pAsotCfg->state, events);
548                     events &= ~Evt_Id_AsotTxMcaspEdma; // clear event
549                 }
551                 // Check for any other unexpected events
552                 if (events != 0)
553                 {
554                     gInitSyncDecInfo1State_Evt_invCnt++; // log invalid event count in state
555                     TRACE_TERSE2("TaskAsop: invalid events, state=%u, events=%u", pAsotCfg->state, events);
556                     events &= ~events; // clear events
557                 }
558                 
559                 break;
560             
561             // FL, New IO: currently using timer event
562             //
563             //  Init-Sync Decode1 state
564             //
565             case ASOT_STATE_INITSYNC_DEC_DECODE1:
566                 if (events & Evt_Id_AsotWakeTimer)
567                 {
568                     gInitSyncDecDecode1State_EvtWakeTimer_cnt++;
569                     events &= ~Evt_Id_AsotWakeTimer; // clear event
570                     
571                     status = PAF_ASOT_initSyncDecDecode1(pP, pQ, pAsotCfg, asopFrameCount);
572                     if (status < 0)
573                     {
574                         // FL, New IO: 
575                         //Tx status==error message to ASDT;   // feedback message ASOT -> ASDT
576                         
577                         pAsotCfg->state = ASOT_STATE_SEL_OUT_DEV;          // starting over with Output device selection in case of error
578                         break;
579                     }
580                     else if (status == ASOP_SOK_INITSYNC_NOTREADY)
581                     {
582                         // FL, New IO: this is only necessary for Wake Timer, POLLING Init-Sync
583                         // FL, New IO: can be removed once Rx ASDT messages are implemented for Init-Sync
584                         
585                         // Dec Reset Init-Sync not ready.
586                         // Remain in current state.
587                         ;
588                     }
589                     else
590                     {
591                         // FL, New IO: 
592                         //Tx status==ok message to ASDT;      // feedback message ASOT -> ASDT
593                         
594                         pAsotCfg->state = ASOT_STATE_PROC_DEC_OUT;
595                         procOutFirstTime = TRUE;
596                     }
597                 }
598             
599                 // Check for unexpected Tx McASP EDMA event
600                 if (events & Evt_Id_AsotTxMcaspEdma)
601                 {
602                     gInitSyncDecDecode1State_EvtTxMcaspEdma_invCnt++; // log invalid event count in state
603                     TRACE_TERSE2("TaskAsop: Tx McASP EDMA event, state=%u, events=%u", pAsotCfg->state, events);
604                     events &= ~Evt_Id_AsotTxMcaspEdma; // clear event
605                 }
607                 // Check for any other unexpected events
608                 if (events != 0)
609                 {
610                     gInitSyncDecDecode1State_Evt_invCnt++; // log invalid event count in state
611                     TRACE_TERSE2("TaskAsop: invalid events, state=%u, events=%u", pAsotCfg->state, events);
612                     events &= ~events; // clear events
613                 }
614                 
615                 break;
616                 
617             //
618             //  Process Decoder Output state
619             //
620             case ASOT_STATE_PROC_DEC_OUT:
621                 if (events & Evt_Id_AsotTxMcaspEdma)
622                 {
623                     gProcDecOutState_EvtTxMcaspEdma_cnt++;
624                     events &= ~Evt_Id_AsotTxMcaspEdma; // clear event
626                     // Process Output
627                     status = PAF_ASOT_procDecOut(pP, pQ, pAsotCfg, &procOutFirstTime, asopFrameCount);
628                     if (status < 0)
629                     {
630                         if (status == ASOP_DOP_ERR_FINALTEST_CBDRAINED)
631                         {
632                             // normal completion, CB drained @ EOS
633                             pAsotCfg->state = ASOT_STATE_SEL_OUT_DEV;
634                             break;
635                             
636                         }
637                         else if (status == ASOP_ERR_PROCDECOUT_OUTDEVSELUPD)
638                         {
639                             // Output re-select
640                             pAsotCfg->state = ASOT_STATE_RESEL_OUT_DEV;
641                             break;
642                         }
643                         // FL, New IO: "backward" error handling.
644                         // Currently all errors handled locally.
645                         else
646                         {
647                             // Handle ASOT "local" errors
648                             pAsotCfg->state = ASOT_STATE_INITSYNC_RESYNC;
649                             procEvents = FALSE;
650                             break;
651                         }
652                     }
653                 }
654             
655                 // Check for Wakeup Timer event.
656                 //  Wakeup Timer events are allowed to occur, but no processing is 
657                 //  performed in response to such an event.
658                 if (events & Evt_Id_AsotWakeTimer)
659                 {
660                     events &= ~Evt_Id_AsotWakeTimer; // clear event
661                     gProcDecOutState_EvtWakeTimer_cnt++; // log event count in state
662                 }
663             
664                 // Check for any other unexpected events
665                 if (events != 0)
666                 {
667                     gProcDecOutState_Evt_invCnt++; // log invalid event count in state
668                     TRACE_TERSE2("TaskAsop: invalid events, state=%u, events=%u", pAsotCfg->state, events);
669                     events &= ~events; // clear events
670                 }
671             
672                 break;
673                 
674             //
675             //  Re-Select Output Device state
676             //
677             case ASOT_STATE_RESEL_OUT_DEV:
678                 if (events & Evt_Id_AsotWakeTimer)
679                 {
680                     gReselOutDevState_EvtWakeTimer_cnt++;
681                     events &= ~Evt_Id_AsotWakeTimer; // clear event
682                     
683                     status = PAF_ASOT_reselectDevices(pP, pQ, pAsotCfg, &decResetAf, &decInfo1Af, asopFrameCount, &outDevSel);
684                     if (status < 0)
685                     {
686                         // FL, New IO: 
687                         //Tx status==error message to ASIT;       // ASOT initiated message to ASIT, "backward" error
688                         
689                         pAsotCfg->state = ASOT_STATE_SEL_OUT_DEV;   // starting over with Output device selection in case of error
690                         break;
691                     }
692                     else if (outDevSel == TRUE)
693                     {
694                         // Re-select successful
695                         pAsotCfg->state = ASOT_STATE_PROC_DEC_OUT;
696                         procOutFirstTime = TRUE;
697                     }
698                     else
699                     {
700                         // No output device selected (outDevSel == FALSE).
701                         // Remain in current state.
702                         ;                
703                     }
704                 }
705             
706                 // Check for unexpected Tx McASP EDMA event
707                 if (events & Evt_Id_AsotTxMcaspEdma)
708                 {
709                     events &= ~Evt_Id_AsotTxMcaspEdma; // clear event
710                     gReselOutDevState_EvtTxMcaspEdma_invCnt++; // log invalid event count in state
711                 }
713                 // Check for any other unexpected events
714                 if (events != 0)
715                 {
716                     gReselOutDevState_Evt_invCnt++; // log invalid event count in state
717                     TRACE_TERSE2("TaskAsop: invalid events, state=%u, events=%u", pAsotCfg->state, events);
718                     events &= ~events; // clear events
719                 }
720             
721                 break;
722                 
723             //
724             //   Init-Sync Re-sync (Process Output Local Error) state
725             //
726             case ASOT_STATE_INITSYNC_RESYNC: // not event driven state
727                 gAsotInitSyncResyncState_Cnt++;
728                 
729                 status = PAF_ASOT_initSyncResync(pP, pQ, pAsotCfg, &decResetAf, &decInfo1Af, asopFrameCount);
730                 if (status < 0)
731                 {
732                     // FL, New IO: 
733                     //Tx status==error message to ASIT;   // ASIT initiated message to ASOT, "backward" error
734                     
735                     pAsotCfg->state = ASOT_STATE_SEL_OUT_DEV;     // starting over with Output device selection in case of error
736                     procEvents = TRUE;
737                     break;
738                 }
739                 else
740                 {
741                     pAsotCfg->state = ASOT_STATE_PROC_DEC_OUT;
742                     procEvents = TRUE;
743                     procOutFirstTime = TRUE;
744                 }
745             
746                 break;
747                 
748             default: 
749                 gAsotInvState_Cnt++;
750                 TRACE_TERSE1("TaskAsop: invalid state, state=%u", pAsotCfg->state);
751             
752                 break;
753         }
755         // FL, New IO: handle ASIT messages separately in each state
756         // FL, New IO: proper SM clean up can be skipped if forward error / DEC restart is handled in this way
757         
758         //
759         // Check forward (ASIT) error, TBD
760         //
761         
762         // Check writeDECCommandRestart, TBD
763         if (gCommandOutputTask_SYNC) 
764         {
765             TRACE_TERSE0("TaskAsop: ack writeDECCommandRestart ... Wait for command de-assert");
766             gCommandOutputTask_ACK = 1;
767             while (gCommandOutputTask_SYNC) 
768             {
769                 Event_pend(asotEvt, Event_Id_NONE, Evt_Id_AsotWakeTimer, BIOS_WAIT_FOREVER);
770             }
771             TRACE_TERSE0("TaskAsop: ack for writeDECCommandRestart ... Sync-ed! Re-start the process");
772             pAsotCfg->state = ASOT_STATE_SEL_OUT_DEV;   // init state -- start over
773             status = ASOP_ERR_FORWARD_ERR;              // set status -- force flushing of output device
774         }
776         // any error forces idling of output
777         if (status < 0)
778         {
779             for (z=OUTPUT1; z < OUTPUTN; z++)
780             {
781                 //if (pAstCfg->xOut[z].hTxSio)
782                 if (pAsotCfg->pIoOut[z].hIoPhy)
783                 {
784                     //SIO_idle(pAstCfg->xOut[z].hTxSio);  JX TO DO: implement proper error handling
785                 }
786             }
788             TRACE_TERSE1("TaskAsop: Trace stopped at loop %d.", asopLoopCount);
789             //ERRNO_RPRT(TaskAsop, errno);
790         }
791     } // End of main processing loop for (;;)
792 } /* taskAsopFxn */
794 // ASOT wake timer (clock) function
795 Void clkAsotFxn(Void)
797     Event_post(asotEvt, Evt_Id_AsotWakeTimer);
800 void asopMcaspCallback(void* arg, MCASP_Packet *mcasp_packet)
802     /* post semaphore */
803     if(mcasp_packet->arg == IOPHY_XFER_FINAL) {
804         //Semaphore_post(asopSemTx);
805         Event_post(asotEvt, Evt_Id_AsotTxMcaspEdma);
806     } else {
807         ;    // intermediate packet due to buffer wrapping around
808     }
811 // Reset audio frame pointers to original values
812 static Void resetAfPointers(
813     const PAF_ASOT_Params *pP, 
814     PAF_AST_Stream *xStr
817     Int z;
818     Int ch;
820     // Reset audio frame pointers to original values
821     for (z = STREAM1; z < STREAMN; z++) 
822     {
823         for (ch = PAF_LEFT; ch < PAF_MAXNUMCHAN_AF; ch++) 
824         {
825             if (xStr[z].audioFrameChannelPointers[ch])
826             {
827                 xStr[z].audioFrameChannelPointers[ch] = 
828                     xStr[z].origAudioFrameChannelPointers[ch];
829             }
830         }
831     }
834 // Check if Output device selected
835 static Int checkOutDevSel(
836     PAF_AST_IoOut *pOut,
837     Bool *pOutDevSel
840     *pOutDevSel = (Bool)(pOut->hMcaspChan != NULL);
841     
842     return ASOP_SOK;
845 // Check if any Output device selected
846 static Int checkAnyOutDevSel(
847     const PAF_ASOT_Params *pP,
848     PAF_AST_IoOut *pOut, 
849     Bool *pOutDevSel
852     Bool outDevSel;
853     Int z;
855     outDevSel = FALSE;
856     for (z=OUTPUT1; z < OUTPUTN; z++)
857     {
858         if (pOut[z].hMcaspChan)
859         {
860             outDevSel = TRUE;
861             break;
862         }
863     }
865     *pOutDevSel = outDevSel;
867     return ASOP_SOK;
870 // ASOT SM function
871 // -----------------------------------------------------------------------------
872 // ASOT Selection Function - Output Device Selection
873 //
874 //   Name:      PAF_ASOT_selectDevices
875 //   Purpose:   Audio Stream Output Task Function for selecting the devices used
876 //              for output.
877 //
878 static Int PAF_ASOT_selectDevices(
879     const PAF_ASOT_Params *pP, 
880     const PAF_ASOT_Patchs *pQ, 
881     PAF_ASOT_Config *pAsotCfg,
882     Bool *pOutDevSel
885     PAF_AST_Config *pAstCfg;        // Common (shared) configuration pointer
886     Int z;
887     Int zS, zO;
888     Int device;
889     Int status;
890     Bool ioPhyInit;
891     
892     pAstCfg = pAsotCfg->pAstCfg;        // get pointer to AST common (shared) configuration
894     // Find first Output associated with Master Stream
895     zO = OUTPUT1;
896     for (z=ENCODE1; z < ENCODEN; z++)
897     {
898         zS = pP->streamsFromEncodes[z]; // get Stream associated with Encoder
899         if (zS == pAstCfg->masterStr)
900         {
901             // This Encoder is associated with Master Stream.
902             // Note other Encoder can also be associated with Master Stream.
903             zO = pP->outputsFromEncodes[z]; // get Output associated with Encoder
904         }
905     }
906     
907     ioPhyInit = asopIoPhyCheckInit(); // check if IO Phy is initialized
908     device = pAstCfg->xOut[zO].outBufStatus.sioSelect; // obtain SIO select for Output
909     if ((ioPhyInit == TRUE) && (device >= 0))
910     {
911         // check for valid index into device array
912         if (device >= pQ->devout->n)
913         {
914             device = 0; // treat as device None
915         }
916         
917         if (device > 0)
918         {
919             // Select Output Devices
920             //  FL, New IO: Placeholder function, this will be reorganized moving forward.
921             //  FL: New IO: API for single Output.
922             //  FL: New IO: Doesn't (re-)configure Output driver.
923             status = asopSelectDevices(&pAsotCfg->pIoOut[zO]);
924             if (status < 0)
925             {
926                 pAstCfg->xOut[zO].outBufStatus.sioSelect = 0x80;
927                 *pOutDevSel = FALSE;
928                 return status;
929             }
930             
931             // Reset IO Buff & IO Phy
932             //  FL, New IO: API for single Output
933             status = asopIoCompsInit(&pAstCfg->xOut[zO], &pAsotCfg->pIoOut[zO]);
934             if (status < 0)
935             {
936                 pAstCfg->xOut[zO].outBufStatus.sioSelect = 0x80;
937                 *pOutDevSel = FALSE;
938                 return status;
939             }
940                 
941             //// I/O physical layer prime operation required by McASP LLD
942             ////  FL, New IO: API for single Output
943             //asopIoPhyPrime(&pAsotCfg->pIoOut[zO]);
944         }
946         pAstCfg->xOut[zO].outBufStatus.sioSelect = device | 0x80;
947     }
948     
949     // Check if Output device selected
950     //  FL, New IO: API for single Output
951     status = checkOutDevSel(&pAsotCfg->pIoOut[zO], pOutDevSel);
952     if (status < 0)
953     {
954         *pOutDevSel = FALSE;
955         return status;
956     }
957     
958     return ASOP_SOK;
961 // ASOT SM function
962 //  Wake Timer + *POLLING* version.
963 //  No explicit Rx ASDT message event from ASDT.
964 //  ASOT wakes on Wake Timer event and polls for flag set.
965 // Reset Decoder Output processing
966 static Int PAF_ASOT_resetDecOutProc(
967     const PAF_ASOT_Params *pP, 
968     const PAF_ASOT_Patchs *pQ, 
969     PAF_ASOT_Config *pAsotCfg,
970     PAF_AudioFrame *pDecResetAf,
971     Bool outDevSel,
972     Int frame
975     Int status;
976     
977     if (outDevSel == FALSE)
978     {
979         // 
980         // Rx Dec Out-IS message before Output selected.
981         // Decoder is producing output, but no Output selected.
982         //
983         return ASOP_ERR_RESETOUTPROC_NOOUTDEVSEL;
984     }
985     
986     // Perform Dec Reset Init-Sync
987     status = PAF_ASOT_initSyncDecReset(pP, pQ, pAsotCfg, pDecResetAf, frame);
988     
989     return status;
993 // Reset audio frame meta data elements
994 static Void resetAfMetadata(
995     const PAF_ASOT_Params *pP, 
996     PAF_AST_Stream *xStr
999     Int z;
1000     Int i;
1002     for (z = STREAM1; z < STREAMN; z++) 
1003     {
1004         xStr[z].pAudioFrame->pafBsMetadataUpdate = XDAS_FALSE;
1005         xStr[z].pAudioFrame->numPrivateMetadata = 0;
1006         xStr[z].pAudioFrame->bsMetadata_offset = 0;
1007         xStr[z].pAudioFrame->bsMetadata_type = PAF_bsMetadata_channelData;
1009         for (i = 0; i < pP->pMetadataBufStatus->NumBuf; i++)
1010         {
1011             xStr[z].pAudioFrame->pafPrivateMetadata[i].offset = 0;
1012             xStr[z].pAudioFrame->pafPrivateMetadata[i].size = 0;
1013         }
1014     }
1017 // Reset audio frames
1018 static Void resetAfs(
1019     const PAF_ASOT_Params *pP, 
1020     PAF_AST_Stream *xStr
1023     // Reset audio frame pointers to original values
1024     // (may be needed if error occurred).
1025     resetAfPointers(pP, xStr);
1026     // Reset audio frame meta data elements
1027     resetAfMetadata(pP, xStr);
1030 //   Purpose:   Performs Dec Reset Init-Sync.
1031 //static Int PAF_ASOT_initSyncDecReset(
1032 // used by new OutProc.c, will be changed back to static once refactoring is done
1033 static Int PAF_ASOT_initSyncDecReset(
1034     const PAF_ASOT_Params *pP, 
1035     const PAF_ASOT_Patchs *pQ, 
1036     PAF_ASOT_Config *pAsotCfg,
1037     PAF_AudioFrame *pDecResetAf,
1038     Int frame
1041     PAF_AST_Config *pAstCfg;            // ASIT/ASOT/ASDT shared configuration
1042     Int zMD, zMS;                       // Dec and Stream Master indices
1043     PAF_AudioFrame *pStrAf;             // stream audio frame
1044     PAF_AST_OutInitSyncCtl *pOutIsCtl;  // Output Init-Sync control
1045     Int8 decFlag;                       // dec stage flag
1046     Int status;                         // status code
1047    
1048     pAstCfg = pAsotCfg->pAstCfg;
1049     zMD = pAstCfg->masterDec;
1050     pOutIsCtl = &pAsotCfg->pAspmCfg->outIsCtl;
1051     
1052     // check for Dec Reset
1053     // store dec reset AF
1054     status = outIsReadDecStageFlagAndAf(pOutIsCtl, zMD,
1055         ASP_OUTIS_DEC_STAGE_RESET_IDX, &decFlag, pDecResetAf);
1056     if (status < 0)
1057     {
1058         return status;
1059     }
1060     
1061     if (decFlag == 0)
1062     {
1063         return ASOP_SOK_INITSYNC_NOTREADY;
1064     }
1065     else
1066     {
1067         zMS = pAstCfg->masterStr;
1068         pStrAf = pAstCfg->xStr[zMS].pAudioFrame;
1069         
1070         // Reset audio frames
1071         // FL, New IO: API for multiple streams.
1072         resetAfs(pP, pAstCfg->xStr);
1073     
1074         // Update Stream Audio Frame.
1075         // Copy Dec Reset AF to Stream AF.
1076         // FL, New IO: Only Master zone (single) stream handled.
1077         outIsCpyAf(pDecResetAf, pStrAf);
1078         
1079         // Enc activate
1080         // Enc reset
1081         status = asopDecOutProcReset(pP, pQ, pAsotCfg, frame);
1082         if (status < 0)
1083         {
1084             return status;
1085         }
1086         
1087         return ASOP_SOK;
1088     }
1091 // ASOT SM function
1092 //   Purpose:   Init-Sync Dec Info1 state function.
1093 //      Wake Timer + *POLLING* version.
1094 //      No explicit Rx ASDT message event from ASDT.
1095 //      ASOT wakes on Wake Timer event and polls for flag set.
1096 static Int PAF_ASOT_initSyncDecInfo1(
1097     const PAF_ASOT_Params *pP, 
1098     const PAF_ASOT_Patchs *pQ, 
1099     PAF_ASOT_Config *pAsotCfg,
1100     PAF_AudioFrame *pDecInfo1Af,
1101     Int frame
1104     PAF_AST_Config *pAstCfg;            // ASIT/ASOT/ASDT shared configuration
1105     Int zMD, zMS;                       // Dec and Stream Master indices
1106     PAF_AudioFrame *pStrAf;             // stream audio frame
1107     PAF_AST_OutInitSyncCtl *pOutIsCtl;  // Output Init-Sync control
1108     Int8 decFlag;                       // dec stage flag
1109     Int status;                         // status code
1110     
1111     pAstCfg = pAsotCfg->pAstCfg;
1112     zMD = pAstCfg->masterDec;
1113     pOutIsCtl = &pAsotCfg->pAspmCfg->outIsCtl;
1114     
1115     // Check for Dec Reset, 
1116     // Store dec reset AF
1117     status = outIsReadDecStageFlagAndAf(pOutIsCtl, zMD,
1118         ASP_OUTIS_DEC_STAGE_INFO1_IDX, &decFlag, pDecInfo1Af);
1119     if (status < 0)
1120     {
1121         return status;
1122     }
1123     
1124     if (decFlag == 0)
1125     {
1126         return ASOP_SOK_INITSYNC_NOTREADY;
1127     }
1128     else
1129     {
1130         zMS = pAstCfg->masterStr;
1131         pStrAf = pAstCfg->xStr[zMS].pAudioFrame;
1132         
1133         // Set ASOT output frame length.
1134             // THD sets this to 256 (hard-coded in Dec Info)
1135             // DDP sets this to 0 (audio frame pass through, 0 from ASDT AF frame length)
1136             // PCM sets this to 256 (decodeControl.frameLength)
1137         pDecInfo1Af->sampleCount = gOutFrameLen;    // !!!! GJ: Revisit !!!!
1138         
1139         // Update Stream Audio Frame.
1140         // Copy Dec Reset AF to Stream AF.
1141         outIsCpyAf(pDecInfo1Af, pStrAf);
1143         // outputInfo1():
1144         //      - ASP chain reset,
1145         //      - Enc Info,
1146         //      - Start Output
1147         status = asopDecOutProcInfo1(pP, pQ, pAsotCfg, frame);
1148         if (status < 0)
1149         {
1150             return status;
1151         }
1152         
1153         return ASOP_SOK;
1154     }
1157 // ASOT SM function
1158 //   Purpose:   Init-Sync Dec Decode1 state function.
1159 //      Wake Timer + *POLLING* version.
1160 //      No explicit Rx ASDT message event from ASDT.
1161 //      ASOT wakes on Wake Timer event and polls for flag set.
1162 //static Int PAF_ASOT_initSyncDecDecode1(
1163 static Int PAF_ASOT_initSyncDecDecode1(
1164     const PAF_ASOT_Params *pP, 
1165     const PAF_ASOT_Patchs *pQ, 
1166     PAF_ASOT_Config *pAsotCfg,
1167     Int frame
1170     PAF_AST_Config *pAstCfg;            // ASIT/ASOT/ASDT shared configuration
1171     Int zMD;                            // Dec Master index
1172     PAF_AST_OutInitSyncCtl *pOutIsCtl;  // Output Init-Sync control
1173     Int8 decFlag;                       // dec stage flag
1174     Int z;
1175     Int zS, zO;
1176     Int status;                         // status code
1178     pAstCfg = pAsotCfg->pAstCfg;
1179     zMD = pAstCfg->masterDec;
1180     pOutIsCtl = &pAsotCfg->pAspmCfg->outIsCtl;
1181     
1182     // Check for Dec Reset, 
1183     // Store dec reset AF
1184     status = outIsReadDecStageFlag(pOutIsCtl, zMD,
1185         ASP_OUTIS_DEC_STAGE_DECODE1_IDX, &decFlag);
1186     if (status < 0)
1187     {
1188         return status;
1189     }
1190     
1191     if (decFlag == 0)
1192     {
1193         return ASOP_SOK_INITSYNC_NOTREADY;
1194     }
1195     else
1196     {
1197         // Find first Output associated with Master Stream
1198         zO = OUTPUT1;
1199         for (z=ENCODE1; z < ENCODEN; z++)
1200         {
1201             zS = pP->streamsFromEncodes[z]; // get Stream associated with Encoder
1202             if (zS == pAstCfg->masterStr)
1203             {
1204                 // This Encoder is associated with Master Stream.
1205                 // Note other Encoder can also be associated with Master Stream.
1206                 zO = pP->outputsFromEncodes[z]; // get Output associated with Encoder
1207             }
1208         }
1210         // FL, New IO: assumption here is Output frame size (output frame size)
1211         //             & McASP Tx clock dividers are set correctly (stream)
1212         //             before IO prime, i.e. IO prime is not set to default
1213         
1214         // I/O physical layer prime operation required by McASP LLD
1215         //  FL, New IO: API for single Output
1216         asopIoPhyPrime(&pAsotCfg->pIoOut[zO]);        
1217         
1218         return ASOP_SOK;
1219     }
1222 // ASOT SM function
1223 // Process Decoder output audio data
1224 static Int PAF_ASOT_procDecOut(
1225     const PAF_ASOT_Params *pP, 
1226     const PAF_ASOT_Patchs *pQ, 
1227     PAF_ASOT_Config *pAsotCfg, 
1228     Bool *pFirstTime, 
1229     Int frame
1232     PAF_AST_Config *pAstCfg;    // ASIT/ASOT/ASDT shared configuration
1233     Bool outDevSioSelUpdate;    // indicates whether Output SIO selection has changed
1234     Int zO, zS;
1235     Int z;                      // decode/encode counter
1236     Int errno;                  // error number
1237     Int status;                 // status code
1238     
1239     status = ASOP_SOK;
1240     pAstCfg = pAsotCfg->pAstCfg;
1241     
1242     if (*pFirstTime == TRUE)
1243     {
1244         // Initialize Decoder output processing
1245         errno = asopDecOutProcInit(pP, pQ, pAsotCfg, frame);
1246         if (errno < 0)
1247         {
1248             status = errno;
1249         }
1250         else
1251         {
1252             *pFirstTime = FALSE;
1253         }
1254     }
1255     
1256     if (status == ASOP_SOK)
1257     {
1258         // Find first Output associated with Master Stream
1259         zO = OUTPUT1;
1260         for (z=ENCODE1; z < ENCODEN; z++)
1261         {
1262             zS = pP->streamsFromEncodes[z]; // get Stream associated with Encoder
1263             if (zS == pAstCfg->masterStr)
1264             {
1265                 // This Encoder is associated with Master Stream.
1266                 // Note other Encoder can also be associated with Master Stream.
1267                 zO = pP->outputsFromEncodes[z]; // get Output associated with Encoder
1268             }
1269         }    
1270         
1271         // Mark Output transfer complete
1272         errno = ioPhyXferComplete(pAsotCfg->pIoOut[zO].hIoPhy, FALSE);
1273         if (errno)
1274         {
1275             status = ASOP_ERR_PROCDECOUT_IOPHYXFERCOMPLETE;
1276         }
1277     }
1278     
1279     if (status == ASOP_SOK)
1280     {
1281         // Check if Output device SIO selection changed
1282         errno = checkOutDevSioSelUpdate(pP, pAsotCfg, zO, &outDevSioSelUpdate);
1283         if (errno)
1284         {
1285             status = ASOP_ERR_PROCDECOUT_CHKOUTDEVSELUPD;
1286         }
1287         else if (outDevSioSelUpdate == TRUE)
1288         {
1289             status = ASOP_ERR_PROCDECOUT_OUTDEVSELUPD;
1290         }
1291     }
1293     if (status == ASOP_SOK)
1294     {
1295         // Process encoder command
1296         errno = asopDecOutProcEncodeCommand(pP, pQ, pAsotCfg);
1297         if (errno < 0)
1298         {
1299             status = errno;
1300         }
1301     }
1303     if (status == ASOP_SOK)
1304     {
1305         // Read CB, execute ASP chain
1306         errno = asopDecOutProcStream(pP, pQ, pAsotCfg, frame);
1307         if (errno < 0)
1308         {
1309             status = errno;
1310         }
1311     }
1313     if (status == ASOP_SOK)
1314     {
1315         // Execute encode
1316         errno = asopDecOutProcEncode(pP, pQ, pAsotCfg, frame);
1317         if (errno < 0)
1318         {
1319             status = errno;
1320         }
1321     }
1323     if (status == ASOP_SOK)
1324     {
1325         // Execute Info2
1326         errno = asopDecOutProcInfo2(pP, pQ, pAsotCfg, frame);
1327         if (errno < 0)
1328         {
1329             status = errno;
1330         }
1331     }
1333     if (status == ASOP_SOK)
1334     {
1335         errno = asopDecOutProcFinalTest(pP, pQ, pAsotCfg, frame);
1336         if (errno < 0)
1337         {
1338             status = errno;
1339         }
1340     }
1342     if (status != ASOP_SOK)    
1343     {
1344         // Complete Output Processing
1345         errno = asopDecOutProcComplete(pP, pQ, pAsotCfg, frame);
1346         if (errno < 0)
1347         {
1348             status = errno;
1349         }
1350     }
1351     
1352     return status;
1355 // ASOT SM function
1356 //   Purpose:   Init-Sync Re-Sync state function.
1357 //              Performs Init-Sync using stored Dec Reset/Info1 AFs.
1358 static Int PAF_ASOT_initSyncResync(
1359     const PAF_ASOT_Params *pP, 
1360     const PAF_ASOT_Patchs *pQ, 
1361     PAF_ASOT_Config *pAsotCfg,
1362     PAF_AudioFrame *pDecResetAf,
1363     PAF_AudioFrame *pDecInfo1Af,
1364     Int frame
1367     PAF_AST_Config *pAstCfg;    // ASIT/ASOT/ASDT shared configuration
1368     Int zMS;                    // Stream Master index
1369     PAF_AudioFrame *pStrAf;     // stream audio frame
1370     Int status;                 // status code
1372     pAstCfg = pAsotCfg->pAstCfg;
1373     zMS = pAstCfg->masterStr;
1374     pStrAf = pAstCfg->xStr[zMS].pAudioFrame;
1375         
1376     // Reset audio frames
1377     resetAfs(pP, pAstCfg->xStr);
1378     
1379     //
1380     // Dec Reset re-sync using stored Dec Reset AF
1381     //
1382     
1383     // Update Stream Audio Frame.
1384     // Copy Dec Reset AF to Stream AF.
1385     outIsCpyAf(pDecResetAf, pStrAf);
1386     
1387     // Enc activate,
1388     // Enc reset
1389     status = asopDecOutProcReset(pP, pQ, pAsotCfg, frame);
1390     if (status < 0)
1391     {
1392         return status;
1393     }
1394     
1395     //
1396     // Dec Info1 re-sync using stored Dec Info1 AF
1397     //
1398     
1399     // Update Stream Audio Frame.
1400     // Copy Dec Info1 AF to Stream AF.
1401     outIsCpyAf(pDecInfo1Af, pStrAf);
1402     
1403     // outputInfo1():
1404     //      - ASP chain reset,
1405     //      - Enc Info,
1406     //      - Start Output
1407     status = asopDecOutProcInfo1(pP, pQ, pAsotCfg, frame);
1408     if (status < 0)
1409     {
1410         return status;
1411     }
1412     
1413     return ASOP_SOK;    
1416 // ASOT SM function
1417 //   Purpose:   Re-select devices used for Output.
1418 //              Performs Init-Sync using stored Dec Reset/Info1 AFs.
1419 static Int PAF_ASOT_reselectDevices(
1420     const PAF_ASOT_Params *pP, 
1421     const PAF_ASOT_Patchs *pQ, 
1422     PAF_ASOT_Config *pAsotCfg,
1423     PAF_AudioFrame *pDecResetAf,
1424     PAF_AudioFrame *pDecInfo1Af,
1425     Int frame, 
1426     Bool *pOutDevSel
1429     Bool outDevSel;
1430     Int status;
1431     
1432     // Re-select Output devices
1433     status = PAF_ASOT_selectDevices(pP, pQ, pAsotCfg, &outDevSel);
1434     if (status < 0)
1435     {
1436         *pOutDevSel = outDevSel;
1437         return status;
1438     }
1439     else if (outDevSel == FALSE)
1440     {
1441         *pOutDevSel = outDevSel;
1442         return status;
1443     }
1444     else
1445     {
1446         // Init-Sync Resync
1447         status = PAF_ASOT_initSyncResync(pP, pQ, pAsotCfg, pDecResetAf, pDecInfo1Af, frame);
1448         if (status < 0)
1449         {
1450             outDevSel = FALSE;
1451             *pOutDevSel = outDevSel;
1452             return status;
1453         }
1454     }
1455     
1456     *pOutDevSel = outDevSel;
1457     return status;