x265 HEVC Encoder

[LigH.de]

None of them will have insisted in keeping Windows XP supported...

[El Heggunte]

Just to make things as clear as possible --- as I said before,
x265 can go and should have gone 64-bit only.

So it would never ever have gotten in the way of the 32-bit builds of ffmpeg

[vhelp]

i did not see any notable speed improvement since, using build 0.9+31 is my last bv since download sites (ie, mefiafire) are blocked on my pc's.

for 720x480 content via avisynth script and --preset ultrafast:

my netbook (atom cpu) gives me <1fps using ultrafast, while my desktop home pc gives me betwen 2.5fps and 6fps depending on picture complexities--ie, on mostly dark or solid areas (the more the greater or lessor the encoding speed) than on areas or all frames with various kinds of motion complexities, thus explaining the speed variance in those lessor detailed frames. i think that everybody knows this fact by now.

and i agree that ultrafast may not be very usefull in some pc setups and videos, but on very slow computers like mine, its better than nothing and testing is still worthwhile. i just wish that the team could resolve the cpu or instruction incompatabilities that cause my netbook intel atom and two intel core i3 and intel core i7 computers to fail on the latest x265.exe encoders.

[racer-x]

Lets be realistic, it will be years (at least) before hevc overtakes avs as the standard platform. The cpu horsepower required to decode hevc is rediculous to say the least even @ 1080p. It's fun to experiment with these new codecs, but I don't plan to use them anytime soon.

No disrespect to the developers, keep them comming.............

[vhelp]

my realistic threashold is for 720x480 since my desktop pc can easily handle it with the current flavors of h265 codecs floating around. even though we've been in the 1080p era for a while i'm still using SD content since that is my main source for the time being. others with better systems may use 720p and 1080p as their primary test bed. all are good, and should be tested, imo. but we need to get organized, create several groups to test this and that, and so on, but in this early stage, that is not the case. anyway. for the analitical work, i use avisynth + l-smash to decode and review frames up close. my goal(s) in part of this is to find out what params serve for "grain retension" and then fine tune it, etc., plus making sure that such params primary function remain consistant through the builds. there are no "template" foundations to work from. we have to create them, make them standards, and use them as part in all these tests.

[vhelp]

i was searching for the listing of the all the parameters for the --preset but can't find it.
i am looking for the latest changes to these presets, for current 09+31 and later builds.

http://x265.readthedocs.org/en/default/

--preset, -p <integer|string>

Sets parameters to preselected values, trading off compression efficiency against encoding
speed. These parameters are applied before all other input parameters are applied, and so
you can override any parameters that these values control.

0. ultrafast   - 
1. superfast   - 
2. veryfast    - 
3. faster      - 
4. fast        - 
5. medium(def) - 
6. slow        - 
7. slower      - 
8. veryslow    - 
9. placebo     -

[Selur]

look into: /source/common/param.cpp

extern "C"
int x265_param_default_preset(x265_param *param, const char *preset, const char *tune)
{
    x265_param_default(param);

    if (preset)
    {
        char *end;
        int i = strtol(preset, &end, 10);
        if (*end == 0 && i >= 0 && i < (int)(sizeof(x265_preset_names) / sizeof(*x265_preset_names) - 1))
            preset = x265_preset_names[i];

        if (!strcmp(preset, "ultrafast"))
        {
            param->lookaheadDepth = 10;
            param->scenecutThreshold = 0; // disable lookahead
            param->maxCUSize = 32;
            param->searchRange = 25;
            param->bFrameAdaptive = 0;
            param->subpelRefine = 0;
            param->searchMethod = X265_DIA_SEARCH;
            param->bEnableRectInter = 0;
            param->bEnableAMP = 0;
            param->bEnableEarlySkip = 1;
            param->bEnableCbfFastMode = 1;
            param->bEnableSAO = 0;
            param->bEnableSignHiding = 0;
            param->bEnableWeightedPred = 0;
            param->maxNumReferences = 1;
            param->rc.aqStrength = 0.0;
            param->rc.aqMode = X265_AQ_NONE;
            param->rc.cuTree = 0;
        }
        else if (!strcmp(preset, "superfast"))
        {
            param->lookaheadDepth = 10;
            param->maxCUSize = 32;
            param->searchRange = 44;
            param->bFrameAdaptive = 0;
            param->subpelRefine = 1;
            param->bEnableRectInter = 0;
            param->bEnableAMP = 0;
            param->bEnableEarlySkip = 1;
            param->bEnableCbfFastMode = 1;
            param->bEnableWeightedPred = 0;
            param->maxNumReferences = 1;
            param->rc.aqStrength = 0.0;
            param->rc.aqMode = X265_AQ_NONE;
            param->rc.cuTree = 0;
        }
        else if (!strcmp(preset, "veryfast"))
        {
            param->lookaheadDepth = 15;
            param->maxCUSize = 32;
            param->bFrameAdaptive = 0;
            param->subpelRefine = 1;
            param->bEnableRectInter = 0;
            param->bEnableAMP = 0;
            param->bEnableEarlySkip = 1;
            param->bEnableCbfFastMode = 1;
            param->maxNumReferences = 1;
            param->rc.cuTree = 0;
        }
        else if (!strcmp(preset, "faster"))
        {
            param->lookaheadDepth = 15;
            param->bFrameAdaptive = 0;
            param->bEnableRectInter = 0;
            param->bEnableAMP = 0;
            param->bEnableEarlySkip = 1;
            param->bEnableCbfFastMode = 1;
            param->maxNumReferences = 1;
            param->rc.cuTree = 0;
        }
        else if (!strcmp(preset, "fast"))
        {
            param->lookaheadDepth = 15;
            param->bEnableRectInter = 0;
            param->bEnableAMP = 0;
        }
        else if (!strcmp(preset, "medium"))
        {
            /* defaults */
        }
        else if (!strcmp(preset, "slow"))
        {
            param->lookaheadDepth = 25;
            param->rdLevel = 4;
            param->subpelRefine = 3;
            param->maxNumMergeCand = 3;
            param->searchMethod = X265_STAR_SEARCH;
        }
        else if (!strcmp(preset, "slower"))
        {
            param->lookaheadDepth = 30;
            param->bframes = 8;
            param->tuQTMaxInterDepth = 2;
            param->tuQTMaxIntraDepth = 2;
            param->rdLevel = 6;
            param->subpelRefine = 3;
            param->maxNumMergeCand = 3;
            param->searchMethod = X265_STAR_SEARCH;
        }
        else if (!strcmp(preset, "veryslow"))
        {
            param->lookaheadDepth = 40;
            param->bframes = 8;
            param->tuQTMaxInterDepth = 3;
            param->tuQTMaxIntraDepth = 3;
            param->rdLevel = 6;
            param->subpelRefine = 4;
            param->maxNumMergeCand = 4;
            param->searchMethod = X265_STAR_SEARCH;
            param->maxNumReferences = 5;
        }
        else if (!strcmp(preset, "placebo"))
        {
            param->lookaheadDepth = 60;
            param->searchRange = 92;
            param->bframes = 8;
            param->tuQTMaxInterDepth = 4;
            param->tuQTMaxIntraDepth = 4;
            param->rdLevel = 6;
            param->subpelRefine = 5;
            param->maxNumMergeCand = 5;
            param->searchMethod = X265_STAR_SEARCH;
            param->bEnableTransformSkip = 1;
            param->maxNumReferences = 5;
            // TODO: optimized esa
        }
        else
            return -1;
    }
    if (tune)
    {
        if (!strcmp(tune, "psnr"))
        {
            param->rc.aqStrength = 0.0;
        }
        else if (!strcmp(tune, "ssim"))
        {
            param->rc.aqMode = X265_AQ_AUTO_VARIANCE;
        }
        else if (!strcmp(tune, "fastdecode") ||
                 !strcmp(tune, "fast-decode"))
        {
            param->bEnableLoopFilter = 0;
            param->bEnableSAO = 0;
            param->bEnableWeightedPred = 0;
            param->bEnableWeightedBiPred = 0;
        }
        else if (!strcmp(tune, "zerolatency") ||
                 !strcmp(tune, "zero-latency"))
        {
            param->bFrameAdaptive = 0;
            param->bframes = 0;
            param->lookaheadDepth = 0;
            param->scenecutThreshold = 0;
            param->rc.cuTree = 0;
        }
        else
            return -1;
    }

    return 0;
}

and since the defauls are the base for the profiles:

