am_event_handler_audio.cc

来自「Motorola synergy audio component」· CC 代码 · 共 1,295 行 · 第 1/3 页

    UINT8 clock_rate;
    
    if (rat_type == TD_RAT_GSM)
    {
        clock_rate = HAPI_CODEC_CLK_13M;
    }
    else if (rat_type == TD_RAT_UTRA)
    {
        clock_rate = HAPI_CODEC_CLK_15M;
    }
    am_event_logic_processor.set_clock_rate(clock_rate);
    am_event_logic_processor.update_audio ();
#endif
}

/* DESCRIPTION:
       This function receives the media open success from MME.

   INPUTS
       The pointer to the message from MME.

   OUTPUTS
       None.

   IMPORTANT NOTES
       None
*/  
void
AM_Event_Handler::handle_aud_media_open_success(void *msg)
{
 
    DL_MMSP_MEDIA_OPEN_SUCCESS_DATA_T* local_msg = (DL_MMSP_MEDIA_OPEN_SUCCESS_DATA_T*)msg;
    MMSS_MEDIA_HANDLE_T media_handle = local_msg->media_handle;
    Tone_Item *current = eventqueuehandler.FindbyMediaSeq(local_msg->iface_data.seq_number);
    TD_AUD_TONE_UNION_T pending_media_tone_type = {media_tone_type};
    BOOL media_alert = !(pending_media_tone_type.fields.pwrup || pending_media_tone_type.fields.send_dl_msg);
    BOOL media_state_change = TRUE;
    MMSS_MEDIA_USAGE_T media_usage = MMSS_MEDIA_USAGE_MMA;

    AUD_MEDIA_TONE_IND_T  dl_msg;
    BOOL attr_value = TRUE;
 

    if ((pending_media_tone_type.type == DL_AUDIO_TONE_TYPE_INVALID_TONE) && (current != NULL))
    {
        media_alert = !(current->ToneEvent.fields.pwrup || current->ToneEvent.fields.send_dl_msg);
    }

    if ( (isVibAlert(pending_media_tone_type.fields.id)) ||  
         ((current != NULL) && (isVibAlert(current->ToneEvent.fields.id))) )
    {
        media_usage = MMSS_MEDIA_USAGE_MFT_VIB;
    }
    else
    if (pending_media_tone_type.fields.pwrup)
    {
        media_usage = MMSS_MEDIA_USAGE_PUPD;
    }
    else
    if (media_alert)
    {
        media_usage = MMSS_MEDIA_USAGE_ALERT;
    }

    DL_MMSP_Playback_MediaSetAttribute((MMSS_MEDIA_HANDLE_T)(media_handle),
                                       MMSS_MEDIA_USAGE,
                                       &media_usage);
    //subscribing for state_change notification from mme
    DL_MMSP_Playback_MediaSetAttribute((MMSS_MEDIA_HANDLE_T)(media_handle),
				       MMSS_MEDIA_STATE_CHANGE,
				       (void*)&media_state_change);
    /* libhh43622: Subscribe to Stop Complete, so that AM restarts MME only after
       receiving STOP_CMPL from MME. */ 
    DL_MMSP_Playback_MediaSetAttribute(media_handle, MMSS_SUBSCRIBE_STOP_COMPLETE, &attr_value);
    
    if ((media_vibrate_type != DL_AUDIO_TONE_TYPE_INVALID_TONE) && (media_alert == TRUE))
    {
        DL_MMSP_Playback_MediaSetAttribute((MMSS_MEDIA_HANDLE_T)(media_handle),
                                       MMSS_MEDIA_VIB_TYPE,
                                       &media_vibrate_type);
        media_vibrate_type = DL_AUDIO_TONE_TYPE_INVALID_TONE;
    }

    dl_msg.media_handle = media_handle;
    dl_msg.seq_num = current->SequenceID;
    
    if ( beat_to_mme != 0xFFFF )
    {
        DL_MMSP_Playback_MediaSetAttribute((MMSS_MEDIA_HANDLE_T)(media_handle),
                                       MMSS_MEDIA_IMELODY_BEAT,
                                       &beat_to_mme);
        beat_to_mme = 0xFFFF;
    }
 
    if (current == NULL) 
    {
        DL_MMSP_Playback_MediaSetAttribute((MMSS_MEDIA_HANDLE_T)(media_handle),
                                                MMSS_MEDIA_VOLUME,
                                                &media_tone_vol);
    }
    else
    {
        DL_MMSP_Playback_MediaSetAttribute((MMSS_MEDIA_HANDLE_T)(media_handle),
                                                MMSS_MEDIA_VOLUME,
                                                &(current->VolumeStep));
    }    

    if (current && current->ToneEvent.fields.send_dl_msg == 1)
    {
        /* Send open success msg to dl */
        dl_msg.status = AUD_MEDIA_OPEN_SUCCESS;
        dl_msg.msg_value = 0;
                
        aud_dl_aud_cnf(AUD_MEDIA_TONE_IND, &dl_msg, sizeof(AUD_MEDIA_TONE_IND_T));
    }
    else if (pending_media_tone_type.type != DL_AUDIO_TONE_TYPE_INVALID_TONE &&
             pending_media_tone_type.fields.send_dl_msg == 1)
    {
        /* Send open success msg to dl */
        AUD_MEDIA_TONE_IND_T dl_msg = {AUD_MEDIA_OPEN_SUCCESS, media_handle, media_tone_seq, NULL};
        
        aud_dl_aud_cnf(AUD_MEDIA_TONE_IND, &dl_msg, sizeof(AUD_MEDIA_TONE_IND_T));
    }
    else 
    {
#if  (MAKE_OMA_DRM_SUPPORT == TRUE) 
        /*  Consme rights object for OMADRM file and unlock it  */
        MMSS_OMA_DRM_RIGHTS_REQ_T  rights_req = {DL_FS_DRM_ACTION_PLAY, TRUE, FALSE };
                                                   
        DL_MMSP_Playback_MediaSetAttribute(media_handle, MMSS_OMA_DRM_RIGHTS_REQ, &rights_req);
                       
        if(DL_MMSP_Playback_MediaStart(media_handle) == MMSS_OMA_DRM_FAIL)
        {    
            dl_msg.status = AUD_MEDIA_START_ERROR;
            dl_msg.msg_value = MMSS_OMA_DRM_INVALID_RIGHTS;
            
            aud_dl_aud_cnf(AUD_MEDIA_TONE_IND, &dl_msg, sizeof(AUD_MEDIA_TONE_IND_T));        
        }
#else
        
        DL_MMSP_Playback_MediaStart(media_handle);
#endif        


        /* set the media handle only if flip is closed */
        if (off_hook_flag_glb == 0)
        {
           mp3_ringer_media_handle_glb = media_handle;
        }
    }
    media_tone_type = DL_AUDIO_TONE_TYPE_INVALID_TONE;
    media_tone_seq = INVALID_SEQ_NUMBER;
    media_tone_vol = INVALID_VOLUME_STEP;
    media_vibrate_type = DL_AUDIO_TONE_TYPE_INVALID_TONE;

}

