ffplay.c源码解析(1)

swordsli

已于 2023-07-18 14:37:19 修改

阅读量182

点赞数 1

分类专栏： ffmpeg 文章标签： ffmpeg 音视频 c语言

于 2023-07-18 11:45:16 首次发布

本文链接：https://blog.csdn.net/qq_41866986/article/details/131783220

版权

ffmpeg 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

一、数据结构

首先需要了解一下ffplay中定义的几个主要结构体(以最新的ffplay.c为例，基于ffmpeg6.0)：

先说明一下一些宏定义的含义吧：

#define MAX_QUEUE_SIZE (15 * 1024 * 1024)
#define MIN_FRAMES 25
#define EXTERNAL_CLOCK_MIN_FRAMES 2
#define EXTERNAL_CLOCK_MAX_FRAMES 10

/* 最小SDL音频缓冲区大小，以样本为单位 */
#define SDL_AUDIO_MIN_BUFFER_SIZE 512
/* 计算实际缓冲区大小，注意不要导致过于频繁的音频回调 */
#define SDL_AUDIO_MAX_CALLBACKS_PER_SEC 30

/* 音量控制的步长（dB） */
#define SDL_VOLUME_STEP (0.75)

/* 如果低于最小AV同步阈值，则不进行AV同步校正 */
#define AV_SYNC_THRESHOLD_MIN 0.04
/* 如果高于最大AV同步阈值，则进行AV同步校正 */
#define AV_SYNC_THRESHOLD_MAX 0.1
/* 如果帧持续时间长于此，则不会对其进行复制以补偿AV同步 */
#define AV_SYNC_FRAMEDUP_THRESHOLD 0.1
/* 如果误差太大，则不进行AV校正 */
#define AV_NOSYNC_THRESHOLD 10.0

/* 更改最大音频速度以获得正确同步 */
#define SAMPLE_CORRECTION_PERCENT_MAX 10

/* 基于缓冲区填充度的实时源外部时钟速度调节常数 */
#define EXTERNAL_CLOCK_SPEED_MIN  0.900
#define EXTERNAL_CLOCK_SPEED_MAX  1.010
#define EXTERNAL_CLOCK_SPEED_STEP 0.001

/* 我们使用AUDIO_DIFF_AVG_NB A-V的差值来进行平均 */
#define AUDIO_DIFF_AVG_NB   20

/* 对可能需要的屏幕刷新的轮询（至少如此频繁）应该小于1/fps */
#define REFRESH_RATE 0.01

/* NOTE: 大小必须足够大，以补偿硬件音频缓冲区大小 */
/* TODO: 我们假设解码和重新采样的帧适合这个缓冲区 */
#define SAMPLE_ARRAY_SIZE (8 * 65536)

VideoState 播放器封装

enum {
    /* 根据时钟信号进行音视频同步的选项 */
    AV_SYNC_AUDIO_MASTER,   // 与音频时钟同步
    AV_SYNC_VIDEO_MASTER,   // 与视频时钟同步
    AV_SYNC_EXTERNAL_CLOCK, // 与外部时钟同步
};

