@@ -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 @@

 .. option:: --lookahead-slices <0..16>

-   Use multiple worker threads to measure the estimated cost of each

-   frame within the lookahead. When :option:`--b-adapt` is 2, most

-   frame cost estimates will be performed in batch mode, many cost

-   estimates at the same time, and lookahead-slices is ignored for

-   batched estimates. The effect on performance can be quite small.

-   The higher this parameter, the less accurate the frame costs will be

-   (since context is lost across slice boundaries) which will result in

-   less accurate B-frame and scene-cut decisions.

-

-   The encoder may internally lower the number of slices to ensure

-   each slice codes at least 10 16x16 rows of lowres blocks. If slices

-   are used in lookahead, they are logged in the list of tools as

-   *lslices*.

-   

-   **Values:** 0 - disabled (default). 1 is the same as 0. Max 16

+   Use multiple worker threads to measure the estimated cost of each frame

+   within the lookahead. The frame is divided into the specified number of

+   slices, and one-thread is launched  per slice. When :option:`--b-adapt` is

+   2, most frame cost estimates will be performed in batch mode (many cost

+   estimates at the same time) and lookahead-slices is ignored for batched

+   estimates; it may still be used for single cost estimations. The higher this

+   parameter, the less accurate the frame costs will be (since context is lost

+   across slice boundaries) which will result in less accurate B-frame and

+   scene-cut decisions. The effect on performance can be significant especially

+   on systems with many threads.

+

+   The encoder may internally lower the number of slices or disable

+    slicing to ensure each slice codes at least 10 16x16 rows of lowres

+    blocks to minimize the impact on quality. For example, for 720p and

+    1080p videos, the number of slices is capped to 4 and 6, respectively.

+    For resolutions lesser than 720p, slicing is auto-disabled.

+        

+    If slices are used in lookahead, they are logged in the list of tools

+    as *lslices*

+

+   **Values:** 0 - disabled. 1 is the same as 0. Max 16.

+    Default: 8 for ultrafast, superfast, faster, fast, medium

+             4 for slow, slower

+             disabled for veryslow, slower

+

 .. option:: --b-adapt <integer>

@@ -1198,6 +1234,13 @@

    is also non-zero. Both vbv-bufsize and vbv-maxrate are required to

    enable VBV in CRF mode. Default 0 (disabled)

+   Note that when VBV is enabled (with a valid :option:`--vbv-bufsize`),

+   VBV emergency denoising is turned on. This will turn on aggressive 

+   denoising at the frame level when frame QP > QP_MAX_SPEC (51), drastically

+   reducing bitrate and allowing ratecontrol to assign lower QPs for

+   the following frames. The visual effect is blurring, but removes 

+   significant blocking/displacement artifacts.

+

 .. option:: --vbv-init <float>

    Initial buffer occupancy. The portion of the decode buffer which

@@ -1405,10 +1448,11 @@

    framenumber frametype QP

-   Frametype can be one of [I,i,P,B,b]. **B** is a referenced B frame,

+   Frametype can be one of [I,i,K,P,B,b]. **B** is a referenced B frame,

    **b** is an unreferenced B frame.  **I** is a keyframe (random

-   access point) while **i** is a I frame that is not a keyframe

-   (references are not broken).

+   access point) while **i** is an I frame that is not a keyframe

+   (references are not broken). **K** implies **I** if closed_gop option

+   is enabled, and **i** otherwise.

    Specifying QP (integer) is optional, and if specified they are

    clamped within the encoder to qpmin/qpmax.

@@ -1551,7 +1595,7 @@

 .. option:: --colorprim <integer|string>

-   Specify color primitive to use when converting to RGB. Default

+   Specify color primaries to use when converting to RGB. Default

    undefined (not signaled)

    1. bt709

@@ -1621,7 +1665,7 @@

    Example for D65P3 1000-nits:

-       G(13200,34500)B(7500,3000)R(34000,16000)WP(15635,16450)L(10000000,1)

+       G(13250,34500)B(7500,3000)R(34000,16000)WP(15635,16450)L(10000000,1)

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

    protect against shell expansion on many platforms. No default.

