FFmpeg的H.264解碼器源代碼簡單分析

本文簡單記錄FFmpeg中libavcodec的H.264解碼器（H.264 Decoder）的源代碼。這個H.264解碼器十分重要，可以說FFmpeg項目今天可以幾乎“壟斷”視音頻編解碼技術，很大一部分貢獻就來自於這個H.264解碼器。這個H.264解碼器一方面功能強大，性能穩定；另一方面源代碼也比較復雜，難以深入研究。本文打算梳理一下這個H.264解碼器的源代碼結構，以方便以后深入學習H.264使用。
PS：這部分代碼挺復雜的，還有不少地方還比較模糊，還需要慢慢學習......

 

函數調用關系圖

 

H.264解碼器的函數調用關系圖如下所示。

 

 

下面解釋一下圖中關鍵標記的含義。

  

作為接口的結構體

FFmpeg和H.264解碼器之間作為接口的結構體有2個：

ff_h264_parser：用於解析H.264碼流的AVCodecParser結構體。
ff_h264_decoder：用於解碼H.264碼流的AVCodec結構體。

函數背景色

函數在圖中以方框的形式表現出來。不同的背景色標志了該函數不同的作用：

白色背景的函數：普通內部函數。
粉紅色背景函數：解析函數（Parser）。這些函數用於解析SPS、PPS等信息。
紫色背景的函數：熵解碼函數（Entropy Decoding）。這些函數讀取碼流數據並且進行CABAC或者CAVLC熵解碼。
綠色背景的函數：解碼函數（Decode）。這些函數通過幀內預測、幀間預測、DCT反變換等方法解碼壓縮數據。
黃色背景的函數：環路濾波函數（Loop Filter）。這些函數對解碼后的數據進行濾波，去除方塊效應。
藍色背景函數：匯編函數（Assembly）。這些函數是做過匯編優化的函數。圖中主要畫出了這些函數的C語言版本，此外這些函數還包含MMX版本、SSE版本、NEON版本等。

箭頭線

箭頭線標志了函數的調用關系：

黑色箭頭線：不加區別的調用關系。
粉紅色的箭頭線：解析函數（Parser）之間的調用關系。
紫色箭頭線：熵解碼函數（Entropy Decoding）之間的調用關系。
綠色箭頭線：解碼函數（Decode）之間的調用關系。
黃色箭頭線：環路濾波函數（Loop Filter）之間的調用關系。

 

函數所在的文件

每個函數標識了它所在的文件路徑。

 

下文簡單記錄幾個關鍵的部分。

FFmpeg和H.264解碼器之間作為接口的結構體

 

FFmpeg和H.264解碼器之間作為接口的結構體有2個：ff_h264_parser和ff_h264_decoder。

ff_h264_parser
ff_h264_parser是用於解析H.264碼流的AVCodecParser結構體。AVCodecParser中包含了幾個重要的函數指針：

parser_init()：初始化解析器。
parser_parse()：解析。
parser_close()：關閉解析器。

在ff_h264_parser結構體中，上述幾個函數指針分別指向下面幾個實現函數：

init()：初始化H.264解析器。
h264_parse()：解析H.264碼流。
close()：關閉H.264解析器。

ff_h264_decoder
ff_h264_decoder是用於解碼H.264碼流的AVCodec結構體。AVCodec中包含了幾個重要的函數指針：

init()：初始化解碼器。
decode()：解碼。
close()：關閉解碼器。

在ff_h264_decoder結構體中，上述幾個函數指針分別指向下面幾個實現函數：

ff_h264_decode_init()：初始化H.264解碼器。
h264_decode_frame()：解碼H.264碼流。
h264_decode_end()：關閉H.264解碼器。

普通內部函數

普通內部函數指的是H.264解碼器中還沒有進行分類的函數。下面舉幾個例子。
ff_h264_decoder中ff_h264_decode_init()調用的初始化函數：

ff_h264dsp_init()：初始化DSP相關的函數。包含了IDCT、環路濾波函數等。
ff_h264qpel_init()：初始化四分之一像素運動補償相關的函數。
ff_h264_pred_init()：初始化幀內預測相關的函數。
ff_h264_decode_extradata()：解析AVCodecContext中的extradata。

