We truncated the diff of some files because they were too big.
If you want to see the full diff for every file, click here.
Changes of Revision 20
x265.changes
Changed
x
1
2
-------------------------------------------------------------------3
+Fri Feb 24 14:03:24 UTC 2017 - ismail@i10z.com4
+5
+- Update to version 2.36
+ Encoder enhancements7
+ * New SSIM-based RD-cost computation for improved visual quality,8
+ and efficiency; use --ssim-rd to exercise.9
+ * Multi-pass encoding can now share analysis information from10
+ prior passes.11
+ * A dedicated thread pool for lookahead can now be specified12
+ with --lookahead-threads.13
+ * option:–dynamic-rd dynamically increase analysis in areas14
+ where the bitrate is being capped by VBV; works for both15
+ CRF and ABR encodes with VBV settings.16
+ * The number of bits used to signal the delta-QP can be17
+ optimized with the --opt-cu-delta-qp option.18
+ * Experimental feature option:–aq-motion adds new QP offsets19
+ based on relative motion of a block with respect to the20
+ movement of the frame.21
+ API changes22
+ * Reconfigure API now supports signalling new scaling lists.23
+ * x265 application’s csv functionality now reports time24
+ (in milliseconds) taken to encode each frame.25
+ * --strict-cbr enables stricter bitrate adherence by adding26
+ filler bits when achieved bitrate is lower than the target.27
+ * --hdr can be used to ensure that max-cll and max-fall values28
+ are always signaled (even if 0,0).29
+ Bug fixes30
+ * Fixed scaling lists support for 4:4:4 videos.31
+ * Inconsistent output fix for --opt-qp-pss by removing last32
+ slice’s QP from cost calculation.33
+34
+-------------------------------------------------------------------35
Sun Jan 1 20:32:07 UTC 2017 - idonmez@suse.com36
37
- Update to version 2.238
- Encode enhancements39
+ Encoder enhancements40
* Enhancements to TU selection algorithm with early-outs for41
improved speed; use --limit-tu to exercise.42
* New motion search method SEA (Successive Elimination Algorithm)43
x265.spec
Changed
14
1
2
# based on the spec file from https://build.opensuse.org/package/view_file/home:Simmphonie/libx265/3
4
Name: x2655
-%define soname 1026
+%define soname 1107
%define libname lib%{name}8
%define libsoname %{libname}-%{soname}9
-Version: 2.210
+Version: 2.311
Release: 012
License: GPL-2.0+13
Summary: A free h265/HEVC encoder - encoder binary14
baselibs.conf
Changed
4
1
2
-libx265-1023
+libx265-1104
x265_2.2.tar.gz/.hg_archival.txt -> x265_2.3.tar.gz/.hg_archival.txt
Changed
8
1
2
repo: 09fe40627f03a0f9c3e6ac78b22ac93da23f9fdf3
-node: be14a7e9755e54f0fd34911c72bdfa66981220bc4
+node: 3037c1448549ca920967831482c653e5892fa8ed5
branch: stable6
-tag: 2.27
+tag: 2.38
x265_2.2.tar.gz/.hgtags -> x265_2.3.tar.gz/.hgtags
Changed
6
1
2
1d3b6e448e01ec40b392ef78b7e55a86249fbe68 1.93
960c9991d0dcf46559c32e070418d3cbb7e8aa2f 2.04
981e3bfef16a997bce6f46ce1b15631a0e234747 2.15
+be14a7e9755e54f0fd34911c72bdfa66981220bc 2.26
x265_2.2.tar.gz/doc/reST/cli.rst -> x265_2.3.tar.gz/doc/reST/cli.rst
Changed
167
1
2
.. option:: --limit-tu <0..4>3
4
Enables early exit from TU depth recursion, for inter coded blocks.5
+ 6
Level 1 - decides to recurse to next higher depth based on cost 7
comparison of full size TU and split TU.8
9
10
quad-tree begins at the same depth of the coded tree unit, but if the11
maximum TU size is smaller than the CU size then transform QT begins 12
at the depth of the max-tu-size. Default: 32.13
+ 14
+.. option:: --dynamic-rd <0..4>15
+ 16
+ Increases the RD level at points where quality drops due to VBV rate 17
+ control enforcement. The number of CUs for which the RD is reconfigured 18
+ is determined based on the strength. Strength 1 gives the best FPS, 19
+ strength 4 gives the best SSIM. Strength 0 switches this feature off. 20
+ Default: 0.21
+ 22
+ Effective for RD levels 4 and below.23
+24
+.. option:: --ssim-rd, --no-ssim-rd25
+26
+ Enable/Disable SSIM RDO. SSIM is a better perceptual quality assessment27
+ method as compared to MSE. SSIM based RDO calculation is based on residual28
+ divisive normalization scheme. This normalization is consistent with the 29
+ luminance and contrast masking effect of Human Visual System. It is used30
+ for mode selection during analysis of CTUs and can achieve significant 31
+ gain in terms of objective quality metrics SSIM and PSNR. It only has effect32
+ on presets which use RDO-based mode decisions (:option:`--rd` 3 and above).33
34
Temporal / motion search options35
================================36
37
Default: 8 for ultrafast, superfast, faster, fast, medium38
4 for slow, slower39
disabled for veryslow, slower40
+ 41
+.. option:: --lookahead-threads <integer>42
43
+ Use multiple worker threads dedicated to doing only lookahead instead of sharing44
+ the worker threads with frame Encoders. A dedicated lookahead threadpool is created with the45
+ specified number of worker threads. This can range from 0 upto half the46
+ hardware threads available for encoding. Using too many threads for lookahead can starve47
+ resources for frame Encoder and can harm performance. Default is 0 - disabled, Lookahead 48
+ shares worker threads with other FrameEncoders . 49
50
+ **Values:** 0 - disabled(default). Max - Half of available hardware threads.51
+ 52
.. option:: --b-adapt <integer>53
54
Set the level of effort in determining B frame placement.55
56
Default 1.0.57
**Range of values:** 0.0 to 3.058
59
+.. option:: --aq-motion, --no-aq-motion60
+61
+ Adjust the AQ offsets based on the relative motion of each block with62
+ respect to the motion of the frame. The more the relative motion of the block,63
+ the more quantization is used. Default disabled. **Experimental Feature**64
+65
.. option:: --qg-size <64|32|16|8>66
67
Enable adaptive quantization for sub-CTUs. This parameter specifies 68
69
* :option:`--subme` = MIN(2, :option:`--subme`)70
* :option:`--rd` = MIN(2, :option:`--rd`)71
72
+.. option:: --multi-pass-opt-analysis, --no-multi-pass-opt-analysis73
+74
+ Enable/Disable multipass analysis refinement along with multipass ratecontrol. Based on 75
+ the information stored in pass 1, in subsequent passes analysis data is refined 76
+ and also redundant steps are skipped.77
+ In pass 1 analysis information like motion vector, depth, reference and prediction78
+ modes of the final best CTU partition is stored for each CTU.79
+ Default disabled.80
+81
+.. option:: --multi-pass-opt-distortion, --no-multi-pass-opt-distortion82
+83
+ Enable/Disable multipass refinement of qp based on distortion data along with multipass84
+ ratecontrol. In pass 1 distortion of best CTU partition is stored. CTUs with high85
+ distortion get lower(negative)qp offsets and vice-versa for low distortion CTUs in pass 2.86
+ This helps to improve the subjective quality.87
+ Default disabled.88
+89
.. option:: --strict-cbr, --no-strict-cbr90
91
Enables stricter conditions to control bitrate deviance from the 92
93
where %hu are unsigned 16bit integers and %u are unsigned 32bit94
integers. The SEI includes X,Y display primaries for RGB channels95
and white point (WP) in units of 0.00002 and max,min luminance (L)96
- values in units of 0.0001 candela per meter square. (HDR)97
+ values in units of 0.0001 candela per meter square. Applicable for HDR98
+ content.99
100
Example for a P3D65 1000-nits monitor, where G(x=0.265, y=0.690),101
B(x=0.150, y=0.060), R(x=0.680, y=0.320), WP(x=0.3127, y=0.3290),102
103
emitted. The string format is "%hu,%hu" where %hu are unsigned 16bit104
integers. The first value is the max content light level (or 0 if no105
maximum is indicated), the second value is the maximum picture106
- average light level (or 0). (HDR)107
+ average light level (or 0). Applicable for HDR content.108
109
Example for MaxCLL=1000 candela per square meter, MaxFALL=400110
candela per square meter:111
112
Note that this string value will need to be escaped or quoted to113
protect against shell expansion on many platforms. No default.114
115
+.. option:: --hdr, --no-hdr116
+117
+ Force signalling of HDR parameters in SEI packets. Enabled118
+ automatically when :option`--master-display` or :option`--max-cll` is119
+ specified. Useful when there is a desire to signal 0 values for max-cll120
+ and max-fall. Default disabled.121
+122
.. option:: --min-luma <integer>123
124
Minimum luma value allowed for input pictures. Any values below min-luma125
126
127
Maximum of the picture order count. Default 8128
129
-.. option:: --[no-]vui-timing-info130
+.. option:: --vui-timing-info, --no-vui-timing-info131
132
Emit VUI timing info in bitstream. Default enabled.133
134
-.. option:: --[no-]vui-hrd-info135
+.. option:: --vui-hrd-info, --no-vui-hrd-info136
137
Emit VUI HRD info in bitstream. Default enabled when138
:option:`--hrd` is enabled.139
140
-.. option:: --[no-]opt-qp-pps141
+.. option:: --opt-qp-pps, --no-opt-qp-pps142
143
Optimize QP in PPS (instead of default value of 26) based on the QP values144
observed in last GOP. Default enabled.145
146
-.. option:: --[no-]opt-ref-list-length-pps147
+.. option:: --opt-ref-list-length-pps, --no-opt-ref-list-length-pps148
149
Optimize L0 and L1 ref list length in PPS (instead of default value of 0)150
based on the lengths observed in the last GOP. Default enabled.151
152
-.. option:: --[no-]multi-pass-opt-rps153
+.. option:: --multi-pass-opt-rps, --no-multi-pass-opt-rps154
155
Enable storing commonly used RPS in SPS in multi pass mode. Default disabled.156
157
+.. option:: --opt-cu-delta-qp, --no-opt-cu-delta-qp158
+159
+ Optimize CU level QPs by pulling up lower QPs to value close to meanQP thereby160
+ minimizing fluctuations in deltaQP signalling. Default disabled.161
+162
+ Only effective at RD levels 5 and 6163
+164
165
Debugging options166
=================167
x265_2.2.tar.gz/doc/reST/releasenotes.rst -> x265_2.3.tar.gz/doc/reST/releasenotes.rst
Changed
45
1
2
Release Notes3
*************4
5
+Version 2.36
+===========7
+8
+Release date - 15th February, 2017.9
+10
+Encoder enhancements11
+--------------------12
+1. New SSIM-based RD-cost computation for improved visual quality, and efficiency; use :option:`--ssim-rd` to exercise.13
+2. Multi-pass encoding can now share analysis information from prior passes (in addition to rate-control information) to improve performance and quality of subsequent passes; to your multi-pass command-lines that use the :option:`--pass` option, add :option:`--multi-pass-opt-distortion` to share distortion information, and :option:`--multi-pass-opt-analysis` to share other analysis information.14
+3. A dedicated thread pool for lookahead can now be specified with :option:`--lookahead-threads`.15
+4. option:`--dynamic-rd` dynamically increase analysis in areas where the bitrate is being capped by VBV; works for both CRF and ABR encodes with VBV settings.16
+5. The number of bits used to signal the delta-QP can be optimized with the :option:`--opt-cu-delta-qp` option; found to be useful in some scenarios for lower bitrate targets.17
+6. Experimental feature option:`--aq-motion` adds new QP offsets based on relative motion of a block with respect to the movement of the frame.18
+19
+API changes20
+-----------21
+1. Reconfigure API now supports signalling new scaling lists.22
+2. x265 application's csv functionality now reports time (in milliseconds) taken to encode each frame.23
+3. :option:`--strict-cbr` enables stricter bitrate adherence by adding filler bits when achieved bitrate is lower than the target; earlier, it was only reacting when the achieved rate was higher.24
+4. :option:`--hdr` can be used to ensure that max-cll and max-fall values are always signaled (even if 0,0).25
+26
+Bug fixes27
+---------28
+1. Fixed incorrect HW thread counting on MacOS platform.29
+2. Fixed scaling lists support for 4:4:4 videos.30
+3. Inconsistent output fix for :option:`--opt-qp-pss` by removing last slice's QP from cost calculation.31
+4. VTune profiling (enabled using ENABLE_VTUNE CMake option) now also works with 2017 VTune builds.32
+33
Version 2.234
===========35
36
37
--------------------38
1. Enhancements to TU selection algorithm with early-outs for improved speed; use :option:`--limit-tu` to exercise.39
2. New motion search method SEA (Successive Elimination Algorithm) supported now as :option: `--me` 440
-3. Bit-stream optimizations to improve fields in PPS and SPS for bit-rate savings through :option:`--[no-]opt-qp-pps`, :option:`--[no-]opt-ref-list-length-pps`, and :option:`--[no-]multi-pass-opt-rps`.41
+3. Bit-stream optimizations to improve fields in PPS and SPS for bit-rate savings through :option:`--opt-qp-pps`, :option:`--opt-ref-list-length-pps`, and :option:`--multi-pass-opt-rps`.42
4. Enabled using VBV constraints when encoding without WPP.43
5. All param options dumped in SEI packet in bitstream when info selected.44
6. x265 now supports POWERPC-based systems. Several key functions also have optimized ALTIVEC kernels.45
x265_2.2.tar.gz/source/CMakeLists.txt -> x265_2.3.tar.gz/source/CMakeLists.txt
Changed
21
1
2
option(NATIVE_BUILD "Target the build CPU" OFF)3
option(STATIC_LINK_CRT "Statically link C runtime for release builds" OFF)4
mark_as_advanced(FPROFILE_USE FPROFILE_GENERATE NATIVE_BUILD)5
-6
# X265_BUILD must be incremented each time the public API is changed7
-set(X265_BUILD 102)8
+set(X265_BUILD 110)9
configure_file("${PROJECT_SOURCE_DIR}/x265.def.in"10
"${PROJECT_BINARY_DIR}/x265.def")11
configure_file("${PROJECT_SOURCE_DIR}/x265_config.h.in"12
13
set(XCODE 1)14
endif()15
if(APPLE)16
- add_definitions(-DMACOS)17
+ add_definitions(-DMACOS=1)18
endif()19
20
if(${CMAKE_CXX_COMPILER_ID} STREQUAL "Clang")21
x265_2.2.tar.gz/source/cmake/FindVtune.cmake -> x265_2.3.tar.gz/source/cmake/FindVtune.cmake
Changed
10
1
2
else()3
NAMES amplxe-vars.bat4
endif(UNIX)5
- HINTS $ENV{VTUNE_AMPLIFIER_XE_2016_DIR} $ENV{VTUNE_AMPLIFIER_XE_2015_DIR}6
+ HINTS $ENV{VTUNE_AMPLIFIER_XE_2017_DIR} $ENV{VTUNE_AMPLIFIER_XE_2016_DIR} $ENV{VTUNE_AMPLIFIER_XE_2015_DIR}7
DOC "Vtune root directory")8
9
set (VTUNE_INCLUDE_DIR ${VTUNE_DIR}/include)10
x265_2.2.tar.gz/source/common/common.h -> x265_2.3.tar.gz/source/common/common.h
Changed
12
1
2
3
#define INTEGRAL_PLANE_NUM 12 // 12 integral planes for 32x32, 32x24, 32x8, 24x32, 16x16, 16x12, 16x4, 12x16, 8x32, 8x8, 4x16 and 4x4.4
5
+#define NAL_TYPE_OVERHEAD 26
+#define START_CODE_OVERHEAD 3 7
+#define FILLER_OVERHEAD (NAL_TYPE_OVERHEAD + START_CODE_OVERHEAD + 1)8
+9
namespace X265_NS {10
11
enum { SAO_NUM_OFFSET = 4 };12
x265_2.2.tar.gz/source/common/cudata.cpp -> x265_2.3.tar.gz/source/common/cudata.cpp
Changed
102
1
2
m_mvd[0] = m_mv[1] + m_numPartitions;3
m_mvd[1] = m_mvd[0] + m_numPartitions;4
5
+ m_distortion = dataPool.distortionMemBlock + instance * m_numPartitions;6
+7
uint32_t cuSize = g_maxCUSize >> depth;8
m_trCoeff[0] = dataPool.trCoeffMemBlock + instance * (cuSize * cuSize);9
m_trCoeff[1] = m_trCoeff[2] = 0;10
m_transformSkip[1] = m_transformSkip[2] = m_cbf[1] = m_cbf[2] = 0;11
+ m_fAc_den[0] = m_fDc_den[0] = 0;12
}13
else14
{15
16
m_mvd[0] = m_mv[1] + m_numPartitions;17
m_mvd[1] = m_mvd[0] + m_numPartitions;18
19
+ m_distortion = dataPool.distortionMemBlock + instance * m_numPartitions;20
+21
uint32_t cuSize = g_maxCUSize >> depth;22
uint32_t sizeL = cuSize * cuSize;23
uint32_t sizeC = sizeL >> (m_hChromaShift + m_vChromaShift); // block chroma part24
m_trCoeff[0] = dataPool.trCoeffMemBlock + instance * (sizeL + sizeC * 2);25
m_trCoeff[1] = m_trCoeff[0] + sizeL;26
m_trCoeff[2] = m_trCoeff[0] + sizeL + sizeC;27
+ for (int i = 0; i < 3; i++)28
+ m_fAc_den[i] = m_fDc_den[i] = 0;29
}30
}31
32
33
for (int8_t i = 0; i < NUM_TU_DEPTH; i++)34
m_refTuDepth[i] = -1;35
36
+ m_vbvAffected = false;37
+38
uint32_t widthInCU = m_slice->m_sps->numCuInWidth;39
m_cuLeft = (m_cuAddr % widthInCU) ? m_encData->getPicCTU(m_cuAddr - 1) : NULL;40
m_cuAbove = (m_cuAddr >= widthInCU) && !m_bFirstRowInSlice ? m_encData->getPicCTU(m_cuAddr - widthInCU) : NULL;41
m_cuAboveLeft = (m_cuLeft && m_cuAbove) ? m_encData->getPicCTU(m_cuAddr - widthInCU - 1) : NULL;42
m_cuAboveRight = (m_cuAbove && ((m_cuAddr % widthInCU) < (widthInCU - 1))) ? m_encData->getPicCTU(m_cuAddr - widthInCU + 1) : NULL;43
+ memset(m_distortion, 0, m_numPartitions * sizeof(sse_t));44
}45
46
// initialize Sub partition47
48
m_bFirstRowInSlice = ctu.m_bFirstRowInSlice;49
m_bLastRowInSlice = ctu.m_bLastRowInSlice;50
m_bLastCuInSlice = ctu.m_bLastCuInSlice;51
+ for (int i = 0; i < 3; i++)52
+ {53
+ m_fAc_den[i] = ctu.m_fAc_den[i];54
+ m_fDc_den[i] = ctu.m_fDc_den[i];55
+ }56
57
X265_CHECK(m_numPartitions == cuGeom.numPartitions, "initSubCU() size mismatch\n");58
59
60
61
/* initialize the remaining CU data in one memset */62
memset(m_predMode, 0, (ctu.m_chromaFormat == X265_CSP_I400 ? BytesPerPartition - 12 : BytesPerPartition - 8) * m_numPartitions);63
+ memset(m_distortion, 0, m_numPartitions * sizeof(sse_t));64
}65
66
/* Copy the results of a sub-part (split) CU to the parent CU */67
68
memcpy(m_mvd[0] + offset, subCU.m_mvd[0], childGeom.numPartitions * sizeof(MV));69
memcpy(m_mvd[1] + offset, subCU.m_mvd[1], childGeom.numPartitions * sizeof(MV));70
71
+ memcpy(m_distortion + offset, subCU.m_distortion, childGeom.numPartitions * sizeof(sse_t));72
+73
uint32_t tmp = 1 << ((g_maxLog2CUSize - childGeom.depth) * 2);74
uint32_t tmp2 = subPartIdx * tmp;75
memcpy(m_trCoeff[0] + tmp2, subCU.m_trCoeff[0], sizeof(coeff_t)* tmp);76
77
memcpy(m_mv[1], cu.m_mv[1], m_numPartitions * sizeof(MV));78
memcpy(m_mvd[0], cu.m_mvd[0], m_numPartitions * sizeof(MV));79
memcpy(m_mvd[1], cu.m_mvd[1], m_numPartitions * sizeof(MV));80
+ memcpy(m_distortion, cu.m_distortion, m_numPartitions * sizeof(sse_t));81
82
/* force TQBypass to true */83
m_partSet(m_tqBypass, true);84
85
memcpy(ctu.m_mvd[0] + m_absIdxInCTU, m_mvd[0], m_numPartitions * sizeof(MV));86
memcpy(ctu.m_mvd[1] + m_absIdxInCTU, m_mvd[1], m_numPartitions * sizeof(MV));87
88
+ memcpy(ctu.m_distortion + m_absIdxInCTU, m_distortion, m_numPartitions * sizeof(sse_t));89
+90
uint32_t tmpY = 1 << ((g_maxLog2CUSize - depth) * 2);91
uint32_t tmpY2 = m_absIdxInCTU << (LOG2_UNIT_SIZE * 2);92
memcpy(ctu.m_trCoeff[0] + tmpY2, m_trCoeff[0], sizeof(coeff_t)* tmpY);93
94
memcpy(m_mvd[0], ctu.m_mvd[0] + m_absIdxInCTU, m_numPartitions * sizeof(MV));95
memcpy(m_mvd[1], ctu.m_mvd[1] + m_absIdxInCTU, m_numPartitions * sizeof(MV));96
97
+ memcpy(m_distortion, ctu.m_distortion + m_absIdxInCTU, m_numPartitions * sizeof(sse_t));98
+99
/* clear residual coding flags */100
m_partSet(m_tuDepth, 0);101
m_partSet(m_transformSkip[0], 0);102
x265_2.2.tar.gz/source/common/cudata.h -> x265_2.3.tar.gz/source/common/cudata.h
Changed
55
1
2
static cubcast_t s_partSet[NUM_FULL_DEPTH]; // pointer to broadcast set functions per absolute depth3
static uint32_t s_numPartInCUSize;4
5
+ bool m_vbvAffected;6
+7
FrameData* m_encData;8
const Slice* m_slice;9
10
11
uint8_t* m_chromaIntraDir; // array of intra directions (chroma)12
enum { BytesPerPartition = 21 }; // combined sizeof() of all per-part data13
14
+ sse_t* m_distortion;15
coeff_t* m_trCoeff[3]; // transformed coefficient buffer per plane16
int8_t m_refTuDepth[NUM_TU_DEPTH]; // TU depth of CU at depths 0, 1 and 217
18
19
const CUData* m_cuAboveRight; // pointer to above-right neighbor CTU20
const CUData* m_cuAbove; // pointer to above neighbor CTU21
const CUData* m_cuLeft; // pointer to left neighbor CTU22
+ double m_meanQP;23
+ uint64_t m_fAc_den[3];24
+ uint64_t m_fDc_den[3];25
26
CUData();27
28
29
uint8_t* charMemBlock;30
coeff_t* trCoeffMemBlock;31
MV* mvMemBlock;32
+ sse_t* distortionMemBlock;33
34
- CUDataMemPool() { charMemBlock = NULL; trCoeffMemBlock = NULL; mvMemBlock = NULL; }35
+ CUDataMemPool() { charMemBlock = NULL; trCoeffMemBlock = NULL; mvMemBlock = NULL; distortionMemBlock = NULL; }36
37
bool create(uint32_t depth, uint32_t csp, uint32_t numInstances)38
{39
40
}41
CHECKED_MALLOC(charMemBlock, uint8_t, numPartition * numInstances * CUData::BytesPerPartition);42
CHECKED_MALLOC_ZERO(mvMemBlock, MV, numPartition * 4 * numInstances);43
+ CHECKED_MALLOC(distortionMemBlock, sse_t, numPartition * numInstances);44
return true;45
fail:46
return false;47
48
X265_FREE(trCoeffMemBlock);49
X265_FREE(mvMemBlock);50
X265_FREE(charMemBlock);51
+ X265_FREE(distortionMemBlock);52
}53
};54
}55
x265_2.2.tar.gz/source/common/frame.cpp -> x265_2.3.tar.gz/source/common/frame.cpp
Changed
18
1
2
m_userSEI.payloads = NULL;3
memset(&m_lowres, 0, sizeof(m_lowres));4
m_rcData = NULL;5
+ m_encodeStartTime = 0;6
}7
8
bool Frame::create(x265_param *param, float* quantOffsets)9
10
CHECKED_MALLOC_ZERO(m_rcData, RcStats, 1);11
12
if (m_fencPic->create(param->sourceWidth, param->sourceHeight, param->internalCsp) &&13
- m_lowres.create(m_fencPic, param->bframes, !!param->rc.aqMode, param->rc.qgSize))14
+ m_lowres.create(m_fencPic, param->bframes, !!param->rc.aqMode || !!param->bAQMotion, param->rc.qgSize))15
{16
X265_CHECK((m_reconColCount == NULL), "m_reconColCount was initialized");17
m_numRows = (m_fencPic->m_picHeight + g_maxCUSize - 1) / g_maxCUSize;18
x265_2.2.tar.gz/source/common/frame.h -> x265_2.3.tar.gz/source/common/frame.h
Changed
12
1
2
Frame* m_prev;3
x265_param* m_param; // Points to the latest param set for the frame.4
x265_analysis_data m_analysisData;5
+ x265_analysis_2Pass m_analysis2Pass;6
RcStats* m_rcData;7
+8
+ int64_t m_encodeStartTime;9
Frame();10
11
bool create(x265_param *param, float* quantOffsets);12
x265_2.2.tar.gz/source/common/framedata.h -> x265_2.3.tar.gz/source/common/framedata.h
Changed
42
1
2
double avgLumaDistortion;3
double avgChromaDistortion;4
double avgPsyEnergy;5
+ double avgSsimEnergy;6
double avgResEnergy;7
double percentIntraNxN;8
double percentSkipCu[NUM_CU_DEPTH];9
10
uint64_t lumaDistortion;11
uint64_t chromaDistortion;12
uint64_t psyEnergy;13
+ int64_t ssimEnergy;14
uint64_t resEnergy;15
uint64_t cntSkipCu[NUM_CU_DEPTH];16
uint64_t cntMergeCu[NUM_CU_DEPTH];17
18
uint8_t* partSize;19
uint8_t* mergeFlag;20
};21
+22
+struct analysis2PassFrameData23
+{24
+ uint8_t* depth;25
+ MV* m_mv[2];26
+ int* mvpIdx[2];27
+ int32_t* ref[2];28
+ uint8_t* modes;29
+ sse_t* distortion;30
+ sse_t* ctuDistortion;31
+ double* scaledDistortion;32
+ double averageDistortion;33
+ double sdDistortion;34
+ uint32_t highDistortionCtuCount;35
+ uint32_t lowDistortionCtuCount;36
+ double* offset;37
+ double* threshold;38
+};39
+40
}41
#endif // ifndef X265_FRAMEDATA_H42
x265_2.2.tar.gz/source/common/lowres.cpp -> x265_2.3.tar.gz/source/common/lowres.cpp
Changed
19
1
2
if (bAQEnabled)3
{4
CHECKED_MALLOC_ZERO(qpAqOffset, double, cuCountFullRes);5
+ CHECKED_MALLOC_ZERO(qpAqMotionOffset, double, cuCountFullRes);6
CHECKED_MALLOC_ZERO(invQscaleFactor, int, cuCountFullRes);7
CHECKED_MALLOC_ZERO(qpCuTreeOffset, double, cuCountFullRes);8
CHECKED_MALLOC_ZERO(blockVariance, uint32_t, cuCountFullRes);9
10
X265_FREE(lowresMvCosts[0][i]);11
X265_FREE(lowresMvCosts[1][i]);12
}13
-14
X265_FREE(qpAqOffset);15
+ X265_FREE(qpAqMotionOffset);16
X265_FREE(invQscaleFactor);17
X265_FREE(qpCuTreeOffset);18
X265_FREE(propagateCost);19
x265_2.2.tar.gz/source/common/lowres.h -> x265_2.3.tar.gz/source/common/lowres.h
Changed
9
1
2
/* rate control / adaptive quant data */3
double* qpAqOffset; // AQ QP offset values for each 16x16 CU4
double* qpCuTreeOffset; // cuTree QP offset values for each 16x16 CU5
+ double* qpAqMotionOffset;6
int* invQscaleFactor; // qScale values for qp Aq Offsets7
int* invQscaleFactor8x8; // temporary buffer for qg-size 88
uint32_t* blockVariance;9
x265_2.2.tar.gz/source/common/param.cpp -> x265_2.3.tar.gz/source/common/param.cpp
Changed
132
1
2
param->bEnableAccessUnitDelimiters = 0;3
param->bEmitHRDSEI = 0;4
param->bEmitInfoSEI = 1;5
+ param->bEmitHDRSEI = 0;6
7
/* CU definitions */8
param->maxCUSize = 64;9
10
param->bBPyramid = 1;11
param->scenecutThreshold = 40; /* Magic number pulled in from x264 */12
param->lookaheadSlices = 8;13
+ param->lookaheadThreads = 0;14
param->scenecutBias = 5.0;15
-16
/* Intra Coding Tools */17
param->bEnableConstrainedIntra = 0;18
param->bEnableStrongIntraSmoothing = 1;19
20
param->bEnableTemporalMvp = 1;21
param->bSourceReferenceEstimation = 0;22
param->limitTU = 0;23
+ param->dynamicRd = 0;24
25
/* Loop Filter */26
param->bEnableLoopFilter = 1;27
28
param->psyRd = 2.0;29
param->psyRdoq = 0.0;30
param->analysisMode = 0;31
+ param->analysisMultiPassRefine = 0;32
+ param->analysisMultiPassDistortion = 0;33
param->analysisFileName = NULL;34
param->bIntraInBFrames = 0;35
param->bLossless = 0;36
37
param->bEnableTemporalSubLayers = 0;38
param->bEnableRdRefine = 0;39
param->bMultiPassOptRPS = 0;40
+ param->bSsimRd = 0;41
42
/* Rate control options */43
param->rc.vbvMaxBitrate = 0;44
45
param->bEmitVUIHRDInfo = 1;46
param->bOptQpPPS = 1;47
param->bOptRefListLengthPPS = 1;48
+ param->bOptCUDeltaQP = 0;49
+ param->bAQMotion = 0;50
51
}52
53
54
OPT("opt-ref-list-length-pps") p->bOptRefListLengthPPS = atobool(value);55
OPT("multi-pass-opt-rps") p->bMultiPassOptRPS = atobool(value);56
OPT("scenecut-bias") p->scenecutBias = atof(value);57
-58
+ OPT("lookahead-threads") p->lookaheadThreads = atoi(value);59
+ OPT("opt-cu-delta-qp") p->bOptCUDeltaQP = atobool(value);60
+ OPT("multi-pass-opt-analysis") p->analysisMultiPassRefine = atobool(value);61
+ OPT("multi-pass-opt-distortion") p->analysisMultiPassDistortion = atobool(value);62
+ OPT("aq-motion") p->bAQMotion = atobool(value);63
+ OPT("dynamic-rd") p->dynamicRd = atof(value);64
+ OPT("ssim-rd")65
+ {66
+ int bval = atobool(value);67
+ if (bError || bval)68
+ {69
+ bError = false;70
+ p->psyRd = 0.0;71
+ p->bSsimRd = atobool(value);72
+ }73
+ }74
+ OPT("hdr") p->bEmitHDRSEI = atobool(value);75
else76
return X265_PARAM_BAD_NAME;77
}78
79
"RD Level is out of range");80
CHECK(param->rdoqLevel < 0 || param->rdoqLevel > 2,81
"RDOQ Level is out of range");82
+ CHECK(param->dynamicRd < 0 || param->dynamicRd > x265_ADAPT_RD_STRENGTH,83
+ "Dynamic RD strength must be between 0 and 4");84
CHECK(param->bframes && param->bframes >= param->lookaheadDepth && !param->rc.bStatRead,85
"Lookahead depth must be greater than the max consecutive bframe count");86
CHECK(param->bframes < 0,87
88
CHECK(param->searchMethod == X265_SEA && (param->sourceWidth > 840 || param->sourceHeight > 480),89
"SEA motion search does not support resolutions greater than 480p in 32 bit build");90
#endif91
+92
+ if (param->masteringDisplayColorVolume || param->maxFALL || param->maxCLL)93
+ param->bEmitHDRSEI = 1;94
+95
return check_failed;96
}97
98
99
TOOLOPT(param->bEnableAMP, "amp");100
TOOLOPT(param->limitModes, "limit-modes");101
TOOLVAL(param->rdLevel, "rd=%d");102
+ TOOLVAL(param->dynamicRd, "dynamic-rd=%.2f");103
TOOLVAL(param->psyRd, "psy-rd=%.2lf");104
TOOLVAL(param->rdoqLevel, "rdoq=%d");105
TOOLVAL(param->psyRdoq, "psy-rdoq=%.2lf");106
107
TOOLOPT(param->bEnableFastIntra, "fast-intra");108
TOOLOPT(param->bEnableStrongIntraSmoothing, "strong-intra-smoothing");109
TOOLVAL(param->lookaheadSlices, "lslices=%d");110
+ TOOLVAL(param->lookaheadThreads, "lthreads=%d")111
if (param->maxSlices > 1)112
TOOLVAL(param->maxSlices, "slices=%d");113
if (param->bEnableLoopFilter)114
115
s += sprintf(s, " tu-intra-depth=%d", p->tuQTMaxIntraDepth);116
s += sprintf(s, " limit-tu=%d", p->limitTU);117
s += sprintf(s, " rdoq-level=%d", p->rdoqLevel);118
+ s += sprintf(s, " dynamic-rd=%.2f", p->dynamicRd);119
BOOL(p->bEnableSignHiding, "signhide");120
BOOL(p->bEnableTransformSkip, "tskip");121
s += sprintf(s, " nr-intra=%d", p->noiseReductionIntra);122
123
BOOL(p->bOptRefListLengthPPS, "opt-ref-list-length-pps");124
BOOL(p->bMultiPassOptRPS, "multi-pass-opt-rps");125
s += sprintf(s, " scenecut-bias=%.2f", p->scenecutBias);126
+ BOOL(p->bOptCUDeltaQP, "opt-cu-delta-qp");127
+ BOOL(p->bAQMotion, "aq-motion");128
+ BOOL(p->bEmitHDRSEI, "hdr");129
#undef BOOL130
return buf;131
}132
x265_2.2.tar.gz/source/common/quant.cpp -> x265_2.3.tar.gz/source/common/quant.cpp
Changed
85
1
2
}3
}4
5
+uint64_t Quant::ssimDistortion(const CUData& cu, const pixel* fenc, uint32_t fStride, const pixel* recon, intptr_t rstride, uint32_t log2TrSize, TextType ttype, uint32_t absPartIdx)6
+{7
+ static const int ssim_c1 = (int)(.01 * .01 * PIXEL_MAX * PIXEL_MAX * 64 + .5); // 4168
+ static const int ssim_c2 = (int)(.03 * .03 * PIXEL_MAX * PIXEL_MAX * 64 * 63 + .5); // 2359639
+ int shift = (X265_DEPTH - 8);10
+11
+ int trSize = 1 << log2TrSize;12
+ uint64_t ssDc = 0, ssBlock = 0, ssAc = 0;13
+14
+ // Calculation of (X(0) - Y(0)) * (X(0) - Y(0)), DC15
+ ssDc = 0;16
+ for (int y = 0; y < trSize; y += 4)17
+ {18
+ for (int x = 0; x < trSize; x += 4)19
+ {20
+ int temp = fenc[y * fStride + x] - recon[y * rstride + x]; // copy of residual coeff21
+ ssDc += temp * temp;22
+ }23
+ }24
+25
+ // Calculation of (X(k) - Y(k)) * (X(k) - Y(k)), AC26
+ ssBlock = 0;27
+ for (int y = 0; y < trSize; y++)28
+ {29
+ for (int x = 0; x < trSize; x++)30
+ {31
+ int temp = fenc[y * fStride + x] - recon[y * rstride + x]; // copy of residual coeff32
+ ssBlock += temp * temp;33
+ }34
+ }35
+36
+ ssAc = ssBlock - ssDc;37
+38
+ // 1. Calculation of fdc'39
+ // Calculate numerator of dc normalization factor40
+ uint64_t fDc_num = 0;41
+42
+ // 2. Calculate dc component43
+ uint64_t dc_k = 0;44
+ for (int block_yy = 0; block_yy < trSize; block_yy += 4)45
+ {46
+ for (int block_xx = 0; block_xx < trSize; block_xx += 4)47
+ {48
+ uint32_t temp = fenc[block_yy * fStride + block_xx] >> shift;49
+ dc_k += temp * temp;50
+ }51
+ }52
+53
+ fDc_num = (2 * dc_k) + (trSize * trSize * ssim_c1); // 16 pixels -> for each 4x4 block54
+ fDc_num /= ((trSize >> 2) * (trSize >> 2));55
+56
+ // 1. Calculation of fac'57
+ // Calculate numerator of ac normalization factor58
+ uint64_t fAc_num = 0;59
+60
+ // 2. Calculate ac component61
+ uint64_t ac_k = 0;62
+ for (int block_yy = 0; block_yy < trSize; block_yy += 1)63
+ {64
+ for (int block_xx = 0; block_xx < trSize; block_xx += 1)65
+ {66
+ uint32_t temp = fenc[block_yy * fStride + block_xx] >> shift;67
+ ac_k += temp * temp;68
+ }69
+ }70
+ ac_k -= dc_k;71
+72
+ double s = 1 + 0.005 * cu.m_qp[absPartIdx];73
+74
+ fAc_num = ac_k + uint64_t(s * ac_k) + ssim_c2;75
+ fAc_num /= ((trSize >> 2) * (trSize >> 2));76
+77
+ // Calculate dc and ac normalization factor78
+ uint64_t ssim_distortion = ((ssDc * cu.m_fDc_den[ttype]) / fDc_num) + ((ssAc * cu.m_fAc_den[ttype]) / fAc_num);79
+ return ssim_distortion;80
+}81
+82
void Quant::invtransformNxN(const CUData& cu, int16_t* residual, uint32_t resiStride, const coeff_t* coeff,83
uint32_t log2TrSize, TextType ttype, bool bIntra, bool useTransformSkip, uint32_t numSig)84
{85
x265_2.2.tar.gz/source/common/quant.h -> x265_2.3.tar.gz/source/common/quant.h
Changed
10
1
2
3
void invtransformNxN(const CUData& cu, int16_t* residual, uint32_t resiStride, const coeff_t* coeff,4
uint32_t log2TrSize, TextType ttype, bool bIntra, bool useTransformSkip, uint32_t numSig);5
+ uint64_t ssimDistortion(const CUData& cu, const pixel* fenc, uint32_t fStride, const pixel* recon, intptr_t rstride,6
+ uint32_t log2TrSize, TextType ttype, uint32_t absPartIdx);7
8
/* Pattern decision for context derivation process of significant_coeff_flag */9
static uint32_t calcPatternSigCtx(uint64_t sigCoeffGroupFlag64, uint32_t cgPosX, uint32_t cgPosY, uint32_t cgBlkPos, uint32_t trSizeCG)10
x265_2.2.tar.gz/source/common/scalinglist.cpp -> x265_2.3.tar.gz/source/common/scalinglist.cpp
Changed
32
1
2
}3
4
/** set quantized matrix coefficient for encode */5
-void ScalingList::setupQuantMatrices()6
+void ScalingList::setupQuantMatrices(int internalCsp)7
{8
for (int size = 0; size < NUM_SIZES; size++)9
{10
11
12
if (m_bEnabled)13
{14
+ if (internalCsp == X265_CSP_I444)15
+ {16
+ for (int i = 0; i < 64; i++)17
+ {18
+ m_scalingListCoef[BLOCK_32x32][1][i] = m_scalingListCoef[BLOCK_16x16][1][i];19
+ m_scalingListCoef[BLOCK_32x32][2][i] = m_scalingListCoef[BLOCK_16x16][2][i];20
+ m_scalingListCoef[BLOCK_32x32][4][i] = m_scalingListCoef[BLOCK_16x16][4][i];21
+ m_scalingListCoef[BLOCK_32x32][5][i] = m_scalingListCoef[BLOCK_16x16][5][i];22
+ }23
+24
+ m_scalingListDC[BLOCK_32x32][1] = m_scalingListDC[BLOCK_16x16][1];25
+ m_scalingListDC[BLOCK_32x32][2] = m_scalingListDC[BLOCK_16x16][2];26
+ m_scalingListDC[BLOCK_32x32][4] = m_scalingListDC[BLOCK_16x16][4];27
+ m_scalingListDC[BLOCK_32x32][5] = m_scalingListDC[BLOCK_16x16][5];28
+ }29
processScalingListEnc(coeff, quantCoeff, s_quantScales[rem] << 4, width, width, ratio, stride, dc);30
processScalingListDec(coeff, dequantCoeff, s_invQuantScales[rem], width, width, ratio, stride, dc);31
}32
x265_2.2.tar.gz/source/common/scalinglist.h -> x265_2.3.tar.gz/source/common/scalinglist.h
Changed
10
1
2
bool init();3
void setDefaultScalingList();4
bool parseScalingList(const char* filename);5
- void setupQuantMatrices();6
+ void setupQuantMatrices(int internalCsp);7
8
/* used during SPS coding */9
int checkPredMode(int sizeId, int listId) const;10
x265_2.2.tar.gz/source/common/threadpool.cpp -> x265_2.3.tar.gz/source/common/threadpool.cpp
Changed
76
1
2
3
#endif4
5
-#if MACOS6
+/* TODO FIX: Macro __MACH__ ideally should be part of MacOS definition, but adding to Cmake7
+ behaving is not as expected, need to fix this. */8
+9
+#if MACOS && __MACH__10
#include <sys/param.h>11
#include <sys/sysctl.h>12
#endif13
14
15
return bondCount;16
}17
-18
-ThreadPool* ThreadPool::allocThreadPools(x265_param* p, int& numPools)19
+ThreadPool* ThreadPool::allocThreadPools(x265_param* p, int& numPools, bool isThreadsReserved)20
{21
enum { MAX_NODE_NUM = 127 };22
int cpusPerNode[MAX_NODE_NUM + 1];23
24
x265_log(p, X265_LOG_DEBUG, "Reducing number of thread pools for frame thread count\n");25
numPools = X265_MAX(p->frameNumThreads / 2, 1);26
}27
-28
+ if (isThreadsReserved)29
+ numPools = 1;30
ThreadPool *pools = new ThreadPool[numPools];31
if (pools)32
{33
- int maxProviders = (p->frameNumThreads + numPools - 1) / numPools + 1; /* +1 is Lookahead, always assigned to threadpool 0 */34
+ int maxProviders = (p->frameNumThreads + numPools - 1) / numPools + !isThreadsReserved; /* +1 is Lookahead, always assigned to threadpool 0 */35
int node = 0;36
for (int i = 0; i < numPools; i++)37
{38
while (!threadsPerPool[node])39
node++;40
int numThreads = X265_MIN(MAX_POOL_THREADS, threadsPerPool[node]);41
+ int origNumThreads = numThreads;42
+ if (p->lookaheadThreads > numThreads / 2)43
+ {44
+ p->lookaheadThreads = numThreads / 2;45
+ x265_log(p, X265_LOG_DEBUG, "Setting lookahead threads to a maximum of half the total number of threads\n");46
+ }47
+ if (isThreadsReserved)48
+ {49
+ numThreads = p->lookaheadThreads;50
+ maxProviders = 1;51
+ }52
+53
+ else54
+ numThreads -= p->lookaheadThreads;55
if (!pools[i].create(numThreads, maxProviders, nodeMaskPerPool[node]))56
{57
X265_FREE(pools);58
59
}60
else61
x265_log(p, X265_LOG_INFO, "Thread pool created using %d threads\n", numThreads);62
- threadsPerPool[node] -= numThreads;63
+ threadsPerPool[node] -= origNumThreads;64
}65
}66
else67
68
return sysconf(_SC_NPROCESSORS_CONF);69
#elif __unix__70
return sysconf(_SC_NPROCESSORS_ONLN);71
-#elif MACOS72
+#elif MACOS && __MACH__73
int nm[2];74
size_t len = 4;75
uint32_t count;76
x265_2.2.tar.gz/source/common/threadpool.h -> x265_2.3.tar.gz/source/common/threadpool.h
Changed
12
1
2
void setThreadNodeAffinity(void *numaMask);3
int tryAcquireSleepingThread(sleepbitmap_t firstTryBitmap, sleepbitmap_t secondTryBitmap);4
int tryBondPeers(int maxPeers, sleepbitmap_t peerBitmap, BondedTaskGroup& master);5
-6
- static ThreadPool* allocThreadPools(x265_param* p, int& numPools);7
-8
+ static ThreadPool* allocThreadPools(x265_param* p, int& numPools, bool isThreadsReserved);9
static int getCpuCount();10
static int getNumaNodeCount();11
};12
x265_2.2.tar.gz/source/encoder/analysis.cpp -> x265_2.3.tar.gz/source/encoder/analysis.cpp
Changed
201
1
2
m_reuseRef = NULL;3
m_bHD = false;4
}5
+6
bool Analysis::create(ThreadLocalData *tld)7
{8
m_tld = tld;9
10
ctu.setQPSubParts((int8_t)qp, 0, 0);11
12
m_rqt[0].cur.load(initialContext);13
+ ctu.m_meanQP = initialContext.m_meanQP;14
m_modeDepth[0].fencYuv.copyFromPicYuv(*m_frame->m_fencPic, ctu.m_cuAddr, 0);15
16
+ if (m_param->bSsimRd)17
+ calculateNormFactor(ctu, qp);18
+19
uint32_t numPartition = ctu.m_numPartitions;20
+ if (m_param->analysisMultiPassRefine && m_param->rc.bStatRead)21
+ {22
+ m_multipassAnalysis = (analysis2PassFrameData*)m_frame->m_analysis2Pass.analysisFramedata;23
+ m_multipassDepth = &m_multipassAnalysis->depth[ctu.m_cuAddr * ctu.m_numPartitions];24
+ if (m_slice->m_sliceType != I_SLICE)25
+ {26
+ int numPredDir = m_slice->isInterP() ? 1 : 2;27
+ for (int dir = 0; dir < numPredDir; dir++)28
+ {29
+ m_multipassMv[dir] = &m_multipassAnalysis->m_mv[dir][ctu.m_cuAddr * ctu.m_numPartitions];30
+ m_multipassMvpIdx[dir] = &m_multipassAnalysis->mvpIdx[dir][ctu.m_cuAddr * ctu.m_numPartitions];31
+ m_multipassRef[dir] = &m_multipassAnalysis->ref[dir][ctu.m_cuAddr * ctu.m_numPartitions];32
+ }33
+ m_multipassModes = &m_multipassAnalysis->modes[ctu.m_cuAddr * ctu.m_numPartitions];34
+ }35
+ }36
+37
if (m_param->analysisMode && m_slice->m_sliceType != I_SLICE)38
{39
int numPredDir = m_slice->isInterP() ? 1 : 2;40
41
compressInterCU_rd5_6(ctu, cuGeom, qp);42
}43
44
- if (m_param->bEnableRdRefine)45
+ if (m_param->bEnableRdRefine || m_param->bOptCUDeltaQP)46
qprdRefine(ctu, cuGeom, qp, qp);47
48
return *m_modeDepth[0].bestMode;49
50
int cuIdx = (cuGeom.childOffset - 1) / 3;51
bestCUCost = origCUCost = cacheCost[cuIdx];52
53
- for (int dir = 2; dir >= -2; dir -= 4)54
+ int direction = m_param->bOptCUDeltaQP ? 1 : 2;55
+56
+ for (int dir = direction; dir >= -direction; dir -= (direction * 2))57
{58
+ if (m_param->bOptCUDeltaQP && ((dir != 1) || ((qp + 3) >= (int32_t)parentCTU.m_meanQP)))59
+ break;60
+61
int threshold = 1;62
int failure = 0;63
cuPrevCost = origCUCost;64
65
int modCUQP = qp + dir;66
while (modCUQP >= m_param->rc.qpMin && modCUQP <= QP_MAX_SPEC)67
{68
+ if (m_param->bOptCUDeltaQP && modCUQP > (int32_t)parentCTU.m_meanQP)69
+ break;70
+71
recodeCU(parentCTU, cuGeom, modCUQP, qp);72
cuCost = md.bestMode->rdCost;73
74
75
76
SplitData Analysis::compressInterCU_rd0_4(const CUData& parentCTU, const CUGeom& cuGeom, int32_t qp)77
{78
+ if (parentCTU.m_vbvAffected && calculateQpforCuSize(parentCTU, cuGeom, 1))79
+ return compressInterCU_rd5_6(parentCTU, cuGeom, qp);80
+81
uint32_t depth = cuGeom.depth;82
uint32_t cuAddr = parentCTU.m_cuAddr;83
ModeDepth& md = m_modeDepth[depth];84
85
}86
}87
}88
+ if (m_param->analysisMultiPassRefine && m_param->rc.bStatRead && m_multipassAnalysis)89
+ {90
+ if (mightNotSplit && depth == m_multipassDepth[cuGeom.absPartIdx])91
+ {92
+ if (m_multipassModes[cuGeom.absPartIdx] == MODE_SKIP)93
+ {94
+ md.pred[PRED_MERGE].cu.initSubCU(parentCTU, cuGeom, qp);95
+ md.pred[PRED_SKIP].cu.initSubCU(parentCTU, cuGeom, qp);96
+ checkMerge2Nx2N_rd0_4(md.pred[PRED_SKIP], md.pred[PRED_MERGE], cuGeom);97
+98
+ skipRecursion = !!m_param->bEnableRecursionSkip && md.bestMode;99
+ if (m_param->rdLevel)100
+ skipModes = m_param->bEnableEarlySkip && md.bestMode;101
+ }102
+ }103
+ }104
105
/* Step 1. Evaluate Merge/Skip candidates for likely early-outs, if skip mode was not set above */106
if (mightNotSplit && depth >= minDepth && !md.bestMode) /* TODO: Re-evaluate if analysis load/save still works */107
108
109
SplitData Analysis::compressInterCU_rd5_6(const CUData& parentCTU, const CUGeom& cuGeom, int32_t qp)110
{111
+ if (parentCTU.m_vbvAffected && !calculateQpforCuSize(parentCTU, cuGeom, 1))112
+ return compressInterCU_rd0_4(parentCTU, cuGeom, qp);113
+114
uint32_t depth = cuGeom.depth;115
ModeDepth& md = m_modeDepth[depth];116
md.bestMode = NULL;117
118
}119
}120
121
+ if (m_param->analysisMultiPassRefine && m_param->rc.bStatRead && m_multipassAnalysis)122
+ {123
+ if (mightNotSplit && depth == m_multipassDepth[cuGeom.absPartIdx])124
+ {125
+ if (m_multipassModes[cuGeom.absPartIdx] == MODE_SKIP)126
+ {127
+ md.pred[PRED_MERGE].cu.initSubCU(parentCTU, cuGeom, qp);128
+ md.pred[PRED_SKIP].cu.initSubCU(parentCTU, cuGeom, qp);129
+ checkMerge2Nx2N_rd0_4(md.pred[PRED_SKIP], md.pred[PRED_MERGE], cuGeom);130
+131
+ skipModes = !!m_param->bEnableEarlySkip && md.bestMode;132
+ refMasks[0] = allSplitRefs;133
+ md.pred[PRED_2Nx2N].cu.initSubCU(parentCTU, cuGeom, qp);134
+ checkInter_rd5_6(md.pred[PRED_2Nx2N], cuGeom, SIZE_2Nx2N, refMasks);135
+ checkBestMode(md.pred[PRED_2Nx2N], cuGeom.depth);136
+137
+ if (m_param->bEnableRecursionSkip && depth && m_modeDepth[depth - 1].bestMode)138
+ skipRecursion = md.bestMode && !md.bestMode->cu.getQtRootCbf(0);139
+ }140
+ }141
+ }142
+143
/* Step 1. Evaluate Merge/Skip candidates for likely early-outs */144
if (mightNotSplit && !md.bestMode)145
{146
147
bestME[i].ref = m_reuseRef[refOffset + index++];148
}149
}150
+151
+ if (m_param->analysisMultiPassRefine && m_param->rc.bStatRead && m_multipassAnalysis)152
+ {153
+ uint32_t numPU = interMode.cu.getNumPartInter(0);154
+ for (uint32_t part = 0; part < numPU; part++)155
+ {156
+ MotionData* bestME = interMode.bestME[part];157
+ for (int32_t i = 0; i < numPredDir; i++)158
+ {159
+ bestME[i].ref = m_multipassRef[i][cuGeom.absPartIdx];160
+ bestME[i].mv = m_multipassMv[i][cuGeom.absPartIdx];161
+ bestME[i].mvpIdx = m_multipassMvpIdx[i][cuGeom.absPartIdx];162
+ }163
+ }164
+ }165
predInterSearch(interMode, cuGeom, m_bChromaSa8d && (m_csp != X265_CSP_I400 && m_frame->m_fencPic->m_picCsp != X265_CSP_I400), refMask);166
167
/* predInterSearch sets interMode.sa8dBits */168
169
bestME[i].ref = m_reuseRef[refOffset + index++];170
}171
}172
+173
+ if (m_param->analysisMultiPassRefine && m_param->rc.bStatRead && m_multipassAnalysis)174
+ {175
+ uint32_t numPU = interMode.cu.getNumPartInter(0);176
+ for (uint32_t part = 0; part < numPU; part++)177
+ {178
+ MotionData* bestME = interMode.bestME[part];179
+ for (int32_t i = 0; i < numPredDir; i++)180
+ {181
+ bestME[i].ref = m_multipassRef[i][cuGeom.absPartIdx];182
+ bestME[i].mv = m_multipassMv[i][cuGeom.absPartIdx];183
+ bestME[i].mvpIdx = m_multipassMvpIdx[i][cuGeom.absPartIdx];184
+ }185
+ }186
+ }187
+188
predInterSearch(interMode, cuGeom, m_csp != X265_CSP_I400 && m_frame->m_fencPic->m_picCsp != X265_CSP_I400, refMask);189
190
/* predInterSearch sets interMode.sa8dBits, but this is ignored */191
192
return false;193
}194
195
-int Analysis::calculateQpforCuSize(const CUData& ctu, const CUGeom& cuGeom, double baseQp)196
+int Analysis::calculateQpforCuSize(const CUData& ctu, const CUGeom& cuGeom, int32_t complexCheck, double baseQp)197
{198
FrameData& curEncData = *m_frame->m_encData;199
double qp = baseQp >= 0 ? baseQp : curEncData.m_cuStat[ctu.m_cuAddr].baseQp;200
201
x265_2.2.tar.gz/source/encoder/analysis.h -> x265_2.3.tar.gz/source/encoder/analysis.h
Changed
27
1
2
uint32_t m_splitRefIdx[4];3
uint64_t* cacheCost;4
5
+6
+ analysis2PassFrameData* m_multipassAnalysis;7
+ uint8_t* m_multipassDepth;8
+ MV* m_multipassMv[2];9
+ int* m_multipassMvpIdx[2];10
+ int32_t* m_multipassRef[2];11
+ uint8_t* m_multipassModes;12
/* refine RD based on QP for rd-levels 5 and 6 */13
void qprdRefine(const CUData& parentCTU, const CUGeom& cuGeom, int32_t qp, int32_t lqp);14
15
16
/* generate residual and recon pixels for an entire CTU recursively (RD0) */17
void encodeResidue(const CUData& parentCTU, const CUGeom& cuGeom);18
19
- int calculateQpforCuSize(const CUData& ctu, const CUGeom& cuGeom, double baseQP = -1);20
+ int calculateQpforCuSize(const CUData& ctu, const CUGeom& cuGeom, int32_t complexCheck = 0, double baseQP = -1);21
22
+ void calculateNormFactor(CUData& ctu, int qp);23
+ void normFactor(const pixel* src, uint32_t blockSize, CUData& ctu, int qp, TextType ttype);24
/* check whether current mode is the new best */25
inline void checkBestMode(Mode& mode, uint32_t depth)26
{27
x265_2.2.tar.gz/source/encoder/api.cpp -> x265_2.3.tar.gz/source/encoder/api.cpp
Changed
30
1
2
}3
else4
{5
+ if (encoder->m_latestParam->scalingLists && encoder->m_latestParam->scalingLists != encoder->m_param->scalingLists)6
+ {7
+ if (encoder->m_param->bRepeatHeaders)8
+ {9
+ if (encoder->m_scalingList.parseScalingList(encoder->m_latestParam->scalingLists))10
+ return -1;11
+ encoder->m_scalingList.setupQuantMatrices(encoder->m_param->internalCsp);12
+ }13
+ else14
+ {15
+ x265_log(encoder->m_param, X265_LOG_ERROR, "Repeat headers is turned OFF, cannot reconfigure scalinglists\n");16
+ return -1;17
+ }18
+ }19
encoder->m_reconfigure = true;20
encoder->printReconfigureParams();21
}22
23
{24
pic_in->analysisData.intraData = NULL;25
pic_in->analysisData.interData = NULL;26
+ pic_in->analysis2Pass.analysisFramedata = NULL;27
}28
29
if (pp_nal && numEncoded > 0)30
x265_2.2.tar.gz/source/encoder/encoder.cpp -> x265_2.3.tar.gz/source/encoder/encoder.cpp
Changed
201
1
2
m_latestParam = NULL;3
m_threadPool = NULL;4
m_analysisFile = NULL;5
+ m_analysisFileIn = NULL;6
+ m_analysisFileOut = NULL;7
m_offsetEmergency = NULL;8
m_iFrameNum = 0;9
m_iPPSQpMinus26 = 0;10
- m_iLastSliceQp = 0;11
m_rpsInSpsCount = 0;12
for (int i = 0; i < X265_MAX_FRAME_THREADS; i++)13
m_frameEncoder[i] = NULL;14
15
MotionEstimate::initScales();16
}17
18
+inline char *strcatFilename(const char *input, const char *suffix)19
+{20
+ char *output = X265_MALLOC(char, strlen(input) + strlen(suffix) + 1);21
+ if (!output)22
+ {23
+ x265_log(NULL, X265_LOG_ERROR, "unable to allocate memory for filename\n");24
+ return NULL;25
+ }26
+ strcpy(output, input);27
+ strcat(output, suffix);28
+ return output;29
+}30
+31
void Encoder::create()32
{33
if (!primitives.pu[0].sad)34
35
else36
p->frameNumThreads = 1;37
}38
-39
m_numPools = 0;40
if (allowPools)41
- m_threadPool = ThreadPool::allocThreadPools(p, m_numPools);42
-43
+ m_threadPool = ThreadPool::allocThreadPools(p, m_numPools, 0);44
if (!m_numPools)45
{46
// issue warnings if any of these features were requested47
48
m_scalingList.setDefaultScalingList();49
else if (m_scalingList.parseScalingList(m_param->scalingLists))50
m_aborted = true;51
-52
- m_lookahead = new Lookahead(m_param, m_threadPool);53
- if (m_numPools)54
+ int pools = m_numPools;55
+ ThreadPool* lookAheadThreadPool = 0;56
+ if (m_param->lookaheadThreads > 0)57
{58
- m_lookahead->m_jpId = m_threadPool[0].m_numProviders++;59
- m_threadPool[0].m_jpTable[m_lookahead->m_jpId] = m_lookahead;60
+ lookAheadThreadPool = ThreadPool::allocThreadPools(p, pools, 1);61
}62
-63
+ else64
+ lookAheadThreadPool = m_threadPool;65
+ m_lookahead = new Lookahead(m_param, lookAheadThreadPool);66
+ if (pools)67
+ {68
+ m_lookahead->m_jpId = lookAheadThreadPool[0].m_numProviders++;69
+ lookAheadThreadPool[0].m_jpTable[m_lookahead->m_jpId] = m_lookahead;70
+ }71
+ if (m_param->lookaheadThreads > 0)72
+ for (int i = 0; i < pools; i++)73
+ lookAheadThreadPool[i].start();74
+ m_lookahead->m_numPools = pools;75
m_dpb = new DPB(m_param);76
m_rateControl = new RateControl(*m_param);77
-78
initVPS(&m_vps);79
initSPS(&m_sps);80
initPPS(&m_pps);81
82
if (!scalingEnabled)83
{84
m_scalingList.setDefaultScalingList();85
- m_scalingList.setupQuantMatrices();86
+ m_scalingList.setupQuantMatrices(m_sps.chromaFormatIdc);87
}88
else89
- m_scalingList.setupQuantMatrices();90
+ m_scalingList.setupQuantMatrices(m_sps.chromaFormatIdc);91
92
for (int q = 0; q < QP_MAX_MAX - QP_MAX_SPEC; q++)93
{94
95
{96
m_scalingList.m_bEnabled = false;97
m_scalingList.m_bDataPresent = false;98
- m_scalingList.setupQuantMatrices();99
+ m_scalingList.setupQuantMatrices(m_sps.chromaFormatIdc);100
}101
}102
else103
- m_scalingList.setupQuantMatrices();104
+ m_scalingList.setupQuantMatrices(m_sps.chromaFormatIdc);105
106
int numRows = (m_param->sourceHeight + g_maxCUSize - 1) / g_maxCUSize;107
int numCols = (m_param->sourceWidth + g_maxCUSize - 1) / g_maxCUSize;108
109
}110
}111
112
+ if (m_param->analysisMultiPassRefine || m_param->analysisMultiPassDistortion)113
+ {114
+ const char* name = m_param->analysisFileName;115
+ if (!name)116
+ name = defaultAnalysisFileName;117
+ if (m_param->rc.bStatWrite)118
+ {119
+ char* temp = strcatFilename(name, ".temp");120
+ if (!temp)121
+ m_aborted = true;122
+ else123
+ {124
+ m_analysisFileOut = fopen(temp, "wb");125
+ X265_FREE(temp);126
+ }127
+ if (!m_analysisFileOut)128
+ {129
+ x265_log(NULL, X265_LOG_ERROR, "Analysis 2 pass: failed to open file %s\n", temp);130
+ m_aborted = true;131
+ }132
+ }133
+ if (m_param->rc.bStatRead)134
+ {135
+ m_analysisFileIn = fopen(name, "rb");136
+ if (!m_analysisFileIn)137
+ {138
+ x265_log(NULL, X265_LOG_ERROR, "Analysis 2 pass: failed to open file %s\n", name);139
+ m_aborted = true;140
+ }141
+ }142
+ }143
+144
m_bZeroLatency = !m_param->bframes && !m_param->lookaheadDepth && m_param->frameNumThreads == 1;145
146
m_aborted |= parseLambdaFile(m_param);147
148
if (m_analysisFile)149
fclose(m_analysisFile);150
151
+ if (m_latestParam != NULL && m_latestParam != m_param)152
+ {153
+ if (m_latestParam->scalingLists != m_param->scalingLists)154
+ free((char*)m_latestParam->scalingLists);155
+156
+ PARAM_NS::x265_param_free(m_latestParam);157
+ }158
+ if (m_analysisFileIn)159
+ fclose(m_analysisFileIn);160
+161
+ if (m_analysisFileOut)162
+ {163
+ int bError = 1;164
+ fclose(m_analysisFileOut);165
+ const char* name = m_param->analysisFileName;166
+ if (!name)167
+ name = defaultAnalysisFileName;168
+ char* temp = strcatFilename(name, ".temp");169
+ if (temp)170
+ {171
+ x265_unlink(name);172
+ bError = x265_rename(temp, name);173
+ }174
+ if (bError)175
+ {176
+ x265_log(m_param, X265_LOG_ERROR, "failed to rename analysis stats file to \"%s\"\n", name);177
+ }178
+ X265_FREE(temp);179
+ }180
if (m_param)181
{182
/* release string arguments that were strdup'd */183
184
185
PARAM_NS::x265_param_free(m_param);186
}187
-188
- PARAM_NS::x265_param_free(m_latestParam);189
}190
191
void Encoder::updateVbvPlan(RateControl* rc)192
193
if (m_dpb->m_freeList.empty())194
{195
inFrame = new Frame;196
+ inFrame->m_encodeStartTime = x265_mdate();197
x265_param* p = m_reconfigure ? m_latestParam : m_param;198
if (inFrame->create(p, pic_in->quantOffsets))199
{200
201
x265_2.2.tar.gz/source/encoder/encoder.h -> x265_2.3.tar.gz/source/encoder/encoder.h
Changed
45
1
2
#include "scalinglist.h"3
#include "x265.h"4
#include "nal.h"5
+#include "framedata.h"6
7
struct x265_encoder {};8
9
10
DPB* m_dpb;11
Frame* m_exportedPic;12
FILE* m_analysisFile;13
+ FILE* m_analysisFileIn;14
+ FILE* m_analysisFileOut;15
x265_param* m_param;16
x265_param* m_latestParam; // Holds latest param during a reconfigure17
RateControl* m_rateControl;18
19
Lock m_sliceQpLock;20
int m_iFrameNum; 21
int m_iPPSQpMinus26;22
- int m_iLastSliceQp;23
int64_t m_iBitsCostSum[QP_MAX_MAX + 1];24
-25
Lock m_sliceRefIdxLock;26
RefIdxLastGOP m_refIdxLastGOP;27
28
29
30
void freeAnalysis(x265_analysis_data* analysis);31
32
+ void allocAnalysis2Pass(x265_analysis_2Pass* analysis, int sliceType);33
+34
+ void freeAnalysis2Pass(x265_analysis_2Pass* analysis, int sliceType);35
+36
void readAnalysisFile(x265_analysis_data* analysis, int poc);37
38
void writeAnalysisFile(x265_analysis_data* pic, FrameData &curEncData);39
-40
+ void readAnalysis2PassFile(x265_analysis_2Pass* analysis2Pass, int poc, int sliceType);41
+ void writeAnalysis2PassFile(x265_analysis_2Pass* analysis2Pass, FrameData &curEncData, int slicetype);42
void finishFrameStats(Frame* pic, FrameEncoder *curEncoder, x265_frame_stats* frameStats, int inPoc);43
44
void calcRefreshInterval(Frame* frameEnc);45
x265_2.2.tar.gz/source/encoder/entropy.cpp -> x265_2.3.tar.gz/source/encoder/entropy.cpp
Changed
9
1
2
markValid();3
m_fracBits = 0;4
m_pad = 0;5
+ m_meanQP = 0;6
X265_CHECK(sizeof(m_contextState) >= sizeof(m_contextState[0]) * MAX_OFF_CTX_MOD, "context state table is too small\n");7
}8
9
x265_2.2.tar.gz/source/encoder/entropy.h -> x265_2.3.tar.gz/source/encoder/entropy.h
Changed
9
1
2
int m_bitsLeft;3
uint64_t m_fracBits;4
EstBitsSbac m_estBitsSbac;5
+ double m_meanQP;6
7
Entropy();8
9
x265_2.2.tar.gz/source/encoder/frameencoder.cpp -> x265_2.3.tar.gz/source/encoder/frameencoder.cpp
Changed
148
1
2
m_top->m_iBitsCostSum[i] += codeLength;3
}4
m_top->m_iFrameNum++;5
- m_top->m_iLastSliceQp = slice->m_sliceQp;6
}7
-8
m_initSliceContext.resetEntropy(*slice);9
10
m_frameFilter.start(m_frame, m_initSliceContext);11
12
m_frame->m_encData->m_frameStats.lumaDistortion += m_rows[i].rowStats.lumaDistortion;13
m_frame->m_encData->m_frameStats.chromaDistortion += m_rows[i].rowStats.chromaDistortion;14
m_frame->m_encData->m_frameStats.psyEnergy += m_rows[i].rowStats.psyEnergy;15
+ m_frame->m_encData->m_frameStats.ssimEnergy += m_rows[i].rowStats.ssimEnergy;16
m_frame->m_encData->m_frameStats.resEnergy += m_rows[i].rowStats.resEnergy;17
for (uint32_t depth = 0; depth <= g_maxCUDepth; depth++)18
{19
20
m_frame->m_encData->m_frameStats.avgLumaDistortion = (double)(m_frame->m_encData->m_frameStats.lumaDistortion) / m_frame->m_encData->m_frameStats.totalCtu;21
m_frame->m_encData->m_frameStats.avgChromaDistortion = (double)(m_frame->m_encData->m_frameStats.chromaDistortion) / m_frame->m_encData->m_frameStats.totalCtu;22
m_frame->m_encData->m_frameStats.avgPsyEnergy = (double)(m_frame->m_encData->m_frameStats.psyEnergy) / m_frame->m_encData->m_frameStats.totalCtu;23
+ m_frame->m_encData->m_frameStats.avgSsimEnergy = (double)(m_frame->m_encData->m_frameStats.ssimEnergy) / m_frame->m_encData->m_frameStats.totalCtu;24
m_frame->m_encData->m_frameStats.avgResEnergy = (double)(m_frame->m_encData->m_frameStats.resEnergy) / m_frame->m_encData->m_frameStats.totalCtu;25
m_frame->m_encData->m_frameStats.percentIntraNxN = (double)(m_frame->m_encData->m_frameStats.cntIntraNxN * 100) / m_frame->m_encData->m_frameStats.totalCu;26
for (uint32_t depth = 0; depth <= g_maxCUDepth; depth++)27
28
}29
m_accessUnitBits = bytes << 3;30
31
- m_endCompressTime = x265_mdate();32
-33
+ int filler = 0;34
/* rateControlEnd may also block for earlier frames to call rateControlUpdateStats */35
- if (m_top->m_rateControl->rateControlEnd(m_frame, m_accessUnitBits, &m_rce) < 0)36
+ if (m_top->m_rateControl->rateControlEnd(m_frame, m_accessUnitBits, &m_rce, &filler) < 0)37
m_top->m_aborted = true;38
39
+ if (filler > 0)40
+ {41
+ filler = (filler - FILLER_OVERHEAD * 8) >> 3;42
+ m_bs.resetBits();43
+ while (filler > 0)44
+ {45
+ m_bs.write(0xff, 8);46
+ filler--;47
+ }48
+ m_bs.writeByteAlignment();49
+ m_nalList.serialize(NAL_UNIT_FILLER_DATA, m_bs);50
+ bytes += m_nalList.m_nal[m_nalList.m_numNal - 1].sizeBytes;51
+ bytes -= 3; //exclude start code prefix52
+ m_accessUnitBits = bytes << 3;53
+ }54
+55
+ m_endCompressTime = x265_mdate();56
+57
/* Decrement referenced frame reference counts, allow them to be recycled */58
for (int l = 0; l < numPredDir; l++)59
{60
61
//m_rows[row - 1].bufferedEntropy.loadContexts(m_initSliceContext);62
}63
64
+ // calculate mean QP for consistent deltaQP signalling calculation65
+ if (m_param->bOptCUDeltaQP)66
+ {67
+ ScopedLock self(curRow.lock);68
+ if (!curRow.avgQPComputed)69
+ {70
+ if (m_param->bEnableWavefront || !row)71
+ {72
+ double meanQPOff = 0;73
+ uint32_t loopIncr, count = 0;74
+ bool isReferenced = IS_REFERENCED(m_frame);75
+ double *qpoffs = (isReferenced && m_param->rc.cuTree) ? m_frame->m_lowres.qpCuTreeOffset : m_frame->m_lowres.qpAqOffset;76
+ if (qpoffs)77
+ {78
+ if (m_param->rc.qgSize == 8)79
+ loopIncr = 8;80
+ else81
+ loopIncr = 16;82
+ uint32_t cuYStart = 0, height = m_frame->m_fencPic->m_picHeight;83
+ if (m_param->bEnableWavefront)84
+ {85
+ cuYStart = intRow * m_param->maxCUSize;86
+ height = cuYStart + m_param->maxCUSize;87
+ }88
+89
+ uint32_t qgSize = m_param->rc.qgSize, width = m_frame->m_fencPic->m_picWidth;90
+ uint32_t maxOffsetCols = (m_frame->m_fencPic->m_picWidth + (loopIncr - 1)) / loopIncr;91
+ for (uint32_t cuY = cuYStart; cuY < height && (cuY < m_frame->m_fencPic->m_picHeight); cuY += qgSize)92
+ {93
+ for (uint32_t cuX = 0; cuX < width; cuX += qgSize)94
+ {95
+ double qp_offset = 0;96
+ uint32_t cnt = 0;97
+98
+ for (uint32_t block_yy = cuY; block_yy < cuY + qgSize && block_yy < m_frame->m_fencPic->m_picHeight; block_yy += loopIncr)99
+ {100
+ for (uint32_t block_xx = cuX; block_xx < cuX + qgSize && block_xx < width; block_xx += loopIncr)101
+ {102
+ int idx = ((block_yy / loopIncr) * (maxOffsetCols)) + (block_xx / loopIncr);103
+ qp_offset += qpoffs[idx];104
+ cnt++;105
+ }106
+ }107
+ qp_offset /= cnt;108
+ meanQPOff += qp_offset;109
+ count++;110
+ }111
+ }112
+ meanQPOff /= count;113
+ }114
+ rowCoder.m_meanQP = slice->m_sliceQp + meanQPOff;115
+ }116
+ else117
+ {118
+ rowCoder.m_meanQP = m_rows[0].rowGoOnCoder.m_meanQP;119
+ }120
+ curRow.avgQPComputed = 1;121
+ }122
+ }123
124
// TODO: specially case handle on first and last row125
126
127
rowCoder.copyState(m_initSliceContext);128
rowCoder.loadContexts(m_rows[row - 1].bufferedEntropy);129
}130
+ analysis2PassFrameData* analysisFrameData = (analysis2PassFrameData*)(m_frame->m_analysis2Pass).analysisFramedata;131
+ if (analysisFrameData && m_param->rc.bStatRead && m_param->analysisMultiPassDistortion && (analysisFrameData->threshold[cuAddr] < 0.9 || analysisFrameData->threshold[cuAddr] > 1.1)132
+ && analysisFrameData->highDistortionCtuCount && analysisFrameData->lowDistortionCtuCount)133
+ curEncData.m_cuStat[cuAddr].baseQp += analysisFrameData->offset[cuAddr];134
+135
+ if (m_param->dynamicRd && (int32_t)(m_rce.qpaRc - m_rce.qpNoVbv) > 0)136
+ ctu->m_vbvAffected = true;137
138
// Does all the CU analysis, returns best top level mode decision139
Mode& best = tld.analysis.compressCTU(*ctu, *m_frame, m_cuGeoms[m_ctuGeomMap[cuAddr]], rowCoder);140
141
curRow.rowStats.lumaDistortion += best.lumaDistortion;142
curRow.rowStats.chromaDistortion += best.chromaDistortion;143
curRow.rowStats.psyEnergy += best.psyEnergy;144
+ curRow.rowStats.ssimEnergy += best.ssimEnergy;145
curRow.rowStats.resEnergy += best.resEnergy;146
curRow.rowStats.cntIntraNxN += frameLog.cntIntraNxN;147
curRow.rowStats.totalCu += frameLog.totalCu;148
x265_2.2.tar.gz/source/encoder/frameencoder.h -> x265_2.3.tar.gz/source/encoder/frameencoder.h
Changed
17
1
2
3
/* count of completed CUs in this row */4
volatile uint32_t completed;5
+ volatile uint32_t avgQPComputed;6
7
/* called at the start of each frame to initialize state */8
void init(Entropy& initContext, unsigned int sid)9
10
active = false;11
busy = false;12
completed = 0;13
+ avgQPComputed = 0;14
sliceId = sid;15
memset(&rowStats, 0, sizeof(rowStats));16
rowGoOnCoder.load(initContext);17
x265_2.2.tar.gz/source/encoder/framefilter.cpp -> x265_2.3.tar.gz/source/encoder/framefilter.cpp
Changed
43
1
2
const uint32_t numCols = m_frame->m_encData->m_slice->m_sps->numCuInWidth;3
const uint32_t lineStartCUAddr = row * numCols;4
5
+ /* Generate integral planes for SEA motion search */6
+ if(m_param->searchMethod == X265_SEA)7
+ computeMEIntegral(row);8
// Notify other FrameEncoders that this row of reconstructed pixels is available9
m_frame->m_reconRowFlag[row].set(1);10
11
12
}13
} // end of (m_param->maxSlices == 1)14
15
- int lastRow = row == (int)m_frame->m_encData->m_slice->m_sps->numCuInHeight - 1;16
+ if (ATOMIC_INC(&m_frameEncoder->m_completionCount) == 2 * (int)m_frameEncoder->m_numRows)17
+ {18
+ m_frameEncoder->m_completionEvent.trigger();19
+ }20
+}21
22
- /* generate integral planes for SEA motion search */23
- if (m_param->searchMethod == X265_SEA && m_frame->m_encData->m_meIntegral && m_frame->m_lowres.sliceType != X265_TYPE_B)24
+void FrameFilter::computeMEIntegral(int row)25
+{26
+ int lastRow = row == (int)m_frame->m_encData->m_slice->m_sps->numCuInHeight - 1;27
+ if (m_frame->m_encData->m_meIntegral && m_frame->m_lowres.sliceType != X265_TYPE_B)28
{29
/* If WPP, other than first row, integral calculation for current row needs to wait till the30
* integral for the previous row is computed */31
32
}33
m_parallelFilter[row].m_frameFilter->integralCompleted.set(1);34
}35
-36
- if (ATOMIC_INC(&m_frameEncoder->m_completionCount) == 2 * (int)m_frameEncoder->m_numRows)37
- {38
- m_frameEncoder->m_completionEvent.trigger();39
- }40
}41
42
static uint64_t computeSSD(pixel *fenc, pixel *rec, intptr_t stride, uint32_t width, uint32_t height)43
x265_2.2.tar.gz/source/encoder/framefilter.h -> x265_2.3.tar.gz/source/encoder/framefilter.h
Changed
9
1
2
3
void processRow(int row);4
void processPostRow(int row);5
+ void computeMEIntegral(int row);6
};7
}8
9
x265_2.2.tar.gz/source/encoder/ratecontrol.cpp -> x265_2.3.tar.gz/source/encoder/ratecontrol.cpp
Changed
127
1
2
m_param->fpsNum, m_param->fpsDenom, k, l);3
return false;4
}5
+ if (m_param->analysisMultiPassRefine)6
+ {7
+ p = strstr(opts, "ref=");8
+ sscanf(p, "ref=%d", &i);9
+ if (i > m_param->maxNumReferences)10
+ {11
+ x265_log(m_param, X265_LOG_ERROR, "maxNumReferences cannot be less than 1st pass (%d vs %d)\n",12
+ i, m_param->maxNumReferences);13
+ return false;14
+ }15
+ }16
+ if (m_param->analysisMultiPassRefine || m_param->analysisMultiPassDistortion)17
+ {18
+ p = strstr(opts, "ctu=");19
+ sscanf(p, "ctu=%u", &k);20
+ if (k != m_param->maxCUSize)21
+ {22
+ x265_log(m_param, X265_LOG_ERROR, "maxCUSize mismatch with 1st pass (%u vs %u)\n",23
+ k, m_param->maxCUSize);24
+ return false;25
+ }26
+ }27
CMP_OPT_FIRST_PASS("bitdepth", m_param->internalBitDepth);28
CMP_OPT_FIRST_PASS("weightp", m_param->bEnableWeightedPred);29
CMP_OPT_FIRST_PASS("bframes", m_param->bframes);30
31
p->offset += new_offset;32
}33
34
-void RateControl::updateVbv(int64_t bits, RateControlEntry* rce)35
+int RateControl::updateVbv(int64_t bits, RateControlEntry* rce)36
{37
int predType = rce->sliceType;38
+ int filler = 0;39
+ double bufferBits;40
predType = rce->sliceType == B_SLICE && rce->keptAsRef ? 3 : predType;41
if (rce->lastSatd >= m_ncu && rce->encodeOrder >= m_lastPredictorReset)42
updatePredictor(&m_pred[predType], x265_qp2qScale(rce->qpaRc), (double)rce->lastSatd, (double)bits);43
if (!m_isVbv)44
- return;45
+ return 0;46
47
m_bufferFillFinal -= bits;48
49
50
51
m_bufferFillFinal = X265_MAX(m_bufferFillFinal, 0);52
m_bufferFillFinal += m_bufferRate;53
- m_bufferFillFinal = X265_MIN(m_bufferFillFinal, m_bufferSize);54
- double bufferBits = X265_MIN(bits + m_bufferExcess, m_bufferRate);55
- m_bufferExcess = X265_MAX(m_bufferExcess - bufferBits + bits, 0);56
- m_bufferFillActual += bufferBits - bits;57
- m_bufferFillActual = X265_MIN(m_bufferFillActual, m_bufferSize);58
+59
+ if (m_bufferFillFinal > m_bufferSize) 60
+ {61
+ if (m_param->rc.bStrictCbr)62
+ {63
+ filler = (int)(m_bufferFillFinal - m_bufferSize);64
+ filler += FILLER_OVERHEAD * 8;65
+ m_bufferFillFinal -= filler;66
+ bufferBits = X265_MIN(bits + filler + m_bufferExcess, m_bufferRate);67
+ m_bufferExcess = X265_MAX(m_bufferExcess - bufferBits + bits + filler, 0);68
+ m_bufferFillActual += bufferBits - bits - filler;69
+ }70
+ else71
+ {72
+ m_bufferFillFinal = X265_MIN(m_bufferFillFinal, m_bufferSize);73
+ bufferBits = X265_MIN(bits + m_bufferExcess, m_bufferRate);74
+ m_bufferExcess = X265_MAX(m_bufferExcess - bufferBits + bits, 0);75
+ m_bufferFillActual += bufferBits - bits;76
+ m_bufferFillActual = X265_MIN(m_bufferFillActual, m_bufferSize);77
+ }78
+ }79
+ return filler;80
}81
82
/* After encoding one frame, update rate control state */83
-int RateControl::rateControlEnd(Frame* curFrame, int64_t bits, RateControlEntry* rce)84
+int RateControl::rateControlEnd(Frame* curFrame, int64_t bits, RateControlEntry* rce, int *filler)85
{86
int orderValue = m_startEndOrder.get();87
int endOrdinal = (rce->encodeOrder + m_param->frameNumThreads) * 2 - 1;88
89
int64_t actualBits = bits;90
Slice *slice = curEncData.m_slice;91
92
- if (m_param->rc.aqMode || m_isVbv)93
+ if (m_param->rc.aqMode || m_isVbv || m_param->bAQMotion)94
{95
if (m_isVbv && !(m_2pass && m_param->rc.rateControlMode == X265_RC_CRF))96
{97
98
rce->qpaRc = curEncData.m_avgQpRc;99
}100
101
- if (m_param->rc.aqMode)102
+ if (m_param->rc.aqMode || m_param->bAQMotion)103
{104
double avgQpAq = 0;105
/* determine actual avg encoded QP, after AQ/cutree adjustments */106
107
108
if (m_isVbv)109
{110
- updateVbv(actualBits, rce);111
+ *filler = updateVbv(actualBits, rce);112
113
if (m_param->bEmitHRDSEI)114
{115
116
117
rce->hrdTiming->cpbInitialAT = hrd->cbrFlag ? m_prevCpbFinalAT : X265_MAX(m_prevCpbFinalAT, cpbEarliestAT);118
}119
-120
+ int filler_bits = *filler ? (*filler - START_CODE_OVERHEAD * 8) : 0; 121
uint32_t cpbsizeUnscale = hrd->cpbSizeValue << (hrd->cpbSizeScale + CPB_SHIFT);122
- rce->hrdTiming->cpbFinalAT = m_prevCpbFinalAT = rce->hrdTiming->cpbInitialAT + actualBits / cpbsizeUnscale;123
+ rce->hrdTiming->cpbFinalAT = m_prevCpbFinalAT = rce->hrdTiming->cpbInitialAT + (actualBits + filler_bits)/ cpbsizeUnscale;124
rce->hrdTiming->dpbOutputTime = (double)rce->picTimingSEI->m_picDpbOutputDelay * time->numUnitsInTick / time->timeScale + rce->hrdTiming->cpbRemovalTime;125
}126
}127
x265_2.2.tar.gz/source/encoder/ratecontrol.h -> x265_2.3.tar.gz/source/encoder/ratecontrol.h
Changed
19
1
2
// to be called for each curFrame to process RateControl and set QP3
int rateControlStart(Frame* curFrame, RateControlEntry* rce, Encoder* enc);4
void rateControlUpdateStats(RateControlEntry* rce);5
- int rateControlEnd(Frame* curFrame, int64_t bits, RateControlEntry* rce);6
+ int rateControlEnd(Frame* curFrame, int64_t bits, RateControlEntry* rce, int *filler);7
int rowVbvRateControl(Frame* curFrame, uint32_t row, RateControlEntry* rce, double& qpVbv);8
int rateControlSliceType(int frameNum);9
bool cuTreeReadFor2Pass(Frame* curFrame);10
11
void accumPQpUpdate();12
13
int getPredictorType(int lowresSliceType, int sliceType);14
- void updateVbv(int64_t bits, RateControlEntry* rce);15
+ int updateVbv(int64_t bits, RateControlEntry* rce);16
void updatePredictor(Predictor *p, double q, double var, double bits);17
double clipQscale(Frame* pic, RateControlEntry* rce, double q);18
void updateVbvPlan(Encoder* enc);19
x265_2.2.tar.gz/source/encoder/rdcost.h -> x265_2.3.tar.gz/source/encoder/rdcost.h
Changed
34
1
2
uint32_t m_chromaDistWeight[2];3
uint32_t m_psyRdBase;4
uint32_t m_psyRd;5
+ uint32_t m_ssimRd;6
int m_qp; /* QP used to configure lambda, may be higher than QP_MAX_SPEC but <= QP_MAX_MAX */7
8
void setPsyRdScale(double scale) { m_psyRdBase = (uint32_t)floor(65536.0 * scale * 0.33); }9
+ void setSsimRd(int ssimRd) { m_ssimRd = ssimRd; };10
11
void setQP(const Slice& slice, int qp)12
{13
14
return distortion + ((m_lambda * m_psyRd * psycost) >> 24) + ((bits * m_lambda2) >> 8);15
}16
17
+ inline uint64_t calcSsimRdCost(uint64_t distortion, uint32_t bits, uint32_t ssimCost) const18
+ {19
+#if X265_DEPTH < 1020
+ X265_CHECK((bits <= (UINT64_MAX / m_lambda2)) && (ssimCost <= UINT64_MAX / m_lambda),21
+ "calcPsyRdCost wrap detected dist: " X265_LL " bits: %u, lambda: " X265_LL ", lambda2: " X265_LL "\n",22
+ distortion, bits, m_lambda, m_lambda2);23
+#else24
+ X265_CHECK((bits <= (UINT64_MAX / m_lambda2)) && (ssimCost <= UINT64_MAX / m_lambda),25
+ "calcPsyRdCost wrap detected dist: " X265_LL ", bits: %u, lambda: " X265_LL ", lambda2: " X265_LL "\n",26
+ distortion, bits, m_lambda, m_lambda2);27
+#endif28
+ return distortion + ((m_lambda * ssimCost) >> 14) + ((bits * m_lambda2) >> 8);29
+ }30
+31
inline uint64_t calcRdSADCost(uint32_t sadCost, uint32_t bits) const32
{33
X265_CHECK(bits <= (UINT64_MAX - 128) / m_lambda,34
x265_2.2.tar.gz/source/encoder/search.cpp -> x265_2.3.tar.gz/source/encoder/search.cpp
Changed
201
1
2
m_numLayers = g_log2Size[param.maxCUSize] - 2;3
4
m_rdCost.setPsyRdScale(param.psyRd);5
+ m_rdCost.setSsimRd(param.bSsimRd);6
m_me.init(param.internalCsp);7
8
bool ok = m_quant.init(param.psyRdoq, scalingList, m_entropyCoder);9
10
fullCost.energy = m_rdCost.psyCost(sizeIdx, fenc, mode.fencYuv->m_size, reconQt, reconQtStride);11
fullCost.rdcost = m_rdCost.calcPsyRdCost(fullCost.distortion, fullCost.bits, fullCost.energy);12
}13
+ else if(m_rdCost.m_ssimRd)14
+ {15
+ fullCost.energy = m_quant.ssimDistortion(cu, fenc, stride, reconQt, reconQtStride, log2TrSize, TEXT_LUMA, absPartIdx);16
+ fullCost.rdcost = m_rdCost.calcSsimRdCost(fullCost.distortion, fullCost.bits, fullCost.energy);17
+ }18
else19
fullCost.rdcost = m_rdCost.calcRdCost(fullCost.distortion, fullCost.bits);20
}21
22
23
if (m_rdCost.m_psyRd)24
splitCost.rdcost = m_rdCost.calcPsyRdCost(splitCost.distortion, splitCost.bits, splitCost.energy);25
+ else if(m_rdCost.m_ssimRd)26
+ splitCost.rdcost = m_rdCost.calcSsimRdCost(splitCost.distortion, splitCost.bits, splitCost.energy);27
else28
splitCost.rdcost = m_rdCost.calcRdCost(splitCost.distortion, splitCost.bits);29
}30
31
tmpEnergy = m_rdCost.psyCost(sizeIdx, fenc, fencYuv->m_size, tmpRecon, tmpReconStride);32
tmpCost = m_rdCost.calcPsyRdCost(tmpDist, tmpBits, tmpEnergy);33
}34
+ else if(m_rdCost.m_ssimRd)35
+ {36
+ tmpEnergy = m_quant.ssimDistortion(cu, fenc, stride, tmpRecon, tmpReconStride, log2TrSize, TEXT_LUMA, absPartIdx);37
+ tmpCost = m_rdCost.calcSsimRdCost(tmpDist, tmpBits, tmpEnergy);38
+ }39
else40
tmpCost = m_rdCost.calcRdCost(tmpDist, tmpBits);41
42
43
44
if (m_rdCost.m_psyRd)45
outCost.energy += m_rdCost.psyCost(sizeIdxC, fenc, stride, reconQt, reconQtStride);46
+ else if(m_rdCost.m_ssimRd)47
+ outCost.energy += m_quant.ssimDistortion(cu, fenc, stride, reconQt, reconQtStride, log2TrSizeC, ttype, absPartIdxC);48
49
primitives.cu[sizeIdxC].copy_pp(picReconC, picStride, reconQt, reconQtStride);50
}51
52
tmpEnergy = m_rdCost.psyCost(sizeIdxC, fenc, stride, reconQt, reconQtStride);53
tmpCost = m_rdCost.calcPsyRdCost(tmpDist, tmpBits, tmpEnergy);54
}55
+ else if(m_rdCost.m_ssimRd)56
+ {57
+ tmpEnergy = m_quant.ssimDistortion(cu, fenc, stride, reconQt, reconQtStride, log2TrSizeC, ttype, absPartIdxC);58
+ tmpCost = m_rdCost.calcSsimRdCost(tmpDist, tmpBits, tmpEnergy);59
+ }60
else61
tmpCost = m_rdCost.calcRdCost(tmpDist, tmpBits);62
63
64
}65
else66
intraMode.distortion += intraMode.lumaDistortion;67
-68
+ cu.m_distortion[0] = intraMode.distortion;69
m_entropyCoder.resetBits();70
if (m_slice->m_pps->bTransquantBypassEnabled)71
m_entropyCoder.codeCUTransquantBypassFlag(cu.m_tqBypass[0]);72
73
m_entropyCoder.store(intraMode.contexts);74
intraMode.totalBits = m_entropyCoder.getNumberOfWrittenBits();75
intraMode.coeffBits = intraMode.totalBits - intraMode.mvBits - skipFlagBits;76
+ const Yuv* fencYuv = intraMode.fencYuv;77
if (m_rdCost.m_psyRd)78
- {79
- const Yuv* fencYuv = intraMode.fencYuv;80
intraMode.psyEnergy = m_rdCost.psyCost(cuGeom.log2CUSize - 2, fencYuv->m_buf[0], fencYuv->m_size, intraMode.reconYuv.m_buf[0], intraMode.reconYuv.m_size);81
- }82
+ else if(m_rdCost.m_ssimRd)83
+ intraMode.ssimEnergy = m_quant.ssimDistortion(cu, fencYuv->m_buf[0], fencYuv->m_size, intraMode.reconYuv.m_buf[0], intraMode.reconYuv.m_size, cuGeom.log2CUSize, TEXT_LUMA, 0);84
+85
intraMode.resEnergy = primitives.cu[cuGeom.log2CUSize - 2].sse_pp(intraMode.fencYuv->m_buf[0], intraMode.fencYuv->m_size, intraMode.predYuv.m_buf[0], intraMode.predYuv.m_size);86
87
updateModeCost(intraMode);88
89
90
intraMode.totalBits = m_entropyCoder.getNumberOfWrittenBits();91
intraMode.coeffBits = intraMode.totalBits - intraMode.mvBits - skipFlagBits;92
+ const Yuv* fencYuv = intraMode.fencYuv;93
if (m_rdCost.m_psyRd)94
- {95
- const Yuv* fencYuv = intraMode.fencYuv;96
intraMode.psyEnergy = m_rdCost.psyCost(cuGeom.log2CUSize - 2, fencYuv->m_buf[0], fencYuv->m_size, reconYuv->m_buf[0], reconYuv->m_size);97
- }98
- intraMode.resEnergy = primitives.cu[cuGeom.log2CUSize - 2].sse_pp(intraMode.fencYuv->m_buf[0], intraMode.fencYuv->m_size, intraMode.predYuv.m_buf[0], intraMode.predYuv.m_size);99
+ else if(m_rdCost.m_ssimRd)100
+ intraMode.ssimEnergy = m_quant.ssimDistortion(cu, fencYuv->m_buf[0], fencYuv->m_size, reconYuv->m_buf[0], reconYuv->m_size, cuGeom.log2CUSize, TEXT_LUMA, 0);101
+102
+ intraMode.resEnergy = primitives.cu[cuGeom.log2CUSize - 2].sse_pp(fencYuv->m_buf[0], fencYuv->m_size, intraMode.predYuv.m_buf[0], intraMode.predYuv.m_size);103
m_entropyCoder.store(intraMode.contexts);104
updateModeCost(intraMode);105
checkDQP(intraMode, cuGeom);106
107
codeCoeffQTChroma(cu, initTuDepth, absPartIdxC, TEXT_CHROMA_U);108
codeCoeffQTChroma(cu, initTuDepth, absPartIdxC, TEXT_CHROMA_V);109
uint32_t bits = m_entropyCoder.getNumberOfWrittenBits();110
- uint64_t cost = m_rdCost.m_psyRd ? m_rdCost.calcPsyRdCost(outCost.distortion, bits, outCost.energy)111
+ uint64_t cost = m_rdCost.m_psyRd ? m_rdCost.calcPsyRdCost(outCost.distortion, bits, outCost.energy) : m_rdCost.m_ssimRd ? m_rdCost.calcSsimRdCost(outCost.distortion, bits, outCost.energy)112
: m_rdCost.calcRdCost(outCost.distortion, bits);113
114
if (cost < bestCost)115
116
cu.getNeighbourMV(puIdx, pu.puAbsPartIdx, interMode.interNeighbours);117
118
/* Uni-directional prediction */119
- if (m_param->analysisMode == X265_ANALYSIS_LOAD)120
+ if (m_param->analysisMode == X265_ANALYSIS_LOAD || (m_param->analysisMultiPassRefine && m_param->rc.bStatRead))121
{122
for (int list = 0; list < numPredDir; list++)123
{124
125
m_me.integral[planes] = interMode.fencYuv->m_integral[list][ref][planes] + puX * pu.width + puY * pu.height * m_slice->m_refFrameList[list][ref]->m_reconPic->m_stride;126
}127
setSearchRange(cu, mvp, m_param->searchRange, mvmin, mvmax);128
- int satdCost = m_me.motionEstimate(&slice->m_mref[list][ref], mvmin, mvmax, mvp, numMvc, mvc, m_param->searchRange, outmv,129
+ MV mvpIn = mvp;130
+ if (m_param->analysisMultiPassRefine && m_param->rc.bStatRead && mvpIdx == bestME[list].mvpIdx)131
+ mvpIn = bestME[list].mv;132
+ 133
+ int satdCost = m_me.motionEstimate(&slice->m_mref[list][ref], mvmin, mvmax, mvpIn, numMvc, mvc, m_param->searchRange, outmv,134
m_param->bSourceReferenceEstimation ? m_slice->m_refFrameList[list][ref]->m_fencPic->getLumaAddr(0) : 0);135
136
/* Get total cost of partition, but only include MV bit cost once */137
138
uint32_t cost = (satdCost - mvCost) + m_rdCost.getCost(bits);139
140
/* Refine MVP selection, updates: mvpIdx, bits, cost */141
- mvp = checkBestMVP(amvp, outmv, mvpIdx, bits, cost);142
+ if (!m_param->analysisMultiPassRefine)143
+ mvp = checkBestMVP(amvp, outmv, mvpIdx, bits, cost);144
+ else145
+ {146
+ /* It is more accurate to compare with actual mvp that was used in motionestimate than amvp[mvpIdx]. Here 147
+ the actual mvp is bestME from pass 1 for that mvpIdx */148
+ int diffBits = m_me.bitcost(outmv, amvp[!mvpIdx]) - m_me.bitcost(outmv, mvpIn);149
+ if (diffBits < 0)150
+ {151
+ mvpIdx = !mvpIdx;152
+ uint32_t origOutBits = bits;153
+ bits = origOutBits + diffBits;154
+ cost = (cost - m_rdCost.getCost(origOutBits)) + m_rdCost.getCost(bits);155
+ }156
+ mvp = amvp[mvpIdx];157
+ }158
159
if (cost < bestME[list].cost)160
{161
162
interMode.chromaDistortion += m_rdCost.scaleChromaDist(2, primitives.chroma[m_csp].cu[part].sse_pp(fencYuv->m_buf[2], fencYuv->m_csize, reconYuv->m_buf[2], reconYuv->m_csize));163
interMode.distortion += interMode.chromaDistortion;164
}165
+ cu.m_distortion[0] = interMode.distortion;166
m_entropyCoder.load(m_rqt[depth].cur);167
m_entropyCoder.resetBits();168
if (m_slice->m_pps->bTransquantBypassEnabled)169
170
interMode.totalBits = interMode.mvBits + skipFlagBits;171
if (m_rdCost.m_psyRd)172
interMode.psyEnergy = m_rdCost.psyCost(part, fencYuv->m_buf[0], fencYuv->m_size, reconYuv->m_buf[0], reconYuv->m_size);173
+ else if(m_rdCost.m_ssimRd)174
+ interMode.ssimEnergy = m_quant.ssimDistortion(cu, fencYuv->m_buf[0], fencYuv->m_size, reconYuv->m_buf[0], reconYuv->m_size, cu.m_log2CUSize[0], TEXT_LUMA, 0);175
+176
interMode.resEnergy = primitives.cu[part].sse_pp(fencYuv->m_buf[0], fencYuv->m_size, predYuv->m_buf[0], predYuv->m_size);177
updateModeCost(interMode);178
m_entropyCoder.store(interMode.contexts);179
180
m_entropyCoder.codeQtRootCbfZero();181
uint32_t cbf0Bits = m_entropyCoder.getNumberOfWrittenBits();182
183
- uint64_t cbf0Cost;184
- uint32_t cbf0Energy;185
+ uint32_t cbf0Energy; uint64_t cbf0Cost;186
if (m_rdCost.m_psyRd)187
{188
cbf0Energy = m_rdCost.psyCost(log2CUSize - 2, fencYuv->m_buf[0], fencYuv->m_size, predYuv->m_buf[0], predYuv->m_size);189
cbf0Cost = m_rdCost.calcPsyRdCost(cbf0Dist, cbf0Bits, cbf0Energy);190
}191
+ else if(m_rdCost.m_ssimRd)192
+ {193
+ cbf0Energy = m_quant.ssimDistortion(cu, fencYuv->m_buf[0], fencYuv->m_size, predYuv->m_buf[0], predYuv->m_size, log2CUSize, TEXT_LUMA, 0);194
+ cbf0Cost = m_rdCost.calcSsimRdCost(cbf0Dist, cbf0Bits, cbf0Energy);195
+ }196
else197
cbf0Cost = m_rdCost.calcRdCost(cbf0Dist, cbf0Bits);198
199
200
}201
x265_2.2.tar.gz/source/encoder/search.h -> x265_2.3.tar.gz/source/encoder/search.h
Changed
45
1
2
uint64_t sa8dCost; // sum of partition sa8d distortion costs (sa8d(fenc, pred) + lambda * bits)3
uint32_t sa8dBits; // signal bits used in sa8dCost calculation4
uint32_t psyEnergy; // sum of partition psycho-visual energy difference5
+ uint32_t ssimEnergy;6
sse_t resEnergy; // sum of partition residual energy after motion prediction7
sse_t lumaDistortion;8
sse_t chromaDistortion;9
10
sa8dCost = 0;11
sa8dBits = 0;12
psyEnergy = 0;13
+ ssimEnergy = 0;14
resEnergy = 0;15
lumaDistortion = 0;16
chromaDistortion = 0;17
18
sa8dCost += subMode.sa8dCost;19
sa8dBits += subMode.sa8dBits;20
psyEnergy += subMode.psyEnergy;21
+ ssimEnergy += subMode.ssimEnergy;22
resEnergy += subMode.resEnergy;23
lumaDistortion += subMode.lumaDistortion;24
chromaDistortion += subMode.chromaDistortion;25
26
Entropy rqtStore[NUM_SUBPART];27
} m_cacheTU;28
29
- uint64_t estimateNullCbfCost(sse_t dist, uint32_t psyEnergy, uint32_t tuDepth, TextType compId);30
+ uint64_t estimateNullCbfCost(sse_t dist, uint32_t energy, uint32_t tuDepth, TextType compId);31
bool splitTU(Mode& mode, const CUGeom& cuGeom, uint32_t absPartIdx, uint32_t tuDepth, ShortYuv& resiYuv, Cost& splitCost, const uint32_t depthRange[2], int32_t splitMore);32
void estimateResidualQT(Mode& mode, const CUGeom& cuGeom, uint32_t absPartIdx, uint32_t depth, ShortYuv& resiYuv, Cost& costs, const uint32_t depthRange[2], int32_t splitMore = -1);33
34
35
// get most probable luma modes for CU part, and bit cost of all non mpm modes36
uint32_t getIntraRemModeBits(CUData & cu, uint32_t absPartIdx, uint32_t mpmModes[3], uint64_t& mpms) const;37
38
- void updateModeCost(Mode& m) const { m.rdCost = m_rdCost.m_psyRd ? m_rdCost.calcPsyRdCost(m.distortion, m.totalBits, m.psyEnergy) : m_rdCost.calcRdCost(m.distortion, m.totalBits); }39
+ void updateModeCost(Mode& m) const { m.rdCost = m_rdCost.m_psyRd ? m_rdCost.calcPsyRdCost(m.distortion, m.totalBits, m.psyEnergy)40
+ : (m_rdCost.m_ssimRd ? m_rdCost.calcSsimRdCost(m.distortion, m.totalBits, m.ssimEnergy) 41
+ : m_rdCost.calcRdCost(m.distortion, m.totalBits)); }42
};43
}44
45
x265_2.2.tar.gz/source/encoder/slicetype.cpp -> x265_2.3.tar.gz/source/encoder/slicetype.cpp
Changed
153
1
2
m_lastKeyframe = -m_param->keyframeMax;3
m_sliceTypeBusy = false;4
m_fullQueueSize = X265_MAX(1, m_param->lookaheadDepth);5
- m_bAdaptiveQuant = m_param->rc.aqMode || m_param->bEnableWeightedPred || m_param->bEnableWeightedBiPred;6
+ m_bAdaptiveQuant = m_param->rc.aqMode || m_param->bEnableWeightedPred || m_param->bEnableWeightedBiPred || m_param->bAQMotion;7
8
/* If we have a thread pool and are using --b-adapt 2, it is generally9
* preferable to perform all motion searches for each lowres frame in large10
11
if (wait)12
m_outputSignal.wait();13
}14
+ if (m_pool && m_param->lookaheadThreads > 0)15
+ {16
+ for (int i = 0; i < m_numPools; i++)17
+ m_pool[i].stopWorkers();18
+ }19
}20
-21
void Lookahead::destroy()22
{23
// these two queues will be empty unless the encode was aborted24
25
}26
27
X265_FREE(m_scratch);28
-29
delete [] m_tld;30
+ if (m_param->lookaheadThreads > 0)31
+ delete [] m_pool;32
}33
-34
/* The synchronization of slicetypeDecide is managed here. The findJob() method35
* polls the occupancy of the input queue. If the queue is36
* full, it will run slicetypeDecide() and output a mini-gop of frames to the37
38
uint32_t widthInLowresCu = (uint32_t)m_8x8Width, heightInLowresCu = (uint32_t)m_8x8Height;39
double *qp_offset = 0;40
/* Factor in qpoffsets based on Aq/Cutree in CU costs */41
- if (m_param->rc.aqMode)42
+ if (m_param->rc.aqMode || m_param->bAQMotion)43
qp_offset = (frames[b]->sliceType == X265_TYPE_B || !m_param->rc.cuTree) ? frames[b]->qpAqOffset : frames[b]->qpCuTreeOffset;44
45
for (uint32_t row = 0; row < numCuInHeight; row++)46
47
CostEstimateGroup estGroup(*this, frames);48
int64_t cost = estGroup.singleCost(p0, p1, b);49
50
- if (m_param->rc.aqMode)51
+ if (m_param->rc.aqMode || m_param->bAQMotion)52
{53
if (m_param->rc.cuTree)54
return frameCostRecalculate(frames, p0, p1, b);55
56
57
resetStart = bKeyframe ? 1 : 2;58
}59
+ if (m_param->bAQMotion)60
+ aqMotion(frames, bKeyframe);61
62
if (m_param->rc.cuTree)63
cuTree(frames, X265_MIN(numFrames, m_param->keyframeMax), bKeyframe);64
65
66
return cost;67
}68
+void Lookahead::aqMotion(Lowres **frames, bool bIntra)69
+{70
+ if (!bIntra)71
+ {72
+ int curnonb = 0, lastnonb = 1;73
+ int bframes = 0, i = 1;74
+ while (frames[lastnonb]->sliceType != X265_TYPE_P)75
+ lastnonb++;76
+ bframes = lastnonb - 1;77
+ if (m_param->bBPyramid && bframes > 1)78
+ {79
+ int middle = (bframes + 1) / 2;80
+ for (i = 1; i < lastnonb; i++)81
+ {82
+ int p0 = i > middle ? middle : curnonb;83
+ int p1 = i < middle ? middle : lastnonb;84
+ if (i != middle)85
+ calcMotionAdaptiveQuantFrame(frames, p0, p1, i);86
+ }87
+ calcMotionAdaptiveQuantFrame(frames, curnonb, lastnonb, middle);88
+ }89
+ else90
+ for (i = 1; i < lastnonb; i++)91
+ calcMotionAdaptiveQuantFrame(frames, curnonb, lastnonb, i);92
+ calcMotionAdaptiveQuantFrame(frames, curnonb, lastnonb, lastnonb);93
+ }94
+}95
+96
+void Lookahead::calcMotionAdaptiveQuantFrame(Lowres **frames, int p0, int p1, int b)97
+{98
+ int listDist[2] = { b - p0 - 1, p1 - b - 1 };99
+ int32_t strideInCU = m_8x8Width;100
+ double qp_adj = 0, avg_adj = 0, avg_adj_pow2 = 0, sd;101
+ for (uint16_t blocky = 0; blocky < m_8x8Height; blocky++)102
+ {103
+ int cuIndex = blocky * strideInCU;104
+ for (uint16_t blockx = 0; blockx < m_8x8Width; blockx++, cuIndex++)105
+ {106
+ int32_t lists_used = frames[b]->lowresCosts[b - p0][p1 - b][cuIndex] >> LOWRES_COST_SHIFT;107
+ double displacement = 0;108
+ for (uint16_t list = 0; list < 2; list++)109
+ {110
+ if ((lists_used >> list) & 1)111
+ {112
+ MV *mvs = frames[b]->lowresMvs[list][listDist[list]];113
+ int32_t x = mvs[cuIndex].x;114
+ int32_t y = mvs[cuIndex].y;115
+ displacement += sqrt(pow(abs(x), 2) + pow(abs(y), 2));116
+ }117
+ else118
+ displacement += 0.0;119
+ }120
+ if (lists_used == 3)121
+ displacement = displacement / 2;122
+ qp_adj = pow(displacement, 0.1);123
+ frames[b]->qpAqMotionOffset[cuIndex] = qp_adj;124
+ avg_adj += qp_adj;125
+ avg_adj_pow2 += qp_adj * qp_adj;126
+ }127
+ }128
+ avg_adj /= m_cuCount;129
+ avg_adj_pow2 /= m_cuCount;130
+ sd = sqrt((avg_adj_pow2 - (avg_adj * avg_adj)));131
+ if (sd > 0)132
+ {133
+ for (uint16_t blocky = 0; blocky < m_8x8Height; blocky++)134
+ {135
+ int cuIndex = blocky * strideInCU;136
+ for (uint16_t blockx = 0; blockx < m_8x8Width; blockx++, cuIndex++)137
+ {138
+ qp_adj = frames[b]->qpAqMotionOffset[cuIndex];139
+ qp_adj = (qp_adj - avg_adj) / sd;140
+ if (qp_adj > 1)141
+ {142
+ frames[b]->qpAqOffset[cuIndex] += qp_adj;143
+ frames[b]->qpCuTreeOffset[cuIndex] += qp_adj;144
+ frames[b]->invQscaleFactor[cuIndex] += x265_exp2fix8(qp_adj);145
+ }146
+ }147
+ }148
+ }149
+}150
151
void Lookahead::cuTree(Lowres **frames, int numframes, bool bIntra)152
{153
x265_2.2.tar.gz/source/encoder/slicetype.h -> x265_2.3.tar.gz/source/encoder/slicetype.h
Changed
21
1
2
bool m_bBatchFrameCosts;3
bool m_filled;4
bool m_isSceneTransition;5
+ int m_numPools;6
Lookahead(x265_param *param, ThreadPool *pool);7
-8
#if DETAILED_CU_STATS9
int64_t m_slicetypeDecideElapsedTime;10
int64_t m_preLookaheadElapsedTime;11
12
int64_t slicetypePathCost(Lowres **frames, char *path, int64_t threshold);13
int64_t vbvFrameCost(Lowres **frames, int p0, int p1, int b);14
void vbvLookahead(Lowres **frames, int numFrames, int keyframes);15
-16
+ void aqMotion(Lowres **frames, bool bintra);17
+ void calcMotionAdaptiveQuantFrame(Lowres **frames, int p0, int p1, int b);18
/* called by slicetypeAnalyse() to effect cuTree adjustments to adaptive19
* quant offsets */20
void cuTree(Lowres **frames, int numframes, bool bintra);21
x265_2.2.tar.gz/source/test/rate-control-tests.txt -> x265_2.3.tar.gz/source/test/rate-control-tests.txt
Changed
18
1
2
BasketballDrive_1920x1080_50.y4m,--preset ultrafast --bitrate 3000 --vbv-bufsize 3000 --vbv-maxrate 3000 --no-wpp3
big_buck_bunny_360p24.y4m,--preset medium --bitrate 400 --vbv-bufsize 600 --vbv-maxrate 600 --no-wpp --aud --hrd --tune fast-decode4
sita_1920x1080_30.yuv,--preset superfast --bitrate 3000 --vbv-bufsize 3000 --vbv-maxrate 3000 --aud --strict-cbr --no-wpp5
+sintel_trailer_2k_480p24.y4m, --preset slow --crf 24 --vbv-bufsize 150 --vbv-maxrate 150 --dynamic-rd 1.536
7
8
9
10
RaceHorses_416x240_30_10bit.yuv,--preset medium --crf 26 --vbv-maxrate 1000 --vbv-bufsize 1000 --pass 1,--preset fast --bitrate 1000 --vbv-maxrate 1000 --vbv-bufsize 700 --pass 3 -F4,--preset slow --bitrate 500 --vbv-maxrate 500 --vbv-bufsize 700 --pass 2 -F411
sita_1920x1080_30.yuv, --preset ultrafast --crf 20 --no-cutree --keyint 50 --min-keyint 50 --no-open-gop --pass 1 --vbv-bufsize 7000 --vbv-maxrate 5000, --preset ultrafast --crf 20 --no-cutree --keyint 50 --min-keyint 50 --no-open-gop --pass 2 --vbv-bufsize 7000 --vbv-maxrate 5000 --repeat-headers12
sita_1920x1080_30.yuv, --preset medium --crf 20 --no-cutree --keyint 50 --min-keyint 50 --no-open-gop --pass 1 --vbv-bufsize 7000 --vbv-maxrate 5000 --repeat-headers --multi-pass-opt-rps, --preset medium --crf 20 --no-cutree --keyint 50 --min-keyint 50 --no-open-gop --pass 2 --vbv-bufsize 7000 --vbv-maxrate 5000 --repeat-headers --multi-pass-opt-rps13
+14
+# multi-pass rate control and analysis15
+ducks_take_off_1080p50.y4m,--bitrate 6000 --pass 1 --multi-pass-opt-analysis --hash 1 --ssim --psnr, --bitrate 6000 --pass 2 --multi-pass-opt-analysis --hash 1 --ssim --psnr16
+big_buck_bunny_360p24.y4m,--preset veryslow --bitrate 600 --pass 1 --multi-pass-opt-analysis --multi-pass-opt-distortion --hash 1 --ssim --psnr, --preset veryslow --bitrate 600 --pass 2 --multi-pass-opt-analysis --multi-pass-opt-distortion --hash 1 --ssim --psnr17
+parkrun_ter_720p50.y4m, --bitrate 3500 --pass 1 --multi-pass-opt-distortion --hash 1 --ssim --psnr, --bitrate 3500 --pass 3 --multi-pass-opt-distortion --hash 1 --ssim --psnr, --bitrate 3500 --pass 2 --multi-pass-opt-distortion --hash 1 --ssim --psnr18
x265_2.2.tar.gz/source/test/regression-tests.txt -> x265_2.3.tar.gz/source/test/regression-tests.txt
Changed
35
1
2
CrowdRun_1920x1080_50_10bit_444.yuv,--preset veryfast --temporal-layers --repeat-headers --limit-refs 23
CrowdRun_1920x1080_50_10bit_444.yuv,--preset medium --dither --keyint -1 --rdoq-level 1 --limit-modes4
CrowdRun_1920x1080_50_10bit_444.yuv,--preset veryslow --tskip --tskip-fast --no-scenecut --limit-tu 15
+CrowdRun_1920x1080_50_10bit_444.yuv,--preset veryslow --aq-mode 3 --aq-strength 1.5 --aq-motion --bitrate 50006
+CrowdRun_1920x1080_50_10bit_444.yuv,--preset veryslow --aq-mode 3 --aq-strength 1.5 --no-psy-rd --ssim-rd7
DucksAndLegs_1920x1080_60_10bit_422.yuv,--preset superfast --weightp --qg-size 168
DucksAndLegs_1920x1080_60_10bit_422.yuv,--preset medium --tune psnr --bframes 16 --limit-modes9
DucksAndLegs_1920x1080_60_10bit_422.yuv,--preset slow --temporal-layers --no-psy-rd --qg-size 32 --limit-refs 0 --cu-lossless10
11
News-4k.y4m,--preset superfast --lookahead-slices 6 --aq-mode 012
News-4k.y4m,--preset superfast --slices 4 --aq-mode 0 13
News-4k.y4m,--preset medium --tune ssim --no-sao --qg-size 1614
+News-4k.y4m,--preset slower --opt-cu-delta-qp15
News-4k.y4m,--preset veryslow --no-rskip16
News-4k.y4m,--preset veryslow --pme --crf 4017
OldTownCross_1920x1080_50_10bit_422.yuv,--preset superfast --weightp18
19
city_4cif_60fps.y4m,--preset superfast --rdpenalty 1 --tu-intra-depth 220
city_4cif_60fps.y4m,--preset medium --crf 4 --cu-lossless --sao-non-deblock21
city_4cif_60fps.y4m,--preset slower --scaling-list default22
+city_4cif_60fps.y4m,--preset veryslow --opt-cu-delta-qp23
city_4cif_60fps.y4m,--preset veryslow --rdpenalty 2 --sao-non-deblock --no-b-intra --limit-refs 024
ducks_take_off_420_720p50.y4m,--preset ultrafast --constrained-intra --rd 125
ducks_take_off_444_720p50.y4m,--preset superfast --weightp --limit-refs 226
27
CrowdRun_1920x1080_50_10bit_422.yuv,--preset fast --interlace bff28
29
#SEA Implementation Test30
-silent_cif_420.y4m,--preset veryslow --me 431
-big_buck_bunny_360p24.y4m,--preset superfast --me 432
+silent_cif_420.y4m,--preset veryslow --me sea33
+big_buck_bunny_360p24.y4m,--preset superfast --me sea34
# vim: tw=20035
x265_2.2.tar.gz/source/test/smoke-tests.txt -> x265_2.3.tar.gz/source/test/smoke-tests.txt
Changed
10
1
2
old_town_cross_444_720p50.y4m,--preset=fast --keyint 20 --min-cu-size 163
old_town_cross_444_720p50.y4m,--preset=slow --sao-non-deblock --pmode --qg-size 324
RaceHorses_416x240_30_10bit.yuv,--preset=veryfast --max-tu-size 85
-RaceHorses_416x240_30_10bit.yuv,--preset=slower --bitrate 500 -F4 --rdoq-level 16
+RaceHorses_416x240_30_10bit.yuv,--preset=slower --bitrate 500 -F4 --rdoq-level 1 --opt-cu-delta-qp7
CrowdRun_1920x1080_50_10bit_444.yuv,--preset=ultrafast --constrained-intra --min-keyint 5 --keyint 108
CrowdRun_1920x1080_50_10bit_444.yuv,--preset=medium --max-tu-size 16 --tu-inter-depth 2 --limit-tu 39
DucksAndLegs_1920x1080_60_10bit_422.yuv,--preset=veryfast --min-cu 1610
x265_2.2.tar.gz/source/x265-extras.cpp -> x265_2.3.tar.gz/source/x265-extras.cpp
Changed
19
1
2
3
/* detailed performance statistics */4
if (level >= 2)5
- fprintf(csvfp, ", DecideWait (ms), Row0Wait (ms), Wall time (ms), Ref Wait Wall (ms), Total CTU time (ms), Stall Time (ms), Avg WPP, Row Blocks");6
+ fprintf(csvfp, ", DecideWait (ms), Row0Wait (ms), Wall time (ms), Ref Wait Wall (ms), Total CTU time (ms), Stall Time (ms), Total frame time (ms), Avg WPP, Row Blocks");7
fprintf(csvfp, "\n");8
}9
else10
11
12
if (level >= 2)13
{14
- fprintf(csvfp, ", %.1lf, %.1lf, %.1lf, %.1lf, %.1lf, %.1lf,", frameStats->decideWaitTime, frameStats->row0WaitTime, frameStats->wallTime, frameStats->refWaitWallTime, frameStats->totalCTUTime, frameStats->stallTime);15
+ fprintf(csvfp, ", %.1lf, %.1lf, %.1lf, %.1lf, %.1lf, %.1lf, %.1lf,", frameStats->decideWaitTime, frameStats->row0WaitTime, frameStats->wallTime, frameStats->refWaitWallTime, frameStats->totalCTUTime, frameStats->stallTime, frameStats->totalFrameTime);16
fprintf(csvfp, " %.3lf, %d", frameStats->avgWPP, frameStats->countRowBlocks);17
}18
fprintf(csvfp, "\n");19
x265_2.2.tar.gz/source/x265.h -> x265_2.3.tar.gz/source/x265.h
Changed
80
1
2
/* All the above values will add up to 100%. */3
} x265_cu_stats;4
5
+6
+typedef struct x265_analysis_2Pass7
+{8
+ uint32_t poc;9
+ uint32_t frameRecordSize;10
+ void* analysisFramedata;11
+}x265_analysis_2Pass;12
+13
/* Frame level statistics */14
typedef struct x265_frame_stats15
{16
17
int bScenecut;18
int frameLatency;19
x265_cu_stats cuStats;20
+ double totalFrameTime;21
} x265_frame_stats;22
23
/* Arbitrary User SEI24
25
uint64_t framesize;26
27
int height;28
+29
+ x265_analysis_2Pass analysis2Pass;30
} x265_picture;31
32
typedef enum33
34
#define X265_AQ_AUTO_VARIANCE 235
#define X265_AQ_AUTO_VARIANCE_BIASED 336
37
+#define x265_ADAPT_RD_STRENGTH 438
+39
/* NOTE! For this release only X265_CSP_I420 and X265_CSP_I444 are supported */40
41
/* Supported internal color space types (according to semantics of chroma_format_idc) */42
43
* intra cost of a frame used in scenecut detection. Default 5. */44
double scenecutBias;45
46
+ /* Use multiple worker threads dedicated to doing only lookahead instead of sharing47
+ * the worker threads with Frame Encoders. A dedicated lookahead threadpool is created with the48
+ * specified number of worker threads. This can range from 0 upto half the49
+ * hardware threads available for encoding. Using too many threads for lookahead can starve50
+ * resources for frame Encoder and can harm performance. Default is 0 - disabled. */51
+ int lookaheadThreads;52
+53
+ /* Optimize CU level QPs to signal consistent deltaQPs in frame for rd level > 4 */54
+ int bOptCUDeltaQP;55
+56
+ /* Refine analysis in multipass ratecontrol based on analysis information stored */57
+ int analysisMultiPassRefine;58
+59
+ /* Refine analysis in multipass ratecontrol based on distortion data stored */60
+ int analysisMultiPassDistortion;61
+62
+ /* Adaptive Quantization based on relative motion */63
+ int bAQMotion;64
+65
+ /* SSIM based RDO, based on residual divisive normalization scheme. Used for mode66
+ * selection during analysis of CTUs, can achieve significant gain in terms of 67
+ * objective quality metrics SSIM and PSNR */68
+ int bSsimRd;69
+70
+ /* Increase RD at points where bitrate drops due to vbv. Default 0 */71
+ double dynamicRd;72
+73
+ /* Enables the emitting of HDR SEI packets which contains HDR-specific params.74
+ * Auto-enabled when max-cll, max-fall, or mastering display info is specified.75
+ * Default is disabled */76
+ int bEmitHDRSEI;77
} x265_param;78
79
/* x265_param_alloc:80
x265_2.2.tar.gz/source/x265cli.h -> x265_2.3.tar.gz/source/x265cli.h
Changed
100
1
2
{ "intra-refresh", no_argument, NULL, 0 },3
{ "rc-lookahead", required_argument, NULL, 0 },4
{ "lookahead-slices", required_argument, NULL, 0 },5
+ { "lookahead-threads", required_argument, NULL, 0 },6
{ "bframes", required_argument, NULL, 'b' },7
{ "bframe-bias", required_argument, NULL, 0 },8
{ "b-adapt", required_argument, NULL, 0 },9
10
{ "rd", required_argument, NULL, 0 },11
{ "rdoq-level", required_argument, NULL, 0 },12
{ "no-rdoq-level", no_argument, NULL, 0 },13
+ { "dynamic-rd", required_argument, NULL, 0 },14
{ "psy-rd", required_argument, NULL, 0 },15
{ "psy-rdoq", required_argument, NULL, 0 },16
{ "no-psy-rd", no_argument, NULL, 0 },17
18
{ "no-opt-qp-pps", no_argument, NULL, 0 },19
{ "opt-ref-list-length-pps", no_argument, NULL, 0 },20
{ "no-opt-ref-list-length-pps", no_argument, NULL, 0 },21
+ { "opt-cu-delta-qp", no_argument, NULL, 0 },22
+ { "no-opt-cu-delta-qp", no_argument, NULL, 0 },23
{ "no-dither", no_argument, NULL, 0 },24
{ "dither", no_argument, NULL, 0 },25
{ "no-repeat-headers", no_argument, NULL, 0 },26
27
{ "nr-inter", required_argument, NULL, 0 },28
{ "stats", required_argument, NULL, 0 },29
{ "pass", required_argument, NULL, 0 },30
+ { "multi-pass-opt-analysis", no_argument, NULL, 0 },31
+ { "no-multi-pass-opt-analysis", no_argument, NULL, 0 },32
+ { "multi-pass-opt-distortion", no_argument, NULL, 0 },33
+ { "no-multi-pass-opt-distortion", no_argument, NULL, 0 },34
{ "slow-firstpass", no_argument, NULL, 0 },35
{ "no-slow-firstpass", no_argument, NULL, 0 },36
{ "multi-pass-opt-rps", no_argument, NULL, 0 },37
38
{ "analyze-src-pics", no_argument, NULL, 0 },39
{ "no-analyze-src-pics", no_argument, NULL, 0 },40
{ "slices", required_argument, NULL, 0 },41
+ { "aq-motion", no_argument, NULL, 0 },42
+ { "no-aq-motion", no_argument, NULL, 0 },43
+ { "ssim-rd", no_argument, NULL, 0 },44
+ { "no-ssim-rd", no_argument, NULL, 0 },45
+ { "hdr", no_argument, NULL, 0 },46
+ { "no-hdr", no_argument, NULL, 0 },47
{ 0, 0, 0, 0 },48
{ 0, 0, 0, 0 },49
{ 0, 0, 0, 0 },50
51
H0(" --[no-]psy-rd <0..5.0> Strength of psycho-visual rate distortion optimization, 0 to disable. Default %.1f\n", param->psyRd);52
H0(" --[no-]rdoq-level <0|1|2> Level of RDO in quantization 0:none, 1:levels, 2:levels & coding groups. Default %d\n", param->rdoqLevel);53
H0(" --[no-]psy-rdoq <0..50.0> Strength of psycho-visual optimization in RDO quantization, 0 to disable. Default %.1f\n", param->psyRdoq);54
+ H0(" --dynamic-rd <0..4.0> Strength of dynamic RD, 0 to disable. Default %.2f\n", param->dynamicRd);55
+ H0(" --[no-]ssim-rd Enable ssim rate distortion optimization, 0 to disable. Default %s\n", OPT(param->bSsimRd));56
H0(" --[no-]rd-refine Enable QP based RD refinement for rd levels 5 and 6. Default %s\n", OPT(param->bEnableRdRefine));57
H0(" --[no-]early-skip Enable early SKIP detection. Default %s\n", OPT(param->bEnableEarlySkip));58
H0(" --[no-]rskip Enable early exit from recursion. Default %s\n", OPT(param->bEnableRecursionSkip));59
60
H0(" --intra-refresh Use Periodic Intra Refresh instead of IDR frames\n");61
H0(" --rc-lookahead <integer> Number of frames for frame-type lookahead (determines encoder latency) Default %d\n", param->lookaheadDepth);62
H1(" --lookahead-slices <0..16> Number of slices to use per lookahead cost estimate. Default %d\n", param->lookaheadSlices);63
+ H0(" --lookahead-threads <integer> Number of threads to be dedicated to perform lookahead only. Default %d\n", param->lookaheadThreads);64
H0(" --bframes <integer> Maximum number of consecutive b-frames (now it only enables B GOP structure) Default %d\n", param->bframes);65
H1(" --bframe-bias <integer> Bias towards B frame decisions. Default %d\n", param->bFrameBias);66
H0(" --b-adapt <0..2> 0 - none, 1 - fast, 2 - full (trellis) adaptive B frame scheduling. Default %d\n", param->bFrameAdaptive);67
68
" - 1 : First pass, creates stats file\n"69
" - 2 : Last pass, does not overwrite stats file\n"70
" - 3 : Nth pass, overwrites stats file\n");71
+ H0(" --[no-]multi-pass-opt-analysis Refine analysis in 2 pass based on analysis information from pass 1\n");72
+ H0(" --[no-]multi-pass-opt-distortion Use distortion of CTU from pass 1 to refine qp in 2 pass\n");73
H0(" --stats Filename for stats file in multipass pass rate control. Default x265_2pass.log\n");74
H0(" --[no-]analyze-src-pics Motion estimation uses source frame planes. Default disable\n");75
H0(" --[no-]slow-firstpass Enable a slow first pass in a multipass rate control mode. Default %s\n", OPT(param->rc.bEnableSlowFirstPass));76
77
H0(" --analysis-file <filename> Specify file name used for either dumping or reading analysis data.\n");78
H0(" --aq-mode <integer> Mode for Adaptive Quantization - 0:none 1:uniform AQ 2:auto variance 3:auto variance with bias to dark scenes. Default %d\n", param->rc.aqMode);79
H0(" --aq-strength <float> Reduces blocking and blurring in flat and textured areas (0 to 3.0). Default %.2f\n", param->rc.aqStrength);80
+ H0(" --[no-]aq-motion Adaptive Quantization based on the relative motion of each CU w.r.t., frame. Default %s\n", OPT(param->bOptCUDeltaQP));81
H0(" --qg-size <int> Specifies the size of the quantization group (64, 32, 16, 8). Default %d\n", param->rc.qgSize);82
H0(" --[no-]cutree Enable cutree for Adaptive Quantization. Default %s\n", OPT(param->rc.cuTree));83
H0(" --[no-]rc-grain Enable ratecontrol mode to handle grains specifically. turned on with tune grain. Default %s\n", OPT(param->rc.bEnableGrain));84
85
H0(" --master-display <string> SMPTE ST 2086 master display color volume info SEI (HDR)\n");86
H0(" format: G(x,y)B(x,y)R(x,y)WP(x,y)L(max,min)\n");87
H0(" --max-cll <string> Emit content light level info SEI as \"cll,fall\" (HDR)\n");88
+ H0(" --[no-]hdr Control dumping of HDR SEI packet. If max-cll or master-display has non-zero values, this is enabled. Default %s\n", OPT(param->bEmitHDRSEI));89
H0(" --min-luma <integer> Minimum luma plane value of input source picture\n");90
H0(" --max-luma <integer> Maximum luma plane value of input source picture\n");91
H0("\nBitstream options:\n");92
93
H0(" --[no-]opt-qp-pps Dynamically optimize QP in PPS (instead of default 26) based on QPs in previous GOP. Default %s\n", OPT(param->bOptQpPPS));94
H0(" --[no-]opt-ref-list-length-pps Dynamically set L0 and L1 ref list length in PPS (instead of default 0) based on values in last GOP. Default %s\n", OPT(param->bOptRefListLengthPPS));95
H0(" --[no-]multi-pass-opt-rps Enable storing commonly used RPS in SPS in multi pass mode. Default %s\n", OPT(param->bMultiPassOptRPS));96
+ H0(" --[no-]opt-cu-delta-qp Optimize to signal consistent CU level delta QPs in frame. Default %s\n", OPT(param->bOptCUDeltaQP));97
H1("\nReconstructed video options (debugging):\n");98
H1("-r/--recon <filename> Reconstructed raw image YUV or Y4M output file name\n");99
H1(" --recon-depth <integer> Bit-depth of reconstructed raw image file. Defaults to input bit depth, or 8 if Y4M\n");100