@@ -1,4 +1,45 @@

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

+Fri May 29 09:11:02 UTC 2015 - aloisio@gmx.com

+

+- soname bump to 59

+- Update to version 1.7

+  * large amount of assembly code optimizations

+  * some preliminary support for high dynamic range content

+  * improvements for multi-library support

+  * some new quality features

+    (full documentation at: http://x265.readthedocs.org/en/1.7)

+  * This release simplifies the multi-library support introduced

+    in version 1.6. Any libx265 can now forward API requests to

+    other installed libx265 libraries (by name) so applications

+    like ffmpeg and the x265 CLI can select between 8bit and 10bit

+    encodes at runtime without the need of a shim library or

+    library load path hacks. See --output-depth, and

+    http://x265.readthedocs.org/en/1.7/api.html#multi-library-interface

+  * For quality, x265 now allows you to configure the quantization

+    group size smaller than the CTU size (for finer grained AQ

+    adjustments). See --qg-size.

+  * x265 now supports limited mid-encode reconfigure via a new public

+    method: x265_encoder_reconfig()

+  * For HDR, x265 now supports signaling the SMPTE 2084 color transfer

+    function, the SMPTE 2086 mastering display color primaries, and the

+    content light levels. See --master-display, --max-cll

+  * x265 will no longer emit any non-conformant bitstreams unless

+    --allow-non-conformance is specified.

+  * The x265 CLI now supports a simple encode preview feature. See

+    --recon-y4m-exec.

+  * The AnnexB NAL headers can now be configured off, via x265_param.bAnnexB

+    This is not configurable via the CLI because it is a function of the

+    muxer being used, and the CLI only supports raw output files. See

+    --annexb

+  Misc:

+  * --lossless encodes are now signaled as level 8.5

+  * --profile now has a -P short option

+  * The regression scripts used by x265 are now public, and can be found at:

+    https://bitbucket.org/sborho/test-harness

+  * x265's cmake scripts now support PGO builds, the test-harness can be

+    used to drive the profile-guided build process.

+

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

 Tue Apr 28 20:08:06 UTC 2015 - aloisio@gmx.com

 - soname bumped to 51

​

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

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

 Name:           x265

-%define soname  51

+%define soname  59

 %define libname lib%{name}

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

-Version:        1.6

+Version:        1.7

 Release:        0

 License:        GPL-2.0+

 Summary:        A free h265/HEVC encoder - encoder binary

​

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

-libx265-51

+libx265-59

​

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

 repo: 09fe40627f03a0f9c3e6ac78b22ac93da23f9fdf

-node: cbeb7d8a4880e4020c4545dd8e498432c3c6cad3

+node: 8425278def1edf0931dc33fc518e1950063e76b0

 branch: stable

-tag: 1.6

+tag: 1.7

​

@@ -14,3 +14,4 @@

 c1e4fc0162c14fdb84f5c3bd404fb28cfe10a17f 1.3

 5e604833c5aa605d0b6efbe5234492b5e7d8ac61 1.4

 9f0324125f53a12f766f6ed6f98f16e2f42337f4 1.5

+cbeb7d8a4880e4020c4545dd8e498432c3c6cad3 1.6

​

@@ -171,8 +171,26 @@

     *      how x265_encoder_open has changed the parameters.

     *      note that the data accessible through pointers in the returned param struct

     *      (e.g. filenames) should not be modified by the calling application. */

-   void x265_encoder_parameters(x265_encoder *, x265_param *);                                                                      

-

+   void x265_encoder_parameters(x265_encoder *, x265_param *);

+

+**x265_encoder_reconfig()** may be used to reconfigure encoder parameters mid-encode::

+

+   /* x265_encoder_reconfig:

+    *       used to modify encoder parameters.

+    *      various parameters from x265_param are copied.

+    *      this takes effect immediately, on whichever frame is encoded next;

+    *      returns 0 on success, negative on parameter validation error.

+    *

+    *      not all parameters can be changed; see the actual function for a

+    *      detailed breakdown.  since not all parameters can be changed, moving

+    *      from preset to preset may not always fully copy all relevant parameters,

+    *      but should still work usably in practice. however, more so than for

+    *      other presets, many of the speed shortcuts used in ultrafast cannot be

+    *      switched out of; using reconfig to switch between ultrafast and other

+    *      presets is not recommended without a more fine-grained breakdown of

+    *      parameters to take this into account. */

+   int x265_encoder_reconfig(x265_encoder *, x265_param *);

+   

 Pictures

 ========

@@ -352,7 +370,7 @@

 Multi-library Interface

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

-If your application might want to make a runtime selection between among

+If your application might want to make a runtime selection between

 a number of libx265 libraries (perhaps 8bpp and 16bpp), then you will

 want to use the multi-library interface.

@@ -370,13 +388,34 @@

      *   libx265 */

     const x265_api* x265_api_get(int bitDepth);

-The general idea is to request the API for the bitDepth you would prefer

-the encoder to use (8 or 10), and if that returns NULL you request the

-API for bitDepth=0, which returns the system default libx265.

-

 Note that using this multi-library API in your application is only the

-first step. Next your application must dynamically link to libx265 and

-then you must build and install a multi-lib configuration of libx265,

-which includes 8bpp and 16bpp builds of libx265 and a shim library which

-forwards x265_api_get() calls to the appropriate library using dynamic

-loading and binding.

+first step.

+

+Your application must link to one build of libx265 (statically or 

+dynamically) and this linked version of libx265 will support one 

+bit-depth (8 or 10 bits). 

+

+Your application must now request the API for the bitDepth you would 

+prefer the encoder to use (8 or 10). If the requested bitdepth is zero, 

+or if it matches the bitdepth of the system default libx265 (the 

+currently linked library), then this library will be used for encode.

+If you request a different bit-depth, the linked libx265 will attempt 

+to dynamically bind a shared library with a name appropriate for the 

+requested bit-depth:

+

+    8-bit:  libx265_main.dll

+    10-bit: libx265_main10.dll

+

+    (the shared library extension is obviously platform specific. On

+    Linux it is .so while on Mac it is .dylib)

+

+For example on Windows, one could package together an x265.exe

+statically linked against the 8bpp libx265 together with a

+libx265_main10.dll in the same folder, and this executable would be able

+to encode main and main10 bitstreams.

+

+On Linux, x265 packagers could install 8bpp static and shared libraries

+under the name libx265 (so all applications link against 8bpp libx265)

+and then also install libx265_main10.so (symlinked to its numbered solib).

+Thus applications which use x265_api_get() will be able to generate main

+or main10 bitstreams.

​

@@ -159,6 +159,13 @@

    handled implicitly.

    One may also directly supply the CPU capability bitmap as an integer.

+   

+   Note that by specifying this option you are overriding x265's CPU

+   detection and it is possible to do this wrong. You can cause encoder

+   crashes by specifying SIMD architectures which are not supported on

+   your CPU.

+

+   Default: auto-detected SIMD architectures

 .. option:: --frame-threads, -F <integer>

@@ -171,7 +178,7 @@

    Over-allocation of frame threads will not improve performance, it

    will generally just increase memory use.

-   **Values:** any value between 8 and 16. Default is 0, auto-detect

+   **Values:** any value between 0 and 16. Default is 0, auto-detect

 .. option:: --pools <string>, --numa-pools <string>

@@ -201,11 +208,11 @@

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

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

-   If the three pool features: :option:`--wpp` :option:`--pmode` and

-   :option:`--pme` are all disabled, then :option:`--pools` is ignored

-   and no thread pools are created.

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

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

+   then :option:`--pools` is ignored and no thread pools are created.

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

+   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

@@ -217,9 +224,22 @@

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

    distributed analysis and motion search.

+   On Windows, the native APIs offer sufficient functionality to

+   discover the NUMA topology and enforce the thread affinity that

+   libx265 needs (so long as you have not chosen to target XP or

+   Vista), but on POSIX systems it relies on libnuma for this

+   functionality. If your target POSIX system is single socket, then

+   building without libnuma is a perfectly reasonable option, as it

+   will have no effect on the runtime behavior. On a multiple-socket

+   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.

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

+   protect against shell expansion on many platforms

+

 .. option:: --wpp, --no-wpp

    Enable Wavefront Parallel Processing. The encoder may begin encoding

@@ -399,10 +419,20 @@

    **CLI ONLY**

+.. option:: --output-depth, -D 8|10

+

+   Bitdepth of output HEVC bitstream, which is also the internal bit

+   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, or libx265_main10 for a 10bit encoder, with the

+   same API version as the linked libx265.

+

+   **CLI ONLY**

+

 Profile, Level, Tier

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

-.. option:: --profile <string>

+.. option:: --profile, -P <string>

    Enforce the requirements of the specified profile, ensuring the

    output stream will be decodable by a decoder which supports that

@@ -437,7 +467,7 @@

    times 10, for example level **5.1** is specified as "5.1" or "51",

    and level **5.0** is specified as "5.0" or "50".

-   Annex A levels: 1, 2, 2.1, 3, 3.1, 4, 4.1, 5, 5.1, 5.2, 6, 6.1, 6.2

+   Annex A levels: 1, 2, 2.1, 3, 3.1, 4, 4.1, 5, 5.1, 5.2, 6, 6.1, 6.2, 8.5

 .. option:: --high-tier, --no-high-tier

@@ -464,11 +494,22 @@

    HEVC specification.  If x265 detects that the total reference count

    is greater than 8, it will issue a warning that the resulting stream

    is non-compliant and it signals the stream as profile NONE and level

-   NONE but still allows the encode to continue.  Compliant HEVC

+   NONE and will abort the encode unless

+   :option:`--allow-non-conformance` it specified.  Compliant HEVC

    decoders may refuse to decode such streams.

    Default 3

+.. option:: --allow-non-conformance, --no-allow-non-conformance

+

+   Allow libx265 to generate a bitstream with profile and level NONE.

+   By default it will abort any encode which does not meet strict level

+   compliance. The two most likely causes for non-conformance are

+   :option:`--ctu` being too small, :option:`--ref` being too high,

+   or the bitrate or resolution being out of specification.

+

+   Default: disabled

+

 .. note::

    :option:`--profile`, :option:`--level-idc`, and

    :option:`--high-tier` are only intended for use when you are

@@ -476,7 +517,7 @@

    limitations and must constrain the bitstream within those limits.

    Specifying a profile or level may lower the encode quality

    parameters to meet those requirements but it will never raise

-   them.

+   them. It may enable VBV constraints on a CRF encode.

 Mode decision / Analysis

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

@@ -1111,6 +1152,14 @@

    **Range of values:** 0.0 to 3.0

+.. option:: --qg-size <64|32|16>

+

+   Enable adaptive quantization for sub-CTUs. This parameter specifies 

+   the minimum CU size at which QP can be adjusted, ie. Quantization Group

+   size. Allowed range of values are 64, 32, 16 provided this falls within 

+   the inclusive range [maxCUSize, minCUSize]. Experimental.

+   Default: same as maxCUSize

+

 .. option:: --cutree, --no-cutree

    Enable the use of lookahead's lowres motion vector fields to

@@ -1162,12 +1211,12 @@

 .. option:: --strict-cbr, --no-strict-cbr

    Enables stricter conditions to control bitrate deviance from the 

-   target bitrate in CBR mode. Bitrate adherence is prioritised

+   target bitrate in ABR mode. Bit rate adherence is prioritised

    over quality. Rate tolerance is reduced to 50%. Default disabled.

    This option is for use-cases which require the final average bitrate 

-   to be within very strict limits of the target - preventing overshoots 

-   completely, and achieve bitrates within 5% of target bitrate, 

+   to be within very strict limits of the target; preventing overshoots, 

+   while keeping the bit rate within 5% of the target setting, 

    especially in short segment encodes. Typically, the encoder stays 

    conservative, waiting until there is enough feedback in terms of 

    encoded frames to control QP. strict-cbr allows the encoder to be 

@@ -1209,7 +1258,7 @@

    lookahead).  Default value is 0.6. Increasing it to 1 will

    effectively generate CQP

