使用国产的QPlayer2实现双播放器观看视频

FFmpeg开发：集成QPlayer2实现双播放器视频观看

核心思路

在FFmpeg开发中集成国产的QPlayer2播放器实现双播放器功能，需要解决以下关键技术点：

1. 双播放器架构：创建两个独立的播放器实例
2. 资源管理：共享解码资源避免内存浪费
3. 同步机制：保持两个播放器的时间同步
4. 渲染控制：独立或组合显示两个视频流

系统架构设计

实现步骤

1. 环境配置与依赖

# 安装QPlayer2 SDK
git clone https://gitlab.com/qmedia/qplayer2.git
cd qplayer2/sdk
./configure --enable-shared --enable-ffmpeg
make && sudo make install

# 配置FFmpeg支持QPlayer2
cd ffmpeg
./configure --enable-qplayer2 \
            --extra-cflags="-I/usr/local/include/qplayer2" \
            --extra-ldflags="-L/usr/local/lib -lqplayer2"
make -j8

2. 双播放器初始化

#include <qplayer2/qp_api.h>

// 创建播放器实例
QPlayerHandle player1 = QP_create_player();
QPlayerHandle player2 = QP_create_player();

// 配置共享FFmpeg上下文
QP_set_option(player1, QP_OPT_SHARE_DECODER_CTX, 1);
QP_set_option(player2, QP_OPT_SHARE_DECODER_CTX, 1);

// 设置数据源
QP_set_data_source(player1, "https://example.com/video1.m3u8");
QP_set_data_source(player2, "https://example.com/video2.mp4");

// 设置渲染窗口
QP_set_video_surface(player1, surface1);
QP_set_video_surface(player2, surface2);

// 设置同步模式（主从同步）
QP_set_sync_mode(player1, QP_SYNC_MASTER);
QP_set_sync_mode(player2, QP_SYNC_SLAVE);
QP_set_sync_target(player2, player1);

3. 双播放器控制逻辑

// 启动双播放器
void start_dual_players() {
    QP_prepare_async(player1);
    QP_prepare_async(player2);
    
    // 等待准备完成
    QP_wait_for_prepared(player1);
    QP_wait_for_prepared(player2);
    
    // 同步启动
    QP_start(player1);
    QP_start(player2);
}

// 暂停/恢复
void toggle_dual_playback() {
    static int playing = 1;
    if(playing) {
        QP_pause(player1);
        QP_pause(player2);
    } else {
        QP_resume(player1);
        QP_resume(player2);
    }
    playing = !playing;
}

// 调整播放器布局
void set_dual_layout(int mode) {
    switch(mode) {
        case LAYOUT_SIDE_BY_SIDE:
            QP_set_video_rect(player1, 0, 0, width/2, height);
            QP_set_video_rect(player2, width/2, 0, width/2, height);
            break;
        case LAYOUT_PIP: // 画中画
            QP_set_video_rect(player1, 0, 0, width, height);
            QP_set_video_rect(player2, width-200, height-150, 200, 150);
            break;
        case LAYOUT_STACKED:
            QP_set_video_rect(player1, 0, 0, width, height/2);
            QP_set_video_rect(player2, 0, height/2, width, height/2);
            break;
    }
}

4. 高级功能实现

音频混合处理

// 自定义音频混合回调
void audio_mix_callback(void* userdata, 
                        uint8_t* mixed_buffer, 
                        const uint8_t* stream1, 
                        const uint8_t* stream2, 
                        int samples) {
    
    float volume1 = *(float*)userdata;
    float volume2 = 1.0 - volume1;
    
    for(int i = 0; i < samples * 2; i++) {
        int16_t s1 = ((int16_t*)stream1)[i];
        int16_t s2 = ((int16_t*)stream2)[i];
        int32_t mixed = (s1 * volume1) + (s2 * volume2);
        ((int16_t*)mixed_buffer)[i] = (int16_t)CLAMP(mixed, -32768, 32767);
    }
}

// 设置音频混合
float main_volume = 0.7f;
QP_set_audio_mixer(player1, player2, audio_mix_callback, &main_volume);

同步状态监控

// 检查同步状态
void check_sync_status() {
    int64_t pts1 = QP_get_current_position(player1);
    int64_t pts2 = QP_get_current_position(player2);
    int64_t diff = llabs(pts1 - pts2);
    
    if(diff > 30000) { // 30ms阈值
        // 自动调整从播放器
        if(pts1 > pts2) {
            QP_seek_to(player2, pts1, QP_SEEK_SYNC);
        } else {
            QP_set_playback_rate(player2, 1.02); // 轻微加速
        }
    }
}

5. 性能优化技巧

// 共享解码资源
QP_set_option(player1, QP_OPT_SHARE_DECODER_POOL, 1);

// 设置硬件加速
QP_set_option(player1, QP_OPT_HW_ACCEL, QP_HWACCEL_VULKAN);
QP_set_option(player2, QP_OPT_HW_ACCEL, QP_HWACCEL_VULKAN);

// 自适应缓冲策略
QP_set_buffer_config(player1, 
                    QP_BUFFER_MIN_MS, 500, 
                    QP_BUFFER_MAX_MS, 5000,
                    QP_BUFFER_ADAPTIVE);

// 降低从播放器优先级
QP_set_thread_priority(player2, QP_THREAD_PRIORITY_LOW);

6. 完整示例 - 双播放器控制器

#include <qplayer2/qp_api.h>
#include <stdio.h>
#include <unistd.h>

typedef enum {
    LAYOUT_SIDE_BY_SIDE,
    LAYOUT_PIP,
    LAYOUT_STACKED
} LayoutMode;

