@@ -1,4 +1,30 @@

 -------------------------------------------------------------------

+Wed Feb  3 13:22:42 UTC 2016 - idonmez@suse.com

+

+- Update to version 1.9

+  API Changes:

+  * x265_frame_stats returns many additional fields: maxCLL, maxFALL,

+    residual energy, scenecut and latency logging

+  * --qpfile now supports frametype 'K"

+  * x265 now allows CRF ratecontrol in pass N (N greater than or equal to 2)

+  * Chroma subsampling format YUV 4:0:0 is now fully supported and tested

+  New Features:

+  * Quant offsets: This feature allows block level quantization offsets

+    to be specified for every frame. An API-only feature.

+  * --intra-refresh: Keyframes can be replaced by a moving column

+    of intra blocks in non-keyframes.

+  * --limit-modes: Intelligently restricts mode analysis.

+  * --max-luma and --min-luma for luma clipping, optional for HDR use-cases

+  * Emergency denoising is now enabled by default in very low bitrate, 

+    VBV encodes

+  Presets and Performance:

+  * Recently added features lookahead-slices, limit-modes, limit-refs

+    have been enabled by default for applicable presets.

+  * The default psy-rd strength has been increased to 2.0

+  * Multi-socket machines now use a single pool of threads that can

+    work cross-socket.

+

+-------------------------------------------------------------------

 Fri Nov 27 18:21:04 UTC 2015 - aloisio@gmx.com

 - Update to version 1.8:

​

@@ -1,10 +1,10 @@

 # based on the spec file from https://build.opensuse.org/package/view_file/home:Simmphonie/libx265/

 Name:           x265

-%define soname  68

+%define soname  79

 %define libname lib%{name}

 %define libsoname %{libname}-%{soname}

-Version:        1.8

+Version:        1.9

 Release:        0

 License:        GPL-2.0+

 Summary:        A free h265/HEVC encoder - encoder binary

@@ -43,35 +43,34 @@

 streams. 

 %prep

-%setup -q -n "%{name}_11047/build/linux"

-cd ../..

+%setup -q -n x265_%{version}

 %patch0 -p1

-cd -

+

 %define FAKE_BUILDDATE %(LC_ALL=C date -u -r %{_sourcedir}/%{name}.changes '+%%b %%e %%Y')

-sed -i -e "s/0.0/%{soname}.0/g" ../../source/cmake/version.cmake

+sed -i -e "s/0.0/%{soname}.0/g" source/cmake/version.cmake

 %build

-export CXXFLAGS="%optflags"

-export CFLAGS="%optflags"

-cmake  -DCMAKE_INSTALL_PREFIX=/usr -DENABLE_TESTS=ON -G "Unix Makefiles" ../../source

-cmake -DCMAKE_INSTALL_PREFIX=/usr ../../source

-#./make-Makefiles.bash

+export CXXFLAGS="%{optflags}"

+export CFLAGS="%{optflags}"

+

+cd build/linux

+cmake  -DCMAKE_INSTALL_PREFIX=%{_prefix} \

+       -DLIB_INSTALL_DIR=%{_lib} \

+       -DENABLE_TESTS=ON \

+       -G "Unix Makefiles" \

+       ../../source

+

 make %{?_smp_mflags} VERBOSE=1

 %install

+cd build/linux

 %makeinstall

-%ifarch x86_64

-  mv "%{buildroot}/usr/lib" "%{buildroot}%{_libdir}"

-%endif

 rm -f %{buildroot}%{_libdir}/%{libname}.a

 echo "%{libname}-%{soname}" > %{_sourcedir}/baselibs.conf

-%clean

-%{?buildroot:%__rm -rf "%{buildroot}"}

-

 %post -n %{libsoname} -p /sbin/ldconfig

 %postun -n %{libsoname} -p /sbin/ldconfig

​

@@ -1,5 +1,4 @@

 repo: 09fe40627f03a0f9c3e6ac78b22ac93da23f9fdf

-node: 5dcc9d3a928c400b41a3547d7bfee10340519e56

+node: 1d3b6e448e01ec40b392ef78b7e55a86249fbe68

 branch: stable

-latesttag: 1.8

-latesttagdistance: 1

+tag: 1.9

​

@@ -84,8 +84,8 @@

    it adds one line per run. If :option:`--csv-log-level` is greater than

    0, it writes one line per frame. Default none

-   When frame level logging is enabled, several frame performance

-   statistics are listed:

+   Several frame performance statistics are available when 

+   :option:`--csv-log-level` is greater than or equal to 2:

    **DecideWait ms** number of milliseconds the frame encoder had to

    wait, since the previous frame was retrieved by the API thread,

@@ -202,15 +202,29 @@

    "-"       - same as "none"

    "10"      - allocate one pool, using up to 10 cores on node 0

    "-,+"     - allocate one pool, using all cores on node 1

-   "+,-,+"   - allocate two pools, using all cores on nodes 0 and 2

-   "+,-,+,-" - allocate two pools, using all cores on nodes 0 and 2

-   "-,*"     - allocate three pools, using all cores on nodes 1, 2 and 3

+   "+,-,+"   - allocate one pool, using only cores on nodes 0 and 2

+   "+,-,+,-" - allocate one pool, using only cores on nodes 0 and 2

+   "-,*"     - allocate one pool, using all cores on nodes 1, 2 and 3

    "8,8,8,8" - allocate four pools with up to 8 threads in each pool

-

-   The total number of threads will be determined by the number of threads

-   assigned to all nodes. The worker threads will each be given affinity for

-   their node, they will not be allowed to migrate between nodes, but they

-   will be allowed to move between CPU cores within their node.

+   "8,+,+,+" - allocate two pools, the first with 8 threads on node 0, and the second with all cores on node 1,2,3

+

+   A thread pool dedicated to a given NUMA node is enabled only when the

+   number of threads to be created on that NUMA node is explicitly mentioned

+   in that corresponding position with the --pools option. Else, all threads

+   are spawned from a single pool. The total number of threads will be

+   determined by the number of threads assigned to the enabled NUMA nodes for

+   that pool. The worker threads are be given affinity to all the enabled

+   NUMA nodes for that pool and may migrate between them, unless explicitly

+   specified as described above.

+

+   In the case that any threadpool has more than 64 threads, the threadpool

+   may be broken down into multiple pools of 64 threads each; on 32-bit

+   machines, this number is 32. All pools are given affinity to the NUMA

+   nodes on which the original pool had affinity. For performance reasons,

+   the last thread pool is spawned only if it has more than 32 threads for

+   64-bit machines, or 16 for 32-bit machines. If the total number of threads

+   in the system doesn't obey this constraint, we may spawn fewer threads

+   than cores which has been emperically shown to be better for performance. 

    If the four pool features: :option:`--wpp`, :option:`--pmode`,

    :option:`--pme` and :option:`--lookahead-slices` are all disabled,

@@ -219,10 +233,6 @@

    If "none" is specified, then all four of the thread pool features are

    implicitly disabled.

-   Multiple thread pools will be allocated for any NUMA node with more than

-   64 logical CPU cores. But any given thread pool will always use at most

-   one NUMA node.

-

    Frame encoders are distributed between the available thread pools,

    and the encoder will never generate more thread pools than

    :option:`--frame-threads`.  The pools are used for WPP and for

@@ -238,8 +248,12 @@

    system, a POSIX build of libx265 without libnuma will be less work

    efficient. See :ref:`thread pools <pools>` for more detail.

-   Default "", one thread is allocated per detected hardware thread

-   (logical CPU cores) and one thread pool per NUMA node.

+   Default "", one pool is created across all available NUMA nodes, with

+   one thread allocated per detected hardware thread

+   (logical CPU cores). In the case that the total number of threads is more

+   than the maximum size that ATOMIC operations can handle (32 for 32-bit

+   compiles, and 64 for 64-bit compiles), multiple thread pools may be

+   spawned subject to the performance constraint described above.

    Note that the string value will need to be escaped or quoted to

    protect against shell expansion on many platforms

@@ -353,7 +367,7 @@

    **CLI ONLY**

-.. option:: --total-frames <integer>

+.. option:: --frames <integer>

    The number of frames intended to be encoded.  It may be left

    unspecified, but when it is specified rate control can make use of

@@ -377,15 +391,15 @@

 .. option:: --input-csp <integer|string>

-   YUV only: Source color space. Only i420, i422, and i444 are

-   supported at this time. The internal color space is always the

-   same as the source color space (libx265 does not support any color

-   space conversions).

+   Chroma Subsampling (YUV only):  Only 4:0:0(monochrome), 4:2:0, 4:2:2, and 4:4:4 are supported at this time. 

