/**
|
* Ò¶º£»Ô
|
* QQȺ121376426
|
* http://blog.yundiantech.com/
|
*/
|
|
#include "VideoPlayer.h"
|
|
#include "Audio/PcmVolumeControl.h"
|
|
#include <stdio.h>
|
#include <QDebug>
|
|
bool VideoPlayer::initPlayer()
|
{
|
mConditon_Video = new Cond;
|
mConditon_Audio = new Cond;
|
|
mPlayerState = VideoPlayer_Stop;
|
|
mVideoPlayerCallBack = nullptr;
|
|
mAudioID = 0;
|
mIsMute = false;
|
mVolume = 1;
|
|
seek_req = 0;
|
seek_pos = 0;
|
seek_flag_audio = 0;
|
seek_flag_video = 0;
|
seek_time = 0;
|
|
mIsNeedPause = false;
|
mIsPause = false;
|
mIsQuit = false;
|
mIsReadFinished = false;
|
mIsReadThreadFinished = false;
|
mIsVideoThreadFinished = false;
|
mIsAudioThreadFinished = false;
|
|
mVideoStartTime = 0;
|
mPauseStartTime = 0;
|
audio_clock = 0;
|
video_clock = 0;
|
|
mVideoStream = nullptr;
|
mAudioStream = nullptr;
|
|
pFormatCtx = nullptr;
|
pCodecCtx = nullptr;
|
pCodec = nullptr;
|
|
aCodecCtx = nullptr;
|
aCodec = nullptr;
|
aFrame = nullptr;
|
aFrame_ReSample = nullptr;
|
swrCtx = nullptr;
|
|
av_register_all(); //³õʼ»¯FFMPEG µ÷ÓÃÁËÕâ¸ö²ÅÄÜÕý³£Ê¹ÓñàÂëÆ÷ºÍ½âÂëÆ÷
|
avformat_network_init(); //Ö§³Ö´ò¿ªÍøÂçÎļþ
|
|
return true;
|
}
|
|
bool VideoPlayer::startPlay(const std::string &filePath, int videoType)
|
{
|
videoType = videoType;
|
if (mPlayerState != VideoPlayer_Stop)
|
{
|
return false;
|
}
|
|
mIsQuit = false;
|
mIsPause = false;
|
|
if (!filePath.empty())
|
mFilePath = filePath;
|
|
//Æô¶¯ÐµÄÏß³ÌʵÏÖ¶ÁÈ¡ÊÓƵÎļþ
|
std::thread([&](VideoPlayer *pointer)
|
{
|
pointer->readVideoFile();
|
|
}, this).detach();
|
|
return true;
|
|
}
|
|
bool VideoPlayer::replay()
|
{
|
stop();
|
|
startPlay(mFilePath);
|
|
return true;
|
}
|
|
bool VideoPlayer::play()
|
{
|
mIsNeedPause = false;
|
mIsPause = false;
|
|
if (mPlayerState != VideoPlayer_Pause)
|
{
|
return false;
|
}
|
|
uint64_t pauseTime = av_gettime() - mVideoStartTime; //ÔÝÍ£Á˶೤ʱ¼ä
|
mVideoStartTime += pauseTime; //½«ÔÝÍ£µÄʱ¼ä¼Óµ½¿ªÊ¼²¥·ÅµÄʱ¼äÉÏ£¬±£Ö¤Í¬²½²»ÊÜÔÝÍ£µÄÓ°Ïì
|
|
mPlayerState = VideoPlayer_Playing;
|
doPlayerStateChanged(VideoPlayer_Playing, mVideoStream != nullptr, mAudioStream != nullptr);
|
|
return true;
|
}
|
|
bool VideoPlayer::pause()
|
{
|
fprintf(stderr, "%s mIsPause=%d \n", __FUNCTION__, mIsPause);
|
|
mIsPause = true;
|
|
if (mPlayerState != VideoPlayer_Playing)
|
{
|
return false;
|
}
|
|
mPauseStartTime = av_gettime();
|
|
mPlayerState = VideoPlayer_Pause;
|
|
emit doPlayerStateChanged(VideoPlayer_Pause, mVideoStream != nullptr, mAudioStream != nullptr);
|
|
return true;
|
}
|
|
bool VideoPlayer::stop(bool isWait)
|
{
|
if (mPlayerState == VideoPlayer_Stop)
|
{
|
return false;
|
}
|
|
mPlayerState = VideoPlayer_Stop;
|
mIsQuit = true;
|
|
if (isWait)
|
{
|
while(!mIsReadThreadFinished)
|
{
|
mSleep(3);
|
}
|
}
|
|
return true;
|
}
|
|
void VideoPlayer::seek(int64_t pos)
|
{
|
if(!seek_req)
|
{
|
seek_pos = pos;
|
seek_req = 1;
|
}
|
}
|
|
void VideoPlayer::setMute(bool isMute){
|
mIsMute = isMute;
|
}
|
|
float VideoPlayer::getVolume()
|
{
|
return mVolume;
|
}
|
|
void VideoPlayer::setVolume(float value)
|
{
|
mVolume = value;
|
}
|
|
double VideoPlayer::getCurrentTime()
|
{
|
return audio_clock;
|
}
|
|
int64_t VideoPlayer::getTotalTime()
|
{
|
return pFormatCtx->duration;
|
}
|
|
void VideoPlayer::setVideoPlayerCallBack(VideoPlayerCallBack *pointer){
|
mVideoPlayerCallBack=pointer;
|
}
|
|
int VideoPlayer::openSDL()
|
{
|
///´ò¿ªSDL£¬²¢ÉèÖò¥·ÅµÄ¸ñʽΪ:AUDIO_S16LSB Ë«ÉùµÀ£¬44100hz
|
///ºóÆÚʹÓÃffmpeg½âÂëÍêÒôƵºó£¬ÐèÒªÖزÉÑù³ÉºÍÕâ¸öÒ»ÑùµÄ¸ñʽ£¬·ñÔò²¥·Å»áÓÐÔÓÒô
|
SDL_AudioSpec wanted_spec, spec;
|
int wanted_nb_channels = 2;
|
int samplerate = 44100;
|
|
wanted_spec.channels = wanted_nb_channels;
|
wanted_spec.freq = samplerate;
|
wanted_spec.format = AUDIO_S16SYS; // ¾ßÌ庬ÒåÇë²é¿´¡°SDLºê¶¨Ò塱²¿·Ö
|
wanted_spec.silence = 0; // 0ָʾ¾²Òô
|
wanted_spec.samples = SDL_AUDIO_BUFFER_SIZE; // ×Ô¶¨ÒåSDL»º³åÇø´óС
|
wanted_spec.callback = sdlAudioCallBackFunc; // »Øµ÷º¯Êý
|
wanted_spec.userdata = this; // ´«¸øÉÏÃæ»Øµ÷º¯ÊýµÄÍâ´øÊý¾Ý
|
|
int num = SDL_GetNumAudioDevices(0);
|
for (int i=0;i<num;i++)
|
{
|
mAudioID = SDL_OpenAudioDevice(SDL_GetAudioDeviceName(i,0), false, &wanted_spec, &spec,0);
|
if (mAudioID > 0)
|
{
|
break;
|
}
|
}
|
|
/* ¼ì²éʵ¼ÊʹÓõÄÅäÖ㨱£´æÔÚspec,ÓÉSDL_OpenAudio()Ìî³ä£© */
|
// if (spec.format != AUDIO_S16SYS)
|
if (mAudioID <= 0)
|
{
|
mIsAudioThreadFinished = true;
|
return -1;
|
}
|
fprintf(stderr, "mAudioID=%d\n\n\n\n\n\n", mAudioID);
|
return 0;
|
}
|
|
void VideoPlayer::closeSDL()
|
{
|
if (mAudioID > 0)
|
{
|
SDL_LockAudioDevice(mAudioID);
|
SDL_PauseAudioDevice(mAudioID, 1);
|
SDL_UnlockAudioDevice(mAudioID);
|
|
SDL_CloseAudioDevice(mAudioID);
|
}
|
|
mAudioID = 0;
|
}
|
|
void VideoPlayer::readVideoFile()
|
{
|
///SDL³õʼ»¯ÐèÒª·ÅÈë×ÓÏß³ÌÖУ¬·ñÔòÓÐЩµçÄÔ»áÓÐÎÊÌâ¡£
|
if (SDL_Init(SDL_INIT_AUDIO))
|
{
|
doOpenSdlFailed(-100);
|
fprintf(stderr, "Could not initialize SDL - %s. \n", SDL_GetError());
|
return;
|
}
|
|
mIsReadThreadFinished = false;
|
mIsReadFinished = false;
|
|
const char * file_path = mFilePath.c_str();
|
|
pFormatCtx = nullptr;
|
pCodecCtx = nullptr;
|
pCodec = nullptr;
|
|
aCodecCtx = nullptr;
|
aCodec = nullptr;
|
aFrame = nullptr;
|
|
mAudioStream = nullptr;
|
mVideoStream = nullptr;
|
|
audio_clock = 0;
|
video_clock = 0;
|
|
int audioStream ,videoStream;
|
|
//Allocate an AVFormatContext.
|
pFormatCtx = avformat_alloc_context();
|
|
AVDictionary* opts = NULL;
|
av_dict_set(&opts, "rtsp_transport", "tcp", 0); //ÉèÖÃtcp or udp£¬Ä¬ÈÏÒ»°ãÓÅÏÈtcpÔÙ³¢ÊÔudp
|
av_dict_set(&opts, "stimeout", "60000000", 0);//ÉèÖó¬Ê±3Ãë
|
|
if (avformat_open_input(&pFormatCtx, file_path, nullptr, &opts) != 0)
|
{
|
fprintf(stderr, "can't open the file. \n");
|
doOpenVideoFileFailed();
|
goto end;
|
}
|
|
if (avformat_find_stream_info(pFormatCtx, nullptr) < 0)
|
{
|
fprintf(stderr, "Could't find stream infomation.\n");
|
doOpenVideoFileFailed();
|
goto end;
|
}
|
|
videoStream = -1;
|
audioStream = -1;
|
|
///Ñ»·²éÕÒÊÓƵÖаüº¬µÄÁ÷ÐÅÏ¢£¬
|
for (int i = 0; i < pFormatCtx->nb_streams; i++)
|
{
|
if (pFormatCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO)
|
{
|
videoStream = i;
|
}
|
if (pFormatCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_AUDIO && audioStream < 0)
|
{
|
audioStream = i;
|
}
|
}
|
|
doTotalTimeChanged(getTotalTime());
|
|
///´ò¿ªÊÓƵ½âÂëÆ÷£¬²¢Æô¶¯ÊÓƵÏß³Ì
|
if (videoStream >= 0)
|
{
|
///²éÕÒÊÓƵ½âÂëÆ÷
|
pCodecCtx = pFormatCtx->streams[videoStream]->codec;
|
pCodec = avcodec_find_decoder(pCodecCtx->codec_id);
|
|
if (pCodec == nullptr)
|
{
|
fprintf(stderr, "PCodec not found.\n");
|
doOpenVideoFileFailed();
|
goto end;
|
}
|
|
///´ò¿ªÊÓƵ½âÂëÆ÷
|
if (avcodec_open2(pCodecCtx, pCodec, NULL) < 0)
|
{
|
fprintf(stderr, "Could not open video codec.\n");
|
doOpenVideoFileFailed();
|
goto end;
|
}
|
|
mVideoStream = pFormatCtx->streams[videoStream];
|
|
///´´½¨Ò»¸öÏß³ÌרÃÅÓÃÀ´½âÂëÊÓƵ
|
std::thread([&](VideoPlayer *pointer)
|
{
|
pointer->decodeVideoThread();
|
|
}, this).detach();
|
|
}
|
|
if (audioStream >= 0)
|
{
|
///²éÕÒÒôƵ½âÂëÆ÷
|
aCodecCtx = pFormatCtx->streams[audioStream]->codec;
|
aCodec = avcodec_find_decoder(aCodecCtx->codec_id);
|
|
if (aCodec == NULL)
|
{
|
fprintf(stderr, "ACodec not found.\n");
|
audioStream = -1;
|
}
|
else
|
{
|
///´ò¿ªÒôƵ½âÂëÆ÷
|
if (avcodec_open2(aCodecCtx, aCodec, nullptr) < 0)
|
{
|
fprintf(stderr, "Could not open audio codec.\n");
|
doOpenVideoFileFailed();
|
goto end;
|
}
|
|
///½âÂëÒôƵÏà¹Ø
|
aFrame = av_frame_alloc();
|
|
|
//ÖزÉÑùÉèÖÃÑ¡Ïî-----------------------------------------------------------start
|
aFrame_ReSample = nullptr;
|
|
//frame->16bit 44100 PCM ͳһÒôƵ²ÉÑù¸ñʽÓë²ÉÑùÂÊ
|
swrCtx = nullptr;
|
|
//ÊäÈëµÄÉùµÀ²¼¾Ö
|
int in_ch_layout;
|
|
//Êä³öµÄÉùµÀ²¼¾Ö
|
int out_ch_layout = av_get_default_channel_layout(audio_tgt_channels); ///AV_CH_LAYOUT_STEREO
|
|
out_ch_layout &= ~AV_CH_LAYOUT_STEREO_DOWNMIX;
|
|
/// ÕâÀïÒôƵ²¥·ÅʹÓÃÁ˹̶¨µÄ²ÎÊý
|
/// Ç¿Öƽ«ÒôƵÖزÉÑù³É44100 Ë«ÉùµÀ AV_SAMPLE_FMT_S16
|
/// SDL²¥·ÅÖÐÒ²ÊÇÓÃÁËͬÑùµÄ²¥·Å²ÎÊý
|
//ÖزÉÑùÉèÖÃÑ¡Ïî----------------
|
//ÊäÈëµÄ²ÉÑù¸ñʽ
|
in_sample_fmt = aCodecCtx->sample_fmt;
|
//Êä³öµÄ²ÉÑù¸ñʽ 16bit PCM
|
out_sample_fmt = AV_SAMPLE_FMT_S16;
|
//ÊäÈëµÄ²ÉÑùÂÊ
|
in_sample_rate = aCodecCtx->sample_rate;
|
//ÊäÈëµÄÉùµÀ²¼¾Ö
|
in_ch_layout = aCodecCtx->channel_layout;
|
|
//Êä³öµÄ²ÉÑùÂÊ
|
out_sample_rate = 44100;
|
//Êä³öµÄÉùµÀ²¼¾Ö
|
|
audio_tgt_channels = 2; ///av_get_channel_layout_nb_channels(out_ch_layout);
|
out_ch_layout = av_get_default_channel_layout(audio_tgt_channels); ///AV_CH_LAYOUT_STEREO
|
|
out_ch_layout &= ~AV_CH_LAYOUT_STEREO_DOWNMIX;
|
|
/// 2019-5-13Ìí¼Ó
|
/// wav/wmv Îļþ»ñÈ¡µ½µÄaCodecCtx->channel_layoutΪ0»áµ¼ÖºóÃæµÄ³õʼ»¯Ê§°Ü£¬Òò´ËÕâÀïÐèÒª¼Ó¸öÅжϡ£
|
if (in_ch_layout <= 0)
|
{
|
in_ch_layout = av_get_default_channel_layout(aCodecCtx->channels);
|
}
|
|
swrCtx = swr_alloc_set_opts(nullptr, out_ch_layout, out_sample_fmt, out_sample_rate,
|
in_ch_layout, in_sample_fmt, in_sample_rate, 0, nullptr);
|
|
/** Open the resampler with the specified parameters. */
|
int ret = swr_init(swrCtx);
|
if (ret < 0)
|
{
|
char buff[128]={0};
|
av_strerror(ret, buff, 128);
|
|
fprintf(stderr, "Could not open resample context %s\n", buff);
|
swr_free(&swrCtx);
|
swrCtx = nullptr;
|
doOpenVideoFileFailed();
|
goto end;
|
}
|
|
//´æ´¢pcmÊý¾Ý
|
int out_linesize = out_sample_rate * audio_tgt_channels;
|
|
// out_linesize = av_samples_get_buffer_size(NULL, audio_tgt_channels, av_get_bytes_per_sample(out_sample_fmt), out_sample_fmt, 1);
|
out_linesize = AVCODEC_MAX_AUDIO_FRAME_SIZE;
|
|
|
mAudioStream = pFormatCtx->streams[audioStream];
|
|
///´ò¿ªSDL²¥·ÅÉùÒô
|
int code = openSDL();
|
|
if (code == 0)
|
{
|
SDL_LockAudioDevice(mAudioID);
|
SDL_PauseAudioDevice(mAudioID,0);
|
SDL_UnlockAudioDevice(mAudioID);
|
|
mIsAudioThreadFinished = false;
|
}
|
else
|
{
|
doOpenSdlFailed(code);
|
}
|
}
|
|
}
|
|
// av_dump_format(pFormatCtx, 0, file_path, 0); //Êä³öÊÓƵÐÅÏ¢
|
|
mPlayerState = VideoPlayer_Playing;
|
doPlayerStateChanged(VideoPlayer_Playing, mVideoStream != nullptr, mAudioStream != nullptr);
|
|
mVideoStartTime = av_gettime();
|
fprintf(stderr, "%s mIsQuit=%d mIsPause=%d \n", __FUNCTION__, mIsQuit, mIsPause);
|
while (1)
|
{
|
if (mIsQuit)
|
{
|
//Í£Ö¹²¥·ÅÁË
|
break;
|
}
|
|
if (seek_req)
|
{
|
int stream_index = -1;
|
int64_t seek_target = seek_pos;
|
|
if (videoStream >= 0)
|
stream_index = videoStream;
|
else if (audioStream >= 0)
|
stream_index = audioStream;
|
|
AVRational aVRational = {1, AV_TIME_BASE};
|
if (stream_index >= 0)
|
{
|
seek_target = av_rescale_q(seek_target, aVRational, pFormatCtx->streams[stream_index]->time_base);
|
}
|
|
if (av_seek_frame(pFormatCtx, stream_index, seek_target, AVSEEK_FLAG_BACKWARD) < 0)
|
{
|
fprintf(stderr, "%s: error while seeking\n",pFormatCtx->filename);
|
}
|
else
|
{
|
if (audioStream >= 0)
|
{
|
AVPacket packet;
|
av_new_packet(&packet, 10);
|
strcpy((char*)packet.data,FLUSH_DATA);
|
clearAudioQuene(); //Çå³ý¶ÓÁÐ
|
inputAudioQuene(packet); //Íù¶ÓÁÐÖдæÈëÓÃÀ´Çå³ýµÄ°ü
|
}
|
|
if (videoStream >= 0)
|
{
|
AVPacket packet;
|
av_new_packet(&packet, 10);
|
strcpy((char*)packet.data,FLUSH_DATA);
|
clearVideoQuene(); //Çå³ý¶ÓÁÐ
|
inputVideoQuene(packet); //Íù¶ÓÁÐÖдæÈëÓÃÀ´Çå³ýµÄ°ü
|
video_clock = 0;
|
}
|
|
mVideoStartTime = av_gettime() - seek_pos;
|
mPauseStartTime = av_gettime();
|
}
|
seek_req = 0;
|
seek_time = seek_pos / 1000000.0;
|
seek_flag_audio = 1;
|
seek_flag_video = 1;
|
|
if (mIsPause)
|
{
|
mIsNeedPause = true;
|
mIsPause = false;
|
}
|
|
}
|
|
//ÕâÀï×öÁ˸öÏÞÖÆ µ±¶ÓÁÐÀïÃæµÄÊý¾Ý³¬¹ýij¸ö´óСµÄʱºò ¾ÍÔÝÍ£¶ÁÈ¡ ·ÀÖ¹Ò»ÏÂ×ӾͰÑÊÓƵ¶ÁÍêÁË£¬µ¼ÖµĿռä·ÖÅä²»×ã
|
//Õâ¸öÖµ¿ÉÒÔÉÔ΢д´óһЩ
|
if (mAudioPacktList.size() > MAX_AUDIO_SIZE || mVideoPacktList.size() > MAX_VIDEO_SIZE)
|
{
|
mSleep(10);
|
continue;
|
}
|
|
if (mIsPause == true)
|
{
|
mSleep(10);
|
continue;
|
}
|
|
AVPacket packet;
|
if (av_read_frame(pFormatCtx, &packet) < 0)
|
{
|
mIsReadFinished = true;
|
|
if (mIsQuit)
|
{
|
break; //½âÂëÏß³ÌÒ²Ö´ÐÐÍêÁË ¿ÉÒÔÍ˳öÁË
|
}
|
|
mSleep(10);
|
continue;
|
}
|
|
if (packet.stream_index == videoStream)
|
{
|
inputVideoQuene(packet);
|
//ÕâÀïÎÒÃǽ«Êý¾Ý´æÈë¶ÓÁÐ Òò´Ë²»µ÷Óà av_free_packet ÊÍ·Å
|
}
|
else if( packet.stream_index == audioStream )
|
{
|
if (mIsAudioThreadFinished)
|
{ ///SDLûÓдò¿ª£¬ÔòÒôƵÊý¾ÝÖ±½ÓÊÍ·Å
|
av_packet_unref(&packet);
|
}
|
else
|
{
|
inputAudioQuene(packet);
|
//ÕâÀïÎÒÃǽ«Êý¾Ý´æÈë¶ÓÁÐ Òò´Ë²»µ÷Óà av_free_packet ÊÍ·Å
|
}
|
|
}
|
else
|
{
|
// Free the packet that was allocated by av_read_frame
|
av_packet_unref(&packet);
|
}
|
}
|
|
///Îļþ¶ÁÈ¡½áÊø Ìø³öÑ»·µÄÇé¿ö
|
///µÈ´ý²¥·ÅÍê±Ï
|
while (!mIsQuit)
|
{
|
mSleep(100);
|
}
|
|
end:
|
|
clearAudioQuene();
|
clearVideoQuene();
|
|
if (mPlayerState != VideoPlayer_Stop) //²»ÊÇÍⲿµ÷ÓõÄstop ÊÇÕý³£²¥·Å½áÊø
|
{
|
stop();
|
}
|
|
while((mVideoStream != nullptr && !mIsVideoThreadFinished) || (mAudioStream != nullptr && !mIsAudioThreadFinished))
|
{
|
mSleep(10);
|
} //È·±£ÊÓƵÏ߳̽áÊøºó ÔÙÏú»Ù¶ÓÁÐ
|
|
closeSDL();
|
|
if (swrCtx != nullptr)
|
{
|
swr_free(&swrCtx);
|
swrCtx = nullptr;
|
}
|
|
if (aFrame != nullptr)
|
{
|
av_frame_free(&aFrame);
|
aFrame = nullptr;
|
}
|
|
if (aFrame_ReSample != nullptr)
|
{
|
av_frame_free(&aFrame_ReSample);
|
aFrame_ReSample = nullptr;
|
}
|
|
if (aCodecCtx != nullptr)
|
{
|
avcodec_close(aCodecCtx);
|
aCodecCtx = nullptr;
|
}
|
|
if (pCodecCtx != nullptr)
|
{
|
avcodec_close(pCodecCtx);
|
pCodecCtx = nullptr;
|
}
|
|
avformat_close_input(&pFormatCtx);
|
avformat_free_context(pFormatCtx);
|
|
SDL_Quit();
|
|
doPlayerStateChanged(VideoPlayer_Stop, mVideoStream != nullptr, mAudioStream != nullptr);
|
|
mIsReadThreadFinished = true;
|
|
fprintf(stderr, "%s finished \n", __FUNCTION__);
|
}
|
|
bool VideoPlayer::inputVideoQuene(const AVPacket &pkt)
|
{
|
if (av_dup_packet((AVPacket*)&pkt) < 0)
|
{
|
return false;
|
}
|
|
mConditon_Video->Lock();
|
mVideoPacktList.push_back(pkt);
|
mConditon_Video->Signal();
|
mConditon_Video->Unlock();
|
|
return true;
|
}
|
|
void VideoPlayer::clearVideoQuene()
|
{
|
mConditon_Video->Lock();
|
for (AVPacket pkt : mVideoPacktList)
|
{
|
// av_free_packet(&pkt);
|
av_packet_unref(&pkt);
|
}
|
mVideoPacktList.clear();
|
mConditon_Video->Unlock();
|
}
|
|
bool VideoPlayer::inputAudioQuene(const AVPacket &pkt)
|
{
|
if (av_dup_packet((AVPacket*)&pkt) < 0)
|
{
|
return false;
|
}
|
|
mConditon_Audio->Lock();
|
mAudioPacktList.push_back(pkt);
|
mConditon_Audio->Signal();
|
mConditon_Audio->Unlock();
|
|
return true;
|
}
|
|
void VideoPlayer::clearAudioQuene()
|
{
|
mConditon_Audio->Lock();
|
for (AVPacket pkt : mAudioPacktList)
|
{
|
// av_free_packet(&pkt);
|
av_packet_unref(&pkt);
|
}
|
mAudioPacktList.clear();
|
mConditon_Audio->Unlock();
|
}
|
|
///µ±Ê¹ÓýçÃæÀà¼Ì³ÐÁ˱¾ÀàÖ®ºó£¬ÒÔϺ¯Êý²»»áÖ´ÐÐ
|
|
///´ò¿ªÎļþʧ°Ü
|
void VideoPlayer::doOpenVideoFileFailed(const int &code)
|
{
|
fprintf(stderr, "%s \n", __FUNCTION__);
|
|
if (mVideoPlayerCallBack != nullptr)
|
{
|
mVideoPlayerCallBack->onOpenVideoFileFailed(code);
|
}
|
|
}
|
|
///´ò¿ªsdlʧ°ÜµÄʱºò»Øµ÷´Ëº¯Êý
|
void VideoPlayer::doOpenSdlFailed(const int &code)
|
{
|
fprintf(stderr, "%s \n", __FUNCTION__);
|
|
if (mVideoPlayerCallBack != nullptr)
|
{
|
mVideoPlayerCallBack->onOpenSdlFailed(code);
|
}
|
}
|
|
///»ñÈ¡µ½ÊÓƵʱ³¤µÄʱºòµ÷Óô˺¯Êý
|
void VideoPlayer::doTotalTimeChanged(const int64_t &uSec)
|
{
|
fprintf(stderr, "%s \n", __FUNCTION__);
|
|
if (mVideoPlayerCallBack != nullptr)
|
{
|
mVideoPlayerCallBack->onTotalTimeChanged(uSec);
|
}
|
}
|
|
///²¥·ÅÆ÷״̬¸Ä±äµÄʱºò»Øµ÷´Ëº¯Êý
|
void VideoPlayer::doPlayerStateChanged(const VideoPlayerState &state, const bool &hasVideo, const bool &hasAudio)
|
{
|
fprintf(stderr, "%s \n", __FUNCTION__);
|
|
if (mVideoPlayerCallBack != nullptr)
|
{
|
mVideoPlayerCallBack->onPlayerStateChanged(state, hasVideo, hasAudio);
|
}
|
|
}
|
|
///ÏÔʾÊÓƵÊý¾Ý£¬´Ëº¯Êý²»ÒË×öºÄʱ²Ù×÷£¬·ñÔò»áÓ°Ïì²¥·ÅµÄÁ÷³©ÐÔ¡£
|
void VideoPlayer::doDisplayVideo(const uint8_t *yuv420Buffer, const int &width, const int &height)
|
{
|
// fprintf(stderr, "%s \n", __FUNCTION__);
|
if (mVideoPlayerCallBack != nullptr)
|
{
|
VideoFramePtr videoFrame = std::make_shared<VideoFrame>();
|
|
VideoFrame * ptr = videoFrame.get();
|
|
ptr->initBuffer(width, height);
|
ptr->setYUVbuf(yuv420Buffer);
|
|
mVideoPlayerCallBack->onDisplayVideo(videoFrame);
|
}
|
}
|
|
void VideoPlayer::decodeVideoThread()
|
{
|
fprintf(stderr, "%s start \n", __FUNCTION__);
|
|
mIsVideoThreadFinished = false;
|
|
int videoWidth = 0;
|
int videoHeight = 0;
|
|
double video_pts = 0; //µ±Ç°ÊÓƵµÄpts
|
double audio_pts = 0; //񙮵pts
|
|
///½âÂëÊÓƵÏà¹Ø
|
AVFrame *pFrame = nullptr;
|
AVFrame *pFrameYUV = nullptr;
|
uint8_t *yuv420pBuffer = nullptr; //½âÂëºóµÄyuvÊý¾Ý
|
struct SwsContext *imgConvertCtx = nullptr; //ÓÃÓÚ½âÂëºóµÄÊÓƵ¸ñʽת»»
|
|
AVCodecContext *pCodecCtx = mVideoStream->codec; //ÊÓƵ½âÂëÆ÷
|
|
pFrame = av_frame_alloc();
|
|
while(1)
|
{
|
if (mIsQuit)
|
{
|
clearVideoQuene(); //Çå¿Õ¶ÓÁÐ
|
break;
|
}
|
|
if (mIsPause == true) //ÅжÏÔÝÍ£
|
{
|
mSleep(10);
|
continue;
|
}
|
|
mConditon_Video->Lock();
|
|
if (mVideoPacktList.size() <= 0)
|
{
|
mConditon_Video->Unlock();
|
if (mIsReadFinished)
|
{
|
//¶ÓÁÐÀïÃæûÓÐÊý¾ÝÁËÇÒ¶ÁÈ¡Íê±ÏÁË
|
break;
|
}
|
else
|
{
|
mSleep(1); //¶ÓÁÐÖ»ÊÇÔÝʱûÓÐÊý¾Ý¶øÒÑ
|
continue;
|
}
|
}
|
|
AVPacket pkt1 = mVideoPacktList.front();
|
mVideoPacktList.pop_front();
|
|
mConditon_Video->Unlock();
|
|
AVPacket *packet = &pkt1;
|
|
//ÊÕµ½Õâ¸öÊý¾Ý ˵Ã÷¸Õ¸ÕÖ´ÐйýÌøת ÏÖÔÚÐèÒª°Ñ½âÂëÆ÷µÄÊý¾Ý Çå³ýÒ»ÏÂ
|
if(strcmp((char*)packet->data, FLUSH_DATA) == 0)
|
{
|
avcodec_flush_buffers(mVideoStream->codec);
|
av_packet_unref(packet);
|
continue;
|
}
|
|
if (avcodec_send_packet(pCodecCtx, packet) != 0)
|
{
|
qDebug("input AVPacket to decoder failed!\n");
|
av_packet_unref(packet);
|
continue;
|
}
|
|
while (0 == avcodec_receive_frame(pCodecCtx, pFrame))
|
{
|
if (packet->dts == AV_NOPTS_VALUE && pFrame->opaque&& *(uint64_t*) pFrame->opaque != AV_NOPTS_VALUE)
|
{
|
video_pts = *(uint64_t *) pFrame->opaque;
|
}
|
else if (packet->dts != AV_NOPTS_VALUE)
|
{
|
video_pts = packet->dts;
|
}
|
else
|
{
|
video_pts = 0;
|
}
|
|
video_pts *= av_q2d(mVideoStream->time_base);
|
video_clock = video_pts;
|
//OUTPUT("%s %f \n", __FUNCTION__, video_pts);
|
if (seek_flag_video)
|
{
|
//·¢ÉúÁËÌøת ÔòÌø¹ý¹Ø¼üÖ¡µ½Ä¿µÄʱ¼äµÄÕ⼸֡
|
if (video_pts < seek_time)
|
{
|
av_packet_unref(packet);
|
continue;
|
}
|
else
|
{
|
seek_flag_video = 0;
|
}
|
}
|
|
///ÒôÊÓƵͬ²½£¬ÊµÏÖµÄÔÀí¾ÍÊÇ£¬ÅжÏÊÇ·ñµ½ÏÔʾ´Ë֡ͼÏñµÄʱ¼äÁË£¬Ã»µ½ÔòÐÝÃß5ms£¬È»ºó¼ÌÐøÅжÏ
|
while(1)
|
{
|
if (mIsQuit)
|
{
|
break;
|
}
|
|
if (mAudioStream != NULL && !mIsAudioThreadFinished)
|
{
|
if (mIsReadFinished && mAudioPacktList.size() <= 0)
|
{//¶ÁÈ¡ÍêÁË ÇÒÒôƵÊý¾ÝÒ²²¥·ÅÍêÁË ¾ÍÊ£ÏÂÊÓƵÊý¾ÝÁË Ö±½ÓÏÔʾ³öÀ´ÁË ²»ÓÃͬ²½ÁË
|
break;
|
}
|
|
///ÓÐÒôƵµÄÇé¿öÏ£¬½«ÊÓƵͬ²½µ½ÒôƵ
|
///¸úÒôƵµÄpts×ö¶Ô±È£¬±ÈÊÓƵ¿ìÔò×öÑÓʱ
|
audio_pts = audio_clock;
|
}
|
else
|
{
|
///ûÓÐÒôƵµÄÇé¿öÏ£¬Ö±½Óͬ²½µ½ÍⲿʱÖÓ
|
audio_pts = (av_gettime() - mVideoStartTime) / 1000000.0;
|
audio_clock = audio_pts;
|
}
|
|
//OUTPUT("%s %f %f \n", __FUNCTION__, video_pts, audio_pts);
|
//Ö÷ÒªÊÇ ÌøתµÄʱºò ÎÒÃÇ°Ñvideo_clockÉèÖóÉ0ÁË
|
//Òò´ËÕâÀïÐèÒª¸üÐÂvideo_pts
|
//·ñÔòµ±´ÓºóÃæÌøתµ½Ç°ÃæµÄʱºò »á¿¨ÔÚÕâÀï
|
video_pts = video_clock;
|
|
if (video_pts <= audio_pts) break;
|
|
int delayTime = (video_pts - audio_pts) * 1000;
|
|
delayTime = delayTime > 5 ? 5:delayTime;
|
|
if (!mIsNeedPause)
|
{
|
mSleep(delayTime);
|
}
|
}
|
|
if (pCodecCtx->width != videoWidth || pCodecCtx->height != videoHeight)
|
{
|
videoWidth = pFrame->width;
|
videoHeight = pFrame->height;
|
|
if (pFrameYUV != nullptr)
|
{
|
av_free(pFrameYUV);
|
}
|
|
if (yuv420pBuffer != nullptr)
|
{
|
av_free(yuv420pBuffer);
|
}
|
|
if (imgConvertCtx != nullptr)
|
{
|
sws_freeContext(imgConvertCtx);
|
}
|
|
pFrameYUV = av_frame_alloc();
|
|
int yuvSize = av_image_get_buffer_size(AV_PIX_FMT_YUV420P, pCodecCtx->width, pCodecCtx->height, 1); //°´1×Ö½Ú½øÐÐÄÚ´æ¶ÔÆë,µÃµ½µÄÄÚ´æ´óС×î½Ó½üʵ¼Ê´óС
|
// int yuvSize = av_image_get_buffer_size(AV_PIX_FMT_YUV420P, pCodecCtx->width, pCodecCtx->height, 0); //°´0×Ö½Ú½øÐÐÄÚ´æ¶ÔÆ룬µÃµ½µÄÄÚ´æ´óСÊÇ0
|
// int yuvSize = av_image_get_buffer_size(AV_PIX_FMT_YUV420P, pCodecCtx->width, pCodecCtx->height, 4); //°´4×Ö½Ú½øÐÐÄÚ´æ¶ÔÆ룬µÃµ½µÄÄÚ´æ´óСÉÔ΢´óһЩ
|
|
unsigned int numBytes = static_cast<unsigned int>(yuvSize);
|
yuv420pBuffer = static_cast<uint8_t *>(av_malloc(numBytes * sizeof(uint8_t)));
|
av_image_fill_arrays(pFrameYUV->data, pFrameYUV->linesize, yuv420pBuffer, AV_PIX_FMT_YUV420P, pCodecCtx->width, pCodecCtx->height, 1);
|
|
///ÓÉÓÚ½âÂëºóµÄÊý¾Ý²»Ò»¶¨¶¼ÊÇyuv420p£¬Òò´ËÐèÒª½«½âÂëºóµÄÊý¾Ýͳһת»»³ÉYUV420P
|
imgConvertCtx = sws_getContext(pCodecCtx->width, pCodecCtx->height,
|
pCodecCtx->pix_fmt, pCodecCtx->width, pCodecCtx->height,
|
AV_PIX_FMT_YUV420P, SWS_BICUBIC, NULL, NULL, NULL);
|
|
}
|
|
sws_scale(imgConvertCtx,
|
(uint8_t const * const *) pFrame->data,
|
pFrame->linesize, 0, pCodecCtx->height, pFrameYUV->data,
|
pFrameYUV->linesize);
|
|
// FILE *fp_yuv = fopen("./frame.yuv", "wb");
|
// fwrite(yuv420pBuffer, 1, pCodecCtx->width * pCodecCtx->height * 3 /2, fp_yuv);
|
// fclose(fp_yuv);
|
doDisplayVideo(yuv420pBuffer, pCodecCtx->width, pCodecCtx->height);
|
|
if (mIsNeedPause)
|
{
|
mIsPause = true;
|
mIsNeedPause = false;
|
}
|
|
}
|
av_packet_unref(packet);
|
}
|
|
av_free(pFrame);
|
|
if (pFrameYUV != nullptr)
|
{
|
av_free(pFrameYUV);
|
}
|
|
if (yuv420pBuffer != nullptr)
|
{
|
av_free(yuv420pBuffer);
|
}
|
|
if (imgConvertCtx != nullptr)
|
{
|
sws_freeContext(imgConvertCtx);
|
}
|
|
if (!mIsQuit)
|
{
|
mIsQuit = true;
|
}
|
|
mIsVideoThreadFinished = true;
|
|
fprintf(stderr, "%s finished \n", __FUNCTION__);
|
|
return;
|
}
|
|
void VideoPlayer::sdlAudioCallBackFunc(void *userdata, Uint8 *stream, int len)
|
{
|
VideoPlayer *player = (VideoPlayer*)userdata;
|
player->sdlAudioCallBack(stream, len);
|
}
|
|
void VideoPlayer::sdlAudioCallBack(Uint8 *stream, int len)
|
{
|
int len1, audio_data_size;
|
|
/* lenÊÇÓÉSDL´«ÈëµÄSDL»º³åÇøµÄ´óС£¬Èç¹ûÕâ¸ö»º³åδÂú£¬ÎÒÃǾÍÒ»Ö±ÍùÀïÌî³äÊý¾Ý */
|
while (len > 0)
|
{
|
/* audio_buf_index ºÍ audio_buf_size ±êʾÎÒÃÇ×Ô¼ºÓÃÀ´·ÅÖýâÂë³öÀ´µÄÊý¾ÝµÄ»º³åÇø£¬*/
|
/* ÕâЩÊý¾Ý´ýcopyµ½SDL»º³åÇø£¬ µ±audio_buf_index >= audio_buf_sizeµÄʱºòÒâζ×ÅÎÒ*/
|
/* ÃǵĻº³åΪ¿Õ£¬Ã»ÓÐÊý¾Ý¿É¹©copy£¬ÕâʱºòÐèÒªµ÷ÓÃaudio_decode_frameÀ´½âÂë³ö¸ü
|
/* ¶àµÄèåÊý¾Ý */
|
if (audio_buf_index >= audio_buf_size)
|
{
|
audio_data_size = decodeAudioFrame();
|
|
/* audio_data_size < 0 ±êʾûÄܽâÂë³öÊý¾Ý£¬ÎÒÃÇĬÈϲ¥·Å¾²Òô */
|
if (audio_data_size <= 0)
|
{
|
/* silence */
|
audio_buf_size = 1024;
|
/* ÇåÁ㣬¾²Òô */
|
memset(audio_buf, 0, audio_buf_size);
|
}
|
else
|
{
|
audio_buf_size = audio_data_size;
|
}
|
audio_buf_index = 0;
|
}
|
/* ²é¿´stream¿ÉÓÿռ䣬¾ö¶¨Ò»´Îcopy¶àÉÙÊý¾Ý£¬Ê£ÏµÄÏ´μÌÐøcopy */
|
len1 = audio_buf_size - audio_buf_index;
|
|
if (len1 > len)
|
{
|
len1 = len;
|
}
|
|
if (audio_buf == NULL) return;
|
|
if (mIsMute || mIsNeedPause) //¾²Òô »òÕß ÊÇÔÚÔÝÍ£µÄʱºòÌøתÁË
|
{
|
memset(audio_buf + audio_buf_index, 0, len1);
|
}
|
else
|
{
|
PcmVolumeControl::RaiseVolume((char*)audio_buf + audio_buf_index, len1, 1, mVolume);
|
}
|
|
memcpy(stream, (uint8_t *)audio_buf + audio_buf_index, len1);
|
|
// SDL_memset(stream, 0x0, len);// make sure this is silence.
|
// SDL_MixAudio(stream, (uint8_t *) audio_buf + audio_buf_index, len1, SDL_MIX_MAXVOLUME);
|
|
// SDL_MixAudio(stream, (uint8_t * )is->audio_buf + is->audio_buf_index, len1, 50);
|
// SDL_MixAudioFormat(stream, (uint8_t * )is->audio_buf + is->audio_buf_index, AUDIO_S16SYS, len1, 50);
|
|
len -= len1;
|
stream += len1;
|
audio_buf_index += len1;
|
|
}
|
|
}
|
|
int VideoPlayer::decodeAudioFrame(bool isBlock)
|
{
|
int audioBufferSize = 0;
|
|
while(1)
|
{
|
if (mIsQuit)
|
{
|
mIsAudioThreadFinished = true;
|
clearAudioQuene(); //Çå¿Õ¶ÓÁÐ
|
break;
|
}
|
|
if (mIsPause == true) //ÅжÏÔÝÍ£
|
{
|
break;
|
}
|
|
mConditon_Audio->Lock();
|
|
if (mAudioPacktList.size() <= 0)
|
{
|
if (isBlock)
|
{
|
mConditon_Audio->Wait();
|
}
|
else
|
{
|
mConditon_Audio->Unlock();
|
break;
|
}
|
}
|
|
AVPacket packet = mAudioPacktList.front();
|
mAudioPacktList.pop_front();
|
qDebug()<<__FUNCTION__<<mAudioPacktList.size();
|
mConditon_Audio->Unlock();
|
|
AVPacket *pkt = &packet;
|
|
/* if update, update the audio clock w/pts */
|
if (pkt->pts != AV_NOPTS_VALUE)
|
{
|
audio_clock = av_q2d(mAudioStream->time_base) * pkt->pts;
|
}
|
|
//ÊÕµ½Õâ¸öÊý¾Ý ˵Ã÷¸Õ¸ÕÖ´ÐйýÌøת ÏÖÔÚÐèÒª°Ñ½âÂëÆ÷µÄÊý¾Ý Çå³ýÒ»ÏÂ
|
if(strcmp((char*)pkt->data,FLUSH_DATA) == 0)
|
{
|
avcodec_flush_buffers(mAudioStream->codec);
|
av_packet_unref(pkt);
|
continue;
|
}
|
|
if (seek_flag_audio)
|
{
|
//·¢ÉúÁËÌøת ÔòÌø¹ý¹Ø¼üÖ¡µ½Ä¿µÄʱ¼äµÄÕ⼸֡
|
if (audio_clock < seek_time)
|
{
|
continue;
|
}
|
else
|
{
|
seek_flag_audio = 0;
|
}
|
}
|
|
//½âÂëAVPacket->AVFrame
|
int got_frame = 0;
|
int size = avcodec_decode_audio4(aCodecCtx, aFrame, &got_frame, &packet);
|
|
//±£´æÖزÉÑù֮ǰµÄÒ»¸öÉùµÀµÄÊý¾Ý·½·¨
|
//size_t unpadded_linesize = aFrame->nb_samples * av_get_bytes_per_sample((AVSampleFormat) aFrame->format);
|
//static FILE * fp = fopen("out.pcm", "wb");
|
//fwrite(aFrame->extended_data[0], 1, unpadded_linesize, fp);
|
|
av_packet_unref(&packet);
|
|
if (got_frame)
|
{
|
/// ffmpeg½âÂëÖ®ºóµÃµ½µÄÒôƵÊý¾Ý²»ÊÇSDLÏëÒªµÄ£¬
|
/// Òò´ËÕâÀïÐèÒªÖزÉÑù³É44100 Ë«ÉùµÀ AV_SAMPLE_FMT_S16
|
if (aFrame_ReSample == NULL)
|
{
|
aFrame_ReSample = av_frame_alloc();
|
}
|
|
if (aFrame_ReSample->nb_samples != aFrame->nb_samples)
|
{
|
aFrame_ReSample->nb_samples = av_rescale_rnd(swr_get_delay(swrCtx, out_sample_rate) + aFrame->nb_samples,
|
out_sample_rate, in_sample_rate, AV_ROUND_UP);
|
|
av_samples_fill_arrays(aFrame_ReSample->data, aFrame_ReSample->linesize, audio_buf, audio_tgt_channels, aFrame_ReSample->nb_samples, out_sample_fmt, 0);
|
|
}
|
|
int len2 = swr_convert(swrCtx, aFrame_ReSample->data, aFrame_ReSample->nb_samples, (const uint8_t**)aFrame->data, aFrame->nb_samples);
|
int resampled_data_size = len2 * audio_tgt_channels * av_get_bytes_per_sample(out_sample_fmt);
|
|
audioBufferSize = resampled_data_size;
|
break;
|
}
|
}
|
|
return audioBufferSize;
|
}
|