@@ -1640,6 +1684,16 @@

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

    protect against shell expansion on many platforms. No default.

+.. option:: --min-luma <integer>

+

+   Minimum luma value allowed for input pictures. Any values below min-luma

+   are clipped. Experimental. No default.

+

+.. option:: --max-luma <integer>

+

+   Maximum luma value allowed for input pictures. Any values above max-luma

+   are clipped. Experimental. No default.

+

 Bitstream options

 =================

​

@@ -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);

+

+        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 a sub-CU part is not present (off the edge of the picture) its depth and

@@ -374,12 +420,17 @@

     /* clear residual coding flags */

     m_partSet(m_predMode, cu.m_predMode[0] & (MODE_INTRA | MODE_INTER));

     m_partSet(m_tuDepth, 0);

-    m_partSet(m_transformSkip[0], 0);

-    m_partSet(m_transformSkip[1], 0);

-    m_partSet(m_transformSkip[2], 0);

     m_partSet(m_cbf[0], 0);

-    m_partSet(m_cbf[1], 0);

-    m_partSet(m_cbf[2], 0);

+    m_partSet(m_transformSkip[0], 0);

+

+    if (cu.m_chromaFormat != X265_CSP_I400)

+    {

+        m_partSet(m_chromaIntraDir, (uint8_t)ALL_IDX);

+        m_partSet(m_cbf[1], 0);

+        m_partSet(m_cbf[2], 0);

+        m_partSet(m_transformSkip[1], 0);

+        m_partSet(m_transformSkip[2], 0);

+    }

 }

 /* Copy completed predicted CU to CTU in picture */

@@ -402,30 +453,34 @@

     m_partCopy(ctu.m_mvpIdx[1] + m_absIdxInCTU, m_mvpIdx[1]);

     m_partCopy(ctu.m_tuDepth + m_absIdxInCTU, m_tuDepth);

     m_partCopy(ctu.m_transformSkip[0] + m_absIdxInCTU, m_transformSkip[0]);

-    m_partCopy(ctu.m_transformSkip[1] + m_absIdxInCTU, m_transformSkip[1]);

-    m_partCopy(ctu.m_transformSkip[2] + m_absIdxInCTU, m_transformSkip[2]);

     m_partCopy(ctu.m_cbf[0] + m_absIdxInCTU, m_cbf[0]);

-    m_partCopy(ctu.m_cbf[1] + m_absIdxInCTU, m_cbf[1]);

-    m_partCopy(ctu.m_cbf[2] + m_absIdxInCTU, m_cbf[2]);

-    m_partCopy(ctu.m_chromaIntraDir + m_absIdxInCTU, m_chromaIntraDir);

-    memcpy(ctu.m_mv[0] + m_absIdxInCTU,  m_mv[0],  m_numPartitions * sizeof(MV));

-    memcpy(ctu.m_mv[1] + m_absIdxInCTU,  m_mv[1],  m_numPartitions * sizeof(MV));

+    memcpy(ctu.m_mv[0] + m_absIdxInCTU, m_mv[0], m_numPartitions * sizeof(MV));

+    memcpy(ctu.m_mv[1] + m_absIdxInCTU, m_mv[1], m_numPartitions * sizeof(MV));

     memcpy(ctu.m_mvd[0] + m_absIdxInCTU, m_mvd[0], m_numPartitions * sizeof(MV));

     memcpy(ctu.m_mvd[1] + m_absIdxInCTU, m_mvd[1], m_numPartitions * sizeof(MV));

     uint32_t tmpY = 1 << ((g_maxLog2CUSize - depth) * 2);

     uint32_t tmpY2 = m_absIdxInCTU << (LOG2_UNIT_SIZE * 2);

-    memcpy(ctu.m_trCoeff[0] + tmpY2, m_trCoeff[0], sizeof(coeff_t) * tmpY);

+    memcpy(ctu.m_trCoeff[0] + tmpY2, m_trCoeff[0], sizeof(coeff_t)* tmpY);

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

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

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

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

+    if (ctu.m_chromaFormat != X265_CSP_I400)

