myvtm/Other/libmediaplayer/player.cpp

/*******************************************************************************
 * player.c
 *
 * details:
 *   A simple ffmpeg player.
 *
 * refrence:
 *   ffplay.c in FFmpeg 4.1 project.
 *******************************************************************************/

#include <stdio.h>
#include <stdbool.h>
#include <assert.h>

#include "player.h"
#include "frame.h"
#include "packet.h"
#include "demux.h"
#include "video.h"
#include "audio.h"

static player_stat_t *player_init(rvc_media_player_param_t* pmedia_player);
static int player_deinit(player_stat_t *is);


// 返回值：返回上一帧的pts更新值(上一帧pts+流逝的时间)
double get_clock(play_clock_t *c)
{
    if (*c->queue_serial != c->serial)
    {
        return NAN;
    }
    if (c->paused)
    {
        return c->pts;
    }
    else
    {
        double time = av_gettime_relative() / 1000000.0;
        double ret = c->pts_drift + time;   // 展开得： c->pts + (time - c->last_updated)
        return ret;
    }
}


void set_clock_at(play_clock_t *c, double pts, int serial, double time)
{
    c->pts = pts;
    c->last_updated = time;
    c->pts_drift = c->pts - time;
    c->serial = serial;
}


void set_clock(play_clock_t *c, double pts, int serial)
{
    double time = av_gettime_relative() / 1000000.0;
    set_clock_at(c, pts, serial, time);
}


static void set_clock_speed(play_clock_t *c, double speed)
{
    set_clock(c, get_clock(c), c->serial);
    c->speed = speed;
}


void init_clock(play_clock_t *c, int *queue_serial)
{
    c->speed = 1.0;
    c->paused = 0;
    c->queue_serial = queue_serial;
    set_clock(c, NAN, -1);
}


static void sync_play_clock_to_slave(play_clock_t *c, play_clock_t *slave)
{
    double clock = get_clock(c);
    double slave_clock = get_clock(slave);
    if (!isnan(slave_clock) && (isnan(clock) || fabs(clock - slave_clock) > AV_NOSYNC_THRESHOLD))
        set_clock(c, slave_clock, slave->serial);
}


static void do_exit(player_stat_t *is)
{
    if (is)
    {
		is->rvc_log("do_exit");
        player_deinit(is);
    }

    if (is->sdl_video.renderer)
        SDL_DestroyRenderer(is->sdl_video.renderer);
    if (is->sdl_video.window)
        SDL_DestroyWindow(is->sdl_video.window);
    
    avformat_network_deinit();

	if (is->prvc_cb)
	{
		is->rvc_log("cb_play_media_finished callback.");
		is->prvc_cb->cb_play_media_finished(is->prvc_cb->user_data);
	}

    SDL_Quit();

    exit(0);
}


static player_stat_t *player_init(rvc_media_player_param_t* pmedia_player)
{
    player_stat_t *is = (player_stat_t*)av_mallocz(sizeof(player_stat_t));

    if (!is || !pmedia_player)
    {
        return NULL;
    }

    is->filename = av_strdup(pmedia_player->p_input_file);
	is->rvc_log = pmedia_player->playlog;
	is->prvc_cb = pmedia_player->cb;
	is->piconpath = av_strdup(pmedia_player->picon_path);
	is->eMType = pmedia_player->eType;
    if (is->filename == NULL || NULL == is->rvc_log || NULL == is->prvc_cb || NULL == is->piconpath)
    {
        goto fail;
    }

    /* start video display */
    if (frame_queue_init(&is->video_frm_queue, &is->video_pkt_queue, VIDEO_PICTURE_QUEUE_SIZE, 1) < 0 ||
        frame_queue_init(&is->audio_frm_queue, &is->audio_pkt_queue, SAMPLE_QUEUE_SIZE, 1) < 0)
    {
        goto fail;
    }

	/* init packet queue */
    if (packet_queue_init(&is->video_pkt_queue, pmedia_player->playlog) < 0 ||
        packet_queue_init(&is->audio_pkt_queue, pmedia_player->playlog) < 0)
    {
        goto fail;
    }

	/* put end pkt into packet queue */
    AVPacket flush_pkt;
    flush_pkt.data = NULL;
    packet_queue_put(&is->video_pkt_queue, &flush_pkt, pmedia_player->playlog);
    packet_queue_put(&is->audio_pkt_queue, &flush_pkt, pmedia_player->playlog);

    if (!(is->continue_read_thread = SDL_CreateCond()))
    {
        //av_log(NULL, AV_LOG_FATAL, "SDL_CreateCond(): %s\n", SDL_GetError());
		is->rvc_log("SDL_CreateCond(): %s.", SDL_GetError());
fail:
        player_deinit(is);
        goto fail;
    }

    init_clock(&is->video_clk, &is->video_pkt_queue.serial);
    init_clock(&is->audio_clk, &is->audio_pkt_queue.serial);

    is->abort_request = 0;

    if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER))
    {
        //av_log(NULL, AV_LOG_FATAL, "Could not initialize SDL - %s\n", SDL_GetError());
        //av_log(NULL, AV_LOG_FATAL, "(Did you set the DISPLAY variable?)\n");
		is->rvc_log("Could not initialize SDL - %s\n", SDL_GetError());
		is->rvc_log("(Did you set the DISPLAY variable?)");
        exit(1);
    }

    return is;
}


