jma_audio_recorder.c

java 1.1 gemini 08_16

 *  This function submit Record request to media task.
 * PARAMETERS
 *  mma_type            [IN]        Int recorder
 *  java_recorder       [IN]        
 * RETURNS
 *  int - 0
 *****************************************************************************/
kal_bool jma_audio_recorder_start_record(kal_int32 java_recorder)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    mdi_result ret = MDI_AUDIO_FAIL;
    
    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    kal_trace(TRACE_GROUP_4, FUNC_J2ME_JMA_AUDIO_RECORDER_START_RECORD, java_recorder, audio_recorder.state);
    JMA_CS_ENTER(KAL_FALSE);

    if (audio_recorder.id != java_recorder)
    {
        kal_trace(TRACE_GROUP_4, INFO_J2ME_MMA_RESOURCE_ERROR, audio_recorder.id);
        JMA_CS_LEAVE(KAL_FALSE);
    }

    if (audio_recorder.state == JAVA_MEDIA_STATE_READY)
    {
        ret = mdi_audio_start_record(audio_recorder.filename, audio_recorder.format, 0, NULL, 
            jma_audio_recorder_record_result_hdlr);                
    }
    else if (audio_recorder.state == JAVA_MEDIA_STATE_PAUSED)
    {
        ret = mdi_audio_resume(NULL, jma_audio_recorder_record_result_hdlr);
    }

    /* Handle result */
    if (ret == MDI_AUDIO_SUCCESS)
    {
        kal_trace(TRACE_GROUP_4, J2ME_MMA_STATE_TRANSITION, audio_recorder.state, JAVA_MEDIA_STATE_RECORDING);
        audio_recorder.state = JAVA_MEDIA_STATE_RECORDING;
        JMA_CS_LEAVE(KAL_TRUE);
    }
    else
    {
        kal_trace(TRACE_GROUP_4, INFO_J2ME_MMA_MARKER_FAIL);
        kal_trace(TRACE_GROUP_4, INFO_J2ME_MMA_D, ret);
        JMA_CS_LEAVE(KAL_FALSE);
    }
}


/*****************************************************************************
 * FUNCTION
 *  jma_audio_recorder_stop_record
 * DESCRIPTION
 *  This function submit stop request to media task.
 * PARAMETERS
 *  mma_type            [IN]        Int recorder
 *  java_recorder       [IN]        
 * RETURNS
 *  int - 0
 *****************************************************************************/
kal_bool jma_audio_recorder_pause_record(kal_int32 java_recorder)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    mdi_result ret;
  
    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    kal_trace(TRACE_GROUP_4, FUNC_J2ME_JMA_AUDIO_RECORDER_PAUSE_RECORD, java_recorder, audio_recorder.state);
    JMA_CS_ENTER(KAL_FALSE);

    if (audio_recorder.id != java_recorder)
    {
        kal_trace(TRACE_GROUP_4, INFO_J2ME_MMA_RESOURCE_ERROR, audio_recorder.id);
        JMA_CS_LEAVE(KAL_FALSE);
    }

    if (audio_recorder.state == JAVA_MEDIA_STATE_RECORDING)
    {
        ret = mdi_audio_pause(NULL, jma_audio_recorder_record_result_hdlr);

        if (ret == MDI_AUDIO_SUCCESS)
        {
            kal_trace(TRACE_GROUP_4, J2ME_MMA_STATE_TRANSITION, audio_recorder.state, JAVA_MEDIA_STATE_PAUSED);
            audio_recorder.state = JAVA_MEDIA_STATE_PAUSED;

        #ifdef __MTK_TARGET__
            audio_recorder.current_time = (long)Media_GetRecordedTime();
            kal_trace(TRACE_GROUP_4, INFO_J2ME_MMA_D, audio_recorder.current_time);
        #endif
        }
        else
        {
            kal_trace(TRACE_GROUP_4, INFO_J2ME_MMA_MARKER_FAIL);
            kal_trace(TRACE_GROUP_4, INFO_J2ME_MMA_D, ret);
        }
        JMA_CS_LEAVE(KAL_TRUE);
    }

    JMA_CS_LEAVE(KAL_TRUE);
}


/*****************************************************************************
 * FUNCTION
 *  jma_audio_recorder_set_record_location
 * DESCRIPTION
 *  The function sets record location
 * PARAMETERS
 *  mma_type          [IN]        
 *  java_recorder       [IN]
 *  path          [?] 
 * RETURNS
 *  int - 0
 *****************************************************************************/
