x265-1.7版本-x265.h代码注释
2016-01-21 21:21
435 查看
注:问号以及未注释部分 会在x265-1.8版本内更新
/***************************************************************************** * Copyright (C) 2013 x265 project * * Authors: Steve Borho <steve@borho.org> * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111, USA. * * This program is also available under a commercial proprietary license. * For more information, contact us at license @ x265.com. *****************************************************************************/ #ifndef X265_H #define X265_H #include <stdint.h> #include "x265_config.h" #ifdef __cplusplus extern "C" { #endif /* x265_encoder: * opaque handler for encoder */ typedef struct x265_encoder x265_encoder; /* Application developers planning to link against a shared library version of * libx265 from a Microsoft Visual Studio or similar development environment * will need to define X265_API_IMPORTS before including this header. * This clause does not apply to MinGW, similar development environments, or non * Windows platforms. */ #ifdef X265_API_IMPORTS #define X265_API __declspec(dllimport) #else #define X265_API #endif //IRAP(Intra Random Access Point) 参考IRAP且在前面的称为前置图像 参考IRAP且在后面的称为后置图像 //前置图像: RADL(Random Access Decodable Leading)(不依赖IRAP前的帧) RASL(Random Access Skipped Leading)(依赖IRAP前的帧) //三种IRAP IDR(Instantaneous Decoding Refresh) CRA(Clean Random Access) BLA(Broken Link Access) //IDR 要求前置图像必须是RADL 即 IDR后续帧不依赖IDR前向帧 //CRA 允许前置图像是RASL(编码效率高) 直接从CRA进入,则其前置图像RASL的不能解码 //BLA 如果直接从CRA介入,其前置RASL不能解码,则此图像被称为BLA //时域号:关键帧号为0 底层不参考高层 最高为6 //下切换:从任何图像开始,可以丢弃其后(码率顺序)具有更高时域层标识号的图像 //上切换:从某一图像开始,可以发送具有该图像时域层标示号的图像,而该图像之前发送的图像的时域标示号小于该图像的时域标识号。 要求:从这个图像开始,其所在时域层内的所有图像不依赖该图像之前(码流顺序)相同时域层中的图像 //TSA(Temporal Sub-layer Access)和 STSA(Step-wise Temporal Sub-layer Access),用于标识时域子层切换点,即从这些图像开始可以进行时域子层上切换 //STSA:从该图像可以切换到该图像所属的时域层,要求:同一层中后续帧不依赖该图像之前的图像 //TSA:可以切换到大于或等于该图像时域层的图像 typedef enum { NAL_UNIT_CODED_SLICE_TRAIL_N = 0,//未被参考的后置图像,且非TSA、非STSA的视频片段 NAL_UNIT_CODED_SLICE_TRAIL_R, //被参考的后置图像,且非TSA、非STSA的视频片段 NAL_UNIT_CODED_SLICE_TSA_N,//未被参考的TSA图像 在时域子层打开的时候有 NAL_UNIT_CODED_SLICE_TLA_R, //被参考的TSA图像 不应该是TLA??? x265中未使用 NAL_UNIT_CODED_SLICE_STSA_N,//不被参考的STSA图像 x265中未使用 NAL_UNIT_CODED_SLICE_STSA_R,//被参考的STSA图像 x265中未使用 NAL_UNIT_CODED_SLICE_RADL_N,//RADL 前置图像(不依赖IRAP前的帧) 不被参考的前置图像 只在openGOP关闭才会有此类型 NAL_UNIT_CODED_SLICE_RADL_R,//RADL 前置图像(不依赖IRAP前的帧) 被参考的前置图像 只在openGOP关闭才会有此类型 NAL_UNIT_CODED_SLICE_RASL_N,//RASL 前置图像(依赖IRAP前的帧) 不被参考的前置图像 只在openGOP打开才会有此类型 NAL_UNIT_CODED_SLICE_RASL_R,//RASL 前置图像(依赖IRAP前的帧) 被参考的前置图像 只在openGOP打开才会有此类型 NAL_UNIT_CODED_SLICE_BLA_W_LP = 16,//BLA x265中未使用 未完成 NAL_UNIT_CODED_SLICE_BLA_W_RADL,//RADL BLA 前置图像(不依赖IRAP前的帧) x265中未使用 未完成 NAL_UNIT_CODED_SLICE_BLA_N_LP, //BLA x265中未使用 未完成 NAL_UNIT_CODED_SLICE_IDR_W_RADL,//RADL IDR 前置图像(不依赖IRAP前的帧) 可能有RADL图像的SS(视频片段)编码数据 NAL_UNIT_CODED_SLICE_IDR_N_LP,//IDR 未完成 NAL_UNIT_CODED_SLICE_CRA,//CRA 关键帧 在openGOP时使用 NAL_UNIT_VPS = 32, NAL_UNIT_SPS, NAL_UNIT_PPS, NAL_UNIT_ACCESS_UNIT_DELIMITER, NAL_UNIT_EOS, NAL_UNIT_EOB, NAL_UNIT_FILLER_DATA, NAL_UNIT_PREFIX_SEI, NAL_UNIT_SUFFIX_SEI, NAL_UNIT_INVALID = 64, } NalUnitType; /* The data within the payload is already NAL-encapsulated; the type is merely * in the struct for easy access by the calling application. All data returned * in an x265_nal, including the data in payload, is no longer valid after the * next call to x265_encoder_encode. Thus it must be used or copied before * calling x265_encoder_encode again. */ typedef struct x265_nal { uint32_t type; /* NalUnitType */ uint32_t sizeBytes; /* size in bytes */ uint8_t* payload; } x265_nal; /* Stores all analysis data for a single frame */ typedef struct x265_analysis_data { void* interData; void* intraData; uint32_t frameRecordSize; uint32_t poc; uint32_t sliceType; uint32_t numCUsInFrame; uint32_t numPartitions; } x265_analysis_data; /* Used to pass pictures into the encoder, and to get picture data back out of * the encoder. The input and output semantics are different */ typedef struct x265_picture { /* presentation time stamp: user-specified, returned on output */ int64_t pts;//显示时间戳,在编码器内环里一般就是poc的值,用于标记显示的顺序 /* display time stamp: ignored on input, copied from reordered pts. Returned * on output */ int64_t dts; /* force quantizer for != X265_QP_AUTO */ /* The value provided on input is returned with the same picture (POC) on * output */ void* userData; /* Must be specified on input pictures, the number of planes is determined * by the colorSpace value */ void* planes[3]; /* Stride is the number of bytes between row starts */ int stride[3]; /* Must be specified on input pictures. x265_picture_init() will set it to * the encoder's internal bit depth, but this field must describe the depth * of the input pictures. Must be between 8 and 16. Values larger than 8 * imply 16bits per input sample. If input bit depth is larger than the * internal bit depth, the encoder will down-shift pixels. Input samples * larger than 8bits will be masked to internal bit depth. On output the * bitDepth will be the internal encoder bit depth */ int bitDepth; /* Must be specified on input pictures: X265_TYPE_AUTO or other. * x265_picture_init() sets this to auto, returned on output */ int sliceType; /* Ignored on input, set to picture count, returned on output */ int poc; /* Must be specified on input pictures: X265_CSP_I420 or other. It must * match the internal color space of the encoder. x265_picture_init() will * initialize this value to the internal color space */ int colorSpace; /* Force the slice base QP for this picture within the encoder. Set to 0 * to allow the encoder to determine base QP */ int forceqp; /* If param.analysisMode is X265_ANALYSIS_OFF this field is ignored on input * and output. Else the user must call x265_alloc_analysis_data() to * allocate analysis buffers for every picture passed to the encoder. * * On input when param.analysisMode is X265_ANALYSIS_LOAD and analysisData * member pointers are valid, the encoder will use the data stored here to * reduce encoder work. * * On output when param.analysisMode is X265_ANALYSIS_SAVE and analysisData * member pointers are valid, the encoder will write output analysis into * this data structure */ x265_analysis_data analysisData; } x265_picture; typedef enum { X265_DIA_SEARCH, // 菱形搜索 X265_HEX_SEARCH, // 六边形搜索 X265_UMH_SEARCH, // UMH搜索 X265_STAR_SEARCH,// 星型搜索,与HM中的TZ很像,但是有一些区别 X265_FULL_SEARCH // 全搜索 } X265_ME_METHODS; /* CPU flags */ /* x86 */ #define X265_CPU_CMOV 0x0000001 #define X265_CPU_MMX 0x0000002 #define X265_CPU_MMX2 0x0000004 /* MMX2 aka MMXEXT aka ISSE */ #define X265_CPU_MMXEXT X265_CPU_MMX2 #define X265_CPU_SSE 0x0000008 #define X265_CPU_SSE2 0x0000010 #define X265_CPU_SSE3 0x0000020 #define X265_CPU_SSSE3 0x0000040 #define X265_CPU_SSE4 0x0000080 /* SSE4.1 */ #define X265_CPU_SSE42 0x0000100 /* SSE4.2 */ #define X265_CPU_LZCNT 0x0000200 /* Phenom support for "leading zero count" instruction. */ #define X265_CPU_AVX 0x0000400 /* AVX support: requires OS support even if YMM registers aren't used. */ #define X265_CPU_XOP 0x0000800 /* AMD XOP */ #define X265_CPU_FMA4 0x0001000 /* AMD FMA4 */ #define X265_CPU_AVX2 0x0002000 /* AVX2 */ #define X265_CPU_FMA3 0x0004000 /* Intel FMA3 */ #define X265_CPU_BMI1 0x0008000 /* BMI1 */ #define X265_CPU_BMI2 0x0010000 /* BMI2 */ /* x86 modifiers */ #define X265_CPU_CACHELINE_32 0x0020000 /* avoid memory loads that span the border between two cachelines */ #define X265_CPU_CACHELINE_64 0x0040000 /* 32/64 is the size of a cacheline in bytes */ #define X265_CPU_SSE2_IS_SLOW 0x0080000 /* avoid most SSE2 functions on Athlon64 */ #define X265_CPU_SSE2_IS_FAST 0x0100000 /* a few functions are only faster on Core2 and Phenom */ #define X265_CPU_SLOW_SHUFFLE 0x0200000 /* The Conroe has a slow shuffle unit (relative to overall SSE performance) */ #define X265_CPU_STACK_MOD4 0x0400000 /* if stack is only mod4 and not mod16 */ #define X265_CPU_SLOW_CTZ 0x0800000 /* BSR/BSF x86 instructions are really slow on some CPUs */ #define X265_CPU_SLOW_ATOM 0x1000000 /* The Atom is terrible: slow SSE unaligned loads, slow * SIMD multiplies, slow SIMD variable shifts, slow pshufb, * cacheline split penalties -- gather everything here that * isn't shared by other CPUs to avoid making half a dozen * new SLOW flags. */ #define X265_CPU_SLOW_PSHUFB 0x2000000 /* such as on the Intel Atom */ #define X265_CPU_SLOW_PALIGNR 0x4000000 /* such as on the AMD Bobcat */ /* ARM */ #define X265_CPU_ARMV6 0x0000001 #define X265_CPU_NEON 0x0000002 /* ARM NEON */ #define X265_CPU_FAST_NEON_MRC 0x0000004 /* Transfer from NEON to ARM register is fast (Cortex-A9) */ #define X265_MAX_SUBPEL_LEVEL 7 /* Log level */ #define X265_LOG_NONE (-1) #define X265_LOG_ERROR 0 #define X265_LOG_WARNING 1 #define X265_LOG_INFO 2 #define X265_LOG_FRAME 3 #define X265_LOG_DEBUG 4 #define X265_LOG_FULL 5 #define X265_B_ADAPT_NONE 0 #define X265_B_ADAPT_FAST 1 #define X265_B_ADAPT_TRELLIS 2 #define X265_REF_LIMIT_DEPTH 1 #define X265_REF_LIMIT_CU 2 #define X265_BFRAME_MAX 16 #define X265_MAX_FRAME_THREADS 16 #define X265_TYPE_AUTO 0x0000 /* Let x265 choose the right type */ #define X265_TYPE_IDR 0x0001 #define X265_TYPE_I 0x0002 #define X265_TYPE_P 0x0003 #define X265_TYPE_BREF 0x0004 /* Non-disposable B-frame */ #define X265_TYPE_B 0x0005 #define IS_X265_TYPE_I(x) ((x) == X265_TYPE_I || (x) == X265_TYPE_IDR) #define IS_X265_TYPE_B(x) ((x) == X265_TYPE_B || (x) == X265_TYPE_BREF) #define X265_QP_AUTO 0 #define X265_AQ_NONE 0 #define X265_AQ_VARIANCE 1 #define X265_AQ_AUTO_VARIANCE 2 /* NOTE! For this release only X265_CSP_I420 and X265_CSP_I444 are supported */ /* Supported internal color space types (according to semantics of chroma_format_idc) */ #define X265_CSP_I400 0 /* yuv 4:0:0 planar */ #define X265_CSP_I420 1 /* yuv 4:2:0 planar */ #define X265_CSP_I422 2 /* yuv 4:2:2 planar */ #define X265_CSP_I444 3 /* yuv 4:4:4 planar */ #define X265_CSP_COUNT 4 /* Number of supported internal color spaces */ /* These color spaces will eventually be supported as input pictures. The pictures will * be converted to the appropriate planar color spaces at ingest */ #define X265_CSP_NV12 4 /* yuv 4:2:0, with one y plane and one packed u+v */ #define X265_CSP_NV16 5 /* yuv 4:2:2, with one y plane and one packed u+v */ /* Interleaved color-spaces may eventually be supported as input pictures */ #define X265_CSP_BGR 6 /* packed bgr 24bits */ #define X265_CSP_BGRA 7 /* packed bgr 32bits */ #define X265_CSP_RGB 8 /* packed rgb 24bits */ #define X265_CSP_MAX 9 /* end of list */ #define X265_EXTENDED_SAR 255 /* aspect ratio explicitly specified as width:height */ /* Analysis options */ #define X265_ANALYSIS_OFF 0 #define X265_ANALYSIS_SAVE 1 #define X265_ANALYSIS_LOAD 2 typedef struct x265_cli_csp { int planes; int width[3]; int height[3]; } x265_cli_csp; static const x265_cli_csp x265_cli_csps[] = { { 1, { 0, 0, 0 }, { 0, 0, 0 } }, /* i400 */ { 3, { 0, 1, 1 }, { 0, 1, 1 } }, /* i420 */ { 3, { 0, 1, 1 }, { 0, 0, 0 } }, /* i422 */ { 3, { 0, 0, 0 }, { 0, 0, 0 } }, /* i444 */ { 2, { 0, 0 }, { 0, 1 } }, /* nv12 */ { 2, { 0, 0 }, { 0, 0 } }, /* nv16 */ }; /* rate tolerance method */ typedef enum { X265_RC_ABR,//可用比特率(ABR: available bit-rate) 固定码率 X265_RC_CQP,//固定QP模式 X265_RC_CRF } X265_RC_METHODS; /* Output statistics from encoder */ typedef struct x265_stats { double globalPsnrY; double globalPsnrU; double globalPsnrV; double globalPsnr; double globalSsim; double elapsedEncodeTime; /* wall time since encoder was opened */ double elapsedVideoTime; /* encoded picture count / frame rate */ double bitrate; /* accBits / elapsed video time */ uint64_t accBits; /* total bits output thus far */ uint32_t encodedPictureCount; /* number of output pictures thus far */ uint32_t totalWPFrames; /* number of uni-directional weighted frames used */ } x265_stats; /* String values accepted by x265_param_parse() (and CLI) for various parameters */ static const char * const x265_motion_est_names[] = { "dia", "hex", "umh", "star", "full", 0 }; static const char * const x265_source_csp_names[] = { "i400", "i420", "i422", "i444", "nv12", "nv16", 0 }; static const char * const x265_video_format_names[] = { "component", "pal", "ntsc", "secam", "mac", "undef", 0 }; static const char * const x265_fullrange_names[] = { "limited", "full", 0 }; static const char * const x265_colorprim_names[] = { "", "bt709", "undef", "", "bt470m", "bt470bg", "smpte170m", "smpte240m", "film", "bt2020", 0 }; static const char * const x265_transfer_names[] = { "", "bt709", "undef", "", "bt470m", "bt470bg", "smpte170m", "smpte240m", "linear", "log100", "log316", "iec61966-2-4", "bt1361e", "iec61966-2-1", "bt2020-10", "bt2020-12", "smpte-st-2084", "smpte-st-428", 0 }; static const char * const x265_colmatrix_names[] = { "GBR", "bt709", "undef", "", "fcc", "bt470bg", "smpte170m", "smpte240m", "YCgCo", "bt2020nc", "bt2020c", 0 }; static const char * const x265_sar_names[] = { "undef", "1:1", "12:11", "10:11", "16:11", "40:33", "24:11", "20:11", "32:11", "80:33", "18:11", "15:11", "64:33", "160:99", "4:3", "3:2", "2:1", 0 }; static const char * const x265_interlace_names[] = { "prog", "tff", "bff", 0 }; static const char * const x265_analysis_names[] = { "off", "save", "load", 0 }; /* Zones: override ratecontrol for specific sections of the video. * If zones overlap, whichever comes later in the list takes precedence. */ typedef struct x265_zone { int startFrame, endFrame; /* range of frame numbers */ int bForceQp; /* whether to use qp vs bitrate factor */ int qp; float bitrateFactor; } x265_zone; /* x265 input parameters * * For version safety you may use x265_param_alloc/free() to manage the * allocation of x265_param instances, and x265_param_parse() to assign values * by name. By never dereferencing param fields in your own code you can treat * x265_param as an opaque data structure */ typedef struct x265_param { /* x265_param_default() will auto-detect this cpu capability bitmap. it is * recommended to not change this value unless you know the cpu detection is * somehow flawed on your target hardware. The asm function tables are * process global, the first encoder configures them for all encoders */ int cpuid; /*== Parallelism Features ==*/ /* Number of concurrently encoded frames between 1 and X265_MAX_FRAME_THREADS * or 0 for auto-detection. By default x265 will use a number of frame * threads empirically determined to be optimal for your CPU core count, * between 2 and 6. Using more than one frame thread causes motion search * in the down direction to be clamped but otherwise encode behavior is * unaffected. With CQP rate control the output bitstream is deterministic * for all values of frameNumThreads greater than 1. All other forms of * rate-control can be negatively impacted by increases to the number of * frame threads because the extra concurrency adds uncertainty to the * bitrate estimations. Frame parallelism is generally limited by the the * is generally limited by the the number of CU rows * * When thread pools are used, each frame thread is assigned to a single * pool and the frame thread itself is given the node affinity of its pool. * But when no thread pools are used no node affinity is assigned. */ int frameNumThreads;//同时几个frame编码,0:自动检测(根据内核数) 1 ~ X265_MAX_FRAME_THREADS 表示有几个同时编码 ,默认为内核数 /* Comma seperated list of threads per NUMA node. If "none", then no worker * pools are created and only frame parallelism is possible. If NULL or "" * (default) x265 will use all available threads on each NUMA node. * * '+' is a special value indicating all cores detected on the node * '*' is a special value indicating all cores detected on the node and all * remaining nodes. * '-' is a special value indicating no cores on the node, same as '0' * * example strings for a 4-node system: * "" - default, unspecified, all numa nodes are used for thread pools * "*" - same as default * "none" - no thread pools are created, only frame parallelism possible * "-" - same as "none" * "10" - allocate one pool, using up to 10 cores on node 0 * "-,+" - allocate one pool, using all cores on node 1 * "+,-,+" - allocate two pools, using all cores on nodes 0 and 2 * "+,-,+,-" - allocate two pools, using all cores on nodes 0 and 2 * "-,*" - allocate three pools, using all cores on nodes 1, 2 and 3 * "8,8,8,8" - allocate four pools with up to 8 threads in each pool * * The total number of threads will be determined by the number of threads * assigned to all nodes. The worker threads will each be given affinity for * their node, they will not be allowed to migrate between nodes, but they * will be allowed to move between CPU cores within their node. * * If the three pool features: bEnableWavefront, bDistributeModeAnalysis and * bDistributeMotionEstimation are all disabled, then numaPools is ignored * and no thread pools are created. * * If "none" is specified, then all three of the thread pool features are * implicitly disabled. * * Multiple thread pools will be allocated for any NUMA node with more than * 64 logical CPU cores. But any given thread pool will always use at most * one NUMA node. * * Frame encoders are distributed between the available thread pools, and * the encoder will never generate more thread pools than frameNumThreads */ const char* numaPools; /* Enable wavefront parallel processing, greatly increases parallelism for * less than 1% compression efficiency loss. Requires a thread pool, enabled * by default */ int bEnableWavefront; // 波前并行处理 (Wavefront Parallel Processing,WPP) 默认打开(行并行) /* Use multiple threads to measure CU mode costs. Recommended for many core * CPUs. On RD levels less than 5, it may not offload enough work to warrant * the overhead. It is useful with the slow preset since it has the * rectangular predictions enabled. At RD level 5 and 6 (preset slower and * below), this feature should be an unambiguous win if you have CPU * cores available for work. Default disabled */ int bDistributeModeAnalysis; /* Use multiple threads to perform motion estimation to (ME to one reference * per thread). Recommended for many core CPUs. The more references the more * motion searches there will be to distribute. This option is often not a * win, particularly in video sequences with low motion. Default disabled */ int bDistributeMotionEstimation; /*== Logging Features ==*/ /* Enable analysis and logging distribution of CUs encoded across various * modes during mode decision. Default disabled */ int bLogCuStats; /* Enable the measurement and reporting of PSNR. Default is enabled */ int bEnablePsnr; /* Enable the measurement and reporting of SSIM. Default is disabled */ int bEnableSsim; /* The level of logging detail emitted by the encoder. X265_LOG_NONE to * X265_LOG_FULL, default is X265_LOG_INFO */ int logLevel; /* filename of CSV log. If logLevel greater than or equal to X265_LOG_FRAME, * the encoder will emit per-slice statistics to this log file in encode * order. Otherwise the encoder will emit per-stream statistics into the log * file when x265_encoder_log is called (presumably at the end of the * encode) */ const char* csvfn; /*== Internal Picture Specification ==*/ /* Internal encoder bit depth. If x265 was compiled to use 8bit pixels * (HIGH_BIT_DEPTH=0), this field must be 8, else this field must be 10. * Future builds may support 12bit pixels. */ int internalBitDepth; /* Color space of internal pictures, must match color space of input * pictures */ int internalCsp; /* Numerator and denominator of frame rate */ uint32_t fpsNum; uint32_t fpsDenom; /* Width (in pixels) of the source pictures. If this width is not an even * multiple of 4, the encoder will pad the pictures internally to meet this * minimum requirement. All valid HEVC widths are supported */ int sourceWidth; /* Height (in pixels) of the source pictures. If this height is not an even * multiple of 4, the encoder will pad the pictures internally to meet this * minimum requirement. All valid HEVC heights are supported */ int sourceHeight; /* Interlace type of source pictures. 0 - progressive pictures (default). * 1 - top field first, 2 - bottom field first. HEVC encodes interlaced * content as fields, they must be provided to the encoder in the correct * temporal order */ int interlaceMode;//场编码: 默认为0 (非场编码) 1顶场 2底场 /* Total Number of frames to be encoded, calculated from the user input * (--frames) and (--seek). In case, the input is read from a pipe, this can * remain as 0. It is later used in 2 pass RateControl, hence storing the * value in param */ int totalFrames; /*== Profile / Tier / Level ==*/ /* Note: the profile is specified by x265_param_apply_profile() */ /* Minimum decoder requirement level. Defaults to 0, which implies auto- * detection by the encoder. If specified, the encoder will attempt to bring * the encode specifications within that specified level. If the encoder is * unable to reach the level it issues a warning and emits the actual * decoder requirement. If the requested requirement level is higher than * the actual level, the actual requirement level is signaled. The value is * an specified as an integer with the level times 10, for example level * "5.1" is specified as 51, and level "5.0" is specified as 50. */ int levelIdc; /* if levelIdc is specified (non-zero) this flag will differentiate between * Main (0) and High (1) tier. Default is Main tier (0) */ int bHighTier; /* The maximum number of L0 references a P or B slice may use. This * influences the size of the decoded picture buffer. The higher this * number, the more reference frames there will be available for motion * search, improving compression efficiency of most video at a cost of * performance. Value must be between 1 and 16, default is 3 */ int maxNumReferences; //L0可以取的最大参考帧个数 取值范围(1~16,默认为3) /* Allow libx265 to emit HEVC bitstreams which do not meet strict level * requirements. Defaults to false */ int bAllowNonConformance; /*== Bitstream Options ==*/ /* Flag indicating whether VPS, SPS and PPS headers should be output with * each keyframe. Default false */ int bRepeatHeaders;//是否将VPS SPS PPS 在每一个关键帧中都写入 默认为false /* Flag indicating whether the encoder should generate start codes (Annex B * format) or length (file format) before NAL units. Default true, Annex B. * Muxers should set this to the correct value */ int bAnnexB; /* Flag indicating whether the encoder should emit an Access Unit Delimiter * NAL at the start of every access unit. Default false */ int bEnableAccessUnitDelimiters;//分解符??????? /* Enables the buffering period SEI and picture timing SEI to signal the HRD * parameters. Default is disabled */ int bEmitHRDSEI; /* Enables the emission of a user data SEI with the stream headers which * describes the encoder version, build info, and parameters. This is * very helpful for debugging, but may interfere with regression tests. * Default enabled */ int bEmitInfoSEI; /* Enable the generation of SEI messages for each encoded frame containing * the hashes of the three reconstructed picture planes. Most decoders will * validate those hashes against the reconstructed images it generates and * report any mismatches. This is essentially a debugging feature. Hash * types are MD5(1), CRC(2), Checksum(3). Default is 0, none */ int decodedPictureHashSEI; /* Enable Temporal Sub Layers while encoding, signals NAL units of coded * slices with their temporalId. Output bitstreams can be extracted either * at the base temporal layer (layer 0) with roughly half the frame rate or * at a higher temporal layer (layer 1) that decodes all the frames in the * sequence. */ int bEnableTemporalSubLayers;//是否应用时域子层???? /*== GOP structure and slice type decisions (lookahead) ==*/ /* Enable open GOP - meaning I slices are not necessarily IDR and thus frames * encoded after an I slice may reference frames encoded prior to the I * frame which have remained in the decoded picture buffer. Open GOP * generally has better compression efficiency and negligible encoder * performance impact, but the use case may preclude it. Default true */ int bOpenGOP; //打开表示,除第一帧为 X265_TYPE_IDR外,其它I帧为 X265_TYPE_I,打开可以提高压缩率,但是要保留前一个I帧,目的是可以获取当前I帧(IDR无须参考任何帧,I帧可能参考其它I帧) //关闭表示,全部I帧都为IDR帧 默认为打开,但是打开不适用随机访问 //打开即其关键帧为CAR 不同CVS(GOP)可以相互参考 关闭为IDR(不同GOP不相互参考) //打开情况:编码顺序。I帧后可能有小于I帧号的帧(RDSL) 关闭情况:I帧后的帧号一定大于I帧 /* Scene cuts closer together than this are coded as I, not IDR. */ int keyframeMin;//默认为fps长度(如果keyframeMax/10 小于fps 则等于keyframeMax/10) //功能一:最小IDR帧间隔,如果当前判断为I帧并且距离上一IDR帧大于此值,则将其置为IDR帧 //功能二:场景切换判断,值越小越容易判断为场景切换,编码I帧的概率越大 /* Maximum keyframe distance or intra period in number of frames. If 0 or 1, * all frames are I frames. A negative value is casted to MAX_INT internally * which effectively makes frame 0 the only I frame. Default is 250 */ int keyframeMax; //标记相邻两个关键帧(IDR帧)的最大间隔 /* Maximum consecutive B frames that can be emitted by the lookahead. When * b-adapt is 0 and keyframMax is greater than bframes, the lookahead emits * a fixed pattern of `bframes` B frames between each P. With b-adapt 1 the * lookahead ignores the value of bframes for the most part. With b-adapt 2 * the value of bframes determines the search (POC) distance performed in * both directions, quadratically increasing the compute load of the * lookahead. The higher the value, the more B frames the lookahead may * possibly use consecutively, usually improving compression. Default is 3, * maximum is 16 */ int bframes; //一个GOP中的连续B帧的最大个数,默认为3,最大为16 /* Sets the operating mode of the lookahead. With b-adapt 0, the GOP * structure is fixed based on the values of keyframeMax and bframes. * With b-adapt 1 a light lookahead is used to chose B frame placement. * With b-adapt 2 (trellis) a viterbi B path selection is performed */ int bFrameAdaptive; //B帧决策 默认为2。如果为0,固定B帧位置,如果为1快速决定B帧位置, 如果为2比较精细的决定B帧位置 /* When enabled, the encoder will use the B frame in the middle of each * mini-GOP larger than 2 B frames as a motion reference for the surrounding * B frames. This improves compression efficiency for a small performance * penalty. Referenced B frames are treated somewhere between a B and a P * frame by rate control. Default is enabled. */ int bBPyramid; //是否有B帧参考 开:有B 关:无B ,默认打开.注意 B:表示可以参考的B帧, b表示不可以参考的b帧, 关闭此开关,只拥有b /* A value which is added to the cost estimate of B frames in the lookahead. * It may be a positive value (making B frames appear more expensive, which * causes the lookahead to chose more P frames) or negative, which makes the * lookahead chose more B frames. Default is 0, there are no limits */ int bFrameBias; //设置B帧权重 默认值为0 取值范围(-90,100) 值越大B帧权重越高 score = score * 100 / (130 + param->bFrameBias) CostEstimateGroup::estimateFrameCost /* The number of frames that must be queued in the lookahead before it may * make slice decisions. Increasing this value directly increases the encode * latency. The longer the queue the more optimally the lookahead may make * slice decisions, particularly with b-adapt 2. When cu-tree is enabled, * the length of the queue linearly increases the effectiveness of the * cu-tree analysis. Default is 40 frames, maximum is 250 */ int lookaheadDepth; /* Use multiple worker threads to measure the estimated cost of each frame * within the lookahead. When bFrameAdaptive is 2, most frame cost estimates * will be performed in batch mode, many cost estimates at the same time, * and lookaheadSlices is ignored for batched estimates. The effect on * performance can be quite small. The higher this parameter, the less * accurate the frame costs will be (since context is lost across slice * boundaries) which will result in less accurate B-frame and scene-cut * decisions. Default is 0 - disabled. 1 is the same as 0. Max 16 */ int lookaheadSlices; //配置在lookachead可以多条slice并行操作,默认为0, 并行可能引起性能损失 /* An arbitrary threshold which determines how aggressively the lookahead * should detect scene cuts. The default (40) is recommended. */ int scenecutThreshold; //场景切换的阈值: 值越大越容易判断为场景切换,编码I帧的概率越大 /*== Coding Unit (CU) definitions ==*/ /* Maximum CU width and height in pixels. The size must be 64, 32, or 16. * The higher the size, the more efficiently x265 can encode areas of low * complexity, greatly improving compression efficiency at large * resolutions. The smaller the size, the more effective wavefront and * frame parallelism will become because of the increase in rows. default 64 * All encoders within the same process must use the same maxCUSize, until * all encoders are closed and x265_cleanup() is called to reset the value. */ uint32_t maxCUSize;//最大的CU大小 /* Minimum CU width and height in pixels. The size must be 64, 32, 16, or * 8. Default 8. All encoders within the same process must use the same * minCUSize. */ uint32_t minCUSize; /* Enable rectangular motion prediction partitions (vertical and * horizontal), available at all CU depths from 64x64 to 8x8. Default is * disabled */ int bEnableRectInter; /* Enable asymmetrical motion predictions. At CU depths 64, 32, and 16, it * is possible to use 25%/75% split partitions in the up, down, right, left * directions. For some material this can improve compression efficiency at * the cost of extra analysis. bEnableRectInter must be enabled for this * feature to be used. Default disabled */ int bEnableAMP; /*== Residual Quadtree Transform Unit (TU) definitions ==*/ /* Maximum TU width and height in pixels. The size must be 32, 16, 8 or 4. * The larger the size the more efficiently the residual can be compressed * by the DCT transforms, at the expense of more computation */ uint32_t maxTUSize; /* The additional depth the residual quad-tree is allowed to recurse beyond * the coding quad-tree, for inter coded blocks. This must be between 1 and * 4. The higher the value the more efficiently the residual can be * compressed by the DCT transforms, at the expense of much more compute */ uint32_t tuQTMaxInterDepth; /* The additional depth the residual quad-tree is allowed to recurse beyond * the coding quad-tree, for intra coded blocks. This must be between 1 and * 4. The higher the value the more efficiently the residual can be * compressed by the DCT transforms, at the expense of much more compute */ uint32_t tuQTMaxIntraDepth; /* Set the amount of rate-distortion analysis to use within quant. 0 implies * no rate-distortion optimization. At level 1 rate-distortion cost is used to * find optimal rounding values for each level (and allows psy-rdoq to be * enabled). At level 2 rate-distortion cost is used to make decimate decisions * on each 4x4 coding group (including the cost of signaling the group within * the group bitmap). Psy-rdoq is less effective at preserving energy when * RDOQ is at level 2 */ int rdoqLevel; /* Enable the implicit signaling of the sign bit of the last coefficient of * each transform unit. This saves one bit per TU at the expense of figuring * out which coefficient can be toggled with the least distortion. * Default is enabled */ int bEnableSignHiding; /* Allow intra coded blocks to be encoded directly as residual without the * DCT transform, when this improves efficiency. Checking whether the block * will benefit from this option incurs a performance penalty. Default is * disabled */ int bEnableTransformSkip; /* An integer value in range of 0 to 2000, which denotes strength of noise * reduction in intra CUs. 0 means disabled */ int noiseReductionIntra; /* An integer value in range of 0 to 2000, which denotes strength of noise * reduction in inter CUs. 0 means disabled */ int noiseReductionInter; /* Quantization scaling lists. HEVC supports 6 quantization scaling lists to * be defined; one each for Y, Cb, Cr for intra prediction and one each for * inter prediction. * * - NULL and "off" will disable quant scaling (default) * - "default" will enable the HEVC default scaling lists, which * do not need to be signaled since they are specified * - all other strings indicate a filename containing custom scaling lists * in the HM format. The encode will fail if the file is not parsed * correctly. Custom lists must be signaled in the SPS. */ const char *scalingLists; /*== Intra Coding Tools ==*/ /* Enable constrained intra prediction. This causes intra prediction to * input samples that were inter predicted. For some use cases this is * believed to me more robust to stream errors, but it has a compression * penalty on P and (particularly) B slices. Defaults to disabled */ int bEnableConstrainedIntra; /* Enable strong intra smoothing for 32x32 blocks where the reference * samples are flat. It may or may not improve compression efficiency, * depending on your source material. Defaults to disabled */ int bEnableStrongIntraSmoothing; /*== Inter Coding Tools ==*/ /* The maximum number of merge candidates that are considered during inter * analysis. This number (between 1 and 5) is signaled in the stream * headers and determines the number of bits required to signal a merge so * it can have significant trade-offs. The smaller this number the higher * the performance but the less compression efficiency. Default is 3 */ uint32_t maxNumMergeCand;//Merge选择的候选个数,默认值为3 /* Limit the motion references used for each search based on the results of * previous motion searches already performed for the same CU: If 0 all * references are always searched. If X265_REF_LIMIT_CU all motion searches * will restrict themselves to the references selected by the 2Nx2N search * at the same depth. If X265_REF_LIMIT_DEPTH the 2Nx2N motion search will * only use references that were selected by the best motion searches of the * 4 split CUs at the next lower CU depth. The two flags may be combined */ uint32_t limitReferences; /* ME search method (DIA, HEX, UMH, STAR, FULL). The search patterns * (methods) are sorted in increasing complexity, with diamond being the * simplest and fastest and full being the slowest. DIA, HEX, and UMH were * adapted from x264 directly. STAR is an adaption of the HEVC reference * encoder's three step search, while full is a naive exhaustive search. The * default is the star search, it has a good balance of performance and * compression efficiency */ int searchMethod; /* A value between 0 and X265_MAX_SUBPEL_LEVEL which adjusts the amount of * effort performed during sub-pel refine. Default is 5 */ int subpelRefine; /* The maximum distance from the motion prediction that the full pel motion * search is allowed to progress before terminating. This value can have an * effect on frame parallelism, as referenced frames must be at least this * many rows of reconstructed pixels ahead of the referencee at all times. * (When considering reference lag, the motion prediction must be ignored * because it cannot be known ahead of time). Default is 60, which is the * default max CU size (64) minus the luma HPEL half-filter length (4). If a * smaller CU size is used, the search range should be similarly reduced */ int searchRange; /* Enable availability of temporal motion vector for AMVP, default is enabled */ int bEnableTemporalMvp; /* Enable weighted prediction in P slices. This enables weighting analysis * in the lookahead, which influences slice decisions, and enables weighting * analysis in the main encoder which allows P reference samples to have a * weight function applied to them prior to using them for motion * compensation. In video which has lighting changes, it can give a large * improvement in compression efficiency. Default is enabled */ int bEnableWeightedPred; //是否应用加权P帧 (默认打开) 在亮度渐变场景中有帮助 /* Enable weighted prediction in B slices. Default is disabled */ int bEnableWeightedBiPred; //是否应用加权B帧 默认关闭 /*== Loop Filters ==*/ /* Enable the deblocking loop filter, which improves visual quality by * reducing blocking effects at block edges, particularly at lower bitrates * or higher QP. When enabled it adds another CU row of reference lag, * reducing frame parallelism effectiveness. Default is enabled */ int bEnableLoopFilter; /* deblocking filter tC offset [-6, 6] -6 light filter, 6 strong. * This is the coded div2 value, actual offset is doubled at use */ int deblockingFilterTCOffset; /* deblocking filter Beta offset [-6, 6] -6 light filter, 6 strong * This is the coded div2 value, actual offset is doubled at use */ int deblockingFilterBetaOffset; /* Enable the Sample Adaptive Offset loop filter, which reduces distortion * effects by adjusting reconstructed sample values based on histogram * analysis to better approximate the original samples. When enabled it adds * a CU row of reference lag, reducing frame parallelism effectiveness. * Default is enabled */ int bEnableSAO; /* Note: when deblocking and SAO are both enabled, the loop filter CU lag is * only one row, as they operate in series on the same row. */ /* Select the method in which SAO deals with deblocking boundary pixels. If * disabled the right and bottom boundary areas are skipped. If enabled, * non-deblocked pixels are used entirely. Default is disabled */ int bSaoNonDeblocked; /*== Analysis tools ==*/ /* A value between X265_NO_RDO_NO_RDOQ and X265_RDO_LEVEL which determines * the level of rate distortion optimizations to perform during mode * decisions and quantization. The more RDO the better the compression * efficiency at a major cost of performance. Default is no RDO (0) */ int rdLevel; /* Enable early skip decisions to avoid intra and inter analysis in likely * skip blocks. Default is disabled */ int bEnableEarlySkip; /* Use a faster search method to find the best intra mode. Default is 0 */ int bEnableFastIntra; /* Enable a faster determination of whether skipping the DCT transform will * be beneficial. Slight performance gain for some compression loss. Default * is enabled */ int bEnableTSkipFast; /* The CU Lossless flag, when enabled, compares the rate-distortion costs * for normal and lossless encoding, and chooses the best mode for each CU. * If lossless mode is chosen, the cu-transquant-bypass flag is set for that * CU */ int bCULossless; /* Specify whether to attempt to encode intra modes in B frames. By default * enabled, but only applicable for the presets which use rdLevel 5 or 6 * (veryslow and placebo). All other presets will not try intra in B frames * regardless of this setting */ int bIntraInBFrames; /* Apply an optional penalty to the estimated cost of 32x32 intra blocks in * non-intra slices. 0 is disabled, 1 enables a small penalty, and 2 enables * a full penalty. This favors inter-coding and its low bitrate over * potential increases in distortion, but usually improves performance. * Default is 0 */ int rdPenalty; /* Psycho-visual rate-distortion strength. Only has an effect in presets * which use RDO. It makes mode decision favor options which preserve the * energy of the source, at the cost of lost compression. The value must * be between 0 and 2.0, 1.0 is typical. Default 0.3 */ double psyRd; /* Strength of psycho-visual optimizations in quantization. Only has an * effect in presets which use RDOQ (rd-levels 4 and 5). The value must be * between 0 and 50, 1.0 is typical. Default 1.0 */ double psyRdoq; /* If X265_ANALYSIS_SAVE, write per-frame analysis information into analysis * buffers. if X265_ANALYSIS_LOAD, read analysis information into analysis * buffer and use this analysis information to reduce the amount of work * the encoder must perform. Default X265_ANALYSIS_OFF */ int analysisMode; /* Filename for analysisMode save/load. Default name is "x265_analysis.dat" */ const char* analysisFileName; /*== Rate Control ==*/ /* The lossless flag enables true lossless coding, bypassing scaling, * transform, quantization and in-loop filter processes. This is used for * ultra-high bitrates with zero loss of quality. It implies no rate control */ int bLossless; /* Generally a small signed integer which offsets the QP used to quantize * the Cb chroma residual (delta from luma QP specified by rate-control). * Default is 0, which is recommended */ int cbQpOffset; /* Generally a small signed integer which offsets the QP used to quantize * the Cr chroma residual (delta from luma QP specified by rate-control). * Default is 0, which is recommended */ int crQpOffset; struct { /* Explicit mode of rate-control, necessary for API users. It must * be one of the X265_RC_METHODS enum values. */ int rateControlMode; /* Base QP to use for Constant QP rate control. Adaptive QP may alter * the QP used for each block. If a QP is specified on the command line * CQP rate control is implied. Default: 32 */ int qp; /* target bitrate for Average BitRate (ABR) rate control. If a non- zero * bitrate is specified on the command line, ABR is implied. Default 0 */ int bitrate; /* qComp sets the quantizer curve compression factor. It weights the frame * quantizer based on the complexity of residual (measured by lookahead). * Default value is 0.6. Increasing it to 1 will effectively generate CQP */ double qCompress; //强度系数:如果为1.0 则 qpCuTreeOffset = qpAqOffset qCompress越大 qpCuTreeOffset越大 默认值:0.6 /* QP offset between I/P and P/B frames. Default ipfactor: 1.4 * Default pbFactor: 1.3 */ double ipFactor; double pbFactor; /* Ratefactor constant: targets a certain constant "quality". * Acceptable values between 0 and 51. Default value: 28 */ double rfConstant; /* Max QP difference between frames. Default: 4 */ int qpStep; /* Enable adaptive quantization. This mode distributes available bits between all * CTUs of a frame, assigning more bits to low complexity areas. Turning * this ON will usually affect PSNR negatively, however SSIM and visual quality * generally improves. Default: X265_AQ_VARIANCE */ int aqMode; //自适应量化 默认打开,一般打开对psnr有损失,但是对ssim和主观质量优增益,选择一下几个值,默认为1 //#define X265_AQ_NONE 0 //#define X265_AQ_VARIANCE 1 //#define X265_AQ_AUTO_VARIANCE 2 /* Sets the strength of AQ bias towards low detail CTUs. Valid only if * AQ is enabled. Default value: 1.0. Acceptable values between 0.0 and 3.0 */ double aqStrength;//自适应量化的强度 取值范围(0.0~3.0) 默认为1.0 //固定QP X265_RC_CQP 、aqMode关闭、tune psnr 都会使其关闭 /* Sets the maximum rate the VBV buffer should be assumed to refill at * Default is zero */ int vbvMaxBitrate;//最大的bits值,默认值为0 CBR规定encoder的输出码率为恒定,但是各帧编码后的大小不是固定的(I,B,P帧的存在),因此需要在encoder后面加入VBV buffer。 // Video Buffer Verifier (VBV)是一个当输入码流遵从MPEG标准时,既不会上溢出,也不会下溢出的理论上的解码缓冲器模型。 /* Sets the size of the VBV buffer in kilobits. Default is zero */ int vbvBufferSize;// 默认值为0 Video Buffering Verifier 视频缓存检验器 /* Sets how full the VBV buffer must be before playback starts. If it is less than * 1, then the initial fill is vbv-init * vbvBufferSize. Otherwise, it is * interpreted as the initial fill in kbits. Default is 0.9 */ double vbvBufferInit; /* Enable CUTree rate-control. This keeps track of the CUs that propagate temporally * across frames and assigns more bits to these CUs. Improves encode efficiency. * Default: enabled */ int cuTree;//如果当前可参考帧中的块的传播cost比较大,分配其更多的bits 默认:打开 /* In CRF mode, maximum CRF as caused by VBV. 0 implies no limit */ double rfConstantMax; /* In CRF mode, minimum CRF as caused by VBV */ double rfConstantMin; /* Multi-pass encoding */ /* Enable writing the stats in a multi-pass encode to the stat output file */ int bStatWrite; /* Enable loading data from the stat input file in a multi pass encode */ int bStatRead; /* Filename of the 2pass output/input stats file, if unspecified the * encoder will default to using x265_2pass.log */ const char* statFileName; /* temporally blur quants */ double qblur; /* temporally blur complexity */ double complexityBlur; /* Enable slow and a more detailed first pass encode in multi pass rate control */ int bEnableSlowFirstPass; /* rate-control overrides */ int zoneCount; x265_zone* zones; /* specify a text file which contains MAX_MAX_QP + 1 floating point * values to be copied into x265_lambda_tab and a second set of * MAX_MAX_QP + 1 floating point values for x265_lambda2_tab. All values * are separated by comma, space or newline. Text after a hash (#) is * ignored. The lambda tables are process-global, so these new lambda * values will affect all encoders in the same process */ const char* lambdaFileName; /* Enable stricter conditions to check bitrate deviations in CBR mode. May compromise * quality to maintain bitrate adherence */ int bStrictCbr; /* Enable adaptive quantization at CU granularity. This parameter specifies * the minimum CU size at which QP can be adjusted, i.e. Quantization Group * (QG) size. Allowed values are 64, 32, 16 provided it falls within the * inclusuve range [maxCUSize, minCUSize]. Experimental, default: maxCUSize*/ uint32_t qgSize; } rc; /*== Video Usability Information ==*/ struct { /* Aspect ratio idc to be added to the VUI. The default is 0 indicating * the apsect ratio is unspecified. If set to X265_EXTENDED_SAR then * sarWidth and sarHeight must also be set */ int aspectRatioIdc; /* Sample Aspect Ratio width in arbitrary units to be added to the VUI * only if aspectRatioIdc is set to X265_EXTENDED_SAR. This is the width * of an individual pixel. If this is set then sarHeight must also be set */ int sarWidth; /* Sample Aspect Ratio height in arbitrary units to be added to the VUI. * only if aspectRatioIdc is set to X265_EXTENDED_SAR. This is the width * of an individual pixel. If this is set then sarWidth must also be set */ int sarHeight; /* Enable overscan info present flag in the VUI. If this is set then * bEnabledOverscanAppropriateFlag will be added to the VUI. The default * is false */ int bEnableOverscanInfoPresentFlag; /* Enable overscan appropriate flag. The status of this flag is added * to the VUI only if bEnableOverscanInfoPresentFlag is set. If this * flag is set then cropped decoded pictures may be output for display. * The default is false */ int bEnableOverscanAppropriateFlag; /* Video signal type present flag of the VUI. If this is set then * videoFormat, bEnableVideoFullRangeFlag and * bEnableColorDescriptionPresentFlag will be added to the VUI. The * default is false */ int bEnableVideoSignalTypePresentFlag; /* Video format of the source video. 0 = component, 1 = PAL, 2 = NTSC, * 3 = SECAM, 4 = MAC, 5 = unspecified video format is the default */ int videoFormat; /* Video full range flag indicates the black level and range of the luma * and chroma signals as derived from E′Y, E′PB, and E′PR or E′R, E′G, * and E′B real-valued component signals. The default is false */ int bEnableVideoFullRangeFlag; /* Color description present flag in the VUI. If this is set then * color_primaries, transfer_characteristics and matrix_coeffs are to be * added to the VUI. The default is false */ int bEnableColorDescriptionPresentFlag; /* Color primaries holds the chromacity coordinates of the source * primaries. The default is 2 */ int colorPrimaries; /* Transfer characteristics indicates the opto-electronic transfer * characteristic of the source picture. The default is 2 */ int transferCharacteristics; /* Matrix coefficients used to derive the luma and chroma signals from * the red, blue and green primaries. The default is 2 */ int matrixCoeffs; /* Chroma location info present flag adds chroma_sample_loc_type_top_field and * chroma_sample_loc_type_bottom_field to the VUI. The default is false */ int bEnableChromaLocInfoPresentFlag; /* Chroma sample location type top field holds the chroma location in * the top field. The default is 0 */ int chromaSampleLocTypeTopField; /* Chroma sample location type bottom field holds the chroma location in * the bottom field. The default is 0 */ int chromaSampleLocTypeBottomField; /* Default display window flag adds def_disp_win_left_offset, * def_disp_win_right_offset, def_disp_win_top_offset and * def_disp_win_bottom_offset to the VUI. The default is false */ int bEnableDefaultDisplayWindowFlag; /* Default display window left offset holds the left offset with the * conformance cropping window to further crop the displayed window */ int defDispWinLeftOffset; /* Default display window right offset holds the right offset with the * conformance cropping window to further crop the displayed window */ int defDispWinRightOffset; /* Default display window top offset holds the top offset with the * conformance cropping window to further crop the displayed window */ int defDispWinTopOffset; /* Default display window bottom offset holds the bottom offset with the * conformance cropping window to further crop the displayed window */ int defDispWinBottomOffset; } vui; /* SMPTE ST 2086 mastering display color volume SEI info, specified as a * string which is parsed when the stream header SEI are emitted. The string * format is "G(%hu,%hu)B(%hu,%hu)R(%hu,%hu)WP(%hu,%hu)L(%u,%u)" where %hu * are unsigned 16bit integers and %u are unsigned 32bit integers. The SEI * includes X,Y display primaries for RGB channels, white point X,Y and * max,min luminance values. */ const char* masteringDisplayColorVolume; /* Content light level info SEI, specified as a string which is parsed when * the stream header SEI are emitted. The string format is "%hu,%hu" where * %hu are unsigned 16bit integers. The first value is the max content light * level (or 0 if no maximum is indicated), the second value is the maximum * picture average light level (or 0). */ const char* contentLightLevelInfo; } x265_param; /* x265_param_alloc: * Allocates an x265_param instance. The returned param structure is not * special in any way, but using this method together with x265_param_free() * and x265_param_parse() to set values by name allows the application to treat * x265_param as an opaque data struct for version safety */ x265_param *x265_param_alloc(void); /* x265_param_free: * Use x265_param_free() to release storage for an x265_param instance * allocated by x265_param_alloc() */ void x265_param_free(x265_param *);//释放param信息,ffmpeg会调用此接口libx265_encode_close /* x265_param_default: * Initialize an x265_param structure to default values */ void x265_param_default(x265_param *param); /* x265_param_parse: * set one parameter by name. * returns 0 on success, or returns one of the following errors. * note: BAD_VALUE occurs only if it can't even parse the value, * numerical range is not checked until x265_encoder_open(). * value=NULL means "true" for boolean options, but is a BAD_VALUE for non-booleans. */ #define X265_PARAM_BAD_NAME (-1) #define X265_PARAM_BAD_VALUE (-2) int x265_param_parse(x265_param *p, const char *name, const char *value); /* x265_param_apply_profile: * Applies the restrictions of the given profile. (one of below) */ static const char * const x265_profile_names[] = { "main", "main10", "mainstillpicture", 0 }; /* (can be NULL, in which case the function will do nothing) * returns 0 on success, negative on failure (e.g. invalid profile name). */ int x265_param_apply_profile(x265_param *, const char *profile); /* x265_param_default_preset: * The same as x265_param_default, but also use the passed preset and tune * to modify the default settings. * (either can be NULL, which implies no preset or no tune, respectively) * * Currently available presets are, ordered from fastest to slowest: */ static const char * const x265_preset_names[] = { "ultrafast", "superfast", "veryfast", "faster", "fast", "medium", "slow", "slower", "veryslow", "placebo", 0 }; /* The presets can also be indexed numerically, as in: * x265_param_default_preset( ¶m, "3", ... ) * with ultrafast mapping to "0" and placebo mapping to "9". This mapping may * of course change if new presets are added in between, but will always be * ordered from fastest to slowest. * * Warning: the speed of these presets scales dramatically. Ultrafast is a full * 100 times faster than placebo! * * Currently available tunings are: */ static const char * const x265_tune_names[] = { "psnr", "ssim", "grain", "zerolatency", "fastdecode", 0 }; /* returns 0 on success, negative on failure (e.g. invalid preset/tune name). */ int x265_param_default_preset(x265_param *, const char *preset, const char *tune); /* x265_picture_alloc: * Allocates an x265_picture instance. The returned picture structure is not * special in any way, but using this method together with x265_picture_free() * and x265_picture_init() allows some version safety. New picture fields will * always be added to the end of x265_picture */ x265_picture *x265_picture_alloc(void); /* x265_picture_free: * Use x265_picture_free() to release storage for an x265_picture instance * allocated by x265_picture_alloc() */ void x265_picture_free(x265_picture *); /* x265_picture_init: * Initialize an x265_picture structure to default values. It sets the pixel * depth and color space to the encoder's internal values and sets the slice * type to auto - so the lookahead will determine slice type. */ void x265_picture_init(x265_param *param, x265_picture *pic); /* x265_max_bit_depth: * Specifies the numer of bits per pixel that x265 uses internally to * represent a pixel, and the bit depth of the output bitstream. * param->internalBitDepth must be set to this value. x265_max_bit_depth * will be 8 for default builds, 10 for HIGH_BIT_DEPTH builds. */ X265_API extern const int x265_max_bit_depth; /* x265_version_str: * A static string containing the version of this compiled x265 library */ X265_API extern const char *x265_version_str; /* x265_build_info: * A static string describing the compiler and target architecture */ X265_API extern const char *x265_build_info_str; /* Force a link error in the case of linking against an incompatible API version. * Glue #defines exist to force correct macro expansion; the final output of the macro * is x265_encoder_open_##X265_BUILD (for purposes of dlopen). */ #define x265_encoder_glue1(x, y) x ## y #define x265_encoder_glue2(x, y) x265_encoder_glue1(x, y) #define x265_encoder_open x265_encoder_glue2(x265_encoder_open_, X265_BUILD) /* x265_encoder_open: * create a new encoder handler, all parameters from x265_param are copied */ x265_encoder* x265_encoder_open(x265_param *); /* x265_encoder_parameters: * copies the current internal set of parameters to the pointer provided * by the caller. useful when the calling application needs to know * how x265_encoder_open has changed the parameters. * note that the data accessible through pointers in the returned param struct * (e.g. filenames) should not be modified by the calling application. */ void x265_encoder_parameters(x265_encoder *, x265_param *); /* x265_encoder_headers: * return the SPS and PPS that will be used for the whole stream. * *pi_nal is the number of NAL units outputted in pp_nal. * returns negative on error, total byte size of payload data on success * the payloads of all output NALs are guaranteed to be sequential in memory. */ int x265_encoder_headers(x265_encoder *, x265_nal **pp_nal, uint32_t *pi_nal); /* x265_encoder_encode: * encode one picture. * *pi_nal is the number of NAL units outputted in pp_nal. * returns negative on error, 1 if a picture and access unit were output, * or zero if the encoder pipeline is still filling or is empty after flushing. * the payloads of all output NALs are guaranteed to be sequential in memory. * To flush the encoder and retrieve delayed output pictures, pass pic_in as NULL. * Once flushing has begun, all subsequent calls must pass pic_in as NULL. */ int x265_encoder_encode(x265_encoder *encoder, x265_nal **pp_nal, uint32_t *pi_nal, x265_picture *pic_in, x265_picture *pic_out); /* x265_encoder_reconfig: * various parameters from x265_param are copied. * this takes effect immediately, on whichever frame is encoded next; * returns 0 on success, negative on parameter validation error. * * not all parameters can be changed; see the actual function for a * detailed breakdown. since not all parameters can be changed, moving * from preset to preset may not always fully copy all relevant parameters, * but should still work usably in practice. however, more so than for * other presets, many of the speed shortcuts used in ultrafast cannot be * switched out of; using reconfig to switch between ultrafast and other * presets is not recommended without a more fine-grained breakdown of * parameters to take this into account. */ int x265_encoder_reconfig(x265_encoder *, x265_param *); /* x265_encoder_get_stats: * returns encoder statistics */ void x265_encoder_get_stats(x265_encoder *encoder, x265_stats *, uint32_t statsSizeBytes); /* x265_encoder_log: * write a line to the configured CSV file. If a CSV filename was not * configured, or file open failed, or the log level indicated frame level * logging, this function will perform no write. */ void x265_encoder_log(x265_encoder *encoder, int argc, char **argv); /* x265_encoder_close: * close an encoder handler */ void x265_encoder_close(x265_encoder *);//释放编码器 会在ffmpeg中调用 /* x265_cleanup: * release library static allocations, reset configured CTU size */ void x265_cleanup(void); /* === Multi-lib API === * By using this method to gain access to the libx265 interfaces, you allow shim * implementations of x265_api_get() to choose between various available libx265 * libraries based on the encoder parameters. The most likely use case is to * choose between 8bpp and 16bpp builds of libx265. */ typedef struct x265_api { /* libx265 public API functions, documented above with x265_ prefixes */ x265_param* (*param_alloc)(void); void (*param_free)(x265_param*); void (*param_default)(x265_param*); int (*param_parse)(x265_param*, const char*, const char*); int (*param_apply_profile)(x265_param*, const char*); int (*param_default_preset)(x265_param*, const char*, const char *); x265_picture* (*picture_alloc)(void); void (*picture_free)(x265_picture*); void (*picture_init)(x265_param*, x265_picture*); x265_encoder* (*encoder_open)(x265_param*); void (*encoder_parameters)(x265_encoder*, x265_param*); int (*encoder_reconfig)(x265_encoder*, x265_param*); int (*encoder_headers)(x265_encoder*, x265_nal**, uint32_t*); int (*encoder_encode)(x265_encoder*, x265_nal**, uint32_t*, x265_picture*, x265_picture*); void (*encoder_get_stats)(x265_encoder*, x265_stats*, uint32_t); void (*encoder_log)(x265_encoder*, int, char**); void (*encoder_close)(x265_encoder*); void (*cleanup)(void); const char* version_str; const char* build_info_str; int max_bit_depth; } x265_api; /* Force a link error in the case of linking against an incompatible API version. * Glue #defines exist to force correct macro expansion; the final output of the macro * is x265_api_get_##X265_BUILD (for purposes of dlopen). */ #define x265_api_glue1(x, y) x ## y #define x265_api_glue2(x, y) x265_api_glue1(x, y) #define x265_api_get x265_api_glue2(x265_api_get_, X265_BUILD) /* x265_api_get: * Retrieve the programming interface for a linked x265 library. * May return NULL if no library is available that supports the * requested bit depth. If bitDepth is 0 the function is guarunteed * to return a non-NULL x265_api pointer, from the linked libx265. * * If the requested bitDepth is not supported by the linked libx265, * it will attempt to dynamically bind x265_api_get() from a shared * library with an appropriate name: * 8bit: libx265_main.so * 10bit: libx265_main10.so * Obviously the shared library file extension is platform specific */ const x265_api* x265_api_get(int bitDepth); #ifdef __cplusplus } #endif #endif // X265_H
相关文章推荐
- 01-SpringMVC Hello,World
- java String 类的replace 和replaceAll 方法替换“?”号
- Python实现Logistic 回归实例
- Mac OS安装java runtime环境
- 用java -X 命令查看JVM的配置说明:
- java包及其使用
- 【JAVA学习】单例模式的七种写法
- Spring面试题一
- 第十七周oj刷题——Problem B: 分数类的四则运算【C++】
- java servlet 总览
- 【window操作系统下Github版本的回滚问题】
- C# DataTable的詳細用法
- Socket游戏编程-五子棋(服务器+多客户端)
- Go语言中调用C语言----类型转换篇
- CPU满格的元凶,这回是由于QTimer引起的(默认interval是0,太猛)
- python[五]:python爬虫进阶
- 在 ASP.NET MVC 3 中应用 KindEditor
- 简单的web实现
- 我在JavaWeb开发中的SSH整合步骤
- 记录——《C Primer Plus (第五版)》第十二章编程练习第1-8题