超详细解析FFplay之视频输出和尺寸变换模块

1.视频输出模块

ffplay为了适应不同的平台，选择了SDL（跨平台）作为显示的SDK，以便在windows、linux、macos等不同平台上实现视频画?的显示。

视频（图像）输出初始化。

开始分析视频（图像）的显示。因为使?了SDL，?video的显示也依赖SDL的窗?显示系统，所以先从main函数的SDL初始化看起（节选）：

int main(int argc, char **argv) 
 {  
   //…… 
  //3. SDL的初始化 
  flags = SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER; 
  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 variabl e?)\n"); 
   exit(1); 
    } 
   //4. 创建窗? 
   window = SDL_CreateWindow(program_name, SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, default_width, default_height, flags);
   if (window) { 
     //创建renderer 
      renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCEL ERATED | SDL_RENDERER_PRESENTVSYNC); 
      if (!renderer) {
        av_log(NULL, AV_LOG_WARNING, "Failed to initialize a har dware 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 rendere r.\n", renderer_info.name);
           } 
         } 
      //5. 通过stream_open函数，开启read_thread读取线程 
     is = stream_open(input_filename, file_iformat);//这?创建了read_th read
     if (!is) { 
        av_log(NULL, AV_LOG_FATAL, "Failed to initialize VideoState! \n");
        do_exit(NULL); 
       } 
      //6. 事件响应 
      event_loop(is); 
   }
        }

main函数主要步骤如下：

(1)SDL_Init，主要是SDL_INIT_VIDEO的?持。

(2)SDL_CreateWindow，创建主窗?。

(3)SDL_CreateRender，基于主窗?创建renderer，?于渲染输出。

(4)stream_open。

(5)event_loop，播放控制事件响应循环，但也负责了video显示输出。

重点分析set_default_window_size的原理，该函数主要获取窗?的宽?，以及视频渲染的区域：

 //7 从待处理流中获取相关参数，设置显示窗?的宽度、?度及宽?? 
 if (st_index[AVMEDIA_TYPE_VIDEO] >= 0) { 
   AVStream *st = ic->streams[st_index[AVMEDIA_TYPE_VIDEO]]; 
    AVCodecParameters *codecpar = st->codecpar; 
   /*根据流和帧宽??猜测帧的样本宽??。该值只是?个参考
    */ 
 AVRational sar = av_guess_sample_aspect_ratio(ic, st, NULL);
   if (codecpar->width) {
     // 设置显示窗?的??和宽?? 
     set_default_window_size(codecpar->width, codecpar->height, s ar); 
      } 
   }

static void set_default_window_size(int width, int height, AVRationa l sar) 
 { 
    SDL_Rect rect; 
    int max_width = screen_width ? screen_width : INT_MAX; // 确定 是否指定窗?最?宽度 
   int max_height = screen_height ? screen_height : INT_MAX; // 确定 是否指定窗?最??度 
    if (max_width == INT_MAX && max_height == INT_MAX) 
      max_height = height; // 没有指定最??度时则使?视频的?度 
    calculate_display_rect(&rect, 0, 0, max_width, max_height, width , height, sar); 
    default_width = rect.w; 
    default_height = rect.h; 
    }

screen_width和screen_height可以在ffplay启动时设置 -x screen_width -y screen_height获取指定的宽?，如果没有指定，则max_height = height，即是视频帧的?度，宽度是窗口宽度。

初始化窗?显示??

主要分析calculate_display_rect，根据传?的参数（int scr_xleft, int scr_ytop, int scr_width, int scr_height,int pic_width, int pic_height, AVRational pic_sar）获取显示区域的起始坐标和??(rect)。

static void calculate_display_rect(SDL_Rect *rect,int scr_xleft, 
                                   int scr_ytop, int scr_width, int scr_height，
                                   int pic_width, int pic_height, AV Rational pic_sar)
                                   { 
                                     AVRational aspect_ratio = pic_sar; // ?率 
                                      int64_t width, height, x, y; 
                                      if (av_cmp_q(aspect_ratio, av_make_q(0, 1)) <= 0) 
                                       aspect_ratio = av_make_q(1, 1);// 如果aspect_ratio是负数或者为 0,设置为1:1 
                                      // 转成真正的播放?例 
                                      aspect_ratio = av_mul_q(aspect_ratio, av_make_q(pic_width, pic_h eight)); 
                                  
                                      /* XXX: we suppose the screen has a 1.0 pixel ratio */ 
                                      // 计算显示视频帧区域的宽? 
                                      // 先以?度为基准 ,就是把高度按照原始视频高度来，铺满
                                      height = scr_height; 
                                      // &~1, 取偶数宽度 
                                     width = av_rescale(height, aspect_ratio.num, aspect_ratio.den) & ~1;
                                     
                                     if (width > scr_width) {
                                        // 当以?度为基准,发现计算出来的需要的窗?宽度不?时调整为以窗?宽度为基准
                                        width = scr_width; 
                                        height = av_rescale(width, aspect_ratio.den, aspect_ratio.nu m) & ~1; 
                                       }
                                      // 计算显示视频帧区域的起始坐标（在显示窗?内部的区域）
                                     x = (scr_width - width) / 2; 
                                      y = (scr_height - height) / 2; 
                                     rect->x = scr_xleft + x; 
                                      rect->y = scr_ytop + y; 
                                      rect->w = FFMAX((int)width, 1); 
                                      rect->h = FFMAX((int)height, 1); 
                                    }

                                     

typedef struct AVRational{

int num; ///< Numerator 分?

int den; ///< Denominator 分?

} AVRational;

注意视频显示尺?比例的计算,计算出真实的比例。

aspect_ratio = av_mul_q(aspect_ratio, av_make_q(pic_width, pic_height));

视频（图像）输出逻辑。

基本步骤如下：

  1main() -- > 
  2 event_loop --> 
  3 refresh_loop_wait_event() -->
4 video_refresh() -->
5 video_display() -->
6 video_image_display() --> 
7 upload_texture()