extern "C"
void x265_param_default(x265_param *param)
{
    memset(param, 0, sizeof(x265_param));

    /* Applying non-zero default values to all elements in the param structure */
    param->cpuid = x265::cpu_detect();
    param->logLevel = X265_LOG_INFO;
    param->bEnableWavefront = 1;
    param->frameNumThreads = 0;
    param->poolNumThreads = 0;
    param->csvfn = NULL;

    /* Source specifications */
    param->internalBitDepth = x265_max_bit_depth;
    param->internalCsp = X265_CSP_I420;

    /* CU definitions */
    param->maxCUSize = 64;
    param->tuQTMaxInterDepth = 1;
    param->tuQTMaxIntraDepth = 1;

    /* Coding Structure */
    param->keyframeMin = 0;
    param->keyframeMax = 250;
    param->bOpenGOP = 1;
    param->bframes = 4;
    param->lookaheadDepth = 20;
    param->bFrameAdaptive = X265_B_ADAPT_TRELLIS;
    param->bBPyramid = 1;
    param->scenecutThreshold = 40; /* Magic number pulled in from x264 */

    /* Intra Coding Tools */
    param->bEnableConstrainedIntra = 0;
    param->bEnableStrongIntraSmoothing = 1;

    /* Inter Coding tools */
    param->searchMethod = X265_HEX_SEARCH;
    param->subpelRefine = 2;
    param->searchRange = 57;
    param->maxNumMergeCand = 2;
    param->bEnableWeightedPred = 1;
    param->bEnableWeightedBiPred = 0;
    param->bEnableEarlySkip = 0;
    param->bEnableCbfFastMode = 0;
    param->bEnableAMP = 1;
    param->bEnableRectInter = 1;
    param->rdLevel = 3;
    param->bEnableSignHiding = 1;
    param->bEnableTransformSkip = 0;
    param->bEnableTSkipFast = 0;
    param->maxNumReferences = 3;

    /* Loop Filter */
    param->bEnableLoopFilter = 1;

    /* SAO Loop Filter */
    param->bEnableSAO = 1;
    param->saoLcuBoundary = 0;
    param->saoLcuBasedOptimization = 1;

    /* Coding Quality */
    param->cbQpOffset = 0;
    param->crQpOffset = 0;
    param->rdPenalty = 0;

    /* Rate control options */
    param->rc.vbvMaxBitrate = 0;
    param->rc.vbvBufferSize = 0;
    param->rc.vbvBufferInit = 0.9;
    param->rc.rfConstant = 28;
    param->rc.bitrate = 0;
    param->rc.rateTolerance = 1.0;
    param->rc.qCompress = 0.6;
    param->rc.ipFactor = 1.4f;
    param->rc.pbFactor = 1.3f;
    param->rc.qpStep = 4;
    param->rc.rateControlMode = X265_RC_CRF;
    param->rc.qp = 32;
    param->rc.aqMode = X265_AQ_VARIANCE;
    param->rc.aqStrength = 1.0;
    param->rc.cuTree = 1;

    /* Quality Measurement Metrics */
    param->bEnablePsnr = 0;
    param->bEnableSsim = 0;

    /* Video Usability Information (VUI) */
    param->vui.aspectRatioIdc = 0;
    param->vui.sarWidth = 0;
    param->vui.sarHeight = 0;
    param->vui.bEnableOverscanAppropriateFlag = 0;
    param->vui.bEnableVideoSignalTypePresentFlag = 0;
    param->vui.videoFormat = 5;
    param->vui.bEnableVideoFullRangeFlag = 0;
    param->vui.bEnableColorDescriptionPresentFlag = 0;
    param->vui.colorPrimaries = 2;
    param->vui.transferCharacteristics = 2;
    param->vui.matrixCoeffs = 2;
    param->vui.bEnableChromaLocInfoPresentFlag = 0;
    param->vui.chromaSampleLocTypeTopField = 0;
    param->vui.chromaSampleLocTypeBottomField = 0;
    param->vui.bEnableDefaultDisplayWindowFlag = 0;
    param->vui.defDispWinLeftOffset = 0;
    param->vui.defDispWinRightOffset = 0;
    param->vui.defDispWinTopOffset = 0;
    param->vui.defDispWinBottomOffset = 0;
}

extern "C"
int x265_param_apply_profile(x265_param *param, const char *profile)
{
    if (!profile)
        return 0;
    if (!strcmp(profile, "main"))
    {}
    else if (!strcmp(profile, "main10"))
    {
#if HIGH_BIT_DEPTH
        param->internalBitDepth = 10;
#else
        x265_log(param, X265_LOG_WARNING, "Main10 not supported, not compiled for 16bpp.\n");
        return -1;
#endif
    }
    else if (!strcmp(profile, "mainstillpicture"))
    {
        /* technically the stream should only have one picture, but we do not
         * enforce this */
        param->bRepeatHeaders = 1;
        param->keyframeMax = 1;
        param->bOpenGOP = 0;
    }
    else
    {
        x265_log(param, X265_LOG_ERROR, "unknown profile <%s>\n", profile);
        return -1;
    }

    return 0;
}

-> have fun
if you want you can read up on the strange doc site they use and write a patch to the documentation

[vhelp]

i will try and work this out in excel somehow, thank you.

[vhelp]

lookaheadDepth       10           ultrafast
scenecutThreshold     0 // disable lookahead           
maxCUSize            32           
searchRange          25           
bFrameAdaptive        0           
subpelRefine          0           
searchMethod          X265_DIA_SEARCH           
bEnableRectInter      0           
bEnableAMP            0           
bEnableEarlySkip      1           
bEnableCbfFastMode    1           
bEnableSAO            0           
bEnableSignHiding     0
bEnableWeightedPred   0
maxNumReferences      1
rc.aqStrength         0.0
rc.aqMode             X265_AQ_NONE
rc.cuTree             0
lookaheadDepth       10           superfast
maxCUSize            32
searchRange          44
bFrameAdaptive        0
subpelRefine          1
bEnableRectInter      0
bEnableAMP            0
bEnableEarlySkip      1
bEnableCbfFastMode    1
bEnableWeightedPred   0
maxNumReferences      1
rc.aqStrength       0.0
rc.aqMode             X265_AQ_NONE
rc.cuTree             0
lookaheadDepth       15           veryfast
maxCUSize            32
bFrameAdaptive        0
subpelRefine          1
bEnableRectInter      0
bEnableAMP            0
bEnableEarlySkip      1
bEnableCbfFastMode    1
maxNumReferences      1
rc.cuTree             0
lookaheadDepth       15           faster
bFrameAdaptive        0
bEnableRectInter      0
bEnableAMP            0
bEnableEarlySkip      1
bEnableCbfFastMode    1
maxNumReferences      1
rc.cuTree             0
lookaheadDepth       15           fast
bEnableRectInter      0
bEnableAMP            0
lookaheadDepth       25           slower
rdLevel               4
subpelRefine          3
maxNumMergeCand       3
searchMethod          X265_STAR_SEARCH
lookaheadDepth       30           slower
bframes               8
tuQTMaxInterDepth     2
tuQTMaxIntraDepth     2
rdLevel               6
subpelRefine          3
maxNumMergeCand       3
searchMethod          X265_STAR_SEARCH
lookaheadDepth       40           veryslow
bframes               8
tuQTMaxInterDepth     3
tuQTMaxIntraDepth     3
rdLevel               6
subpelRefine          4
maxNumMergeCand       4
searchMethod          X265_STAR_SEARCH
maxNumReferences      5           placebo
lookaheadDepth       60
searchRange          92
bframes               8
tuQTMaxInterDepth     4
tuQTMaxIntraDepth     4
rdLevel               6
subpelRefine          5
maxNumMergeCand       5
searchMethod          X265_STAR_SEARCH
bEnableTransformSkip  1
maxNumReferences      5

[Marchand]

x265 - Grupo VideoLAN - Updated: 20 Apr 2014

x265 is a free software library and application for encoding video streams into the H.265/MPEG-H HEVC compression format, and is released under the terms of the GNU GPL.

Font: http://www.videolan.org/developers/x265.html

Features Overview
Provides next-generation compression and codec.

Fast and excellent quality.

Completly free and libre software, ensuring freedom for everyone.

The APIs are similar to x264 APIs

Getting x265
Source

The latest x265 source code can always be found by anonymous hg repository:

# hg clone http://hg.videolan.org/x265

You can browse the source on-line.

Encoder features

Full prediction and transform quad-tree recursion supported
Adaptive B-frame placement
B-frames as references / arbitrary frame order
CABAC entropy coding
Intra: all block types (32x32, 16x16, 8x8, 4x4, and PCM with all predictions)
Inter P: all partitions (from 64x64 down to 8x4)
Inter B: partitions from 64x64 down to 8x4 (including all merge modes
and biprediction)
Weighted prediction for P slices
Multiple reference frames
Ratecontrol: constant quantizer, constant quality, single pass ABR, optional VBV
Scenecut detection
Parallel encoding on multiple CPUs, both frame-level and wavefront parallelism

