jma_audio_player.c

java 1.1 gemini 08_16

        return KAL_FALSE;
    }

    /* MED would set mute when play dummy audio for pure video */
    jam_set_aud_volume_level(jam_get_aud_volume_level()); 
            
    dynamic_player_delete(&midi_players, (mma_player_node*) midi_player);
    jma_midi_insert_active_player(midi_player);

    jma_register_device(
        JAVA_MEDIA_MIDI_DEVICE,
        midi_player->id, 
        &jma_audio_suspend_hdlr, 
        &jma_audio_resume_hdlr, 
        &jma_audio_close_hdlr);

    /* Register callback */
    jma_audio_player_register_callback();
    return KAL_TRUE;
}


/*****************************************************************************
 * FUNCTION
 *  jma_midi_init_device_resource
 * DESCRIPTION
 *  This function is inserting function of an active player between last active player
 *  and first inactive player in linked list.
 * PARAMETERS
 *  midi_player     [?]     
 * RETURNS
 *  void
 *****************************************************************************/
static void jma_midi_init_device_resource(audio_player_struct *midi_player)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    med_result_enum ms = MED_RES_FAIL;
    kal_int32 mma_type = MMA_TYPE_MIDI;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    kal_trace(TRACE_GROUP_4, FUNC_J2ME_JMA_MIDI_INIT_DEVICE_RESOURCE);
    
#ifdef SUPPORT_MMAPI

    /* set again if the player has ever set it.
       because when play finish or pause, midi_player is closed,
       Original pitch, rate, tempo are also cleared */
    /* Don't clear the flag */
    if (midi_player->is_setpitch == KAL_TRUE)
    {
        ms = media_mma_aud_set_pitch(MOD_J2ME, midi_player->handle, mma_type, midi_player->pitch);
    }

    if (midi_player->is_setrate == KAL_TRUE)
    {
        ms = media_mma_aud_set_rate(MOD_J2ME, midi_player->handle, mma_type, midi_player->rate);
    }

    if (midi_player->is_settempo == KAL_TRUE)
    {
        ms = media_mma_aud_set_tempo(MOD_J2ME, midi_player->handle, mma_type, midi_player->tempo);
    }

#endif /* SUPPORT_MMAPI */ 

    /* Don't clear the flag */
    if (midi_player->is_setstoptime == KAL_TRUE)
    {
        ms = media_mma_aud_set_stop_time(MOD_J2ME, midi_player->handle, mma_type, midi_player->stoptime);
    }

    /* after MediaEnd, player should play from the beginning */
    if (midi_player->is_need_reset_time)
    {
        midi_player->current_time = 0;
        midi_player->is_need_reset_time = KAL_FALSE;
    }
    
    ms = media_mma_aud_set_start_time(MOD_J2ME, midi_player->handle, mma_type, midi_player->current_time);
    ms = media_mma_aud_set_volume(MOD_J2ME, midi_player->handle, mma_type, midi_player->volume);

}


/*****************************************************************************
 * FUNCTION
 *  jma_midi_is_sp_midi
 * DESCRIPTION
 *  This function submit AudioGetDuration request to media task.
 * PARAMETERS
 *  mma_type        [IN]        
 *  java_player     [IN]        
 * RETURNS
 *  long - duration
 *****************************************************************************/
