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

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

+Mon Jun  1 17:51:22 UTC 2020 - Luigi Baldoni <aloisio@gmx.com>

+

+- Update to version 3.4

+  New features:

+  * Edge-aware quadtree partitioning to terminate CU depth

+    recursion based on edge information. --rskip level 2 enables

+    the feature and --rskip-edge-threshold denotes the minimum

+    expected edge-density percentage within the CU, below which

+    the recursion is skipped. Experimental feature.

+  * Application-level feature --abr-ladder for automating

+    efficient ABR ladder generation. Shows ~65% savings in the

+    over-all turn-around time required for the generation of a

+    typical Apple HLS ladder in Intel(R) Xeon(R) Platinum 8280

+    CPU @ 2.70GHz over a sequential ABR-ladder generation

+    approach that leverages save-load architecture.

+  Enhancements to existing features:

+  * Improved efficiency in 2-pass rate-control algorithm. The

+    savings in the bitrate is ~1.72% with visual improvement in

+    quality in the initial 1-2 secs.

+  Encoder enhancements:

+  * Faster ARM64 encodes enabled by ASM contributions from

+    Huawei. The speed-up over no-asm version for 1080p encodes @

+    medium preset is ~15% in a 16 core H/W.

+  * Strict VBV conformance in zone encoding.

+  Bug fixes:

+  * Multi-pass encode failures with --frame-dup.

+  * Corrupted bitstreams with --hist-scenecut when input depth

+    and internal bit-depth differ.

+  * Incorrect analysis propagation in multi-level save-load

+    architecture.

+  * Failure in detecting NUMA packages installed in non-standard

+    directories.

+

+- Refreshed arm.patch

+

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

 Sat Mar 28 14:28:56 UTC 2020 - Luigi Baldoni <aloisio@gmx.com>

 - Update to version 3.3

​

@@ -17,11 +17,11 @@

 #

-%define sover  188

+%define sover  192

 %define libname lib%{name}

 %define libsoname %{libname}-%{sover}

 Name:           x265

-Version:        3.3

+Version:        3.4

 Release:        0

 Summary:        A free h265/HEVC encoder - encoder binary

 License:        GPL-2.0-or-later

@@ -67,7 +67,6 @@

 %patch0 -p1

 %patch1 -p1

 %patch2 -p1

-

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

​

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

-Index: x265_2.2/source/CMakeLists.txt

+Index: x265_3.4/source/CMakeLists.txt

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

---- x265_2.2.orig/source/CMakeLists.txt

-+++ x265_2.2/source/CMakeLists.txt

-@@ -65,15 +65,22 @@ elseif(POWERMATCH GREATER "-1")

+--- x265_3.4.orig/source/CMakeLists.txt

++++ x265_3.4/source/CMakeLists.txt

+@@ -64,26 +64,26 @@ elseif(POWERMATCH GREATER "-1")

          add_definitions(-DPPC64=1)

          message(STATUS "Detected POWER PPC64 target processor")

      endif()

@@ -12,41 +12,62 @@

 -    else()

 -        set(CROSS_COMPILE_ARM 0)

 -    endif()

--    message(STATUS "Detected ARM target processor")

 -    set(ARM 1)

--    add_definitions(-DX265_ARCH_ARM=1 -DHAVE_ARMV6=1)

+-    if("${CMAKE_SIZEOF_VOID_P}" MATCHES 8)

+-        message(STATUS "Detected ARM64 target processor")

+-        set(ARM64 1)

+-        add_definitions(-DX265_ARCH_ARM=1 -DX265_ARCH_ARM64=1 -DHAVE_ARMV6=0)

+-    else()

+-        message(STATUS "Detected ARM target processor")

+-        add_definitions(-DX265_ARCH_ARM=1 -DX265_ARCH_ARM64=0 -DHAVE_ARMV6=1)

+-    endif()

 +elseif(${SYSPROC} MATCHES "armv5.*")

 +    message(STATUS "Detected ARMV5 system processor")

 +    set(ARMV5 1)

-+    add_definitions(-DX265_ARCH_ARM=1 -DHAVE_ARMV6=0 -DHAVE_NEON=0)

++    add_definitions(-DX265_ARCH_ARM=1 -DX265_ARCH_ARM64=0 -DHAVE_ARMV6=0 -DHAVE_NEON=0)

 +elseif(${SYSPROC} STREQUAL "armv6l")

 +    message(STATUS "Detected ARMV6 system processor")

 +    set(ARMV6 1)

-+    add_definitions(-DX265_ARCH_ARM=1 -DHAVE_ARMV6=1 -DHAVE_NEON=0)

++    add_definitions(-DX265_ARCH_ARM=1 -DX265_ARCH_ARM64=0 -DHAVE_ARMV6=1 -DHAVE_NEON=0)

 +elseif(${SYSPROC} STREQUAL "armv7l")

 +    message(STATUS "Detected ARMV7 system processor")

 +    set(ARMV7 1)

-+    add_definitions(-DX265_ARCH_ARM=1 -DHAVE_ARMV6=1 -DHAVE_NEON=0)

++    add_definitions(-DX265_ARCH_ARM=1 -DX265_ARCH_ARM64=0 -DHAVE_ARMV6=1 -DHAVE_NEON=0)

 +elseif(${SYSPROC} STREQUAL "aarch64")

 +    message(STATUS "Detected AArch64 system processor")

 +    set(ARMV7 1)

-+    add_definitions(-DX265_ARCH_ARM=1 -DHAVE_ARMV6=1 -DHAVE_NEON=0)

++    add_definitions(-DX265_ARCH_ARM=1 -DX265_ARCH_ARM64=1 -DHAVE_ARMV6=0 -DHAVE_NEON=0)

  else()

      message(STATUS "CMAKE_SYSTEM_PROCESSOR value `${CMAKE_SYSTEM_PROCESSOR}` is unknown")

      message(STATUS "Please add this value near ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE}")

-@@ -208,18 +215,9 @@ if(GCC)

+ endif()

+-

+ if(UNIX)

+     list(APPEND PLATFORM_LIBS pthread)

+     find_library(LIBRT rt)

+@@ -238,28 +238,9 @@ if(GCC)

              endif()

          endif()

      endif()

 -    if(ARM AND CROSS_COMPILE_ARM)

--        set(ARM_ARGS -march=armv6 -mfloat-abi=soft -mfpu=vfp -marm -fPIC)

+-        if(ARM64)

+-            set(ARM_ARGS -fPIC)

+-        else()

+-            set(ARM_ARGS -march=armv6 -mfloat-abi=soft -mfpu=vfp -marm -fPIC)

+-        endif()

+-        message(STATUS "cross compile arm")

 -    elseif(ARM)

--        find_package(Neon)

--        if(CPU_HAS_NEON)

--            set(ARM_ARGS -mcpu=native -mfloat-abi=hard -mfpu=neon -marm -fPIC)

+-        if(ARM64)

+-            set(ARM_ARGS -fPIC)

 -            add_definitions(-DHAVE_NEON)

 -        else()