view source/x265.h @ 6728:2fc309678785
Merge with stable
author 	Steve Borho <steve@borho.org>
date 	Wed, 16 Apr 2014 21:17:54 -0500 (4 days ago)
parents 	c1300ae4e7ba
children 	
line source
1 /*****************************************************************************
2 * Copyright (C) 2013 x265 project
3 *
4 * Authors: Steve Borho <steve@borho.org>
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111, USA.
19 *
20 * This program is also available under a commercial proprietary license.
21 * For more information, contact us at licensing@multicorewareinc.com.
22 *****************************************************************************/
23
24 #ifndef X265_H
25 #define X265_H
26
27 #include <stdint.h>
28 #include "x265_config.h"
29
30 #ifdef __cplusplus
31 extern "C" {
32 #endif
33
34 /* x265_encoder:
35 * opaque handler for encoder */
36 typedef struct x265_encoder x265_encoder;
37
38 /* Application developers planning to link against a shared library version of
39 * libx265 from a Microsoft Visual Studio or similar development environment
40 * will need to define X265_API_IMPORTS before including this header.
41 * This clause does not apply to MinGW, similar development environments, or non
42 * Windows platforms. */
43 #ifdef X265_API_IMPORTS
44 #define X265_API __declspec(dllimport)
45 #else
46 #define X265_API
47 #endif
48
49 typedef enum
50 {
51 NAL_UNIT_CODED_SLICE_TRAIL_N = 0,
52 NAL_UNIT_CODED_SLICE_TRAIL_R,
53 NAL_UNIT_CODED_SLICE_TSA_N,
54 NAL_UNIT_CODED_SLICE_TLA_R,
55 NAL_UNIT_CODED_SLICE_STSA_N,
56 NAL_UNIT_CODED_SLICE_STSA_R,
57 NAL_UNIT_CODED_SLICE_RADL_N,
58 NAL_UNIT_CODED_SLICE_RADL_R,
59 NAL_UNIT_CODED_SLICE_RASL_N,
60 NAL_UNIT_CODED_SLICE_RASL_R,
61 NAL_UNIT_CODED_SLICE_BLA_W_LP = 16,
62 NAL_UNIT_CODED_SLICE_BLA_W_RADL,
63 NAL_UNIT_CODED_SLICE_BLA_N_LP,
64 NAL_UNIT_CODED_SLICE_IDR_W_RADL,
65 NAL_UNIT_CODED_SLICE_IDR_N_LP,
66 NAL_UNIT_CODED_SLICE_CRA,
67 NAL_UNIT_VPS = 32,
68 NAL_UNIT_SPS,
69 NAL_UNIT_PPS,
70 NAL_UNIT_ACCESS_UNIT_DELIMITER,
71 NAL_UNIT_EOS,
72 NAL_UNIT_EOB,
73 NAL_UNIT_FILLER_DATA,
74 NAL_UNIT_PREFIX_SEI,
75 NAL_UNIT_SUFFIX_SEI,
76 NAL_UNIT_INVALID = 64,
77 } NalUnitType;
78
79 /* The data within the payload is already NAL-encapsulated; the type is merely
80 * in the struct for easy access by the calling application. All data returned
81 * in an x265_nal, including the data in payload, is no longer valid after the
82 * next call to x265_encoder_encode. Thus it must be used or copied before
83 * calling x265_encoder_encode again. */
84 typedef struct x265_nal
85 {
86 uint32_t type; /* NalUnitType */
87 uint32_t sizeBytes; /* size in bytes */
88 uint8_t* payload;
89 } x265_nal;
90
91 /* Used to pass pictures into the encoder, and to get picture data back out of
92 * the encoder. The input and output semantics are different */
93 typedef struct x265_picture
94 {
95 /* Must be specified on input pictures, the number of planes is determined
96 * by the colorSpace value */
97 void* planes[3];
98
99 /* Stride is the number of bytes between row starts */
100 int stride[3];
101
102 /* Must be specified on input pictures. x265_picture_init() will set it to
103 * the encoder's internal bit depth, but this field must describe the depth
104 * of the input pictures. Must be between 8 and 16. Values larger than 8
105 * imply 16bits per input sample. If input bit depth is larger than the
106 * internal bit depth, the encoder will down-shift pixels. Input samples
107 * larger than 8bits will be masked to internal bit depth. On output the
108 * bitDepth will be the internal encoder bit depth */
109 int bitDepth;
110
111 /* Must be specified on input pictures: X265_TYPE_AUTO or other.
112 * x265_picture_init() sets this to auto, returned on output */
113 int sliceType;
114
115 /* Ignored on input, set to picture count, returned on output */
116 int poc;
117
118 /* Must be specified on input pictures: X265_CSP_I420 or other. It must
119 * match the internal color space of the encoder. x265_picture_init() will
120 * initialize this value to the internal color space */
121 int colorSpace;
122
123 /* presentation time stamp: user-specified, returned on output */
124 int64_t pts;
125
126 /* display time stamp: ignored on input, copied from reordered pts. Returned
127 * on output */
128 int64_t dts;
129
130 /* The value provided on input is returned with the same picture (POC) on
131 * output */
132 void* userData;
133
134 /* new data members to this structure must be added to the end so that
135 * users of x265_picture_alloc/free() can be assured of future safety */
136 } x265_picture;
137
138 typedef enum
139 {
140 X265_DIA_SEARCH,
141 X265_HEX_SEARCH,
142 X265_UMH_SEARCH,
143 X265_STAR_SEARCH,
144 X265_FULL_SEARCH
145 } X265_ME_METHODS;
146
147 /* CPU flags */
148
149 /* x86 */
150 #define X265_CPU_CMOV 0x0000001
151 #define X265_CPU_MMX 0x0000002
152 #define X265_CPU_MMX2 0x0000004 /* MMX2 aka MMXEXT aka ISSE */
153 #define X265_CPU_MMXEXT X265_CPU_MMX2
154 #define X265_CPU_SSE 0x0000008
155 #define X265_CPU_SSE2 0x0000010
156 #define X265_CPU_SSE3 0x0000020
157 #define X265_CPU_SSSE3 0x0000040
158 #define X265_CPU_SSE4 0x0000080 /* SSE4.1 */
159 #define X265_CPU_SSE42 0x0000100 /* SSE4.2 */
160 #define X265_CPU_LZCNT 0x0000200 /* Phenom support for "leading zero count" instruction. */
161 #define X265_CPU_AVX 0x0000400 /* AVX support: requires OS support even if YMM registers aren't used. */
162 #define X265_CPU_XOP 0x0000800 /* AMD XOP */
163 #define X265_CPU_FMA4 0x0001000 /* AMD FMA4 */
164 #define X265_CPU_AVX2 0x0002000 /* AVX2 */
165 #define X265_CPU_FMA3 0x0004000 /* Intel FMA3 */
166 #define X265_CPU_BMI1 0x0008000 /* BMI1 */
167 #define X265_CPU_BMI2 0x0010000 /* BMI2 */
168 /* x86 modifiers */
169 #define X265_CPU_CACHELINE_32 0x0020000 /* avoid memory loads that span the border between two cachelines */
170 #define X265_CPU_CACHELINE_64 0x0040000 /* 32/64 is the size of a cacheline in bytes */
171 #define X265_CPU_SSE2_IS_SLOW 0x0080000 /* avoid most SSE2 functions on Athlon64 */
172 #define X265_CPU_SSE2_IS_FAST 0x0100000 /* a few functions are only faster on Core2 and Phenom */
173 #define X265_CPU_SLOW_SHUFFLE 0x0200000 /* The Conroe has a slow shuffle unit (relative to overall SSE performance) */
174 #define X265_CPU_STACK_MOD4 0x0400000 /* if stack is only mod4 and not mod16 */
175 #define X265_CPU_SLOW_CTZ 0x0800000 /* BSR/BSF x86 instructions are really slow on some CPUs */
176 #define X265_CPU_SLOW_ATOM 0x1000000 /* The Atom is terrible: slow SSE unaligned loads, slow
177 * SIMD multiplies, slow SIMD variable shifts, slow pshufb,
178 * cacheline split penalties -- gather everything here that
179 * isn't shared by other CPUs to avoid making half a dozen
180 * new SLOW flags. */
181 #define X265_CPU_SLOW_PSHUFB 0x2000000 /* such as on the Intel Atom */
182 #define X265_CPU_SLOW_PALIGNR 0x4000000 /* such as on the AMD Bobcat */
183
184 /* ARM */
185 #define X265_CPU_ARMV6 0x0000001
186 #define X265_CPU_NEON 0x0000002 /* ARM NEON */
187 #define X265_CPU_FAST_NEON_MRC 0x0000004 /* Transfer from NEON to ARM register is fast (Cortex-A9) */
188
189 #define X265_MAX_SUBPEL_LEVEL 7
190
191 /* Log level */
192 #define X265_LOG_NONE (-1)
193 #define X265_LOG_ERROR 0
194 #define X265_LOG_WARNING 1
195 #define X265_LOG_INFO 2
196 #define X265_LOG_DEBUG 3
197 #define X265_LOG_FULL 4
198
199 #define X265_B_ADAPT_NONE 0
200 #define X265_B_ADAPT_FAST 1
201 #define X265_B_ADAPT_TRELLIS 2
202
203 #define X265_BFRAME_MAX 16
204
205 #define X265_TYPE_AUTO 0x0000 /* Let x265 choose the right type */
206 #define X265_TYPE_IDR 0x0001
207 #define X265_TYPE_I 0x0002
208 #define X265_TYPE_P 0x0003
209 #define X265_TYPE_BREF 0x0004 /* Non-disposable B-frame */
210 #define X265_TYPE_B 0x0005
211
212 #define X265_AQ_NONE 0
213 #define X265_AQ_VARIANCE 1
214 #define X265_AQ_AUTO_VARIANCE 2
215 #define IS_X265_TYPE_I(x) ((x) == X265_TYPE_I || (x) == X265_TYPE_IDR)
216 #define IS_X265_TYPE_B(x) ((x) == X265_TYPE_B || (x) == X265_TYPE_BREF)
217
218 /* NOTE! For this release only X265_CSP_I420 and X265_CSP_I444 are supported */
219
220 /* Supported internal color space types (according to semantics of chroma_format_idc) */
221 #define X265_CSP_I400 0 /* yuv 4:0:0 planar */
222 #define X265_CSP_I420 1 /* yuv 4:2:0 planar */
223 #define X265_CSP_I422 2 /* yuv 4:2:2 planar */
224 #define X265_CSP_I444 3 /* yuv 4:4:4 planar */
225 #define X265_CSP_COUNT 4 /* Number of supported internal color spaces */
226
227 /* These color spaces will eventually be supported as input pictures. The pictures will
228 * be converted to the appropriate planar color spaces at ingest */
229 #define X265_CSP_NV12 4 /* yuv 4:2:0, with one y plane and one packed u+v */
230 #define X265_CSP_NV16 5 /* yuv 4:2:2, with one y plane and one packed u+v */
231
232 /* Interleaved color-spaces may eventually be supported as input pictures */
233 #define X265_CSP_BGR 6 /* packed bgr 24bits */
234 #define X265_CSP_BGRA 7 /* packed bgr 32bits */
235 #define X265_CSP_RGB 8 /* packed rgb 24bits */
236 #define X265_CSP_MAX 9 /* end of list */
237
238 #define X265_EXTENDED_SAR 255 /* aspect ratio explicitly specified as width:height */
239
240 typedef struct
241 {
242 int planes;
243 int width[3];
244 int height[3];
245 } x265_cli_csp;
246
247 static const x265_cli_csp x265_cli_csps[] =
248 {
249 { 1, { 0, 0, 0 }, { 0, 0, 0 } }, /* i400 */
250 { 3, { 0, 1, 1 }, { 0, 1, 1 } }, /* i420 */
251 { 3, { 0, 1, 1 }, { 0, 0, 0 } }, /* i422 */
252 { 3, { 0, 0, 0 }, { 0, 0, 0 } }, /* i444 */
253 { 2, { 0, 0 }, { 0, 1 } }, /* nv12 */
254 { 2, { 0, 0 }, { 0, 0 } }, /* nv16 */
255 };
256
257 /* rate tolerance method */
258 typedef enum
259 {
260 X265_RC_ABR,
261 X265_RC_CQP,
262 X265_RC_CRF
263 } X265_RC_METHODS;
264
265 /* Output statistics from encoder */
266 typedef struct x265_stats
267 {
268 double globalPsnrY;
269 double globalPsnrU;
270 double globalPsnrV;
271 double globalPsnr;
272 double globalSsim;
273 double elapsedEncodeTime; /* wall time since encoder was opened */
274 double elapsedVideoTime; /* encoded picture count / frame rate */
275 double bitrate; /* accBits / elapsed video time */
276 uint32_t encodedPictureCount; /* number of output pictures thus far */
277 uint32_t totalWPFrames; /* number of uni-directional weighted frames used */
278 uint64_t accBits; /* total bits output thus far */
279
280 /* new statistic member variables must be added below this line */
281 } x265_stats;
282
283 /* String values accepted by x265_param_parse() (and CLI) for various parameters */
284 static const char * const x265_motion_est_names[] = { "dia", "hex", "umh", "star", "full", 0 };
285 static const char * const x265_source_csp_names[] = { "i400", "i420", "i422", "i444", "nv12", "nv16", 0 };
286 static const char * const x265_video_format_names[] = { "component", "pal", "ntsc", "secam", "mac", "undef", 0 };
287 static const char * const x265_fullrange_names[] = { "limited", "full", 0 };
288 static const char * const x265_colorprim_names[] = { "", "bt709", "undef", "", "bt470m", "bt470bg", "smpte170m", "smpte240m", "film", "bt2020", 0 };
289 static const char * const x265_transfer_names[] = { "", "bt709", "undef", "", "bt470m", "bt470bg", "smpte170m", "smpte240m", "linear", "log100",
290 "log316", "iec61966-2-4", "bt1361e", "iec61966-2-1", "bt2020-10", "bt2020-12", 0 };
291 static const char * const x265_colmatrix_names[] = { "GBR", "bt709", "undef", "", "fcc", "bt470bg", "smpte170m", "smpte240m",
292 "YCgCo", "bt2020nc", "bt2020c", 0 };
293 static const char * const x265_sar_names[] = { "undef", "1:1", "12:11", "10:11", "16:11", "40:33", "24:11", "20:11",
294 "32:11", "80:33", "18:11", "15:11", "64:33", "160:99", "4:3", "3:2", "2:1", 0 };
295 static const char * const x265_interlace_names[] = { "prog", "tff", "bff", 0 };
296
297 /* x265 input parameters
298 *
299 * For version safety you may use x265_param_alloc/free() to manage the
300 * allocation of x265_param instances, and x265_param_parse() to assign values
301 * by name. By never dereferencing param fields in your own code you can treat
302 * x265_param as an opaque data structure */
303 typedef struct x265_param
304 {
305 /*== Encoder Environment ==*/
306
307 /* x265_param_default() will auto-detect this cpu capability bitmap. it is
308 * recommended to not change this value unless you know the cpu detection is
309 * somehow flawed on your target hardware. The asm function tables are
310 * process global, the first encoder configures them for all encoders */
311 int cpuid;
312
313 /* Enable wavefront parallel processing, greatly increases parallelism for
314 * less than 1% compression efficiency loss */
315 int bEnableWavefront;
316
317 /* Number of threads to allocate for the process global thread pool, if no
318 * thread pool has yet been created. 0 implies auto-detection. By default
319 * x265 will try to allocate one worker thread per CPU core */
320 int poolNumThreads;
321
322 /* Number of concurrently encoded frames, 0 implies auto-detection. By
323 * default x265 will use a number of frame threads emperically determined to
324 * be optimal for your CPU core count, between 2 and 6. Using more than one
325 * frame thread causes motion search in the down direction to be clamped but
326 * otherwise encode behavior is unaffected. With CQP rate control the output
327 * bitstream is deterministic for all values of frameNumThreads greater than
328 * 1. All other forms of rate-control can be negatively impacted by
329 * increases to the number of frame threads because the extra concurrency
330 * adds uncertainty to the bitrate estimations. There is no limit to the
331 * number of frame threads you use for each encoder, but frame parallelism
332 * is generally limited by the the number of CU rows */
333 int frameNumThreads;
334
335 /* The level of logging detail emitted by the encoder. X265_LOG_NONE to
336 * X265_LOG_FULL, default is X265_LOG_INFO */
337 int logLevel;
338
339 /* Enable the measurement and reporting of PSNR. Default is enabled */
340 int bEnablePsnr;
341
342 /* Enable the measurement and reporting of SSIM. Default is disabled */
343 int bEnableSsim;
344
345 /* filename of CSV log. If logLevel is X265_LOG_DEBUG, the encoder will emit
346 * per-slice statistics to this log file in encode order. Otherwise the
347 * encoder will emit per-stream statistics into the log file when
348 * x265_encoder_log is called (presumably at the end of the encode) */
349 const char *csvfn;
350
351 /* Enable the generation of SEI messages for each encoded frame containing
352 * the hashes of the three reconstructed picture planes. Most decoders will
353 * validate those hashes against the reconstructed images it generates and
354 * report any mismatches. This is essentially a debugging feature. Hash
355 * types are MD5(1), CRC(2), Checksum(3). Default is 0, none */
356 int decodedPictureHashSEI;
357
358 /*== Internal Picture Specification ==*/
359
360 /* Internal encoder bit depth. If x265 was compiled to use 8bit pixels
361 * (HIGH_BIT_DEPTH=0), this field must be 8, else this field must be 10.
362 * Future builds may support 12bit pixels. */
363 int internalBitDepth;
364
365 /* Color space of internal pictures. Only X265_CSP_I420 and X265_CSP_I444
366 * are supported. Eventually, i422 will also be supported as an internal
367 * color space and other packed formats will be supported in
368 * x265_picture.colorSpace */
369 int internalCsp;
370
371 /* Numerator and denominator of frame rate */
372 uint32_t fpsNum;
373 uint32_t fpsDenom;
374
375 /* Width (in pixels) of the source pictures. If this width is not an even
376 * multiple of 4, the encoder will pad the pictures internally to meet this
377 * minimum requirement. All valid HEVC widths are supported */
378 int sourceWidth;
379
380 /* Height (in pixels) of the source pictures. If this height is not an even
381 * multiple of 4, the encoder will pad the pictures internally to meet this
382 * minimum requirement. All valid HEVC heights are supported */
383 int sourceHeight;
384
385 /* Interlace type of source pictures. 0 - progressive pictures (default).
386 * 1 - top field first, 2 - bottom field first. HEVC encodes interlaced
387 * content as fields, they must be provided to the encoder in the correct
388 * temporal order. EXPERIMENTAL */
389 int interlaceMode;
390
391 /* Flag indicating whether VPS, SPS and PPS headers should be output with
392 * each keyframe. Default false */
393 int bRepeatHeaders;
394
395 /* Flag indicating whether the encoder should emit an Access Unit Delimiter
396 * NAL at the start of every access unit. Default false */
397 int bEnableAccessUnitDelimiters;
398
399 /*== Coding Unit (CU) definitions ==*/
400
401 /* Maxiumum CU width and height in pixels. The size must be 64, 32, or 16.
402 * The higher the size, the more efficiently x265 can encode areas of low
403 * complexity, greatly improving compression efficiency at large
404 * resolutions. The smaller the size, the more effective wavefront and
405 * frame parallelism will become because of the increase in rows. default 64 */
406 uint32_t maxCUSize;
407
408 /* The additional depth the residual quadtree is allowed to recurse beyond
409 * the coding quadtree, for inter coded blocks. This must be between 1 and
410 * 3. The higher the value the more efficiently the residual can be
411 * compressed by the DCT transforms, at the expense of much more compute */
412 uint32_t tuQTMaxInterDepth;
413
414 /* The additional depth the residual quadtree is allowed to recurse beyond
415 * the coding quadtree, for intra coded blocks. This must be between 1 and
416 * 3. The higher the value the more efficiently the residual can be
417 * compressed by the DCT transforms, at the expense of much more compute */
418 uint32_t tuQTMaxIntraDepth;
419
420 /*== GOP Structure and Lokoahead ==*/
421
422 /* Enable open GOP - meaning I slices are not necessariy IDR and thus frames
423 * encoded after an I slice may reference frames encoded prior to the I
424 * frame which have remained in the decoded picture buffer. Open GOP
425 * generally has better compression efficiency and negligable encoder
426 * performance impact, but the use case may preclude it. Default true */
427 int bOpenGOP;
428
429 /* Scenecuts closer together than this are coded as I, not IDR. */
430 int keyframeMin;
431
432 /* Maximum keyframe distance or intra period in number of frames. If 0 or 1,
433 * all frames are I frames. A negative value is casted to MAX_INT internally
434 * which effectively makes frame 0 the only I frame. Default is 250 */
435 int keyframeMax;
436
437 /* The maximum number of L0 references a P or B slice may use. This
438 * influences the size of the decoded picture buffer. The higher this
439 * number, the more reference frames there will be available for motion
440 * search, improving compression efficiency of most video at a cost of
441 * performance. Value must be between 1 and 16, default is 3 */
442 int maxNumReferences;
443
444 /* Sets the operating mode of the lookahead. With b-adapt 0, the GOP
445 * structure is fixed based on the values of keyframeMax and bframes.
446 * With b-adapt 1 a light lookahead is used to chose B frame placement.
447 * With b-adapt 2 (trellis) a viterbi B path selection is performed */
448 int bFrameAdaptive;
449
450 /* Maximum consecutive B frames that can be emitted by the lookehead. When
451 * b-adapt is 0 and keyframMax is greater than bframes, the lookahead emits
452 * a fixed pattern of `bframes` B frames between each P. With b-adapt 1 the
453 * lookahead ignores the value of bframes for the most part. With b-adapt 2
454 * the value of bframes determines the search (POC) distance performeed in
455 * both directions, quadradically increasing the compute load of the
456 * lookahead. The higher the value, the more B frames the lookahead may
457 * possibly use consecutively, usually improving compression. Default is 3,
458 * maximum is 16 */
459 int bframes;
460
461 /* When enabled, the encoder will use the B frame in the middle of each
462 * mini-GOP larger than 2 B frames as a motion reference for the surrounding
463 * B frames. This improves compression efficiency for a small performance
464 * penalty. Referenced B frames are treated somewhere between a B and a P
465 * frame by rate control. Default is enabled. */
466 int bBPyramid;
467
468 /* The number of frames that must be queued in the lookahead before it may
469 * make slice decisions. Increasing this value directly increases the encode
470 * latency. The longer the queue the more optimally the lookahead may make
471 * slice decisions, particularly with b-adapt 2. When mb-tree is enabled,
472 * the length of the queue linearly increases the effectiveness of the
473 * mb-tree analysis. Default is 40 frames, maximum is 250 */
474 int lookaheadDepth;
475
476 /* A value which is added to the cost estimate of B frames in the lookahead.
477 * It may be a positive value (making B frames appear more expensive, which
478 * causes the lookahead to chose more P frames) or negative, which makes the
479 * lookahead chose more B frames. Default is 0, there are no limits */
480 int bFrameBias;
481
482 /* An arbitrary threshold which determines how agressively the lookahead
483 * should detect scene cuts. The default (40) is recommended. */
484 int scenecutThreshold;
485
486 /*== Intra Coding Tools ==*/
487
488 /* Enable constrained intra prediction. This causes intra prediction to
489 * input samples that were inter predicted. For some use cases this is
490 * believed to me more robust to stream errors, but it has a compression
491 * penalty on P and (particularly) B slices. Defaults to diabled */
492 int bEnableConstrainedIntra;
493
494 /* Enable strong intra smoothing for 32x32 blocks where the reference
495 * samples are flat. It may or may not improve compression efficiency,
496 * depending on your source material. Defaults to disabled */
497 int bEnableStrongIntraSmoothing;
498
499 /*== Inter Coding Tools ==*/
500
501 /* ME search method (DIA, HEX, UMH, STAR, FULL). The search patterns
502 * (methods) are sorted in increasing complexity, with diamond being the
503 * simplest and fastest and full being the slowest. DIA, HEX, and UMH were
504 * adapted from x264 directly. STAR is an adaption of the HEVC reference
505 * encoder's three step search, while full is a naive exhaustive search. The
506 * default is the star search, it has a good balance of performance and
507 * compression efficiecy */
508 int searchMethod;
509
510 /* A value between 0 and X265_MAX_SUBPEL_LEVEL which adjusts the amount of
511 * effort performed during subpel refine. Default is 5 */
512 int subpelRefine;
513
514 /* The maximum distance from the motion prediction that the full pel motion
515 * search is allowed to progress before terminating. This value can have an
516 * effect on frame parallelism, as referenced frames must be at least this
517 * many rows of reconstructed pixels ahead of the referencee at all times.
518 * (When considering reference lag, the motion prediction must be ignored
519 * because it cannot be known ahead of time). Default is 60, which is the
520 * default max CU size (64) minus the luma HPEL half-filter length (4). If a
521 * smaller CU size is used, the search range should be similarly reduced */
522 int searchRange;
523
524 /* The maximum number of merge candidates that are considered during inter
525 * analysis. This number (between 1 and 5) is signaled in the stream
526 * headers and determines the number of bits required to signal a merge so
527 * it can have significant trade-offs. The smaller this number the higher
528 * the performance but the less compression efficiency. Default is 3 */
529 uint32_t maxNumMergeCand;
530
531 /* Enable weighted prediction in P slices. This enables weighting analysis
532 * in the lookahead, which influences slice decisions, and enables weighting
533 * analysis in the main encoder which allows P reference samples to have a
534 * weight function applied to them prior to using them for motion
535 * compensation. In video which has lighting changes, it can give a large
536 * improvement in compression efficiency. Default is enabled */
537 int bEnableWeightedPred;
538
539 /* Enable weighted prediction in B slices. Default is disabled */
540 int bEnableWeightedBiPred;
541
542 /*== Analysis tools ==*/
543
544 /* Enable asymmetrical motion predictions. At CU depths 64, 32, and 16, it
545 * is possible to use 25%/75% split partitions in the up, down, right, left
546 * directions. For some material this can improve compression efficiency at
547 * the cost of extra analysis. bEnableRectInter must be enabled for this
548 * feature to be used. Default enabled */
549 int bEnableAMP;
550
551 /* Enable rectangular motion prediction partitions (vertical and
552 * horizontal), available at all CU depths from 64x64 to 8x8. Default is
553 * enabled */
554 int bEnableRectInter;
555
556 /* Enable the use of `coded block flags` (flags set to true when a residual
557 * has been coded for a given block) to avoid intra analysis in likely skip
558 * blocks. Default is disabled */
559 int bEnableCbfFastMode;
560
561 /* Enable early skip decisions to avoid intra and inter analysis in likely
562 * skip blocks. Default is disabled */
563 int bEnableEarlySkip;
564
565 /* Apply an optional penalty to the estimated cost of 32x32 intra blocks in
566 * non-intra slices. 0 is disabled, 1 enables a small penalty, and 2 enables
567 * a full penalty. This favors inter-coding and its low bitrate over
568 * potential increases in distortion, but usually improves performance.
569 * Default is 0 */
570 int rdPenalty;
571
572 /* A value betwen X265_NO_RDO_NO_RDOQ and X265_RDO_LEVEL which determines
573 * the level of rate distortion optimizations to perform during mode
574 * decisions and quantization. The more RDO the better the compression
575 * efficiency at a major cost of performance. Default is no RDO (0) */
576 int rdLevel;
577
578 /*== Coding tools ==*/
579
580 /* Enable the implicit signaling of the sign bit of the last coefficient of
581 * each transform unit. This saves one bit per TU at the expense of figuring
582 * out which coefficient can be toggled with the least distortion.
583 * Default is enabled */
584 int bEnableSignHiding;
585
586 /* Allow intra coded blocks to be encoded directly as residual without the
587 * DCT transform, when this improves efficiency. Checking whether the block
588 * will benefit from this option incurs a performance penalty. Default is
589 * enabled */
590 int bEnableTransformSkip;
591
592 /* Enable a faster determination of whether skippig the DCT transform will
593 * be beneficial. Slight performance gain for some compression loss. Default
594 * is enabled */
595 int bEnableTSkipFast;
596
597 /* Enable the deblocking loop filter, which improves visual quality by
598 * reducing blocking effects at block edges, particularly at lower bitrates
599 * or higher QP. When enabled it adds another CU row of reference lag,
600 * reducing frame parallelism effectiveness. Default is enabled */
601 int bEnableLoopFilter;
602
603 /* Enable the Sample Adaptive Offset loop filter, which reduces distortion
604 * effects by adjusting reconstructed sample values based on histogram
605 * analysis to better approximate the original samples. When enabled it adds
606 * a CU row of reference lag, reducing frame parallelism effectiveness.
607 * Default is enabled */
608 int bEnableSAO;
609
610 /* Note: when deblocking and SAO are both enabled, the loop filter CU lag is
611 * only one row, as they operate in series o the same row. */
612
613 /* Select the method in which SAO deals with deblocking boundary pixels. If
614 * 0 the right and bottom boundary areas are skipped. If 1, non-deblocked
615 * pixels are used entirely. Default is 0 */
616 int saoLcuBoundary;
617
618 /* Select the scope of the SAO optimization. If 0 SAO is performed over the
619 * entire output picture at once, this can severly restrict frame
620 * parallelism so it is not recommended for many-core machines. If 1 SAO is
621 * performed on LCUs in series. Default is 1 */
622 int saoLcuBasedOptimization;
623
624 /* Generally a small signed integer which offsets the QP used to quantize
625 * the Cb chroma residual (delta from luma QP specified by rate-control).
626 * Default is 0, which is recommended */
627 int cbQpOffset;
628
629 /* Generally a small signed integer which offsets the QP used to quantize
630 * the Cr chroma residual (delta from luma QP specified by rate-control).
631 * Default is 0, which is recommended */
632 int crQpOffset;
633
634 /*== Rate Control ==*/
635
636 struct
637 {
638 /* Explicit mode of rate-control, necessary for API users. It must
639 * be one of the X265_RC_METHODS enum values. */
640 int rateControlMode;
641
642 /* Base QP to use for Constant QP rate control. Adaptive QP may alter
643 * the QP used for each block. If a QP is specified on the command line
644 * CQP rate control is implied. Default: 32 */
645 int qp;
646
647 /* target bitrate for Average BitRate (ABR) rate control. If a non- zero
648 * bitrate is specified on the command line, ABR is implied. Default 0 */
649 int bitrate;
650
651 /* The degree of rate fluctuation that x265 tolerates. Rate tolerance is used
652 * alongwith overflow (difference between actual and target bitrate), to adjust
653 qp. Default is 1.0 */
654 double rateTolerance;
655
656 /* qComp sets the quantizer curve compression factor. It weights the frame
657 * quantizer based on the complexity of residual (measured by lookahead).
658 * Default value is 0.6. Increasing it to 1 will effectively generate CQP */
659 double qCompress;
660
661 /* QP offset between I/P and P/B frames. Default ipfactor: 1.4
662 * Default pbFactor: 1.3 */
663 double ipFactor;
664 double pbFactor;
665
666 /* Max QP difference between frames. Default: 4 */
667 int qpStep;
668
669 /* Ratefactor constant: targets a certain constant "quality".
670 * Acceptable values between 0 and 51. Default value: 28 */
671 double rfConstant;
672
673 /* Enable adaptive quantization. This mode distributes available bits between all
674 * macroblocks of a frame, assigning more bits to low complexity areas. Turning
675 * this ON will usually affect PSNR negatively, however SSIM and visual quality
676 * generally improves. Default: X265_AQ_VARIANCE */
677 int aqMode;
678
679 /* Sets the strength of AQ bias towards low detail macroblocks. Valid only if
680 * AQ is enabled. Default value: 1.0. Acceptable values between 0.0 and 3.0 */
681 double aqStrength;
682
683 /* Sets the maximum rate the VBV buffer should be assumed to refill at
684 * Default is zero */
685 int vbvMaxBitrate;
686
687 /* Sets the size of the VBV buffer in kilobits. Default is zero */
688 int vbvBufferSize;
689
690 /* Sets how full the VBV buffer must be before playback starts. If it is less than
691 * 1, then the initial fill is vbv-init * vbvBufferSize. Otherwise, it is
692 * interpreted as the initial fill in kbits. Default is 0.9 */
693 double vbvBufferInit;
694
695 /* Enable CUTree ratecontrol. This keeps track of the CUs that propagate temporally
696 * across frames and assigns more bits to these CUs. Improves encode efficiency.
697 * Default: enabled */
698 int cuTree;
699
700 /* In CRF mode, maximum CRF as caused by VBV. 0 implies no limit */
701 double rfConstantMax;
702 } rc;
703
704 /*== Video Usability Information ==*/
705 struct
706 {
707 /* Aspect ratio idc to be added to the VUI. The default is 0 indicating
708 * the apsect ratio is unspecified. If set to X265_EXTENDED_SAR then
709 * sarWidth and sarHeight must also be set */
710 int aspectRatioIdc;
711
712 /* Sample Aspect Ratio width in arbitrary units to be added to the VUI
713 * only if aspectRatioIdc is set to X265_EXTENDED_SAR. This is the width
714 * of an individual pixel. If this is set then sarHeight must also be set */
715 int sarWidth;
716
717 /* Sample Aspect Ratio height in arbitrary units to be added to the VUI.
718 * only if aspectRatioIdc is set to X265_EXTENDED_SAR. This is the width
719 * of an individual pixel. If this is set then sarWidth must also be set */
720 int sarHeight;
721
722 /* Enable overscan info present flag in the VUI. If this is set then
723 * bEnabledOverscanAppropriateFlag will be added to the VUI. The default
724 * is false */
725 int bEnableOverscanInfoPresentFlag;
726
727 /* Enable overscan appropriate flag. The status of this flag is added
728 * to the VUI only if bEnableOverscanInfoPresentFlag is set. If this
729 * flag is set then cropped decoded pictures may be output for display.
730 * The default is false */
731 int bEnableOverscanAppropriateFlag;
732
733 /* Video signal type present flag of the VUI. If this is set then
734 * videoFormat, bEnableVideoFullRangeFlag and
735 * bEnableColorDescriptionPresentFlag will be added to the VUI. The
736 * default is false */
737 int bEnableVideoSignalTypePresentFlag;
738
739 /* Video format of the source video. 0 = component, 1 = PAL, 2 = NTSC,
740 * 3 = SECAM, 4 = MAC, 5 = unspecified video format is the default */
741 int videoFormat;
742
743 /* Video full range flag indicates the black level and range of the luma
744 * and chroma signals as derived from E′Y, E′PB, and E′PR or E′R, E′G,
745 * and E′B real-valued component signals. The default is false */
746 int bEnableVideoFullRangeFlag;
747
748 /* Color description present flag in the VUI. If this is set then
749 * color_primaries, transfer_characteristics and matrix_coeffs are to be
750 * added to the VUI. The default is false */
751 int bEnableColorDescriptionPresentFlag;
752
753 /* Color primaries holds the chromacity coordinates of the source
754 * primaries. The default is 2 */
755 int colorPrimaries;
756
757 /* Transfer characteristics indicates the opto-electronic transfer
758 * characteristic of the source picture. The default is 2 */
759 int transferCharacteristics;
760
761 /* Matrix coefficients used to derive the luma and chroma signals from
762 * the red, blue and green primaries. The default is 2 */
763 int matrixCoeffs;
764
765 /* Chroma location info present flag adds chroma_sample_loc_type_top_field and
766 * chroma_sample_loc_type_bottom_field to the VUI. The default is false */
767 int bEnableChromaLocInfoPresentFlag;
768
769 /* Chroma sample location type top field holds the chroma location in
770 * the top field. The default is 0 */
771 int chromaSampleLocTypeTopField;
772
773 /* Chroma sample location type bottom field holds the chroma location in
774 * the bottom field. The default is 0 */
775 int chromaSampleLocTypeBottomField;
776
777 /* Default display window flag adds def_disp_win_left_offset,
778 * def_disp_win_right_offset, def_disp_win_top_offset and
779 * def_disp_win_bottom_offset to the VUI. The default is false */
780 int bEnableDefaultDisplayWindowFlag;
781
782 /* Default display window left offset holds the left offset with the
783 * conformance cropping window to further crop the displayed window */
784 int defDispWinLeftOffset;
785
786 /* Default display window right offset holds the right offset with the
787 * conformance cropping window to further crop the displayed window */
788 int defDispWinRightOffset;
789
790 /* Default display window top offset holds the top offset with the
791 * conformance cropping window to further crop the displayed window */
792 int defDispWinTopOffset;
793
794 /* Default display window bottom offset holds the bottom offset with the
795 * conformance cropping window to further crop the displayed window */
796 int defDispWinBottomOffset;
797 } vui;
798
799 } x265_param;
800
801 /***
802 * If not called, first encoder allocated will auto-detect the CPU and
803 * initialize performance primitives, which are process global.
804 * DEPRECATED: use x265_param.cpuid to specify CPU */
805 void x265_setup_primitives(x265_param *param, int cpu);
806
807 /* x265_param_alloc:
808 * Allocates an x265_param instance. The returned param structure is not
809 * special in any way, but using this method together with x265_param_free()
810 * and x265_param_parse() to set values by name allows the application to treat
811 * x265_param as an opaque data struct for version safety */
812 x265_param *x265_param_alloc();
813
814 /* x265_param_free:
815 * Use x265_param_free() to release storage for an x265_param instance
816 * allocated by x26_param_alloc() */
817 void x265_param_free(x265_param *);
818
819 /***
820 * Initialize an x265_param_t structure to default values
821 */
822 void x265_param_default(x265_param *param);
823
824 /* x265_param_parse:
825 * set one parameter by name.
826 * returns 0 on success, or returns one of the following errors.
827 * note: BAD_VALUE occurs only if it can't even parse the value,
828 * numerical range is not checked until x265_encoder_open() or
829 * x265_encoder_reconfig().
830 * value=NULL means "true" for boolean options, but is a BAD_VALUE for non-booleans. */
831 #define X265_PARAM_BAD_NAME (-1)
832 #define X265_PARAM_BAD_VALUE (-2)
833 int x265_param_parse(x265_param *p, const char *name, const char *value);
834
835 /* x265_param_apply_profile:
836 * Applies the restrictions of the given profile. (one of below) */
837 static const char * const x265_profile_names[] = { "main", "main10", "mainstillpicture", 0 };
838
839 /* (can be NULL, in which case the function will do nothing)
840 * returns 0 on success, negative on failure (e.g. invalid profile name). */
841 int x265_param_apply_profile(x265_param *, const char *profile);
842
843 /* x265_param_default_preset:
844 * The same as x265_param_default, but also use the passed preset and tune
845 * to modify the default settings.
846 * (either can be NULL, which implies no preset or no tune, respectively)
847 *
848 * Currently available presets are, ordered from fastest to slowest: */
849 static const char * const x265_preset_names[] = { "ultrafast", "superfast", "veryfast", "faster", "fast", "medium", "slow", "slower", "veryslow", "placebo", 0 };
850
851 /* The presets can also be indexed numerically, as in:
852 * x265_param_default_preset( &param, "3", ... )
853 * with ultrafast mapping to "0" and placebo mapping to "9". This mapping may
854 * of course change if new presets are added in between, but will always be
855 * ordered from fastest to slowest.
856 *
857 * Warning: the speed of these presets scales dramatically. Ultrafast is a full
858 * 100 times faster than placebo!
859 *
860 * Currently available tunings are: */
861 static const char * const x265_tune_names[] = { "psnr", "ssim", "zerolatency", "fastdecode", 0 };
862
863 /* returns 0 on success, negative on failure (e.g. invalid preset/tune name). */
864 int x265_param_default_preset(x265_param *, const char *preset, const char *tune);
865
866 /* x265_picture_alloc:
867 * Allocates an x265_picture instance. The returned picture structure is not
868 * special in any way, but using this method together with x265_picture_free()
869 * and x265_picture_init() allows some version safety. New picture fields will
870 * always be added to the end of x265_picture */
871 x265_picture *x265_picture_alloc();
872
873 /* x265_picture_free:
874 * Use x265_picture_free() to release storage for an x265_picture instance
875 * allocated by x26_picture_alloc() */
876 void x265_picture_free(x265_picture *);
877
878 /***
879 * Initialize an x265_picture structure to default values. It sets the pixel
880 * depth and color space to the encoder's internal values and sets the slice
881 * type to auto - so the lookahead will determine slice type.
882 */
883 void x265_picture_init(x265_param *param, x265_picture *pic);
884
885 /* x265_max_bit_depth:
886 * Specifies the maximum number of bits per pixel that x265 can input. This
887 * is also the max bit depth that x265 encodes in. When x265_max_bit_depth
888 * is 8, the internal and input bit depths must be 8. When
889 * x265_max_bit_depth is 12, the internal and input bit depths can be
890 * either 8, 10, or 12. Note that the internal bit depth must be the same
891 * for all encoders allocated in the same process. */
892 X265_API extern const int x265_max_bit_depth;
893
894 /* x265_version_str:
895 * A static string containing the version of this compiled x265 library */
896 X265_API extern const char *x265_version_str;
897
898 /* x265_build_info:
899 * A static string describing the compiler and target architecture */
900 X265_API extern const char *x265_build_info_str;
901
902 /* Force a link error in the case of linking against an incompatible API version.
903 * Glue #defines exist to force correct macro expansion; the final output of the macro
904 * is x265_encoder_open_##X264_BUILD (for purposes of dlopen). */
905 #define x265_encoder_glue1(x, y) x ## y
906 #define x265_encoder_glue2(x, y) x265_encoder_glue1(x, y)
907 #define x265_encoder_open x265_encoder_glue2(x265_encoder_open_, X265_BUILD)
908
909 /* x265_encoder_open:
910 * create a new encoder handler, all parameters from x265_param_t are copied */
911 x265_encoder* x265_encoder_open(x265_param *);
912
913 /* x265_encoder_headers:
914 * return the SPS and PPS that will be used for the whole stream.
915 * *pi_nal is the number of NAL units outputted in pp_nal.
916 * returns negative on error, total byte size of payload data on success
917 * the payloads of all output NALs are guaranteed to be sequential in memory. */
918 int x265_encoder_headers(x265_encoder *, x265_nal **pp_nal, uint32_t *pi_nal);
919
920 /* x265_encoder_encode:
921 * encode one picture.
922 * *pi_nal is the number of NAL units outputted in pp_nal.
923 * returns negative on error, zero if no NAL units returned.
924 * the payloads of all output NALs are guaranteed to be sequential in memory. */
925 int x265_encoder_encode(x265_encoder *encoder, x265_nal **pp_nal, uint32_t *pi_nal, x265_picture *pic_in, x265_picture *pic_out);
926
927 /* x265_encoder_get_stats:
928 * returns encoder statistics */
929 void x265_encoder_get_stats(x265_encoder *encoder, x265_stats *, uint32_t statsSizeBytes);
930
931 /* x265_encoder_log:
932 * write a line to the configured CSV file. If a CSV filename was not
933 * configured, or file open failed, or the log level indicated frame level
934 * logging, this function will perform no write. */
935 void x265_encoder_log(x265_encoder *encoder, int argc, char **argv);
936
937 /* x265_encoder_close:
938 * close an encoder handler */
939 void x265_encoder_close(x265_encoder *);
940
941 /***
942 * Release library static allocations
943 */
944 void x265_cleanup(void);
945
946 #ifdef __cplusplus
947 }
948 #endif
949
950 #endif // X265_H

