jma_audio_player.c

java 1.1 gemini 08_16

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    while (player)
    {
        next_player = player->next;
        jvm_free(player);
        player = next_player;
    }
    midi_players.head = NULL;
}


/*****************************************************************************
 * FUNCTION
 *  jma_midi_player_init
 * DESCRIPTION
 *  This function is to initialize player information
 * PARAMETERS
 *  player      [?]     
 *  Media_Handle *handle (AL)(?)
 * RETURNS
 *  void
 *****************************************************************************/
static void jma_midi_player_init(audio_player_struct *player)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    player->next_node.next = player->next_node.prev = NULL;
    player->next_node.flag_on_list = KAL_FALSE;
    player->next_node.forced_paused_time = 0;
    player->next_node.med_device_status = JAVA_MED_DEVICE_NONACTIVE;
    player->state = JAVA_MEDIA_STATE_READY;
    player->id = INVALID_JPLAYER_ID;
    player->handle = NULL;
    player->is_setstoptime = KAL_FALSE;
    player->is_midi_device = KAL_FALSE;    /* Default is not midi device */
    player->duration = 0;
    player->current_time = 0;
    player->pitch = 0;  /* Default value */
    player->stoptime = -1;
    player->is_setpitch = KAL_FALSE;
    player->volume = DEFAULT_AUDIO_VOLUME;
    player->rate = 100000;  /* Default value */
    player->is_setrate = KAL_FALSE;
    player->tempo = 120000;  /* No Default value: defined in midi file */
    player->is_settempo = KAL_FALSE;
    player->aud_id = 0;
    player->sequence_id = 0;
    player->drm_state = JAVA_DRM_STATE_NULL;
    player->drm_id = -1;
    player->is_need_reset_time = KAL_FALSE;    
}


/*****************************************************************************
 * FUNCTION
 *  jma_midi_locate_handle
 * DESCRIPTION
 *  This function is to position a player in linked list by media handle.
 * PARAMETERS
 *  handle          [?]     (AL)
 *  java_player     [?]     
 * RETURNS
 *  audio_player_struct* null_midi_player if not found else the ponter to the midi_players
 *****************************************************************************/
static audio_player_struct *jma_midi_locate_handle(kal_int32 handle)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    audio_player_struct *player =
        (audio_player_struct*) dynamic_player_search(&midi_players, midi_handle_key, (kal_int32) handle);

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    return player;
}


/*****************************************************************************
 * FUNCTION
 *  jma_midi_locate_player
 * DESCRIPTION
 *  This function is to position a player in linked list by java_player.
 * PARAMETERS
 *  java_player     [IN]        (JL)
 * RETURNS
 *  audio_player_struct* null_midi_player if not found else the ponter to the midi_players
 *****************************************************************************/
static audio_player_struct *jma_midi_locate_player(kal_int32 java_player)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    return (audio_player_struct*) dynamic_player_search(&midi_players, midi_jplayer_key, java_player);
}


/*****************************************************************************
 * FUNCTION
 *  jma_midi_insert_inactive_player
 * DESCRIPTION
 *  This function is inserting function of an inactive player between last active player
 *  and first inactive player in linked list.
 * PARAMETERS
 *  inserted_player     [?]     
 *  int java_player (JL)(?)
 * RETURNS
 *  void
 *****************************************************************************/
static void jma_midi_insert_inactive_player(audio_player_struct *inserted_player)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    ((mma_player_node*) inserted_player)->med_device_status = JAVA_MED_DEVICE_NONACTIVE;
    dynamic_player_insert(&midi_players, (mma_player_node*) inserted_player, midi_player_insert_func);
}


/*****************************************************************************
 * FUNCTION
 *  jma_midi_insert_active_player
 * DESCRIPTION
 *  This function is inserting function of an active player between last active player
 *  and first inactive player in linked list.
 * PARAMETERS
 *  inserted_player     [?]     
 *  int java_player (JL)(?)
 * RETURNS
 *  void
 *****************************************************************************/
static void jma_midi_insert_active_player(audio_player_struct *inserted_player)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    ((mma_player_node*) inserted_player)->med_device_status = JAVA_MED_DEVICE_ACTIVE;
    dynamic_player_insert(&midi_players, (mma_player_node*) inserted_player, midi_player_inserthead_func);
    midi_players.active_player_count++;
}