event_loop 开始处理SDL事件：

static void event_loop(VideoState *cur_stream) 
{ 
  SDL_Event event; 
   double incr, pos, frac; 
   for (;;) { 
     double x;
     refresh_loop_wait_event(cur_stream, &event);//video是在这?显示 的 
     switch (event.type) { 
         //…… 
         case SDLK_SPACE://按空格键触发暂停/恢复 
         toggle_pause(cur_stream); 
         break; 
         case SDL_QUIT: 
         case FF_QUIT_EVENT://?定义事件，?于出错时的主动退出 
         do_exit(cur_stream); 
         break; 
         } 
     }

event_loop 的主要代码是?个主循环，主循环内执?：

(1)refresh_loop_wait_event。

(2)处理SDL事件队列中的事件。?如按空格键可以触发暂停/恢复，关闭窗?可以触发do_exit销毁播放现场。

video的显示主要在 refresh_loop_wait_event ：

static void refresh_loop_wait_event(VideoState *is, SDL_Event *event ) { 
  double remaining_time = 0.0; /* 休眠等待，remaining_time的计算在vide o_refresh中 */
  /* 调?SDL_PeepEvents前先调?SDL_PumpEvents，将输?设备的事件抽到事件队 列中 */ 
   SDL_PumpEvents(); 
  /* 
   * SDL_PeepEvents check是否事件，?如?标移?显示区等 
   * 从事件队列中拿?个事件，放到event中，如果没有事件，则进?循环中
  * SDL_PeekEvents?于读取事件，在调?该函数之前，必须调?SDL_PumpEvents 搜集键盘等事件 
   */ 
   while (!SDL_PeepEvents(event, 1, SDL_GETEVENT, SDL_FIRSTEVENT, S DL_LASTEVENT)) {
     if (!cursor_hidden && av_gettime_relative() - cursor_last_sh own > CURSOR_HIDE_DELAY) { 
        SDL_ShowCursor(0); 
        cursor_hidden = 1; 
        } 
      /* 
       * remaining_time就是?来进??视频同步的。
        * 在video_refresh函数中，根据当前帧显示时刻(display time)和实际时刻 (actual time) 
         * 计算需要sleep的时间，保证帧按时显示 
          */ 
      if (remaining_time > 0.0)
        //sleep控制画?输出的时机 
        av_usleep((int64_t)(remaining_time * 1000000.0)); 
      remaining_time = REFRESH_RATE;
      if (is->show_mode != SHOW_MODE_NONE && // 显示模式不等于SHOW_MO DE_NONE
          (!is->paused // ?暂停状态 
            || is->force_refresh) // ?强制刷新状态
           ) {
         video_refresh(is, &remaining_time); 
         }
      /* 从输?设备中搜集事件，推动这些事件进?事件队列，更新事件队列的状态，
         * 不过它还有?个作?是进?视频?系统的设备状态更新，如果不调?这个函数， 
         * 所显示的视频会在?约10秒后丢失?彩。没有调?SDL_PumpEvents，将不会 
        * 有任何的输?设备事件进?队列，这种情况下，SDL就?法响应任何的键盘等硬件 输?。 
         */
     //响应更多事件
      SDL_PumpEvents(); 
     } 
 }

响应事件时，画面就有可能要暂停。

SDL_PeepEvents通过参数SDL_GETEVENT?阻塞查询队列中是否有事件。如果返回值不为0，表示有事件发?（或-1表示发?错误），那么函数就会返回，接着让event_loop处理事件；否则，就调?video_refresh显示画?，并通过输出参数remaining_time获取下?轮应当sleep的时间，以保持稳定的画?输出。

这?还有?个判断是否要调?video_refresh的前置条件。满?以下条件即可显示：

(1)显示模式不为SHOW_MODE_NONE（如果?件中只有audio，也会显示其波形或者频谱图等）。

(2)或者，当前没有被暂停。

(3)或者，当前设置了force_refresh，我们分析force_refresh置为1的场景：

a. video_refresh??帧该显示，这个是常规情况。

b. SDL_WINDOWEVENT_EXPOSED，窗?需要重新绘制。

c.SDL_MOUSEBUTTONDOWN && SDL_BUTTON_LEFT 连续?标左键点击2次显示窗?间隔?

于0.5秒，进?全屏或者恢复原始窗?播放。

d. SDLK_f，按f键进?全屏或者恢复原始窗?播放。

video_refresh:视频刷新显示

接下来，分析video显示的关键函数 video_refresh （经简化）：

static void video_refresh(void *opaque, double *remaining_time)
 { 
   VideoState *is = opaque; 
   double time; 
  Frame *sp, *sp2;
  
  if (is->video_st) { 
     retry:
     if (frame_queue_nb_remaining(&is->pictq) == 0) {// 帧队列是否为 空 
      // nothing to do, no picture to display in the queue 
       // 什么都不做，队列中没有图像可显示 
       } else { 
         double last_duration, duration, delay; 
         Frame *vp, *lastvp; 
        /* dequeue the picture */ 
         lastvp = frame_queue_peek_last(&is->pictq); //读取上?帧 
         vp = frame_queue_peek(&is->pictq); // 读取待显示帧 
         if (vp->serial != is->videoq.serial) { 
           // 如果不是最新的播放序列，则将其出队列，以尽快读取最新序列的帧 
           frame_queue_next(&is->pictq); 
           goto retry; 
           }
         
         if (lastvp->serial != vp->serial) // 新的播放序列重置当前时间 
            is->frame_timer = av_gettime_relative() / 1000000.0; 
          if (is->paused) 
            goto display; 
          /* compute nominal last_duration */ 
          last_duration = vp_duration(is, lastvp, vp); //计算上?帧l astvp应显示的时? 
          delay = compute_target_delay(last_duration, is); //计算上 ?帧lastvp还要播放的时间 
         time= av_gettime_relative()/1000000.0; 
         //相当于做了一个流控
          if (time < is->frame_timer + delay) { // 还没有到播放时间 
            *remaining_time = FFMIN(is->frame_timer + delay - ti me, *remaining_time); 
            goto display; 
            }
         
         // ?少该到vp播放的时间了
          is->frame_timer += delay; 
         //事件差值在某个范围，也认定是有效。
         if (delay > 0 && time - is->frame_timer > AV_SYNC_THRESH OLD_MAX) 
            is->frame_timer = time; //实时更新时间 
          SDL_LockMutex(is->pictq.mutex); 
          if (!isnan(vp->pts)) 
            update_video_pts(is, vp->pts, vp->pos, vp->serial);
         
         // 更新video的时钟 
          SDL_UnlockMutex(is->pictq.mutex); 
         //表示队列至少有2帧
          if (frame_queue_nb_remaining(&is->pictq) > 1) { 
            //取出下一帧
             Frame *nextvp = frame_queue_peek_next(&is->pictq);
            //计算与上一帧时长 
            duration = vp_duration(is, vp, nextvp); 
            //如果不是video_master，并且可以drop
             if(!is->step && (framedrop>0 
                               || (framedrop && get_master_sync_ty pe(is) != AV_SYNC_VIDEO_MASTER)) 
                && time > is->frame_timer + duration){ 
                   is->frame_drops_late++; 
                  //尽快拿到下一帧
                   frame_queue_next(&is->pictq); 
                  goto retry; 
                  //检测下?帧 
                   } 
             } 
          if (is->subtitle_st) {
            //显示字幕 
            //…… 
             } frame_queue_next(&is->pictq); 
          is->force_refresh = 1; 
          if (is->step && !is->paused) 
             stream_toggle_pause(is); 
         } 
     display: 
     /* display picture */ 
     if (!display_disable && is->force_refresh && is->show_mode = = SHOW_MODE_VIDEO 
       && is->pictq.rindex_shown) 
      video_display(is);
     } 
   is->force_refresh = 0; 
    }

video_refresh ?较?，即使已经经过了简化，去掉了次要分?。

函数中涉及到FrameQueue中的3个节点是lastvp, vp, nextvp，其中：

(1)vp这次将要显示的?标帧（待显示帧）。

(2)lastvp是已经显示了的帧（也是当前屏幕上看到的帧）。

(3)nextvp是下?次要显示的帧（排在vp后?）。

顺序就是nextvp(下下次准备显示)->vp(待显示)->lastvp(已经显示)

取出其前??帧与后??帧，是为了通过pts准确计算duration(这个值有可能会发生变化)。duration的计算通过函数 vp_duration完成：

// 计算上?帧需要持续的duration，这?有校正算法 
 static double vp_duration(VideoState *is, Frame *vp, Frame *nextvp) { 
   if (vp->serial == nextvp->serial) { // 同?播放序列，序列连续的情况下
    double duration = nextvp->pts - vp->pts; 
    if (isnan(duration) // duration 数值异常 
           || duration <= 0 // pts值没有递增时 
           || duration > is->max_frame_duration // 超过了最?帧 范围 
           ) { // 异常情况， 
     // 1. 异常情况??之前?队列的时候计算的帧间隔(主要根据帧率去计算)
       return vp->duration; /* 异常时以帧时间为基准(1秒/帧率) */ 
       } 
     else { // 2. 相邻pts' 
       return duration; //使?两帧pts差值计算duration，?般情况下也是 ?的这个分?
       } 
      } else { // 不同播放序列, 序列不连续则返回0 
        return 0.0; 
        } 
    }

video_refresh 的主要流程如下：

先来看下上?流程图中的主流程——即中间?列框图。从框图进?步抽象， video_refresh 的主体流程分为3个步骤：

(1)取出上?帧lastvp和待显示的帧vip。

(2)计算上?帧lastvp应显示的时?，判断是否继续显示上?帧。

(3)估算当前帧应显示的时?，判断是否要丢帧，已过时就要丢帧。未过时，就要显示。

(4)调?video_display进?显示。

整体一个渲染逻辑就是，video_display 会调? frame_queue_peek_last 获取上次显示的frame（lastvp），并显示。所以在 video_refresh 中如果流程直接?到 video_display 就会显示 lastvp （需要注意的是在此时如果不是触发了force_refresh，则不会去重新取lastvp进?重新渲染），如果先调? frame_queue_next再调? video_display ，那么就会显示 vp。

下?我们具体分析这3个步骤，并和流程图与代码进?对应阅读。

计算上?帧应显示的时?，判断是否继续显示上?帧

?先检查pictq是否为空（调? frame_queue_nb_remaining 判断队列中是否有未显示的帧），如果为空，则调? video_display (显示上?帧)。

在进?步准确计算上?帧应显示时间前，需要先判断 frame_queue_peek 获取的 vp 是否是最新序列——即 if (vp->serial != is->videoq.serial) ，如果条件成?，说明发?过seek等操作，流不连续，应该抛弃lastvp。故调? frame_queue_next 抛弃lastvp后，返回流程开头重试下?轮。

接下来可以计算准确的 lastvp 应显示时?了。计算应显示时间的代码是：

last_duration = vp_duration(is, lastvp, vp); 
delay = compute_target_delay(last_duration, is);

直观理解，主要基于 vp_duration 计算两帧pts差，即帧持续时间，即可。但是，如果考虑到同步，?如视频同步到?频，则还需要考虑当前与主时钟的差距，进?决定是重复上?帧还是丢帧，还是正常显示下?帧（待显示帧vp）。这?只需要理解通过以上两步就可以计算出准确的上?帧应显示时?了。最后，根据上?帧应显示时?（delay变量），确定是否继续显示上?帧：

time= av_gettime_relative()/1000000.0;//获取当前系统时间(单位秒) 
 if (time < is->frame_timer + delay) 
{ 
   *remaining_time = FFMIN(is->frame_timer + delay - time, *remainin g_time); 
   goto display; 
 }

frame_timer 可以理解为帧显示时刻，对于更新前，可以理解为上?帧的显示时刻。对于更新后，可以理解为当前帧显示时刻。time < is->frame_timer + delay (上一帧显示还没结束)，如果当前系统时刻还未到达上?帧的结束时刻，那么还应该继续显示上?帧。这里的delay就是如图下的last_duration。

估算当前帧应显示的时?，判断是否要丢帧

这个步骤执?前，还需要?点准备?作：更新frame_timer和更新vidclk。

is->frame_timer += delay;//更新frame_timer，现在表示vp的显示时刻 
 if (delay > 0 && time - is->frame_timer > AV_SYNC_THRESHOLD_MAX)
 is->frame_timer = time;//如果和系统时间差距太?，就纠正为系统时间 
 SDL_LockMutex(is->pictq.mutex); 
 if (!isnan(vp->pts)) 
 update_video_pts(is, vp->pts, vp->pos, vp->serial);//更新vidclk 
 SDL_UnlockMutex(is->pictq.mutex);

接下来就可以判断是否要丢帧了：

if (frame_queue_nb_remaining(&is->pictq) > 1) {//有nextvp才会检测是否该 丢帧 
   Frame *nextvp = frame_queue_peek_next(&is->pictq); 
   duration = vp_duration(is, vp, nextvp); 
   if(!is->step // ?逐帧模式才检测是否需要丢帧 is->step==1 为逐帧播放 ,逐帧播放最好别丢帧。
  && (framedrop>0 || // cpu解帧过慢 
    (framedrop && get_master_sync_type(is) != AV_SYNC_VIDEO_M ASTER)) // ?视频同步?式 
 && time > is->frame_timer + duration // 确实落后了?帧数据 
   ) { 
  printf("%s(%d) dif:%lfs, drop frame\n", __FUNCTION__, __LINE __, 
 (is->frame_timer + duration) - time); 11 is->frame_drops_late++; // 统计丢帧情况
     // 这?实现真正的丢帧
     frame_queue_next(&is->pictq);
     goto retry;
     }
   }

丢帧的代码也?较简单，只需要 frame_queue_next ，然后retry。丢帧的前提条件是frame_queue_nb_remaining(&is->pictq) > 1，即是要有nextvp，且需要同时满?以下条件：

(1)不处于step状态。换?之，如果当前是step状态，不会触发丢帧逻辑。（step?于pause状态下进?seek操作时，于seek操作结束后显示seek后的?帧画?，?于直观体现seek?效了）。

(2)启?framedrop机制，或?AV_SYNC_VIDEO_MASTER（不是以video为同步）。

(3)时间已?于frame_timer + duration，已经超过该帧该显示的时?(超过一定的阈值)。

调?video_display进?显示

如果既不需要重复上?帧，也不需要抛弃当前帧，那么就可以安?显示当前帧了。之前有顺带提过video_display 中显示的是 frame_queue_peek_last ，所以需要先调? frame_queue_next ，移动pictq内的指针，将vp变成shown，确保 frame_queue_peek_last 取到的是vp。

static void video_display(VideoState *is) 
{ 
   if (!is->width) 
    video_open(is);//如果窗?未显示，则显示窗? 
  SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255); 
   SDL_RenderClear(renderer); 
   if (is->audio_st && is->show_mode != SHOW_MODE_VIDEO) 
   video_audio_display(is);//图形化显示仅有?轨的?件 
   else if (is->video_st) 
   video_image_display(is);//显示?帧视频画? 
   SDL_RenderPresent(renderer); 
  }