ff_h264_decoder中h264_decode_frame()逐層調用的和解碼Slice相關的函數：

decode_nal_units()，ff_h264_execute_decode_slices()，decode_slice()等。

ff_h264_decoder中h264_decode_end()調用的清理函數：

ff_h264_remove_all_refs()：移除所有參考幀。
ff_h264_free_context()：釋放在初始化H.264解碼器的時候分配的內存。
ff_h264_parser中h264_parse()逐層調用的和解析Slice相關的函數：
h264_find_frame_end()：查找NALU的結尾。
parse_nal_units()：解析一個NALU。

解析函數（Parser）

解析函數（Parser）用於解析H.264碼流中的一些信息（例如SPS、PPS、Slice Header等）。在parse_nal_units()和decode_nal_units()中都調用這些解析函數完成了解析。下面舉幾個解析函數的例子。

ff_h264_decode_nal()：解析NALU。這個函數是后幾個解析函數的前提。
ff_h264_decode_slice_header()：解析Slice Header。
ff_h264_decode_sei()：解析SEI。
ff_h264_decode_seq_parameter_set()：解析SPS。
ff_h264_decode_picture_parameter_set()：解析PPS。

熵解碼函數（Entropy Decoding）

熵解碼函數（Entropy Decoding）讀取碼流數據並且進行CABAC或者CAVLC熵解碼。CABAC解碼函數是ff_h264_decode_mb_cabac()，CAVLC解碼函數是ff_h264_decode_mb_cavlc()。熵解碼函數中包含了很多的讀取指數哥倫布編碼數據的函數，例如get_ue_golomb_long()，get_ue_golomb()，get_se_golomb()，get_ue_golomb_31()等等。
在獲取殘差數據的時候需要進行CAVLC/CABAC解碼。例如解碼CAVLC的時候，會調用decode_residual()函數，而decode_residual()會調用get_vlc2()函數，get_vlc2()會調用OPEN_READER()，UPDATE_CACHE()，GET_VLC()，CLOSE_READER()幾個函數讀取CAVLC格式的數據。
此外，在獲取運動矢量的時候，會調用pred_motion()以及類似的幾個函數獲取運動矢量相關的信息。

解碼函數（Decode）

解碼函數（Decode）通過幀內預測、幀間預測、DCT反變換等方法解碼壓縮數據。解碼函數是ff_h264_hl_decode_mb()。其中跟宏塊類型的不同，會調用幾個不同的函數，最常見的就是調用hl_decode_mb_simple_8()。
hl_decode_mb_simple_8()的定義是無法在源代碼中直接找到的，這是因為它實際代碼的函數名稱是使用宏的方式寫的（以后再具體分析）。hl_decode_mb_simple_8()的源代碼實際上就是FUNC(hl_decode_mb)()函數的源代碼。
FUNC(hl_decode_mb)()根據宏塊類型的不同作不同的處理：如果宏塊類型是INTRA，就會調用hl_decode_mb_predict_luma()進行幀內預測；如果宏塊類型不是INTRA，就會調用FUNC(hl_motion_422)()或者FUNC(hl_motion_420)()進行四分之一像素運動補償。
隨后FUNC(hl_decode_mb)()會調用hl_decode_mb_idct_luma()等幾個函數對數據進行DCT反變換工作。

環路濾波函數（Loop Filter）

環路濾波函數（Loop Filter）對解碼后的數據進行濾波，去除方塊效應。環路濾波函數是loop_filter()。其中調用了ff_h264_filter_mb()和ff_h264_filter_mb_fast()。ff_h264_filter_mb_fast()中又調用了h264_filter_mb_fast_internal()。而h264_filter_mb_fast_internal()中又調用了下面幾個函數進行濾波：

filter_mb_edgeh()：亮度水平濾波
filter_mb_edgev()：亮度垂直濾波
filter_mb_edgech()：色度水平濾波

filter_mb_edgecv()：色度垂直濾波

 

 

 

匯編函數（Assembly）

匯編函數（Assembly）是做過匯編優化的函數。為了提高效率，整個H.264解碼器中（主要在解碼部分和環路濾波部分）包含了大量的匯編函數。實際解碼的過程中，FFmpeg會根據系統的特性調用相應的匯編函數（而不是C語言函數）以提高解碼的效率。如果系統不支持匯編優化的話，FFmpeg才會調用C語言版本的函數。例如在幀內預測的時候，對於16x16亮度DC模式，有以下幾個版本的函數：