/*****************************************************************************
 * FUNCTION
 *  jma_midi_pick_active_player_candidate
 * DESCRIPTION
 *  This function is inserting function of an active player between last active player
 *  and first inactive player in linked list.
 * PARAMETERS
 *  skip_player     [?]     
 *  int java_player (JL)(?)
 * RETURNS
 *  audio_player_struct* null_midi_player if not found else the ponter to the midi_players
 *****************************************************************************/
static audio_player_struct *jma_midi_pick_active_player_candidate(audio_player_struct *skip_player)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    audio_player_struct *cur_player = NULL;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    kal_trace(TRACE_GROUP_4, FUNC_J2ME_JMA_MIDI_PICK_ACTIVE_PLAYER_CANDIDATE);
    if ((midi_players.player_count <= midi_players.max_active_player_count) ||
        (midi_players.active_player_count <= midi_players.max_active_player_count))
    {
        return NULL;
    }

    /* Check cache candiate player first */
    if (midi_players.active_candidate &&
        (midi_players.active_candidate != (mma_player_node*) skip_player) &&
        (midi_players.active_candidate->med_device_status == JAVA_MED_DEVICE_NONACTIVE) &&
        (((audio_player_struct*) midi_players.active_candidate)->state == JAVA_MEDIA_STATE_PLAYING))
    {
        cur_player = (audio_player_struct*) midi_players.active_candidate;
        midi_players.active_candidate = NULL;
        return cur_player;
    }

    cur_player = (audio_player_struct*) midi_players.head;

    /* Pick device nonactive, however, java player status is playing */
    while (cur_player)
    {
        if ((((mma_player_node*) cur_player)->med_device_status == JAVA_MED_DEVICE_NONACTIVE) &&
            (cur_player->state == JAVA_MEDIA_STATE_PLAYING) && (cur_player != skip_player))
        {
            break;
        }

        cur_player = (audio_player_struct*) cur_player->next_node.next;
    }

    return cur_player;
}


/*****************************************************************************
 * FUNCTION
 *  jma_midi_pick_replace_player_candidate
 * DESCRIPTION
 *  This function is inserting function of an active player between last active player
 *  and first inactive player in linked list.
 * PARAMETERS
 *  skip_player     [?]     
 *  int java_player (JL)(?)
 * RETURNS
 *  audio_player_struct* null_midi_player if not found else the ponter to the midi_players
 *****************************************************************************/
static audio_player_struct *jma_midi_pick_replace_player_candidate(audio_player_struct *skip_player)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    /* kick off one playing player according to some kind of criteria */
    /* algorithm1: kick off the player which come in playing state earliest */
    audio_player_struct *player = (audio_player_struct*) midi_players.head;
    audio_player_struct *prev_player = player;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    kal_trace(TRACE_GROUP_4, FUNC_J2ME_JMA_MIDI_PICK_REPLACE_PLAYER_CANDIDATE);
    /* First find non-playing but hold device player */
    while (player)
    {
        if ((player->state != JAVA_MEDIA_STATE_PLAYING) &&
            (((mma_player_node*) player)->med_device_status == JAVA_MED_DEVICE_ACTIVE) && (player != skip_player))
        {
            break;
        }
        player = (audio_player_struct*) player->next_node.next;
    }

    if (player)
    {
        ((mma_player_node*) player)->forced_paused_time = CurrentTime_md();
        midi_players.active_candidate = (mma_player_node*) player;     /* cache as candidate */
        return player;
    }

    player = (audio_player_struct*) midi_players.head;
    /* Second find oldest playing player */
    while (player && (player->state == JAVA_MEDIA_STATE_PLAYING) &&
           (((mma_player_node*) player)->med_device_status == JAVA_MED_DEVICE_ACTIVE) && (player != skip_player))
    {
        prev_player = player;
        player = (audio_player_struct*) player->next_node.next;
    }

    if (prev_player)
    {
        ((mma_player_node*) prev_player)->forced_paused_time = CurrentTime_md();
        midi_players.active_candidate = (mma_player_node*) prev_player;        /* cache as candidate */
        return prev_player;
    }
    return NULL;
}