kal_bool jma_midi_is_sp_midi(kal_int32 java_player, kal_char *data, kal_int32 count, kal_wchar *filename)
{    
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    kal_bool is_spmidi;
    mma_player_struct player;
    kal_int32 handle;
    kal_int32 result;
    
    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    kal_trace(TRACE_GROUP_4, FUNC_J2ME_JMA_MIDI_IS_SP_MIDI, java_player);

    JMA_AUDIO_CS_ENTER(KAL_FALSE);
    /* Audio player, audio recorder, video player, camera, video recorder are multual exclusive */
    if (jma_audio_recorder_is_active())
    {
        JMA_CS_LEAVE(KAL_FALSE);
    }
    
#if defined (SUPPORT_MMAPI)
    if (video_player.device_type != JAVA_MEDIA_INVALID_DEVICE)
    {
        JMA_CS_LEAVE(KAL_FALSE);        
    }
#endif

    /* single player */
    if (filename != NULL)
    {
        if (jma_audio_player_is_active())
        {
            JMA_CS_LEAVE(KAL_FALSE);
        }
    }
    else /* Multiple player */
    {        
        /* Check if single player is closed */
        if (mma_audio_player[JAVA_AUDIO_SINGLE].id != INVALID_JPLAYER_ID)
        {
            JMA_CS_LEAVE(KAL_FALSE);
        }
    }


    memset((kal_uint8 *) &player, 0, sizeof(mma_player_struct));
    player.handler = (med_handler) &jma_audio_event_hdlr;
    player.media_type = MMA_TYPE_MIDI; 
    player.repeats = 1;    

    /* Do not copy data */
    if (filename == NULL)
    {
        if(!jma_audio_player_parse_data(MMA_TYPE_MIDI, data, count, &player))
        {
            kal_trace(TRACE_GROUP_4, INFO_J2ME_MMA_MARKER_FAIL);
            JMA_CS_LEAVE(KAL_FALSE);
        }
    }
    else
    {
        player.file_path = filename;
    } 
  
    handle = media_mma_aud_open(MOD_J2ME, &player, &result);
    kal_trace(TRACE_GROUP_4, INFO_J2ME_MMA_D, handle);

    if (handle == NULL)
    {
        kal_trace(TRACE_GROUP_4, INFO_J2ME_MMA_MARKER_FAIL);
        JMA_CS_LEAVE(KAL_FALSE);
    }
    
    /* Get duration by handle */
    is_spmidi = media_mma_aud_is_sp_midi(handle, MMA_TYPE_MIDI);
    kal_trace(TRACE_GROUP_4, INFO_J2ME_MMA_D, is_spmidi);
    
    media_mma_aud_close(MOD_J2ME, handle, MMA_TYPE_MIDI);
    if (player.data != NULL)
    {
        jvm_free(player.data);
        player.data = NULL;
    }
    JMA_CS_LEAVE(is_spmidi);
}


/*****************************************************************************
 * FUNCTION
 *  jma_toneseq_push
 * DESCRIPTION
 *  This function is event handler of midi playback, and this handler is executed under
 *  context of media task.
 * PARAMETERS
 *  block_id        [IN]        
 * RETURNS
 *  int - result.
 *****************************************************************************/
static kal_int32 jma_toneseq_push(kal_int32 block_id)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    /* stack overflow */
    if (mma_toneseq_block_stack_index >= MAX_TONESEQ_BLOCK_NUM)
    {
        return (-1);
    }

    mma_toneseq_block_stack[mma_toneseq_block_stack_index++] = block_id;
    return 0;
}


/*****************************************************************************
 * FUNCTION
 *  jma_toneseq_pop
 * DESCRIPTION
 *  This function is event handler of midi playback, and this handler is executed under
 *  context of media task.
 * PARAMETERS
 *  block_id        [?]     
 * RETURNS
 *  int - result.
 *****************************************************************************/
static kal_int32 jma_toneseq_pop(kal_int32 *block_id)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    /* stack empty */
    if (mma_toneseq_block_stack_index == 0)
    {
        return (-1);
    }

    *block_id = mma_toneseq_block_stack[--mma_toneseq_block_stack_index];
    return (0);
}


/*****************************************************************************
 * FUNCTION
 *  jma_transform_tone_seq
 * DESCRIPTION
 *  This function is translation from java tone sequence to native l1audio proprietary format.
 * PARAMETERS
 *  native_player           [IN]        
 *  seq                     [?]         
 *  len                     [IN]        
 *  play_toneseq_len        [?]         
 * RETURNS
 *  java_error_enum
 *****************************************************************************/