如果初步了解解SDL接?的使?，我们直接看 video_image_display ：

static void video_image_display(VideoState *is) 
{ 
 Frame *vp; 
 Frame *sp = NULL; 
 SDL_Rect rect;
  vp = frame_queue_peek_last(&is->pictq);//取要显示的视频帧 
   if (is->subtitle_st) { 
   //字幕显示逻辑 
 } 
   //将帧宽?按照sar最?适配到窗? 
   calculate_display_rect(&rect, is->xleft, is->ytop, is->width, is ->height, vp->width, vp->height, vp->sar); 
   if (!vp->uploaded) {//如果是重复显示上?帧，那么uploaded就是1 
    if (upload_texture(&is->vid_texture, vp->frame, &is->img_con vert_ctx) < 0) 
    return; 
     vp->uploaded = 1; // 已经拷?过?次到vid_texture则不需要再拷? 
    vp->flip_v = vp->frame->linesize[0] < 0; // = 1垂直翻转, = 0正 常播放 
     } 
   SDL_RenderCopyEx(renderer, is->vid_texture, NULL, &rect, 0, NULL , vp->flip_v ? SDL_FLIP_VERTICAL : 0); 
   if (sp) { 
     //字幕显示逻辑 
     } 
  }

如果了解了SDL的显示， video_image_display 的逻辑不算复杂，即先 frame_queue_peek_last取要显示帧，然后 upload_texture 更新到SDL_Texture，最后通过 SDL_RenderCopyEx 拷?纹理给render显示。