typedef struct VideoState {
    SDL_Thread *read_tid;   // 读线程句柄
    const AVInputFormat *iformat;   // 指向demuxer，解复用器格式：dshow、flv
    int abort_request;      // =1请求退出播放
    int force_refresh;      // =1需要刷新画面
    int paused;             // =1暂停，=0播放
    int last_paused;        // 保存暂停/播放状态
    int queue_attachments_req;      // mp3、acc音频文件附带的专辑封面，所以需要注意的是音频文件不一定只存在音频流本身
    int seek_req;           // 标识一次seek请求
    int seek_flags;         // seek标志，按字节还是时间seek，诸如AVSEEK_BYTE等
    int64_t seek_pos;       // 请求seek的目标位置（当前位置+增量）
    int64_t seek_rel;       // 本次seek的增量
    int read_pause_return;
    AVFormatContext *ic;    // iformat的上下文
    int realtime;           // =1为实时流，还是本地文件

    /* 三种同步的时钟 */
    Clock audclk;           // 音频时钟
    Clock vidclk;           // 视频时钟
    Clock extclk;           // 外部时钟

    FrameQueue pictq;       // 视频frame队列
    FrameQueue subpq;       // 字幕frame队列
    FrameQueue sampq;       // 采样frame队列

    Decoder auddec;         // 音频解码器
    Decoder viddec;         // 视频解码器
    Decoder subdec;         // 字幕解码器

    int audio_stream;       // 音频流索引

    int av_sync_type;       // 音视频同步类型，默认audio master

    double audio_clock;     // 当前音频帧的pts+当前帧Duration
    int audio_clock_serial; // 播放序列，seek可改变此值

    /* 以下四个参数，非audio master 同步方式使用 */
    double audio_diff_cum;  // 用于AV差值平均计算
    double audio_diff_avg_coef;
    double audio_diff_threshold;
    int audio_diff_avg_count;

    AVStream *audio_st;     // 音频流
    PacketQueue audioq;     // 音频packet队列
    int audio_hw_buf_size;  // SDL音频缓冲区的大小
    uint8_t *audio_buf;     // 指向需要重采样的数据
    uint8_t *audio_buf1;    // 指向重采样后的数据
    unsigned int audio_buf_size;    // 带播放的一帧音频数据（audio_buf）大小
    unsigned int audio_buf1_size;   // 申请到的音频缓冲区audio_buf1实际大小
    int audio_buf_index;            // 更新拷贝位置，当前音频帧中已拷贝入SDL音频缓冲区的位置索引
    int audio_write_buf_size;       // 当前音频帧中尚未拷贝入SDL音频缓冲区的数据量
    int audio_volume;               // 音量
    int muted;                      // =1静音，=0正常
    struct AudioParams audio_src;   // 音频frame的参数
#if CONFIG_AVFILTER
    struct AudioParams audio_filter_src;
#endif
    struct AudioParams audio_tgt;   // SDL支持的音频参数，重采样转换
    struct SwrContext *swr_ctx;     // 音频重采样context
    int frame_drops_early;          // 丢弃视频packet计数
    int frame_drops_late;           // 丢弃视频frame计数

    enum ShowMode {
        SHOW_MODE_NONE = -1, SHOW_MODE_VIDEO = 0, SHOW_MODE_WAVES, SHOW_MODE_RDFT, SHOW_MODE_NB
    } show_mode;
    int16_t sample_array[SAMPLE_ARRAY_SIZE];
    int sample_array_index;
    int last_i_start;
    RDFTContext *rdft;
    int rdft_bits;
    FFTSample *rdft_data;
    int xpos;
    double last_vis_time;
    SDL_Texture *vis_texture;
    SDL_Texture *sub_texture;       // 字幕显示
    SDL_Texture *vid_texture;       // 视频显示

    int subtitle_stream;            // 字幕流索引
    AVStream *subtitle_st;          // 字幕流
    PacketQueue subtitleq;          // 字幕packet队列

    double frame_timer;             // 记录最后一帧播放时间
    double frame_last_returned_time;
    double frame_last_filter_delay;
    int video_stream;               // 视频流索引
    AVStream *video_st;             // 视频流
    PacketQueue videoq;             // 视频packet队列
    double max_frame_duration;      // 一帧最大的间隔，即帧的最大持续时间，超过这个值，我们认为跳跃是时间戳的不连续性
    struct SwsContext *img_convert_ctx; // 输入输出图像
    struct SwsContext *sub_convert_ctx; // 字幕尺寸格式变换
    int eof;                        // 是否读取结束

    char *filename;                 // 文件名
    int width, height, xleft, ytop; // 宽，高，x起始坐标，y起始坐标
    int step;                       // =1步进播放模式，=0其他模式

#if CONFIG_AVFILTER
    int vfilter_idx;
    AVFilterContext *in_video_filter;   // 视频链中的第一个滤波器
    AVFilterContext *out_video_filter;  // 视频链中的最后一个滤波器
    AVFilterContext *in_audio_filter;   // 音频链中的第一个滤波器
    AVFilterContext *out_audio_filter;  // 音频链中的最后一个滤波器
    AVFilterGraph *agraph;              // 音频滤波器图
#endif

    /* 保存最近的相应audio、video、subtitle流的stream_index */
    int last_video_stream, last_audio_stream, last_subtitle_stream;

    SDL_cond *continue_read_thread;     // 当读取线程队列满后进入休眠，可通过condition唤醒读取线程
} VideoState;