kal_bool jma_audio_recorder_set_record_location(kal_int32 java_recorder, kal_char *path)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    kal_int32 file_handle;
    kal_int32 result, length;
    kal_wchar *ext_name;
    kal_char *file_name;
    
    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    kal_trace(TRACE_GROUP_4, FUNC_J2ME_JMA_AUDIO_RECORDER_SET_RECORD_LOCATION, java_recorder, audio_recorder.state);
    JMA_CS_ENTER(KAL_FALSE);

    if (audio_recorder.id != java_recorder)
    {
        kal_trace(TRACE_GROUP_4, INFO_J2ME_MMA_RESOURCE_ERROR, audio_recorder.id);
        JMA_CS_LEAVE(KAL_FALSE);
    }
    
    mmi_ucs2ncpy((PS8) audio_recorder.filename, (PS8) path, J2ME_PATH_BUFFER_SIZE);
    
    length = mmi_ucs2strlen((S8*) audio_recorder.filename);
    if (length < 4)
    {
        JMA_CS_LEAVE(KAL_FALSE);
    }

    /* assign format */
    ext_name = &audio_recorder.filename[length - 4];
    if (kal_wstrcmp(ext_name, L".amr") == 0 || kal_wstrcmp(ext_name, L".AMR") == 0)
    {
        audio_recorder.format = MED_TYPE_AMR;
    }
    else if (kal_wstrcmp(ext_name, L".wav") == 0 || kal_wstrcmp(ext_name, L".WAV") == 0)
    {
        audio_recorder.format = MED_TYPE_WAV;
    }
#if defined (AMRWB_ENCODE)   
    else if (kal_wstrcmp(ext_name, L".awb") == 0 || kal_wstrcmp(ext_name, L".AWB") == 0)
    {
        audio_recorder.format = MED_TYPE_AMR_WB;
    }
#endif    
    else
    {
        kal_trace(TRACE_GROUP_4, INFO_J2ME_MMA_MARKER_FAIL);
        JMA_CS_LEAVE(KAL_FALSE);
    }

    kal_trace(TRACE_GROUP_4, INFO_J2ME_MMA_D, audio_recorder.format);
    /* Check if valid file path and delete the file */
    result = FS_GetDevStatus(audio_recorder.filename[0], FS_MOUNT_STATE_ENUM);
    if (result == FS_NO_ERROR) 
    {
        /* Check if valid file name */
        file_name = kal_dchar_strrchr((S8*) audio_recorder.filename, '\\');

        if (file_name)
        {
            file_name += 2;
            if (!mmi_fmgr_is_filename_valid(file_name))
            {
                kal_trace(TRACE_GROUP_4, INFO_J2ME_MMA_MARKER_FAIL);
                JMA_CS_LEAVE(KAL_FALSE);
            }               
        }
        else /* Do not file '\\' */
        {
            kal_trace(TRACE_GROUP_4, INFO_J2ME_MMA_MARKER_FAIL);
            JMA_CS_LEAVE(KAL_FALSE);
        }        

        /* Check if dir exist or if valid dir */
        *file_name = '\0';
        file_handle = FS_Open(audio_recorder.filename, FS_OPEN_DIR | FS_READ_ONLY);            
        if (file_handle > 0)
        {
           FS_Close(file_handle);
        }
        else
        {
           kal_trace(TRACE_GROUP_4, INFO_J2ME_MMA_MARKER_FAIL);
           JMA_CS_LEAVE(KAL_FALSE);
        }
 
        /* Copy again to repair audio_recorder.filename */
        mmi_ucs2ncpy((PS8) audio_recorder.filename, (PS8) path, J2ME_PATH_BUFFER_SIZE);
        
        /* Check if file exist */
        file_handle = FS_Open(audio_recorder.filename, FS_READ_ONLY);
        if (file_handle > 0) 
        {
            result = FS_Close(file_handle); /* need to close file before delete */
            result = FS_Delete(audio_recorder.filename);
            if (result != FS_NO_ERROR)
            {
                kal_trace(TRACE_GROUP_4, INFO_J2ME_MMA_D, result);
                JMA_CS_LEAVE(KAL_FALSE);
            }
        }

        JMA_CS_LEAVE(KAL_TRUE);
    }
    else
    {
       kal_trace(TRACE_GROUP_4, INFO_J2ME_MMA_MARKER_FAIL);
       kal_trace(TRACE_GROUP_4, INFO_J2ME_MMA_D, result);
       JMA_CS_LEAVE(KAL_FALSE);
    }

}


/*****************************************************************************
 * FUNCTION
 *  jma_audio_recorder_set_record_size_limit
 * DESCRIPTION
 *  This function set the size limit of recorded data
 * PARAMETERS
 *  mma_type            [IN]        Int recorder
 *  java_recorder       [IN]        
 *  limit_size          [IN]        
 * RETURNS
 *  int - limit_size set
 *****************************************************************************/