--            set(ARM_ARGS -mcpu=native -mfloat-abi=hard -mfpu=vfp -marm)

+-            find_package(Neon)

+-            if(CPU_HAS_NEON)

+-                set(ARM_ARGS -mcpu=native -mfloat-abi=hard -mfpu=neon -marm -fPIC)

+-                add_definitions(-DHAVE_NEON)

+-            else()

+-                set(ARM_ARGS -mcpu=native -mfloat-abi=hard -mfpu=vfp -marm)

+-            endif()

 -        endif()

 +    if(ARMV7)

 +        add_definitions(-fPIC)

@@ -55,11 +76,11 @@

      if(FPROFILE_GENERATE)

          if(INTEL_CXX)

              add_definitions(-prof-gen -prof-dir="${CMAKE_CURRENT_BINARY_DIR}")

-Index: x265_2.2/source/common/cpu.cpp

+Index: x265_3.4/source/common/cpu.cpp

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

---- x265_2.2.orig/source/common/cpu.cpp

-+++ x265_2.2/source/common/cpu.cpp

-@@ -37,7 +37,7 @@

+--- x265_3.4.orig/source/common/cpu.cpp

++++ x265_3.4/source/common/cpu.cpp

+@@ -39,7 +39,7 @@

  #include <machine/cpu.h>

  #endif

@@ -68,7 +89,7 @@

  #include <signal.h>

  #include <setjmp.h>

  static sigjmp_buf jmpbuf;

-@@ -344,7 +344,6 @@ uint32_t cpu_detect(void)

+@@ -350,7 +350,6 @@ uint32_t cpu_detect(bool benableavx512)

      }

      canjump = 1;

@@ -76,7 +97,7 @@

      canjump = 0;

      signal(SIGILL, oldsig);

  #endif // if !HAVE_NEON

-@@ -360,7 +359,7 @@ uint32_t cpu_detect(void)

+@@ -366,7 +365,7 @@ uint32_t cpu_detect(bool benableavx512)

      // which may result in incorrect detection and the counters stuck enabled.

      // right now Apple does not seem to support performance counters for this test

  #ifndef __MACH__

@@ -84,4 +105,4 @@

 +    //flags |= PFX(cpu_fast_neon_mrc_test)() ? X265_CPU_FAST_NEON_MRC : 0;

  #endif

      // TODO: write dual issue test? currently it's A8 (dual issue) vs. A9 (fast mrc)

- #endif // if HAVE_ARMV6

+ #elif X265_ARCH_ARM64

​

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

-libx265-179

+libx265-192

​

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

 repo: 09fe40627f03a0f9c3e6ac78b22ac93da23f9fdf

-node: f94b0d32737d40b2b9a9d74df57fee45e6be5cb0

-branch: Release_3.3

-latesttag: 3.3

-latesttagdistance: 1

+node: 2a65b720985096bcb1664f7cb05c3d04aeb576f5

+branch: Release_3.4

+tag: 3.4

​

@@ -40,3 +40,4 @@

 5ee3593ebd82b4d8957909bbc1b68b99b59ba773 3.3_RC1

 96a10df63c0b778b480330bdf3be8da7db8a5fb1 3.3_RC2

 057215961bc4b51b6260a584ff3d506e6d65cfd6 3.3

+ee92f36782800f145970131e01c79955a3ed5c10 3.4_RC1

​

@@ -0,0 +1,15 @@

+# CMake toolchain file for cross compiling x265 for aarch64

+# This feature is only supported as experimental. Use with caution.

+# Please report bugs on bitbucket

+# Run cmake with: cmake -DCMAKE_TOOLCHAIN_FILE=crosscompile.cmake -G "Unix Makefiles" ../../source && ccmake ../../source

+

+set(CROSS_COMPILE_ARM 1)

+set(CMAKE_SYSTEM_NAME Linux)

+set(CMAKE_SYSTEM_PROCESSOR aarch64)

+

+# specify the cross compiler

+set(CMAKE_C_COMPILER aarch64-linux-gnu-gcc)

+set(CMAKE_CXX_COMPILER aarch64-linux-gnu-g++)

+

+# specify the target environment

+SET(CMAKE_FIND_ROOT_PATH  /usr/aarch64-linux-gnu)

​

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

+#!/bin/bash

+# Run this from within a bash shell

+

+cmake -DCMAKE_TOOLCHAIN_FILE="crosscompile.cmake" -G "Unix Makefiles" ../../source && ccmake ../../source

​

@@ -107,6 +107,9 @@

    **BufferFillFinal** Buffer bits available after removing the frame out of CPB.

+   **UnclippedBufferFillFinal** Unclipped buffer bits available after removing the frame 

+   out of CPB only used for csv logging purpose.

+   

    **Latency** Latency in terms of number of frames between when the frame 

    was given in and when the frame is given out.

@@ -842,15 +845,31 @@

    Measure 2Nx2N merge candidates first; if no residual is found, 

    additional modes at that depth are not analysed. Default disabled

-.. option:: --rskip, --no-rskip

+.. option:: --rskip <0|1|2>

+

+   This option determines early exit from CU depth recursion in modes 1 and 2. When a skip CU is

+   found, additional heuristics (depending on the RD level and rskip mode) are used to decide whether

+   to terminate recursion. The following table summarizes the behavior.

+   

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

+   | RD Level | Rskip Mode |   Skip Recursion Heuristic                                     |

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

+   |   0 - 4  |      1     |   Neighbour costs and CU homogenity.                           |

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

+   |   5 - 6  |      1     |   Comparison with inter2Nx2N.                                  |

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

+   |   0 - 6  |      2     |   CU edge density.                                             |

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

+

+   Provides minimal quality degradation at good performance gains for non-zero modes.

+   :option:`--rskip mode 0` means disabled. Default: 1, disabled when :option:`--tune grain` is used.

+   This is a integer value representing the edge-density percentage within the CU. Internally normalized to a number between 0.0 to 1.0 in x265. 

+   Recommended low thresholds for slow encodes and high for fast encodes.

-   This option determines early exit from CU depth recursion. When a skip CU is

-   found, additional heuristics (depending on rd-level) are used to decide whether

-   to terminate recursion. In rdlevels 5 and 6, comparison with inter2Nx2N is used, 

-   while at rdlevels 4 and neighbour costs are used to skip recursion.

-   Provides minimal quality degradation at good performance gains when enabled. 

+.. option:: --rskip-edge-threshold <0..100>

-   Default: enabled, disabled for :option:`--tune grain`

+   Denotes the minimum expected edge-density percentage within the CU, below which the recursion is skipped.

+   Default: 5, requires :option:`--rskip mode 2` to be enabled.

 .. option:: --splitrd-skip, --no-splitrd-skip

@@ -2501,6 +2520,28 @@

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

    **CLI ONLY**

+   

+ABR-ladder Options

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

+

+.. option:: --abr-ladder <filename>

+

+   File containing the encoder configurations to generate ABR ladder.

+   The format of each line is:

+

+   **<encID:reuse-level:refID> <CLI>**

+   

