^-^
音视频开发_FFmpeg QT 播放器实现
最近更新：2024-09-23   |   字数总计：2.1k   |   阅读估时：9分钟   |   阅读量：次
  1. 分析
    1. 简介
    2. 模块分解
    3. 核心问题
  2. 界面设计
    1. CtrlBar
    2. PlayListWind
    3. TitleBar
    4. 整体框架
  3. 界面与核心交互——消息队列
  4. 代码结构
  5. 核心类与接口
    1. 核心函数
      1. 函数ijkmp_create
      2. 函数ijkmp_destroy
      3. 函数ijkmp_prepare_async
      4. 函数ijkmp_start
      5. 函数ijkmp_stop
    2. 类与接口
      1. 消息循环的处理
        1. 额外开辟的两个独立线程：
        2. 消息处理流程：
        3. 发出消息（FFPlayer）
        4. 由IjkMediaPlayer处理阶段一
        5. 由Ui::MainWind处理阶段二
    3. 核心函数2
      1. stream_open
      2. stream_close
      3. stream_component_open
      4. stream_component_close
    4. 类与接口2

分析

简介

  • 实现一个带界面的播放器，功能：播放、停止、暂停、拖动、快进、快退、变速

模块分解

  • 控制线程
  • 读取数据线程
  • 音频解码线程
  • 视频解码线程
  • 音频声音输出
  • 视频画面渲染

核心问题

  1. 缓存队列最大多少？多线程安全？队列满了怎么办？
  2. 软件解码与硬件解码？
  3. 音视频同步方式？三种方式的区别？只有视频如何播放？只有音频如何播放？
  4. 暂停如何实现？
  5. 逐帧如何播放？
  6. 拖动播放如何实现？
  7. 快进快退如何实现？
  8. 调节声音如何实现？
  9. 变速播放如何实现？
  10. 如果是网络流如何实现最低延迟？

界面设计

CtrlBar

PlayListWind

TitleBar

整体框架

界面与核心交互——消息队列

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
#ifndef FFMSG_QUEUE_H
#define FFMSG_QUEUE_H
#include "SDL.h"

typedef struct AVMessage{
    int what; // 消息类型
    int arg1; // 参数1
    int arg2; // 参数2
    void *obj;  // 如果arg1 arg2还不够存储消息则使用该参数
    void (*free_l)(void *obj); // obj的对象是分配的，这里要给出函数怎么释放
    struct AVMessage *next; // 下一个消息
}AVMessage;


typedef struct MessageQueue{ // 消息队列
    AVMessage *first_msg, *last_msg; // 消息头，消息尾
    int nb_messages; // 有多少个消息
    int abort_request; // 请求终止消息队列
    SDL_mutex *mutex; // 互斥量
    SDL_cond *cond; // 条件变量
    AVMessage *recycle_msg; // 消息循环使用
    int recycle_count; // 循环的次数，利用局部性原理
    int alloc_count; // 分配的次数
}MessageQueue;


// 释放msg的obj资源
void msg_free_res(AVMessage *msg);
// 私有插入消息
int msg_queue_put_private(MessageQueue* q, AVMessage *msg);
// 插入消息
int msg_queue_put(MessageQueue* q, AVMessage *msg);
// 初始化消息
void msg_init_msg(AVMessage *msg);
// 插入简单消息，只带消息类型，不带参数
void msg_queue_put_sample1(MessageQueue* q, int what);
// 插入简单消息，只带消息类型，只带1个参数
void msg_queue_put_sample2(MessageQueue* q, int what, int arg1);
// 插入简单消息，只带消息类型，带2个参数
void msg_queue_put_sample3(MessageQueue* q, int what, int arg1, int arg2);
// 释放msg的obj资源
void msg_obj_free_l(void *obj);
// 插入消息，带消息类型，带2个参数，带obj
void msg_queue_put_sample4(MessageQueue* q, int what, int arg1, int arg2, void* obj, int obj_len);
// 消息队列初始化
void msg_queue_init(MessageQueue* q);
// 消息队列flush，清空所有的消息
void msg_queue_flush(MessageQueue* q);
// 消息销毁
void msg_queue_destroy(MessageQueue* q);
// 消息队列终止
void msg_queue_abort(MessageQueue* q);
// 启用消息队列
void msg_queue_start(MessageQueue* q);
// 读取消息
int msg_queue_get(MessageQueue* q, AVMessage *msg, int block);
// 消息删除，把队列里同一消息类型的消息全删除掉
void msg_queue_remove(MessageQueue* q, int what);


