AnsweredAssumed Answered

Trouble with the Multiband Graphic Equalizer SDK again, Linker Error

Question asked by chris_k. on Aug 20, 2015
Latest reply on Aug 20, 2015 by chris_k.

Hello Comunity,

 

i'm working with the Multiband Graphic Equalizer SDK on the BF561-EZLITE board again and i'm facing a Linker Error again.

 

When i was using the SDK in a former project i was facing the same error and i started the Thread "Trouble with the Multiband Graphic Equalizer SDK, Linker Error" where CraigG helped me out ( Trouble with the Multiband Graphic Equalizer SDK, Linker Error ).

This time i'm facing the same Linker Error, but i'm not able to fix it like i did in the former project.

 

In the actual project i want to run ten instances of the equalizer on processor core b. The input and output buffers for the equalizer are placed in shared memory L3. When i try to create an instance of the equalizer, i get the following Linker Error.

 

[Error li1021]  The following symbols referenced in processor 'p1' could not be resolved:

        'adi_eq_audpp_create_2_0 [_adi_eq_audpp_create_2_0]' referenced from 'coreb.dlb[main_core_B.doj]'

 

I tryed to fix this like i did in the former project. I copied the missing "adi_fast_prio0_code" and "adi_slow_noprio_r" commands to the corresponding positions in my LDF file. I've recognized that there are different sections for Processor core p0 and p1 in my LDF file. I placed the commads into both sections and i placed them only in the p1 section. Both cases did not fix the linker error.

 

 

I'm a little overextended with this again. Does someone of You know what i'm making wrong this time? The only differences to my former project are that i'm running the Equalizer ob Core B and the equalizers input/output buffers are in external memory L3.

 

 

Here's my code, running in processor core B it's main function:

 