static int player_deinit(player_stat_t *is)
{
    /* XXX: use a special url_shutdown call to abort parse cleanly */
    is->abort_request = 1;

    SDL_WaitThread(is->read_tid, NULL);
	is->rvc_log("is->read_tid finished.");
    /* close each stream */
    if (is->audio_idx >= 0)
    {
        //stream_component_close(is, is->p_audio_stream);
    }
    if (is->video_idx >= 0)
    {
        //stream_component_close(is, is->p_video_stream);
    }

    avformat_close_input(&is->p_fmt_ctx);

    packet_queue_abort(&is->video_pkt_queue);
    packet_queue_abort(&is->audio_pkt_queue);
    packet_queue_destroy(&is->video_pkt_queue);
    packet_queue_destroy(&is->audio_pkt_queue);

    /* free all pictures */
    frame_queue_destory(&is->video_frm_queue);
    frame_queue_destory(&is->audio_frm_queue);

    SDL_DestroyCond(is->continue_read_thread);
    sws_freeContext(is->img_convert_ctx);
    av_free(is->filename);
	av_free(is->piconpath);
    if (is->sdl_video.texture)
    {
        SDL_DestroyTexture(is->sdl_video.texture);
    }
	is->rvc_log("av_free is.");
	is->rvc_log = NULL;

    av_free(is);

    return 0;
}


/* pause or resume the video */
static void stream_toggle_pause(player_stat_t *is)
{
    if (is->paused)
    {
        // 这里表示当前是暂停状态，将切换到继续播放状态。在继续播放之前，先将暂停期间流逝的时间加到frame_timer中
        is->frame_timer += av_gettime_relative() / 1000000.0 - is->video_clk.last_updated;
        set_clock(&is->video_clk, get_clock(&is->video_clk), is->video_clk.serial);
    }
    is->paused = is->audio_clk.paused = is->video_clk.paused = !is->paused;
}


static void toggle_pause(player_stat_t *is)
{
    stream_toggle_pause(is);
    is->step = 0;
}


CMediaPlayer::CMediaPlayer()
{
	m_player_stat = (player_stat_t*)av_mallocz(sizeof(player_stat_t));
	m_uvolume = SDL_MIX_MAXVOLUME;
	m_bplaying = false;

}

CMediaPlayer::~CMediaPlayer()
{
	player_deinit(m_player_stat);
	m_player_stat = NULL;
}


int CMediaPlayer::Init(rvc_media_player_param_t* pMedia_Player)
{
	int iRet = -1;
	if (NULL == pMedia_Player || NULL == m_player_stat)
	{
		return iRet;
	}

	m_player_stat->filename = av_strdup(pMedia_Player->p_input_file);
	m_player_stat->rvc_log = pMedia_Player->playlog;
	m_player_stat->prvc_cb = pMedia_Player->cb;
	m_player_stat->piconpath = av_strdup(pMedia_Player->picon_path);
	m_player_stat->eMType = pMedia_Player->eType;
	m_player_stat->uVolume = m_uvolume;
	if (m_player_stat->filename == NULL || NULL == m_player_stat->rvc_log || NULL == m_player_stat->prvc_cb || NULL == m_player_stat->piconpath)
	{
		player_deinit(m_player_stat);
		m_player_stat = NULL;
		return iRet;
	}

	/* start video display */
	if (frame_queue_init(&m_player_stat->video_frm_queue, &m_player_stat->video_pkt_queue, VIDEO_PICTURE_QUEUE_SIZE, 1) < 0 ||
		frame_queue_init(&m_player_stat->audio_frm_queue, &m_player_stat->audio_pkt_queue, SAMPLE_QUEUE_SIZE, 1) < 0)
	{
		player_deinit(m_player_stat);
		m_player_stat = NULL;
		return iRet;
	}

	/* init packet queue */
	if (packet_queue_init(&m_player_stat->video_pkt_queue, pMedia_Player->playlog) < 0 ||
		packet_queue_init(&m_player_stat->audio_pkt_queue, pMedia_Player->playlog) < 0)
	{
		player_deinit(m_player_stat);
		m_player_stat = NULL;
		return iRet;
	}

	/* put end pkt into packet queue */
	AVPacket flush_pkt;
	flush_pkt.data = NULL;
	packet_queue_put(&m_player_stat->video_pkt_queue, &flush_pkt, pMedia_Player->playlog);
	packet_queue_put(&m_player_stat->audio_pkt_queue, &flush_pkt, pMedia_Player->playlog);

	if (!(m_player_stat->continue_read_thread = SDL_CreateCond()))
	{
		m_player_stat->rvc_log("SDL_CreateCond(): %s.", SDL_GetError());
		player_deinit(m_player_stat);
		m_player_stat = NULL;
		return iRet;
	}

	init_clock(&m_player_stat->video_clk, &m_player_stat->video_pkt_queue.serial);
	init_clock(&m_player_stat->audio_clk, &m_player_stat->audio_pkt_queue.serial);

	m_player_stat->abort_request = 0;

	if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER))
	{
		m_player_stat->rvc_log("Could not initialize SDL - %s\n", SDL_GetError());
		m_player_stat->rvc_log("(Did you set the DISPLAY variable?)");
	}
	else {
		iRet = 0;
	}

	return iRet;
}


