aud_interface.c

Motorola synergy audio component

    UINT16 t_array[3];

    AUDSCM_SDSR_COMPLETE_IND * msgptr = NULL;
    msgptr =  suCreateMessage((UINT32)sizeof(AUDSCM_SDSR_COMPLETE_IND), 
                                                  (UINT32)DSP_MCU_VR_SD_RECOGNIZE_COMPLETE, SU_INVALID_HANDLE, NULL);

#if (AUDIO_CDMA == TRUE)
    L1_MODEM_API_QUEUE_read_vr_buff(DSP_MCU_AUDIO_DATA, t_array, 3, 0);
#endif
    msgptr->error_code = t_array[0];
    msgptr->header.id = 0;
    if( ( t_array[2] == 0xFF) || (t_array[2] == 0xFE))
    {
        msgptr->header.stamp_n_length = 2;
    }
    else
    {
        msgptr->header.stamp_n_length = 3;
    }
    msgptr->word_array[0] = t_array[1];
    msgptr->word_array[1] = t_array[2];
    AM_SendMessage((char *) msgptr);


}
#endif


#if (MAKE_FTR_VA == TRUE)
/*=========================Interface for Interrupt routines==============*/

void aud_scm_va_record_ind(UINT8 error_code, UINT8 warning_code )
{
    AUDSCM_VA_RECORD_COMPLETE_IND   * msgptr = NULL;
    msgptr =  suCreateMessage((UINT32)sizeof(AUDSCM_VA_RECORD_COMPLETE_IND), 
                                                  (UINT32)AUDSCM_VA_RECORD_COMPLETE_IND_ID, SU_INVALID_HANDLE, NULL);
    msgptr->warning_code = warning_code;
    msgptr->error_code   = error_code;
    AM_SendMessage((char *) msgptr);
}

void aud_scm_va_playback_ind(UINT16 error_code)
{
    AUDSCM_VA_PLAYBACK_COMPLETE_IND  * msgptr = NULL;
    msgptr =  suCreateMessage((UINT32)sizeof(AUDSCM_VA_PLAYBACK_COMPLETE_IND), 
                                                  (UINT32)AUDSCM_VA_PLAYBACK_COMPLETE_IND_ID, SU_INVALID_HANDLE, NULL);
    msgptr->error_code = error_code;
    AM_SendMessage((char *) msgptr);
}




void aud_scm_va_time_remaining( UINT16 error_code, UINT16 time)
{
    AUDSCM_VA_TIME_REMAINING_IND  * msgptr = NULL;
    msgptr =  suCreateMessage((UINT32)sizeof(AUDSCM_VA_TIME_REMAINING_IND), 
                              (UINT32)AUDSCM_VA_TIME_REMAINING_IND_ID, SU_INVALID_HANDLE, NULL);
    msgptr->error_code = error_code;
    msgptr->time = time;   
    AM_SendMessage((char *) msgptr);
}

void aud_scm_va_erase_ind( UINT16 error_code)
{    
    AUDSCM_VA_ERASE_COMPLETE_IND  * msgptr = NULL;
    msgptr =  suCreateMessage((UINT32)sizeof(AUDSCM_VA_ERASE_COMPLETE_IND), 
                              (UINT32)AUDSCM_VA_ERASE_COMPLETE_IND_ID, SU_INVALID_HANDLE, NULL);
    msgptr->error_code = error_code;
    AM_SendMessage((char *) msgptr);
}
#endif

#if ( (MAKE_FTR_VR == TRUE) || (MAKE_FTR_VA == TRUE) )
/*============================================================================================
   For Digital Voice Annotator or Hardware Speaker Dependent VR 
============================================================================================*/
void aud_reformat_flash_req()
{
    void * msgptr = NULL;
    msgptr =  suCreateMessage((UINT32)0, (UINT32)AUD_REFORMAT_FLASH_REQ_ID, SU_INVALID_HANDLE, NULL);
    AM_SendMessage((char *) msgptr);
}
#endif


SU_PORT_HANDLE aud_get_aud_mgr_task_port_handle()
{
    return am_server_task_port;
}

/*============================================================================================
   For Power Up/Down Interface
============================================================================================*/
void aud_suspend(UINT16 reserved, UINT16 reserved2, UINT16 reserved3)
{
    void * msgptr = NULL;
    msgptr =  suCreateMessage((UINT32)0, (UINT32)AUDIO_SUSPEND_REQ_ID, SU_INVALID_HANDLE, NULL);
    AM_SendMessage((char *) msgptr);
}