+   The chroma subsampling format of your input must match your desired output chroma subsampling format 

+   (libx265 will not perform any chroma subsampling conversion), and it must be supported by the 

+   HEVC profile you have specified.

-   0. i400

-   1. i420 **(default)**

-   2. i422

-   3. i444

+   0. i400 (4:0:0 monochrome) - Not supported by Main or Main10 profiles

+   1. i420 (4:2:0 default)    - Supported by all HEVC profiles

+   2. i422 (4:2:2)            - Not supported by Main, Main10 and Main12 profiles

+   3. i444 (4:4:4)            - Supported by Main 4:4:4, Main 4:4:4 10, Main 4:4:4 12, Main 4:4:4 16 Intra profiles

    4. nv12

    5. nv16

@@ -436,8 +450,8 @@

    depth of the encoder. If the requested bit depth is not the bit

    depth of the linked libx265, it will attempt to bind libx265_main

    for an 8bit encoder, libx265_main10 for a 10bit encoder, or

-   libx265_main12 for a 12bit encoder (EXPERIMENTAL), with the

-   same API version as the linked libx265.

+   libx265_main12 for a 12bit encoder, with the same API version as the

+   linked libx265.

    If the output depth is not specified but :option:`--profile` is

    specified, the output depth will be derived from the profile name.

@@ -486,13 +500,6 @@

    The CLI application will derive the output bit depth from the

    profile name if :option:`--output-depth` is not specified.

-.. note::

-

-   All 12bit presets are extremely unstable, do not use them yet.

-   16bit is not supported at all, but those profiles are included

-   because it is possible for libx265 to make bitstreams compatible

-   with them.

-

 .. option:: --level-idc <integer|float>

    Minimum decoder requirement level. Defaults to 0, which implies

@@ -606,7 +613,8 @@

    +-------+---------------------------------------------------------------+

    | Level | Description                                                   |

    +=======+===============================================================+

-   | 0     | sa8d mode and split decisions, intra w/ source pixels         |

+   | 0     | sa8d mode and split decisions, intra w/ source pixels,        |

+   |       | currently not supported                                       |

    +-------+---------------------------------------------------------------+

    | 1     | recon generated (better intra), RDO merge/skip selection      |

    +-------+---------------------------------------------------------------+

@@ -677,7 +685,16 @@

    (within your decoder level limits) if you enable one or

    both of these flags.

-   This feature is EXPERIMENTAL and functional at all RD levels.

+   Default 3.

+

+.. option:: --limit-modes, --no-limit-modes

+    

+   When enabled, limit-modes will limit modes analyzed for each CU using cost 

+   metrics from the 4 sub-CUs. When multiple inter modes like :option:`--rect`

+   and/or :option:`--amp` are enabled, this feature will use motion cost 

+   heuristics from the 4 sub-CUs to bypass modes that are unlikely to be the 

+   best choice. This can significantly improve performance when :option:`rect`

+   and/or :option:`--amp` are enabled at minimal compression efficiency loss.

 .. option:: --rect, --no-rect

@@ -1049,9 +1066,9 @@

    energy of the source image in the encoded image at the expense of

    compression efficiency. It only has effect on presets which use

    RDO-based mode decisions (:option:`--rd` 3 and above). 1.0 is a

-   typical value. Default 0.3

+   typical value. Default 2.0

-   **Range of values:** 0 .. 2.0

+   **Range of values:** 0 .. 5.0

 .. option:: --psy-rdoq <float>

@@ -1076,7 +1093,8 @@

    Max intra period in frames. A special case of infinite-gop (single

    keyframe at the beginning of the stream) can be triggered with

-   argument -1. Use 1 to force all-intra. Default 250

+   argument -1. Use 1 to force all-intra. When intra-refresh is enabled

+   it specifies the interval between which refresh sweeps happen. Default 250

 .. option:: --min-keyint, -i <integer>

@@ -1095,6 +1113,14 @@

    :option:`--scenecut` 0 or :option:`--no-scenecut` disables adaptive

    I frame placement. Default 40

+.. option:: --intra-refresh

+

+   Enables Periodic Intra Refresh(PIR) instead of keyframe insertion.

+   PIR can replace keyframes by inserting a column of intra blocks in 

+   non-keyframes, that move across the video from one side to the other

+   and thereby refresh the image but over a period of multiple 

+   frames instead of a single keyframe.