-.. option:: --qstep <integer>

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

    The maximum single adjustment in QP allowed to rate control. Default

    4

@@ -1451,9 +1500,48 @@

    specification for a description of these values. Default undefined

    (not signaled)

+.. option:: --master-display <string>

+

+   SMPTE ST 2086 mastering display color volume SEI info, specified as

+   a string which is parsed when the stream header SEI are emitted. The

+   string format is "G(%hu,%hu)B(%hu,%hu)R(%hu,%hu)WP(%hu,%hu)L(%u,%u)"

+   where %hu are unsigned 16bit integers and %u are unsigned 32bit

+   integers. The SEI includes X,Y display primaries for RGB channels,

+   white point X,Y and max,min luminance values. (HDR)

+

+   Example for P65D3 1000-nits:

+

+       G(13200,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.

+

+.. option:: --max-cll <string>

+

+   Maximum content light level and maximum frame average light level as

+   required by the Consumer Electronics Association 861.3 specification.

+

+   Specified as a string which is parsed when the stream header SEI are

+   emitted. The string format is "%hu,%hu" where %hu are unsigned 16bit

+   integers. The first value is the max content light level (or 0 if no

+   maximum is indicated), the second value is the maximum picture

+   average light level (or 0). (HDR)

+

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

+   protect against shell expansion on many platforms. No default.

+

 Bitstream options

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

+.. option:: --annexb, --no-annexb

+

+   If enabled, x265 will produce Annex B bitstream format, which places

+   start codes before NAL. If disabled, x265 will produce file format,

+   which places length before NAL. x265 CLI will choose the right option

+   based on output format. Default enabled

+

+   **API ONLY**

+

 .. option:: --repeat-headers, --no-repeat-headers

    If enabled, x265 will emit VPS, SPS, and PPS headers with every

@@ -1498,8 +1586,8 @@

    Enable a temporal sub layer. All referenced I/P/B frames are in the

    base layer and all unreferenced B frames are placed in a temporal

-   sublayer. A decoder may chose to drop the sublayer and only decode

-   and display the base layer slices.

+   enhancement layer. A decoder may chose to drop the enhancement layer 

+   and only decode and display the base layer slices.

    If used with a fixed GOP (:option:`b-adapt` 0) and :option:`bframes`

    3 then the two layers evenly split the frame rate, with a cadence of

@@ -1525,4 +1613,20 @@

    **CLI ONLY**

+.. option:: --recon-y4m-exec <string>

+

+   If you have an application which can play a Y4MPEG stream received

+   on stdin, the x265 CLI can feed it reconstructed pictures in display

+   order.  The pictures will have no timing info, obviously, so the

+   picture timing will be determined primarily by encoding elapsed time

+   and latencies, but it can be useful to preview the pictures being

+   output by the encoder to validate input settings and rate control

+   parameters.

+

+   Example command for ffplay (assuming it is in your PATH):

+

+   --recon-y4m-exec "ffplay -i pipe:0 -autoexit"

+

+   **CLI ONLY**

+

 .. vim: noet

​

@@ -2,6 +2,8 @@

 Threading

 *********

+.. _pools:

+

 Thread Pools

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

@@ -31,6 +33,18 @@

 expected to drop that job so the worker thread may go back to the pool

 and find more work.

+On Windows, the native APIs offer sufficient functionality to discover

+the NUMA topology and enforce the thread affinity that libx265 needs (so

+long as you have not chosen to target XP or Vista), but on POSIX systems

+it relies on libnuma for this functionality. If your target POSIX system

+is single socket, then building without libnuma is a perfectly

+reasonable option, as it will have no effect on the runtime behavior. On

+a multiple-socket system, a POSIX build of libx265 without libnuma will

+be less work efficient, but will still function correctly. You lose the

+work isolation effect that keeps each frame encoder from only using the

+threads of a single socket and so you incur a heavier context switching

+cost.

+

 Wavefront Parallel Processing

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

@@ -225,6 +239,7 @@

 lowres cost analysis to worker threads. It will use bonded task groups

 to perform batches of frame cost estimates, and it may optionally use

 bonded task groups to measure single frame cost estimates using slices.

+(see :option:`--lookahead-slices`)

 The function slicetypeDecide() itself is also be performed by a worker

 thread if your encoder has a thread pool, else it runs within the

​

@@ -3,7 +3,7 @@

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

 | **Read:** | Online `documentation <http://x265.readthedocs.org/en/default/>`_ | Developer `wiki <http://bitbucket.org/multicoreware/x265/wiki/>`_

-| **Download:** | `releases <http://bitbucket.org/multicoreware/x265/downloads/>`_ 

+| **Download:** | `releases <http://ftp.videolan.org/pub/videolan/x265/>`_ 

 | **Interact:** | #x265 on freenode.irc.net | `x265-devel@videolan.org <http://mailman.videolan.org/listinfo/x265-devel>`_ | `Report an issue <https://bitbucket.org/multicoreware/x265/issues?status=new&status=open>`_

 `x265 <https://www.videolan.org/developers/x265.html>`_ is an open

​

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

+set(X265_BUILD 59)

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

                "${PROJECT_BINARY_DIR}/x265.def")

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