/* DESCRIPTION:
       This function receives the media started from MME.

   INPUTS
       The pointer to the message from MME.

   OUTPUTS
       None.

   IMPORTANT NOTES
       None
*/ 
void
AM_Event_Handler::handle_aud_media_started(void *msg)
{
    DL_MMSP_MEDIA_CAPTURE_STARTED_DATA_T* local_msg = (DL_MMSP_MEDIA_CAPTURE_STARTED_DATA_T*)msg;
    UINT32              seq_id = INVALID_SEQ_NUMBER;
    TD_AUD_TONE_UNION_T tone = {0};
    Tone_Item *current = eventqueuehandler.FindbyMediaSeq(local_msg->iface_data.seq_number);
    

    if (current)
    {
        seq_id = current->SequenceID;
        tone = current->ToneEvent;
    }
    
    /* If send_dl_msg flag set send started status to dl */
    if(tone.fields.send_dl_msg == 1)
    {
        AUD_MEDIA_TONE_IND_T dl_msg = {AUD_MEDIA_STARTED, local_msg->media_handle, seq_id, 0};
        /* Send error msg to dl */
        aud_dl_aud_cnf(AUD_MEDIA_TONE_IND, &dl_msg, sizeof(AUD_MEDIA_TONE_IND_T));
    }
}

