音视频同步版本【基于外部时钟】--版本的优化，现在视频可以正常至播放结束

人间花木2024-10-26 12:10

基于 音视频同步版本【基于外部时钟】 版本的优化，之前的每个代码版本都没有对获取到的包和帧进行内存释放，导致内存占用过多无法创建新的包崩溃了。这个版本：

  1. 创建普通变量packet对象，而不是指针packet了【这样方便调用av_packet_unref()。如果使用指针就需要在每次while的开头重新new一次，然后结尾在av_packet_free()一次，比较麻烦。】
  2. 在使用了包的地方加上了av_packet_unref()
  3. 在使用帧的地方加上了av_free_free()。

很奇怪！！！！

问题：在主线程的while读取包和帧的地方，第一句的printf有时候会导致程序崩溃。注释掉了就不会有问题，但是如果放开，那么有时候启动就会崩溃，有时候就不会崩溃。

  1. 多线程问题：
    如果程序是多线程的，并且printf被多个线程同时调用，而没有适当的同步机制，则可能会导致数据竞争和崩溃。
    答案：也许是这样？待确认
cpp 复制代码 
#include <iostream>
#include <windows.h>
#include<queue>
#include<chrono>
#include<ctime>
#ifdef __cplusplus  ///
extern "C"
{
// 包含ffmpeg头文件
#include "libavutil/avutil.h"
#include"libavformat/avformat.h"
#include"libswscale/swscale.h"
#include"libswresample/swresample.h"
// 包含SDL头文件
#include"SDL.h"
}
#endif

using namespace std;

class AVSync{
public:
    AVSync() {

    }

    void init()
    {
        start_time = getNowMilliseconds();
    }

    // 获取当前时间的pts应该是多少了
    int getPts() {
        return getNowMilliseconds() - start_time;
    }

    // 毫秒时间戳。【获取1970年到现在过去了多少微秒，例如：1672531199876】
    Uint64 getNowMilliseconds() {
        return getNowMicroseconds() / 1000;
    }

    // 微秒时间戳。【获取1970年到现在过去了多少微秒，例如：1672531199876543】
    Uint64 getNowMicroseconds() {
        using namespace std::chrono;
        //
        system_clock::time_point time_point_now = system_clock::now();
        system_clock::duration duration = time_point_now.time_since_epoch();
        return duration_cast<microseconds>(duration).count();
    }

private:
    // 音视频播放启动的时间--毫秒时间戳
    Uint64 start_time = 0;
};

// 线程停止运行标识，0为正在运行，1为停止
int thread_exit = 0;
// 当前帧音频PCM数据
static Uint8 *audio_pcm_g;
// 当前帧音频PCM数据的字节总大小长度
static Uint32 audio_len_g;
// 音视频帧队列
queue<AVFrame*> audio_frame_queue_;
queue<AVFrame*> video_frame_queue_;
// 将main方法中的变量提取到全局以供两个线程函数中使用
AVFormatContext *input_fmt_ctx = NULL;
int video_idx = -1;
int audio_idx = -1;
AVCodecContext *audio_codec_ctx;
// 音视频同步工具类
AVSync sync_;

// 输出错误信息
void showError(int ret, const char *methodName = "method")
{
    if(ret == 0) {
        return ;
    }
    // 错误消息日志
    char err2str[256];
    // 将返回结果转化为字符串信息
    av_strerror(ret, err2str, sizeof(err2str));
    printf("%s failed, ret:%d, msg:%s\n", methodName, ret, err2str);
}

// 填充PCM数据到SDL中
void fill_audio_pcm(void *udata, Uint8 *stream, int len) {
    // 清空上一帧的数据
    SDL_memset(stream, 0, len);
    // 如果外部线程【主线程读帧】还未读取到数据，那么无法填充PCM到SDL中进行播放
    if(audio_len_g == 0)
    {
        return ;
    }
    // 本次回调结束最多只能取len字节的数据
    // 如果外部读取的帧小于len字节，那么直接填充外部读取到的所有数据即可
    // 如果外部读取的帧大于len字节，那么本次填充len字节的数据，等下次回调再填充 audio_len_g - len字节的数据
    // 【如果audio_len_g - len 还是大于了len字节，那么继续取len填充即可】
    len = len > audio_len_g ? audio_len_g : len;
    //填充PCM数据到SDL中
    SDL_MixAudio(stream, audio_pcm_g, len, SDL_MIX_MAXVOLUME/2);// SDL_MIX_MAXVOLUME/2 为音频大小，在0-128之间调整
    // 更新pcm内存指针指向位置，已经【又】使用了len个字节空间，那么下次需要从当前位置+len的位置开始使用
    audio_pcm_g += len;
    // 更新剩余字节大小数量，已经读取了len个字节大小的数据，那么下次还剩 audio_len_g - len 个字节大小的数据可以使用
    audio_len_g -= len;

}