kal_int32 jma_audio_recorder_set_record_size_limit(kal_int32 java_recorder, kal_int32 limit_size)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    /* Use timer to limit record size */
    /* For example, 8K, 16bits, mono channel means record size == 8000*16*1/sizeof(char) bytes */
    kal_int32 samplesize_per_ms = 8000 * 16 * 1 / sizeof(kal_uint8) / 1000;
    kal_int32 limit_ms = limit_size / samplesize_per_ms;
    kal_int32 limit_ticks = kal_milli_secs_to_ticks(limit_ms);
    kal_int32 saved_size;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    kal_trace(TRACE_GROUP_4, FUNC_J2ME_JMA_AUDIO_RECORDER_SET_RECORD_SIZE_LIMIT, java_recorder, limit_size);
    JMA_CS_ENTER(0);

    if (audio_recorder.id != java_recorder)
    {
        kal_trace(TRACE_GROUP_4, INFO_J2ME_MMA_RESOURCE_ERROR, audio_recorder.id);
        JMA_CS_LEAVE(0);
    }


    saved_size = aud_context_p->offset;

    kal_trace(TRACE_GROUP_4, INFO_J2ME_MMA_D, saved_size);


    if (limit_ticks && (limit_size > saved_size))
    {
        stack_stop_timer(audio_recorder.record_timer);
        stack_start_timer(
            audio_recorder.record_timer,
            JAVA_MEDIA_TIMER_AUDIO_RECORDER,
            (kal_uint32) limit_ticks);
    }
    else
    {
        jma_audio_recorder_commit(java_recorder);
        jvm_post_mma_event(MMA_EVENT_RECORD_STOPPED, 
            (kal_int16) audio_recorder.id, audio_recorder.current_time);
    } 
    
    JMA_CS_LEAVE(limit_size);
}


/*****************************************************************************
 * FUNCTION
 *  jma_audio_recorder_get_record_time
 * DESCRIPTION
 *  This function invoke AudioGetRecordTime request to media task.
 * PARAMETERS
 *  mma_type        [IN]        
 *  java_recorder     [IN]        
 * RETURNS
 *  long - current_time
 *****************************************************************************/
kal_uint64 jma_audio_recorder_get_record_time(kal_int32 java_recorder)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    kal_uint64 current_time = 0;
  
    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    kal_trace(TRACE_GROUP_4, FUNC_J2ME_JMA_AUDIO_RECORDER_GET_RECORD_TIME, java_recorder, audio_recorder.state); 
    JMA_CS_ENTER(0);

    if (audio_recorder.id != java_recorder)
    {
        kal_trace(TRACE_GROUP_4, INFO_J2ME_MMA_RESOURCE_ERROR, audio_recorder.id);
        JMA_CS_LEAVE(0);
    }


    if (audio_recorder.state == JAVA_MEDIA_STATE_RECORDING ||
        audio_recorder.state == JAVA_MEDIA_STATE_PAUSED)
    {
    #ifdef __MTK_TARGET__
        current_time = (kal_uint64)Media_GetRecordedTime();
    #endif
        audio_recorder.current_time = current_time;
    }
    else
    {        
        audio_recorder.current_time = current_time;
    }
 
    kal_trace(TRACE_GROUP_4, INFO_J2ME_MMA_D, current_time);
    JMA_CS_LEAVE(current_time);
}
#else
kal_bool jma_audio_recorder_open(kal_int32 java_recorder){return KAL_FALSE;}
kal_bool jma_audio_recorder_close(kal_int32 java_recorder){return KAL_FALSE;}
kal_bool jma_audio_recorder_start_record(kal_int32 java_recorder){return KAL_FALSE;}
kal_bool jma_audio_recorder_pause_record(kal_int32 java_recorder){return KAL_FALSE;}
kal_bool jma_audio_recorder_commit(kal_int32 java_recorder){return KAL_FALSE;}
kal_bool jma_audio_recorder_reset(kal_int32 java_recorder){return KAL_FALSE;}
kal_bool jma_audio_recorder_set_record_location(kal_int32 java_recorder, kal_char *path){return KAL_FALSE;}
kal_int32 jma_audio_recorder_set_record_size_limit(kal_int32 java_recorder, kal_int32 limit_size){return 0;}
kal_uint64 jma_audio_recorder_get_record_time(kal_int32 java_recorder){return 0;}


#endif

/*****************************************************************************
 * FUNCTION
 *  jma_audio_recorder_is_active
 * DESCRIPTION
 *  This function return if any recorder is active
 * PARAMETERS
 *  void
 * RETURNS
 *  kal_bool - true or false
 *****************************************************************************/
kal_bool jma_audio_recorder_is_active(void)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
   

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
#ifdef SUPPORT_MMAPI
    if (audio_recorder.id != INVALID_JPLAYER_ID)
    {
        return KAL_TRUE;
    }
    else
    {
        return KAL_FALSE;
    }
#else /* SUPPORT_MMAPI */ 
    return KAL_FALSE;
#endif /* SUPPORT_MMAPI */ 
}