转自:http://nkwavelet.blog.163.com/blog/static/2277560382013103010312144/

x264版本:   x264-snapshot-20140226-2245

 1.     首先对主函数进行分析,main函数很简洁,主要有三个步骤,见下图:

2.   接下来分析一下Parse函数中的主要过程:

static int parse( int argc, char **argv, x264_param_t *param, cli_opt_t *opt )
{
        // 设置编码器默认参数,此处并不是真正设置编码器参数,而是设置到变量defaults中,
// 该变量用于命令行help查看的时候,显示默认的参数值而已。
// 该函数的详细分析见:x264编码器默认参数值

x264_param_default( &defaults );

/* Presets are applied before all other options. */
for( optind = 0;; )
{ // 获取preset 和tune
int c = getopt_long( argc, argv, short_options, long_options, NULL );
... ... ... ...
}

       
// 如果preset设置为placebo,此设置获取更大的psnr值,但是速度非常慢,通常不采用此设置

if ( preset && !strcasecmp( preset, "placebo" ) )
b_turbo = 0;

// 首先设置缺省的编码器参数,然后根据给定的preset和tune修改部分编码器参数
// 该函数代码详细分析见:x264_param_xxxx 系列函数代码分析
if ( x264_param_default_preset( param, preset, tune ) < 0 )
return -1;

/*  解释命令行参数 */
for( optind = 0;; )
{      ... ... ... ...     }

/* If first pass mode is used, apply faster settings. */
if ( b_turbo )  
x264_param_apply_fastfirstpass( param );

/* Apply profile restrictions. 主要用于检测设置的profile与其他的编码器参数是否有冲突 */
// 该函数代码详细分析见:x264_param_xxxx 系列函数代码分析
if ( x264_param_apply_profile( param, profile ) < 0 )
return -1;

// 根据输出文件名的后缀名选择相应的文件操作函数集合
if ( select_output( muxer, output_filename, param ) )
return -1;

// 打开输出文件,如果输出文件是flv格式,则此处调用的函数
// 就是 output/flv.c 文件中的open_file 函数
cli_output.open_file( output_filename, &opt->hout, &output_opt );

// 选择输入文件打开方式,有avs, y4m, ffms, lavf, raw等方式,
// 具体方式还依赖编译选项的支持
if( select_input( demuxer, demuxername, input_filename, &opt->hin, &info, &input_opt ) )
return -1;

// 打开输入文件
cli_input.open_file( input_filename, &opt->hin, &info, &input_opt );

// 计算宽高比和帧率,即约分数表示
x264_reduce_fraction( &info.sar_width, &info.sar_height );
x264_reduce_fraction( &info.fps_num, &info.fps_den );

// 初始化视频filter参数,该函数定义在x264.c中
if( init_vid_filters( vid_filters, &opt->hin, &info, param, output_csp ) )
return -1;

/* set param flags from the post-filtered video */
param->b_vfr_input = info.vfr;
param->i_fps_num = info.fps_num;
param->i_fps_den = info.fps_den;
param->i_timebase_num = info.timebase_num;
param->i_timebase_den = info.timebase_den;
param->vui.i_sar_width  = info.sar_width;
param->vui.i_sar_height = info.sar_height;

/* Automatically reduce reference frame count to match the user's target 
 level if the user didn't explicitly set a reference frame count. */
param->i_frame_reference = .......
}

 
3.  编码函数encode分析如下:
static int encode( x264_param_t *param, cli_opt_t *opt )
{
      x264_t *h  =  NULL;         // 结构体x264_t的定义在common/common.h文件中
      x264_picture_t  pic;        // 结构体x264_picture_t的定义在x264.h文件中
      cli_pic_t   cli_pic;            // 结构体cli_pic_t的定义在input/input.h文件中
 
      // 函数x264_encoder_open定义在encoder/encoder.c文件中,这个函数是对不正确的参数进行修改,
      // 并对各结构体参数和cabac编码、预测等需要的参数进行初始化,打开编码器句柄。
      // 通过x264_encoder_parameters得到设置给x264的参数,通过x264_encoder_reconfig更新x264参数
      x264_t *h = x264_encoder_open( param );
 
      // 该函数定义在encoder/encoder.c文件中,该函数只有一句话,将线程中x264_t参数集拷贝到param中
      x264_encoder_parameters( h, param );
 
      /* ticks/frame = ticks/second / frames/second */
      ticks_per_frame = (int64_t)param->i_timebase_den * param->i_fps_den
                                       / param->i_timebase_num  / param->i_fps_num;
      ticks_per_frame = X264_MAX( ticks_per_frame, 1 );
 
      if ( !param->b_repeat_headers )
      {
              // Write SPS/PPS/SEI
             x264_nal_t *headers;
             int i_nal;
 
             // 该函数定义在encoder/encoder.c文件中
             x264_encoder_headers( h, &headers, &i_nal );
 
             // 写文件头,如果是flv文件,则调用output/flv.c 文件中的write_headers函数
             cli_output.write_headers( opt->hout, headers );
      }
 
      /* Encode frames,循环编码每一帧 */
      for( ; !b_ctrl_c && (i_frame < param->i_frame_total || !param->i_frame_total); i_frame++ )
      {
             // 从输入文件中获取一帧,存放在cli_pic中
             if ( filter.get_frame( opt->hin, &cli_pic, i_frame + opt->i_seek ) )
                   break;
             
              // 初始化一帧图片,该函数定义在common/common.c文件中
              x264_picture_init( &pic );
 
              // 将cli_pic 转换成x264_picture_t格式的pic
              convert_cli_to_lib_pic( &pic, &cli_pic );
 
              // 对一帧编码,返回编码后的字节数,该函数定义在x264.c中
              i_frame_size = encode_frame( h, opt->hout, &pic, &last_dts );
              // 此处将函数encode_frame展开来分析
             {
                      x264_picture_t pic_out;
                     x264_nal_t *nal;
                     int i_nal;
                     int i_frame_size = 0;
 
                     // 具体执行编码一帧图片,该函数定义在x264的encoder/encoder.c文件中,执行完之后得到nal 和i_nal的值
                     // 该函数详细分析见:x264_encoder_encode 函数代码分析
                     i_frame_size = x264_encoder_encode( h, &nal, &i_nal, pic, &pic_out );
                    if ( i_frame_size )
                   {          // 将一帧数据写入到输出文件中
                              i_frame_size = cli_output.write_frame( hout, nal[0].p_payload, i_frame_size, &pic_out );
                             *last_dts = pic_out.i_dts;
                   } 
                  return i_frame_size;
            }
 
           if( i_frame_size < 0 )
           {    
                     b_ctrl_c = 1;        /* lie to exit the loop */
                     retval = -1;
           }    
          else if ( i_frame_size )
          {    
                    i_file += i_frame_size;
                    i_frame_output++;
                   if( i_frame_output == 1 )
                           first_dts = prev_dts = last_dts;
           }
 
           // 释放一帧
          if ( filter.release_frame( opt->hin, &cli_pic, i_frame + opt->i_seek ) )
                      break;
      }  // 循环编码一帧结束
 
      /* Flush delayed frames */
      while( !b_ctrl_c && x264_encoder_delayed_frames( h ) )
      {
                  i_frame_size = encode_frame( h, opt->hout, NULL, &last_dts );
                  ... ... ... ...
       }
 
       // 关闭编码器
       x264_encoder_close( h );
 
       // 关闭输出文件
       cli_output.close_file( opt->hout, largest_pts, second_largest_pts );
 
       return retval;
}
4.  编码函数x264_encoder_open分析如下:
x264_t* x264_encoder_open( x264_param_t *param )
{
/* 结构体x264_t的定义在common/common.h中 */
x264_t *h;

/* Create a copy of param, 创建一个param拷贝 */
memcpy( &h->param, param, sizeof(x264_param_t) );

/*  x264线程初始化 */
x264_threading_init();

/* 该函数位于encoder/encoder.c中,主要用于检查h->param中的参数设置是否有冲突  */
if( x264_validate_parameters( h, 1 ) < 0 )
goto fail;

/* 如果提供了外部量化矩阵文件,则读取分析该量化矩阵文件 */

if( h->param.psz_cqm_file )
if( x264_cqm_parse_file( h, h->param.psz_cqm_file ) < 0 ) 
goto fail;

/* 用于2pass模式,保存编码的统计数据 */
if( h->param.rc.psz_stat_out ) 
h->param.rc.psz_stat_out = strdup( h->param.rc.psz_stat_out ); 
if( h->param.rc.psz_stat_in ) 
h->param.rc.psz_stat_in = strdup( h->param.rc.psz_stat_in );

/* 将fps和timebase化为既约分数 */
x264_reduce_fraction( &h->param.i_fps_num, &h->param.i_fps_den ); 
x264_reduce_fraction( &h->param.i_timebase_num, &h->param.i_timebase_den );

/* Init x264_t */

h->i_frame = -1;
h->i_frame_num = 0;
h->i_idr_pic_id = 0;
·/* 设置vui的宽高比,也就是将vui.i_sar_width和vui.i_sar_height按比例缩放到65535以内并化为即约分数,通常可以忽略 */
x264_set_aspect_ratio( h, &h->param, 1 );

/* 初始化sps和pps,这两个函数位于encoder/set.c中 */
x264_sps_init( h->sps, h->param.i_sps_id, &h->param ); 
x264_pps_init( h->pps, h->param.i_sps_id, &h->param, h->sps );

/* 检查设定的level是否有效,该函数及数组x264_levels[] 定义定义在encoder/set.c中  */

/* 有关各种level的极限值,可参考h264官方协议:Table A-1 – Level limits */
x264_validate_levels( h, 1 );

h->chroma_qp_table = i_chroma_qp_table + 12 + h->pps->i_chroma_qp_index_offset;

/* 初始化量化矩阵  */
if( x264_cqm_init( h ) < 0 )
goto fail;

/* 每行每列及一帧总的宏块数目  */
h->mb.i_mb_width  = h->sps->i_mb_width; 
h->mb.i_mb_height = h->sps->i_mb_height; 
h->mb.i_mb_count  = h->mb.i_mb_width * h->mb.i_mb_height; 

// 对于csp取值X264_CSP_I420而言,以下两个值都是1
h->mb.chroma_h_shift = CHROMA_FORMAT == CHROMA_420 || CHROMA_FORMAT == CHROMA_422; 
h->mb.chroma_v_shift = CHROMA_FORMAT == CHROMA_420;

/* Adaptive MBAFF and subme 0 are not supported as we require halving motion 
 * vectors during prediction, resulting in hpel mvs. 
 * The chosen solution is to make MBAFF non-adaptive in this case. */
// 忽略隔行,因此下面变量值通常为0
h->mb.b_adaptive_mbaff = PARAM_INTERLACED && h->param.analyse.i_subpel_refine;

/* Init frames. 初始化一些帧设置,包括延迟帧数、参考帧数、关键帧间隔等 */ 
// i_bframe_adaptive的默认值为X264_B_ADAPT_FAST,rc.b_stat_read通常取值0

// i_bframe_adaptive可以通过命令行参数--b-adapt设定,可以取值0、1、2,默认值为1,即X264_B_ADAPT_FAST
// param.i_bframe的值可以通过命令行参数--bframes设定
if( h->param.i_bframe_adaptive == X264_B_ADAPT_TRELLIS && !h->param.rc.b_stat_read ) 
h->frames.i_delay = X264_MAX(h->param.i_bframe,3)*4; 
else 
h->frames.i_delay = h->param.i_bframe;

// mb_tree默认是开启的,i_vbv_buffer_size默认值为0,
// rc.i_lookahead默认值为40,但是对于不同的preset,rc.i_lookahead取不同的值
// rc.i_lookahead的值还可以通过命令行参数--rc-lookahead设定
if ( h->param.rc.b_mb_tree || h->param.rc.i_vbv_buffer_size ) 
h->frames.i_delay = X264_MAX( h->frames.i_delay, h->param.rc.i_lookahead ); 

i_slicetype_length = h->frames.i_delay; 
h->frames.i_delay += h->i_thread_frames - 1;  // h->i_thread_frames通常取值1
h->frames.i_delay += h->param.i_sync_lookahead;  // h->param.i_sync_lookahead通常取值0
h->frames.i_delay += h->param.b_vfr_input;  // h->param.b_vfr_input默认值为1

// param.i_bframe_pyramid的值可以通过命令行参数--b-pyramid设定,可以取值0、1、2
// --b-pyramid表示是否允许B帧作为参考帧,默认值为normal=2,none=0表示不允许B帧作为参考帧
h->frames.i_bframe_delay = h->param.i_bframe ? (h->param.i_bframe_pyramid ? 2 : 1) : 0; 

// 获取前向、后向最大参考帧数,解码缓冲区最大帧数
h->frames.i_max_ref0 = h->param.i_frame_reference; 
h->frames.i_max_ref1 = X264_MIN( h->sps->vui.i_num_reorder_frames, h->param.i_frame_reference ); 
h->frames.i_max_dpb = h->sps->vui.i_max_dec_frame_buffering; 
h->frames.b_have_lowres = !h->param.rc.b_stat_read 
 && ( h->param.rc.i_rc_method == X264_RC_ABR 
 || h->param.rc.i_rc_method == X264_RC_CRF 
 || h->param.i_bframe_adaptive 
 || h->param.i_scenecut_threshold 
 || h->param.rc.b_mb_tree 
 || h->param.analyse.i_weighted_pred );  // h->frames.b_have_lowres通常取值1
h->frames.b_have_lowres |= h->param.rc.b_stat_read && h->param.rc.i_vbv_buffer_size > 0; 
h->frames.b_have_sub8x8_esa = !!(h->param.analyse.inter & X264_ANALYSE_PSUB8x8);

// i_keyint_max默认值250,上一个idr帧和上一个关键帧的序号,初始化为负值
h->frames.i_last_idr = 
h->frames.i_last_keyframe = - h->param.i_keyint_max;
h->frames.i_input = 0; 
h->frames.i_largest_pts = h->frames.i_second_largest_pts = -1;  // 初始化帧的最大pts和次大pts值为-1
h->frames.i_poc_last_open_gop = -1;

/* Allocate room for max refs plus a few extra just in case. */

CHECKED_MALLOCZERO( h->frames.unused[0], (h->frames.i_delay + 3) * sizeof(x264_frame_t *) );
CHECKED_MALLOCZERO( h->frames.unused[1], (h->i_thread_frames + X264_REF_MAX + 4) * sizeof(x264_frame_t *) );
CHECKED_MALLOCZERO( h->frames.current, (h->param.i_sync_lookahead + h->param.i_bframe 
 + h->i_thread_frames + 3) * sizeof(x264_frame_t *) ); 
if ( h->param.analyse.i_weighted_pred > 0 )  // 如果开启了P帧加权预测,则还需要申请额外的帧空间;默认是开启的
CHECKED_MALLOCZERO( h->frames.blank_unused, h->i_thread_frames * 4 * sizeof(x264_frame_t *) );
h->i_ref[0] = h->i_ref[1] = 0;  // 初始化前向和后向参考帧数为0
h->i_cpb_delay = h->i_coded_fields = h->i_disp_fields = 0; 
h->i_prev_duration = ((uint64_t)h->param.i_fps_den * h->sps->vui.i_time_scale) 
/ ((uint64_t)h->param.i_fps_num * h->sps->vui.i_num_units_in_tick); 
h->i_disp_fields_last_frame = -1;

/* precalculate the cost of coding various combinations of bits in a single context,该函数定义在encoder/rdo.c中 */
x264_rdo_init();

/* init CPU functions */

x264_predict_16x16_init( h->param.cpu, h->predict_16x16 );  // 该函数定义在common/predict.c中 
x264_predict_8x8c_init( h->param.cpu, h->predict_8x8c );  // 该函数定义在common/predict.c中
x264_predict_8x16c_init( h->param.cpu, h->predict_8x16c );  // 该函数定义在common/predict.c中
x264_predict_8x8_init( h->param.cpu, h->predict_8x8, &h->predict_8x8_filter );  // 该函数定义在common/predict.c中
x264_predict_4x4_init( h->param.cpu, h->predict_4x4 );  // 该函数定义在common/predict.c中
x264_pixel_init( h->param.cpu, &h->pixf );  // 该函数定义在common/pixel.c中 
x264_dct_init( h->param.cpu, &h->dctf );  // 该函数定义在common/dct.c中 
x264_zigzag_init( h->param.cpu, &h->zigzagf_progressive, &h->zigzagf_interlaced ); // 该函数定义在common/dct.c中 
memcpy( &h->zigzagf, PARAM_INTERLACED ? &h->zigzagf_interlaced : &h->zigzagf_progressive, sizeof(h->zigzagf) ); 
x264_mc_init( h->param.cpu, &h->mc, h->param.b_cpu_independent );  // 该函数定义在common/mc.c中 
x264_quant_init( h, h->param.cpu, &h->quantf );  // 该函数定义在common/quant.c中
x264_deblock_init( h->param.cpu, &h->loopf, PARAM_INTERLACED ); // 该函数定义在common/deblock.c中
x264_bitstream_init( h->param.cpu, &h->bsf ); // 该函数定义在common/bitstream.c中
if( h->param.b_cabac ) 
x264_cabac_init( h );  // 该函数定义在common/cabac.c中 
else  // 函数x264_cavlc_init定义在common/vlc.c中 
x264_stack_align( x264_cavlc_init, h ); // 该函数定义在common/cpu.h中

mbcmp_init( h );  // 该函数定义在encoder/encoder.c中 
  chroma_dsp_init( h ); // 该函数定义在encoder/encoder.c中

/*  输出cpu可以利用的多媒体指令集,例如mmx、sse2、sse3等 */
p = buf + sprintf( buf, "using cpu capabilities:" );
for( int i = 0; x264_cpu_names[i].flags; i++ ) // 数组x264_cpu_names定义在common/cpu.c中
{ ... ... }
if( !h->param.cpu ) 
p += sprintf( p, " none!" );
x264_log( h, X264_LOG_INFO, "%s\n", buf );

/* 生成数组logs,其中logs[0] = 0.718、 logs[i] = 2 * log2(i + 1) + 1.718,
   其中log2表示以2为底的对数,该函数定义在encoder/analyse.c中  */

float *logs = x264_analyse_prepare_costs( h );

/* 初始化不同qp值所对应的代价,该函数定义在encoder/analyse.c中  */

for( qp = X264_MIN( h->param.rc.i_qp_min, QP_MAX_SPEC ); qp <= h->param.rc.i_qp_max; qp++ )
if ( x264_analyse_init_costs( h, logs, qp ) ) 
goto fail;
if ( x264_analyse_init_costs( h, logs, X264_LOOKAHEAD_QP ) )

goto fail;
x264_free( logs );

static const uint16_t cost_mv_correct[7] = { 24, 47, 95, 189, 379, 757, 1515 };
/* Checks for known miscompilation issues. */
if( h->cost_mv[X264_LOOKAHEAD_QP][2013] != cost_mv_correct[BIT_DEPTH-8] )
goto fail;

/* Must be volatile or else GCC will optimize it out. */

volatile int temp = 392;
if( x264_clz( temp ) != 23 )
goto fail;

h->out.i_nal = 0;
h->out.i_bitstream = X264_MAX( 1000000, h->param.i_width * h->param.i_height * 4
 * ( h->param.rc.i_rc_method == X264_RC_ABR ? pow( 0.95, h->param.rc.i_qp_min )
: pow( 0.95, h->param.rc.i_qp_constant ) * X264_MAX( 1, h->param.rc.f_ip_factor )));
h->nal_buffer_size = h->out.i_bitstream * 3/2 + 4 + 64;  /* +4 for startcode, +64 for nal_escape assembly padding */

// 有关线程池、线程锁定等代码
... ...

if ( x264_lookahead_init( h, i_slicetype_length ) ) // 该函数定义在encoder/lookahead.c中
goto fail;

for( int i = 0; i < h->param.i_threads; i++ )
if ( x264_macroblock_thread_allocate( h->thread[i], 0 ) < 0 ) // 该函数定义在common/macroblock.c中
goto fail;

/* 初始化码率控制的一些参数,该函数详细分析见:x264_ratecontrol_new 函数代码分析(码率控制) */

if ( x264_ratecontrol_new( h ) < 0 ) // 该函数定义在encoder/ratecontrol.c中
goto fail;

/* 输出profile、level等一些日志信息 */
... ...

return h;

}

