流媒体-H264协议-编码-x264学习-主要函数（三）

今天药忘吃喽~ 2022-12-29 02:11 350阅读 0赞

1.  [流媒体-H264协议-编码-x264学习-相关概念x264编译及文件解析（一）][-H264_-_-x264_-_x264]
2.  [流媒体-H264协议-编码-x264学习-主要结构体（二）][-H264_-_-x264_-]
3.  [流媒体-H264协议-编码-x264学习-主要函数（三）][-H264_-_-x264_- 1]
4.  [流媒体-H264协议-编码-x264学习-C++11多线程实现编码（四）][-H264_-_-x264_-C_11]

### 文章目录 ###

*   *  x264.c main()函数相关函数
     *   *  x264\_param\_default\_preset()
         *  x264\_param\_default() 设置参数集结构体x264\_param\_t的缺省值
         *  x264\_encoder\_encode() 编码
         *  static intptr\_t slice\_write( x264\_t \*h )
         *  x264\_encoder\_delayed\_frames( x264\_t \*h ) 获取缓冲区的frame数目
     *  参考文献

## x264.c main()函数相关函数 ##

### x264\_param\_default\_preset() ###

值得注意的是函数中调用了x264\_param\_default()

REALIGN_STACK int x264_param_default_preset( x264_param_t *param, const char *preset, const char *tune )
    {
        x264_param_default( param );
    
        if( preset && param_apply_preset( param, preset ) < 0 )
            return -1;
        if( tune && param_apply_tune( param, tune ) < 0 )
            return -1;
        return 0;
    }

### x264\_param\_default() 设置参数集结构体x264\_param\_t的缺省值 ###