最后，了解下 upload_texture 具体是如何将AVFormat的图像数据传给sdl的纹理：

 static int upload_texture(SDL_Texture **tex, AVFrame *frame, struct SwsContext **img_convert_ctx) { 
    int ret = 0; 
    Uint32 sdl_pix_fmt; 
    SDL_BlendMode sdl_blendmode; 
    // 根据frame中的图像格式(FFmpeg像素格式)，获取对应的SDL像素格式 
    get_sdl_pix_fmt_and_blendmode(frame->format, &sdl_pix_fmt, &sdl_ blendmode); 
    // 参数tex实际是&is->vid_texture，此处根据得到的SDL像素格式，为&is->vid_ texture 
    if (realloc_texture(tex, sdl_pix_fmt == SDL_PIXELFORMAT_UNKNOWN 
     ? SDL_PIXELFORMAT_ARGB8888 : sdl_pix_fmt, frame->width, frame->heigh t, sdl_blendmode, 0) < 0)
    return -1; 
    switch (sdl_pix_fmt) { 
    /*
     frame格式是SDL不?持的格式，则需要进?图像格式转换，
     转换为?标格式AV_ PIX_FMT_BGRA(因为这个转换导致效率可能不如libyuv和shader)
     ，对应SDL_PIXELFORMAT_BGRA32 
    */
    case SDL_PIXELFORMAT_UNKNOWN: 
    /* This should only happen if we are not using avfilte r... */ 
    *img_convert_ctx = sws_getCachedContext(*img_convert_ctx ,
    frame->width, frame->height, frame->format, frame->w idth, frame->height,  AV_PIX_FMT_BGRA, sws_flags, NULL, NULL, NULL); 
     (*img_convert_ctx != NULL) { 
      uint8_t *pixels[4]; 
       int pitch[4];
       
       if (!SDL_LockTexture(*tex, NULL, (void **)pixels, pi tch)) { 
            sws_scale(*img_convert_ctx, (const uint8_t * con st *)frame->data, frame->linesize, 
          0, frame->height, pixels, pitch); 
        SDL_UnlockTexture(*tex); 
        } 
         } else { 
           av_log(NULL, AV_LOG_FATAL, "Cannot initialize the co nversion context\n");
           ret = -1; 
           } 
    break;
   // frame格式对应SDL_PIXELFORMAT_IYUV，不?进?图像格式转换，调?SDL _UpdateYUVTexture()更新SDL texture 
    case SDL_PIXELFORMAT_IYUV: 
    if (frame->linesize[0] > 0 && frame->linesize[1] > 0 && frame->linesize[2] > 0) {
     ret = SDL_UpdateYUVTexture(*tex, NULL, frame->data[0 ], frame->linesize[0],
                                    frame->data[1 ], frame->linesize[1],frame->data[2 ], frame->linesize[2]); 
       } else if (frame->linesize[0] < 0 && frame->linesize[1]< 0 && frame->linesize[2] < 0) { 
          ret = SDL_UpdateYUVTexture(*tex, NULL, frame->data[0 ] + frame->linesize[0] * (frame->height - 1), -fr ame->linesize[0], 
          frame->data[1 ] + frame->linesize[1] * (AV_CEIL_RSHIFT(frame->height, 1) - 1), -fr ame->linesize[1], 
              frame->data[2 ] + frame->linesize[2] * (AV_CEIL_RSHIFT(frame->height, 1) - 1), -fr ame->linesize[2]); 
          } else { 
           av_log(NULL, AV_LOG_ERROR, "Mixed negative and posit ive linesizes are not supported.\n"); 
           return -1; 
           } 
    break; 
    // frame格式对应其他SDL像素格式，不?进?图像格式转换，调?SDL_UpdateT exture()更新SDL texture 
  default:
   if (frame->linesize[0] < 0) { 
      ret = SDL_UpdateTexture(*tex, NULL, frame->data[0] + frame->linesize[0] * (frame->height - 1), -frame->linesize[0]); 
     } else { 
        ret = SDL_UpdateTexture(*tex, NULL, frame->data[0], frame->linesize[0]); 
        } 
    break; 
    } 
 return ret; 
 }
 