[Selur]

Is this only a mirror of the bitbucket repository or will this be a different branch?
Will this replace the bitbucket repository?
Anyone know something more?

[Baldrick]

Any good mirror download site with latest x265 executables?

[Brazil]

Any good mirror download site with latest x265 executables?

There are some listed in this post:
https://forum.videohelp.com/threads/357754-%5BHEVC%5D-x265-EXE-mingw-builds?p=2257098#post2257098

I'm using LigH's ones because:
He provides both x86 and x64 builds
His builds are XP compatible
They don't need fancy runtimes like MSVC2012.

[LigH.de]

But I don't build and upload daily — only when I notice very important changes or when there is a merge between "stable" and "default" branch.

[Gravitator]

Hi all,
check with your system
Hybrid_2014.04.04.1 ; parameters used: --preset veryslow --bitrate 1200 (x265 encoder version 0.9+68-8bit)
It turns crumbly - I want to understand what a miss (converter/settings, encoder, decoder, evil eye)
samply for analysis

[gonca]

Check the test encodes I did above

Bit rate of 1184 for UHD content? A little low maybe?

[Gravitator]

Check the test encodes I did above

Bit rate of 1184 for UHD content? A little low maybe?

DivX shows that not a little

[gonca]

I'll run a test encode in a second

[Gravitator]