Clock 时钟封装

typedef struct Clock {
    double pts;                 // 时钟基础, 当前帧(待播放)显示时间戳，播放后,当前帧变成上一帧
    double pts_drift;           // 当前pts与当前系统时钟的差值, audio、video对于该值是独立的
    double last_updated;        // 最后一次更新的系统时钟
    double speed;               // 时钟速度控制，用于控制播放速度
    int serial;                 // 播放序列，所谓播放序列就是一段连续的播放动作，一个seek操作会启动一段新的播放序列
    int paused;                 // =1 说明是暂停状态
    int *queue_serial;          // 指向packet_serial
} Clock;

数据包数据帧（音频、视频、字幕）队列结构的封装

typedef struct MyAVPacketList {
    AVPacket *pkt;      // 解封装后的数据
    int serial;         // 播放序列
} MyAVPacketList;
/* MyAVPacketList可以理解为队列的一个节点，serial标记当前节点的播放序号，
 * 主要用来区分是否连续数据，每做一次seek，serial都会+1以区分不同的播放序列。 */

typedef struct PacketQueue {
    AVFifo *pkt_list;   // 存储队首，队尾指针
    int nb_packets;     // 包数量，也就是队列元素数量
    int size;           // 队列所有元素的数据大小总和
    int64_t duration;   // 队列所有元素的数据播放持续时间
    int abort_request;  // 用户退出请求标志
    int serial;         // 播放序列号
    SDL_mutex *mutex;   // 用于维持PacketQueue的多线程安全
    SDL_cond *cond;     // 用于读、写线程相互通知
} PacketQueue;

typedef struct AudioParams {
    int freq;                   // 采样率
    AVChannelLayout ch_layout;  // 通道布局，如：2.1声道，5.1声道
    enum AVSampleFormat fmt;    // 音频采样格式，如：AV_SAMPLE_FMT_S16
    int frame_size;             // 一个采样单元占用的字节数
    int bytes_per_sec;          // 一秒时间的字节数
} AudioParams;

/* 用于处理所有类型的解码数据和分配的渲染缓冲区的通用结构 */
typedef struct Frame {
    AVFrame *frame;     // 指向数据帧，音视频解码后的数据
    AVSubtitle sub;     // 用于字幕
    int serial;         // 播放序列，在seek时serial会变化
    double pts;         // 帧的时间戳，单位为秒
    double duration;    // 该帧持续时间，单位为秒
    int64_t pos;        // 该帧在输入文件中的字节位置
    int width;
    int height;
    int format;
    AVRational sar;
    int uploaded;       // 记录该帧是否已经显示过
    int flip_v;         // 0正常播放，1旋转180
} Frame;

typedef struct FrameQueue {
    Frame queue[FRAME_QUEUE_SIZE];  // 队列大小，数字太大时占用内存就会越大，需要注意设置
    int rindex;         // 读索引，待播放时读取此帧进行播放，播放后此帧成为上一帧
    int windex;         // 写索引
    int size;           // 当前总帧数
    int max_size;       // 可存储最大帧数
    int keep_last;      // =1 说明要在队列里面保持最后一帧的数据不释放，只在销毁队列的时候才真正释放
    int rindex_shown;   // 初始化值为0，配合kepp_last=1使用
    SDL_mutex *mutex;
    SDL_cond *cond;
    PacketQueue *pktq;  // 数据包缓冲队列
} FrameQueue;