// memory for Equalizer instances

  char EQinstanceCH1_memory[1764];

  char EQinstanceCH2_memory[1764];

  char EQinstanceCH3_memory[1764];

  char EQinstanceCH4_memory[1764];

  char EQinstanceCH5_memory[1764];

  char EQinstanceCH6_memory[1764];

  char EQinstanceCH7_memory[1764];

  char EQinstanceCH8_memory[1764];

  char EQinstanceCH9_memory[1764];

  char EQinstanceCH10_memory[1764];

  char EQinstanceMIC1_memory[1764];

  char EQinstanceMIC2_memory[1764];

 

 

  //create memory pool structure for Equalizer instances

  adi_eq_audpp_mem_t EQ_CH1_memory_blocks;

  adi_eq_audpp_mem_t EQ_CH2_memory_blocks;

  adi_eq_audpp_mem_t EQ_CH3_memory_blocks;

  adi_eq_audpp_mem_t EQ_CH4_memory_blocks;

  adi_eq_audpp_mem_t EQ_CH5_memory_blocks;

  adi_eq_audpp_mem_t EQ_CH6_memory_blocks;

  adi_eq_audpp_mem_t EQ_CH7_memory_blocks;

  adi_eq_audpp_mem_t EQ_CH8_memory_blocks;

  adi_eq_audpp_mem_t EQ_CH9_memory_blocks;

  adi_eq_audpp_mem_t EQ_CH10_memory_blocks;

  adi_eq_audpp_mem_t EQ_MIC1_memory_blocks;

  adi_eq_audpp_mem_t EQ_MIC2_memory_blocks;

 

  adi_eq_audpp_instance_t* EQinstanceCH1 = 0;

  adi_eq_audpp_instance_t* EQinstanceCH2 = 0;

  adi_eq_audpp_instance_t* EQinstanceCH3 = 0;

  adi_eq_audpp_instance_t* EQinstanceCH4 = 0;

  adi_eq_audpp_instance_t* EQinstanceCH5 = 0;

  adi_eq_audpp_instance_t* EQinstanceCH6 = 0;

  adi_eq_audpp_instance_t* EQinstanceCH7 = 0;

  adi_eq_audpp_instance_t* EQinstanceCH8 = 0;

  adi_eq_audpp_instance_t* EQinstanceCH9 = 0;

  adi_eq_audpp_instance_t* EQinstanceCH10 = 0;

  adi_eq_audpp_instance_t* EQinstanceMIC1 = 0;

  adi_eq_audpp_instance_t* EQinstanceMIC2 = 0;

 

 

    // buffes are in L3 shared memory

 

    adi_eq_audpp_audio_data_t *EQ_CH1_input_pcm_data1[1] = {i_CH1_InputEQbuffer1};

    adi_eq_audpp_audio_data_t *EQ_CH1_input_pcm_data2[1] = {i_CH1_InputEQbuffer2};

    adi_eq_audpp_audio_data_t *EQ_CH1_output_pcm_data1[1] = {i_CH1_OutputEQbuffer1};

    adi_eq_audpp_audio_data_t *EQ_CH1_output_pcm_data2[1] = {i_CH1_OutputEQbuffer2};

  

    adi_eq_audpp_audio_data_t *EQ_CH2_input_pcm_data1[1] = {i_CH2_InputEQbuffer1};

    adi_eq_audpp_audio_data_t *EQ_CH2_input_pcm_data2[1] = {i_CH2_InputEQbuffer2};

    adi_eq_audpp_audio_data_t *EQ_CH2_output_pcm_data1[1] = {i_CH2_OutputEQbuffer1};

    adi_eq_audpp_audio_data_t *EQ_CH2_output_pcm_data2[1] = {i_CH2_OutputEQbuffer2};

   

    adi_eq_audpp_audio_data_t *EQ_CH3_input_pcm_data1[1] = {i_CH3_InputEQbuffer1};

    adi_eq_audpp_audio_data_t *EQ_CH3_input_pcm_data2[1] = {i_CH3_InputEQbuffer2};

    adi_eq_audpp_audio_data_t *EQ_CH3_output_pcm_data1[1] = {i_CH3_OutputEQbuffer1};

    adi_eq_audpp_audio_data_t *EQ_CH3_output_pcm_data2[1] = {i_CH3_OutputEQbuffer2};

   

    adi_eq_audpp_audio_data_t *EQ_CH4_input_pcm_data1[1] = {i_CH4_InputEQbuffer1};

    adi_eq_audpp_audio_data_t *EQ_CH4_input_pcm_data2[1] = {i_CH4_InputEQbuffer2};

    adi_eq_audpp_audio_data_t *EQ_CH4_output_pcm_data1[1] = {i_CH4_OutputEQbuffer1};

    adi_eq_audpp_audio_data_t *EQ_CH4_output_pcm_data2[1] = {i_CH4_OutputEQbuffer2};

   

    adi_eq_audpp_audio_data_t *EQ_CH5_input_pcm_data1[1] = {i_CH5_InputEQbuffer1};

    adi_eq_audpp_audio_data_t *EQ_CH5_input_pcm_data2[1] = {i_CH5_InputEQbuffer2};

    adi_eq_audpp_audio_data_t *EQ_CH5_output_pcm_data1[1] = {i_CH5_OutputEQbuffer1};

    adi_eq_audpp_audio_data_t *EQ_CH5_output_pcm_data2[1] = {i_CH5_OutputEQbuffer2};

   

    adi_eq_audpp_audio_data_t *EQ_CH6_input_pcm_data1[1] = {i_CH6_InputEQbuffer1};

    adi_eq_audpp_audio_data_t *EQ_CH6_input_pcm_data2[1] = {i_CH6_InputEQbuffer2};

    adi_eq_audpp_audio_data_t *EQ_CH6_output_pcm_data1[1] = {i_CH6_OutputEQbuffer1};

    adi_eq_audpp_audio_data_t *EQ_CH6_output_pcm_data2[1] = {i_CH6_OutputEQbuffer2};

   

    adi_eq_audpp_audio_data_t *EQ_CH7_input_pcm_data1[1] = {i_CH7_InputEQbuffer1};

    adi_eq_audpp_audio_data_t *EQ_CH7_input_pcm_data2[1] = {i_CH7_InputEQbuffer2};

    adi_eq_audpp_audio_data_t *EQ_CH7_output_pcm_data1[1] = {i_CH7_OutputEQbuffer1};

    adi_eq_audpp_audio_data_t *EQ_CH7_output_pcm_data2[1] = {i_CH7_OutputEQbuffer2};

   

    adi_eq_audpp_audio_data_t *EQ_CH8_input_pcm_data1[1] = {i_CH8_InputEQbuffer1};

    adi_eq_audpp_audio_data_t *EQ_CH8_input_pcm_data2[1] = {i_CH8_InputEQbuffer2};

    adi_eq_audpp_audio_data_t *EQ_CH8_output_pcm_data1[1] = {i_CH8_OutputEQbuffer1};

    adi_eq_audpp_audio_data_t *EQ_CH8_output_pcm_data2[1] = {i_CH8_OutputEQbuffer2};

   

    adi_eq_audpp_audio_data_t *EQ_CH9_input_pcm_data1[1] = {i_CH9_InputEQbuffer1};

    adi_eq_audpp_audio_data_t *EQ_CH9_input_pcm_data2[1] = {i_CH9_InputEQbuffer2};

    adi_eq_audpp_audio_data_t *EQ_CH9_output_pcm_data1[1] = {i_CH9_OutputEQbuffer1};

    adi_eq_audpp_audio_data_t *EQ_CH9_output_pcm_data2[1] = {i_CH9_OutputEQbuffer2};

  

    adi_eq_audpp_audio_data_t *EQ_CH10_input_pcm_data1[1] = {i_CH10_InputEQbuffer1};

    adi_eq_audpp_audio_data_t *EQ_CH10_input_pcm_data2[1] = {i_CH10_InputEQbuffer2};

    adi_eq_audpp_audio_data_t *EQ_CH10_output_pcm_data1[1] = {i_CH10_OutputEQbuffer1};

    adi_eq_audpp_audio_data_t *EQ_CH10_output_pcm_data2[1] = {i_CH10_OutputEQbuffer2};

   

    adi_eq_audpp_audio_data_t *EQ_MIC1_input_pcm_data1[1] = {i_MIC1_InputEQbuffer1};

    adi_eq_audpp_audio_data_t *EQ_MIC1_input_pcm_data2[1] = {i_MIC1_InputEQbuffer2};

    adi_eq_audpp_audio_data_t *EQ_MIC1_output_pcm_data1[1] = {i_MIC1_OutputEQbuffer1};

    adi_eq_audpp_audio_data_t *EQ_MIC1_output_pcm_data2[1] = {i_MIC1_OutputEQbuffer2};

   

    adi_eq_audpp_audio_data_t *EQ_MIC2_input_pcm_data1[1] = {i_MIC2_InputEQbuffer1};

    adi_eq_audpp_audio_data_t *EQ_MIC2_input_pcm_data2[1] = {i_MIC2_InputEQbuffer2};

    adi_eq_audpp_audio_data_t *EQ_MIC2_output_pcm_data1[1] = {i_MIC2_OutputEQbuffer1};

    adi_eq_audpp_audio_data_t *EQ_MIC2_output_pcm_data2[1] = {i_MIC2_OutputEQbuffer2};

   

    adi_eq_audpp_config_t EQconfigurationCH1 = {};

  adi_eq_audpp_config_t EQconfigurationCH2 = {};

  adi_eq_audpp_config_t EQconfigurationCH3 = {};

  adi_eq_audpp_config_t EQconfigurationCH4 = {};

  adi_eq_audpp_config_t EQconfigurationCH5 = {};

  adi_eq_audpp_config_t EQconfigurationCH6 = {};

  adi_eq_audpp_config_t EQconfigurationCH7 = {};

  adi_eq_audpp_config_t EQconfigurationCH8 = {};

  adi_eq_audpp_config_t EQconfigurationCH9 = {};

  adi_eq_audpp_config_t EQconfigurationCH10 = {};

  adi_eq_audpp_config_t EQconfigurationMIC1 = {};

  adi_eq_audpp_config_t EQconfigurationMIC2 = {};

 

 

  // generate Equalizer configurations

 

    EQconfigurationCH1.num_channels = 2;

    EQconfigurationCH1.sample_rate = 44000;

    EQconfigurationCH1.num_bands = 3;

    int EQ_CH1_gains[3] = {0, 0, 0}; //goes from -1200 (-12dB) to 1200 (+12dB)

    EQconfigurationCH1.gains = &EQ_CH1_gains[0];

   

    EQconfigurationCH2.num_channels = 2;

    EQconfigurationCH2.sample_rate = 44000;

    EQconfigurationCH2.num_bands = 3;

    int EQ_CH2_gains[3] = {0, 0, 0}; //goes from -1200 (-12dB) to 1200 (+12dB)

    EQconfigurationCH2.gains = &EQ_CH2_gains[0];

   

    EQconfigurationCH3.num_channels = 2;

    EQconfigurationCH3.sample_rate = 44000;

    EQconfigurationCH3.num_bands = 3;

    int EQ_CH3_gains[3] = {0, 0, 0}; //goes from -1200 (-12dB) to 1200 (+12dB)

    EQconfigurationCH3.gains = &EQ_CH3_gains[0];

   

    EQconfigurationCH4.num_channels = 2;

    EQconfigurationCH4.sample_rate = 44000;

    EQconfigurationCH4.num_bands = 3;

    int EQ_CH4_gains[3] = {0, 0, 0}; //goes from -1200 (-12dB) to 1200 (+12dB)

    EQconfigurationCH4.gains = &EQ_CH4_gains[0];

   

    EQconfigurationCH5.num_channels = 2;

    EQconfigurationCH5.sample_rate = 44000;

    EQconfigurationCH5.num_bands = 3;

    int EQ_CH5_gains[3] = {0, 0, 0}; //goes from -1200 (-12dB) to 1200 (+12dB)

    EQconfigurationCH5.gains = &EQ_CH5_gains[0];

   

    EQconfigurationCH6.num_channels = 2;

    EQconfigurationCH6.sample_rate = 44000;

    EQconfigurationCH6.num_bands = 3;

    int EQ_CH6_gains[3] = {0, 0, 0}; //goes from -1200 (-12dB) to 1200 (+12dB)

    EQconfigurationCH6.gains = &EQ_CH6_gains[0];

   

    EQconfigurationCH7.num_channels = 2;

    EQconfigurationCH7.sample_rate = 44000;

    EQconfigurationCH7.num_bands = 3;

    int EQ_CH7_gains[3] = {0, 0, 0}; //goes from -1200 (-12dB) to 1200 (+12dB)

    EQconfigurationCH7.gains = &EQ_CH7_gains[0];

   

    EQconfigurationCH8.num_channels = 2;

    EQconfigurationCH8.sample_rate = 44000;

    EQconfigurationCH8.num_bands = 3;

    int EQ_CH8_gains[3] = {0, 0, 0}; //goes from -1200 (-12dB) to 1200 (+12dB)

    EQconfigurationCH8.gains = &EQ_CH8_gains[0];

   

    EQconfigurationCH9.num_channels = 2;

    EQconfigurationCH9.sample_rate = 44000;

    EQconfigurationCH9.num_bands = 3;

    int EQ_CH9_gains[3] = {0, 0, 0}; //goes from -1200 (-12dB) to 1200 (+12dB)

    EQconfigurationCH9.gains = &EQ_CH9_gains[0];

   

    EQconfigurationCH10.num_channels = 2;

    EQconfigurationCH10.sample_rate = 44000;

    EQconfigurationCH10.num_bands = 3;

    int EQ_CH10_gains[3] = {0, 0, 0}; //goes from -1200 (-12dB) to 1200 (+12dB)

    EQconfigurationCH10.gains = &EQ_CH10_gains[0];

   

    EQconfigurationMIC1.num_channels = 2;

    EQconfigurationMIC1.sample_rate = 44000;

    EQconfigurationMIC1.num_bands = 3;

    int EQ_MIC1_gains[3] = {0, 0, 0}; //goes from -1200 (-12dB) to 1200 (+12dB)

    EQconfigurationMIC1.gains = &EQ_MIC1_gains[0];

   

    EQconfigurationMIC2.num_channels = 2;

    EQconfigurationMIC2.sample_rate = 44000;

    EQconfigurationMIC2.num_bands = 3;

    int EQ_MIC2_gains[3] = {0, 0, 0}; //goes from -1200 (-12dB) to 1200 (+12dB)

    EQconfigurationMIC2.gains = &EQ_MIC2_gains[0];

 

 

   

    // prepare Equalizer instances

    EQ_CH1_memory_blocks.state.fast.prio0 = EQinstanceCH1_memory;

    EQ_CH2_memory_blocks.state.fast.prio0 = EQinstanceCH2_memory;

    EQ_CH3_memory_blocks.state.fast.prio0 = EQinstanceCH3_memory;

    EQ_CH4_memory_blocks.state.fast.prio0 = EQinstanceCH4_memory;

    EQ_CH5_memory_blocks.state.fast.prio0 = EQinstanceCH5_memory;

    EQ_CH6_memory_blocks.state.fast.prio0 = EQinstanceCH6_memory;

    EQ_CH7_memory_blocks.state.fast.prio0 = EQinstanceCH7_memory;

    EQ_CH8_memory_blocks.state.fast.prio0 = EQinstanceCH8_memory;

    EQ_CH9_memory_blocks.state.fast.prio0 = EQinstanceCH9_memory;

    EQ_CH10_memory_blocks.state.fast.prio0 = EQinstanceCH10_memory;

    EQ_MIC1_memory_blocks.state.fast.prio0 = EQinstanceMIC1_memory;

    EQ_MIC2_memory_blocks.state.fast.prio0 = EQinstanceMIC2_memory;

 

    // create Equalizer instances

    EQinstanceCH1 = adi_eq_audpp_create(&EQ_CH1_memory_blocks); //----------> here i get the error

 

  while(1);

Outcomes