frame中的像素格式是FFmpeg中定义的像素格式，FFmpeg中定义的很多像素格式和SDL中定义的很多像素格式其实是同?种格式，只名称不同?已。根据frame中的像素格式与SDL?持的像素格式的匹配情况，upload_texture()处理三种类型，对应switch语句的三个分?：

(1)如果frame图像格式对应SDL_PIXELFORMAT_IYUV格式，不进?图像格式转换，使?SDL_UpdateYUVTexture() 将图像数据更新到 &is->vid_texture。

(2)如果frame图像格式对应其他被SDL?持的格式(诸如AV_PIX_FMT_RGB32)，也不进?图像格式转换，使? SDL_UpdateTexture() 将图像数据更新到 &is->vid_texture。

(3)如果frame图像格式不被SDL?持(即对应SDL_PIXELFORMAT_UNKNOWN)，则需要进?图像格式转换。

根据映射表获取frame对应SDL中的像素格式

get_sdl_pix_fmt_and_blendmode()

这个函数的作?，获取输?参数 format (FFmpeg像素格式)在SDL中的像素格式，取到的SDL像素格式存在输出参数 sdl_pix_fmt 中。

static void get_sdl_pix_fmt_and_blendmode(int format, Uint32 *sdl_pi x_fmt, SDL_BlendMode *sdl_blendmode)
 { 
   int i;
   *sdl_blendmode = SDL_BLENDMODE_NONE;
   *sdl_pix_fmt = SDL_PIXELFORMAT_UNKNOWN; 
   if (format == AV_PIX_FMT_RGB32 || 
   format == AV_PIX_FMT_RGB32_1 || 
   format == AV_PIX_FMT_BGR32 || 
   format == AV_PIX_FMT_BGR32_1) 
   *sdl_blendmode = SDL_BLENDMODE_BLEND; 
   for (i = 0; i < FF_ARRAY_ELEMS(sdl_texture_format_map) - 1; i++) { 
   if (format == sdl_texture_format_map[i].format) { 
   *sdl_pix_fmt = sdl_texture_format_map[i].texture_fmt; 
   return; 
   } 
   } 
   }

在ffplay.c中定义了?个表 sdl_texture_format_map[] ，其中定义了FFmpeg中?些像素格式与SDL像素格式的映射关系，如下：

