帧类型决策-x264_slicetype_analyse()

于 2020-02-20 21:38:30 发布
阅读量855 收藏 6
点赞数 5
分类专栏： X264
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lj501886285/article/details/104418628
版权 
/*
	对lookahead队列中的帧分析，确定他们的帧类型

	过程：
		1.	若第一帧是AUTO/I，检查其相对于上一个非B帧是否场景切换，若场景切换则将当前帧设置为I，return
		2.	遍历，将所有的关键帧根据openGOP设置成I/IDR
		3.	将所有IDR帧前的AUTO/B帧改为P帧
		4.	若允许使用B帧
			·	使用X264_B_ADAPT_TRELLIS方法自适应设置B帧
			·	使用X264_B_ADAPT_FAST方法自适应设置B帧
			·	不自适应设置B帧
			若不允许使用B帧，则将全部的AUTO/B设置成P
		5.	将最后一帧AUTO/B帧改为P帧
		6.	若允许宏块树分析则进行宏块树分析
		7.	根据关键帧之间的距离限制检查帧类型
		8.	若允许vbv则进行vbv检查
*/
void x264_slicetype_analyse( x264_t *h, int intra_minigop )
{
    x264_mb_analysis_t a;
    x264_frame_t *frames[X264_LOOKAHEAD_MAX+3] = { NULL, };
    int num_frames, orig_num_frames, keyint_limit, framecnt;
    int i_max_search = X264_MIN( h->lookahead->next.i_size, X264_LOOKAHEAD_MAX );
    int b_vbv_lookahead = h->param.rc.i_vbv_buffer_size && h->param.rc.i_lookahead;
    /* For determinism we should limit the search to the number of frames lookahead has for sure
     * in h->lookahead->next.list buffer, except at the end of stream.
     * For normal calls with (intra_minigop == 0) that is h->lookahead->i_slicetype_length + 1 frames.
     * And for I-frame calls (intra_minigop != 0) we already removed intra_minigop frames from there. */
    if( h->param.b_deterministic )
        i_max_search = X264_MIN( i_max_search, h->lookahead->i_slicetype_length + 1 - intra_minigop );
    int keyframe = !!intra_minigop;

    assert( h->frames.b_have_lowres );

    if( !h->lookahead->last_nonb )	//若前面没有非B帧，则return
        return;

	//frame[0]存储前面最近的非B帧，frame[1~i_max_search]存储要分析的帧
    frames[0] = h->lookahead->last_nonb;	//取最近的非B帧为frame0
    for( framecnt = 0; framecnt < i_max_search; framecnt++ )	//从list中拷贝到frames中
        frames[framecnt+1] = h->lookahead->next.list[framecnt];

	//低分辨率上下文初始化
    lowres_context_init( h, &a );

    if( !framecnt )	//若framecnt = 0，即i_max_search = 0，则无帧分析，return
    {
        if( h->param.rc.b_mb_tree )
            macroblock_tree( h, &a, frames, 0, keyframe );
        return;
    }

	//计算keyint_limit = 最大关键帧距离 - 最近的非B帧 + 最近一个关键帧 - 1
    keyint_limit = h->param.i_keyint_max - frames[0]->i_frame + h->lookahead->i_last_keyframe - 1;

	//计算orig_num_frames和num_frames
    orig_num_frames = num_frames = h->param.b_intra_refresh ? framecnt : X264_MIN( framecnt, keyint_limit );

    /* This is important psy-wise: if we have a non-scenecut keyframe,
     * there will be significant visual artifacts if the frames just before
     * go down in quality due to being referenced less, despite it being
     * more RD-optimal. 
	 * 如果我们有一个非场景切换的关键帧，将会有一个明显的视觉影响
	 */
    if( (h->param.analyse.b_psy && h->param.rc.b_mb_tree) || b_vbv_lookahead )
        num_frames = framecnt;
    else if( h->param.b_open_gop && num_frames < framecnt )
        num_frames++;
    else if( num_frames == 0 )
    {
        frames[1]->i_type = X264_TYPE_I;
        return;
    }

    if( IS_X264_TYPE_AUTO_OR_I( frames[1]->i_type ) &&
        h->param.i_scenecut_threshold && scenecut( h, &a, frames, 0, 1, 1, orig_num_frames, i_max_search ) )
    {	//若是第一帧是auto/I 且 相对于上一个非B帧有场景切换，则设置为I帧
        if( frames[1]->i_type == X264_TYPE_AUTO )	
            frames[1]->i_type = X264_TYPE_I;	//当前帧定为I帧
        return;
    }

    /* Replace forced keyframes with I/IDR-frames */
    for( int j = 1; j <= num_frames; j++ )
    {	遍历检查是否关键帧，依openGOP设定为I/IDR
        if( frames[j]->i_type == X264_TYPE_KEYFRAME )
            frames[j]->i_type = h->param.b_open_gop ? X264_TYPE_I : X264_TYPE_IDR;
    }

    /* Close GOP at IDR-frames */
    for( int j = 2; j <= num_frames; j++ )
    {	//遍历检查IDR帧，将IDR帧前的AUTO/B帧设置为P帧
        if( frames[j]->i_type == X264_TYPE_IDR && IS_X264_TYPE_AUTO_OR_B( frames[j-1]->i_type ) )
            frames[j-1]->i_type = X264_TYPE_P;
    }

    int num_analysed_frames = num_frames;
    int reset_start;

    if( h->param.i_bframe )	//若允许B帧
    {
		/*	根据i_bframe_adaptive来进行自适应B帧设置
			i_bframe_adaptive = X264_B_ADAPT_TRELLIS	使用最佳判别方法，即viterbi
			i_bframe_adaptive = X264_B_ADAPT_FAST		使用快速判别方法
			i_bframe_adaptive = X264_B_ADAPT_NONE		不使用自适应B帧	*/
        if( h->param.i_bframe_adaptive == X264_B_ADAPT_TRELLIS )//b_adaptive=2，使用最佳算法，即viterbi
        {
            if( num_frames > 1 )
            {
				//初始化最优帧类型路径 和 路径索引
                char best_paths[X264_BFRAME_MAX+1][X264_LOOKAHEAD_MAX+1] = {"","P"};
                int best_path_index = num_frames % (X264_BFRAME_MAX+1);

                /* Perform the frametype analysis. */
                for( int j = 2; j <= num_frames; j++ )
					//执行viterbi计算最优帧类型路径，将最优帧类型路径写入best_paths
                    slicetype_path( h, &a, frames, j, best_paths );

                /* Load the results of the analysis into the frame types. */
				//根据分析的最优帧类型路径设置各个帧
                for( int j = 1; j < num_frames; j++ )
                {
                    if( best_paths[best_path_index][j-1] != 'B' )
                    {	//若是'P'则将AUTO/B该成P
                        if( IS_X264_TYPE_AUTO_OR_B( frames[j]->i_type ) )
                            frames[j]->i_type = X264_TYPE_P;
                    }
                    else
                    {	//若是'B'则将AUTO改成B
                        if( frames[j]->i_type == X264_TYPE_AUTO )
                            frames[j]->i_type = X264_TYPE_B;
                    }
                }
            }
        }	//end of b_adaptive = X264_B_ADAPT_TRELLIS

        else if( h->param.i_bframe_adaptive == X264_B_ADAPT_FAST )	//b_adaptive=1，快速决定
        {
            int last_nonb = 0;
            int num_bframes = h->param.i_bframe;	//得到两个参考帧中最多所允许的B帧数量
            char path[X264_LOOKAHEAD_MAX+1];
            for( int j = 1; j < num_frames; j++ )	//遍历list里的每一帧，除了最后一帧
            {
				/*
					针对前一帧来更新 B坑数num_bframes 和 最近非B帧last_nonb
				*/
                if( j-1 > 0 && IS_X264_TYPE_B( frames[j-1]->i_type ) )	//若前一帧为B帧
                    num_bframes--;	//则占一个B帧的坑
                else	//若前一帧为非B帧
                {
                    last_nonb = j-1;	//更新最近非B帧为前一帧
                    num_bframes = h->param.i_bframe;	//这重置B帧的坑数了
                }

				/*
					设置当前帧的帧类型
				*/
                if( !num_bframes )	//若B帧坑占满了，且当前帧B/auto则改P，其余不变
                {
                    if( IS_X264_TYPE_AUTO_OR_B( frames[j]->i_type ) )
                        frames[j]->i_type = X264_TYPE_P;
                    continue;
                }
				// else	允许到这里的帧允许使用B帧 （还有B坑）
                if( frames[j]->i_type != X264_TYPE_AUTO )	//若已经有类型了，则下一个
                    continue;
				// else	运行到这里的帧全是AUTO帧
                if( IS_X264_TYPE_B( frames[j+1]->i_type ) )	//若后面一帧为B帧
                {
                    frames[j]->i_type = X264_TYPE_P;	//当前帧改P，为什么？？
                    continue;
                }
				/* else	运行到这里的帧后面一帧一定是P帧，不可能是I帧，
				   因为之前将所有I帧的前一帧设置成P帧，即只可能PI，不可能BI;  */

                int bframes = j - last_nonb - 1;	//得到上一个非B帧到最后一帧之间的B帧数量bframes
                memset( path, 'B', bframes );		//在path中填充bframes个B

				//	将当前帧设置为P帧，计算BBB...BBB(P)P帧类型路径的开销
                strcpy( path+bframes, "PP" );
                uint64_t cost_p = slicetype_path_cost( h, &a, frames+last_nonb, path, COST_MAX64 );

				//	将当前帧设置为B帧，计算BBB...BBB(B)P帧类型路径的开销
                strcpy( path+bframes, "BP" );		
                uint64_t cost_b = slicetype_path_cost( h, &a, frames+last_nonb, path, cost_p );

				//选择开销最小的，定当前帧的帧类型
                if( cost_b < cost_p )
                    frames[j]->i_type = X264_TYPE_B;
                else
                    frames[j]->i_type = X264_TYPE_P;
            }
        }	//end of b_adaptive = X264_B_ADAPT_FAST

        else	//b_adaptive=0,即不适用自适应B帧
        {
            int num_bframes = h->param.i_bframe;
            for( int j = 1; j < num_frames; j++ )
            {
                if( !num_bframes )	//没有B帧坑位了
                {
                    if( IS_X264_TYPE_AUTO_OR_B( frames[j]->i_type ) )
                        frames[j]->i_type = X264_TYPE_P;	//设置为P
                }
                else if( frames[j]->i_type == X264_TYPE_AUTO )	//有B帧坑位
                {
                    if( IS_X264_TYPE_B( frames[j+1]->i_type ) )	//后面是B则当前设P，同样为什么？
                        frames[j]->i_type = X264_TYPE_P;
                    else										//后面是P则当前设B
                        frames[j]->i_type = X264_TYPE_B;
                }

				//更新坑位
                if( IS_X264_TYPE_B( frames[j]->i_type ) )	//B帧
                    num_bframes--;							//占一个坑位
                else
                    num_bframes = h->param.i_bframe;		//更新坑位
            }
        }	//end of b_adaptive = X264_B_ADAPT_NONE		自适应B帧判别结束

        if( IS_X264_TYPE_AUTO_OR_B( frames[num_frames]->i_type ) )	//如果最后一帧是B，则改P
            frames[num_frames]->i_type = X264_TYPE_P;

		//从第1帧开始统计连续的B帧数量
        int num_bframes = 0;
        while( num_bframes < num_frames && IS_X264_TYPE_B( frames[num_bframes+1]->i_type ) )
            num_bframes++;

        /* Check scenecut on the first minigop. */
        for( int j = 1; j < num_bframes+1; j++ )	//遍历连续的B帧
        {
            if( frames[j]->i_forced_type == X264_TYPE_AUTO && IS_X264_TYPE_AUTO_OR_I( frames[j+1]->i_forced_type ) &&
                h->param.i_scenecut_threshold && scenecut( h, &a, frames, j, j+1, 0, orig_num_frames, i_max_search ) )
            {	//若后一帧是相对当前帧是场景切换，则当前帧设置为P帧
                frames[j]->i_type = X264_TYPE_P;
                num_analysed_frames = j;
                break;
            }
        }

        reset_start = keyframe ? 1 : X264_MIN( num_bframes+2, num_analysed_frames+1 );
    }
    else		//不允许B帧
    {
        for( int j = 1; j <= num_frames; j++ )
            if( IS_X264_TYPE_AUTO_OR_B( frames[j]->i_type ) )	//所有AUTO/B帧全改P
                frames[j]->i_type = X264_TYPE_P;
        reset_start = !keyframe + 1;
    }

    /* Perform the actual macroblock tree analysis.
     * Don't go farther than the maximum keyframe interval; this helps in short GOPs. */
    if( h->param.rc.b_mb_tree )	//使用mb tree
        macroblock_tree( h, &a, frames, X264_MIN(num_frames, h->param.i_keyint_max), keyframe );

    /* Enforce keyframe limit.	进行关键帧限制 */
    if( !h->param.b_intra_refresh )	//是否用定期的帧内刷新来替代IDR
    {
        int last_keyframe = h->lookahead->i_last_keyframe;	//取最近一个关键帧
        int last_possible = 0;
        for( int j = 1; j <= num_frames; j++ )	//遍历所有帧
        {
            x264_frame_t *frm = frames[j];
            int keyframe_dist = frm->i_frame - last_keyframe;	//计算距离上一个关键帧的距离

            if( IS_X264_TYPE_AUTO_OR_I( frm->i_forced_type ) )	//若i_forced_type是I或auto
            {
                if( h->param.b_open_gop || !IS_X264_TYPE_B( frames[j-1]->i_forced_type ) )//openGOP || 前一帧非B
                    last_possible = j;
            }
            if( keyframe_dist >= h->param.i_keyint_max )
            {	//若当前帧距离上一关键帧的距离 >= 最大关键帧间距离，则依据openGOP设置当前帧为I/IDR
                if( last_possible != 0 && last_possible != j )
                {
                    j = last_possible;
                    frm = frames[j];
                    keyframe_dist = frm->i_frame - last_keyframe;
                }
                last_possible = 0;
                if( frm->i_type != X264_TYPE_IDR )	//非IDR，根据openGOP设置I/IDR
                    frm->i_type = h->param.b_open_gop ? X264_TYPE_I : X264_TYPE_IDR;
            }
            if( frm->i_type == X264_TYPE_I && keyframe_dist >= h->param.i_keyint_min )
            {	//若是I帧 && 当前帧距离上一关键帧的距离 >= 最小关键帧间距离
                if( h->param.b_open_gop )	//openGOP
                {
                    last_keyframe = frm->i_frame;	//更新当前帧为上一关键帧
                    if( h->param.b_bluray_compat )
                    {
                        // Use bluray order
                        int bframes = 0;
                        while( bframes < j-1 && IS_X264_TYPE_B( frames[j-1-bframes]->i_type ) )
                            bframes++;
                        last_keyframe -= bframes;
                    }
                }
                else if( frm->i_forced_type != X264_TYPE_I )//非openGOP，且i_forced_type不是I帧，则设置为IDR
                    frm->i_type = X264_TYPE_IDR;
            }
            if( frm->i_type == X264_TYPE_IDR )	//若是IDR
            {
                last_keyframe = frm->i_frame;	//更新 最近关键帧
                if( j > 1 && IS_X264_TYPE_B( frames[j-1]->i_type ) )	//若前一帧是B
                    frames[j-1]->i_type = X264_TYPE_P;	//改为P
            }
        }
    }

    if( b_vbv_lookahead )	//若允许vbv，则进行vbv
        vbv_lookahead( h, &a, frames, num_frames, keyframe );

    /* Restore frametypes for all frames that haven't actually been decided yet. */
	//将需要重新设置帧类型的帧全部重置
    for( int j = reset_start; j <= num_frames; j++ )
        frames[j]->i_type = frames[j]->i_forced_type;
}
其中使用自适应B帧 X264_B_ADAPT_TRELLIS方法部分：
/* Viterbi/trellis slicetype decision algorithm. */
/* Uses strings due to the fact that the speed of the control functions is
   negligible compared to the cost of running slicetype_frame_cost, and because
   it makes debugging easier. 
   
   使用viterbi算法来确定frames[1~length]的最优帧类型路径
   将结果存放在best_paths[length % (X264_BFRAME_MAX+1)]中，以字符I/P/B表示
   */
