am_hw_primitive_builder_main.cc

Motorola synergy audio component

        hPortConfigure( HAPI_SMART_AUDIO_DAI_EN );
    }


    // ===========  MUTE/UNMUTE FM CHIP ============

    //    Screen out phones not supporting HAPI CE bus accy signals. 
#if ((MAKE_NEPTUNE_CHIPSET == TRUE && MAKE_HDW_BB_IC != MAKE_HDW_NEPTUNE_LT) \
 ||  (MAKE_NEPTUNE_CHIPSET == FALSE))

    //    HAPI_get_power_ic_type() is only defined for C650, an LTS product. 
  #if (MAKE_HDW_BB_IC == MAKE_HDW_NEPTUNE_LTS)

    /*  The call below will find out if we have seaweed, pcap or atlas ul. */
    if (( HAPI_get_power_ic_type() == HAPI_POWER_IC_TYPE_PCAP ) ||
        ( HAPI_get_power_ic_type() == HAPI_POWER_IC_TYPE_AUL ))
  #endif
    {
        if ( info_ptr->tone.type != am_hw_current_info_ptr->tone.type 
           && (is_ext_generated_audio_on_queue == TRUE) )
        {    
            if (info_ptr->tone.fields.id == DL_AUDIO_TONE_TYPE_RADIO )
            {    
                hPortConfigure(HAPI_FM_ACC_MUTE_EN);   
                aud_hPortWrite(HAPI_FM_ACC_MUTE_EN, HAPI_SIGNAL_DISABLE, AM_HW_FM_ACC_MUTE_EN );
                if(fm_muted == TRUE)
                {
                    HAPI_FM_RADIO_FREQ_T frequency;

                    //   Delay to allow FM Chip to power up successfully 
                    suSleep(50, NULL);
 
                    //   Set the frequency after unmuting 
                    DL_DbFeatureGetValue(DL_DB_FEATURE_ID_FM_RADIO_ACTIVE_STATION,
                       &frequency);

                    HAPI_FM_RADIO_set_channel(frequency);  
                 }
                 fm_muted = FALSE;
            }
            else            
            if (info_ptr->tone.fields.id == DL_AUDIO_TONE_TYPE_MP3_PLAYER )
            {
                hPortConfigure(HAPI_FM_ACC_MUTE_EN);   
                aud_hPortWrite(HAPI_FM_ACC_MUTE_EN, HAPI_SIGNAL_DISABLE, AM_HW_FM_ACC_MUTE_EN );
            }
            else
            {
                hPortConfigure(HAPI_FM_ACC_MUTE_EN);
                aud_hPortWrite(HAPI_FM_ACC_MUTE_EN, HAPI_SIGNAL_ENABLE, AM_HW_FM_ACC_MUTE_EN ); 
                fm_muted=TRUE;
            } 
        } 
    }                            
#endif


    //============   NOISE SUPPRESSION   ===========
    if (read_bit (delta_I_mask, AM_I_MASK_NOISE_SUPPRESS) ||
        (( info_ptr->echo_mode != am_hw_current_info_ptr->echo_mode ) &&
         ( read_bit(info_ptr->instruction_mask, AM_I_MASK_NOISE_SUPPRESS))))
    {
        am_hw_string_primitive << (AM_HW_MSG_HEADER_WORD_LEN);
        
        if( read_bit( info_ptr->instruction_mask, AM_I_MASK_NOISE_SUPPRESS ))
        {
            am_hw_string_primitive = am_hw_string_primitive
                + (UINT16) MCU_DSP_AUDIO_NS_ENABLE
                + (UINT8)  am_hw_string_primitive.stamp_time()
                + (UINT8)  0;
        }
        else
        {
            am_hw_string_primitive = am_hw_string_primitive
                + (UINT16) MCU_DSP_AUDIO_NS_DISABLE
                + (UINT8)  am_hw_string_primitive.stamp_time()
                + (UINT8)  0;            
        }

        am_hw_string_primitive.send ();
    }

    //============   ECHO CONTROL/MODE   ===========
    if ((info_ptr->echo_mode != am_hw_current_info_ptr->echo_mode ) &&
        (info_ptr->echo_mode != ECHO_MODE_NONE))
    {
        am_hw_string_primitive << (AM_HW_MSG_HEADER_WORD_LEN + MCU_DSP_AUDIO_MODE_SELECT_WORD_LEN);
        
        am_hw_string_primitive = am_hw_string_primitive
            + (UINT16) MCU_DSP_AUDIO_MODE_SELECT
            + (UINT8)  am_hw_string_primitive.stamp_time()
            + (UINT8)  MCU_DSP_AUDIO_MODE_SELECT_WORD_LEN
            + (UINT16) info_ptr->echo_mode;
        
        am_hw_string_primitive.send ();
    }
    
    if (read_bit (delta_I_mask, AM_I_MASK_ECHO_CONTROL) ||
        (( info_ptr->echo_mode != am_hw_current_info_ptr->echo_mode ) &&
         ( read_bit(info_ptr->instruction_mask, AM_I_MASK_ECHO_CONTROL))))
    {
        if( read_bit(info_ptr->instruction_mask, AM_I_MASK_ECHO_CONTROL))
        {
            am_hw_string_primitive << (AM_HW_MSG_HEADER_WORD_LEN);
            
            am_hw_string_primitive = am_hw_string_primitive
                + (UINT16) MCU_DSP_AUDIO_ECHO_CTL_ENABLE
                + (UINT8)  am_hw_string_primitive.stamp_time()
                + (UINT8)  0;
            
            am_hw_string_primitive.send ();
        }
        else
        {
            am_hw_string_primitive << (AM_HW_MSG_HEADER_WORD_LEN);
            
            am_hw_string_primitive = am_hw_string_primitive
                + (UINT16) MCU_DSP_AUDIO_ECHO_CTL_DISABLE
                + (UINT8)  am_hw_string_primitive.stamp_time()
                + (UINT8)  0; 
            
            am_hw_string_primitive.send ();           
        }
    }

    //============   NOTIFY DSP OF A CHANGE IN THE TTY MODE  ============