static const struct TextureFormatEntry { 
   enum AVPixelFormat format; 
   int texture_fmt;
   } sdl_texture_format_map[] = {
     { AV_PIX_FMT_RGB8, SDL_PIXELFORMAT_RGB332 }, 
      { AV_PIX_FMT_RGB444, SDL_PIXELFORMAT_RGB444 }, 
      { AV_PIX_FMT_RGB555, SDL_PIXELFORMAT_RGB555 }, 
      { AV_PIX_FMT_BGR555, SDL_PIXELFORMAT_BGR555 }, 
      { AV_PIX_FMT_RGB565, SDL_PIXELFORMAT_RGB565 }, 
     { AV_PIX_FMT_BGR565, SDL_PIXELFORMAT_BGR565 }, 
     { AV_PIX_FMT_RGB24, SDL_PIXELFORMAT_RGB24 },
     { AV_PIX_FMT_BGR24, SDL_PIXELFORMAT_BGR24 },
     { AV_PIX_FMT_0RGB32, SDL_PIXELFORMAT_RGB888 }, 
     { AV_PIX_FMT_0BGR32, SDL_PIXELFORMAT_BGR888 }, 
    { AV_PIX_FMT_NE(RGB0, 0BGR), SDL_PIXELFORMAT_RGBX8888 }, 
     { AV_PIX_FMT_NE(BGR0, 0RGB), SDL_PIXELFORMAT_BGRX8888 }, 
    { AV_PIX_FMT_RGB32, SDL_PIXELFORMAT_ARGB8888 },
     { AV_PIX_FMT_RGB32_1, SDL_PIXELFORMAT_RGBA8888 }, 
    { AV_PIX_FMT_BGR32, SDL_PIXELFORMAT_ABGR8888 },
    { AV_PIX_FMT_BGR32_1, SDL_PIXELFORMAT_BGRA8888 },
     { AV_PIX_FMT_YUV420P, SDL_PIXELFORMAT_IYUV }, 
    { AV_PIX_FMT_YUYV422, SDL_PIXELFORMAT_YUY2 }, 
    { AV_PIX_FMT_UYVY422, SDL_PIXELFORMAT_UYVY }, 
     { AV_PIX_FMT_NONE, SDL_PIXELFORMAT_UNKNOWN }, 
    };

可以看到，除了最后?项，其他格式的图像送给SDL是可以直接显示的，不必进?图像转换。关于这些像素格式的含义，可参考附录：?彩空间与像素格式。

重新分配vid_texture

realloc_texture()

根据新得到的SDL像素格式，为 &is->vid_texture 重新分配空间，如下所示，先SDL_DestroyTexture() 销毁，再 SDL_CreateTexture() 创建。

static int realloc_texture(SDL_Texture **texture, Uint32 new_format, int new_width, int new_height, SDL_BlendMode blendmode, int init_tex ture)
 { 
 Uint32 format; 
 int access, w, h; 
if (!*texture || SDL_QueryTexture(*texture, &format, &access, &w , &h) < 0 || 
    new_width != w || new_height != h || new_format != form at) {
  void *pixels; 
   int pitch; 
  if (*texture) 
   SDL_DestroyTexture(*texture); 
   if (!(*texture = SDL_CreateTexture(renderer, new_format, SDL _TEXTUREACCESS_STREAMING, new_width, new_height))) 
   return -1; 
   if (SDL_SetTextureBlendMode(*texture, blendmode) < 0) 
   return -1; 
   if (init_texture) { 
  if (SDL_LockTexture(*texture, NULL, &pixels, &pitch) < 0 ) 
   return -1; 
   memset(pixels, 0, pitch * new_height); 
   SDL_UnlockTexture(*texture); 
   } 
   av_log(NULL, AV_LOG_VERBOSE, "Created %dx%d texture with % s.\n", new_width, new_height, SDL_GetPixelFormatName(new_format)); 
   } 
  return 0; 
  }

什么情况下realloc_texture？

(1)?于显示的texture 还没有分配。

(2)SDL_QueryTexture?效。

(3)?前texture的width，height、format和新要显示的Frame不?致。

从上分析可以看出，窗???的变化不?，让realloc_texture重新SDL_CreateTexture。

格式转换-复?或新分配?个SwsContext

sws_getCachedContext()

*img_convert_ctx = sws_getCachedContext(*img_convert_ctx,
                                         frame->width, frame->height, 
                                        frame->format, frame->width, frame-> height, 
                                         AV_PIX_FMT_BGRA, sws_flags, NULL, NULL, NULL);

检查输?参数，第?个输?参数 *img_convert_ctx 对应形参 struct SwsContext *context 。如果context是NULL，调? sws_getContext() 重新获取?个context。

如果context不是NULL，检查其他项输?参数是否和context中存储的各参数?样，若不?样，则先释放context再按照新的输?参数重新分配?个context。若?样，直接使?现有的context。

图像显示

texture对应?帧待显示的图像数据，得到texture后，执?如下步骤即可显示：

SDL_RenderClear(); // 使?特定颜?清空当前渲染?标 
SDL_RenderCopy(); // 使?部分图像数据(texture)更新当前渲 染?标 
SDL_RenderCopyEx(); // 和SDL_RenderCopy类似，但?持旋转 
SDL_RenderPresent(sdl_renderer); // 执?渲染，更新屏幕显示

2.图像格式转换

FFmpeg中的 sws_scale() 函数主要是?来做视频像素格式和分辨率的转换，其优势在于：可以在同?个函数?实现：1.图像?彩空间转换， 2:分辨率缩放，3:前后图像滤波处理。不?之处在于：效率相对较低，不如libyuv或shader，其关联的函数主要有：

(1)sws_getContext：分配和返回?个SwsContext，需要传?输?参数和输出参数；

(2)sws_getCachedContext：检查传?的上下?是否可以?，如果不可?则重新分配?个，如果可?则返回传?的，这个是自动分配。

(3)sws_freeContext：释放SwsContext结构体。

(4)sws_scale：转换?帧图像。

