更新记录 2022-04-28 第一次编辑
正文 H.264 H.264简介 H.264是目前最为主流的视频编码标准，同时也是MPEG-4第十部分，一般称为H.264/AVC。对比H.264以前广泛使用的视频编码，H.264提供更低的码率和更高的视频质量，同时也提供了更强的容错能力和良好的IP网络适应性。H.264编码在推出之后被视频点播和实时流媒体领域被广泛使用，在标准成立之初，H.264主要提供三个档次的流媒体能力：基本档次(baseline profile)，扩展档次(Extended profile)和主要档次(main profile)；其中，baseline profile被广泛应用于实时流媒体传输，例如视频会议，远程医疗等，提供低码率，低延时，高质量的流媒体视频流。
图像质量PSNR PSNR即图像峰值信噪比(Peak Signal to Noise Ratio)，作为一种客观的图像质量评价标准，在图像处理相关的工程中被广泛使用，用于评价图像在经过压缩处理之后，获取到的处理图像的质量对比原始图像能否让人满意。其计算公式如下（其中，MSE是原图像与处理图像之间均方误差）：
帧类型和参考帧 H.264编码中，图像存在不同的帧类型；一般可以分为IDR帧，I帧，P帧，B帧，还有SP/SI等帧类型。同时，H.264还会产生SPS、PPS和SEI等NALU单元。下面简单介绍一下主要使用的帧类型(一些扩展类型这里不提)：
IDR帧 Instantaneous Decoding Refresh 即时解码刷新帧，一定是一个I帧，解码器在接收到IDR帧时，会清空参考帧列表，并重置部分参数。IDR帧后的帧永远不会参考IDR帧前的帧。 I帧 Intra-coded picture 关键帧，只做帧内预测，只需要当帧画面即可解锁 P帧 Predictive-coded Picture 前向预测帧，会参考可以之前的参考帧进行帧间预测 B帧 Bidirectionally predicted picture双向预测帧，会参考前向和后向的参考帧进行帧间预测 SPS Sequence Parameter Set，序列参数集；包含profile，level，分辨率等重要信息，代表了一组编码序列的全局参数 PPS Picture Parameter Set，图像参数集，保持了图像编码时所使用的参数 SEI Supplementary Enhancement Information，图像增强信息，会携带一些自定义信息和对解码可能有帮助的信息 CABAC和CAVLC 熵编码的两种方式，熵编码是一种无损压缩的方式。H.264在处理完图像数据之后，通过熵编码进一步提高了编码压缩率。其中CABAC为基于上下文的自适应二进制算数熵编码，CAVLC为基于上下文自适应的可变长编码。实时流媒体传输一般来说baseline profile，只支持CAVLC。
视频码率控制 图像是由一个一个的像素点组成，视频则又是由连续的图像组成，因此传输原始的无损图片会占用极大的带宽。视频编码的主要目的就在于，通过有损的压缩，在保证图像质量的同时尽可能的降低视频传输时占用的带宽，即视频码率。显然，视频的质量越高，视频的码率必然越高，进行码率控制，就是要求视频编码在质量和码率直接达到一定平衡。
CBR VS VBR CBR即恒定码率控制(Constant Bitrate)，指定一个比特率，每一帧图像都按照这个比特数进行编码。这种编码方式在音频编码中非常常见，但是在视频编码领域，由于H.264当中不同帧类型要求的比特数本来就不同，同时不同的场景对于比特数的需求也不相同，复杂的场景显然需要更多的比特数，而简单固定的场景并不需要很多的比特数进行编码。导致固定码率，意味着对复杂的场景可能出现画质很差，对简单恒定的场景出现大量的比特浪费。
为了修正CBR存在的问题，视频编码就出现了VBR的码率控制方法，即可变码率控制(Variable Bitrate)，用于在给定比特限制下保持图像的最高质量。简单来说，VBR的核心思想在于，对于复杂的难编码的场景给予更多的比特，对于简单的易于编码的场景使用更少的比特，从而达成始终以较少的比特保持一定的图像质量。
可变比特率类型的码率控制方式在视频码率控制当中是主流方式。
编码应用场景 可变码率控制方式，对于不同的场景给予不同的比特数；同时，实际使用视频的场景也对视频的码率具有影响。不同的profile之间，由于启用的压缩技术不同，码率差距和编码速度也有区别。对于视频应用来说，一般有如下几种应用场景：
视频存档：单纯的保存视频，不关心编码速度，最重要的指标是视频质量和视频大小，可以预知场景 流媒体点播：通过网络传输视频，不关心编码速度，在保证视频质量的时候视频码率不能超过带宽，尽量不占用带宽，可以预知场景 流媒体直播：通过网络传输实时视频，要求编码速度快，码率不超过带宽的情况下尽可能低，同时保证视频质量，不能预知场景 面向特定存储介质：将媒体刻录到DVD等介质上，要求编码出的视频大小刚好占满介质容量，并且质量高，可以预知场景 不同的编码场景对视频指标的关注点不尽相同，其中流媒体直播即实时流媒体传输，对视频编码的要求更高。在实时流媒体传输当中，最重要的是保持流媒体的实时性，因此一般只采用baseline profile。同时，实时流媒体传输同样关注视频码率和视频质量，要求在码率足够小的同时质量足够好。并且，不能预知场景使得实时流媒体传输难以根据特定场景应用场景的优化参数。
QP 量化参数（Quantization Parameter,QP）控制着压缩大小。QP越大压缩率越高同时质量越低，QP越小压缩率越低同时质量越高。在H.264中，QP的范围是0-51间的整数。一般而言，控制码率就是控制编码的比特数，也即控制编码的QP值
TODO QP的原理
码率控制方式 CQP 恒定QP值（Constant QP）是通过保证每帧画面QP值固定进行码率控制的方法，可以发现，通过恒定QP完全无法控制码率，每帧画面编码出的大小完全受限于画面复杂度。因此，在x264文档中只推荐启用CQP用于研究，而不推荐使用CQP控制码率。
ABR 平均码率控制模式(Average Bitrate)是通过控制整个码流的平均码率，从而控制码率的模式。ABR并不要求整个视频码率恒定，但是面对突发的过高码率，ABR会压低后续画面的码率以保持平均码率。因此，ABR虽然简单，但是由于在大部分场景中，编码器无法知道接下来的编码帧需要多大的码率，从而导致在画面变化时画面质量波动十分剧烈，使得视频质量低于预期。因此，在大多数情况都不应该使用ABR模式。
2-PASS ABR ABR模式因为很难预测下一帧画面的消耗，往往导致码率控制效果很差。但是，如果允许编码器进行多次编码，编码器在第二次及之后的编码过程中就可以提前知道每一帧编码的消耗，从而更好的分配比特，这就是2-PASS ABR控制方式。在第一次编码时，编码器首先获得了视频编码的消耗，从而在第二次编码时更合理的分配，一般而言第二次编码会应用ABR码率控制，第一次编码CQP即可。
2-PASS编码能够在给定码率下达到较好质量，但是仍然存在一些问题。首先，如果给定的码率不足以保证图像质量，画面质量还是会低于预期，为了获得最好质量必须要有一个经验性的码率（需要多次实验）；其次，2-PASS码率控制进行两次编码，这对于实时流媒体来说基本是无法忍受的；最后，码率波动同样无法避免，如果瞬时码率过高，流媒体客户端的接受能力就必须纳入考虑。
CRF 恒定视频质量( Constant Rate Factor)通过指定crf值，使编码器试图保证输出的图像质量恒定。crf值是一个类似于QP的概念，8bit的H.264编码的crf值理论范围是[0,51]，在x264中，默认的crf值为23。crf值每增长6，输出的视频码率就变为原来的1/2，crf值和视频码率满足对数关系。在理论上，crf = 0 即完全无损压缩，crf = 51 即最大程度的压缩。在实际实践中，一般认为crf = 18 即为H.264的无损画面，因此在主观图像质量评价中，crf值一般使用[18,28]作为范围，有时也会应用到17,29等边界值用于极端情况。
使用CRF进行码率控制，可以达到比较优质的图像质量，但是类似于CQP，CRF并不能对码率做出很好的保证。
VBV 视频缓存验证(Video Buffering Verifier)通过设定视频流的码率上界和码率下界，保证媒体流既不会高于某个特定码率，也不会低于某个特定码率，从而完成码率的控制。使用VBV需要设置编码器的buffsize，一般设置为码率上界的两倍。
VBV的特性保证了在实时流媒体传输中，视频编码的码率总是被约束在接受方的能力范围内，因此在实时流媒体传输中被普遍使用，同时VBV实际上与2-PASS和CRF等控制方式兼容，因此可以做到结合使用。
CRF + VBV 由于CRF和VBV完全兼容，因此可以同时启用这两个策略，在一定码率下保证画面的画质。
各个码率控制方式对比总结 控制方式 应用面 不适合的场景 CQP 可以用于研究 几乎所有实际落地场景 ABR 要求简单快速 除非必须极低延时，几乎所有场景不应该使用 2-PASS ABR 面向特定场景，非实时的处理 要求低延时的场景，快速编码场景 CRF 对图像质量有要求的场景 对码率波动十分敏感的场景 VBV 实时流媒体，带宽受限的流媒体 存档类的编码 CRF + VBV 实时流媒体，带宽受限的流媒体 存档类的编码
参考文档 [x264-devel] Making sense out of x264 rate control methods
x264 x264代码框架 文件组织如下：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 > tree -L 1
完整树如下（删减了git相关的文件）：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 > tree -a
代码框架分析 TODO
x264代码分析 在编译完成之后，x264分为可执行程序x264和库libx264。先从可执行程序x264看起，了解大概流程。
整体调用分析 x264调用流程 注：图中橙色函数为实际调用需要的x264 API，红色函数为目前认为和码率控制有关的函数，绿色为注释
main函数 x264.c中定义了x264的main函数，这个函数处理命令行参数，设置信号；然后进行编码处理和完成后的清理工作。在该函数中，主要的核心函数为prase()和encode()，核心结构体为x264_param_t和cli_opt_t，如下所示:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 REALIGN_STACK int main ( int argc, char **argv ) if ( argc == 4 && !strcmp ( argv[1 ], "--autocomplete" ) )return x264_cli_autocomplete( argv[2 ], argv[3 ] );x264_param_t param; cli_opt_t opt = {0 }; int ret = 0 ;"unable to initialize threading\n" );#ifdef _WIN32 "unable to convert command line to UTF-8\n" );stdin ), _O_BINARY );stdout ), _O_BINARY );stderr ), _O_BINARY );#endif if ( parse( argc, argv, ¶m, &opt ) < 0 )-1 ;#ifdef _WIN32 #endif if ( !ret )if ( filter.free )free ( opt.hin );else if ( opt.hin )if ( opt.hout )0 , 0 );if ( opt.tcfile_out )if ( opt.qpfile )#ifdef _WIN32 free ( argv );#endif return ret;
继续分析两个关键函数
parse( argc, argv, ¶m, &opt ) prase函数用于解析命令行参数，并对x264_param_t进行初始化。prase主要调用了以下函数(位于common/base.c)进行设置设置：
x264_param_default_preset - 根据preset和tune设置参数 x264_param_default - 设置默认参数 x264_param_parse - 解析用户自带的参数 x264_param_apply_profile - 设置profile x264_param_default(common/base.c) 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 void x264_param_default ( x264_param_t *param ) memset ( param, 0 , sizeof ( x264_param_t ) );1 ;0 ;0 ;0 ;0 ;0 ; 5 ; -1 ; 2 ; 2 ; -1 ; 0 ; 25 ;1 ;-1 ;0 ;0 ;0 ;#if HAVE_BITDEPTH8 8 ;#elif HAVE_BITDEPTH10 10 ;#else 8 ;#endif 3 ;250 ;3 ;40 ;0 ;0 ;0 ;1 ;0 ;0 ;1 ;0 ;0 ;1.0 ;0 ;0 ;0.9 ;-1 ;23 ;0 ;4 ;1.4 ;1.3 ;1.0 ;40 ;0 ;"x264_2pass.log" ;0 ;"x264_2pass.log" ;0.6 ;0.5 ;20 ;0 ;1 ;NULL ;1.0 ;1 ;0 ;16 ;7 ;1 ;1 ;-1 ;-1 ; 0 ;1 ;1 ;1 ;1 ;1 ;0 ] = 21 ;1 ] = 11 ;0 ;0 ;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 ) );1 ;1 ;0 ;1 ;1 ;0 ;0 ;-1 ;2 ; 0 ;0 ;NULL ;NULL ;0 ;
x264_param_default_preset(common/base.c) 1 2 3 4 5 6 7 8 9 10 11 12 int x264_param_default_preset ( x264_param_t *param, const char *preset, const char *tune ) if ( preset && param_apply_preset( param, preset ) < 0 )return -1 ;if ( tune && param_apply_tune( param, tune ) < 0 )return -1 ;return 0 ;
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 static int param_apply_preset ( x264_param_t *param, const char *preset ) char *end;int i = strtol( preset, &end, 10 );if ( *end == 0 && i >= 0 && i < ARRAY_ELEMS(x264_preset_names)-1 )if ( !strcasecmp( preset, "ultrafast" ) )1 ;0 ;0 ; 0 ;0 ; 0 ;0 ;0 ; 0 ;0 ;0 ;0 ;0 ;0 ;0 ;else if ( !strcasecmp( preset, "superfast" ) )1 ;1 ;0 ;0 ;0 ;0 ;else if ( !strcasecmp( preset, "veryfast" ) )2 ;1 ;0 ;0 ;10 ;else if ( !strcasecmp( preset, "faster" ) )0 ;2 ;4 ;20 ;else if ( !strcasecmp( preset, "fast" ) )2 ;6 ;30 ;else if ( !strcasecmp( preset, "medium" ) )else if ( !strcasecmp( preset, "slow" ) )8 ;5 ;2 ;50 ;else if ( !strcasecmp( preset, "slower" ) )9 ;8 ;2 ;60 ;else if ( !strcasecmp( preset, "veryslow" ) )10 ;24 ;16 ;2 ;8 ;60 ;else if ( !strcasecmp( preset, "placebo" ) )11 ;24 ;16 ;0 ;2 ;16 ;60 ;else "invalid preset '%s'\n" , preset );return -1 ;return 0 ;
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 static int param_apply_tune ( x264_param_t *param, const char *tune ) int psy_tuning_used = 0 ;for ( int len; tune += strspn ( tune, ",./-+" ), (len = strcspn ( tune, ",./-+" )); tune += len )if ( len == 4 && !strncasecmp( tune, "film" , 4 ) )if ( psy_tuning_used++ ) goto psy_failure;-1 ;-1 ;0.15 ;else if ( len == 9 && !strncasecmp( tune, "animation" , 9 ) )if ( psy_tuning_used++ ) goto psy_failure;1 ? param->i_frame_reference*2 : 1 ;1 ;1 ;0.4 ;0.6 ;2 ;else if ( len == 5 && !strncasecmp( tune, "grain" , 5 ) )if ( psy_tuning_used++ ) goto psy_failure;-2 ;-2 ;0.25 ;0 ;1.1 ;1.1 ;0.5 ;0 ] = 6 ;1 ] = 6 ;0.8 ;else if ( len == 10 && !strncasecmp( tune, "stillimage" , 10 ) )if ( psy_tuning_used++ ) goto psy_failure;-3 ;-3 ;2.0 ;0.7 ;1.2 ;else if ( len == 4 && !strncasecmp( tune, "psnr" , 4 ) )if ( psy_tuning_used++ ) goto psy_failure;0 ;else if ( len == 4 && !strncasecmp( tune, "ssim" , 4 ) )if ( psy_tuning_used++ ) goto psy_failure;0 ;else if ( len == 10 && !strncasecmp( tune, "fastdecode" , 10 ) )0 ;0 ;0 ;else if ( len == 11 && !strncasecmp( tune, "zerolatency" , 11 ) )0 ; 0 ;0 ; 1 ;0 ;0 ;else if ( len == 6 && !strncasecmp( tune, "touhou" , 6 ) )if ( psy_tuning_used++ ) goto psy_failure;1 ? param->i_frame_reference*2 : 1 ;-1 ;-1 ;0.2 ;1.3 ;if ( param->analyse.inter & X264_ANALYSE_PSUB16x16 )else "invalid tune '%.*s'\n" , len, tune );return -1 ;"only 1 psy tuning can be used: ignoring tune %.*s\n" , len, tune );return 0 ;
encode( ¶m, &opt ) encode是真正的编码处理，代码开头定义部分如下，开头几个是x264的结构体：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 static int encode ( x264_param_t *param, cli_opt_t *opt ) x264_t *h = NULL ; x264_picture_t pic; cli_pic_t cli_pic; const cli_pulldown_t *pulldown = NULL ; int i_frame = 0 ;int i_frame_output = 0 ;int64_t i_end, i_previous = 0 , i_start = 0 ;int64_t i_file = 0 ;int i_frame_size;int64_t last_dts = 0 ;int64_t prev_dts = 0 ;int64_t first_dts = 0 ;# define MAX_PTS_WARNING 3 int pts_warning_cnt = 0 ;int64_t largest_pts = -1 ;int64_t second_largest_pts = -1 ;int64_t ticks_per_frame;double duration;double pulldown_pts = 0 ;int retval = 0 ;
encode 的主要工作是初始化结构体后调用encode_frame函数编码，而encode_frame调用了x264_encoder_encode进行实际的编码。这个函数位于encoder/api.c，是个调用函数指针的封装：
1 2 3 4 5 6 REALIGN_STACK 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_api_t *api = (x264_api_t *)h;return api->encoder_encode( api->x264, pp_nal, pi_nal, pic_in, pic_out );
因此，回到编码器开启的时候寻找当时注册的encode函数，这个注册过程同样实现在encoder/api.c：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 REALIGN_STACK x264_t *x264_encoder_open ( x264_param_t *param ) x264_api_t *api = calloc ( 1 , sizeof ( x264_api_t ) );if ( !api )return NULL ;if ( HAVE_BITDEPTH8 && param->i_bitdepth == 8 )else if ( HAVE_BITDEPTH10 && param->i_bitdepth == 10 )else "not compiled with %d bit depth support\n" , param->i_bitdepth );if ( !api->x264 )free ( api );return NULL ;return (x264_t *)api;
目前x264主要是按照8bit和10bit两种不同的深度对调用进行了注册。但是全文搜索并找不到这些指向的函数实现，只能找到定义，同样位于encoder/api.c
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 x264_t *x264_8_encoder_open ( x264_param_t * ) ;void x264_8_nal_encode ( x264_t *h, uint8_t *dst, x264_nal_t *nal ) ;int x264_8_encoder_reconfig ( x264_t *, x264_param_t * ) ;void x264_8_encoder_parameters ( x264_t *, x264_param_t * ) ;int x264_8_encoder_headers ( x264_t *, x264_nal_t **pp_nal, int *pi_nal ) ;int x264_8_encoder_encode ( x264_t *, x264_nal_t **pp_nal, int *pi_nal, x264_picture_t *pic_in, x264_picture_t *pic_out ) ;void x264_8_encoder_close ( x264_t * ) ;int x264_8_encoder_delayed_frames ( x264_t * ) ;int x264_8_encoder_maximum_delayed_frames ( x264_t * ) ;void x264_8_encoder_intra_refresh ( x264_t * ) ;int x264_8_encoder_invalidate_reference ( x264_t *, int64_t pts ) ;x264_t *x264_10_encoder_open ( x264_param_t * ) ;void x264_10_nal_encode ( x264_t *h, uint8_t *dst, x264_nal_t *nal ) ;int x264_10_encoder_reconfig ( x264_t *, x264_param_t * ) ;void x264_10_encoder_parameters ( x264_t *, x264_param_t * ) ;int x264_10_encoder_headers ( x264_t *, x264_nal_t **pp_nal, int *pi_nal ) ;int x264_10_encoder_encode ( x264_t *, x264_nal_t **pp_nal, int *pi_nal, x264_picture_t *pic_in, x264_picture_t *pic_out ) ;void x264_10_encoder_close ( x264_t * ) ;int x264_10_encoder_delayed_frames ( x264_t * ) ;int x264_10_encoder_maximum_delayed_frames ( x264_t * ) ;void x264_10_encoder_intra_refresh ( x264_t * ) ;int x264_10_encoder_invalidate_reference ( x264_t *, int64_t pts ) ;
在编译后，可以看到x264会生成两种不同位深的.o文件，例如在encoder/：
1 2 3 4 5 6 7 8 9 10 11 > ls
全局搜索可以看到，相关的实现被x264通过宏定义进行区分(common/common.h):
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 #define x264_template(w) x264_glue3(x264, BIT_DEPTH, w) #define x264_nal_encode x264_template(nal_encode) #define x264_encoder_reconfig x264_template(encoder_reconfig) #define x264_encoder_parameters x264_template(encoder_parameters) #define x264_encoder_headers x264_template(encoder_headers) #define x264_encoder_encode x264_template(encoder_encode) #define x264_encoder_close x264_template(encoder_close) #define x264_encoder_delayed_frames x264_template(encoder_delayed_frames) #define x264_encoder_maximum_delayed_frames x264_template(encoder_maximum_delayed_frames) #define x264_encoder_intra_refresh x264_template(encoder_intra_refresh) #define x264_encoder_invalidate_reference x264_template(encoder_invalidate_reference)
因此，无论是8bit还是10bit的处理，在API逻辑上没有区别。
上文API的实现位于encoder/encoder.c，现在再回头看之前寻找的编码函数，定义如下：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 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 )
该函数的入参如下：
1. x264_t *h编码器参数
2. x264_nal_t **pp_nal 编码的结果
3. int *pi_nal 已编码的帧数
4. x264_picture_t *pic_in 存放输入的raw数据
5. x264_picture_t *pic_out
主要调用的函数:
x264_frame_pop_unused 获取一个没有使用的frame(fenc) x264_frame_copy_picture 拷贝raw数据到fenc x264_frame_expand_border_mod16 对分辨率不是16倍数的帧，增加pad位进行扩边 x264_macroblock_tree_read mb-tree相关的码率控制 x264_adaptive_quant_frame 宏块级码率控制 x264_frame_init_lowres 1/2像素的内插 x264_lookahead_put_frame 将帧加入lookahead分析 x264_lookahead_get_frames 从lookahead取出帧 x264_frame_shift 从队列中取出用于编码的帧 x264_ratecontrol_zone_init 码率控制初始化 reference_reset 清空参考帧列表 reference_hierarchy_reset 在帧类型为I帧，P帧等类型时，调用判断是否重置参考帧 reference_build_list 建立参考帧列表，list0，list1 x264_ratecontrol_start 开启码率控制，选择合适的QP x264_ratecontrol_qp 获取计算出的QP slice_init 创建头信息 slices_write 真正的编码函数，内部进行了编码 encoder_frame_end 编码后的处理内容 码率控制 x264_ratecontrol相关的处理被定义在encoder/ratecontrol.c当中。其中，x264_ratecontrol_start的ratecontrol针对的是帧层级的计算。在该函数中，主要进行帧预期QP值的运算，主要使用ABR，2-PASS和VBV三种控制方式。
ABR算法 && 2-PASS ABR 在x264_ratecontrol_start函数中, 关于ABR和2-PASS ABR计算，主要是如下几行：
1 2 3 4 5 6 7 8 9 if ( rc->b_abr )else if ( rc->b_2pass )
其中q代表ABR算法计算的QP值；下面分析函数的调用（这里看的是原生代码，不是优化后代码）
1 2 3 4 5 6 #define QP_BD_OFFSET (6*(BIT_DEPTH-8)) static inline float qscale2qp ( float qscale ) return (12.0f + QP_BD_OFFSET) + 6.0f * log2f( qscale/0.85f );
这个函数代表了计算ABR的换算公式，x264选择了固定的公式（经验公式）换算qscale和qp。此时查看反向的切换
1 2 3 4 static inline float qp2qscale ( float qp ) return 0.85f * powf( 2.0f , ( qp - (12.0f + QP_BD_OFFSET) ) / 6.0f );
可以看到公式为 （假设是8bit位深）
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 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] if ( rcc->b_2pass )if ( pict_type != rce.pict_type )"slice=%c but 2pass stats say %c\n" ,if ( pict_type == SLICE_TYPE_B )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 )2 ;if ( h->fref_nearest[1 ]->i_type == X264_TYPE_BREF )2 ;if ( i0 && i1 )2 + rcc->ip_offset;else if ( i0 )else if ( i1 )else if ( h->fenc->b_kept_as_ref )2 ;else if ( rcc->b_2pass )else 1 ][h->i_ref[1 ]-1 ]->i_satd );if ( rcc->b_vbv )if ( rcc->b_vbv )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 = rcc - 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 ;if ( rcc->b_2pass )double lmin = rcc->lmin[pict_type];double lmax = rcc->lmax[pict_type];double diff;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 );0.5 * X264_MAX( scale_factor, 0.5 );.5 , 2 );if ( h->i_frame >= rcc->fps && rcc->expected_bits_sum >= 1 )double cur_time = (double )h->i_frame / rcc->num_entries;double w = x264_clip3f( cur_time*100 , 0.0 , 1.0 );pow ( (double )total_bits / rcc->expected_bits_sum, w );if ( rcc->b_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;if ( expected_fullness < .05 )while ( ((expected_vbv < rce.expected_vbv/size_constraint) && (q < qmax)) ||0 ) && (q < lmax)))1.05 ;else double wanted_bits, overflow = 1 ;0.5 ;0.5 ;0 ;0 ;0 ;1 ;if ( h->param.rc.i_rc_method == X264_RC_CRF ) else if ( !rcc->b_vbv_min_rate && rcc->last_satd ) 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 )double )(h->fenc->i_reordered_pts - h->i_reordered_pts_delay)) * h->param.i_timebase_num / h->param.i_timebase_den;if ( wanted_bits > 0 )1 , sqrt ( time_done ) );1.0 + (predicted_bits - wanted_bits) / abr_buffer, .5 , 2 );if ( pict_type == SLICE_TYPE_I && h->param.i_keyint_max > 1 else if ( h->i_frame > 0 )if ( h->param.rc.i_rc_method != X264_RC_CRF )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 )else if ( overflow < 0.9 )else if ( h->param.rc.i_rc_method == X264_RC_CRF && rcc->qcompress != 1 )if ( !(rcc->b_2pass && !rcc->b_vbv) && h->fenc->i_frame == 0 )if ( rcc->b_2pass )else if ( rcc->single_frame_vbv )if ( rcc->b_vbv )return q;
根据这段代码，可以绘制如下流程图：
rate_estimate_qscale流程图 VBV算法 x264_ratecontrol_start中关于vbv的代码
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 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 ) );const x264_level_t *l = x264_levels;while ( l->level_idc != 0 && l->level_idc != h->param.i_level_idc )int mincr = l->mincr;if ( h->param.b_bluray_compat )4 ;if ( h->sps->i_profile_idc > PROFILE_HIGH )1e9 ;else if ( h->i_frame == 0 )double fr = 1. / (h->param.i_level_idc >= 60 ? 300 : 172 );int pic_size_in_mbs = h->mb.i_mb_width * h->mb.i_mb_height;384 * BIT_DEPTH * X264_MAX( pic_size_in_mbs, fr*l->mbps ) / mincr;else 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;
update_vbv_plan函数如下，可以发现这个函数主要更新了buffer_fill作为计划缓冲区。实际的更新不在这里。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 static void update_vbv_plan ( x264_t *h, int overhead ) x264_ratecontrol_t *rcc = h->rc;0 ]->rc->buffer_fill_final_min / h->sps->vui.i_time_scale;if ( h->i_thread_frames > 1 )int j = rcc - 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 ;0 );
实际的更新在完成编码之后，由x264_ratecontrol_end调用update_vbv;这个函数更新了buffer_fill_final，代表vbv最后实际使用的bits。vbv算法还有许多宏块级的处理，分散在代码中，本次学习暂时没有分析相关内容
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 static int update_vbv ( x264_t *h, int bits ) int filler = 0 ;int bitrate = h->sps->vui.hrd.i_bit_rate_unscaled;x264_ratecontrol_t *rcc = h->rc;x264_ratecontrol_t *rct = h->thread[0 ]->rc;int64_t buffer_size = (int64_t )h->sps->vui.hrd.i_cpb_size_unscaled * h->sps->vui.i_time_scale;if ( rcc->last_satd >= h->mb.i_mb_count )if ( !rcc->b_vbv )return filler;uint64_t buffer_diff = (uint64_t )bits * h->sps->vui.i_time_scale;if ( rct->buffer_fill_final_min < 0 )double underflow = (double )rct->buffer_fill_final_min / h->sps->vui.i_time_scale;if ( rcc->rate_factor_max_increment && rcc->qpm >= rcc->qp_novbv + rcc->rate_factor_max_increment )"VBV underflow due to CRF-max (frame %d, %.0f bits)\n" , h->i_frame, underflow );else "VBV underflow (frame %d, %.0f bits)\n" , h->i_frame, underflow );0 ;if ( h->param.i_avcintra_class )else uint64_t )bitrate * h->sps->vui.i_num_units_in_tick * h->fenc->i_cpb_duration;if ( rct->buffer_fill_final > buffer_size )if ( h->param.rc.b_filler )int64_t scale = (int64_t )h->sps->vui.i_time_scale * 8 ;1 ) / scale;8 : X264_MAX( (FILLER_OVERHEAD - h->param.b_annexb), filler ) * 8 ;uint64_t )bits * h->sps->vui.i_time_scale;else return filler;
