1396 lines
43 KiB
C++
1396 lines
43 KiB
C++
|
||
#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;
|
||
}
|