/* --------------------------------------------------------------------------*/
int player_exit(int pid)
{
int ret = PLAYER_SUCCESS;
play_para_t *para;
log_print("[player_exit:enter]pid=%d\n", pid);
para = player_open_pid_data(pid);
if (para != NULL) {
log_print("[player_exit]player_state=0x%x\n", get_player_state(para));
if (get_player_state(para) != PLAYER_EXIT) {
player_stop(pid);
}
ret = player_thread_wait_exit(para);
log_print("[player_exit]player thread already exit: %d\n", ret);
ffmpeg_uninterrupt(para->thread_mgt.pthread_id);
FREE(para);
para = NULL;
}
player_close_pid_data(pid);
player_release_pid(pid);
log_print("[player_exit:exit]pid=%d\n", pid);
return ret;
}
static unsigned int handle_current_time(play_para_t *para, unsigned int scr, unsigned int pts)
{
player_status sta = get_player_state(para);
if (!para->playctrl_info.pts_valid) {
log_debug("[handle_current_time:sta=0x%x]scr=0x%x pts=0x%x\n", sta, scr, pts);
}
//if(sta == PLAYER_STOPED || sta == PLAYER_INITING)
if (sta < PLAYER_RUNNING) {
return 0;
}
if (pts == 0xffffffff) {
return 0;
}
if (!para->playctrl_info.pts_valid) {
if (scr > 0 && abs(scr - pts) <= PTS_FREQ) { //in tsync_avevent, pts as u32
para->playctrl_info.pts_valid = 1;
log_print("[%s:%d]scr=0x%x pts=0x%x diff=0x%x \n", __FUNCTION__, __LINE__, scr, pts, (scr - pts));
}
}
if (para->playctrl_info.pts_valid) {
return scr;
} else {
return 0;
}
}
int update_player_states(play_para_t *para, int force)
{
callback_t *cb = ¶->update_state;
update_state_fun_t fn;
para->state.last_sta = para->state.status;
para->state.status = get_player_state(para);
if (check_time_interrupt(&cb->callback_old_time, cb->update_interval) || force) {
player_info_t state;
MEMCPY(&state, ¶->state, sizeof(state));
//if(force == 1)
log_print("**[update_state]pid:%d status=%s(last:%s) err=0x%x curtime=%d (ms:%d) fulltime=%d lsttime=%d\n",
para->player_id,
player_status2str(state.status),
player_status2str(state.last_sta),
(-state.error_no),
state.current_time,
state.current_ms,
state.full_time,
state.last_time);
fn = cb->update_statue_callback;
if (fn) {
fn(para->player_id, &state);
}
send_event(para, PLAYER_EVENTS_PLAYER_INFO, &state, 0);
para->state.error_no = 0;
}
return 0;
}
/* --------------------------------------------------------------------------*/
int player_stop_async(int pid)
{
player_cmd_t *cmd;
int r = PLAYER_SUCCESS;
play_para_t *player_para;
player_status sta;
player_para = player_open_pid_data(pid);
if (player_para == NULL) {
return PLAYER_NOT_VALID_PID;
}
sta = get_player_state(player_para);
log_print("[player_stop]player_status=%x\n", sta);
if (PLAYER_THREAD_IS_STOPPED(sta)) {
player_close_pid_data(pid);
log_print("[player_stop]pid=%d thread is already stopped\n", pid);
return PLAYER_SUCCESS;
}
cmd = message_alloc();
if (cmd) {
cmd->ctrl_cmd = CMD_STOP;
ffmpeg_interrupt(player_para->thread_mgt.pthread_id);
r = send_message(player_para, cmd);
} else {
r = PLAYER_NOMEM;
}
player_close_pid_data(pid);
return r;
}
/* --------------------------------------------------------------------------*/
player_status player_get_state(int pid)
{
player_status status;
play_para_t *player_para;
player_para = player_open_pid_data(pid);
if (player_para == NULL) {
return PLAYER_NOT_VALID_PID;
}
status = get_player_state(player_para);
player_close_pid_data(pid);
return status;
}
/* --------------------------------------------------------------------------*/
int player_stop(int pid)
{
player_cmd_t *cmd;
int r = PLAYER_SUCCESS;
play_para_t *player_para;
player_status sta;
log_print("[player_stop:enter]pid=%d\n", pid);
player_para = player_open_pid_data(pid);
if (player_para == NULL) {
return PLAYER_NOT_VALID_PID;
}
sta = get_player_state(player_para);
log_print("[player_stop]player_status=%x\n", sta);
if (PLAYER_THREAD_IS_STOPPED(sta)) {
player_close_pid_data(pid);
log_print("[player_stop]pid=%d thread is already stopped\n", pid);
return PLAYER_SUCCESS;
}
/*if (player_para->pFormatCtx) {
av_ioctrl(player_para->pFormatCtx, AVIOCTL_STOP, 0, 0);
}*/
cmd = message_alloc();
if (cmd) {
cmd->ctrl_cmd = CMD_STOP;
ffmpeg_interrupt(player_para->thread_mgt.pthread_id);
r = send_message(player_para, cmd);
r = player_thread_wait_exit(player_para);
log_print("[player_stop:%d]wait player_theadpid[%d] r = %d\n", __LINE__, player_para->player_id, r);
clear_all_message(player_para);
ffmpeg_uninterrupt(player_para->thread_mgt.pthread_id);
} else {
r = PLAYER_NOMEM;
}
player_close_pid_data(pid);
log_print("[player_stop:exit]pid=%d\n", pid);
return r;
}
int update_player_states(play_para_t *para, int force)
{
callback_t *cb = ¶->update_state;
update_state_fun_t fn;
para->state.last_sta = para->state.status;
para->state.status = get_player_state(para);
if (check_time_interrupt(&cb->callback_old_time, cb->update_interval) || force) {
player_info_t state;
MEMCPY(&state, ¶->state, sizeof(state));
//if(force == 1)
log_print("**[update_state]pid:%d status=%s(tttlast:%s) err=0x%x curtime=%d (ms:%d) fulltime=%d lsttime=%d\n",
para->player_id,
player_status2str(state.status),
player_status2str(state.last_sta),
(-state.error_no),
state.current_time,
state.current_ms,
state.full_time,
state.last_time);
log_print("**[update_state]abuflevel=%.08f vbublevel=%.08f abufrp=%x vbufrp=%x read_end=%d\n",
state.audio_bufferlevel,
state.video_bufferlevel,
para->abuffer.buffer_rp,
para->vbuffer.buffer_rp,
para->playctrl_info.read_end_flag);
fn = cb->update_statue_callback;
if (fn) {
fn(para->player_id, &state);
}
send_event(para, PLAYER_EVENTS_PLAYER_INFO, &state, 0);
para->state.error_no = 0;
player_hwbuflevel_update(para);
}
return 0;
}
/* --------------------------------------------------------------------------*/
int player_get_media_info(int pid, media_info_t *minfo)
{
play_para_t *player_para;
player_status sta;
player_para = player_open_pid_data(pid);
if (player_para == NULL) {
return PLAYER_NOT_VALID_PID; /*this data is 0 for default!*/
}
sta = get_player_state(player_para);
if (sta >= PLAYER_ERROR && sta <= PLAYER_EXIT) {
player_close_pid_data(pid);
return PLAYER_INVALID_CMD;
}
MEMSET(minfo, 0, sizeof(media_info_t));
MEMCPY(minfo, &player_para->media_info, sizeof(media_info_t));
log_print("[player_get_media_info]video_num=%d vidx=%d\n", minfo->stream_info.total_video_num, minfo->stream_info.cur_video_index);
player_close_pid_data(pid);
return PLAYER_SUCCESS;
}
static int player_mate_thread_cmd_proxy(play_para_t *player, struct player_mate *mate)
{
player_cmd_t *cmd = NULL;
int ret;
play_para_t *p_para=player;
/*
check the cmd & do for main thread;
*/
if (p_para->oldcmd.ctrl_cmd == CMD_SEARCH &&
nextcmd_is_cmd(p_para, CMD_SEARCH) &&
((p_para->oldcmdtime >= player_get_systemtime_ms() - 400)) && /*lastcmd is not too old.*/
((p_para->stream_type == STREAM_ES && p_para->vcodec != NULL) || /*ES*/
(p_para->stream_type != STREAM_ES && p_para->codec && p_para->vstream_info.has_video))) { /*PS,RM,TS*/
/*if latest cmd and next cmd are all search,we must wait the frame show.*/
if (p_para->vcodec) {
ret = codec_get_cntl_state(p_para->vcodec); /*es*/
} else {
ret = codec_get_cntl_state(p_para->codec); /*not es*/
}
if(p_para->avsynctmpchanged == 0) {
p_para->oldavsyncstate = get_tsync_enable();
}
if (p_para->oldavsyncstate == 1) {
set_tsync_enable(0);
p_para->avsynctmpchanged = 1;
}
if (ret <= 0) {
return NONO_FLAG;
}
}
cmd = get_message(player);
if (!cmd) {
return 0; /*no cmds*/
}
p_para->oldcmd = *cmd;
p_para->oldcmdtime = player_get_systemtime_ms();
log_print("pid[%d]:: [check_flag:%d]cmd=%x set_mode=%x info=%x param=%d fparam=%f\n", p_para->player_id, __LINE__, cmd->ctrl_cmd, cmd->set_mode, cmd->info_cmd, cmd->param, cmd->f_param);
if (cmd->ctrl_cmd != CMD_SEARCH && p_para->avsynctmpchanged > 0) {
/*not search now,resore the sync states...*/
set_tsync_enable(p_para->oldavsyncstate);
p_para->avsynctmpchanged = 0;
}
check_msg(player,cmd);
message_free(cmd);
if(player->playctrl_info.search_flag && !(p_para->pFormatCtx->iformat->flags & AVFMT_NOFILE) && p_para->pFormatCtx->pb!=NULL && p_para->pFormatCtx->pb->local_playback == 0){
/*in mate thread seek,and interrupt the read thread.
so we need to ignore the first ffmpeg erros. */
player->playctrl_info.ignore_ffmpeg_errors=1;
player->playctrl_info.temp_interrupt_ffmpeg=1;
log_print("ffmpeg_interrupt tmped by player mate!\n");
ffmpeg_interrupt_light(player->thread_mgt.pthread_id);
codec_resume(player->codec); /*auto resume on*/
}
if (p_para->playctrl_info.search_flag) {
set_black_policy(0);
}
if (p_para->playctrl_info.end_flag) {
log_print("player_mate: end_flag! \n");
update_playing_info(p_para);
update_player_states(p_para, 1);
return 0;
}
if (p_para->playctrl_info.pause_flag) {
if (get_player_state(p_para) != PLAYER_PAUSE) {
ret = codec_pause(p_para->codec);
if (ret != 0) {
log_error("[%s:%d]pause failed!ret=%d\n", __FUNCTION__, __LINE__, ret);
}
set_player_state(p_para, PLAYER_PAUSE);
update_playing_info(p_para);
update_player_states(p_para, 1);
}
return CONTINUE_FLAG;
} else {
if ((get_player_state(p_para) == PLAYER_PAUSE) || (get_player_state(p_para) == PLAYER_SEARCHOK)) {
ret = codec_resume(p_para->codec);
if (ret != 0) {
log_error("[%s:%d]resume failed!ret=%d\n", __FUNCTION__, __LINE__, ret);
}
set_player_state(p_para, PLAYER_RUNNING);
update_playing_info(p_para);
update_player_states(p_para, 1);
}
}
return 0;
}
static int player_mate_thread_cmd_proxy(play_para_t *player, struct player_mate *mate)
{
player_cmd_t *cmd = NULL;
int ret;
/*
check the cmd & do for main thread;
*/
lock_message_pool(player);
cmd = peek_message_locked(player);
if (cmd) {
mate_print("[MATE]Get cmd-------------------------[%x],[%x]\n", cmd->ctrl_cmd, (CMD_START | CMD_PAUSE | CMD_RESUME | CMD_SWITCH_AID));
if (((cmd->ctrl_cmd) & (CMD_START | CMD_PAUSE | CMD_RESUME | CMD_SWITCH_AID)) ||
((cmd->set_mode) & (CMD_LOOP | CMD_NOLOOP | CMD_EN_AUTOBUF | CMD_SET_AUTOBUF_LEV))) {
cmd = get_message_locked(player);
} else {
cmd = NULL;
}
}
unlock_message_pool(player);
if (!cmd) {
return 0; /*no I can handle cmd*/
}
if (cmd->ctrl_cmd & CMD_PAUSE) {
mate_print("[MATE]Get puase cmd\n");
if (get_player_state(player) != PLAYER_PAUSE) {
ret = codec_pause(player->codec);
if (ret != 0) {
log_error("[%s:%d]pause failed!ret=%d\n", __FUNCTION__, __LINE__, ret);
}
player->playctrl_info.pause_flag = 1;
set_player_state(player, PLAYER_PAUSE);
update_playing_info(player);
update_player_states(player, 1);
}
} else if ((cmd->ctrl_cmd & CMD_RESUME) || (cmd->ctrl_cmd & CMD_START)) {
mate_print("[MATE]Get resume cmd\n");
if ((get_player_state(player) == PLAYER_PAUSE) || (get_player_state(player) == PLAYER_SEARCHOK)) {
ret = codec_resume(player->codec);
if (ret != 0) {
log_error("[%s:%d]resume failed!ret=%d\n", __FUNCTION__, __LINE__, ret);
}
player->playctrl_info.pause_flag = 0;
set_player_state(player, PLAYER_RUNNING);
update_playing_info(player);
update_player_states(player, 1);
}
} else if (cmd->ctrl_cmd & CMD_SWITCH_AID) {
player->playctrl_info.seek_base_audio = 1;
player->playctrl_info.switch_audio_id = cmd->param;
set_black_policy(0);
} else if (cmd->set_mode & CMD_LOOP) {
player->playctrl_info.loop_flag = 1;
} else if (cmd->set_mode & CMD_NOLOOP) {
player->playctrl_info.loop_flag = 0;
} else if (cmd->set_mode & CMD_EN_AUTOBUF) {
player->buffering_enable = cmd->param;
} else if (cmd->set_mode & CMD_SET_AUTOBUF_LEV) {
player->buffering_threshhold_min = cmd->f_param;
player->buffering_threshhold_middle = cmd->f_param1;
player->buffering_threshhold_max = cmd->f_param2;
}
message_free(cmd);
return 0;
}