I'll run a test encode in a second

If you normally get, then informed about your system and what encoder assembly used

Та!

[gonca]

Done and it looks fine

Hybrid: homepage
Forum: public forum
Regarding problems please read: needed infos
Donate: via PayPal
Added new job with id 17_00_00_6610
Added new job with id 17_06_50_4110
 ->disabling qaac support since 'Apple Application Support' is not installed,...
Finished initialization, finished after 1.12s

Filtering input files,..
Analysing 1 input files,...
analyzing: TimeScapes-satellite dish (orig).mkv
 checking a/v ids in ffmpeg,...
  analyzing TimeScapes-satellite dish (orig).mkv
 grabbing audio ids for: I:\TimeScapes-satellite dish (orig).mkv
 -> audio ids found: 0
 analyzing audio streams...
  analyzing audio stream: 0
   analyzing audio stream with mplayer
   grabbing audio data and delay infos with MediaInfo for I:\TimeScapes-satellite dish (orig).mkv
 grabbing video ids for: TimeScapes-satellite dish (orig).mkv
  -> video ids found: 0
 analyzing video streams...
  analyzing video stream: 0
starting auto routines for source number: 1
 -> finished auto routines for source number 1.
Input is completely analysed,...
Extracting attachments from I:\TimeScapes-satellite dish (orig).mkv to C:\Users\LUIS\AppData\Roaming\hybrid\fonts
Creating jobs for 1 sources,...
 -> Creating jobs for source 1,...
 -> Generating calls for: W:\OUTPUT\TimeScapes-satellite dish (orig).mkv