+

 .. option:: --rc-lookahead <integer>

    Number of frames for slice-type decision lookahead (a key

@@ -1108,21 +1134,31 @@

​

@@ -6,76 +6,83 @@

 Presets

 =======

-x265 has a number of predefined :option:`--preset` options that make

-trade-offs between encode speed (encoded frames per second) and

+x265 has ten predefined :option:`--preset` options that optimize the

+trade-off between encoding speed (encoded frames per second) and

 compression efficiency (quality per bit in the bitstream).  The default

-preset is medium, it does a reasonably good job of finding the best

-possible quality without spending enormous CPU cycles looking for the

-absolute most efficient way to achieve that quality.  As you go higher

-than medium, the encoder takes shortcuts to improve performance at the

-expense of quality and compression efficiency.  As you go lower than

-medium, the encoder tries harder and harder to achieve the best quailty

-per bit compression ratio.

-

-The presets adjust encoder parameters to affect these trade-offs.

-

-+--------------+-----------+-----------+----------+--------+------+--------+------+--------+----------+---------+

-|              | ultrafast | superfast | veryfast | faster | fast | medium | slow | slower | veryslow | placebo |

-+==============+===========+===========+==========+========+======+========+======+========+==========+=========+

-| ctu          |   32      |    32     |   32     |  64    |  64  |   64   |  64  |  64    |   64     |   64    |

-+--------------+-----------+-----------+----------+--------+------+--------+------+--------+----------+---------+

-| min-cu-size  |   16      |     8     |    8     |   8    |   8  |    8   |   8  |   8    |    8     |    8    |

-+--------------+-----------+-----------+----------+--------+------+--------+------+--------+----------+---------+

-| bframes      |    3      |     3     |    4     |   4    |  4   |    4   |  4   |   8    |    8     |    8    |

-+--------------+-----------+-----------+----------+--------+------+--------+------+--------+----------+---------+

-| b-adapt      |    0      |     0     |    0     |   0    |  0   |    2   |  2   |   2    |    2     |    2    |

-+--------------+-----------+-----------+----------+--------+------+--------+------+--------+----------+---------+

-| rc-lookahead |    5      |    10     |   15     |  15    |  15  |   20   |  25  |   30   |   40     |   60    |

-+--------------+-----------+-----------+----------+--------+------+--------+------+--------+----------+---------+

-| scenecut     |    0      |    40     |   40     |  40    |  40  |   40   |  40  |   40   |   40     |   40    |

-+--------------+-----------+-----------+----------+--------+------+--------+------+--------+----------+---------+

-| refs         |    1      |     1     |    1     |   1    |  2   |    3   |  3   |   3    |    5     |    5    |

-+--------------+-----------+-----------+----------+--------+------+--------+------+--------+----------+---------+

-| me           |   dia     |   hex     |   hex    |  hex   | hex  |   hex  | star |  star  |   star   |   star  |

-+--------------+-----------+-----------+----------+--------+------+--------+------+--------+----------+---------+

-| merange      |   57      |    57     |   57     |  57    |  57  |   57   | 57   |  57    |   57     |   92    |

-+--------------+-----------+-----------+----------+--------+------+--------+------+--------+----------+---------+

-| subme        |    0      |     1     |    1     |   2    |  2   |    2   |  3   |   3    |    4     |    5    |

-+--------------+-----------+-----------+----------+--------+------+--------+------+--------+----------+---------+

-| rect         |    0      |     0     |    0     |   0    |  0   |    0   |  1   |   1    |    1     |    1    |

-+--------------+-----------+-----------+----------+--------+------+--------+------+--------+----------+---------+

-| amp          |    0      |     0     |    0     |   0    |  0   |    0   |  0   |   1    |    1     |    1    |

-+--------------+-----------+-----------+----------+--------+------+--------+------+--------+----------+---------+

-| max-merge    |    2      |     2     |    2     |   2    |  2   |    2   |  3   |   3    |    4     |    5    |

-+--------------+-----------+-----------+----------+--------+------+--------+------+--------+----------+---------+

-| early-skip   |    1      |     1     |    1     |   1    |  0   |    0   |  0   |   0    |    0     |    0    |

-+--------------+-----------+-----------+----------+--------+------+--------+------+--------+----------+---------+

-| fast-intra   |    1      |     1     |    1     |   1    |  1   |    0   |  0   |   0    |    0     |    0    |

-+--------------+-----------+-----------+----------+--------+------+--------+------+--------+----------+---------+

-| b-intra      |    0      |     0     |    0     |   0    |  0   |    0   |  0   |   1    |    1     |    1    |

-+--------------+-----------+-----------+----------+--------+------+--------+------+--------+----------+---------+

-| sao          |    0      |     0     |    1     |   1    |  1   |    1   |  1   |   1    |    1     |    1    |

-+--------------+-----------+-----------+----------+--------+------+--------+------+--------+----------+---------+

-| signhide     |    0      |     1     |    1     |   1    |  1   |    1   |  1   |   1    |    1     |    1    |

-+--------------+-----------+-----------+----------+--------+------+--------+------+--------+----------+---------+

-| weightp      |    0      |     0     |    1     |   1    |  1   |    1   |  1   |   1    |    1     |    1    |

-+--------------+-----------+-----------+----------+--------+------+--------+------+--------+----------+---------+

-| weightb      |    0      |     0     |    0     |   0    |  0   |    0   |  0   |   1    |    1     |    1    |

-+--------------+-----------+-----------+----------+--------+------+--------+------+--------+----------+---------+

-| aq-mode      |    0      |     0     |    1     |   1    |  1   |    1   |  1   |   1    |    1     |    1    |

-+--------------+-----------+-----------+----------+--------+------+--------+------+--------+----------+---------+

-| cuTree       |    0      |     0     |    0     |   0    |  1   |    1   |  1   |   1    |    1     |    1    |

-+--------------+-----------+-----------+----------+--------+------+--------+------+--------+----------+---------+

-| rdLevel      |    2      |     2     |    2     |   2    |  2   |    3   |  4   |   6    |    6     |    6    |

-+--------------+-----------+-----------+----------+--------+------+--------+------+--------+----------+---------+

-| rdoq-level   |    0      |     0     |    0     |   0    |  0   |    0   |  2   |   2    |    2     |    2    |

-+--------------+-----------+-----------+----------+--------+------+--------+------+--------+----------+---------+

-| tu-intra     |    1      |     1     |    1     |   1    |  1   |    1   |  1   |   2    |    3     |    4    |

-+--------------+-----------+-----------+----------+--------+------+--------+------+--------+----------+---------+

-| tu-inter     |    1      |     1     |    1     |   1    |  1   |    1   |  1   |   2    |    3     |    4    |

-+--------------+-----------+-----------+----------+--------+------+--------+------+--------+----------+---------+

-

-Placebo mode enables transform-skip prediction evaluation.

+preset is medium.  It does a reasonably good job of finding the best

+possible quality without spending excessive CPU cycles looking for the

+absolute most efficient way to achieve that quality.  When you use 

+faster presets, the encoder takes shortcuts to improve performance at 

+the expense of quality and compression efficiency.  When you use slower

+presets, x265 tests more encoding options, using more computations to  

+achieve the best quality at your selected bit rate (or in the case of

+--crf rate control, the lowest bit rate at the selected quality).

+

+The presets adjust encoder parameters as shown in the following table.

+Any parameters below that are specified in your command-line will be 

+changed from the value specified by the preset.

+

++-----------------+----------+----------+---------+-------+-----+-------+-----+-------+---------+--------+

+|                 |ultrafast |superfast |veryfast |faster |fast |medium |slow |slower |veryslow |placebo |

++=================+==========+==========+=========+=======+=====+=======+=====+=======+=========+========+

+| ctu             |    32    |    32    |   64    |  64   | 64  |  64   | 64  |  64   |   64    |  64    |

++-----------------+----------+----------+---------+-------+-----+-------+-----+-------+---------+--------+

+| min-cu-size     |    16    |     8    |    8    |   8   |  8  |   8   |  8  |   8   |    8    |   8    |

++-----------------+----------+----------+---------+-------+-----+-------+-----+-------+---------+--------+

+| bframes         |     3    |     3    |    4    |   4   |  4  |   4   |  4  |   8   |    8    |   8    |

++-----------------+----------+----------+---------+-------+-----+-------+-----+-------+---------+--------+

+| b-adapt         |     0    |     0    |    0    |   0   |  0  |   2   |  2  |   2   |    2    |   2    |

++-----------------+----------+----------+---------+-------+-----+-------+-----+-------+---------+--------+

+| rc-lookahead    |     5    |    10    |   15    |  15   | 15  |  20   | 25  |  30   |   40    |  60    |

++-----------------+----------+----------+---------+-------+-----+-------+-----+-------+---------+--------+

+| lookahead-slices|     8    |     8    |    8    |   8   |  8  |   8   |  4  |   4   |    1    |   1    |

++-----------------+----------+----------+---------+-------+-----+-------+-----+-------+---------+--------+

+| scenecut        |     0    |    40    |   40    |  40   | 40  |  40   | 40  |  40   |   40    |  40    |

++-----------------+----------+----------+---------+-------+-----+-------+-----+-------+---------+--------+

+| ref             |     1    |     1    |    2    |   2   |  3  |   3   |  4  |   4   |    5    |   5    |

++-----------------+----------+----------+---------+-------+-----+-------+-----+-------+---------+--------+

+| limit-refs      |     0    |     0    |    3    |   3   |  3  |   3   |  3  |   2   |    1    |   0    |

++-----------------+----------+----------+---------+-------+-----+-------+-----+-------+---------+--------+

+| me              |    dia   |   hex    |   hex   |  hex  |hex  |  hex  |star | star  |   star  |  star  |

++-----------------+----------+----------+---------+-------+-----+-------+-----+-------+---------+--------+

+| merange         |    57    |    57    |   57    |  57   | 57  |  57   | 57  |  57   |   57    |  92    |

++-----------------+----------+----------+---------+-------+-----+-------+-----+-------+---------+--------+

+| subme           |     0    |     1    |    1    |   2   |  2  |   2   |  3  |   3   |    4    |   5    |

++-----------------+----------+----------+---------+-------+-----+-------+-----+-------+---------+--------+

+| rect            |     0    |     0    |    0    |   0   |  0  |   0   |  1  |   1   |    1    |   1    |

++-----------------+----------+----------+---------+-------+-----+-------+-----+-------+---------+--------+

+| amp             |     0    |     0    |    0    |   0   |  0  |   0   |  0  |   1   |    1    |   1    |

++-----------------+----------+----------+---------+-------+-----+-------+-----+-------+---------+--------+

+| limit-modes     |     0    |     0    |    0    |   0   |  0  |   0   |  1  |   1   |    1    |   0    |

++-----------------+----------+----------+---------+-------+-----+-------+-----+-------+---------+--------+

+| max-merge       |     2    |     2    |    2    |   2   |  2  |   2   |  3  |   3   |    4    |   5    |

++-----------------+----------+----------+---------+-------+-----+-------+-----+-------+---------+--------+

+| early-skip      |     1    |     1    |    1    |   1   |  0  |   0   |  0  |   0   |    0    |   0    |

++-----------------+----------+----------+---------+-------+-----+-------+-----+-------+---------+--------+

+| fast-intra      |     1    |     1    |    1    |   1   |  1  |   0   |  0  |   0   |    0    |   0    |

++-----------------+----------+----------+---------+-------+-----+-------+-----+-------+---------+--------+

+| b-intra         |     0    |     0    |    0    |   0   |  0  |   0   |  0  |   1   |    1    |   1    |

++-----------------+----------+----------+---------+-------+-----+-------+-----+-------+---------+--------+

+| sao             |     0    |     0    |    1    |   1   |  1  |   1   |  1  |   1   |    1    |   1    |

++-----------------+----------+----------+---------+-------+-----+-------+-----+-------+---------+--------+

+| signhide        |     0    |     1    |    1    |   1   |  1  |   1   |  1  |   1   |    1    |   1    |

++-----------------+----------+----------+---------+-------+-----+-------+-----+-------+---------+--------+

+| weightp         |     0    |     0    |    1    |   1   |  1  |   1   |  1  |   1   |    1    |   1    |

++-----------------+----------+----------+---------+-------+-----+-------+-----+-------+---------+--------+

+| weightb         |     0    |     0    |    0    |   0   |  0  |   0   |  0  |   1   |    1    |   1    |

++-----------------+----------+----------+---------+-------+-----+-------+-----+-------+---------+--------+

+| aq-mode         |     0    |     0    |    1    |   1   |  1  |   1   |  1  |   1   |    1    |   1    |

++-----------------+----------+----------+---------+-------+-----+-------+-----+-------+---------+--------+

+| cuTree          |     1    |     1    |    1    |   1   |  1  |   1   |  1  |   1   |    1    |   1    |

++-----------------+----------+----------+---------+-------+-----+-------+-----+-------+---------+--------+

+| rdLevel         |     2    |     2    |    2    |   2   |  2  |   3   |  4  |   6   |    6    |   6    |

++-----------------+----------+----------+---------+-------+-----+-------+-----+-------+---------+--------+

+| rdoq-level      |     0    |     0    |    0    |   0   |  0  |   0   |  2  |   2   |    2    |   2    |

++-----------------+----------+----------+---------+-------+-----+-------+-----+-------+---------+--------+

+| tu-intra        |     1    |     1    |    1    |   1   |  1  |   1   |  1  |   2   |    3    |   4    |

++-----------------+----------+----------+---------+-------+-----+-------+-----+-------+---------+--------+

+| tu-inter        |     1    |     1    |    1    |   1   |  1  |   1   |  1  |   2   |    3    |   4    |

++-----------------+----------+----------+---------+-------+-----+-------+-----+-------+---------+--------+

 .. _tunings:

​

@@ -30,7 +30,7 @@

 mark_as_advanced(FPROFILE_USE FPROFILE_GENERATE NATIVE_BUILD)

 # X265_BUILD must be incremented each time the public API is changed

-set(X265_BUILD 68)

+set(X265_BUILD 79)

 configure_file("${PROJECT_SOURCE_DIR}/x265.def.in"

                "${PROJECT_BINARY_DIR}/x265.def")

 configure_file("${PROJECT_SOURCE_DIR}/x265_config.h.in"

@@ -45,12 +45,14 @@

 set(POWER_ALIASES ppc64 ppc64le)

 list(FIND POWER_ALIASES "${SYSPROC}" POWERMATCH)

 if("${SYSPROC}" STREQUAL "" OR X86MATCH GREATER "-1")

-    message(STATUS "Detected x86 target processor")

     set(X86 1)

     add_definitions(-DX265_ARCH_X86=1)

     if("${CMAKE_SIZEOF_VOID_P}" MATCHES 8)

         set(X64 1)

         add_definitions(-DX86_64=1)

+        message(STATUS "Detected x86_64 target processor")

+    else()

+        message(STATUS "Detected x86 target processor")

     endif()

 elseif(POWERMATCH GREATER "-1")

     message(STATUS "Detected POWER target processor")

@@ -71,23 +73,27 @@

     if(LIBRT)

         list(APPEND PLATFORM_LIBS rt)

     endif()

+    mark_as_advanced(LIBRT)

     find_library(LIBDL dl)

     if(LIBDL)

         list(APPEND PLATFORM_LIBS dl)

     endif()

-    find_package(Numa)

-    if(NUMA_FOUND)

-        link_directories(${NUMA_LIBRARY_DIR})

-        list(APPEND CMAKE_REQUIRED_LIBRARIES numa)

-        check_symbol_exists(numa_node_of_cpu numa.h NUMA_V2)

-        if(NUMA_V2)

-            add_definitions(-DHAVE_LIBNUMA)

-            message(STATUS "libnuma found, building with support for NUMA nodes")

-            list(APPEND PLATFORM_LIBS numa)

-            include_directories(${NUMA_INCLUDE_DIR})

+    option(ENABLE_LIBNUMA "Enable libnuma usage (Linux only)" ON)

+    if(ENABLE_LIBNUMA)

+        find_package(Numa)

+        if(NUMA_FOUND)

+            link_directories(${NUMA_LIBRARY_DIR})

+            list(APPEND CMAKE_REQUIRED_LIBRARIES numa)

+            check_symbol_exists(numa_node_of_cpu numa.h NUMA_V2)

+            if(NUMA_V2)

+                add_definitions(-DHAVE_LIBNUMA)

+                message(STATUS "libnuma found, building with support for NUMA nodes")

+                list(APPEND PLATFORM_LIBS numa)

+                include_directories(${NUMA_INCLUDE_DIR})

+            endif()

         endif()

-    endif()

-    mark_as_advanced(LIBRT NUMA_FOUND)

+        mark_as_advanced(NUMA_FOUND)

+    endif(ENABLE_LIBNUMA)

     option(NO_ATOMICS "Use a slow mutex to replace atomics" OFF)

     if(NO_ATOMICS)

         add_definitions(-DNO_ATOMICS=1)

@@ -157,6 +163,7 @@

 if(GCC)

     add_definitions(-Wall -Wextra -Wshadow)

     add_definitions(-D__STDC_LIMIT_MACROS=1)

+    add_definitions(-std=gnu++98)

     if(ENABLE_PIC)

          add_definitions(-fPIC)

     endif(ENABLE_PIC)

@@ -379,16 +386,19 @@

 option(ENABLE_VTUNE "Enable Vtune profiling instrumentation" OFF)

 if(ENABLE_VTUNE)

-    add_definitions(-DENABLE_VTUNE)

-    include_directories($ENV{VTUNE_AMPLIFIER_XE_2015_DIR}/include)

-    list(APPEND PLATFORM_LIBS vtune)

-    link_directories($ENV{VTUNE_AMPLIFIER_XE_2015_DIR}/lib64)

-    if(WIN32)

-        list(APPEND PLATFORM_LIBS libittnotify.lib)

-    else()

-        list(APPEND PLATFORM_LIBS libittnotify.a dl)

-    endif()

-    add_subdirectory(profile/vtune)

+    find_package(Vtune)

+    if(VTUNE_FOUND)

+        add_definitions(-DENABLE_VTUNE)

+        include_directories(${VTUNE_INCLUDE_DIR})

+        list(APPEND PLATFORM_LIBS vtune)

+        link_directories(${VTUNE_LIBRARY_DIR})

+        if(WIN32)

+            list(APPEND PLATFORM_LIBS libittnotify.lib)

+        else()

+            list(APPEND PLATFORM_LIBS libittnotify.a dl)

+        endif()

+        add_subdirectory(profile/vtune)

+    endif(VTUNE_FOUND)

 endif(ENABLE_VTUNE)

 option(DETAILED_CU_STATS "Enable internal profiling of encoder work" OFF)

@@ -455,6 +465,9 @@

 if(ENABLE_SHARED)

     add_library(x265-shared SHARED "${PROJECT_BINARY_DIR}/x265.def" ${YASM_OBJS}

                 ${X265_RC_FILE} $<TARGET_OBJECTS:encoder> $<TARGET_OBJECTS:common>)

+    if(EXTRA_LIB)

+        target_link_libraries(x265-shared ${EXTRA_LIB})

+    endif()

     target_link_libraries(x265-shared ${PLATFORM_LIBS})

     if(MSVC)

         set_target_properties(x265-shared PROPERTIES OUTPUT_NAME libx265)

@@ -465,6 +478,8 @@

         set_target_properties(x265-shared PROPERTIES VERSION ${X265_BUILD})

         if(APPLE)

             set_target_properties(x265-shared PROPERTIES MACOSX_RPATH 1)

+        elseif(CYGWIN)

+            # Cygwin is not officially supported or tested. MinGW with msys is recommended.

         else()

             list(APPEND LINKER_OPTIONS "-Wl,-Bsymbolic,-znoexecstack")

         endif()

@@ -480,9 +495,6 @@

                 ARCHIVE DESTINATION ${LIB_INSTALL_DIR}

                 RUNTIME DESTINATION ${BIN_INSTALL_DIR})

     endif()

-    if(EXTRA_LIB)

-        target_link_libraries(x265-shared ${EXTRA_LIB})

-    endif()

     if(LINKER_OPTIONS)

         # set_target_properties can't do list expansion

         string(REPLACE ";" " " LINKER_OPTION_STR "${LINKER_OPTIONS}")

​

@@ -0,0 +1,25 @@

+# Module for locating Vtune

+#

+# Read-only variables

+#   VTUNE_FOUND: Indicates that the library has been found

+#   VTUNE_INCLUDE_DIR: Points to the vtunes include dir

+#   VTUNE_LIBRARY_DIR: Points to the directory with libraries

+#

+# Copyright (c) 2015 Pradeep Ramachandran

+

+include(FindPackageHandleStandardArgs)

+

+find_path(VTUNE_DIR

+    if(UNIX)

+        NAMES amplxe-vars.sh

+    else()

+        NAMES amplxe-vars.bat

+    endif(UNIX)

+    HINTS $ENV{VTUNE_AMPLIFIER_XE_2016_DIR} $ENV{VTUNE_AMPLIFIER_XE_2015_DIR}

+    DOC "Vtune root directory")

+

+set (VTUNE_INCLUDE_DIR ${VTUNE_DIR}/include)

+set (VTUNE_LIBRARY_DIR ${VTUNE_DIR}/lib64)

+

+mark_as_advanced(VTUNE_DIR)

+find_package_handle_standard_args(VTUNE REQUIRED_VARS VTUNE_DIR VTUNE_INCLUDE_DIR VTUNE_LIBRARY_DIR)

​

@@ -1,5 +1,6 @@

 #include "common.h"

 #include "bitstream.h"

+#include "threading.h"

 using namespace X265_NS;

@@ -112,16 +113,13 @@

 void SyntaxElementWriter::writeUvlc(uint32_t code)

 {

-    uint32_t length = 1;

-    uint32_t temp = ++code;

+    ++code;

-    X265_CHECK(temp, "writing -1 code, will cause infinite loop\n");

+    X265_CHECK(code, "writing -1 code, will cause infinite loop\n");

-    while (1 != temp)

-    {

-        temp >>= 1;

-        length += 2;

-    }

+    unsigned long idx;

+    CLZ(idx, code);

+    uint32_t length = (uint32_t)idx * 2 + 1;

     // Take care of cases where length > 32

     m_bitIf->write(0, length >> 1);

​

@@ -2,6 +2,7 @@

  * Copyright (C) 2013 x265 project

  *

  * Author: Steve Borho <steve@borho.org>

+ *         Min Chen <chenm003@163.com>

  *

  * This program is free software; you can redistribute it and/or modify

  * it under the terms of the GNU General Public License as published by

​

@@ -2,6 +2,7 @@

  * Copyright (C) 2013 x265 project

  *

  * Authors: Deepthi Nandakumar <deepthi@multicorewareinc.com>

+ *          Min Chen <chenm003@163.com>

  *

  * This program is free software; you can redistribute it and/or modify

  * it under the terms of the GNU General Public License as published by

@@ -134,10 +135,10 @@

 typedef int32_t  ssum2_t; // Signed sum

 #endif // if HIGH_BIT_DEPTH

-#if X265_DEPTH <= 10

-typedef uint32_t sse_ret_t;

+#if X265_DEPTH < 10

+typedef uint32_t sse_t;

 #else

-typedef uint64_t sse_ret_t;

+typedef uint64_t sse_t;

 #endif

 #ifndef NULL

@@ -214,6 +215,7 @@

 #define X265_MALLOC(type, count)    (type*)x265_malloc(sizeof(type) * (count))

 #define X265_FREE(ptr)              x265_free(ptr)

+#define X265_FREE_ZERO(ptr)         x265_free(ptr); (ptr) = NULL

 #define CHECKED_MALLOC(var, type, count) \

     { \

         var = (type*)x265_malloc(sizeof(type) * (count)); \

@@ -317,6 +319,9 @@

 #define CHROMA_V_SHIFT(x) (x == X265_CSP_I420)

 #define X265_MAX_PRED_MODE_PER_CTU 85 * 2 * 8

+#define MAX_NUM_TR_COEFFS           MAX_TR_SIZE * MAX_TR_SIZE // Maximum number of transform coefficients, for a 32x32 transform

+#define MAX_NUM_TR_CATEGORIES       16                        // 32, 16, 8, 4 transform categories each for luma and chroma

+

 namespace X265_NS {

 enum { SAO_NUM_OFFSET = 4 };

@@ -366,25 +371,6 @@

         delete[] ctuParam[2];

     }

 };

-

-/* Stores inter analysis data for a single frame */

-struct analysis_inter_data

-{

-    int32_t*    ref;

-    uint8_t*    depth;

-    uint8_t*    modes;

-    uint32_t*   bestMergeCand;

-};

-

-/* Stores intra analysis data for a single frame. This struct needs better packing */

-struct analysis_intra_data

-{

-    uint8_t*  depth;

-    uint8_t*  modes;

-    char*     partSizes;

-    uint8_t*  chromaModes;

-};

-

 enum TextType

 {

     TEXT_LUMA     = 0,  // luma

​

@@ -2,6 +2,7 @@

 * Copyright (C) 2015 x265 project

 *

 * Authors: Steve Borho <steve@borho.org>

+*          Min Chen <chenm003@163.com>

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

​

@@ -2,6 +2,7 @@

  * Copyright (C) 2015 x265 project

  *

  * Authors: Steve Borho <steve@borho.org>

+ *          Min Chen <chenm003@163.com>

  *

  * This program is free software; you can redistribute it and/or modify

  * it under the terms of the GNU General Public License as published by

​

@@ -2,6 +2,7 @@

 * Copyright (C) 2015 x265 project

 *

 * Authors: Steve Borho <steve@borho.org>

+*          Min Chen <chenm003@163.com>

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

​

@@ -2,6 +2,7 @@

  * Copyright (C) 2015 x265 project

  *

  * Authors: Steve Borho <steve@borho.org>

+ *          Min Chen <chenm003@163.com>

  *

  * This program is free software; you can redistribute it and/or modify

  * it under the terms of the GNU General Public License as published by

@@ -192,44 +193,82 @@

         break;

     }

-    /* Each CU's data is layed out sequentially within the charMemBlock */

-    uint8_t *charBuf = dataPool.charMemBlock + (m_numPartitions * BytesPerPartition) * instance;

-

-    m_qp        = (int8_t*)charBuf; charBuf += m_numPartitions;

-    m_log2CUSize         = charBuf; charBuf += m_numPartitions;

-    m_lumaIntraDir       = charBuf; charBuf += m_numPartitions;

-    m_tqBypass           = charBuf; charBuf += m_numPartitions;

-    m_refIdx[0] = (int8_t*)charBuf; charBuf += m_numPartitions;

-    m_refIdx[1] = (int8_t*)charBuf; charBuf += m_numPartitions;

-    m_cuDepth            = charBuf; charBuf += m_numPartitions;

-    m_predMode           = charBuf; charBuf += m_numPartitions; /* the order up to here is important in initCTU() and initSubCU() */

-    m_partSize           = charBuf; charBuf += m_numPartitions;

-    m_mergeFlag          = charBuf; charBuf += m_numPartitions;

-    m_interDir           = charBuf; charBuf += m_numPartitions;

-    m_mvpIdx[0]          = charBuf; charBuf += m_numPartitions;

-    m_mvpIdx[1]          = charBuf; charBuf += m_numPartitions;

-    m_tuDepth            = charBuf; charBuf += m_numPartitions;

-    m_transformSkip[0]   = charBuf; charBuf += m_numPartitions;

-    m_transformSkip[1]   = charBuf; charBuf += m_numPartitions;

-    m_transformSkip[2]   = charBuf; charBuf += m_numPartitions;

-    m_cbf[0]             = charBuf; charBuf += m_numPartitions;

-    m_cbf[1]             = charBuf; charBuf += m_numPartitions;

-    m_cbf[2]             = charBuf; charBuf += m_numPartitions;

-    m_chromaIntraDir     = charBuf; charBuf += m_numPartitions;

-

-    X265_CHECK(charBuf == dataPool.charMemBlock + (m_numPartitions * BytesPerPartition) * (instance + 1), "CU data layout is broken\n");

-

-    m_mv[0]  = dataPool.mvMemBlock + (instance * 4) * m_numPartitions;

-    m_mv[1]  = m_mv[0] +  m_numPartitions;

-    m_mvd[0] = m_mv[1] +  m_numPartitions;

-    m_mvd[1] = m_mvd[0] + m_numPartitions;

-

-    uint32_t cuSize = g_maxCUSize >> depth;

-    uint32_t sizeL = cuSize * cuSize;

-    uint32_t sizeC = sizeL >> (m_hChromaShift + m_vChromaShift);

-    m_trCoeff[0] = dataPool.trCoeffMemBlock + instance * (sizeL + sizeC * 2);

-    m_trCoeff[1] = m_trCoeff[0] + sizeL;

-    m_trCoeff[2] = m_trCoeff[0] + sizeL + sizeC;

+    if (csp == X265_CSP_I400)

+    {

+        /* Each CU's data is layed out sequentially within the charMemBlock */

+        uint8_t *charBuf = dataPool.charMemBlock + (m_numPartitions * (BytesPerPartition - 4)) * instance;

+

+        m_qp        = (int8_t*)charBuf; charBuf += m_numPartitions;

+        m_log2CUSize         = charBuf; charBuf += m_numPartitions;

+        m_lumaIntraDir       = charBuf; charBuf += m_numPartitions;

+        m_tqBypass           = charBuf; charBuf += m_numPartitions;

+        m_refIdx[0] = (int8_t*)charBuf; charBuf += m_numPartitions;

+        m_refIdx[1] = (int8_t*)charBuf; charBuf += m_numPartitions;

+        m_cuDepth            = charBuf; charBuf += m_numPartitions;

+        m_predMode           = charBuf; charBuf += m_numPartitions; /* the order up to here is important in initCTU() and initSubCU() */

+        m_partSize           = charBuf; charBuf += m_numPartitions;

+        m_mergeFlag          = charBuf; charBuf += m_numPartitions;

+        m_interDir           = charBuf; charBuf += m_numPartitions;

+        m_mvpIdx[0]          = charBuf; charBuf += m_numPartitions;

+        m_mvpIdx[1]          = charBuf; charBuf += m_numPartitions;

+        m_tuDepth            = charBuf; charBuf += m_numPartitions;

+        m_transformSkip[0]   = charBuf; charBuf += m_numPartitions;

+        m_cbf[0]             = charBuf; charBuf += m_numPartitions;

+        m_chromaIntraDir     = charBuf; charBuf += m_numPartitions;

+

+        X265_CHECK(charBuf == dataPool.charMemBlock + (m_numPartitions * (BytesPerPartition - 4)) * (instance + 1), "CU data layout is broken\n"); //BytesPerPartition

+

+        m_mv[0]  = dataPool.mvMemBlock + (instance * 4) * m_numPartitions;

+        m_mv[1]  = m_mv[0] +  m_numPartitions;

+        m_mvd[0] = m_mv[1] +  m_numPartitions;

+        m_mvd[1] = m_mvd[0] + m_numPartitions;

+

+        uint32_t cuSize = g_maxCUSize >> depth;

+        m_trCoeff[0] = dataPool.trCoeffMemBlock + instance * (cuSize * cuSize);

+        m_trCoeff[1] = m_trCoeff[2] = 0;

+        m_transformSkip[1] = m_transformSkip[2] = m_cbf[1] = m_cbf[2] = 0;

+    }

+    else

+    {

+        /* Each CU's data is layed out sequentially within the charMemBlock */

+        uint8_t *charBuf = dataPool.charMemBlock + (m_numPartitions * BytesPerPartition) * instance;

+

+        m_qp        = (int8_t*)charBuf; charBuf += m_numPartitions;

+        m_log2CUSize         = charBuf; charBuf += m_numPartitions;

+        m_lumaIntraDir       = charBuf; charBuf += m_numPartitions;

+        m_tqBypass           = charBuf; charBuf += m_numPartitions;

+        m_refIdx[0] = (int8_t*)charBuf; charBuf += m_numPartitions;

+        m_refIdx[1] = (int8_t*)charBuf; charBuf += m_numPartitions;

+        m_cuDepth            = charBuf; charBuf += m_numPartitions;

+        m_predMode           = charBuf; charBuf += m_numPartitions; /* the order up to here is important in initCTU() and initSubCU() */

+        m_partSize           = charBuf; charBuf += m_numPartitions;

+        m_mergeFlag          = charBuf; charBuf += m_numPartitions;

+        m_interDir           = charBuf; charBuf += m_numPartitions;

+        m_mvpIdx[0]          = charBuf; charBuf += m_numPartitions;

+        m_mvpIdx[1]          = charBuf; charBuf += m_numPartitions;

+        m_tuDepth            = charBuf; charBuf += m_numPartitions;

+        m_transformSkip[0]   = charBuf; charBuf += m_numPartitions;

+        m_transformSkip[1]   = charBuf; charBuf += m_numPartitions;

+        m_transformSkip[2]   = charBuf; charBuf += m_numPartitions;

+        m_cbf[0]             = charBuf; charBuf += m_numPartitions;

+        m_cbf[1]             = charBuf; charBuf += m_numPartitions;

+        m_cbf[2]             = charBuf; charBuf += m_numPartitions;

+        m_chromaIntraDir     = charBuf; charBuf += m_numPartitions;

+

+        X265_CHECK(charBuf == dataPool.charMemBlock + (m_numPartitions * BytesPerPartition) * (instance + 1), "CU data layout is broken\n");

+

+        m_mv[0]  = dataPool.mvMemBlock + (instance * 4) * m_numPartitions;

+        m_mv[1]  = m_mv[0] +  m_numPartitions;

+        m_mvd[0] = m_mv[1] +  m_numPartitions;

+        m_mvd[1] = m_mvd[0] + m_numPartitions;

+

+        uint32_t cuSize = g_maxCUSize >> depth;

+        uint32_t sizeL = cuSize * cuSize;

+        uint32_t sizeC = sizeL >> (m_hChromaShift + m_vChromaShift); // block chroma part

+        m_trCoeff[0] = dataPool.trCoeffMemBlock + instance * (sizeL + sizeC * 2);

+        m_trCoeff[1] = m_trCoeff[0] + sizeL;

+        m_trCoeff[2] = m_trCoeff[0] + sizeL + sizeC;

+    }

 }

 void CUData::initCTU(const Frame& frame, uint32_t cuAddr, int qp)

@@ -245,7 +284,8 @@

     /* sequential memsets */

     m_partSet((uint8_t*)m_qp, (uint8_t)qp);

     m_partSet(m_log2CUSize,   (uint8_t)g_maxLog2CUSize);

-    m_partSet(m_lumaIntraDir, (uint8_t)DC_IDX);

+    m_partSet(m_lumaIntraDir, (uint8_t)ALL_IDX);

+    m_partSet(m_chromaIntraDir, (uint8_t)ALL_IDX);

     m_partSet(m_tqBypass,     (uint8_t)frame.m_encData->m_param->bLossless);

     if (m_slice->m_sliceType != I_SLICE)

     {

@@ -256,7 +296,7 @@

     X265_CHECK(!(frame.m_encData->m_param->bLossless && !m_slice->m_pps->bTransquantBypassEnabled), "lossless enabled without TQbypass in PPS\n");

     /* initialize the remaining CU data in one memset */

-    memset(m_cuDepth, 0, (BytesPerPartition - 6) * m_numPartitions);

+    memset(m_cuDepth, 0, (frame.m_param->internalCsp == X265_CSP_I400 ? BytesPerPartition - 11 : BytesPerPartition - 7) * m_numPartitions);

     uint32_t widthInCU = m_slice->m_sps->numCuInWidth;

     m_cuLeft = (m_cuAddr % widthInCU) ? m_encData->getPicCTU(m_cuAddr - 1) : NULL;

@@ -283,14 +323,15 @@

     m_partSet((uint8_t*)m_qp, (uint8_t)qp);

     m_partSet(m_log2CUSize,   (uint8_t)cuGeom.log2CUSize);

-    m_partSet(m_lumaIntraDir, (uint8_t)DC_IDX);

+    m_partSet(m_lumaIntraDir, (uint8_t)ALL_IDX);

+    m_partSet(m_chromaIntraDir, (uint8_t)ALL_IDX);

     m_partSet(m_tqBypass,     (uint8_t)m_encData->m_param->bLossless);

     m_partSet((uint8_t*)m_refIdx[0], (uint8_t)REF_NOT_VALID);

     m_partSet((uint8_t*)m_refIdx[1], (uint8_t)REF_NOT_VALID);

     m_partSet(m_cuDepth,      (uint8_t)cuGeom.depth);

     /* initialize the remaining CU data in one memset */

-    memset(m_predMode, 0, (BytesPerPartition - 7) * m_numPartitions);

+    memset(m_predMode, 0, (ctu.m_chromaFormat == X265_CSP_I400 ? BytesPerPartition - 12 : BytesPerPartition - 8) * m_numPartitions);

 }

 /* Copy the results of a sub-part (split) CU to the parent CU */

@@ -314,13 +355,9 @@

     m_subPartCopy(m_mvpIdx[0] + offset, subCU.m_mvpIdx[0]);

     m_subPartCopy(m_mvpIdx[1] + offset, subCU.m_mvpIdx[1]);

     m_subPartCopy(m_tuDepth + offset, subCU.m_tuDepth);

+

     m_subPartCopy(m_transformSkip[0] + offset, subCU.m_transformSkip[0]);

-    m_subPartCopy(m_transformSkip[1] + offset, subCU.m_transformSkip[1]);

-    m_subPartCopy(m_transformSkip[2] + offset, subCU.m_transformSkip[2]);

     m_subPartCopy(m_cbf[0] + offset, subCU.m_cbf[0]);

-    m_subPartCopy(m_cbf[1] + offset, subCU.m_cbf[1]);

-    m_subPartCopy(m_cbf[2] + offset, subCU.m_cbf[2]);

-    m_subPartCopy(m_chromaIntraDir + offset, subCU.m_chromaIntraDir);

     memcpy(m_mv[0] + offset, subCU.m_mv[0], childGeom.numPartitions * sizeof(MV));

     memcpy(m_mv[1] + offset, subCU.m_mv[1], childGeom.numPartitions * sizeof(MV));

@@ -329,12 +366,21 @@

     uint32_t tmp = 1 << ((g_maxLog2CUSize - childGeom.depth) * 2);

     uint32_t tmp2 = subPartIdx * tmp;

-    memcpy(m_trCoeff[0] + tmp2, subCU.m_trCoeff[0], sizeof(coeff_t) * tmp);

+    memcpy(m_trCoeff[0] + tmp2, subCU.m_trCoeff[0], sizeof(coeff_t)* tmp);

-    uint32_t tmpC = tmp >> (m_hChromaShift + m_vChromaShift);

-    uint32_t tmpC2 = tmp2 >> (m_hChromaShift + m_vChromaShift);

-    memcpy(m_trCoeff[1] + tmpC2, subCU.m_trCoeff[1], sizeof(coeff_t) * tmpC);

-    memcpy(m_trCoeff[2] + tmpC2, subCU.m_trCoeff[2], sizeof(coeff_t) * tmpC);

+    if (subCU.m_chromaFormat != X265_CSP_I400)

+    {

+        m_subPartCopy(m_transformSkip[1] + offset, subCU.m_transformSkip[1]);

+        m_subPartCopy(m_transformSkip[2] + offset, subCU.m_transformSkip[2]);

+        m_subPartCopy(m_cbf[1] + offset, subCU.m_cbf[1]);

+        m_subPartCopy(m_cbf[2] + offset, subCU.m_cbf[2]);

+        m_subPartCopy(m_chromaIntraDir + offset, subCU.m_chromaIntraDir);

+

​

@@ -222,12 +222,12 @@

     void     copyToPic(uint32_t depth) const;

     /* RD-0 methods called only from encodeResidue */

-    void     copyFromPic(const CUData& ctu, const CUGeom& cuGeom);

+    void     copyFromPic(const CUData& ctu, const CUGeom& cuGeom, int csp);

     void     updatePic(uint32_t depth) const;

     void     setPartSizeSubParts(PartSize size)    { m_partSet(m_partSize, (uint8_t)size); }

     void     setPredModeSubParts(PredMode mode)    { m_partSet(m_predMode, (uint8_t)mode); }

-    void     clearCbf()                            { m_partSet(m_cbf[0], 0); m_partSet(m_cbf[1], 0); m_partSet(m_cbf[2], 0); }

+    void     clearCbf()                            { m_partSet(m_cbf[0], 0); if (m_chromaFormat != X265_CSP_I400) { m_partSet(m_cbf[1], 0); m_partSet(m_cbf[2], 0);} }

     /* these functions all take depth as an absolute depth from CTU, it is used to calculate the number of parts to copy */

     void     setQPSubParts(int8_t qp, uint32_t absPartIdx, uint32_t depth)                    { s_partSet[depth]((uint8_t*)m_qp + absPartIdx, (uint8_t)qp); }

@@ -246,7 +246,7 @@

     void     setPURefIdx(int list, int8_t refIdx, int absPartIdx, int puIdx);

     uint8_t  getCbf(uint32_t absPartIdx, TextType ttype, uint32_t tuDepth) const { return (m_cbf[ttype][absPartIdx] >> tuDepth) & 0x1; }

-    uint8_t  getQtRootCbf(uint32_t absPartIdx) const                             { return m_cbf[0][absPartIdx] || m_cbf[1][absPartIdx] || m_cbf[2][absPartIdx]; }

+    uint8_t  getQtRootCbf(uint32_t absPartIdx) const                             { if (m_chromaFormat == X265_CSP_I400) return m_cbf[0][absPartIdx] || false; else { return m_cbf[0][absPartIdx] || m_cbf[1][absPartIdx] || m_cbf[2][absPartIdx];} }

     int8_t   getRefQP(uint32_t currAbsIdxInCTU) const;

     uint32_t getInterMergeCandidates(uint32_t absPartIdx, uint32_t puIdx, MVField (*candMvField)[2], uint8_t* candDir) const;

     void     clipMv(MV& outMV) const;

@@ -323,7 +323,6 @@

     const uint16_t *scan;

     const uint16_t *scanCG;

     ScanType        scanType;

-    uint32_t        log2TrSizeCG;

     uint32_t        firstSignificanceMapContext;

 };

@@ -340,8 +339,15 @@

         uint32_t numPartition = NUM_4x4_PARTITIONS >> (depth * 2);

         uint32_t cuSize = g_maxCUSize >> depth;

         uint32_t sizeL = cuSize * cuSize;

-        uint32_t sizeC = sizeL >> (CHROMA_H_SHIFT(csp) + CHROMA_V_SHIFT(csp));

-        CHECKED_MALLOC(trCoeffMemBlock, coeff_t, (sizeL + sizeC * 2) * numInstances);

+        if (csp == X265_CSP_I400)

+        {

+            CHECKED_MALLOC(trCoeffMemBlock, coeff_t, (sizeL) * numInstances);

+        }

+        else

+        {            

+            uint32_t sizeC = sizeL >> (CHROMA_H_SHIFT(csp) + CHROMA_V_SHIFT(csp));

+            CHECKED_MALLOC(trCoeffMemBlock, coeff_t, (sizeL + sizeC * 2) * numInstances);

+        }

         CHECKED_MALLOC(charMemBlock, uint8_t, numPartition * numInstances * CUData::BytesPerPartition);

         CHECKED_MALLOC(mvMemBlock, MV, numPartition * 4 * numInstances);

         return true;

​

@@ -703,7 +703,10 @@

         if (level)

             ++numSig;

         level *= sign;

-        qCoef[blockpos] = (int16_t)x265_clip3(-32768, 32767, level);

+

+        // TODO: when we limit range to [-32767, 32767], we can get more performance with output change

+        //       But nquant is a little percent in rdoQuant, so I keep old dynamic range for compatible

+        qCoef[blockpos] = (int16_t)abs(x265_clip3(-32768, 32767, level));

     }

     return numSig;

