X264 - x264_encoder_encode

最新推荐文章于 2024-05-17 10:47:46 发布
最新推荐文章于 2024-05-17 10:47:46 发布
阅读量4.5k 收藏 1
点赞数
分类专栏： Stream Media/H264
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fanbird2008/article/details/9087509
版权

这个函数前面有一段注释(如下):

****************************************************************************

 * 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//poc是实际的帧的位置.

 *       P      1   2*3//frame是编码的顺序.

 *       B      2   2*1

 *       B      3   2*2

 *       P      4   2*6

 *       B      5   2*4

 *       B      6   2*5

 ****************************************************************************/

要搞清poc和frame的区别.

假设一个视频序列如下:

I     B    B    P     B     B     P

我们编码是按I  P  B  B  P  B  B的顺序,这就是frame的编号.

而我们视频序列的播放序号是POC的序号,这里是乘以了2.



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;
    int i_nal_type, i_nal_ref_idc, i_global_qp;
    int overhead = NALU_OVERHEAD;


#if HAVE_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 ];
        x264_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;
    }
#if HAVE_MMX
    if( h->param.cpu&X264_CPU_SSE_MISALIGN )
        x264_cpu_mask_misalign_sse();
#endif
    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 )
    {

        /* 1: Copy the picture to a frame and move it to a buffer */

        // get a unused frame fenc

        x264_frame_t *fenc = x264_frame_pop_unused( h, 0 );
        if( !fenc )
            return -1;

        // copy from pic_in to fenc
        if( x264_frame_copy_picture( h, fenc, pic_in ) < 0 )
            return -1;


        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 );


        fenc->i_frame = h->frames.i_input++;   // frame number of frame encoded


        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;


        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" );


        h->frames.i_second_largest_pts = h->frames.i_largest_pts;
        h->frames.i_largest_pts = fenc->i_pts;


        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;
        }

        // x264 encode 2 pass
        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_stack_align( 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 );

        // calc 1/2 pixel of luma plane and expand border of luma plane
        if( h->frames.b_have_lowres )
            x264_frame_init_lowres( h, fenc );


        /* 2: Place the frame into the queue for its slice type decision */

        // put frame into ifbuf or 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++;    // add h's frame number

    /* 3: The picture is analyzed in the lookahead */

    // shift items from lookahead->ofbuf to h->frames.current

    if( !h->frames.current[0] )
        x264_lookahead_get_frames( h );

    // 

    if( !h->frames.current[0] && x264_lookahead_is_empty( h ) )
        return x264_encoder_frame_end( thread_oldest, thread_current, pp_nal, pi_nal, pic_out );


    /* ------------------- Get frame to be encoded ------------------------- */

    /* 4: get picture to encode */

    // get h->frames.current[0], and set it to h->fenc

    h->fenc = x264_frame_shift( h->frames.current );


    /* If applicable, wait for previous frame reconstruction to finish */
    if( h->param.b_sliced_threads )
        if( x264_threadpool_wait_all( h ) < 0 )
            return -1;


    if( h->i_frame == h->i_thread_frames - 1 )
        h->i_reordered_pts_delay = h->fenc->i_reordered_pts;
    if( h->fenc->param )
    {
        x264_encoder_reconfig( h, h->fenc->param );
        if( h->fenc->param->param_free )
        {
            h->fenc->param->param_free( h->fenc->param );
            h->fenc->param = NULL;
        }
    }


    // ok to call this before encoding any frames, since the initial values of fdec have b_kept_as_ref=0

    // update reference frame

    if( x264_reference_update( h ) )
        return -1;
    h->fdec->i_lines_completed = -1;


    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. */
        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;
        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;
        x264_reference_reset( h );      // clear reference frame list
        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;
        x264_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;
        x264_reference_hierarchy_reset( h );
        h->frames.i_poc_last_open_gop = -1;
    }
    else if( h->fenc->i_type == X264_TYPE_BREF )
    {
        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;
        x264_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;
    }


    // reconstruct frame as reference, only b_kept_as_ref is true

    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 */
    x264_reference_build_list( h, h->fdec->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;


        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;


        x264_nal_start( h, NAL_AUD, NAL_PRIORITY_DISPOSABLE );
        bs_write( &h->out.bs, 3, pic_type );
        bs_rbsp_trailing( &h->out.bs );
        if( x264_nal_end( h ) )
            return -1;
        overhead += h->out.nal[h->out.i_nal-1].i_payload + NALU_OVERHEAD - (h->param.b_annexb && h->out.i_nal-1);
    }


    h->i_nal_type = i_nal_type;
    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 */
        if( h->param.b_repeat_headers )
        {
            /* generate sequence parameters */
            x264_nal_start( h, NAL_SPS, NAL_PRIORITY_HIGHEST );
            x264_sps_write( &h->out.bs, h->sps );
            if( x264_nal_end( h ) )
                return -1;
            overhead += h->out.nal[h->out.i_nal-1].i_payload + NALU_OVERHEAD;


            /* generate picture parameters */
            x264_nal_start( h, NAL_PPS, NAL_PRIORITY_HIGHEST );
            x264_pps_write( &h->out.bs, h->sps, h->pps );
            if( x264_nal_end( h ) )
                return -1;
            overhead += h->out.nal[h->out.i_nal-1].i_payload + NALU_OVERHEAD;
        }


        /* when frame threading is used, buffering period sei is written in x264_encoder_frame_end */
        if( h->i_thread_frames == 1 && h->sps->vui.b_nal_hrd_parameters_present )
        {
            x264_hrd_fullness( h );
            x264_nal_start( h, NAL_SEI, NAL_PRIORITY_DISPOSABLE );
            x264_sei_buffering_period_write( h, &h->out.bs );
            if( x264_nal_end( h ) )
               return -1;
            overhead += h->out.nal[h->out.i_nal-1].i_payload + NALU_OVERHEAD;
        }
    }


    /* write extra sei */
    for( int i = 0; i < h->fenc->extra_sei.num_payloads; i++ )
    {
        x264_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( x264_nal_end( h ) )
            return -1;
        overhead += h->out.nal[h->out.i_nal-1].i_payload + NALU_OVERHEAD - (h->param.b_annexb && h->out.i_nal-1);
        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 )
    {
        if( h->param.b_repeat_headers && h->fenc->i_frame == 0 )
        {
            /* identify ourself */
            x264_nal_start( h, NAL_SEI, NAL_PRIORITY_DISPOSABLE );
            if( x264_sei_version_write( h, &h->out.bs ) )
                return -1;
            if( x264_nal_end( h ) )
                return -1;
            overhead += h->out.nal[h->out.i_nal-1].i_payload + NALU_OVERHEAD - (h->param.b_annexb && h->out.i_nal-1);
        }


        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;
            x264_nal_start( h, NAL_SEI, NAL_PRIORITY_DISPOSABLE );
            x264_sei_recovery_point_write( h, &h->out.bs, time_to_recovery );
            if( x264_nal_end( h ) )
                return -1;
            overhead += h->out.nal[h->out.i_nal-1].i_payload + NALU_OVERHEAD - (h->param.b_annexb && h->out.i_nal-1);
        }


        if ( h->param.i_frame_packing >= 0 )
        {
            x264_nal_start( h, NAL_SEI, NAL_PRIORITY_DISPOSABLE );
            x264_sei_frame_packing_write( h, &h->out.bs );
            if( x264_nal_end( h ) )
                return -1;
            overhead += h->out.nal[h->out.i_nal-1].i_payload + NALU_OVERHEAD - (h->param.b_annexb && h->out.i_nal-1);
        }
    }


    /* generate sei pic timing */
    if( h->sps->vui.b_pic_struct_present || h->sps->vui.b_nal_hrd_parameters_present )
    {
        x264_nal_start( h, NAL_SEI, NAL_PRIORITY_DISPOSABLE );
        x264_sei_pic_timing_write( h, &h->out.bs );
        if( x264_nal_end( h ) )
            return -1;
        overhead += h->out.nal[h->out.i_nal-1].i_payload + NALU_OVERHEAD - (h->param.b_annexb && h->out.i_nal-1);
    }


    /* As required by Blu-ray. */
    if( !IS_X264_TYPE_B( h->fenc->i_type ) && h->b_sh_backup )
    {
        h->b_sh_backup = 0;
        x264_nal_start( h, NAL_SEI, NAL_PRIORITY_DISPOSABLE );
        x264_sei_dec_ref_pic_marking_write( h, &h->out.bs );
        if( x264_nal_end( h ) )
            return -1;
        overhead += h->out.nal[h->out.i_nal-1].i_payload + NALU_OVERHEAD - (h->param.b_annexb && h->out.i_nal-1);
    }


    if( h->fenc->b_keyframe && h->param.b_intra_refresh )
        h->i_cpb_delay_pir_offset_next = h->fenc->i_cpb_delay;


    /* 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 );
        x264_reference_check_reorder( h );
    }


    if( h->i_ref[0] )
        h->fdec->i_poc_l0ref0 = h->fref[0][0]->i_poc;


    /* ------------------------ Create slice header  ----------------------- */
    x264_slice_init( h, i_nal_type, i_global_qp );


    /*------------------------- Weights -------------------------------------*/
    if( h->sh.i_type == SLICE_TYPE_B )
        x264_macroblock_bipred_init( h );


    x264_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*) x264_slices_write, h );
        h->b_thread_active = 1;
    }
    else if( h->param.b_sliced_threads )
    {
        if( x264_threaded_slices_write( h ) )
            return -1;
    }
    else
        if( (intptr_t) x264_slices_write( h ) )
            return -1;


    return x264_encoder_frame_end( thread_oldest, thread_current, pp_nal, pi_nal, pic_out );
}
fanbird2008
关注
专栏目录
x264代码学习笔记（二）：x264_encoder_encode函数
lifei092的博客
08-21 6486
encode()函数中循环调用encode_frame()函数进行逐帧编码： 调用x264_encoder_encode()函数完成一帧编码； 将编码后的码流载入码流文件中。 static int encode_frame( x264_t *h, hnd_t hout, x264_picture_t *pic, int64_t *last_dts ) { x264_picture_t...
x264代码剖析（九）：x264_encoder_encode()函数之x264_slice's'_write()函数
weixin_34277853的博客
03-10 248
x264代码剖析（九）：x264_encoder_encode()函数之x264_slice's'_write()函数 x264_encoder_encode()函数的核心函数就是x264_slices_write()函数。在x264_slices_write()函数中，最主要的工作就是调用了x264_slice_write()函...
x264源码分析--函数x264_encoder_encode
fantasy_ARM9的博客
04-28 739
x264_encoder_encode 这个函数是ffmpeg调用x264的接口，传入的是数据帧，函数实现编码最终调用x264_slices_write/**************************************************************************** * x264_encoder_encode: *  XXX: i_poc   : is th...
h264源码分析之x264_encoder_encode
fxbjye的博客
11-17 1117
/* **frame_next队列（临时缓存，帧类型没确定，待编码的帧队列） **frame_current队列（按编码顺序排放，已经确定了帧的类型，正在编码的帧队列） **frame_unused队列（空白队列，将要编码的帧放入该队列）  */ int     x264_encoder_encode( x264_t *h,                              x
x264代码剖析（六）：encode()函数之x264_encoder_headers()函数
成长Bar的博客专栏
03-09 4560
x264代码剖析（六）：encode()函数之x264_encoder_headers()函数           encode()函数是x264的主干函数，主要包括x264_encoder_open()函数、x264_encoder_headers()函数、x264_encoder_encode()函数与x264_encoder_close()函数四大部分，其中x264_encoder_en
ffmpeg---旧函数avcodec_encode_video2要延迟几帧才能got_packet-----设置参数av_opt_set
qq_42024067的博客
01-18 1197
ffmpeg 编码延迟问题（编码后avcodec_encode_video2要延迟几帧才能got_packet） // gcc temp.c -o 2 -I/root/ffmpeg/include/ -L/root/ffmpeg/lib -lavcodec -lavformat -lavdevice -lavutil -lswscale -lswresample //没有包含x264库 //...
x264代码剖析（九）：x264_encoder_encode()函数之x264_slice's'_write()函数
成长Bar的博客专栏
03-10 3432
x264代码剖析（九）：x264_encoder_encode()函数之x264_slice's'_write()函数           x264_encoder_encode()函数的核心函数就是x264_slices_write()函数。在x264_slices_write()函数中，最主要的工作就是调用了x264_slice_write()函数（注意“x264_slices_write
cyclic_encoder_decoder.zip_cyclic encode_cyclic_encoder
07-14
标题中的“cyclic_encoder_decoder.zip_cyclic encode_cyclic_encoder”暗示了这个压缩包包含与循环编码相关的源代码文件，用于实现编码和解码过程。我们可以通过分析提供的文件名来了解其中的具体内容： 1. `...
X264中的x264_encoder_encode和x264_nal_encode函数
qq_32790673的博客
10-18 1508
函数原型： int x264_encoder_encode( x264_t *h, x264_nal_t **pp_nal, int *pi_nal, x264_picture_t *pic_in,
x264代码剖析（七）：encode()函数之x264_encoder_encode()函数
weixin_34104341的博客
03-10 434
x264代码剖析（七）：encode()函数之x264_encoder_encode()函数 encode()函数是x264的主干函数，主要包括x264_encoder_open()函数、x264_encoder_headers()函数、x264_encoder_encode()函数与x264_encoder_close()函数四...
【x264】编码核心函数（x264_encoder_encode）的简单分析
最新发布
weixin_42877471的博客
05-17 868
x264_encoder_encode中实现了实际编码一帧的功能，其中涉及到了编码器中诸多方面的内容，大体可以归类如下： 1. 码流存储的方式 2. 码率控制的实现 3. 预测模块（帧内预测，帧间预测） 4. 实际编码（DCT变换，Quant量化） 5. 熵编码（CABAC，CAVLC） 6. 滤波模块 在视频编码当中，工作的大致流程是，输入一帧，经过mb块划分之后，对每一个mb进行参考帧预测（帧内或帧间）获得残差，对残差进行实际编码（变换量化）获得系数，系数通过熵编码进行编码并写入码流。
【obs】x264_encoder_encode 编码输出pts dts和 framesize
突围
07-27 372
x264_encoder_encode
x264代码剖析（十四）：核心算法之宏块编码函数x264_macroblock_encode()
weixin_34138139的博客
03-22 294
x264代码剖析（十四）：核心算法之宏块编码函数x264_macroblock_encode() 宏块编码函数x264_macroblock_encode()是完成变换与量化的主要函数，而x264_macroblock_encode()调用了x264_macroblock_encode_internal()函数，在x264_macr...
x264 encode
fanbird2008的专栏
04-25 2016
http://www.cnblogs.com/chuncn/archive/2011/02/25/1459805.html （1）       x264_param_default( x264_param_t *param )  作用： 对编码器进行参数设定 cqm:量化表相关信息                  csp：
x264_encoder_encode( h, &nal, &i_nal, pic, &pic_out )返回值
wmnmtm的专栏
09-22 380
    改一下,输出它的返回值：   每次打印结果均为　０
x264源码分析二：encode_frame函数和x264_encoder_encode函数
Austin的博客
05-07 4377
下面将开始分析x
int x264_nal_encode( void *p_data, int *pi_data, int b_annexeb, x264_nal_t *nal ) .
HEVC_CJL的专栏
12-15 3058
原文地址：http://blog.csdn.net/diffenyu/article/details/8292541 /****************************************************************************   * x264_nal_encode:  * x264_nal_encode( mux_buffer, &i
x264编码解析：关键函数详解
1.2 x264_encoder_encode(x264_t*h, x264_nal_t** pp_nal, int* pi_nal, x264_picture_t* pic) 此函数是编码的核心，执行以下操作： - 处理待编码的图片(`x264_picture_t* pic`)，决定其帧类型（I/P/B帧）。 - 初始...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值