@@ -65,15 +65,19 @@

     if(LIBRT)

         list(APPEND PLATFORM_LIBS rt)

     endif()

+    find_library(LIBDL dl)

+    if(LIBDL)

+        list(APPEND PLATFORM_LIBS dl)

+    endif()

     find_package(Numa)

     if(NUMA_FOUND)

-        list(APPEND CMAKE_REQUIRED_LIBRARIES ${NUMA_LIBRARY})

+        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_LIBRARY})

-            link_directories(${NUMA_LIBRARY_DIR})

+            list(APPEND PLATFORM_LIBS numa)

             include_directories(${NUMA_INCLUDE_DIR})

         endif()

     endif()

@@ -90,7 +94,7 @@

 if(CMAKE_GENERATOR STREQUAL "Xcode")

   set(XCODE 1)

 endif()

-if (APPLE)

+if(APPLE)

   add_definitions(-DMACOS)

 endif()

@@ -196,6 +200,7 @@

         add_definitions(-static)

         list(APPEND LINKER_OPTIONS "-static")

     endif(STATIC_LINK_CRT)

+    check_cxx_compiler_flag(-Wno-strict-overflow CC_HAS_NO_STRICT_OVERFLOW)

     check_cxx_compiler_flag(-Wno-narrowing CC_HAS_NO_NARROWING) 

     check_cxx_compiler_flag(-Wno-array-bounds CC_HAS_NO_ARRAY_BOUNDS) 

     if (CC_HAS_NO_ARRAY_BOUNDS)

@@ -291,7 +296,7 @@

     endif()

 endif(WARNINGS_AS_ERRORS)

-if (WIN32)

+if(WIN32)

     # Visual leak detector

     find_package(VLD QUIET)

     if(VLD_FOUND)

@@ -300,12 +305,15 @@

         list(APPEND PLATFORM_LIBS ${VLD_LIBRARIES})

         link_directories(${VLD_LIBRARY_DIRS})

     endif()