@@ -784,11 +787,12 @@

     return scanPosLast - 1;

 }

+// NOTE: no defined value on lastNZPosInCG & absSumSign when ALL ZEROS block as input

 static uint32_t findPosFirstLast_c(const int16_t *dstCoeff, const intptr_t trSize, const uint16_t scanTbl[16])

 {

     int n;

-    for (n = SCAN_SET_SIZE - 1; n >= 0; --n)

+    for (n = SCAN_SET_SIZE - 1; n >= 0; n--)

     {

         const uint32_t idx = scanTbl[n];

         const uint32_t idxY = idx / MLS_CG_SIZE;

@@ -812,8 +816,17 @@

     uint32_t firstNZPosInCG = (uint32_t)n;

+    uint32_t absSumSign = 0;

+    for (n = firstNZPosInCG; n <= (int)lastNZPosInCG; n++)

+    {

+        const uint32_t idx = scanTbl[n];

+        const uint32_t idxY = idx / MLS_CG_SIZE;

+        const uint32_t idxX = idx % MLS_CG_SIZE;

+        absSumSign += dstCoeff[idxY * trSize + idxX];

+    }

+

     // NOTE: when coeff block all ZERO, the lastNZPosInCG is undefined and firstNZPosInCG is 16

-    return ((lastNZPosInCG << 16) | firstNZPosInCG);

+    return ((absSumSign << 31) | (lastNZPosInCG << 8) | firstNZPosInCG);

 }

​

@@ -2,6 +2,7 @@

 * Copyright (C) 2013 x265 project

 *

 * Author: Gopu Govindaswamy <gopu@multicorewareinc.com>

+*         Min Chen <chenm003@163.com>

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

@@ -108,7 +109,7 @@

     for (uint32_t e = 0; e < numUnits; e += partIdxIncr)

     {

         edgeFilterLuma(cu, absPartIdx, depth, dir, e, blockStrength);

-        if (!((e0 + e) & chromaMask))

+        if (!((e0 + e) & chromaMask) && cu->m_chromaFormat != X265_CSP_I400)

             edgeFilterChroma(cu, absPartIdx, depth, dir, e, blockStrength);

     }

 }