#endif // FFMSG_QUEUE_H

代码结构

核心类与接口

核心函数

函数ijkmp_create
  • 创建IjkMediaPlayer
  • 创建FFPlayer
    • 初始化消息队列msg_queue_init
    • 初始化FFPlayer成员变量
    • 刷新队列msg_queue_flush
  • 保持ui传入的回调msg_loop函数
  • 初始化mutex
  • 如果失败调用destroy_p
函数ijkmp_destroy
  • 停止msg_loop函数
  • 销毁播放器FFPlayer
    • stream_close
      • 请求abort_request
      • packet_queue_abort
      • stream_compoent_close关闭audio、video、subtitle
      • avformat_close_input关闭解复用器
      • packet_queue_destroy销毁audio、video、subtitle包队列
      • frame_queue_destroy销毁audio、video、subtitle包队列
    • 销毁消息队列msg_queue_destroy
  • 释放mutex
  • 释放自己delete this
函数ijkmp_prepare_async
  • 状态设置为MP_STATE_ASYNC_PREPARING(正在准备)，何时转化为MP_STATE_PREPARED(已经准备)
    • 在FFPlayer的read_thread线程 解复用分析完成流情况、初始化完对应的解码器、音视频输出后，先调用toggle_pause设置系统处于暂停播放状态，然后发送FFP_STATE_PREPARED
    • IjkMediaPlayer收到FFP_STATE_PREPARED把状态设置为MP_STATE_PREPARED
    • UI收到FFP_STATE_PREPARED消息后，调用start接口，开始播放
  • 启用消息队列msg_queue_start
  • 创建msg_loop线程
  • 调用FFPlayer的prepare_async_l
    • 调用stream_open
      • 分配VideoState
      • 保存filename到VideoState
      • frame_queue_init初始化audio、video、subtitle帧队列
      • queue_queue_init初始化audio、video、subtitle帧队列
      • 创建continue_read_thread解复用读取线程条件变量
      • init_clock初始化audio、video、ext时钟
      • 设置音量
      • 创建视频刷新线程video_refresh_thread
      • 创建视频读取线程video_read_thread
    • 保存filename
函数ijkmp_start
  • 先检查当前状态是否可以转成start，MP_START_IDLE,MP_STATE_INITIALIZED状态肯定是不能转为start的状态的
  • 删除队列里的FFP_REQ_START消息，毕淼start消息请求重复
  • 删除队列里的FFP_REQ_PAUSE消息,因为要执行start，所以队列里还有pause消息就没有必要被处理
  • 发送FFP_REQ_START消息
    • IjkMediaPlayer的ijkmp_get_msg处理FFP_REQ_START然后调用ffp_start_l触发播放（本质调用toggle_pause实现）
函数ijkmp_stop
  • 先检查当前状态是否可以转成stop，MP_START_IDLE状态肯定是不能转为stop的状态的
  • 删除队列里的FFP_REQ_START、FFP_REQ_PAUSE消息
  • 调用FFPlayer的ffp_stop_l
    • 先请求abort_request = 1，
    • 暂停输出toggle_pause
    • msg_queue_abort消息队列也不允许再插入消息

类与接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
#ifndef IJKMEDIAPLAYER_H
#define IJKMEDIAPLAYER_H

#include <iostream>
#include <functional>
#include <mutex>
#include <thread>

#include "ffmsg_queue.h"
#include "ffplayer.h"