Decoder

typedef struct Decoder {
    AVPacket *pkt;              // packet缓存
    PacketQueue *queue;         // packet队列，音频归音频、视频归视频
    AVCodecContext *avctx;      // 解码器上下文
    int pkt_serial;             // 包序列
    int finished;               // =0解码器处理工作状态，!=0处于空闲状态
    int packet_pending;         // =0解码器处于异常状态，需要考虑重置解码器，=1解码器处于正常状态
    SDL_cond *empty_queue_cond; // 检查到packet队列为空时发送signal缓存read_thread读取数据
    int64_t start_pts;          // 初始化时是stream的start_time
    AVRational start_pts_tb;    // 初始化时是stream的time_base
    int64_t next_pts;           // 记录最近一次解码后的frame的pts
    AVRational next_pts_tb;     // next_pts的单位
    SDL_Thread *decoder_tid;    // 线程句柄
} Decoder;

二、main函数程序入口

接下来需要解析一下ffplay.c的main函数，即程序入口：

/* Called from the main */
int main(int argc, char **argv)
{
    int flags;
    VideoState *is;

    init_dynload();

    av_log_set_flags(AV_LOG_SKIP_REPEATED);
    parse_loglevel(argc, argv, options);

    /* register all codecs, demux and protocols */
#if CONFIG_AVDEVICE
    avdevice_register_all();
#endif
    avformat_network_init();

    init_opts();

    signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).    */
    signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */

    show_banner(argc, argv, options);

    parse_options(NULL, argc, argv, options, opt_input_file);

    if (!input_filename) {
        show_usage();
        av_log(NULL, AV_LOG_FATAL, "An input file must be specified\n");
        av_log(NULL, AV_LOG_FATAL,
               "Use -h to get full help or, even better, run 'man %s'\n", program_name);
        exit(1);
    }

    if (display_disable) {
        video_disable = 1;
    }
    flags = SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER;
    if (audio_disable)
        flags &= ~SDL_INIT_AUDIO;
    else {
        /* Try to work around an occasional ALSA buffer underflow issue when the
         * period size is NPOT due to ALSA resampling by forcing the buffer size. */
        if (!SDL_getenv("SDL_AUDIO_ALSA_SET_BUFFER_SIZE"))
            SDL_setenv("SDL_AUDIO_ALSA_SET_BUFFER_SIZE","1", 1);
    }
    if (display_disable)
        flags &= ~SDL_INIT_VIDEO;
    if (SDL_Init (flags)) {
        av_log(NULL, AV_LOG_FATAL, "Could not initialize SDL - %s\n", SDL_GetError());
        av_log(NULL, AV_LOG_FATAL, "(Did you set the DISPLAY variable?)\n");
        exit(1);
    }

    SDL_EventState(SDL_SYSWMEVENT, SDL_IGNORE);
    SDL_EventState(SDL_USEREVENT, SDL_IGNORE);

    av_init_packet(&flush_pkt);
    flush_pkt.data = (uint8_t *)&flush_pkt;

    if (!display_disable) {
        int flags = SDL_WINDOW_HIDDEN;
        if (alwaysontop)
#if SDL_VERSION_ATLEAST(2,0,5)
            flags |= SDL_WINDOW_ALWAYS_ON_TOP;
#else
            av_log(NULL, AV_LOG_WARNING, "Your SDL version doesn't support SDL_WINDOW_ALWAYS_ON_TOP. Feature will be inactive.\n");
#endif
        if (borderless)
            flags |= SDL_WINDOW_BORDERLESS;
        else
            flags |= SDL_WINDOW_RESIZABLE;
        window = SDL_CreateWindow(program_name, SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, default_width, default_height, flags);
        SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "linear");
        if (window) {
            renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
            if (!renderer) {
                av_log(NULL, AV_LOG_WARNING, "Failed to initialize a hardware accelerated renderer: %s\n", SDL_GetError());
                renderer = SDL_CreateRenderer(window, -1, 0);
            }
            if (renderer) {
                if (!SDL_GetRendererInfo(renderer, &renderer_info))
                    av_log(NULL, AV_LOG_VERBOSE, "Initialized %s renderer.\n", renderer_info.name);
            }
        }
        if (!window || !renderer || !renderer_info.num_texture_formats) {
            av_log(NULL, AV_LOG_FATAL, "Failed to create window or renderer: %s", SDL_GetError());
            do_exit(NULL);
        }
    }

    is = stream_open(input_filename, file_iformat);
    if (!is) {
        av_log(NULL, AV_LOG_FATAL, "Failed to initialize VideoState!\n");
        do_exit(NULL);
    }

    event_loop(is);

    /* never returns */

    return 0;
}