// 视频播放线程
int play_video_thread(void *opaque) {
    // SDL
    // 初始化视频
    if(SDL_Init(SDL_INIT_VIDEO)) {
        return -1;
    }
    // 视频宽度
    int video_width_ = input_fmt_ctx->streams[video_idx]->codecpar->width;
    // 视频高度
    int video_height_ = input_fmt_ctx->streams[video_idx]->codecpar->height;
    // 创建窗口--显示器
    // 在这里设置显示出来的窗口的总大小
    SDL_Window *win_ = SDL_CreateWindow("苏花末测试窗口", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,
                                    video_width_, video_height_, SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE);
    if(!win_) {
        return -1;
    }
    // 渲染器，用于将纹理渲染到窗口上
    SDL_Renderer *renderer_ = SDL_CreateRenderer(win_, -1, 0);
    if(!renderer_) {
        return -1;
    }
    // 纹理，用于设置渲染图片数据
    SDL_Texture *texture_ = SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_IYUV,  SDL_TEXTUREACCESS_STREAMING, video_width_, video_height_);
    if(!texture_) {
        return -1;
    }
    // Rect--页面显示区域
    SDL_Rect rect_;
    // 刷新事件队列【防止有缓存】
    SDL_PumpEvents();
    SDL_Event event;
    // 线程运行中
    while(thread_exit == 0)
    {
        // 在没有事件的情况下才能刷新页面
        if(SDL_PollEvent(&event) != 0) {
            continue;
        }
        AVFrame *frame = video_frame_queue_.front();
        // 帧的相对时间过去了多久【单位：1/刻度 秒】
        double pts = frame->pts * av_q2d(input_fmt_ctx->streams[video_idx]->time_base);
        printf("video.pts: %f ; now.pts: %f\n", pts, sync_.getPts() / 1000.0);
        pts = pts * 1000;//转换毫秒
        // 当前帧如果实际上应该播放的时间超过了当前时间，则代表当前帧应该在未来播放，现在不能播放
        // 故在这里等待时间
        if(pts > sync_.getPts())
        {
            SDL_Delay(pts - sync_.getPts());//等待时间直到时间到了pts，那么才播放
            // 这里可以使用continue，或者也可以直接向下运行，加个continue方便盘逻辑
            continue;
        }
        // 将当前帧移除待播放队列，因为这一帧马上就播放了
        video_frame_queue_.pop();
        // 如果当前帧已经延迟了500ms了，那么丢弃该帧，直接播放下一帧
        if(pts < sync_.getPts() - 500)
        {
            continue;
        }
        // SDL: output
        // 清空之前的页面
        SDL_RenderClear(renderer_);
        // 设置rect所占区域
        rect_.x = 0;
        rect_.y = 0;
        // 在这里设置rect区域的大小，如果这里和窗口总大小不一样，那么其他地方是黑屏显示
        // 故这里也体现了一个win可以设置多个rect，每个rect可以占据不同的位置
        rect_.w = video_width_;
        rect_.h = video_height_;
        // 通过YUV格式渲染图片
        SDL_UpdateYUVTexture(texture_, &rect_,
                frame->data[0], frame->linesize[0],
                frame->data[1], frame->linesize[1],
                frame->data[2], frame->linesize[2]);
        // 页面内容设置
        SDL_RenderCopy(renderer_, texture_, NULL, &rect_);
        // 显示新的页面
        SDL_RenderPresent(renderer_);
        // 释放内存
        av_frame_free(&frame);
    }
    return 0;
}