/*****************************************************************************
 * FUNCTION
 *  jma_midi_release_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     [?]         
 *  need_resume     [IN]        
 * RETURNS
 *  kal_bool - TRUE for success.
 *****************************************************************************/
/* Before entering this routine, lcd mutex has been locked */
static kal_bool jma_midi_release_device_resource(audio_player_struct *midi_player, kal_bool need_resume)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    med_result_enum ms = MED_RES_FAIL;
    audio_player_struct *candidate_player = NULL;
    kal_int32 cur_time;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    kal_trace(TRACE_GROUP_4, FUNC_J2ME_JMA_MIDI_RELEASE_DEVICE_RESOURCE);
    /* Don't remove the assert. Replaced midi player cannot come into this function */
    ASSERT(midi_player->handle);


    midi_player->volume = media_mma_aud_get_volume(MOD_J2ME, midi_player->handle, MMA_TYPE_MIDI);

    ms = media_mma_aud_close(MOD_J2ME, midi_player->handle, MMA_TYPE_MIDI);

    if (ms == MED_RES_OK)
    {
        midi_player->handle = NULL;
    }
    else
    {
        sprintf(_kvmLogStr, "release_device_resource() close failed %d", ms);
        Kputs(_kvmLogStr);
        midi_player->handle = NULL;
    }


    /* delete the midi player */
    dynamic_player_delete(&midi_players, (mma_player_node*) midi_player);
    /* put it to inactive position */
    jma_midi_insert_inactive_player(midi_player);
    /* deregister resource management registration */
    jma_deregister_device(JAVA_MEDIA_MIDI_DEVICE, midi_player->id);

    /* Clear callback only when all player is closed */
    jma_audio_player_clear_callback();
    
    if (need_resume == KAL_FALSE)
    {
        return KAL_TRUE;
    }

    candidate_player = jma_midi_pick_active_player_candidate(midi_player);

    if (candidate_player && candidate_player != midi_player)
    {
        ASSERT(candidate_player->handle == NULL);

        cur_time = candidate_player->current_time + CurrentTime_md() -
            ((mma_player_node*) candidate_player)->forced_paused_time;

        /* Clear force paused time */
        ((mma_player_node*) candidate_player)->forced_paused_time = 0;

        if ((candidate_player->stoptime <= 0 && cur_time < candidate_player->duration) ||
            (cur_time < candidate_player->stoptime))
        {

            if (jma_midi_acquire_device_resource(candidate_player) == KAL_FALSE)
            {
                return KAL_FALSE;
            }

            candidate_player->current_time = cur_time;


            ms = media_mma_aud_set_start_time(MOD_J2ME, 
                    candidate_player->handle,
                    MMA_TYPE_MIDI,
                    (kal_int32) candidate_player->current_time);
            ms = media_mma_aud_set_volume(MOD_J2ME, candidate_player->handle, MMA_TYPE_MIDI, midi_player->volume);
            ms = media_mma_aud_play(MOD_J2ME, candidate_player->handle, MMA_TYPE_MIDI);
            kal_trace(TRACE_GROUP_4, INFO_J2ME_MMA_D, candidate_player->sequence_id);
        }
        else
        {
            /* EOM */
            jma_audio_eom_handler(MMA_TYPE_MIDI, candidate_player);
        }
    }
    return KAL_TRUE;
}


/*****************************************************************************
 * FUNCTION
 *  jma_midi_acquire_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
 *  kal_bool - TRUE for success.
 *****************************************************************************/
/* Before entering this routine, lcd mutex has been locked */
static kal_bool jma_midi_acquire_device_resource(audio_player_struct *midi_player)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    kal_int32 result;
    
    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    kal_trace(TRACE_GROUP_4, FUNC_J2ME_JMA_MIDI_ACQUIRE_DEVICE_RESOURCE);
    /* Already acquired device resource */
    if (((mma_player_node*) midi_player)->med_device_status == JAVA_MED_DEVICE_ACTIVE)
    {
        return KAL_TRUE;
    }


    midi_player->handle = media_mma_aud_open(MOD_J2ME, &(midi_player->player), &result);
    midi_player->aud_id = g_aud_id ++;
    kal_trace(TRACE_GROUP_4, INFO_J2ME_MMA_DD, midi_player->handle, midi_player->aud_id);

    if (midi_player->handle == NULL)
    {