static void slicetype_path( x264_t *h, x264_mb_analysis_t *a, x264_frame_t **frames, int length, char (*best_paths)[X264_LOOKAHEAD_MAX+1] )
{
    char paths[2][X264_LOOKAHEAD_MAX+1];

	//分析的路径数量最多i_bframe+1个，即最多向前分析到BBB...BBBP，length表示需要1~length帧，取两者最小值
    int num_paths = X264_MIN( h->param.i_bframe+1, length );
    
	uint64_t best_cost = COST_MAX64;	//初始化best_cost为MAX

    int best_possible = 0;
    int idx = 0;

    /* Iterate over all currently possible paths */
    for( int path = 0; path < num_paths; path++ )	//遍历每条路径
    {
        /* Add suffixes to the current path 构造路径 
		 * 结构：
		 *			  |			   length		   |
		 *		即    (	  best-path   ,B  ... B, P )
		 *		      |     len个     | path个 |1个|
		 * path range:
		 *			  |   len个                |1个|	path = 0
		 *			  |   len个            |1个|1个|		path = 1
		 *			  |   len个           | 2个|1个|		path = 2
		 *			  |   len个          | 3个 |1个|		path = 3
		 *							...						...
		 *			  |   len个  | num_paths个 |1个|		path = num_paths */
        int len = length - (path + 1);
        memcpy( paths[idx], best_paths[len % (X264_BFRAME_MAX+1)], len );//拷贝之前已经计算好的最优路径
        memset( paths[idx]+len, 'B', path );	//再到后面添加path个'B'
        strcpy( paths[idx]+len+path, "P" );		//最后一帧改成P帧

        int possible = 1;
        for( int i = 1; i <= length; i++ )	//遍历待确定类型的每一帧，来修改path
        {
            int i_type = frames[i]->i_type;
            if( i_type == X264_TYPE_AUTO )	//若auto则不改path
                continue;
            if( IS_X264_TYPE_B( i_type ) )	//若是B帧
				//该帧在已确定的最优路径内 || 该帧为待分析的最后一帧 || 该帧在路径中标识为B
                possible = possible && (i < len || i == length || paths[idx][i-1] == 'B');
            else	//若非B则改path
            {	
				//该帧在已确定的最优路径内 || 该帧在路径中标识为非B
                possible = possible && (i < len || paths[idx][i-1] != 'B');
                paths[idx][i-1] = IS_X264_TYPE_I( i_type ) ? 'I' : 'P';	//根据帧类型修改路径中的标识
            }
        }

        if( possible || !best_possible )	//possible和best_possible什么意思？？？
        {
            if( possible && !best_possible ) 
                best_cost = COST_MAX64;

            /* Calculate the actual cost of the current path 计算当前路径paths[idx]的开销*/
            uint64_t cost = slicetype_path_cost( h, a, frames, paths[idx], best_cost );

            if( cost < best_cost )	//更新best，且切换paths idx
            {
                best_cost = cost;
                best_possible = possible;
                idx ^= 1;
            }
        }
    }	//end of for( int path = 0; path < num_paths; path++ )

    /* Store the best path. 存储最优路径*/
    memcpy( best_paths[length % (X264_BFRAME_MAX+1)], paths[idx^1], length );
}
其中使用自适应B帧 X264_B_ADAPT_FAST方法部分：
/*
	过程：
		1.	根据前一帧的帧类型来更新B帧的坑位以及最近的非B帧
		2.	若B帧没坑位，则将AUTO/B改P，则continue
		3.	若已经确定了帧类型，即非AUTO，则continue
		4.	若后面一帧是B帧，设置当前帧为P帧
			若后面一帧是P帧，计算当前帧为B帧时和P帧时的帧类型路径开销，选开销小的作为当前帧类型
*/
if( h->param.i_bframe_adaptive == X264_B_ADAPT_FAST )	//b_adaptive=1，快速决定
        {
            int last_nonb = 0;
            int num_bframes = h->param.i_bframe;	//得到两个参考帧中最多所允许的B帧数量
            char path[X264_LOOKAHEAD_MAX+1];
            for( int j = 1; j < num_frames; j++ )	//遍历list里的每一帧，除了最后一帧
            {
				/*
					针对前一帧来更新 B坑数num_bframes 和 最近非B帧last_nonb
				*/
                if( j-1 > 0 && IS_X264_TYPE_B( frames[j-1]->i_type ) )	//若前一帧为B帧
                    num_bframes--;	//则占一个B帧的坑
                else	//若前一帧为非B帧
                {
                    last_nonb = j-1;	//更新最近非B帧为前一帧
                    num_bframes = h->param.i_bframe;	//这重置B帧的坑数了
                }

				/*
					设置当前帧的帧类型
				*/
                if( !num_bframes )	//若B帧坑占满了，且当前帧B/auto则改P，其余不变
                {
                    if( IS_X264_TYPE_AUTO_OR_B( frames[j]->i_type ) )
                        frames[j]->i_type = X264_TYPE_P;
                    continue;
                }
				// else	允许到这里的帧允许使用B帧 （还有B坑）
                if( frames[j]->i_type != X264_TYPE_AUTO )	//若已经有类型了，则下一个
                    continue;
				// else	运行到这里的帧全是AUTO帧
                if( IS_X264_TYPE_B( frames[j+1]->i_type ) )	//若后面一帧为B帧
                {
                    frames[j]->i_type = X264_TYPE_P;	//当前帧改P，为什么？？
                    continue;
                }
				/* else	运行到这里的帧后面一帧一定是P帧，不可能是I帧，
				   因为之前将所有I帧的前一帧设置成P帧，即只可能PI，不可能BI;  */

                int bframes = j - last_nonb - 1;	//得到上一个非B帧到最后一帧之间的B帧数量bframes
                memset( path, 'B', bframes );		//在path中填充bframes个B

				//	将当前帧设置为P帧，计算BBB...BBB(P)P帧类型路径的开销
                strcpy( path+bframes, "PP" );
                uint64_t cost_p = slicetype_path_cost( h, &a, frames+last_nonb, path, COST_MAX64 );

				//	将当前帧设置为B帧，计算BBB...BBB(B)P帧类型路径的开销
                strcpy( path+bframes, "BP" );		
                uint64_t cost_b = slicetype_path_cost( h, &a, frames+last_nonb, path, cost_p );

				//选择开销最小的，定当前帧的帧类型
                if( cost_b < cost_p )
                    frames[j]->i_type = X264_TYPE_B;
                else
                    frames[j]->i_type = X264_TYPE_P;
            }
        }	//end of b_adaptive = X264_B_ADAPT_FAST