-    option(WINXP_SUPPORT "Make binaries compatible with Windows XP" OFF)

+    option(WINXP_SUPPORT "Make binaries compatible with Windows XP and Vista" OFF)

     if(WINXP_SUPPORT)

         # force use of workarounds for CONDITION_VARIABLE and atomic

         # intrinsics introduced after XP

-        add_definitions(-D_WIN32_WINNT=_WIN32_WINNT_WINXP)

-    endif()

+        add_definitions(-D_WIN32_WINNT=_WIN32_WINNT_WINXP -D_WIN32_WINNT_WIN7=0x0601)

+    else(WINXP_SUPPORT)

+        # default to targeting Windows 7 for the NUMA APIs

+        add_definitions(-D_WIN32_WINNT=_WIN32_WINNT_WIN7)

+    endif(WINXP_SUPPORT)

 endif()

 include(version) # determine X265_VERSION and X265_LATEST_TAG

@@ -462,8 +470,10 @@

 # Main CLI application

 option(ENABLE_CLI "Build standalone CLI application" ON)

 if(ENABLE_CLI)

-    file(GLOB InputFiles input/*.cpp input/*.h)

-    file(GLOB OutputFiles output/*.cpp output/*.h)

+    file(GLOB InputFiles input/input.cpp input/yuv.cpp input/y4m.cpp input/*.h)

+    file(GLOB OutputFiles output/output.cpp output/reconplay.cpp output/*.h

+                          output/yuv.cpp output/y4m.cpp # recon

+                          output/raw.cpp)               # muxers

     file(GLOB FilterFiles filters/*.cpp filters/*.h)

     source_group(input FILES ${InputFiles})

     source_group(output FILES ${OutputFiles})

​

@@ -100,11 +100,14 @@

     return (x265_exp2_lut[i & 63] + 256) << (i >> 6) >> 8;

 }

-void x265_log(const x265_param *param, int level, const char *fmt, ...)

+void general_log(const x265_param* param, const char* caller, int level, const char* fmt, ...)

 {

     if (param && level > param->logLevel)

         return;

-    const char *log_level;

+    const int bufferSize = 4096;

+    char buffer[bufferSize];

+    int p = 0;

+    const char* log_level;

     switch (level)

     {

     case X265_LOG_ERROR:

@@ -127,11 +130,13 @@

         break;

     }

-    fprintf(stderr, "x265 [%s]: ", log_level);

+    if (caller)

+        p += sprintf(buffer, "%-4s [%s]: ", caller, log_level);

     va_list arg;

     va_start(arg, fmt);

-    vfprintf(stderr, fmt, arg);

+    vsnprintf(buffer + p, bufferSize - p, fmt, arg);

     va_end(arg);

+    fputs(buffer, stderr);

 }

 double x265_ssim2dB(double ssim)

​

@@ -413,7 +413,8 @@

 /* outside x265 namespace, but prefixed. defined in common.cpp */

 int64_t  x265_mdate(void);

-void     x265_log(const x265_param *param, int level, const char *fmt, ...);

+#define  x265_log(param, ...) general_log(param, "x265", __VA_ARGS__)

+void     general_log(const x265_param* param, const char* caller, int level, const char* fmt, ...);

 int      x265_exp2fix8(double x);

 double   x265_ssim2dB(double ssim);

​

@@ -324,7 +324,7 @@

       4,  12, 20, 28,  5, 13, 21, 29,  6, 14, 22, 30,  7, 15, 23, 31, 36, 44, 52, 60, 37, 45, 53, 61, 38, 46, 54, 62, 39, 47, 55, 63 }

 };

-const uint16_t g_scan4x4[NUM_SCAN_TYPE][4 * 4] =

+ALIGN_VAR_16(const uint16_t, g_scan4x4[NUM_SCAN_TYPE][4 * 4]) =

 {

     { 0,  4,  1,  8,  5,  2, 12,  9,  6,  3, 13, 10,  7, 14, 11, 15 },

     { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15 },

​

@@ -106,6 +106,7 @@

 // private namespace

 extern const uint32_t g_entropyBits[128];

+extern const uint32_t g_entropyStateBits[128];

 extern const uint8_t g_nextState[128][2];

 #define sbacGetMps(S)            ((S) & 1)

​

@@ -298,7 +298,7 @@

 }

 // initialize Sub partition

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

+void CUData::initSubCU(const CUData& ctu, const CUGeom& cuGeom, int qp)

 {

     m_absIdxInCTU   = cuGeom.absPartIdx;

     m_encData       = ctu.m_encData;

@@ -312,8 +312,8 @@

     m_cuAboveRight  = ctu.m_cuAboveRight;

     X265_CHECK(m_numPartitions == cuGeom.numPartitions, "initSubCU() size mismatch\n");

-    /* sequential memsets */

-    m_partSet((uint8_t*)m_qp, (uint8_t)ctu.m_qp[0]);

+    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_tqBypass,     (uint8_t)m_encData->m_param->bLossless);

@@ -1830,6 +1830,10 @@

     }

 }

+/* Clip motion vector to within slightly padded boundary of picture (the

+ * MV may reference a block that is completely within the padded area).

+ * Note this function is unaware of how much of this picture is actually

+ * available for use (re: frame parallelism) */

 void CUData::clipMv(MV& outMV) const

 {

     const uint32_t mvshift = 2;

@@ -2027,6 +2031,7 @@

         uint32_t blockSize = 1 << log2CUSize;

         uint32_t sbWidth   = 1 << (g_log2Size[maxCUSize] - log2CUSize);

         int32_t lastLevelFlag = log2CUSize == g_log2Size[minCUSize];

+

         for (uint32_t sbY = 0; sbY < sbWidth; sbY++)

         {

             for (uint32_t sbX = 0; sbX < sbWidth; sbX++)

​

@@ -85,8 +85,8 @@

     uint32_t childOffset;   // offset of the first child CU from current CU

     uint32_t absPartIdx;    // Part index of this CU in terms of 4x4 blocks.

     uint32_t numPartitions; // Number of 4x4 blocks in the CU

-    uint32_t depth;         // depth of this CU relative from CTU

     uint32_t flags;         // CU flags.

+    uint32_t depth;         // depth of this CU relative from CTU

 };

 struct MVField

@@ -182,7 +182,7 @@

     static void calcCTUGeoms(uint32_t ctuWidth, uint32_t ctuHeight, uint32_t maxCUSize, uint32_t minCUSize, CUGeom cuDataArray[CUGeom::MAX_GEOMS]);

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

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

+    void     initSubCU(const CUData& ctu, const CUGeom& cuGeom, int qp);

     void     initLosslessCU(const CUData& cu, const CUGeom& cuGeom);

     void     copyPartFrom(const CUData& cu, const CUGeom& childGeom, uint32_t subPartIdx);

​

@@ -752,7 +752,7 @@

     }

 }