// 音频播放线程
int play_audio_thread(void *opaque) {
    int ret = 0;
    // 初始化音频
    if(SDL_Init(SDL_INIT_AUDIO)) {
        return -1;
    }
    // 音频播放上下文，音频播放只能通过这个结构体进行操作
    // 创建 SwrContext 只能使用 swr_alloc() 函数
    SwrContext *swrContext = swr_alloc();
    if(!swrContext)
    {
        cout << "初始化swrContext对象失败" << endl;
        return -1;
    }
    // 设置具体参数来创建 SwrContext对象
    /* channel布局:如立体声、5.1声道、单声道等
     * 采样格式：不同音频格式的采样格式不同，如AAC的采样格式是 AV_SAMPLE_FMT_FLTP，
     *      而MP3的采样格式是 AV_SAMPLE_FMT_S16P
     * 采样率：一秒钟采集多少次样本
     * */
    swrContext = swr_alloc_set_opts(NULL,   //是否需要继承一个存在的SwrContext的内容
                                    AV_CH_LAYOUT_STEREO, //输出的channel布局
                                    AV_SAMPLE_FMT_S16, //输出的采样格式
                                    44100, //输出的采样率
                                    av_get_default_channel_layout(audio_codec_ctx->channels), //输入的channel布局
                                    audio_codec_ctx->sample_fmt, //输入的采用格式
                                    audio_codec_ctx->sample_rate, //输入的采用率
                                    0,
                                    NULL);
    /* 为什么要重采样？
     * 是因为输入的音频可能是mp4格式的，但是我们的电脑只能播放avi格式的音频，
     *  所以需要转换数据，转换为确保我们的电脑一定能播放的格式。
     * */
    // 初始化重采样上下文
    ret = swr_init(swrContext);
    // 初始化重采样失败，那么音频无法播放
    if(ret < 0)
    {
        cout << "初始化重采样上下文失败" << endl;
        return -1;
    }
    // SDL_AudioSpc 是音频播放参数的结构体
    // 期望能够实现的音频参数
    SDL_AudioSpec wanted_spec;
    wanted_spec.freq = 44100; //期望的采样率
    wanted_spec.format = AUDIO_S16SYS; //期望的采样格式
    wanted_spec.channels = 2; //期望的通道格式
    wanted_spec.silence = 0; //期望中静音大小的值
    wanted_spec.samples = 1024; //期望中一帧的数据大小，即样本数
    wanted_spec.callback = fill_audio_pcm;//播放音频时会开启一个线程，反复调用这个回调函数，用来给音频填充PCM
    wanted_spec.userdata = audio_codec_ctx; //回调函数中第一个参数的对象
    // 按照指定参数打开真实的物理设备
    ret = SDL_OpenAudio(&wanted_spec, NULL);
    if(ret < 0)
    {
        cout << "打开音频设备失败" << endl;
        return -1;
    }
    // 开始播放音频
    SDL_PauseAudio(0);
    // 分配输出音频数据
    Uint8 *out_buffer = nullptr;
    // 线程运行中
    while(thread_exit == 0)
    {
        // 如果队列为空，则等待帧
        if(audio_frame_queue_.empty())
        {
            SDL_Delay(1);
            continue;
        }
        AVFrame *frame = audio_frame_queue_.front();
        // 帧的相对时间过去了多久【单位：1/刻度 秒】
        double pts = frame->pts * av_q2d(input_fmt_ctx->streams[audio_idx]->time_base);
        printf("audio.pts: %f ; now.pts: %f\n", pts, sync_.getPts() / 1000.0);
        pts = pts * 1000;//转换毫秒
        // 当前帧如果实际上应该播放的时间超过了当前时间，则代表当前帧应该在未来播放，现在不能播放
        // 故在这里等待时间
        if(pts > sync_.getPts())
        {
            SDL_Delay(pts - sync_.getPts());//等待时间直到时间到了pts，那么才播放
            // 这里可以使用continue，或者也可以直接向下运行，加个continue方便盘逻辑
            continue;
        }
        // 将当前帧移除待播放队列，因为这一帧马上就播放了
        audio_frame_queue_.pop();
        // 如果当前帧已经延迟了500ms了，那么丢弃该帧，直接播放下一帧
        if(pts < sync_.getPts() - 500)
        {
            continue;
        }
        // 获取输入的样本数
        int in_samples = frame->nb_samples;
        // 目标样本数【想要输出的样本数】
        int dst_samples = av_rescale_rnd(in_samples, wanted_spec.freq, frame->sample_rate, AV_ROUND_UP);
        // 计算需要输出的样本数内存空间大小
        int out_buffer_size = av_samples_get_buffer_size(NULL, wanted_spec.channels,
                                                         dst_samples, AV_SAMPLE_FMT_S16, 0);
        // 如果输出的音频数据未开辟过空间，那么开辟空间
        if(!out_buffer)
        {
            // 输出数据的空间大小即为计算出来需要输出的样本数大小
            out_buffer = (Uint8 *)av_malloc(out_buffer_size);
        }
        // 返回每个通道需要输出的样本数，错误时返回负值
        int sample_count = swr_convert(swrContext, &out_buffer, dst_samples,
                                      (const Uint8 **)frame->data, in_samples);// frame->data 即为采样到的数据
        // 释放内存
        av_frame_free(&frame);
        // 获取不到样本数了，那么进行下一个包数据的读取
        if(sample_count < 0)
        {
            break;
        }
        // 计算这一帧的字节数大小/长度
        int out_size = sample_count * wanted_spec.channels *av_get_bytes_per_sample(AV_SAMPLE_FMT_S16);
        // 如果回调函数中的字节数还未处理完，那么不能进行下一个音频帧的处理
        while(audio_len_g > 0)
            SDL_Delay(1);
        // 回调函数中的字节已经处理完了，那么可以填充下一个音频帧需要的数据了
        // 这一帧的字节长度
        audio_len_g = out_size;
        // 填充pcm数据
        audio_pcm_g = (Uint8 *)out_buffer;
    }
    return 0;
}

