x264代码阅读笔记——非常详细

心已赠人 2022-06-08 08:23 256阅读 0赞

（一）common/set.h的注释

\#ifndef \_SET\_H  
\#define \_SET\_H 1

enum profile\_e  
\{  
    PROFILE\_BASELINE = 66,  
    PROFILE\_MAIN     = 77,  
    PROFILE\_EXTENTED = 88,  
    PROFILE\_HIGH    = 100,  
    PROFILE\_HIGH10  = 110,  
    PROFILE\_HIGH422 = 122,  
    PROFILE\_HIGH444 = 144  
\};

enum cqm4\_e  
\{  
    CQM\_4IY = 0,  
    CQM\_4PY = 1,  
    CQM\_4IC = 2,  
    CQM\_4PC = 3  
\};  
enum cqm8\_e  
\{  
    CQM\_8IY = 0,  
    CQM\_8PY = 1  
\};

typedef struct//profile:外形,评测,概况,剖面  
\{  
    int i\_id; //?????

int i\_profile\_idc; //指明所用profile  
    int i\_level\_idc; //指明所用level

int b\_constraint\_set0;//\[毕厚杰书 160 页,constraint\_set0\_flag\]，等于1时，表时必须遵从A.2.1 ...所指明的所有制约条件，等于0时表示不必遵从所有条件  
    int b\_constraint\_set1;//\[毕厚杰书 160 页,constraint\_set0\_flag\]，等于1时，表时必须遵从A.2.2 ...所指明的所有制约条件，等于0时表示不必遵从所有条件  
    int b\_constraint\_set2;//\[毕厚杰书 160 页,constraint\_set0\_flag\]，等于1时，表时必须遵从A.2.3 ...所指明的所有制约条件，等于0时表示不必遵从所有条件//constraint:约束;限制;强迫;强制  
       //注意：当constraint\_set0\_flag、中有两个以上等于1时，A.2中的所有制约条件都要被遵从  
    int i\_log2\_max\_frame\_num;//表示图像解码顺序的最大取值  
       //\[毕 厚杰书 160 页,log2\_max\_frame\_num\_minus4\]，这个句法元素主要是为读取另一个句法元素frame\_num服务的，frame\_num是最 重要的句法元素之一，它标识所属图像的解码顺序。可以在句法表中看到，frame\_num的解码函数是ue(v)，函数中的v在这里指 定，v=log2\_max\_frame\_num\_minus + 4  
    int i\_poc\_type;   //\[毕厚杰书 160 页,pic\_order\_cnt\_type\]，指明了POC(Picture Order Count)的编码方法、POC标识图像的播放顺序。由于H.264使用了B帧预测，使得图像的解码顺序不一定等于播放顺序，但它们之间存在一定的映射关 系。POC可以由frame\_num通过映射关系计算得来，也可以索性由编码器显式地传送。H.264一共定义了3种POC的编码方法，这个句法元素就是 用来通知解码器该用哪种方法来计算POC。pic\_order\_cnt\_tye的取值范围是\[0,2\]...  
     
    int i\_log2\_max\_poc\_lsb; //\[毕厚杰书 160 页,log2\_max\_pic\_order\_cnt\_lsb\_minus4\]，指明了变量MaxPicOrderCntLsb的值。  
     
    int b\_delta\_pic\_order\_always\_zero;//\[毕厚杰书 161 页,delta\_pic\_order\_always\_zero\_flag\]，其值等于1时句法元素delta\_pic\_order\_cnt\[0\]和 delta\_pic\_order\_cnt\[1\]不再片头出现，且他们的默认值都为0。为0时上述则出现。  
    int i\_offset\_for\_non\_ref\_pic;//\[毕厚杰书 161 页,offset\_for\_non\_ref\_pic\]，用来计算非参考帧或场的picture order count ,其值应在\[-2e31,2e31-1\]  
    int i\_offset\_for\_top\_to\_bottom\_field;//\[毕厚杰书 161 页,offset\_for\_top\_to\_bottom\_field\]，用来计算帧的底场的picture order count 其值应在\[-2e31,2e31-1\]  
    int i\_num\_ref\_frames\_in\_poc\_cycle;//\[毕厚杰书 161 页,num\_ref\_frames\_in\_pic\_order\_cnt\_cycle\]，用来解码picture order count 取值应在\[0，255\]之间  
    int i\_offset\_for\_ref\_frame\[256\];//\[毕厚杰书 161 页,offset\_for\_ref\_frame\[i\]\]，当picture order count type=1时用来解码poc，这句语法对循环num\_ref\_frames\_in\_poc\_cycle中的每一个元素指定了一个偏移

int i\_num\_ref\_frames;//\[毕厚杰书 161 页,num\_ref\_frames\]，指定参考帧队列的最大长度，h264规定最多可为16个参考帧，本句法元素的值最大为16。值得注意的是这个长度以 帧为单位，如果在场模式下，应该相应地扩展一倍。  
    int b\_gaps\_in\_frame\_num\_value\_allowed;//\[毕厚杰书 161 页,gaps\_in\_frame\_num\_value\_allowed\_flag\]，为1时表示允许句法frame\_num可以不连续。当传输信道堵塞严 重时，编码器来不及将编码后的图像全部发出，这时允许丢弃若干帧图像。在正常情况下每一帧图像都有依次连续的frame\_num值，解码器检查到如果 frame\_num不连续，便能确定有图像被编码器丢弃。这时，解码器必须启动错误掩藏机制来近似地恢复这些图像，因为这些图像有可能被后续图像用作参考 帧。  
         //当这个句法元素=0时，表示不允许frame\_num不连续，即编码器在任何情况下都不能丢弃图像。这时，H.264 允许解码器可以不去检查frame\_num的连续性以减少计算量。这种情况下如果依然发生frame\_num不连续，表示在传输中发生丢包，解码器会通过 其他机制检测到丢包的发生，然后启动错误掩藏的恢复图像。  
    int i\_mb\_width;//\[毕厚杰书 161 页,pic\_width\_in\_mbs\_minus1\]，本句法元素加1后指明图像宽度，以宏块为单位。  
    int i\_mb\_height;//\[毕厚杰书 161 页,pic\_height\_in\_map\_units\_minus1\]，本句法元素加1后指明图像的高度。  
    int b\_frame\_mbs\_only;//\[毕厚杰书 161 页,frame\_mbs\_only\_flag\]，本句法元素=1时，表示本序列中所有图像的编码模式都是帧，没有其他编码模式存在；本句法元素=0时，表 示本序列中图像的编码模式可能是帧，也可能是场或帧场自适应，某个图像具体是哪一种要由其他句法元素决定。  
    int b\_mb\_adaptive\_frame\_field;//\[毕厚杰书 161 页,mb\_adaptive\_frame\_field\_flag\]，指明本序列是否属于帧场自适应模式。=1时，表明在本序列  
    int b\_direct8x8\_inference;//指明b片的直接和skip模式下运动矢量的预测方法

int b\_crop;//crop:剪裁 \[毕厚杰书 162 页,frame\_cropping\_flag\]，用于指明解码器是否要将图像裁剪后输出，如果是的话，后面紧跟着的四个句法元素分别指出左、右、上、下裁剪的宽度。  
    struct  
    \{  
        int i\_left;  //\[毕厚杰书 162 页,frame\_crop\_left\_offset\]，左  
        int i\_right; //\[毕厚杰书 162 页,frame\_crop\_left\_offset\]，右  
        int i\_top;  //\[毕厚杰书 162 页,frame\_crop\_left\_offset\]，上  
        int i\_bottom; //\[毕厚杰书 162 页,frame\_crop\_left\_offset\]，下  
    \} crop;//图像剪裁后输出的参数;crop:剪裁,剪切,剪辑

int b\_vui; \[毕厚杰书 162 页,vui\_parameters\_present\_flag\]，指明vui子结构是否出现在码流中，vui的码流结构在...附录指明，用以表征视频格式等额外信息  
    struct  
    \{  
        int b\_aspect\_ratio\_info\_present;  
        int i\_sar\_width;  
        int i\_sar\_height;  
         
        int b\_overscan\_info\_present;  
        int b\_overscan\_info;

int b\_signal\_type\_present;  
        int i\_vidformat;  
        int b\_fullrange;  
        int b\_color\_description\_present;  
        int i\_colorprim;  
        int i\_transfer;  
        int i\_colmatrix;

int b\_chroma\_loc\_info\_present;  
        int i\_chroma\_loc\_top;  
        int i\_chroma\_loc\_bottom;

int b\_timing\_info\_present;  
        int i\_num\_units\_in\_tick;  
        int i\_time\_scale;  
        int b\_fixed\_frame\_rate;

int b\_bitstream\_restriction;  
        int b\_motion\_vectors\_over\_pic\_boundaries;  
        int i\_max\_bytes\_per\_pic\_denom;  
        int i\_max\_bits\_per\_mb\_denom;  
        int i\_log2\_max\_mv\_length\_horizontal;  
        int i\_log2\_max\_mv\_length\_vertical;  
        int i\_num\_reorder\_frames;  
        int i\_max\_dec\_frame\_buffering;

\} vui;

int b\_qpprime\_y\_zero\_transform\_bypass;

\} x264\_sps\_t;//x264\_sps\_t定义序列参考队列的参数以及初始化

