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