void aud_unsuspend(UINT16 no_cnf, UINT16 reserved2, UINT16 reserved3)
{
    AUD_UNSUSPEND_REQ * msgptr = NULL;
    msgptr = suCreateMessage((UINT32)sizeof(AUD_UNSUSPEND_REQ), (UINT32)AUDIO_UNSUSPEND_REQ_ID,
                              SU_INVALID_HANDLE, NULL);
    msgptr->no_cnf = no_cnf;
    AM_SendMessage((char *) msgptr);
}

void aud_powerdown(UINT16 reserved, UINT16 reserved2, UINT16 reserved3)
{
    void * msgptr = NULL;
    msgptr =  suCreateMessage((UINT32)0, (UINT32)AUDIO_DEACTIVATE_REQ_ID, SU_INVALID_HANDLE, NULL);
    AM_SendMessage((char *) msgptr);
}

BOOL am_status()
{
    if (am_suspend == TRUE)
    {
        return TRUE;
    }
    else
    {
        return FALSE;
    }
}

/*============================================================================================
   Loopback test mode         
============================================================================================*/

void aud_ctia_mode_req(BOOL enable, UINT8 mode)
{
    AUD_CTIA_MODE_REQ * msgptr = NULL;
    msgptr =  (AUD_CTIA_MODE_REQ*) suCreateMessage((UINT32)0, (UINT32)AUD_CTIA_MODE_REQ_ID, 
                                                   SU_INVALID_HANDLE, NULL);

    msgptr->enabled = enable;
    msgptr->mode = mode;

    AM_SendMessage((char*) msgptr);
}

#if ((AUDIO_GSM == TRUE) || (AUDIO_TDMA == TRUE))
UINT8 audio_dai_mode_get(void)
{
    UINT8 mode;

    switch (audio_dai_mode)
    {
        case DL_AUDIO_TONE_TYPE_DAI_ANALOG_UPLINK:
            mode = AUDIO_DAI_MODE_ANALOG_UPLINK;
            break;

        case DL_AUDIO_TONE_TYPE_DAI_ANALOG_DOWNLINK:
            mode = AUDIO_DAI_MODE_ANALOG_DOWNLINK;
            break;

        case DL_AUDIO_TONE_TYPE_DAI_DIGITAL_UPLINK:
            mode = AUDIO_DAI_MODE_DIGITAL_UPLINK;
            break;

        case DL_AUDIO_TONE_TYPE_DAI_DIGITAL_DOWNLINK:
            mode = AUDIO_DAI_MODE_DIGITAL_DOWNLINK;
            break;

        default :
        case DL_AUDIO_TONE_TYPE_DAI_NORMAL:
            mode = AUDIO_DAI_MODE_NORMAL;
            break;
    }
    return mode;
}
#endif

#if (MAKE_FTR_VR == TRUE)
BOOL aud_is_vr_active(void)
{
    return is_vr_active;
}

/*********************************************************************
 This routine will abort VR.  If blocking==TRUE, it will return when VR is stopped.  
 Otherwise, it will return immediately and stop VR in the background.
 *********************************************************************/

void aud_sdvr_abort_vr(BOOL blocking)
{
   char data[2];
   am_send_log_data(0x80666, data, 1);
   if(blocking == TRUE)
   {
      aud_sdvr_abort_immediate();
   }
   else
   {
      void * msgptr = NULL;
      msgptr =  suCreateMessage((UINT32)0, (UINT32)AUD_ABORT_ALL_VR_ID, SU_INVALID_HANDLE, NULL);
      AM_SendMessage((char *) msgptr);
   }
   am_send_log_data(0x81666, data, 1);
   return;
}
#endif


/* The following routines notify the audio manager about the status of the volume app */
/* If it is active, we shouldn't mute the voice. */

void aud_volume_app_active(BOOL active)
{
    if( active != is_volume_app_active)
    {
        /* set the flag */
        is_volume_app_active = active;
    
        /* Update the audio settings */
        aud_tone_req ( AUD_TONE_UPDATE,
                       DL_AUDIO_TONE_TYPE_INVALID_TONE,
                       INVALID_SEQ_NUMBER,
                       DL_AUDIO_VOLUME_SETTING_CURRENT );
    }
}

BOOL aud_is_volume_app_active (void)
{ 
    return is_volume_app_active;
}


