QT-c++使用FFMpeg库实现音视频同步的方法

最新推荐文章于 2025-06-17 10:17:57 发布

原创最新推荐文章于 2025-06-17 10:17:57 发布 · 808 阅读

8 ·

CC 4.0 BY-SA版权

文章标签：

#qt #c++ #ffmpeg

基于QT ffmpeg多媒体播放器项目专栏收录该内容

2 篇文章

订阅专栏

该文章已生成可运行项目，

在QT中使用FFMpeg库实现音视频同步是一个复杂但重要的任务，以下将详细讲解实现步骤和方法。

1. 环境准备

首先，你需要安装FFMpeg库，并在QT项目中配置好相关的头文件和库文件路径。假设你已经完成了这些步骤，接下来可以开始编写代码。

2. 整体思路

音视频同步的核心是让音频和视频的播放时间保持一致。通常有三种同步策略：音频同步到视频、视频同步到音频、音视频都同步到外部时钟。这里我们采用视频同步到音频的方式，即以音频的播放时间为基准来调整视频的播放。

3. 代码实现步骤

步骤1：初始化FFMpeg和QT组件

// 头文件

#include <QCoreApplication>
#include <QDebug>
extern "C"{
#include <libavformat/avformat.h>
#include <libavcodec/avcodec.h>
#include <libswscale/swscale.h>
#include <libswresample/swresample.h>
#include <libavutil/imgutils.h>
}

int main(int argc, char *argv[]) {
    QCoreApplication a(argc, argv);

// 初始化FFMpeg库

av_register_all();
avformat_network_init();

// 打开输入文件

AVFormatContext *formatContext = nullptr;
if (avformat_open_input(&formatContext, "input.mp4", nullptr, nullptr)!= 0) 
{
      qDebug() << "Could not open input file";
      return -1;
}

// 查找流信息

if (avformat_find_stream_info(formatContext, nullptr) < 0) 
{
    qDebug() << "Could not find stream information";
    return -1;
}

// 查找音频和视频流

int audioStreamIndex = -1;
int videoStreamIndex = -1;
for (unsigned int i = 0; i < formatContext->nb_streams; i++) 
{
  if (formatContext->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&audioStreamIndex < 0) 
    {
        audioStreamIndex = i;
    }
  if (formatContext->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&videoStreamIndex < 0) 
    {
        videoStreamIndex = i;
    }
}
if (audioStreamIndex < 0 || videoStreamIndex < 0) 
{
    qDebug() << "Could not find audio or video stream";
    return -1;
}

// 查找音频和视频解码器

AVCodec *audioCodec = avcodec_find_decoder(formatContext->streams[audioStreamIndex]->codecpar->codec_id);
AVCodec *videoCodec = avcodec_find_decoder(formatContext->streams[videoStreamIndex]->codecpar->codec_id);
if (!audioCodec ||!videoCodec) 
{
    qDebug() << "Could not find audio or video codec";
    return -1;
}

// 分配解码器上下文

AVCodecContext *audioCodecContext = avcodec_alloc_context3(audioCodec);
AVCodecContext *videoCodecContext = avcodec_alloc_context3(videoCodec);

// 填充解码器上下文参数

avcodec_parameters_to_context(audioCodecContext, formatContext->streams[audioStreamIndex]->codecpar);
avcodec_parameters_to_context(videoCodecContext, formatContext->streams[videoStreamIndex]->codecpar);

// 打开解码器

if (avcodec_open2(audioCodecContext, audioCodec, nullptr) < 0) 
{
    qDebug() << "Could not open audio codec";
    return -1;
}
if (avcodec_open2(videoCodecContext, videoCodec, nullptr) < 0) 
{
    qDebug() << "Could not open video codec";
    return -1;
}

// 后续代码...

return a.exec();
}

步骤2：音频解码和播放

使用SwrContext进行音频重采样，将解码后的音频数据转换为适合播放的格式。这里可以使用QT的QAudioOutput进行音频播放。

// 音频重采样上下文

SwrContext *swrContext = swr_alloc();
av_opt_set_int(swrContext, "in_channel_layout", audioCodecContext->channel_layout, 0);
av_opt_set_int(swrContext, "out_channel_layout", AV_CH_LAYOUT_STEREO, 0);
av_opt_set_int(swrContext, "in_sample_rate", audioCodecContext->sample_rate, 0);
av_opt_set_int(swrContext, "out_sample_rate", 44100, 0);
av_opt_set_sample_fmt(swrContext, "in_sample_fmt", audioCodecContext->sample_fmt, 0);
av_opt_set_sample_fmt(swrContext, "out_sample_fmt", AV_SAMPLE_FMT_S16, 0);
swr_init(swrContext);

