Add header for BSD-3-Clause
[processor-sdk/performance-audio-sr.git] / processor_audio_sdk_1_00_00_00 / pasdk / test_arm / framework / audioStreamDecodeProc.c
2 /*
3 Copyright (c) 2016, 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  *  ======== audioStreamDecodeProc.c ========
38  */
40 #include <xdc/cfg/global.h>
41 #include <xdc/runtime/Error.h>
42 #include <xdc/runtime/Log.h>
43 #include <xdc/runtime/Memory.h>
44 #include <ti/sysbios/BIOS.h>
45 #include <ti/sysbios/hal/Cache.h>
46 #include <ti/sysbios/knl/Task.h>
47 #include <ti/ipc/Ipc.h>
48 #include <ti/ipc/MessageQ.h>
49 #include <ti/ipc/MultiProc.h>
51 #include <acp_mds.h>
52 #include <pcm.h>
53 #include "audioStreamProc_params.h"
54 #include "audioStreamProc_patchs.h"
55 #include "audioStreamProc_config.h"
56 #include "paf_decOpCircBuf.h"
58 #include "common.h"
59 #include "aspMsg_common.h"
60 #include "aspMsg_slave.h"
62 #include "audioStreamProc_common.h"
63 #include "audioStreamDecodeProc.h"
65 // FL: debug
66 //#include "fwkSim.h"
67 #include "dbgCapAf.h"
68 #include "dbgDib.h"
71 //
72 // Decoder Definitions
73 //
74 #define decLinkInit pQ->i_decLinkInit
76 #define __TASK_NAME__  "TaskAsdp"
78 LINNO_DEFN(TaskAsdp); /* Line number macros */
79 ERRNO_DEFN(TaskAsdp); /* Error number macros */
81 extern struct {
82     Int size;
83     IALG_Status *pStatus[512];
84 } IACP_STD_BETA_TABLE;
86 extern const char AFChanPtrMap[PAF_MAXNUMCHAN+1][PAF_MAXNUMCHAN];
87 extern PAF_ChannelConfigurationMaskTable PAF_ASP_stdCCMT;
89 // Global debug counters */
90 extern Uint32 gTaskAsdpCnt; // debug counter for ASDP task
92 PAF_AudioFrame *gpDecAudioFrame=NULL;
93 PAF_AudioData  *gDecAudioFrameChannelPointers[PAF_MAXNUMCHAN_AF];
94 PAF_AudioSize  gDecAudioFrameChannelSizes[PAF_MAXNUMCHAN_AF];
95 PAF_AudioData  *gDecOrigAudioFrameChannelPointers[PAF_MAXNUMCHAN_AF];
97 // Debug counters
98 UInt32 gSlaveStartErrCnt        =0;
99 UInt32 gSlaveStartCnt           =0;
100 UInt32 gSlaveSourceSelectCnt    =0;
101 UInt32 gSlaveExitCnt            =0;
102 UInt32 gSlaveDecExitCnt         =0;
103 UInt32 gSlaveDecControlCnt      =0;
104 UInt32 gSlaveDecActivateCnt     =0;
105 UInt32 gSlaveDecResetCnt        =0;
106 UInt32 gSlaveDecInfoCnt         =0;
107 UInt32 gSlaveDecDecodeCnt       =0;
108 UInt32 gSlaveDecDeactivateCnt   =0;
111 /*
112  *  ======== taskAsdpFxn ========
113  *  Audio Stream Decode Processing task function
114  */
115 Void taskAsdpFxn(
116 //    Int betaPrimeValue, // FL: revisit
117     const PAF_AST_Params *pP,
118     const PAF_AST_Patchs *pQ
121     Int as;                         /* Audio Stream Number (1, 2, etc.) */
122     Int z;                          /* input/encode/stream/decode/output counter */
123     Int i;                          /* phase */
124     Int zMD, zMS;
125     Bool done;
126     Bool decDone;
127     ALG_Handle alg[DECODEN_MAX];
128     ASP_Slave_Cmd slaveCmd;
129     Int sourceSelect;
130     DEC_Handle dec;
131     IALG_Cmd decCtrlCmd;            // decoder control command
132     Int decCtrlRet;                 // decoder control return
133     Int errno;                      /* error number */
134     Int size;
135     Int argIdx;
136     // Decoder output circular buffer
137     PAF_DecodeOpCircBuf *pCb;
138     PAF_AudioFrame *pAfWrt;
139     Int cbErrno;    
140     // Messaging
141     PAF_InpBufConfig *pIpBufConfig;
142     ASP_Msg *pAspMsg;
143     MessageQ_QueueId queId;
144     Int status;
145     Int zI;
147     
148     Log_info0("Enter taskAsdpFxn()");
149     
150     //
151     // Audio Framework Parameters & Patch (*pP, *pQ):
152     //
153     if (!pP) 
154     {
155         TRACE_TERSE0("TaskAsdp: No Parameters defined. Exiting.");
156         LINNO_RPRT(TaskAsdp, -1);
157         return;
158     }
160     if (!pQ) 
161     {
162         TRACE_TERSE0("TaskAsdp: No Patchs defined. Exiting.");
163         LINNO_RPRT(TaskAsdp, -1);
164         return;
165     }    
167     // wait for initialization message from master
168     do {
169         status = MessageQ_get(hAspMsgSlave->slaveQue, (MessageQ_Msg *)&pAspMsg, MessageQ_FOREVER);
170         //TRACE_TERSE1("Rx ASP message: status=%d", status);
171     //} while ((status != MessageQ_S_SUCCESS || (pAspMsg->cmd != ASP_SLAVE_START));
172     } while (status != MessageQ_S_SUCCESS);
173     if ((pAspMsg->procId != hAspMsgSlave->masterProcId) ||
174         (pAspMsg->cmd != ASP_SLAVE_START))
175     {
176         TRACE_TERSE3("ERROR: Rx ASP message: procId=%d, cmd=%d, messageId=0x%04x", pAspMsg->procId, pAspMsg->cmd, pAspMsg->messageId);
177         SW_BREAKPOINT;
178     }
179     hAspMsgSlave->masterMessageId = pAspMsg->messageId; 
180     gSlaveStartCnt++;
181     TRACE_MSG3("Rx ASP message, procId=%d, cmd=%d, messageId=0x%04x", pAspMsg->procId, pAspMsg->cmd, pAspMsg->messageId);
183     Cache_inv(&gPAF_AST_config, sizeof(PAF_AST_Config), Cache_Type_ALLD, 0);
184     Cache_inv(&pC, sizeof(PAF_AST_Config *), Cache_Type_ALLD, 0);
185     Cache_wait();
186     if (!pC)
187     {
188         TRACE_TERSE0("TaskAsdp: No Configuration defined. Exiting.");
189         LINNO_RPRT(TaskAsdp, -1);
190         return;
191     }
192     
193     // (***) FL: revisit
194     // invalidate Dec configuration
195     Cache_inv(&gPAF_AST_config.xDec[0], DECODEN*sizeof(PAF_AST_Decode), Cache_Type_ALLD, 0);
196     Cache_wait();
198     // (***) FL: revisit
199     Cache_inv((Ptr)(&IACP_STD_BETA_TABLE.pStatus[0]), 512*sizeof(IALG_Status *), Cache_Type_ALLD, 0); // invalidate entire beta table
200     Cache_wait();
202     // Audio Framework Configuration (*pC):
203     as = pC->as; // obtain audio stream number
204     
205     //
206     // Initialize message log trace and line number reporting
207     //
208     for (z=STREAM1; z < STREAMN; z++)
209     {
210         TRACE_TERSE1("TaskAsdp: AS%d: initiated", as+z);
211     }
212     LINNO_RPRT(TaskAsdp, -1);
214     // Get decoder and stream index associated with the master input
215     zMD = pC->masterDec;
216     zMS = pC->masterStr;
218     // 
219     // Initialize per parameterized phases.
220     //   - AcpAlg: ACP Algorithm Initialization and Local Attachment
221     //   - Common: Common Algorithm Initialization
222     //   - AlgKey: Dec/Enc chain to Array Initialization
223     //   - Unused: (available)
224     //
225     LINNO_RPRT(TaskAsdp, -2);
226     for (i=0; i < lengthof(pP->fxns->initPhase); i++)
227     {
228         Int linno;
229         if (pP->fxns->initPhase[i])
230         {
231             if ((linno = pP->fxns->initPhase[i](pP, pQ, pC)))
232             {
233                 LINNO_RPRT(TaskAsdp, linno);
234                 return;
235             }
236         }
237         else 
238         {
239             TRACE_TERSE1("TaskAsdp: AS%d: initialization phase - null", as+zMS);
240         }
241         TRACE_TERSE2("TaskAsdp: AS%d: initialization phase - %d completed", as+zMS, i);
242         LINNO_RPRT(TaskAsdp, -i-3);
243     }
244     
245     //
246     // End of Initialization -- final memory usage report.
247     //
248     if (pP->fxns->memStatusPrint)
249     {
250         pP->fxns->memStatusPrint(HEAP_INTERNAL, HEAP_INTERNAL1, HEAP_EXTERNAL, HEAP_INTERNAL1_SHM);
251     }
253     // (***) FL: revisit
254     // write back Status structure addresses for Beta Units initialized on Slave
255     Cache_wb((Ptr)(&IACP_STD_BETA_TABLE.pStatus[STD_BETA_DECODE]), sizeof(IALG_Status *), Cache_Type_ALLD, 0);
256     Cache_wb((Ptr)(&IACP_STD_BETA_TABLE.pStatus[STD_BETA_PCM]), sizeof(IALG_Status *), Cache_Type_ALLD, 0);
257     Cache_wb((Ptr)(&IACP_STD_BETA_TABLE.pStatus[STD_BETA_PCM2]), sizeof(IALG_Status *), Cache_Type_ALLD, 0);
258     //Cache_wb((Ptr)(&IACP_STD_BETA_TABLE.pStatus[STD_BETA_DDP]), sizeof(IALG_Status *), Cache_Type_ALLD, 0);
259     //Cache_wb((Ptr)(&IACP_STD_BETA_TABLE.pStatus[STD_BETA_DDP2]), sizeof(IALG_Status *), Cache_Type_ALLD, 0);
260     Cache_wait();
261     
262     // (***) FL: revisit
263     // write back Status structures for Beta Units initialized on Slave
264     size = IACP_STD_BETA_TABLE.pStatus[STD_BETA_DECODE]->size;
265     Cache_wb((Ptr)(IACP_STD_BETA_TABLE.pStatus[STD_BETA_DECODE]), size, Cache_Type_ALLD, 0);
266     size = IACP_STD_BETA_TABLE.pStatus[STD_BETA_PCM]->size;
267     Cache_wb((Ptr)(IACP_STD_BETA_TABLE.pStatus[STD_BETA_PCM]), size, Cache_Type_ALLD, 0);
268     size = IACP_STD_BETA_TABLE.pStatus[STD_BETA_PCM2]->size;
269     Cache_wb((Ptr)(IACP_STD_BETA_TABLE.pStatus[STD_BETA_PCM2]), size, Cache_Type_ALLD, 0);
270     //size = IACP_STD_BETA_TABLE.pStatus[STD_BETA_DDP]->size;
271     //Cache_wb((Ptr)(IACP_STD_BETA_TABLE.pStatus[STD_BETA_DDP]), size, Cache_Type_ALLD, 0);
272     //size = IACP_STD_BETA_TABLE.pStatus[STD_BETA_DDP2]->size;
273     //Cache_wb((Ptr)(IACP_STD_BETA_TABLE.pStatus[STD_BETA_DDP2]), size, Cache_Type_ALLD, 0);
274     Cache_wait();
276     // (***) FL: revisit
277     // write back Dec configuration
278     Cache_wb(&gPAF_AST_config.xDec[0], DECODEN*sizeof(PAF_AST_Decode), Cache_Type_ALLD, 0);
279     Cache_wait();
280     
281     // Send initialization complete message to master
282     queId = MessageQ_getReplyQueue(pAspMsg);
283     pAspMsg->procId = hAspMsgSlave->slaveProcId;
284     pAspMsg->cmd = ASP_MASTER_START_DONE;
285     pAspMsg->messageId = hAspMsgSlave->masterMessageId | ((UInt32)1<<31);
286     TRACE_MSG3("Tx ASP message, procId=%d, cmd=%d, messageId=0x%04x", pAspMsg->procId, pAspMsg->cmd, pAspMsg->messageId);
287     status = MessageQ_put(queId, (MessageQ_Msg)pAspMsg); /* send message back */
288     if (status != MessageQ_S_SUCCESS)
289     {
290         SW_BREAKPOINT;
291     }
293     done = FALSE;
294     while (done==FALSE)
295     {
296         // wait for source select message from master
297         do {
298             status = MessageQ_get(hAspMsgSlave->slaveQue, (MessageQ_Msg *)&pAspMsg, MessageQ_FOREVER);
299         } while ((status < 0) || (pAspMsg->cmd != ASP_SLAVE_DEC_SOURCE_SELECT));
300         if ((pAspMsg->procId != hAspMsgSlave->masterProcId) ||
301             (pAspMsg->cmd != ASP_SLAVE_DEC_SOURCE_SELECT))
302         {
303             TRACE_TERSE3("ERROR: Rx ASP message: procId=%d, cmd=%d, messageId=0x%04x", pAspMsg->procId, pAspMsg->cmd, pAspMsg->messageId);
304             SW_BREAKPOINT;
305         }            
306         hAspMsgSlave->masterMessageId = pAspMsg->messageId; 
307         sourceSelect = *(Int32 *)&pAspMsg->buf[0];
308         TRACE_MSG3("Rx ASP message, procId=%d, cmd=%d, messageId=0x%04x", pAspMsg->procId, pAspMsg->cmd, pAspMsg->messageId);
309         TRACE_MSG1("sourceSelect=%d.", sourceSelect);
310         // send source select complete message to master
311         queId = MessageQ_getReplyQueue(pAspMsg);
312         pAspMsg->procId = hAspMsgSlave->slaveProcId;
313         pAspMsg->cmd = ASP_MASTER_DEC_SOURCE_SELECT_DONE;
314         pAspMsg->messageId = hAspMsgSlave->masterMessageId | ((UInt32)1<<31);
315         gSlaveSourceSelectCnt++;
316         TRACE_MSG3("Tx ASP message, procId=%d, cmd=%d, messageId=0x%04x", pAspMsg->procId, pAspMsg->cmd, pAspMsg->messageId);
317         MessageQ_put(queId, (MessageQ_Msg)pAspMsg); /* send message back */
318         
319         for (z=DECODE1; z < DECODEN; z++)
320         {
321             alg[z] = pC->xDec[z].decAlg[PAF_SOURCE_PCM];
322         }
323         alg[zMD] = pC->xDec[zMD].decAlg[sourceSelect];
325         // FL: debug, reset IB capture buffer
326         //capIbReset();
327         //Log_info0("capIbReset()");
328         // FL: debug, reset audio frame capture buffer
329         //capAfReset();
330         
331         decDone = FALSE;
332         while (decDone==FALSE)
333         {
334             // wait for received message from master
335             do {
336                 status = MessageQ_get(hAspMsgSlave->slaveQue, (MessageQ_Msg *)&pAspMsg, MessageQ_FOREVER);
337             } while (status < 0);
338             if (pAspMsg->procId != hAspMsgSlave->masterProcId)
339             {
340                 TRACE_TERSE3("ERROR: Rx ASP message: procId=%d, cmd=%d, messageId=0x%04x", pAspMsg->procId, pAspMsg->cmd, pAspMsg->messageId);
341                 SW_BREAKPOINT;
342             }
343             hAspMsgSlave->masterMessageId = pAspMsg->messageId; 
344             slaveCmd = pAspMsg->cmd;
345             TRACE_MSG3("Rx ASP message, procId=%d, cmd=%d, messageId=0x%04x", pAspMsg->procId, pAspMsg->cmd, pAspMsg->messageId);
347             switch (slaveCmd)
348             {
349                 case ASP_SLAVE_NULL:
350                 case ASP_SLAVE_START:
351                     gSlaveStartErrCnt++;
352                     TRACE_TERSE1("ERROR: unexpected slaveCmd=%d", slaveCmd);
353                     
354                     break;
355                     
356                 case ASP_SLAVE_EXIT:
357                     gSlaveExitCnt++;
358                     TRACE_TERSE1("slaveCmd=%d", slaveCmd);
359                     
360                     decDone = TRUE;
361                     done = TRUE;
362                     break;
363                     
364                 case ASP_SLAVE_DEC_EXIT:
365                     gSlaveDecExitCnt++;
366                     TRACE_TERSE1("slaveCmd=%d", slaveCmd);
367                     
368                     // send dec exit complete message to master
369                     queId = MessageQ_getReplyQueue(pAspMsg);
370                     pAspMsg->procId = hAspMsgSlave->slaveProcId;
371                     pAspMsg->cmd = ASP_MASTER_DEC_EXIT_DONE;
372                     pAspMsg->messageId = hAspMsgSlave->masterMessageId | ((UInt32)1<<31);
373                     TRACE_MSG3("Tx ASP message, procId=%d, cmd=%d, messageId=0x%04x", pAspMsg->procId, pAspMsg->cmd, pAspMsg->messageId);
374                     status = MessageQ_put(queId, (MessageQ_Msg)pAspMsg); /* send message back */
375                     if (status != MessageQ_S_SUCCESS)
376                     {
377                         SW_BREAKPOINT;
378                     }
379                     
380                     decDone=TRUE;
381                     break;
382                     
383                 case ASP_SLAVE_DEC_CONTROL:
384                     gSlaveDecControlCnt++;
385                     // simulate dec control load
386                     //simLoad(DEC_CONTROL_LOAD);
387                     
388                     argIdx = 0; // get decIdx
389                     z = *(Int32 *)&pAspMsg->buf[argIdx];
390                     argIdx += sizeof(Int32);
391                     decCtrlCmd = *(IALG_Cmd *)&pAspMsg->buf[argIdx]; // get decCtrlCmd
392                     TRACE_MSG3("slaveCmd=%d, decIdx=%d, decCtrlCmd=%d", slaveCmd, z, decCtrlCmd);
393                     
394                     decCtrlRet = alg[z]->fxns->algControl(alg[z], decCtrlCmd, NULL);
396                     // send dec control complete message to master
397                     queId = MessageQ_getReplyQueue(pAspMsg);
398                     pAspMsg->procId = hAspMsgSlave->slaveProcId;
399                     pAspMsg->cmd = ASP_MASTER_DEC_CONTROL_DONE;
400                     pAspMsg->messageId = hAspMsgSlave->masterMessageId | ((UInt32)1<<31);
401                     argIdx = 0; // set decCtrlRet
402                     *(Int32 *)&pAspMsg->buf[argIdx] = decCtrlRet;
403                     TRACE_MSG3("Tx ASP message, procId=%d, cmd=%d, messageId=0x%04x", pAspMsg->procId, pAspMsg->cmd, pAspMsg->messageId);
404                     status = MessageQ_put(queId, (MessageQ_Msg)pAspMsg); /* send message back */
405                     if (status != MessageQ_S_SUCCESS)
406                     {
407                         SW_BREAKPOINT;
408                     }
410                     break;
411                     
412                 case ASP_SLAVE_DEC_ACTIVATE:
413                     gSlaveDecActivateCnt++;
414                     // simulate dec activate load
415                     //simLoad(DEC_ACTIVATE_LOAD);
416                     
417                     // (***) FL: revisit
418                     // invalidate Status structures for shared Beta Units
419                     size = IACP_STD_BETA_TABLE.pStatus[STD_BETA_DECODE]->size;
420                     Cache_inv((Ptr)(IACP_STD_BETA_TABLE.pStatus[STD_BETA_DECODE]), size, Cache_Type_ALLD, 0);
421                     size = IACP_STD_BETA_TABLE.pStatus[STD_BETA_PCM]->size;
422                     Cache_inv((Ptr)(IACP_STD_BETA_TABLE.pStatus[STD_BETA_PCM]), size, Cache_Type_ALLD, 0);
423                     Cache_wait();
424                     
425                     argIdx = 0; // get decIdx
426                     z = *(Int32 *)&pAspMsg->buf[argIdx];
427                     TRACE_MSG2("slaveCmd=%d, decIdx=%d", slaveCmd, z);
428                     
429                     if (alg[z]->fxns->algActivate)
430                     {
431                         alg[z]->fxns->algActivate(alg[z]);
432                     }
434                     // Start writes to circular buffer
435                     pCb = &pC->xDec[z].decOpCb;
436                     cbWriteStart(pCb);
437                     // Reset audio frame
438                     resetAf(pP, z, sourceSelect);
439                     
440                     // send dec activate complete message to master
441                     queId = MessageQ_getReplyQueue(pAspMsg);
442                     pAspMsg->procId = hAspMsgSlave->slaveProcId;
443                     pAspMsg->cmd = ASP_MASTER_DEC_ACTIVATE_DONE;
444                     pAspMsg->messageId = hAspMsgSlave->masterMessageId | ((UInt32)1<<31);
445                     TRACE_MSG3("Tx ASP message, procId=%d, cmd=%d, messageId=0x%04x", pAspMsg->procId, pAspMsg->cmd, pAspMsg->messageId);
446                     status = MessageQ_put(queId, (MessageQ_Msg)pAspMsg); /* send message back */
447                     if (status != MessageQ_S_SUCCESS)
448                     {
449                         SW_BREAKPOINT;
450                     }
451                    
452                     break;
453                     
454                 case ASP_SLAVE_DEC_RESET:
455                     gSlaveDecResetCnt++;
456                     // simulate dec reset load
457                     //simLoad(DEC_RESET_LOAD);
458                     
459                     argIdx = 0; // get decIdx
460                     z = *(Int32 *)&pAspMsg->buf[argIdx];
461                     TRACE_TERSE2("slaveCmd=%d,decIdx=%d", slaveCmd, z);
462                     
463                     dec = (DEC_Handle)alg[z];
464                     errno = 0;
465                     if (dec->fxns->reset)
466                     {
467                         errno = dec->fxns->reset(dec, NULL, &pC->xDec[z].decodeControl, &pC->xDec[z].decodeStatus);
468                     }
470                     // (***) FL: revisit
471                     // write back Status structures for shared Beta Units
472                     size = IACP_STD_BETA_TABLE.pStatus[STD_BETA_DECODE]->size;
473                     Cache_wb((Ptr)(IACP_STD_BETA_TABLE.pStatus[STD_BETA_DECODE]), size, Cache_Type_ALLD, 0);
474                     size = IACP_STD_BETA_TABLE.pStatus[STD_BETA_PCM]->size;
475                     Cache_wb((Ptr)(IACP_STD_BETA_TABLE.pStatus[STD_BETA_PCM]), size, Cache_Type_ALLD, 0);
476                     Cache_wait();
477                     
478                     // send dec reset complete message to master
479                     queId = MessageQ_getReplyQueue(pAspMsg);
480                     pAspMsg->procId = hAspMsgSlave->slaveProcId;
481                     pAspMsg->cmd = ASP_MASTER_DEC_RESET_DONE;
482                     pAspMsg->messageId = hAspMsgSlave->masterMessageId | ((UInt32)1<<31);
483                     argIdx = 0; // set decErrno
484                     *(Int32 *)&pAspMsg->buf[argIdx] = errno;
485                     TRACE_MSG3("Tx ASP message, procId=%d, cmd=%d, messageId=0x%04x", pAspMsg->procId, pAspMsg->cmd, pAspMsg->messageId);
486                     status = MessageQ_put(queId, (MessageQ_Msg)pAspMsg); /* send message back */
487                     if (status != MessageQ_S_SUCCESS)
488                     {
489                         SW_BREAKPOINT;
490                     }
492                     break;
493                     
494                 case ASP_SLAVE_DEC_INFO:
495                     gSlaveDecInfoCnt++;
496                     // simulate dec info load
497                     //simLoad(DEC_INFO_LOAD);
498                     
499                     argIdx = 0; // get decIdx
500                     z = *(Int32 *)&pAspMsg->buf[argIdx];
501                     TRACE_TERSE2("slaveCmd=%d,decIdx=%d", slaveCmd, z);
502                     // Get input associated w/ decoder
503                     zI = pP->inputsFromDecodes[z];
504                     
505                     // (***) FL: revisit
506                     // invalidate Inp configuration
507                     Cache_inv(&gPAF_AST_config.xInp[zI], sizeof(PAF_AST_InpBuf), Cache_Type_ALLD, 0);
508                     // invalidate input data
509                     pIpBufConfig = &gPAF_AST_config.xInp[zI].inpBufConfig;
510                     size = pIpBufConfig->frameLength * pIpBufConfig->sizeofElement;
511                     if (sourceSelect == PAF_SOURCE_PCM)
512                     {
513                         size *= pIpBufConfig->stride;
514                     }
515                     Cache_inv((Ptr)pIpBufConfig->pntr.pSmInt, size, Cache_Type_ALLD, 0);
516                     // invalidate Dec configuration
517                     Cache_inv(&gPAF_AST_config.xDec[z], sizeof(PAF_AST_Decode), Cache_Type_ALLD, 0);
518                     // status for selected decoder should be invalidated
519                     Cache_wait();
520             
521                     dec = (DEC_Handle)alg[z];
522                     errno = 0;
523                     if (dec->fxns->info)
524                     {
525                         errno = dec->fxns->info(dec, NULL, &pC->xDec[z].decodeControl, &pC->xDec[z].decodeStatus);
526                     }
527                     
528                     // write back Dec configuration
529                     Cache_wb(&gPAF_AST_config.xDec[z], sizeof(PAF_AST_Decode), Cache_Type_ALLD, 0);
530                     Cache_wait();            
531                     
532                     // Re-initialize audio frame if decoder is disabled or 
533                     // doesn't have a valid input 
534                     if (!pC->xDec[z].decodeStatus.mode || !pC->xInp[zI].hRxSio)
535                     {
536                         pP->fxns->initFrame1(pP, pQ, pC, z, 0);
537                     }
539                     // send dec info complete message to master
540                     queId = MessageQ_getReplyQueue(pAspMsg);
541                     pAspMsg->procId = hAspMsgSlave->slaveProcId;
542                     pAspMsg->cmd = ASP_MASTER_DEC_INFO_DONE;
543                     pAspMsg->messageId = hAspMsgSlave->masterMessageId | ((UInt32)1<<31);
544                     argIdx = 0; // set decErrno
545                     *(Int32 *)&pAspMsg->buf[argIdx] = errno;
546                     TRACE_MSG3("Tx ASP message, procId=%d, cmd=%d, messageId=0x%04x", pAspMsg->procId, pAspMsg->cmd, pAspMsg->messageId);
547                     status = MessageQ_put(queId, (MessageQ_Msg)pAspMsg); /* send message back */
548                     if (status != MessageQ_S_SUCCESS)
549                     {
550                         SW_BREAKPOINT;
551                     }
552                     
553                     break;
554                     
555                 case ASP_SLAVE_DEC_DECODE:
556                     gSlaveDecDecodeCnt++;
557                     // simulate dec info load
558                     //simLoad(DEC_DECODE_LOAD);
559                     
560                     argIdx = 0; // get decIdx
561                     z = *(Int32 *)&pAspMsg->buf[argIdx];
562                     TRACE_TERSE2("slaveCmd=%d, decIdx=%d", slaveCmd, z);
563                     // Get input associated w/ decoder
564                     zI = pP->inputsFromDecodes[z];
565                     
566                     // Reset AF samsiz
567                     resetAfSamsiz(z);
568                     
569                     // invalidate Dec configuration
570                     Cache_inv(&gPAF_AST_config.xDec[z], sizeof(PAF_AST_Decode), Cache_Type_ALLD, 0);
571                     Cache_wait();
572                     //TRACE_TERSE0("Dec:cache wb done");
573             
574                     dec = (DEC_Handle)alg[z];
575                     //TRACE_TERSE1("Dec:dec handle=0x%04x", (IArg)dec);
577                     errno = 0;
578                     cbErrno = 0;
579                     if (dec->fxns->decode)
580                     {
581                         // FL: debug, capture input buffer
582                         //capIb(pC->xInp[z].pInpBuf);
583                     
584                         errno = dec->fxns->decode(dec, NULL, &pC->xDec[z].decodeInStruct, &pC->xDec[z].decodeOutStruct);
585                         if (errno < 0)
586                         {
587                             SW_BREAKPOINT;
588                         }
589                         //TRACE_TERSE0("Dec:decode done");
590                         
591                         // copy decoder output to decoder output circular buffers
592                         pCb = &pC->xDec[z].decOpCb;
593                         //TRACE_TERSE1("Dec:pCb=0x%04x", (IArg)pCb);
594                         
595                         pAfWrt = pC->xDec[z].decodeOutStruct.pAudioFrame;
596                         //TRACE_TERSE1("Dec:pAfWrt=0x%04x", (IArg)pAfWrt);
597                         //TRACE_TERSE1("nSamples=%d",pAfWrt->data.nSamples);
598                         
599                         // FL: debug, capture audio frame
600                         //if (capAfWrite(pAfWrt, PAF_CNTR) != CAP_AF_SOK)
601                         //{
602                         //    Log_info0("capAfWrite() error");
603                         //}                        
605                         cbErrno = cbWriteAf(pCb, pAfWrt);
606                         if (cbErrno < 0)
607                         {
608                             SW_BREAKPOINT;
609                         }
610                         //TRACE_TERSE0("Dec:cbWriteAf() complete");
611                         
612                         // FL: debug, log circular buffer control variables
613                         cbLog(pCb, 0);
614                     }
615                     
616                     // write back Dec configuration
617                     Cache_wb(&gPAF_AST_config.xDec[z], sizeof(PAF_AST_Decode), Cache_Type_ALLD, 0);
618                     Cache_wait();
619                     
620                     // Re-initialize audio frame if decoder is disabled or 
621                     // doesn't have a valid input 
622                     if (!pC->xDec[z].decodeStatus.mode || !pC->xInp[zI].hRxSio)
623                     {
624                         pP->fxns->initFrame1(pP, pQ, pC, z, 0);
625                     }
627                     // send dec info complete message to master
628                     queId = MessageQ_getReplyQueue(pAspMsg);
629                     pAspMsg->procId = hAspMsgSlave->slaveProcId;
630                     pAspMsg->cmd = ASP_MASTER_DEC_DECODE_DONE;
631                     pAspMsg->messageId = hAspMsgSlave->masterMessageId | ((UInt32)1<<31);
632                     argIdx = 0; // set decErrno
633                     *(Int32 *)&pAspMsg->buf[argIdx] = errno;
634                     argIdx += sizeof(Int32); // set cbErrno
635                     *(Int32 *)&pAspMsg->buf[argIdx] = cbErrno;                    
636                     TRACE_MSG3("Tx ASP message, procId=%d, cmd=%d, messageId=0x%04x", pAspMsg->procId, pAspMsg->cmd, pAspMsg->messageId);
637                     status = MessageQ_put(queId, (MessageQ_Msg)pAspMsg); /* send message back */
638                     if (status != MessageQ_S_SUCCESS)
639                     {
640                         SW_BREAKPOINT;
641                     }
642                     
643                     break;
644                     
645                 case ASP_SLAVE_DEC_DEACTIVATE:
646                     gSlaveDecDeactivateCnt++;
647                     // simulate dec info load
648                     //simLoad(DEC_DEACTIVATE_LOAD);
649                     
650                     argIdx = 0; // get decIdx
651                     z = *(Int32 *)&pAspMsg->buf[argIdx];
652                     TRACE_TERSE2("slaveCmd=%d, decIdx=%d", slaveCmd, z);
653                     
654                     if (alg[z]->fxns->algDeactivate)
655                     {
656                         alg[z]->fxns->algDeactivate(alg[z]);
657                     }
658                     
659                     // Stop writes to circular buffer
660                     pCb = &pC->xDec[z].decOpCb;
661                     cbWriteStop(pCb);
662                     
663                     // send dec deactivate complete message to master
664                     queId = MessageQ_getReplyQueue(pAspMsg);
665                     pAspMsg->procId = hAspMsgSlave->slaveProcId;
666                     pAspMsg->cmd = ASP_MASTER_DEC_DEACTIVATE_DONE;
667                     pAspMsg->messageId = hAspMsgSlave->masterMessageId | ((UInt32)1<<31);
668                     TRACE_MSG3("Tx ASP message, procId=%d, cmd=%d, messageId=0x%04x", pAspMsg->procId, pAspMsg->cmd, pAspMsg->messageId);
669                     status = MessageQ_put(queId, (MessageQ_Msg)pAspMsg); /* send message back */
670                     if (status != MessageQ_S_SUCCESS)
671                     {
672                         SW_BREAKPOINT;
673                     }
674                     
675                     break;
676                     
677                 default:
678                     TRACE_TERSE1("ERROR: invalid slaveCmd=%d", slaveCmd);
679                     break;
680             }
681         }
682     }
683     
684     Log_info0("exit taskAsdpFxn()");   
688 // -----------------------------------------------------------------------------
689 // AST Initialization Function - Memory Allocation
690 //
691 //   Name:      PAF_AST_initPhaseMalloc
692 //   Purpose:   Audio Stream Task Function for initialization of data pointers
693 //              by allocation of memory.
694 //   From:      audioStream1Task or equivalent
695 //   Uses:      See code.
696 //   States:    x
697 //   Return:    0 on success.
698 //              Source code line number on MEM_calloc failure.
699 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
700 //              * State information as per parent.
701 //              * Memory allocation errors.
702 //
703 Int
704 PAF_ASDT_initPhaseMalloc(
705     const PAF_AST_Params *pP, 
706     const PAF_AST_Patchs *pQ, 
707     PAF_AST_Config *pC
710     Int as = pC->as;                    /* Audio Stream Number (1, 2, etc.) */
711     Int zMS = pC->masterStr;
712     Error_Block    eb;
714     TRACE_TERSE1("PAF_AST_initPhaseMallocSlave: AS%d: initialization phase - memory allocation", as+zMS);
716     // Initialize error block
717     Error_init(&eb); 
719     if (!(gpDecAudioFrame = (PAF_AudioFrame *)Memory_calloc((IHeap_Handle)HEAP_INTERNAL1,
720         DECODEN * sizeof (PAF_AudioFrame), 4, &eb)))
721     {
722         TRACE_TERSE1("PAF_AST_initPhaseMallocSlave: AS%d: Memory_calloc failed", as+zMS);
723         SW_BREAKPOINT;
724         return __LINE__;
725     }
726     TRACE_TERSE3("PAF_AST_initPhaseMalloc. (gpAudioFrameSlave) %d bytes from space %d at 0x%x.",
727             DECODEN * sizeof (PAF_AudioFrame),
728             HEAP_ID_INTERNAL1, (IArg)gpDecAudioFrame);
730     TRACE_TERSE1("PAF_AST_initPhaseMallocSlave: AS%d: initialization phase - memory allocation complete.", as+zMS);
731     return 0;
732 } //PAF_ASDT_initPhaseMalloc
734 // -----------------------------------------------------------------------------
735 // AST Initialization Function - Memory Initialization from Configuration
736 //
737 //   Name:      PAF_AST_initPhaseConfig
738 //   Purpose:   Audio Stream Task Function for initialization of data values
739 //              from parameters.
740 //   From:      audioStream1Task or equivalent
741 //   Uses:      See code.
742 //   States:    x
743 //   Return:    0 on success.
744 //              Other as per initFrame0 and initFrame1.
745 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
746 //              * State information as per parent.
747 //
749 Int
750 PAF_ASDT_initPhaseConfig(
751     const PAF_AST_Params *pP, 
752     const PAF_AST_Patchs *pQ, 
753     PAF_AST_Config *pC
756     Int z;
758     // overwrite pointer to audio frame in framework decode control
759     for (z=DECODE1; z < DECODEN; z++) 
760     {
761         //Int zS = pP->streamsFromDecodes[z]; // FL: slave
762         //pC->xDec[z].decodeControl.pAudioFrame = pC->xStr[zS].pAudioFrame; // FL: slave
763         //pC->xDec[z].decodeInStruct.pAudioFrame = pC->xStr[zS].pAudioFrame; // FL: slave        
764         pC->xDec[z].decodeControl.pAudioFrame = &gpDecAudioFrame[z];
765         pC->xDec[z].decodeInStruct.pAudioFrame = &gpDecAudioFrame[z];
766         pP->fxns->initFrame0(pP, pQ, pC, z);
767     }
769     return 0;
770 }  //PAF_ASDT_initPhaseConfig
772 // -----------------------------------------------------------------------------
773 // AST Initialization Function - ACP Algorithm Instantiation
774 //
775 //   Name:      PAF_AST_initPhaseAcpAlg
776 //   Purpose:   Audio Stream Task Function for initialization of ACP by
777 //              instantiation of the algorithm.
778 //   From:      audioStream1Task or equivalent
779 //   Uses:      See code.
780 //   States:    x
781 //   Return:    0 on success.
782 //              Source code line number on ACP Algorithm creation failure.
783 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
784 //              * State information as per parent.
785 //              * Memory allocation errors.
786 //
787 Int
788 PAF_ASDT_initPhaseAcpAlg(
789     const PAF_AST_Params *pP, 
790     const PAF_AST_Patchs *pQ, 
791     PAF_AST_Config *pC
794     Int as = pC->as;                    /* Audio Stream Number (1, 2, etc.) */
795     Int z;                              /* input/encode/stream/decode/output */
796                                         /* counter                           */
797     Int betaPrimeOffset;
798     ACP_Handle acp;
799     Int zMS = pC->masterStr;
800     Int zS; //, zX;
802     TRACE_TERSE1("PAF_ASDT_initPhaseAcpAlg: AS%d: initialization phase - ACP Algorithm", as+zMS);
804     ACP_MDS_init();
806     if (!(acp = (ACP_Handle )ACP_MDS_create (NULL))) 
807     {
808         TRACE_TERSE1("PAF_ASDT_initPhaseAcpAlg: AS%d: ACP algorithm instance creation  failed", as+zMS);
809         return __LINE__;
810     }
811     pC->acpSlave = acp;
813     ((ALG_Handle)acp)->fxns->algControl((ALG_Handle)acp,
814         ACP_GETBETAPRIMEOFFSET, (IALG_Status *)&betaPrimeOffset);
816 #if 0 // FL: master
817     for (z=INPUT1; z < INPUTN; z++) 
818     {
819         zS = z;
820         for (zX = DECODE1; zX < DECODEN; zX++) 
821         {
822             if (pP->inputsFromDecodes[zX] == z) 
823             {
824                 zS = pP->streamsFromDecodes[zX];
825                 break;
826             }
827         }
828         acp->fxns->attach(acp, ACP_SERIES_STD,
829             STD_BETA_IB + betaPrimeOffset * (as-1+zS),
830             (IALG_Status *)&pC->xInp[z].inpBufStatus);
831         /* Ignore errors, not reported. */
832     }
833 #endif
835     for (z=DECODE1; z < DECODEN; z++) 
836     {
837         zS = pP->streamsFromDecodes[z];
838         acp->fxns->attach(acp, ACP_SERIES_STD,
839             STD_BETA_DECODE + betaPrimeOffset * (as-1+zS),
840             (IALG_Status *)&pC->xDec[z].decodeStatus);
841         /* Ignore errors, not reported. */
842     }
844 #if 0 // FL: master
845     for (z=ENCODE1; z < ENCODEN; z++) 
846     {
847         zS = pP->streamsFromEncodes[z];
848         acp->fxns->attach(acp, ACP_SERIES_STD,
849             STD_BETA_ENCODE + betaPrimeOffset * (as-1+zS),
850             (IALG_Status *)&pC->xEnc[z].encodeStatus);
851         acp->fxns->attach(acp, ACP_SERIES_STD,
852             STD_BETA_VOLUME + betaPrimeOffset * (as-1+zS),
853             (IALG_Status *)&pC->xEnc[z].volumeStatus);
854         /* Ignore errors, not reported. */
855     }
856 #endif
857     
858 #if 0 // FL: master
859     for (z=OUTPUT1; z < OUTPUTN; z++) 
860     {
861         zS = z;
862         for (zX = ENCODE1; zX < ENCODEN; zX++) 
863         {
864             if (pP->outputsFromEncodes[zX] == z) 
865             {
866                 zS = pP->streamsFromEncodes[zX];
867                 break;
868             }
869         }
870         acp->fxns->attach(acp, ACP_SERIES_STD,
871             STD_BETA_OB + betaPrimeOffset * (as-1+zS),
872             (IALG_Status *)&pC->xOut[z].outBufStatus);
873         /* Ignore errors, not reported. */
874     }
875 #endif
876     
877     TRACE_TERSE1("PAF_ASDT_initPhaseAcpAlg: AS%d: initialization phase - ACP Algorithm complete.", as+zMS);
879     return 0;
880 } //PAF_AST_initPhaseAcpAlg
882 // -----------------------------------------------------------------------------
883 // AST Initialization Function - Common Memory and Algorithms
884 //
885 //   Name:      PAF_AST_initPhaseCommon
886 //   Purpose:   Audio Stream Task Function for initialization of data pointers
887 //              by allocation for common memory and by instantiation for
888 //              algorithms.
889 //   From:      audioStream1Task or equivalent
890 //   Uses:      See code.
891 //   States:    x
892 //   Return:    0 on success.
893 //              Source code line number on PAF_ALG_alloc failure.
894 //              Source code line number on PAF_ALG_mallocMemory failure.
895 //              Source code line number on Decode Chain initialization failure.
896 //              Source code line number on ASP Chain initialization failure.
897 //              Source code line number on Encode Chain initialization failure.
898 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
899 //              * State information as per parent.
900 //              * Memory allocation errors.
901 //
903 #include <pafsio_ialg.h>
905 Int
906 PAF_ASDT_initPhaseCommon(
907     const PAF_AST_Params *pP, 
908     const PAF_AST_Patchs *pQ, 
909     PAF_AST_Config *pC
912     Int as = pC->as;                    /* Audio Stream Number (1, 2, etc.) */
913     Int z;                              /* stream counter */
914     //Int g;                              /* gear */
915     ACP_Handle acp = pC->acpSlave;
916     PAF_IALG_Config pafAlgConfig;
917     IALG_MemRec common[3][PAF_IALG_COMMON_MEMN+1];
918    
919     TRACE_TERSE0("PAF_AST_initPhaseCommonSlav: initialization phase - Common Algorithms");
921     //
922     // Determine memory needs and instantiate algorithms across audio streams
923     //
925     TRACE_TERSE0("PAF_ASDT_initPhaseCommon: calling PAF_ALG_setup.");
926     PAF_ALG_setup(&pafAlgConfig, 
927         HEAP_ID_INTERNAL,       HEAP_INTERNAL, 
928         HEAP_ID_INTERNAL1,      HEAP_INTERNAL1, 
929         HEAP_ID_EXTERNAL,       HEAP_EXTERNAL, 
930         HEAP_ID_INTERNAL1_SHM,  HEAP_INTERNAL1_SHM, 
931         HEAP_CLEAR);
933     if (pP->fxns->headerPrint)
934         pP->fxns->headerPrint();
936     for (z=STREAM1; z < STREAMN; z++) 
937     {
938         //Int zD, zE, zX;
939         Int zD, zX;
941         TRACE_TERSE1("PAF_ASDT_initPhaseCommon: AS%d: initialization phase - Common Algorithms", as+z);
943         //
944         // Determine common memory needs of Decode Algorithms
945         //
946         PAF_ALG_init (common[z], lengthof (common[z]), COMMONSPACE);
948         zD = -1;
949         for (zX = DECODE1; zX < DECODEN; zX++) 
950         {
951             if (pP->streamsFromDecodes[zX] == z) 
952             {
953                 zD = zX;
954                 break;
955             }
956         }
958 #if 0 // FL: master
959         zE = -1;
960         for (zX = ENCODE1; zX < ENCODEN; zX++) 
961         {
962             if (pP->streamsFromEncodes[zX] == z) 
963             {
964                 zE = zX;
965                 break;
966             }
967         }
968 #endif
970         if (zD >= 0) 
971         {
972             TRACE_TERSE1("PAF_ASDT_initPhaseCommon: calling PAF_ALG_ALLOC for decoder common[%d].", z);
973             if (PAF_ALG_ALLOC (decLinkInit[zD-DECODE1], common[z])) 
974             {
975                 TRACE_TERSE3("AS%d: %s.%d: PAF_ALG_alloc failed", as+z, (IArg)__FUNCTION__, __LINE__);
976                 TRACE_TERSE2("Failed to alloc %d bytes from space %d", common[z]->size, common[z]->space);
978                 SW_BREAKPOINT;
979                 return __LINE__;
980             }
981             TRACE_TERSE3("alloced %d bytes from space %d at 0x%x", common[z]->size, common[z]->space, (IArg)common[z]->base);
982             if(pP->fxns->allocPrint)
983                 pP->fxns->allocPrint ((const PAF_ALG_AllocInit *)(decLinkInit[z-DECODE1]),sizeof (*(decLinkInit[z-DECODE1])), &pafAlgConfig);
984         }
986 #if 0 // FL: master
987         TRACE_TERSE3("%s.%d: calling PAF_ALG_ALLOC for stream common[%d].", (IArg)__FUNCTION__, __LINE__, z);
988         TRACE_TERSE3("%s.%d: calling PAF_ALG_ALLOC for stream common[%d].", (IArg)__FUNCTION__, __LINE__, z);
989         if (PAF_ALG_ALLOC (aspLinkInit[z-STREAM1][0], common[z])) 
990         {
991             TRACE_TERSE3("AS%d: %s.%d: PAF_ALG_alloc failed", as+z, (IArg)__FUNCTION__, __LINE__);
992             TRACE_TERSE2("Failed to alloc %d bytes from space %d ", common[z]->size, common[z]->space);
993             SW_BREAKPOINT;
994             return __LINE__;
995         }
996         TRACE_TERSE3("alloced %d bytes from space %d at 0x%x", common[z]->size, common[z]->space, (IArg)common[z]->base);
997         if(pP->fxns->allocPrint)
998             pP->fxns->allocPrint((const PAF_ALG_AllocInit *)(aspLinkInit[z-STREAM1][0]), sizeof (*(aspLinkInit[z-STREAM1][0])), &pafAlgConfig);
999 #endif
1000         
1001 #if 0 // FL: master
1002         if (zE >= 0) 
1003         {
1004             TRACE_TERSE3("%s.%d: calling PAF_ALG_ALLOC/ for encoder common[%d].", (IArg)__FUNCTION__, __LINE__, z);
1005             if (PAF_ALG_ALLOC (encLinkInit[zE-ENCODE1], common[z])) 
1006             {
1007                 TRACE_TERSE3("AS%d: %s.%d: PAF_ALG_alloc failed",
1008                              as+z, (IArg)__FUNCTION__, __LINE__);
1009                 SW_BREAKPOINT;
1010                 return __LINE__;
1011             }
1012             TRACE_TERSE3("alloced %d bytes from space %d at 0x%x", common[z]->size, common[z]->space, (IArg)common[z]->base);
1013             if(pP->fxns->allocPrint)
1014                 pP->fxns->allocPrint((const PAF_ALG_AllocInit *)(encLinkInit[z-ENCODE1]), sizeof (*(encLinkInit[z-ENCODE1])), &pafAlgConfig);
1015         }
1016 #endif
1018         //
1019         // Determine common memory needs of Logical IO drivers
1020         //
1022 #if 0 // FL: master
1023         // really need to loop over all inputs for this stream using the tables
1024         // inputsFromDecodes and streamsFromDecodes. But these don't exist for this
1025         // patch, and not needed for FS11, since there is only one input.
1026         if (INPUT1 <= z && z < INPUTN) 
1027         {
1028             TRACE_TERSE3("AS%d: PAF_AST_initPhaseCommon.%d: alloc inpLinkInit common[%d]", as+z, __LINE__, z);
1029             if (PAF_ALG_ALLOC (inpLinkInit[z-INPUT1], common[z])) 
1030             {
1031                 TRACE_TERSE3("AS%d: %s.%d: PAF_ALG_alloc failed", as+z, (IArg)__FUNCTION__, __LINE__);
1032                 TRACE_TERSE2("failed to alloc %d bytes from space %d", common[z]->size, (IArg)common[z]->space);
1033                 SW_BREAKPOINT;
1034                 return __LINE__;
1035             }
1036             TRACE_TERSE3("alloced %d bytes from space %d at 0x%x", common[z]->size, common[z]->space, (IArg)common[z]->base);
1037             if(pP->fxns->allocPrint)
1038                 pP->fxns->allocPrint((const PAF_ALG_AllocInit *)(inpLinkInit[z-INPUT1]), sizeof (*(inpLinkInit[z-INPUT1])), &pafAlgConfig);
1039         }
1040 #endif        
1042 #if 0 // FL: master
1043         if (OUTPUT1 <= z && z < OUTPUTN) 
1044         {
1045             TRACE_TERSE3("%s.%d: calling PAF_ALG_ALLOC outLinkInit common[%d].", (IArg)__FUNCTION__, __LINE__, z);
1046             if (PAF_ALG_ALLOC (outLinkInit[z-OUTPUT1], common[z])) 
1047             {
1048                 TRACE_TERSE3("AS%d: %s.%d: PAF_ALG_alloc failed", as+z, (IArg)__FUNCTION__, __LINE__);
1049                 TRACE_TERSE2("Failed to alloc %d bytes from space %d", common[z]->size, (IArg)common[z]->space);
1050                 SW_BREAKPOINT;
1051                 return __LINE__;
1052             }
1053             TRACE_TERSE3("alloced %d bytes from space %d at 0x%x", common[z]->size, common[z]->space, (IArg)common[z]->base);
1054             if(pP->fxns->allocPrint)
1055                 pP->fxns->allocPrint((const PAF_ALG_AllocInit *)(outLinkInit[z-INPUT1]), sizeof (*(outLinkInit[z-INPUT1])), &pafAlgConfig);
1056         }
1057 #endif        
1058     }
1059     {
1060         // Changes made to share scratch between zones
1061         // Assume maximum 3 zones and scratch common memory is at offset 0;
1062         int max=0;
1063         for (z=STREAM1; z < STREAMN; z++)
1064         {
1065             if (max<common[z][0].size)
1066                 max=common[z][0].size;
1067         }
1068         common[STREAM1][0].size=max;
1069         for (z=STREAM1+1; z < STREAMN; z++)
1070             common[z][0].size=0;
1071     }
1072     
1073     //
1074     // Provide common memory needs of Decode Algorithms
1075     //
1076     for (z=STREAM1; z < STREAMN; z++) 
1077     {
1078         //Int zD, zE, zX;
1079         Int zD, zX;
1081         zD = -1;        
1082         for (zX = DECODE1; zX < DECODEN; zX++) 
1083         {
1084            if (pP->streamsFromDecodes[zX] == z) 
1085            {
1086                zD = zX;
1087                break;
1088            }
1089         }
1091 #if 0 // FL: master
1092         zE = -1;
1093         for (zX = ENCODE1; zX < ENCODEN; zX++) 
1094         {
1095            if (pP->streamsFromEncodes[zX] == z) 
1096            {
1097                zE = zX;
1098                break;
1099            }
1100         }
1101 #endif
1103         TRACE_TERSE0("PAF_ASDT_initPhaseCommon: calling PAF_ALG_mallocMemory for common space.");
1104         if (PAF_ALG_mallocMemory (common[z], &pafAlgConfig)) 
1105         {
1106             TRACE_TERSE3("AS%d: %s.%d: PAF_ALG_mallocMemory failed", as+z, (IArg)__FUNCTION__, __LINE__);
1107             TRACE_TERSE3("AS%d: z: %d.  Size 0x%x", as+z, z, common[z][0].size);
1108             SW_BREAKPOINT;
1109             return __LINE__;
1110         }
1111         TRACE_TERSE3("alloced %d bytes from space %d at 0x%x", common[z]->size, common[z]->space, (IArg)common[z]->base);
1112         // share zone0 scratch with all zones 
1113         common[z][0].base=common[0][0].base;
1114         if (pP->fxns->commonPrint)
1115                 pP->fxns->commonPrint (common[z], &pafAlgConfig);
1117         //
1118         // Instantiate Decode Algorithms
1119         //
1120         if (zD >= 0) 
1121         {
1122             PAF_ASP_Chain *chain;
1123             TRACE_TERSE0("PAF_ASDT_initPhaseCommon: calling PAF_ASP_chainInit for decode.");
1124             chain =
1125                 PAF_ASP_chainInit (&pC->xDec[zD].decChainData, pP->pChainFxns,
1126                                    HEAP_INTERNAL, as+z, acp, &trace,
1127                                    decLinkInit[zD-DECODE1], NULL, common[z], &pafAlgConfig);
1128             if (!chain) 
1129             {
1130                 TRACE_TERSE1("AS%d: Decode chain initialization failed", as+z);
1131                 return __LINE__;
1132             }
1133         }
1135 #if 0 // FL: master
1136         pC->xStr[z].aspChain[0] = NULL;
1137         for (g=0; g < GEARS; g++) 
1138         {
1139             PAF_ASP_Chain *chain;
1140             TRACE_TERSE2("%s.%d: calling PAF_ASP_chainInit for ASPs.", (IArg)__FUNCTION__, __LINE__);
1141             chain =
1142                 PAF_ASP_chainInit (&pC->xStr[z].aspChainData[g], pP->pChainFxns,
1143                                    HEAP_INTERNAL, as+z, acp, &trace,
1144                                    aspLinkInit[z-STREAM1][g], pC->xStr[z].aspChain[0], common[z], &pafAlgConfig);
1145             if (! chain) 
1146             {
1147                 TRACE_TERSE2("AS%d: ASP chain %d initialization failed", as+z, g);
1148                 return __LINE__;
1149             }
1150             else
1151                 pC->xStr[z].aspChain[g] = chain;
1152         }
1153 #endif
1155 #if 0 // FL: master
1156         if (zE >= 0) 
1157         {
1158             PAF_ASP_Chain *chain;
1159             TRACE_TERSE2("%s.%d: calling PAF_ASP_chainInit for encode.", (IArg)__FUNCTION__, __LINE__);
1160             chain =
1161                 PAF_ASP_chainInit (&pC->xEnc[zE].encChainData, pP->pChainFxns,
1162                                    HEAP_INTERNAL, as+z, acp, &trace,
1163                                    encLinkInit[zE-ENCODE1], NULL, common[z], &pafAlgConfig);
1164             if (!chain) 
1165             {
1166                 TRACE_TERSE1("AS%d: Encode chain initialization failed", as+z);
1167                 return __LINE__;
1168             }
1169         }
1170 #endif
1172 #if 0 // FL: master
1173         //
1174         // Allocate non-common memories for Logical IO drivers
1175         //    Since these structures are used at run-time we allocate from external memory
1176         if (INPUT1 <= z && z < INPUTN) 
1177         {
1178             PAF_ASP_Chain *chain;
1179             TRACE_TERSE3("AS%d: PAF_AST_initPhaseCommon.%d: non-common input chain init for %d",
1180                            as+z, __LINE__, z);
1181             chain = PAF_ASP_chainInit (&pC->xInp[z].inpChainData, pP->pChainFxns,
1182                     HEAP_EXTERNAL, as+z, acp, &trace,
1183                     inpLinkInit[z-INPUT1], NULL, common[z], &pafAlgConfig);
1184             if (!chain) 
1185             {
1186                 TRACE_TERSE1("AS%d: Input chain initialization failed", as+z);
1187                 return __LINE__;
1188             }
1189         }
1190 #endif        
1192 #if 0 // FL: master
1193         if (OUTPUT1 <= z && z < OUTPUTN) 
1194         {
1195             PAF_ASP_Chain *chain;
1196             TRACE_TERSE3("AS%d: PAF_AST_initPhaseCommon.%d: non-common output chain init for %d",
1197                            as+z, __LINE__, z);
1198             chain = PAF_ASP_chainInit (&pC->xOut[z].outChainData, pP->pChainFxns,
1199                     HEAP_EXTERNAL, as+z, acp, &trace,
1200                     outLinkInit[z-OUTPUT1], NULL, common[z], &pafAlgConfig);
1201             if (!chain) 
1202             {
1203                 TRACE_TERSE1("AS%d: Output chain initialization failed", as+z);
1204                 return __LINE__;
1205             }
1206         }
1207 #endif        
1208     }
1209     TRACE_TERSE1("PAF_ASDT_initPhaseCommon: AS%d: Returning complete.", as+z);
1211     return 0;
1212 } //PAF_ASDT_initPhaseCommon
1214 // -----------------------------------------------------------------------------
1215 // AST Initialization Function - Algorithm Keys
1216 //
1217 //   Name:      PAF_AST_initPhaseAlgKey
1218 //   Purpose:   Audio Stream Task Function for initialization of data values
1219 //              from parameters for Algorithm Keys.
1220 //   From:      audioStream1Task or equivalent
1221 //   Uses:      See code.
1222 //   States:    x
1223 //   Return:    0.
1224 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
1225 //              * State information as per parent.
1226 //
1227 // .............................................................................
1228 Int
1229 PAF_ASDT_initPhaseAlgKey(
1230     const PAF_AST_Params *pP, 
1231     const PAF_AST_Patchs *pQ, 
1232     PAF_AST_Config *pC
1235     Int as = pC->as;                    /* Audio Stream Number (1, 2, etc.) */
1236     Int z;                              /* decode/encode counter */
1237     Int s;                              /* key number */
1238     PAF_ASP_Link *that;
1240     (void)as;  // clear warning.
1242     TRACE_VERBOSE1("PAF_ASDT_initPhaseCommon: AS%d: initialization phase - Algorithm Keys", as);
1244     for (z=DECODE1; z < DECODEN; z++) 
1245     {
1246         for (s=0; s < pP->pDecAlgKey->length; s++) 
1247         {
1248             if ((pP->pDecAlgKey->code[s].full != 0)
1249                 && (that = PAF_ASP_chainFind (&pC->xDec[z].decChainData, pP->pDecAlgKey->code[s])))
1250             {
1251                 pC->xDec[z].decAlg[s] = (ALG_Handle )that->alg;
1252                     /* Cast in interface, for now --Kurt */
1253             }
1254             else
1255                 pC->xDec[z].decAlg[s] = NULL;
1256         }
1257     }
1259 #if 0 // FL: master
1260     for (z=ENCODE1; z < ENCODEN; z++) 
1261     {
1262         for (s=0; s < pP->pEncAlgKey->length; s++) 
1263         {
1264             if (pP->pEncAlgKey->code[s].full != 0
1265                 && (that = PAF_ASP_chainFind (&pC->xEnc[z].encChainData, pP->pEncAlgKey->code[s])))
1266                 pC->xEnc[z].encAlg[s] = (ALG_Handle )that->alg;
1267             /* Cast in interface, for now --Kurt */
1268             else
1269                 pC->xEnc[z].encAlg[s] = NULL;
1270         }
1271     }
1272 #endif    
1274     return 0;
1275 } //PAF_AST_initPhaseAlgKey
1277 Int
1278 PAF_ASDT_initFrame0(
1279     const PAF_AST_Params *pP, 
1280     const PAF_AST_Patchs *pQ, 
1281     PAF_AST_Config *pC, 
1282     Int z
1285     Int as = pC->as;                    /* Audio Stream Number (1, 2, etc.) */
1286     Int aLen;
1287     Int aSize = sizeof(PAF_AudioData);
1288     Int aAlign = aSize < sizeof (int) ? sizeof (int) : aSize;
1289     Int maxFrameLength = pP->maxFramelength;
1290     PAF_AudioData *aBuf=NULL;
1291     XDAS_UInt8 *metadataBuf;
1292     Error_Block    eb;
1293     PAF_AudioFrame *pAudioFrame;
1294     Int i;
1296     pAudioFrame = &gpDecAudioFrame[z];
1297     if (pAudioFrame == NULL)
1298     {
1299         SW_BREAKPOINT;
1300     }
1301     
1302     // Initialize error block
1303     Error_init(&eb); 
1304     
1305     //maxFrameLength += PA_MODULO - maxFrameLength % PA_MODULO; // compute maximum framelength (needed for ARC support)
1306     aLen = numchan[z] * maxFrameLength;
1308     //
1309     // Initialize audio frame elements directly
1310     //
1311     pAudioFrame->fxns = pP->pAudioFrameFunctions;
1312     pAudioFrame->data.nChannels = PAF_MAXNUMCHAN;
1313     pAudioFrame->data.nSamples = FRAMELENGTH;
1314     pAudioFrame->data.sample = gDecAudioFrameChannelPointers;
1315     pAudioFrame->data.samsiz = gDecAudioFrameChannelSizes;
1316     pAudioFrame->pChannelConfigurationMaskTable = &PAF_ASP_stdCCMT;
1318     //
1319     // Allocate memory for and initialize pointers to audio data buffers
1320     //
1321     //   The NUMCHANMASK is used to identify the channels for which data
1322     //   buffers can be allocated. Using this mask and switch statement
1323     //   rather than some other construct allows efficient code generation,
1324     //   providing just the code necessary (with significant savings).
1325     //
1326     if (pP->fxns->bufMemPrint)
1327     {
1328         pP->fxns->bufMemPrint(z, aLen*aSize, HEAP_ID_FRMBUF, 2);
1329     }
1331     TRACE_TERSE1("PAF_ASDT_initFrame0: AS%d: Memory_calloc for audio buffers", as+z);
1332     
1333     if (aLen != 0)
1334     {
1335         if (!(aBuf = (PAF_AudioData *)Memory_calloc((IHeap_Handle)HEAP_FRMBUF, aLen*aSize, aAlign, &eb)))
1336         {
1337             TRACE_TERSE2("AS%d: %s: MEM_calloc failed", as+z, (IArg)__FUNCTION__);
1338             TRACE_TERSE2("  maxFrameLength: %d.  aLen*aSize: %d", maxFrameLength, aLen*aSize);
1339             SW_BREAKPOINT;
1340             return __LINE__;
1341         }
1342     }
1344     TRACE_TERSE3("  maxFrameLength: %d.  aLen*aSize: %d.  aBuf: 0x%x", maxFrameLength, aLen*aSize, (IArg)aBuf);
1346     TRACE_TERSE1("PAF_ASDT_initFrame0: AS%d: Memory_calloc for metadata buffers", as+z);
1347     if (!(metadataBuf = (XDAS_UInt8 *)Memory_calloc((IHeap_Handle)HEAP_MDBUF, pP->pMetadataBufStatus->bufSize*pP->pMetadataBufStatus->NumBuf, pP->pMetadataBufStatus->alignment, &eb)))
1348     {
1349         TRACE_TERSE1("PAF_ASDT_initFrame0: AS%d: Memory_calloc failed", as+z);
1350         TRACE_TERSE1("  bufSize*NumBuf: %d", pP->pMetadataBufStatus->bufSize*pP->pMetadataBufStatus->NumBuf);
1351         SW_BREAKPOINT;
1352         return __LINE__;
1353     }
1355     for (i=0; i < PAF_MAXNUMCHAN_AF; i++)
1356     {
1357         gDecAudioFrameChannelPointers[i] = NULL;
1358     }
1360     if ((numchan[z] > PAF_MAXNUMCHAN) || (numchan[z] < 1)) 
1361     {
1362         TRACE_TERSE1("PAF_ASDT_initFrame0: AS%d: unsupported option", as+z);
1363         return __LINE__;
1364     }
1365     else 
1366     {
1367         Int j = 0;
1368         TRACE_TERSE1("PAF_ASDT_initFrame0: AFChanPtrMap[%d][i]", numchan[z]);
1369         for (i=0; i<numchan[z]; i++)
1370         {
1371             Int8 chan = AFChanPtrMap[numchan[z]][i];
1372             if (chan != -1)
1373             {
1374                 gDecAudioFrameChannelPointers[chan] = aBuf + maxFrameLength*(j+1) - FRAMELENGTH;
1375                 j++;
1376                 TRACE_TERSE3("PAF_ASDT_initFrame0: chan = %d = AFChanPtrMap[%d][%d].", chan, numchan[z], i);
1377                 TRACE_TERSE2("PAF_ASDT_initFrame0: audioFrameChannelPointers[%d]: 0x%x", chan, (IArg)gDecAudioFrameChannelPointers[chan]);
1378             }
1379         }
1380     }
1382     // Initialize original audio frame channel pointers
1383     for (i=PAF_LEFT; i < PAF_MAXNUMCHAN_AF; i++) 
1384     {
1385         if (gDecAudioFrameChannelPointers[i])
1386         {
1387             gDecOrigAudioFrameChannelPointers[i] = gDecAudioFrameChannelPointers[i];
1388         }
1389     }
1391     //
1392     // Initialize meta data elements
1393     //
1394     pAudioFrame->pafBsMetadataUpdate = XDAS_FALSE;
1395     pAudioFrame->numPrivateMetadata = 0;
1396     pAudioFrame->bsMetadata_offset = 0;
1397     pAudioFrame->bsMetadata_type = PAF_bsMetadata_channelData;
1398     pAudioFrame->privateMetadataBufSize = pP->pMetadataBufStatus->bufSize;
1399     for (i=0; i<pP->pMetadataBufStatus->NumBuf; i++)
1400     {
1401         pAudioFrame->pafPrivateMetadata[i].offset = 0;
1402         pAudioFrame->pafPrivateMetadata[i].size = 0;
1403         pAudioFrame->pafPrivateMetadata[i].pMdBuf = metadataBuf + pP->pMetadataBufStatus->bufSize*i;
1404     }
1406     return 0;
1407 } //PAF_ASDT_initFrame0
1409 // -----------------------------------------------------------------------------
1410 // ASOT Initialization Function Helper - Reinitialization of Audio Frame
1411 // AST Decoding Function              - Reinitialization of Audio Frame
1412 //
1413 //   Name:      PAF_ASOT_initFrame1
1414 //   Purpose:   Audio Stream Task Function for initialization or reinitiali-
1415 //              zation of the Audio Frame(s) by loading of data values of a
1416 //              time-varying nature.
1417 //   From:      audioStream1Task or equivalent
1418 //              AST Parameter Function -> decodeInfo
1419 //              AST Parameter Function -> decodeDecode
1420 //   Uses:      See code.
1421 //   States:    x
1422 //   Return:    0.
1423 //   Trace:     None.
1424 //
1425 Int
1426 PAF_ASDT_initFrame1(
1427     const PAF_AST_Params *pP, 
1428     const PAF_AST_Patchs *pQ, 
1429     PAF_AST_Config *pC, 
1430     Int z, 
1431     Int apply
1434     PAF_AudioFrame *pAudioFrame;
1436     //
1437     // Reinitialize audio frame elements:
1438     //
1439     //   Channel Configurations during sys init                 = Unknown
1440     //      "          "        during info or decode           = None
1441     //
1442     //   Sample Rate / Count    during sys init, info or decode = Unknown / 0
1443     //
1445     pAudioFrame = &gpDecAudioFrame[z];
1447     if (apply < 0) 
1448     {
1449         pAudioFrame->channelConfigurationRequest.legacy = PAF_CC_UNKNOWN;
1450         pAudioFrame->channelConfigurationStream.legacy = PAF_CC_UNKNOWN;
1451     }
1452     else 
1453     {
1454         pAudioFrame->channelConfigurationRequest.legacy = PAF_CC_NONE;
1455         pAudioFrame->channelConfigurationStream.legacy = PAF_CC_NONE;
1456     }
1458     if (apply < 1) 
1459     {
1460         pAudioFrame->sampleRate = PAF_SAMPLERATE_UNKNOWN;
1461         pAudioFrame->sampleCount = 0;
1462     }
1464     return 0;
1465 } //PAF_ASDT_initFrame1
1467 // Reset AF, invoked during decode ACTIVATE (during state=INIT on Master)
1468 Int resetAf(
1469     const PAF_AST_Params *pP, 
1470     Int z, 
1471     Int sourceSelect
1474     PAF_AudioFrame *pAudioFrame;
1475     Int ch;
1476     Int i;
1478     // Get audio frame
1479     pAudioFrame = &gpDecAudioFrame[z];
1480     if (pAudioFrame == NULL)
1481     {
1482         SW_BREAKPOINT;
1483     }
1485     // Reinitialize audio frame elements
1486     pAudioFrame->channelConfigurationRequest.legacy = PAF_CC_NONE;
1487     pAudioFrame->channelConfigurationStream.legacy = PAF_CC_NONE;
1488     pAudioFrame->sampleRate = PAF_SAMPLERATE_UNKNOWN;
1489     pAudioFrame->sampleCount = 0;
1490     pAudioFrame->data.nChannels = PAF_MAXNUMCHAN;
1491     
1492     if (sourceSelect == PAF_SOURCE_PCM)
1493     {
1494         pAudioFrame->data.nSamples = FRAMELENGTH;
1495     }
1496     else if (sourceSelect == PAF_SOURCE_DDP)
1497     {
1498         pAudioFrame->data.nSamples = 1536;        
1499     }
1500     else
1501     {
1502         pAudioFrame->data.nSamples = FRAMELENGTH;
1503     }   
1505     // Reset audio frame channel pointers
1506     for (ch=PAF_LEFT; ch < PAF_MAXNUMCHAN_AF; ch++) 
1507     {
1508         if (gDecAudioFrameChannelPointers[ch])
1509         {
1510             gDecAudioFrameChannelPointers[ch] = gDecOrigAudioFrameChannelPointers[ch];
1511         }
1512     }
1513     
1514     // Reset audio frame meta data elements
1515     pAudioFrame->pafBsMetadataUpdate = XDAS_FALSE;
1516     pAudioFrame->numPrivateMetadata = 0;
1517     pAudioFrame->bsMetadata_offset = 0;
1518     pAudioFrame->bsMetadata_type = PAF_bsMetadata_channelData;
1519     for (i=0; i<pP->pMetadataBufStatus->NumBuf; i++)
1520     {
1521         pAudioFrame->pafPrivateMetadata[i].offset = 0;
1522         pAudioFrame->pafPrivateMetadata[i].size = 0;
1523     }
1524     
1525     return 0;
1528 // Reset AF samsiz, invoked during DECODE
1529 Int resetAfSamsiz(
1530     Int z
1533     PAF_AudioFrame *pAudioFrame;
1534     Int ch;
1535     
1536     // Get audio frame
1537     pAudioFrame = &gpDecAudioFrame[z];
1538     if (pAudioFrame == NULL)
1539     {
1540         SW_BREAKPOINT;
1541     }
1542     
1543     // Clear samsiz for all channels - MID 208.
1544     for (ch=0; ch < PAF_MAXNUMCHAN_AF; ch++) 
1545     {
1546         pAudioFrame->data.samsiz[ch] = 0;
1547     }
1549     return 0;