• ffplay.c源码阅读之音频、字幕、视频渲染原理

    在实现一个播放器时，会涉及到如下三个部分

    拉流：从本地或者远程读取压缩音视频数据

    解码：将读取到的音视频数据进行解码得到未压缩音视频数据

    渲染：将解码得到的未压缩视频渲染到屏幕、未压缩音频通过扬声器播放

    那么应该创建几个线程来做这些事情？首先拉流肯定要单独的线程，解码和渲染是否应该放到一个线程里面呢，我觉得应该分开，因为不分开的话流程就是，解码成功->渲染-->解码下一帧-->渲染 一直循环。对于I、B、P帧解码所花时间会不一样，那么渲染时间非等间隔的就会导致播放不那么流畅。综上，应该有拉流一个线程(音视频共用)，解码两个(音视频独立)，渲染两个(音视频独立)

    音视频要分开的原因是音视频渲染间隔是是不同的。

    今天先从渲染部分开始阅读和学习
    对于线程的创建实际上ffplay.c也是这样实现的，它的整个架构设计图如下：
    截止到ffmpeg 4.2版本，ffplay.c大概有近四千行代码。整体的流程图架构设计如下：

    ffplay.c的实现

    实际上ffplay.c也是按照这样

    • 视频渲染线程的代码

    这里只贴出关键代码。这段代码的主要工作流程如下： 1、取视频帧；没有可渲染视频帧就返回睡眠，有则进入步骤2 2、取出上一次已渲染视频帧和当前待渲染视频帧 3、根据音视频同步规则决定当前待渲染视频帧是否立即渲染，即：如果本帧的播放时刻(即上一帧的播放时刻+上一帧的时长)大于当前时刻，代表本帧的播放时刻还未到来，渲染时间未到来则继续播放上一帧(由如下goto语句进行跳转)，然后将remain_time赋值为本帧的播放时刻与当前时刻的时间差值(睡眠remain_time时间后)下一个流程再渲染此帧；否则进入步骤4 4、更新视频帧FrameQueue队列相关数据，然后渲染本帧(真正执行视频渲染工作的代码在video_display()函数中)

    步骤1-4循环调用

    本文福利， 免费领取C++音视频学习资料包、技术视频，内容包括（音视频开发，面试题，FFmpeg ，webRTC ，rtmp ，hls ，rtsp ，ffplay ，srs）↓↓↓↓↓↓见下面↓↓文章底部点击免费领取↓↓

    1. /** 1、用于控制视频的显示
    2.  *  2、如果音视频同步方式为视频同步到音频，则这块逻辑在此实现
    3.  */
    4. static void video_refresh(void *opaque, double *remaining_time)
    5. {
    6.     VideoState *is = opaque;
    7.     double time;
    8.  
    9.     Frame *sp, *sp2;
    10.     ....省略代码.....
    11.  
    12.     // rtsp 等实时流则is->realtime的值为1，本地文件的播放则为0
    13.     if (!is->paused && get_master_sync_type(is) == AV_SYNC_EXTERNAL_CLOCK && is->realtime)
    14.         check_external_clock_speed(is);
    15.  
    16.  
    17.     if (is->video_st) {
    18. retry:
    19.         if (frame_queue_nb_remaining(&is->pictq) == 0) { // 步骤1、取视频帧；没有可渲染视频帧就返回睡眠，
    20.             // nothing to do, no picture to display in the queue
    21.         } else {
    22.             double last_duration, duration, delay;
    23.             Frame *vp, *lastvp;
    24.  
    25.             /* dequeue the picture */
    26.             // 步骤2、取出上一次已渲染视频帧和当前待渲染视频帧
    27.             // 首次进入此方法，由于f->rindex_shown是默认值，所以得到的lastvp和vp是同一个Frame
    28.             lastvp = frame_queue_peek_last(&is->pictq);
    29.             vp = frame_queue_peek(&is->pictq);
    30.  
    31.             if (vp->serial != is->videoq.serial) {
    32.                 frame_queue_next(&is->pictq);
    33.                 goto retry;
    34.             }
    35.  
    36.             if (lastvp->serial != vp->serial)
    37.                 is->frame_timer = av_gettime_relative() / 1000000.0;
    38.  
    39.             if (is->paused)
    40.                 goto display;
    41.  
    42.             
    43.             /* compute nominal last_duration */
    44.             last_duration = vp_duration(is, lastvp, vp);
    45.             /** 这里实现了视频同步音频或者同步系统时钟的关键代码
    46.              *  本帧视频是否能够播放的条件为 is->frame_timer (上一帧视频的播放时间) + delay(本帧视频的播放延迟) >= 当前系统时间
    47.              *  delay是基于音频时钟或者系统时钟计算出来的播放延迟时间(它的理论值就是本帧pts-上帧pts)
    48.              *  delay>=0 值越小代表视频播的太慢了，本帧越需要尽快播放，越大则代表视频播的太快了，本帧需要延后播放 为0 则视频有可能慢了音频至少一个帧
    49.              */
    50.             delay = compute_target_delay(last_duration, is);
    51.             
    52.             // frame_timer表示上一帧的播放时刻(这个时刻比非实际显示到屏幕的时刻提前一点点时间)
    53.             time= av_gettime_relative()/1000000.0;
    54.             if (time < is->frame_timer + delay) {   // 步骤3、 如果本帧的播放时刻(即上一帧的播放时刻+上一帧的时长)大于当前时刻，代表本帧的播放时刻还未到来
    55.                 // 渲染时间未到来则继续播放上一帧(由如下goto语句进行跳转)，然后将remain_time赋值为本帧的播放时刻与当前时刻的时间差值
    56.                 *remaining_time = FFMIN(is->frame_timer + delay - time, *remaining_time);
    57.                 goto display;   //继续播放上一帧
    58.             }
    59.             
    60.             // 同步上一帧的播放时间
    61.             /** 疑问：这里is->frame_timer += delay;为什么是这样写的，而不是直接is->frame_timer = time;呢？
    62.              *  分析：如果直接用is->frame_timer = time;进行赋值，那么视频帧因为某种原因累积了很多帧未播放时，那么会导致多出来的视频帧无法丢弃
    63.              *  实际上ffplay有两条时钟，一条时钟音视频时钟，用于音视频同步用，即计算这里的delay值，另一条时钟frame_timer用来记录上一帧的播放时间
    64.              *  同时用于计算是否满足丢帧的条件
    65.              */
    66.             is->frame_timer += delay;
    67.             if (delay > 0 && time - is->frame_timer > AV_SYNC_THRESHOLD_MAX)    // 处理首帧播放和音视频帧同时出现解码时间过程导致的抖动，这里就需要重新更新上一帧播放时间为当前时间了
    68.                 is->frame_timer = time;
    69.             
    70.             // 步骤4、以下都是
    71.             /** ffplay.c里面有三个时间
    72.              *  1、frame_timer：保存在VideoState结构体里面，用以记录视频播放的时间点，该时间点基于系统时钟
    73.              *  2、pts:保存在视频Clock结构体里面，等同于视频帧的pts
    74.              *  3、pts_drift:视频帧的pts与视频播放时刻的时间差
    75.              */
    76.             SDL_LockMutex(is->pictq.mutex);
    77.             if (!isnan(vp->pts))
    78.                 update_video_pts(is, vp->pts, vp->pos, vp->serial);
    79.             SDL_UnlockMutex(is->pictq.mutex);
    80.  
    81.             // 如果本帧的pts+duration < time(当前时间)则丢弃该帧(说明队列中有大量还未渲染的视频帧，必须得丢掉一些了)
    82.             if (frame_queue_nb_remaining(&is->pictq) > 1) {
    83.                 Frame *nextvp = frame_queue_peek_next(&is->pictq);
    84.                 duration = vp_duration(is, vp, nextvp);
    85.                 if(!is->step && (framedrop>0 || (framedrop && get_master_sync_type(is) != AV_SYNC_VIDEO_MASTER)) && time > is->frame_timer + duration){
    86.                     is->frame_drops_late++;
    87.                     frame_queue_next(&is->pictq);
    88.                     goto retry;
    89.                 }
    90.             }
    91.  
    92.             // FrameQueue队列的当前读取指针rindex的值+1(即指向本帧的索引),并且删除上一帧的Frame数据(因为已经不需要了)
    93.             frame_queue_next(&is->pictq);
    94.             is->force_refresh = 1;
    95.  
    96.             if (is->step && !is->paused)
    97.                 stream_toggle_pause(is);
    98.         }
    99. display:
    100.         /* display picture */
    101.         // 执行渲染本帧的工作
    102.         if (!display_disable && is->force_refresh && is->show_mode == SHOW_MODE_VIDEO && is->pictq.rindex_shown)
    103.             video_display(is);
    104.     }
    105.     is->force_refresh = 0;
    106.     }
    107.     ....省略代码.....
    108. }
    109.  
    110. /* display the current picture, if any */
    111. static void video_display(VideoState *is)
    112. {
    113.     if (!is->width)
    114.         video_open(is);
    115.  
    116.     SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
    117.     SDL_RenderClear(renderer);
    118.     if (is->audio_st && is->show_mode != SHOW_MODE_VIDEO)
    119.         video_audio_display(is);
    120.     else if (is->video_st)
    121.         video_image_display(is);
    122.     SDL_RenderPresent(renderer);
    123. }

    还有一个很重要的就是如何保证前面的video_refresh()函数循环调用呢，通过如下的refresh_loop_wait_event()函数，它通过SDL库检测是否有鼠标和键盘等事件，如果没有则一直循环，有则退出循环去处理事件。处理事件又在event_loop()函数中，它是在main()函数中启动的。

    1. static void refresh_loop_wait_event(VideoState *is, SDL_Event *event) {
    2.     double remaining_time = 0.0;
    3.     SDL_PumpEvents();
    4.     while (!SDL_PeepEvents(event, 1, SDL_GETEVENT, SDL_FIRSTEVENT, SDL_LASTEVENT)) { // 没有捕捉到事件就去渲染视频，捕捉到了视频则先处理事件
    5.         if (!cursor_hidden && av_gettime_relative() - cursor_last_shown > CURSOR_HIDE_DELAY) {
    6.             SDL_ShowCursor(0);
    7.             cursor_hidden = 1;
    8.         }
    9.         if (remaining_time > 0.0)
    10.             av_usleep((int64_t)(remaining_time * 1000000.0));
    11.         remaining_time = REFRESH_RATE;
    12.         if (is->show_mode != SHOW_MODE_NONE && (!is->paused || is->force_refresh))
    13.             video_refresh(is, &remaining_time);
    14.         SDL_PumpEvents();
    15.     }
    16. }
    17.  
    18. static void event_loop(VideoState *cur_stream)
    19. {
    20.     SDL_Event event;
    21.     double incr, pos, frac;
    22.     /** 学习：线程的事件循环队列
    23.      *  分析：时间循环队列的组成一定是 for/while循环+usleep()休眠+事件捕捉器组成，如果没有usleep()休眠那么会导致cpu空转，造成大量浪费
    24.      *  这里休眠时间由播放视频的帧率(间隔)根据一定的规则计算而来，然后如果捕捉到事件则优先处理事件，接着再去播放视频
    25.      */
    26.     for (;;) {
    27.         double x;
    28.         refresh_loop_wait_event(cur_stream, &event);
    29.         switch (event.type) {
    30.         case SDL_KEYDOWN:
    31.          .......各种键盘和鼠标事件....省略
    32.         .....
    33.     }
    34. }

    学习：线程的事件循环队列
    分析：事件循环队列的组成一定是 for/while循环+usleep()休眠+事件捕捉器组成，如果没有usleep()休眠那么会导致cpu空转，造成大量浪费这里休眠时间由播放视频的帧率(间隔)根据一定的规则计算而来，然后如果捕捉到事件则优先处理事件，接着再去播放视频

    这一套事件循环队列机制就保证了视频持续播放又能响应用户键盘和鼠标事件。以上就是视频渲染线程的工作流程和机制

    • 音频渲染线程的代码
      音频渲染线程，它是通过SDL内部自驱动的一个回调函数，被周期性的回调，只需要不停的往里面填充音频即可进行音频的渲染了。每一次调用称为一个音频渲染周期
      len:代表需要填充的音频数据长度;stream代表填充音频的buffer地址
    1. /* prepare a new audio buffer */
    2. static void sdl_audio_callback(void *opaque, Uint8 *stream, int len)
    3. {
    4.     VideoState *is = opaque;
    5.     int audio_size, len1;
    6.  
    7.     audio_callback_time = av_gettime_relative();
    8.     
    9.     /** 学习：音频渲染线程，它是通过SDL内部自驱动的一个回调函数，被周期性的回调，只需要不停的往里面填充音频即可进行音频的渲染了。每一次调用称为一个音频渲染周期
    10.      *  len:代表需要填充的音频数据长度;stream代表填充音频的buffer地址
    11.      *
    12.      *  is->audio_buf_index：表示当前渲染周期内已拷贝的音频数据字节的索引，即下一块音频数据放入stream+is->audio_buf_index的位置
    13.      *  is->audio_buf_size：表示当前音频Frame的字节数
    14.      */
    15.     while (len > 0) {
    16.         if (is->audio_buf_index >= is->audio_buf_size) {
    17.            audio_size = audio_decode_frame(is);
    18.            if (audio_size < 0) {
    19.                 /* if error, just output silence */
    20.                is->audio_buf = NULL;
    21.                is->audio_buf_size = SDL_AUDIO_MIN_BUFFER_SIZE / is->audio_tgt.frame_size * is->audio_tgt.frame_size;
    22.            } else {
    23.                if (is->show_mode != SHOW_MODE_VIDEO)
    24.                    update_sample_display(is, (int16_t *)is->audio_buf, audio_size);
    25.                is->audio_buf_size = audio_size;
    26.            }
    27.            is->audio_buf_index = 0;
    28.         }
    29.         len1 = is->audio_buf_size - is->audio_buf_index;
    30.         if (len1 > len)
    31.             len1 = len;
    32.         if (!is->muted && is->audio_buf && is->audio_volume == SDL_MIX_MAXVOLUME)
    33.             memcpy(stream, (uint8_t *)is->audio_buf + is->audio_buf_index, len1);
    34.         else {
    35.             memset(stream, 0, len1);
    36.             if (!is->muted && is->audio_buf)
    37.                 SDL_MixAudioFormat(stream, (uint8_t *)is->audio_buf + is->audio_buf_index, AUDIO_S16SYS, len1, is->audio_volume);
    38.         }
    39.         len -= len1;
    40.         stream += len1;
    41.         is->audio_buf_index += len1;
    42.     }
    43.     is->audio_write_buf_size = is->audio_buf_size - is->audio_buf_index;
    44.     /* Let's assume the audio driver that is used by SDL has two periods. */
    45.     if (!isnan(is->audio_clock)) {
    46.         set_clock_at(&is->audclk, is->audio_clock - (double)(2 * is->audio_hw_buf_size + is->audio_write_buf_size) / is->audio_tgt.bytes_per_sec, is->audio_clock_serial, audio_callback_time / 1000000.0);
    47.         // 如果音视频同步方式为同步外部时钟，则调用此方法会有用
    48.         sync_clock_to_slave(&is->extclk, &is->audclk);
    49.     }
    50. }

    该函数的开启过程是随着拉流线程开启的，在拉流线程内通过stream_component_open()开启音频流处理

    1. static int read_thread(void *arg){
    2. .....省略代码.....
    3. /* open the streams */
    4.     if (st_index[AVMEDIA_TYPE_AUDIO] >= 0) {
    5.         stream_component_open(is, st_index[AVMEDIA_TYPE_AUDIO]);
    6.     }
    7. .....省略代码.....
    8. }

    接下来在音频流处理流程中开启音频渲染相关代码

    1. static int stream_component_open(VideoState *is, int stream_index){
    2. .....省略代码.....
    3.  /* prepare audio output */
    4.         if ((ret = audio_open(is, channel_layout, nb_channels, sample_rate, &is->audio_tgt)) < 0)
    5.             goto fail;
    6. ....省略代码......
    7. }

    然后就是初始化SDL音频渲染相关，在这里指定音频渲染回调

    1. static int stream_component_open(VideoState *is, int stream_index)
    2. {
    3. ....省略代码......
    4. wanted_spec.format = AUDIO_S16SYS;
    5. wanted_spec.silence = 0;
    6. wanted_spec.samples = FFMAX(SDL_AUDIO_MIN_BUFFER_SIZE, 2 << av_log2(wanted_spec.freq / SDL_AUDIO_MAX_CALLBACKS_PER_SEC));
    7. wanted_spec.callback = sdl_audio_callback;
    8. wanted_spec.userdata = opaque;
    9. ....省略代码......
    10. }

    字幕渲染线程的代码

    实际上字幕渲染没有单独的线程，它与视频共用一个线程，可以看到这段代码和视频渲染在同一个函数中的，前面说道，视频渲染流程到了步骤4之后，就代表着即将渲染本帧视频，而字幕的渲染则是在本帧视频渲染之前进行渲染，即下面这段代码是在视频帧渲染之前执行 

    1. static void video_refresh(void *opaque, double *remaining_time){
    2.     .....省略代码.....
    3.     if (is->subtitle_st) {
    4.                 // 步骤1、字幕FrameQueue队列中是否有字幕帧，没有则退出循环
    5.                 while (frame_queue_nb_remaining(&is->subpq) > 0) {
    6.                     // 步骤2、获取当前待渲染字幕帧sp以及下一个待渲染字幕帧sp2(如果有的话)
    7.                     sp = frame_queue_peek(&is->subpq);
    8.  
    9.                     if (frame_queue_nb_remaining(&is->subpq) > 1)
    10.                         sp2 = frame_queue_peek_next(&is->subpq);
    11.                     else
    12.                         sp2 = NULL;
    13.                     
    14.                     // 步骤3、决定当前字幕帧是否需要被渲染。一帧字幕开始显示时间=pts+start_display_time,结束显示时间=pts+end_display_time
    15.                     /** 学习：视频和字幕同步
    16.                      *  分析：视频帧和字幕帧的同步主要以视频的时钟为准进行同步，这里is->vidclk.pts表示即将要渲染的视频帧的时间,当它大于(晚于)当前要渲染字
    17.                      *  幕帧结束时间或者下一个要渲染字幕帧开始时间表示字幕显示已经落后于视频了，赶紧渲染当前字幕帧；否则就退出字幕帧渲染循环
    18.                      */
    19.                     // sp->serial != is->subtitleq.serial 用于首帧字幕渲染
    20.                     /** 疑问：既然当前字幕帧都落后于即将要渲染的字幕帧了直接丢弃不就好了么？为撒要渲染上去呢？
    21.                      *  分析：知悉分析就发现，下面这个if语句写法保证字幕帧在其显示时间内只被渲染一次。这样有利于效率提升
    22.                      */
    23.                     if (sp->serial != is->subtitleq.serial
    24.                             || (is->vidclk.pts > (sp->pts + ((float) sp->sub.end_display_time / 1000)))
    25.                             || (sp2 && is->vidclk.pts > (sp2->pts + ((float) sp2->sub.start_display_time / 1000))))
    26.                     {
    27.                         if (sp->uploaded) {
    28.                             int i;
    29.                             for (i = 0; i < sp->sub.num_rects; i++) {
    30.                                 AVSubtitleRect *sub_rect = sp->sub.rects[i];
    31.                                 uint8_t *pixels;
    32.                                 int pitch, j;
    33.  
    34.                                 if (!SDL_LockTexture(is->sub_texture, (SDL_Rect *)sub_rect, (void **)&pixels, &pitch)) {
    35.                                     for (j = 0; j < sub_rect->h; j++, pixels += pitch)
    36.                                         memset(pixels, 0, sub_rect->w << 2);
    37.                                     SDL_UnlockTexture(is->sub_texture);
    38.                                 }
    39.                             }
    40.                         }
    41.                         frame_queue_next(&is->subpq);
    42.                     } else {
    43.                         break;
    44.                     }
    45.                 }
    46.             }
    47.     .....省略代码.....
    48. }

    本文福利， 免费领取C++音视频学习资料包、技术视频，内容包括（音视频开发，面试题，FFmpeg ，webRTC ，rtmp ，hls ，rtsp ，ffplay ，srs）↓↓↓↓↓↓见下面↓↓文章底部点击免费领取↓↓ 

  • 相关阅读:
    【云原生】配置Kubernetes CronJob自动备份Clickhouse数据库（单机版）
    计算机毕业设计JavaOA办公系统设计与实现(源码+系统+mysql数据库+lw文档）
    Microolap DAC for MySQL驱动程序或其他库
    [JS] canvas 详解
    【目标检测】MMDetection的安装与基础使用
    [附源码]Python计算机毕业设计Django高校实验室仪器设备管理系统
    【EMC专题】案例：PCB走线参考平面不完整导致辐射超标
    大咖说·图书分享｜Serverless工程实践：从入门到进阶
    计算机毕业设计Java汉服服装租赁系统(源码+系统+mysql数据库+lw文档)
    定制化、高可用前台样式处理方案——tailwindcss
  • 原文地址：https://blog.csdn.net/m0_60259116/article/details/126527394