typedef struct  
\{  
    int i\_id;//\[毕厚杰：P146 pic\_parameter\_set\_id\] 本参数集的序号，在各片的片头被引用  
    int i\_sps\_id;//\[毕厚杰：P146 seq\_parameter\_set\_id\] 指明本图像参数集所引用的序列参数集的序号

int b\_cabac;//\[毕厚杰：P146 entropy\_coding\_mode\_flag\] 指明熵编码的选择：0时使用cavlc，1时使用cabac

int b\_pic\_order;//\[毕厚杰：P147 pic\_order\_present\_flag\] poc的三种计算方法在片层还各需要用一些句法元素作为参数；当等于时，表示在片头会有句句法元素指明这些参数；当不为时，表示片头不会给出这些参数  
    int i\_num\_slice\_groups;//\[毕厚杰：P147 num\_slice\_groups\_minus1\] 加一表示图像中片组的个数

int i\_num\_ref\_idx\_l0\_active;//\[毕厚杰：P147 num\_ref\_idx\_10\_active\_minus1\] 指明目前参考帧队列的长度，即有多少个参考帧（短期和长期），用于list0  
    int i\_num\_ref\_idx\_l1\_active;//\[毕厚杰：P147 num\_ref\_idx\_11\_active\_minus1\] 指明目前参考帧队列的长度，即有多少个参考帧（短期和长期），用于list1

int b\_weighted\_pred;//\[毕厚杰：P147 weighted\_pred\_flag\] 指明是否允许p和sp片的加权预测，如果允许，在片头会出现用以计算加权预测的句法元素  
    int b\_weighted\_bipred;//\[毕厚杰：P147 weighted\_bipred\_idc\] 指明是否允许b片的加权预测

int i\_pic\_init\_qp;//\[毕厚杰：P147 pic\_init\_qp\_minus26\] 亮度分量的量化参数的初始值  
    int i\_pic\_init\_qs;//\[毕厚杰：P147 pic\_init\_qs\_minus26\] 亮度分量的量化参数的初始值，用于SP和SI

int i\_chroma\_qp\_index\_offset;//\[毕厚杰：P147 chroma\_qp\_index\_offset\] 色度分量的量化参数是根据亮度分量的量化参数计算出来的，本句法元素用以指明计算时用到的参数表示为在 QPC 值的表格中寻找 Cb色度分量而应加到参数 QPY 和 QSY 上的偏移,chroma\_qp\_index\_offset 的值应在-12 到 +12范围内（包括边界值）

int b\_deblocking\_filter\_control;//\[毕厚杰：P147 deblocking\_filter\_control\_present\_flag\] 编码器可以通过句法元素显式地控制去块滤波的强度  
    int b\_constrained\_intra\_pred;//\[毕厚杰：P147 constrained\_intra\_pred\_flag\] 在p和b片中，帧内编码的宏块的邻近宏块可能是采用的帧间编码  
    int b\_redundant\_pic\_cnt;//\[毕厚杰：P147 redundant\_pic\_cnt\_present\_flag\] redundant\_pic\_cnt 对于那些属于基本编码图像的条带和条带数据分割块应等于0。在冗余编码图像中的编码条带和编码条带数据分割块的 redundant\_pic\_cnt 的值应大于 0。当redundant\_pic\_cnt 不存在时，默认其值为 0。redundant\_pic\_cnt的值应该在 0到 127范围内（包括 0和127）

int b\_transform\_8x8\_mode;//?????????????

int i\_cqm\_preset;//cqm:外部量化矩阵的设置  
    const uint8\_t \*scaling\_list\[6\];

\} x264\_pps\_t;//图像参数集\[毕厚杰，P146 \]