@@ -209,8 +210,8 @@

     const Slice* const sliceQ = cuQ->m_slice;

     const Slice* const sliceP = cuP->m_slice;

-    const Frame* refP0 = sliceP->getRefPic(0, cuP->m_refIdx[0][partP]);

-    const Frame* refQ0 = sliceQ->getRefPic(0, cuQ->m_refIdx[0][partQ]);

+    const Frame* refP0 = sliceP->m_refFrameList[0][cuP->m_refIdx[0][partP]];

+    const Frame* refQ0 = sliceQ->m_refFrameList[0][cuQ->m_refIdx[0][partQ]];

     const MV& mvP0 = refP0 ? cuP->m_mv[0][partP] : zeroMv;

     const MV& mvQ0 = refQ0 ? cuQ->m_mv[0][partQ] : zeroMv;

@@ -221,8 +222,8 @@

     }

     // (sliceQ->isInterB() || sliceP->isInterB())

-    const Frame* refP1 = sliceP->getRefPic(1, cuP->m_refIdx[1][partP]);

-    const Frame* refQ1 = sliceQ->getRefPic(1, cuQ->m_refIdx[1][partQ]);

+    const Frame* refP1 = sliceP->m_refFrameList[1][cuP->m_refIdx[1][partP]];

+    const Frame* refQ1 = sliceQ->m_refFrameList[1][cuQ->m_refIdx[1][partQ]];

     const MV& mvP1 = refP1 ? cuP->m_mv[1][partP] : zeroMv;

     const MV& mvQ1 = refQ1 ? cuQ->m_mv[1][partQ] : zeroMv;