+   where, encID indicates the unique name given to the encode, refID indicates

+   the name of the encode from which analysis info has to be re-used ( set to 'nil'

+   if analysis reuse isn't preferred ), and reuse-level indicates the level ( :option:`--analysis-load-reuse-level`)

+   at which analysis info has to be reused.

+   

+   A sample config file is available in `the downloads page <https://bitbucket.org/multicoreware/x265/downloads/Sample_ABR_ladder_config>`_

+   

+   Default: Disabled ( Conventional single encode generation ). Experimental feature.

+

+   **CLI ONLY**

+

 SVT-HEVC Encoder Options

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

​

@@ -2,6 +2,32 @@

 Release Notes

 *************

+Version 3.4

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

+

+Release date - 29th May, 2020.

+

+New features

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

+1. **Edge-aware quadtree partitioning** to terminate CU depth recursion based on edge information. :option:`--rskip` level 2 enables the feature and  :option:`--rskip-edge-threshold` denotes the minimum expected edge-density percentage within the CU, below which the recursion is skipped. Experimental feature.

+2. Application-level feature :option:`--abr-ladder` for automating efficient ABR ladder generation. Shows ~65% savings in the over-all turn-around time required for the generation of a typical Apple HLS ladder in Intel(R) Xeon(R) Platinum 8280 CPU @ 2.70GHz over a sequential ABR-ladder generation approach that leverages save-load architecture.

+

+Enhancements to existing features

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

+1. Improved efficiency in 2-pass rate-control algorithm. The savings in the bitrate is ~1.72% with visual improvement in quality in the initial 1-2 secs.

+

+Encoder enhancements

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

+1. Faster ARM64 encodes enabled by ASM contributions from Huawei. The speed-up over no-asm version for 1080p encodes @ medium preset is ~15% in a 16 core H/W.

+2. Strict VBV conformance in zone encoding.

+

+Bug fixes

+---------

+1. Multi-pass encode failures with :option:`--frame-dup`.

+2. Corrupted bitstreams with :option:`--hist-scenecut` when input depth and internal bit-depth differ.

+3. Incorrect analysis propagation in multi-level save-load architecture.

+4. Failure in detecting NUMA packages installed in non-standard directories.

+

 Version 3.3

 ===========

​

@@ -29,7 +29,7 @@

 option(STATIC_LINK_CRT "Statically link C runtime for release builds" OFF)

 mark_as_advanced(FPROFILE_USE FPROFILE_GENERATE NATIVE_BUILD)

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

-set(X265_BUILD 188)

+set(X265_BUILD 192)

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

                "${PROJECT_BINARY_DIR}/x265.def")

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

@@ -40,7 +40,7 @@

 # System architecture detection

 string(TOLOWER "${CMAKE_SYSTEM_PROCESSOR}" SYSPROC)

 set(X86_ALIASES x86 i386 i686 x86_64 amd64)

-set(ARM_ALIASES armv6l armv7l)

+set(ARM_ALIASES armv6l armv7l aarch64)

 list(FIND X86_ALIASES "${SYSPROC}" X86MATCH)

 list(FIND ARM_ALIASES "${SYSPROC}" ARMMATCH)

 set(POWER_ALIASES ppc64 ppc64le)

@@ -70,9 +70,15 @@

     else()

         set(CROSS_COMPILE_ARM 0)

     endif()

-    message(STATUS "Detected ARM target processor")

     set(ARM 1)

-    add_definitions(-DX265_ARCH_ARM=1 -DHAVE_ARMV6=1)

+    if("${CMAKE_SIZEOF_VOID_P}" MATCHES 8)

+        message(STATUS "Detected ARM64 target processor")

+        set(ARM64 1)

+        add_definitions(-DX265_ARCH_ARM=1 -DX265_ARCH_ARM64=1 -DHAVE_ARMV6=0)

+    else()

+        message(STATUS "Detected ARM target processor")

+        add_definitions(-DX265_ARCH_ARM=1 -DX265_ARCH_ARM64=0 -DHAVE_ARMV6=1)

+    endif()

 else()

     message(STATUS "CMAKE_SYSTEM_PROCESSOR value `${CMAKE_SYSTEM_PROCESSOR}` is unknown")

     message(STATUS "Please add this value near ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE}")

@@ -95,6 +101,8 @@

         if(NUMA_FOUND)

             link_directories(${NUMA_LIBRARY_DIR})

             list(APPEND CMAKE_REQUIRED_LIBRARIES numa)

+            list(APPEND CMAKE_REQUIRED_INCLUDES ${NUMA_INCLUDE_DIR})

+            list(APPEND CMAKE_REQUIRED_LINK_OPTIONS "-L${NUMA_LIBRARY_DIR}")

             check_symbol_exists(numa_node_of_cpu numa.h NUMA_V2)

             if(NUMA_V2)

                 add_definitions(-DHAVE_LIBNUMA)

@@ -231,14 +239,24 @@

         endif()

     endif()

     if(ARM AND CROSS_COMPILE_ARM)

-        set(ARM_ARGS -march=armv6 -mfloat-abi=soft -mfpu=vfp -marm -fPIC)

+        if(ARM64)

+            set(ARM_ARGS -fPIC)

+        else()

+            set(ARM_ARGS -march=armv6 -mfloat-abi=soft -mfpu=vfp -marm -fPIC)

+        endif()

+        message(STATUS "cross compile arm")

     elseif(ARM)

-        find_package(Neon)

-        if(CPU_HAS_NEON)

-            set(ARM_ARGS -mcpu=native -mfloat-abi=hard -mfpu=neon -marm -fPIC)

+        if(ARM64)

+            set(ARM_ARGS -fPIC)

             add_definitions(-DHAVE_NEON)

         else()

-            set(ARM_ARGS -mcpu=native -mfloat-abi=hard -mfpu=vfp -marm)

+            find_package(Neon)

+            if(CPU_HAS_NEON)

+                set(ARM_ARGS -mcpu=native -mfloat-abi=hard -mfpu=neon -marm -fPIC)

+                add_definitions(-DHAVE_NEON)

+            else()

+                set(ARM_ARGS -mcpu=native -mfloat-abi=hard -mfpu=vfp -marm)

+            endif()

         endif()

     endif()

     add_definitions(${ARM_ARGS})

@@ -518,7 +536,11 @@

     # compile ARM arch asm files here

         enable_language(ASM)

         foreach(ASM ${ARM_ASMS})

-            set(ASM_SRC ${CMAKE_CURRENT_SOURCE_DIR}/common/arm/${ASM})

+            if(ARM64)

+                set(ASM_SRC ${CMAKE_CURRENT_SOURCE_DIR}/common/aarch64/${ASM})

+            else()

+                set(ASM_SRC ${CMAKE_CURRENT_SOURCE_DIR}/common/arm/${ASM})