其中不使用自适应B帧（X264_B_ADAPT_NONE）部分：
/*
	过程：
		1.	若没有B帧的坑位了则将AUTO/B改P
		2.	若有B帧坑位，则
			·	后面一帧为B，当前设P
			·	后面一帧为P，当前设B
		3.	更新B帧的坑位
*/
else	//b_adaptive=0,即不使用自适应B帧
        {
            int num_bframes = h->param.i_bframe;
            for( int j = 1; j < num_frames; j++ )
            {
                if( !num_bframes )	//没有B帧坑位了
                {
                    if( IS_X264_TYPE_AUTO_OR_B( frames[j]->i_type ) )
                        frames[j]->i_type = X264_TYPE_P;	//设置为P
                }
                else if( frames[j]->i_type == X264_TYPE_AUTO )	//有B帧坑位
                {
                    if( IS_X264_TYPE_B( frames[j+1]->i_type ) )	//后面是B则当前设P，同样为什么？
                        frames[j]->i_type = X264_TYPE_P;
                    else										//后面是P则当前设B
                        frames[j]->i_type = X264_TYPE_B;
                }

				//更新B帧的坑位
                if( IS_X264_TYPE_B( frames[j]->i_type ) )	//B帧
                    num_bframes--;							//占一个坑位
                else
                    num_bframes = h->param.i_bframe;		//更新坑位
            }
        }	//end of b_adaptive = X264_B_ADAPT_NONE