@@ -279,31 +280,6 @@

  * \param maskQ   indicator to enable filtering on partQ

  * \param maskP1  decision weak filter/no filter for partP

  * \param maskQ1  decision weak filter/no filter for partQ */

-static inline void pelFilterLumaStrong(pixel* src, intptr_t srcStep, intptr_t offset, int32_t tc, int32_t maskP, int32_t maskQ)

-{

-    int32_t tc2 = 2 * tc;

-    int32_t tcP = (tc2 & maskP);

-    int32_t tcQ = (tc2 & maskQ);

-    for (int32_t i = 0; i < UNIT_SIZE; i++, src += srcStep)

-    {

-        int16_t m4  = (int16_t)src[0];

-        int16_t m3  = (int16_t)src[-offset];

-        int16_t m5  = (int16_t)src[offset];

-        int16_t m2  = (int16_t)src[-offset * 2];

-        int16_t m6  = (int16_t)src[offset * 2];

-        int16_t m1  = (int16_t)src[-offset * 3];

-        int16_t m7  = (int16_t)src[offset * 3];

-        int16_t m0  = (int16_t)src[-offset * 4];

-        src[-offset * 3] = (pixel)(x265_clip3(-tcP, tcP, ((2 * m0 + 3 * m1 + m2 + m3 + m4 + 4) >> 3) - m1) + m1);

-        src[-offset * 2] = (pixel)(x265_clip3(-tcP, tcP, ((m1 + m2 + m3 + m4 + 2) >> 2) - m2) + m2);

-        src[-offset]     = (pixel)(x265_clip3(-tcP, tcP, ((m1 + 2 * m2 + 2 * m3 + 2 * m4 + m5 + 4) >> 3) - m3) + m3);

-        src[0]           = (pixel)(x265_clip3(-tcQ, tcQ, ((m2 + 2 * m3 + 2 * m4 + 2 * m5 + m6 + 4) >> 3) - m4) + m4);

-        src[offset]      = (pixel)(x265_clip3(-tcQ, tcQ, ((m3 + m4 + m5 + m6 + 2) >> 2) - m5) + m5);

-        src[offset * 2]  = (pixel)(x265_clip3(-tcQ, tcQ, ((m3 + m4 + m5 + 3 * m6 + 2 * m7 + 4) >> 3) - m6) + m6);

-    }

-}