+            endif()

             list(APPEND ASM_SRCS ${ASM_SRC})

             list(APPEND ASM_OBJS ${ASM}.${SUFFIX})

             add_custom_command(

@@ -725,16 +747,16 @@

         # Xcode seems unable to link the CLI with libs, so link as one targget

         if(ENABLE_HDR10_PLUS)

         add_executable(cli ../COPYING ${InputFiles} ${OutputFiles} ${GETOPT}

-                        x265.cpp x265.h x265cli.h

+                        x265.cpp x265.h x265cli.cpp x265cli.h abrEncApp.cpp abrEncApp.h

                         $<TARGET_OBJECTS:encoder> $<TARGET_OBJECTS:common> $<TARGET_OBJECTS:dynamicHDR10> ${ASM_OBJS})

         else()

             add_executable(cli ../COPYING ${InputFiles} ${OutputFiles} ${GETOPT}

-                        x265.cpp x265.h x265cli.h

+                        x265.cpp x265.h x265cli.cpp x265cli.h abrEncApp.cpp abrEncApp.h

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

         endif()

     else()

         add_executable(cli ../COPYING ${InputFiles} ${OutputFiles} ${GETOPT} ${X265_RC_FILE}

-                       ${ExportDefs} x265.cpp x265.h x265cli.h)

+                       ${ExportDefs} x265.cpp x265.h x265cli.cpp x265cli.h abrEncApp.cpp abrEncApp.h)

         if(WIN32 OR NOT ENABLE_SHARED OR INTEL_CXX)

             # The CLI cannot link to the shared library on Windows, it

             # requires internal APIs not exported from the DLL

​

@@ -0,0 +1,1108 @@

+/*****************************************************************************

+* Copyright (C) 2013-2020 MulticoreWare, Inc

+*

+* Authors: Pooja Venkatesan <pooja@multicorewareinc.com>

+*          Aruna Matheswaran <aruna@multicorewareinc.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

+* the Free Software Foundation; either version 2 of the License, or

+* (at your option) any later version.

+*

+* This program is distributed in the hope that it will be useful,

+* but WITHOUT ANY WARRANTY; without even the implied warranty of

+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

+* GNU General Public License for more details.

+*

+* You should have received a copy of the GNU General Public License

+* along with this program; if not, write to the Free Software

+* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111, USA.

+*

+* This program is also available under a commercial proprietary license.

+* For more information, contact us at license @ x265.com.

+*****************************************************************************/

+

+#include "abrEncApp.h"

+#include "mv.h"

+#include "slice.h"

+#include "param.h"

+

+#include <signal.h>

+#include <errno.h>

+

+#include <queue>

+

+using namespace X265_NS;

+

+/* Ctrl-C handler */

+static volatile sig_atomic_t b_ctrl_c /* = 0 */;

+static void sigint_handler(int)

+{

+    b_ctrl_c = 1;

+}

+

+namespace X265_NS {

+    // private namespace

+#define X265_INPUT_QUEUE_SIZE 250

+

+    AbrEncoder::AbrEncoder(CLIOptions cliopt[], uint8_t numEncodes, int &ret)

+    {

+        m_numEncodes = numEncodes;

+        m_numActiveEncodes.set(numEncodes);

+        m_queueSize = (numEncodes > 1) ? X265_INPUT_QUEUE_SIZE : 1;

+        m_passEnc = X265_MALLOC(PassEncoder*, m_numEncodes);

+

+        for (uint8_t i = 0; i < m_numEncodes; i++)

+        {

+            m_passEnc[i] = new PassEncoder(i, cliopt[i], this);

+            if (!m_passEnc[i])

+            {

+                x265_log(NULL, X265_LOG_ERROR, "Unable to allocate memory for passEncoder\n");

+                ret = 4;

+            }

+            m_passEnc[i]->init(ret);

+        }

+

+        if (!allocBuffers())

+        {

+            x265_log(NULL, X265_LOG_ERROR, "Unable to allocate memory for buffers\n");

+            ret = 4;

+        }

+

+        /* start passEncoder worker threads */

+        for (uint8_t pass = 0; pass < m_numEncodes; pass++)

+            m_passEnc[pass]->startThreads();

+    }

+

+    bool AbrEncoder::allocBuffers()

+    {

+        m_inputPicBuffer = X265_MALLOC(x265_picture**, m_numEncodes);

+        m_analysisBuffer = X265_MALLOC(x265_analysis_data*, m_numEncodes);

+

+        m_picWriteCnt = new ThreadSafeInteger[m_numEncodes];

+        m_picReadCnt = new ThreadSafeInteger[m_numEncodes];

+        m_analysisWriteCnt = new ThreadSafeInteger[m_numEncodes];

+        m_analysisReadCnt = new ThreadSafeInteger[m_numEncodes];

+

+        m_picIdxReadCnt = X265_MALLOC(ThreadSafeInteger*, m_numEncodes);

+        m_analysisWrite = X265_MALLOC(ThreadSafeInteger*, m_numEncodes);

+        m_analysisRead = X265_MALLOC(ThreadSafeInteger*, m_numEncodes);

+        m_readFlag = X265_MALLOC(int*, m_numEncodes);

+

+        for (uint8_t pass = 0; pass < m_numEncodes; pass++)

+        {

+            m_inputPicBuffer[pass] = X265_MALLOC(x265_picture*, m_queueSize);

+            for (uint32_t idx = 0; idx < m_queueSize; idx++)

+            {

+                m_inputPicBuffer[pass][idx] = x265_picture_alloc();

+                x265_picture_init(m_passEnc[pass]->m_param, m_inputPicBuffer[pass][idx]);

+            }

+

+            m_analysisBuffer[pass] = X265_MALLOC(x265_analysis_data, m_queueSize);

+            m_picIdxReadCnt[pass] = new ThreadSafeInteger[m_queueSize];

+            m_analysisWrite[pass] = new ThreadSafeInteger[m_queueSize];

+            m_analysisRead[pass] = new ThreadSafeInteger[m_queueSize];

+            m_readFlag[pass] = X265_MALLOC(int, m_queueSize);

+        }

+        return true;

+    }

+

+    void AbrEncoder::destroy()

+    {

+        x265_cleanup(); /* Free library singletons */

+        for (uint8_t pass = 0; pass < m_numEncodes; pass++)

+        {

+            for (uint32_t index = 0; index < m_queueSize; index++)

+            {

+                X265_FREE(m_inputPicBuffer[pass][index]->planes[0]);

+                x265_picture_free(m_inputPicBuffer[pass][index]);

+            }

+

+            X265_FREE(m_inputPicBuffer[pass]);

+            X265_FREE(m_analysisBuffer[pass]);

+            X265_FREE(m_readFlag[pass]);

+            delete[] m_picIdxReadCnt[pass];

+            delete[] m_analysisWrite[pass];

+            delete[] m_analysisRead[pass];

+            m_passEnc[pass]->destroy();

+            delete m_passEnc[pass];

+        }

+        X265_FREE(m_inputPicBuffer);

+        X265_FREE(m_analysisBuffer);

+        X265_FREE(m_readFlag);

+

+        delete[] m_picWriteCnt;

+        delete[] m_picReadCnt;

+        delete[] m_analysisWriteCnt;

+        delete[] m_analysisReadCnt;

+

+        X265_FREE(m_picIdxReadCnt);

+        X265_FREE(m_analysisWrite);

+        X265_FREE(m_analysisRead);

+

+        X265_FREE(m_passEnc);

+    }

+

+    PassEncoder::PassEncoder(uint32_t id, CLIOptions cliopt, AbrEncoder *parent)

+    {

+        m_id = id;

+        m_cliopt = cliopt;

+        m_parent = parent;

+        if(!(m_cliopt.enableScaler && m_id))

+            m_input = m_cliopt.input;

+        m_param = cliopt.param;

+        m_inputOver = false;

+        m_lastIdx = -1;

+        m_encoder = NULL;

+        m_scaler = NULL;

+        m_reader = NULL;

+        m_ret = 0;

+    }

+

+    int PassEncoder::init(int &result)

+    {

+        if (m_parent->m_numEncodes > 1)

+            setReuseLevel();

+                

+        if (!(m_cliopt.enableScaler && m_id))

+            m_reader = new Reader(m_id, this);

+        else

+        {

+            VideoDesc *src = NULL, *dst = NULL;

+            dst = new VideoDesc(m_param->sourceWidth, m_param->sourceHeight, m_param->internalCsp, m_param->internalBitDepth);

+            int dstW = m_parent->m_passEnc[m_id - 1]->m_param->sourceWidth;

+            int dstH = m_parent->m_passEnc[m_id - 1]->m_param->sourceHeight;

+            src = new VideoDesc(dstW, dstH, m_param->internalCsp, m_param->internalBitDepth);

+            if (src != NULL && dst != NULL)

+            {

+                m_scaler = new Scaler(0, 1, m_id, src, dst, this);

+                if (!m_scaler)

+                {

+                    x265_log(m_param, X265_LOG_ERROR, "\n MALLOC failure in Scaler");

+                    result = 4;

+                }

+            }

+        }

+

+        /* note: we could try to acquire a different libx265 API here based on

+        * the profile found during option parsing, but it must be done before

+        * opening an encoder */

+

+        if (m_param)

+            m_encoder = m_cliopt.api->encoder_open(m_param);

+        if (!m_encoder)

+        {

+            x265_log(NULL, X265_LOG_ERROR, "x265_encoder_open() failed for Enc, \n");

+            m_ret = 2;

+            return -1;

+        }

+

+        /* get the encoder parameters post-initialization */

+        m_cliopt.api->encoder_parameters(m_encoder, m_param);

+

+        return 1;

+    }

+

+    void PassEncoder::setReuseLevel()

+    {

+        uint32_t r, padh = 0, padw = 0;

+

+        m_param->confWinBottomOffset = m_param->confWinRightOffset = 0;

+

+        m_param->analysisLoadReuseLevel = m_cliopt.loadLevel;

+        m_param->analysisSaveReuseLevel = m_cliopt.saveLevel;

+        m_param->analysisSave = m_cliopt.saveLevel ? "save.dat" : NULL;

+        m_param->analysisLoad = m_cliopt.loadLevel ? "load.dat" : NULL;

+        m_param->bUseAnalysisFile = 0;

+

+        if (m_cliopt.loadLevel)

+        {

+            x265_param *refParam = m_parent->m_passEnc[m_cliopt.refId]->m_param;

+

+            if (m_param->sourceHeight == (refParam->sourceHeight - refParam->confWinBottomOffset) &&

+                m_param->sourceWidth == (refParam->sourceWidth - refParam->confWinRightOffset))

+            {

+                m_parent->m_passEnc[m_id]->m_param->confWinBottomOffset = refParam->confWinBottomOffset;

+                m_parent->m_passEnc[m_id]->m_param->confWinRightOffset = refParam->confWinRightOffset;

+            }

+            else

+            {

+                int srcH = refParam->sourceHeight - refParam->confWinBottomOffset;

+                int srcW = refParam->sourceWidth - refParam->confWinRightOffset;

+

+                double scaleFactorH = double(m_param->sourceHeight / srcH);

+                double scaleFactorW = double(m_param->sourceWidth / srcW);

+

+                int absScaleFactorH = (int)(10 * scaleFactorH + 0.5);

+                int absScaleFactorW = (int)(10 * scaleFactorW + 0.5);

+

+                if (absScaleFactorH == 20 && absScaleFactorW == 20)

+                {

+                    m_param->scaleFactor = 2;

+

+                    m_parent->m_passEnc[m_id]->m_param->confWinBottomOffset = refParam->confWinBottomOffset * 2;

+                    m_parent->m_passEnc[m_id]->m_param->confWinRightOffset = refParam->confWinRightOffset * 2;

+

+                }

+            }

+        }

+

+        int h = m_param->sourceHeight + m_param->confWinBottomOffset;

+        int w = m_param->sourceWidth + m_param->confWinRightOffset;

+        if (h & (m_param->minCUSize - 1))

+        {

+            r = h & (m_param->minCUSize - 1);

+            padh = m_param->minCUSize - r;

+            m_param->confWinBottomOffset += padh;

+

+        }

+

+        if (w & (m_param->minCUSize - 1))

+        {

+            r = w & (m_param->minCUSize - 1);

+            padw = m_param->minCUSize - r;

+            m_param->confWinRightOffset += padw;

+        }

+    }

+

+    void PassEncoder::startThreads()

+    {

+        /* Start slave worker threads */

+        m_threadActive = true;

+        start();

+        /* Start reader threads*/

+        if (m_reader != NULL)

+        {

+            m_reader->m_threadActive = true;

+            m_reader->start();

+        }

+        /* Start scaling worker threads */

+        if (m_scaler != NULL)

+        {

+            m_scaler->m_threadActive = true;

+            m_scaler->start();

+        }

+    }

+

+    void PassEncoder::copyInfo(x265_analysis_data * src)

+    {

+

+        uint32_t written = m_parent->m_analysisWriteCnt[m_id].get();

+

+        int index = written % m_parent->m_queueSize;

+        //If all streams have read analysis data, reuse that position in Queue

+

+        int read = m_parent->m_analysisRead[m_id][index].get();

+        int write = m_parent->m_analysisWrite[m_id][index].get();

+

+        int overwrite = written / m_parent->m_queueSize;

+        bool emptyIdxFound = 0;

+        while (!emptyIdxFound && overwrite)

+        {

+            for (uint32_t i = 0; i < m_parent->m_queueSize; i++)

+            {

+                read = m_parent->m_analysisRead[m_id][i].get();

+                write = m_parent->m_analysisWrite[m_id][i].get();

+                write *= m_cliopt.numRefs;

+

+                if (read == write)

+                {

+                    index = i;

+                    emptyIdxFound = 1;

+                }

+            }

+        }

+

+        x265_analysis_data *m_analysisInfo = &m_parent->m_analysisBuffer[m_id][index];

+

+        memcpy(m_analysisInfo, src, sizeof(x265_analysis_data));

+        x265_alloc_analysis_data(m_param, m_analysisInfo);

+

+        bool isVbv = m_param->rc.vbvBufferSize && m_param->rc.vbvMaxBitrate;

+        if (m_param->bDisableLookahead && isVbv)

+        {

+            memcpy(m_analysisInfo->lookahead.intraSatdForVbv, src->lookahead.intraSatdForVbv, src->numCuInHeight * sizeof(uint32_t));

+            memcpy(m_analysisInfo->lookahead.satdForVbv, src->lookahead.satdForVbv, src->numCuInHeight * sizeof(uint32_t));

+            memcpy(m_analysisInfo->lookahead.intraVbvCost, src->lookahead.intraVbvCost, src->numCUsInFrame * sizeof(uint32_t));

+            memcpy(m_analysisInfo->lookahead.vbvCost, src->lookahead.vbvCost, src->numCUsInFrame * sizeof(uint32_t));

+        }

+

+        if (src->sliceType == X265_TYPE_IDR || src->sliceType == X265_TYPE_I)

+        {

+            if (m_param->analysisSaveReuseLevel < 2)

+                goto ret;

+            x265_analysis_intra_data *intraDst, *intraSrc;

+            intraDst = (x265_analysis_intra_data*)m_analysisInfo->intraData;

+            intraSrc = (x265_analysis_intra_data*)src->intraData;

+            memcpy(intraDst->depth, intraSrc->depth, sizeof(uint8_t) * src->depthBytes);

+            memcpy(intraDst->modes, intraSrc->modes, sizeof(uint8_t) * src->numCUsInFrame * src->numPartitions);

+            memcpy(intraDst->partSizes, intraSrc->partSizes, sizeof(char) * src->depthBytes);

+            memcpy(intraDst->chromaModes, intraSrc->chromaModes, sizeof(uint8_t) * src->depthBytes);

+            if (m_param->rc.cuTree)

+                memcpy(intraDst->cuQPOff, intraSrc->cuQPOff, sizeof(int8_t) * src->depthBytes);

+        }

+        else

+        {

+            bool bIntraInInter = (src->sliceType == X265_TYPE_P || m_param->bIntraInBFrames);

+            int numDir = src->sliceType == X265_TYPE_P ? 1 : 2;

+            memcpy(m_analysisInfo->wt, src->wt, sizeof(WeightParam) * 3 * numDir);

+            if (m_param->analysisSaveReuseLevel < 2)

+                goto ret;

+            x265_analysis_inter_data *interDst, *interSrc;

+            interDst = (x265_analysis_inter_data*)m_analysisInfo->interData;

+            interSrc = (x265_analysis_inter_data*)src->interData;

+            memcpy(interDst->depth, interSrc->depth, sizeof(uint8_t) * src->depthBytes);

+            memcpy(interDst->modes, interSrc->modes, sizeof(uint8_t) * src->depthBytes);

+            if (m_param->rc.cuTree)

+                memcpy(interDst->cuQPOff, interSrc->cuQPOff, sizeof(int8_t) * src->depthBytes);

+            if (m_param->analysisSaveReuseLevel > 4)

+            {

+                memcpy(interDst->partSize, interSrc->partSize, sizeof(uint8_t) * src->depthBytes);

+                memcpy(interDst->mergeFlag, interSrc->mergeFlag, sizeof(uint8_t) * src->depthBytes);

+                if (m_param->analysisSaveReuseLevel == 10)

+                {

+                    memcpy(interDst->interDir, interSrc->interDir, sizeof(uint8_t) * src->depthBytes);

+                    for (int dir = 0; dir < numDir; dir++)

+                    {

+                        memcpy(interDst->mvpIdx[dir], interSrc->mvpIdx[dir], sizeof(uint8_t) * src->depthBytes);

+                        memcpy(interDst->refIdx[dir], interSrc->refIdx[dir], sizeof(int8_t) * src->depthBytes);

+                        memcpy(interDst->mv[dir], interSrc->mv[dir], sizeof(MV) * src->depthBytes);

+                    }

+                    if (bIntraInInter)

+                    {

+                        x265_analysis_intra_data *intraDst = (x265_analysis_intra_data*)m_analysisInfo->intraData;

+                        x265_analysis_intra_data *intraSrc = (x265_analysis_intra_data*)src->intraData;

+                        memcpy(intraDst->modes, intraSrc->modes, sizeof(uint8_t) * src->numPartitions * src->numCUsInFrame);

+                        memcpy(intraDst->chromaModes, intraSrc->chromaModes, sizeof(uint8_t) * src->depthBytes);

+                    }

+               }

+            }

+            if (m_param->analysisSaveReuseLevel != 10)

+                memcpy(interDst->ref, interSrc->ref, sizeof(int32_t) * src->numCUsInFrame * X265_MAX_PRED_MODE_PER_CTU * numDir);

+        }

+

+ret:

+        //increment analysis Write counter 

+        m_parent->m_analysisWriteCnt[m_id].incr();

+        m_parent->m_analysisWrite[m_id][index].incr();

+        return;

+    }

+

+

+    bool PassEncoder::readPicture(x265_picture *dstPic)

+    {

+        /*Check and wait if there any input frames to read*/

+        int ipread = m_parent->m_picReadCnt[m_id].get();

+        int ipwrite = m_parent->m_picWriteCnt[m_id].get();

+

+        bool isAbrLoad = m_cliopt.loadLevel && (m_parent->m_numEncodes > 1);

+        while (!m_inputOver && (ipread == ipwrite))

+        {

+            ipwrite = m_parent->m_picWriteCnt[m_id].waitForChange(ipwrite);

+        }

+

+        if (m_threadActive && ipread < ipwrite)

+        {

+            /*Get input index to read from inputQueue. If doesn't need analysis info, it need not wait to fetch poc from analysisQueue*/

+            int readPos = ipread % m_parent->m_queueSize;

+            x265_analysis_data* analysisData = 0;

+

+            if (isAbrLoad)

+            {

+                /*If stream is master of each slave pass, then fetch analysis data from prev pass*/

+                int analysisQId = m_cliopt.refId;

+                /*Check and wait if there any analysis Data to read*/

+                int analysisWrite = m_parent->m_analysisWriteCnt[analysisQId].get();

+                int written = analysisWrite * m_parent->m_passEnc[analysisQId]->m_cliopt.numRefs;

+                int analysisRead = m_parent->m_analysisReadCnt[analysisQId].get();

+                

+                while (m_threadActive && written == analysisRead)

+                {

+                    analysisWrite = m_parent->m_analysisWriteCnt[analysisQId].waitForChange(analysisWrite);

+                    written = analysisWrite * m_parent->m_passEnc[analysisQId]->m_cliopt.numRefs;

+                }

+

+                if (analysisRead < written)

+                {

+                    int analysisIdx = 0;

+                    if (!m_param->bDisableLookahead)

+                    {

+                        bool analysisdRead = false;

+                        while ((analysisRead < written) && !analysisdRead)

+                        {

+                            while (analysisWrite < ipread)

+                            {

+                                analysisWrite = m_parent->m_analysisWriteCnt[analysisQId].waitForChange(analysisWrite);

+                                written = analysisWrite * m_parent->m_passEnc[analysisQId]->m_cliopt.numRefs;

+                            }

+                            for (uint32_t i = 0; i < m_parent->m_queueSize; i++)

+                            {

+                                analysisData = &m_parent->m_analysisBuffer[analysisQId][i];

+                                int read = m_parent->m_analysisRead[analysisQId][i].get();

+                                int write = m_parent->m_analysisWrite[analysisQId][i].get() * m_parent->m_passEnc[analysisQId]->m_cliopt.numRefs;

+                                if ((analysisData->poc == (uint32_t)(ipread)) && (read < write))

+                                {

+                                    analysisIdx = i;

+                                    analysisdRead = true;

+                                    break;

+                                }

+                            }

+                        }

+                    }

+                    else

+                    {

+                        analysisIdx = analysisRead % m_parent->m_queueSize;

+                        analysisData = &m_parent->m_analysisBuffer[analysisQId][analysisIdx];

+                        readPos = analysisData->poc % m_parent->m_queueSize;

+                        while ((ipwrite < readPos) || ((ipwrite - 1) < (int)analysisData->poc))

+                        {

+                            ipwrite = m_parent->m_picWriteCnt[m_id].waitForChange(ipwrite);

+                        }

+                    }

+

+                    m_lastIdx = analysisIdx;

+                }

+                else

+                    return false;

+            }

+

+

+            x265_picture *srcPic = (x265_picture*)(m_parent->m_inputPicBuffer[m_id][readPos]);

+

+            x265_picture *pic = (x265_picture*)(dstPic);

+            pic->colorSpace = srcPic->colorSpace;

+            pic->bitDepth = srcPic->bitDepth;

+            pic->framesize = srcPic->framesize;

+            pic->height = srcPic->height;

+            pic->pts = srcPic->pts;

+            pic->dts = srcPic->dts;

+            pic->reorderedPts = srcPic->reorderedPts;

+            pic->width = srcPic->width;

+            pic->analysisData = srcPic->analysisData;

+            pic->userSEI = srcPic->userSEI;

+            pic->stride[0] = srcPic->stride[0];

+            pic->stride[1] = srcPic->stride[1];

+            pic->stride[2] = srcPic->stride[2];

+            pic->planes[0] = srcPic->planes[0];

+            pic->planes[1] = srcPic->planes[1];

+            pic->planes[2] = srcPic->planes[2];

+            if (isAbrLoad)

+                pic->analysisData = *analysisData;

+            return true;

+        }

+        else

+            return false;

+    }

+

+    void PassEncoder::threadMain()

+    {

+        THREAD_NAME("PassEncoder", m_id);

+

+        while (m_threadActive)

+        {

+

+#if ENABLE_LIBVMAF

+            x265_vmaf_data* vmafdata = m_cliopt.vmafData;

+#endif

+            /* This allows muxers to modify bitstream format */

+            m_cliopt.output->setParam(m_param);

+            const x265_api* api = m_cliopt.api;

+            ReconPlay* reconPlay = NULL;

+            if (m_cliopt.reconPlayCmd)

+                reconPlay = new ReconPlay(m_cliopt.reconPlayCmd, *m_param);

+            char* profileName = m_cliopt.encName ? m_cliopt.encName : (char *)"x265";

+

+            if (m_cliopt.zoneFile)

+            {

+                if (!m_cliopt.parseZoneFile())

+                {

+                    x265_log(NULL, X265_LOG_ERROR, "Unable to parse zonefile in %s\n", profileName);

+                    fclose(m_cliopt.zoneFile);

+                    m_cliopt.zoneFile = NULL;

+                }

+            }

+

+            if (signal(SIGINT, sigint_handler) == SIG_ERR)

+                x265_log(m_param, X265_LOG_ERROR, "Unable to register CTRL+C handler: %s in %s\n",

+                    strerror(errno), profileName);

+

+            x265_picture pic_orig, pic_out;

+            x265_picture *pic_in = &pic_orig;

+            /* Allocate recon picture if analysis save/load is enabled */

+            std::priority_queue<int64_t>* pts_queue = m_cliopt.output->needPTS() ? new std::priority_queue<int64_t>() : NULL;

+            x265_picture *pic_recon = (m_cliopt.recon || m_param->analysisSave || m_param->analysisLoad || pts_queue || reconPlay || m_param->csvLogLevel) ? &pic_out : NULL;

+            uint32_t inFrameCount = 0;

+            uint32_t outFrameCount = 0;

+            x265_nal *p_nal;

+            x265_stats stats;

+            uint32_t nal;

+            int16_t *errorBuf = NULL;

+            bool bDolbyVisionRPU = false;

+            uint8_t *rpuPayload = NULL;

+            int inputPicNum = 1;

+            x265_picture picField1, picField2;

+            x265_analysis_data* analysisInfo = (x265_analysis_data*)(&pic_out.analysisData);

+            bool isAbrSave = m_cliopt.saveLevel && (m_parent->m_numEncodes > 1);

+

+            if (!m_param->bRepeatHeaders && !m_param->bEnableSvtHevc)

+            {

+                if (api->encoder_headers(m_encoder, &p_nal, &nal) < 0)

+                {

+                    x265_log(m_param, X265_LOG_ERROR, "Failure generating stream headers in %s\n", profileName);

+                    m_ret = 3;

+                    goto fail;

+                }

+                else

+                    m_cliopt.totalbytes += m_cliopt.output->writeHeaders(p_nal, nal);

+            }

+

+            if (m_param->bField && m_param->interlaceMode)

+            {

+                api->picture_init(m_param, &picField1);

+                api->picture_init(m_param, &picField2);

+                // return back the original height of input

+                m_param->sourceHeight *= 2;

+                api->picture_init(m_param, &pic_orig);

+            }

+            else

+                api->picture_init(m_param, &pic_orig);

+

+            if (m_param->dolbyProfile && m_cliopt.dolbyVisionRpu)

+            {

+                rpuPayload = X265_MALLOC(uint8_t, 1024);

+                pic_in->rpu.payload = rpuPayload;

+                if (pic_in->rpu.payload)

+                    bDolbyVisionRPU = true;

+            }

+

+            if (m_cliopt.bDither)

+            {

+                errorBuf = X265_MALLOC(int16_t, m_param->sourceWidth + 1);

+                if (errorBuf)

+                    memset(errorBuf, 0, (m_param->sourceWidth + 1) * sizeof(int16_t));

+                else

+                    m_cliopt.bDither = false;

+            }

+

+            // main encoder loop

+            while (pic_in && !b_ctrl_c)

+            {

+                pic_orig.poc = (m_param->bField && m_param->interlaceMode) ? inFrameCount * 2 : inFrameCount;

+                if (m_cliopt.qpfile)

+                {

+                    if (!m_cliopt.parseQPFile(pic_orig))

+                    {

+                        x265_log(NULL, X265_LOG_ERROR, "can't parse qpfile for frame %d in %s\n",

+                            pic_in->poc, profileName);

+                        fclose(m_cliopt.qpfile);

+                        m_cliopt.qpfile = NULL;

+                    }

+                }

+

+                if (m_cliopt.framesToBeEncoded && inFrameCount >= m_cliopt.framesToBeEncoded)

+                    pic_in = NULL;

+                else if (readPicture(pic_in))

+                    inFrameCount++;

+                else

+                    pic_in = NULL;

+

+                if (pic_in)

+                {

+                    if (pic_in->bitDepth > m_param->internalBitDepth && m_cliopt.bDither)

+                    {

+                        x265_dither_image(pic_in, m_cliopt.input->getWidth(), m_cliopt.input->getHeight(), errorBuf, m_param->internalBitDepth);

+                        pic_in->bitDepth = m_param->internalBitDepth;

+                    }

+                    /* Overwrite PTS */

+                    pic_in->pts = pic_in->poc;

+

+                    // convert to field

+                    if (m_param->bField && m_param->interlaceMode)

+                    {

+                        int height = pic_in->height >> 1;

+

+                        int static bCreated = 0;

+                        if (bCreated == 0)

+                        {

+                            bCreated = 1;

+                            inputPicNum = 2;

+                            picField1.fieldNum = 1;

+                            picField2.fieldNum = 2;

+

+                            picField1.bitDepth = picField2.bitDepth = pic_in->bitDepth;

+                            picField1.colorSpace = picField2.colorSpace = pic_in->colorSpace;

+                            picField1.height = picField2.height = pic_in->height >> 1;

+                            picField1.framesize = picField2.framesize = pic_in->framesize >> 1;

+

+                            size_t fieldFrameSize = (size_t)pic_in->framesize >> 1;

+                            char* field1Buf = X265_MALLOC(char, fieldFrameSize);

+                            char* field2Buf = X265_MALLOC(char, fieldFrameSize);

+

+                            int stride = picField1.stride[0] = picField2.stride[0] = pic_in->stride[0];

+                            uint64_t framesize = stride * (height >> x265_cli_csps[pic_in->colorSpace].height[0]);

+                            picField1.planes[0] = field1Buf;

+                            picField2.planes[0] = field2Buf;

+                            for (int i = 1; i < x265_cli_csps[pic_in->colorSpace].planes; i++)

+                            {

+                                picField1.planes[i] = field1Buf + framesize;

+                                picField2.planes[i] = field2Buf + framesize;

+

+                                stride = picField1.stride[i] = picField2.stride[i] = pic_in->stride[i];

+                                framesize += (stride * (height >> x265_cli_csps[pic_in->colorSpace].height[i]));

+                            }

+                            assert(framesize == picField1.framesize);

+                        }

+

+                        picField1.pts = picField1.poc = pic_in->poc;

+                        picField2.pts = picField2.poc = pic_in->poc + 1;

+

+                        picField1.userSEI = picField2.userSEI = pic_in->userSEI;

+

+                        //if (pic_in->userData)

+                        //{

+                        //    // Have to handle userData here

+                        //}

+

+                        if (pic_in->framesize)

+                        {

+                            for (int i = 0; i < x265_cli_csps[pic_in->colorSpace].planes; i++)

+                            {

+                                char* srcP1 = (char*)pic_in->planes[i];

+                                char* srcP2 = (char*)pic_in->planes[i] + pic_in->stride[i];

+                                char* p1 = (char*)picField1.planes[i];

+                                char* p2 = (char*)picField2.planes[i];

+

+                                int stride = picField1.stride[i];

+

+                                for (int y = 0; y < (height >> x265_cli_csps[pic_in->colorSpace].height[i]); y++)

+                                {

+                                    memcpy(p1, srcP1, stride);

+                                    memcpy(p2, srcP2, stride);

+                                    srcP1 += 2 * stride;

+                                    srcP2 += 2 * stride;

+                                    p1 += stride;

+                                    p2 += stride;

+                                }

+                            }

+                        }

+                    }

+

+                    if (bDolbyVisionRPU)

+                    {

+                        if (m_param->bField && m_param->interlaceMode)

+                        {

+                            if (m_cliopt.rpuParser(&picField1) > 0)

+                                goto fail;

+                            if (m_cliopt.rpuParser(&picField2) > 0)

+                                goto fail;

+                        }

+                        else

+                        {

+                            if (m_cliopt.rpuParser(pic_in) > 0)

+                                goto fail;

+                        }

+                    }

+                }

+

+                for (int inputNum = 0; inputNum < inputPicNum; inputNum++)

+                {

+                    x265_picture *picInput = NULL;

+                    if (inputPicNum == 2)

+                        picInput = pic_in ? (inputNum ? &picField2 : &picField1) : NULL;

+                    else

+                        picInput = pic_in;

+

+                    int numEncoded = api->encoder_encode(m_encoder, &p_nal, &nal, picInput, pic_recon);

+

+                    int idx = (inFrameCount - 1) % m_parent->m_queueSize;

+                    m_parent->m_picIdxReadCnt[m_id][idx].incr();

+                    m_parent->m_picReadCnt[m_id].incr();

+                    if (m_cliopt.loadLevel && picInput)

+                    {

+                        m_parent->m_analysisReadCnt[m_cliopt.refId].incr();

+                        m_parent->m_analysisRead[m_cliopt.refId][m_lastIdx].incr();

+                    }

+

+                    if (numEncoded < 0)

+                    {

+                        b_ctrl_c = 1;

+                        m_ret = 4;

+                        break;

+                    }

+

+                    if (reconPlay && numEncoded)

+                        reconPlay->writePicture(*pic_recon);

+

+                    outFrameCount += numEncoded;

+

+                    if (isAbrSave && numEncoded)

+                    {

+                        copyInfo(analysisInfo);

+                    }

+

+                    if (numEncoded && pic_recon && m_cliopt.recon)

+                        m_cliopt.recon->writePicture(pic_out);

+                    if (nal)

+                    {

+                        m_cliopt.totalbytes += m_cliopt.output->writeFrame(p_nal, nal, pic_out);

+                        if (pts_queue)

+                        {

+                            pts_queue->push(-pic_out.pts);

+                            if (pts_queue->size() > 2)

+                                pts_queue->pop();

+                        }

+                    }

+                    m_cliopt.printStatus(outFrameCount);

+                }

+            }

+

+            /* Flush the encoder */

+            while (!b_ctrl_c)

+            {

+                int numEncoded = api->encoder_encode(m_encoder, &p_nal, &nal, NULL, pic_recon);

+                if (numEncoded < 0)

+                {

+                    m_ret = 4;

+                    break;

+                }

+

+                if (reconPlay && numEncoded)

+                    reconPlay->writePicture(*pic_recon);

+

+                outFrameCount += numEncoded;

+                if (isAbrSave && numEncoded)

+                {

+                    copyInfo(analysisInfo);

+                }

+

+                if (numEncoded && pic_recon && m_cliopt.recon)

+                    m_cliopt.recon->writePicture(pic_out);

+                if (nal)

+                {

+                    m_cliopt.totalbytes += m_cliopt.output->writeFrame(p_nal, nal, pic_out);

+                    if (pts_queue)

+                    {