Post Go back to editing

How to use multi channel IIR Accelerator in two different subfunction files ?

Category: Software
Product Number: ADSP-21569
Software Version: CCES 2.11

By using the Engineer-to-Engineer Note EE-436, I could use IIR Accelerator to save CPU time (4 TASKs, 16 Channels), and it works!

Recently, I have  two different subfunctions (two different .c / .h files) in the same project,both of them need IIR Accelerator 。But it does't works if I copy all the procedures (such as: Open the IIR Device / Register the Callback /  Create Accelerator Tasks / INIT the data and IIR coefficient / Queue the Tasks Created ) in both two subfunctions , so please teach me how to use the IIR Accelerator in two  different subfunctions, thanks!

  • Hi Louis,

    Please provide more information on below points to assist you better on this.
    1.Which accelerator mode are you using in your application and what changes have you made in the IIR configuration files?
    2.Could you please share the steps you are following to add the two sub functions?
    3.Is it possible to check with a single sub function and let us know whether you are facing the same issue?
    4.Please let us know how you are calling the sub function in the main function. Could you share an example code or snippet?
    5.Are you using an Ez-kit or a custom board?

    Regards,
    Ranjitha.R
  • I appreciate your response,and I will try my best to offer more imformation. 

    1、It must be the default option,LEGACY;

    2、3、4、In MAIN, the code is below(I delete the irrelevant parts, and offer one of the subfunction files,  the IIR ACC procedure of another subfunction is almost the same except the  variable name):

        INIT_FIR_IIR();                    // IIR ACC INI
        while(1)
        {
          CallUpmixMethod(in , out);  //in upmix.c/.h  one of the sub function
         DRC(out,aout) ;                           //in  DRC.c/DRC.h  another sub function
         }
    In upmix.c:
    #include "upmix.h"
    #include <math.h>
    #include <stdlib.h>
    #include <vector.h>
    #include <string.h>
    #include <drivers/iir/adi_iir.h>
    
    
    float IIR_Buffer[IIR_WINDOW_SIZE];
    float IIR_Out_LFE[IIR_WINDOW_SIZE];
    float IIR_Out_HP1[IIR_WINDOW_SIZE];
    float IIR_Out_HP2[IIR_WINDOW_SIZE];
    float IIR_Out_HP3[IIR_WINDOW_SIZE];
    float IIR_Out_HP4[IIR_WINDOW_SIZE];
    float IIR_Out_LP1[IIR_WINDOW_SIZE];
    float IIR_Out_LP2[IIR_WINDOW_SIZE];
    float IIR_Out_LP3[IIR_WINDOW_SIZE];
    float IIR_Out_LP4[IIR_WINDOW_SIZE];
    float IIR_Out_BP1[IIR_WINDOW_SIZE];
    
    
    #if 1
    #pragma align 32
    uint8_t IirTask1Memory[IIR_MEM_SIZE_TASK1];
    
    uint8_t IirTask2Memory[IIR_MEM_SIZE_TASK2];
    
    uint8_t IirTask3Memory[IIR_MEM_SIZE_TASK3];
    
    ADI_IIR_CHANNEL_INFO IirTask1_Channels[IIR_NUMBER_OF_CHANNELS_TASK1];
    
    ADI_IIR_CHANNEL_INFO IirTask2_Channels[IIR_NUMBER_OF_CHANNELS_TASK2];
    
    ADI_IIR_CHANNEL_INFO IirTask3_Channels[IIR_NUMBER_OF_CHANNELS_TASK3];
    
    ADI_IIR_DEV_HANDLE hIir;
    
    //ADI_IIR_TASK_HANDLE hIirTasks[IIR_NUMBER_OF_TASKS] = {0};
    ADI_IIR_TASK_HANDLE hIirTasks1;
    
    ADI_IIR_TASK_HANDLE hIirTasks2;
    
    ADI_IIR_TASK_HANDLE hIirTasks3;
    
    volatile uint32_t IIRTaskDoneCount = 0;
    //volatile void *IIRCompletedTaskHandles[60] = {0};
    void IIRTaskDoneCallback( void * pCBParam, ADI_IIR_EVENT Event, void * pArg);
    
    void IIRTaskDoneCallback( void * pCBParam, ADI_IIR_EVENT Event, void * pArg)
    {
    	switch(Event)
    	{
    #if  ADI_IIR_CFG_ACCELERATOR_MODE == ADI_IIR_ACCELERATOR_MODE_ACM
    	    case ADI_IIR_EVENT_CHANNEL_DONE:
    #else
    	    case ADI_IIR_EVENT_ALL_CHANNEL_DONE:
    #endif
    //	    	IIRCompletedTaskHandles[IIRTaskDoneCount++] = pArg;
    	    	IIRTaskDoneCount++;
    	}
    }
    
    
    #endif
    
    volatile int count = 0;
    float out;
    float iir_Gain_LFE = 8.30790576894626e-05;		// IIR_LowPass_200Hz_Order24_SOS
    
    float iir_Gain_LP1 = 0.000109750029908326;		// IIR_LowPass_2000Hz_Order12_SOS
    float iir_Gain_LP2 = 0.000111765720881903;		// IIR_LowPass_2000Hz_Order24_SOS
    float iir_Gain_LP3 = 0.000249277069314157; 		// IIR_LowPass_4000Hz_Order24_SOS
    float iir_Gain_LP4 = 0.00125663432717671;		// IIR_LowPass_8000Hz_Order24_SOS
    
    float iir_Gain_HP1 = 0.397202804495130;			// IIR_HighPass_2000Hz_Order12_SOS
    float iir_Gain_HP2 = 0.427748529321013;			// IIR_HighPass_2000Hz_Order24_SOS
    float iir_Gain_HP3 = 0.808661453709790;			// IIR_HighPass_500Hz_Order24_SOS
    float iir_Gain_HP4 = 0.911663660426965;			// IIR_HighPass_200Hz_Order12_SOS
    
    float iir_Gain_BP1 = 0.000241070564039328;		// IIR_BandPass_1000_4000Hz_Order12_SOS
    
    //start = clock();
    #if 1
    
    void CallUpmixMethod(int* SrcBuf,int SrcBufLength,int* DestBuf,int DestBufLength,int ChannelLength , int count)
    {
    //	start = clock();
    
    	for(int i = 0;i< ChannelLength;i++)
    	{
    		int sig_L = SrcBuf[i*2];
    		int sig_R = SrcBuf[i*2 + 1];
    		//PSD
    		// BANZI 3
    		DestBuf[i*16 + 0] = (int)(IIR_Out_LP3[i] * iir_Gain_LP3);			// LTF
    		DestBuf[i*16 + 1] = (int)(IIR_Out_HP4[i] * iir_Gain_HP4);			// RTF
    		DestBuf[i*16 + 2] = sig_L;			// LTR
    		// BANZI 1
    		DestBuf[i*16 + 8] = (int)(IIR_Out_LP4[i] * iir_Gain_LP4);			// C
    		DestBuf[i*16 + 9] = (int)(IIR_Out_LFE[i] * iir_Gain_LFE);			// L
    		DestBuf[i*16 + 10] = (int)(IIR_Out_BP1[i] * iir_Gain_BP1);			// R
    		DestBuf[i*16 + 11] = (int)(IIR_Out_LP2[i] * iir_Gain_LP2);			//LS
    
    		IIR_Buffer[i] = (float)sig_L;	
    		// BANZI 2
    		DestBuf[i*16 + 12] = (int)(IIR_Out_HP3[i] * iir_Gain_HP3);			// RTR
    		DestBuf[i*16 + 13] = (int)(IIR_Out_HP1[i] * iir_Gain_HP1);			// LRS
    		DestBuf[i*16 + 14] = (int)(IIR_Out_LP1[i] * iir_Gain_LP1);			// RS
    		DestBuf[i*16 + 15] = (int)(IIR_Out_HP2[i] * iir_Gain_HP2);			// RRS
    
    	}
    
    		// IIR ACC BEGIN
    		ADI_IIR_RESULT eIirResult = ADI_IIR_RESULT_SUCCESS;
    
    	    /* Queue the Tasks Created */
    	    eIirResult = adi_iir_QueueTask(hIirTasks1);
    	    CHECK_IIR_RESULT(eIirResult);
    
    	    eIirResult = adi_iir_QueueTask(hIirTasks2);
    	    CHECK_IIR_RESULT(eIirResult);
    
    	    eIirResult = adi_iir_QueueTask(hIirTasks3);
    	    CHECK_IIR_RESULT(eIirResult);
    
    	    while(IIRTaskDoneCount < IIR_NUMBER_OF_TASKS);
    	    IIRTaskDoneCount=0;
    
    
    
    }
    
    #endif
    
    
    #if 1
    void INIT_FIR_IIR()
    {
    	ADI_IIR_RESULT eIirResult = ADI_IIR_RESULT_SUCCESS;
    
    	/* Initialize IIR task channels */
    	InitializeIIRTaskChannels();
    
    
    	/* Open the IIR Device */
    	    eIirResult  = adi_iir_Open(0u,&hIir);
    	    CHECK_IIR_RESULT(eIirResult);
    
    	    /* Register the Callback */
    	    eIirResult = adi_iir_RegisterCallback(hIir,IIRTaskDoneCallback,0);
    	    CHECK_IIR_RESULT(eIirResult);
    
    	    /* Create Accelerator Tasks */
    	    eIirResult = adi_iir_CreateTask(hIir, /* Device Handle */
    	    		IirTask1_Channels,            /* Pointer to Channel List */
    				IIR_NUMBER_OF_CHANNELS_TASK1, /* Number of Channels */
    				&IirTask1Memory,              /* Pointer to Task Memory */
    				IIR_MEM_SIZE_TASK1,           /* Memory Size */
    //				&hIirTasks[0]);               /* Address to store handle */
    				&hIirTasks1);
    	    CHECK_IIR_RESULT(eIirResult);
    
    	    eIirResult = adi_iir_CreateTask(hIir, /* Device Handle */
    	    		IirTask2_Channels,            /* Pointer to Channel List */
    				IIR_NUMBER_OF_CHANNELS_TASK2, /* Number of Channels */
    				&IirTask2Memory,              /* Pointer to Task Memory */
    				IIR_MEM_SIZE_TASK2,           /* Memory Size */
    //				&hIirTasks[0]);               /* Address to store handle */
    				&hIirTasks2);
    	    CHECK_IIR_RESULT(eIirResult);
    //
    	    eIirResult = adi_iir_CreateTask(hIir, /* Device Handle */
    	    		IirTask3_Channels,            /* Pointer to Channel List */
    				IIR_NUMBER_OF_CHANNELS_TASK3, /* Number of Channels */
    				&IirTask3Memory,              /* Pointer to Task Memory */
    				IIR_MEM_SIZE_TASK3,           /* Memory Size */
    //				&hIirTasks[0]);               /* Address to store handle */
    				&hIirTasks3);
    	    CHECK_IIR_RESULT(eIirResult);
    
    //	    printf("IIR  ACC  INIT  FINISHED \n");
    }
    #endif
    
    
    #if 1
    void InitializeIIRTaskChannels()
    {
    	///////////////////////   TASK 1   ////////////////////////////////
    			IirTask1_Channels[0].nBiquads 				= 	BIQUADS12;
    			IirTask1_Channels[0].nWindowSize 			= 	IIR_WINDOW_SIZE;
    			IirTask1_Channels[0].nCoefficientLength 	= 	7*BIQUADS12;
    			IirTask1_Channels[0].nCoefficientModify 	= 	1;
    			IirTask1_Channels[0].pCoefficientIndex 		= 	(void*)&filter_LFE[0];
    			IirTask1_Channels[0].pOutputBuffBase 		= 	(void*)&IIR_Out_LFE[0];
    			IirTask1_Channels[0].nOutputBuffLength 		= 	IIR_WINDOW_SIZE;
    			IirTask1_Channels[0].nOutputBuffModify 		= 	1;
    			IirTask1_Channels[0].pOutputBuffIndex 		= 	(void*)&IIR_Out_LFE[0];
    			IirTask1_Channels[0].pInputBuffBase 		= 	(void*)&IIR_Buffer[0];
    			IirTask1_Channels[0].nInputBuffModify 		= 	1;
    			IirTask1_Channels[0].nInputBuffLength 		= 	IIR_WINDOW_SIZE;
    			IirTask1_Channels[0].pInputBuffIndex 		= 	(void*)&IIR_Buffer[0];
    
    			IirTask1_Channels[1].nBiquads 				= 	BIQUADS12;
    			IirTask1_Channels[1].nWindowSize 			= 	IIR_WINDOW_SIZE;
    			IirTask1_Channels[1].nCoefficientLength 	= 	7*BIQUADS12;
    			IirTask1_Channels[1].nCoefficientModify 	= 	1;
    			IirTask1_Channels[1].pCoefficientIndex 		= 	(void*)&filter_LP2[0];
    			IirTask1_Channels[1].pOutputBuffBase 		= 	(void*)&IIR_Out_LP2[0];
    			IirTask1_Channels[1].nOutputBuffLength 		= 	IIR_WINDOW_SIZE;
    			IirTask1_Channels[1].nOutputBuffModify 		= 	1;
    			IirTask1_Channels[1].pOutputBuffIndex 		= 	(void*)&IIR_Out_LP2[0];
    			IirTask1_Channels[1].pInputBuffBase 		= 	(void*)&IIR_Buffer[0];
    			IirTask1_Channels[1].nInputBuffModify 		= 	1;
    			IirTask1_Channels[1].nInputBuffLength 		= 	IIR_WINDOW_SIZE;
    			IirTask1_Channels[1].pInputBuffIndex 		= 	(void*)&IIR_Buffer[0];
    
    			IirTask1_Channels[2].nBiquads 				= 	BIQUADS6;
    			IirTask1_Channels[2].nWindowSize 			= 	IIR_WINDOW_SIZE;
    			IirTask1_Channels[2].nCoefficientLength 	= 	7*BIQUADS6;
    			IirTask1_Channels[2].nCoefficientModify 	= 	1;
    			IirTask1_Channels[2].pCoefficientIndex 		= 	(void*)&filter_LP1[0];
    			IirTask1_Channels[2].pOutputBuffBase 		= 	(void*)&IIR_Out_LP1[0];
    			IirTask1_Channels[2].nOutputBuffLength 		= 	IIR_WINDOW_SIZE;
    			IirTask1_Channels[2].nOutputBuffModify 		= 	1;
    			IirTask1_Channels[2].pOutputBuffIndex 		= 	(void*)&IIR_Out_LP1[0];
    			IirTask1_Channels[2].pInputBuffBase 		= 	(void*)&IIR_Buffer[0];
    			IirTask1_Channels[2].nInputBuffModify 		= 	1;
    			IirTask1_Channels[2].nInputBuffLength 		= 	IIR_WINDOW_SIZE;
    			IirTask1_Channels[2].pInputBuffIndex 		= 	(void*)&IIR_Buffer[0];
    
    			IirTask1_Channels[3].nBiquads 				= 	BIQUADS12;
    			IirTask1_Channels[3].nWindowSize 			= 	IIR_WINDOW_SIZE;
    			IirTask1_Channels[3].nCoefficientLength 	= 	7*BIQUADS12;
    			IirTask1_Channels[3].nCoefficientModify 	= 	1;
    			IirTask1_Channels[3].pCoefficientIndex 		= 	(void*)&filter_HP2[0];
    			IirTask1_Channels[3].pOutputBuffBase 		= 	(void*)&IIR_Out_HP2[0];
    			IirTask1_Channels[3].nOutputBuffLength 		= 	IIR_WINDOW_SIZE;
    			IirTask1_Channels[3].nOutputBuffModify 		= 	1;
    			IirTask1_Channels[3].pOutputBuffIndex 		= 	(void*)&IIR_Out_HP2[0];
    			IirTask1_Channels[3].pInputBuffBase 		= 	(void*)&IIR_Buffer[0];
    			IirTask1_Channels[3].nInputBuffModify 		= 	1;
    			IirTask1_Channels[3].nInputBuffLength 		= 	IIR_WINDOW_SIZE;
    			IirTask1_Channels[3].pInputBuffIndex 		= 	(void*)&IIR_Buffer[0];
    
    //			IirTask1_Channels[4].nBiquads 				= 	BIQUADS6;
    //			IirTask1_Channels[4].nWindowSize 			= 	IIR_WINDOW_SIZE;
    //			IirTask1_Channels[4].nCoefficientLength 	= 	7*BIQUADS6;
    //			IirTask1_Channels[4].nCoefficientModify 	= 	1;
    //			IirTask1_Channels[4].pCoefficientIndex 		= 	(void*)&filter_HP1[0];
    //			IirTask1_Channels[4].pOutputBuffBase 		= 	(void*)&IIR_Out_HP1[0];
    //			IirTask1_Channels[4].nOutputBuffLength 		= 	IIR_WINDOW_SIZE;
    //			IirTask1_Channels[4].nOutputBuffModify 		= 	1;
    //			IirTask1_Channels[4].pOutputBuffIndex 		= 	(void*)&IIR_Out_HP1[0];
    //			IirTask1_Channels[4].pInputBuffBase 		= 	(void*)&IIR_Buffer[0];
    //			IirTask1_Channels[4].nInputBuffModify 		= 	1;
    //			IirTask1_Channels[4].nInputBuffLength 		= 	IIR_WINDOW_SIZE;
    //			IirTask1_Channels[4].pInputBuffIndex 		= 	(void*)&IIR_Buffer[0];
    //
    //			IirTask1_Channels[5].nBiquads 				= 	BIQUADS12;
    //			IirTask1_Channels[5].nWindowSize 			= 	IIR_WINDOW_SIZE;
    //			IirTask1_Channels[5].nCoefficientLength 	= 	7*BIQUADS12;
    //			IirTask1_Channels[5].nCoefficientModify 	= 	1;
    //			IirTask1_Channels[5].pCoefficientIndex 		= 	(void*)&filter_BP1[0];
    //			IirTask1_Channels[5].pOutputBuffBase 		= 	(void*)&IIR_Out_BP1[0];
    //			IirTask1_Channels[5].nOutputBuffLength 		= 	IIR_WINDOW_SIZE;
    //			IirTask1_Channels[5].nOutputBuffModify 		= 	1;
    //			IirTask1_Channels[5].pOutputBuffIndex 		= 	(void*)&IIR_Out_BP1[0];
    //			IirTask1_Channels[5].pInputBuffBase 		= 	(void*)&IIR_Buffer[0];
    //			IirTask1_Channels[5].nInputBuffModify 		= 	1;
    //			IirTask1_Channels[5].nInputBuffLength 		= 	IIR_WINDOW_SIZE;
    //			IirTask1_Channels[5].pInputBuffIndex 		= 	(void*)&IIR_Buffer[0];
    
    ///////////////////////   TASK 2   ////////////////////////////////
    			IirTask2_Channels[0].nBiquads 				= 	BIQUADS6;
    			IirTask2_Channels[0].nWindowSize 			= 	IIR_WINDOW_SIZE;
    			IirTask2_Channels[0].nCoefficientLength 	= 	7*BIQUADS6;
    			IirTask2_Channels[0].nCoefficientModify 	= 	1;
    			IirTask2_Channels[0].pCoefficientIndex 		= 	(void*)&filter_HP1[0];
    			IirTask2_Channels[0].pOutputBuffBase 		= 	(void*)&IIR_Out_HP1[0];
    			IirTask2_Channels[0].nOutputBuffLength 		= 	IIR_WINDOW_SIZE;
    			IirTask2_Channels[0].nOutputBuffModify 		= 	1;
    			IirTask2_Channels[0].pOutputBuffIndex 		= 	(void*)&IIR_Out_HP1[0];
    			IirTask2_Channels[0].pInputBuffBase 		= 	(void*)&IIR_Buffer[0];
    			IirTask2_Channels[0].nInputBuffModify 		= 	1;
    			IirTask2_Channels[0].nInputBuffLength 		= 	IIR_WINDOW_SIZE;
    			IirTask2_Channels[0].pInputBuffIndex 		= 	(void*)&IIR_Buffer[0];
    
    			IirTask2_Channels[1].nBiquads 				= 	BIQUADS12;
    			IirTask2_Channels[1].nWindowSize 			= 	IIR_WINDOW_SIZE;
    			IirTask2_Channels[1].nCoefficientLength 	= 	7*BIQUADS12;
    			IirTask2_Channels[1].nCoefficientModify 	= 	1;
    			IirTask2_Channels[1].pCoefficientIndex 		= 	(void*)&filter_BP1[0];
    			IirTask2_Channels[1].pOutputBuffBase 		= 	(void*)&IIR_Out_BP1[0];
    			IirTask2_Channels[1].nOutputBuffLength 		= 	IIR_WINDOW_SIZE;
    			IirTask2_Channels[1].nOutputBuffModify 		= 	1;
    			IirTask2_Channels[1].pOutputBuffIndex 		= 	(void*)&IIR_Out_BP1[0];
    			IirTask2_Channels[1].pInputBuffBase 		= 	(void*)&IIR_Buffer[0];
    			IirTask2_Channels[1].nInputBuffModify 		= 	1;
    			IirTask2_Channels[1].nInputBuffLength 		= 	IIR_WINDOW_SIZE;
    			IirTask2_Channels[1].pInputBuffIndex 		= 	(void*)&IIR_Buffer[0];
    
    
    			IirTask2_Channels[2].nBiquads 				= 	BIQUADS12;
    			IirTask2_Channels[2].nWindowSize 			= 	IIR_WINDOW_SIZE;
    			IirTask2_Channels[2].nCoefficientLength 	= 	7*BIQUADS12;
    			IirTask2_Channels[2].nCoefficientModify 	= 	1;
    			IirTask2_Channels[2].pCoefficientIndex 		= 	(void*)&filter_LP3[0];
    			IirTask2_Channels[2].pOutputBuffBase 		= 	(void*)&IIR_Out_LP3[0];
    			IirTask2_Channels[2].nOutputBuffLength 		= 	IIR_WINDOW_SIZE;
    			IirTask2_Channels[2].nOutputBuffModify 		= 	1;
    			IirTask2_Channels[2].pOutputBuffIndex 		= 	(void*)&IIR_Out_LP3[0];
    			IirTask2_Channels[2].pInputBuffBase 		= 	(void*)&IIR_Buffer[0];
    			IirTask2_Channels[2].nInputBuffModify 		= 	1;
    			IirTask2_Channels[2].nInputBuffLength 		= 	IIR_WINDOW_SIZE;
    			IirTask2_Channels[2].pInputBuffIndex 		= 	(void*)&IIR_Buffer[0];
    
    			IirTask2_Channels[3].nBiquads 				= 	BIQUADS12;
    			IirTask2_Channels[3].nWindowSize 			= 	IIR_WINDOW_SIZE;
    			IirTask2_Channels[3].nCoefficientLength 	= 	7*BIQUADS12;
    			IirTask2_Channels[3].nCoefficientModify 	= 	1;
    			IirTask2_Channels[3].pCoefficientIndex 		= 	(void*)&filter_HP3[0];
    			IirTask2_Channels[3].pOutputBuffBase 		= 	(void*)&IIR_Out_HP3[0];
    			IirTask2_Channels[3].nOutputBuffLength 		= 	IIR_WINDOW_SIZE;
    			IirTask2_Channels[3].nOutputBuffModify 		= 	1;
    			IirTask2_Channels[3].pOutputBuffIndex 		= 	(void*)&IIR_Out_HP3[0];
    			IirTask2_Channels[3].pInputBuffBase 		= 	(void*)&IIR_Buffer[0];
    			IirTask2_Channels[3].nInputBuffModify 		= 	1;
    			IirTask2_Channels[3].nInputBuffLength 		= 	IIR_WINDOW_SIZE;
    			IirTask2_Channels[3].pInputBuffIndex 		= 	(void*)&IIR_Buffer[0];
    
    			///////////////////////   TASK 3   ////////////////////////////////
    			IirTask3_Channels[0].nBiquads 				= 	BIQUADS12;
    			IirTask3_Channels[0].nWindowSize 			= 	IIR_WINDOW_SIZE;
    			IirTask3_Channels[0].nCoefficientLength 	= 	7*BIQUADS12;
    			IirTask3_Channels[0].nCoefficientModify 	= 	1;
    			IirTask3_Channels[0].pCoefficientIndex 		= 	(void*)&filter_LP4[0];
    			IirTask3_Channels[0].pOutputBuffBase 		= 	(void*)&IIR_Out_LP4[0];
    			IirTask3_Channels[0].nOutputBuffLength 		= 	IIR_WINDOW_SIZE;
    			IirTask3_Channels[0].nOutputBuffModify 		= 	1;
    			IirTask3_Channels[0].pOutputBuffIndex 		= 	(void*)&IIR_Out_LP4[0];
    			IirTask3_Channels[0].pInputBuffBase 		= 	(void*)&IIR_Buffer[0];
    			IirTask3_Channels[0].nInputBuffModify 		= 	1;
    			IirTask3_Channels[0].nInputBuffLength 		= 	IIR_WINDOW_SIZE;
    			IirTask3_Channels[0].pInputBuffIndex 		= 	(void*)&IIR_Buffer[0];
    
    			IirTask3_Channels[1].nBiquads 				= 	BIQUADS6;
    			IirTask3_Channels[1].nWindowSize 			= 	IIR_WINDOW_SIZE;
    			IirTask3_Channels[1].nCoefficientLength 	= 	7*BIQUADS6;
    			IirTask3_Channels[1].nCoefficientModify 	= 	1;
    			IirTask3_Channels[1].pCoefficientIndex 		= 	(void*)&filter_HP4[0];
    			IirTask3_Channels[1].pOutputBuffBase 		= 	(void*)&IIR_Out_HP4[0];
    			IirTask3_Channels[1].nOutputBuffLength 		= 	IIR_WINDOW_SIZE;
    			IirTask3_Channels[1].nOutputBuffModify 		= 	1;
    			IirTask3_Channels[1].pOutputBuffIndex 		= 	(void*)&IIR_Out_HP4[0];
    			IirTask3_Channels[1].pInputBuffBase 		= 	(void*)&IIR_Buffer[0];
    			IirTask3_Channels[1].nInputBuffModify 		= 	1;
    			IirTask3_Channels[1].nInputBuffLength 		= 	IIR_WINDOW_SIZE;
    			IirTask3_Channels[1].pInputBuffIndex 		= 	(void*)&IIR_Buffer[0];
    }
    #endif
    
    
    

    In upmix.h:

    #ifndef __NEWEST_UPMIX_H__
    #define __NEWEST_UPMIX_H__
    
    #include <stdio.h>
    //#include <drivers/fir/adi_iir.h>
    
    
    void CallUpmixMethod(int* SrcBuf,int SrcBufLength,int* DestBuf,int DestBufLength,int ChannelLength,int count);
    void InitializeIIRTaskChannels(void);
    void INIT_FIR_IIR(void);
    void InitUpmixZero(void);
    void INIT_FIR_IIR(void);
    
    /* Biquads. Note that Biquad number can be varied across channels of a task*/
    #define BIQUADS6   		6		// IIR order 12, THE NUMBER OF SOS IS 42
    #define BIQUADS12   	12		// IIR order 12, THE NUMBER OF SOS IS 84
    #define NCH 6		//  channel
    /* Window Size. Note that Window size can be varied across channels in a task */
    #define IIR_WINDOW_SIZE    1024
    
    /* Number of IIR Tasks */
    #define IIR_NUMBER_OF_TASKS    3
    
    /* Number of Channels in IIR task 1 */
    #define IIR_NUMBER_OF_CHANNELS_TASK1    4		// 
    
    ///* Number of Channels in IIR task 2 */
    #define IIR_NUMBER_OF_CHANNELS_TASK2    4
    //
    ///* Number of Channels in IIR task 3 */
    #define IIR_NUMBER_OF_CHANNELS_TASK3    2
    
    ///* Total Number of Channels */
    //#define IIR_NUMBER_OF_CHANNELS    (IIR_NUMBER_OF_CHANNELS_TASK1 + IIR_NUMBER_OF_CHANNELS_TASK2)
    
    /* IIR Task 1 Memory Size */
    #define IIR_MEM_SIZE_TASK1    (IIR_MEM_SIZE(IIR_NUMBER_OF_CHANNELS_TASK1))
    
    /* IIR Task 2 Memory Size */
    #define IIR_MEM_SIZE_TASK2    (IIR_MEM_SIZE(IIR_NUMBER_OF_CHANNELS_TASK2))
    
    /* IIR Task 3 Memory Size */
    #define IIR_MEM_SIZE_TASK3    (IIR_MEM_SIZE(IIR_NUMBER_OF_CHANNELS_TASK3))
    
    /* Macro for checking Result returned by the driver after API call */
    #define CHECK_IIR_RESULT(eResult) \
            if(eResult != ADI_IIR_RESULT_SUCCESS)\
    		{\
                printf("CHECK_RESULT failed at line %d of file %s \n",__LINE__,__FILE__);\
                exit(-2);\
            }
    
    
    
    /* Tap Size IIR filter NO.6*/
    #define TAP_LFE  	84		// IIR_LowPass_200Hz_Order24_SOS
    #define TAP_HP1  	42		// IIR_HighPass_2000Hz_Order12_SOS
    #define TAP_HP2   	84		// IIR_HighPass_2000Hz_Order24_SOS
    #define TAP_LP1   	42		// IIR_LowPass_2000Hz_Order12_SOS
    #define TAP_LP2   	84		// IIR_LowPass_2000Hz_Order24_SOS
    #define TAP_BP1   	84		// IIR_BandPass_1000_4000Hz_Order12_SOS
    
    #define TAP_LP3   	84		// IIR_LowPass_4000Hz_Order24_SOS
    #define TAP_HP3   	84 		// IIR_HighPass_500Hz_Order24_SOS
    #define TAP_LP4   	84		// IIR_LowPass_8000Hz_Order24_SOS
    #define TAP_HP4   	42 		// IIR_HighPass_200Hz_Order12_SOS
    
    struct AudioData{
    
    	float* pfDstfl;
    	float* pfDstfr;
    	float* pfDstfc;
    	float* pfDstlfe;
    	float* pfDstsl;
    	float* pfDstsr;
    	float* pfDstbl;
    	float* pfDstbr;
    
    };
    
    
    //IIR_LowPass_200Hz_Order24_SOS
    static float filter_LFE[TAP_LFE] = {.........} //Omit all filter parameter

    5、The custom board, but I always do the validation  experiments in the SC594 EZ-KIT.

    Looking forward to your reply,thanks!

  • Hi Louis,

    We assume that your are facing an issue,when calling the CallUpmixMethod() in main() and while building the project. Please correct us if our understanding is incorrect.

    We reviewed your code and found an issue with calling the CallUpmixMethod(in,out) function in main(). The function parameters(in and out) don't match the expected number of defined parameters (SrcBuf, SrcBufLength, DestBuf, DestBufLength, ChannelLength, count).
    Make sure to pass all defined function parameters correctly when calling any function/subfunction from main().

    Regards,
    Ranjitha.R

  • Thanks for  your response. I'm afraid that the reason why  function parameters(in and out) don't match is that I delete it BY MISTAKE. I' sure the main function works well if only one of the subfunctions is included.

    So, the know-how I want to find out is that how to config the IIR ACC if I want use IIR ACC in these both two subfunctions.Just as my question description say,  I could use IIR Accelerator (4 TASKs, 16 Channels) in the subfunction CallUpmixMethod(upmix.c/h ) by copying the procedures  from Engineer-to-Engineer Note EE-436. When it comes two subfunction, I have copied all the same procedures (such as: Open the IIR Device / Register the Callback /  Create Accelerator Tasks / INIT the data and IIR coefficient / Queue the Tasks Created ) in both two subfunctions. But it DIDN'T WORKS!  This issue upset me.
    Recently, I'm wodering ALL the the same procedures should't be copied, maybe I should create a new .c/.h file, and remove some procedures (such as: Open the IIR Device / Register the Callback /  Create Accelerator Tasks ) in it. And the other procedures ( Queue the Tasks Created) could be copied in the two subfunction......

    Looking forward to your reply,thanks!

  • Hi Louis,

    We have created example code for ADSP-21569 IIR multichannel with two sub functions (one IIR task created, each having two channels). Please use this example code as a reference and modify it as per your requirements .ADSP_21569_IIR_multichannel.zip

    Please let us know if you need any assistance on this.

    Regards,
    Ranjitha.R