/****************************************************************************
     * Basic parameter handling functions
     ****************************************************************************/
    
    /* x264_param_default:
     *      fill x264_param_t with default values and do CPU detection */
    REALIGN_STACK void x264_param_default( x264_param_t *param )
    {
        /* */
        memset( param, 0, sizeof( x264_param_t ) );
    
        /* CPU autodetect */
        param->cpu = x264_cpu_detect();
        param->i_threads = X264_THREADS_AUTO;
        param->i_lookahead_threads = X264_THREADS_AUTO;
        param->b_deterministic = 1;
        param->i_sync_lookahead = X264_SYNC_LOOKAHEAD_AUTO;
    
        /* Video properties */
        param->i_csp           = X264_CHROMA_FORMAT ? X264_CHROMA_FORMAT : X264_CSP_I420;
        param->i_width         = 0;
        param->i_height        = 0;
        param->vui.i_sar_width = 0;
        param->vui.i_sar_height= 0;
        param->vui.i_overscan  = 0;  /* undef */
        param->vui.i_vidformat = 5;  /* undef */
        param->vui.b_fullrange = -1; /* default depends on input */
        param->vui.i_colorprim = 2;  /* undef */
        param->vui.i_transfer  = 2;  /* undef */
        param->vui.i_colmatrix = -1; /* default depends on input */
        param->vui.i_chroma_loc= 0;  /* left center */
        param->i_fps_num       = 25;
        param->i_fps_den       = 1;
        param->i_level_idc     = -1;
        param->i_slice_max_size = 0;
        param->i_slice_max_mbs = 0;
        param->i_slice_count = 0;
    #if HAVE_BITDEPTH8
        param->i_bitdepth = 8;
    #elif HAVE_BITDEPTH10
        param->i_bitdepth = 10;
    #else
        param->i_bitdepth = 8;
    #endif
    
        /* Encoder parameters */
        param->i_frame_reference = 3;
        param->i_keyint_max = 250;
        param->i_keyint_min = X264_KEYINT_MIN_AUTO;
        param->i_bframe = 3;
        param->i_scenecut_threshold = 40;
        param->i_bframe_adaptive = X264_B_ADAPT_FAST;
        param->i_bframe_bias = 0;
        param->i_bframe_pyramid = X264_B_PYRAMID_NORMAL;
        param->b_interlaced = 0;
        param->b_constrained_intra = 0;
    
        param->b_deblocking_filter = 1;
        param->i_deblocking_filter_alphac0 = 0;
        param->i_deblocking_filter_beta = 0;
    
        param->b_cabac = 1;
        param->i_cabac_init_idc = 0;
    
        param->rc.i_rc_method = X264_RC_CRF;
        param->rc.i_bitrate = 0;
        param->rc.f_rate_tolerance = 1.0;
        param->rc.i_vbv_max_bitrate = 0;
        param->rc.i_vbv_buffer_size = 0;
        param->rc.f_vbv_buffer_init = 0.9;
        param->rc.i_qp_constant = -1;
        param->rc.f_rf_constant = 23;
        param->rc.i_qp_min = 0;
        param->rc.i_qp_max = INT_MAX;
        param->rc.i_qp_step = 4;
        param->rc.f_ip_factor = 1.4;
        param->rc.f_pb_factor = 1.3;
        param->rc.i_aq_mode = X264_AQ_VARIANCE;
        param->rc.f_aq_strength = 1.0;
        param->rc.i_lookahead = 40;
    
        param->rc.b_stat_write = 0;
        param->rc.psz_stat_out = "x264_2pass.log";
        param->rc.b_stat_read = 0;
        param->rc.psz_stat_in = "x264_2pass.log";
        param->rc.f_qcompress = 0.6;
        param->rc.f_qblur = 0.5;
        param->rc.f_complexity_blur = 20;
        param->rc.i_zones = 0;
        param->rc.b_mb_tree = 1;
    
        /* Log */
        param->pf_log = x264_log_default;
        param->p_log_private = NULL;
        param->i_log_level = X264_LOG_INFO;
    
        /* */
        param->analyse.intra = X264_ANALYSE_I4x4 | X264_ANALYSE_I8x8;
        param->analyse.inter = X264_ANALYSE_I4x4 | X264_ANALYSE_I8x8
                             | X264_ANALYSE_PSUB16x16 | X264_ANALYSE_BSUB16x16;
        param->analyse.i_direct_mv_pred = X264_DIRECT_PRED_SPATIAL;
        param->analyse.i_me_method = X264_ME_HEX;
        param->analyse.f_psy_rd = 1.0;
        param->analyse.b_psy = 1;
        param->analyse.f_psy_trellis = 0;
        param->analyse.i_me_range = 16;
        param->analyse.i_subpel_refine = 7;
        param->analyse.b_mixed_references = 1;
        param->analyse.b_chroma_me = 1;
        param->analyse.i_mv_range_thread = -1;
        param->analyse.i_mv_range = -1; // set from level_idc
        param->analyse.i_chroma_qp_offset = 0;
        param->analyse.b_fast_pskip = 1;
        param->analyse.b_weighted_bipred = 1;
        param->analyse.i_weighted_pred = X264_WEIGHTP_SMART;
        param->analyse.b_dct_decimate = 1;
        param->analyse.b_transform_8x8 = 1;
        param->analyse.i_trellis = 1;
        param->analyse.i_luma_deadzone[0] = 21;
        param->analyse.i_luma_deadzone[1] = 11;
        param->analyse.b_psnr = 0;
        param->analyse.b_ssim = 0;
    
        param->i_cqm_preset = X264_CQM_FLAT;
        memset( param->cqm_4iy, 16, sizeof( param->cqm_4iy ) );
        memset( param->cqm_4py, 16, sizeof( param->cqm_4py ) );
        memset( param->cqm_4ic, 16, sizeof( param->cqm_4ic ) );
        memset( param->cqm_4pc, 16, sizeof( param->cqm_4pc ) );
        memset( param->cqm_8iy, 16, sizeof( param->cqm_8iy ) );
        memset( param->cqm_8py, 16, sizeof( param->cqm_8py ) );
        memset( param->cqm_8ic, 16, sizeof( param->cqm_8ic ) );
        memset( param->cqm_8pc, 16, sizeof( param->cqm_8pc ) );
    
        param->b_repeat_headers = 1;
        param->b_annexb = 1;
        param->b_aud = 0;
        param->b_vfr_input = 1;
        param->i_nal_hrd = X264_NAL_HRD_NONE;
        param->b_tff = 1;
        param->b_pic_struct = 0;
        param->b_fake_interlaced = 0;
        param->i_frame_packing = -1;
        param->i_alternative_transfer = 2; /* undef */
        param->b_opencl = 0;
        param->i_opencl_device = 0;
        param->opencl_device_id = NULL;
        param->psz_clbin_file = NULL;
        param->i_avcintra_class = 0;
        param->i_avcintra_flavor = X264_AVCINTRA_FLAVOR_PANASONIC;
    }

### x264\_encoder\_encode() 编码 ###