static const uint8\_t x264\_cqm\_jvt4i\[16\] =  
\{  
      6,13,20,28,  
     13,20,28,32,  
     20,28,32,37,  
     28,32,37,42  
\};  
  
static const uint8\_t x264\_cqm\_jvt4p\[16\] =  
\{  
    10,14,20,24,  
    14,20,24,27,  
    20,24,27,30,  
    24,27,30,34  
\};  
  
static const uint8\_t x264\_cqm\_jvt8i\[64\] =  
\{  
     6,10,13,16,18,23,25,27,  
    10,11,16,18,23,25,27,29,  
    13,16,18,23,25,27,29,31,  
    16,18,23,25,27,29,31,33,  
    18,23,25,27,29,31,33,36,  
    23,25,27,29,31,33,36,38,  
    25,27,29,31,33,36,38,40,  
    27,29,31,33,36,38,40,42  
\};  
  
static const uint8\_t x264\_cqm\_jvt8p\[64\] =  
\{  
     9,13,15,17,19,21,22,24,  
    13,13,17,19,21,22,24,25,  
    15,17,19,21,22,24,25,27,  
    17,19,21,22,24,25,27,28,  
    19,21,22,24,25,27,28,30,  
    21,22,24,25,27,28,30,32,  
    22,24,25,27,28,30,32,33,  
    24,25,27,28,30,32,33,35  
\};