adding x265 calls for source: 1
createJobs for W:\OUTPUT\TimeScapes-satellite dish (orig).mkv
 optimizing the subJobs
Added new job with id 16_09_19_3410
Created jobs for:
 I:\TimeScapes-satellite dish (orig).mkv

Starting Main@16:09:24.915:
"C:\PROGRA~1\Hybrid\x265.exe" --preset veryslow --input - --input-res 2560x1440 --fps 23.976 --frames 242 --bitrate 1200 --output "W:\TEMP\TimeScapes-satellite dish (orig)_16_09_19_3410_01.265"
x265 [info]: HEVC encoder version 0.9+9-8273932bc5b7
x265 [info]: build info [Windows][GCC 4.8.2][64 bit] 8bpp
x265 [info]: using cpu capabilities: MMX2 SSE2Fast SSSE3 SSE4.2 AVX
x265 [info]: Main profile, Level-5 (Main tier)
x265 [info]: WPP streams / pool / frames         : 23 / 12 / 3
x265 [info]: CU size                             : 64
x265 [info]: Max RQT depth inter / intra         : 3 / 3
x265 [info]: ME / range / subpel / merge         : star / 57 / 4 / 4
x265 [info]: Keyframe min / max / scenecut       : 23 / 250 / 40
x265 [info]: Lookahead / bframes / badapt        : 40 / 8 / 2
x265 [info]: b-pyramid / weightp / weightb / refs: 1 / 1 / 0 / 5
x265 [info]: Rate Control / AQ-Strength / CUTree : ABR-1200 kbps / 1.0 / 1
x265 [info]: tools: rect amp rd=6 lft sao-lcu sign-hide
encoded 240 frames in 292.36s (0.82 fps), 1196.71 kb/s
x265 [info]: frame I: 1      Avg QP:34.25  kb/s: 13242.04
x265 [info]: frame P: 62     Avg QP:34.05  kb/s: 2559.71
x265 [info]: frame B: 177    Avg QP:36.45  kb/s: 651.22
x265 [info]: global : 240    Avg QP:35.82  kb/s: 1196.71
x265 [info]: Weighted P-Frames: Y:8.1% UV:8.1%
x265 [info]: consecutive B-frames: 3.2% 11.1% 31.7% 25.4% 14.3% 12.7% 1.6% 0.0% 0.0%
finished after 00:04:52.939
Created W:\TEMP\TimeScapes-satellite dish (orig)_16_09_19_3410_01.265 (1.429 MB)