C語言版本的pred16x16_dc_8_c()
NEON版本的ff_pred16x16_dc_neon()
MMXEXT版本的ff_pred16x16_dc_8_mmxext()
SSE2版本的ff_pred16x16_dc_8_sse2()

至此FFmpeg的H.264解碼器的結構就大致梳理完畢了。

 

下面是C++源碼：

//h264dec.h:
//
//[cpp]
#pragma once 
#include "tdll.h" 
#include "avcodec.h" 
#include "postprocess.h" 
//#include "EMVideoCodec.h" 
 
class h264dec /*: public IH264Decoder*/ 
{ 
public: 
    virtual bool InitH264Deocder(int width,int height); 
    virtual bool H264Decode(unsigned char * inbuf, const int & inlen,unsigned char * outbuf,int & outlen); 
    virtual void StopH264Decoder(); 
    virtual void ReleaseConnection(); 
 
public: 
    h264dec(void); 
    virtual ~h264dec(void); 
private: 
    Tdll *dll; 
 
    bool LoadDllFun(); 
    void (*avcodec_init)(void); 
    void (*avcodec_register_all)(void); 
    AVCodecContext* (*avcodec_alloc_context)(void); 
    AVFrame* (*avcodec_alloc_frame)(void); 
    AVCodec *(*avcodec_find_decoder)(enum CodecID id); 
    int (*avcodec_decode_video)(AVCodecContext *avctx, AVFrame *picture,int *got_picture_ptr, 
                                uint8_t *buf, int buf_size); 
    int  (*avcodec_open)(AVCodecContext *avctx, AVCodec *codec); 
    int  (*avcodec_close)(AVCodecContext *avctx); 
    void (*av_free)(void *ptr);      
     
    bool InitPostproc(int w,int h); 
    void ClosePostproc(); 
    pp_context_t *(*pp_get_context)(int width, int height, int flags); 
    void (*pp_free_context)(pp_context_t *ppContext); 
    void (*pp_free_mode)(pp_mode_t *mode); 
    pp_mode_t *(*pp_get_mode_by_name_and_quality)(char *name, int quality); 
    void  (*pp_postprocess)(uint8_t * src[3], int srcStride[3], 
                 uint8_t * dst[3], int dstStride[3], 
                 int horizontalSize, int verticalSize, 
                 QP_STORE_T *QP_store,  int QP_stride, 
         pp_mode_t *mode, pp_context_t *ppContext, int pict_type); 
private: 
    AVCodec         *pdec; 
    AVCodecContext  *pdecContext; 
    AVFrame         *pdecFrame; 
    int             m_width; 
    int             m_height; 
 
    Tdll* prodll; 
    pp_context_t *pp_context; 
    pp_mode_t    *pp_mode; 
}; 

h264dec.cpp:
[cpp] view plaincopy
#include "StdAfx.h" 
#include ".\h264dec.h" 
 
h264dec::h264dec(void) 
:dll(NULL) 
,pdec(NULL) 
,pdecContext(NULL) 
,pdecFrame(NULL) 
,pp_context(NULL) 
,pp_mode(NULL) 
,prodll(NULL) 
{ 
} 
 
h264dec::~h264dec(void) 
{ 
} 
 
bool h264dec::LoadDllFun() 
{ 
    dll=new Tdll(L"libavcodec.dll"); 
    dll->loadFunction((void**)&avcodec_init,"avcodec_init"); 
    dll->loadFunction((void**)&avcodec_register_all,"avcodec_register_all"); 
    dll->loadFunction((void**)&avcodec_alloc_context,"avcodec_alloc_context"); 
    dll->loadFunction((void**)&avcodec_alloc_frame,"avcodec_alloc_frame"); 
    dll->loadFunction((void**)&avcodec_find_decoder,"avcodec_find_decoder"); 
    dll->loadFunction((void**)&avcodec_open,"avcodec_open");  
    dll->loadFunction((void**)&avcodec_decode_video,"avcodec_decode_video"); 
    dll->loadFunction((void**)&avcodec_close,"avcodec_close"); 
    dll->loadFunction((void**)&av_free,"av_free"); 
    if (!dll->ok) 
        return false; 
 
    prodll = new Tdll(L"postproc.dll"); 
    prodll->loadFunction((void**)&pp_get_context,"pp_get_context"); 
    prodll->loadFunction((void**)&pp_free_context,"pp_free_context"); 
    prodll->loadFunction((void**)&pp_free_mode,"pp_free_mode"); 
    prodll->loadFunction((void**)&pp_get_mode_by_name_and_quality,"pp_get_mode_by_name_and_quality"); 
    prodll->loadFunction((void**)&pp_postprocess,"pp_postprocess"); 
    if(!prodll->ok) 
        return false; 
 
    avcodec_init(); 
    avcodec_register_all(); 
    return true; 
} 
 