#define MP_STATE_IDLE               0
#define MP_STATE_INITIALIZED        1
#define MP_STATE_ASYNC_PREPARING    2
#define MP_STATE_PREPARED           3
#define MP_STATE_STARTED            4
#define MP_STATE_PAUSED             5
#define MP_STATE_COMPLETED          6
#define MP_STATE_STOPPED            7
#define MP_STATE_ERROR              8
#define MP_STATE_END                9


class IjkMediaPlayer
{
public:
    IjkMediaPlayer();
    ~IjkMediaPlayer();
    int ijkmp_create(std::function<int(void*)> msg_loop);
    int ijkmp_destroy();
    // 设置要播放的url
    int ijkmp_set_data_source(const char* url);
    // 准备播放
    int ijkmp_prepare_async();
    // 触发播放
    int ijkmp_start();
    // 停止
    int ijkmp_stop();
    // 暂停
    int ijkmp_pause();
    // seek到指定位置
    int ijkmp_seek_to(long msec);
    // 获取播放状态
    int ijkmp_get_state();
    // 是不是播放中
    bool ijkmp_is_playing();
    // 当前播放位置
    long ijkmp_get_current_position();
    // 总长度
    long ijkmp_get_duration();
    // 已经播放的长度
    long ijkmp_get_playable_duration();
    // 设置循环播放
    void ijkmp_get_loop();
    // 读取消息
    int ijkmp_get_msg(AVMessage* msg, int block);
    // 设置音量
    void ijkmp_set_playback_volume(float volume);

    // 循环线程
    int ijkmp_msg_loop(void *arg);
private:
    // 互斥量
    std::mutex mutex_;
    // 播放器核心
    FFPlayer *ffplayer_ = NULL;
    // 函数指针，指向创建message_loop即消息循环函数
    std::function<int(void *)> msg_loop_ = NULL; // ui处理消息函数
    // 消息机制线程
    std::thread *msg_thread_; // 执行msg_loop
    // 字符串，播放url
    char *data_source_;
    // 播放器状态，例如prepared, resumed, error, completed等
    int mp_state_; // 播放状态
};

#endif // IJKMEDIAPLAYER_H
消息循环的处理
额外开辟的两个独立线程：
  1. ui::MainWind::message_loop
  2. FFPlayer::read_thread
消息处理流程：
  1. 由FFplayer::read_thread向消息队列插入消息
  2. ui::MainWind::message_loop捕获队列中的消息，调用IjkMediaPlayer::ijkmp_get_msg，处理消息（可选是否将该消息再交给ui处理）
  3. 如有需要ui::MainWind::message_loop再次处理消息