// 将帧写入队列
void push_frame(queue<AVFrame*> &queue_, AVFrame *frame_) {
    AVFrame *frame = av_frame_alloc();
    av_frame_move_ref(frame, frame_);
    queue_.push(frame);
}

#undef main
int main(int argc, char *argv[])
{
    SetConsoleOutputCP(CP_UTF8);
    if(argc < 2)
    {
        cout << "请输入视频地址" << endl;
        return -1;
    }
    // 获取视频地址
    char *url = argv[1];
    // 方法调用结果
    int ret = 0;
    // FFmpeg
    // AVFormatContext 是音视频开发使用到最多的结构体，无论什么函数基本上都会用到它
    // AVFormatContext 只能通过 avformat_alloc_context() 创建空的对象
    input_fmt_ctx = avformat_alloc_context();
    // 加载视频内容到音视频格式上下文中
    ret = avformat_open_input(&input_fmt_ctx, url, NULL, NULL);
    // 输出日志
    showError(ret);
    // 查看流信息,可以不写，只是单纯拿返回值来做校验的
    ret = avformat_find_stream_info(input_fmt_ctx, NULL);
    // 输出日志
    showError(ret);
    // 输出视频信息，可以不写
    av_dump_format(input_fmt_ctx, 0, url, 0);
    // 查找指定流的idx，如果使用不到，可以不写; AVMEDIA_TYPE_VIDEO 代表视频流，AVMEDIA_TYPE_AUDIO代表音频流
    video_idx = av_find_best_stream(input_fmt_ctx, AVMEDIA_TYPE_VIDEO, -1, -1, NULL, 0);
    audio_idx = av_find_best_stream(input_fmt_ctx, AVMEDIA_TYPE_AUDIO, -1, -1, NULL, 0);
    printf("video_idx: %d , audio_idx: %d\n", video_idx, audio_idx);
    // AVCodecContext 是解码器上下文，需要对帧处理基本上都会用到它
    // AVCodecContext 只能通过 avcodec_alloc_context3(NULL) 创建空的对象
    // 视频解码器上下文
    AVCodecContext *video_codec_ctx = avcodec_alloc_context3(NULL);
    // 将音视频格式上下文中的参数加载到解码器上下文对象中
    ret = avcodec_parameters_to_context(video_codec_ctx, input_fmt_ctx->streams[video_idx]->codecpar);
    // 输出日志
    showError(ret);
    // 指定物理解码器；这里参数传的是codec_ctx->codec_id，实际上物理解码器有很多中，这里可以传不同的内容
    AVCodec *video_codec = avcodec_find_decoder(video_codec_ctx->codec_id);
    // 将物理解码器加载到解码器上下文中
    ret = avcodec_open2(video_codec_ctx, video_codec, NULL);
    // 音频解码器上下文
    audio_codec_ctx = avcodec_alloc_context3(NULL);
    // 将音视频格式上下文中的参数加载到解码器上下文对象中
    ret = avcodec_parameters_to_context(audio_codec_ctx, input_fmt_ctx->streams[audio_idx]->codecpar);
    // 输出日志
    showError(ret);
    // 指定物理解码器；这里参数传的是codec_ctx->codec_id，实际上物理解码器有很多中，这里可以传不同的内容
    AVCodec *audio_codec = avcodec_find_decoder(audio_codec_ctx->codec_id);
    // 将物理解码器加载到解码器上下文中
    ret = avcodec_open2(audio_codec_ctx, audio_codec, NULL);
    // 输出日志
    showError(ret);
    // 包，用来获取音视频格式上下文中的数据
    // AVPacket 只能通过 av_packet_alloc() 创建对象
    AVPacket pkt;
    // 开启播放线程
    SDL_CreateThread(play_video_thread, NULL, NULL);
    SDL_CreateThread(play_audio_thread, NULL, NULL);
    // 设置时钟
    sync_.init();
    // output and readFrame
    while(1)
    {
        // printf("video_queue.size: %d ; audio_queue.size: %d\n", video_frame_queue_.size(), audio_frame_queue_.size());
        // 防止读取内存过大
        if(video_frame_queue_.size() >= 100 || audio_frame_queue_.size() >= 100)
        {
            SDL_Delay(1);
            continue;
        }
        // FFmpeg: readFrame
        // 获取该音视频格式上下文中的第一个包，并将从音视频格式上下文中移除
        // 则代表了每次调用都会获取到新的包，之前的包不会再在该音视频格式上下文中找到了
        ret = av_read_frame(input_fmt_ctx, &pkt);
        // 如果包数据读取完毕，则代表视频播放结束了
        if(ret < 0)
        {
            cout << "play video finish" << endl;
            break;
        }
        // AVFrame 只能通过 av_frame_alloc() 创建对象
        AVFrame *frame = av_frame_alloc();
        // 音频帧
        if(pkt.stream_index == audio_idx)
        {
            // 将包加载到解码器上下文中进行解码
            ret = avcodec_send_packet(audio_codec_ctx, &pkt);
            // 对应音频的包数据来说，一次包读取，可以获取到多个frame
            while(1)
            {
                // 读取解码后的包中的帧
                ret = avcodec_receive_frame(audio_codec_ctx, frame);
                // 如果 AVERROR(EAGAIN) == ret，则代表这个包无法获取到帧，需要再次加载下一个包配合解析帧
                // 如果所有的帧都读取完成了，那么开始读取下一个包
                if(ret == AVERROR(EAGAIN))
                {
                    break;
                }
                // 将帧添加到队列中
                push_frame(audio_frame_queue_, frame);
            }
        }
        // 视频帧
        else if(pkt.stream_index == video_idx)
        {
            // 将包加载到解码器上下文中进行解码
            ret = avcodec_send_packet(video_codec_ctx, &pkt);
            // 读取解码后的包中的帧
            ret = avcodec_receive_frame(video_codec_ctx, frame);
            // 如果 AVERROR(EAGAIN) == ret，则代表这个包无法获取到帧，需要再次加载下一个包配合解析帧
            if(AVERROR(EAGAIN) == ret)
            {
                continue;
            }
            // 将帧添加到队列中
            push_frame(video_frame_queue_, frame);
        }
        // 释放内存
        av_packet_unref(&pkt);
    }
    // 加载帧完成了，现在需要等待所有帧播放完毕
    while(!video_frame_queue_.empty() || !audio_frame_queue_.empty())
    {
        printf("video_queue.size: %d ; audio_queue.size: %d --wait_over\n", video_frame_queue_.size(), audio_frame_queue_.size());
        SDL_Delay(10);
    }
    // 标记线程结束了
    thread_exit = 1;
    system("pause");
    return 0;
}
相关推荐
EasyCVR1 小时前
私有化部署视频平台EasyCVR宇视设备视频平台如何构建视频联网平台及升级视频转码业务？
大数据·网络·音视频·h.265
天空中的野鸟1 小时前
Android音频采集
android·音视频
计算机毕设孵化场2 小时前
计算机毕设-基于springboot的高校网上缴费综合务系统视频的设计与实现（附源码+lw+ppt+开题报告）
java·spring boot·计算机外设·音视频·课程设计·高校网上缴费综合务系统视频·计算机毕设ppt
lxkj_20247 小时前
使用线程局部存储解决ffmpeg中多实例调用下自定义日志回调问题
ffmpeg
简鹿办公9 小时前
如何提取某站 MV 视频中的音乐为 MP3 音频
音视频·简鹿视频格式转换器·视频提取mp3音频
yufengxinpian10 小时前
集成了高性能ARM Cortex-M0+处理器的一款SimpleLink 2.4 GHz无线模块-RF-BM-2340B1
单片机·嵌入式硬件·音视频·智能硬件
runing_an_min11 小时前
ffmpeg视频滤镜：替换部分帧-freezeframes
ffmpeg·音视频·freezeframes
ruizhenggang11 小时前
ffmpeg本地编译不容易发现的问题 — Error:xxxxx not found!
ffmpeg
runing_an_min13 小时前
ffmpeg视频滤镜：提取缩略图-framestep
ffmpeg·音视频·framestep
小曲曲14 小时前
接口上传视频和oss直传视频到阿里云组件
javascript·阿里云·音视频
热门推荐
01(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明02PyTorch机器学习实现液态神经网络03【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总04玄机平台应急响应—webshell查杀05Coze扣子平台完整体验和实践（附国内和国际版对比）06Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO07怎样让音频速度变慢？请跟随以下方法进行操作08Unity中PICO实现 隔空取物 和 接触抓取物体09RAG 实践- Ollama+RagFlow 部署本地知识库10【目标跟踪】相机运动补偿