Starting Main@16:14:17.870:
"C:\PROGRA~1\Hybrid\mkvmerge.exe" --ui-language en -o "W:\OUTPUT\TimeScapes-satellite dish (orig).mkv" --engage no_cue_duration --engage no_cue_relative_position --global-tags "W:\TEMP\TimeScapes-satellite dish (orig)_16_09_19_3410__02.xml" -d 0 --default-track 0:yes --default-duration 0:24000/1001fps --aspect-ratio-factor 0:1/1 --no-chapters --compression -1:none --forced-track 0:yes --no-audio --no-subtitles "W:\TEMP\TimeScapes-satellite dish (orig)_16_09_19_3410_01.265"
finished after 00:00:00.117
Created W:\OUTPUT\TimeScapes-satellite dish (orig).mkv (1.43594 MB)
finishedJob: 16_09_19_3410
Job 16_09_19_3410 finished!

[gonca]

I'll run a test encode in a second

If you normally get, then informed about your system and what encoder assembly used

Та!

I just had a look at your x265 encode and it appears to be fine

[Gravitator]

Done and it looks fine

And now this version

[Gravitator]

What the result is a file from the build x265-09.68 (version of Hybrid do you use?)

[gonca]

The x265 you rar'd gives lousy results at 1200
I use the latest hybrid with the x265 that comes with it, 0.9+9-8277xxxx