int CMediaPlayer::SetVolume(uint8_t uVolume)
{
	int iRet = -1;
	
	m_uvolume = uVolume;
	if (NULL != m_player_stat)
	{
		if (GetPlayingFlag())
		{
			m_player_stat->uVolume = m_uvolume;
			iRet = 0;
		}
		else 
		{
			m_player_stat->rvc_log("set audio volume failed for not in playing status.");
		}
	}

	return iRet;
}


bool CMediaPlayer::GetPlayingFlag()
{
	return m_bplaying;
}


void CMediaPlayer::StartMediaPlay()
{
	if (0 == open_demux(m_player_stat)){
		m_player_stat->rvc_log("open_demux function call success.");
	}
	else{
		m_player_stat->rvc_log("open_demux function call failed.");
	}

	if (eVideo_Type == m_player_stat->eMType) {
		open_video(m_player_stat);
	}
	open_audio(m_player_stat);

	m_bplaying = true;

	SDL_Event event;
	while (1)
	{
		SDL_PumpEvents();
		// SDL event队列为空，则在while循环中播放视频帧。否则从队列头部取一个event，退出当前函数，在上级函数中处理event
		while (!SDL_PeepEvents(&event, 1, SDL_GETEVENT, SDL_FIRSTEVENT, SDL_LASTEVENT))
		{
			av_usleep(100000);
			SDL_PumpEvents();
		}

		switch (event.type) {
		case SDL_KEYDOWN:
			if (event.key.keysym.sym == SDLK_ESCAPE)
			{
				ExitMediaPlayingThread();
				break;
			}

			switch (event.key.keysym.sym) {
			case SDLK_SPACE:        // 空格键：暂停
				toggle_pause(m_player_stat);
				break;
			case SDL_WINDOWEVENT:
				break;
			default:
				break;
			}
			break;

		case SDL_QUIT:
		case FF_QUIT_EVENT:
			ExitMediaPlayingThread();
			break;
		default:
			break;
		}
	}
}


int CMediaPlayer::StopMediaPlay()
{
	int iRet = -1;

	SDL_QuitRequested();

	iRet = 0;

	return iRet;
}


int CMediaPlayer::ExitMediaPlayingThread()
{
	int iRet = -1;

	if (NULL == m_player_stat)
	{
		return iRet;
	}

	m_player_stat->rvc_log("ExitMediaPlayingThread called.");

	if (m_player_stat->sdl_video.renderer)
		SDL_DestroyRenderer(m_player_stat->sdl_video.renderer);
	if (m_player_stat->sdl_video.window)
		SDL_DestroyWindow(m_player_stat->sdl_video.window);

	avformat_network_deinit();

	if (m_player_stat->prvc_cb)
	{
		m_player_stat->rvc_log("cb_play_media_finished callback.");
		m_player_stat->prvc_cb->cb_play_media_finished(m_player_stat->prvc_cb->user_data);
	}

	SDL_Quit();

	player_deinit(m_player_stat);
	m_player_stat = NULL;

	m_bplaying = false;

	iRet = 0;

	return iRet;
}


int64_t CMediaPlayer::GetMediaPlayingThreadId()
{
	int64_t iRet = 0;
	if (NULL != m_player_stat)
	{
		if (NULL != m_player_stat->read_tid)
		{
			iRet = SDL_GestureID(m_player_stat->read_tid);
		}
	}

	return iRet;
}