该部分代码是基于ffmpeg4.2.2版本进行学习的，与最新的ffmpeg6.0在一些结构体的定义方面有部分差别，但是基本思路逻辑相差不大。

按顺序调用了以下函数：

首先是初始化一些参数：

init_dynload()：初始化动态加载库的函数，用于在 Windows 系统上初始化动态加载库。
av_log_set_flags(AV_LOG_SKIP_REPEATED) ：设置日志输出标志，跳过重复的日志消息。
parse_loglevel(argc, argv, options);：解析命令行参数中的日志级别选项。

接下来的部分是注册所有的编解码器、解封装器和协议：

av_register_all()：注册所有编码器和解码器。
avformat_network_init()：初始化网络协议，在使用rtsp获取网络流等时需要调用该函数。
init_opts()：初始化一些选项。该函数在此只是调用av_dict_set函数设置了一对键值对。

之后是设置信号处理器函数:

signal(SIGINT , sigterm_handler): 设置当接收到中断信号时调用 sigterm_handler 函数。
signal(SIGTERM, sigterm_handler): 设置当接收到终止信号时调用 sigterm_handler 函数。

然后是显示程序的横幅和解析命令行参数:

show_banner(argc, argv, options)：显示程序的横幅信息，包括版本号等。
parse_options(NULL, argc, argv, options, opt_input_file)：解析命令行参数，根据参数执行不同的操作。

接下来进行一些参数以及状态的判断：

如果没有指定输入文件，则显示用法信息，并输出错误日志，然后退出程序。
如果禁用了显示，将视频禁用标志 video_disable 设置为1。
初始化SDL库并检查初始化是否成功。这里设置了需要初始化的子系统，包括视频、音频和定时器。根据禁用音频和显示的标志设置相应的子系统初始化标志。如果初始化失败，则输出错误日志并退出程序。

设置特定类型的事件状态，这里忽略了系统事件和用户自定义事件。

SDL_EventState(SDL_SYSWMEVENT, SDL_IGNORE);
SDL_EventState(SDL_USEREVENT, SDL_IGNORE);

初始化SDL渲染

av_init_packet(&flush_pkt)：初始化一个packet用于刷新音视频缓冲区
如果未禁用显示，创建一个SDL窗口，并根据选项设置窗口的属性。
然后创建一个SDL渲染器，并根据硬件支持情况选择硬件加速渲染器或软件渲染器。
如果窗口或渲染器创建失败，或者没有可用的纹理格式，则输出错误日志并退出程序。

打开数据流并设置循环播放

is = stream_open(input_filename, file_iformat)：打开输入流并将其存储在 VideoState结构体中，如果初始化失败，则输出错误日志并退出程序。
event_loop(is)：进入事件循环，等待和处理用户输入和其他事件。
return 0：程序执行完毕，返回0表示成功退出。