/****************************************************************************
     * x264_encoder_encode:
     *  XXX: i_poc   : is the poc of the current given picture
     *       i_frame : is the number of the frame being coded
     *  ex:  type frame poc
     *       I      0   2*0
     *       P      1   2*3
     *       B      2   2*1
     *       B      3   2*2
     *       P      4   2*6
     *       B      5   2*4
     *       B      6   2*5
     ****************************************************************************/
    int     x264_encoder_encode( x264_t *h,
                                 x264_nal_t **pp_nal, int *pi_nal,
                                 x264_picture_t *pic_in,
                                 x264_picture_t *pic_out )
    {
        // 当前线程、前一个线程、后一个线程
        x264_t *thread_current, *thread_prev, *thread_oldest;
        // NAL类型、NAL优先级、全局QP
        int i_nal_type, i_nal_ref_idc, i_global_qp;
        // startcode四字节(0x00 00 00 01) + NAL type一字节，即NAL的头信息字节个数:#define NALU_OVERHEAD 5
        int overhead = NALU_OVERHEAD;
    
    #if HAVE_OPENCL   // 判断是否有OPencl支持
        if( h->opencl.b_fatal_error )
            return -1;
    #endif
    
        if( h->i_thread_frames > 1 )
        {
            thread_prev    = h->thread[ h->i_thread_phase ];
            h->i_thread_phase = (h->i_thread_phase + 1) % h->i_thread_frames;
            thread_current = h->thread[ h->i_thread_phase ];
            thread_oldest  = h->thread[ (h->i_thread_phase + 1) % h->i_thread_frames ];
            thread_sync_context( thread_current, thread_prev );
            x264_thread_sync_ratecontrol( thread_current, thread_prev, thread_oldest );
            h = thread_current;
        }
        else
        {
            thread_current =
            thread_oldest  = h;
        }
        h->i_cpb_delay_pir_offset = h->i_cpb_delay_pir_offset_next;
    
        /* no data out */
        *pi_nal = 0;
        *pp_nal = NULL;
    
        /* ------------------- Setup new frame from picture -------------------- */
        if( pic_in != NULL )
        {
            // lookahead 线程退出
            if( h->lookahead->b_exit_thread )
            {
                x264_log( h, X264_LOG_ERROR, "lookahead thread is already stopped\n" );
                return -1;
            }
    
            /* 1: Copy the picture to a frame and move it to a buffer */
            //
            /**
             * @brief fenc 获取x264_frame_t:fenc的存储空间，用来存放待编码的帧
             * 如果 h->frames.unused[b_fdec][0]不为空，就调用x264_frame_pop()从unused[]队列取1个现成的；
             * 否则就调用x264_frame_new()创建一个新的
             */
            x264_frame_t *fenc = x264_frame_pop_unused( h, 0 );
            if( !fenc )
                return -1;
    
            //将输入的图像数据拷贝至fenc,根据pic_in中图像的颜色空间情况进行了数据的复制
            if( x264_frame_copy_picture( h, fenc, pic_in ) < 0 )
                return -1;
    
            //宽和高都确保是16的整数倍（宏块宽度的整数倍）
            if( h->param.i_width != 16 * h->mb.i_mb_width ||
                h->param.i_height != 16 * h->mb.i_mb_height )
                x264_frame_expand_border_mod16( h, fenc );// 不是则进行边界处理，扩展至16整数倍
    
            // 图像的输入序号（原始顺序或播放顺序）
            fenc->i_frame = h->frames.i_input++;
    
            if( fenc->i_frame == 0 )// 第一帧
                h->frames.i_first_pts = fenc->i_pts;
            if( h->frames.i_bframe_delay && fenc->i_frame == h->frames.i_bframe_delay )
                h->frames.i_bframe_delay_time = fenc->i_pts - h->frames.i_first_pts;
    
            // 判断pts是否严格递增
            if( h->param.b_vfr_input && fenc->i_pts <= h->frames.i_largest_pts )
                x264_log( h, X264_LOG_WARNING, "non-strictly-monotonic PTS\n" );
    
            // 判断pts是否严格递增
            h->frames.i_second_largest_pts = h->frames.i_largest_pts;
            // 更新最大pts值
            h->frames.i_largest_pts = fenc->i_pts;
    
            //enum pic_struct_e
            //{
            //    PIC_STRUCT_AUTO              = 0, // automatically decide (default)
            //    PIC_STRUCT_PROGRESSIVE       = 1, // progressive frame
            //    // "TOP" and "BOTTOM" are not supported in x264 (PAFF only)
            //    PIC_STRUCT_TOP_BOTTOM        = 4, // top field followed by bottom,顶场-底场
            //    PIC_STRUCT_BOTTOM_TOP        = 5, // bottom field followed by top 底场-顶场
            //    PIC_STRUCT_TOP_BOTTOM_TOP    = 6, // top field, bottom field, top field repeated
            //    PIC_STRUCT_BOTTOM_TOP_BOTTOM = 7, // bottom field, top field, bottom field repeated
            //    PIC_STRUCT_DOUBLE            = 8, // double frame 重复两次
            //    PIC_STRUCT_TRIPLE            = 9, // triple frame 重复三次
            //};
            // 图像类型参数校验
            if( (fenc->i_pic_struct < PIC_STRUCT_AUTO) || (fenc->i_pic_struct > PIC_STRUCT_TRIPLE) )
                fenc->i_pic_struct = PIC_STRUCT_AUTO;
    
            // 确定帧结构
            if( fenc->i_pic_struct == PIC_STRUCT_AUTO )
            {
    #if HAVE_INTERLACED  //定义隔行扫描
                int b_interlaced = fenc->param ? fenc->param->b_interlaced : h->param.b_interlaced;
    #else
                int b_interlaced = 0;
    #endif
                if( b_interlaced )
                {
                    int b_tff = fenc->param ? fenc->param->b_tff : h->param.b_tff;
                    fenc->i_pic_struct = b_tff ? PIC_STRUCT_TOP_BOTTOM : PIC_STRUCT_BOTTOM_TOP;
                }
                else
                    fenc->i_pic_struct = PIC_STRUCT_PROGRESSIVE;
            }
    
            // mb_tree（宏块级码率控制）算法是否开启及编码多遍是否开启
            // rate control encoding only : x264_ratecontrol_t *rc;
            if( h->param.rc.b_mb_tree && h->param.rc.b_stat_read )
            {
                if( x264_macroblock_tree_read( h, fenc, pic_in->prop.quant_offsets ) )
                    return -1;
            }
            else
                x264_adaptive_quant_frame( h, fenc, pic_in->prop.quant_offsets );
    
            if( pic_in->prop.quant_offsets_free )
                pic_in->prop.quant_offsets_free( pic_in->prop.quant_offsets );
    
            //降低分辨率处理（原来的一半），线性内插
            if( h->frames.b_have_lowres )
                x264_frame_init_lowres( h, fenc );
    
            /* 2: Place the frame into the queue for its slice type decision */
            //初始化lookahead线程,fenc放入h的lookahead.next.list[]队列，等待确定帧类型
            x264_lookahead_put_frame( h, fenc );
    
            if( h->frames.i_input <= h->frames.i_delay + 1 - h->i_thread_frames )
            {
                /* Nothing yet to encode, waiting for filling of buffers */
                pic_out->i_type = X264_TYPE_AUTO;
                return 0;
            }
        }
        else
        {
            /* signal kills for lookahead thread */
            x264_pthread_mutex_lock( &h->lookahead->ifbuf.mutex );
            h->lookahead->b_exit_thread = 1;
            x264_pthread_cond_broadcast( &h->lookahead->ifbuf.cv_fill );
            x264_pthread_mutex_unlock( &h->lookahead->ifbuf.mutex );
        }
    
        h->i_frame++;   // 编码帧号
    
        /* 3: The picture is analyzed in the lookahead */
        // 在lookhead线程中分析图像帧,通过lookahead分析帧类型。该函数调用了x264_slicetype_decide()
        // x264_slicetype_analyse()和x264_slicetype_frame_cost()等函数。
        // 经过一些列分析之后，最终确定了帧类型信息，并且将帧放入frames.current[]队列
        if( !h->frames.current[0] )
            x264_lookahead_get_frames( h );
    
        if( !h->frames.current[0] && x264_lookahead_is_empty( h ) )
            return encoder_frame_end( thread_oldest, thread_current, pp_nal, pi_nal, pic_out );
    
        /* ------------------- Get frame to be encoded ------------------------- */
        /* 4: get picture to encode */
        // 从frames.current[]队列取出1帧用于编码并更新currect队列
        h->fenc = x264_frame_shift( h->frames.current );
    
        /* If applicable, wait for previous frame reconstruction to finish */
        // 判断是否使用基于slice的多线程，若使用则需等待上一帧图像重建完成
        if( h->param.b_sliced_threads )
            if( threadpool_wait_all( h ) < 0 )
                return -1;
    
        if( h->i_frame == 0 )
            h->i_reordered_pts_delay = h->fenc->i_reordered_pts;
        if( h->reconfig )
        {
            x264_encoder_reconfig_apply( h, &h->reconfig_h->param );
            h->reconfig = 0;
        }
        if( h->fenc->param )
        {
            x264_encoder_reconfig_apply( h, h->fenc->param );
            if( h->fenc->param->param_free )
            {
                x264_param_cleanup( h->fenc->param );
                h->fenc->param->param_free( h->fenc->param );
                h->fenc->param = NULL;
            }
        }
    
        // x264_t结构体内率控结构体部分的初始化
        x264_ratecontrol_zone_init( h );
    
        // ok to call this before encoding any frames,
        //since the initial values of fdec have b_kept_as_ref=0
        //更新参考帧队列frames.reference[].若为B帧则不更新
        //重建帧fdec移植参考帧列表，新建一个fdec
        if( reference_update( h ) ) // 更新参考帧队列
            return -1;
        h->fdec->i_lines_completed = -1; //完成多少线像素
    
        // 判断是否为I帧
        // #define IS_X264_TYPE_I(x) ((x)==X264_TYPE_I || (x)==X264_TYPE_IDR || (x)==X264_TYPE_KEYFRAME)
        if( !IS_X264_TYPE_I( h->fenc->i_type ) )
        {
            int valid_refs_left = 0;
            for( int i = 0; h->frames.reference[i]; i++ )
                if( !h->frames.reference[i]->b_corrupt ) // 交互式编码器控制
                    valid_refs_left++;
            /* No valid reference frames left: force an IDR. */
            //不是I帧且参考帧队列中没有可参考的帧,强制其为IDR帧
            if( !valid_refs_left )
            {
                h->fenc->b_keyframe = 1;
                h->fenc->i_type = X264_TYPE_IDR;
            }
        }
    
        // 判断是否为关键帧
        if( h->fenc->b_keyframe )
        {
            h->frames.i_last_keyframe = h->fenc->i_frame;
            //IDR帧,清空缓存
            if( h->fenc->i_type == X264_TYPE_IDR )
            {
                h->i_frame_num = 0;
                h->frames.i_last_idr = h->fenc->i_frame;
            }
        }
        h->sh.i_mmco_command_count =
        h->sh.i_mmco_remove_from_end = 0;
        h->b_ref_reorder[0] =
        h->b_ref_reorder[1] = 0;
        h->fdec->i_poc =
        h->fenc->i_poc = 2 * ( h->fenc->i_frame - X264_MAX( h->frames.i_last_idr, 0 ) );
    
        /* ------------------- Setup frame context ----------------------------- */
        /* 5: Init data dependent of frame type */
        if( h->fenc->i_type == X264_TYPE_IDR )
        {
            /* reset ref pictures */
            i_nal_type    = NAL_SLICE_IDR;
            i_nal_ref_idc = NAL_PRIORITY_HIGHEST;
            h->sh.i_type = SLICE_TYPE_I;
            reference_reset( h );// 若为IDR帧，则清空参考帧列表
            h->frames.i_poc_last_open_gop = -1;
        }
        else if( h->fenc->i_type == X264_TYPE_I )
        {
            i_nal_type    = NAL_SLICE;
            i_nal_ref_idc = NAL_PRIORITY_HIGH; /* Not completely true but for now it is (as all I/P are kept as ref)*/
            h->sh.i_type = SLICE_TYPE_I;
            reference_hierarchy_reset( h );
            if( h->param.b_open_gop )
                h->frames.i_poc_last_open_gop = h->fenc->b_keyframe ? h->fenc->i_poc : -1;
        }
        else if( h->fenc->i_type == X264_TYPE_P )
        {
            i_nal_type    = NAL_SLICE;
            i_nal_ref_idc = NAL_PRIORITY_HIGH; /* Not completely true but for now it is (as all I/P are kept as ref)*/
            h->sh.i_type = SLICE_TYPE_P;
            reference_hierarchy_reset( h );
            h->frames.i_poc_last_open_gop = -1;
        }
        else if( h->fenc->i_type == X264_TYPE_BREF )
        {
            //可以作为参考帧的B帧，这是个特色
    
            i_nal_type    = NAL_SLICE;
            i_nal_ref_idc = h->param.i_bframe_pyramid == X264_B_PYRAMID_STRICT ? NAL_PRIORITY_LOW : NAL_PRIORITY_HIGH;
            h->sh.i_type = SLICE_TYPE_B;
            reference_hierarchy_reset( h );
        }
        else    /* B frame */
        {
            i_nal_type    = NAL_SLICE;
            i_nal_ref_idc = NAL_PRIORITY_DISPOSABLE;
            h->sh.i_type = SLICE_TYPE_B;
        }
    
        //重建帧与编码帧的赋值..
        h->fdec->i_type = h->fenc->i_type;
        h->fdec->i_frame = h->fenc->i_frame;
        h->fenc->b_kept_as_ref =
        h->fdec->b_kept_as_ref = i_nal_ref_idc != NAL_PRIORITY_DISPOSABLE && h->param.i_keyint_max > 1;
    
        h->fdec->mb_info = h->fenc->mb_info;
        h->fdec->mb_info_free = h->fenc->mb_info_free;
        h->fenc->mb_info = NULL;
        h->fenc->mb_info_free = NULL;
    
        h->fdec->i_pts = h->fenc->i_pts;
        if( h->frames.i_bframe_delay )
        {
            int64_t *prev_reordered_pts = thread_current->frames.i_prev_reordered_pts;
            h->fdec->i_dts = h->i_frame > h->frames.i_bframe_delay
                           ? prev_reordered_pts[ (h->i_frame - h->frames.i_bframe_delay) % h->frames.i_bframe_delay ]
                           : h->fenc->i_reordered_pts - h->frames.i_bframe_delay_time;
            prev_reordered_pts[ h->i_frame % h->frames.i_bframe_delay ] = h->fenc->i_reordered_pts;
        }
        else
            h->fdec->i_dts = h->fenc->i_reordered_pts;
        if( h->fenc->i_type == X264_TYPE_IDR )
            h->i_last_idr_pts = h->fdec->i_pts;
    
        /* ------------------- Init                ----------------------------- */
        /* build ref list 0/1 */
        // 参考帧队列（List[0]/list[1]）的建立
        reference_build_list( h, h->fdec->i_poc ); //int i_poc;视频帧播放顺序号
    
        /* ---------------------- Write the bitstream -------------------------- */
        /* Init bitstream context */
        if( h->param.b_sliced_threads )
        {
            for( int i = 0; i < h->param.i_threads; i++ )
            {
                bs_init( &h->thread[i]->out.bs, h->thread[i]->out.p_bitstream, h->thread[i]->out.i_bitstream );
                h->thread[i]->out.i_nal = 0;
            }
        }
        else
        {
            bs_init( &h->out.bs, h->out.p_bitstream, h->out.i_bitstream );
            h->out.i_nal = 0;
        }
    
        if( h->param.b_aud )
        {
            int pic_type;
    
            // Slice header :x264_slice_header_t sh;
            if( h->sh.i_type == SLICE_TYPE_I )
                pic_type = 0;
            else if( h->sh.i_type == SLICE_TYPE_P )
                pic_type = 1;
            else if( h->sh.i_type == SLICE_TYPE_B )
                pic_type = 2;
            else
                pic_type = 7;int     i_poc;   // poc 视频帧播放顺序号
    
            nal_start( h, NAL_AUD, NAL_PRIORITY_DISPOSABLE );
            bs_write( &h->out.bs, 3, pic_type );
            bs_rbsp_trailing( &h->out.bs );
            bs_flush( &h->out.bs );
            if( nal_end( h ) )
                return -1;
            overhead += h->out.nal[h->out.i_nal-1].i_payload + NALU_OVERHEAD;
        }
    
        h->i_nal_type = i_nal_type; // NAL类型
        h->i_nal_ref_idc = i_nal_ref_idc; // 包重要程度
    
        if( h->param.b_intra_refresh )
        {
            if( IS_X264_TYPE_I( h->fenc->i_type ) )
            {
                h->fdec->i_frames_since_pir = 0;
                h->b_queued_intra_refresh = 0;
                /* PIR is currently only supported with ref == 1, so any intra frame effectively refreshes
                 * the whole frame and counts as an intra refresh. */
                h->fdec->f_pir_position = h->mb.i_mb_width;
            }
            else if( h->fenc->i_type == X264_TYPE_P )
            {
                int pocdiff = (h->fdec->i_poc - h->fref[0][0]->i_poc)/2;
                float increment = X264_MAX( ((float)h->mb.i_mb_width-1) / h->param.i_keyint_max, 1 );
                h->fdec->f_pir_position = h->fref[0][0]->f_pir_position;
                h->fdec->i_frames_since_pir = h->fref[0][0]->i_frames_since_pir + pocdiff;
                if( h->fdec->i_frames_since_pir >= h->param.i_keyint_max ||
                    (h->b_queued_intra_refresh && h->fdec->f_pir_position + 0.5 >= h->mb.i_mb_width) )
                {
                    h->fdec->f_pir_position = 0;
                    h->fdec->i_frames_since_pir = 0;
                    h->b_queued_intra_refresh = 0;
                    h->fenc->b_keyframe = 1;
                }
                h->fdec->i_pir_start_col = h->fdec->f_pir_position+0.5;
                h->fdec->f_pir_position += increment * pocdiff;
                h->fdec->i_pir_end_col = h->fdec->f_pir_position+0.5;
                /* If our intra refresh has reached the right side of the frame, we're done. */
                if( h->fdec->i_pir_end_col >= h->mb.i_mb_width - 1 )
                {
                    h->fdec->f_pir_position = h->mb.i_mb_width;
                    h->fdec->i_pir_end_col = h->mb.i_mb_width - 1;
                }
            }
        }
    
        if( h->fenc->b_keyframe )
        {
            /* Write SPS and PPS */
            //每个关键帧前面重复加上SPS和PPS
            if( h->param.b_repeat_headers )
            {
                /* generate sequence parameters */
                nal_start( h, NAL_SPS, NAL_PRIORITY_HIGHEST );
                x264_sps_write( &h->out.bs, h->sps );
                if( nal_end( h ) )
                    return -1;
                /* Pad AUD/SPS to 256 bytes like Panasonic */
                if( h->param.i_avcintra_class )
                    h->out.nal[h->out.i_nal-1].i_padding = 256 - bs_pos( &h->out.bs ) / 8 - 2*NALU_OVERHEAD;
                overhead += h->out.nal[h->out.i_nal-1].i_payload + h->out.nal[h->out.i_nal-1].i_padding + NALU_OVERHEAD;
    
                /* generate picture parameters */
                nal_start( h, NAL_PPS, NAL_PRIORITY_HIGHEST );
                x264_pps_write( &h->out.bs, h->sps, h->pps );
                if( nal_end( h ) )
                    return -1;
                if( h->param.i_avcintra_class )
                {
                    int total_len = 256;
                    /* Sony XAVC uses an oversized PPS instead of SEI padding */
                    if( h->param.i_avcintra_flavor == X264_AVCINTRA_FLAVOR_SONY )
                        total_len += h->param.i_height == 1080 ? 18*512 : 10*512;
                    h->out.nal[h->out.i_nal-1].i_padding = total_len - h->out.nal[h->out.i_nal-1].i_payload - NALU_OVERHEAD;
                }
                overhead += h->out.nal[h->out.i_nal-1].i_payload + h->out.nal[h->out.i_nal-1].i_padding + NALU_OVERHEAD;
            }
    
            /* when frame threading is used, buffering period sei is written in encoder_frame_end */
            if( h->i_thread_frames == 1 && h->sps->vui.b_nal_hrd_parameters_present )
            {
                x264_hrd_fullness( h );
                nal_start( h, NAL_SEI, NAL_PRIORITY_DISPOSABLE );
                x264_sei_buffering_period_write( h, &h->out.bs );
                if( nal_end( h ) )
                   return -1;
                overhead += h->out.nal[h->out.i_nal-1].i_payload + SEI_OVERHEAD;
            }
        }
    
        /* write extra sei */
        for( int i = 0; i < h->fenc->extra_sei.num_payloads; i++ )
        {
            nal_start( h, NAL_SEI, NAL_PRIORITY_DISPOSABLE );
            x264_sei_write( &h->out.bs, h->fenc->extra_sei.payloads[i].payload, h->fenc->extra_sei.payloads[i].payload_size,
                            h->fenc->extra_sei.payloads[i].payload_type );
            if( nal_end( h ) )
                return -1;
            overhead += h->out.nal[h->out.i_nal-1].i_payload + SEI_OVERHEAD;
            if( h->fenc->extra_sei.sei_free )
            {
                h->fenc->extra_sei.sei_free( h->fenc->extra_sei.payloads[i].payload );
                h->fenc->extra_sei.payloads[i].payload = NULL;
            }
        }
    
        if( h->fenc->extra_sei.sei_free )
        {
            h->fenc->extra_sei.sei_free( h->fenc->extra_sei.payloads );
            h->fenc->extra_sei.payloads = NULL;
            h->fenc->extra_sei.sei_free = NULL;
        }
    
        if( h->fenc->b_keyframe )
        {
            /* Avid's decoder strictly wants two SEIs for AVC-Intra so we can't insert the x264 SEI */
            if( h->param.b_repeat_headers && h->fenc->i_frame == 0 && !h->param.i_avcintra_class )
            {
                /* identify ourself */
                nal_start( h, NAL_SEI, NAL_PRIORITY_DISPOSABLE );
                if( x264_sei_version_write( h, &h->out.bs ) )
                    return -1;
                if( nal_end( h ) )
                    return -1;
                overhead += h->out.nal[h->out.i_nal-1].i_payload + SEI_OVERHEAD;
            }
    
            if( h->fenc->i_type != X264_TYPE_IDR )
            {
                int time_to_recovery = h->param.b_open_gop ? 0 : X264_MIN( h->mb.i_mb_width - 1, h->param.i_keyint_max ) + h->param.i_bframe - 1;
                nal_start( h, NAL_SEI, NAL_PRIORITY_DISPOSABLE );
                x264_sei_recovery_point_write( h, &h->out.bs, time_to_recovery );
                if( nal_end( h ) )
                    return -1;
                overhead += h->out.nal[h->out.i_nal-1].i_payload + SEI_OVERHEAD;
            }
        }
    
        if( h->param.i_frame_packing >= 0 && (h->fenc->b_keyframe || h->param.i_frame_packing == 5) )
        {
            nal_start( h, NAL_SEI, NAL_PRIORITY_DISPOSABLE );
            x264_sei_frame_packing_write( h, &h->out.bs );
            if( nal_end( h ) )
                return -1;
            overhead += h->out.nal[h->out.i_nal-1].i_payload + SEI_OVERHEAD;
        }
    
        if( h->param.i_alternative_transfer != 2 )
        {
            nal_start( h, NAL_SEI, NAL_PRIORITY_DISPOSABLE );
            x264_sei_alternative_transfer_write( h, &h->out.bs );
            if( nal_end( h ) )
                return -1;
            overhead += h->out.nal[h->out.i_nal-1].i_payload + SEI_OVERHEAD;
        }
    
        /* generate sei pic timing */
        if( h->sps->vui.b_pic_struct_present || h->sps->vui.b_nal_hrd_parameters_present )
        {
            nal_start( h, NAL_SEI, NAL_PRIORITY_DISPOSABLE );
            x264_sei_pic_timing_write( h, &h->out.bs );
            if( nal_end( h ) )
                return -1;
            overhead += h->out.nal[h->out.i_nal-1].i_payload + SEI_OVERHEAD;
        }
    
        /* As required by Blu-ray. */
        if( !IS_X264_TYPE_B( h->fenc->i_type ) && h->b_sh_backup )
        {
            h->b_sh_backup = 0;
            nal_start( h, NAL_SEI, NAL_PRIORITY_DISPOSABLE );
            x264_sei_dec_ref_pic_marking_write( h, &h->out.bs );
            if( nal_end( h ) )
                return -1;
            overhead += h->out.nal[h->out.i_nal-1].i_payload + SEI_OVERHEAD;
        }
    
        if( h->fenc->b_keyframe && h->param.b_intra_refresh )
            h->i_cpb_delay_pir_offset_next = h->fenc->i_cpb_delay;
    
        /* Filler space: 10 or 18 SEIs' worth of space, depending on resolution */
        if( h->param.i_avcintra_class && h->param.i_avcintra_flavor != X264_AVCINTRA_FLAVOR_SONY )
        {
            /* Write an empty filler NAL to mimic the AUD in the P2 format*/
            nal_start( h, NAL_FILLER, NAL_PRIORITY_DISPOSABLE );
            x264_filler_write( h, &h->out.bs, 0 );
            if( nal_end( h ) )
                return -1;
            overhead += h->out.nal[h->out.i_nal-1].i_payload + NALU_OVERHEAD;
    
            /* All lengths are magic lengths that decoders expect to see */
            /* "UMID" SEI */
            nal_start( h, NAL_SEI, NAL_PRIORITY_DISPOSABLE );
            if( x264_sei_avcintra_umid_write( h, &h->out.bs ) < 0 )
                return -1;
            if( nal_end( h ) )
                return -1;
            overhead += h->out.nal[h->out.i_nal-1].i_payload + SEI_OVERHEAD;
    
            int unpadded_len;
            int total_len;
            if( h->param.i_height == 1080 )
            {
                unpadded_len = 5780;
                total_len = 17*512;
            }
            else
            {
                unpadded_len = 2900;
                total_len = 9*512;
            }
            /* "VANC" SEI */
            nal_start( h, NAL_SEI, NAL_PRIORITY_DISPOSABLE );
            if( x264_sei_avcintra_vanc_write( h, &h->out.bs, unpadded_len ) < 0 )
                return -1;
            if( nal_end( h ) )
                return -1;
    
            h->out.nal[h->out.i_nal-1].i_padding = total_len - h->out.nal[h->out.i_nal-1].i_payload - SEI_OVERHEAD;
            overhead += h->out.nal[h->out.i_nal-1].i_payload + h->out.nal[h->out.i_nal-1].i_padding + SEI_OVERHEAD;
        }
    
        /* Init the rate control */
        /* FIXME: Include slice header bit cost. */
        // 开启码率控制
        x264_ratecontrol_start( h, h->fenc->i_qpplus1, overhead*8 );
        i_global_qp = x264_ratecontrol_qp( h );
    
        pic_out->i_qpplus1 =
        h->fdec->i_qpplus1 = i_global_qp + 1;
    
        if( h->param.rc.b_stat_read && h->sh.i_type != SLICE_TYPE_I )
        {
            x264_reference_build_list_optimal( h );
            reference_check_reorder( h );
        }
    
        if( h->i_ref[0] )
            h->fdec->i_poc_l0ref0 = h->fref[0][0]->i_poc;
    
        /* ------------------------ Create slice header  ----------------------- */
        // 创建slice头，并初始化头信息结构体
        slice_init( h, i_nal_type, i_global_qp );
    
        /*------------------------- Weights -------------------------------------*/
        if( h->sh.i_type == SLICE_TYPE_B )
            x264_macroblock_bipred_init( h );
    
        // 加权预测
        weighted_pred_init( h );
    
        if( i_nal_ref_idc != NAL_PRIORITY_DISPOSABLE )
            h->i_frame_num++;
    
        /* Write frame */
        h->i_threadslice_start = 0;
        h->i_threadslice_end = h->mb.i_mb_height;
        if( h->i_thread_frames > 1 )
        {
            x264_threadpool_run( h->threadpool, (void*)slices_write, h );
            h->b_thread_active = 1;
        }
        else if( h->param.b_sliced_threads )
        {
            // 编码数据（最关键的步骤）。其中调用了x264_slice_write()完成了编码的工作
            //（注意“x264_slices_write()”和“x264_slice_write()”名字差了一个“s”）
            if( threaded_slices_write( h ) )
                return -1;
        }
        else
            if( (intptr_t)slices_write( h ) )
                return -1;
    
        return encoder_frame_end( thread_oldest, thread_current, pp_nal, pi_nal, pic_out );
    }