JahnLiang
关注
  • 5
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
x264 帧类型决策模块x264_lookahead_get_frames函数详细分析
小金牛来了
05-09 72
x264 片类型决策模块x264_lookahead_get_frames函数详细分析
帧类型决策-x264_slicetype_decide()
workspace
02-24 971
/* lookahead队列中的帧类型确定 过程： 1.计算每一帧的时长duration 2.对lookahead里的每一帧进行帧类型分析 ·x264_ratecontrol_slice_type() ·x264_slicetpye_analyse() 3.对一段BBB...BBB(IDR/I/P) 1.检查BREF是否合规 2.检查Keyframe，设置...
x264_slicetype_analyse函数
weixin_42448721的博客
02-09 346
x264_slicetype_decide函数（代码所在位置为“x264-snapshot-20171128-2245-stable\encoder\slicetype.c”）的主要作用为：真正用于分析帧类型（I\P\B帧） 调用顺序如下： x264_encoder_encode —> x264_lookahead_get_frames —> x264_slicetype_decide...
x264 x264_slicetype_analyse 函数分析
weixin_34309543的博客
05-01 148
2019独角兽企业重金招聘Python工程师标准>>> ...
x264 slicetype选择
fantasy_ARM9的博客
05-13 397
x264 如何判断当前帧要不要编码出IDR x264_slicetype_analyse()->scenecut() 判断场景是否切换了，这种是opengop的方式， 还有一种是固定gop的方式，gop之间的帧数是固定的，不是由scenecut决定的。 看下scenecut函数实现 static int scenecut_internal( x264_t *h, x264_mb_...
U-Boot_Makefile-analyse.zip_uboot
09-24
《深入剖析U-Boot Makefile编译机制》 在嵌入式系统开发中，U-Boot作为一款广泛应用的引导加载程序，其构建过程至关重要。本文将深入探讨U-Boot的Makefile，解析其背后的编译逻辑，帮助读者理解并掌握U-Boot的构建...
GPS_Analyse.zip_GPS解析函数_gps analyse
09-15
标题中的“GPS_Analyse.zip_GPS解析函数_gps analyse”表明这是一个关于GPS数据解析的软件包，其中包含了实现GPS数据解析功能的源代码。这个压缩包里有两个主要的文件：GPS_Analyse.c 和 GPS_Analyse.h。这些文件...
comment_analyse-master_NLP_舆情分析_情感分析_舆情
09-11
在本项目“comment_analyse-master_NLP_舆情分析_情感分析_舆情”中，我们聚焦于利用NLP技术进行舆情分析和情感分析，以揭示评论数据中的商业价值。 首先，舆情分析是大数据时代企业决策的重要工具。它涉及到收集、...
x264_macroblock_analyse模块分析
03-27
详细分析x264_macroblock_analyse中的代码指令
fundamental-analysis-master_stock_
10-02
《Python基础分析大师：股票市场中的基本面分析》 在金融投资领域，基本面...通过学习和实践"fundamental-analysis-master"这样的项目，投资者可以更好地理解和运用基本面分析，从而在股市中做出更为明智的投资决策。
GetSliceType
09-09
ffmpeg中抽取出来的几个函数，主要是指数哥伦布编码函数，用来判断slice_type 从而判断I P B帧类型 希望对大家有用
计算h264码流slice的数目及大小
04-24
计算h264码流slice的数目及大小，码流文件需自己改，不区分SPS、PPS，可能有误差
x264 - x264_slicetype_analyse
fanbird2008的专栏
06-17 1535
void x264_slicetype_analyse( x264_t *h, int intra_minigop ) {     x264_mb_analysis_t a;     x264_frame_t *frames[X264_LOOKAHEAD_MAX+3] = { NULL, };     int num_frames, orig_num_frames, keyint_limi
x264 slicetype 选定中的x264_lowres_context_init函数分析
weixin_33843947的博客
04-25 258
2019独角兽企业重金招聘Python工程师标准>>> ...
x264代码学习笔记（五）：x264_slicetype_analyse函数
lifei092的博客
09-03 1125
x264_slicetype_decide函数（代码所在位置为“x264-snapshot-20171128-2245-stable\encoder\slicetype.c”）的主要作用为：真正用于分析帧类型（I\P\B帧） 调用顺序如下： x264_encoder_encode—&gt;x264_lookahead_get_frames—&gt;x264_slicetype_deci...
帧类型决策-slicetype_frame/slice/mb_cost()
workspace
02-19 983
/* 计算并返回帧b的开销，其中p0表示b的前向参考帧，p1表示b的后向参考帧 若p0 = p1 = b,则表示没有参考帧，即I帧 若p1 = b，则表示只有前向参考帧，即P帧 其中每一个帧都带有开销矩阵i_cost_est[b-p0][p1-b] 表示帧b以p0为前向参考，p1为后向参考时的帧cost */ static int x264_slicetype_frame_cost( ...
T264中的slice type decision
jasonme的专栏
08-11 2222
在H.264里面当前帧属于哪个slice的决定形式是多种多样的，对于JM中的码流中，一般一帧图象就认为是一个slice，那么如果当前帧是一个I帧，那么它就属于一个I slice.这时整个frame的为一个slice.但是具体我们用什么样的方式来进行slice type的决策呢，这也是一个问题。我们看一下T264里面是如何处理这个问题的。在T264中,如果我们设定了,USE_SCENEDETECT的
x265-1.7版本-encoder/slicetype.h注释
热门推荐
cabbage2008的专栏
01-23 1万+
x265-1.7版本-encoder/slicetype.h注释
fund_analyse_system_share
最新发布
04-28
fund_analyse_system_share指的是基金分析系统的共享功能。基金是投资人员常用的金融工具之一，基金分析系统的作用是为投资人员提供基金的相关信息、历史表现以及当前市场动态等，为其进行理性的投资决策提供依据。 基金分析系统的共享功能即指该系统的信息、数据可以被不同的投资人或投资机构所共享使用。这个功能的实现有效地节省了各个投资机构在建立自己的基金分析系统过程中的时间和成本，同时也提高了基金信息的传递效率，展示了信息资源共享的好处。 以此为例，某投资机构准备进行基金投资，在该机构将资金分配给基金经理对基金进行管理的前提下，必须了解基金的信息和市场动态等等。如果该机构的自建基金分析系统信息不完善或信息落后，可能导致其做出错误决策而影响投资效益。而有了fund_analyse_system_share就能够大大降低这样的风险，提高机构的投资成功率，也方便了信息的互通，推动了行业的发展。 总而言之，fund_analyse_system_share的功能带来了很多优点，比如节省了时间成本，提高了基金投资的成功率，增加了信息传递的效率等等。这对于整个投资市场都有很大的益处。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值