/* DESCRIPTION:
       This function receives the media open failure from MME.

   INPUTS
       The pointer to the message from MME.

   OUTPUTS
       None.

   IMPORTANT NOTES
       None
*/ 
void
AM_Event_Handler::handle_aud_media_open_failure(void *msg)
{
    DL_MMSP_MEDIA_OPEN_FAILED_DATA_T* local_msg = (DL_MMSP_MEDIA_OPEN_FAILED_DATA_T*)msg;
    TD_AUD_MEDIA_INFO_T media_info = {local_msg->media_handle, local_msg->iface_data.seq_number};
    UINT32              seq_id = INVALID_SEQ_NUMBER;
    TD_AUD_TONE_UNION_T tone = {0};
    Tone_Item *current = eventqueuehandler.FindbyMediaSeq(media_info.seq);
    
    if (current)
    {
        am_event_logic_processor.generate_tone(current->ToneEvent, AUD_TONE_STOP, current->SequenceID,
                                               INVALID_VOLUME_STEP, DL_AUDIO_TONE_TYPE_INVALID_TONE,
                                                   FALSE, media_info, AM_SAMPLING_RATE_08_00);
        seq_id = current->SequenceID;
        tone = current->ToneEvent;
    }
    
    /* If send_dl_msg flag set send error status to dl */
    if(tone.fields.send_dl_msg == 1)
    {
        AUD_MEDIA_TONE_IND_T dl_msg = {AUD_MEDIA_ERROR, local_msg->media_handle, seq_id, local_msg->media_error};

        /* Send error msg to dl */
        aud_dl_aud_cnf(AUD_MEDIA_TONE_IND, &dl_msg, sizeof(AUD_MEDIA_TONE_IND_T));
    }
}

/* DESCRIPTION:
       This function receives the state change message from MME.

   INPUTS
       The pointer to the message from MME.

   OUTPUTS
       None.

   IMPORTANT NOTES
       None
*/

void
AM_Event_Handler::handle_aud_media_state_change(void *msg)
{
   DL_MMSP_MEDIA_STATE_DATA_T *media_state = (DL_MMSP_MEDIA_STATE_DATA_T *) msg;  
   MMSS_RETURN_STATUS_T media_status = MMSS_NO_ERROR;
   MMSS_MEDIA_HANDLE_T mHandle = media_state->media_handle;

   Tone_Item * front = eventqueuehandler.GetCurrent ();

   if((front->MediaInfo).handle == mHandle && media_state->media_state == MMSS_MEDIA_STATE_FORCED_PAUSE)
   {
       DL_MMSP_Playback_MediaClose(mHandle);
   }

}