-int findPosLast_c(const uint16_t *scan, const coeff_t *coeff, uint16_t *coeffSign, uint16_t *coeffFlag, uint8_t *coeffNum, int numSig)

+int scanPosLast_c(const uint16_t *scan, const coeff_t *coeff, uint16_t *coeffSign, uint16_t *coeffFlag, uint8_t *coeffNum, int numSig, const uint16_t* /*scanCG4x4*/, const int /*trSize*/)

 {

     memset(coeffNum, 0, MLS_GRP_NUM * sizeof(*coeffNum));

     memset(coeffFlag, 0, MLS_GRP_NUM * sizeof(*coeffFlag));

@@ -785,6 +785,37 @@

     return scanPosLast - 1;

 }

+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)

+    {

+        const uint32_t idx = scanTbl[n];

+        const uint32_t idxY = idx / MLS_CG_SIZE;

+        const uint32_t idxX = idx % MLS_CG_SIZE;

+        if (dstCoeff[idxY * trSize + idxX])

+            break;

+    }

+

+    X265_CHECK(n >= 0, "non-zero coeff scan failuare!\n");

+

+    uint32_t lastNZPosInCG = (uint32_t)n;

+

+    for (n = 0;; n++)

+    {

+        const uint32_t idx = scanTbl[n];

+        const uint32_t idxY = idx / MLS_CG_SIZE;

+        const uint32_t idxX = idx % MLS_CG_SIZE;

+        if (dstCoeff[idxY * trSize + idxX])

+            break;

+    }

+

+    uint32_t firstNZPosInCG = (uint32_t)n;

+

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

+}

+

 }  // closing - anonymous file-static namespace

 namespace x265 {

@@ -817,6 +848,7 @@

     p.cu[BLOCK_16x16].copy_cnt = copy_count<16>;

     p.cu[BLOCK_32x32].copy_cnt = copy_count<32>;

-    p.findPosLast = findPosLast_c;

+    p.scanPosLast = scanPosLast_c;

+    p.findPosFirstLast = findPosFirstLast_c;

 }

 }

​

