x264码率控制过程解析

最新推荐文章于 2022-11-01 15:31:47 发布
最新推荐文章于 2022-11-01 15:31:47 发布
阅读量465 收藏 2
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sharp_sword111/article/details/108668601
版权

x264码率控制过程解析

本文对x264的码控流程和关键函数进行分析码控流程图

Lookahead Process

Ratecontrol Process

x264_slicetype_decide

x264_ratecontrol_zone_init

码控zone的初始化
相关结构体x264_zone_t
重写了ratecontrol

/* Zones: override ratecontrol or other options for specific sections of the video.
 * See x264_encoder_reconfig() for which options can be changed.
 * If zones overlap, whichever comes later in the list takes precedence. */
typedef struct x264_zone_t
{
    int i_start, i_end; /* range of frame numbers */
    int b_force_qp; /* whether to use qp vs bitrate factor */
    int i_qp;
    float f_bitrate_factor;
    struct x264_param_t *param;
} x264_zone_t;

主要用在对编码器reconfigure时来应用新的参数

void x264_ratecontrol_zone_init( x264_t *h )
{
    x264_ratecontrol_t *rc = h->rc;
    x264_zone_t *zone = get_zone( h, h->fenc->i_frame );
    if( zone && (!rc->prev_zone || zone->param != rc->prev_zone->param) )
        x264_encoder_reconfig_apply( h, zone->param );
    rc->prev_zone = zone;
}

x264_ratecontrol_start

相关的重要函数：rate_estimate_qscale