/* DESCRIPTION:
       This function receives the media complete from MME.

   INPUTS
       The pointer to the message from MME.

   OUTPUTS
       None.

   IMPORTANT NOTES
       None
*/ 
void
AM_Event_Handler::handle_aud_media_complete(void *msg)
{
    DL_MMSP_MEDIA_COMPLETE_DATA_T* local_msg = (DL_MMSP_MEDIA_COMPLETE_DATA_T*)msg;
    TD_AUD_MEDIA_INFO_T  media_info = {local_msg->media_handle, local_msg->iface_data.seq_number};
    Tone_Item           *current = eventqueuehandler.FindbyMediaSeq(media_info.seq);

    if (current)
    {
        TD_AUD_TONE_UNION_T  tone = current->ToneEvent;

        /* check if we need to repeat the media, e.g. for ringer */
        if (tone.fields.one_shot == 0)
        {
            DL_MMSP_Playback_MediaStart(local_msg->media_handle);
        }
        /* If send_dl_msg flag clear close the media else only send compleate status to dl */
        else if (tone.fields.send_dl_msg == 0)
        {
            am_event_logic_processor.generate_tone(current->ToneEvent, AUD_TONE_STOP, current->SequenceID,
                                                   INVALID_VOLUME_STEP, DL_AUDIO_TONE_TYPE_INVALID_TONE,
                                                   FALSE, media_info, AM_SAMPLING_RATE_08_00);
        }
        else
        {
            /* Send media complete msg to dl */
            AUD_MEDIA_TONE_IND_T dl_msg = {AUD_MEDIA_COMPLETE, local_msg->media_handle, current->SequenceID, 0};

            aud_dl_aud_cnf(AUD_MEDIA_TONE_IND, &dl_msg, sizeof(AUD_MEDIA_TONE_IND_T));
        }
    }
}


/* DESCRIPTION:
       Function to handle turning on Echo Cancellation, Noise Supression and
       Entertainment mute for Telematics and Bluetooth Handsfree. This is done 
       through couple of test commands sent down to the Device Layer which lets 
       AM to set these parameters

  INPUTS:
       void *msg

  OUTPUTS:
       none

  IMPORTANT NOTES:
       none
*/
void
AM_Event_Handler::handle_aud_dynamic_echo_noise_on_req(void *msg)
{
    DL_ACC_ATTRIBUTE_T attribute = *((DL_ACC_ATTRIBUTE_T*)msg); 
    
    switch(attribute)
    { 
    case DL_ACC_ECHO_CANCELATION:
        echo_control = TRUE;
        break;
    case DL_ACC_NOISE_SUPPRESSION:
        noise_sup = TRUE;
        break;  
    default:
        break;
    }
    am_event_logic_processor.update_audio();
}   

/* DESCRIPTION:
       Function to handle turning off Echo Cancellation, Noise Supression and 
       Entertainment mute for Telematics and bluetooth handsfree. 

  INPUTS:
       void *msg

  OUTPUTS:
       none

  IMPORTANT NOTES:
       none
*/
void
AM_Event_Handler::handle_aud_dynamic_echo_noise_off_req(void *msg)
{
    DL_ACC_ATTRIBUTE_T attribute = *((DL_ACC_ATTRIBUTE_T*)msg); 
    
    switch(attribute)
    { 
    case DL_ACC_ECHO_CANCELATION:
        echo_control = FALSE;
        break;
    case DL_ACC_NOISE_SUPPRESSION:
        noise_sup = FALSE;
        break;  
    default:
        break;
    }
    am_event_logic_processor.update_audio();
}

/* DESCRIPTION:
       Function to handle turning off Noise Supression for an AMR voice call 
       when the network needs it 

  INPUTS:
       void *msg

  OUTPUTS:
       none

  IMPORTANT NOTES:
       none
*/
void
AM_Event_Handler::handle_aud_amr_allow_ns_req(void *msg)
{
    am_allow_ns = *(BOOL *)msg;
    am_event_logic_processor.update_audio();
}  

/* DESCRIPTION:
       Function to "kick" the Audio Manager when settings change

  INPUTS:
       void 

  OUTPUTS:
       none

  IMPORTANT NOTES:
       none
*/
void 
AM_Event_Handler::handle_aud_setting_change_ind(void *msg)
{
    am_event_logic_processor.update_audio();    
}

/* DESCRIPTION:
       Function to handle Haptics ON/OFF settings

  INPUTS:
       void 

  OUTPUTS:
       none

  IMPORTANT NOTES:
       The actual reading of the feature database would be done
       right before turning on or off the instruction mask
*/
void 
AM_Event_Handler::handle_aud_haptics_setting_change_ind(void *msg)
{
    am_event_logic_processor.update_audio();    
}