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 / audioStreamOutInit.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  *  ======== audioStreamOutInit.c ========
38  */
40 #include <xdc/std.h>
41 #include <xdc/runtime/Log.h>
42 #include <xdc/runtime/Error.h>
43 #include <xdc/runtime/Memory.h>
45 #include <acp_mds.h>
46 #include "pafsio_ialg.h"
47 #include "stdasp.h"
49 #include "common.h"
50 #include "audioStreamProc_common.h"
51 #include "audioStreamOutProc.h"
53 // -----------------------------------------------------------------------------
54 // Debugging Trace Control, local to this file.
55 // 
56 #include "logp.h"
58 // Allow a developer to selectively enable tracing.
59 #define CURRENT_TRACE_MASK      0x07
61 #define TRACE_MASK_TERSE        0x01   // only flag errors and show init
62 #define TRACE_MASK_GENERAL      0x02   // half dozen lines per frame
63 #define TRACE_MASK_VERBOSE      0x04   // trace full operation
65 #if !(CURRENT_TRACE_MASK & TRACE_MASK_TERSE)
66     #undef  TRACE_TERSE0
67     #undef  TRACE_TERSE1
68     #undef  TRACE_TERSE2
69     #undef  TRACE_TERSE3
70     #undef  TRACE_TERSE4
71     #define TRACE_TERSE0(a)
72     #define TRACE_TERSE1(a,b)
73     #define TRACE_TERSE2(a,b,c)
74     #define TRACE_TERSE3(a,b,c,d)
75     #define TRACE_TERSE4(a,b,c,d,e)
76 #endif
77     
78 #if !(CURRENT_TRACE_MASK & TRACE_MASK_GENERAL)
79     #undef  TRACE_GEN0
80     #undef  TRACE_GEN1
81     #undef  TRACE_GEN2
82     #undef  TRACE_GEN3
83     #undef  TRACE_GEN4
84     #define TRACE_GEN0(a)
85     #define TRACE_GEN1(a,b)
86     #define TRACE_GEN2(a,b,c)
87     #define TRACE_GEN3(a,b,c,d)
88     #define TRACE_GEN4(a,b,c,d,e)
89 #endif
91 #if !(CURRENT_TRACE_MASK & TRACE_MASK_VERBOSE)
92     #undef  TRACE_VERBOSE0
93     #undef  TRACE_VERBOSE1
94     #undef  TRACE_VERBOSE2
95     #undef  TRACE_VERBOSE3
96     #undef  TRACE_VERBOSE4
97     #define TRACE_VERBOSE0(a)
98     #define TRACE_VERBOSE1(a,b)
99     #define TRACE_VERBOSE2(a,b,c)
100     #define TRACE_VERBOSE3(a,b,c,d)
101     #define TRACE_VERBOSE4(a,b,c,d,e)
102 #endif
104 // -----------------------------------------------------------------------------
105 //
106 // Audio Stream Output Task definitions
107 //
109 //
110 // Audio Stream Processing Definitions
111 //
112 #define aspLinkInit pQ->i_aspLinkInit
114 //
115 // Encoder Definitions
116 //
117 #define encLinkInit pQ->i_encLinkInit
119 //
120 // Output Definitions
121 //
122 #define outLinkInit pP->i_outLinkInit
124 // -----------------------------------------------------------------------------
126 LINNO_DECL(TaskAsop); // Line number macros
127 ERRNO_DECL(TaskAsop); // Error number macros
129 #if 0
130 // Create ASOT event
131 static Int asotCreateEvent(void);
132 #endif
134 // Create IO Buff & Phy framework components
135 static Int PAF_ASOT_ioCompCreate(
136     PAF_AST_IoOut *pIoOut, 
137     Int numOut, 
138     IHeap_Handle iHeapHandle
139 );
141 // Audio Stream Output Processing initialization function
142 Void taskAsopFxnInit(
143     const PAF_ASOT_Params *pP,
144     const PAF_ASOT_Patchs *pQ
147     PAF_ASOT_Config *pAsotCfg;      /* ASOT configuration pointer */
148     PAF_AST_Config *pAstCfg;        /* Common (shared) configuration pointer */
149     PAF_AST_IoOut *pOut;
150     Int as;                         /* Audio Stream Number (1, 2, etc.) */
151     Int z;                          /* input/encode/stream/decode/output counter */
152     Int i;                          /* phase */
153     Int zMS;
154     Int status;
156     Log_info0("Enter taskAsopFxnInit()");
158     //
159     // Audio Stream Output Task Parameters & Patch (*pP, *pQ)
160     //
161     if (!pP)
162     {
163         TRACE_TERSE0("TaskAsop: No Parameters defined. Exiting.");
164         LINNO_RPRT(TaskAsop, -1);
165         return;
166     }
168     if (!pQ)
169     {
170         TRACE_TERSE0("TaskAsop: No Patchs defined. Exiting.");
171         LINNO_RPRT(TaskAsop, -1);
172         return;
173     }
175     //
176     // Audio Stream Output Task Configuration (*pAsotCfg):
177     //
178     pAsotCfg = &gPAF_ASOT_config;       // initialize pointer to task configuration
179     pAsotCfg->taskHandle = Task_self(); // set task handle
180     pAstCfg = pAsotCfg->pAstCfg;        // get pointer to AST common (shared) configuration
182     // Create ASOT event
183     status = astCreateEvent(&gAsotEvtHandle);
184     if (status < 0)
185     {
186         TRACE_TERSE0("TaskAsop: unable to initialize event. Exiting.");
187         return;
188     }
189     
190     /* Obtain Audio Stream Number (1, 2, etc.) */
191     as = pAstCfg->as;
192     TRACE_TERSE1("TaskAsop: Started with AS%d.", as);
194     //
195     // Initialize message log trace and line number reporting
196     //
197     for (z=STREAM1; z < STREAMN; z++)
198     {
199         TRACE_TERSE1("TaskAsop: AS%d: initiated", as+z);
200     }
201     LINNO_RPRT(TaskAsop, -1);
203     //
204     // Determine stream index
205     //
206     zMS = pAstCfg->masterStr;
208     // Initialize as per parametrized phases:
209     //
210     //   In standard form these are:
211     //      - Malloc: Memory Allocation
212     //      - Config: Configuration Initialization
213     //      - AcpAlg: ACP Algorithm Initialization and Local Attachment
214     //      - Common: Common Memory Initialization
215     //      - AlgKey: Dec/Enc chain to Array Initialization
216     //      - Device: I/O Device Initialization
217     //      - Unused: (available)
218     //      - Unused: (available)
219     //
220     LINNO_RPRT(TaskAsop, -2);
221     for (i=0; i < lengthof(pP->fxns->initPhase); i++)
222     {
223         Int linno;
224         if (pP->fxns->initPhase[i])
225         {
226             linno = pP->fxns->initPhase[i](pP, pQ, pAsotCfg);
227             if (linno)
228             {
229                 LINNO_RPRT(TaskAsop, linno);
230                 return;
231             }
232         }
233         else
234         {
235             TRACE_TERSE1("TaskAsop: AS%d: initialization phase - null", as+zMS);
236         }
237         TRACE_TERSE2("TaskAsop: AS%d: initialization phase - %d completed", as+zMS, i);
238         LINNO_RPRT(TaskAsop, -i-3);
239     }
241     //
242     // End of Initialization -- display memory usage report.
243     //
244     if (pP->fxns->memStatusPrint)
245     {
246         pP->fxns->memStatusPrint("ASOT MEMSTAT REPORT",
247             HEAP_INTERNAL, HEAP_INTERNAL1, HEAP_EXTERNAL,
248             HEAP_INTERNAL1_SHM, HEAP_EXTERNAL_SHM, HEAP_EXTERNAL_NONCACHED_SHM);
249     }
251     pOut = &pAsotCfg->pIoOut[zMS];
252     pOut->hMcaspChan = NULL;
253 } /* taskAsopFxnInit */
255 #if 0
256 // Create ASOT event object
257 static Int asotCreateEvent(void)
259     Error_Block eb;
260     
261     Error_init(&eb);
262     
263     // Default instance configuration params
264     asotEvt = Event_create(NULL, &eb);
265     if (asotEvt == NULL)
266     {
267         return -1; // error code
268     }
269     
270     return 0;
271 } /* asotCreateEvent */
272 #endif
274 // Create IO Buff & Phy framework components
275 static Int PAF_ASOT_ioCompCreate(
276     PAF_AST_IoOut *pIoOut, 
277     Int numOut, 
278     IHeap_Handle iHeapHandle)
280     int i, j, num_alloc;
281     lib_mem_rec_t   *mem_rec;
282     ioBuffHandle_t  ioBufHandle;
283     ioPhyHandle_t   ioPhyHandle;
284     Error_Block     eb;
286     for(i=0; i<numOut; i++)
287     {
288         // Create an I/O BUFF instance
289         // Obtain number of memory blocks required by I/O BUFF
290         num_alloc = ioBuffNumAlloc();
292         // Obtain requirements of each memory block
293         mem_rec   = (lib_mem_rec_t *)malloc(sizeof(lib_mem_rec_t)*num_alloc);
294         if(ioBuffAlloc(mem_rec) != IOBUFF_NOERR) {
295             return __LINE__;
296         }
298         /* Allocate memory and create I/O BUFF instance */
299         for(j=0; j<num_alloc; j++) {
300             mem_rec[j].base = Memory_calloc(iHeapHandle, mem_rec[j].size,
301                                             (1<<mem_rec[j].alignment), &eb);
302         }
304         if(ioBuffCreate(&ioBufHandle, mem_rec) != IOBUFF_NOERR) {
305             return __LINE__;
306         }
308         pIoOut[i].hIoBuff = ioBufHandle;
310         free(mem_rec);
312         // Create an I/O PHY instance
313         // Obtain number of memory blocks required by I/O PHY
314         num_alloc = ioPhyNumAlloc();
316         // Obtain requirements of each memory block
317         mem_rec   = (lib_mem_rec_t *)malloc(sizeof(lib_mem_rec_t)*num_alloc);
318         if(ioPhyAlloc(mem_rec) != IOBUFF_NOERR) {
319             return __LINE__;
320         }
322         /* Allocate memory and create I/O PHY instance */
323         for(j=0; j<num_alloc; j++) {
324             mem_rec[j].base = Memory_calloc(iHeapHandle, mem_rec[j].size,
325                                             (1<<mem_rec[j].alignment), &eb);
326         }
328         if(ioPhyCreate(&ioPhyHandle, mem_rec) != IOBUFF_NOERR) {
329             return __LINE__;
330         }
332         pIoOut[i].hIoPhy = ioPhyHandle;
333                 
334 #if 1
335 #ifdef _TMS320C6X
336     GateMP_Params gateParams;
337     GateMP_Handle gateHandle;
338     
339     GateMP_Params_init(&gateParams);
340     gateParams.localProtect = GateMP_LocalProtect_TASKLET;//GateMP_LocalProtect_THREAD;
341     gateParams.remoteProtect = GateMP_RemoteProtect_SYSTEM;
342     gateParams.name = ASP_STREAM_OUT_GATE_NAME;
343     gateParams.regionId = ASP_STREAM_OUT_GATE_REGION_ID;
344     gateHandle = GateMP_create(&gateParams);
345     if (gateHandle != NULL)
346     {
347         pIoOut[i].gateHandle = gateHandle;
348     }
349     else
350     {
351         pIoOut[i].gateHandle = NULL;
352         return ASP_STREAM_OUT_INV_GATE;
353     }
355 #elif defined(ARMCOMPILE)
356     GateMP_Handle gateHandle;
357     Int status;
358     
359     do {
360         status = GateMP_open(ASP_STREAM_OUT_GATE_NAME, &gateHandle);
361     } while (status == GateMP_E_NOTFOUND);
362     if (status == GateMP_S_SUCCESS)
363     {
364         pIoOut[i].gateHandle = gateHandle;
365     }
366     else
367     {
368         pIoOut[i].gateHandle = NULL;
369         return ASP_STREAM_OUT_INV_GATE;
370     }
372 #else
373     #error "Unsupported platform"
375 #endif  
376 #endif
377         free(mem_rec);
379     } // end of for loop
381     return 0;
382 } // PAF_ASOT_ioCompCreate
384 // -----------------------------------------------------------------------------
385 // AST Initialization Function - Memory Allocation
386 //
387 //   Name:      PAF_ASOT_initPhaseMalloc
388 //   Purpose:   Audio Stream Output Task Function for initialization of data pointers
389 //              by allocation of memory.
390 //   From:      audioStream1Task or equivalent
391 //   Uses:      See code.
392 //   States:    x
393 //   Return:    0 on success.
394 //              Source code line number on MEM_calloc failure.
395 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
396 //              * State information as per parent.
397 //              * Memory allocation errors.
398 //
400 Int PAF_ASOT_initPhaseMalloc(
401     const PAF_ASOT_Params *pP, 
402     const PAF_ASOT_Patchs *pQ, 
403     PAF_ASOT_Config *pAsotCfg
406     PAF_AST_Config *pAstCfg;
407     Int as;                     /* Audio Stream Number (1, 2, etc.) */
408     Int zMS, errLineNum;
409     Error_Block    eb;
410     //Int i;
412     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
413     as = pAstCfg->as;
414     zMS = pAstCfg->masterStr;
416     TRACE_TERSE1("PAF_ASOT_initPhaseMalloc: AS%d: initialization phase - memory allocation", as+zMS);
418     // Initialize error block
419     Error_init(&eb); 
421     /* Stream memory */
422     if (!(pAstCfg->xStr = Memory_calloc((IHeap_Handle)HEAP_INTERNAL, STREAMN * sizeof (*pAstCfg->xStr), 4, &eb)))
423     {
424         TRACE_TERSE1("PAF_ASOT_initPhaseMalloc: AS%d: Memory_calloc failed", as+zMS);
425         SW_BREAKPOINT;
426         return __LINE__;
427     }
428     TRACE_TERSE3("PAF_ASOT_initPhaseMalloc. (pAstCfg->xStr) %d bytes from space %d at 0x%x.",
429             STREAMN * sizeof (*pAstCfg->xStr),
430             HEAP_ID_INTERNAL, (IArg)pAstCfg->xStr);
432     {
433         Int z;                          /* stream counter */
435         PAF_AudioFrame *fBuf;
437         if (!(fBuf = (PAF_AudioFrame *)Memory_calloc((IHeap_Handle)HEAP_INTERNAL, STREAMS * sizeof (*fBuf), 4, &eb)))
438         {
439             TRACE_TERSE1("PAF_ASOT_initPhaseMalloc: AS%d: Memory_calloc failed", as+zMS);
440             SW_BREAKPOINT;
441             return __LINE__;
442         }
443         TRACE_TERSE3("PAF_ASOT_initPhaseMalloc. (fBuf) %d bytes from space %d at 0x%x.",
444                 STREAMS * sizeof (*fBuf),
445                 HEAP_ID_INTERNAL, (IArg)fBuf);
447         for (z=STREAM1; z < STREAMN; z++)
448         {
449             pAstCfg->xStr[z].pAudioFrame = &fBuf[z-STREAM1];
450             TRACE_TERSE2("pAstCfg->xStr[%d].pAudioFrame = 0x%x", z, (IArg)pAstCfg->xStr[z].pAudioFrame);
451         }
452     }
454     /* Encode memory */
455     if (!(pAstCfg->xEnc = Memory_calloc((IHeap_Handle)HEAP_INTERNAL, ENCODEN * sizeof (*pAstCfg->xEnc), 4, &eb)))
456     {
457         TRACE_TERSE1("PAF_ASOT_initPhaseMalloc: AS%d: Memory_calloc failed", as+zMS);
458         SW_BREAKPOINT;
459         return __LINE__;
460     }
461     TRACE_TERSE3("PAF_ASOT_initPhaseMalloc. (pAstCfg->xEnc) %d bytes from space %d at 0x%x.",
462             ENCODEN * sizeof (*pAstCfg->xEnc),
463             HEAP_ID_INTERNAL, (IArg)pAstCfg->xEnc);
465     /* Output memory */
466     if (!(pAstCfg->xOut = Memory_calloc((IHeap_Handle)HEAP_INTERNAL, OUTPUTN * sizeof (*pAstCfg->xOut), 4, &eb)))
467     {
468         TRACE_TERSE1("PAF_ASOT_initPhaseMalloc: AS%d: Memory_calloc failed", as+zMS);
469         SW_BREAKPOINT;
470         return __LINE__;
471     }
472     TRACE_TERSE3("PAF_ASOT_initPhaseMalloc. (pAstCfg->xOut) %d bytes from space %d at 0x%x.",
473             OUTPUTN * sizeof (*pAstCfg->xOut),
474             HEAP_ID_INTERNAL, (IArg)pAstCfg->xOut);
476     /* Output I/O data structure memory */
477     if (!(pAsotCfg->pIoOut = Memory_calloc((IHeap_Handle)HEAP_INTERNAL, OUTPUTN * sizeof (*pAsotCfg->pIoOut), 4, &eb)))
478     {
479         TRACE_TERSE1("PAF_ASOT_initPhaseMalloc: AS%d: Memory_calloc failed", as+zMS);
480         SW_BREAKPOINT;
481         return __LINE__;
482     }
483     TRACE_TERSE3("PAF_ASOT_initPhaseMalloc. (pAsotCfg->pIoOut) %d bytes from space %d at 0x%x.",
484                  OUTPUTN * sizeof (*pAsotCfg->pIoOut),
485                  HEAP_ID_INTERNAL, (IArg)pAsotCfg->pIoOut);
487     /* I/O components memory for output */
488     errLineNum = PAF_ASOT_ioCompCreate(pAsotCfg->pIoOut, OUTPUTN, (IHeap_Handle)HEAP_INTERNAL);
489     if(errLineNum)
490     {
491         SW_BREAKPOINT;
492         return errLineNum;
493     }
494     TRACE_TERSE1("PAF_ASOT_initPhaseMalloc: AS%d: initialization phase - memory allocation complete.", as+zMS);
495     return 0;
496 } //PAF_ASOT_initPhaseMalloc
498 // -----------------------------------------------------------------------------
499 // ASOT Initialization Function - Memory Initialization from Configuration
500 //
501 //   Name:      PAF_ASOT_initPhaseConfig
502 //   Purpose:   Audio Stream Output Task Function for initialization of data values
503 //              from parameters.
504 //   From:      audioStream1Task or equivalent
505 //   Uses:      See code.
506 //   States:    x
507 //   Return:    0 on success.
508 //              Other as per initFrame0 and initFrame1.
509 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
510 //              * State information as per parent.
511 //
512 Int PAF_ASOT_initPhaseConfig(
513     const PAF_ASOT_Params *pP, 
514     const PAF_ASOT_Patchs *pQ, 
515     PAF_ASOT_Config *pAsotCfg
518     PAF_AST_Config *pAstCfg;
519     Int as;                     /* Audio Stream Number (1, 2, etc.) */
520     Int z;                      /* input/encode/stream/decode/output counter */
521     Int zMS;
523     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
524     as = pAstCfg->as;
525     zMS = pAstCfg->masterStr;
527     TRACE_TERSE1("PAF_ASOT_initPhaseConfig: AS%d: initialization phase - configuration", as+zMS);
529     //
530     // Unspecified elements have been initialized to zero during alloc
531     //
533     for (z=STREAM1; z < STREAMN; z++) 
534     {
535         Int linno;
536         if (linno = pP->fxns->initFrame0(pP, pQ, pAsotCfg, z))
537         {
538             return linno;           
539         }
540         if (linno = pP->fxns->initFrame1(pP, pQ, pAsotCfg, z, -1))
541         {
542             return linno;
543         }
544     }
546     for (z=ENCODE1; z < ENCODEN; z++) 
547     {
548         Int zO = pP->outputsFromEncodes[z];
549         Int zS = pP->streamsFromEncodes[z];
550         pAstCfg->xEnc[z].encodeControl.size = sizeof(pAstCfg->xEnc[z].encodeControl);
551         pAstCfg->xEnc[z].encodeControl.pAudioFrame = pAstCfg->xStr[zS].pAudioFrame;
552         pAstCfg->xEnc[z].encodeControl.pVolumeStatus = &pAstCfg->xEnc[z].volumeStatus;
553         pAstCfg->xEnc[z].encodeControl.pOutBufConfig = &pAstCfg->xOut[zO].outBufConfig;
554         pAstCfg->xEnc[z].encodeStatus = *pP->z_pEncodeStatus[z];
555         pAstCfg->xEnc[z].encodeControl.encActive = pAstCfg->xEnc[z].encodeStatus.select;
556         pAstCfg->xEnc[z].volumeStatus = *pP->pVolumeStatus;
557         pAstCfg->xEnc[z].encodeInStruct.pAudioFrame = pAstCfg->xStr[zS].pAudioFrame;
558     }
560     for (z=OUTPUT1; z < OUTPUTN; z++)
561     {
562         pAstCfg->xOut[z].outBufStatus = *pP->pOutBufStatus;
563     }
565     TRACE_TERSE1("PAF_ASOT_initPhaseConfig: AS%d: initialization phase - configuration complete.", as+zMS);
566     return 0;
567 } //PAF_ASOT_initPhaseConfig
569 // -----------------------------------------------------------------------------
570 // ASOT Initialization Function - ACP Algorithm Instantiation
571 //
572 //   Name:      PAF_ASOT_initPhaseAcpAlg
573 //   Purpose:   Audio Stream Input Task Function for initialization of ACP by
574 //              instantiation of the algorithm.
575 //   From:      audioStream1Task or equivalent
576 //   Uses:      See code.
577 //   States:    x
578 //   Return:    0 on success.
579 //              Source code line number on ACP Algorithm creation failure.
580 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
581 //              * State information as per parent.
582 //              * Memory allocation errors.
583 //
584 Int PAF_ASOT_initPhaseAcpAlg(
585     const PAF_ASOT_Params *pP, 
586     const PAF_ASOT_Patchs *pQ, 
587     PAF_ASOT_Config *pAsotCfg
590     PAF_AST_Config *pAstCfg;
591     Int as;                     /* Audio Stream Number (1, 2, etc.) */
592     Int z;                      /* input/encode/stream/decode/output counter */
593     Int betaPrimeOffset;
594     ACP_Handle acp;
595     Int zMS;
596     Int zS, zX;
598     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
599     as = pAstCfg->as;
600     zMS = pAstCfg->masterStr;
602     TRACE_TERSE1("PAF_ASOT_initPhaseAcpAlg: AS%d: initialization phase - ACP Algorithm", as+zMS);
604     ACP_MDS_init();
606     if (!(acp = (ACP_Handle )ACP_MDS_create(NULL))) 
607     {
608         TRACE_TERSE1("PAF_ASOT_initPhaseAcpAlg: AS%d: ACP algorithm instance creation  failed", as+zMS);
609         return __LINE__;
610     }
611     pAsotCfg->acp = acp;
613     ((ALG_Handle)acp)->fxns->algControl((ALG_Handle) acp,
614         ACP_GETBETAPRIMEOFFSET, (IALG_Status *)&betaPrimeOffset);
616     for (z=ENCODE1; z < ENCODEN; z++) 
617     {
618         zS = pP->streamsFromEncodes[z];
619         acp->fxns->attach(acp, ACP_SERIES_STD,
620             STD_BETA_ENCODE + betaPrimeOffset * (as-1+zS),
621             (IALG_Status *)&pAstCfg->xEnc[z].encodeStatus);
622         acp->fxns->attach(acp, ACP_SERIES_STD,
623             STD_BETA_VOLUME + betaPrimeOffset * (as-1+zS),
624             (IALG_Status *)&pAstCfg->xEnc[z].volumeStatus);
625         /* Ignore errors, not reported. */
626     }
628     for (z=OUTPUT1; z < OUTPUTN; z++) 
629     {
630         zS = z;
631         for (zX = ENCODE1; zX < ENCODEN; zX++) 
632         {
633             if (pP->outputsFromEncodes[zX] == z) 
634             {
635                 zS = pP->streamsFromEncodes[zX];
636                 break;
637             }
638         }
639         acp->fxns->attach(acp, ACP_SERIES_STD,
640             STD_BETA_OB + betaPrimeOffset * (as-1+zS),
641             (IALG_Status *)&pAstCfg->xOut[z].outBufStatus);
642         /* Ignore errors, not reported. */
643     }
645     TRACE_TERSE1("PAF_ASOT_initPhaseAcpAlg: AS%d: initialization phase - ACP Algorithm complete.", as+zMS);
647     return 0;
648 } //PAF_ASOT_initPhaseAcpAlg
650 // -----------------------------------------------------------------------------
651 // ASOT Initialization Function - Common Memory
652 //
653 //   Name:      PAF_ASOT_initPhaseCommon
654 //   Purpose:   Audio Stream Output Task Function for allocation of common memory.
655 //   From:      audioStream1Task or equivalent
656 //   Uses:      See code.
657 //   States:    x
658 //   Return:    0 on success.
659 //              Source code line number on PAF_ALG_alloc failure.
660 //              Source code line number on PAF_ALG_mallocMemory failure.
661 //              Source code line number on Decode Chain initialization failure.
662 //              Source code line number on ASP Chain initialization failure.
663 //              Source code line number on Encode Chain initialization failure.
664 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
665 //              * State information as per parent.
666 //              * Memory allocation errors.
667 //
668 Int PAF_ASOT_initPhaseCommon(
669     const PAF_ASOT_Params *pP, 
670     const PAF_ASOT_Patchs *pQ, 
671     PAF_ASOT_Config *pAsotCfg
674     PAF_AST_Config *pAstCfg;
675     Int as;                     /* Audio Stream Number (1, 2, etc.) */
676     Int z;                      /* stream counter */
677     Int g;                      /* gear */
678     ACP_Handle acp;
679     PAF_IALG_Config pafAlgConfig;
680     IALG_MemRec common[3][PAF_IALG_COMMON_MEMN+1];
681    
682     acp = pAsotCfg->acp;
683     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
684     as = pAstCfg->as;
686     TRACE_TERSE0("PAF_ASOT_initPhaseCommon: initialization phase - Common Memory");
688     //
689     // Determine memory needs and instantiate algorithms across audio streams
690     //
691     TRACE_TERSE0("PAF_ASOT_initPhaseCommon: calling PAF_ALG_setup.");
692     PAF_ALG_setup(&pafAlgConfig, 
693         HEAP_ID_INTERNAL,                 HEAP_INTERNAL, 
694         HEAP_ID_INTERNAL1,                HEAP_INTERNAL1, 
695         HEAP_ID_EXTERNAL,                 HEAP_EXTERNAL, 
696         HEAP_ID_INTERNAL1_SHM,            HEAP_INTERNAL1_SHM, 
697         HEAP_ID_EXTERNAL_SHM,             HEAP_EXTERNAL_SHM, 
698         HEAP_ID_EXTERNAL_NONCACHED_SHM,   HEAP_EXTERNAL_NONCACHED_SHM,
699         HEAP_CLEAR);
701     if (pP->fxns->headerPrint)
702     {
703         pP->fxns->headerPrint();        
704     }
706     for (z = STREAM1; z < STREAMN; z++) 
707     {
708         //Int zD, zE, zX;
709         Int zE, zX;
711         TRACE_TERSE1("PAF_ASOT_initPhaseCommon: AS%d: initialization phase - Common Memory", as+z);
713         //
714         // Determine common memory needs for:
715         //  (1) ASP Algorithms
716         //  (2) Encode Algorithms
717         //  (3) Logical Output drivers
718         //
719         PAF_ALG_init(common[z], lengthof(common[z]), COMMONSPACE);
721         zE = -1;
722         for (zX = ENCODE1; zX < ENCODEN; zX++) 
723         {
724             if (pP->streamsFromEncodes[zX] == z) 
725             {
726                 zE = zX;
727                 break;
728             }
729         }
731         TRACE_TERSE1("Calling PAF_ALG_ALLOC for stream common[%d].", z);
732         if (PAF_ALG_ALLOC(aspLinkInit[z-STREAM1][0], common[z])) 
733         {
734             TRACE_TERSE1("PAF_ASOT_initPhaseCommon: AS%d: PAF_ALG_alloc failed", as+z);
735             TRACE_TERSE2("Failed to alloc %d bytes from space %d ", common[z]->size, common[z]->space);
736             SW_BREAKPOINT;
737             return __LINE__;
738         }
739         TRACE_TERSE3("alloced %d bytes from space %d at 0x%x", common[z]->size, common[z]->space, (IArg)common[z]->base);
740         if (pP->fxns->allocPrint)
741         {
742             pP->fxns->allocPrint((const PAF_ALG_AllocInit *)(aspLinkInit[z-STREAM1][0]), sizeof (*(aspLinkInit[z-STREAM1][0])), &pafAlgConfig);
743         }
745         if (zE >= 0) 
746         {
747             TRACE_TERSE1("PAF_ASOT_initPhaseCommon: calling PAF_ALG_ALLOC/ for encoder common[%d].", z);
748             if (PAF_ALG_ALLOC(encLinkInit[zE-ENCODE1], common[z])) 
749             {
750                 TRACE_TERSE1("PAF_ASOT_initPhaseCommon: AS%d: PAF_ALG_alloc failed", as+z);
751                 SW_BREAKPOINT;
752                 return __LINE__;
753             }
754             TRACE_TERSE3("alloced %d bytes from space %d at 0x%x", common[z]->size, common[z]->space, (IArg)common[z]->base);
755             if (pP->fxns->allocPrint)
756             {
757                 pP->fxns->allocPrint((const PAF_ALG_AllocInit *)(encLinkInit[z-ENCODE1]), sizeof (*(encLinkInit[z-ENCODE1])), &pafAlgConfig);
758             }
759         }
761         //
762         // Determine common memory needs of Logical IO drivers
763         //
765         if (OUTPUT1 <= z && z < OUTPUTN)
766         {
767             TRACE_TERSE1("PAF_ASOT_initPhaseCommon: calling PAF_ALG_ALLOC outLinkInit common[%d].", z);
768             if (PAF_ALG_ALLOC(outLinkInit[z-OUTPUT1], common[z]))
769             {
770                 TRACE_TERSE1("PAF_ASOT_initPhaseMalloc: AS%d: PAF_ALG_alloc failed", as+z);
771                 TRACE_TERSE2("Failed to alloc %d bytes from space %d", common[z]->size, (IArg)common[z]->space);
772                 SW_BREAKPOINT;
773                 return __LINE__;
774             }
775             TRACE_TERSE3("alloced %d bytes from space %d at 0x%x", common[z]->size, common[z]->space, (IArg)common[z]->base);
776             if (pP->fxns->allocPrint)
777             {
778                 pP->fxns->allocPrint((const PAF_ALG_AllocInit *)(outLinkInit[z-INPUT1]), sizeof (*(outLinkInit[z-INPUT1])), &pafAlgConfig);
779             }
780         }
781     }
782     {
783         // Changes made to share scratch between zones
784         // Assume maximum 3 zones and scratch common memory is at offset 0;
785         int max=0;
786         for (z=STREAM1; z<STREAMN; z++)
787         {
788             if (max < common[z][0].size)
789             {
790                 max = common[z][0].size;
791             }
792         }
793         common[STREAM1][0].size=max;
794         for (z=STREAM1+1; z<STREAMN; z++)
795         {
796             common[z][0].size = 0;            
797         }
798     }
799         
800     //
801     // Allocate common memory for:
802     //  (1) ASP Algorithms
803     //  (2) Encode Algorithms
804     //  (3) Logical Output drivers
805     //
806     for (z = STREAM1; z < STREAMN; z++) 
807     {
808         //Int zD, zE, zX;
809         Int zE, zX;
811         TRACE_TERSE0("PAF_ASOT_initPhaseCommon: calling PAF_ALG_mallocMemory for common space.");
812         if (PAF_ALG_mallocMemory(common[z], &pafAlgConfig)) 
813         {
814             TRACE_TERSE1("AS%d: PAF_ALG_mallocMemory failed", as+z);
815             TRACE_TERSE3("AS%d: z: %d.  Size 0x%x", as+z, z, common[z][0].size);
816             SW_BREAKPOINT;
817             return __LINE__;
818         }
819         TRACE_TERSE3("alloced %d bytes from space %d at 0x%x", common[z]->size, common[z]->space, (IArg)common[z]->base);
820         // share zone0 scratch with all zones 
821         common[z][0].base = common[0][0].base;
822         if (pP->fxns->commonPrint)
823         {
824             pP->fxns->commonPrint(common[z], &pafAlgConfig);
825         }
827         zE = -1;
828         for (zX = ENCODE1; zX < ENCODEN; zX++) 
829         {
830             if (pP->streamsFromEncodes[zX] == z) 
831             {
832                 zE = zX;
833                 break;
834             }
835         }
837         pAstCfg->xStr[z].aspChain[0] = NULL;
838         for (g=0; g < GEARS; g++) 
839         {
840             PAF_ASP_Chain *chain;
841             TRACE_TERSE0("PAF_ASOT_initPhaseCommon: calling PAF_ASP_chainInit for ASPs.");
842             chain = PAF_ASP_chainInit(&pAstCfg->xStr[z].aspChainData[g], pP->pChainFxns,
843                 HEAP_INTERNAL, as+z, acp, &trace,
844                 aspLinkInit[z-STREAM1][g], pAstCfg->xStr[z].aspChain[0], common[z], &pafAlgConfig);
845             if (!chain) 
846             {
847                 TRACE_TERSE2("AS%d: ASP chain %d initialization failed", as+z, g);
848                 return __LINE__;
849             }
850             else
851             {
852                 pAstCfg->xStr[z].aspChain[g] = chain;
853             }
854         }
856         if (zE >= 0) 
857         {
858             PAF_ASP_Chain *chain;
859             TRACE_TERSE0("PAF_ASOT_initPhaseCommon: calling PAF_ASP_chainInit for encode.");
860             chain = PAF_ASP_chainInit(&pAstCfg->xEnc[zE].encChainData, pP->pChainFxns,
861                 HEAP_INTERNAL, as+z, acp, &trace,
862                 encLinkInit[zE-ENCODE1], NULL, common[z], &pafAlgConfig);
863             if (!chain) 
864             {
865                 TRACE_TERSE1("AS%d: Encode chain initialization failed", as+z);
866                 return __LINE__;
867             }
868         }
870         //
871         // Allocate non-common memories for Logical IO drivers
872         //    Since these structures are used at run-time we allocate from external memory
873         if (OUTPUT1 <= z && z < OUTPUTN) 
874         {
875             PAF_ASP_Chain *chain;
876             TRACE_TERSE2("PAF_ASOT_initPhaseMalloc: AS%d: non-common output chain init for %d",
877                            as+z, z);
878             chain = PAF_ASP_chainInit (&pAstCfg->xOut[z].outChainData, pP->pChainFxns,
879                         HEAP_EXTERNAL, as+z, acp, &trace,
880                         outLinkInit[z-OUTPUT1], NULL, common[z], &pafAlgConfig);
881             if (!chain) 
882             {
883                 TRACE_TERSE1("AS%d: Output chain initialization failed", as+z);
884                 return __LINE__;
885             }
886         }
887     }
888     TRACE_TERSE1("AS%d: PAF_ASOT_initPhaseCommon: Returning complete.", as+z);
890     return 0;
891 } //PAF_ASOT_initPhaseCommon
893 // -----------------------------------------------------------------------------
894 // ASOT Initialization Function - Algorithm Keys
895 //
896 //   Name:      PAF_ASOT_initPhaseAlgKey
897 //   Purpose:   Audio Stream Output Task Function for initialization of data values
898 //              from parameters for Algorithm Keys.
899 //   From:      audioStream1Task or equivalent
900 //   Uses:      See code.
901 //   States:    x
902 //   Return:    0.
903 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
904 //              * State information as per parent.
905 //
906 // .............................................................................
907 Int PAF_ASOT_initPhaseAlgKey(
908     const PAF_ASOT_Params *pP, 
909     const PAF_ASOT_Patchs *pQ, 
910     PAF_ASOT_Config *pAsotCfg
913     PAF_AST_Config *pAstCfg;
914     Int as;                     /* Audio Stream Number (1, 2, etc.) */
915     Int z;                      /* decode/encode counter */
916     Int s;                      /* key number */
917     PAF_ASP_Link *that;
919     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
920     as = pAstCfg->as;
921     (void)as; // clear compiler warning in case not used with tracing disabled
923     TRACE_VERBOSE1("PAF_ASOT_initPhaseAlgKey: AS%d: initialization phase - Algorithm Keys", as);
925     for (z=ENCODE1; z < ENCODEN; z++) 
926     {
927         for (s=0; s < pP->pEncAlgKey->length; s++) 
928         {
929             if ((pP->pEncAlgKey->code[s].full != 0) && 
930                 (that = PAF_ASP_chainFind(&pAstCfg->xEnc[z].encChainData, pP->pEncAlgKey->code[s])))
931             {
932                 pAstCfg->xEnc[z].encAlg[s] = (ALG_Handle )that->alg;
933             }
934             /* Cast in interface, for now --Kurt */
935             else
936             {
937                 pAstCfg->xEnc[z].encAlg[s] = NULL;                
938             }
939         }
940     }
942     return 0;
943 } //PAF_ASOT_initPhaseAlgKey
945 // -----------------------------------------------------------------------------
946 // ASOT Initialization Function - I/O Devices
947 //
948 //   Name:      PAF_ASOT_initPhaseDevice
949 //   Purpose:   Audio Stream Output Task Function for initialization of I/O Devices.
950 //   From:      audioStream1Task or equivalent
951 //   Uses:      See code.
952 //   States:    x
953 //   Return:    0 on success.
954 //              Source code line number on device allocation failure.
955 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
956 //              * State information as per parent.
957 //              * Memory allocation errors.
958 //
959 Int PAF_ASOT_initPhaseDevice(
960     const PAF_ASOT_Params *pP, 
961     const PAF_ASOT_Patchs *pQ, 
962     PAF_ASOT_Config *pAsotCfg
965     PAF_AST_Config *pAstCfg;
966     Int as;                     /* Audio Stream Number (1, 2, etc.) */
967     Int z;                      /* input/output counter */
968     PAF_SIO_IALG_Obj    *pObj;
969     PAF_SIO_IALG_Config *pAlgConfig;
970     PAF_IALG_Config pafAlgConfig;
972     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
973     as = pAstCfg->as;
974     (void)as; // clear compiler warning in case not used with tracing disabled
976     TRACE_TERSE1("PAF_ASOT_initPhaseDevice: AS%d: initialization phase - I/O Devices", as);
978     if(pP->fxns->bufMemPrint)
979     {
980         PAF_ALG_setup (&pafAlgConfig, 
981             HEAP_ID_INTERNAL,               HEAP_INTERNAL, 
982             HEAP_ID_INTERNAL1,              HEAP_INTERNAL1,
983             HEAP_ID_EXTERNAL,               HEAP_EXTERNAL,
984             HEAP_ID_INTERNAL1_SHM,          HEAP_INTERNAL1_SHM,
985             HEAP_ID_EXTERNAL_SHM,           HEAP_EXTERNAL_SHM,
986             HEAP_ID_EXTERNAL_NONCACHED_SHM, HEAP_EXTERNAL_NONCACHED_SHM,
987             HEAP_CLEAR);
988         TRACE_TERSE2("PAF_ASOT_initPhaseDevice: AS%d: calling PAF_ALG_setup with clear at %d.", as, HEAP_CLEAR);
989     }
990     
991     for (z=OUTPUT1; z < OUTPUTN; z++) 
992     {
993         PAF_OutBufConfig *pConfig = &pAstCfg->xOut[z].outBufConfig;
995         pObj = (PAF_SIO_IALG_Obj *)pAstCfg->xOut[z].outChainData.head->alg;
996         pAlgConfig = &pObj->config;
998         pAstCfg->xOut[z].hTxSio = NULL;
999         pConfig->base.pVoid     = pAlgConfig->pMemRec[0].base;
1000         pConfig->pntr.pVoid     = pAlgConfig->pMemRec[0].base;
1001         pConfig->head.pVoid     = pAlgConfig->pMemRec[0].base;
1002         pConfig->allocation     = pAlgConfig->pMemRec[0].size;
1003         pConfig->sizeofElement  = 3;
1004         pConfig->precision      = 24;
1005         if(pP->fxns->bufMemPrint)
1006         {
1007             pP->fxns->bufMemPrint(z,pAlgConfig->pMemRec[0].size,PAF_ALG_memSpaceToHeapId(&pafAlgConfig,pAlgConfig->pMemRec[0].space),1);
1008         }
1009     }
1010     TRACE_TERSE1("PAF_ASOT_initPhaseDevice: AS%d: initialization phase - I/O Devices complete.", as);
1012     return 0;
1013 } //PAF_ASOT_initPhaseDevice
1015 // -----------------------------------------------------------------------------
1016 // ASOT Initialization Function Helper - Initialization of Audio Frame
1017 //
1018 //   Name:      PAF_ASOT_initFrame0
1019 //   Purpose:   Audio Stream Output Task Function for initialization of the Audio
1020 //              Frame(s) by memory allocation and loading of data pointers
1021 //              and values.
1022 //   From:      AST Parameter Function -> decodeInfo
1023 //   Uses:      See code.
1024 //   States:    x
1025 //   Return:    0 on success.
1026 //              Source code line number on MEM_calloc failure.
1027 //              Source code line number on unsupported option.
1028 //   Trace:     Message Log "trace" in Debug Project Configuration reports:
1029 //              * Memory allocation errors.
1030 //              * Unsupported option errors.
1031 //
1033 // MID 314
1034 extern const char AFChanPtrMap[PAF_MAXNUMCHAN+1][PAF_MAXNUMCHAN];
1035 extern PAF_ChannelConfigurationMaskTable PAF_ASP_stdCCMT_patch;
1037 Int PAF_ASOT_initFrame0(
1038     const PAF_ASOT_Params *pP, 
1039     const PAF_ASOT_Patchs *pQ, 
1040     PAF_ASOT_Config *pAsotCfg, 
1041     Int z
1044     PAF_AST_Config *pAstCfg;
1045     Int as;                     /* Audio Stream Number (1, 2, etc.) */
1046     Int ch;
1047     //Int aLen;
1048     Int aLen_int=0,aLen_ext=0;
1049     Int aSize = sizeof(PAF_AudioData);
1050     Int aAlign = aSize < sizeof (int) ? sizeof (int) : aSize;
1051     Int maxFrameLength = pP->maxFramelength;
1052     Int zX;
1053     PAF_AudioData *aBuf_int=NULL;
1054     PAF_AudioData *aBuf_ext=NULL;
1055     XDAS_UInt8 *metadataBuf;
1056     char i;
1057     Error_Block    eb;
1059     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
1060     as = pAstCfg->as;
1062     // Initialize error block
1063     Error_init(&eb); 
1065     // Compute maximum framelength (needed for ARC support)
1066     maxFrameLength += PA_MODULO - maxFrameLength % PA_MODULO;
1067     //aLen = numchan[z] * maxFrameLength;
1068     for (i=0; i < numchan[z]; i++)
1069     {
1070         if (pP->pAudioFrameBufStatus->space[i] == IALG_SARAM)
1071         {
1072             aLen_int += maxFrameLength;
1073         }
1074         else
1075         {
1076             aLen_ext += maxFrameLength;
1077         }
1078     }
1080     //
1081     // Initialize audio frame elements directly
1082     //
1083     pAstCfg->xStr[z].pAudioFrame->fxns = pP->pAudioFrameFunctions;
1084     pAstCfg->xStr[z].pAudioFrame->data.nChannels = PAF_MAXNUMCHAN; ///
1085 ///    pAstCfg->xStr[z].pAudioFrame->data.nChannels = PAF_MAXNUMCHAN_AF;
1086     pAstCfg->xStr[z].pAudioFrame->data.nSamples = FRAMELENGTH;
1087     pAstCfg->xStr[z].pAudioFrame->data.sample = pAstCfg->xStr[z].audioFrameChannelPointers;
1088     pAstCfg->xStr[z].pAudioFrame->data.samsiz = pAstCfg->xStr[z].audioFrameChannelSizes;
1089     pAstCfg->xStr[z].pAudioFrame->pChannelConfigurationMaskTable = &PAF_ASP_stdCCMT;
1091     //
1092     // Allocate memory for and initialize pointers to audio data buffers
1093     //
1094     //   The NUMCHANMASK is used to identify the channels for which data
1095     //   buffers can be allocated. Using this mask and switch statement
1096     //   rather than some other construct allows efficient code generation,
1097     //   providing just the code necessary (with significant savings).
1098     //
1099     if (pP->fxns->bufMemPrint)
1100     {
1101         pP->fxns->bufMemPrint(z, aLen_int*aSize, HEAP_ID_FRMBUF, 2);
1102         pP->fxns->bufMemPrint(z, aLen_ext*aSize, HEAP_ID_EXTERNAL, 2);
1103     }
1105     TRACE_TERSE1("PAF_ASOT_initFrame0: AS%d: Memory_calloc for audio buffers", as+z);
1106     
1107     if (aLen_int*aSize!=0) // check size != 0, otherwise malloc throws fatal error
1108     {
1109         if (!(aBuf_int = (PAF_AudioData *)Memory_calloc((IHeap_Handle)HEAP_FRMBUF, (aLen_int+(maxFrameLength-FRAMELENGTH))*aSize, aAlign, &eb))) //Qin: Add start offset
1110         {
1111             TRACE_TERSE1("PAF_ASOT_initFrame0: AS%d: Memory_calloc failed", as+z);
1112             TRACE_TERSE2("  maxFrameLength: %d.  aLen_int*aSize: %d", maxFrameLength, (aLen_int+(maxFrameLength-FRAMELENGTH))*aSize);
1113             SW_BREAKPOINT;
1114             return __LINE__;
1115         }
1116     }
1117         
1118     if (aLen_ext*aSize!=0)
1119     {
1120         if (!(aBuf_ext = (PAF_AudioData *)Memory_calloc((IHeap_Handle)HEAP_EXTERNAL, (aLen_ext+(maxFrameLength-FRAMELENGTH))*aSize, aAlign, &eb)))//Qin: Add start offset
1121         {
1122             TRACE_TERSE1("PAF_ASOT_initFrame0: AS%d: Memory_calloc failed", as+z);
1123             TRACE_TERSE2("  maxFrameLength: %d.  aLen_ext*aSize: %d", maxFrameLength, (aLen_ext+(maxFrameLength-FRAMELENGTH))*aSize);
1124             SW_BREAKPOINT;
1125             return __LINE__;
1126         }
1127     }
1128     
1129     TRACE_TERSE3("  maxFrameLength: %d.  aLen_int*aSize: %d.  aBuf_int: 0x%x", maxFrameLength, (aLen_int+(maxFrameLength-FRAMELENGTH))*aSize, (IArg)aBuf_int);
1130     TRACE_TERSE3("  maxFrameLength: %d.  aLen_ext*aSize: %d.  aBuf_ext: 0x%x", maxFrameLength, (aLen_ext+(maxFrameLength-FRAMELENGTH))*aSize, (IArg)aBuf_ext);
1132     TRACE_TERSE1("PAF_ASOT_initFrame0: AS%d: Memory_calloc for metadata buffers", as+z);
1133     if (!(metadataBuf = (XDAS_UInt8 *)Memory_calloc((IHeap_Handle)HEAP_MDBUF, pP->pMetadataBufStatus->bufSize*pP->pMetadataBufStatus->NumBuf, pP->pMetadataBufStatus->alignment, &eb)))
1134     {
1135         TRACE_TERSE1("PAF_ASOT_initFrame0: AS%d: Memory_calloc failed", as+z);
1136         TRACE_TERSE1("  bufSize*NumBuf: %d", pP->pMetadataBufStatus->bufSize*pP->pMetadataBufStatus->NumBuf);
1137         SW_BREAKPOINT;
1138         return __LINE__;
1139     }
1141     {
1142         Int i;
1144 #pragma UNROLL(1)
1145         for (i=0; i < PAF_MAXNUMCHAN_AF; i++)
1146         {
1147             pAstCfg->xStr[z].audioFrameChannelPointers[i] = NULL;
1148         }
1149     }
1151     // MID 314
1152     if((numchan[z] > PAF_MAXNUMCHAN) || (numchan[z] < 1)) 
1153     {
1154         TRACE_TERSE1("PAF_ASOT_initFrame0: AS%d: unsupported option", as+z);
1155         return __LINE__;
1156     }
1157     else 
1158     {
1159         Int j = 0;
1160         Int k = 0;
1161         TRACE_TERSE1("PAF_ASOT_initFrame0: AFChanPtrMap[%d][i]", numchan[z]);
1162         for(i=0;i<numchan[z];i++)
1163         {
1164             char chan = AFChanPtrMap[numchan[z]][i];
1165             if(chan != -1)
1166             {
1167                 if(pP->pAudioFrameBufStatus->space[i] == IALG_SARAM)
1168                 {
1169                     pAstCfg->xStr[z].audioFrameChannelPointers[chan] = aBuf_int + maxFrameLength*(j+1) - FRAMELENGTH;
1170                     j++;
1171                 }
1172                 else
1173                 {        
1174                     pAstCfg->xStr[z].audioFrameChannelPointers[chan] = aBuf_ext + maxFrameLength*(k+1) - FRAMELENGTH;
1175                     k++;
1176                 }    
1177                 TRACE_TERSE3("PAF_ASOT_initFrame0: chan = %d = AFChanPtrMap[%d][%d].", chan, numchan[z], i);
1178                 TRACE_TERSE2("PAF_ASOT_initFrame0: audioFrameChannelPointers[%d]: 0x%x", chan, (IArg)pAstCfg->xStr[z].audioFrameChannelPointers[chan]);
1179             }
1180         }
1181     }
1183     for (ch=PAF_LEFT; ch < PAF_MAXNUMCHAN_AF; ch++) 
1184     {
1185         if (pAstCfg->xStr[z].audioFrameChannelPointers[ch])
1186         {
1187             pAstCfg->xStr[z].origAudioFrameChannelPointers[ch] = pAstCfg->xStr[z].audioFrameChannelPointers[ch];
1188         }
1189     }
1191     //
1192     // Initialize meta data elements
1193     //
1194     pAstCfg->xStr[z].pAudioFrame->pafBsMetadataUpdate = XDAS_FALSE;
1195     pAstCfg->xStr[z].pAudioFrame->numPrivateMetadata = 0;
1196     pAstCfg->xStr[z].pAudioFrame->bsMetadata_offset = 0;
1197     pAstCfg->xStr[z].pAudioFrame->bsMetadata_type = PAF_bsMetadata_channelData;
1198     pAstCfg->xStr[z].pAudioFrame->privateMetadataBufSize = pP->pMetadataBufStatus->bufSize;
1199     for(i=0;i<pP->pMetadataBufStatus->NumBuf;i++)
1200     {
1201         pAstCfg->xStr[z].pAudioFrame->pafPrivateMetadata[i].offset = 0;
1202         pAstCfg->xStr[z].pAudioFrame->pafPrivateMetadata[i].size = 0;
1203         pAstCfg->xStr[z].pAudioFrame->pafPrivateMetadata[i].pMdBuf = metadataBuf + pP->pMetadataBufStatus->bufSize*i;
1204     }
1206     //
1207     // Initialize decoder elements directly
1208     //
1210     for (zX = DECODE1; zX < DECODEN; zX++) 
1211     {
1212         if (pP->streamsFromDecodes[zX] == z) 
1213         {
1214 #ifdef NOAUDIOSHARE
1215             pAstCfg->xDec[zX].decodeInStruct.audioShare.nSamples = 0;
1216             pAstCfg->xDec[zX].decodeInStruct.audioShare.sample = NULL;
1217 #else /* NOAUDIOSHARE */
1218             pAstCfg->xDec[zX].decodeInStruct.audioShare.nSamples = aLen_int;
1219             pAstCfg->xDec[zX].decodeInStruct.audioShare.sample = aBuf_int;
1220 #endif /* NOAUDIOSHARE */
1221         }
1222     }
1224     return 0;
1225 } //PAF_ASOT_initFrame0
1227 // -----------------------------------------------------------------------------
1228 // ASOT Initialization Function Helper - Reinitialization of Audio Frame
1229 // AST Decoding Function              - Reinitialization of Audio Frame
1230 //
1231 //   Name:      PAF_ASOT_initFrame1
1232 //   Purpose:   Audio Stream Task Function for initialization or reinitiali-
1233 //              zation of the Audio Frame(s) by loading of data values of a
1234 //              time-varying nature.
1235 //   From:      audioStream1Task or equivalent
1236 //              AST Parameter Function -> decodeInfo
1237 //              AST Parameter Function -> decodeDecode
1238 //   Uses:      See code.
1239 //   States:    x
1240 //   Return:    0.
1241 //   Trace:     None.
1242 //
1243 Int PAF_ASOT_initFrame1(
1244     const PAF_ASOT_Params *pP, 
1245     const PAF_ASOT_Patchs *pQ, 
1246     PAF_ASOT_Config *pAsotCfg, 
1247     Int z, 
1248     Int apply
1251     PAF_AST_Config *pAstCfg;
1253     pAstCfg = pAsotCfg->pAstCfg; // get pointer to AST common (shared) configuration
1255     //
1256     // Reinitialize audio frame elements:
1257     //
1258     //   Channel Configurations during sys init                 = Unknown
1259     //      "          "        during info or decode           = None
1260     //
1261     //   Sample Rate / Count    during sys init, info or decode = Unknown / 0
1262     //
1264     if (apply < 0) 
1265     {
1266         pAstCfg->xStr[z].pAudioFrame->channelConfigurationRequest.legacy = PAF_CC_UNKNOWN;
1267         pAstCfg->xStr[z].pAudioFrame->channelConfigurationStream.legacy = PAF_CC_UNKNOWN;
1268     }
1269     else 
1270     {
1271         pAstCfg->xStr[z].pAudioFrame->channelConfigurationRequest.legacy = PAF_CC_NONE;
1272         pAstCfg->xStr[z].pAudioFrame->channelConfigurationStream.legacy = PAF_CC_NONE;
1273     }
1275     if (apply < 1) 
1276     {
1277         pAstCfg->xStr[z].pAudioFrame->sampleRate = PAF_SAMPLERATE_UNKNOWN;
1278         pAstCfg->xStr[z].pAudioFrame->sampleCount = 0;
1279     }
1281     return 0;
1282 } //PAF_ASOT_initFrame1