(转)x264源码分析(1):main、parse、encode、x264_encoder_open函数代码分析的更多相关文章

  1. 51ak带你看MYSQL5.7源码1:main入口函数

    从事DBA工作多年 MYSQL源码也是头一次接触 尝试记录下自己看MYSQL5.7源码的历程 目录: 51ak带你看MYSQL5.7源码1:main入口函数 51ak带你看MYSQL5.7源码2:编译 ...

  2. Netty 源码解析(五): Netty 的线程池分析

    今天是猿灯塔“365篇原创计划”第五篇. 接下来的时间灯塔君持续更新Netty系列一共九篇 Netty 源码解析(一): 开始 Netty 源码解析(二): Netty 的 Channel Netty ...

  3. AngularJS源码解析4:Parse解析器的详解

    $ParseProvider简介 此服务提供者也是angularjs中用的比较多的,下面我们来详细的说下这个provider. function $ParseProvider() { var cach ...

  4. 源码详解系列(五) ------ C3P0的使用和分析(包括JNDI)

    简介 c3p0是用于创建和管理连接,利用"池"的方式复用连接减少资源开销,和其他数据源一样,也具有连接数控制.连接可靠性测试.连接泄露控制.缓存语句等功能.目前,hibernate ...

  5. Qt Creator 源码学习笔记04,多插件实现原理分析

    阅读本文大概需要 8 分钟 插件听上去很高大上,实际上就是一个个动态库,动态库在不同平台下后缀名不一样,比如在 Windows下以.dll结尾,Linux 下以.so结尾 开发插件其实就是开发一个动态 ...

  6. 【源码分享】WPF漂亮界面框架实现原理分析及源码分享

    1 源码下载 2 OSGi.NET插件应用架构概述 3 漂亮界面框架原理概述 4 漂亮界面框架实现  4.1 主程序  4.2 主程序与插件的通讯   4.2.1 主程序获取插件注册的服务   4.2 ...

  7. 曹工力荐:调试 jdk 中 rt.jar 包部分的源码(可自由增加注释,修改代码并debug)

    背景 大家知道,jdk安装的目录下,一般会有个src.zip包,这个包基本对应了rt.jar这个包.rt.jar这个包里面,就放了jdk中,jdk采用java实现的那部分类库代码,比如java.lan ...

  8. [PHP源码阅读]trim、rtrim、ltrim函数

    trim系列函数是用于去除字符串中首尾的空格或其他字符.ltrim函数只去除掉字符串首部的字符,rtrim函数只去除字符串尾部的字符. 我在github有对PHP源码更详细的注解.感兴趣的可以围观一下 ...

  9. Linux源码与编译出的目标文件汇编代码的一致性问题

    start_kernel是内核启动时比较重要的一个函数,然而我发现一个问题,我编译出来的目标文件中的汇编代码与C源码并不完全对应,这是怎么一回事呢? asmlinkage void __init st ...

随机推荐

  1. docker lnmp php

    使用 Docker 构建 LNMP 环境 https://segmentfault.com/a/1190000008833012 Docker 快速上手指南 https://segmentfault. ...

  2. Java:多线程,分别用Thread、Runnable、Callable实现线程

    并发性(concurrency)和并行性(parallel)是两个概念,并行是指在同一时刻,有多条指令在多个处理器上同时执行:并发指在同一时刻只能有一条指令执行,但多个进程指令被快速轮换执行,使得宏观 ...

  3. MFC程序开始的执行过程详述

    1)我们知道在WIN32API程序当中,程序的入口为WinMain函数,在这个函数当中我们完成注册窗口类,创建窗口,进入消息循环,最后由操作系统根据发送到程序窗口的消息调用程序的窗口函数.而在MFC程 ...

  4. 优雅得使用composer来安装各种PHP小工具

    Composer对php世界的影响是巨大的,使用composer来代替PEAR一定是大势所趋.当小伙伴们都还沉浸在composer带来的便利的时候,有没有想过如何更好的使用composer呢,网上大部 ...

  5. js 的登录验证

    $scope.startLogin = function () { console.log('loginTimeHelper:startLogin: ' + getCurrentTime()); ef ...

  6. oracle中的字符串函数详解

    花了点时间 复习.了一下字符串函数 希望对初学者有帮助 ----------连接字符串函数-----------------select concat('leiyi','hubei') from du ...

  7. LeetCode: Combinations 解题报告

    Combinations Given two integers n and k, return all possible combinations of k numbers out of 1 ... ...

  8. LeetCode: Surrounded Regions 解题报告

    Surrounded Regions Given a 2D board containing 'X' and 'O', capture all regions surrounded by 'X'. A ...

  9. 【Java】Iterator迭代器总结

    迭代器是一个对象,它的工作时遍历并选择序列中的对象,而客户端程序员不必知道或关心该序列底层的结构,此外,迭代器通常被称为轻量级对象:创建它的代价小.因此,经常可以见到对迭代器有些奇怪的限制,例如Jav ...

  10. FreeRTOS 事件标志组

    以下转载自安富莱电子: http://forum.armfly.com/forum.php 为什么要使用事件标志事件标志组是实现多任务同步的有效机制之一.也许有不理解的初学者会问采用事件标志组多麻烦, ...