// update qscale for 1 frame based on actual bits used so far
static float rate_estimate_qscale( x264_t *h )
{
    float q;
    x264_ratecontrol_t *rcc = h->rc;
    ratecontrol_entry_t rce = {0};
    int pict_type = h->sh.i_type;
    int64_t total_bits = 8*(h->stat.i_frame_size[SLICE_TYPE_I]
                          + h->stat.i_frame_size[SLICE_TYPE_P]
                          + h->stat.i_frame_size[SLICE_TYPE_B])
                       - rcc->filler_bits_sum;

    if( rcc->b_2pass )
    {
        rce = *rcc->rce;
        if( pict_type != rce.pict_type )
        {
            x264_log( h, X264_LOG_ERROR, "slice=%c but 2pass stats say %c\n",
                      slice_type_to_char[pict_type], slice_type_to_char[rce.pict_type] );
        }
    }

    if( pict_type == SLICE_TYPE_B )
    {
        /* B-frames don't have independent ratecontrol, but rather get the
         * average QP of the two adjacent P-frames + an offset */

        int i0 = IS_X264_TYPE_I(h->fref_nearest[0]->i_type);
        int i1 = IS_X264_TYPE_I(h->fref_nearest[1]->i_type);
        int dt0 = abs(h->fenc->i_poc - h->fref_nearest[0]->i_poc);
        int dt1 = abs(h->fenc->i_poc - h->fref_nearest[1]->i_poc);
        float q0 = h->fref_nearest[0]->f_qp_avg_rc;
        float q1 = h->fref_nearest[1]->f_qp_avg_rc;

        if( h->fref_nearest[0]->i_type == X264_TYPE_BREF )
            q0 -= rcc->pb_offset/2;
        if( h->fref_nearest[1]->i_type == X264_TYPE_BREF )
            q1 -= rcc->pb_offset/2;

        if( i0 && i1 )
            q = (q0 + q1) / 2 + rcc->ip_offset;
        else if( i0 )
            q = q1;
        else if( i1 )
            q = q0;
        else
            q = (q0*dt1 + q1*dt0) / (dt0 + dt1);

        if( h->fenc->b_kept_as_ref )
            q += rcc->pb_offset/2;
        else
            q += rcc->pb_offset;

        rcc->qp_novbv = q;
        q = qp2qscale( q );
        if( rcc->b_2pass )
            rcc->frame_size_planned = qscale2bits( &rce, q );
        else
            rcc->frame_size_planned = predict_size( rcc->pred_b_from_p, q, h->fref[1][h->i_ref[1]-1]->i_satd );
        /* Limit planned size by MinCR */
        if( rcc->b_vbv )
            rcc->frame_size_planned = X264_MIN( rcc->frame_size_planned, rcc->frame_size_maximum );
        h->rc->frame_size_estimated = rcc->frame_size_planned;

        /* For row SATDs */
        if( rcc->b_vbv )
            rcc->last_satd = x264_rc_analyse_slice( h );
        return q;
    }
    else
    {
        double abr_buffer = 2 * rcc->rate_tolerance * rcc->bitrate;
        double predicted_bits = total_bits;
        if( h->i_thread_frames > 1 )
        {
            int j = h->rc - h->thread[0]->rc;
            for( int i = 1; i < h->i_thread_frames; i++ )
            {
                x264_t *t = h->thread[(j+i) % h->i_thread_frames];
                double bits = t->rc->frame_size_planned;
                if( !t->b_thread_active )
                    continue;
                bits = X264_MAX(bits, t->rc->frame_size_estimated);
                predicted_bits += bits;
            }
        }

        if( rcc->b_2pass )
        {
            double lmin = rcc->lmin[pict_type];
            double lmax = rcc->lmax[pict_type];
            double diff;

            /* Adjust ABR buffer based on distance to the end of the video. */
            if( rcc->num_entries > h->i_frame )
            {
                double final_bits = rcc->entry_out[rcc->num_entries-1]->expected_bits;
                double video_pos = rce.expected_bits / final_bits;
                double scale_factor = sqrt( (1 - video_pos) * rcc->num_entries );
                abr_buffer *= 0.5 * X264_MAX( scale_factor, 0.5 );
            }

            diff = predicted_bits - rce.expected_bits;
            q = rce.new_qscale;
            q /= x264_clip3f((abr_buffer - diff) / abr_buffer, .5, 2);
            if( h->i_frame >= rcc->fps && rcc->expected_bits_sum >= 1 )
            {
                /* Adjust quant based on the difference between
                 * achieved and expected bitrate so far */
                double cur_time = (double)h->i_frame / rcc->num_entries;
                double w = x264_clip3f( cur_time*100, 0.0, 1.0 );
                q *= pow( (double)total_bits / rcc->expected_bits_sum, w );
            }
            rcc->qp_novbv = qscale2qp( q );
            if( rcc->b_vbv )
            {
                /* Do not overflow vbv */
                double expected_size = qscale2bits( &rce, q );
                double expected_vbv = rcc->buffer_fill + rcc->buffer_rate - expected_size;
                double expected_fullness = rce.expected_vbv / rcc->buffer_size;
                double qmax = q*(2 - expected_fullness);
                double size_constraint = 1 + expected_fullness;
                qmax = X264_MAX( qmax, rce.new_qscale );
                if( expected_fullness < .05 )
                    qmax = lmax;
                qmax = X264_MIN(qmax, lmax);
                while( ((expected_vbv < rce.expected_vbv/size_constraint) && (q < qmax)) ||
                        ((expected_vbv < 0) && (q < lmax)))
                {
                    q *= 1.05;
                    expected_size = qscale2bits(&rce, q);
                    expected_vbv = rcc->buffer_fill + rcc->buffer_rate - expected_size;
                }
                rcc->last_satd = x264_rc_analyse_slice( h );
            }
            q = x264_clip3f( q, lmin, lmax );
        }
        else /* 1pass ABR */
        {
            /* Calculate the quantizer which would have produced the desired
             * average bitrate if it had been applied to all frames so far.
             * Then modulate that quant based on the current frame's complexity
             * relative to the average complexity so far (using the 2pass RCEQ).
             * Then bias the quant up or down if total size so far was far from
             * the target.
             * Result: Depending on the value of rate_tolerance, there is a
             * tradeoff between quality and bitrate precision. But at large
             * tolerances, the bit distribution approaches that of 2pass. */

            double wanted_bits, overflow = 1;

            rcc->last_satd = x264_rc_analyse_slice( h );
            rcc->short_term_cplxsum *= 0.5;
            rcc->short_term_cplxcount *= 0.5;
            rcc->short_term_cplxsum += rcc->last_satd / (CLIP_DURATION(h->fenc->f_duration) / BASE_FRAME_DURATION);
            rcc->short_term_cplxcount ++;

            rce.tex_bits = rcc->last_satd;
            rce.blurred_complexity = rcc->short_term_cplxsum / rcc->short_term_cplxcount;
            rce.mv_bits = 0;
            rce.p_count = rcc->nmb;
            rce.i_count = 0;
            rce.s_count = 0;
            rce.qscale = 1;
            rce.pict_type = pict_type;
            rce.i_duration = h->fenc->i_duration;

            if( h->param.rc.i_rc_method == X264_RC_CRF )
            {
                q = get_qscale( h, &rce, rcc->rate_factor_constant, h->fenc->i_frame );
            }
            else
            {
                q = get_qscale( h, &rce, rcc->wanted_bits_window / rcc->cplxr_sum, h->fenc->i_frame );

                /* ABR code can potentially be counterproductive in CBR, so just don't bother.
                 * Don't run it if the frame complexity is zero either. */
                if( !rcc->b_vbv_min_rate && rcc->last_satd )
                {
                    // FIXME is it simpler to keep track of wanted_bits in ratecontrol_end?
                    int i_frame_done = h->i_frame;
                    double time_done = i_frame_done / rcc->fps;
                    if( h->param.b_vfr_input && i_frame_done > 0 )
                        time_done = ((double)(h->fenc->i_reordered_pts - h->i_reordered_pts_delay)) * h->param.i_timebase_num / h->param.i_timebase_den;
                    wanted_bits = time_done * rcc->bitrate;
                    if( wanted_bits > 0 )
                    {
                        abr_buffer *= X264_MAX( 1, sqrt( time_done ) );
                        overflow = x264_clip3f( 1.0 + (predicted_bits - wanted_bits) / abr_buffer, .5, 2 );
                        q *= overflow;
                    }
                }
            }

            if( pict_type == SLICE_TYPE_I && h->param.i_keyint_max > 1
                /* should test _next_ pict type, but that isn't decided yet */
                && rcc->last_non_b_pict_type != SLICE_TYPE_I )
            {
                q = qp2qscale( rcc->accum_p_qp / rcc->accum_p_norm );
                q /= fabs( h->param.rc.f_ip_factor );
            }
            else if( h->i_frame > 0 )
            {
                if( h->param.rc.i_rc_method != X264_RC_CRF )
                {
                    /* Asymmetric clipping, because symmetric would prevent
                     * overflow control in areas of rapidly oscillating complexity */
                    double lmin = rcc->last_qscale_for[pict_type] / rcc->lstep;
                    double lmax = rcc->last_qscale_for[pict_type] * rcc->lstep;
                    if( overflow > 1.1 && h->i_frame > 3 )
                        lmax *= rcc->lstep;
                    else if( overflow < 0.9 )
                        lmin /= rcc->lstep;

                    q = x264_clip3f(q, lmin, lmax);
                }
            }
            else if( h->param.rc.i_rc_method == X264_RC_CRF && rcc->qcompress != 1 )
            {
                q = qp2qscale( ABR_INIT_QP ) / fabs( h->param.rc.f_ip_factor );
            }
            rcc->qp_novbv = qscale2qp( q );

            //FIXME use get_diff_limited_q() ?
            q = clip_qscale( h, pict_type, q );
        }

        rcc->last_qscale_for[pict_type] =
        rcc->last_qscale = q;

        if( !(rcc->b_2pass && !rcc->b_vbv) && h->fenc->i_frame == 0 )
            rcc->last_qscale_for[SLICE_TYPE_P] = q * fabs( h->param.rc.f_ip_factor );

        if( rcc->b_2pass )
            rcc->frame_size_planned = qscale2bits( &rce, q );
        else
            rcc->frame_size_planned = predict_size( &rcc->pred[h->sh.i_type], q, rcc->last_satd );

        /* Always use up the whole VBV in this case. */
        if( rcc->single_frame_vbv )
            rcc->frame_size_planned = rcc->buffer_rate;
        /* Limit planned size by MinCR */
        if( rcc->b_vbv )
            rcc->frame_size_planned = X264_MIN( rcc->frame_size_planned, rcc->frame_size_maximum );
        h->rc->frame_size_estimated = rcc->frame_size_planned;
        return q;
    }
}