三、stream_open函数解析

函数调用及说明已经添加到代码中进行注释和解析了。

static VideoState *stream_open(const char *filename,
                               const AVInputFormat *iformat)
{
    VideoState *is;

    /* 分配 VideoState 结构体的内存空间，并将其初始化为零。如果分配失败，则返回 NULL。 */
    is = av_mallocz(sizeof(VideoState));
    if (!is)
        return NULL;
    /* 将视频、音频和字幕流的索引初始化为-1。 */
    is->last_video_stream = is->video_stream = -1;
    is->last_audio_stream = is->audio_stream = -1;
    is->last_subtitle_stream = is->subtitle_stream = -1;
    /* 将文件名复制到 VideoState 结构体中。如果复制失败，则跳转到 fail 标签。 */
    /* 并将输入格式、y轴顶部偏移量和x轴左侧偏移量设置为给定的值。 */
    is->filename = av_strdup(filename);
    if (!is->filename)
        goto fail;
    is->iformat = iformat;
    is->ytop    = 0;
    is->xleft   = 0;

    /* start video display */
    /* 初始化视频帧队列、字幕帧队列和音频帧队列，并设置它们的大小。如果初始化失败，则跳转到 fail 标签。 */
    if (frame_queue_init(&is->pictq, &is->videoq, VIDEO_PICTURE_QUEUE_SIZE, 1) < 0)
        goto fail;
    if (frame_queue_init(&is->subpq, &is->subtitleq, SUBPICTURE_QUEUE_SIZE, 0) < 0)
        goto fail;
    if (frame_queue_init(&is->sampq, &is->audioq, SAMPLE_QUEUE_SIZE, 1) < 0)
        goto fail;

    /* 初始化视频包队列、音频包队列和字幕包队列。如果初始化失败，则跳转到 fail 标签。 */
    if (packet_queue_init(&is->videoq) < 0 ||
        packet_queue_init(&is->audioq) < 0 ||
        packet_queue_init(&is->subtitleq) < 0)
        goto fail;

    /* 条件变量 continue_read_thread，用于控制读取线程的继续运行。如果创建失败，则跳转到 fail 标签。 */
    if (!(is->continue_read_thread = SDL_CreateCond())) {
        av_log(NULL, AV_LOG_FATAL, "SDL_CreateCond(): %s\n", SDL_GetError());
        goto fail;
    }

    /* 初始化视频时钟、音频时钟和外部时钟，并将音频时钟序列号设置为-1。 */
    init_clock(&is->vidclk, &is->videoq.serial);
    init_clock(&is->audclk, &is->audioq.serial);
    init_clock(&is->extclk, &is->extclk.serial);
    is->audio_clock_serial = -1;
    if (startup_volume < 0)
        av_log(NULL, AV_LOG_WARNING, "-volume=%d < 0, setting to 0\n", startup_volume);
    if (startup_volume > 100)
        av_log(NULL, AV_LOG_WARNING, "-volume=%d > 100, setting to 100\n", startup_volume);
    /* 对初始音量进行修正，确保在合理范围内（0到100）。然后将音频音量和静音标志设置为修正后的值。 */
    startup_volume = av_clip(startup_volume, 0, 100);
    startup_volume = av_clip(SDL_MIX_MAXVOLUME * startup_volume / 100, 0, SDL_MIX_MAXVOLUME);
    is->audio_volume = startup_volume;
    is->muted = 0;
    /* 设置音视频同步类型，并创建读取线程。如果创建读取线程失败，则输出错误日志并跳转到 fail 标签。 */
    is->av_sync_type = av_sync_type;
    is->read_tid     = SDL_CreateThread(read_thread, "read_thread", is);
    if (!is->read_tid) {
        av_log(NULL, AV_LOG_FATAL, "SDL_CreateThread(): %s\n", SDL_GetError());
fail:
        stream_close(is);
        return NULL;
    }
    return is;
}