发出消息（FFPlayer）
1
2
3
4
5
6
7
8
9
10
11
12
13
int FFPlayer::read_thread()
{
    // ffp_notify_msg1(this, FFP_MSG_OPEN_INPUT);
    // ffp_notify_msg1(this, FFP_MSG_FIND_STREAM_INFO);
    // ffp_notify_msg1(this, FFP_MSG_COMPONENT_OPEN);
    ffp_notify_msg1(this, FFP_MSG_PREPARED);
    // std::cout << "FFPlayer send FFP_MSG_OPEN_INPUT、FFP_MSG_FIND_STREAM_INFO、FFP_MSG_COMPONENT_OPEN、FFP_MSG_PREPARED message！" << std::endl;
    std::cout << "FFPlayer send FFP_MSG_PREPARED message！" << std::endl;
    while(1)
    {
        std::this_thread::sleep_for(std::chrono::milliseconds(1000));
    }
}
由IjkMediaPlayer处理阶段一
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
int IjkMediaPlayer::ijkmp_get_msg(AVMessage *msg, int block)
{
    while(1)
    {
        int continue_wait_next_msg = 0;
        int retval = msg_queue_get(&ffplayer_->msg_queue_, msg, block);
        if(retval<=0)
            return retval; // -1 abort, 0 在非阻塞时没有消息
        switch(msg->what)
        {
        case FFP_MSG_FLUSH:
            std::cout << __FUNCTION__ <<" FFP_MSG_FLUSH"<<std::endl;
            break;
        case FFP_MSG_PREPARED:
            std::cout << __FUNCTION__ <<" FFP_MSG_PREPARED"<<std::endl;
            break;
        case FFP_REQ_START:
            std::cout << __FUNCTION__ <<" FFP_REQ_START"<<std::endl;
            continue_wait_next_msg = 1;
            break;
        default:
            std::cout << __FUNCTION__ <<" default"<<std::endl;
            break;
        }
        if(continue_wait_next_msg){
            msg_free_res(msg);
            continue; // 当不希望MainWind处理该消息时，这里直接continue，处理下一个消息
        }
        return retval;
    }
    return -1;
}
由Ui::MainWind处理阶段二
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
int MainWind::message_loop(void *arg)
{
    IjkMediaPlayer *mp = (IjkMediaPlayer*)arg;
    qDebug() << "MainWind::message_loop into";
    while(1)
    {
        AVMessage msg;
        // 阻塞式等待消息
        int retval = mp->ijkmp_get_msg(&msg, 1);
        if(retval < 0)
            break;
        // 得到消息后，ijkmp_get_msg内部选择将msg交给ui，ui仍然处理一次该消息
        switch(msg.what)
        {
        case FFP_MSG_FLUSH:
            qDebug() << __FUNCTION__ << " FFP_MSG_FLUSH";
            break;
        case FFP_MSG_PREPARED:
            qDebug() << __FUNCTION__ << " FFP_MSG_PREPARED";
            mp->ijkmp_start();
            break;
        case FFP_REQ_START:
            qDebug() << __FUNCTION__ << " FFP_REQ_START";
            break;
        default:
            qDebug() << __FUNCTION__ << " default";
            break;
        }
        msg_free_res(&msg);
        std::this_thread::sleep_for(std::chrono::milliseconds(1000));
    }
    qDebug() << "MainWind::message_loop quit!";
    return 0;
}

核心函数2

stream_open
  • 初始化SDL允许音频输出
  • 初始化帧Frame队列
  • 初始化包Packet队列
  • 初始化时钟Clock
  • 初始化音量
  • 创建解复用读取线程read_thread
  • 创建视频刷新线程 video_refresh_thread
stream_close
  • 请求关闭read_thread线程
  • 关闭解复用器
  • 关闭stream，比如调用stream_component_close，该函数实现的时候涉及到：
    • 关闭解码线程
    • 释放解码器资源
    • 关闭对应的音频、视频设备
  • 消耗包队列
  • 消耗帧队列
  • 释放其他资源
stream_component_open
  • 打开对应的解码器并做初始化
  • 创建和启动解码线程
  • 初始化音频或视频输出设备
stream_component_close
  • 关闭解码器线程
  • 释放解码器资源
  • 关闭音频或视频输出设备

类与接口2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
#ifndef DECODER_H
#define DECODER_H

#include <thread>

#include "ffplayer_basic.h"

class Decoder
{
public:
    AVPacket pkt_;
    PacketQueue *queue_;
    AVCodecContext *avctx_;
    int pkt_serial_;
    int finished_;
    std::thread *decoder_thread_ = NULL;

public:
    Decoder();
    ~Decoder();

    void decoder_init(AVCodecContext* avctx, PacketQueue *queue);
    int decoder_start(enum AVMediaType codec_type, const char *thread_name, void *arg);
    void decoder_abort(FrameQueue *fq);
    void decoder_destroy();
    int decoder_decode_frame(AVFrame* frame);
    int get_video_frame(AVFrame* frame);
    int queue_picture(FrameQueue* fq, AVFrame* src_frame, double pts, double duration, int64_t pos, int serial);

    int audio_thread(void *arg);
    int video_thread(void *arg);
};

#endif // DECODER_H
2023-12-13 该篇文章被 Cleofwine 归为分类: 音视频

上一篇：后端技术_http服务器的实现 下一篇：音视频开发_过滤器串实现图像叠加
© 2023-2026 Cleofwine / Email / GitHub / 浙ICP备2024136127号
🌙赠我弯弯一枚月，也赠予我晚星⭐ 本站由Hexo驱动｜使用Hexo-theme-A4主题