/*==================================================================================================
  VST VR FUNCTIONS
==================================================================================================*/

/*==================================================================================================
FUNCTION: aud_stop_vr_audio_capture_req

DESCRIPTION:
Stops a currently active audio capture session.  If session has already completed, the confirmation
is sent immediately.


ARGUMENTS PASSED:
   None

RETURN VALUE:
   None

PRE-CONDITIONS:
   None

POST-CONDITIONS:
   Return Message to VR SP: AUD_STOP_AUDIO_CAPTURE_CNF_ID when the capture session has been stopped

IMPORTANT NOTES:
   None
==================================================================================================*/
void aud_stop_vr_audio_capture_req(void)
{
    SU_PORT_HANDLE dest_phandle = (SU_PORT_HANDLE)suFindName(DL_PORT_NAME_MEDIA_VR_SP,
                                                             SU_WAIT_FOREVER,
                                                             NULL);

    if ( audVstParams.abort_activity == TRUE )
    {
        void * msg;
        msg =  suCreateMessage((UINT32)0, AM_VR_UNAVAILABLE_IND, SU_INVALID_HANDLE, NULL);
        suSendMessage(msg, dest_phandle, NULL);
    }
    else if ( audVstParams.activity == AUD_VST_IDLE )
    {
        AUD_STOP_AUDIO_CAPTURE_CNF_T* msgptr;
        /* Confirm the completion of the action to VST */
        msgptr = (AUD_STOP_AUDIO_CAPTURE_CNF_T*) suCreateMessage((UINT32)sizeof(AUD_STOP_AUDIO_CAPTURE_CNF_T),
                                                                 (UINT32)AUD_STOP_AUDIO_CAPTURE_CNF_ID,
                                                                 SU_INVALID_HANDLE,
                                                                 NULL);
        msgptr->status_code = DL_MEDIA_OK;
        /* send message */
        suSendMessage(msgptr, dest_phandle, NULL);
    }
    else
    {
    audVstParams.activity = AUD_VST_STOP_CAPTURE;

    aud_va_command_req(TD_VA_COMMAND_STOP_RECORD,
                       DL_MEDIA_VA_MESSAGE_INVALID,
                       DL_MEDIA_VA_INVALID_GROUP);
}
}

/*==================================================================================================
FUNCTION:  aud_start_vr_audio_capture_req

DESCRIPTION:
Requests the audio manager to setup the DSP and start acquiring PCM and vocoded data from the DSP
to be sent up the the VST VR SP in the device layer for VR functionality.

ARGUMENTS PASSED:
    UINT16 frame_num - number of frames in the audio capture session
    BOOL play_tone - whether a tone should be played out before starting the capture session

    Note that these input parameters are not currently used as the tone is always originated by
    the application and the frame count for audio timeout is being kept in the device layer.

RETURN VALUE:
   None

PRE-CONDITIONS:
   None

POST-CONDITIONS:
   Return Message to VR SP: AUD_START_AUDIO_CAPTURE_CNF_ID when the capture session has started

IMPORTANT NOTES:
   None
==================================================================================================*/
void aud_start_vr_audio_capture_req (UINT16 frame_num, BOOL play_tone)
{
    if ( audVstParams.abort_activity == TRUE )
    {
        SU_PORT_HANDLE dest_phandle = (SU_PORT_HANDLE)suFindName(DL_PORT_NAME_MEDIA_VR_SP,
                                                                 SU_WAIT_FOREVER,
                                                                 NULL);
        void* msgptr;

        msgptr =  suCreateMessage((UINT32)0, AM_VR_UNAVAILABLE_IND, SU_INVALID_HANDLE, NULL);
        suSendMessage(msgptr, dest_phandle, NULL);
    }
    else
    {
    audVstParams.activity = AUD_VST_CAPTURE_AUDIO;
    audVstParams.frame_num = frame_num;
    audVstParams.play_tone = play_tone;
    audVstParams.frame_count = 0;

    aud_va_command_req(TD_VA_COMMAND_START_RECORD,
                       DL_MEDIA_VA_MESSAGE_INVALID,
                       DL_MEDIA_VA_INVALID_GROUP);
}
}

/*==================================================================================================
FUNCTION: aud_play_audio_from_flash_req

DESCRIPTION:
Opens the audio file described by the input filename, copies it to a RAM buffer and then calls the
audio manager to play the data out of the speaker.