bool h264dec::InitH264Deocder(int width,int height) 
{ 
    if(!LoadDllFun()) 
        return false; 
    if(!InitPostproc(width,height)) 
        return false; 
 
    m_width=width; 
    m_height=height; 
    pdec = avcodec_find_decoder(CODEC_ID_H264); 
    if (pdec == NULL )   
        return false; 
 
    pdecContext = avcodec_alloc_context(); 
    pdecFrame = avcodec_alloc_frame(); 
 
    pdecContext->width  = width; 
    pdecContext->height = height; 
    pdecContext->pix_fmt = PIX_FMT_YUV420P; 
    /* open it */ 
    if (avcodec_open(pdecContext, pdec) < 0)  
    { 
        return false; 
    } 
    return true; 
} 
 
bool h264dec::InitPostproc(int w,int h) 
{ 
    int i_flags = 0; 
    i_flags |= PP_CPU_CAPS_MMX | PP_CPU_CAPS_MMX2 | PP_FORMAT_420; 
    pp_context = pp_get_context( w, h, i_flags ); 
    if(!pp_context) 
        return false; 
    pp_mode = pp_get_mode_by_name_and_quality( "default", 6 ); 
    if(!pp_mode) 
        return false; 
    return true; 
} 
 
bool h264dec::H264Decode(unsigned char * inbuf, const int & inlen,unsigned char * outbuf,int & outlen) 
{ 
    int got_frame; 
    BYTE* showImage[3]; 
    int showheight[3],showLx[3]; 
 
    int len; 
    len=avcodec_decode_video(pdecContext, pdecFrame, &got_frame, inbuf, inlen); 
    if(len < 0) 
        return false; 
 
    if(got_frame) 
    { 
        showImage[0]=outbuf; 
        showImage[1]=showImage[0]+m_width*m_height; 
        showImage[2]=showImage[1]+m_width*m_height/4; 
        showLx[0]=m_width;showLx[1]=m_width>>1;showLx[2]=m_width>>1; 
        showheight[0]=m_height;showheight[1]=m_height>>1;showheight[2]=m_height>>1; 
        pp_postprocess(pdecFrame->data,pdecFrame->linesize,showImage,showLx,m_width,m_height,pdecFrame->qscale_table, 
            pdecFrame->qstride,pp_mode,pp_context,pdecFrame->pict_type); 
        //GetImage( pdecFrame->data, 
        //          showImage, 
        //          pdecFrame->linesize, 
        //          showLx, 
        //          showheight); 
        outlen=m_width*m_height*3/2; 
    } 
    else 
    { 
        outlen = 0; 
    } 
 
    return true; 
} 
 
void h264dec::StopH264Decoder() 
{ 
    if (pdecContext != NULL)  
    {      
        avcodec_close(pdecContext); 
        av_free( pdecContext ); 
        pdecContext = NULL; 
        if(pdecFrame){ 
            av_free(pdecFrame); 
            pdecFrame = NULL; 
        } 
    } 
    if(dll){ 
        delete dll; 
        dll=0; 
    } 
 
    ClosePostproc(); 
} 
 
void h264dec::ClosePostproc() 
{ 
    if(pp_mode){ 
        pp_free_mode( pp_mode ); 
        pp_mode=0; 
    } 
    if(pp_context){ 
        pp_free_context(pp_context); 
        pp_context=0; 
    } 
    if(prodll){ 
        delete prodll; 
        prodll=0; 
    } 
} 
 
void h264dec::ReleaseConnection() 
{ 
    delete this; 
} 

