mirror/libbpg
1
0
Fork 1
Code Issues Pull requests Releases Wiki Activity
libbpg/x265/source/x265.h
King_DuckZ 35a8402710 libbpg-0.9.6
2015-10-27 11:46:00 +01:00

1488 lines
68 KiB
C
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/*****************************************************************************
* 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
typedef enum
{
NAL_UNIT_CODED_SLICE_TRAIL_N = 0,
NAL_UNIT_CODED_SLICE_TRAIL_R,
NAL_UNIT_CODED_SLICE_TSA_N,
NAL_UNIT_CODED_SLICE_TLA_R,
NAL_UNIT_CODED_SLICE_STSA_N,
NAL_UNIT_CODED_SLICE_STSA_R,
NAL_UNIT_CODED_SLICE_RADL_N,
NAL_UNIT_CODED_SLICE_RADL_R,
NAL_UNIT_CODED_SLICE_RASL_N,
NAL_UNIT_CODED_SLICE_RASL_R,
NAL_UNIT_CODED_SLICE_BLA_W_LP = 16,
NAL_UNIT_CODED_SLICE_BLA_W_RADL,
NAL_UNIT_CODED_SLICE_BLA_N_LP,
NAL_UNIT_CODED_SLICE_IDR_W_RADL,
NAL_UNIT_CODED_SLICE_IDR_N_LP,
NAL_UNIT_CODED_SLICE_CRA,
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;
/* cu statistics */
typedef struct x265_cu_stats
{
double percentSkipCu[4]; // Percentage of skip cu in all depths
double percentMergeCu[4]; // Percentage of merge cu in all depths
double percentIntraDistribution[4][3]; // Percentage of DC, Planar, Angular intra modes in all depths
double percentInterDistribution[4][3]; // Percentage of 2Nx2N inter, rect and amp in all depths
double percentIntraNxN; // Percentage of 4x4 cu
/* All the above values will add up to 100%. */
} x265_cu_stats;
/* Frame level statistics */
typedef struct x265_frame_stats
{
double qp;
double rateFactor;
double psnrY;
double psnrU;
double psnrV;
double psnr;
double ssim;
double decideWaitTime;
double row0WaitTime;
double wallTime;
double refWaitWallTime;
double totalCTUTime;
double stallTime;
double avgWPP;
double avgLumaDistortion;
double avgChromaDistortion;
double avgPsyEnergy;
double avgResEnergy;
double avgLumaLevel;
uint64_t bits;
int encoderOrder;
int poc;
int countRowBlocks;
int list0POC[16];
int list1POC[16];
uint16_t maxLumaLevel;
char sliceType;
int bScenecut;
x265_cu_stats cuStats;
} x265_frame_stats;
/* 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;
/* 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;
/* An array of quantizer offsets to be applied to this image during encoding.
* These are added on top of the decisions made by rateControl.
* Adaptive quantization must be enabled to use this feature. These quantizer
* offsets should be given for each 16x16 block. Behavior if quant
* offsets differ between encoding passes is undefined. */
float *quantOffsets;
/* Frame level statistics */
x265_frame_stats frameData;
} x265_picture;
typedef enum
{
X265_DIA_SEARCH,
X265_HEX_SEARCH,
X265_UMH_SEARCH,
X265_STAR_SEARCH,
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_DEBUG 3
#define X265_LOG_FULL 4
#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
#define X265_AQ_AUTO_VARIANCE_BIASED 3
/* 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,
X265_RC_CQP,
X265_RC_CRF
} X265_RC_METHODS;
/* slice type statistics */
typedef struct x265_sliceType_stats
{
double avgQp;
double bitrate;
double psnrY;
double psnrU;
double psnrV;
double ssim;
uint32_t numPics;
} x265_sliceType_stats;
/* 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_sliceType_stats statsI; /* statistics of I slice */
x265_sliceType_stats statsP; /* statistics of P slice */
x265_sliceType_stats statsB; /* statistics of B slice */
uint16_t maxCLL; /* maximum content light level */
uint16_t maxFALL; /* maximum frame average light level */
} 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", "arib-std-b67", 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;
/* 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;
/* 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. Now deprecated */
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. Now deprecated */
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;
/* 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;
/* 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;
/* 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;
/* Scene cuts closer together than this are coded as I, not IDR. */
int keyframeMin;
/* 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;
/* 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;
/* 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;
/* 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;
/* 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;
/* 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;
/* An arbitrary threshold which determines how aggressively the lookahead
* should detect scene cuts. The default (40) is recommended. */
int scenecutThreshold;
/*== 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;
/* 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;
/* 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;
/* Enable weighted prediction in B slices. Default is disabled */
int bEnableWeightedBiPred;
/*== 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;
/* 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;
/* 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;
/* Sets the maximum rate the VBV buffer should be assumed to refill at
* Default is zero */
int vbvMaxBitrate;
/* Sets the size of the VBV buffer in kilobits. Default is zero */
int vbvBufferSize;
/* 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;
/* 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;
/* Maximum Content light level(MaxCLL), specified as integer that indicates the
* maximum pixel intensity level in units of 1 candela per square metre of the
* bitstream. x265 will also calculate MaxCLL programmatically from the input
* pixel values and set in the Content light level info SEI */
uint16_t maxCLL;
/* Maximum Frame Average Light Level(MaxFALL), specified as integer that indicates
* the maximum frame average intensity level in units of 1 candela per square
* metre of the bitstream. x265 will also calculate MaxFALL programmatically
* from the input pixel values and set in the Content light level info SEI */
uint16_t maxFALL;
/* Minimum luma level of input source picture, specified as a integer which
* would automatically increase any luma values below the specified --min-luma
* value to that value. */
uint16_t minLuma;
/* Maximum luma level of input source picture, specified as a integer which
* would automatically decrease any luma values above the specified --max-luma
* value to that value. */
uint16_t maxLuma;
} 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 *);
/* 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);
static const char * const x265_profile_names[] = {
/* HEVC v1 */
"main", "main10", "mainstillpicture", /* alias */ "msp",
/* HEVC v2 (Range Extensions) */
"main-intra", "main10-intra",
"main444-8", "main444-intra", "main444-stillpicture",
"main422-10", "main422-10-intra",
"main444-10", "main444-10-intra",
"main12", "main12-intra",
"main422-12", "main422-12-intra",
"main444-12", "main444-12-intra",
"main444-16-intra", "main444-16-stillpicture", /* Not Supported! */
0
};
/* x265_param_apply_profile:
* Applies the restrictions of the given profile. (one of x265_profile_names)
* (can be NULL, in which case the function will do nothing)
* Note: the detected profile can be lower than the one specified to this
* function. This function will force the encoder parameters to fit within
* the specified profile, or fail if that is impossible.
* 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( &param, "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:
* This function is deprecated */
void x265_encoder_log(x265_encoder *encoder, int argc, char **argv);
/* x265_encoder_close:
* close an encoder handler */
void x265_encoder_close(x265_encoder *);
/* x265_cleanup:
* release library static allocations, reset configured CTU size */
void x265_cleanup(void);
#define X265_MAJOR_VERSION 1
/* === Multi-lib API ===
* By using this method to gain access to the libx265 interfaces, you allow run-
* time selection between various available libx265 libraries based on the
* encoder parameters. The most likely use case is to choose between Main and
* Main10 builds of libx265. */
typedef struct x265_api
{
int api_major_version; /* X265_MAJOR_VERSION */
int api_build_number; /* X265_BUILD (soname) */
int sizeof_param; /* sizeof(x265_param) */
int sizeof_picture; /* sizeof(x265_picture) */
int sizeof_analysis_data; /* sizeof(x265_analysis_data) */
int sizeof_zone; /* sizeof(x265_zone) */
int sizeof_stats; /* sizeof(x265_stats) */
int bit_depth;
const char* version_str;
const char* build_info_str;
/* 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);
int sizeof_frame_stats; /* sizeof(x265_frame_stats) */
/* add new pointers to the end, or increment X265_MAJOR_VERSION */
} 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);
/* x265_api_query:
* Retrieve the programming interface for a linked x265 library, like
* x265_api_get(), except this function accepts X265_BUILD as the second
* argument rather than using the build number as part of the function name.
* Applications which dynamically link to libx265 can use this interface to
* query the library API and achieve a relative amount of version skew
* flexibility. The function may return NULL if the library determines that
* the apiVersion that your application was compiled against is not compatible
* with the library you have linked with.
*
* api_major_version will be incremented any time non-backward compatible
* changes are made to any public structures or functions. If
* api_major_version does not match X265_MAJOR_VERSION from the x265.h your
* application compiled against, your application must not use the returned
* x265_api pointer.
*
* Users of this API *must* also validate the sizes of any structures which
* are not treated as opaque in application code. For instance, if your
* application dereferences a x265_param pointer, then it must check that
* api->sizeof_param matches the sizeof(x265_param) that your application
* compiled with. */
const x265_api* x265_api_query(int bitDepth, int apiVersion, int* err);
#define X265_API_QUERY_ERR_NONE 0 /* returned API pointer is non-NULL */
#define X265_API_QUERY_ERR_VER_REFUSED 1 /* incompatible version skew */
#define X265_API_QUERY_ERR_LIB_NOT_FOUND 2 /* libx265_main10 not found, for ex */
#define X265_API_QUERY_ERR_FUNC_NOT_FOUND 3 /* unable to bind x265_api_query */
#define X265_API_QUERY_ERR_WRONG_BITDEPTH 4 /* libx265_main10 not 10bit, for ex */
static const char * const x265_api_query_errnames[] = {
"api queried from libx265",
"libx265 version is not compatible with this application",
"unable to bind a libx265 with requested bit depth",
"unable to bind x265_api_query from libx265",
"libx265 has an invalid bitdepth"
};
#ifdef __cplusplus
}
#endif
#endif // X265_H
Reference in a new issue View git blame Copy permalink