函数说明

 /** 2 * Allocate and return an SwsContext. You need it to perform 
 3 * scaling/conversion operations using sws_scale(). 
 4 * 
 5 * @param srcW the width of the source image 
 6 * @param srcH the height of the source image 
 7 * @param srcFormat the source image format 
 8 * @param dstW the width of the destination image 
 9 * @param dstH the height of the destination image 
 10 * @param dstFormat the destination image format
  * @param flags specify which algorithm and options to use for resca ling 
  12 * @param param extra parameters to tune the used scaler 
  13 * For SWS_BICUBIC param[0] and [1] tune the shape of t he basis 
  14 * function, param[0] tunes f(1) and param[1] f′(1) 
  15 * For SWS_GAUSS param[0] tunes the exponent and thus c utoff 
  16 * frequency 
  17 * For SWS_LANCZOS param[0] tunes the width of the wind ow function 
  18 * @return a pointer to an allocated context, or NULL in case of err or 
  19 * @note this function is to be removed after a saner alternative is 
  20 * written 
  21 */

 struct SwsContext *sws_getContext(int srcW, int srcH, enum AVPixelFo rmat srcFormat, 
                                      int dstW, int dstH, enum AVPixelFo rmat dstFormat, 
                                      int flags, SwsFilter *srcFilter, 
                                      SwsFilter *dstFilter, const double *param);

(1)srcW,srcH, srcFormat， 原始数据的宽?和原始像素格式(YUV420)。

(2)dstW,dstH,dstFormat; ?标宽，?标?，?标的像素格式(这?的宽?可能是?机屏幕分辨率，RGBA8888)，这?不仅仅包含了尺?的转换，还有像素格式的转换。

(3)flag 提供了?系列的算法，快速线性，差值，矩阵，不同的算法性能也不同，快速线性算法性能相对较?。只针对尺?的变换。对像素格式转换?此问题。不同算法的效率?《10.3 ffmpeg中的sws_scale算法性能测试》?节。

#define SWS_FAST_BILINEAR 1

#define SWS_BILINEAR 2

#define SWS_BICUBIC 4

#define SWS_X 8

#define SWS_POINT 0x10

#define SWS_AREA 0x20

#define SWS_BICUBLIN 0x40

(4)后?还有两个参数是做过滤器?的，?般?不到，传NULL，最后?个参数是跟flag算法相关，也可以传NULL。

sws_getCachedContext

 /**  * Check if context can be reused, otherwise reallocate a new one. 
  *  * If context is NULL, just calls sws_getContext() to get a new 
  * context. Otherwise, checks if the parameters are the ones already 
  * saved in context. If that is the case, returns the current 
  * context. Otherwise, frees context and gets a new context with 
* the new parameters. 
  *  * Be warned that srcFilter and dstFilter are not checked, they 
  * are assumed to remain the same. 
 */ 
 struct SwsContext *sws_getCachedContext(struct SwsContext *context, 
                                     14 int srcW, int srcH, enum AVP ixelFormat srcFormat, 
                                     15 int dstW, int dstH, enum AVP ixelFormat dstFormat, 
                                     16 int flags, SwsFilter *srcFil ter, 
                                     17 SwsFilter *dstFilter, const double *param);

int srcW, /* 输?图像的宽度 */

int srcH, /* 输?图像的宽度 */

enum AVPixelFormat srcFormat, /* 输?图像的像素格式 */

int dstW, /* 输出图像的宽度 */

int dstH, /* 输出图像的?度 */

enum AVPixelFormat dstFormat, /* 输出图像的像素格式 */

int flags,/* 选择缩放算法(只有当输?输出图像??不同时有效),?般选择SWS_FAST_BILINEAR */

SwsFilter *srcFilter, /* 输?图像的滤波器信息, 若不需要传NULL */

SwsFilter *dstFilter, /* 输出图像的滤波器信息, 若不需要传NULL */

const double *param /* 特定缩放算法需要的参数(?)，默认为NULL */

getCachedContext和sws_getContext的区别是就是多了struct SwsContext *context的传?。

struct SwsContext *img_convert_ctx = NULL;
 img_convert_ctx = sws_getCachedContext(img_convert_ctx, 
 frame->width, frame->height, frame->forma t, 
 frame->width, frame->height, AV_PIX_FMT_B GRA, 
  sws_flags, NULL, NULL, NULL);

sws_scale

/**  * Scale the image slice in srcSlice and put the resulting scaled 
 * slice in the image in dst. A slice is a sequence of consecutive 
 * rows in an image. 
 * 
 * Slices have to be provided in sequential order, either in 
 * top-bottom or bottom-top order. If slices are provided in 
 * non-sequential order the behavior of the function is undefined. 
 * 
 * @param c the scaling context previously created with 
 * sws_getContext() 
 * @param srcSlice the array containing the pointers to the planes of 
 * the source slice 
* @param srcStride the array containing the strides for each plane of 
 * the source image 
 * @param srcSliceY the position in the source image of the slice to 
 * process, that is the number (counted starting fr om 
 * zero) in the image of the first row of the slice 
 * @param srcSliceH the height of the source slice, that is the numb er
 * of rows in the slice 
 * @param dst the array containing the pointers to the planes of 
* the destination image 
* @param dstStride the array containing the strides for each plane of 
 * the destination image 
 * @return the height of the output slice 
  */ 
int sws_scale(struct SwsContext *c, const uint8_t *const srcSlice[], 
   const int srcStride[], int srcSliceY, int srcSliceH, 
      uint8_t *const dst[], const int dstStride[]);

(1)参数 SwsContext *c， 转换格式的上下?。也就是 sws_getContext 函数返回的结果。

(2)参数 const uint8_t *const srcSlice[], 输?图像的每个颜?通道的数据指针。其实就是解码后的AVFrame中的data[]数组。因为不同像素的存储格式不同，所以srcSlice[]维数也有可能不同。

以YUV420P为例，它是planar格式，它的内存中的排布如下：

YYYYYYYY UUUU VVVV

使?FFmpeg解码后存储在AVFrame的data[]数组中时：

data[0]——-Y分量, Y1, Y2, Y3, Y4, Y5, Y6, Y7, Y8……

data[1]——-U分量, U1, U2, U3, U4……

data[2]——-V分量, V1, V2, V3, V4……

linesize[]数组中保存的是对应通道的数据宽度，这些都是通过计算:

linesize[0]——-Y分量的宽度。

linesize[1]——-U分量的宽度。

inesize[2]——-V分量的宽度。

