ffmpeg time_base详解

小咪咪 2022-06-11 01:58 221阅读 0赞

[ffmpeg time\_base][ffmpeg time_base]

ffmpeg存在多个时间基准(time\_base)，对应不同的阶段(结构体)，每个time\_base具体的值不一样，ffmpeg提供函数在各个time\_base中进行切换。搞清楚各个time\_base的来源，对于阅读ffmpeg的代码很重要。  
  
一、time\_base  
1、AVStream(libavformat/avformat.h)

typedef struct AVStream \{  
     /\*\*   
      \*  This  is  the fundamental unit of  time  (in seconds) in terms  
      \*  of which frame timestamps are represented.  
      \*   
      \*  decoding:  set  by libavformat  
      \*  encoding: May be  set  by the caller before avformat\_write\_header()  to   
      \*            provide a hint  to  the muxer about the desired timebase. In  
      \*            avformat\_write\_header(), the muxer will overwrite this field  
      \*             with  the timebase that will actually be used  for  the timestamps  
      \*            written into the file (which may  or  may  not  be related  to  the  
      \*            user \- provided one, depending  on  the format).  
      \*/   
    AVRational time\_base;  
  
     /\*\*   
      \*  Decoding: pts of the first frame of the stream in presentation order, in stream  time  base.  
      \*  Only  set  this  if  you are absolutely  100 % sure that the value you  set   
      \*  it  to  really  is  the pts of the first frame.  
      \*  This may be undefined (AV\_NOPTS\_VALUE).  
      \*  @note The ASF header does  NOT  contain a correct start\_time the ASF  
      \*  demuxer must  NOT   set  this.  
      \*/   
    int64\_t start\_time;  
  
     /\*\*   
      \*  Decoding: duration of the stream, in stream  time  base.  
      \*   If  a source file does  not  specify a duration, but does specify  
      \*  a bitrate, this value will be estimated from bitrate  and  file size.  
      \*/   
    int64\_t duration;

从上面的信息可以看到，AVStream->time\_base单位为秒。  
  
那AVStream->time\_base具体的值是多少呢？下面以mpegts\_demuxer为例：

static  int  mpegts\_set\_stream\_info(AVStream  \* st, PESContext  \* pes,  
                                  uint32\_t stream\_type, uint32\_t prog\_reg\_desc)  
\{  
avpriv\_set\_pts\_info(st,  33 ,  1 ,  90000 );  
  
  
void avpriv\_set\_pts\_info(AVStream  \* s,  int  pts\_wrap\_bits,  
                         unsigned  int  pts\_num, unsigned  int  pts\_den)  
\{  
    AVRational new\_tb;  
     if  (av\_reduce( & new\_tb.num,  & new\_tb.den, pts\_num, pts\_den, INT\_MAX)) \{  
         if  (new\_tb.num ! =  pts\_num)  
            av\_log( NULL , AV\_LOG\_DEBUG,  
                    " st:%d removing common factor %d from timebase\\n " ,  
                   s \-> index, pts\_num  /  new\_tb.num);  
    \}  else   
        av\_log( NULL , AV\_LOG\_WARNING,  
                " st:%d has too large timebase, reducing\\n " , s \-> index);  
  
     if  (new\_tb.num  <=   0  || new\_tb.den  <=   0 ) \{  
        av\_log( NULL , AV\_LOG\_ERROR,  
                " Ignoring attempt to set invalid timebase %d/%d for st:%d\\n " ,  
               new\_tb.num, new\_tb.den,  
               s \-> index);  
        return;  
    \}  
    s \-> time\_base      =  new\_tb;  
    av\_codec\_set\_pkt\_timebase(s \-> codec, new\_tb);  
    s \-> pts\_wrap\_bits  =  pts\_wrap\_bits;  
\}

通过avpriv\_set\_pts\_info(st, 33, 1, 90000)函数，设置AVStream->time\_base为1/90000。为什么是90000？因为mpeg的pts、dts都是以90kHz来采样的，所以采样间隔为1/90000秒。  
  
2、AVCodecContext

typedef struct AVCodecContext \{  
     /\*\*   
      \*  This  is  the fundamental unit of  time  (in seconds) in terms  
      \*  of which frame timestamps are represented.  For  fixed \- fps content,  
      \*  timebase should be  1 / framerate  and  timestamp increments should be  
      \*  identically  1 .  
      \*   \-  encoding: MUST be  set  by user.  
      \*   \-  decoding:  Set  by libavcodec.  
      \*/   
    AVRational time\_base;

从上面的信息可以看到，AVCodecContext->time\_base单位同样为秒，不过精度没有AVStream->time\_base高，大小为1/framerate。  
  
下面以ffmpeg转码工具为例：

static  int  transcode\_init(void)  
\{  
             if  (enc\_ctx \-> codec\_type  ==  AVMEDIA\_TYPE\_VIDEO) \{  
                 if  (ost \-> filter   &&  !ost \-> frame\_rate.num)  
                    ost \-> frame\_rate  =  av\_buffersink\_get\_frame\_rate(ost \-> filter \-> filter );  
                 if  (ist  &&  !ost \-> frame\_rate.num)  
                    ost \-> frame\_rate  =  ist \-> framerate;  
                 if  (ist  &&  !ost \-> frame\_rate.num)  
                    ost \-> frame\_rate  =  ist \-> st \-> r\_frame\_rate;  
                 if  (ist  &&  !ost \-> frame\_rate.num) \{  
                    ost \-> frame\_rate  =  (AVRational)\{  25 ,  1 \};  
                    av\_log( NULL , AV\_LOG\_WARNING,  
                            " No information  "   
                            " about the input framerate is available. Falling  "   
                            " back to a default value of 25fps for output stream \#%d:%d. Use the -r option  "   
                            " if you want a different framerate.\\n " ,  
                           ost \-> file\_index, ost \-> index);  
                \}  
 //                     ost \-> frame\_rate  =  ist \-> st \-> avg\_frame\_rate.num ? ist \-> st \-> avg\_frame\_rate : (AVRational)\{  25 ,  1 \};  
                 if  (ost \-> enc  &&  ost \-> enc \-> supported\_framerates  &&  !ost \-> force\_fps) \{  
                     int  idx  =  av\_find\_nearest\_q\_idx(ost \-> frame\_rate, ost \-> enc \-> supported\_framerates);  
                    ost \-> frame\_rate  =  ost \-> enc \-> supported\_framerates\[idx\];  
                \}  
                 if  (enc\_ctx \-> codec\_id  ==  AV\_CODEC\_ID\_MPEG4) \{  
                    av\_reduce( & ost \-> frame\_rate.num,  & ost \-> frame\_rate.den,  
                              ost \-> frame\_rate.num, ost \-> frame\_rate.den,  65535 );  
                \}  
            \}  
  
            switch (enc\_ctx \-> codec\_type) \{  
             case  AVMEDIA\_TYPE\_VIDEO:  
                  
                enc\_ctx \-> time\_base  =  av\_inv\_q(ost \-> frame\_rate);  
                 if  (ost \-> filter   &&  !(enc\_ctx \-> time\_base.num  &&  enc\_ctx \-> time\_base.den))  
                    enc\_ctx \-> time\_base  =  ost \-> filter \-> filter \-> inputs\[ 0 \] \-> time\_base;  
                 if  (   av\_q2d(enc\_ctx \-> time\_base)  <   0.001   &&  video\_sync\_method ! =  VSYNC\_PASSTHROUGH  
                    &&  (video\_sync\_method  ==  VSYNC\_CFR || video\_sync\_method  ==  VSYNC\_VSCFR || (video\_sync\_method  ==  VSYNC\_AUTO  &&  !(oc \-> oformat \-> flags  &  AVFMT\_VARIABLE\_FPS))))\{  
                    av\_log(oc, AV\_LOG\_WARNING,  " Frame rate very high for a muxer not efficiently supporting it.\\n "   
                                                " Please consider specifying a lower framerate, a different muxer or -vsync 2\\n " );  
                \}

首先获取ost->frame\_rate，然后计算enc\_ctx->time\_base = 1/ost->frame\_rate。  
  
总结：  
    AVStream->time\_base比AVCodecContext->time\_base精度要高(数值要小)，比如AVStream->time\_base为1/90000，而AVCodecContext->time\_base为1/30(假设frame\_rate为30)；同样的pts和dts，以AVStream->time\_base为单位，数值要比以AVCodecContext->time\_base为单位要大。  
  
二、pts、dts  
那各个结构下，pts和dts使用哪个time\_base来表示呢？  
  
1、AVPacket

typedef struct AVPacket \{  
     /\*\*   
      \*  Presentation timestamp in AVStream \-> time\_base units; the  time  at which  
      \*  the decompressed packet will be presented  to  the user.  
      \*  Can be AV\_NOPTS\_VALUE  if  it  is   not  stored in the file.  
      \*  pts MUST be larger  or  equal  to  dts  as  presentation cannot happen before  
      \*  decompression, unless one wants  to  view  hex  dumps. Some formats misuse  
      \*  the terms dts  and  pts / cts  to  mean something different. Such timestamps  
      \*  must be converted  to   true  pts / dts before they are stored in AVPacket.  
      \*/   
    int64\_t pts;  
     /\*\*   
      \*  Decompression timestamp in AVStream \-> time\_base units; the  time  at which  
      \*  the packet  is  decompressed.  
      \*  Can be AV\_NOPTS\_VALUE  if  it  is   not  stored in the file.  
      \*/   
    int64\_t dts;

从上面可以看到，AVPacket下的pts和dts以AVStream->time\_base为单位(数值比较大)。这也很容易理解，根据mpeg的协议，压缩后或解压前的数据，pts和dts是90kHz时钟的采样值，时间间隔就是AVStream->time\_base。  
  
2、AVFrame

typedef struct AVFrame \{  
     /\*\*   
      \*  Presentation timestamp in time\_base units ( time  when frame should be shown  to  user).  
      \*/   
    int64\_t pts;  
  
     /\*\*   
      \*  PTS copied from the AVPacket that was decoded  to  produce this frame.  
      \*/   
    int64\_t pkt\_pts;  
  
     /\*\*   
      \*  DTS copied from the AVPacket that triggered returning this frame. ( if  frame threading isn ' t used)   
       \*  This  is  also the Presentation  time  of this AVFrame calculated from  
      \*  only AVPacket.dts values without pts values.  
      \*/   
    int64\_t pkt\_dts;

注意：  
    AVFrame里面的pkt\_pts和pkt\_dts是拷贝自AVPacket，同样以AVStream->time\_base为单位；而pts是为输出(显示)准备的，以AVCodecContex->time\_base为单位)。//FIXME  
  
3、InputStream

typedef struct InputStream \{  
     int  file\_index;  
    AVStream  \* st;  
    AVCodecContext  \* dec\_ctx;  
    int64\_t       start;      /\*   time  when read started  \*/   
     /\*  predicted dts of the  next  packet read  for  this stream  or  (when there are  
      \*  several frames in a packet) of the  next  frame in current packet (in AV\_TIME\_BASE units)  \*/   
    int64\_t       next\_dts;  
    int64\_t       dts;        ///<  dts of the last packet read  for  this stream (in AV\_TIME\_BASE units)  
  
    int64\_t       next\_pts;   ///<  synthetic pts  for  the  next  decode frame (in AV\_TIME\_BASE units)  
    int64\_t       pts;        ///<  current pts of the decoded frame  (in AV\_TIME\_BASE units)

从上面可以看到，InputStream下的pts和dts以AV\_TIME\_BASE为单位(微秒)，至于为什么要转化为微妙，可能是为了避免使用浮点数。  
  
4、OutputStream

typedef struct OutputStream \{  
     int  file\_index;           /\*  file index  \*/   
     int  index;                /\*  stream index in the output file  \*/   
     int  source\_index;         /\*  InputStream index  \*/   
    AVStream  \* st;             /\*  stream in the output file  \*/   
     int  encoding\_needed;      /\*   true   if  encoding needed  for  this stream  \*/   
     int  frame\_number;  
     /\*  input pts  and  corresponding output pts  
        for  A / V sync  \*/   
    struct InputStream  \* sync\_ist;  /\*  input stream  to  sync against  \*/   
    int64\_t sync\_opts;        /\*  output frame counter, could be changed  to  some  true  timestamp  \*/   //  FIXME look at frame\_number  
     /\*  pts of the first frame encoded  for  this stream, used  for  limiting  
      \*  recording  time   \*/   
    int64\_t first\_pts;  
     /\*  dts of the last packet sent  to  the muxer  \*/   
    int64\_t last\_mux\_dts;  
    AVBitStreamFilterContext  \* bitstream\_filters;  
    AVCodecContext  \* enc\_ctx;  
    AVCodec  \* enc;  
    int64\_t max\_frames;  
    AVFrame  \* filtered\_frame;

OutputStream涉及音视频同步，结构和InputStream不同，暂时只作记录，不分析。  
  
  
三、各个time\_base之间转换  
  
ffmpeg提供av\_rescale\_q函数用于time\_base之间转换，av\_rescale\_q(a,b,c)作用相当于执行a\*b/c，通过设置b,c的值，可以很方便的实现time\_base之间转换。  
例如：  
1、InputStream(AV\_TIME\_BASE)到AVPacket(AVStream->time\_base)

static  int  decode\_video(InputStream  \* ist, AVPacket  \* pkt,  int   \* got\_output)  
\{  
pkt \-> dts   =  av\_rescale\_q(ist \-> dts, AV\_TIME\_BASE\_Q, ist \-> st \-> time\_base);

2、AVPacket(AVStream->time\_base)到InputStream(AV\_TIME\_BASE)

static  int  process\_input\_packet(InputStream  \* ist,  const  AVPacket  \* pkt)  
\{  
  
     if  (pkt \-> dts ! =  AV\_NOPTS\_VALUE) \{  
        ist \-> next\_dts  =  ist \-> dts  =  av\_rescale\_q(pkt \-> dts, ist \-> st \-> time\_base, AV\_TIME\_BASE\_Q);

四、后记：  
   AVFrame->pts和AVPacket->pts、AVPacket->dts的值，在解码/编码后，会经历短暂的time\_base不匹配的情况：  
  
1、解码后

static  int  decode\_video(InputStream  \* ist, AVPacket  \* pkt,  int   \* got\_output)  
\{  
    decoded\_frame  =  ist \-> decoded\_frame;  
    pkt \-> dts   =  av\_rescale\_q(ist \-> dts, AV\_TIME\_BASE\_Q, ist \-> st \-> time\_base);   
  
    update\_benchmark( NULL );  
    ret  =  avcodec\_decode\_video2(ist \-> dec\_ctx,  
                                decoded\_frame, got\_output, pkt);  
  
    best\_effort\_timestamp =  av\_frame\_get\_best\_effort\_timestamp(decoded\_frame);     
     if (best\_effort\_timestamp ! =  AV\_NOPTS\_VALUE)  
        ist \-> next\_pts  =  ist \-> pts  =  av\_rescale\_q(decoded\_frame \-> pts  =  best\_effort\_timestamp, ist \-> st \-> time\_base, AV\_TIME\_BASE\_Q);

解码后，decoded\_frame->pts的值使用AVStream->time\_base为单位，后在AVFilter里面转换成以AVCodecContext->time\_base为单位。   //FIXME  
  
2、编码后

static void do\_video\_out(AVFormatContext  \* s,  
                         OutputStream  \* ost,  
                         AVFrame  \* in\_picture)  
\{  
        ret  =  avcodec\_encode\_video2(enc,  & pkt, in\_picture,  & got\_packet);      
         if  (got\_packet) \{  
             if  (debug\_ts) \{  
                av\_log( NULL , AV\_LOG\_INFO,  " encoder -> type:video  "   
                        " pkt\_pts:%s pkt\_pts\_time:%s pkt\_dts:%s pkt\_dts\_time:%s\\n " ,  
                       av\_ts2str(pkt.pts), av\_ts2timestr(pkt.pts,  & enc \-> time\_base),  
                       av\_ts2str(pkt.dts), av\_ts2timestr(pkt.dts,  & enc \-> time\_base));  
            \}  
  
             if  (pkt.pts  ==  AV\_NOPTS\_VALUE  &&  !(enc \-> codec \-> capabilities  &  CODEC\_CAP\_DELAY))  
                pkt.pts  =  ost \-> sync\_opts;  
  
            av\_packet\_rescale\_ts( & pkt, enc \-> time\_base, ost \-> st \-> time\_base);    
  
             if  (debug\_ts) \{  
                av\_log( NULL , AV\_LOG\_INFO,  " encoder -> type:video  "   
                     " pkt\_pts:%s pkt\_pts\_time:%s pkt\_dts:%s pkt\_dts\_time:%s\\n " ,  
                    av\_ts2str(pkt.pts), av\_ts2timestr(pkt.pts,  & ost \-> st \-> time\_base),  
                    av\_ts2str(pkt.dts), av\_ts2timestr(pkt.dts,  & ost \-> st \-> time\_base));  
            \}  
  
            frame\_size  =  pkt.size;  
            write\_frame(s,  & pkt, ost);    
             /\*   if  two pass, output  log   \*/   
             if  (ost \-> logfile  &&  enc \-> stats\_out) \{  
                fprintf(ost \-> logfile,  " %s " , enc \-> stats\_out);  
            \}  
        \}

编码后，pkt.pts、pkt.dts使用AVCodecContext->time\_base为单位，后通过调用"av\_packet\_rescale\_ts"转换为AVStream->time\_base为单位。

[ffmpeg time_base]: http://www.cnitblog.com/luofuchong/archive/2014/11/28/89869.html