+    {

+        m_partCopy(ctu.m_transformSkip[1] + m_absIdxInCTU, m_transformSkip[1]);

+        m_partCopy(ctu.m_transformSkip[2] + m_absIdxInCTU, m_transformSkip[2]);

+        m_partCopy(ctu.m_cbf[1] + m_absIdxInCTU, m_cbf[1]);

+        m_partCopy(ctu.m_cbf[2] + m_absIdxInCTU, m_cbf[2]);

+        m_partCopy(ctu.m_chromaIntraDir + m_absIdxInCTU, m_chromaIntraDir);

+

+        uint32_t tmpC = tmpY >> (m_hChromaShift + m_vChromaShift);

+        uint32_t tmpC2 = tmpY2 >> (m_hChromaShift + m_vChromaShift);

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

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

+    }

 }

 /* The reverse of copyToPic, called only by encodeResidue */

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

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

 {

     m_encData       = ctu.m_encData;

     m_slice         = ctu.m_slice;

@@ -451,19 +506,23 @@

     m_partCopy(m_mvpIdx[1],    ctu.m_mvpIdx[1] + m_absIdxInCTU);

     m_partCopy(m_chromaIntraDir, ctu.m_chromaIntraDir + m_absIdxInCTU);

-    memcpy(m_mv[0],  ctu.m_mv[0] + m_absIdxInCTU,  m_numPartitions * sizeof(MV));

-    memcpy(m_mv[1],  ctu.m_mv[1] + m_absIdxInCTU,  m_numPartitions * sizeof(MV));

+    memcpy(m_mv[0], ctu.m_mv[0] + m_absIdxInCTU, m_numPartitions * sizeof(MV));

+    memcpy(m_mv[1], ctu.m_mv[1] + m_absIdxInCTU, m_numPartitions * sizeof(MV));

     memcpy(m_mvd[0], ctu.m_mvd[0] + m_absIdxInCTU, m_numPartitions * sizeof(MV));

     memcpy(m_mvd[1], ctu.m_mvd[1] + m_absIdxInCTU, m_numPartitions * sizeof(MV));

     /* clear residual coding flags */

     m_partSet(m_tuDepth, 0);

     m_partSet(m_transformSkip[0], 0);

-    m_partSet(m_transformSkip[1], 0);

-    m_partSet(m_transformSkip[2], 0);

     m_partSet(m_cbf[0], 0);

-    m_partSet(m_cbf[1], 0);

-    m_partSet(m_cbf[2], 0);

+

+    if (csp != X265_CSP_I400)

+    {        

+        m_partSet(m_transformSkip[1], 0);

+        m_partSet(m_transformSkip[2], 0);

+        m_partSet(m_cbf[1], 0);

+        m_partSet(m_cbf[2], 0);

+    }

 }

 /* Only called by encodeResidue, these fields can be modified during inter/intra coding */

@@ -473,22 +532,28 @@

     m_partCopy((uint8_t*)ctu.m_qp + m_absIdxInCTU, (uint8_t*)m_qp);

     m_partCopy(ctu.m_transformSkip[0] + m_absIdxInCTU, m_transformSkip[0]);

-    m_partCopy(ctu.m_transformSkip[1] + m_absIdxInCTU, m_transformSkip[1]);

-    m_partCopy(ctu.m_transformSkip[2] + m_absIdxInCTU, m_transformSkip[2]);

     m_partCopy(ctu.m_predMode + m_absIdxInCTU, m_predMode);

     m_partCopy(ctu.m_tuDepth + m_absIdxInCTU, m_tuDepth);

     m_partCopy(ctu.m_cbf[0] + m_absIdxInCTU, m_cbf[0]);

-    m_partCopy(ctu.m_cbf[1] + m_absIdxInCTU, m_cbf[1]);

-    m_partCopy(ctu.m_cbf[2] + m_absIdxInCTU, m_cbf[2]);

-    m_partCopy(ctu.m_chromaIntraDir + m_absIdxInCTU, m_chromaIntraDir);

     uint32_t tmpY = 1 << ((g_maxLog2CUSize - depth) * 2);

     uint32_t tmpY2 = m_absIdxInCTU << (LOG2_UNIT_SIZE * 2);