#if (MAKE_TTY == TRUE)
    if (DL_DbGetFeatureAvailability(DL_DB_FEATURE_ID_DIGITAL_TTY_AVAILABLE) == TRUE)
    {    
        am_send_tty_enable_disable();      
    }
#endif


    //============   AUDIO SHAPING   ===============
    //note that the "handset filter" uses the audio shaper, as do the companders
    if ((read_bit (delta_I_mask, AM_I_MASK_MIDI_COMPAND)) ||
        (read_bit (delta_I_mask, AM_I_MASK_MP3_COMPAND)) || 
        (read_bit (delta_I_mask, AM_I_MASK_INT_SPEAKER_PHONE_VOICE_COMPAND)) ||
        (read_bit (delta_I_mask, AM_I_MASK_CLIP_ON_SPEAKER_PHONE_COMPAND)) ||
        (read_bit (delta_I_mask, AM_I_MASK_PLOVER_VOICE_COMPAND)) ||
        (read_bit (delta_I_mask, AM_I_MASK_ZIHF_VOICE_COMPAND)) ||
        (read_bit (delta_I_mask, AM_I_MASK_PLOVER_HIFI_COMPAND)) ||
        (read_bit (delta_I_mask, AM_I_MASK_ZIHF_HIFI_COMPAND)) ||
        (read_bit (delta_I_mask, AM_I_MASK_BT_HEADSET_COMPAND)) ||
        (read_bit (delta_I_mask, AM_I_MASK_HEADSET_VOICE_COMPAND)) ||
        (read_bit (delta_I_mask, AM_I_MASK_AUDIO_HANDSET_FILTERING)) ||
        (read_bit (delta_I_mask, AM_I_MASK_HAPTICS_AS )) ||
        (read_bit (delta_I_mask, AM_I_MASK_STEREO_EMU_HS_MM_COMPAND)) || 
        (transition_type == AM_HW_TRANSITION_HIFI_TO_LOFI) ||
        (transition_type == AM_HW_TRANSITION_LOFI_TO_HIFI))
    {
        //first we need to check if any audio shaping is active
        if ((read_bit (am_hw_current_info_ptr->instruction_mask, AM_I_MASK_MIDI_COMPAND )) ||
            (read_bit (am_hw_current_info_ptr->instruction_mask, AM_I_MASK_MP3_COMPAND )) ||
            (read_bit (am_hw_current_info_ptr->instruction_mask, AM_I_MASK_INT_SPEAKER_PHONE_VOICE_COMPAND )) ||
            (read_bit (am_hw_current_info_ptr->instruction_mask, AM_I_MASK_CLIP_ON_SPEAKER_PHONE_COMPAND )) ||
            (read_bit (am_hw_current_info_ptr->instruction_mask, AM_I_MASK_PLOVER_VOICE_COMPAND )) ||
            (read_bit (am_hw_current_info_ptr->instruction_mask, AM_I_MASK_ZIHF_VOICE_COMPAND )) ||
            (read_bit (am_hw_current_info_ptr->instruction_mask, AM_I_MASK_PLOVER_HIFI_COMPAND )) ||
            (read_bit (am_hw_current_info_ptr->instruction_mask, AM_I_MASK_ZIHF_HIFI_COMPAND )) ||
            (read_bit (am_hw_current_info_ptr->instruction_mask, AM_I_MASK_BT_HEADSET_COMPAND )) ||
            (read_bit (am_hw_current_info_ptr->instruction_mask, AM_I_MASK_HEADSET_VOICE_COMPAND )) ||
            (read_bit (am_hw_current_info_ptr->instruction_mask, AM_I_MASK_AUDIO_HANDSET_FILTERING )) ||
            (read_bit (am_hw_current_info_ptr->instruction_mask, AM_I_MASK_HAPTICS_AS )) ||
            (read_bit (am_hw_current_info_ptr->instruction_mask, AM_I_MASK_STEREO_EMU_HS_MM_COMPAND)) )
        {
            //disable the entire audio shaper if it was on -- this is so parameters can be changed safely.
            am_hw_string_primitive << ( AM_HW_MSG_HEADER_WORD_LEN 
                                    + MCU_DSP_AUDIO_AS_DISABLE_WORD_LEN );
            
            am_hw_string_primitive = am_hw_string_primitive
                + (UINT16) MCU_DSP_AUDIO_AS_DISABLE
                + (UINT8)  am_hw_string_primitive.stamp_time()
                + (UINT8)  MCU_DSP_AUDIO_AS_DISABLE_WORD_LEN
                + (UINT16) AM_HW_DISABLE_ALL_AUDIO_SHAPING ;

            am_hw_string_primitive.send();
        }

        //Need to add companding for Multimedia Playback with the Stereo EMU headset.  Due to time constraints,
        //can't add it to flex, so hardcode for now.
        if (read_bit( info_ptr->instruction_mask, AM_I_MASK_STEREO_EMU_HS_MM_COMPAND))
        {
            //Filter Coeffs
            am_hw_string_primitive << ( AM_HW_MSG_HEADER_WORD_LEN
                + MCU_DSP_AUDIO_AS_FILTER_COEFFS_WORD_LEN );

            am_hw_string_primitive = am_hw_string_primitive
                + (UINT16) MCU_DSP_AUDIO_AS_FILTER_COEFFS
                + (UINT8)  am_hw_string_primitive.stamp_time()
                + (UINT8)  MCU_DSP_AUDIO_AS_FILTER_COEFFS_WORD_LEN
                + (UINT16) 0x0080 //Downlink AS HIFI
                + (UINT16) 0x0800 //Input Gain
                + (UINT16) 0x1000 //Output Gain
                + (UINT16) 0x0000 //IIR Biquad filter not used
                + (UINT16) 0x0000 //IIR Biquad filter not used
                + (UINT16) 0x0000 //IIR Biquad filter not used
                + (UINT16) 0x0000 //IIR Biquad filter not used
                + (UINT16) 0x0000 //IIR Biquad filter not used
                + (UINT16) 0x0000 //IIR Biquad filter not used
                + (UINT16) 0x0000 //IIR Biquad filter not used
                + (UINT16) 0x0000 //IIR Biquad filter not used
                + (UINT16) 0x0000 //IIR Biquad filter not used
                + (UINT16) 0x0000;//IIR Biquad filter not used

            am_hw_string_primitive.send ();

            //Compander Config
            am_hw_string_primitive << ( AM_HW_MSG_HEADER_WORD_LEN
                + MCU_DSP_AUDIO_AS_COMPANDER_CONFIG_WORD_LEN );

            am_hw_string_primitive = am_hw_string_primitive
                + (UINT16) MCU_DSP_AUDIO_AS_COMPANDER_CONFIG
                + (UINT8)  am_hw_string_primitive.stamp_time()
#if (MAKE_HDW_BB_IC == MAKE_HDW_NEPTUNE_LTS)
                + (UINT8)  AM_AS_HIFI_COMPANDER_CONFIG_WORD_LEN
#else
                + (UINT8)  MCU_DSP_AUDIO_AS_COMPANDER_CONFIG_WORD_LEN
#endif
                + (UINT16) 0x0080 //Downlink HIFI
                + (UINT16) stereo_EMU_multimedia_compand_beta_table[info_ptr->sampling_rate].beta1  //beta 1
                + (UINT16) stereo_EMU_multimedia_compand_beta_table[info_ptr->sampling_rate].beta2  //beta 2
                + (UINT16) 0x0001 //signal level 1
                + (UINT16) 0x2D6B //signal level 2
                + (UINT16) 0x2FF6 //signal level 3
                + (UINT16) 0x32A6 //signal level 4
                + (UINT16) 0x357D //signal level 5
                + (UINT16) 0x387D //signal level 6
                + (UINT16) 0x3BA7 //signal level 7
                + (UINT16) 0x3EFF //signal level 8
                + (UINT16) 0x4287 //signal level 9
                + (UINT16) 0x4642 //signal level 10
                + (UINT16) 0x4A32 //signal level 11
                + (UINT16) 0x4E5A //signal level 12
                + (UINT16) 0x52BE //signal level 13
                + (UINT16) 0x5762 //signal level 14
                + (UINT16) 0x5C48 //signal level 15
                + (UINT16) 0x6174 //signal level 16
                + (UINT16) 0x66EA //signal level 17
                + (UINT16) 0x6CAF //signal level 18
                + (UINT16) 0x72C6 //signal level 19
                + (UINT16) 0x7935 //signal level 20
                + (UINT16) 0x7FFF //gain value 1
                + (UINT16) 0x7FFF //gain value 2
                + (UINT16) 0x7A61 //gain value 3
                + (UINT16) 0x7501 //gain value 4
                + (UINT16) 0x6FDE //gain value 5
                + (UINT16) 0x6AF5 //gain value 6
                + (UINT16) 0x6642 //gain value 7
                + (UINT16) 0x61C5 //gain value 8
                + (UINT16) 0x5D7A //gain value 9
                + (UINT16) 0x595F //gain value 10
                + (UINT16) 0x5572 //gain value 11
                + (UINT16) 0x51B2 //gain value 12
                + (UINT16) 0x4E1B //gain value 13
                + (UINT16) 0x4AAD //gain value 14
                + (UINT16) 0x4766 //gain value 15
                + (UINT16) 0x4443 //gain value 16
                + (UINT16) 0x4144 //gain value 17
                + (UINT16) 0x3E66 //gain value 18
                + (UINT16) 0x3BA9 //gain value 19
                + (UINT16) 0x390A //gain value 20
                + (UINT16) stereo_EMU_multimedia_compand_beta_table[info_ptr->sampling_rate].beta3; //beta 3

             am_hw_string_primitive.send ();

            //AS Enable
            am_hw_string_primitive << ( AM_HW_MSG_HEADER_WORD_LEN
                                        + MCU_DSP_AUDIO_AS_ENABLE_WORD_LEN );

            am_hw_string_primitive = am_hw_string_primitive
                + (UINT16) MCU_DSP_AUDIO_AS_ENABLE
                + (UINT8)  am_hw_string_primitive.stamp_time()
                + (UINT8)  MCU_DSP_AUDIO_AS_ENABLE_WORD_LEN
                + (UINT16) 0x00C8; //DL HIFI, DL Output Gain, and DL Companding 

             am_hw_string_primitive.send ();
        }


        // MIDI is enabled, Haptics is enabled
        // Words 0, 1, 2, 3, 4 of the am_companding_midi_table will contain
        // Word 0: Control word for MCU_DSP_AUDIO_AS_FILTER_COEFFS message, 
        // Word 1: Control word for MCU_DSP_AUDIO_AS_FILTER_COEFFS message with Haptics disabled
        // Word 2: Control word for MCU_DSP_AUDIO_AS_COMPANDER_CONFIG message
        // Word 3: Control word for MCU_DSP_AUDIO_AS_ENABLE message
        // Word 4: Control word for MCU_DSP_AUDIO_AS_ENABLE message with Haptics disabled 
        // One of these four are used are at some point during MIDI companding.
        // The rest of the array with have the actual parameters
        // We want to send the companding parameters only if the gain is valid
        else if( read_bit( info_ptr->instruction_mask, AM_I_MASK_MIDI_COMPAND ))
        { 
            if ((am_companding_midi_table[0] != 0x0000)
            ||  (am_companding_midi_table[1] != 0x0000))
            {
                //Start by setting up output gain for audio shaper
                am_hw_string_primitive << ( AM_HW_MSG_HEADER_WORD_LEN
                    + MCU_DSP_AUDIO_AS_FILTER_COEFFS_WORD_LEN );

                am_hw_string_primitive = am_hw_string_primitive
                    + (UINT16) MCU_DSP_AUDIO_AS_FILTER_COEFFS
                    + (UINT8)  am_hw_string_primitive.stamp_time()
                    + (UINT8)  MCU_DSP_AUDIO_AS_FILTER_COEFFS_WORD_LEN;
            
                if (read_bit( info_ptr->instruction_mask, AM_I_MASK_HAPTICS_AS ))  
                {
                    am_hw_string_primitive = am_hw_string_primitive
                        + am_companding_midi_table[1]
                        // This is to ensure that if companding had been enabled for the
                        // corresponding signal before, we send the input and output gains
                        // co