RGB24，它是packed格式，它在data[]数组中则只有?维，它在存储?式如下：

data[0]: R1, G1, B1, R2, G2, B2, R3, G3, B3, R4, G4, B4……

特别注意，linesize[0]的值并不?定等于图?的宽度，有时候为了对?各解码器的内存，提高CPU访问速度，实际尺?会?于图?的宽度，这点在我们编程时（?如OpengGL硬件转换/渲染）要特别注意，否则解码出来的图像会异常。

(3)参数const int srcStride[]，输?图像的每个颜?通道的跨度。.也就是每个通道的?字节数，对应的是解码后的AVFrame中的linesize[]数组。根据它可以确?下??的起始位置，不过stride和width不?定相同，这是因为有以下2点原因：

第一，由于数据帧存储的对?，有可能会向每?后?增加?些填充字节这样 stride = width + N。

第二，packet?彩空间下，每个像素?个通道数据混合在?起，例如RGB24，每个像素3字节连续存放，因此下??的位置需要跳过3*width字节。

(4)参数int srcSliceY, int srcSliceH,定义在输?图像上处理区域，srcSliceY是起始位置，srcSliceH是处理多少?。如果srcSliceY=0，srcSliceH=height，表示?次性处理完整个图像。这种设置是为了多线程并?，例如可以创建两个线程，第?个线程处理 [0, h/2-1]?，第?个线程处理 [h/2, h-1]?。并?处理加快速度。

(5)参数uint8_t *const dst[], const int dstStride[]定义输出图像信息，输出的每个颜?通道数据指针，每个颜?通道?字节数(也就是宽度)，对应上面的输入和输出。

sws_freeContext：释放SwsContext。

 /** 
 * Free the swscaler context swsContext. 
* If swsContext is NULL, then does nothing. 
*/ 
 void sws_freeContext(struct SwsContext *swsContext);

具体转换

if (*img_convert_ctx != NULL) { 
   uint8_t *pixels[4]; 
   int pitch[4]; 
  if (!SDL_LockTexture(*tex, NULL, (void **)pixels, pitch)) { 
        sws_scale(*img_convert_ctx, (const uint8_t * const *)frame->d ata, frame->linesize, 
     0, frame->height, pixels, pitch); 
   SDL_UnlockTexture(*tex); 
   } 
 }
 

上述代码有三个步骤：

(1)SDL_LockTexture() 锁定texture中的?个rect(此处是锁定整个texture)，锁定区具有只写属性，?于更新图像数据。 pixels 指向锁定区。

(2)sws_scale() 进?图像格式转换，转换后的数据写? pixels 指定的区域。 pixels 包含4个指针，指向?组图像plane。

(3)SDL_UnlockTexture() 将锁定的区域解锁，将改变的数据更新到视频缓冲区中。上述三步完成后，texture中已包含经过格式转换后新的图像数据。

由上分析可以得出texture的缓存区，我们可以直接使?，避免?次拷?。

3.ffmpeg中的sws_scale算法性能测试

这里的性能测试仅供参考，根据不同的配置环境，效果可能些许不一样。

?先，将?幅1920*1080的?景图像，缩放为400*300的24位RGB，下?的帧率，是指每秒钟缩放并渲染的次数。（经过我的测试，渲染的时间可以忽略不计，主要时间还是耗费在缩放算法上。）

总评，以上各种算法，图?缩?之后的效果似乎都不错。如果不是对?着看，?乎看不出缩放效果的好坏。上?所说的清晰（锐利）与平滑（模糊），是?种客观感受，并?清晰就?平滑好，也?平滑?清晰好。其中的Point算法，效率之?，让我震撼，但效果却不差。此外，我对?过使?CImage的绘制时缩放，其帧率可到190，但效果惨不忍睹，颜?严重失真。

第?个试验，将?幅1024*768的?景图像，放?到1920*1080，并进?渲染（此时的渲染时间，虽然不是忽略不计，但不超过5ms的渲染时间，不影响下?结论的相对准确性）。

总评，Point算法有明显锯?，Area算法锯?要不明显?点，其余各种算法，?眼看来?明显差异。此外，使?CImage进?渲染时缩放，帧率可达105，效果与Point相似。

方案选型

个?建议，如果对图像的缩放，要追求?效，?如说是视频图像的处理，在不明确是放?还是缩?时，直接使?SWS_FAST_BILINEAR算法即可。如果明确是要缩?并显示，建议使?Point算法，如果是明确要放?并显示，其实使?CImage的Strech更?效。当然，如果不计速度追求画?质量。在上?的算法中，选择帧率最低的那个即可，画?效果?般是最好的。

不过总的来说，ffmpeg的scale算法，速度还是?常快的，毕竟我选择的素材可是?清的图?。(本想顺便上传?下图?，但各组图?差异其实?常?，恐怕上传的时候格式转换所造成的图像细节丢失，已经超过了各图?本身的细节差异，因此此处不上传图?了。)

注意：试验了?下OpenCV的Resize效率，和上?相同的情况下，OpenCV在上?的放?试验中，每秒可以进?52次，缩?试验中，每秒可以进?458次。放大和缩小是不一样的结果，放大处理，更消耗资源。

FFmpeg使?不同sws_scale()缩放算法的命令示例（bilinear，bicubic，neighbor）：

ffmpeg -s 480x272 -pix_fmt yuv420p -i src01_480x272.yuv -s 1280x720 - sws_flags bilinear -pix_fmt yuv420p src01_bilinear_1280x720.yuv 
ffmpeg -s 480x272 -pix_fmt yuv420p -i src01_480x272.yuv -s 1280x720 - sws_flags bicubic -pix_fmt yuv420p src01_bicubic_1280x720.yuv 
ffmpeg -s 480x272 -pix_fmt yuv420p -i src01_480x272.yuv -s 1280x720 - sws_flags neighbor -pix_fmt yuv420p src01_neighbor_1280x720.yuv

这篇文章就分析到这里，欢迎关注，点赞，转发，收藏。