// 创建QT音频输出

QAudioFormat audioFormat;
audioFormat.setSampleRate(44100);
audioFormat.setChannelCount(2);
audioFormat.setSampleSize(16);
audioFormat.setCodec("audio/pcm");
audioFormat.setByteOrder(QAudioFormat::LittleEndian);
audioFormat.setSampleType(QAudioFormat::SignedInt);
QAudioOutput *audioOutput = new QAudioOutput(audioFormat);
QIODevice *audioDevice = audioOutput->start();

// 音频解码和播放循环

// 音频解码和播放循环
AVPacket packet;
AVFrame *audioFrame = av_frame_alloc();while (av_read_frame(formatContext, &packet) >= 0) {
    if (packet.stream_index == audioStreamIndex) 
    {
        // 发送数据包到解码器
        if (avcodec_send_packet(audioCodecContext, &packet) < 0) 
        {
            qDebug() << "Error sending audio packet to decoder";
            continue;
        }

        // 接收解码后的帧
        while (avcodec_receive_frame(audioCodecContext, audioFrame) == 0) 
        {
            // 重采样音频数据
            uint8_t *resampledData = nullptr;
            int resampledSamples = swr_convert(swrContext, &resampledData, audioFrame->nb_samples, (const uint8_t **)audioFrame->data, audioFrame->nb_samples);
            // 计算音频播放时间
            double audioPts = av_frame_get_best_effort_timestamp(audioFrame) * av_q2d(formatContext->streams[audioStreamIndex]->time_base);
            // 写入音频数据到QT音频设备
            audioDevice->write((const char *)resampledData, resampledSamples * 2 * 2); 
            // 2 channels, 2 bytes per sample
        }
    }
    av_packet_unref(&packet);
}
av_frame_free(&audioFrame);

步骤3：视频解码和同步播放

以音频的播放时间为基准，调整视频帧的显示时间。

// 视频转换上下文

SwsContext *swsContext = sws_getContext(videoCodecContext->width, 
videoCodecContext>height,
videoCodecContext->pix_fmt, 
videoCodecContext->width, 
videoCodecContext->height,
AV_PIX_FMT_RGB24, 
SWS_BILINEAR, 
nullptr, 
nullptr, 
nullptr);

// 分配RGB帧

AVFrame *rgbFrame = av_frame_alloc();
int numBytes = av_image_get_buffer_size(AV_PIX_FMT_RGB24, videoCodecContext->width, videoCodecContext->height, 1);
uint8_t *buffer = (uint8_t *)av_malloc(numBytes * sizeof(uint8_t));
av_image_fill_arrays(rgbFrame->data, rgbFrame->linesize, buffer, AV_PIX_FMT_RGB24,
videoCodecContext->width, videoCodecContext->height, 1);

// 视频解码和同步播放循环

AVFrame *videoFrame = av_frame_alloc();
while (av_read_frame(formatContext, &packet) >= 0) 
{
    if (packet.stream_index == videoStreamIndex) 
    {
        // 发送数据包到解码器
        if (avcodec_send_packet(videoCodecContext, &packet) < 0) 
        {
            qDebug() << "Error sending video packet to decoder";
            continue;
        }
 // 接收解码后的帧
        while (avcodec_receive_frame(videoCodecContext, videoFrame) == 0) 
        {
            // 转换视频帧到RGB格式
            sws_scale(swsContext, (const uint8_t *const *)videoFrame->data, videoFrame->linesize, 0,videoCodecContext->height, rgbFrame->data, rgbFrame->linesize);
            // 计算视频帧的显示时间
            double videoPts = av_frame_get_best_effort_timestamp(videoFrame) * av_q2d(formatContext->streams[videoStreamIndex]->time_base);
            // 等待音频时间赶上视频时间
            while (audioPts < videoPts) 
            {
                QThread::msleep(1); // 等待1毫秒
            }
            // 显示视频帧，这里可以使用QT的QImage和QLabel进行显示
            QImage image(rgbFrame->data[0], videoCodecContext->width, videoCodecContext->height, QImage::Format_RGB888);
            // 在QT界面上显示image
        }
    }
    av_packet_unref(&packet);
}

av_frame_free(&videoFrame);av_frame_free(&rgbFrame);
av_free(buffer);
sws_freeContext(swsContext);

步骤4：释放资源

// 释放资源
swr_free(&swrContext);
avcodec_free_context(&audioCodecContext);
avcodec_free_context(&videoCodecContext);
avformat_close_input(&formatContext);
avformat_network_deinit();
delete audioOutput;
return a.exec();
}