hgf/qt
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
qt/LedOK/wProgramManager/wEditProgram/wElement/videoplayer.cpp

1396 lines
43 KiB
C++
Raw Normal View History

提交 lekok
2022-01-04 18:11:48 +08:00

#include "videoplayer.h"
#include <stdio.h>
#include <QDebug>
#include <QTimer>
#include <qeventloop.h>
#define FLUSH_DATA "FLUSH"
#define SDL_AUDIO_BUFFER_SIZE 1024
#define AVCODEC_MAX_AUDIO_FRAME_SIZE 192000 // 1 second of 48khz 32bit audio
/********************************************************
Function: packet_queue_init
Description: 队列初始化
Input: *q
OutPut: *q
Return:
Others:
Author:
Date:
*********************************************************/
void packet_queue_init(PacketQueue *q)
{
memset(q, 0, sizeof(PacketQueue));
/**Create a mutex, initialized unlocked.**/
q->mutex = SDL_CreateMutex();
/**Create a condition variable.**/
q->cond = SDL_CreateCond();
q->size = 0;
q->nb_packets = 0;
q->first_pkt = NULL;
q->last_pkt = NULL;
}
/********************************************************
Function: packet_queue_put
Description: 数据压入队列
Input: *pkt
OutPut: *q
Return:
Others:
Author:
Date:
*********************************************************/
int packet_queue_put(PacketQueue *q, AVPacket *pkt) {
AVPacketList *pkt1;
if (av_dup_packet(pkt) < 0) {
return -1;
}
pkt1 = (AVPacketList*)av_malloc(sizeof(AVPacketList));
if (!pkt1)
{
return -1;
}
pkt1->pkt = *pkt;
pkt1->next = NULL;
SDL_LockMutex(q->mutex);
if (!q->last_pkt)
{
q->first_pkt = pkt1;
}
else
{
q->last_pkt->next = pkt1;
}
q->last_pkt = pkt1;
q->nb_packets++;
q->size += pkt1->pkt.size;
SDL_CondSignal(q->cond);
SDL_UnlockMutex(q->mutex);
return 0;
}
/********************************************************
Function: packet_queue_get
Description: 数据出队列
Input: *pkt，block
OutPut: *q
Return:
Others:
Author:
Date:
*********************************************************/
static int packet_queue_get(PacketQueue *q, AVPacket *pkt, int block) {
AVPacketList *pkt1;
int ret = 0;
SDL_LockMutex(q->mutex);
for (;;)
{
pkt1 = q->first_pkt;
if (pkt1)
{
q->first_pkt = pkt1->next;
if (!q->first_pkt)
{
q->last_pkt = NULL;
}
q->nb_packets--;
q->size -= pkt1->pkt.size;
*pkt = pkt1->pkt;
av_free(pkt1);
ret = 1;
break;
}
else if (!block)
{
ret = 0;
break;
}
else
{
SDL_CondWait(q->cond, q->mutex);
}
}
SDL_UnlockMutex(q->mutex);
return ret;
}
/********************************************************
Function: packet_queue_flush
Description: 清空队列
Input: *q
OutPut: *q
Return:
Others:
Author:
Date:
*********************************************************/
static void packet_queue_flush(PacketQueue *q)
{
AVPacketList *pkt, *pkt1;
SDL_LockMutex(q->mutex);
for(pkt = q->first_pkt; pkt != NULL; pkt = pkt1)
{
pkt1 = pkt->next;
if(pkt1->pkt.data != (uint8_t *)"FLUSH")
{
/**do nothing ?**/
}
av_free_packet(&pkt->pkt);
av_freep(&pkt);
}
q->last_pkt = NULL;
q->first_pkt = NULL;
q->nb_packets = 0;
q->size = 0;
SDL_UnlockMutex(q->mutex);
}
/********************************************************
Function: audio_decode_frame
Description: 音频解码函数
Input: m_pstVideosState
OutPut: pts_ptr
Return:
Others:
Author:
Date:
*********************************************************/
static int audio_decode_frame(VideoState *m_pstVideosState, double *pts_ptr)
{
int n;
int len1;
int len2;
int decoded_data_size;
int got_frame = 0;
int wanted_nb_samples;
int resampled_data_size;
double pts;
int64_t dec_channel_layout;
AVPacket *pkt = &m_pstVideosState->audio_pkt;
for (;;)
{
while (m_pstVideosState->audio_pkt_size > 0)
{
/**判断暂停**/
if (m_pstVideosState->isPause == true)
{
SDL_Delay(10);
continue;
}
/**为audio_frame分配空间**/
if (!m_pstVideosState->audio_frame)
{
if (!(m_pstVideosState->audio_frame = av_frame_alloc()))
{
return AVERROR(ENOMEM);
}
}
else
{
/**Unreference all the buffers referenced by frame and reset the frame fields.**/
//取消引用帧引用的所有缓冲区并重置帧字段。
av_frame_unref(m_pstVideosState->audio_frame);
}
/**Decode the audio frame of size pkt->size from pkt->data into audio_frame.**/
//将大小为pkt->size from pkt->data的音频帧解码为音频帧。
len1 = avcodec_decode_audio4(m_pstVideosState->audio_st->codec, m_pstVideosState->audio_frame,
&got_frame, pkt);
/**解码失败**/
if (len1 < 0)
{
/**error, skip the frame**/
m_pstVideosState->audio_pkt_size = 0;
break;
}
m_pstVideosState->audio_pkt_data += len1; /**??**/
m_pstVideosState->audio_pkt_size -= len1; /**??**/
/**获取帧失败**/
if (!got_frame)
{
continue;
}
/**计算解码出来的桢需要的缓冲大小**/
decoded_data_size = av_samples_get_buffer_size(NULL,
m_pstVideosState->audio_frame->channels, m_pstVideosState->audio_frame->nb_samples,
(AVSampleFormat)m_pstVideosState->audio_frame->format, 1);
/**Channel layout of the audio data**/
dec_channel_layout =
(m_pstVideosState->audio_frame->channel_layout
&& m_pstVideosState->audio_frame->channels
== av_get_channel_layout_nb_channels(
m_pstVideosState->audio_frame->channel_layout)) ?
m_pstVideosState->audio_frame->channel_layout :
av_get_default_channel_layout(
m_pstVideosState->audio_frame->channels);
/**number of audio samples (per channel) described by this frame**/
//此帧描述的音频采样数（每个通道）
wanted_nb_samples = m_pstVideosState->audio_frame->nb_samples;
if (m_pstVideosState->audio_frame->format != m_pstVideosState->audio_src_fmt
|| dec_channel_layout != m_pstVideosState->audio_src_channel_layout
|| m_pstVideosState->audio_frame->sample_rate != m_pstVideosState->audio_src_freq
|| (wanted_nb_samples != m_pstVideosState->audio_frame->nb_samples
&& !m_pstVideosState->swr_ctx))
{
if (m_pstVideosState->swr_ctx)
{
swr_free(&m_pstVideosState->swr_ctx);
}
/**Allocate SwrContext if needed and set/reset common parameters**/
m_pstVideosState->swr_ctx = swr_alloc_set_opts(NULL,
m_pstVideosState->audio_tgt_channel_layout, (AVSampleFormat)m_pstVideosState->audio_tgt_fmt,
m_pstVideosState->audio_tgt_freq, dec_channel_layout,
(AVSampleFormat)m_pstVideosState->audio_frame->format, m_pstVideosState->audio_frame->sample_rate,
0, NULL);
if (!m_pstVideosState->swr_ctx || swr_init(m_pstVideosState->swr_ctx) < 0)
{
//fprintf(stderr,"swr_init() failed\n");
break;
}
m_pstVideosState->audio_src_channel_layout = dec_channel_layout;
m_pstVideosState->audio_src_channels = m_pstVideosState->audio_st->codec->channels;
m_pstVideosState->audio_src_freq = m_pstVideosState->audio_st->codec->sample_rate;
m_pstVideosState->audio_src_fmt = m_pstVideosState->audio_st->codec->sample_fmt;
}
/* 这里我们可以对采样数进行调整，增加或者减少，一般可以用来做声画同步 */
if (m_pstVideosState->swr_ctx)
{
const uint8_t **in =
(const uint8_t **) m_pstVideosState->audio_frame->extended_data;
uint8_t *out[] = { m_pstVideosState->audio_buf2 };
if (wanted_nb_samples != m_pstVideosState->audio_frame->nb_samples)
{
if (swr_set_compensation(m_pstVideosState->swr_ctx,
(wanted_nb_samples - m_pstVideosState->audio_frame->nb_samples)
* m_pstVideosState->audio_tgt_freq
/ m_pstVideosState->audio_frame->sample_rate,
wanted_nb_samples * m_pstVideosState->audio_tgt_freq
/ m_pstVideosState->audio_frame->sample_rate) < 0)
{
//fprintf(stderr,"swr_set_compensation() failed\n");
break;
}
}
len2 = swr_convert(m_pstVideosState->swr_ctx, out,
sizeof(m_pstVideosState->audio_buf2) / m_pstVideosState->audio_tgt_channels
/ av_get_bytes_per_sample(m_pstVideosState->audio_tgt_fmt),
in, m_pstVideosState->audio_frame->nb_samples);
if (len2 < 0)
{
//fprintf(stderr,"swr_convert() failed\n");
break;
}
if (len2== sizeof(m_pstVideosState->audio_buf2) / m_pstVideosState->audio_tgt_channels
/ av_get_bytes_per_sample(m_pstVideosState->audio_tgt_fmt))
{
//fprintf(stderr,"warning: audio buffer m_pstVideosState probably too small\n");
swr_init(m_pstVideosState->swr_ctx);
}
m_pstVideosState->audio_buf = m_pstVideosState->audio_buf2;
resampled_data_size = len2 * m_pstVideosState->audio_tgt_channels
* av_get_bytes_per_sample(m_pstVideosState->audio_tgt_fmt);
}
else
{
resampled_data_size = decoded_data_size;
m_pstVideosState->audio_buf = m_pstVideosState->audio_frame->data[0];
}
pts = m_pstVideosState->audio_clock;
*pts_ptr = pts;
n = 2 * m_pstVideosState->audio_st->codec->channels;
m_pstVideosState->audio_clock += (double) resampled_data_size
/ (double) (n * m_pstVideosState->audio_st->codec->sample_rate);
if (m_pstVideosState->seek_flag_audio)
{
/**发生了跳转 则跳过关键帧到目的时间的这几帧**/
if (m_pstVideosState->audio_clock < m_pstVideosState->seek_time)
{
break;
}
else
{
m_pstVideosState->seek_flag_audio = 0;
}
}
/**We have data, return it and come back for more later**/
return resampled_data_size;
}
/**判断暂停**/
if (m_pstVideosState->isPause == true)
{
SDL_Delay(10);
continue;
}
if (pkt->data)
{
av_free_packet(pkt);
}
memset(pkt, 0, sizeof(*pkt));
if (m_pstVideosState->quit)
{
return -1;
}
/**从音频队列中获取音频数据**/
if (packet_queue_get(&m_pstVideosState->audioq, pkt, 0) <= 0)
{
return -1;
}
/**收到这个数据 说明刚刚执行过跳转 现在需要把解码器的数据 清除一下**/
if(strcmp((char*)pkt->data,FLUSH_DATA) == 0)
{
avcodec_flush_buffers(m_pstVideosState->audio_st->codec);
av_free_packet(pkt);
continue;
}
m_pstVideosState->audio_pkt_data = pkt->data;
m_pstVideosState->audio_pkt_size = pkt->size;
/**if update, update the audio clock w/pts **/
if (pkt->pts != AV_NOPTS_VALUE)
{
m_pstVideosState->audio_clock = av_q2d(m_pstVideosState->audio_st->time_base) * pkt->pts;
}
}
return 0;
}
/********************************************************
Function: audio_callback
Description: 音频解码回调函数
Input: *userdata
OutPut:
Return:
Others:
* This function is called when the audio device needs more data.
*
* \param userdata An application-specific parameter saved in
* the SDL_AudioSpec structure
* \param stream A pointer to the audio data buffer.
* \param len The length of that buffer in bytes.
*
* Once the callback returns, the buffer will no longer be valid.
* Stereo samples are stored in a LRLRLR ordering.
*
* You can choose to avoid callbacks and use SDL_QueueAudio() instead, if
* you like. Just open your audio device with a NULL callback.
Author:
Date:
*********************************************************/
static void audio_callback(void *userdata, Uint8 *stream, int len)
{
VideoState *m_pstVideosState = (VideoState *) userdata;
int len1;
double pts;
int 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 (m_pstVideosState->audio_buf_index >= m_pstVideosState->audio_buf_size)
{
/**音频解码**/
audio_data_size = audio_decode_frame(m_pstVideosState, &pts);
/**没能解码出数据，默认播放静音 **/
if (audio_data_size < 0)
{
/**silence**/
m_pstVideosState->audio_buf_size = 1024;
/**清零，静音**/
if (m_pstVideosState->audio_buf == NULL)
{
printf("audio decode error \n");
return;
}
memset(m_pstVideosState->audio_buf, 0, m_pstVideosState->audio_buf_size);
}
else
{
m_pstVideosState->audio_buf_size = audio_data_size;
}
m_pstVideosState->audio_buf_index = 0;
}
/**查看stream可用空间，决定一次copy多少数据，剩下的下次继续copy **/
len1 = m_pstVideosState->audio_buf_size - m_pstVideosState->audio_buf_index;
if (len1 > len) {
len1 = len;
}
if (m_pstVideosState->audio_buf == NULL)
{
printf("audio buf is full \n");
return;
}
memcpy(stream, (uint8_t *) m_pstVideosState->audio_buf + m_pstVideosState->audio_buf_index, len1);
len -= len1;
stream += len1;
m_pstVideosState->audio_buf_index += len1;
}
}
/********************************************************
Function: get_audio_clock
Description:
Input:
OutPut:
Return:
Others: 实际该函数没有被使用
Author:
Date:
*********************************************************/
static double get_audio_clock(VideoState *m_pstVideosState)
{
double pts;
int hw_buf_size, bytes_per_sec, n;
pts = m_pstVideosState->audio_clock; /**maintained in the audio thread**/
hw_buf_size = m_pstVideosState->audio_buf_size - m_pstVideosState->audio_buf_index;
bytes_per_sec = 0;
n = m_pstVideosState->audio_st->codec->channels * 2;
if(m_pstVideosState->audio_st)
{
bytes_per_sec = m_pstVideosState->audio_st->codec->sample_rate * n;
}
if(bytes_per_sec)
{
pts -= (double)hw_buf_size / bytes_per_sec;
}
return pts;
}
/********************************************************
Function: synchronize_video
Description:
Input:
OutPut:
Return:
Others: 视频时间同步
Author:
Date:
*********************************************************/
static double synchronize_video(VideoState *m_pstVideosState, AVFrame *src_frame, double pts)
{
double frame_delay;
if (pts != 0) {
/* if we have pts, set video clock to it */
m_pstVideosState->video_clock = pts;
} else {
/* if we aren't given a pts, set it to the clock */
pts = m_pstVideosState->video_clock;
}
/* update the video clock */
frame_delay = av_q2d(m_pstVideosState->video_st->codec->time_base);
/* if we are repeating a frame, adjust clock accordingly */
frame_delay += src_frame->repeat_pict * (frame_delay * 0.5);
m_pstVideosState->video_clock += frame_delay;
return pts;
}
/********************************************************
Function: audio_stream_component_open
Description: 音频相关设置
Input: m_pstVideosState，stream_index
OutPut: none
Return:
Others: 初始化音频解码器，初始化音频存储队列
Author:
Date:
*********************************************************/
int audio_stream_component_open(VideoState *m_pstVideosState, uint stream_index)
{
AVCodecContext *codecCtx;
AVCodec *codec;
SDL_AudioSpec spec; /**输出实际音频信息**/
SDL_AudioSpec wanted_spec; /**输入音频信息**/
AVFormatContext *pFormatContext = m_pstVideosState->pFormatContext;
int wanted_nb_channels;
uint64_t wanted_channel_layout = 0;
/**SDL支持的声道数为 1, 2, 4, 6 **/
/**后面我们会使用这个数组来纠正不支持的声道数目**/
const int next_nb_channels[] = { 0, 0, 1, 6, 2, 6, 4, 6 };
if (stream_index < 0 || stream_index >= pFormatContext->nb_streams)
{
return -1;
}
codecCtx = pFormatContext->streams[stream_index]->codec;
wanted_nb_channels = codecCtx->channels;
if (!wanted_channel_layout|| wanted_nb_channels
!= av_get_channel_layout_nb_channels(wanted_channel_layout))
{
wanted_channel_layout = av_get_default_channel_layout(wanted_nb_channels);
wanted_channel_layout &= ~AV_CH_LAYOUT_STEREO_DOWNMIX;
}
/**音频通道设置**/
wanted_spec.channels = av_get_channel_layout_nb_channels(wanted_channel_layout);
wanted_spec.freq = codecCtx->sample_rate;
/**没有音频信息**/
if (wanted_spec.freq <= 0 || wanted_spec.channels <= 0)
{
/**fprintf(stderr,"Invalid sample rate or channel count!\n");**/
return -1;
}
wanted_spec.format = AUDIO_S16SYS; /**Signed 16-bit samples**/
wanted_spec.silence = 0; /**0指示静音**/
wanted_spec.samples = SDL_AUDIO_BUFFER_SIZE; /**自定义SDL缓冲区大小 1024**/
/**This function is called when the audio device needs more data**/
wanted_spec.callback = audio_callback; /**音频解码的关键回调函数**/
wanted_spec.userdata = m_pstVideosState; /**传给上面回调函数的外带数据**/
do
{
/**Open a specific audio device，正常时返回值不为0**/
//打开音频设备，SDL_OpenAudioDevice函数只能用来打开AudioDeviceID大于等于2的设备， 而默认的设备，即AudioDeviceID等于1，只能用SDL_OpenAudio函数打开
int count = SDL_GetNumAudioDevices(0);
for (int i = 0; i < count; i++)
{
qDebug() << "Audio device " << i << " : " << SDL_GetAudioDeviceName(i, 0);
}
m_pstVideosState->audioID = SDL_OpenAudioDevice(SDL_GetAudioDeviceName(1,0),0,&wanted_spec, &spec,0);
/**打印通道信息**/
fprintf(stderr,"SDL_OpenAudio (%d channels): %s\n",wanted_spec.channels, SDL_GetError());
qDebug()<<QString("SDL_OpenAudio (%1 channels): %2").arg(wanted_spec.channels).arg(SDL_GetError());
/**通道合法性判断**/
wanted_spec.channels = next_nb_channels[FFMIN(7, wanted_spec.channels)];
if (!wanted_spec.channels)
{
fprintf(stderr,"No more channel combinations to tyu, audio open failed\n");
break;
}
/**Return default channel layout for a given number of channels**/
wanted_channel_layout = av_get_default_channel_layout(wanted_spec.channels);
}while(m_pstVideosState->audioID == 0);
/**检查实际使用的配置（保存在spec,由SDL_OpenAudio()填充）**/
if (spec.format != AUDIO_S16SYS)
{
fprintf(stderr,"SDL advised audio format %d m_pstVideosState not supported!\n",spec.format);
return -1;
}
/**通道判断**/
if (spec.channels != wanted_spec.channels)
{
wanted_channel_layout = av_get_default_channel_layout(spec.channels);
if (!wanted_channel_layout)
{
fprintf(stderr,"SDL advised channel count %d m_pstVideosState not supported!\n",spec.channels);
return -1;
}
}
m_pstVideosState->audio_hw_buf_size = spec.size;
/**把设置好的参数保存到大结构中**/
m_pstVideosState->audio_src_fmt = m_pstVideosState->audio_tgt_fmt = AV_SAMPLE_FMT_S16;
m_pstVideosState->audio_src_freq = m_pstVideosState->audio_tgt_freq = spec.freq;
m_pstVideosState->audio_src_channel_layout = m_pstVideosState->audio_tgt_channel_layout = wanted_channel_layout;
m_pstVideosState->audio_src_channels = m_pstVideosState->audio_tgt_channels = spec.channels;
/** Find a registered decoder with a matching codec ID.**/
codec = avcodec_find_decoder(codecCtx->codec_id);
/**open codec**/
if (!codec || (avcodec_open2(codecCtx, codec, NULL) < 0))
{
fprintf(stderr,"Unsupported codec!\n");
return -1;
}
/**设置丢弃没有用的音频包**/
pFormatContext->streams[stream_index]->discard = AVDISCARD_DEFAULT;
switch (codecCtx->codec_type)
{
case AVMEDIA_TYPE_AUDIO:
{
// m_pstVideosState->s32AStreamCount = stream_index;
m_pstVideosState->audio_st = pFormatContext->streams[stream_index];
m_pstVideosState->audio_buf_size = 0;
m_pstVideosState->audio_buf_index = 0;
memset(&m_pstVideosState->audio_pkt, 0, sizeof(m_pstVideosState->audio_pkt));
/**队列初始化**/
packet_queue_init(&m_pstVideosState->audioq);
// SDL_PauseAudio(0); // 开始播放静音
/**设置开始和停止调用回调函数**/
/**para2 为0 时，开始回调函数audio_callback**/
SDL_PauseAudioDevice(m_pstVideosState->audioID,0);
break;
}
default:
break;
}
return 0;
}
/********************************************************
Function: video_thread
Description: 视频解码线程
Input: none
OutPut: none
Return:
Others:
Author:
Date:
*********************************************************/
int video_thread(void *arg)
{
int ret;
int got_picture;
int numBytes;
//int l_s32VideoPack = 0;
double video_pts = 0; /**当前视频的pts**/
double audio_pts = 0; /**音频pts**/
AVPacket pkt1;
AVPacket *packet = &pkt1;
VideoState *m_pstVideosState = (VideoState *) arg;
/**解码视频相关**/
AVFrame *pFrame; /**解码器解码之后的图像**/
AVFrame *pFrameRGB;/**转换编码之后的视频流**/
uint8_t *out_buffer_rgb; /**解码后的图像数据**/
struct SwsContext *img_convert_ctx; /**用于解码后的视频格式转换**/
AVCodecContext *l_pstVCodecCtx = m_pstVideosState->video_st->codec; /**视频解码器上下文**/
pFrame = av_frame_alloc();//分配空间
pFrameRGB = av_frame_alloc();//分配空间
/**这里我们改成了 将解码后的YUV数据转换成RGB32**/
//成功后返回SwsContext 类型的结构体。
//参数1：被转换源的宽
//参数2：被转换源的高
//参数3：被转换源的格式，eg：YUV、RGB……（枚举格式，也可以直接用枚举的代号表示eg：AV_PIX_FMT_YUV420P这些枚举的格式在libavutil/pixfmt.h中列出）
//参数4：转换后指定的宽
//参数5：转换后指定的高
//参数6：转换后指定的格式同参数3的格式
//参数7：转换所使用的算法，
img_convert_ctx = sws_getContext(l_pstVCodecCtx->width, l_pstVCodecCtx->height,
AV_PIX_FMT_YUV420P, l_pstVCodecCtx->width, l_pstVCodecCtx->height,
AV_PIX_FMT_YUV420P, SWS_BICUBIC, NULL, NULL, NULL);
numBytes = avpicture_get_size(AV_PIX_FMT_YUV420P, l_pstVCodecCtx->width,l_pstVCodecCtx->height);
out_buffer_rgb = (uint8_t *) av_malloc(numBytes * sizeof(uint8_t));
//该函数会自动填充AVFrame的data和linesize字段
avpicture_fill((AVPicture *) pFrameRGB, out_buffer_rgb, AV_PIX_FMT_YUV420P,l_pstVCodecCtx->width, l_pstVCodecCtx->height);
while(1)
{
/**判断退出**/
if (m_pstVideosState->quit)
{
break;
}
/**判断暂停**/
if (m_pstVideosState->isPause == true)
{
/**延时,ms 单位**/
SDL_Delay(10);
continue;
}
/**队列里取数据**/
if (packet_queue_get(&m_pstVideosState->videoq, packet, 0) <= 0)
{
if (m_pstVideosState->readFinished)
{
/**队列里面没有数据了且读取完毕了**/
break;
}
else
{
/**队列只是暂时没有数据而已**/
/**延时,ms 单位**/
SDL_Delay(1);
continue;
}
}
// printf("get video packe %d \n",l_s32VideoPack++);
/**收到这个数据 说明刚刚执行过跳转 现在需要把解码器的数据 清除一下**/
if(strcmp((char*)packet->data,FLUSH_DATA) == 0)
{
avcodec_flush_buffers(m_pstVideosState->video_st->codec);
av_free_packet(packet);
continue;
}
/**视频解码**/
/**将packet->data中packet->size 字节的数据解码到 pFrame 中**/
ret = avcodec_decode_video2(l_pstVCodecCtx, pFrame, &got_picture,packet);
/**解码失败**/
if (ret < 0)
{
qDebug()<<"decode error.\n";
av_free_packet(packet);
continue;
}
/**解码时间无效**/
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
{
/**显示时间戳赋值为0**/
video_pts = 0;
}
/**AVRational 转换为double 数据类型**/
video_pts *= av_q2d(m_pstVideosState->video_st->time_base);
/**同步视频时间**/
video_pts = synchronize_video(m_pstVideosState, pFrame, video_pts);
/**跳转标志 -- 用于视频线程中，run 线程中设置该标志**/
if (m_pstVideosState->seek_flag_video)
{
/**发生了跳转 则跳过关键帧到目的时间的这几帧**/
if (video_pts < m_pstVideosState->seek_time)
{
av_free_packet(packet);
continue;
}
else
{
m_pstVideosState->seek_flag_video = 0;
}
}
/**循环等待视频和视频的时间同步
有个问题：如果音频解码失败，音频pts一直为0 ，者会播放卡住**/
while(1)
{
/**判断是否退出**/
if (m_pstVideosState->quit)
{
break;
}
audio_pts = m_pstVideosState->audio_clock;
/**主要是 跳转的时候 我们把video_clock设置成0了
因此这里需要更新video_pts
否则当从后面跳转到前面的时候 会卡在这里**/
video_pts = m_pstVideosState->video_clock;
if(video_pts <= audio_pts)
{
break;
}
// printf("video_pts = %f,audio_pts = %f, diff = %f \n",
// video_pts,audio_pts,video_pts - audio_pts);
int delayTime = (video_pts - audio_pts) * 1000;
delayTime = delayTime > 5 ? 5:delayTime;
SDL_Delay(delayTime);
}
if (got_picture)
{
sws_scale(img_convert_ctx,
(uint8_t const * const *) pFrame->data,
pFrame->linesize, 0, l_pstVCodecCtx->height, pFrameRGB->data,
pFrameRGB->linesize);
/**把这个RGB数据 用QImage加载**/
// QImage tmpImg((uchar *)out_buffer_rgb,l_pstVCodecCtx->width,l_pstVCodecCtx->height,QImage::Format_RGB32);
/**把图像复制一份 传递给界面显示**/
//QImage image = tmpImg.copy();
/**调用激发信号的函数，更新图像显示**/
// char *outputfilename = "d:\\test3.yuv";
// m_pstVideosState->player->SaveYuv(pFrameRGB->data[0], pFrameRGB->linesize[0], l_pstVCodecCtx->width, l_pstVCodecCtx->height, outputfilename);
// m_pstVideosState->player->SaveYuv(pFrameRGB->data[1], pFrameRGB->linesize[1], l_pstVCodecCtx->width/2, l_pstVCodecCtx->height/2, outputfilename);
// m_pstVideosState->player->SaveYuv(pFrameRGB->data[2], pFrameRGB->linesize[2], l_pstVCodecCtx->width/2, l_pstVCodecCtx->height/2, outputfilename);
m_pstVideosState->player->disPlayVideo(out_buffer_rgb,l_pstVCodecCtx->width,l_pstVCodecCtx->height);
}
av_free_packet(packet);
}
av_free(pFrame);
av_free(pFrameRGB);
av_free(out_buffer_rgb);
if (!m_pstVideosState->quit)
{
m_pstVideosState->quit = true;
}
m_pstVideosState->videoThreadFinished = true;
return 0;
}
/********************************************************
Function: VideoPlayer
Description: 构造函数
Input: none
OutPut: none
Return:
Others: 默认停止播放
Author:
Date:
*********************************************************/
VideoPlayer::VideoPlayer()
{
mPlayerState = Stop;
}
/********************************************************
Function: VideoPlayer
Description: 析构函数
Input: none
OutPut: none
Return:
Others:
Author:
Date:
*********************************************************/
VideoPlayer::~VideoPlayer()
{
}
/********************************************************
Function: setFileName
Description: 获取需要播放文件的名字
Input: path
OutPut: none
Return:
Others:获取到名字之后开始自动视频播放
Author:
Date:
*********************************************************/
bool VideoPlayer::setFileName(QString path)
{
if (mPlayerState != Stop)
{
return false;
}
mFileName = path;
/**启动run线程**/
this->start();
mPlayerState = Playing;
return true;
}
/********************************************************
Function: play
Description: 视频播放事件
Input: none
OutPut: none
Return:
Others:
Author:
Date:
*********************************************************/
bool VideoPlayer::play()
{
mVideoState.isPause = false;
if (mPlayerState != Pause)
{
return false;
}
mPlayerState = Playing;
emit sig_StateChanged(Playing);
return true;
}
/********************************************************
Function: pause
Description: 视频停止播放
Input: none
OutPut: none
Return:
Others:
Author:
Date:
*********************************************************/
bool VideoPlayer::pause()
{
mVideoState.isPause = true;
if (mPlayerState != Playing)
{
return false;
}
mPlayerState = Pause;
emit sig_StateChanged(Pause);
return true;
}
/********************************************************
Function: stop
Description: 关闭视频播放
Input: isWait
OutPut: none
Return:
Others:
Author:
Date:
*********************************************************/
bool VideoPlayer::stop(bool isWait)
{
if (mPlayerState == Stop)
{
return false;
}
//给退出标记赋值
mVideoState.quit = 1;
if (isWait)
{
while(!mVideoState.readThreadFinished || !mVideoState.videoThreadFinished)
{
SDL_Delay(10);
}
}
/**关闭SDL音频播放设备**/
if (mVideoState.audioID != 0)
{
SDL_LockAudio();
SDL_PauseAudioDevice(mVideoState.audioID,1);
SDL_UnlockAudio();
mVideoState.audioID = 0;
}
mPlayerState = Stop;
emit sig_StateChanged(Stop);
return true;
}
/********************************************************
Function: seek
Description: 发生了拖动事件
Input: pos
OutPut: none
Return:
Others:
Author:
Date:
*********************************************************/
void VideoPlayer::seek(int64_t pos)
{
if(!mVideoState.seek_req)
{
mVideoState.seek_pos = pos;
mVideoState.seek_req = 1;
}
}
/********************************************************
Function: getCurrentTime
Description: 获取当前的pts
Input: none
OutPut: none
Return:
Others:
Author:
Date:
*********************************************************/
double VideoPlayer::getCurrentTime()
{
return mVideoState.audio_clock;
}
/********************************************************
Function: getTotalTime
Description: 获取当前播放文件的总时长
Input: none
OutPut: none
Return:
Others:
Author:
Date:
*********************************************************/
int64_t VideoPlayer::getTotalTime()
{
return mVideoState.pFormatContext->duration;
}
/********************************************************
Function: disPlayVideo
Description: 发送信号，刷新视频画面显示
Input: none
OutPut: none
Return:
Others:
Author:
Date:
*********************************************************/
void VideoPlayer::disPlayVideo(QImage img)
{
emit sig_GetOneFrame(img);
}
void VideoPlayer::disPlayVideo(uchar *ptr, uint width, uint height)
{
emit sigYuv_liuyi(ptr,width,height);
}
/********************************************************
Function: run()
Description: 视频音频数据读取线程，将读取的视频数据存入视频
队列，将读取的音频数据存入音频队列里
Input: none
OutPut: none
Return:
Others:
Author:
Date:
*********************************************************/
void VideoPlayer::run()
{
AVCodec *l_pstVCodec;//视频解码器
AVCodec *l_pstACodec;//音频解码器
AVFormatContext *l_pstFormatCtx;//存储整个视频信息
AVCodecContext *l_pstVCodecCtx;//视频解码器
AVCodecContext *l_pstACodecCtx;//音频解码器
VideoState *m_pstVideosState = &mVideoState;
int l_s32VStreamCount;
int l_s32AStreamCount;
char file_path[1280] = {0};
//int l_s32VideoPacketNum = 0;
//int l_s32AudioPacketNum = 0;
strcpy(file_path,mFileName.toUtf8().data());
memset(&mVideoState,0,sizeof(VideoState));
/**分配空间**/
l_pstFormatCtx = avformat_alloc_context();
/**打开输入文件**/
if (avformat_open_input(&l_pstFormatCtx, file_path, NULL, NULL) != 0)
{
printf("can't open the file. \n");
return;
}
/**获取媒体信息**/
if (avformat_find_stream_info(l_pstFormatCtx, NULL) < 0)
{
printf("Could't find stream infomation.\n");
return;
}
l_s32VStreamCount = -1;
l_s32AStreamCount = -1;
/**循环查找视频中包含的流信息**/
for (uint i = 0; i < l_pstFormatCtx->nb_streams; i++)
{
if (l_pstFormatCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO)
{
l_s32VStreamCount = i;//记录视频流的数量
}
if (l_pstFormatCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_AUDIO && l_s32AStreamCount < 0)
{
l_s32AStreamCount = i;//记录音频流的数量
}
}
/**如果videoStream为-1 说明没有找到视频流**/
if (l_s32VStreamCount == -1) {
printf("Didn't find a video stream.\n");
return;
}
/**如果videoStream为-1 说明没有找到音频流**/
if (l_s32AStreamCount == -1) {
printf("Didn't find a audio stream.\n");
return;
}
/**赋值**/
m_pstVideosState->pFormatContext = l_pstFormatCtx;
m_pstVideosState->s32VStreamCount = l_s32VStreamCount;
m_pstVideosState->s32AStreamCount = l_s32AStreamCount;
/**发送媒体长度，用来更新显示进度条**/
emit sig_TotalTimeChanged(getTotalTime());
if (l_s32AStreamCount >= 0)
{
/**所有设置SDL音频流信息的步骤都在这个函数里完成**/
audio_stream_component_open(&mVideoState, l_s32AStreamCount);
}
/**查找音频解码器**/
l_pstACodecCtx = l_pstFormatCtx->streams[l_s32AStreamCount]->codec;
l_pstACodec = avcodec_find_decoder(l_pstACodecCtx->codec_id);
if (l_pstACodec == NULL) {
printf("ACodec not found.\n");
return;
}
/**打开音频解码器**/
if (avcodec_open2(l_pstACodecCtx, l_pstACodec, NULL) < 0) {
printf("Could not open audio codec.\n");
return;
}
//转化为音频流
m_pstVideosState->audio_st = l_pstFormatCtx->streams[l_s32AStreamCount];
/**查找视频解码器**/
l_pstVCodecCtx = l_pstFormatCtx->streams[l_s32VStreamCount]->codec;
l_pstVCodec = avcodec_find_decoder(l_pstVCodecCtx->codec_id);
if (l_pstVCodec == NULL) {
printf("PCodec not found.\n");
return;
}
/**打开视频解码器**/
if (avcodec_open2(l_pstVCodecCtx, l_pstVCodec, NULL) < 0) {
printf("Could not open video codec.\n");
return;
}
//转化为视频流
m_pstVideosState->video_st = l_pstFormatCtx->streams[l_s32VStreamCount];
/**初始化队列**/
packet_queue_init(&m_pstVideosState->videoq);
/**创建一个线程专门用来解码视频**/
m_pstVideosState->video_tid = SDL_CreateThread(video_thread, "video_thread", &mVideoState);
m_pstVideosState->player = this;
// int y_size = l_pstVCodecCtx->width * l_pstVCodecCtx->height;
/**分配一个packet 用来存放读取的视频**/
AVPacket *packet = (AVPacket *) malloc(sizeof(AVPacket));
// av_new_packet(packet, y_size); //av_read_frame 会给它分配空间 因此这里不需要了
/**打印输出视频信息**/
av_dump_format(l_pstFormatCtx, 0, file_path, 0);
// int l_s32VideoPacketNum = 1;
// int l_s32AudioPacketNum = 1;
while (1)
{
/**停止播放了**/
if (m_pstVideosState->quit) {
break;
}
/**发生了进度条的拖动事件**/
if (m_pstVideosState->seek_req)
{
int stream_index = -1;
int64_t seek_target = m_pstVideosState->seek_pos;//获取拖动的位置
if (m_pstVideosState->s32VStreamCount >= 0)
{
stream_index = m_pstVideosState->s32VStreamCount;
}
else if (m_pstVideosState->s32AStreamCount >= 0)
{
stream_index = m_pstVideosState->s32AStreamCount;
}
AVRational aVRational = {1, AV_TIME_BASE};
if (stream_index >= 0)
{
/**重新调整时间位置**/
/**Rescale a 64-bit integer by 2 rational numbers.**/
seek_target = av_rescale_q(seek_target, aVRational,
l_pstFormatCtx->streams[stream_index]->time_base);
}
/**跳转到需要偏移时间位置附近的视频关键帧位置**/
/**Seek to the keyframe at timestamp.**/
if (av_seek_frame(m_pstVideosState->pFormatContext, stream_index, seek_target, AVSEEK_FLAG_BACKWARD) < 0)
{
fprintf(stderr, "%s: error while seeking\n",m_pstVideosState->pFormatContext->filename);
}
else
{
if (m_pstVideosState->s32AStreamCount >= 0)
{
/**分配一个packet**/
AVPacket *packet = (AVPacket *) malloc(sizeof(AVPacket));
av_new_packet(packet, 10);
strcpy((char*)packet->data,FLUSH_DATA);
/**清除队列**/
packet_queue_flush(&m_pstVideosState->audioq);
/**往队列中存入用来清除的包**/
packet_queue_put(&m_pstVideosState->audioq, packet);
}
if (m_pstVideosState->s32VStreamCount >= 0)
{
/**分配一个packet**/
AVPacket *packet = (AVPacket *) malloc(sizeof(AVPacket));
av_new_packet(packet, 10);
strcpy((char*)packet->data,FLUSH_DATA);
/**清除队列**/
packet_queue_flush(&m_pstVideosState->videoq);
/**往队列中存入用来清除的包**/
packet_queue_put(&m_pstVideosState->videoq, packet);
/**视频时钟清零**/
m_pstVideosState->video_clock = 0;
}
}
m_pstVideosState->seek_req = 0;
m_pstVideosState->seek_time = m_pstVideosState->seek_pos / 1000000.0;
m_pstVideosState->seek_flag_audio = 1;
m_pstVideosState->seek_flag_video = 1;
}
/**这里做了个限制 当队列里面的数据超过某个大小的时候 就暂停读取 防止一下子就把视频读完了，导致的空间分配不足**/
/**这里audioq.size是指队列中的所有数据包带的音频数据的总量或者视频数据总量，并不是包的数量**/
/**这个值可以稍微写大一些**/
if (m_pstVideosState->audioq.size > MAX_AUDIO_SIZE || m_pstVideosState->videoq.size > MAX_VIDEO_SIZE)
{
SDL_Delay(10);
continue;
}
if (m_pstVideosState->isPause == true)
{
SDL_Delay(10);
continue;
}
if (av_read_frame(l_pstFormatCtx, packet) < 0)
{
m_pstVideosState->readFinished = true;
if (m_pstVideosState->quit)
{
break; /**解码线程也执行完了 可以退出了**/
}
SDL_Delay(10);
continue;
}
if (packet->stream_index == l_s32VStreamCount)
{
/**将视频数据存入视频队列中**/
packet_queue_put(&m_pstVideosState->videoq, packet);
//qDebug()<<("video input num %d \n",l_s32VideoPacketNum++);
}
else if( packet->stream_index == l_s32AStreamCount )
{
/**将音频数据存入音频队列中**/
packet_queue_put(&m_pstVideosState->audioq, packet);
// qDebug()<<("audio input num %d \n",l_s32AudioPacketNum++);
}
else
{
/**Free the packet that was allocated by av_read_frame**/
av_free_packet(packet);
}
}
/**文件读取结束 跳出循环的情况**/
/**等待播放完毕**/
while (!m_pstVideosState->quit) {
SDL_Delay(100);
}
stop();
avcodec_close(l_pstVCodecCtx);
avformat_close_input(&l_pstFormatCtx);
m_pstVideosState->readThreadFinished = true;
}
int VideoPlayer::SaveYuv(unsigned char *buf, int wrap, int xsize, int ysize, char *filename)
{
FILE *f;
int i;
f = fopen(filename, "ab+");
for (i = 0; i<ysize; i++)
{
fwrite(buf + i * wrap, 1, xsize, f);
}
fclose(f);
return 1;
}
Reference in New Issue Copy Permalink