[Marchand]

Hybrid fully functional 8 and 10 bits (HEVC encoder version 0.9+68-78c1f43f12f57ba6)

Hybrid 10bits.04.04.14v1_17_59_50_6010_10.265"
x265 [info]: HEVC encoder version 0.9+68-78c1f43f12f57ba6
x265 [info]: build info [Windows][GCC 4.8.2][64 bit] 16bpp
x265 [info]: Compiling by snayper [x265.ru]
x265 [info]: using cpu capabilities: MMX2 SSE2Fast SSSE3 SSE4.1 Cache64
x265 [info]: WPP streams / pool / frames : 17 / 4 / 2
x265 [info]: Main10 profile, Level-4 (Main tier)
x265 [info]: Internal bit depth : 10
x265 [info]: CU size : 64
x265 [info]: Max RQT depth inter / intra : 1 / 1
x265 [info]: ME / range / subpel / merge : umh / 60 / 4 / 2
x265 [info]: Keyframe min / max / scenecut : 1 / 250 / 40
x265 [info]: Cb/Cr QP Offset : 3 / 3
x265 [info]: Lookahead / bframes / badapt : 15 / 4 / 1
x265 [info]: b-pyramid / weightp / weightb / refs: 1 / 1 / 0 / 1
x265 [info]: Rate Control / AQ-Strength / CUTree : CRF-28.0 / 1.0 / 1
x265 [info]: tools: cfm esd rd=3 lft sao-lcu sign-hide
encoded 179 frames in 106.22s (1.69 fps), 1318.06 kb/s, SSIM Mean Y: 0.9860045 (18.540 dB)
x265 [info]: frame I: 3 Avg QP:24.92 kb/s: 3837.18 SSIM Mean: 0.992583 (21.298dB)
x265 [info]: frame P: 97 Avg QP:28.33 kb/s: 1917.52 SSIM Mean: 0.985924 (18.515dB)
x265 [info]: frame B: 79 Avg QP:30.81 kb/s: 486.35 SSIM Mean: 0.985854 (18.494dB)
x265 [info]: global : 179 Avg QP:29.37 kb/s: 1318.06 SSIM Mean: 0.986005 (18.540dB)
x265 [info]: Weighted P-Frames: Y:17.5% UV:16.5%
x265 [info]: consecutive B-frames: 21.0% 79.0% 0.0% 0.0% 0.0%
finished after 00:01:46.628

[Gravitator]

The x265 you rar'd gives lousy results at 1200

Degradation? ... Then developer should look at what is wrong with him

[Marchand]

The x265 you rar'd gives lousy results at 1200

Degradation? ... Then developer should look at what is wrong with him

Friend, simply replace the files x265_0.9 _x64_8bpp +68 (x265.exe) and x265_0.9 _x64_16bpp +68 (x265-16bit.exe) and restart the Hybrid is ready or use the files on x32 if your system is Win32.

[Gravitator]

I very slowly turns to track the changes (old computer)

"C:\PROGRA~1\Hybrid\x265.exe" --preset veryslow --input - --input-res 2560x1440 --fps 23.976 --frames 242 --bitrate 1200 --colormatrix bt470bg
x265 [info]: HEVC encoder version 0.9+68-78c1f43f12f5
x265 [info]: build info [Windows][ICC 1400][64 bit] 8bpp
x265 [info]: using cpu capabilities: MMX2 SSE2Fast SSSE3 Cache64
x265 [info]: WPP streams / pool / frames : 23 / 2 / 1
x265 [info]: Main profile, Level-5 (Main tier)
x265 [info]: CU size : 64
x265 [info]: Max RQT depth inter / intra : 3 / 3
x265 [info]: ME / range / subpel / merge : star / 57 / 4 / 4
x265 [info]: Keyframe min / max / scenecut : 23 / 250 / 40
x265 [info]: Lookahead / bframes / badapt : 40 / 8 / 2
x265 [info]: b-pyramid / weightp / weightb / refs: 1 / 1 / 0 / 5
x265 [info]: Rate Control / AQ-Strength / CUTree : ABR-1200 kbps / 1.0 / 1
x265 [info]: tools: rect amp rd=6 lft sao-lcu sign-hide
encoded 240 frames in 5272.58s (0.05 fps), 1201.56 kb/s
x265 [info]: frame I: 1 Avg QP:34.26 kb/s: 13232.26
x265 [info]: frame P: 62 Avg QP:33.76 kb/s: 2561.16
x265 [info]: frame B: 177 Avg QP:36.19 kb/s: 657.34
x265 [info]: global : 240 Avg QP:35.56 kb/s: 1201.56
x265 [info]: Weighted P-Frames: Y:8.1% UV:8.1%
x265 [info]: consecutive B-frames: 3.2% 11.1% 31.7% 25.4% 14.3% 12.7% 1.6% 0.0% 0.0%
finished after 01:27:57.716

[Marchand]

[QUOTE=Gravitator;2316696]I very slowly turns to track the changes (old computer)

[Gravitator]

I choose here this