在编码一帧之前被调用，会为这帧选取QP

/* Before encoding a frame, choose a QP for it */
void x264_ratecontrol_start( x264_t *h, int i_force_qp, int overhead )
{
    x264_ratecontrol_t *rc = h->rc;
    ratecontrol_entry_t *rce = NULL;
    x264_zone_t *zone = get_zone( h, h->fenc->i_frame );
    float q;

    x264_emms();

    if( h->param.rc.b_stat_read )
    {
        int frame = h->fenc->i_frame;
        assert( frame >= 0 && frame < rc->num_entries );
        rce = h->rc->rce = &h->rc->entry[frame];

        if( h->sh.i_type == SLICE_TYPE_B
            && h->param.analyse.i_direct_mv_pred == X264_DIRECT_PRED_AUTO )
        {
            h->sh.b_direct_spatial_mv_pred = ( rce->direct_mode == 's' );
            h->mb.b_direct_auto_read = ( rce->direct_mode == 's' || rce->direct_mode == 't' );
        }
    }

    if( rc->b_vbv )
    {
        memset( h->fdec->i_row_bits, 0, h->mb.i_mb_height * sizeof(int) );
        memset( h->fdec->f_row_qp, 0, h->mb.i_mb_height * sizeof(float) );
        memset( h->fdec->f_row_qscale, 0, h->mb.i_mb_height * sizeof(float) );
        rc->row_pred = rc->row_preds[h->sh.i_type];
        rc->buffer_rate = h->fenc->i_cpb_duration * rc->vbv_max_rate * h->sps->vui.i_num_units_in_tick / h->sps->vui.i_time_scale;
        update_vbv_plan( h, overhead );

        const x264_level_t *l = x264_levels;
        while( l->level_idc != 0 && l->level_idc != h->param.i_level_idc )
            l++;

        int mincr = l->mincr;

        if( h->param.b_bluray_compat )
            mincr = 4;

        /* Profiles above High don't require minCR, so just set the maximum to a large value. */
        if( h->sps->i_profile_idc > PROFILE_HIGH )
            rc->frame_size_maximum = 1e9;
        else
        {
            /* The spec has a bizarre special case for the first frame. */
            if( h->i_frame == 0 )
            {
                //384 * ( Max( PicSizeInMbs, fR * MaxMBPS ) + MaxMBPS * ( tr( 0 ) - tr,n( 0 ) ) ) / MinCR
                double fr = 1. / 172;
                int pic_size_in_mbs = h->mb.i_mb_width * h->mb.i_mb_height;
                rc->frame_size_maximum = 384 * BIT_DEPTH * X264_MAX( pic_size_in_mbs, fr*l->mbps ) / mincr;
            }
            else
            {
                //384 * MaxMBPS * ( tr( n ) - tr( n - 1 ) ) / MinCR
                rc->frame_size_maximum = 384 * BIT_DEPTH * ((double)h->fenc->i_cpb_duration * h->sps->vui.i_num_units_in_tick / h->sps->vui.i_time_scale) * l->mbps / mincr;
            }
        }
    }

    if( h->sh.i_type != SLICE_TYPE_B )
        rc->bframes = h->fenc->i_bframes;

    if( rc->b_abr )
    {
        q = qscale2qp( rate_estimate_qscale( h ) );
    }
    else if( rc->b_2pass )
    {
        rce->new_qscale = rate_estimate_qscale( h );
        q = qscale2qp( rce->new_qscale );
    }
    else /* CQP */
    {
        if( h->sh.i_type == SLICE_TYPE_B && h->fdec->b_kept_as_ref )
            q = ( rc->qp_constant[ SLICE_TYPE_B ] + rc->qp_constant[ SLICE_TYPE_P ] ) / 2;
        else
            q = rc->qp_constant[ h->sh.i_type ];

        if( zone )
        {
            if( zone->b_force_qp )
                q += zone->i_qp - rc->qp_constant[SLICE_TYPE_P];
            else
                q -= 6*log2f( zone->f_bitrate_factor );
        }
    }
    if( i_force_qp != X264_QP_AUTO )
        q = i_force_qp - 1;

    q = x264_clip3f( q, h->param.rc.i_qp_min, h->param.rc.i_qp_max );

    rc->qpa_rc = rc->qpa_rc_prev =
    rc->qpa_aq = rc->qpa_aq_prev = 0;
    h->fdec->f_qp_avg_rc =
    h->fdec->f_qp_avg_aq =
    rc->qpm = q;
    if( rce )
        rce->new_qp = q;

    accum_p_qp_update( h, rc->qpm );

    if( h->sh.i_type != SLICE_TYPE_B )
        rc->last_non_b_pict_type = h->sh.i_type;
}