static kal_int32 jma_transform_tone_seq(audio_player_struct *audio_player, kal_int8 *seq, kal_int32 len, kal_char **errThrowClassName)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    kal_int32 startseq = 2, note_index = 0, tone_seq_len = 0;
    kal_int32 tempo = 120;
    kal_int32 resolution = 64;
    kal_int32 frac = 1;
    kal_int32 note;
    bool_t inblk = FALSE;
    kal_int32 found = 0, thisblen = 0;
    kal_int32 tmp = 0;
    kal_int32 mul = 1;
    kal_int32 duration;
    kal_uint8 *tone_seq;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    /* Clean toneseq parser internal structures */
    kal_mem_set(toneseq_block_info, 0, sizeof(mma_toneseq_block_info_struct) * MAX_TONESEQ_BLOCK_NUM);
    kal_mem_set(mma_toneseq_block_stack, 0, sizeof(int) * MAX_TONESEQ_BLOCK_NUM);
    mma_toneseq_block_stack_index = 0;

    /* VERSION */
    if (seq[0] != VERSION || seq[1] != 1)
    {
        return VERSION_ERROR;
    }

    /* TEMPO */
    if (seq[startseq] == TEMPO)
    {
        if (seq[startseq + 1] < 5)
        {
            return TEMPO_ERROR;
        }
        tempo = (seq[startseq + 1] & 0x7f) << 2;
        startseq += 2;
    }

    /* RESOLUTION */
    if (seq[startseq] == RESOLUTION)
    {
        if (seq[startseq + 1] <= 0)
        {
            return RESOLUTION_ERROR;
        }
        resolution = seq[startseq + 1];
        startseq += 2;
    }

    frac = tempo * resolution;

    /* parse block_definition and sequence_event */
    for (note_index = startseq; note_index < len; note_index += 2)
    {
        note = seq[note_index];

        /* note out of bound */
        if (note < TONE_REPEAT || ((note >= 0 || note == SILENCE) && seq[note_index + 1] <= 0))
        {
            return NOTE_ERROR;
        }

        switch (note)
        {
                /* BLOCK_START */
            case BLOCK_START:
                /* Block start */
                if (!inblk)
                {
                    if (seq[note_index + 1] < 0 || seq[note_index + 1] > 127)
                    {
                        return BLOCK_BEGIN_ERROR;
                    }

                    /* Block number */
                    found = seq[note_index + 1];
                    inblk = TRUE;

                    /* Save block begining offset */
                    toneseq_block_info[found].block_seq_offset = note_index;

                    thisblen = 0;
                    continue;
                }
                else
                {
                    return BLOCK_NESTED_ERROR;
                }
                break;

                /* BLOCK_END */
            case BLOCK_END:
                /* already in block */
                if (inblk)
                {
                    /* match block number */
                    if (seq[note_index + 1] == found)
                    {
                        inblk = FALSE;
                        /* Save block length */
                        toneseq_block_info[found].block_len = thisblen;

                    }
                    else
                    {
                        return BLOCK_END_ERROR;
                    }
                    continue;
                }
                else
                {
                    return BLOCK_END_ERROR;
                }
                break;

                /* REPEAT */
            case TONE_REPEAT:
                /* times to repeat */
                if (seq[note_index + 1] < 2)
                {
                    return REPEAT_TIME_ERROR;
                }

                note = seq[note_index + 2];
                if (!(note == SILENCE || note >= 0))
                {
                    return REPEAT_SILENCE_ERROR;
                }
                break;

                /* SET_VOLUME */
            case SET_VOLUME:
                /* volume out of bound */
                if (seq[note_index + 1] < 0 || seq[note_index + 1] > 100)
                {
                    return VOLUME_ERROR;
                }

                /* volume event use 1 byte */
                tone_seq_len += 1;
                break;

                /* PLAY_BLOCK */
            case PLAY_BLOCK:
                tmp = toneseq_block_info[seq[note_index + 1]].block_len;

                if (tmp == 0)
                {
                    return PLAY_BLOCK_ERROR;
                }

                /* already in block */
                if (inblk)
                {