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