x264_ratecontrol_slice_type

去博客设置页面，选择一款你喜欢的代码片高亮样式，下面展示同样高亮的 代码片.

// An highlighted block
var foo = 'bar';

x264_ratecontrol_set_weights

去博客设置页面，选择一款你喜欢的代码片高亮样式，下面展示同样高亮的 代码片.

// An highlighted block
var foo = 'bar';

x264_ratecontrol_mb

去博客设置页面，选择一款你喜欢的代码片高亮样式，下面展示同样高亮的 代码片.

// An highlighted block
var foo = 'bar';

x264_ratecontrol_qp

去博客设置页面，选择一款你喜欢的代码片高亮样式，下面展示同样高亮的 代码片.

int x264_ratecontrol_qp( x264_t *h )
{
    x264_emms();
    return x264_clip3( h->rc->qpm + 0.5f, h->param.rc.i_qp_min, h->param.rc.i_qp_max );
}

x264_ratecontrol_mb_qp

去博客设置页面，选择一款你喜欢的代码片高亮样式，下面展示同样高亮的 代码片.

int x264_ratecontrol_mb_qp( x264_t *h )
{
    x264_emms();
    float qp = h->rc->qpm;
    if( h->param.rc.i_aq_mode )
    {
         /* MB-tree currently doesn't adjust quantizers in unreferenced frames. */
        float qp_offset = h->fdec->b_kept_as_ref ? h->fenc->f_qp_offset[h->mb.i_mb_xy] : h->fenc->f_qp_offset_aq[h->mb.i_mb_xy];
        /* Scale AQ's effect towards zero in emergency mode. */
        if( qp > QP_MAX_SPEC )
            qp_offset *= (QP_MAX - qp) / (QP_MAX - QP_MAX_SPEC);
        qp += qp_offset;
    }
    return x264_clip3( qp + 0.5f, h->param.rc.i_qp_min, h->param.rc.i_qp_max );
}