### static intptr\_t slice\_write( x264\_t \*h ) ###

写入slice：

### x264\_encoder\_delayed\_frames( x264\_t \*h ) 获取缓冲区的frame数目 ###

int x264_encoder_delayed_frames( x264_t *h )
    {
        int delayed_frames = 0;
        if( h->i_thread_frames > 1 )
        {
            for( int i = 0; i < h->i_thread_frames; i++ )
                delayed_frames += h->thread[i]->b_thread_active;
            h = h->thread[h->i_thread_phase];
        }
        for( int i = 0; h->frames.current[i]; i++ )
            delayed_frames++;
        x264_pthread_mutex_lock( &h->lookahead->ofbuf.mutex );
        x264_pthread_mutex_lock( &h->lookahead->ifbuf.mutex );
        x264_pthread_mutex_lock( &h->lookahead->next.mutex );
        delayed_frames += h->lookahead->ifbuf.i_size + h->lookahead->next.i_size + h->lookahead->ofbuf.i_size;
        x264_pthread_mutex_unlock( &h->lookahead->next.mutex );
        x264_pthread_mutex_unlock( &h->lookahead->ifbuf.mutex );
        x264_pthread_mutex_unlock( &h->lookahead->ofbuf.mutex );
        return delayed_frames;
    }

## 参考文献 ##

1.  \[雷霄骅 [x264][]\]

[-H264_-_-x264_-_x264]: https://blog.csdn.net/bwangk/article/details/111314768
[-H264_-_-x264_-]: https://blog.csdn.net/bwangk/article/details/111402799
[-H264_-_-x264_- 1]: https://blog.csdn.net/bwangk/article/details/111402883
[-H264_-_-x264_-C_11]: https://blog.csdn.net/bwangk/article/details/111402909
[x264]: https://blog.csdn.net/leixiaohua1020/category_2619503.html