typedef struct {
    QPlayerHandle player1;
    QPlayerHandle player2;
    LayoutMode layout;
    int width;
    int height;
    int running;
} DualPlayer;

DualPlayer* create_dual_player(const char* url1, const char* url2, 
                               void* surface1, void* surface2,
                               int width, int height) {
    
    DualPlayer* dp = malloc(sizeof(DualPlayer));
    dp->player1 = QP_create_player();
    dp->player2 = QP_create_player();
    dp->width = width;
    dp->height = height;
    dp->layout = LAYOUT_SIDE_BY_SIDE;
    dp->running = 0;
    
    // 共享资源配置
    QP_set_option(dp->player1, QP_OPT_SHARE_DECODER_CTX, 1);
    QP_set_option(dp->player2, QP_OPT_SHARE_DECODER_CTX, 1);
    QP_set_option(dp->player1, QP_OPT_SHARE_DECODER_POOL, 1);
    
    // 设置数据源
    QP_set_data_source(dp->player1, url1);
    QP_set_data_source(dp->player2, url2);
    
    // 设置渲染表面
    QP_set_video_surface(dp->player1, surface1);
    QP_set_video_surface(dp->player2, surface2);
    
    // 同步设置
    QP_set_sync_mode(dp->player1, QP_SYNC_MASTER);
    QP_set_sync_mode(dp->player2, QP_SYNC_SLAVE);
    QP_set_sync_target(dp->player2, dp->player1);
    
    // 初始布局
    set_layout(dp, dp->layout);
    
    return dp;
}

void set_layout(DualPlayer* dp, LayoutMode mode) {
    dp->layout = mode;
    switch(mode) {
        case LAYOUT_SIDE_BY_SIDE:
            QP_set_video_rect(dp->player1, 0, 0, dp->width/2, dp->height);
            QP_set_video_rect(dp->player2, dp->width/2, 0, dp->width/2, dp->height);
            break;
        case LAYOUT_PIP:
            QP_set_video_rect(dp->player1, 0, 0, dp->width, dp->height);
            QP_set_video_rect(dp->player2, dp->width-200, dp->height-150, 200, 150);
            break;
        case LAYOUT_STACKED:
            QP_set_video_rect(dp->player1, 0, 0, dp->width, dp->height/2);
            QP_set_video_rect(dp->player2, 0, dp->height/2, dp->width, dp->height/2);
            break;
    }
}

void start_dual_playback(DualPlayer* dp) {
    QP_prepare_async(dp->player1);
    QP_prepare_async(dp->player2);
    
    // 等待准备完成
    while(!QP_is_prepared(dp->player1) usleep(10000);
    while(!QP_is_prepared(dp->player2) usleep(10000);
    
    QP_start(dp->player1);
    QP_start(dp->player2);
    dp->running = 1;
}

void stop_dual_playback(DualPlayer* dp) {
    QP_stop(dp->player1);
    QP_stop(dp->player2);
    dp->running = 0;
}

void toggle_playback(DualPlayer* dp) {
    if(QP_is_playing(dp->player1)) {
        QP_pause(dp->player1);
        QP_pause(dp->player2);
    } else {
        QP_resume(dp->player1);
        QP_resume(dp->player2);
    }
}

void switch_audio_focus(DualPlayer* dp, int player_num) {
    if(player_num == 1) {
        QP_set_audio_volume(dp->player1, 1.0f);
        QP_set_audio_volume(dp->player2, 0.0f);
    } else {
        QP_set_audio_volume(dp->player1, 0.0f);
        QP_set_audio_volume(dp->player2, 1.0f);
    }
}

void destroy_dual_player(DualPlayer* dp) {
    stop_dual_playback(dp);
    QP_destroy_player(dp->player1);
    QP_destroy_player(dp->player2);
    free(dp);
}

性能优化策略

资源分配策略

内存管理优化

1. 帧缓冲共享池：两个播放器共享解码后的帧缓冲区
2. 纹理复用：OpenGL/Vulkan纹理在双播放器间复用
3. 自适应分辨率：根据系统负载动态调整从播放器分辨率
4. 后台预加载：从播放器在后台低优先级预加载

常见问题解决方案

1. 同步漂移问题：

   • 实现PTP(Precision Time Protocol)风格的时间同步
   • 使用音频时钟作为主同步参考
   • 动态调整从播放器速率

2. 资源竞争处理：

   // 使用QPlayer2的互斥锁API
   QP_lock_resource(QP_RESOURCE_DECODER);
   // 关键操作
   QP_unlock_resource(QP_RESOURCE_DECODER);
   

3. 低端设备适配：

   • 自动检测设备等级
   • 降级为单播放器模式
   • 使用软件解码后备方案

4. 网络带宽管理：

   // 动态调整码率
   if(network_slow) {
       QP_set_max_bitrate(player2, 500000); // 限制从播放器为500Kbps
   }
   

总结与最佳实践

通过QPlayer2实现双播放器功能的关键点：

1. 资源复用：充分利用QPlayer2的共享上下文功能
2. 智能同步：主从同步机制结合动态调整策略
3. 灵活布局：支持多种布局模式适应不同场景
4. 性能分级：主播放器优先保证体验，从播放器动态调整

最佳实践建议：

• 在高端设备上使用硬件加速双解码
• 中端设备采用硬件+软件混合解码
• 低端设备降级为单播放器模式
• 使用QPlayer2的QP_monitor_performance()实时监控性能
• 定期调用QP_collect_garbage()释放未使用资源

通过这种双播放器架构，可以实现如画中画、多角度观看、实时对比等高级视频观看体验，充分发挥国产QPlayer2播放器在FFmpeg生态中的优势。