x264_ratecontrol_end

去博客设置页面，选择一款你喜欢的代码片高亮样式，下面展示同样高亮的 代码片.

// An highlighted block
var foo = 'bar';

x264_ratecontrol_summary

去博客设置页面，选择一款你喜欢的代码片高亮样式，下面展示同样高亮的 代码片.

// An highlighted block
var foo = 'bar';

x264_ratecontrol_set_estimated_size

去博客设置页面，选择一款你喜欢的代码片高亮样式，下面展示同样高亮的 代码片.

// An highlighted block
var foo = 'bar';

x264_ratecontrol_get_estimated_size

去博客设置页面，选择一款你喜欢的代码片高亮样式，下面展示同样高亮的 代码片.

// An highlighted block
var foo = 'bar';

x264_rc_analyse_slice

去博客设置页面，选择一款你喜欢的代码片高亮样式，下面展示同样高亮的 代码片.

// An highlighted block
var foo = 'bar';

x264_threads_distribute_ratecontrol

去博客设置页面，选择一款你喜欢的代码片高亮样式，下面展示同样高亮的 代码片.

// An highlighted block
var foo = 'bar';

x264_threads_merge_ratecontrol

去博客设置页面，选择一款你喜欢的代码片高亮样式，下面展示同样高亮的 代码片.

// An highlighted block
var foo = 'bar';

x264_hrd_fullness

去博客设置页面，选择一款你喜欢的代码片高亮样式，下面展示同样高亮的 代码片.

// An highlighted block
var foo = 'bar';

x264_ratecontrol_reset_bitrate

去博客设置页面，选择一款你喜欢的代码片高亮样式，下面展示同样高亮的 代码片.