static const uint8\_t x264\_cqm\_flat16\[64\] =  
\{  
    16,16,16,16,16,16,16,16,  
    16,16,16,16,16,16,16,16,  
    16,16,16,16,16,16,16,16,  
    16,16,16,16,16,16,16,16,  
    16,16,16,16,16,16,16,16,  
    16,16,16,16,16,16,16,16,  
    16,16,16,16,16,16,16,16,  
    16,16,16,16,16,16,16,16  
\};  
static const uint8\_t \* const x264\_cqm\_jvt\[6\] =  
\{  
    x264\_cqm\_jvt4i, x264\_cqm\_jvt4p,  
    x264\_cqm\_jvt4i, x264\_cqm\_jvt4p,  
    x264\_cqm\_jvt8i, x264\_cqm\_jvt8p  
\};

void x264\_cqm\_init( x264\_t \*h );  
void x264\_cqm\_delete( x264\_t \*h );  
int  x264\_cqm\_parse\_file( x264\_t \*h, const char \*filename );

\#endif

（二）

1. if( p\_set\_outfile\_param( opt->hout, param ) )  // p\_set\_outfile\_param = set\_param\_bsf 判断输出文件  
    \{  
        fprintf( stderr, "can't set outfile param\\n" );  
        p\_close\_infile( opt->hin );  
        p\_close\_outfile( opt->hout );  
        return -1;  
    \}

p\_set\_outfile\_param = set\_param\_bsf , 在muxers.c中，函数原型为：

int set\_param\_bsf( hnd\_t handle, x264\_param\_t \*p\_param )  
\{  
    return 0;  
\}

2.  x264\_picture\_alloc( &pic, X264\_CSP\_I420, param->i\_width, param->i\_height );

//构造一个图像帧的初始化空间，在common.c中，函数原型为：

void x264\_picture\_alloc( x264\_picture\_t \*pic, int i\_csp, int i\_width, int i\_height )  
\{  
    pic->i\_type = X264\_TYPE\_AUTO;  
    pic->i\_qpplus1 = 0;  
    pic->img.i\_csp = i\_csp;  
    switch( i\_csp & X264\_CSP\_MASK )  
    \{  
        case X264\_CSP\_I420:  
        case X264\_CSP\_YV12:  
            pic->img.i\_plane = 3;  
            pic->img.plane\[0\] = x264\_malloc( 3 \* i\_width \* i\_height / 2 );  
            pic->img.plane\[1\] = pic->img.plane\[0\] + i\_width \* i\_height;  
            pic->img.plane\[2\] = pic->img.plane\[1\] + i\_width \* i\_height / 4;  
            pic->img.i\_stride\[0\] = i\_width;  
            pic->img.i\_stride\[1\] = i\_width / 2;  
            pic->img.i\_stride\[2\] = i\_width / 2;  
            break;

case X264\_CSP\_I422:  
            ...

\}  
\}