@@ -31,18 +31,21 @@

 Frame::Frame()

 {

     m_bChromaExtended = false;

+    m_lowresInit = false;

     m_reconRowCount.set(0);

     m_countRefEncoders = 0;

     m_encData = NULL;

     m_reconPic = NULL;

     m_next = NULL;

     m_prev = NULL;

+    m_param = NULL;

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

 }

 bool Frame::create(x265_param *param)

 {

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

​

@@ -56,6 +56,7 @@

     void*                  m_userData;           // user provided pointer passed in with this picture

     Lowres                 m_lowres;

+    bool                   m_lowresInit;         // lowres init complete (pre-analysis)

     bool                   m_bChromaExtended;    // orig chroma planes motion extended for weight analysis

     /* Frame Parallelism - notification between FrameEncoders of available motion reference rows */

@@ -64,7 +65,7 @@

     Frame*                 m_next;               // PicList doubly linked list pointers

     Frame*                 m_prev;

-

+    x265_param*            m_param;              // Points to the latest param set for the frame.

     x265_analysis_data     m_analysisData;

     Frame();

​

@@ -74,6 +74,7 @@

         uint32_t numEncodedCUs; /* ctuAddr of last encoded CTU in row */

         uint32_t encodedBits;   /* sum of 'totalBits' of encoded CTUs */

         uint32_t satdForVbv;    /* sum of lowres (estimated) costs for entire row */

+        uint32_t intraSatdForVbv; /* sum of lowres (estimated) intra costs for entire row */

         uint32_t diagSatd;

         uint32_t diagIntraSatd;

         double   diagQp;

​

@@ -34,27 +34,8 @@

 #endif

 namespace {

-template<int dstStride, int width, int height>

-void pixelToShort_c(const pixel* src, intptr_t srcStride, int16_t* dst)

-{

-    int shift = IF_INTERNAL_PREC - X265_DEPTH;

-    int row, col;

-

-    for (row = 0; row < height; row++)

-    {

-        for (col = 0; col < width; col++)

-        {

-            int16_t val = src[col] << shift;

-            dst[col] = val - (int16_t)IF_INTERNAL_OFFS;

-        }

-

-        src += srcStride;

-        dst += dstStride;

-    }

-}

-

-template<int dstStride>

-void filterPixelToShort_c(const pixel* src, intptr_t srcStride, int16_t* dst, int width, int height)

+template<int width, int height>

+void filterPixelToShort_c(const pixel* src, intptr_t srcStride, int16_t* dst, intptr_t dstStride)

 {

     int shift = IF_INTERNAL_PREC - X265_DEPTH;

     int row, col;

@@ -398,7 +379,7 @@

     p.chroma[X265_CSP_I420].pu[CHROMA_420_ ## W ## x ## H].filter_vps = interp_vert_ps_c<4, W, H>;  \

     p.chroma[X265_CSP_I420].pu[CHROMA_420_ ## W ## x ## H].filter_vsp = interp_vert_sp_c<4, W, H>;  \

     p.chroma[X265_CSP_I420].pu[CHROMA_420_ ## W ## x ## H].filter_vss = interp_vert_ss_c<4, W, H>; \

-    p.chroma[X265_CSP_I420].pu[CHROMA_420_ ## W ## x ## H].chroma_p2s = pixelToShort_c<MAX_CU_SIZE / 2, W, H>; 

+    p.chroma[X265_CSP_I420].pu[CHROMA_420_ ## W ## x ## H].p2s = filterPixelToShort_c<W, H>;

 #define CHROMA_422(W, H) \

     p.chroma[X265_CSP_I422].pu[CHROMA_422_ ## W ## x ## H].filter_hpp = interp_horiz_pp_c<4, W, H>; \

@@ -407,7 +388,7 @@

     p.chroma[X265_CSP_I422].pu[CHROMA_422_ ## W ## x ## H].filter_vps = interp_vert_ps_c<4, W, H>;  \

     p.chroma[X265_CSP_I422].pu[CHROMA_422_ ## W ## x ## H].filter_vsp = interp_vert_sp_c<4, W, H>;  \

     p.chroma[X265_CSP_I422].pu[CHROMA_422_ ## W ## x ## H].filter_vss = interp_vert_ss_c<4, W, H>; \

-    p.chroma[X265_CSP_I422].pu[CHROMA_422_ ## W ## x ## H].chroma_p2s = pixelToShort_c<MAX_CU_SIZE / 2, W, H>; 

+    p.chroma[X265_CSP_I422].pu[CHROMA_422_ ## W ## x ## H].p2s = filterPixelToShort_c<W, H>;

 #define CHROMA_444(W, H) \

     p.chroma[X265_CSP_I444].pu[LUMA_ ## W ## x ## H].filter_hpp = interp_horiz_pp_c<4, W, H>; \

@@ -416,7 +397,7 @@

     p.chroma[X265_CSP_I444].pu[LUMA_ ## W ## x ## H].filter_vps = interp_vert_ps_c<4, W, H>;  \

     p.chroma[X265_CSP_I444].pu[LUMA_ ## W ## x ## H].filter_vsp = interp_vert_sp_c<4, W, H>;  \

     p.chroma[X265_CSP_I444].pu[LUMA_ ## W ## x ## H].filter_vss = interp_vert_ss_c<4, W, H>; \

-    p.chroma[X265_CSP_I444].pu[LUMA_ ## W ## x ## H].chroma_p2s = pixelToShort_c<MAX_CU_SIZE, W, H>; 

+    p.chroma[X265_CSP_I444].pu[LUMA_ ## W ## x ## H].p2s = filterPixelToShort_c<W, H>;

 #define LUMA(W, H) \

     p.pu[LUMA_ ## W ## x ## H].luma_hpp     = interp_horiz_pp_c<8, W, H>; \

@@ -426,7 +407,7 @@

     p.pu[LUMA_ ## W ## x ## H].luma_vsp     = interp_vert_sp_c<8, W, H>;  \

     p.pu[LUMA_ ## W ## x ## H].luma_vss     = interp_vert_ss_c<8, W, H>;  \

     p.pu[LUMA_ ## W ## x ## H].luma_hvpp    = interp_hv_pp_c<8, W, H>; \

-    p.pu[LUMA_ ## W ## x ## H].filter_p2s = pixelToShort_c<MAX_CU_SIZE, W, H>

+    p.pu[LUMA_ ## W ## x ## H].convert_p2s = filterPixelToShort_c<W, H>;

 void setupFilterPrimitives_c(EncoderPrimitives& p)

 {

@@ -482,6 +463,7 @@

     CHROMA_422(4, 8);

     CHROMA_422(4, 4);

+    CHROMA_422(2, 4);

     CHROMA_422(2, 8);

     CHROMA_422(8,  16);

     CHROMA_422(8,  8);

@@ -530,11 +512,6 @@

     CHROMA_444(48, 64);

     CHROMA_444(64, 16);

     CHROMA_444(16, 64);

-    p.luma_p2s = filterPixelToShort_c<MAX_CU_SIZE>;

-

-    p.chroma[X265_CSP_I444].p2s = filterPixelToShort_c<MAX_CU_SIZE>;

-    p.chroma[X265_CSP_I420].p2s = filterPixelToShort_c<MAX_CU_SIZE / 2>;

-    p.chroma[X265_CSP_I422].p2s = filterPixelToShort_c<MAX_CU_SIZE / 2>;

     p.extendRowBorder = extendCURowColBorder;

 }

​

@@ -42,18 +42,23 @@

         dst[x] = signOf(src1[x] - src2[x]);

 }

-void processSaoCUE0(pixel * rec, int8_t * offsetEo, int width, int8_t signLeft)

+void processSaoCUE0(pixel * rec, int8_t * offsetEo, int width, int8_t* signLeft, intptr_t stride)

 {

-    int x;

-    int8_t signRight;

+    int x, y;

+    int8_t signRight, signLeft0;

     int8_t edgeType;

-    for (x = 0; x < width; x++)

+    for (y = 0; y < 2; y++)

     {

-        signRight = ((rec[x] - rec[x + 1]) < 0) ? -1 : ((rec[x] - rec[x + 1]) > 0) ? 1 : 0;

-        edgeType = signRight + signLeft + 2;

-        signLeft  = -signRight;

-        rec[x] = x265_clip(rec[x] + offsetEo[edgeType]);

+        signLeft0 = signLeft[y];

+        for (x = 0; x < width; x++)

+        {

+            signRight = ((rec[x] - rec[x + 1]) < 0) ? -1 : ((rec[x] - rec[x + 1]) > 0) ? 1 : 0;

+            edgeType = signRight + signLeft0 + 2;

+            signLeft0 = -signRight;

+            rec[x] = x265_clip(rec[x] + offsetEo[edgeType]);

+        }

+        rec += stride;

     }

 }

@@ -72,6 +77,25 @@

     }

 }

+void processSaoCUE1_2Rows(pixel* rec, int8_t* upBuff1, int8_t* offsetEo, intptr_t stride, int width)

+{

+    int x, y;

+    int8_t signDown;

+    int edgeType;

+

+    for (y = 0; y < 2; y++)

+    {

+        for (x = 0; x < width; x++)

+        {

+            signDown = signOf(rec[x] - rec[x + stride]);

+            edgeType = signDown + upBuff1[x] + 2;

+            upBuff1[x] = -signDown;

+            rec[x] = x265_clip(rec[x] + offsetEo[edgeType]);

+        }

+        rec += stride;

+    }

+}

+

 void processSaoCUE2(pixel * rec, int8_t * bufft, int8_t * buff1, int8_t * offsetEo, int width, intptr_t stride)

 {

     int x;

@@ -119,8 +143,11 @@

 {

     p.saoCuOrgE0 = processSaoCUE0;

     p.saoCuOrgE1 = processSaoCUE1;

-    p.saoCuOrgE2 = processSaoCUE2;

-    p.saoCuOrgE3 = processSaoCUE3;

+    p.saoCuOrgE1_2Rows = processSaoCUE1_2Rows;

+    p.saoCuOrgE2[0] = processSaoCUE2;

+    p.saoCuOrgE2[1] = processSaoCUE2;

+    p.saoCuOrgE3[0] = processSaoCUE3;

+    p.saoCuOrgE3[1] = processSaoCUE3;

     p.saoCuOrgB0 = processSaoCUB0;

     p.sign = calSign;

 }

​

@@ -87,7 +87,7 @@

 extern "C"

 void x265_param_free(x265_param* p)

 {

-    return x265_free(p);

+    x265_free(p);

 }

 extern "C"

@@ -117,6 +117,7 @@

     param->levelIdc = 0;

     param->bHighTier = 0;

     param->interlaceMode = 0;

+    param->bAnnexB = 1;

     param->bRepeatHeaders = 0;

     param->bEnableAccessUnitDelimiters = 0;

     param->bEmitHRDSEI = 0;

@@ -209,6 +210,7 @@

     param->rc.zones = NULL;

     param->rc.bEnableSlowFirstPass = 0;

     param->rc.bStrictCbr = 0;

+    param->rc.qgSize = 64; /* Same as maxCUSize */

     /* Video Usability Information (VUI) */

     param->vui.aspectRatioIdc = 0;

@@ -263,6 +265,7 @@

             param->rc.aqStrength = 0.0;

             param->rc.aqMode = X265_AQ_NONE;

             param->rc.cuTree = 0;

+            param->rc.qgSize = 32;

             param->bEnableFastIntra = 1;

         }

         else if (!strcmp(preset, "superfast"))

@@ -279,6 +282,7 @@

             param->rc.aqStrength = 0.0;

             param->rc.aqMode = X265_AQ_NONE;

             param->rc.cuTree = 0;

+            param->rc.qgSize = 32;

             param->bEnableSAO = 0;

             param->bEnableFastIntra = 1;

         }

@@ -292,6 +296,7 @@

             param->rdLevel = 2;

             param->maxNumReferences = 1;

             param->rc.cuTree = 0;

+            param->rc.qgSize = 32;

             param->bEnableFastIntra = 1;

         }

         else if (!strcmp(preset, "faster"))

@@ -565,6 +570,7 @@

             p->levelIdc = atoi(value);

     }

     OPT("high-tier") p->bHighTier = atobool(value);

+    OPT("allow-non-conformance") p->bAllowNonConformance = atobool(value);

     OPT2("log-level", "log")

     {

         p->logLevel = atoi(value);

@@ -575,6 +581,7 @@

         }

     }

     OPT("cu-stats") p->bLogCuStats = atobool(value);

+    OPT("annexb") p->bAnnexB = atobool(value);

     OPT("repeat-headers") p->bRepeatHeaders = atobool(value);

     OPT("wpp") p->bEnableWavefront = atobool(value);

     OPT("ctu") p->maxCUSize = (uint32_t)atoi(value);

@@ -843,6 +850,9 @@

     OPT2("pools", "numa-pools") p->numaPools = strdup(value);

     OPT("lambda-file") p->rc.lambdaFileName = strdup(value);

     OPT("analysis-file") p->analysisFileName = strdup(value);

+    OPT("qg-size") p->rc.qgSize = atoi(value);

+    OPT("master-display") p->masteringDisplayColorVolume = strdup(value);

+    OPT("max-cll") p->contentLightLevelInfo = strdup(value);

     else

         return X265_PARAM_BAD_NAME;

 #undef OPT

@@ -1183,7 +1193,7 @@

     uint32_t maxLog2CUSize = (uint32_t)g_log2Size[param->maxCUSize];

     uint32_t minLog2CUSize = (uint32_t)g_log2Size[param->minCUSize];

-    if (g_ctuSizeConfigured || ATOMIC_INC(&g_ctuSizeConfigured) > 1)

+    if (ATOMIC_INC(&g_ctuSizeConfigured) > 1)

     {

         if (g_maxCUSize != param->maxCUSize)

         {

@@ -1264,22 +1274,20 @@

     x265_log(param, X265_LOG_INFO, "b-pyramid / weightp / weightb / refs: %d / %d / %d / %d\n",

              param->bBPyramid, param->bEnableWeightedPred, param->bEnableWeightedBiPred, param->maxNumReferences);

+    if (param->rc.aqMode)

+        x265_log(param, X265_LOG_INFO, "AQ: mode / str / qg-size / cu-tree  : %d / %0.1f / %d / %d\n", param->rc.aqMode,

+                 param->rc.aqStrength, param->rc.qgSize, param->rc.cuTree);

+

     if (param->bLossless)

         x265_log(param, X265_LOG_INFO, "Rate Control                        : Lossless\n");

     else switch (param->rc.rateControlMode)

     {

     case X265_RC_ABR:

-        x265_log(param, X265_LOG_INFO, "Rate Control / AQ-Strength / CUTree : ABR-%d kbps / %0.1f / %d\n", param->rc.bitrate,

-                 param->rc.aqStrength, param->rc.cuTree);

-        break;

+        x265_log(param, X265_LOG_INFO, "Rate Control / qCompress            : ABR-%d kbps / %0.2f\n", param->rc.bitrate, param->rc.qCompress); break;

     case X265_RC_CQP:

-        x265_log(param, X265_LOG_INFO, "Rate Control / AQ-Strength / CUTree : CQP-%d / %0.1f / %d\n", param->rc.qp, param->rc.aqStrength,

-                 param->rc.cuTree);

-        break;

+        x265_log(param, X265_LOG_INFO, "Rate Control                        : CQP-%d\n", param->rc.qp); break;

     case X265_RC_CRF:

-        x265_log(param, X265_LOG_INFO, "Rate Control / AQ-Strength / CUTree : CRF-%0.1f / %0.1f / %d\n", param->rc.rfConstant,

-                 param->rc.aqStrength, param->rc.cuTree);

-        break;

+        x265_log(param, X265_LOG_INFO, "Rate Control / qCompress            : CRF-%0.1f / %0.2f\n", param->rc.rfConstant, param->rc.qCompress); break;

     }

     if (param->rc.vbvBufferSize)

@@ -1327,6 +1335,43 @@

     fflush(stderr);

 }

+void x265_print_reconfigured_params(x265_param* param, x265_param* reconfiguredParam)

+{

+    if (!param || !reconfiguredParam)

+        return;

+

+    x265_log(param,X265_LOG_INFO, "Reconfigured param options :\n");

+

+    char buf[80] = { 0 };

+    char tmp[40];

+#define TOOLCMP(COND1, COND2, STR, VAL)  if (COND1 != COND2) { sprintf(tmp, STR, VAL); appendtool(param, buf, sizeof(buf), tmp); }

+    TOOLCMP(param->maxNumReferences, reconfiguredParam->maxNumReferences, "ref=%d", reconfiguredParam->maxNumReferences);

+    TOOLCMP(param->maxTUSize, reconfiguredParam->maxTUSize, "max-tu-size=%d", reconfiguredParam->maxTUSize);

+    TOOLCMP(param->searchRange, reconfiguredParam->searchRange, "merange=%d", reconfiguredParam->searchRange);

+    TOOLCMP(param->subpelRefine, reconfiguredParam->subpelRefine, "subme= %d", reconfiguredParam->subpelRefine);

+    TOOLCMP(param->rdLevel, reconfiguredParam->rdLevel, "rd=%d", reconfiguredParam->rdLevel);

+    TOOLCMP(param->psyRd, reconfiguredParam->psyRd, "psy-rd=%.2lf", reconfiguredParam->psyRd);

+    TOOLCMP(param->rdoqLevel, reconfiguredParam->rdoqLevel, "rdoq=%d", reconfiguredParam->rdoqLevel);

+    TOOLCMP(param->psyRdoq, reconfiguredParam->psyRdoq, "psy-rdoq=%.2lf", reconfiguredParam->psyRdoq);

+    TOOLCMP(param->noiseReductionIntra, reconfiguredParam->noiseReductionIntra, "nr-intra=%d", reconfiguredParam->noiseReductionIntra);

+    TOOLCMP(param->noiseReductionInter, reconfiguredParam->noiseReductionInter, "nr-inter=%d", reconfiguredParam->noiseReductionInter);

+    TOOLCMP(param->bEnableTSkipFast, reconfiguredParam->bEnableTSkipFast, "tskip-fast=%d", reconfiguredParam->bEnableTSkipFast);

+    TOOLCMP(param->bEnableSignHiding, reconfiguredParam->bEnableSignHiding, "signhide=%d", reconfiguredParam->bEnableSignHiding);

+    TOOLCMP(param->bEnableFastIntra, reconfiguredParam->bEnableFastIntra, "fast-intra=%d", reconfiguredParam->bEnableFastIntra);

+    if (param->bEnableLoopFilter && (param->deblockingFilterBetaOffset != reconfiguredParam->deblockingFilterBetaOffset 

+        || param->deblockingFilterTCOffset != reconfiguredParam->deblockingFilterTCOffset))

+    {

+        sprintf(tmp, "deblock(tC=%d:B=%d)", param->deblockingFilterTCOffset, param->deblockingFilterBetaOffset);

+        appendtool(param, buf, sizeof(buf), tmp);

+    }

+    else

+        TOOLCMP(param->bEnableLoopFilter,  reconfiguredParam->bEnableLoopFilter, "deblock=%d", reconfiguredParam->bEnableLoopFilter);

+

+    TOOLCMP(param->bEnableTemporalMvp, reconfiguredParam->bEnableTemporalMvp, "tmvp=%d", reconfiguredParam->bEnableTemporalMvp);

+    TOOLCMP(param->bEnableEarlySkip, reconfiguredParam->bEnableEarlySkip, "early-skip=%d", reconfiguredParam->bEnableEarlySkip);

+    x265_log(param, X265_LOG_INFO, "tools:%s\n", buf);

+}

+

 char *x265_param2string(x265_param* p)

 {

     char *buf, *s;

​

@@ -28,6 +28,7 @@

 int   x265_check_params(x265_param *param);

 int   x265_set_globals(x265_param *param);

 void  x265_print_params(x265_param *param);

+void  x265_print_reconfigured_params(x265_param* param, x265_param* reconfiguredParam);

 void  x265_param_apply_fastfirstpass(x265_param *p);

 char* x265_param2string(x265_param *param);

 int   x265_atoi(const char *str, bool& bError);

​

@@ -175,8 +175,7 @@

         for (int r = 0; r < height; r++)

         {

-            for (int c = 0; c < width; c++)

-                yPixel[c] = (pixel)yChar[c];

+            memcpy(yPixel, yChar, width * sizeof(pixel));

             yPixel += m_stride;

             yChar += pic.stride[0] / sizeof(*yChar);

@@ -184,11 +183,8 @@

         for (int r = 0; r < height >> m_vChromaShift; r++)

         {

-            for (int c = 0; c < width >> m_hChromaShift; c++)

-            {

-                uPixel[c] = (pixel)uChar[c];

-                vPixel[c] = (pixel)vChar[c];

-            }

+            memcpy(uPixel, uChar, (width >> m_hChromaShift) * sizeof(pixel));

+            memcpy(vPixel, vChar, (width >> m_hChromaShift) * sizeof(pixel));

             uPixel += m_strideC;

             vPixel += m_strideC;

​

@@ -582,7 +582,7 @@

     }

 }

-void scale1D_128to64(pixel *dst, const pixel *src, intptr_t /*stride*/)

+void scale1D_128to64(pixel *dst, const pixel *src)

 {

     int x;

     const pixel* src1 = src;

​

@@ -273,7 +273,7 @@

 void Predict::predInterLumaShort(const PredictionUnit& pu, ShortYuv& dstSYuv, const PicYuv& refPic, const MV& mv) const

 {

     int16_t* dst = dstSYuv.getLumaAddr(pu.puAbsPartIdx);

-    int dstStride = dstSYuv.m_size;

+    intptr_t dstStride = dstSYuv.m_size;

     intptr_t srcStride = refPic.m_stride;

     intptr_t srcOffset = (mv.x >> 2) + (mv.y >> 2) * srcStride;

@@ -288,7 +288,7 @@

     X265_CHECK(dstStride == MAX_CU_SIZE, "stride expected to be max cu size\n");

     if (!(yFrac | xFrac))

-        primitives.luma_p2s(src, srcStride, dst, pu.width, pu.height);

+        primitives.pu[partEnum].convert_p2s(src, srcStride, dst, dstStride);

     else if (!yFrac)

         primitives.pu[partEnum].luma_hps(src, srcStride, dst, dstStride, xFrac, 0);

     else if (!xFrac)

@@ -375,14 +375,13 @@

     int partEnum = partitionFromSizes(pu.width, pu.height);

     uint32_t cxWidth  = pu.width >> m_hChromaShift;

-    uint32_t cxHeight = pu.height >> m_vChromaShift;

-    X265_CHECK(((cxWidth | cxHeight) % 2) == 0, "chroma block size expected to be multiple of 2\n");

+    X265_CHECK(((cxWidth | (pu.height >> m_vChromaShift)) % 2) == 0, "chroma block size expected to be multiple of 2\n");