// An highlighted block
var foo = 'bar';

rc_add_frame_size

去博客设置页面，选择一款你喜欢的代码片高亮样式，下面展示同样高亮的 代码片.

// An highlighted block
var foo = 'bar';
你过来呀~_~
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
X264码率控制：ABR模式
小小柴的博客
04-30 1528
因为ABR模式在控制过程中会产生较大的码率波动，进而导致图像质量不稳定，同时在Http Adaptive Streaming中，也会导致视频segment大小不稳定，在接收端产生卡顿。所以ABR模式一般配合vbv使用，使用vbv buffer来限制码率的波动。 ABR模式的流程图如下: ABR会在帧级、行级和宏块级去调整qscale(QP)。帧级和行级调整的目的主要有两个：1，总码率逼近目标码...
x264中码率控制（一）
yihuanyihuan的博客
03-20 544
x264码率控制方法：采用的码率控制算法并没有采用拉格朗日代价函数来控制编码，而是使用一种更简单的方法，即利用半精度帧的SATD(sum of absolute transformeddifference)作为模式选择的依据。SATD即将残差经哈德曼变换的4×4块的预测残差绝对值总和，可以将其看作简单的时频变换，其值在一定程度上可以反映生成码流的大小。SATD是将残差经哈达曼变换4*4块的预测残差...
码控-x264_ratecontrol_mb_qp()
workspace
03-12 591
/* 得到当前待编码宏块的qp 过程: 1.取之前帧级码控决定的qp 2.计算当前宏块的qp,若使用adaptive qp ·若是参考帧，则 宏块qp = 帧级qp + qp_offset[mb_index] ·若非参考帧，则 宏块qp = 帧级qp + qp_offset_aq[mb_index] 3.clip宏块级qp */ int x264_ratecontro...
x264源码分析--函数x264_rc_analyse_slice
fantasy_ARM9的博客
04-28 665
x264_rc_analyse_slice 函数的功能是分析当前要编码的slice，并计算得到cost。大体流程，先从编码缓存fenc中找到当前要编码的编码帧。然后计算cost，这种计算cost来控制码控的方法是用于B帧和2pass模式的。下面具体看代码：int x264_rc_analyse_slice( x264_t *h )//分析一个slice,在B帧和2pass的时候计算残差{    i...
x264码率控制（一）
fantasy_ARM9的博客
05-07 830
本文讲解一下x264大体的码率控制流程 码率控制分为帧级别的码率控制和宏块级别的。 帧级别的码率控制代码逻辑流程： x264_encoder_encode()-> x264_ratecontrol_start()--> rate_estimate_qscale() //传入帧的时候，先做一次帧级别的码率调控 /*根据帧复杂度，计算一个初步...
x264详尽编码过程解析
07-27
《深入剖析x264编码过程》 x264是一种高效的H.264/AVC视频编码库，广泛应用于视频编码、流媒体...在实际开发中，针对特定场景进行针对性优化，如码率控制策略调整、预处理算法改进等，都是提升x264性能的重要途径。
X264源代码
09-08
6. **速率控制**：X264具有智能的码率控制算法，可以根据目标比特率自动调整编码参数，确保视频质量和文件大小的平衡。 深入学习X264源代码，不仅有助于理解H.264编码的复杂性，还能为开发者提供优化视频编码的思路...
基于hi3531、x264的h264压缩
12-05
《基于hi3531与x264的H264压缩技术解析》 H264，全称为High Efficiency Video Coding（高效视频编码），是目前广泛应用的视频压缩标准，广泛应用于网络视频流传输、高清电视等领域。本文将深入探讨基于hi3531芯片与...
vs2010编译的x264库：x264-161（2021-最新版）
05-12
此外，x264库还提供了丰富的编码参数调整选项，如码率控制、质量控制、帧率转换等，允许开发者根据实际需求优化编码过程。例如，通过设置`x264_param_t`结构体的参数，可以调整编码器的行为，以达到最佳的性能和质量...
X264转换后的.264文件
11-23
在分析和处理这些.264文件时，开发者和研究人员通常会关注编码效率、视频质量、码率控制以及解码性能等因素。通过比较不同编码参数和编码后的文件大小，可以优化编码设置以满足特定应用的需求。同时，对于测试和调试...
X264代码走读一（ABR算法码控）
CrystalShaw的博客
04-12 2971
一、码控简介 x264码率控制主要分为单次编码（1pass）和多次编码（2pass）两大类，其中单次编码主要分如下三种： CRF(constant Rate Factor)：恒定质量编码(运动/纹理复杂场景，码率上升；静态/纹理简单的画面，码率下降) CQP(constant quantization parameter)：固定的量化参数，随着视频运动情况,码率会上升和下降。但是码率不可控，...
x264编码参数动态调整
小金牛来了
11-01 356
x264动态参数调整
x264-码控
workspace
03-14 915
x264提供三级码控基本单位：帧级，行级，宏块级 帧级 定位：帧类型决策之后，帧实际编码之前 主控函数：x264_ratecontrol_start() 关键函数1：rate_estimate_qscale() 用于根据当前实际使用的比特开销来确定当前帧的qscale 关键函数2：clip_qscale() 用于对得到的qscale进行clip，并进行vbv检验 辅助函数1：qp2qscale()...
x264 码率控制：ABR模式
zhoudegui88的博客
07-21 5559
前段时间看了一下x264 码率控制部分，在这里简要分析一下x264的ABR模式相关代码，有不对的地方欢迎指正。 因为ABR模式在控制过程中会产生较大的码率波动，进而导致图像质量不稳定，同时在Http Adaptive Streaming中，也会导致视频segment大小不稳定，在接收端产生卡顿。所以ABR模式一般配合vbv使用，使用vbv buffer来限制码率的波动。 ABR模式的流程图如下...
x264源代码简单分析：x264_slice_write()
热门推荐
雷霄骅(leixiaohua1020)的专栏
05-17 1万+
本文简单分析x264的x264_slice_write()的源代码。x264_slice_write()是x264项目的核心，它完成了编码了一个Slice的工作。根据功能的不同，该函数可以分为滤波（Filter），分析（Analysis），宏块编码（Encode）和熵编码（Entropy Encoding）几个子模块。本文首先对x264_slice_write()进行总体的概括，在后续文章中将会对上述几个子模块展开进行分析。
x264中的码率控制算法
智眸之音
01-21 865
1. 码率控制的选择策略：�率失真优化模型 RDO: rate-distortion optimization率失真优化 限定码率值Rc，选择合适的编码模式，使得失真D最小。 编码模式包括量化步长、宏块模式选择、帧内/帧间预测模式选择等。 码率控制的RDO模型的目标是确定每帧或每个宏块合适的量化步长。 1.1 Lagrangian RDO H.264标准使用了一种基于Lagrangia...
x264码率控制总结3——码率控制参数详解
huibailingyu的专栏
02-12 8499
x264码率控制参数详解   -q, --qp           Force constant QP (0-51, 0=lossless) 默认：无 说明：三种可选的码率控制方法(bitrate, CQP，CRF)之一。设置x264使用固定QP模式。设定的QP将被作为P帧的量化参数，I帧和B帧的量化参数由–ipratio and –pbratio参数进一步算出。CQP模式使用固定的QP
x264源码分析--函数x264_encoder_encode
fantasy_ARM9的博客
04-28 675
x264_encoder_encode 这个函数是ffmpeg调用x264的接口，传入的是数据帧，函数实现编码最终调用x264_slices_write/**************************************************************************** * x264_encoder_encode: *  XXX: i_poc   : is th...
x264 - x264_slicetype_frame_cost
fanbird2008的专栏
06-20 1394
static int x264_slicetype_frame_cost( x264_t *h, x264_mb_analysis_t *a,                                       x264_frame_t **frames, int p0, int p1, int b,                                       int
openh264码率控制
最新发布
08-08
openh264提供了几种不同的码率控制模式。其中包括质量模式（RC_QUALITY_MODE）、比特率模式（RC_BITRATE_MODE）、基于缓冲区的模式（RC_BUFFERBASED_MODE）、基于时间戳的模式（RC_TIMESTAMP_MODE）和关闭模式（RC_...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值