-

-/* Weak filter */

 static inline void pelFilterLuma(pixel* src, intptr_t srcStep, intptr_t offset, int32_t tc, int32_t maskP, int32_t maskQ,

                                  int32_t maskP1, int32_t maskQ1)

 {

@@ -445,7 +421,12 @@

                    useStrongFiltering(offset, beta, tc, src + unitOffset + srcStep * 3));

         if (sw)

-            pelFilterLumaStrong(src + unitOffset, srcStep, offset, tc, maskP, maskQ);

+        {

+            int32_t tc2 = 2 * tc;

+            int32_t tcP = (tc2 & maskP);

+            int32_t tcQ = (tc2 & maskQ);

+            primitives.pelFilterLumaStrong[dir](src + unitOffset, srcStep, offset, tcP, tcQ);

+        }

         else

         {

             int32_t sideThreshold = (beta + (beta >> 1)) >> 3;

​

@@ -2,6 +2,7 @@

 * Copyright (C) 2013 x265 project

 *

 * Author: Gopu Govindaswamy <gopu@multicorewareinc.com>

+*         Min Chen <chenm003@163.com>

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

@@ -37,24 +38,24 @@

 public:

     enum { EDGE_VER, EDGE_HOR };

-    void deblockCTU(const CUData* ctu, const CUGeom& cuGeom, int32_t dir);

+    static void deblockCTU(const CUData* ctu, const CUGeom& cuGeom, int32_t dir);

 protected:

     // CU-level deblocking function

-    void deblockCU(const CUData* cu, const CUGeom& cuGeom, const int32_t dir, uint8_t blockStrength[]);

+    static void deblockCU(const CUData* cu, const CUGeom& cuGeom, const int32_t dir, uint8_t blockStrength[]);

     // set filtering functions

-    void setEdgefilterTU(const CUData* cu, uint32_t absPartIdx, uint32_t tuDepth, int32_t dir, uint8_t blockStrength[]);

-    void setEdgefilterPU(const CUData* cu, uint32_t absPartIdx, int32_t dir, uint8_t blockStrength[], uint32_t numUnits);

-    void setEdgefilterMultiple(const CUData* cu, uint32_t absPartIdx, int32_t dir, int32_t edgeIdx, uint8_t value, uint8_t blockStrength[], uint32_t numUnits);

+    static void setEdgefilterTU(const CUData* cu, uint32_t absPartIdx, uint32_t tuDepth, int32_t dir, uint8_t blockStrength[]);

+    static void setEdgefilterPU(const CUData* cu, uint32_t absPartIdx, int32_t dir, uint8_t blockStrength[], uint32_t numUnits);

+    static void setEdgefilterMultiple(const CUData* cu, uint32_t absPartIdx, int32_t dir, int32_t edgeIdx, uint8_t value, uint8_t blockStrength[], uint32_t numUnits);

     // get filtering functions

-    uint8_t getBoundaryStrength(const CUData* cuQ, int32_t dir, uint32_t partQ, const uint8_t blockStrength[]);

+    static uint8_t getBoundaryStrength(const CUData* cuQ, int32_t dir, uint32_t partQ, const uint8_t blockStrength[]);

     // filter luma/chroma functions

-    void edgeFilterLuma(const CUData* cuQ, uint32_t absPartIdx, uint32_t depth, int32_t dir, int32_t edge, const uint8_t blockStrength[]);

-    void edgeFilterChroma(const CUData* cuQ, uint32_t absPartIdx, uint32_t depth, int32_t dir, int32_t edge, const uint8_t blockStrength[]);

+    static void edgeFilterLuma(const CUData* cuQ, uint32_t absPartIdx, uint32_t depth, int32_t dir, int32_t edge, const uint8_t blockStrength[]);

+    static void edgeFilterChroma(const CUData* cuQ, uint32_t absPartIdx, uint32_t depth, int32_t dir, int32_t edge, const uint8_t blockStrength[]);

     static const uint8_t s_tcTable[54];

     static const uint8_t s_betaTable[52];

​

@@ -33,22 +33,37 @@

     m_bChromaExtended = false;

     m_lowresInit = false;

     m_reconRowCount.set(0);

+    m_reconColCount = NULL;

     m_countRefEncoders = 0;

     m_encData = NULL;

     m_reconPic = NULL;

+    m_quantOffsets = NULL;

     m_next = NULL;

     m_prev = NULL;

     m_param = NULL;

     memset(&m_lowres, 0, sizeof(m_lowres));

 }

-bool Frame::create(x265_param *param)

+bool Frame::create(x265_param *param, float* quantOffsets)

 {

     m_fencPic = new PicYuv;

     m_param = param;

-    return m_fencPic->create(param->sourceWidth, param->sourceHeight, param->internalCsp) &&

-           m_lowres.create(m_fencPic, param->bframes, !!param->rc.aqMode);

+    if (m_fencPic->create(param->sourceWidth, param->sourceHeight, param->internalCsp) &&

+        m_lowres.create(m_fencPic, param->bframes, !!param->rc.aqMode))

+    {

+        X265_CHECK((m_reconColCount == NULL), "m_reconColCount was initialized");

+        m_numRows = (m_fencPic->m_picHeight + g_maxCUSize - 1)  / g_maxCUSize;

+        m_reconColCount = new ThreadSafeInteger[m_numRows];

+

+        if (quantOffsets)

+        {

+            int32_t cuCount = m_lowres.maxBlocksInRow * m_lowres.maxBlocksInCol;

+            m_quantOffsets = new float[cuCount];

+        }

+        return true;

+    }

+    return false;

 }