-    memcpy(ctu.m_trCoeff[0] + tmpY2, m_trCoeff[0], sizeof(coeff_t) * tmpY);

-    tmpY  >>= m_hChromaShift + m_vChromaShift;

-    tmpY2 >>= m_hChromaShift + m_vChromaShift;

-    memcpy(ctu.m_trCoeff[1] + tmpY2, m_trCoeff[1], sizeof(coeff_t) * tmpY);

-    memcpy(ctu.m_trCoeff[2] + tmpY2, m_trCoeff[2], sizeof(coeff_t) * tmpY);

+    memcpy(ctu.m_trCoeff[0] + tmpY2, m_trCoeff[0], sizeof(coeff_t)* tmpY);

+

+    if (ctu.m_chromaFormat != X265_CSP_I400)

+    {

+        m_partCopy(ctu.m_transformSkip[1] + m_absIdxInCTU, m_transformSkip[1]);

+        m_partCopy(ctu.m_transformSkip[2] + m_absIdxInCTU, m_transformSkip[2]);

+

+        m_partCopy(ctu.m_cbf[1] + m_absIdxInCTU, m_cbf[1]);

+        m_partCopy(ctu.m_cbf[2] + m_absIdxInCTU, m_cbf[2]);

+        m_partCopy(ctu.m_chromaIntraDir + m_absIdxInCTU, m_chromaIntraDir);

+

+        tmpY  >>= m_hChromaShift + m_vChromaShift;

+        tmpY2 >>= m_hChromaShift + m_vChromaShift;

+        memcpy(ctu.m_trCoeff[1] + tmpY2, m_trCoeff[1], sizeof(coeff_t) * tmpY);

+        memcpy(ctu.m_trCoeff[2] + tmpY2, m_trCoeff[2], sizeof(coeff_t) * tmpY);

+    }

 }

 const CUData* CUData::getPULeft(uint32_t& lPartUnitIdx, uint32_t curPartUnitIdx) const

@@ -1676,7 +1741,7 @@

         if (tempRefIdx != -1)

         {

             uint32_t cuAddr = neighbours[MD_COLLOCATED].cuAddr[picList];

-            const Frame* colPic = m_slice->m_refPicList[m_slice->isInterB() && !m_slice->m_colFromL0Flag][m_slice->m_colRefIdx];

+            const Frame* colPic = m_slice->m_refFrameList[m_slice->isInterB() && !m_slice->m_colFromL0Flag][m_slice->m_colRefIdx];

             const CUData* colCU = colPic->m_encData->getPicCTU(cuAddr);

             // Scale the vector

@@ -1857,7 +1922,7 @@

 bool CUData::getColMVP(MV& outMV, int& outRefIdx, int picList, int cuAddr, int partUnitIdx) const

 {

-    const Frame* colPic = m_slice->m_refPicList[m_slice->isInterB() && !m_slice->m_colFromL0Flag][m_slice->m_colRefIdx];

+    const Frame* colPic = m_slice->m_refFrameList[m_slice->isInterB() && !m_slice->m_colFromL0Flag][m_slice->m_colRefIdx];

     const CUData* colCU = colPic->m_encData->getPicCTU(cuAddr);

     uint32_t absPartAddr = partUnitIdx & TMVP_UNIT_MASK;

@@ -1892,7 +1957,7 @@

 // Cache the collocated MV.

 bool CUData::getCollocatedMV(int cuAddr, int partUnitIdx, InterNeighbourMV *neighbour) const

 {

-    const Frame* colPic = m_slice->m_refPicList[m_slice->isInterB() && !m_slice->m_colFromL0Flag][m_slice->m_colRefIdx];

+    const Frame* colPic = m_slice->m_refFrameList[m_slice->isInterB() && !m_slice->m_colFromL0Flag][m_slice->m_colRefIdx];

     const CUData* colCU = colPic->m_encData->getPicCTU(cuAddr);

     uint32_t absPartAddr = partUnitIdx & TMVP_UNIT_MASK;

@@ -1951,7 +2016,7 @@

     bool bIsIntra = isIntra(absPartIdx);