tdll.h:
[cpp] 
#ifndef _TDLL_ 
#define _TDLL_ 
 
class Tdll 
{ 
private: 
    HMODULE hdll; 
    void loadDll(const char *dllName); 
public: 
    bool ok; 
    Tdll(const TCHAR *dllName1) 
    { 
        hdll=LoadLibrary(dllName1); 
        if (!hdll) 
        { 
            hdll=NULL; 
        } 
        ok=(hdll!=NULL); 
    }; 
    ~Tdll() 
    { 
        if (hdll) 
            FreeLibrary(hdll); 
    } 
    void loadFunction(void **fnc,const char *name) 
    { 
        *fnc=GetProcAddress(hdll,name); 
        ok&=(*fnc!=NULL); 
    }; 
};   
 
#endif 

main.cpp:
[cpp]
#include "stdafx.h" 
#include "h264dec.h" 
#include "postprocess.h" 
 
#define INBUF_SIZE 100 * 1024; 
 
 
static int FindStartCode (unsigned char *Buf, int zeros_in_startcode) 
{ 
    int info; 
    int i; 
 
    info = 1; 
    for (i = 0; i < zeros_in_startcode; i++) 
    { 
        if(Buf[i] != 0) 
            info = 0; 
    } 
 
    if(Buf[i] != 1) 
        info = 0; 
    return info; 
} 
 
static bool Check_StartCode(unsigned char *Buf, int pos) 
{ 
    int info3 = 0; 
 
    info3 = FindStartCode(&Buf[pos-4], 3); 
    return info3 == 1; 
 
} 
 
static int getNextNal(FILE* inpf, unsigned char* Buf) 
{ 
    int pos = 0; 
    int StartCodeFound = 0; 
    int info2 = 0; 
    int info3 = 0; 
 
    int nCount = 0; 
    while(!feof(inpf) && ++nCount <= 4) 
    { 
        Buf[pos++]=fgetc(inpf); 
    } 
 
    if(!Check_StartCode(Buf, pos)) 
    { 
        return 0; 
    } 
 
 
    while(!feof(inpf) && (Buf[pos++]=fgetc(inpf))==0); 
 
    while (!StartCodeFound) 
    { 
        if (feof (inpf)) 
        { 
            //          return -1; 
            return pos-1; 
        } 
        Buf[pos++] = fgetc (inpf); 
 
        StartCodeFound = Check_StartCode(Buf, pos); 
    } 
 
    fseek (inpf, -4, SEEK_CUR); 
    return pos - 4; 
} 
 
int main(int argc, char* argv[]) 
{ 
    if (argc != 5) 
    { 
        printf("please input: PP_Demo.exe filename1[input] Width Height filename2[output]\n"); 
    } 
     
    //params set 
    unsigned short usWidth = atoi(argv[2]); 
    unsigned short usHeight = atoi(argv[3]); 
     
    //create dec&pp 
    h264dec *pdec = new h264dec; 
    if(!pdec->InitH264Deocder(usWidth, usHeight)) 
    { 
        return false; 
    } 
 
 
 
    unsigned char *p_In_Frame = new unsigned char[usWidth * usHeight * 3/2]; 
    unsigned char *p_Out_Frame = new unsigned char[usWidth * usHeight * 3/2]; 
    FILE* ifp = fopen(argv[1],"rb"); 
    FILE* ofp = fopen(argv[4],"wb"); 
 
    bool b_continue = true; 
    int nReadUnit = usWidth * usHeight * 3/2; 
    while(!feof(ifp)) 
    { 
        int nCount = getNextNal(ifp, p_In_Frame); 
 
        if(nCount == 0) 
        { 
            continue; 
        } 
         
        unsigned char *ptr = p_In_Frame; 
        int n_Outlen = 0; 
        pdec->H264Decode(ptr, nCount, p_Out_Frame, n_Outlen); 
         
        if(n_Outlen > 0) 
        { 
            fwrite(p_Out_Frame, 1, n_Outlen, ofp); 
        } 
    } 
 
 
    //realse 
    delete []p_In_Frame; 
    delete []p_Out_Frame; 
    pdec->StopH264Decoder(); 
    pdec->ReleaseConnection(); 
    fclose(ifp); 
    fclose(ofp); 
 
    return 0;