3. i\_start = x264\_mdate();  //用于编码用时的计算，设定起始时间，在 mdate.c中，函数原型为：

int64\_t x264\_mdate( void )  
\{  
\#if !(defined(\_MSC\_VER) || defined(\_\_MINGW32\_\_))  
    struct timeval tv\_date;

gettimeofday( &tv\_date, NULL );  
    return( (int64\_t) tv\_date.tv\_sec \* 1000000 + (int64\_t) tv\_date.tv\_usec );  
\#else  
    struct \_timeb tb;  
    \_ftime(&tb);  
    return ((int64\_t)tb.time \* (1000) + (int64\_t)tb.millitm) \* (1000);  
\#endif  
\}

4.  进入编码帧  
    for( i\_frame = 0, i\_file = 0, i\_progress = 0;  
         b\_ctrl\_c == 0 && (i\_frame < i\_frame\_total || i\_frame\_total == 0); )  
    \{  
        if( p\_read\_frame( &pic, opt->hin, i\_frame + opt->i\_seek ) )//读取  
            break;

//p\_read\_frame() 按照h->hin提供的输入文件的地址，读入图像的内容到&pic提供的存储区的首地址

pic.i\_pts = (int64\_t)i\_frame \* param->i\_fps\_den;

i\_file += Encode\_frame( h, opt->hout, &pic );//编码并保存,  
                                               //Encode\_frame( h, opt->hout, &pic )实现编码,是x264的核心部分

i\_frame++;

if( opt->b\_progress && param->i\_log\_level < X264\_LOG\_DEBUG &&  
            ( i\_frame\_total ? i\_frame \* 1000 / i\_frame\_total > i\_progress  
                            : i\_frame % 10 == 0 ) )  
        \{  
            int64\_t i\_elapsed = x264\_mdate() - i\_start;  
            double fps = i\_elapsed > 0 ? i\_frame \* 1000000. / i\_elapsed : 0;  
            if( i\_frame\_total )  
            \{  
                int eta = i\_elapsed \* (i\_frame\_total - i\_frame) / ((int64\_t)i\_frame \* 1000000);  
                i\_progress = i\_frame \* 1000 / i\_frame\_total;  
                fprintf( stderr, "encoded frames: %d/%d (%.1f%%), %.2f fps, eta %d:d:d  \\r",  
                         i\_frame, i\_frame\_total, (float)i\_progress / 10, fps,  
                         eta/3600, (eta/60)\`, eta\` );  
            \}  
            else  
                fprintf( stderr, "encoded frames: %d, %.2f fps   \\r", i\_frame, fps );  
            fflush( stderr ); // needed in windows  
        \}  
    \}

注1： //在本文环境下，p\_read\_frame=read\_frame\_yuv，read\_frame\_yuv()定义在muxers.c中，原型为：

int read\_frame\_yuv( x264\_picture\_t \*p\_pic, hnd\_t handle, int i\_frame )  
\{  
    yuv\_input\_t \*h = handle;

if( i\_frame != h->next\_frame )  
        if( fseek( h->fh, (uint64\_t)i\_frame \* h->width \* h->height \* 3 / 2, SEEK\_SET ) )  
            return -1;

if( fread( p\_pic->img.plane\[0\], 1, h->width \* h->height, h->fh ) <= 0  
            || fread( p\_pic->img.plane\[1\], 1, h->width \* h->height / 4, h->fh ) <= 0  
            || fread( p\_pic->img.plane\[2\], 1, h->width \* h->height / 4, h->fh ) <= 0 )  
        return -1;

h->next\_frame = i\_frame+1;

return 0;  
\}

从 文件中分别读取288\*352（亮度信息），144\*176（Cr），144\*176(Cb)的数据放入 p\_pic->img.plane\[0\]，p\_pic->img.plane\[1\]，p\_pic->img.plane\[2\],如果成 功则继续执行一下程序；如果不成功则打断程序，返回-1.

注2： i\_file += Encode\_frame( h, opt->hout, &pic );//编码并保存,  
                      //Encode\_frame( h, opt->hout, &pic )实现编码,是x264的核心部分，在X264.c中，

//这个函数主要是调用了 x264\_encoder\_encode( h, &nal, &i\_nal, pic, &pic\_out ) 来实现编码。

// 原型为：

static int  Encode\_frame( x264\_t \*h, hnd\_t hout, x264\_picture\_t \*pic )  
\{  
    x264\_picture\_t pic\_out;  
    x264\_nal\_t \*nal;  
    int i\_nal, i;  
    int i\_file = 0;

if( pic )  
    \{  
        pic->i\_type = X264\_TYPE\_AUTO;  
        pic->i\_qpplus1 = 0;  
    \}  
    if( x264\_encoder\_encode( h, &nal, &i\_nal, pic, &pic\_out ) < 0 )  
    \{  
        fprintf( stderr, "x264\_encoder\_encode failed\\n" );  
    \}

for( i = 0; i < i\_nal; i++ )  
    \{  
        int i\_size;  
        int i\_data;

i\_data = DATA\_MAX;  
        if( ( i\_size = x264\_nal\_encode( data, &i\_data, 1, &nal\[i\] ) ) > 0 )  
        \{  
            i\_file += p\_write\_nalu( hout, data, i\_size );  
        \}  
        else if( i\_size < 0 )  
        \{  
            fprintf( stderr, "need to increase buffer size (size=%d)\\n", -i\_size );  
        \}  
    \}  
    if (i\_nal)  
        p\_set\_eop( hout, &pic\_out );

return i\_file;  
\}

（三）

1. x264\_encoder\_encode( x264\_t \*h,  x264\_nal\_t \*\*pp\_nal, int \*pi\_nal,

x264\_picture\_t \*pic\_in,   x264\_picture\_t \*pic\_out )          //encoder.c中

（1）x264\_frame\_t   \*frame\_psnr = h->fdec; // just to keep the current decoded frame for psnr calculation

(2)  x264\_frame\_t \*fenc = x264\_frame\_get( h->frames.unused );//返回h->frames.unused\[0\]的值，即得到了一幀图像给编码器fenc, x264\_frame\_get函数在encoder.c中，原型为：

static x264\_frame\_t \*x264\_frame\_get( x264\_frame\_t \*list\[X264\_BFRAME\_MAX+1\] )  
\{  
    x264\_frame\_t \*frame = list\[0\];  
    int i;  
    for( i = 0; list\[i\]; i++ )  
        list\[i\] = list\[i+1\];  
    return frame;  
\}

(3)  x264\_frame\_copy\_picture( h, fenc, pic\_in );   //  pic\_in复制到 fenc ，把要编码的帧存放到 fenc

该函数在frame.c中，原型为：

void x264\_frame\_copy\_picture( x264\_t \*h, x264\_frame\_t \*dst, x264\_picture\_t \*src )  
\{  
    dst->i\_type     = src->i\_type;  
    dst->i\_qpplus1  = src->i\_qpplus1;  
    dst->i\_pts      = src->i\_pts;

switch( src->img.i\_csp & X264\_CSP\_MASK )  
    \{  
        case X264\_CSP\_I420:  
            h->csp.i420( dst, &src->img, h->param.i\_width, h->param.i\_height );  
            break;  
        ....

default:  
            x264\_log( h, X264\_LOG\_ERROR, "Arg invalid CSP\\n" );  
            break;  
    \}  
\}

(4) if( h->param.i\_width % 16 || h->param.i\_height % 16 )      x264\_frame\_expand\_border\_mod16( h, fenc );

fenc->i\_frame = h->frames.i\_input++;

//若图像宽或高不是16的整数倍，调用 x264\_frame\_expand\_border\_mod16( h, fenc );

x264\_frame\_put( h->frames.next, fenc );//将fenc拷贝给h->frames.next数组中第一个不为0的位置，该函数在encoder.c中，原型为：

static void x264\_frame\_put( x264\_frame\_t \*list\[X264\_BFRAME\_MAX\], x264\_frame\_t \*frame )  
\{  
    int i = 0;  
    while( list\[i\] ) i++;  
    list\[i\] = frame;  
\}

（5）x264\_slicetype\_decide( h );      //判断slice的类型,在slicetype\_decision.c中,如下：

void x264\_slicetype\_decide( x264\_t \*h )  
\{  
    ...

if( h->param.rc.b\_stat\_read )  
    \{  
         
        for( i = 0; h->frames.next\[i\] != NULL; i++ )  
            h->frames.next\[i\]->i\_type =  
                x264\_ratecontrol\_slice\_type( h, h->frames.next\[i\]->i\_frame );  
    \}  
    else if( h->param.i\_bframe && h->param.b\_bframe\_adaptive )  
        x264\_slicetype\_analyse( h );//x264\_slicetype\_analyse函数在slicetype\_decision.c中。

//这里要注意默认的x264里面是没有B帧的，如果需要用到B帧可以在最初的参数设置的时候，

//用语句“--frames 数字”来定义，x264\_slicetype\_analyse 也只有在定义了“--frames 数字”时候，

//才会执行。

...  
\}

(6)

while( IS\_X264\_TYPE\_B( h->frames.next\[bframes\]->i\_type ) )  
            bframes++;  
        x264\_frame\_put( h->frames.current, x264\_frame\_get( &h->frames.next\[bframes\] ) );

//将当前要编码的帧h->frames.current送给编码器，然后开始编码

(7)  h->fenc = x264\_frame\_get( h->frames.current );//将当前要编码的帧给编码器

(8)   if( h->fenc->i\_type == X264\_TYPE\_IDR )  
    \{  
        h->frames.i\_last\_idr = h->fenc->i\_frame;  
    \}

TIMER\_START( i\_mtime\_encode\_frame );

// 如果是解码即时刷新片，则h->frames.i\_last\_idr = h->fenc->i\_frame;然后计时开

（9）if( h->fenc->i\_type == X264\_TYPE\_IDR )  
    \{  
         
        x264\_reference\_reset( h );

i\_nal\_type    = NAL\_SLICE\_IDR;  
        i\_nal\_ref\_idc = NAL\_PRIORITY\_HIGHEST;  
        i\_slice\_type = SLICE\_TYPE\_I;  
    \}  
    else if( h->fenc->i\_type == X264\_TYPE\_I )  
    \{  
        i\_nal\_type    = NAL\_SLICE;  
        i\_nal\_ref\_idc = NAL\_PRIORITY\_HIGH;  
        i\_slice\_type = SLICE\_TYPE\_I;  
    \}  
    else if( h->fenc->i\_type == X264\_TYPE\_P )  
    \{  
        i\_nal\_type    = NAL\_SLICE;  
        i\_nal\_ref\_idc = NAL\_PRIORITY\_HIGH;  
        i\_slice\_type = SLICE\_TYPE\_P;  
    \}  
    else if( h->fenc->i\_type == X264\_TYPE\_BREF )  
    \{  
        i\_nal\_type    = NAL\_SLICE;  
        i\_nal\_ref\_idc = NAL\_PRIORITY\_HIGH;  
        i\_slice\_type = SLICE\_TYPE\_B;  
    \}  
    else     
    \{  
        i\_nal\_type    = NAL\_SLICE;  
        i\_nal\_ref\_idc = NAL\_PRIORITY\_DISPOSABLE;  
        i\_slice\_type = SLICE\_TYPE\_B;  
    \}

//根据帧的类型初始化数据。总共有五种片的类型IDR，I，P，BREF，B 。如果是解码即时刷新片（idr），则要对参考帧重新设置

（四）

（1）  
          x264\_reference\_build\_list( h, h->fdec->i\_poc, i\_slice\_type );

//创建list0和list1（ref0和ref1），ref0从大到小，ref1从小到大

//x264\_reference\_build\_list( h, h->fdec->i\_poc, i\_slice\_type )定义在encoder.c中，如下：

static inline void x264\_reference\_build\_list( x264\_t \*h, int i\_poc, int i\_slice\_type )  
\{  
    int i;  
    int b\_ok;

...

(2)   
    x264\_ratecontrol\_start( h, i\_slice\_type, h->fenc->i\_qpplus1 );  
    i\_global\_qp = x264\_ratecontrol\_qp( h );

pic\_out->i\_qpplus1 = h->fdec->i\_qpplus1 = i\_global\_qp + 1;

// 初始化速率和量化步长

(3) x264\_slice\_init( h, i\_nal\_type, i\_slice\_type, i\_global\_qp );

// 创建片头，片头初始化；

(4)  
    if( i\_nal\_type == NAL\_SLICE\_IDR && h->param.b\_repeat\_headers )  
    \{  
        if( h->fenc->i\_frame == 0 )  
        \{  
            x264\_nal\_start( h, NAL\_SEI, NAL\_PRIORITY\_DISPOSABLE );  
            x264\_sei\_version\_write( h, &h->out.bs );  
            x264\_nal\_end( h );  
        \}

x264\_nal\_start( h, NAL\_SPS, NAL\_PRIORITY\_HIGHEST );  
        x264\_sps\_write( &h->out.bs, h->sps );  
        x264\_nal\_end( h );

x264\_nal\_start( h, NAL\_PPS, NAL\_PRIORITY\_HIGHEST );  
        x264\_pps\_write( &h->out.bs, h->pps );  
        x264\_nal\_end( h );  
    \}

(5)  
    i\_frame\_size = x264\_slices\_write( h );

// encoder.c中，原型：

static inline int x264\_slices\_write( x264\_t \*h )  
\{  
    ...  
\}

关键部分为x264\_slice\_write( h );该函数定义在encoder.c中，实现一帧的编码。

注1：for( mb\_xy = h->sh.i\_first\_mb, i\_skip = 0; mb\_xy < h->sh.i\_last\_mb; mb\_xy++ )

//循环22\*18=396次对396个宏块进行编码，mb\_xy是16\*16宏块序号0~395，

//其赋值过程在x264\_encoder\_encode 中的x264\_slice\_init里。

const int i\_mb\_y = mb\_xy / h->sps->i\_mb\_width;

//计算当前宏块垂直坐标（行坐标，以宏块为单位）  i\_mb\_width=22

const int i\_mb\_x = mb\_xy % h->sps->i\_mb\_width;

//计算当前宏块水平坐标（列坐标，以宏块为单位）

int mb\_spos = bs\_pos(&h->out.bs);

//在bs.h中，静态内联函数，如下：

static inline int bs\_pos( bs\_t \*s )  
       \{  
         return( 8 \* ( s->p - s->p\_start ) + 8 - s->i\_left );  
       \}

x264\_macroblock\_cache\_load( h, i\_mb\_x, i\_mb\_y );

//它是将要编码的宏块的周围宏块的值读进来。要想得到当前块的预测值，要先知道上面，左面的预测值。

// 分析参数选择合适的块编码模式，加载相邻块的信息。

x264\_macroblock\_analyse( h );

//对一个16\*16块进行预测模式选择，通过比较得出最佳预测模式。

// 定义在analyse.c 中,计算sad值分析是否要对16\*16的宏块进行分割和采用哪种分割方式合适。

x264\_macroblock\_encode( h );

// 根据前面分析得到的h->mb.i\_type的类型，对一个16\*16块进行编码。

（五）

X264代码主要的部分分为三个步骤，即数据的读入与存放，视频编码层（VCL）的视频编码和网络提取层（Network Abstraction Layer，NAL）单元输出。

数 据的读入与存放：X264开辟了unused、next、current、refrence等区域分别保存未处理原始图片序列、即将编码帧序列、当前编码 帧和参考帧序列，同时还开辟了fenc和fdec区域用于存放已编码帧和重构帧 。程序按以下顺序读入数据：首先，从YUV数据文件中读取数据存到临时变量pic\_in，同时为unused开辟存储空间，并用fenc指针指向这个空 间。接着，将pic\_in中的图片数据拷贝到fenc所指向的区域，并在拷贝完成后对图片大小进行判断，如果长宽不为16的整数倍则进行像素扩展；将处理 后的fenc区域数据放入next区域。之后，如果存在B帧，则从next区域取出B帧以后的P帧放到current区域中，也就是说先编码I、P帧再编 码之间的B帧；否则，直接从next区域取出一帧存入current区域。此时current区域中存放的就是已经过预处理的即将要编码的帧数据了。最 后，由于fenc区域是编码的直接对象，再将current区域中的内容拷贝到fenc中正式开始编码 。

视频编码层（VCL）的视频编码：输入文件foreman.yuv格式是CIF，即352\*288。在对一帧图像进行处理的过程中以宏块（16\*16）为单位，一帧图像处理步骤如下：

定位当前处理的16\*16宏块的位置；

X264\_macroblock\_chche\_load(h,i\_mb\_x,I,mb\_y) ；

X264\_macroblock\_analyse(h)；X264\_macroblock\_encode(h) ；

根据h->mb.i\_type的类型进行操作， 如果是I帧,则x264\_macroblock\_write\_caclc(h,&h->out.bs)；

X264\_macroblock\_chche\_save(h) ；

计算mb stats.