Request 2403 (accepted)

kvazaar.changes Changed

kvazaar.spec Changed

@@ -1,7 +1,7 @@
 #
 # spec file for package kvazaar
 #
-# Copyright (c) 2015 Packman Team <packman@links2linux.de>
+# Copyright (c) 2016 Packman Team <packman@links2linux.de>
 #
 # All modifications and additions to the file contributed by third parties
 # remain the property of their copyright owners, unless otherwise agreed
@@ -18,14 +18,17 @@
 %define libname libkvazaar
 %define libmver 2
 Name:           kvazaar
-Version:        0.7.2
+Version:        0.8.1
 Release:        0
 Summary:        HEVC encoder
 License:        LGPL-2.1
 Group:          Productivity/Multimedia/Video/Editors and Convertors
 Url:            http://ultravideo.cs.tut.fi/#encoder
 Source0:        https://github.com/ultravideo/%{name}/archive/v%{version}.tar.gz#/%{name}-%{version}.tar.gz
+BuildRequires:  automake
+BuildRequires:  findutils
 BuildRequires:  gcc >= 4.4
+BuildRequires:  libtool
 BuildRequires:  make
 BuildRequires:  pkg-config
 %ifnarch %arm
@@ -44,30 +47,34 @@
 %{libname} shared library
 
 %package -n %{libname}-devel
-Summary:        Header files and static library for the %{libname} library
+Summary:        Header files %{libname}
 Group:          Development/Libraries/C and C++
 Requires:       %{libname}%{libmver} = %{version}
 
 %description -n %{libname}-devel
-An open-source HEVC encoder
+Header files for the %{libname} library
 
 %prep
 %setup -q
 
 %build
-cd src
+autoreconf -fi
+%configure --disable-static
 make %{?_smp_mflags}
 
 %install
-cd src
-make install PREFIX=%{_prefix} LIBDIR=%{_libdir} DESTDIR=%{buildroot}
+make install DESTDIR=%{buildroot}
+find %{buildroot} -type f -name "*.la" -delete -print
 
 %post   -n %{libname}%{libmver} -p /sbin/ldconfig
 %postun -n %{libname}%{libmver} -p /sbin/ldconfig
 
 %files
 %defattr(-,root,root)
-%doc COPYING CREDITS README.md
+%dir %{_datadir}/doc/%{name}
+%doc %{_datadir}/doc/%{name}/COPYING
+%doc %{_datadir}/doc/%{name}/CREDITS
+%doc %{_datadir}/doc/%{name}/README.md
 %{_bindir}/kvazaar
 
 %files -n %{libname}%{libmver}
@@ -79,7 +86,6 @@
 %defattr(-,root,root)
 %{_includedir}/kvazaar.h
 %{_includedir}/kvazaar_version.h
-%{_libdir}/%{libname}.a
 %{_libdir}/%{libname}.so
 %{_libdir}/pkgconfig/kvazaar.pc

kvazaar-0.7.2.tar.gz/src/Makefile Deleted

@@ -1,394 +0,0 @@
-# Simple Makefile for Kvazaar HEVC encoder
-
-all: cli lib-shared
-.PHONY: all
-
-# Installation locations
-DESTDIR =
-PREFIX  = /usr/local
-BINDIR  = $(PREFIX)/bin
-INCDIR  = $(PREFIX)/include
-LIBDIR  = $(PREFIX)/lib
-DLLDIR  = $(BINDIR)
-
-# Library version number
-VER_MAJOR = 2
-VER_MINOR = 1
-VER_RELEASE = 0
-
-PROG   = kvazaar
-DEBUG  = kvazaar_debug
-TESTS  = kvazaar_tests
-
-NAME   = libkvazaar
-STATIC = $(NAME).a
-SO     = $(NAME).so
-LIB    = $(SO).$(VER_MAJOR).$(VER_MINOR).$(VER_RELEASE)
-DYLIB  = $(NAME).$(VER_MAJOR).dylib
-DLL    = kvazaar.dll
-IMPLIB = libkvazaar.dll.a
-INC    = kvazaar.h \
-         kvazaar_version.h
-
-# Compilers and other tools
-AS = yasm
-LD = $(CC)
-INSTALL = install
-LN_S = ln -s
-RANLIB = ranlib
-
-# Do not use variable length arrays because they don't work in Visual Studio 2013.
-WARNINGS = -Werror -Wall -Wtype-limits -Wvla
-INCLUDEDIRS = -I. -I./strategies -I./extras -I..
-
-# nasm requires trailing slashes in include directories
-ASFLAGS += $(patsubst %,%/,$(INCLUDEDIRS))
-
-# Notes about optimization levels:
-# Overall, kvazaar seems to run 15-20 % faster when compiled with gcc.
-# gcc-5.1.1: no benefit from -flto, slight harm from -O3
-# clang-4.3.0: slight benefit from -O3, more from -flto
-CFLAGS += -O2 -g -ftree-vectorize
-
-CFLAGS += -fvisibility=hidden -std=gnu99
-CFLAGS += -DKVZ_DLL_EXPORTS
-CFLAGS += $(INCLUDEDIRS) $(WARNINGS)
-LDFLAGS += -O2 -fvisibility=hidden -lm -pthread
-
-ARCH ?= $(shell uname -m)
-
-ifneq ($(findstring Windows, $(OS)),)
-  SYSTEM ?= Windows
-else
-  SYSTEM ?= $(shell uname -s)
-endif
-
-# ARCH related flags
-ifeq (, $(filter-out i386 i686 x86_64 amd64, $(ARCH)))
-  TARGET_CPU_ARCH := x86
-else ifeq (, $(filter-out ppc ppc64, $(ARCH)))
-  TARGET_CPU_ARCH := ppc
-else ifeq (, $(filter-out armv7l armv6l, $(ARCH)))
-  TARGET_CPU_ARCH := arm
-else
-  TARGET_CPU_ARCH := x86
-endif
-
-ifeq (, $(filter-out i386 i686 ppc, $(ARCH)))
-  TARGET_CPU_BITS := 32
-else ifeq (, $(filter-out x86_64 amd64 ppc64, $(ARCH)))
-  TARGET_CPU_BITS := 64
-else
-  TARGET_CPU_BITS := 0
-endif
-
-# The -m32 and -m64 flags are used for making sure the C files use the same
-# instruction set as the ASM files. They can't be used on ARM processors.
-ifneq (0, $(TARGET_CPU_BITS))
-  CFLAGS += -m$(TARGET_CPU_BITS)
-  LDFLAGS += -m$(TARGET_CPU_BITS)
-endif
-
-INSTALL_TARGETS = install-prog install-pc
-
-# Windows (cygwin/mingw) specific flags
-ifeq ($(SYSTEM), Windows)
-  ifeq ($(TARGET_CPU_BITS), 64)
-    ASFLAGS += -f win64
-    ASFLAGS += -DHAVE_ALIGNED_STACK=1
-  else
-    ASFLAGS += -f win32
-    ASFLAGS += -DPREFIX
-    ASFLAGS += -DHAVE_ALIGNED_STACK=0
-  endif
-  CFLAGS += -D__USE_MINGW_ANSI_STDIO=1
-  LIBKVAZAAR_SHARED = $(DLL)
-  INSTALL_TARGETS += install-dll
-
-# OS X specific flags
-else ifeq ($(SYSTEM), Darwin)
-  ifeq ($(TARGET_CPU_BITS), 64)
-    ASFLAGS += -f macho64
-  else
-    ASFLAGS += -f macho32
-  endif
-  ASFLAGS += -DPREFIX
-  LIBKVAZAAR_SHARED = $(DYLIB)
-  INSTALL_TARGETS += install-dylib
-
-# Default to Linux/elf specific flags
-else
-  LIBS += -lrt
-  LDFLAGS += -Wl,-z,noexecstack
-  ifeq ($(TARGET_CPU_BITS), 64)
-    ASFLAGS += -f elf64
-  else
-    ASFLAGS += -f elf32
-  endif
-  LIBKVAZAAR_SHARED = $(LIB)
-  INSTALL_TARGETS += install-lib install-static
-endif
-
-# Flags shared across systems
-ifeq ($(TARGET_CPU_ARCH) $(TARGET_CPU_BITS), x86 64)
-  ASFLAGS += -DARCH_X86_64=1
-else
-  ASFLAGS += -DARCH_X86_64=0
-endif
-
-# Disable ASM optimizations if YASM is not found on path.
-ifndef KVZ_DISABLE_ASM
-  has_as := $(shell type $(AS) 2>/dev/null)
-  ifeq ($(has_as),)
-    KVZ_DISABLE_ASM := 1
-  endif
-endif
-
-ifdef CHECKPOINTS
-  CFLAGS += -DCHECKPOINTS
-endif
-
-# The optimized functions reside in these instruction set specific
-# directories. If the instruction set is supported by the
-# architecture, compile the files in these directories with the
-# apropriate flags to cause the intrinsics to work.
-# Note: Using LTO on strategies caused issues on some older
-# compilers, -fno-lto on these files seemed to fix the issue.
-# LTO is no longer used and -fno-lto shouldn't be needed.
-ifeq ($(TARGET_CPU_ARCH), ppc)
-  strategies/altivec/%.o:  EXTRA_FLAGS += -maltivec
-  strategies/altivec/%.lo: EXTRA_FLAGS += -maltivec
-else ifeq ($(TARGET_CPU_ARCH), x86)
-  strategies/sse2/%.o:   EXTRA_FLAGS += -msse2
-  strategies/sse41/%.o:  EXTRA_FLAGS += -msse4.1
-  strategies/sse2/%.lo:  EXTRA_FLAGS += -msse2
-  strategies/sse41/%.lo: EXTRA_FLAGS += -msse4.1
-  # To disable avx2 on old compilers that don't support it.
-  ifndef KVZ_DISABLE_AVX2
-    strategies/avx2/%.o:  EXTRA_FLAGS += -mavx2
-    strategies/avx2/%.lo: EXTRA_FLAGS += -mavx2
-  endif
-endif
-
-OBJS = \
-  bitstream.o \
-  cabac.o \
-  checkpoint.o \
-  config.o \
-  context.o \
-  cu.o \
-  encoder.o \
-  encoderstate.o \
-  rate_control.o \
-  filter.o \
-  input_frame_buffer.o \
-  inter.o \
-  intra.o \
-  kvazaar.o \
-  nal.o \
-  imagelist.o \
-  rdo.o \
-  sao.o \
-  scalinglist.o \
-  search.o \
-  search_intra.o \
-  search_inter.o \
-  strategyselector.o \
-  tables.o \
-  threadqueue.o \
-  transform.o \
-  encoder_state-bitstream.o \
-  encoder_state-ctors_dtors.o \
-  encoder_state-geometry.o \
-  image.o \
-  videoframe.o \
-  strategies/strategies-picture.o \
-  strategies/strategies-nal.o \
-  strategies/strategies-dct.o \
-  strategies/strategies-ipol.o \
-  strategies/strategies-quant.o \
-  strategies/strategies-intra.o \
-  strategies/generic/nal-generic.o \
-  strategies/generic/picture-generic.o \
-  strategies/sse2/picture-sse2.o \
-  strategies/sse41/picture-sse41.o \
-  strategies/altivec/picture-altivec.o \
-  strategies/avx2/picture-avx2.o \
-  strategies/x86_asm/picture-x86-asm.o \
-  strategies/generic/dct-generic.o \
-  strategies/avx2/dct-avx2.o \
-  strategies/generic/ipol-generic.o \
-  strategies/avx2/ipol-avx2.o \
-  strategies/generic/quant-generic.o \
-  strategies/avx2/quant-avx2.o \
-  strategies/generic/intra-generic.o \
-  strategies/avx2/intra-avx2.o
-
-ifndef KVZ_DISABLE_ASM
-  # Compile C files in x86_asm folder with KVZ_COMPILE_ASM, which will cause
-  # the registration function to register the function pointers in the ASM
-  # files.
-  strategies/x86_asm/%.o: EXTRA_FLAGS += -DKVZ_COMPILE_ASM
-
-  # Add ASM files to the list of objects to be compiled.
-  OBJS += \
-    strategies/x86_asm/picture-x86-asm-sad.o \
-    strategies/x86_asm/picture-x86-asm-satd.o
-endif
-
-TESTDIR := ../tests
-TEST_OBJS := \
-  $(TESTDIR)/dct_tests.o \
-  $(TESTDIR)/intra_sad_tests.o \
-  $(TESTDIR)/sad_tests.o \
-  $(TESTDIR)/satd_tests.o \
-  $(TESTDIR)/speed_tests.o \
-  $(TESTDIR)/tests_main.o \
-  $(TESTDIR)/test_strategies.o
-
-MAIN_OBJS := \
-    encmain.o \
-    cli.o \
-    yuv_io.o
-
-RELEASE_OBJS = $(MAIN_OBJS) $(OBJS)
-# Compile separate PIC objects for shared libraries
-SHARED_OBJS = $(OBJS:.o=.lo)
-DEBUG_OBJS = $(RELEASE_OBJS:.o=_debug.o)
-TESTS_OBJS = $(TEST_OBJS) $(OBJS)
-
-DEPS = $(RELEASE_OBJS:.o=.d) $(DEBUG_OBJS:.o=.d) $(TESTS_OBJS:.o=.d)
-
-.PHONY: cli lib-shared lib-static debug tests build_tests
-cli: $(PROG)
-lib-shared: $(LIBKVAZAAR_SHARED)
-lib-static: $(STATIC)
-
-debug: LDFLAGS := $(filter-out -O3 -O2 -flto, $(LDFLAGS))
-debug: CFLAGS := $(filter-out -O3 -O2 -flto, $(CFLAGS))
-debug: $(DEBUG)
-
-tests: build_tests
-	./$(TESTS)
-
-build_tests: CFLAGS := $(filter-out -Werror, $(CFLAGS))
-build_tests: init_submodules $(TESTS)
-
-$(LIB):   LDFLAGS += -shared -Wl,-soname,$(SO).$(VER_MAJOR)
-$(DLL):   LDFLAGS += -shared -Wl,--out-implib,$(IMPLIB) -o $@
-$(DYLIB): LDFLAGS += -dynamiclib \
-                     -current_version $(VER_MAJOR).$(VER_MINOR).$(VER_RELEASE) \
-                     -compatibility_version $(VER_MAJOR) \
-                     -install_name $(LIBDIR)/$@
-
-$(PROG): $(MAIN_OBJS) $(STATIC)
-	$(LD) $^ $(LDFLAGS) $(LIBS) -o $@
-
-$(STATIC): $(OBJS)
-	$(RM) $@
-	$(AR) rc $@ $^
-	$(RANLIB) $@
-
-$(LIB) $(DLL) $(DYLIB): $(SHARED_OBJS)
-	$(LD) $^ $(LDFLAGS) $(LIBS) -o $@
-
-$(DEBUG): $(DEBUG_OBJS)
-	$(LD) $^ $(LDFLAGS) $(LIBS) -o $@
-
-$(TESTS): $(TESTS_OBJS)
-	$(LD) $^ $(LDFLAGS) $(LIBS) -o $@
-
-
-%.o: %.asm Makefile
-	$(AS) $(ASFLAGS) -o $@ $<
-%_debug.o: %.asm Makefile
-	$(AS) $(ASFLAGS) -o $@ $<
-
-# Hopefully the ASM code is PIC. If not, we have to disable for the .so and .dylib.
-%.lo: %.asm Makefile
-	$(AS) $(ASFLAGS) -o $@ $<
-%_debug.lo: %.asm Makefile
-	$(AS) $(ASFLAGS) -o $@ $<
-
-# Object files not meant for shared libs need KVZ_STATIC_LIB defined so
-# that the names of the API functions don't get mangled on Windows.
-%.o: CFLAGS += -DKVZ_STATIC_LIB
-%.o: %.c Makefile
-	$(CC) $(CFLAGS) $(CPPFLAGS) $(EXTRA_FLAGS) -MMD -MP -c $< -o $@
-%_debug.o: %.c Makefile
-	$(CC) $(CFLAGS) $(CPPFLAGS) $(EXTRA_FLAGS) -MMD -MP -c $< -o $@
-
-ifneq ($(SYSTEM), Windows)
-  # Only use -fpic when not on Windows
-  %.lo: CFLAGS += -fpic
-endif
-%.lo: %.c Makefile
-	$(CC) $(CFLAGS) $(CPPFLAGS) $(EXTRA_FLAGS) -MMD -MP -c $< -o $@
-%_debug.lo: %.c Makefile
-	$(CC) $(CFLAGS) $(CPPFLAGS) $(EXTRA_FLAGS) -MMD -MP -c $< -o $@
-
-
-.PHONY: kvazaar.pc init_submodules install install-pc install-prog install-lib
-.PHONY: install-dylib install-dll clean
-kvazaar.pc: KVZ_VERSION = $(shell awk '/#define KVZ_VERSION/ { print $$3 }' global.h)
-kvazaar.pc: kvazaar.pc.in Makefile
-	sed -e "s;@prefix@;$(PREFIX);" -e "s;@libdir@;$(LIBDIR);" \
-            -e "s;@VERSION@;$(KVZ_VERSION);" \
-            -e "s;@LIBS@;$(LIBS);" kvazaar.pc.in > $@
-
-init_submodules:
-	git submodule init
-	git submodule update
-
-install: $(INSTALL_TARGETS)
-
-install-pc: kvazaar.pc
-	$(INSTALL) -d $(DESTDIR)$(LIBDIR)/pkgconfig
-	$(INSTALL) -m644 $^ $(DESTDIR)$(LIBDIR)/pkgconfig
-
-install-prog: $(PROG)
-	$(INSTALL) -d $(DESTDIR)$(BINDIR)
-	$(INSTALL) -m755 $(PROG) $(DESTDIR)$(BINDIR)
-
-install-static: $(STATIC)
-	$(INSTALL) -d $(DESTDIR)$(INCDIR)
-	$(INSTALL) -d $(DESTDIR)$(LIBDIR)
-	$(INSTALL) -m644 $(INC) $(DESTDIR)$(INCDIR)
-	$(INSTALL) -m644 $(STATIC) $(DESTDIR)$(LIBDIR)
-
-install-lib: $(LIB)
-	$(INSTALL) -d $(DESTDIR)$(INCDIR)
-	$(INSTALL) -d $(DESTDIR)$(LIBDIR)
-	$(INSTALL) -m644 $(INC) $(DESTDIR)$(INCDIR)
-	$(INSTALL) -m644 $(LIB) $(DESTDIR)$(LIBDIR)
-	$(LN_S) -f -T $(LIB) $(DESTDIR)$(LIBDIR)/$(SO).$(VER_MAJOR)
-	$(LN_S) -f -T $(LIB) $(DESTDIR)$(LIBDIR)/$(SO)
-
-install-dylib: $(DYLIB)
-	$(INSTALL) -d $(DESTDIR)$(INCDIR)
-	$(INSTALL) -d $(DESTDIR)$(LIBDIR)
-	$(INSTALL) -m644 $(INC) $(DESTDIR)$(INCDIR)
-	$(INSTALL) -m644 $(DYLIB) $(DESTDIR)$(LIBDIR)
-	$(LN_S) -f $(DYLIB) $(DESTDIR)$(LIBDIR)/$(NAME).dylib
-
-install-dll: $(DLL)
-	$(INSTALL) -d $(DESTDIR)$(DLLDIR)
-	$(INSTALL) -d $(DESTDIR)$(INCDIR)
-	$(INSTALL) -d $(DESTDIR)$(LIBDIR)
-	$(INSTALL) -m644 $(DLL) $(DESTDIR)$(DLLDIR)
-	$(INSTALL) -m644 $(INC) $(DESTDIR)$(INCDIR)
-	$(INSTALL) -m644 $(IMPLIB) $(DESTDIR)$(LIBDIR)
-
-clean:
-	$(RM) $(RELEASE_OBJS) $(SHARED_OBJS) $(DEBUG_OBJS) $(TESTS_OBJS) $(DEPS)
-	$(RM) $(PROG) $(DEBUG) $(TESTS) $(STATIC) $(LIB) $(DLL) $(IMPLIB) $(DYLIB)
-
-ifneq ($(MAKECMDGOALS),clean)
--include $(DEPS)
-endif
-
-# Disable default rules
-.SUFFIXES:
-
-.PHONY: all clean build_tests tests debug init_submodules
-.PHONY: install install-prog install-lib install-dll

kvazaar-0.7.2.tar.gz/src/interface_main.c Deleted

@@ -1,50 +0,0 @@
-/*****************************************************************************
- * This file is part of Kvazaar HEVC encoder.
- *
- * Copyright (C) 2013-2015 Tampere University of Technology and others (see
- * COPYING file).
- *
- * Kvazaar is free software: you can redistribute it and/or modify it under
- * the terms of the GNU Lesser General Public License as published by the
- * Free Software Foundation; either version 2.1 of the License, or (at your
- * option) any later version.
- *
- * Kvazaar 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 Lesser General Public License for
- * more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with Kvazaar.  If not, see <http://www.gnu.org/licenses/>.
- ****************************************************************************/
-
-/**
- * \file
- * \brief Entry point for the Visual Studio project.
- *
- * This file is needed for Visual Studio, because it will not link the main
- * function from the .lib if the project has no .c files.
- *
- * \author Marko Viitanen ( fador@iki.fi ),
- *         Tampere University of Technology,
- *         Department of Pervasive Computing.
- * \author Ari Koivula ( ari@koivu.la ),
- *         Tampere University of Technology,
- *         Department of Pervasive Computing.
- */
-
-// This is not actually needed, because the linker will use the main from the
-// .lib of the encoder, but I will leave it here in case we encounter some
-// problem with that.
-/*
-int encmain(int argc, char *argv[]);
-
-int main(int argc, char *argv[])
-{
-  int i = 10;
-  while (i) {
-    --i;
-  }
-  return encmain(argc, argv);
-}
-*/

kvazaar-0.7.2.tar.gz/.gitignore -> kvazaar-0.8.1.tar.gz/.gitignore Changed

kvazaar-0.7.2.tar.gz/.travis-script.sh -> kvazaar-0.8.1.tar.gz/.travis-script.sh Changed

kvazaar-0.7.2.tar.gz/.travis.yml -> kvazaar-0.8.1.tar.gz/.travis.yml Changed

@@ -2,7 +2,6 @@
 
 env:
   global:
-  - AS=nasm
   - KVZ_DISABLE_AVX2=1
   - TEST_DIM=264x130
   - TEST_FRAMES=10
@@ -15,10 +14,15 @@
   
   include:
     - compiler: clang
-      env: KVZ_DISABLE_AVX2=""
     - compiler: gcc-4.8
-      env: KVZ_DISABLE_AVX2=""
-    
+
+    # Check for external symbols without kvz_ prefix.
+    - compiler: gcc-4.8
+      script:
+        - ./autogen.sh
+        - ./configure && make
+        - (! nm -go --defined-only src/.libs/libkvazaar.a | grep -v ' kvz_')
+
     # These valgrind tests are slow, so they are performed with the minimum
     # number of small frames and fast settings.
     
@@ -40,7 +44,12 @@
     # Tests for all-intra.
     - env: VALGRIND_TEST="-p1 --threads=2 --owf=1 --rd=1 --no-rdoq --no-deblock --no-sao --no-signhide"
     - env: VALGRIND_TEST="-p1 --threads=2 --owf=1 --rd=2 --no-rdoq --no-deblock --no-sao --no-signhide --no-transform-skip"
-    
+
+    # Tests for SMP and AMP blocks.
+    - env: TEST_FRAMES=4 VALGRIND_TEST="--threads=2 --owf=1 --wpp --smp"
+    - env: TEST_FRAMES=4 VALGRIND_TEST="--threads=2 --owf=1 --wpp --amp"
+    - env: TEST_FRAMES=4 VALGRIND_TEST="--threads=2 --owf=1 --wpp --smp --amp"
+
     # Tests for rate control
     - env: VALGRIND_TEST="--bitrate=500000 -p0 -r1 --owf=1 --threads=2 --rd=0 --no-rdoq --no-deblock --no-sao --no-signhide --subme=0 --pu-depth-inter=1-3 --pu-depth-intra=2-3"
     
@@ -50,7 +59,7 @@
     - env: TEST_FRAMES=20 VALGRIND_TEST="--gop=8 -p0 --threads=2 --wpp --owf=0 --rd=0 --no-rdoq --no-deblock --no-sao --no-signhide --subme=0 --pu-depth-inter=1-3 --pu-depth-intra=2-3"
 
     # Tests trying to use invalid input dimensions
-    - env: EXPECTED_STATUS=1 PARAMS="-i kvazaar --input-res=1x65 -o /dev/null"
+    - env: EXPECTED_STATUS=1 PARAMS="-i src/kvazaar --input-res=1x65 -o /dev/null"
 
 addons:
   apt:
@@ -58,11 +67,14 @@
     - ubuntu-toolchain-r-test
 
     packages:
+    - autoconf
     - gcc
     - gcc-4.8
+    - libtool
     - nasm
     - p7zip-full
     - valgrind
+    - yasm
 
 install:
   - source .travis-install.sh

kvazaar-0.8.1.tar.gz/Makefile.am Added

kvazaar-0.7.2.tar.gz/README.md -> kvazaar-0.8.1.tar.gz/README.md Changed

@@ -1,4 +1,5 @@
-#Kvazaar
+Kvazaar {#mainpage}
+=========
 An open-source HEVC encoder licensed under LGPLv2.1
 
 Join channel #kvazaar_hevc in Freenode IRC network to contact us.
@@ -20,7 +21,7 @@
           --seek <integer>           : First frame to code [0]
           --input-res <int>x<int>    : Input resolution (width x height) or
                       auto           : try to detect from file name [auto]
-          --input-fps <number>       : Framerate of the input video [25.0]
+          --input-fps <num>/<denom>  : Framerate of the input video [25.0]
           -q, --qp <integer>         : Quantization Parameter [32]
           -p, --period <integer>     : Period of intra pictures [0]
                                          0: only first picture is intra
@@ -38,10 +39,13 @@
               --no-sao               : Disable sample adaptive offset
               --no-rdoq              : Disable RDO quantization
               --no-signhide          : Disable sign hiding in quantization
+              --smp                  : Enable Symmetric Motion Partition
+              --amp                  : Enable Asymmetric Motion Partition
               --rd <integer>         : Rate-Distortion Optimization level [1]
                                          0: no RDO
                                          1: estimated RDO
                                          2: full RDO
+              --mv-rdo               : Enable Rate-Distortion Optimized motion vector costs
               --full-intra-search    : Try all intra modes.
               --no-transform-skip    : Disable transform skip
               --aud                  : Use access unit delimiters
@@ -51,6 +55,7 @@
               --me <string>          : Set integer motion estimation algorithm ["hexbs"]
                                          "hexbs": Hexagon Based Search (faster)
                                          "tz":    Test Zone Search (better quality)
+                                         "full":  Full Search (super slow)
               --subme <integer>      : Set fractional pixel motion estimation level [1].
                                          0: only integer motion estimation
                                          1: fractional pixel motion estimation enabled
@@ -63,11 +68,17 @@
               --pu-depth-intra <int>-<int> : Range for sizes of intra prediction units to try.
                                          0: 64x64, 1: 32x32, 2: 16x16, 3: 8x8, 4: 4x4
               --no-info              : Don't add information about the encoder to settings.
-              --gop <int>            : Length of Group of Pictures, must be 8 or 0 [0]
+              --gop <string>         : Definition for GOP [0]
+                                         - 0 disabled
+                                         - 8 B-frame pyramid of length 8
+                                         - lp-gop syntax, defined below (example: g8d4r3t2)
               --bipred               : Enable bi-prediction search
               --bitrate <integer>    : Target bitrate. [0]
                                          0: disable rate-control
                                          N: target N bits per second
+              --preset <string>      : Use preset. This will override previous options.
+                                         ultrafast, superfast,veryfast, faster,
+                                         fast, medium, slow, slower, veryslow, placebo
 
       Video Usability Information:
               --sar <width:height>   : Specify Sample Aspect Ratio
@@ -122,12 +133,45 @@
            -w, --width               : Width of input in pixels
            -h, --height              : Height of input in pixels
 
-For example:
+
+###For example:
 
     kvazaar -i BQMall_832x480_60.yuv --input-res 832x480 -o out.hevc -n 600 -q 32
 
 The only accepted input format so far is 8-bit YUV 4:2:0.
 
+
+### LP-GOP syntax
+The LP-GOP syntax is "lp-g(num)d(num)r(num)t(num)", where
+- g = GOP length.
+- d = Number of GOP layers.
+- r = Number of references, where one reference is always the previous picture,
+  unless temporal scaling is used. The others are key-frames.
+- t = How many references to skip for temporal scaling, where 4 means only
+  every fourth picture needs to be decoded.
+
+
+
+##Presets
+The names of the presets are the same as with x264: ultrafast, superfast, veryfast, faster, fast, medium, slow, slower, veryslow and placebo. The effects of the presets are listed in the following table, where the names have been abreviated to fit the layout in GitHub.
+
+                  | 0-uf  | 1-sf  | 2-vf  | 3-fr  | 4-f   | 5-m   | 6-s   | 7-sr  | 8-vs  | 9-p
+----------------- | ----- | ----- | ----- | ----- | ----- | ----- | ----- | ----- | ----- | -----
+rd                | 0     | 1     | 1     | 1     | 1     | 1     | 2     | 2     | 2     | 3
+pu-depth-intra    | 2-3   | 1-3   | 1-3   | 1-3   | 1-3   | 1-4   | 1-4   | 1-4   | 1-4   | 0-4
+pu-depth-inter    | 1-3   | 1-3   | 0-3   | 0-3   | 0-3   | 0-3   | 0-3   | 0-3   | 0-3   | 0-3
+me                | hexbs | hexbs | hexbs | hexbs | hexbs | hexbs | hexbs | tz    | tz    | tz
+ref               | 1     | 1     | 2     | 2     | 2     | 3     | 3     | 4     | 4     | 6
+deblock           | 0     | 0     | 1     | 1     | 1     | 1     | 1     | 1     | 1     | 1
+signhide          | 0     | 0     | 0     | 1     | 1     | 1     | 1     | 1     | 1     | 1
+subme             | 0     | 0     | 0     | 0     | 1     | 1     | 1     | 1     | 1     | 1
+sao               | 0     | 0     | 0     | 0     | 0     | 0     | 1     | 1     | 1     | 1
+rdoq              | 0     | 0     | 0     | 0     | 0     | 0     | 0     | 1     | 1     | 1
+transform-skip    | 0     | 0     | 0     | 0     | 0     | 0     | 0     | 0     | 1     | 1
+mv-rdo            | 0     | 0     | 0     | 0     | 0     | 0     | 0     | 0     | 1     | 1
+full-intra-search | 0     | 0     | 0     | 0     | 0     | 0     | 0     | 0     | 0     | 1
+
+
 ##Kvazaar library
 
 See [kvazaar.h](src/kvazaar.h) for the library API and its
@@ -155,17 +199,15 @@
   - The executable needs pthreadVC2.dll to be present. Either install it
     somewhere or ship it with the executable.
 
-###GCC
-- Makefile can be found in the src directory.
-- Yasm is expected to be in PATH.
-    - Alternatively, NASM can be used by passing `AS=nasm` to make.
+###Autotools
+Run the following commands to compile and install Kvazaar.
 
-On Linux, both the shared and the static library are built and installed
-by default. On Windows and OS&nbsp;X, the default is to only build the
-DLL/dylib. The static command line program is built by default on all
-platforms.
+    ./autogen.sh
+    ./configure
+    make
+    sudo make install
 
-The default targets can be installed by running `make install`.
+See `./configure --help` for more options.
 
 ###OS X
 - The program should compile and work on OS X but you might need a newer
@@ -187,7 +229,14 @@
 
 See http://github.com/ultravideo/kvazaar/wiki/List-of-suggested-topics
 for a list of topics you might want to examine if you would like to do
-    something bigger than a bug fix but don't know what yet.
+something bigger than a bug fix but don't know what yet.
+
+
+###Code documentation
+
+You can generate Doxygen documentation pages by running the command
+"doxygen docs.doxy". Here is a rough schetch of the module structure:
+![Kvazaar module hierarchy](https://github.com/ultravideo/kvazaar/blob/master/doc/kvazaar_module_hierarchy.png)
 
 ###For version control we try to follow these conventions:

kvazaar-0.8.1.tar.gz/autogen.sh Added

kvazaar-0.7.2.tar.gz/build/kvazaar_cli/kvazaar_cli.vcxproj -> kvazaar-0.8.1.tar.gz/build/kvazaar_cli/kvazaar_cli.vcxproj Changed

kvazaar-0.7.2.tar.gz/build/kvazaar_cli/kvazaar_cli.vcxproj.filters -> kvazaar-0.8.1.tar.gz/build/kvazaar_cli/kvazaar_cli.vcxproj.filters Changed

@@ -1,22 +1,12 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <ItemGroup>
-    <Filter Include="Source Files">
-      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
-      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
-    </Filter>
-    <Filter Include="Header Files">
-      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
-      <Extensions>h;hpp;hxx;hm;inl;inc;xsd</Extensions>
-    </Filter>
-    <Filter Include="Resource Files">
-      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
-      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
-    </Filter>
+    <ClCompile Include="..\..\src\cli.c" />
+    <ClCompile Include="..\..\src\yuv_io.c" />
+    <ClCompile Include="..\..\src\encmain.c" />
   </ItemGroup>
   <ItemGroup>
-    <ClCompile Include="..\..\src\interface_main.c">
-      <Filter>Source Files</Filter>
-    </ClCompile>
+    <ClInclude Include="..\..\src\yuv_io.h" />
+    <ClInclude Include="..\..\src\cli.h" />
   </ItemGroup>
 </Project>
\ No newline at end of file

kvazaar-0.7.2.tar.gz/build/kvazaar_lib/kvazaar_lib.vcxproj -> kvazaar-0.8.1.tar.gz/build/kvazaar_lib/kvazaar_lib.vcxproj Changed

@@ -129,11 +129,9 @@
     <ClCompile Include="..\..\src\kvazaar.c" />
     <ClCompile Include="..\..\src\bitstream.c" />
     <ClCompile Include="..\..\src\cabac.c" />
-    <ClCompile Include="..\..\src\cli.c" />
     <ClCompile Include="..\..\src\config.c" />
     <ClCompile Include="..\..\src\context.c" />
     <ClCompile Include="..\..\src\cu.c" />
-    <ClCompile Include="..\..\src\encmain.c" />
     <ClCompile Include="..\..\src\encoder.c" />
     <ClCompile Include="..\..\src\encoderstate.c" />
     <ClCompile Include="..\..\src\encoder_state-bitstream.c" />
@@ -169,9 +167,7 @@
     <ClCompile Include="..\..\src\strategies\generic\quant-generic.c" />
     <ClCompile Include="..\..\src\strategies\strategies-intra.c" />
     <ClCompile Include="..\..\src\strategies\strategies-quant.c" />
-    <ClCompile Include="..\..\src\yuv_io.c" />
     <ClInclude Include="..\..\src\checkpoint.h" />
-    <ClInclude Include="..\..\src\cli.h" />
     <ClInclude Include="..\..\src\cu.h" />
     <ClInclude Include="..\..\src\image.h" />
     <ClInclude Include="..\..\src\imagelist.h" />
@@ -224,7 +220,6 @@
     <ClInclude Include="..\..\src\strategies\generic\quant-generic.h" />
     <ClInclude Include="..\..\src\strategies\strategies-intra.h" />
     <ClInclude Include="..\..\src\strategies\strategies-quant.h" />
-    <ClInclude Include="..\..\src\yuv_io.h" />
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="..\..\src\bitstream.h" />

kvazaar-0.7.2.tar.gz/build/kvazaar_lib/kvazaar_lib.vcxproj.filters -> kvazaar-0.8.1.tar.gz/build/kvazaar_lib/kvazaar_lib.vcxproj.filters Changed

@@ -1,428 +1,400 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <ItemGroup>
-    <Filter Include="Source Files">
-      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
-      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
+    <Filter Include="Control">
+      <UniqueIdentifier>{c7f0ebb9-e5c1-479d-bb12-c2403f551ae0}</UniqueIdentifier>
     </Filter>
-    <Filter Include="Header Files">
-      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
-      <Extensions>h;hpp;hxx;hm;inl;inc;xsd</Extensions>
+    <Filter Include="Bitstream">
+      <UniqueIdentifier>{2d160ce0-596b-4f8c-ae61-1ddd5ccbe1ea}</UniqueIdentifier>
     </Filter>
-    <Filter Include="Resource Files">
-      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
-      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
+    <Filter Include="Compression">
+      <UniqueIdentifier>{871a51e7-0a11-4870-ad93-0809af9a2412}</UniqueIdentifier>
     </Filter>
-    <Filter Include="Header Files\strategies">
-      <UniqueIdentifier>{84b28f88-c0de-4ee8-8566-c2c56d2b0f6e}</UniqueIdentifier>
+    <Filter Include="Reconstruction">
+      <UniqueIdentifier>{8a1eee84-49e9-4e2d-9681-a23a774cdb18}</UniqueIdentifier>
     </Filter>
-    <Filter Include="Source Files\strategies">
+    <Filter Include="Optimization">
+      <UniqueIdentifier>{1dce39e5-50a3-4cd7-adfa-6d382446debd}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Optimization\strategies">
       <UniqueIdentifier>{aa218f1d-2e13-425d-80a7-3f4d74076c5c}</UniqueIdentifier>
     </Filter>
-    <Filter Include="Source Files\strategies\generic">
+    <Filter Include="Optimization\strategies\generic">
       <UniqueIdentifier>{e4e77a4f-e708-4b11-9ba7-9d2b746e3f5d}</UniqueIdentifier>
     </Filter>
-    <Filter Include="Source Files\strategies\sse2">
+    <Filter Include="Optimization\strategies\sse2">
       <UniqueIdentifier>{0c7b7451-4b19-443f-b51c-588e63bb4c93}</UniqueIdentifier>
     </Filter>
-    <Filter Include="Source Files\strategies\sse41">
+    <Filter Include="Optimization\strategies\sse41">
       <UniqueIdentifier>{2b47e32d-3fee-4a34-a4cb-8453b769b1b0}</UniqueIdentifier>
     </Filter>
-    <Filter Include="Source Files\strategies\altivec">
+    <Filter Include="Optimization\strategies\altivec">
       <UniqueIdentifier>{770e42cd-56bc-4377-af83-c14872722ed2}</UniqueIdentifier>
     </Filter>
-    <Filter Include="Header Files\strategies\generic">
-      <UniqueIdentifier>{62b39266-3f82-421d-91df-7f12caa817ad}</UniqueIdentifier>
-    </Filter>
-    <Filter Include="Header Files\strategies\sse2">
-      <UniqueIdentifier>{675b31f0-f1a3-4b1f-b436-ae24c2ab7279}</UniqueIdentifier>
+    <Filter Include="Optimization\strategies\avx2">
+      <UniqueIdentifier>{4ffb5d27-c5bb-44d5-a935-fa93066a259e}</UniqueIdentifier>
     </Filter>
-    <Filter Include="Header Files\strategies\sse41">
-      <UniqueIdentifier>{1e811a93-2291-426e-951b-0c1137af77f7}</UniqueIdentifier>
+    <Filter Include="Optimization\strategies\x86_asm">
+      <UniqueIdentifier>{d0ce7d00-30c6-4e8a-b96e-51e13cb038ea}</UniqueIdentifier>
     </Filter>
-    <Filter Include="Header Files\strategies\altivec">
-      <UniqueIdentifier>{9e275b7f-3094-4614-b817-6ce0bee827b2}</UniqueIdentifier>
+    <Filter Include="CABAC">
+      <UniqueIdentifier>{c696e039-5ba4-48ab-845d-cfe1a5713525}</UniqueIdentifier>
     </Filter>
-    <Filter Include="Source Files\extras">
+    <Filter Include="Extras">
       <UniqueIdentifier>{7b258ce6-90d8-4e47-ab43-babda9eefbd9}</UniqueIdentifier>
     </Filter>
-    <Filter Include="Header Files\strategies\avx2">
-      <UniqueIdentifier>{80a08f4c-ca27-488b-bd63-8df6eacd1f3a}</UniqueIdentifier>
-    </Filter>
-    <Filter Include="Source Files\strategies\avx2">
-      <UniqueIdentifier>{4ffb5d27-c5bb-44d5-a935-fa93066a259e}</UniqueIdentifier>
-    </Filter>
-    <Filter Include="Source Files\strategies\x86_asm">
-      <UniqueIdentifier>{d0ce7d00-30c6-4e8a-b96e-51e13cb038ea}</UniqueIdentifier>
+    <Filter Include="Data structures">
+      <UniqueIdentifier>{f4560af3-b3b4-47b4-b401-908f2d279847}</UniqueIdentifier>
     </Filter>
-    <Filter Include="Header Files\strategies\x86_asm">
-      <UniqueIdentifier>{62f151c5-cdcd-46e5-aaef-fe5fdd33dce4}</UniqueIdentifier>
+    <Filter Include="Threading">
+      <UniqueIdentifier>{63c21cb2-b379-4d38-bcb8-173786c2466d}</UniqueIdentifier>
     </Filter>
   </ItemGroup>
   <ItemGroup>
-    <ClCompile Include="..\..\src\encmain.c">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\..\src\config.c">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\..\src\bitstream.c">
-      <Filter>Source Files</Filter>
+    <ClCompile Include="..\..\src\strategies\strategies-nal.c">
+      <Filter>Optimization\strategies</Filter>
     </ClCompile>
-    <ClCompile Include="..\..\src\encoder.c">
-      <Filter>Source Files</Filter>
+    <ClCompile Include="..\..\src\strategies\strategies-picture.c">
+      <Filter>Optimization\strategies</Filter>
     </ClCompile>
-    <ClCompile Include="..\..\src\cabac.c">
-      <Filter>Source Files</Filter>
+    <ClCompile Include="..\..\src\strategies\generic\nal-generic.c">
+      <Filter>Optimization\strategies\generic</Filter>
     </ClCompile>
-    <ClCompile Include="..\..\src\nal.c">
-      <Filter>Source Files</Filter>
+    <ClCompile Include="..\..\src\strategies\generic\picture-generic.c">
+      <Filter>Optimization\strategies\generic</Filter>
     </ClCompile>
-    <ClCompile Include="..\..\src\intra.c">
-      <Filter>Source Files</Filter>
+    <ClCompile Include="..\..\src\strategies\altivec\picture-altivec.c">
+      <Filter>Optimization\strategies\altivec</Filter>
     </ClCompile>
-    <ClCompile Include="..\..\src\transform.c">
-      <Filter>Source Files</Filter>
+    <ClCompile Include="..\..\src\strategies\sse41\picture-sse41.c">
+      <Filter>Optimization\strategies\sse41</Filter>
     </ClCompile>
-    <ClCompile Include="..\..\src\context.c">
-      <Filter>Source Files</Filter>
+    <ClCompile Include="..\..\src\strategies\sse2\picture-sse2.c">
+      <Filter>Optimization\strategies\sse2</Filter>
     </ClCompile>
-    <ClCompile Include="..\..\src\filter.c">
-      <Filter>Source Files</Filter>
+    <ClCompile Include="..\..\src\strategies\avx2\picture-avx2.c">
+      <Filter>Optimization\strategies\avx2</Filter>
     </ClCompile>
-    <ClCompile Include="..\..\src\search.c">
-      <Filter>Source Files</Filter>
+    <ClCompile Include="..\..\src\strategies\x86_asm\picture-x86-asm.c">
+      <Filter>Optimization\strategies\x86_asm</Filter>
     </ClCompile>
-    <ClCompile Include="..\..\src\inter.c">
-      <Filter>Source Files</Filter>
+    <ClCompile Include="..\..\src\strategies\avx2\dct-avx2.c">
+      <Filter>Optimization\strategies\avx2</Filter>
     </ClCompile>
-    <ClCompile Include="..\..\src\sao.c">
-      <Filter>Source Files</Filter>
+    <ClCompile Include="..\..\src\strategies\generic\dct-generic.c">
+      <Filter>Optimization\strategies\generic</Filter>
     </ClCompile>
-    <ClCompile Include="..\..\src\rdo.c">
-      <Filter>Source Files</Filter>
+    <ClCompile Include="..\..\src\strategies\strategies-dct.c">
+      <Filter>Optimization\strategies</Filter>
     </ClCompile>
-    <ClCompile Include="..\..\src\extras\getopt.c">
-      <Filter>Source Files</Filter>
+    <ClCompile Include="..\..\src\strategies\strategies-ipol.c">
+      <Filter>Optimization\strategies</Filter>
     </ClCompile>
-    <ClCompile Include="..\..\src\scalinglist.c">
-      <Filter>Source Files</Filter>
+    <ClCompile Include="..\..\src\strategies\avx2\ipol-avx2.c">
+      <Filter>Optimization\strategies\avx2</Filter>
     </ClCompile>
-    <ClCompile Include="..\..\src\tables.c">
-      <Filter>Source Files</Filter>
+    <ClCompile Include="..\..\src\strategies\generic\ipol-generic.c">
+      <Filter>Optimization\strategies\generic</Filter>
     </ClCompile>
-    <ClCompile Include="..\..\src\strategyselector.c">
-      <Filter>Source Files</Filter>
+    <ClCompile Include="..\..\src\strategies\strategies-quant.c">
+      <Filter>Optimization\strategies</Filter>
     </ClCompile>
-    <ClCompile Include="..\..\src\threadqueue.c">
-      <Filter>Source Files</Filter>
+    <ClCompile Include="..\..\src\strategies\generic\quant-generic.c">
+      <Filter>Optimization\strategies\generic</Filter>
     </ClCompile>
-    <ClCompile Include="..\..\src\encoder_state-bitstream.c">
-      <Filter>Source Files</Filter>
+    <ClCompile Include="..\..\src\strategies\avx2\quant-avx2.c">
+      <Filter>Optimization\strategies\avx2</Filter>
     </ClCompile>
-    <ClCompile Include="..\..\src\encoder_state-ctors_dtors.c">
-      <Filter>Source Files</Filter>
+    <ClCompile Include="..\..\src\strategies\strategies-intra.c">
+      <Filter>Optimization\strategies</Filter>
     </ClCompile>
-    <ClCompile Include="..\..\src\encoder_state-geometry.c">
-      <Filter>Source Files</Filter>
+    <ClCompile Include="..\..\src\strategies\generic\intra-generic.c">
+      <Filter>Optimization\strategies\generic</Filter>
     </ClCompile>
-    <ClCompile Include="..\..\src\encoderstate.c">
-      <Filter>Source Files</Filter>
+    <ClCompile Include="..\..\src\strategies\avx2\intra-avx2.c">
+      <Filter>Optimization\strategies\avx2</Filter>
     </ClCompile>
-    <ClCompile Include="..\..\src\image.c">
-      <Filter>Source Files</Filter>
+    <ClCompile Include="..\..\src\search.c">
+      <Filter>Compression</Filter>
     </ClCompile>
-    <ClCompile Include="..\..\src\imagelist.c">
-      <Filter>Source Files</Filter>
+    <ClCompile Include="..\..\src\search_inter.c">
+      <Filter>Compression</Filter>
     </ClCompile>
-    <ClCompile Include="..\..\src\videoframe.c">
-      <Filter>Source Files</Filter>
+    <ClCompile Include="..\..\src\search_intra.c">
+      <Filter>Compression</Filter>
     </ClCompile>
-    <ClCompile Include="..\..\src\cu.c">
-      <Filter>Source Files</Filter>
+    <ClCompile Include="..\..\src\encoderstate.c">
+      <Filter>Control</Filter>
     </ClCompile>
-    <ClCompile Include="..\..\src\strategies\strategies-nal.c">
-      <Filter>Source Files\strategies</Filter>
+    <ClCompile Include="..\..\src\encoder.c">
+      <Filter>Control</Filter>
     </ClCompile>
-    <ClCompile Include="..\..\src\strategies\strategies-picture.c">
-      <Filter>Source Files\strategies</Filter>
+    <ClCompile Include="..\..\src\encoder_state-ctors_dtors.c">
+      <Filter>Control</Filter>
     </ClCompile>
-    <ClCompile Include="..\..\src\strategies\generic\nal-generic.c">
-      <Filter>Source Files\strategies\generic</Filter>
+    <ClCompile Include="..\..\src\encoder_state-geometry.c">
+      <Filter>Control</Filter>
     </ClCompile>
-    <ClCompile Include="..\..\src\strategies\generic\picture-generic.c">
-      <Filter>Source Files\strategies\generic</Filter>
+    <ClCompile Include="..\..\src\cabac.c">
+      <Filter>CABAC</Filter>
     </ClCompile>
-    <ClCompile Include="..\..\src\strategies\altivec\picture-altivec.c">
-      <Filter>Source Files\strategies\altivec</Filter>
+    <ClCompile Include="..\..\src\context.c">
+      <Filter>CABAC</Filter>
     </ClCompile>
-    <ClCompile Include="..\..\src\strategies\sse41\picture-sse41.c">
-      <Filter>Source Files\strategies\sse41</Filter>
+    <ClCompile Include="..\..\src\bitstream.c">
+      <Filter>CABAC</Filter>
     </ClCompile>
-    <ClCompile Include="..\..\src\strategies\sse2\picture-sse2.c">
-      <Filter>Source Files\strategies\sse2</Filter>
+    <ClCompile Include="..\..\src\config.c">
+      <Filter>Control</Filter>
     </ClCompile>
-    <ClCompile Include="..\..\src\strategies\avx2\picture-avx2.c">
-      <Filter>Source Files\strategies\avx2</Filter>
+    <ClCompile Include="..\..\src\filter.c">
+      <Filter>Reconstruction</Filter>
     </ClCompile>
-    <ClCompile Include="..\..\src\strategies\x86_asm\picture-x86-asm.c">
-      <Filter>Source Files\strategies\x86_asm</Filter>
+    <ClCompile Include="..\..\src\extras\getopt.c">
+      <Filter>Extras</Filter>
     </ClCompile>
-    <ClCompile Include="..\..\src\strategies\avx2\dct-avx2.c">
-      <Filter>Source Files\strategies\avx2</Filter>
+    <ClCompile Include="..\..\src\videoframe.c">
+      <Filter>Data structures</Filter>
     </ClCompile>
-    <ClCompile Include="..\..\src\strategies\generic\dct-generic.c">
-      <Filter>Source Files\strategies\generic</Filter>
+    <ClCompile Include="..\..\src\cu.c">
+      <Filter>Data structures</Filter>
     </ClCompile>
-    <ClCompile Include="..\..\src\strategies\strategies-dct.c">
-      <Filter>Source Files\strategies</Filter>
+    <ClCompile Include="..\..\src\image.c">
+      <Filter>Data structures</Filter>
     </ClCompile>
-    <ClCompile Include="..\..\src\strategies\strategies-ipol.c">
-      <Filter>Source Files\strategies</Filter>
+    <ClCompile Include="..\..\src\imagelist.c">
+      <Filter>Data structures</Filter>
     </ClCompile>
-    <ClCompile Include="..\..\src\strategies\avx2\ipol-avx2.c">
-      <Filter>Source Files\strategies\avx2</Filter>
+    <ClCompile Include="..\..\src\rdo.c">
+      <Filter>Compression</Filter>
     </ClCompile>
-    <ClCompile Include="..\..\src\strategies\generic\ipol-generic.c">
-      <Filter>Source Files\strategies\generic</Filter>
+    <ClCompile Include="..\..\src\inter.c">
+      <Filter>Reconstruction</Filter>
     </ClCompile>
-    <ClCompile Include="..\..\src\cli.c">
-      <Filter>Source Files</Filter>
+    <ClCompile Include="..\..\src\intra.c">
+      <Filter>Reconstruction</Filter>
     </ClCompile>
     <ClCompile Include="..\..\src\kvazaar.c">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\..\src\rate_control.c">
-      <Filter>Source Files</Filter>
+      <Filter>Control</Filter>
     </ClCompile>
-    <ClCompile Include="..\..\src\yuv_io.c">
-      <Filter>Source Files</Filter>
+    <ClCompile Include="..\..\src\input_frame_buffer.c">
+      <Filter>Control</Filter>
     </ClCompile>
-    <ClCompile Include="..\..\src\search_inter.c">
-      <Filter>Source Files</Filter>
+    <ClCompile Include="..\..\src\nal.c">
+      <Filter>Bitstream</Filter>
     </ClCompile>
-    <ClCompile Include="..\..\src\search_intra.c">
-      <Filter>Source Files</Filter>
+    <ClCompile Include="..\..\src\rate_control.c">
+      <Filter>Control</Filter>
     </ClCompile>
-    <ClCompile Include="..\..\src\input_frame_buffer.c">
-      <Filter>Source Files</Filter>
+    <ClCompile Include="..\..\src\sao.c">
+      <Filter>Reconstruction</Filter>
     </ClCompile>
-    <ClCompile Include="..\..\src\strategies\strategies-quant.c">
-      <Filter>Source Files\strategies</Filter>
+    <ClCompile Include="..\..\src\strategyselector.c">
+      <Filter>Optimization</Filter>
     </ClCompile>
-    <ClCompile Include="..\..\src\strategies\generic\quant-generic.c">
-      <Filter>Source Files\strategies\generic</Filter>
+    <ClCompile Include="..\..\src\transform.c">
+      <Filter>Reconstruction</Filter>
     </ClCompile>
-    <ClCompile Include="..\..\src\strategies\avx2\quant-avx2.c">
-      <Filter>Source Files\strategies\avx2</Filter>
+    <ClCompile Include="..\..\src\tables.c">
+      <Filter>Reconstruction</Filter>
     </ClCompile>
-    <ClCompile Include="..\..\src\strategies\strategies-intra.c">
-      <Filter>Source Files\strategies</Filter>
+    <ClCompile Include="..\..\src\scalinglist.c">
+      <Filter>Reconstruction</Filter>
     </ClCompile>
-    <ClCompile Include="..\..\src\strategies\generic\intra-generic.c">
-      <Filter>Source Files\strategies\generic</Filter>
+    <ClCompile Include="..\..\src\threadqueue.c">
+      <Filter>Threading</Filter>
     </ClCompile>
-    <ClCompile Include="..\..\src\strategies\avx2\intra-avx2.c">
-      <Filter>Source Files\strategies\avx2</Filter>
+    <ClCompile Include="..\..\src\encoder_state-bitstream.c">
+      <Filter>Bitstream</Filter>
     </ClCompile>
   </ItemGroup>
   <ItemGroup>
-    <ClInclude Include="..\..\src\global.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\..\src\config.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
     <ClInclude Include="..\..\src\bitstream.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\..\src\encoder.h">
-      <Filter>Header Files</Filter>
+      <Filter>CABAC</Filter>
     </ClInclude>
     <ClInclude Include="..\..\src\cabac.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\..\src\nal.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\..\src\intra.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\..\src\transform.h">
-      <Filter>Header Files</Filter>
+      <Filter>CABAC</Filter>
     </ClInclude>
     <ClInclude Include="..\..\src\context.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\..\src\filter.h">
-      <Filter>Header Files</Filter>
+      <Filter>CABAC</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\src\search.h">
-      <Filter>Header Files</Filter>
+    <ClInclude Include="..\..\src\config.h">
+      <Filter>Control</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\src\inter.h">
-      <Filter>Header Files</Filter>
+    <ClInclude Include="..\..\src\encoder.h">
+      <Filter>Control</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\src\sao.h">
-      <Filter>Header Files</Filter>
+    <ClInclude Include="..\..\src\encoder_state-ctors_dtors.h">
+      <Filter>Control</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\src\rdo.h">
-      <Filter>Header Files</Filter>
+    <ClInclude Include="..\..\src\encoder_state-geometry.h">
+      <Filter>Control</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\src\extras\getopt.h">
-      <Filter>Header Files</Filter>
+    <ClInclude Include="..\..\src\encoderstate.h">
+      <Filter>Control</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\src\scalinglist.h">
-      <Filter>Header Files</Filter>
+    <ClInclude Include="..\..\src\input_frame_buffer.h">
+      <Filter>Control</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\src\tables.h">
-      <Filter>Header Files</Filter>
+    <ClInclude Include="..\..\src\rate_control.h">
+      <Filter>Control</Filter>
     </ClInclude>
     <ClInclude Include="..\..\src\threads.h">
-      <Filter>Header Files</Filter>
+      <Filter>Threading</Filter>
     </ClInclude>
     <ClInclude Include="..\..\src\threadqueue.h">
-      <Filter>Header Files</Filter>
+      <Filter>Threading</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\src\encoderstate.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\..\src\encoder_state-bitstream.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\..\src\encoder_state-ctors_dtors.h">
-      <Filter>Header Files</Filter>
+    <ClInclude Include="..\..\src\kvazaar.h">
+      <Filter>Control</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\src\encoder_state-geometry.h">
-      <Filter>Header Files</Filter>
+    <ClInclude Include="..\..\src\kvazaar_internal.h">
+      <Filter>Control</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\src\image.h">
-      <Filter>Header Files</Filter>
+    <ClInclude Include="..\..\src\kvazaar_version.h">
+      <Filter>Control</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\src\checkpoint.h">
-      <Filter>Header Files</Filter>
+    <ClInclude Include="..\..\src\videoframe.h">
+      <Filter>Data structures</Filter>
     </ClInclude>
     <ClInclude Include="..\..\src\cu.h">
-      <Filter>Header Files</Filter>
+      <Filter>Data structures</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\image.h">
+      <Filter>Data structures</Filter>
     </ClInclude>
     <ClInclude Include="..\..\src\imagelist.h">
-      <Filter>Header Files</Filter>
+      <Filter>Data structures</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\src\strategyselector.h">
-      <Filter>Header Files</Filter>
+    <ClInclude Include="..\..\src\extras\getopt.h">
+      <Filter>Extras</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\src\videoframe.h">
-      <Filter>Header Files</Filter>
+    <ClInclude Include="..\..\src\filter.h">
+      <Filter>Reconstruction</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\src\strategies\strategies-nal.h">
-      <Filter>Header Files\strategies</Filter>
+    <ClInclude Include="..\..\src\inter.h">
+      <Filter>Reconstruction</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\src\strategies\strategies-picture.h">
-      <Filter>Header Files\strategies</Filter>
+    <ClInclude Include="..\..\src\intra.h">
+      <Filter>Reconstruction</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\src\strategies\altivec\picture-altivec.h">
-      <Filter>Header Files\strategies\altivec</Filter>
+    <ClInclude Include="..\..\src\sao.h">
+      <Filter>Reconstruction</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\src\strategies\generic\nal-generic.h">
-      <Filter>Header Files\strategies\generic</Filter>
+    <ClInclude Include="..\..\src\scalinglist.h">
+      <Filter>Reconstruction</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\src\strategies\generic\picture-generic.h">
-      <Filter>Header Files\strategies\generic</Filter>
+    <ClInclude Include="..\..\src\tables.h">
+      <Filter>Reconstruction</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\src\strategies\sse41\picture-sse41.h">
-      <Filter>Header Files\strategies\sse41</Filter>
+    <ClInclude Include="..\..\src\transform.h">
+      <Filter>Reconstruction</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\src\strategies\sse2\picture-sse2.h">
-      <Filter>Header Files\strategies\sse2</Filter>
+    <ClInclude Include="..\..\src\global.h" />
+    <ClInclude Include="..\..\src\checkpoint.h" />
+    <ClInclude Include="..\..\src\strategyselector.h">
+      <Filter>Optimization</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\src\strategies\avx2\picture-avx2.h">
-      <Filter>Header Files\strategies\avx2</Filter>
+    <ClInclude Include="..\..\src\search_intra.h">
+      <Filter>Compression</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\src\strategies\x86_asm\picture-x86-asm.h">
-      <Filter>Header Files\strategies\x86_asm</Filter>
+    <ClInclude Include="..\..\src\search.h">
+      <Filter>Compression</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\src\strategies\x86_asm\picture-x86-asm-sad.h">
-      <Filter>Header Files\strategies\x86_asm</Filter>
+    <ClInclude Include="..\..\src\search_inter.h">
+      <Filter>Compression</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\src\strategies\x86_asm\picture-x86-asm-satd.h">
-      <Filter>Header Files\strategies\x86_asm</Filter>
+    <ClInclude Include="..\..\src\nal.h">
+      <Filter>Bitstream</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\src\strategies\avx2\dct-avx2.h">
-      <Filter>Header Files\strategies\avx2</Filter>
+    <ClInclude Include="..\..\src\rdo.h">
+      <Filter>Compression</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\strategies\strategies-common.h">
+      <Filter>Optimization\strategies</Filter>
     </ClInclude>
     <ClInclude Include="..\..\src\strategies\strategies-dct.h">
-      <Filter>Header Files\strategies</Filter>
+      <Filter>Optimization\strategies</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\src\strategies\generic\dct-generic.h">
-      <Filter>Header Files\strategies\generic</Filter>
+    <ClInclude Include="..\..\src\strategies\strategies-intra.h">
+      <Filter>Optimization\strategies</Filter>
     </ClInclude>
     <ClInclude Include="..\..\src\strategies\strategies-ipol.h">
-      <Filter>Header Files\strategies</Filter>
+      <Filter>Optimization\strategies</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\src\strategies\generic\ipol-generic.h">
-      <Filter>Header Files\strategies\generic</Filter>
+    <ClInclude Include="..\..\src\strategies\strategies-nal.h">
+      <Filter>Optimization\strategies</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\src\strategies\avx2\ipol-avx2.h">
-      <Filter>Header Files\strategies\avx2</Filter>
+    <ClInclude Include="..\..\src\strategies\strategies-picture.h">
+      <Filter>Optimization\strategies</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\src\cli.h">
-      <Filter>Header Files</Filter>
+    <ClInclude Include="..\..\src\strategies\strategies-quant.h">
+      <Filter>Optimization\strategies</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\src\kvazaar.h">
-      <Filter>Header Files</Filter>
+    <ClInclude Include="..\..\src\strategies\x86_asm\picture-x86-asm.h">
+      <Filter>Optimization\strategies\x86_asm</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\src\kvazaar_version.h">
-      <Filter>Header Files</Filter>
+    <ClInclude Include="..\..\src\strategies\x86_asm\picture-x86-asm-sad.h">
+      <Filter>Optimization\strategies\x86_asm</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\src\rate_control.h">
-      <Filter>Header Files</Filter>
+    <ClInclude Include="..\..\src\strategies\x86_asm\picture-x86-asm-satd.h">
+      <Filter>Optimization\strategies\x86_asm</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\src\yuv_io.h">
-      <Filter>Header Files</Filter>
+    <ClInclude Include="..\..\src\strategies\sse41\picture-sse41.h">
+      <Filter>Optimization\strategies\sse41</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\src\kvazaar_internal.h">
-      <Filter>Header Files</Filter>
+    <ClInclude Include="..\..\src\strategies\sse2\picture-sse2.h">
+      <Filter>Optimization\strategies\sse2</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\src\search_inter.h">
-      <Filter>Header Files</Filter>
+    <ClInclude Include="..\..\src\strategies\generic\dct-generic.h">
+      <Filter>Optimization\strategies\generic</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\src\search_intra.h">
-      <Filter>Header Files</Filter>
+    <ClInclude Include="..\..\src\strategies\generic\intra-generic.h">
+      <Filter>Optimization\strategies\generic</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\src\input_frame_buffer.h">
-      <Filter>Header Files</Filter>
+    <ClInclude Include="..\..\src\strategies\generic\ipol-generic.h">
+      <Filter>Optimization\strategies\generic</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\src\strategies\strategies-common.h">
-      <Filter>Header Files\strategies</Filter>
+    <ClInclude Include="..\..\src\strategies\generic\nal-generic.h">
+      <Filter>Optimization\strategies\generic</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\src\strategies\strategies-quant.h">
-      <Filter>Header Files\strategies</Filter>
+    <ClInclude Include="..\..\src\strategies\generic\picture-generic.h">
+      <Filter>Optimization\strategies\generic</Filter>
     </ClInclude>
     <ClInclude Include="..\..\src\strategies\generic\quant-generic.h">
-      <Filter>Header Files\strategies\generic</Filter>
+      <Filter>Optimization\strategies\generic</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\src\strategies\avx2\quant-avx2.h">
-      <Filter>Header Files\strategies\avx2</Filter>
+    <ClInclude Include="..\..\src\strategies\avx2\dct-avx2.h">
+      <Filter>Optimization\strategies\avx2</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\src\strategies\strategies-intra.h">
-      <Filter>Header Files\strategies</Filter>
+    <ClInclude Include="..\..\src\strategies\avx2\intra-avx2.h">
+      <Filter>Optimization\strategies\avx2</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\src\strategies\generic\intra-generic.h">
-      <Filter>Header Files\strategies\generic</Filter>
+    <ClInclude Include="..\..\src\strategies\avx2\ipol-avx2.h">
+      <Filter>Optimization\strategies\avx2</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\src\strategies\avx2\intra-avx2.h">
-      <Filter>Header Files\strategies\avx2</Filter>
+    <ClInclude Include="..\..\src\strategies\avx2\picture-avx2.h">
+      <Filter>Optimization\strategies\avx2</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\strategies\avx2\quant-avx2.h">
+      <Filter>Optimization\strategies\avx2</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\strategies\altivec\picture-altivec.h">
+      <Filter>Optimization\strategies\altivec</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\encoder_state-bitstream.h">
+      <Filter>Bitstream</Filter>
     </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <YASM Include="..\..\src\extras\x86inc.asm">
-      <Filter>Source Files\extras</Filter>
+      <Filter>Extras</Filter>
     </YASM>
     <YASM Include="..\..\src\strategies\x86_asm\picture-x86-asm-sad.asm">
-      <Filter>Source Files\strategies\x86_asm</Filter>
+      <Filter>Optimization\strategies\x86_asm</Filter>
     </YASM>
     <YASM Include="..\..\src\strategies\x86_asm\picture-x86-asm-satd.asm">
-      <Filter>Source Files\strategies\x86_asm</Filter>
+      <Filter>Optimization\strategies\x86_asm</Filter>
     </YASM>
   </ItemGroup>
 </Project>
\ No newline at end of file

kvazaar-0.7.2.tar.gz/build/kvazaar_tests/kvazaar_tests.vcxproj -> kvazaar-0.8.1.tar.gz/build/kvazaar_tests/kvazaar_tests.vcxproj Changed

kvazaar-0.8.1.tar.gz/configure.ac Added

@@ -0,0 +1,104 @@
+
+AC_INIT([kvazaar], m4_esyscmd([printf $(awk '/#define KVZ_VERSION/ { print $3 }' src/global.h)]))
+AC_CONFIG_SRCDIR([src/encmain.c])
+
+# Library version number
+ver_major=2
+ver_minor=4
+ver_release=0
+
+# not used, but it prevents configure from adding a lot of defines to the CFLAGS
+AC_CONFIG_HEADERS([config.h])
+
+AC_CONFIG_MACRO_DIR([m4])
+AC_CONFIG_AUX_DIR([build-aux])
+
+AM_INIT_AUTOMAKE([-Wall -Werror dist-bzip2 dist-xz foreign subdir-objects])
+AM_SILENT_RULES([yes])
+
+AC_PROG_CC
+AM_PROG_AR
+
+LT_INIT([win32-dll])
+
+
+CFLAGS="-Wall -Wtype-limits -Wvla -I$srcdir/src -ftree-vectorize -fvisibility=hidden -std=gnu99 -DKVZ_DLL_EXPORTS $CFLAGS"
+LIBS="-lm $LIBS"
+
+
+# --disable-werror
+AC_ARG_ENABLE([werror], [AS_HELP_STRING([--disable-werror], [don't treat warnings as errors [no]])],
+              [], [CFLAGS="-Werror $CFLAGS"]
+)
+
+
+# check for getopt
+AC_CHECK_HEADER([getopt.h], [], [CFLAGS="$CFLAGS -I$srcdir/src/extras"])
+
+
+# host and cpu specific settings
+AS_CASE([$host_cpu],
+        [i?86], [BITS="32" ASFLAGS="$ASFLAGS -DARCH_X86_64=0" X86="true"],
+        [x86_64], [BITS="64" ASFLAGS="$ASFLAGS -DARCH_X86_64=1 -m amd64" X86="true"],
+        [powerpc*], [PPC="true"],
+        [arm*], [ARM="true"]
+)
+
+AS_CASE([$host_os],
+        [darwin*], [
+         ASFLAGS="$ASFLAGS -f macho$BITS -DPREFIX"
+        ],
+        [cygwin*|msys*|mingw*], [
+         CFLAGS="$CFLAGS -D__USE_MINGW_ANSI_STDIO=1"
+         AS_IF(
+               [test "x$BITS" = "x32"], [
+                ASFLAGS="$ASFLAGS -fwin32 -DPREFIX -DHAVE_ALIGNED_STACK=0"
+               ], [
+                ASFLAGS="$ASFLAGS -fwin64 -DHAVE_ALIGNED_STACK=1"
+               ]
+         )
+        ], [
+         ASFLAGS="$ASFLAGS -f elf$BITS"
+         CFLAGS="$CFLAGS -pthread"
+         LDFLAGS="$LDFLAGS -pthread -Wl,-z,noexecstack"
+         LIBS="$LIBS -lrt -lpthread"
+        ]
+)
+
+
+# YASM checks
+AS_IF([test "x$X86" = "xtrue"], [
+       AC_CHECK_TOOL([YASM], [yasm], [no])
+])
+AS_IF([test "x$YASM" != "xno"], [have_yasm="yes"])
+
+AC_ARG_ENABLE([asm], [AS_HELP_STRING([--disable-asm], [disable assembly [no]])],
+              [], [enable_asm="yes"]
+)
+AS_IF([test "x$enable_asm" != "xno" -a $have_yasm != "yes"],
+      [enable_asm="no"]
+)
+
+
+AM_CONDITIONAL([HAVE_X86], [test "x$X86" = "xtrue"])
+AM_CONDITIONAL([HAVE_PPC], [test "x$PPC" = "xtrue"])
+AM_CONDITIONAL([HAVE_ARM], [test "x$ARM" = "xtrue"])
+AM_CONDITIONAL([ENABLE_ASM], [test "x$enable_asm" = "xyes" -a "x$have_yasm" = "xyes" ])
+
+AC_ARG_VAR([ASFLAGS], [ASFLAGS to use for assembler])
+AC_SUBST([ASFLAGS])
+
+# use KVZ_API_VERSION for sonames
+#KVZ_API_VERSION="$($AWK '/#define KVZ_API_VERSION/ { print $3 }' $srcdir/src/kvazaar_version.h)"
+
+# use library version for sonames (specified in src/Makefile)
+KVZ_API_VERSION="$ver_major:$ver_minor:$ver_release"
+AC_SUBST([KVZ_API_VERSION])
+
+
+AC_CONFIG_FILES([Makefile
+                 src/Makefile
+                 src/kvazaar.pc
+                 tests/Makefile])
+AC_OUTPUT
+

kvazaar-0.8.1.tar.gz/doc/kvazaar_module_hierarchy.graphmlz Added

kvazaar-0.8.1.tar.gz/doc/kvazaar_module_hierarchy.png Added

kvazaar-0.7.2.tar.gz/docs.doxy -> kvazaar-0.8.1.tar.gz/docs.doxy Changed

@@ -97,7 +97,7 @@
 # brief descriptions will be completely suppressed.
 # The default value is: YES.
 
-REPEAT_BRIEF           = YES
+REPEAT_BRIEF           = NO
 
 # This tag implements a quasi-intelligent brief description abbreviator that is
 # used to form the text in various listings. Each string in this list, if found
@@ -167,7 +167,7 @@
 # description.)
 # The default value is: NO.
 
-JAVADOC_AUTOBRIEF      = NO
+JAVADOC_AUTOBRIEF      = YES
 
 # If the QT_AUTOBRIEF tag is set to YES then doxygen will interpret the first
 # line (until the first dot) of a Qt-style comment as the brief description. If
@@ -734,7 +734,8 @@
 # spaces.
 # Note: If this tag is empty the current directory is searched.
 
-INPUT                  = src
+INPUT                  = README.md src src/strategies src/strategies/altivec src/strategies/avx2 src/strategies/generic src/strategies/sse2 src/strategies/sse41 src/strategies/x86_asm tools
+USE_MDFILE_AS_MAINPAGE = README.md
 
 # This tag can be used to specify the character encoding of the source files
 # that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses
@@ -754,7 +755,7 @@
 # *.md, *.mm, *.dox, *.py, *.f90, *.f, *.for, *.tcl, *.vhd, *.vhdl, *.ucf,
 # *.qsf, *.as and *.js.
 
-FILE_PATTERNS          =
+FILE_PATTERNS          = *.md *.c *.h *.asm *.py
 
 # The RECURSIVE tag can be used to specify whether or not subdirectories should
 # be searched for input files as well.
@@ -2043,7 +2044,7 @@
 # Minimum value: 0, maximum value: 32, default value: 0.
 # This tag requires that the tag HAVE_DOT is set to YES.
 
-DOT_NUM_THREADS        = 1 # Marko usually has encoding in the background.
+DOT_NUM_THREADS        = 6
 
 # When you want a differently looking font n the dot files that doxygen
 # generates you can specify the font name using DOT_FONTNAME. You need to make

kvazaar-0.8.1.tar.gz/src/Makefile.am Added

@@ -0,0 +1,182 @@
+
+bin_PROGRAMS = kvazaar
+lib_LTLIBRARIES = libkvazaar.la
+
+
+EXTRA_DIST = \
+	Makefile-old \
+	SConscript \
+	extras/getopt.c \
+	extras/getopt.h
+
+
+pkgconfigdir = $(libdir)/pkgconfig
+nodist_pkgconfig_DATA = kvazaar.pc
+
+
+include_HEADERS = \
+	kvazaar.h \
+	kvazaar_version.h
+
+noinst_HEADERS = \
+	extras/x86inc.asm
+
+
+kvazaar_SOURCES = \
+	encmain.c \
+	cli.h \
+	cli.c \
+	yuv_io.c \
+	yuv_io.h
+kvazaar_LDADD = libkvazaar.la $(LIBS)
+
+
+libkvazaar_la_SOURCES = \
+	bitstream.c \
+	bitstream.h \
+	cabac.c \
+	cabac.h \
+	checkpoint.c \
+	checkpoint.h \
+	config.c \
+	config.h \
+	context.c \
+	context.h \
+	cu.c \
+	cu.h \
+	encoder.c \
+	encoder.h \
+	encoderstate.c \
+	encoderstate.h \
+	encoder_state-bitstream.c \
+	encoder_state-bitstream.h \
+	encoder_state-ctors_dtors.c \
+	encoder_state-ctors_dtors.h \
+	encoder_state-geometry.c \
+	encoder_state-geometry.h \
+	filter.c \
+	filter.h \
+	global.h \
+	image.c \
+	image.h \
+	imagelist.c \
+	imagelist.h \
+	input_frame_buffer.c \
+	input_frame_buffer.h \
+	inter.c \
+	inter.h \
+	intra.c \
+	intra.h \
+	kvazaar.c \
+	kvazaar_internal.h \
+	nal.c \
+	nal.h \
+	rate_control.c \
+	rate_control.h \
+	rdo.c \
+	rdo.h \
+	sao.c \
+	sao.h \
+	scalinglist.c \
+	scalinglist.h \
+	search.c \
+	search.h \
+	search_inter.c \
+	search_inter.h \
+	search_intra.c \
+	search_intra.h \
+	tables.c \
+	tables.h \
+	threadqueue.c \
+	threadqueue.h \
+	threads.h \
+	transform.c \
+	transform.h \
+	videoframe.c \
+	videoframe.h \
+	strategies/altivec/picture-altivec.c \
+	strategies/altivec/picture-altivec.h \
+	strategies/generic/dct-generic.c \
+	strategies/generic/dct-generic.h \
+	strategies/generic/intra-generic.c \
+	strategies/generic/intra-generic.h \
+	strategies/generic/ipol-generic.c \
+	strategies/generic/ipol-generic.h \
+	strategies/generic/nal-generic.c \
+	strategies/generic/nal-generic.h \
+	strategies/generic/picture-generic.c \
+	strategies/generic/picture-generic.h \
+	strategies/generic/quant-generic.c \
+	strategies/generic/quant-generic.h \
+	strategies/sse2/picture-sse2.c \
+	strategies/sse2/picture-sse2.h \
+	strategies/sse41/picture-sse41.c \
+	strategies/sse41/picture-sse41.h \
+	strategies/strategies-common.h \
+	strategies/strategies-dct.c \
+	strategies/strategies-dct.h \
+	strategies/strategies-intra.c \
+	strategies/strategies-intra.h \
+	strategies/strategies-ipol.c \
+	strategies/strategies-ipol.h \
+	strategies/strategies-nal.c \
+	strategies/strategies-nal.h \
+	strategies/strategies-picture.c \
+	strategies/strategies-picture.h \
+	strategies/strategies-quant.c \
+	strategies/strategies-quant.h \
+	strategies/x86_asm/picture-x86-asm.c \
+	strategies/x86_asm/picture-x86-asm.h \
+	strategyselector.c \
+	strategyselector.h
+
+avx2_sources = \
+	strategies/avx2/dct-avx2.c \
+	strategies/avx2/dct-avx2.h \
+	strategies/avx2/intra-avx2.c \
+	strategies/avx2/intra-avx2.h \
+	strategies/avx2/ipol-avx2.c \
+	strategies/avx2/ipol-avx2.h \
+	strategies/avx2/picture-avx2.c \
+	strategies/avx2/picture-avx2.h \
+	strategies/avx2/quant-avx2.c \
+	strategies/avx2/quant-avx2.h
+
+libkvazaar_la_SOURCES += $(avx2_sources)
+libkvazaar_la_LDFLAGS = $(AM_LDFLAGS) -no-undefined -version-number $(KVZ_API_VERSION)
+
+
+if HAVE_PPC
+
+strategies/altivec/picture-altivec.lo: CFLAGS += -maltivec
+
+else #HAVE_PPC
+
+if HAVE_X86
+strategies/sse2/picture-sse2.lo: CFLAGS += -msse2
+strategies/sse41/picture-sse41.lo: CFLAGS += -msse4.1
+$(avx2_sources): CFLAGS += -mavx2
+
+if ENABLE_ASM
+libkvazaar_la_SOURCES += \
+	strategies/x86_asm/picture-x86-asm-sad.asm \
+	strategies/x86_asm/picture-x86-asm-sad.h \
+	strategies/x86_asm/picture-x86-asm-satd.asm \
+	strategies/x86_asm/picture-x86-asm-satd.h
+
+strategies/x86_asm/picture-x86-asm.lo: CFLAGS += -DKVZ_COMPILE_ASM
+strategies/x86_asm/picture-x86-asm-sad.lo: strategies/x86_asm/picture-x86-asm-sad.asm
+strategies/x86_asm/picture-x86-asm-satd.lo: strategies/x86_asm/picture-x86-asm-satd.asm
+endif #ENABLE_ASM
+endif #HAVE_X86
+
+endif #HAVE_PPC
+
+
+yasm_verbose = $(yasm_verbose_@AM_V@)
+yasm_verbose_ = $(yasm_verbose_@AM_DEFAULT_V@)
+yasm_verbose_0 = @echo "  YASM    " $@;
+
+.asm.lo:
+	$(yasm_verbose)$(LIBTOOL) --mode=compile $(YASM) -I$(srcdir)/extras $(ASFLAGS) $< -o $@ -prefer-non-pic 1>/dev/null
+

kvazaar-0.7.2.tar.gz/src/bitstream.c -> kvazaar-0.8.1.tar.gz/src/bitstream.c Changed

kvazaar-0.7.2.tar.gz/src/bitstream.h -> kvazaar-0.8.1.tar.gz/src/bitstream.h Changed

kvazaar-0.7.2.tar.gz/src/cabac.c -> kvazaar-0.8.1.tar.gz/src/cabac.c Changed

kvazaar-0.7.2.tar.gz/src/cabac.h -> kvazaar-0.8.1.tar.gz/src/cabac.h Changed

kvazaar-0.7.2.tar.gz/src/checkpoint.h -> kvazaar-0.8.1.tar.gz/src/checkpoint.h Changed

kvazaar-0.7.2.tar.gz/src/cli.c -> kvazaar-0.8.1.tar.gz/src/cli.c Changed

@@ -45,13 +45,22 @@
   { "vps-period",         required_argument, NULL, 0 },
   { "input-res",          required_argument, NULL, 0 },
   { "input-fps",          required_argument, NULL, 0 },
-  { "no-deblock",               no_argument, NULL, 0 },
   { "deblock",            required_argument, NULL, 0 },
+  { "no-deblock",               no_argument, NULL, 0 },
+  { "sao",                      no_argument, NULL, 0 },
   { "no-sao",                   no_argument, NULL, 0 },
+  { "rdoq",                     no_argument, NULL, 0 },
   { "no-rdoq",                  no_argument, NULL, 0 },
+  { "signhide",                 no_argument, NULL, 0 },
   { "no-signhide",              no_argument, NULL, 0 },
+  { "smp",                      no_argument, NULL, 0 },
+  { "no-smp",                   no_argument, NULL, 0 },
+  { "amp",                      no_argument, NULL, 0 },
+  { "no-amp",                   no_argument, NULL, 0 },
   { "rd",                 required_argument, NULL, 0 },
   { "full-intra-search",        no_argument, NULL, 0 },
+  { "no-full-intra-search",     no_argument, NULL, 0 },
+  { "transform-skip",           no_argument, NULL, 0 },
   { "no-transform-skip",        no_argument, NULL, 0 },
   { "tr-depth-intra",     required_argument, NULL, 0 },
   { "me",                 required_argument, NULL, 0 },
@@ -66,21 +75,28 @@
   { "colormatrix",        required_argument, NULL, 0 },
   { "chromaloc",          required_argument, NULL, 0 },
   { "aud",                      no_argument, NULL, 0 },
+  { "no-aud",                   no_argument, NULL, 0 },
   { "cqmfile",            required_argument, NULL, 0 },
   { "seek",               required_argument, NULL, 0 },
   { "tiles-width-split",  required_argument, NULL, 0 },
   { "tiles-height-split", required_argument, NULL, 0 },
   { "wpp",                      no_argument, NULL, 0 },
+  { "no-wpp",                   no_argument, NULL, 0 },
   { "owf",                required_argument, NULL, 0 },
   { "slice-addresses",    required_argument, NULL, 0 },
   { "threads",            required_argument, NULL, 0 },
   { "cpuid",              required_argument, NULL, 0 },
   { "pu-depth-inter",     required_argument, NULL, 0 },
   { "pu-depth-intra",     required_argument, NULL, 0 },
+  { "info",                     no_argument, NULL, 0 },
   { "no-info",                  no_argument, NULL, 0 },
   { "gop",                required_argument, NULL, 0 },
   { "bipred",                   no_argument, NULL, 0 },
+  { "no-bipred",                no_argument, NULL, 0 },
   { "bitrate",            required_argument, NULL, 0 },
+  { "preset",             required_argument, NULL, 0 },
+  { "mv-rdo",                   no_argument, NULL, 0 },
+  { "no-mv-rdo",                no_argument, NULL, 0 },
   {0, 0, 0, 0}
 };
 
@@ -185,13 +201,20 @@
       opts->seek = atoi(optarg);
     } else if (!strcmp(name, "frames")) {
       opts->frames = atoi(optarg);
-    } else if (!kvz_config_parse(opts->config, name, optarg)) {
+    } else if (!api->config_parse(opts->config, name, optarg)) {
       fprintf(stderr, "invalid argument: %s=%s\n", name, optarg);
       ok = 0;
       goto done;
     }
   }
 
+  // Check for extra arguments.
+  if (argc - optind > 0) {
+    fprintf(stderr, "Input error: Extra argument found: \"%s\"\n", argv[optind]);
+    ok = 0;
+    goto done;
+  }
+
   // Check that the required files were defined
   if (opts->input == NULL || opts->output == NULL) {
     ok = 0;
@@ -277,14 +300,18 @@
     "          --no-sao               : Disable sample adaptive offset\n"
     "          --no-rdoq              : Disable RDO quantization\n"
     "          --no-signhide          : Disable sign hiding in quantization\n"
+    "          --smp                  : Enable Symmetric Motion Partition\n"
+    "          --amp                  : Enable Asymmetric Motion Partition\n"
     "          --rd <integer>         : Rate-Distortion Optimization level [1]\n"
     "                                     0: no RDO\n"
     "                                     1: estimated RDO\n"
     "                                     2: full RDO\n"
+    "          --mv-rdo               : Enable Rate-Distortion Optimized motion vector costs\n"
     "          --full-intra-search    : Try all intra modes.\n"
     "          --me <string>          : Set integer motion estimation algorithm [\"hexbs\"]\n"
     "                                     \"hexbs\": Hexagon Based Search (faster)\n"
     "                                     \"tz\":    Test Zone Search (better quality)\n"
+    "                                     \"full\":  Full Search (super slow)\n"
     "          --no-transform-skip    : Disable transform skip\n"
     "          --aud                  : Use access unit delimiters\n"
     "          --cqmfile <string>     : Custom Quantization Matrices from a file\n"
@@ -307,6 +334,9 @@
     "          --bitrate <integer>    : Target bitrate. [0]\n"
     "                                     0: disable rate-control\n"
     "                                     N: target N bits per second\n"
+    "          --preset <string>      : Use preset\n"
+    "                                     ultrafast, superfast,veryfast, faster,\n"
+    "                                     fast, medium, slow, slower, veryslow, placebo\n"
     "\n"
     "  Video Usability Information:\n"
     "          --sar <width:height>   : Specify Sample Aspect Ratio\n"

kvazaar-0.7.2.tar.gz/src/cli.h -> kvazaar-0.8.1.tar.gz/src/cli.h Changed

kvazaar-0.7.2.tar.gz/src/config.c -> kvazaar-0.8.1.tar.gz/src/config.c Changed

@@ -18,10 +18,6 @@
  * with Kvazaar.  If not, see <http://www.gnu.org/licenses/>.
  ****************************************************************************/
 
-/*
- * \file
- */
-
 #include "config.h"
 
 #include <stdio.h>
@@ -45,7 +41,9 @@
 {
   cfg->width           = 0;
   cfg->height          = 0;
-  cfg->framerate       = 25;
+  cfg->framerate       = 25; // deprecated and will be removed.
+  cfg->framerate_num   = 0;
+  cfg->framerate_denom = 1;
   cfg->qp              = 32;
   cfg->intra_period    = 0;
   cfg->vps_period      = 0;
@@ -55,7 +53,10 @@
   cfg->sao_enable      = 1;
   cfg->rdoq_enable     = 1;
   cfg->signhide_enable = true;
+  cfg->smp_enable      = false;
+  cfg->amp_enable      = false;
   cfg->rdo             = 1;
+  cfg->mv_rdo          = 0;
   cfg->full_intra_search = 0;
   cfg->trskip_enable   = 1;
   cfg->tr_depth_intra  = 0;
@@ -264,7 +265,7 @@
 
 int kvz_config_parse(kvz_config *cfg, const char *name, const char *value)
 {
-  static const char * const me_names[]          = { "hexbs", "tz", NULL };
+  static const char * const me_names[]          = { "hexbs", "tz", "full", NULL };
   static const char * const source_scan_type_names[] = { "progressive", "tff", "bff", NULL };
 
   static const char * const overscan_names[]    = { "undef", "show", "crop", NULL };
@@ -278,6 +279,180 @@
   static const char * const colormatrix_names[] = { "GBR", "bt709", "undef", "", "fcc", "bt470bg", "smpte170m",
                                                     "smpte240m", "YCgCo", "bt2020nc", "bt2020c", NULL };
 
+  static const char * const preset_values[11][28] = {
+      { 
+        "ultrafast", 
+        "pu-depth-intra", "2-3",
+        "pu-depth-inter", "1-3",
+        "rd", "0",
+        "me", "hexbs",
+        "ref", "1",
+        "deblock", "0",
+        "signhide", "0",
+        "subme", "0",
+        "sao", "0",
+        "rdoq", "0",
+        "transform-skip", "0", 
+        "full-intra-search", "0",
+        "mv-rdo", "0",
+        NULL 
+      },
+      { 
+        "superfast",
+        "pu-depth-intra", "1-3",
+        "pu-depth-inter", "1-3",
+        "rd", "1",
+        "me", "hexbs",
+        "ref", "1",
+        "deblock", "0",
+        "signhide", "0",
+        "subme", "0",
+        "sao", "0",
+        "rdoq", "0",
+        "transform-skip", "0",
+        "full-intra-search", "0",
+        "mv-rdo", "0",
+        NULL
+      },
+      {
+        "veryfast",
+        "pu-depth-intra", "1-3",
+        "pu-depth-inter", "0-3",
+        "rd", "1",
+        "me", "hexbs",
+        "ref", "2",
+        "deblock", "1",
+        "signhide", "0",
+        "subme", "0",
+        "sao", "0",
+        "rdoq", "0",
+        "transform-skip", "0",
+        "full-intra-search", "0",
+        "mv-rdo", "0",
+        NULL
+      },
+      {
+        "faster",
+        "pu-depth-intra", "1-3",
+        "pu-depth-inter", "0-3",
+        "rd", "1",
+        "me", "hexbs",
+        "ref", "2",
+        "deblock", "1",
+        "signhide", "1",
+        "subme", "0",
+        "sao", "0",
+        "rdoq", "0",
+        "transform-skip", "0",
+        "full-intra-search", "0",
+        "mv-rdo", "0",
+        NULL
+      },
+      {
+        "fast",
+        "pu-depth-intra", "1-3",
+        "pu-depth-inter", "0-3",
+        "rd", "1",
+        "me", "hexbs",
+        "ref", "2",
+        "deblock", "1",
+        "signhide", "1",
+        "subme", "1",
+        "sao", "0",
+        "rdoq", "0",
+        "transform-skip", "0",
+        "full-intra-search", "0",
+        "mv-rdo", "0",
+        NULL
+      },
+      {
+        "medium",
+        "pu-depth-intra", "1-4",
+        "pu-depth-inter", "0-3",
+        "rd", "1",
+        "me", "hexbs",
+        "ref", "3",
+        "deblock", "1",
+        "signhide", "1",
+        "subme", "1",
+        "sao", "0",
+        "rdoq", "0",
+        "transform-skip", "0",
+        "full-intra-search", "0",
+        "mv-rdo", "0",
+        NULL
+      },
+      {
+        "slow",
+        "pu-depth-intra", "1-4",
+        "pu-depth-inter", "0-3",
+        "rd", "2",
+        "me", "hexbs",
+        "ref", "3",
+        "deblock", "1",
+        "signhide", "1",
+        "subme", "1",
+        "sao", "1",
+        "rdoq", "0",
+        "transform-skip", "0",
+        "full-intra-search", "0",
+        "mv-rdo", "0",
+        NULL
+      },
+      {
+        "slower",
+        "pu-depth-intra", "1-4",
+        "pu-depth-inter", "0-3",
+        "rd", "2",
+        "me", "tz",
+        "ref", "4",
+        "deblock", "1",
+        "signhide", "1",
+        "subme", "1",
+        "sao", "1",
+        "rdoq", "1",
+        "transform-skip", "0",
+        "full-intra-search", "0",
+        "mv-rdo", "0",
+        NULL
+      },
+      {
+        "veryslow",
+        "pu-depth-intra", "1-4",
+        "pu-depth-inter", "0-3",
+        "rd", "2",
+        "me", "tz",
+        "ref", "4",
+        "deblock", "1",
+        "signhide", "1",
+        "subme", "1",
+        "sao", "1",
+        "rdoq", "1",
+        "transform-skip", "1",
+        "full-intra-search", "0",
+        "mv-rdo", "1",
+        NULL
+      },
+      {
+        "placebo",
+        "pu-depth-intra", "0-4",
+        "pu-depth-inter", "0-3",
+        "rd", "3",
+        "me", "tz",
+        "ref", "6",
+        "deblock", "1",
+        "signhide", "1",
+        "subme", "1",
+        "sao", "1",
+        "rdoq", "1",
+        "transform-skip", "1",
+        "full-intra-search", "1",
+        "mv-rdo", "1",
+        NULL
+      },
+      { NULL }
+  };
+
   if (!name)
     return 0;
 
@@ -301,8 +476,17 @@
     } else {
       return (sscanf(value, "%dx%d", &cfg->width, &cfg->height) == 2);
     }
-  else if OPT("input-fps")
-    cfg->framerate = atof(value);
+  else if OPT("input-fps") {
+    int32_t fps_num, fps_denom;
+    if (sscanf(value, "%d/%d", &fps_num, &fps_denom) == 2) {
+      cfg->framerate_num = fps_num;
+      cfg->framerate_denom = fps_denom;
+    } else {
+      // Accept decimal notation, making sure not to round 0 to 1.
+      cfg->framerate_num = (int)(atof(value) * 1000 + 0.49);
+      cfg->framerate_denom = 1000;
+    }
+  }
   else if OPT("qp")
     cfg->qp = atoi(value);
   else if OPT("period")
@@ -317,10 +501,6 @@
       cfg->deblock_enable = 1;
       cfg->deblock_beta   = beta;
       cfg->deblock_tc     = tc;
-    } else if (sscanf(value, "%d", &beta)) {
-      cfg->deblock_enable = 1;
-      cfg->deblock_beta   = beta;
-      cfg->deblock_tc     = cfg->deblock_beta;
     } else {
       cfg->deblock_enable = atobool(value);
     }
@@ -331,6 +511,10 @@
     cfg->rdoq_enable = atobool(value);
   else if OPT("signhide")
     cfg->signhide_enable = (bool)atobool(value);
+  else if OPT("smp")
+    cfg->smp_enable = (bool)atobool(value);
+  else if OPT("amp")
+    cfg->amp_enable = (bool)atobool(value);
   else if OPT("rd")
     cfg->rdo = atoi(value);
   else if OPT("full-intra-search")
@@ -394,8 +578,111 @@
   else if OPT("info")
     cfg->add_encoder_info = atobool(value);
   else if OPT("gop") {
-    // TODO: Defining the whole GOP structure via parameters
-    if(atoi(value) == 8) {
+    if (!strncmp(value, "lp-", 3)) {  // Handle GOPs starting with "lp-".
+      struct {
+        unsigned g;  // length
+        unsigned d;  // depth
+        unsigned r;  // references 
+        unsigned t;  // temporal
+      } gop = { 0 };
+
+      if (sscanf(value, "lp-g%ud%ur%ut%u", &gop.g, &gop.d, &gop.r, &gop.t) != 4) {
+        fprintf(stderr, "Error in GOP syntax. Example: lp-g8d4r2t2\n");
+        return 0;
+      }
+
+      if (gop.g < 1 || gop.g > 32) {
+        fprintf(stderr, "gop.g must be between 1 and 32.\n");
+      }
+      if (gop.d < 1 || gop.d > 8) {
+        fprintf(stderr, "gop.d must be between 1 and 8.\n");
+      }
+      if (gop.r < 1 || gop.r > 15) {
+        fprintf(stderr, "gop.d must be between 1 and 15.\n");
+      }
+      if (gop.t < 1 || gop.t > 15) {
+        fprintf(stderr, "gop.t must be between 1 and 32.\n");
+      }
+      
+      // Initialize modulos for testing depth.
+      // The picture belong to the lowest depth in which (poc % modulo) == 0.
+      unsigned depth_modulos[8] = { 0 };
+      for (int d = 0; d < gop.d; ++d) {
+        depth_modulos[gop.d - 1 - d] = 1 << d;
+      }
+      depth_modulos[0] = gop.g;
+
+      cfg->gop_lowdelay = 1;
+      cfg->gop_len = gop.g;
+      for (int g = 1; g <= gop.g; ++g) {
+        kvz_gop_config *gop_pic = &cfg->gop[g - 1];
+
+        // Find gop depth for picture.
+        int gop_layer = 0;
+        while (gop_layer < gop.d && (g % depth_modulos[gop_layer])) {
+          ++gop_layer;
+        }
+
+        gop_pic->poc_offset = g;
+        gop_pic->layer = gop_layer + 1;
+        gop_pic->qp_offset = gop_layer + 1;
+        gop_pic->ref_pos_count = 0;
+        gop_pic->ref_neg_count = gop.r;
+        gop_pic->is_ref = 0;
+
+        // Set first ref to point to previous frame, and the rest to previous
+        // key-frames.
+        // If gop.t > 1, have (poc % gop.t) == 0 point gop.t frames away,
+        // instead of the previous frame. Set the frames in between to
+        // point to the nearest frame with a lower gop-depth.
+        if (gop.t > 1) {
+          if (gop_pic->poc_offset % gop.t == 0) {
+            gop_pic->ref_neg[0] = gop.t;
+          } else {
+            int r = gop_pic->poc_offset - 1;
+            while (r > 0) {
+              if (cfg->gop[r].layer < gop_pic->layer) break;
+              --r;
+            }
+            // Var r is now 0 or index of the pic with layer < depth.
+            if (cfg->gop[r].layer < gop_pic->layer) {
+              gop_pic->ref_neg[0] = gop_pic->poc_offset - cfg->gop[r].poc_offset;
+              cfg->gop[r].is_ref = 1;
+            } else {
+              // No ref was found, just refer to the previous key-frame.
+              gop_pic->ref_neg[0] = gop_pic->poc_offset % gop.g;
+            }
+          }
+        } else {
+          gop_pic->ref_neg[0] = 1;
+          if (gop_pic->poc_offset >= 2) {
+            cfg->gop[gop_pic->poc_offset - 2].is_ref = 1;
+          }
+        }
+
+        int keyframe = gop_pic->poc_offset;
+        for (int i = 1; i < gop_pic->ref_neg_count; ++i) {
+          while (keyframe == gop_pic->ref_neg[i - 1]) {
+            keyframe += gop.g;
+          }
+          gop_pic->ref_neg[i] = keyframe;
+        }
+
+        gop_pic->qp_factor = 0.4624;  // from HM
+      }
+
+      for (int g = 0; g < gop.g; ++g) {
+        kvz_gop_config *gop_pic = &cfg->gop[g];
+        if (!gop_pic->is_ref) {
+          gop_pic->qp_factor = 0.68 * 1.31;  // derived from HM
+        }
+      }
+
+      // Key-frame is always a reference.
+      cfg->gop[gop.g - 1].is_ref = 1;
+      cfg->gop[gop.g - 1].qp_factor = 0.578;  // from HM
+    } else if (atoi(value) == 8) {
+      cfg->gop_lowdelay = 0;
       // GOP
       cfg->gop_len = 8;
       cfg->gop[0].poc_offset = 8; cfg->gop[0].qp_offset = 1; cfg->gop[0].layer = 1; cfg->gop[0].qp_factor = 0.442;  cfg->gop[0].is_ref = 1;
@@ -438,6 +725,37 @@
     cfg->bipred = atobool(value);
   else if OPT("bitrate")
     cfg->target_bitrate = atoi(value);
+  else if OPT("preset") {
+    int preset_line = 0;
+
+    // Accept numbers from 0 to 9.
+    if ((atoi(value) == 0 && !strcmp(value, "0")) || (atoi(value) >= 1 && atoi(value) <= 9)) {
+      preset_line = atoi(value);
+    } else {
+      // Find the selected preset from the list
+      while (preset_values[preset_line][0] != NULL) {
+        if (!strcmp(value, preset_values[preset_line][0])) {
+          break;
+        }
+        preset_line++;
+      }
+    }
+
+    if (preset_values[preset_line][0] != NULL) {
+      fprintf(stderr, "Using preset %s: ", value);
+      // Loop all the name and value pairs and push to the config parser
+      for (int preset_value = 1; preset_values[preset_line][preset_value] != NULL; preset_value += 2) {
+        fprintf(stderr, "--%s=%s ", preset_values[preset_line][preset_value], preset_values[preset_line][preset_value + 1]);
+        kvz_config_parse(cfg, preset_values[preset_line][preset_value], preset_values[preset_line][preset_value + 1]);
+      }
+      fprintf(stderr, "\n");
+    } else {
+      fprintf(stderr, "Input error: unknown preset \"%s\"\n", value);
+      return 0;
+    }
+  }
+  else if OPT("mv-rdo")
+    cfg->mv_rdo = atobool(value);
   else
     return 0;
 #undef OPT
@@ -475,10 +793,18 @@
     error = 1;
   }
 
-  if (cfg->framerate <= 0.0) {
+  if (cfg->framerate < 0.0) {
     fprintf(stderr, "Input error: --input-fps must be positive\n");
     error = 1;
   }
+  if (cfg->framerate_num < 0) {
+    fprintf(stderr, "Input error: --input-fps must >=0\n");
+    error = 1;
+  }
+  if (cfg->framerate_denom <= 0) {
+    fprintf(stderr, "Input error: --input-fps denominator must be >0\n");
+    error = 1;
+  }
 
   if (cfg->gop_len &&
       cfg->intra_period &&

kvazaar-0.7.2.tar.gz/src/config.h -> kvazaar-0.8.1.tar.gz/src/config.h Changed

kvazaar-0.7.2.tar.gz/src/context.c -> kvazaar-0.8.1.tar.gz/src/context.c Changed

kvazaar-0.7.2.tar.gz/src/context.h -> kvazaar-0.8.1.tar.gz/src/context.h Changed

kvazaar-0.7.2.tar.gz/src/cu.c -> kvazaar-0.8.1.tar.gz/src/cu.c Changed

@@ -18,25 +18,123 @@
  * with Kvazaar.  If not, see <http://www.gnu.org/licenses/>.
  ****************************************************************************/
 
-/*
- * \file
- */
-
 #include <string.h>
 #include <stdlib.h>
 
 #include "cu.h"
 #include "threads.h"
 
+/**
+ * \brief Number of PUs in a CU.
+ *
+ * Indexed by part_mode_t values.
+ */
+const uint8_t kvz_part_mode_num_parts[] = {
+  1, // 2Nx2N
+  2, // 2NxN
+  2, // Nx2N
+  4, // NxN
+  2, // 2NxnU
+  2, // 2NxnD
+  2, // nLx2N
+  2, // nRx2N
+};
+
+/**
+ * \brief PU offsets.
+ *
+ * Indexed by [part mode][PU number][axis].
+ *
+ * Units are 1/4 of the width of the CU.
+ */
+const uint8_t kvz_part_mode_offsets[][4][2] = {
+  { {0, 0}                         }, // 2Nx2N
+  { {0, 0}, {0, 2}                 }, // 2NxN
+  { {0, 0}, {2, 0}                 }, // Nx2N
+  { {0, 0}, {2, 0}, {0, 2}, {2, 2} }, // NxN
+  { {0, 0}, {0, 1}                 }, // 2NxnU
+  { {0, 0}, {0, 3}                 }, // 2NxnD
+  { {0, 0}, {1, 0}                 }, // nLx2N
+  { {0, 0}, {3, 0}                 }, // nRx2N
+};
+
+/**
+ * \brief PU sizes.
+ *
+ * Indexed by [part mode][PU number][axis].
+ *
+ * Units are 1/4 of the width of the CU.
+ */
+const uint8_t kvz_part_mode_sizes[][4][2] = {
+  { {4, 4}                         }, // 2Nx2N
+  { {4, 2}, {4, 2}                 }, // 2NxN
+  { {2, 4}, {2, 4}                 }, // Nx2N
+  { {2, 2}, {2, 2}, {2, 2}, {2, 2} }, // NxN
+  { {4, 1}, {4, 3}                 }, // 2NxnU
+  { {4, 3}, {4, 1}                 }, // 2NxnD
+  { {1, 4}, {3, 4}                 }, // nLx2N
+  { {3, 4}, {1, 4}                 }, // nRx2N
+};
 
 void kvz_coefficients_blit(const coeff_t * const orig, coeff_t * const dst,
                          const unsigned width, const unsigned height,
                          const unsigned orig_stride, const unsigned dst_stride)
 {
   unsigned y;
-
-  for (y = 0; y < height; ++y) {
-    memcpy(&dst[y*dst_stride], &orig[y*orig_stride], width * sizeof(coeff_t));
+  
+  int nxn_width = (width == height) ? width : 0;
+  switch (nxn_width) {
+    case 4:
+      *(int64_t*)&dst[dst_stride*0] = *(int64_t*)&orig[orig_stride*0];
+      *(int64_t*)&dst[dst_stride*1] = *(int64_t*)&orig[orig_stride*1];
+      *(int64_t*)&dst[dst_stride*2] = *(int64_t*)&orig[orig_stride*2];
+      *(int64_t*)&dst[dst_stride*3] = *(int64_t*)&orig[orig_stride*3];
+      break;
+    case 8:
+#define KVZ_COPY_ROW_8(row_num) \
+*(int64_t*)&dst[dst_stride*(row_num)] = *(int64_t*)&orig[orig_stride*(row_num)]; \
+*(int64_t*)&dst[dst_stride*(row_num) + 4] = *(int64_t*)&orig[orig_stride*(row_num) + 4];
+      
+      KVZ_COPY_ROW_8(0);
+      KVZ_COPY_ROW_8(1);
+      KVZ_COPY_ROW_8(2);
+      KVZ_COPY_ROW_8(3);
+      KVZ_COPY_ROW_8(4);
+      KVZ_COPY_ROW_8(5);
+      KVZ_COPY_ROW_8(6);
+      KVZ_COPY_ROW_8(7);
+      break;
+#undef KVZ_COPY_ROW_8
+          case 16:
+#define KVZ_COPY_ROW_16(row_num) \
+*(int64_t*)&dst[dst_stride*(row_num)] = *(int64_t*)&orig[orig_stride*(row_num)]; \
+*(int64_t*)&dst[dst_stride*(row_num) + 4] = *(int64_t*)&orig[orig_stride*(row_num) + 4]; \
+*(int64_t*)&dst[dst_stride*(row_num) + 8] = *(int64_t*)&orig[orig_stride*(row_num) + 8]; \
+*(int64_t*)&dst[dst_stride*(row_num) + 12] = *(int64_t*)&orig[orig_stride*(row_num) + 12];
+      
+      KVZ_COPY_ROW_16(0);
+      KVZ_COPY_ROW_16(1);
+      KVZ_COPY_ROW_16(2);
+      KVZ_COPY_ROW_16(3);
+      KVZ_COPY_ROW_16(4);
+      KVZ_COPY_ROW_16(5);
+      KVZ_COPY_ROW_16(6);
+      KVZ_COPY_ROW_16(7);
+      KVZ_COPY_ROW_16(8);
+      KVZ_COPY_ROW_16(9);
+      KVZ_COPY_ROW_16(10);
+      KVZ_COPY_ROW_16(11);
+      KVZ_COPY_ROW_16(12);
+      KVZ_COPY_ROW_16(13);
+      KVZ_COPY_ROW_16(14);
+      KVZ_COPY_ROW_16(15);
+      break;
+#undef KVZ_COPY_ROW_16
+  default:
+    for (y = 0; y < height; ++y) {
+      memcpy(&dst[y*dst_stride], &orig[y*orig_stride], width * sizeof(coeff_t));
+    }
+    break;
   }
 }
 
@@ -70,7 +168,7 @@
   int32_t new_refcount;
   if (!cua) return 1;
   
-  new_refcount = ATOMIC_DEC(&(cua->refcount));
+  new_refcount = KVZ_ATOMIC_DEC(&(cua->refcount));
   //Still we have some references, do nothing
   if (new_refcount > 0) return 1;
   
@@ -79,3 +177,4 @@
 
   return 1;
 }
+

kvazaar-0.7.2.tar.gz/src/cu.h -> kvazaar-0.8.1.tar.gz/src/cu.h Changed

@@ -20,9 +20,10 @@
  * with Kvazaar.  If not, see <http://www.gnu.org/licenses/>.
  ****************************************************************************/
 
-/*
+/**
+ * \ingroup DataStructures
  * \file
- * \brief CU and coefficients related functions
+ * Coding Unit data structure and related functions.
  */
 
 #include "global.h"
@@ -34,6 +35,67 @@
 
 typedef enum { CU_NOTSET = 0, CU_PCM, CU_SKIP, CU_SPLIT, CU_INTRA, CU_INTER } cu_type_t;
 
+typedef enum {
+  SIZE_2Nx2N = 0,
+  SIZE_2NxN  = 1,
+  SIZE_Nx2N  = 2,
+  SIZE_NxN   = 3,
+  SIZE_2NxnU = 4,
+  SIZE_2NxnD = 5,
+  SIZE_nLx2N = 6,
+  SIZE_nRx2N = 7,
+} part_mode_t;
+
+extern const uint8_t kvz_part_mode_num_parts[];
+extern const uint8_t kvz_part_mode_offsets[][4][2];
+extern const uint8_t kvz_part_mode_sizes[][4][2];
+
+/**
+ * \brief Get the x coordinate of a PU.
+ *
+ * \param part_mode   partition mode of the containing CU
+ * \param cu_width    width of the containing CU
+ * \param cu_x        x coordinate of the containing CU
+ * \param i           number of the PU
+ * \return            location of the left edge of the PU
+ */
+#define PU_GET_X(part_mode, cu_width, cu_x, i) \
+  ((cu_x) + kvz_part_mode_offsets[(part_mode)][(i)][0] * (cu_width) / 4)
+
+/**
+ * \brief Get the y coordinate of a PU.
+ *
+ * \param part_mode   partition mode of the containing CU
+ * \param cu_width    width of the containing CU
+ * \param cu_y        y coordinate of the containing CU
+ * \param i           number of the PU
+ * \return            location of the top edge of the PU
+ */
+#define PU_GET_Y(part_mode, cu_width, cu_y, i) \
+  ((cu_y) + kvz_part_mode_offsets[(part_mode)][(i)][1] * (cu_width) / 4)
+
+/**
+ * \brief Get the width of a PU.
+ *
+ * \param part_mode   partition mode of the containing CU
+ * \param cu_width    width of the containing CU
+ * \param i           number of the PU
+ * \return            width of the PU
+ */
+#define PU_GET_W(part_mode, cu_width, i) \
+  (kvz_part_mode_sizes[(part_mode)][(i)][0] * (cu_width) / 4)
+
+/**
+ * \brief Get the height of a PU.
+ *
+ * \param part_mode   partition mode of the containing CU
+ * \param cu_width    width of the containing CU
+ * \param i           number of the PU
+ * \return            height of the PU
+ */
+#define PU_GET_H(part_mode, cu_width, i) \
+  (kvz_part_mode_sizes[(part_mode)][(i)][1] * (cu_width) / 4)
+
 //////////////////////////////////////////////////////////////////////////
 // TYPES
 
@@ -106,10 +168,15 @@
 
 cu_array_t * kvz_cu_array_alloc(int width_in_scu, int height_in_scu);
 int kvz_cu_array_free(cu_array_t *cua);
-  
 
-#define SUB_SCU_BIT_MASK (64 - 1)
-#define SUB_SCU(xy) (xy & SUB_SCU_BIT_MASK)
+/**
+ * \brief Return the 7 lowest-order bits of the pixel coordinate.
+ *
+ * The 7 lower-order bits correspond to the distance from the left or top edge
+ * of the containing LCU.
+ */
+#define SUB_SCU(xy) ((xy) & (LCU_WIDTH - 1))
+
 #define LCU_CU_WIDTH 8
 #define LCU_T_CU_WIDTH 9
 #define LCU_CU_OFFSET 10
@@ -153,10 +220,66 @@
    * - Left reference CUs on column 0.
    * - All of LCUs CUs on 1:9, 1:9.
    * - Top right reference CU on the last slot.
+   *
+   \verbatim
+
+      .-- left reference CUs
+      v
+       0 |  1  2  3  4  5  6  7  8 | 81 <-- top reference CUs
+     ----+-------------------------+----
+       9 | 10 11 12 13 14 15 16 17 |
+      18 | 19 20 21 22 23 24 25 26 <-- this LCU
+      27 | 28 29 30 31 32 33 34 35 |
+      36 | 37 38 39 40 41 42 43 44 |
+      45 | 46 47 48 49 50 51 52 53 |
+      54 | 55 56 57 58 59 60 61 62 |
+      63 | 64 65 66 67 68 69 70 71 |
+      72 | 73 74 75 76 77 78 79 80 |
+     ----+-------------------------+----
+
+   \endverbatim
    */
   cu_info_t cu[9*9+1];
 } lcu_t;
 
+/**
+ * \brief Return pointer to a given CU.
+ *
+ * \param lcu   pointer to the containing LCU
+ * \param x_cu  x-index of the CU
+ * \param y_cu  y-index of the CU
+ * \return      pointer to the CU
+ */
+#define LCU_GET_CU(lcu, x_cu, y_cu) \
+  (&(lcu)->cu[LCU_CU_OFFSET + (x_cu) + (y_cu) * LCU_T_CU_WIDTH])
+
+/**
+ * \brief Return pointer to the top right reference CU.
+ */
+#define LCU_GET_TOP_RIGHT_CU(lcu) \
+  (&(lcu)->cu[LCU_T_CU_WIDTH * LCU_T_CU_WIDTH])
+
+/**
+ * \brief Return pointer to the CU containing a given pixel.
+ *
+ * \param lcu   pointer to the containing LCU
+ * \param x_px  x-coordinate relative to the upper left corner of the LCU
+ * \param y_px  y-coordinate relative to the upper left corner of the LCU
+ * \return      pointer to the CU at coordinates (x_px, y_px)
+ */
+#define LCU_GET_CU_AT_PX(lcu, x_px, y_px) LCU_GET_CU(lcu, (x_px) >> 3, (y_px) >> 3)
+
+/**
+ * \brief Return pointer to a CU relative to the given CU.
+ *
+ * \param cu      pointer to a CU in the array at some location (x, y)
+ * \param x_offs  x-offset
+ * \param y_offs  y-offset
+ * \return        pointer to the CU at (x + x_offs, y + y_offs)
+ */
+#define CU_GET_CU(cu_array, x_offs, y_offs) \
+  (&cu_array[(x_offs) + (y_offs) * LCU_T_CU_WIDTH])
+
 #define CHECKPOINT_LCU(prefix_str, lcu) do { \
   CHECKPOINT_CU(prefix_str " cu[0]", (lcu).cu[0]); \
   CHECKPOINT_CU(prefix_str " cu[1]", (lcu).cu[1]); \

kvazaar-0.7.2.tar.gz/src/encmain.c -> kvazaar-0.8.1.tar.gz/src/encmain.c Changed

@@ -33,6 +33,7 @@
 
 #include "kvazaar_internal.h"
 
+#include <math.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -40,9 +41,7 @@
 
 #include "checkpoint.h"
 #include "global.h"
-#include "threadqueue.h"
 #include "encoder.h"
-#include "videoframe.h"
 #include "cli.h"
 #include "yuv_io.h"
 
@@ -74,6 +73,53 @@
   return fopen(filename, "wb");
 }
 
+static unsigned get_padding(unsigned width_or_height){
+  if (width_or_height % CU_MIN_SIZE_PIXELS){
+    return CU_MIN_SIZE_PIXELS - (width_or_height % CU_MIN_SIZE_PIXELS);
+  }else{
+    return 0;
+  }
+}
+
+#if KVZ_BIT_DEPTH == 8
+#define PSNRMAX (255.0 * 255.0)
+#else
+  #define PSNRMAX ((double)PIXEL_MAX * (double)PIXEL_MAX)
+#endif
+
+/**
+ * \brief Calculates image PSNR value
+ *
+ * \param src   source picture
+ * \param rec   reconstructed picture
+ * \prama psnr  returns the PSNR
+ */
+static void compute_psnr(const kvz_picture *const src,
+                         const kvz_picture *const rec,
+                         double psnr[NUM_COLORS])
+{
+  assert(src->width  == rec->width);
+  assert(src->height == rec->height);
+
+  int32_t pixels = src->width * src->height;
+
+  for (int32_t c = 0; c < NUM_COLORS; ++c) {
+    int32_t num_pixels = pixels;
+    if (c != COLOR_Y) {
+      num_pixels >>= 2;
+    }
+    psnr[c] = 0;
+    for (int32_t i = 0; i < num_pixels; ++i) {
+      const int32_t error = src->data[c][i] - rec->data[c][i];
+      psnr[c] += error * error;
+    }
+
+    // Avoid division by zero
+    if (psnr[c] == 0) psnr[c] = 99.0;
+    psnr[c] = 10 * log10((num_pixels * PSNRMAX) / ((double)psnr[c]));;
+  }
+}
+
 /**
  * \brief Program main function.
  * \param argc Argument count from commandline
@@ -91,10 +137,10 @@
   FILE *recout = NULL; //!< reconstructed YUV output, --debug
   clock_t start_time = clock();
   clock_t encoding_start_cpu_time;
-  CLOCK_T encoding_start_real_time;
+  KVZ_CLOCK_T encoding_start_real_time;
   
   clock_t encoding_end_cpu_time;
-  CLOCK_T encoding_end_real_time;
+  KVZ_CLOCK_T encoding_end_real_time;
 
   // Stdin and stdout need to be binary for input and output to work.
   // Stderr needs to be text mode to convert \n to \r\n in Windows.
@@ -160,7 +206,7 @@
   //Now, do the real stuff
   {
 
-    GET_TIME(&encoding_start_real_time);
+    KVZ_GET_TIME(&encoding_start_real_time);
     encoding_start_cpu_time = clock();
 
     uint64_t bitstream_length = 0;
@@ -170,8 +216,8 @@
 
     int8_t field_parity = 0;
     kvz_picture *frame_in = NULL;
-    uint8_t padding_x = kvz_get_padding(opts->config->width);
-    uint8_t padding_y = kvz_get_padding(opts->config->height);
+    uint8_t padding_x = get_padding(opts->config->width);
+    uint8_t padding_y = get_padding(opts->config->height);
 
     for (;;) {
 
@@ -252,7 +298,7 @@
         // Compute and print stats.
 
         double frame_psnr[3] = { 0.0, 0.0, 0.0 };
-        kvz_videoframe_compute_psnr(img_src, img_rec, frame_psnr);
+        compute_psnr(img_src, img_rec, frame_psnr);
 
         if (recout) {
           // Since chunks_out was not NULL, img_rec should have been set.
@@ -279,10 +325,8 @@
       api->picture_free(img_src);
     }
 
-    GET_TIME(&encoding_end_real_time);
+    KVZ_GET_TIME(&encoding_end_real_time);
     encoding_end_cpu_time = clock();
-
-    kvz_threadqueue_flush(encoder->threadqueue);
     // Coding finished
 
     // Print statistics of the coding
@@ -300,7 +344,7 @@
 
     {
       double encoding_time = ( (double)(encoding_end_cpu_time - encoding_start_cpu_time) ) / (double) CLOCKS_PER_SEC;
-      double wall_time = CLOCK_T_AS_DOUBLE(encoding_end_real_time) - CLOCK_T_AS_DOUBLE(encoding_start_real_time);
+      double wall_time = KVZ_CLOCK_T_AS_DOUBLE(encoding_end_real_time) - KVZ_CLOCK_T_AS_DOUBLE(encoding_start_real_time);
       fprintf(stderr, " Encoding time: %.3f s.\n", encoding_time);
       fprintf(stderr, " Encoding wall time: %.3f s.\n", wall_time);
       fprintf(stderr, " Encoding CPU usage: %.2f%%\n", encoding_time/wall_time*100.f);

kvazaar-0.7.2.tar.gz/src/encoder.c -> kvazaar-0.8.1.tar.gz/src/encoder.c Changed

@@ -18,10 +18,6 @@
  * with Kvazaar.  If not, see <http://www.gnu.org/licenses/>.
  ****************************************************************************/
 
-/*
- * \file
- */
-
 #include "encoder.h"
 
 #include <stdio.h>
@@ -172,13 +168,18 @@
   
   kvz_encoder_control_input_init(encoder, cfg->width, cfg->height);
 
-  encoder->target_avg_bppic = cfg->target_bitrate / cfg->framerate;
+  if (cfg->framerate_num != 0) {
+    double framerate = cfg->framerate_num / (double)cfg->framerate_denom;
+    encoder->target_avg_bppic = cfg->target_bitrate / (framerate);
+  } else {
+    encoder->target_avg_bppic = cfg->target_bitrate / cfg->framerate;
+  }
   encoder->target_avg_bpp = encoder->target_avg_bppic / encoder->in.pixels_per_pic;
 
   if (!encoder_control_init_gop_layer_weights(encoder)) {
     goto init_failed;
   }
-  
+
   //Tiles
   encoder->tiles_enable = encoder->cfg->tiles_width_count > 0 ||
                           encoder->cfg->tiles_height_count > 0;
@@ -430,6 +431,14 @@
   encoder->vui.transfer = encoder->cfg->vui.transfer;
   encoder->vui.colormatrix = encoder->cfg->vui.colormatrix;
   encoder->vui.chroma_loc = (int8_t)encoder->cfg->vui.chroma_loc;
+
+  // If fractional framerate is set, use that instead of the floating point framerate.
+  if (cfg->framerate_num != 0) {
+    encoder->vui.timing_info_present_flag = 1;
+    encoder->vui.num_units_in_tick = cfg->framerate_denom;
+    encoder->vui.time_scale = cfg->framerate_num;
+  }
+
   // AUD
   encoder->aud_enable = (int8_t)encoder->cfg->aud_enable;
 
@@ -547,6 +556,7 @@
     case 0:
       break;
 
+    case 3:
     case 4:
       // These weights were copied from http://doi.org/10.1109/TIP.2014.2336550
       if (encoder->target_avg_bpp <= 0.05) {
@@ -588,11 +598,3 @@
 
   return 1;
 }
-
-unsigned kvz_get_padding(unsigned width_or_height){
-  if (width_or_height % CU_MIN_SIZE_PIXELS){
-    return CU_MIN_SIZE_PIXELS - (width_or_height % CU_MIN_SIZE_PIXELS);
-  }else{
-    return 0;
-  }
-}

kvazaar-0.7.2.tar.gz/src/encoder.h -> kvazaar-0.8.1.tar.gz/src/encoder.h Changed

@@ -20,9 +20,10 @@
  * with Kvazaar.  If not, see <http://www.gnu.org/licenses/>.
  ****************************************************************************/
 
-/*
+/**
+ * \ingroup Control
  * \file
- * \brief The highest level of the encoder.
+ * Initialization of encoder_control_t.
  */
 
 #include "global.h"
@@ -83,6 +84,10 @@
   /* VUI */
   struct
   {
+    /* Timing info */
+    int32_t num_units_in_tick; /*!< \brief Timing scale numerator */
+    int32_t time_scale; /*!< \brief Timing scale denominator */
+
     int16_t sar_width;
     int16_t sar_height;
     int8_t overscan;
@@ -95,6 +100,8 @@
 
     int8_t field_seq_flag;
     int8_t frame_field_info_present_flag;
+
+    int8_t timing_info_present_flag;
   } vui;
 
   int8_t aud_enable;
@@ -159,5 +166,4 @@
 void kvz_encoder_control_free(encoder_control_t *encoder);
 
 void kvz_encoder_control_input_init(encoder_control_t *encoder, int32_t width, int32_t height);
-unsigned kvz_get_padding(unsigned width_or_height);
 #endif

kvazaar-0.7.2.tar.gz/src/encoder_state-bitstream.c -> kvazaar-0.8.1.tar.gz/src/encoder_state-bitstream.c Changed

@@ -265,11 +265,15 @@
   //IF default display window
   //ENDIF
 
-  WRITE_U(stream, 0, 1, "vui_timing_info_present_flag");
-
-  //IF timing info
-  //ENDIF
+  WRITE_U(stream, encoder->vui.timing_info_present_flag, 1, "vui_timing_info_present_flag");
+  if (encoder->vui.timing_info_present_flag) {
+    WRITE_U(stream, encoder->vui.num_units_in_tick, 32, "vui_num_units_in_tick");
+    WRITE_U(stream, encoder->vui.time_scale, 32, "vui_time_scale");
 
+    WRITE_U(stream, 0, 1, "vui_poc_proportional_to_timing_flag");
+    WRITE_U(stream, 0, 1, "vui_hrd_parameters_present_flag");    
+  }
+  
   WRITE_U(stream, 0, 1, "bitstream_restriction_flag");
 
   //IF bitstream restriction
@@ -329,8 +333,13 @@
   WRITE_U(stream, 0, 1, "sps_sub_layer_ordering_info_present_flag");
 
   //for each layer
-  WRITE_UE(stream, encoder->cfg->ref_frames + encoder->cfg->gop_len, "sps_max_dec_pic_buffering");
-  WRITE_UE(stream, encoder->cfg->gop_len, "sps_num_reorder_pics");
+  if (encoder->cfg->gop_lowdelay) {
+    WRITE_UE(stream, encoder->cfg->ref_frames, "sps_max_dec_pic_buffering");
+    WRITE_UE(stream, 0, "sps_num_reorder_pics");
+  } else {
+    WRITE_UE(stream, encoder->cfg->ref_frames + encoder->cfg->gop_len, "sps_max_dec_pic_buffering");
+    WRITE_UE(stream, encoder->cfg->gop_len, "sps_num_reorder_pics");
+  }
   WRITE_UE(stream, 0, "sps_max_latency_increase");
   //end for
 
@@ -348,7 +357,8 @@
     encoder_state_write_bitstream_scaling_list(stream, state);
   }
 
-  WRITE_U(stream, 0, 1, "amp_enabled_flag");
+  WRITE_U(stream, (encoder->cfg->amp_enable ? 1 : 0), 1, "amp_enabled_flag");
+
   WRITE_U(stream, encoder->sao_enable ? 1 : 0, 1,
           "sample_adaptive_offset_enabled_flag");
   WRITE_U(stream, ENABLE_PCM, 1, "pcm_enabled_flag");

kvazaar-0.7.2.tar.gz/src/encoder_state-bitstream.h -> kvazaar-0.8.1.tar.gz/src/encoder_state-bitstream.h Changed

kvazaar-0.7.2.tar.gz/src/encoder_state-ctors_dtors.h -> kvazaar-0.8.1.tar.gz/src/encoder_state-ctors_dtors.h Changed

kvazaar-0.7.2.tar.gz/src/encoder_state-geometry.h -> kvazaar-0.8.1.tar.gz/src/encoder_state-geometry.h Changed

kvazaar-0.7.2.tar.gz/src/encoderstate.c -> kvazaar-0.8.1.tar.gz/src/encoderstate.c Changed

@@ -18,10 +18,6 @@
  * with Kvazaar.  If not, see <http://www.gnu.org/licenses/>.
  ****************************************************************************/
 
-/*
- * \file
- */
-
 #include "encoderstate.h"
 
 #include <math.h>
@@ -43,6 +39,7 @@
 #include "sao.h"
 #include "rdo.h"
 #include "rate_control.h"
+#include "strategies/strategies-picture.h"
 
 int kvz_encoder_state_match_children_of_previous_frame(encoder_state_t * const state) {
   int i;
@@ -787,6 +784,12 @@
       state->global->pictype = KVZ_NAL_IDR_W_RADL;
     } else {
       state->global->slicetype = encoder->cfg->intra_period==1 ? KVZ_SLICE_I : (state->encoder_control->cfg->gop_len?KVZ_SLICE_B:KVZ_SLICE_P);
+
+      // Use P-slice for lowdelay.
+      if (state->global->slicetype == KVZ_SLICE_B && encoder->cfg->gop_lowdelay) {
+        state->global->slicetype = KVZ_SLICE_P;
+      }
+
       state->global->pictype = KVZ_NAL_TRAIL_R;
       if (state->encoder_control->cfg->gop_len) {
         if (encoder->cfg->intra_period > 1 && (state->global->poc % encoder->cfg->intra_period) == 0) {
@@ -970,6 +973,353 @@
   state->prepared = 1;
 }
 
+static void encode_part_mode(encoder_state_t * const state,
+                             cabac_data_t * const cabac,
+                             const cu_info_t * const cur_cu,
+                             int depth)
+{
+  // Binarization from Table 9-34 of the HEVC spec:
+  //
+  //                |   log2CbSize >     |    log2CbSize ==
+  //                |   MinCbLog2SizeY   |    MinCbLog2SizeY
+  // -------+-------+----------+---------+-----------+----------
+  //  pred  | part  | AMP      | AMP     |           |
+  //  mode  | mode  | disabled | enabled | size == 8 | size > 8
+  // -------+-------+----------+---------+-----------+----------
+  //  intra | 2Nx2N |        -         - |         1          1
+  //        |   NxN |        -         - |         0          0
+  // -------+-------+--------------------+----------------------
+  //  inter | 2Nx2N |        1         1 |         1          1
+  //        |  2NxN |       01       011 |        01         01
+  //        |  Nx2N |       00       001 |        00        001
+  //        |   NxN |        -         - |         -        000
+  //        | 2NxnU |        -      0100 |         -          -
+  //        | 2NxnD |        -      0101 |         -          -
+  //        | nLx2N |        -      0000 |         -          -
+  //        | nRx2N |        -      0001 |         -          -
+  // -------+-------+--------------------+----------------------
+  //
+  //
+  // Context indices from Table 9-37 of the HEVC spec:
+  //
+  //                                      binIdx
+  //                               |  0  1  2       3
+  // ------------------------------+------------------
+  //  log2CbSize == MinCbLog2SizeY |  0  1  2  bypass
+  //  log2CbSize >  MinCbLog2SizeY |  0  1  3  bypass
+  // ------------------------------+------------------
+
+  if (cur_cu->type == CU_INTRA) {
+    if (depth == MAX_DEPTH) {
+      cabac->cur_ctx = &(cabac->ctx.part_size_model[0]);
+      if (cur_cu->part_size == SIZE_2Nx2N) {
+        CABAC_BIN(cabac, 1, "part_mode 2Nx2N");
+      } else {
+        CABAC_BIN(cabac, 0, "part_mode NxN");
+      }
+    }
+  } else {
+
+    cabac->cur_ctx = &(cabac->ctx.part_size_model[0]);
+    if (cur_cu->part_size == SIZE_2Nx2N) {
+      CABAC_BIN(cabac, 1, "part_mode 2Nx2N");
+      return;
+    }
+    CABAC_BIN(cabac, 0, "part_mode split");
+
+    cabac->cur_ctx = &(cabac->ctx.part_size_model[1]);
+    if (cur_cu->part_size == SIZE_2NxN ||
+        cur_cu->part_size == SIZE_2NxnU ||
+        cur_cu->part_size == SIZE_2NxnD) {
+      CABAC_BIN(cabac, 1, "part_mode vertical");
+    } else {
+      CABAC_BIN(cabac, 0, "part_mode horizontal");
+    }
+
+    if (state->encoder_control->cfg->amp_enable) {
+      if (depth == MAX_DEPTH) {
+        cabac->cur_ctx = &(cabac->ctx.part_size_model[2]);
+      } else {
+        cabac->cur_ctx = &(cabac->ctx.part_size_model[3]);
+      }
+
+      if (cur_cu->part_size == SIZE_2NxN ||
+          cur_cu->part_size == SIZE_Nx2N) {
+        CABAC_BIN(cabac, 1, "part_mode SMP");
+        return;
+      }
+      CABAC_BIN(cabac, 0, "part_mode AMP");
+
+      if (cur_cu->part_size == SIZE_2NxnU ||
+          cur_cu->part_size == SIZE_nLx2N) {
+        CABAC_BINS_EP(cabac, 0, 1, "part_mode AMP");
+      } else {
+        CABAC_BINS_EP(cabac, 1, 1, "part_mode AMP");
+      }
+    }
+  }
+}
+
+static void encode_inter_prediction_unit(encoder_state_t * const state,
+                                         cabac_data_t * const cabac,
+                                         const cu_info_t * const cur_cu,
+                                         int x_ctb, int y_ctb, int depth)
+{
+  // Mergeflag
+  int16_t num_cand = 0;
+  cabac->cur_ctx = &(cabac->ctx.cu_merge_flag_ext_model);
+  CABAC_BIN(cabac, cur_cu->merged, "MergeFlag");
+  num_cand = MRG_MAX_NUM_CANDS;
+  if (cur_cu->merged) { //merge
+    if (num_cand > 1) {
+      int32_t ui;
+      for (ui = 0; ui < num_cand - 1; ui++) {
+        int32_t symbol = (ui != cur_cu->merge_idx);
+        if (ui == 0) {
+          cabac->cur_ctx = &(cabac->ctx.cu_merge_idx_ext_model);
+          CABAC_BIN(cabac, symbol, "MergeIndex");
+        } else {
+          CABAC_BIN_EP(cabac,symbol,"MergeIndex");
+        }
+        if (symbol == 0) break;
+      }
+    }
+  } else {
+    uint32_t ref_list_idx;
+    uint32_t j;
+    int ref_list[2] = { 0, 0 };
+    for (j = 0; j < state->global->ref->used_size; j++) {
+      if (state->global->ref->pocs[j] < state->global->poc) {
+        ref_list[0]++;
+      } else {
+        ref_list[1]++;
+      }
+    }
+
+    // Void TEncSbac::codeInterDir( TComDataCU* pcCU, UInt uiAbsPartIdx )
+    if (state->global->slicetype == KVZ_SLICE_B)
+    {
+      // Code Inter Dir
+      uint8_t inter_dir = cur_cu->inter.mv_dir-1;
+      uint8_t ctx = depth;
+      
+
+      if (cur_cu->part_size == SIZE_2Nx2N || (LCU_WIDTH >> depth) != 8)
+      {
+        cabac->cur_ctx = &(cabac->ctx.inter_dir[ctx]);
+        CABAC_BIN(cabac, (inter_dir == 2), "inter_pred_idc");
+      }
+      if (inter_dir < 2)
+      {
+        cabac->cur_ctx = &(cabac->ctx.inter_dir[4]);
+        CABAC_BIN(cabac, inter_dir, "inter_pred_idc");
+      }
+    }
+
+    for (ref_list_idx = 0; ref_list_idx < 2; ref_list_idx++) {
+      if (cur_cu->inter.mv_dir & (1 << ref_list_idx)) {
+        if (ref_list[ref_list_idx] > 1) {
+          // parseRefFrmIdx
+          int32_t ref_frame = cur_cu->inter.mv_ref_coded[ref_list_idx];
+
+          cabac->cur_ctx = &(cabac->ctx.cu_ref_pic_model[0]);
+          CABAC_BIN(cabac, (ref_frame != 0), "ref_idx_lX");
+
+          if (ref_frame > 0) {
+            int32_t i;
+            int32_t ref_num = ref_list[ref_list_idx] - 2;
+
+            cabac->cur_ctx = &(cabac->ctx.cu_ref_pic_model[1]);
+            ref_frame--;
+
+            for (i = 0; i < ref_num; ++i) {
+              const uint32_t symbol = (i == ref_frame) ? 0 : 1;
+
+              if (i == 0) {
+                CABAC_BIN(cabac, symbol, "ref_idx_lX");
+              } else {
+                CABAC_BIN_EP(cabac, symbol, "ref_idx_lX");
+              }
+              if (symbol == 0) break;
+            }
+          }
+        }
+
+        if (!(/*pcCU->getSlice()->getMvdL1ZeroFlag() &&*/ state->global->ref_list == REF_PIC_LIST_1 && cur_cu->inter.mv_dir == 3)) {
+          const int32_t mvd_hor = cur_cu->inter.mvd[ref_list_idx][0];
+          const int32_t mvd_ver = cur_cu->inter.mvd[ref_list_idx][1];
+          const int8_t hor_abs_gr0 = mvd_hor != 0;
+          const int8_t ver_abs_gr0 = mvd_ver != 0;
+          const uint32_t mvd_hor_abs = abs(mvd_hor);
+          const uint32_t mvd_ver_abs = abs(mvd_ver);
+
+          cabac->cur_ctx = &(cabac->ctx.cu_mvd_model[0]);
+          CABAC_BIN(cabac, (mvd_hor != 0), "abs_mvd_greater0_flag_hor");
+          CABAC_BIN(cabac, (mvd_ver != 0), "abs_mvd_greater0_flag_ver");
+
+          cabac->cur_ctx = &(cabac->ctx.cu_mvd_model[1]);
+
+          if (hor_abs_gr0) {
+            CABAC_BIN(cabac, (mvd_hor_abs>1), "abs_mvd_greater1_flag_hor");
+          }
+
+          if (ver_abs_gr0) {
+            CABAC_BIN(cabac, (mvd_ver_abs>1), "abs_mvd_greater1_flag_ver");
+          }
+
+          if (hor_abs_gr0) {
+            if (mvd_hor_abs > 1) {
+              kvz_cabac_write_ep_ex_golomb(cabac,mvd_hor_abs-2, 1);
+            }
+
+            CABAC_BIN_EP(cabac, (mvd_hor>0)?0:1, "mvd_sign_flag_hor");
+          }
+
+          if (ver_abs_gr0) {
+            if (mvd_ver_abs > 1) {
+              kvz_cabac_write_ep_ex_golomb(cabac,mvd_ver_abs-2, 1);
+            }
+
+            CABAC_BIN_EP(cabac, (mvd_ver>0)?0:1, "mvd_sign_flag_ver");
+          }
+        }
+
+        // Signal which candidate MV to use
+        kvz_cabac_write_unary_max_symbol(cabac, cabac->ctx.mvp_idx_model, cur_cu->inter.mv_cand[ref_list_idx], 1,
+                                    AMVP_MAX_NUM_CANDS - 1);
+      }
+    } // for ref_list
+  } // if !merge
+}
+
+static void encode_intra_coding_unit(encoder_state_t * const state,
+                                     cabac_data_t * const cabac,
+                                     const cu_info_t * const cur_cu,
+                                     int x_ctb, int y_ctb, int depth)
+{
+  const videoframe_t * const frame = state->tile->frame;
+  uint8_t intra_pred_mode[4] = {
+    cur_cu->intra[0].mode, cur_cu->intra[1].mode,
+    cur_cu->intra[2].mode, cur_cu->intra[3].mode };
+    uint8_t intra_pred_mode_chroma = cur_cu->intra[0].mode_chroma;
+  int8_t intra_preds[4][3] = {{-1, -1, -1},{-1, -1, -1},{-1, -1, -1},{-1, -1, -1}};
+  int8_t mpm_preds[4] = {-1, -1, -1, -1};
+  int i, j;
+  uint32_t flag[4];
+  int num_pred_units = (cur_cu->part_size == SIZE_2Nx2N ? 1 : 4);
+
+  #if ENABLE_PCM == 1
+  // Code must start after variable initialization
+  kvz_cabac_encode_bin_trm(cabac, 0); // IPCMFlag == 0
+  #endif
+
+  // PREDINFO CODING
+  // If intra prediction mode is found from the predictors,
+  // it can be signaled with two EP's. Otherwise we can send
+  // 5 EP bins with the full predmode
+  for (j = 0; j < num_pred_units; ++j) {
+    static const vector2d_t offset[4] = {{0,0},{1,0},{0,1},{1,1}};
+    const cu_info_t *left_cu = NULL;
+    const cu_info_t *above_cu = NULL;
+
+    if (x_ctb > 0) {
+      left_cu = kvz_videoframe_get_cu_const(frame, x_ctb - 1, y_ctb);
+    }
+    // Don't take the above CU across the LCU boundary.
+    if (y_ctb > 0 && (y_ctb & 7) != 0) {
+      above_cu = kvz_videoframe_get_cu_const(frame, x_ctb, y_ctb - 1);
+    }
+
+    kvz_intra_get_dir_luma_predictor((x_ctb<<3) + (offset[j].x<<2),
+                                 (y_ctb<<3) + (offset[j].y<<2),
+                                 intra_preds[j], cur_cu,
+                                 left_cu, above_cu);
+    for (i = 0; i < 3; i++) {
+      if (intra_preds[j][i] == intra_pred_mode[j]) {
+        mpm_preds[j] = (int8_t)i;
+        break;
+      }
+    }
+    flag[j] = (mpm_preds[j] == -1) ? 0 : 1;
+  }
+
+  cabac->cur_ctx = &(cabac->ctx.intra_mode_model);
+  for (j = 0; j < num_pred_units; ++j) {
+    CABAC_BIN(cabac, flag[j], "prev_intra_luma_pred_flag");
+  }
+
+  for (j = 0; j < num_pred_units; ++j) {
+    // Signal index of the prediction mode in the prediction list.
+    if (flag[j]) {
+      CABAC_BIN_EP(cabac, (mpm_preds[j] == 0 ? 0 : 1), "mpm_idx");
+      if (mpm_preds[j] != 0) {
+        CABAC_BIN_EP(cabac, (mpm_preds[j] == 1 ? 0 : 1), "mpm_idx");
+      }
+    } else {
+      // Signal the actual prediction mode.
+      int32_t tmp_pred = intra_pred_mode[j];
+
+      // Sort prediction list from lowest to highest.
+      if (intra_preds[j][0] > intra_preds[j][1]) SWAP(intra_preds[j][0], intra_preds[j][1], int8_t);
+      if (intra_preds[j][0] > intra_preds[j][2]) SWAP(intra_preds[j][0], intra_preds[j][2], int8_t);
+      if (intra_preds[j][1] > intra_preds[j][2]) SWAP(intra_preds[j][1], intra_preds[j][2], int8_t);
+
+      // Reduce the index of the signaled prediction mode according to the
+      // prediction list, as it has been already signaled that it's not one
+      // of the prediction modes.
+      for (i = 2; i >= 0; i--) {
+        tmp_pred = (tmp_pred > intra_preds[j][i] ? tmp_pred - 1 : tmp_pred);
+      }
+
+      CABAC_BINS_EP(cabac, tmp_pred, 5, "rem_intra_luma_pred_mode");
+    }
+  }
+
+  {  // start intra chroma pred mode coding
+    unsigned pred_mode = 5;
+    unsigned chroma_pred_modes[4] = {0, 26, 10, 1};
+
+    if (intra_pred_mode_chroma == intra_pred_mode[0]) {
+      pred_mode = 4;
+    } else if (intra_pred_mode_chroma == 34) {
+      // Angular 34 mode is possible only if intra pred mode is one of the
+      // possible chroma pred modes, in which case it is signaled with that
+      // duplicate mode.
+      for (i = 0; i < 4; ++i) {
+        if (intra_pred_mode[0] == chroma_pred_modes[i]) pred_mode = i;
+      }
+    } else {
+      for (i = 0; i < 4; ++i) {
+        if (intra_pred_mode_chroma == chroma_pred_modes[i]) pred_mode = i;
+      }
+    }
+
+    // pred_mode == 5 mean intra_pred_mode_chroma is something that can't
+    // be coded.
+    assert(pred_mode != 5);
+
+    /**
+     * Table 9-35 - Binarization for intra_chroma_pred_mode
+     *   intra_chroma_pred_mode  bin_string
+     *                        4           0
+     *                        0         100
+     *                        1         101
+     *                        2         110
+     *                        3         111
+     * Table 9-37 - Assignment of ctxInc to syntax elements with context coded bins
+     *   intra_chroma_pred_mode[][] = 0, bypass, bypass
+     */
+    cabac->cur_ctx = &(cabac->ctx.chroma_pred_model[0]);
+    if (pred_mode == 4) {
+      CABAC_BIN(cabac, 0, "intra_chroma_pred_mode");
+    } else {
+      CABAC_BIN(cabac, 1, "intra_chroma_pred_mode");
+      CABAC_BINS_EP(cabac, pred_mode, 2, "intra_chroma_pred_mode");
+    }
+  }  // end intra chroma pred mode coding
+
+  kvz_encode_transform_coeff(state, x_ctb * 2, y_ctb * 2, depth, 0, 0, 0);
+}
 
 void kvz_encode_coding_tree(encoder_state_t * const state,
                         uint16_t x_ctb, uint16_t y_ctb, uint8_t depth)
@@ -1075,149 +1425,19 @@
   }
 
   // part_mode
-  if (cur_cu->type == CU_INTRA) {
-    if (depth == MAX_DEPTH) {
-      cabac->cur_ctx = &(cabac->ctx.part_size_model[0]);
-      if (cur_cu->part_size == SIZE_2Nx2N) {
-        CABAC_BIN(cabac, 1, "part_mode 2Nx2N");
-      } else {
-        CABAC_BIN(cabac, 0, "part_mode NxN");
-      }
-    }
-  } else {
-    // TODO: Handle inter sizes other than 2Nx2N
-    cabac->cur_ctx = &(cabac->ctx.part_size_model[0]);
-    CABAC_BIN(cabac, 1, "part_mode 2Nx2N");
-  }
+  encode_part_mode(state, cabac, cur_cu, depth);
 
-  //end partsize
   if (cur_cu->type == CU_INTER) {
-    // FOR each part
-    // Mergeflag
-    int16_t num_cand = 0;
-    cabac->cur_ctx = &(cabac->ctx.cu_merge_flag_ext_model);
-    CABAC_BIN(cabac, cur_cu->merged, "MergeFlag");
-    num_cand = MRG_MAX_NUM_CANDS;
-    if (cur_cu->merged) { //merge
-      if (num_cand > 1) {
-        int32_t ui;
-        for (ui = 0; ui < num_cand - 1; ui++) {
-          int32_t symbol = (ui != cur_cu->merge_idx);
-          if (ui == 0) {
-            cabac->cur_ctx = &(cabac->ctx.cu_merge_idx_ext_model);
-            CABAC_BIN(cabac, symbol, "MergeIndex");
-          } else {
-            CABAC_BIN_EP(cabac,symbol,"MergeIndex");
-          }
-          if (symbol == 0) break;
-        }
-      }
-    } else {
-      uint32_t ref_list_idx;
-      uint32_t j;
-      int ref_list[2] = { 0, 0 };
-      for (j = 0; j < state->global->ref->used_size; j++) {
-        if (state->global->ref->pocs[j] < state->global->poc) {
-          ref_list[0]++;
-        } else {
-          ref_list[1]++;
-        }
-      }
-
-      // Void TEncSbac::codeInterDir( TComDataCU* pcCU, UInt uiAbsPartIdx )
-      if (state->global->slicetype == KVZ_SLICE_B)
-      {
-        // Code Inter Dir
-        uint8_t inter_dir = cur_cu->inter.mv_dir-1;
-        uint8_t ctx = depth;
-        
-
-        if (cur_cu->part_size == SIZE_2Nx2N || (LCU_WIDTH >> depth) != 8)
-        {
-          cabac->cur_ctx = &(cabac->ctx.inter_dir[ctx]);
-          CABAC_BIN(cabac, (inter_dir == 2), "inter_pred_idc");
-        }
-        if (inter_dir < 2)
-        {
-          cabac->cur_ctx = &(cabac->ctx.inter_dir[4]);
-          CABAC_BIN(cabac, inter_dir, "inter_pred_idc");
-        }
-      }
-
-      for (ref_list_idx = 0; ref_list_idx < 2; ref_list_idx++) {
-        if (cur_cu->inter.mv_dir & (1 << ref_list_idx)) {
-          if (ref_list[ref_list_idx] > 1) {
-            // parseRefFrmIdx
-            int32_t ref_frame = cur_cu->inter.mv_ref_coded[ref_list_idx];
-
-            cabac->cur_ctx = &(cabac->ctx.cu_ref_pic_model[0]);
-            CABAC_BIN(cabac, (ref_frame != 0), "ref_idx_lX");
+    const int num_pu = kvz_part_mode_num_parts[cur_cu->part_size];
+    const int cu_width_scu = LCU_CU_WIDTH >> depth;
 
-            if (ref_frame > 0) {
-              int32_t i;
-              int32_t ref_num = ref_list[ref_list_idx] - 2;
-
-              cabac->cur_ctx = &(cabac->ctx.cu_ref_pic_model[1]);
-              ref_frame--;
-
-              for (i = 0; i < ref_num; ++i) {
-                const uint32_t symbol = (i == ref_frame) ? 0 : 1;
-
-                if (i == 0) {
-                  CABAC_BIN(cabac, symbol, "ref_idx_lX");
-                } else {
-                  CABAC_BIN_EP(cabac, symbol, "ref_idx_lX");
-                }
-                if (symbol == 0) break;
-              }
-            }
-          }
-
-          if (!(/*pcCU->getSlice()->getMvdL1ZeroFlag() &&*/ state->global->ref_list == REF_PIC_LIST_1 && cur_cu->inter.mv_dir == 3)) {
-            const int32_t mvd_hor = cur_cu->inter.mvd[ref_list_idx][0];
-            const int32_t mvd_ver = cur_cu->inter.mvd[ref_list_idx][1];
-            const int8_t hor_abs_gr0 = mvd_hor != 0;
-            const int8_t ver_abs_gr0 = mvd_ver != 0;
-            const uint32_t mvd_hor_abs = abs(mvd_hor);
-            const uint32_t mvd_ver_abs = abs(mvd_ver);
-
-            cabac->cur_ctx = &(cabac->ctx.cu_mvd_model[0]);
-            CABAC_BIN(cabac, (mvd_hor != 0), "abs_mvd_greater0_flag_hor");
-            CABAC_BIN(cabac, (mvd_ver != 0), "abs_mvd_greater0_flag_ver");
-
-            cabac->cur_ctx = &(cabac->ctx.cu_mvd_model[1]);
-
-            if (hor_abs_gr0) {
-              CABAC_BIN(cabac, (mvd_hor_abs>1), "abs_mvd_greater1_flag_hor");
-            }
-
-            if (ver_abs_gr0) {
-              CABAC_BIN(cabac, (mvd_ver_abs>1), "abs_mvd_greater1_flag_ver");
-            }
+    for (int i = 0; i < num_pu; ++i) {
+      const int pu_x_scu = PU_GET_X(cur_cu->part_size, cu_width_scu, x_ctb, i);
+      const int pu_y_scu = PU_GET_Y(cur_cu->part_size, cu_width_scu, y_ctb, i);
+      const cu_info_t *cur_pu = kvz_videoframe_get_cu_const(frame, pu_x_scu, pu_y_scu);
 
-            if (hor_abs_gr0) {
-              if (mvd_hor_abs > 1) {
-                kvz_cabac_write_ep_ex_golomb(cabac,mvd_hor_abs-2, 1);
-              }
-
-              CABAC_BIN_EP(cabac, (mvd_hor>0)?0:1, "mvd_sign_flag_hor");
-            }
-
-            if (ver_abs_gr0) {
-              if (mvd_ver_abs > 1) {
-                kvz_cabac_write_ep_ex_golomb(cabac,mvd_ver_abs-2, 1);
-              }
-
-              CABAC_BIN_EP(cabac, (mvd_ver>0)?0:1, "mvd_sign_flag_ver");
-            }
-          }
-
-          // Signal which candidate MV to use
-          kvz_cabac_write_unary_max_symbol(cabac, cabac->ctx.mvp_idx_model, cur_cu->inter.mv_cand[ref_list_idx], 1,
-                                      AMVP_MAX_NUM_CANDS - 1);
-        }
-      } // for ref_list
-    } // if !merge
+      encode_inter_prediction_unit(state, cabac, cur_pu, pu_x_scu, pu_y_scu, depth);
+    }
 
     {
       int cbf = (cbf_is_set(cur_cu->cbf.y, depth) ||
@@ -1226,7 +1446,7 @@
 
       // Only need to signal coded block flag if not skipped or merged
       // skip = no coded residual, merge = coded residual
-      if (!cur_cu->merged) {
+      if (cur_cu->part_size != SIZE_2Nx2N || !cur_cu->merged) {
         cabac->cur_ctx = &(cabac->ctx.cu_qt_root_cbf_model);
         CABAC_BIN(cabac, cbf, "rqt_root_cbf");
       }
@@ -1236,130 +1456,8 @@
         kvz_encode_transform_coeff(state, x_ctb * 2, y_ctb * 2, depth, 0, 0, 0);
       }
     }
-
-    // END for each part
   } else if (cur_cu->type == CU_INTRA) {
-    uint8_t intra_pred_mode[4] = {
-      cur_cu->intra[0].mode, cur_cu->intra[1].mode,
-      cur_cu->intra[2].mode, cur_cu->intra[3].mode };
-      uint8_t intra_pred_mode_chroma = cur_cu->intra[0].mode_chroma;
-    int8_t intra_preds[4][3] = {{-1, -1, -1},{-1, -1, -1},{-1, -1, -1},{-1, -1, -1}};
-    int8_t mpm_preds[4] = {-1, -1, -1, -1};
-    int i, j;
-    uint32_t flag[4];
-    int num_pred_units = (cur_cu->part_size == SIZE_2Nx2N ? 1 : 4);
-
-    #if ENABLE_PCM == 1
-    // Code must start after variable initialization
-    kvz_cabac_encode_bin_trm(cabac, 0); // IPCMFlag == 0
-    #endif
-
-    // PREDINFO CODING
-    // If intra prediction mode is found from the predictors,
-    // it can be signaled with two EP's. Otherwise we can send
-    // 5 EP bins with the full predmode
-    for (j = 0; j < num_pred_units; ++j) {
-      static const vector2d_t offset[4] = {{0,0},{1,0},{0,1},{1,1}};
-      const cu_info_t *left_cu = NULL;
-      const cu_info_t *above_cu = NULL;
-
-      if (x_ctb > 0) {
-        left_cu = kvz_videoframe_get_cu_const(frame, x_ctb - 1, y_ctb);
-      }
-      // Don't take the above CU across the LCU boundary.
-      if (y_ctb > 0 && (y_ctb & 7) != 0) {
-        above_cu = kvz_videoframe_get_cu_const(frame, x_ctb, y_ctb - 1);
-      }
-
-      kvz_intra_get_dir_luma_predictor((x_ctb<<3) + (offset[j].x<<2),
-                                   (y_ctb<<3) + (offset[j].y<<2),
-                                   intra_preds[j], cur_cu,
-                                   left_cu, above_cu);
-      for (i = 0; i < 3; i++) {
-        if (intra_preds[j][i] == intra_pred_mode[j]) {
-          mpm_preds[j] = (int8_t)i;
-          break;
-        }
-      }
-      flag[j] = (mpm_preds[j] == -1) ? 0 : 1;
-    }
-
-    cabac->cur_ctx = &(cabac->ctx.intra_mode_model);
-    for (j = 0; j < num_pred_units; ++j) {
-      CABAC_BIN(cabac, flag[j], "prev_intra_luma_pred_flag");
-    }
-
-    for (j = 0; j < num_pred_units; ++j) {
-      // Signal index of the prediction mode in the prediction list.
-      if (flag[j]) {
-        CABAC_BIN_EP(cabac, (mpm_preds[j] == 0 ? 0 : 1), "mpm_idx");
-        if (mpm_preds[j] != 0) {
-          CABAC_BIN_EP(cabac, (mpm_preds[j] == 1 ? 0 : 1), "mpm_idx");
-        }
-      } else {
-        // Signal the actual prediction mode.
-        int32_t tmp_pred = intra_pred_mode[j];
-
-        // Sort prediction list from lowest to highest.
-        if (intra_preds[j][0] > intra_preds[j][1]) SWAP(intra_preds[j][0], intra_preds[j][1], int8_t);
-        if (intra_preds[j][0] > intra_preds[j][2]) SWAP(intra_preds[j][0], intra_preds[j][2], int8_t);
-        if (intra_preds[j][1] > intra_preds[j][2]) SWAP(intra_preds[j][1], intra_preds[j][2], int8_t);
-
-        // Reduce the index of the signaled prediction mode according to the
-        // prediction list, as it has been already signaled that it's not one
-        // of the prediction modes.
-        for (i = 2; i >= 0; i--) {
-          tmp_pred = (tmp_pred > intra_preds[j][i] ? tmp_pred - 1 : tmp_pred);
-        }
-
-        CABAC_BINS_EP(cabac, tmp_pred, 5, "rem_intra_luma_pred_mode");
-      }
-    }
-
-    {  // start intra chroma pred mode coding
-      unsigned pred_mode = 5;
-      unsigned chroma_pred_modes[4] = {0, 26, 10, 1};
-
-      if (intra_pred_mode_chroma == intra_pred_mode[0]) {
-        pred_mode = 4;
-      } else if (intra_pred_mode_chroma == 34) {
-        // Angular 34 mode is possible only if intra pred mode is one of the
-        // possible chroma pred modes, in which case it is signaled with that
-        // duplicate mode.
-        for (i = 0; i < 4; ++i) {
-          if (intra_pred_mode[0] == chroma_pred_modes[i]) pred_mode = i;
-        }
-      } else {
-        for (i = 0; i < 4; ++i) {
-          if (intra_pred_mode_chroma == chroma_pred_modes[i]) pred_mode = i;
-        }
-      }
-
-      // pred_mode == 5 mean intra_pred_mode_chroma is something that can't
-      // be coded.
-      assert(pred_mode != 5);
-
-      /**
-       * Table 9-35 - Binarization for intra_chroma_pred_mode
-       *   intra_chroma_pred_mode  bin_string
-       *                        4           0
-       *                        0         100
-       *                        1         101
-       *                        2         110
-       *                        3         111
-       * Table 9-37 - Assignment of ctxInc to syntax elements with context coded bins
-       *   intra_chroma_pred_mode[][] = 0, bypass, bypass
-       */
-      cabac->cur_ctx = &(cabac->ctx.chroma_pred_model[0]);
-      if (pred_mode == 4) {
-        CABAC_BIN(cabac, 0, "intra_chroma_pred_mode");
-      } else {
-        CABAC_BIN(cabac, 1, "intra_chroma_pred_mode");
-        CABAC_BINS_EP(cabac, pred_mode, 2, "intra_chroma_pred_mode");
-      }
-    }  // end intra chroma pred mode coding
-
-    kvz_encode_transform_coeff(state, x_ctb * 2, y_ctb * 2, depth, 0, 0, 0);
+    encode_intra_coding_unit(state, cabac, cur_cu, x_ctb, y_ctb, depth);
   }
 
     #if ENABLE_PCM == 1
@@ -1606,20 +1704,15 @@
   uint8_t last_coeff_x = 0;
   uint8_t last_coeff_y = 0;
   int32_t i;
-  uint32_t sig_coeffgroup_flag[64];
+  uint32_t sig_coeffgroup_flag[8 * 8] = { 0 };
 
-  uint32_t num_nonzero = 0;
-  int32_t scan_pos_last = -1;
-  int32_t pos_last = 0;
-  int32_t shift   = 4>>1;
   int8_t be_valid = encoder->sign_hiding;
   int32_t scan_pos_sig;
-  int32_t last_scan_set;
   uint32_t go_rice_param = 0;
   uint32_t blk_pos, pos_y, pos_x, sig, ctx_sig;
 
   // CONSTANTS
-  const uint32_t num_blk_side    = width >> shift;
+  const uint32_t num_blk_side    = width >> TR_MIN_LOG2_SIZE;
   const uint32_t log2_block_size = kvz_g_convert_to_bit[width] + 2;
   const uint32_t *scan           =
     kvz_g_sig_last_scan[scan_mode][log2_block_size - 1];
@@ -1629,39 +1722,49 @@
   cabac_ctx_t *base_coeff_group_ctx = &(cabac->ctx.cu_sig_coeff_group_model[type]);
   cabac_ctx_t *baseCtx           = (type == 0) ? &(cabac->ctx.cu_sig_model_luma[0]) :
                                  &(cabac->ctx.cu_sig_model_chroma[0]);
-  FILL(sig_coeffgroup_flag, 0);
 
-  // Count non-zero coeffs
-  for (i = 0; i < width * width; i++) {
-    if (coeff[i] != 0) {
-      num_nonzero++;
+  // Scan all coeff groups to find out which of them have coeffs.
+  // Populate sig_coeffgroup_flag with that info.
+  unsigned sig_cg_cnt = 0;
+  for (int cg_y = 0; cg_y < width / 4; ++cg_y) {
+    for (int cg_x = 0; cg_x < width / 4; ++cg_x) {
+      unsigned cg_pos = cg_y * width * 4 + cg_x * 4;
+      for (int coeff_row = 0; coeff_row < 4; ++coeff_row) {
+        // Load four 16-bit coeffs and see if any of them are non-zero.
+        unsigned coeff_pos = cg_pos + coeff_row * width;
+        uint64_t four_coeffs = *(uint64_t*)(&coeff[coeff_pos]);
+        if (four_coeffs) {
+          ++sig_cg_cnt;
+          unsigned cg_pos_y = (cg_pos >> log2_block_size) >> TR_MIN_LOG2_SIZE;
+          unsigned cg_pos_x = (cg_pos & (width - 1)) >> TR_MIN_LOG2_SIZE;
+          sig_coeffgroup_flag[cg_pos_x + cg_pos_y * num_blk_side] = 1;
+          break;
+        }
+      }
     }
   }
 
-  // Transforms with no non-zero coefficients are indicated with CBFs.
-  assert(num_nonzero != 0);
+  // Rest of the code assumes at least one non-zero coeff.
+  assert(sig_cg_cnt > 0);
 
-  // transform skip flag
-  if(width == 4 && encoder->trskip_enable) {
-    cabac->cur_ctx = (type == 0) ? &(cabac->ctx.transform_skip_model_luma) : &(cabac->ctx.transform_skip_model_chroma);
-    CABAC_BIN(cabac, tr_skip, "transform_skip_flag");
+  // Find the last coeff group by going backwards in scan order.
+  unsigned scan_cg_last = num_blk_side * num_blk_side - 1;
+  while (!sig_coeffgroup_flag[scan_cg[scan_cg_last]]) {
+    --scan_cg_last;
   }
 
-  scan_pos_last = -1;
-
-  // Significance mapping
-  while (num_nonzero > 0) {
-    pos_last = scan[++scan_pos_last];
-#define POSY (pos_last >> log2_block_size)
-#define POSX (pos_last - ( POSY << log2_block_size ))
+  // Find the last coeff by going backwards in scan order.
+  unsigned scan_pos_last = scan_cg_last * 16 + 15;
+  while (!coeff[scan[scan_pos_last]]) {
+    --scan_pos_last;
+  }
 
-    if (coeff[pos_last] != 0) {
-      sig_coeffgroup_flag[(num_blk_side * (POSY >> shift) + (POSX >> shift))] = 1;
-    }
+  int pos_last = scan[scan_pos_last];
 
-    num_nonzero -= (coeff[pos_last] != 0) ? 1 : 0;
-    #undef POSY
-    #undef POSX
+  // transform skip flag
+  if(width == 4 && encoder->trskip_enable) {
+    cabac->cur_ctx = (type == 0) ? &(cabac->ctx.transform_skip_model_luma) : &(cabac->ctx.transform_skip_model_chroma);
+    CABAC_BIN(cabac, tr_skip, "transform_skip_flag");
   }
 
   last_coeff_x = pos_last & (width - 1);
@@ -1672,10 +1775,9 @@
                              type, scan_mode);
 
   scan_pos_sig  = scan_pos_last;
-  last_scan_set = (scan_pos_last >> 4);
 
   // significant_coeff_flag
-  for (i = last_scan_set; i >= 0; i--) {
+  for (i = scan_cg_last; i >= 0; i--) {
     int32_t sub_pos        = i << 4; // LOG2_SCAN_SET_SIZE;
     int32_t abs_coeff[16];
     int32_t cg_blk_pos     = scan_cg[i];
@@ -1697,7 +1799,7 @@
       scan_pos_sig--;
     }
 
-    if (i == last_scan_set || i == 0) {
+    if (i == scan_cg_last || i == 0) {
       sig_coeffgroup_flag[cg_blk_pos] = 1;
     } else {
       uint32_t sig_coeff_group   = (sig_coeffgroup_flag[cg_blk_pos] != 0);

kvazaar-0.7.2.tar.gz/src/encoderstate.h -> kvazaar-0.8.1.tar.gz/src/encoderstate.h Changed

kvazaar-0.7.2.tar.gz/src/filter.c -> kvazaar-0.8.1.tar.gz/src/filter.c Changed

@@ -18,10 +18,6 @@
  * with Kvazaar.  If not, see <http://www.gnu.org/licenses/>.
  ****************************************************************************/
 
-/*
- * \file
- */
-
 #include "filter.h"
 
 #include <assert.h>
@@ -83,11 +79,16 @@
 /**
  * \brief
  */
-INLINE void kvz_filter_deblock_luma(const encoder_control_t * const encoder, kvz_pixel *src, int32_t offset,
-                                int32_t tc, int8_t sw,
-                                int8_t part_P_nofilter, int8_t part_Q_nofilter,
-                                int32_t thr_cut,
-                                int8_t filter_second_P, int8_t filter_second_Q)
+static INLINE void kvz_filter_deblock_luma(const encoder_control_t * const encoder,
+                                           kvz_pixel *src,
+                                           int32_t offset,
+                                           int32_t tc,
+                                           int8_t sw,
+                                           int8_t part_P_nofilter,
+                                           int8_t part_Q_nofilter,
+                                           int32_t thr_cut,
+                                           int8_t filter_second_P,
+                                           int8_t filter_second_Q)
 {
   int32_t delta;
 
@@ -143,8 +144,12 @@
 /**
  * \brief
  */
-INLINE void kvz_filter_deblock_chroma(const encoder_control_t * const encoder, kvz_pixel *src, int32_t offset, int32_t tc,
-                                  int8_t part_P_nofilter, int8_t part_Q_nofilter)
+static INLINE void kvz_filter_deblock_chroma(const encoder_control_t * const encoder,
+                                             kvz_pixel *src,
+                                             int32_t offset,
+                                             int32_t tc,
+                                             int8_t part_P_nofilter,
+                                             int8_t part_Q_nofilter)
 {
   int32_t delta;
   int16_t m2 = src[-offset * 2];
@@ -161,80 +166,173 @@
   }
 }
 
+
 /**
- * \brief
+ * \brief Check whether an edge is a TU boundary.
+ *
+ * \param state   encoder state
+ * \param x       x-coordinate of the scu in pixels
+ * \param y       y-coordinate of the scu in pixels
+ * \param dir     direction of the edge to check
+ * \return        true, if the edge is a TU boundary, otherwise false
+ */
+static bool is_tu_boundary(const encoder_state_t *const state,
+                           int32_t x,
+                           int32_t y,
+                           edge_dir dir)
+{
+  const cu_info_t *const scu = kvz_videoframe_get_cu(state->tile->frame,
+                                                     x >> MIN_SIZE,
+                                                     y >> MIN_SIZE);
+  const int tu_width = LCU_WIDTH >> scu->tr_depth;
+
+  if (dir == EDGE_HOR) {
+    return (y & (tu_width - 1)) == 0;
+  } else {
+    return (x & (tu_width - 1)) == 0;
+  }
+}
+
+
+/**
+ * \brief Check whether an edge is a PU boundary.
+ *
+ * \param state   encoder state
+ * \param x       x-coordinate of the scu in pixels
+ * \param y       y-coordinate of the scu in pixels
+ * \param dir     direction of the edge to check
+ * \return        true, if the edge is a TU boundary, otherwise false
  */
-void kvz_filter_deblock_edge_luma(encoder_state_t * const state,
-                              int32_t xpos, int32_t ypos,
-                              int8_t depth, int8_t dir)
+static bool is_pu_boundary(const encoder_state_t *const state,
+                           int32_t x,
+                           int32_t y,
+                           edge_dir dir)
+{
+  const cu_info_t *const scu = kvz_videoframe_get_cu(state->tile->frame,
+                                                     x >> MIN_SIZE,
+                                                     y >> MIN_SIZE);
+  // Get the containing CU.
+  const int32_t cu_width = LCU_WIDTH >> scu->depth;
+  const int32_t x_cu = x & ~(cu_width - 1);
+  const int32_t y_cu = y & ~(cu_width - 1);
+  const cu_info_t *const cu = kvz_videoframe_get_cu(state->tile->frame,
+                                                    x_cu >> MIN_SIZE,
+                                                    y_cu >> MIN_SIZE);
+
+  const int num_pu = kvz_part_mode_num_parts[cu->part_size];
+  for (int i = 0; i < num_pu; i++) {
+    if (dir == EDGE_HOR) {
+      int y_pu = PU_GET_Y(cu->part_size, cu_width, y_cu, i);
+      if (y_pu == y) return true;
+
+    } else {
+      int x_pu = PU_GET_X(cu->part_size, cu_width, x_cu, i);
+      if (x_pu == x) return true;
+    }
+  }
+
+  return false;
+}
+
+
+/**
+ * \brief Check whether an edge is aligned on a 8x8 grid.
+ *
+ * \param x     x-coordinate of the edge
+ * \param y     y-coordinate of the edge
+ * \param dir   direction of the edge
+ * \return      true, if the edge is aligned on a 8x8 grid, otherwise false
+ */
+static bool is_on_8x8_grid(int x, int y, edge_dir dir)
+{
+  if (dir == EDGE_HOR) {
+    return (y & 7) == 0;
+  } else {
+    return (x & 7) == 0;
+  }
+}
+
+/**
+ * \brief Apply the deblocking filter to luma pixels on a single edge.
+ *
+ * The caller should check that the edge is a TU boundary or a PU boundary.
+ *
+ \verbatim
+
+         .-- filter this edge if dir == EDGE_HOR
+         v
+     +--------+
+     |o <-- pixel at (x, y)
+     |        |
+     |<-- filter this edge if dir == EDGE_VER
+     |        |
+     +--------+
+
+ \endverbatim
+ *
+ * \param state     encoder state
+ * \param x         x-coordinate in pixels (see above)
+ * \param y         y-coordinate in pixels (see above)
+ * \param length    length of the edge in pixels
+ * \param dir       direction of the edge to filter
+ * \param tu_boundary   whether the edge is a TU boundary
+ */
+static void filter_deblock_edge_luma(encoder_state_t * const state,
+                                     int32_t x,
+                                     int32_t y,
+                                     int32_t length,
+                                     edge_dir dir,
+                                     bool tu_boundary)
 {
   videoframe_t * const frame = state->tile->frame;
   const encoder_control_t * const encoder = state->encoder_control;
   
-  cu_info_t *cu_q = kvz_videoframe_get_cu(frame, xpos >> MIN_SIZE, ypos >> MIN_SIZE);
-
-  {
-    // Return if called with a coordinate which is not at CU or TU boundary.
-    // TODO: Add handling for asymmetric inter CU boundaries which do not coincide
-    // with transform boundaries.
-    const int tu_width = LCU_WIDTH >> cu_q->tr_depth;
-    if (dir == EDGE_HOR && (ypos & (tu_width - 1))) return;
-    if (dir == EDGE_VER && (xpos & (tu_width - 1))) return;
-  }
+  cu_info_t *cu_q = kvz_videoframe_get_cu(frame, x >> MIN_SIZE, y >> MIN_SIZE);
 
   {
     int32_t stride = frame->rec->stride;
-    int32_t offset = stride;
     int32_t beta_offset_div2 = encoder->beta_offset_div2;
     int32_t tc_offset_div2   = encoder->tc_offset_div2;
     // TODO: support 10+bits
-    kvz_pixel *orig_src = &frame->rec->y[xpos + ypos*stride];
+    kvz_pixel *orig_src = &frame->rec->y[x + y*stride];
     kvz_pixel *src = orig_src;
-    int32_t step = 1;
     cu_info_t *cu_p = NULL;
-    int16_t x_cu = xpos>>MIN_SIZE,y_cu = ypos>>MIN_SIZE;
-    int8_t strength = 0;
+    int16_t x_cu = x >> MIN_SIZE;
+    int16_t y_cu = y >> MIN_SIZE;
 
+    int8_t strength = 0;
     int32_t qp              = state->global->QP;
     int32_t bitdepth_scale  = 1 << (encoder->bitdepth - 8);
     int32_t b_index         = CLIP(0, 51, qp + (beta_offset_div2 << 1));
     int32_t beta            = kvz_g_beta_table_8x8[b_index] * bitdepth_scale;
     int32_t side_threshold  = (beta + (beta >>1 )) >> 3;
-    uint32_t blocks_in_part = (LCU_WIDTH >> depth) / 4;
-    uint32_t block_idx;
-    int32_t tc_index,tc,thr_cut;
+    int32_t tc_index;
+    int32_t tc;
+    int32_t thr_cut;
 
-    if (dir == EDGE_VER) {
-      offset = 1;
-      step = stride;
-    }
+    uint32_t num_4px_parts  = length / 4;
+
+    const int32_t offset = (dir == EDGE_HOR) ? stride :      1;
+    const int32_t step   = (dir == EDGE_HOR) ?      1 : stride;
 
     // TODO: add CU based QP calculation
 
     // For each 4-pixel part in the edge
-    for (block_idx = 0; block_idx < blocks_in_part; ++block_idx) {
+    for (uint32_t block_idx = 0; block_idx < num_4px_parts; ++block_idx) {
       int32_t dp0, dq0, dp3, dq3, d0, d3, dp, dq, d;
 
       {
-        vector2d_t px = {
-          (dir == EDGE_HOR ? xpos + block_idx * 4 : xpos),
-          (dir == EDGE_VER ? ypos + block_idx * 4 : ypos)
-        };
-
-        // Don't deblock the last 4x4 block of the LCU. This will be deblocked
-        // when processing the next LCU.
-        if (block_idx > 0 && dir == EDGE_HOR && (px.x + 4) % 64 == 0 && (px.x + 4 != frame->width)) {
-          continue;
-        }
-
         // CU in the side we are filtering, update every 8-pixels
         cu_p = kvz_videoframe_get_cu(frame, x_cu - (dir == EDGE_VER) + (dir == EDGE_HOR ? block_idx>>1 : 0), y_cu - (dir == EDGE_HOR) + (dir == EDGE_VER ? block_idx>>1 : 0));
 
+        bool nonzero_coeffs = cbf_is_set(cu_q->cbf.y, cu_q->tr_depth)
+                           || cbf_is_set(cu_p->cbf.y, cu_p->tr_depth);
+
         // Filter strength
         strength = 0;
-        if(cu_q->type == CU_INTRA || cu_p->type == CU_INTRA) {
+        if (cu_q->type == CU_INTRA || cu_p->type == CU_INTRA) {
           strength = 2;
-        } else if(cbf_is_set(cu_q->cbf.y, cu_q->tr_depth) || cbf_is_set(cu_p->cbf.y, cu_p->tr_depth)) {
+        } else if (tu_boundary && nonzero_coeffs) {
           // Non-zero residual/coeffs and transform boundary
           // Neither CU is intra so tr_depth <= MAX_DEPTH.
           strength = 1;       
@@ -341,53 +439,62 @@
                     useStrongFiltering(offset, 2*d3, (src+step*(block_idx*4+3)));
 
         // Filter four rows/columns
-        kvz_filter_deblock_luma(encoder, src + step * (4*block_idx + 0), offset, tc, sw, 0, 0, thr_cut, filter_P, filter_Q);
-        kvz_filter_deblock_luma(encoder, src + step * (4*block_idx + 1), offset, tc, sw, 0, 0, thr_cut, filter_P, filter_Q);
-        kvz_filter_deblock_luma(encoder, src + step * (4*block_idx + 2), offset, tc, sw, 0, 0, thr_cut, filter_P, filter_Q);
-        kvz_filter_deblock_luma(encoder, src + step * (4*block_idx + 3), offset, tc, sw, 0, 0, thr_cut, filter_P, filter_Q);
+        for (int i = 0; i < 4; i++) {
+          kvz_filter_deblock_luma(encoder, src + step * (4*block_idx + i), offset, tc, sw, 0, 0, thr_cut, filter_P, filter_Q);
+        }
       }
     }
   }
 }
 
 /**
- * \brief
+ * \brief Apply the deblocking filter to chroma pixels on a single edge.
+ *
+ * The caller should check that the edge is a TU boundary or a PU boundary.
+ *
+ \verbatim
+
+         .-- filter this edge if dir == EDGE_HOR
+         v
+     +--------+
+     |o <-- pixel at (x, y)
+     |        |
+     |<-- filter this edge if dir == EDGE_VER
+     |        |
+     +--------+
+
+ \endverbatim
+ *
+ * \param state         encoder state
+ * \param x             x-coordinate in chroma pixels (see above)
+ * \param y             y-coordinate in chroma pixels (see above)
+ * \param length        length of the edge in chroma pixels
+ * \param dir           direction of the edge to filter
+ * \param tu_boundary   whether the edge is a TU boundary
  */
-void kvz_filter_deblock_edge_chroma(encoder_state_t * const state,
-                                int32_t x, int32_t y,
-                                int8_t depth, int8_t dir)
+static void filter_deblock_edge_chroma(encoder_state_t * const state,
+                                       int32_t x,
+                                       int32_t y,
+                                       int32_t length,
+                                       edge_dir dir,
+                                       bool tu_boundary)
 {
   const encoder_control_t * const encoder = state->encoder_control;
   const videoframe_t * const frame = state->tile->frame;
   const cu_info_t *cu_q = kvz_videoframe_get_cu_const(frame, x >> (MIN_SIZE - 1), y >> (MIN_SIZE - 1));
-  
-  // Chroma edges that do not lay on a 8x8 grid are not deblocked.
-  if (depth >= MAX_DEPTH) {
-    if (dir == EDGE_HOR && (y & (8 - 1))) return;
-    if (dir == EDGE_VER && (x & (8 - 1))) return;
-  }
-
-  {
-    // Return if called with a coordinate which is not at CU or TU boundary.
-    // TODO: Add handling for asymmetric inter CU boundaries which do not coincide
-    // with transform boundaries.
-    const int tu_width = (LCU_WIDTH / 2) >> cu_q->tr_depth;
-    if (dir == EDGE_HOR && (y & (tu_width - 1))) return;
-    if (dir == EDGE_VER && (x & (tu_width - 1))) return;
-  }
 
   // For each subpart
   {
     int32_t stride = frame->rec->stride >> 1;
     int32_t tc_offset_div2 = encoder->tc_offset_div2;
     // TODO: support 10+bits
-    kvz_pixel *src_u = &frame->rec->u[x + y*stride];
-    kvz_pixel *src_v = &frame->rec->v[x + y*stride];
-    // Init offset and step to EDGE_HOR
-    int32_t offset = stride;
-    int32_t step = 1;
+    kvz_pixel *src[] = {
+      &frame->rec->u[x + y*stride],
+      &frame->rec->v[x + y*stride],
+    };
     const cu_info_t *cu_p = NULL;
-    int16_t x_cu = x>>(MIN_SIZE-1),y_cu = y>>(MIN_SIZE-1);
+    int16_t x_cu = x >> (MIN_SIZE-1);
+    int16_t y_cu = y >> (MIN_SIZE-1);
     int8_t strength = 2;
 
     int32_t QP             = kvz_g_chroma_scale[state->global->QP];
@@ -395,131 +502,186 @@
     int32_t TC_index       = CLIP(0, 51+2, (int32_t)(QP + 2*(strength-1) + (tc_offset_div2 << 1)));
     int32_t Tc             = kvz_g_tc_table_8x8[TC_index]*bitdepth_scale;
 
-    // Special handling for depth 4. It's meaning is that we want to bypass
-    // last block in LCU check in order to deblock just that block.
-    uint32_t blocks_in_part= (LCU_WIDTH>>(depth == 4 ? depth : depth + 1)) / 4;
-    uint32_t blk_idx;
+    const uint32_t num_4px_parts = length / 4;
 
-    if(dir == EDGE_VER) {
-      offset = 1;
-      step = stride;
-    }
+    const int32_t offset = (dir == EDGE_HOR) ? stride :      1;
+    const int32_t step   = (dir == EDGE_HOR) ?      1 : stride;
 
-    for (blk_idx = 0; blk_idx < blocks_in_part; ++blk_idx)
+    for (uint32_t blk_idx = 0; blk_idx < num_4px_parts; ++blk_idx)
     {
-      vector2d_t px = {
-        (dir == EDGE_HOR ? x + blk_idx * 4 : x),
-        (dir == EDGE_VER ? y + blk_idx * 4 : y)
-      };
       cu_p = kvz_videoframe_get_cu_const(frame, x_cu - (dir == EDGE_VER) + (dir == EDGE_HOR ? blk_idx : 0), y_cu - (dir == EDGE_HOR) + (dir == EDGE_VER ? blk_idx : 0));
 
-      // Don't deblock the last 4x4 block of the LCU. This will be deblocked
-      // when processing the next LCU.
-      if (depth != 4 && dir == EDGE_HOR && (px.x + 4) % 32 == 0 && (px.x + 4 != frame->width / 2)) {
-        continue;
-      }
-
       // Only filter when strenght == 2 (one of the blocks is intra coded)
       if (cu_q->type == CU_INTRA || cu_p->type == CU_INTRA) {
-        // Chroma U
-        kvz_filter_deblock_chroma(encoder, src_u + step * (4*blk_idx + 0), offset, Tc, 0, 0);
-        kvz_filter_deblock_chroma(encoder, src_u + step * (4*blk_idx + 1), offset, Tc, 0, 0);
-        kvz_filter_deblock_chroma(encoder, src_u + step * (4*blk_idx + 2), offset, Tc, 0, 0);
-        kvz_filter_deblock_chroma(encoder, src_u + step * (4*blk_idx + 3), offset, Tc, 0, 0);
-        // Chroma V
-        kvz_filter_deblock_chroma(encoder, src_v + step * (4*blk_idx + 0), offset, Tc, 0, 0);
-        kvz_filter_deblock_chroma(encoder, src_v + step * (4*blk_idx + 1), offset, Tc, 0, 0);
-        kvz_filter_deblock_chroma(encoder, src_v + step * (4*blk_idx + 2), offset, Tc, 0, 0);
-        kvz_filter_deblock_chroma(encoder, src_v + step * (4*blk_idx + 3), offset, Tc, 0, 0);
+        for (int component = 0; component < 2; component++) {
+          for (int i = 0; i < 4; i++) {
+            kvz_filter_deblock_chroma(encoder, src[component] + step * (4*blk_idx + i), offset, Tc, 0, 0);
+          }
+        }
       }
     }
   }
 }
 
+
 /**
- * \brief function to split LCU into smaller CU blocks
- * \param encoder the encoder info structure
- * \param xCtb block x-position (as SCU)
- * \param yCtb block y-position (as SCU)
- * \param depth block depth
- * \param edge which edge we are filtering
+ * \brief Filter edge of a single PU or TU
  *
- * This function takes (SCU) block position as input and splits the block
- * until the coded block size has been achived. Calls luma and chroma filtering
- * functions for each coded CU size.
+ * \param state     encoder state
+ * \param x         block x-position in pixels
+ * \param y         block y-position in pixels
+ * \param width     block width in pixels
+ * \param height    block height in pixels
+ * \param dir       direction of the edges to filter
+ * \param tu_boundary   whether the edge is a TU boundary
  */
-void kvz_filter_deblock_cu(encoder_state_t * const state, int32_t x, int32_t y, int8_t depth, int32_t edge)
+static void filter_deblock_unit(encoder_state_t * const state,
+                                int x,
+                                int y,
+                                int width,
+                                int height,
+                                edge_dir dir,
+                                bool tu_boundary)
 {
-  const videoframe_t * const frame = state->tile->frame;
-  const cu_info_t *cur_cu = kvz_videoframe_get_cu_const(frame, x, y);
-  uint8_t split_flag = (cur_cu->depth > depth) ? 1 : 0;
-  uint8_t tr_split = (cur_cu->tr_depth > depth) ? 1 : 0;
-  uint8_t border_x = (frame->width  < x*(LCU_WIDTH >> MAX_DEPTH) + (LCU_WIDTH >> depth)) ? 1 : 0;
-  uint8_t border_y = (frame->height < y*(LCU_WIDTH >> MAX_DEPTH) + (LCU_WIDTH >> depth)) ? 1 : 0;
-  uint8_t border_split_x = (frame->width  < ((x + 1) * (LCU_WIDTH >> MAX_DEPTH)) + (LCU_WIDTH >> (depth + 1))) ? 0 : 1;
-  uint8_t border_split_y = (frame->height < ((y + 1) * (LCU_WIDTH >> MAX_DEPTH)) + (LCU_WIDTH >> (depth + 1))) ? 0 : 1;
-
-  uint8_t border = border_x | border_y; // are we in any border CU?
-
-  // split 64x64, on split flag and on border
-  if (depth < MAX_DEPTH && (depth == 0 || split_flag || border || tr_split)) {
-    // Split the four sub-blocks of this block recursively.
-    uint8_t change;
-    assert(depth >= 0);  // for clang-analyzer
-    change = 1 << (MAX_DEPTH - 1 - depth);
-
-    kvz_filter_deblock_cu(state, x, y, depth + 1, edge);
-    if(!border_x || border_split_x) {
-      kvz_filter_deblock_cu(state, x + change, y, depth + 1, edge);
-    }
-    if(!border_y || border_split_y) {
-      kvz_filter_deblock_cu(state, x , y + change, depth + 1, edge);
-    }
-    if((!border_x && !border_y) || (border_split_x && border_split_y)) {
-      kvz_filter_deblock_cu(state, x + change, y + change, depth + 1, edge);
+  // no filtering on borders (where filter would use pixels outside the picture)
+  if (x == 0 && dir == EDGE_VER) return;
+  if (y == 0 && dir == EDGE_HOR) return;
+
+  // Length of luma and chroma edges.
+  int32_t length;
+  int32_t length_c;
+
+  if (dir == EDGE_HOR) {
+    const videoframe_t * const frame = state->tile->frame;
+    const int32_t x_right             = x + width;
+    const bool rightmost_4px_of_lcu   = x_right % LCU_WIDTH == 0;
+    const bool rightmost_4px_of_frame = x_right == frame->width;
+
+    if (rightmost_4px_of_lcu && !rightmost_4px_of_frame) {
+      // The last 4 pixels will be deblocked when processing the next LCU.
+      length   = width - 4;
+      length_c = (width >> 1) - 4;
+
+    } else {
+      length   = width;
+      length_c = width >> 1;
     }
-    return;
+  } else {
+    length   = height;
+    length_c = height >> 1;
   }
 
-  // no filtering on borders (where filter would use pixels outside the picture)
-  if ((x == 0 && edge == EDGE_VER) || (y == 0 && edge == EDGE_HOR)) return;
+  filter_deblock_edge_luma(state, x, y, length, dir, tu_boundary);
 
-  // do the filtering for block edge
-  kvz_filter_deblock_edge_luma(state,   x*(LCU_WIDTH >> MAX_DEPTH),       y*(LCU_WIDTH >> MAX_DEPTH),       depth, edge);
-  kvz_filter_deblock_edge_chroma(state, x*(LCU_WIDTH >> (MAX_DEPTH + 1)), y*(LCU_WIDTH >> (MAX_DEPTH + 1)), depth, edge);
+  // Chroma pixel coordinates.
+  const int32_t x_c = x >> 1;
+  const int32_t y_c = y >> 1;
+  if (is_on_8x8_grid(x_c, y_c, dir)) {
+    filter_deblock_edge_chroma(state, x_c, y_c, length_c, dir, tu_boundary);
+  }
 }
 
 
 /**
- * \brief Deblock a single LCU without using data from right or down.
+ * \brief Deblock PU and TU boundaries inside an LCU.
+ *
+ * \param state     encoder state
+ * \param x_px      block x-position in pixels
+ * \param y_px      block y-position in pixels
+ * \param dir       direction of the edges to filter
  *
- * Filter all the following edges:
- * - All edges within the LCU, except for the last 4 pixels on the right when
- *   using horizontal filtering.
- * - Left edge and top edge.
- * - After vertical filtering the left edge, filter the last 4 pixels of
- *   horizontal edges in the LCU to the left.
+ * Recursively traverse the CU/TU quadtree. At the lowest level, apply the
+ * deblocking filter to the left edge (when dir == EDGE_VER) or the top edge
+ * (when dir == EDGE_HOR) as needed. Both luma and chroma are filtered.
  */
-void kvz_filter_deblock_lcu(encoder_state_t * const state, int x_px, int y_px)
+static void filter_deblock_lcu_inside(encoder_state_t * const state,
+                                      int32_t x,
+                                      int32_t y,
+                                      edge_dir dir)
 {
-  const vector2d_t lcu = { x_px / LCU_WIDTH, y_px / LCU_WIDTH };
+  const int end_x = MIN(x + LCU_WIDTH, state->tile->frame->width);
+  const int end_y = MIN(y + LCU_WIDTH, state->tile->frame->height);
+
+  for (int edge_y = y; edge_y < end_y; edge_y += 8) {
+    for (int edge_x = x; edge_x < end_x; edge_x += 8) {
+      bool tu_boundary = is_tu_boundary(state, edge_x, edge_y, dir);
+      if (tu_boundary || is_pu_boundary(state, edge_x, edge_y, dir)) {
+        filter_deblock_unit(state, edge_x, edge_y, 8, 8, dir, tu_boundary);
+      }
+    }
+  }
+}
 
-  kvz_filter_deblock_cu(state, lcu.x << MAX_DEPTH, lcu.y << MAX_DEPTH, 0, EDGE_VER);
 
-  // Filter rightmost 4 pixels from last LCU now that they have been
-  // finally deblocked vertically.
-  if (lcu.x > 0) {
-    int y;
-    for (y = 0; y < 64; y += 8) {
-      if (lcu.y + y == 0) continue;
-      kvz_filter_deblock_edge_luma(state, lcu.x * 64 - 4, lcu.y * 64 + y, 4, EDGE_HOR);
-    }
-    for (y = 0; y < 32; y += 8) {
-      if (lcu.y + y == 0) continue;
-      kvz_filter_deblock_edge_chroma(state, lcu.x * 32 - 4, lcu.y * 32 + y, 4, EDGE_HOR);
+/**
+ * \brief Filter rightmost 4 pixels of the horizontal egdes of an LCU.
+ *
+ * \param state     encoder state
+ * \param x_px      x-coordinate of the *right* edge of the LCU in pixels
+ * \param y_px      y-coordinate of the top edge of the LCU in pixels
+ */
+static void filter_deblock_lcu_rightmost(encoder_state_t * const state,
+                                         int32_t x_px,
+                                         int32_t y_px)
+{
+  // Luma
+  const int x = x_px - 4;
+  const int end = MIN(y_px + LCU_WIDTH, state->tile->frame->height);
+  for (int y = y_px; y < end; y += 8) {
+    // The top edge of the whole frame is not filtered.
+    bool tu_boundary = is_tu_boundary(state, x, y, EDGE_HOR);
+    bool pu_boundary = is_pu_boundary(state, x, y, EDGE_HOR);
+    if (y > 0 && (tu_boundary || pu_boundary)) {
+      filter_deblock_edge_luma(state, x, y, 4, EDGE_HOR, tu_boundary);
     }
   }
 
-  kvz_filter_deblock_cu(state, lcu.x << MAX_DEPTH, lcu.y << MAX_DEPTH, 0, EDGE_HOR);
+  // Chroma
+  const int x_px_c = x_px >> 1;
+  const int y_px_c = y_px >> 1;
+  const int x_c = x_px_c - 4;
+  const int end_c = MIN(y_px_c + LCU_WIDTH_C, state->tile->frame->height >> 1);
+  for (int y_c = y_px_c; y_c < end_c; y_c += 8) {
+    // The top edge of the whole frame is not filtered.
+    bool tu_boundary = is_tu_boundary(state, x_c << 1, y_c << 1, EDGE_HOR);
+    bool pu_boundary = is_pu_boundary(state, x_c << 1, y_c << 1, EDGE_HOR);
+    if (y_c > 0 && (tu_boundary || pu_boundary)) {
+      filter_deblock_edge_chroma(state, x_c, y_c, 4, EDGE_HOR, tu_boundary);
+    }
+  }
 }
 
+
+/**
+ * \brief Deblock a single LCU without using data from right or down.
+ *
+ * Filter the following vertical edges (horizontal filtering):
+ *  1. The left edge of the LCU.
+ *  2. All vertical edges within the LCU.
+ *
+ * Filter the following horizontal edges (vertical filtering):
+ *  1. The rightmost 4 pixels of the top edge of the LCU to the left.
+ *  2. The rightmost 4 pixels of all horizontal edges within the LCU to the
+ *     left.
+ *  3. The top edge and all horizontal edges within the LCU, excluding the
+ *     rightmost 4 pixels. If the LCU is the rightmost LCU of the frame, the
+ *     last 4 pixels are also filtered.
+ *
+ * What is not filtered:
+ *  - The rightmost 4 pixels of the top edge and all horizontal edges within
+ *    the LCU, unless the LCU is the rightmost LCU of the frame.
+ *  - The bottom edge of the LCU.
+ *  - The right edge of the LCU.
+ *
+ * \param state   encoder state
+ * \param x_px    x-coordinate of the left edge of the LCU in pixels
+ * \param y_px    y-coordinate of the top edge of the LCU in pixels
+ */
+void kvz_filter_deblock_lcu(encoder_state_t * const state, int x_px, int y_px)
+{
+  filter_deblock_lcu_inside(state, x_px, y_px, EDGE_VER);
+  if (x_px > 0) {
+    filter_deblock_lcu_rightmost(state, x_px, y_px);
+  }
+  filter_deblock_lcu_inside(state, x_px, y_px, EDGE_HOR);
+}

kvazaar-0.7.2.tar.gz/src/filter.h -> kvazaar-0.8.1.tar.gz/src/filter.h Changed

@@ -20,9 +20,10 @@
  * with Kvazaar.  If not, see <http://www.gnu.org/licenses/>.
  ****************************************************************************/
 
-/*
+/**
+ * \ingroup Reconstruction
  * \file
- * \brief Filtering, such as deblocking.
+ * Deblocking filter.
  */
 
 #include "global.h"
@@ -31,30 +32,15 @@
 #include "encoderstate.h"
 
 
-//////////////////////////////////////////////////////////////////////////
-// FUNCTIONS
-// Deblocking
-void kvz_filter_deblock_cu(encoder_state_t *state, int32_t x_px, int32_t y_px,
-                       int8_t depth, int32_t edge);
-void kvz_filter_deblock_edge_luma(encoder_state_t *state,
-                              int32_t x_pos, int32_t y_pos,
-                              int8_t depth, int8_t dir);
-void kvz_filter_deblock_edge_chroma(encoder_state_t *state,
-                                int32_t xpos, int32_t ypos,
-                                int8_t depth, int8_t dir);
+/**
+ * \brief Edge direction.
+ */
+typedef enum edge_dir {
+  EDGE_VER = 0, // vertical
+  EDGE_HOR = 1, // horizontal
+} edge_dir;
+
+
 void kvz_filter_deblock_lcu(encoder_state_t *state, int x_px, int y_px);
-void kvz_filter_deblock_luma(const encoder_control_t * const encoder, kvz_pixel *src, int32_t offset, int32_t tc , int8_t sw,
-                         int8_t part_p_nofilter, int8_t part_q_nofilter,
-                         int32_t thr_cut,
-                         int8_t filter_second_p, int8_t filter_second_q);
-void kvz_filter_deblock_chroma(const encoder_control_t * const encoder, kvz_pixel *src, int32_t offset, int32_t tc,
-                           int8_t part_p_nofilter, int8_t part_q_nofilter);
-
-// SAO
-
-//////////////////////////////////////////////////////////////////////////
-// MACROS
-#define EDGE_VER 0
-#define EDGE_HOR 1
 
 #endif

kvazaar-0.7.2.tar.gz/src/global.h -> kvazaar-0.8.1.tar.gz/src/global.h Changed

@@ -20,9 +20,9 @@
  * with Kvazaar.  If not, see <http://www.gnu.org/licenses/>.
  ****************************************************************************/
 
-/*
+/**
  * \file
- * \brief Header that is included in every other header.
+ * Header that is included in every other header.
  *
  * This file contains global constants that can be referred to from any header
  * or source file. It also contains some helper macros and includes stdint.h
@@ -39,6 +39,37 @@
 
 #include "kvazaar.h"
 
+
+/**
+ * \defgroup Bitstream
+ * HEVC bitstream coding
+ *
+ * \defgroup CABAC
+ * Context Adaptive Binary Arithmetic Encoder implementation
+ * 
+ * \defgroup Compression
+ * Prediction parameter decisions and ratedistortion optimization
+ *
+ * \defgroup Control
+ * Initialization and control flow of the encoder
+ * 
+ * \defgroup DataStructures
+ * Containers for images, predictions parameters and such
+ * 
+ * \defgroup Extras
+ * 3rd party modules not considered part of the encoder.
+ *
+ * \defgroup Optimization
+ * Architecture dependant SIMD optimizations and dynamic dispatch mechanism
+ *
+ * \defgroup Reconstruction
+ * Stuff required for creating the resulting image after lossy compression
+ *
+ * \defgroup Threading
+ * Stuff related to multi-threading using pthreads
+ */
+
+
 #if defined(_MSC_VER) && defined(_M_AMD64)
   #define X86_64
 #endif
@@ -144,20 +175,13 @@
 
 // NOTE: When making a release, remember to also bump library version in
 // Makefile, if necessary.
-#define KVZ_VERSION 0.7.2
+#define KVZ_VERSION 0.8.1
 #define VERSION_STRING QUOTE_EXPAND(KVZ_VERSION)
 
 //#define VERBOSE 1
 
 #define SAO_ABS_OFFSET_MAX ((1 << (MIN(KVZ_BIT_DEPTH, 10) - 5)) - 1)
 
-
-#define SIZE_2Nx2N 0
-#define SIZE_2NxN  1
-#define SIZE_Nx2N  2
-#define SIZE_NxN   3
-#define SIZE_NONE  15
-
 #define MAX_TILES_PER_DIM 48
 #define MAX_SLICES 16

kvazaar-0.7.2.tar.gz/src/image.c -> kvazaar-0.8.1.tar.gz/src/image.c Changed

@@ -18,10 +18,6 @@
  * with Kvazaar.  If not, see <http://www.gnu.org/licenses/>.
  ****************************************************************************/
 
-/*
- * \file
- */
-
 #include "threads.h"
 #include "image.h"
 #include "strategyselector.h"
@@ -86,7 +82,7 @@
 {
   if (im == NULL) return;
 
-  int32_t new_refcount = ATOMIC_DEC(&(im->refcount));
+  int32_t new_refcount = KVZ_ATOMIC_DEC(&(im->refcount));
   if (new_refcount > 0) {
     // There are still references so we don't free the data yet.
     return;
@@ -116,7 +112,7 @@
 {
   // The caller should have had another reference.
   assert(im->refcount > 0);
-  ATOMIC_INC(&(im->refcount));
+  KVZ_ATOMIC_INC(&(im->refcount));
 
   return im;
 }
@@ -428,20 +424,15 @@
 * \returns  
 */
 unsigned kvz_image_calc_sad(const kvz_picture *pic, const kvz_picture *ref, int pic_x, int pic_y, int ref_x, int ref_y,
-                        int block_width, int block_height, int max_lcu_below) {
+                        int block_width, int block_height, int max_px_below_lcu) {
   assert(pic_x >= 0 && pic_x <= pic->width - block_width);
   assert(pic_y >= 0 && pic_y <= pic->height - block_height);
   
   // Check that we are not referencing pixels that are not final.
-  if (max_lcu_below >= 0) {
-    // When SAO is off, row is considered reconstructed when the last LCU
-    // is done, although the bottom 2 pixels might still need deblocking.
-    // To work around this, add 2 luma pixels to the reach of the mv
-    // in order to avoid referencing those possibly non-deblocked pixels.
-    int mv_lcu_row_reach = (ref_y + block_height - 1 + 2) / LCU_WIDTH;
-    int cur_lcu_row = pic_y / LCU_WIDTH;
-    if (mv_lcu_row_reach > cur_lcu_row + max_lcu_below) {
-      //printf("OOB %d %d -> %d\n", ref_y + block_height, pic_y, ref_y + block_height - pic_y);
+  if (max_px_below_lcu >= 0) {
+    int next_lcu_row_px = ((pic_y >> LOG2_LCU_WIDTH) + 1) << LOG2_LCU_WIDTH;
+    int px_below_lcu = ref_y + block_height - next_lcu_row_px;
+    if (px_below_lcu > max_px_below_lcu) {
       return INT_MAX;
     }
   }
@@ -476,55 +467,4 @@
   }
 
   return ssd;
-}
-
-
-/**
- * \brief BLock Image Transfer from one buffer to another.
- *
- * It's a stupidly simple loop that copies pixels.
- *
- * \param orig  Start of the originating buffer.
- * \param dst  Start of the destination buffer.
- * \param width  Width of the copied region.
- * \param height  Height of the copied region.
- * \param orig_stride  Width of a row in the originating buffer.
- * \param dst_stride  Width of a row in the destination buffer.
- *
- * This should be inlined, but it's defined here for now to see if Visual
- * Studios LTCG will inline it.
- */
-void kvz_pixels_blit(const kvz_pixel * const orig, kvz_pixel * const dst,
-                         const unsigned width, const unsigned height,
-                         const unsigned orig_stride, const unsigned dst_stride)
-{
-  unsigned y;
-  //There is absolutely no reason to have a width greater than the source or the destination stride.
-  assert(width <= orig_stride);
-  assert(width <= dst_stride);
-
-#ifdef CHECKPOINTS
-  char *buffer = malloc((3 * width + 1) * sizeof(char));
-  for (y = 0; y < height; ++y) {
-    int p;
-    for (p = 0; p < width; ++p) {
-      sprintf((buffer + 3*p), "%02X ", orig[y*orig_stride]);
-    }
-    buffer[3*width] = 0;
-    CHECKPOINT("kvz_pixels_blit: %04d: %s", y, buffer);
-  }
-  FREE_POINTER(buffer);
-#endif //CHECKPOINTS
-
-  if (orig == dst) {
-    //If we have the same array, then we should have the same stride
-    assert(orig_stride == dst_stride);
-    return;
-  }
-  assert(orig != dst || orig_stride == dst_stride);
-
-  for (y = 0; y < height; ++y) {
-    memcpy(&dst[y*dst_stride], &orig[y*orig_stride], width * sizeof(kvz_pixel));
-  }
-}
-
+}
\ No newline at end of file

kvazaar-0.7.2.tar.gz/src/image.h -> kvazaar-0.8.1.tar.gz/src/image.h Changed

kvazaar-0.7.2.tar.gz/src/imagelist.c -> kvazaar-0.8.1.tar.gz/src/imagelist.c Changed

kvazaar-0.7.2.tar.gz/src/imagelist.h -> kvazaar-0.8.1.tar.gz/src/imagelist.h Changed

kvazaar-0.7.2.tar.gz/src/input_frame_buffer.c -> kvazaar-0.8.1.tar.gz/src/input_frame_buffer.c Changed

kvazaar-0.7.2.tar.gz/src/input_frame_buffer.h -> kvazaar-0.8.1.tar.gz/src/input_frame_buffer.h Changed

kvazaar-0.7.2.tar.gz/src/inter.c -> kvazaar-0.8.1.tar.gz/src/inter.c Changed

@@ -18,10 +18,6 @@
  * with Kvazaar.  If not, see <http://www.gnu.org/licenses/>.
  ****************************************************************************/
 
-/*
- * \file
- */
-
 #include "inter.h"
 
 #include <stdio.h>
@@ -34,37 +30,14 @@
 #include "strategies/generic/ipol-generic.h"
 #include "strategies/generic/picture-generic.h"
 
-/**
- * \brief Set block info to the CU structure
- * \param pic picture to use
- * \param x_cu x CU position (smallest CU)
- * \param y_cu y CU position (smallest CU)
- * \param depth current CU depth
- * \param cur_cu CU to take the settings from
- * \returns Void
-*/
-void kvz_inter_set_block(videoframe_t* frame, uint32_t x_cu, uint32_t y_cu, uint8_t depth, cu_info_t* cur_cu)
-{
-  uint32_t x, y;
-  // Width in smallest CU
-  int block_scu_width = (LCU_WIDTH>>depth)/(LCU_WIDTH>>MAX_DEPTH);
-  int tr_depth = (depth == 0 ? 1 : depth);
-  // Loop through all the block in the area of cur_cu
-  for (y = y_cu; y < y_cu + block_scu_width; y++) {
-    for (x = x_cu; x < x_cu + block_scu_width; x++) {
-      cu_info_t * const cu = kvz_videoframe_get_cu(frame, x, y);
-      // Set all SCU's to this blocks values at the bottom most depth.
-      cu->depth = depth;
-      cu->type  = CU_INTER;
-      cu->part_size = SIZE_2Nx2N;
-      memcpy(&cu->inter, &cur_cu->inter, sizeof(cur_cu->inter));
-      
-      cu->tr_depth = tr_depth;
-    }
-  }
-}
-
-void kvz_inter_recon_frac_luma(const encoder_state_t * const state, const kvz_picture * const ref, int32_t xpos, int32_t ypos, int32_t block_width, const int16_t mv_param[2], lcu_t *lcu)
+static void inter_recon_frac_luma(const encoder_state_t * const state,
+                                  const kvz_picture * const ref,
+                                  int32_t xpos,
+                                  int32_t ypos,
+                                  int32_t block_width,
+                                  int32_t block_height,
+                                  const int16_t mv_param[2],
+                                  lcu_t *lcu)
 {
   int mv_frac_x = (mv_param[0] & 3);
   int mv_frac_y = (mv_param[1] & 3);
@@ -75,15 +48,41 @@
   kvz_extended_block src = {0, 0, 0};
 
   // Fractional luma
-  kvz_get_extended_block(xpos, ypos, mv_param[0] >> 2, mv_param[1] >> 2, state->tile->lcu_offset_x * LCU_WIDTH, state->tile->lcu_offset_y * LCU_WIDTH,
-    ref->y, ref->width, ref->height, FILTER_SIZE_Y, block_width, block_width, &src);
-  kvz_sample_quarterpel_luma_generic(state->encoder_control, src.orig_topleft, src.stride, block_width,
-    block_width, lcu->rec.y + (ypos%LCU_WIDTH)*LCU_WIDTH + (xpos%LCU_WIDTH), LCU_WIDTH, mv_frac_x, mv_frac_y, mv_param);
+  kvz_get_extended_block(xpos,
+                         ypos,
+                         mv_param[0] >> 2,
+                         mv_param[1] >> 2,
+                         state->tile->lcu_offset_x * LCU_WIDTH,
+                         state->tile->lcu_offset_y * LCU_WIDTH,
+                         ref->y,
+                         ref->width,
+                         ref->height,
+                         FILTER_SIZE_Y,
+                         block_width,
+                         block_height,
+                         &src);
+  kvz_sample_quarterpel_luma_generic(state->encoder_control,
+                                     src.orig_topleft,
+                                     src.stride,
+                                     block_width,
+                                     block_height,
+                                     lcu->rec.y + (ypos%LCU_WIDTH)*LCU_WIDTH + (xpos%LCU_WIDTH),
+                                     LCU_WIDTH,
+                                     mv_frac_x,
+                                     mv_frac_y,
+                                     mv_param);
 
   if (src.malloc_used) free(src.buffer);
 }
 
-void kvz_inter_recon_14bit_frac_luma(const encoder_state_t * const state, const kvz_picture * const ref, int32_t xpos, int32_t ypos, int32_t block_width, const int16_t mv_param[2], hi_prec_buf_t *hi_prec_out)
+static void inter_recon_14bit_frac_luma(const encoder_state_t * const state,
+                                        const kvz_picture * const ref,
+                                        int32_t xpos,
+                                        int32_t ypos,
+                                        int32_t block_width,
+                                        int32_t block_height,
+                                        const int16_t mv_param[2],
+                                        hi_prec_buf_t *hi_prec_out)
 {
   int mv_frac_x = (mv_param[0] & 3);
   int mv_frac_y = (mv_param[1] & 3);
@@ -94,15 +93,41 @@
   kvz_extended_block src = { 0, 0, 0 };
 
   // Fractional luma
-  kvz_get_extended_block(xpos, ypos, mv_param[0] >> 2, mv_param[1] >> 2, state->tile->lcu_offset_x * LCU_WIDTH, state->tile->lcu_offset_y * LCU_WIDTH,
-    ref->y, ref->width, ref->height, FILTER_SIZE_Y, block_width, block_width, &src);
-  kvz_sample_14bit_quarterpel_luma_generic(state->encoder_control, src.orig_topleft, src.stride, block_width,
-    block_width, hi_prec_out->y + (ypos%LCU_WIDTH)*LCU_WIDTH + (xpos%LCU_WIDTH), LCU_WIDTH, mv_frac_x, mv_frac_y, mv_param);
+  kvz_get_extended_block(xpos,
+                         ypos,
+                         mv_param[0] >> 2,
+                         mv_param[1] >> 2,
+                         state->tile->lcu_offset_x * LCU_WIDTH,
+                         state->tile->lcu_offset_y * LCU_WIDTH,
+                         ref->y,
+                         ref->width,
+                         ref->height,
+                         FILTER_SIZE_Y,
+                         block_width,
+                         block_height,
+                         &src);
+  kvz_sample_14bit_quarterpel_luma_generic(state->encoder_control,
+                                           src.orig_topleft,
+                                           src.stride,
+                                           block_width,
+                                           block_height,
+                                           hi_prec_out->y + (ypos%LCU_WIDTH)*LCU_WIDTH + (xpos%LCU_WIDTH),
+                                           LCU_WIDTH,
+                                           mv_frac_x,
+                                           mv_frac_y,
+                                           mv_param);
 
   if (src.malloc_used) free(src.buffer);
 }
 
-void kvz_inter_recon_frac_chroma(const encoder_state_t * const state, const kvz_picture * const ref, int32_t xpos, int32_t ypos, int32_t block_width, const int16_t mv_param[2], lcu_t *lcu)
+static void inter_recon_frac_chroma(const encoder_state_t * const state,
+                                    const kvz_picture * const ref,
+                                    int32_t xpos,
+                                    int32_t ypos,
+                                    int32_t block_width,
+                                    int32_t block_height,
+                                    const int16_t mv_param[2],
+                                    lcu_t *lcu)
 {
   int mv_frac_x = (mv_param[0] & 7);
   int mv_frac_y = (mv_param[1] & 7);
@@ -111,6 +136,7 @@
   xpos >>= 1;
   ypos >>= 1;
   block_width >>= 1;
+  block_height >>= 1;
 
 #define FILTER_SIZE_C 4 //Chroma filter size
 
@@ -120,21 +146,28 @@
 
   //Fractional chroma U
   kvz_get_extended_block(xpos, ypos, (mv_param[0] >> 2) >> 1, (mv_param[1] >> 2) >> 1, state->tile->lcu_offset_x * LCU_WIDTH_C, state->tile->lcu_offset_y * LCU_WIDTH_C,
-    ref->u, ref->width >> 1, ref->height >> 1, FILTER_SIZE_C, block_width, block_width, &src_u);
+    ref->u, ref->width >> 1, ref->height >> 1, FILTER_SIZE_C, block_width, block_height, &src_u);
   kvz_sample_octpel_chroma_generic(state->encoder_control, src_u.orig_topleft, src_u.stride, block_width,
-    block_width, lcu->rec.u + (ypos % LCU_WIDTH_C)*LCU_WIDTH_C + (xpos % LCU_WIDTH_C), LCU_WIDTH_C, mv_frac_x, mv_frac_y, mv_param);
+    block_height, lcu->rec.u + (ypos % LCU_WIDTH_C)*LCU_WIDTH_C + (xpos % LCU_WIDTH_C), LCU_WIDTH_C, mv_frac_x, mv_frac_y, mv_param);
 
   //Fractional chroma V
   kvz_get_extended_block(xpos, ypos, (mv_param[0] >> 2) >> 1, (mv_param[1] >> 2) >> 1, state->tile->lcu_offset_x * LCU_WIDTH_C, state->tile->lcu_offset_y * LCU_WIDTH_C,
-    ref->v, ref->width >> 1, ref->height >> 1, FILTER_SIZE_C, block_width, block_width, &src_v);
+    ref->v, ref->width >> 1, ref->height >> 1, FILTER_SIZE_C, block_width, block_height, &src_v);
   kvz_sample_octpel_chroma_generic(state->encoder_control, src_v.orig_topleft, src_v.stride, block_width,
-    block_width, lcu->rec.v + (ypos  % LCU_WIDTH_C)*LCU_WIDTH_C + (xpos % LCU_WIDTH_C), LCU_WIDTH_C, mv_frac_x, mv_frac_y, mv_param);
+    block_height, lcu->rec.v + (ypos  % LCU_WIDTH_C)*LCU_WIDTH_C + (xpos % LCU_WIDTH_C), LCU_WIDTH_C, mv_frac_x, mv_frac_y, mv_param);
 
   if (src_u.malloc_used) free(src_u.buffer);
   if (src_v.malloc_used) free(src_v.buffer);
 }
 
-void kvz_inter_recon_14bit_frac_chroma(const encoder_state_t * const state, const kvz_picture * const ref, int32_t xpos, int32_t ypos, int32_t block_width, const int16_t mv_param[2], hi_prec_buf_t *hi_prec_out)
+static void inter_recon_14bit_frac_chroma(const encoder_state_t * const state,
+                                          const kvz_picture * const ref,
+                                          int32_t xpos,
+                                          int32_t ypos,
+                                          int32_t block_width,
+                                          int32_t block_height,
+                                          const int16_t mv_param[2],
+                                          hi_prec_buf_t *hi_prec_out)
 {
   int mv_frac_x = (mv_param[0] & 7);
   int mv_frac_y = (mv_param[1] & 7);
@@ -143,6 +176,7 @@
   xpos >>= 1;
   ypos >>= 1;
   block_width >>= 1;
+  block_height >>= 1;
 
 #define FILTER_SIZE_C 4 //Chroma filter size
 
@@ -151,16 +185,54 @@
   kvz_extended_block src_v = { 0, 0, 0 };
 
   //Fractional chroma U
-  kvz_get_extended_block(xpos, ypos, (mv_param[0] >> 2) >> 1, (mv_param[1] >> 2) >> 1, state->tile->lcu_offset_x * LCU_WIDTH_C, state->tile->lcu_offset_y * LCU_WIDTH_C,
-    ref->u, ref->width >> 1, ref->height >> 1, FILTER_SIZE_C, block_width, block_width, &src_u);
-  kvz_sample_14bit_octpel_chroma_generic(state->encoder_control, src_u.orig_topleft, src_u.stride, block_width,
-    block_width, hi_prec_out->u + (ypos % LCU_WIDTH_C)*LCU_WIDTH_C + (xpos % LCU_WIDTH_C), LCU_WIDTH_C, mv_frac_x, mv_frac_y, mv_param);
+  kvz_get_extended_block(xpos,
+                         ypos,
+                         (mv_param[0] >> 2) >> 1,
+                         (mv_param[1] >> 2) >> 1,
+                         state->tile->lcu_offset_x * LCU_WIDTH_C,
+                         state->tile->lcu_offset_y * LCU_WIDTH_C,
+                         ref->u,
+                         ref->width >> 1,
+                         ref->height >> 1,
+                         FILTER_SIZE_C,
+                         block_width,
+                         block_height,
+                         &src_u);
+  kvz_sample_14bit_octpel_chroma_generic(state->encoder_control,
+                                         src_u.orig_topleft,
+                                         src_u.stride,
+                                         block_width,
+                                         block_height,
+                                         hi_prec_out->u + (ypos % LCU_WIDTH_C)*LCU_WIDTH_C + (xpos % LCU_WIDTH_C),
+                                         LCU_WIDTH_C,
+                                         mv_frac_x,
+                                         mv_frac_y,
+                                         mv_param);
 
   //Fractional chroma V
-  kvz_get_extended_block(xpos, ypos, (mv_param[0] >> 2) >> 1, (mv_param[1] >> 2) >> 1, state->tile->lcu_offset_x * LCU_WIDTH_C, state->tile->lcu_offset_y * LCU_WIDTH_C,
-    ref->v, ref->width >> 1, ref->height >> 1, FILTER_SIZE_C, block_width, block_width, &src_v);
-  kvz_sample_14bit_octpel_chroma_generic(state->encoder_control, src_v.orig_topleft, src_v.stride, block_width,
-    block_width, hi_prec_out->v + (ypos  % LCU_WIDTH_C)*LCU_WIDTH_C + (xpos % LCU_WIDTH_C), LCU_WIDTH_C, mv_frac_x, mv_frac_y, mv_param);
+  kvz_get_extended_block(xpos,
+                         ypos,
+                         (mv_param[0] >> 2) >> 1,
+                         (mv_param[1] >> 2) >> 1,
+                         state->tile->lcu_offset_x * LCU_WIDTH_C,
+                         state->tile->lcu_offset_y * LCU_WIDTH_C,
+                         ref->v,
+                         ref->width >> 1,
+                         ref->height >> 1,
+                         FILTER_SIZE_C,
+                         block_width,
+                         block_height,
+                         &src_v);
+  kvz_sample_14bit_octpel_chroma_generic(state->encoder_control,
+                                         src_v.orig_topleft,
+                                         src_v.stride,
+                                         block_width,
+                                         block_height,
+                                         hi_prec_out->v + (ypos  % LCU_WIDTH_C)*LCU_WIDTH_C + (xpos % LCU_WIDTH_C),
+                                         LCU_WIDTH_C,
+                                         mv_frac_x,
+                                         mv_frac_y,
+                                         mv_param);
 
   if (src_u.malloc_used) free(src_u.buffer);
   if (src_v.malloc_used) free(src_v.buffer);
@@ -172,12 +244,21 @@
  * \param xpos block x position
  * \param ypos block y position
  * \param width block width
+ * \param height block height
  * \param mv[2] motion vector
  * \param lcu destination lcu
  * \param hi_prec destination of high precision output (null if not needed)
  * \returns Void
 */
-void kvz_inter_recon_lcu(const encoder_state_t * const state, const kvz_picture * const ref, int32_t xpos, int32_t ypos,int32_t width, const int16_t mv_param[2], lcu_t *lcu, hi_prec_buf_t *hi_prec_out)
+void kvz_inter_recon_lcu(const encoder_state_t * const state,
+                         const kvz_picture * const ref,
+                         int32_t xpos,
+                         int32_t ypos,
+                         int32_t width,
+                         int32_t height,
+                         const int16_t mv_param[2],
+                         lcu_t *lcu,
+                         hi_prec_buf_t *hi_prec_out)
 {
   int x,y,coord_x,coord_y;
   int16_t mv[2] = { mv_param[0], mv_param[1] };
@@ -191,7 +272,7 @@
 
   // positive overflow flag
   int8_t overflow_pos_x = (state->tile->lcu_offset_x * LCU_WIDTH + xpos + (mv[0]>>2) + width > ref->width )?1:0;
-  int8_t overflow_pos_y = (state->tile->lcu_offset_y * LCU_WIDTH + ypos + (mv[1]>>2) + width > ref->height)?1:0;
+  int8_t overflow_pos_y = (state->tile->lcu_offset_y * LCU_WIDTH + ypos + (mv[1]>>2) + height > ref->height)?1:0;
 
   int8_t chroma_halfpel = ((mv[0]>>2)&1) || ((mv[1]>>2)&1); //!< (luma integer mv) lsb is set -> chroma is half-pel
   // Luma quarter-pel
@@ -199,11 +280,11 @@
 
   if(fractional_mv) {
     if (state->encoder_control->cfg->bipred && hi_prec_out){
-      kvz_inter_recon_14bit_frac_luma(state, ref, xpos, ypos, width, mv_param, hi_prec_out);
-      kvz_inter_recon_14bit_frac_chroma(state, ref, xpos, ypos, width, mv_param, hi_prec_out);
+      inter_recon_14bit_frac_luma(state, ref, xpos, ypos, width, height, mv_param, hi_prec_out);
+      inter_recon_14bit_frac_chroma(state, ref, xpos, ypos, width, height, mv_param, hi_prec_out);
     } else {
-      kvz_inter_recon_frac_luma(state, ref, xpos, ypos, width, mv_param, lcu);
-      kvz_inter_recon_frac_chroma(state, ref, xpos, ypos, width, mv_param, lcu);
+      inter_recon_frac_luma(state, ref, xpos, ypos, width, height, mv_param, lcu);
+      inter_recon_frac_chroma(state, ref, xpos, ypos, width, height, mv_param, lcu);
     }
   }
 
@@ -215,16 +296,16 @@
   if(!fractional_mv) {
     if(chroma_halfpel) {
       if (state->encoder_control->cfg->bipred && hi_prec_out){
-        kvz_inter_recon_14bit_frac_chroma(state, ref, xpos, ypos, width, mv_param, hi_prec_out);
+        inter_recon_14bit_frac_chroma(state, ref, xpos, ypos, width, height, mv_param, hi_prec_out);
       } else {
-        kvz_inter_recon_frac_chroma(state, ref, xpos, ypos, width, mv_param, lcu);
+        inter_recon_frac_chroma(state, ref, xpos, ypos, width, height, mv_param, lcu);
       }
     }
 
     // With overflow present, more checking
     if (overflow_neg_x || overflow_neg_y || overflow_pos_x || overflow_pos_y) {
       // Copy Luma with boundary checking
-      for (y = ypos; y < ypos + width; y++) {
+      for (y = ypos; y < ypos + height; y++) {
         for (x = xpos; x < xpos + width; x++) {
           int x_in_lcu = (x & ((LCU_WIDTH)-1));
           int y_in_lcu = (y & ((LCU_WIDTH)-1));
@@ -258,7 +339,7 @@
 
       if(!chroma_halfpel) {
         // Copy Chroma with boundary checking
-        for (y = ypos>>1; y < (ypos + width)>>1; y++) {
+        for (y = ypos>>1; y < (ypos + height)>>1; y++) {
           for (x = xpos>>1; x < (xpos + width)>>1; x++) {
             int x_in_lcu = (x & ((LCU_WIDTH>>1)-1));
             int y_in_lcu = (y & ((LCU_WIDTH>>1)-1));
@@ -294,7 +375,7 @@
       }
     } else { //If no overflow, we can copy without checking boundaries
       // Copy Luma
-      for (y = ypos; y < ypos + width; y++) {
+      for (y = ypos; y < ypos + height; y++) {
         int y_in_lcu = (y & ((LCU_WIDTH)-1));
         coord_y = ((y + state->tile->lcu_offset_y * LCU_WIDTH) + mv[1]) * ref->width; // pre-calculate
         for (x = xpos; x < xpos + width; x++) {
@@ -307,7 +388,7 @@
       if(!chroma_halfpel) {
         // Copy Chroma
         // TODO: chroma fractional pixel interpolation
-        for (y = ypos>>1; y < (ypos + width)>>1; y++) {
+        for (y = ypos>>1; y < (ypos + height)>>1; y++) {
           int y_in_lcu = (y & ((LCU_WIDTH>>1)-1));
           coord_y = ((y + state->tile->lcu_offset_y * (LCU_WIDTH>>1)) + (mv[1]>>1)) * ref_width_c; // pre-calculate
           for (x = xpos>>1; x < (xpos + width)>>1; x++) {
@@ -328,12 +409,22 @@
 * \param xpos block x position
 * \param ypos block y position
 * \param width block width
+* \param height block height
 * \param mv[2][2] motion vectors
 * \param lcu destination lcu
 * \returns Void
 */
 
-void kvz_inter_recon_lcu_bipred(const encoder_state_t * const state, const kvz_picture * ref1, const kvz_picture * ref2, int32_t xpos, int32_t ypos, int32_t width, int16_t mv_param[2][2], lcu_t* lcu) {
+void kvz_inter_recon_lcu_bipred(const encoder_state_t * const state,
+                                const kvz_picture * ref1,
+                                const kvz_picture * ref2,
+                                int32_t xpos,
+                                int32_t ypos,
+                                int32_t width,
+                                int32_t height,
+                                int16_t mv_param[2][2],
+                                lcu_t* lcu)
+{
   kvz_pixel temp_lcu_y[LCU_WIDTH*LCU_WIDTH];
   kvz_pixel temp_lcu_u[LCU_WIDTH_C*LCU_WIDTH_C];
   kvz_pixel temp_lcu_v[LCU_WIDTH_C*LCU_WIDTH_C];
@@ -352,7 +443,7 @@
   if (hi_prec_chroma_rec0) high_precision_rec0 = kvz_hi_prec_buf_t_alloc(LCU_WIDTH*LCU_WIDTH);
   if (hi_prec_chroma_rec1) high_precision_rec1 = kvz_hi_prec_buf_t_alloc(LCU_WIDTH*LCU_WIDTH);
   //Reconstruct both predictors
-  kvz_inter_recon_lcu(state, ref1, xpos, ypos, width, mv_param[0], lcu, high_precision_rec0);
+  kvz_inter_recon_lcu(state, ref1, xpos, ypos, width, height, mv_param[0], lcu, high_precision_rec0);
   if (!hi_prec_luma_rec0){
     memcpy(temp_lcu_y, lcu->rec.y, sizeof(kvz_pixel) * 64 * 64);
   }
@@ -360,10 +451,10 @@
     memcpy(temp_lcu_u, lcu->rec.u, sizeof(kvz_pixel) * 32 * 32);
     memcpy(temp_lcu_v, lcu->rec.v, sizeof(kvz_pixel) * 32 * 32);
   }
-  kvz_inter_recon_lcu(state, ref2, xpos, ypos, width, mv_param[1], lcu, high_precision_rec1);
+  kvz_inter_recon_lcu(state, ref2, xpos, ypos, width, height, mv_param[1], lcu, high_precision_rec1);
 
   // After reconstruction, merge the predictors by taking an average of each pixel
-  for (temp_y = 0; temp_y < width; ++temp_y) {
+  for (temp_y = 0; temp_y < height; ++temp_y) {
     int y_in_lcu = ((ypos + temp_y) & ((LCU_WIDTH)-1));
     for (temp_x = 0; temp_x < width; ++temp_x) {
       int x_in_lcu = ((xpos + temp_x) & ((LCU_WIDTH)-1));
@@ -373,7 +464,7 @@
     }
 
   }
-  for (temp_y = 0; temp_y < width >> 1; ++temp_y) {
+  for (temp_y = 0; temp_y < height >> 1; ++temp_y) {
     int y_in_lcu = (((ypos >> 1) + temp_y) & (LCU_WIDTH_C - 1));
     for (temp_x = 0; temp_x < width >> 1; ++temp_x) {
       int x_in_lcu = (((xpos >> 1) + temp_x) & (LCU_WIDTH_C - 1));
@@ -395,34 +486,43 @@
  * \param cu coding unit to clear
  */
 static void inter_clear_cu_unused(cu_info_t* cu) {
-  if(!(cu->inter.mv_dir & 1)) {
-    cu->inter.mv[0][0] = 0;
-    cu->inter.mv[0][1] = 0;
-    cu->inter.mv_ref[0] = 255;
-  }
-  if(!(cu->inter.mv_dir & 2)) {
-    cu->inter.mv[1][0] = 0;
-    cu->inter.mv[1][1] = 0;
-    cu->inter.mv_ref[1] = 255;
+  for (unsigned i = 0; i < 2; ++i) {
+    if (cu->inter.mv_dir & (1 << i)) continue;
+
+    cu->inter.mv[i][0] = 0;
+    cu->inter.mv[i][1] = 0;
+    cu->inter.mv_ref[i] = 255;
   }
 }
 
 /**
  * \brief Get merge candidates for current block
  * \param encoder encoder control struct to use
- * \param x_cu block x position in SCU
- * \param y_cu block y position in SCU
- * \param depth current block depth
+ * \param x block x position in SCU
+ * \param y block y position in SCU
+ * \param width current block width
+ * \param height current block height
  * \param b0 candidate b0
  * \param b1 candidate b1
  * \param b2 candidate b2
  * \param a0 candidate a0
  * \param a1 candidate a1
  */
-void kvz_inter_get_spatial_merge_candidates(int32_t x, int32_t y, int8_t depth, cu_info_t **b0, cu_info_t **b1,
-                                        cu_info_t **b2,cu_info_t **a0,cu_info_t **a1, lcu_t *lcu)
+void kvz_inter_get_spatial_merge_candidates(int32_t x,
+                                            int32_t y,
+                                            int32_t width,
+                                            int32_t height,
+                                            cu_info_t **b0,
+                                            cu_info_t **b1,
+                                            cu_info_t **b2,
+                                            cu_info_t **a0,
+                                            cu_info_t **a1,
+                                            lcu_t *lcu)
 {
-  uint8_t cur_block_in_scu = (LCU_WIDTH>>depth) / CU_MIN_SIZE_PIXELS; //!< the width of the current block on SCU
+  // the width and height of the current block on SCU
+  uint8_t width_in_scu = width / CU_MIN_SIZE_PIXELS;
+  uint8_t height_in_scu = height / CU_MIN_SIZE_PIXELS;
+
   /*
   Predictor block locations
   ____      _______
@@ -433,43 +533,63 @@
   |A1|_________|
   |A0|
   */
-  int32_t x_cu = (x & (LCU_WIDTH - 1)) >> MAX_DEPTH; //!< coordinates from top-left of this LCU
-  int32_t y_cu = (y & (LCU_WIDTH - 1)) >> MAX_DEPTH;
-  cu_info_t* cu = &lcu->cu[LCU_CU_OFFSET];
+  int32_t x_cu = SUB_SCU(x) >> MAX_DEPTH; //!< coordinates from top-left of this LCU
+  int32_t y_cu = SUB_SCU(y) >> MAX_DEPTH;
   // A0 and A1 availability testing
   if (x != 0) {
-    *a1 = &cu[x_cu - 1 + (y_cu + cur_block_in_scu - 1) * LCU_T_CU_WIDTH];
-    if (!(*a1)->coded) *a1 = NULL;
-    if(*a1) inter_clear_cu_unused(*a1);
+    *a1 = LCU_GET_CU(lcu, x_cu - 1, y_cu + height_in_scu - 1);
+    // Do not check (*a1)->coded because the block above is always coded before
+    // the current one and the flag is not set when searching an SMP block.
+    if ((*a1)->type == CU_INTER) {
+      inter_clear_cu_unused(*a1);
+    } else {
+      *a1 = NULL;
+    }
 
-    if (y_cu + cur_block_in_scu < LCU_WIDTH>>3) {
-      *a0 = &cu[x_cu - 1 + (y_cu + cur_block_in_scu) * LCU_T_CU_WIDTH];
-      if (!(*a0)->coded) *a0 = NULL;
+    if (y_cu + height_in_scu < LCU_WIDTH>>3) {
+      *a0 = LCU_GET_CU(lcu, x_cu - 1, y_cu + height_in_scu);
+      if ((*a0)->coded && (*a0)->type == CU_INTER) {
+        inter_clear_cu_unused(*a0);
+      } else {
+        *a0 = NULL;
+      }
     }
-    if(*a0) inter_clear_cu_unused(*a0);
   }
 
   // B0, B1 and B2 availability testing
   if (y != 0) {
-    if (x_cu + cur_block_in_scu < LCU_WIDTH>>3) {
-      *b0 = &cu[x_cu + cur_block_in_scu + (y_cu - 1) * LCU_T_CU_WIDTH];
-      if (!(*b0)->coded) *b0 = NULL;
-    } else if(y_cu == 0) {
-      // Special case, top-right cu from LCU is the last in lcu->cu array
-      *b0 = &lcu->cu[LCU_T_CU_WIDTH*LCU_T_CU_WIDTH];
-      if (!(*b0)->coded) *b0 = NULL;
+    if (x_cu + width_in_scu < LCU_WIDTH>>3) {
+      *b0 = LCU_GET_CU(lcu, x_cu + width_in_scu, y_cu - 1);
+    } else if (y_cu == 0) {
+      // Special case, top-right CU
+      *b0 = LCU_GET_TOP_RIGHT_CU(lcu);
+    }
+    if ((*b0) && (*b0)->coded && (*b0)->type == CU_INTER) {
+      inter_clear_cu_unused(*b0);
+    } else {
+      *b0 = NULL;
     }
-    if(*b0) inter_clear_cu_unused(*b0);
 
-    *b1 = &cu[x_cu + cur_block_in_scu - 1 + (y_cu - 1) * LCU_T_CU_WIDTH];
-    if (!(*b1)->coded) *b1 = NULL;
-    if(*b1) inter_clear_cu_unused(*b1);
+    *b1 = LCU_GET_CU(lcu, x_cu + width_in_scu - 1, y_cu - 1);
+    // Do not check (*b1)->coded because the block to the left is always coded
+    // before the current one and the flag is not set when searching an SMP
+    // block.
+    if ((*b1)->type == CU_INTER) {
+      inter_clear_cu_unused(*b1);
+    } else {
+      *b1 = NULL;
+    }
 
     if (x != 0) {
-      *b2 = &cu[x_cu - 1 + (y_cu - 1) * LCU_T_CU_WIDTH];
-      if(!(*b2)->coded) *b2 = NULL;
+      *b2 = LCU_GET_CU(lcu, x_cu - 1, y_cu - 1);
+      // Do not check (*b2)->coded because the block above and to the left is
+      // always coded before the current one.
+      if ((*b2)->type == CU_INTER) {
+        inter_clear_cu_unused(*b2);
+      } else {
+        *b2 = NULL;
+      }
     }
-    if(*b2) inter_clear_cu_unused(*b2);
   }
 }
 
@@ -478,10 +598,19 @@
  * \param encoder encoder control struct to use
  * \param x_cu block x position in SCU
  * \param y_cu block y position in SCU
- * \param depth current block depth
- * \param mv_pred[2][2] 2x motion vector prediction
+ * \param width current block width
+ * \param height current block height
+ * \param mv_cand[2][2] return the motion vector candidates
  */
-void kvz_inter_get_mv_cand(const encoder_state_t * const state, int32_t x, int32_t y, int8_t depth, int16_t mv_cand[2][2], cu_info_t* cur_cu, lcu_t *lcu, int8_t reflist)
+void kvz_inter_get_mv_cand(const encoder_state_t * const state,
+                           int32_t x,
+                           int32_t y,
+                           int32_t width,
+                           int32_t height,
+                           int16_t mv_cand[2][2],
+                           cu_info_t* cur_cu,
+                           lcu_t *lcu,
+                           int8_t reflist)
 {
   uint8_t candidates = 0;
   uint8_t b_candidates = 0;
@@ -489,7 +618,7 @@
 
   cu_info_t *b0, *b1, *b2, *a0, *a1;
   b0 = b1 = b2 = a0 = a1 = NULL;
-  kvz_inter_get_spatial_merge_candidates(x, y, depth, &b0, &b1, &b2, &a0, &a1, lcu);
+  kvz_inter_get_spatial_merge_candidates(x, y, width, height, &b0, &b1, &b2, &a0, &a1, lcu);
 
  #define CALCULATE_SCALE(cu,tb,td) ((tb * ((0x4000 + (abs(td)>>1))/td) + 32) >> 6)
 #define APPLY_MV_SCALING(cu, cand, list) {int td = state->global->poc - state->global->ref->pocs[(cu)->inter.mv_ref[list]];\
@@ -500,7 +629,7 @@
                                        mv_cand[cand][1] = ((scale * (cu)->inter.mv[list][1] + 127 + (scale * (cu)->inter.mv[list][1] < 0)) >> 8 ); }}
 
   // Left predictors
-  if (a0 && a0->type == CU_INTER && (
+  if (a0 && (
     ((a0->inter.mv_dir & 1) && a0->inter.mv_ref[0] == cur_cu->inter.mv_ref[reflist]) ||
     ((a0->inter.mv_dir & 2) && a0->inter.mv_ref[1] == cur_cu->inter.mv_ref[reflist]))) {
     if (a0->inter.mv_dir & (1 << reflist) && a0->inter.mv_ref[reflist] == cur_cu->inter.mv_ref[reflist]) {
@@ -511,7 +640,7 @@
       mv_cand[candidates][1] = a0->inter.mv[reflist2nd][1];
     }
     candidates++;
-  } else if (a1 && a1->type == CU_INTER && (
+  } else if (a1 && (
     ((a1->inter.mv_dir & 1) && a1->inter.mv_ref[0] == cur_cu->inter.mv_ref[reflist]) ||
     ((a1->inter.mv_dir & 2) && a1->inter.mv_ref[1] == cur_cu->inter.mv_ref[reflist]))) {
     if (a1->inter.mv_dir & (1 << reflist) && a1->inter.mv_ref[reflist] == cur_cu->inter.mv_ref[reflist]) {
@@ -526,7 +655,7 @@
 
   if(!candidates) {
       // Left predictors
-    if (a0 && a0->type == CU_INTER) {
+    if (a0) {
       if (a0->inter.mv_dir & (1 << reflist)) {
         mv_cand[candidates][0] = a0->inter.mv[reflist][0];
         mv_cand[candidates][1] = a0->inter.mv[reflist][1];
@@ -537,7 +666,7 @@
         APPLY_MV_SCALING(a0, candidates, reflist2nd);
       }
       candidates++;
-    } else if (a1 && a1->type == CU_INTER) {
+    } else if (a1) {
       if (a1->inter.mv_dir & (1 << reflist)) {
         mv_cand[candidates][0] = a1->inter.mv[reflist][0];
         mv_cand[candidates][1] = a1->inter.mv[reflist][1];
@@ -552,7 +681,7 @@
   }
 
   // Top predictors
-  if (b0 && b0->type == CU_INTER && (
+  if (b0 && (
     ((b0->inter.mv_dir & 1) && b0->inter.mv_ref[0] == cur_cu->inter.mv_ref[reflist]) ||
     ((b0->inter.mv_dir & 2) && b0->inter.mv_ref[1] == cur_cu->inter.mv_ref[reflist]))) {
     if (b0->inter.mv_dir & (1 << reflist) && b0->inter.mv_ref[reflist] == cur_cu->inter.mv_ref[reflist]) {
@@ -563,7 +692,7 @@
       mv_cand[candidates][1] = b0->inter.mv[reflist2nd][1];
     }
     b_candidates++;
-  } else if (b1 && b1->type == CU_INTER && (
+  } else if (b1 && (
     ((b1->inter.mv_dir & 1) && b1->inter.mv_ref[0] == cur_cu->inter.mv_ref[reflist]) ||
     ((b1->inter.mv_dir & 2) && b1->inter.mv_ref[1] == cur_cu->inter.mv_ref[reflist]))) {
     if (b1->inter.mv_dir & (1 << reflist) && b1->inter.mv_ref[reflist] == cur_cu->inter.mv_ref[reflist]) {
@@ -574,7 +703,7 @@
       mv_cand[candidates][1] = b1->inter.mv[reflist2nd][1];
     }
     b_candidates++;
-  } else if (b2 && b2->type == CU_INTER && (
+  } else if (b2 && (
     ((b2->inter.mv_dir & 1) && b2->inter.mv_ref[0] == cur_cu->inter.mv_ref[reflist]) ||
     ((b2->inter.mv_dir & 2) && b2->inter.mv_ref[1] == cur_cu->inter.mv_ref[reflist]))) {
     if (b2->inter.mv_dir & (1 << reflist) && b2->inter.mv_ref[reflist] == cur_cu->inter.mv_ref[reflist]) {
@@ -589,7 +718,7 @@
   candidates += b_candidates;
 
   // When a1 or a0 is available, we dont check for secondary B candidates
-  if((a1 && a1->type == CU_INTER) || (a0 && a0->type == CU_INTER)) {
+  if (a1 || a0) {
     b_candidates = 1;
   } else if(candidates != 2) {
     b_candidates = 0;
@@ -597,7 +726,7 @@
 
   if(!b_candidates) {
     // Top predictors
-    if (b0 && b0->type == CU_INTER) {
+    if (b0) {
       if (b0->inter.mv_dir & (1 << reflist)) {
         mv_cand[candidates][0] = b0->inter.mv[reflist][0];
         mv_cand[candidates][1] = b0->inter.mv[reflist][1];
@@ -608,7 +737,7 @@
         APPLY_MV_SCALING(b0, candidates, reflist2nd);
       }
       candidates++;
-    } else if (b1 && b1->type == CU_INTER) {
+    } else if (b1) {
       if (b1->inter.mv_dir & (1 << reflist)) {
         mv_cand[candidates][0] = b1->inter.mv[reflist][0];
         mv_cand[candidates][1] = b1->inter.mv[reflist][1];
@@ -619,7 +748,7 @@
         APPLY_MV_SCALING(b1, candidates, reflist2nd);
       }
       candidates++;
-    } else if(b2 && b2->type == CU_INTER) {
+    } else if (b2) {
       if (b2->inter.mv_dir & (1 << reflist)) {
         mv_cand[candidates][0] = b2->inter.mv[reflist][0];
         mv_cand[candidates][1] = b2->inter.mv[reflist][1];
@@ -656,13 +785,23 @@
 
 /**
  * \brief Get merge predictions for current block
- * \param encoder encoder control struct to use
- * \param x_cu block x position in SCU
- * \param y_cu block y position in SCU
- * \param depth current block depth
- * \param mv_pred[MRG_MAX_NUM_CANDS][2] MRG_MAX_NUM_CANDS motion vector prediction
+ * \param state     the encoder state
+ * \param x         block x position in SCU
+ * \param y         block y position in SCU
+ * \param width     block width
+ * \param height    block height
+ * \param use_a1    true, if candidate a1 can be used
+ * \param use_b1    true, if candidate b1 can be used
+ * \param mv_cand   Returns the merge candidates.
+ * \param lcu       lcu containing the block
+ * \return          number of merge candidates
  */
-uint8_t kvz_inter_get_merge_cand(const encoder_state_t * const state, int32_t x, int32_t y, int8_t depth, inter_merge_cand_t mv_cand[MRG_MAX_NUM_CANDS], lcu_t *lcu)
+uint8_t kvz_inter_get_merge_cand(const encoder_state_t * const state,
+                                 int32_t x, int32_t y,
+                                 int32_t width, int32_t height,
+                                 bool use_a1, bool use_b1,
+                                 inter_merge_cand_t mv_cand[MRG_MAX_NUM_CANDS],
+                                 lcu_t *lcu)
 {
   uint8_t candidates = 0;
   int8_t duplicate = 0;
@@ -670,10 +809,12 @@
   cu_info_t *b0, *b1, *b2, *a0, *a1;
   int8_t zero_idx = 0;
   b0 = b1 = b2 = a0 = a1 = NULL;
-  kvz_inter_get_spatial_merge_candidates(x, y, depth, &b0, &b1, &b2, &a0, &a1, lcu);
+  kvz_inter_get_spatial_merge_candidates(x, y, width, height, &b0, &b1, &b2, &a0, &a1, lcu);
 
+  if (!use_a1) a1 = NULL;
+  if (!use_b1) b1 = NULL;
 
-#define CHECK_DUPLICATE(CU1,CU2) {duplicate = 0; if ((CU2) && (CU2)->type == CU_INTER && \
+#define CHECK_DUPLICATE(CU1,CU2) {duplicate = 0; if ((CU2) && \
                                                      (CU1)->inter.mv_dir == (CU2)->inter.mv_dir && \
                                                     (!(((CU1)->inter.mv_dir & 1) && ((CU2)->inter.mv_dir & 1)) || \
                                                       ((CU1)->inter.mv[0][0] == (CU2)->inter.mv[0][0] && \
@@ -685,7 +826,7 @@
                                                        (CU1)->inter.mv_ref[1] == (CU2)->inter.mv_ref[1]) ) \
                                                       ) duplicate = 1; }
 
-  if (a1 && a1->type == CU_INTER) {
+  if (a1) {
     mv_cand[candidates].mv[0][0] = a1->inter.mv[0][0];
     mv_cand[candidates].mv[0][1] = a1->inter.mv[0][1];
     mv_cand[candidates].mv[1][0] = a1->inter.mv[1][0];
@@ -696,7 +837,7 @@
     candidates++;
   }
 
-  if (b1 && b1->type == CU_INTER) {
+  if (b1) {
     if(candidates) CHECK_DUPLICATE(b1, a1);
     if(!duplicate) {
       mv_cand[candidates].mv[0][0] = b1->inter.mv[0][0];
@@ -710,7 +851,7 @@
     }
   }
 
-  if (b0 && b0->type == CU_INTER) {
+  if (b0) {
     if(candidates) CHECK_DUPLICATE(b0,b1);
     if(!duplicate) {
       mv_cand[candidates].mv[0][0] = b0->inter.mv[0][0];
@@ -724,7 +865,7 @@
     }
   }
 
-  if (a0 && a0->type == CU_INTER) {
+  if (a0) {
     if(candidates) CHECK_DUPLICATE(a0,a1);
     if(!duplicate) {
       mv_cand[candidates].mv[0][0] = a0->inter.mv[0][0];
@@ -739,7 +880,7 @@
   }
 
   if (candidates != 4) {
-    if(b2 && b2->type == CU_INTER) {
+    if (b2) {
       CHECK_DUPLICATE(b2,a1);
       if(!duplicate) {
         CHECK_DUPLICATE(b2,b1);

kvazaar-0.7.2.tar.gz/src/inter.h -> kvazaar-0.8.1.tar.gz/src/inter.h Changed

@@ -20,9 +20,10 @@
  * with Kvazaar.  If not, see <http://www.gnu.org/licenses/>.
  ****************************************************************************/
 
-/*
+/**
+ * \ingroup Reconstruction
  * \file
- * \brief Handling Coding Units (CU's) for inter frames.
+ * Inter prediction.
  */
 
 #include "global.h"
@@ -39,12 +40,51 @@
 } inter_merge_cand_t;
 
 
-//void kvz_inter_set_block(image* im,uint32_t x_cu, uint32_t y_cu, uint8_t depth, cu_info *cur_cu);
-void kvz_inter_recon_lcu(const encoder_state_t * const state, const kvz_picture * ref, int32_t xpos, int32_t ypos, int32_t width, const int16_t mv_param[2], lcu_t* lcu, hi_prec_buf_t *hi_prec_out);
-void kvz_inter_recon_lcu_bipred(const encoder_state_t * const state, const kvz_picture * ref1, const kvz_picture * ref2, int32_t xpos, int32_t ypos, int32_t width, int16_t mv_param[2][2], lcu_t* lcu);
+void kvz_inter_recon_lcu(const encoder_state_t * const state,
+                         const kvz_picture * ref,
+                         int32_t xpos,
+                         int32_t ypos,
+                         int32_t width,
+                         int32_t height,
+                         const int16_t mv_param[2],
+                         lcu_t* lcu,
+                         hi_prec_buf_t *hi_prec_out);
 
-void kvz_inter_get_spatial_merge_candidates(int32_t x, int32_t y, int8_t depth, cu_info_t **b0, cu_info_t **b1,
-                                        cu_info_t **b2, cu_info_t **a0, cu_info_t **a1, lcu_t *lcu);
-void kvz_inter_get_mv_cand(const encoder_state_t *state, int32_t x, int32_t y, int8_t depth, int16_t mv_cand[2][2], cu_info_t* cur_cu, lcu_t *lcu, int8_t reflist);
-uint8_t kvz_inter_get_merge_cand(const encoder_state_t *state, int32_t x, int32_t y, int8_t depth, inter_merge_cand_t mv_cand[MRG_MAX_NUM_CANDS], lcu_t *lcu);
+void kvz_inter_recon_lcu_bipred(const encoder_state_t * const state,
+                                const kvz_picture * ref1,
+                                const kvz_picture * ref2,
+                                int32_t xpos,
+                                int32_t ypos,
+                                int32_t width,
+                                int32_t height,
+                                int16_t mv_param[2][2],
+                                lcu_t* lcu);
+
+void kvz_inter_get_spatial_merge_candidates(int32_t x,
+                                            int32_t y,
+                                            int32_t width,
+                                            int32_t height,
+                                            cu_info_t **b0,
+                                            cu_info_t **b1,
+                                            cu_info_t **b2,
+                                            cu_info_t **a0,
+                                            cu_info_t **a1,
+                                            lcu_t *lcu);
+
+void kvz_inter_get_mv_cand(const encoder_state_t * const state,
+                           int32_t x,
+                           int32_t y,
+                           int32_t width,
+                           int32_t height,
+                           int16_t mv_cand[2][2],
+                           cu_info_t* cur_cu,
+                           lcu_t *lcu,
+                           int8_t reflist);
+
+uint8_t kvz_inter_get_merge_cand(const encoder_state_t * const state,
+                                 int32_t x, int32_t y,
+                                 int32_t width, int32_t height,
+                                 bool use_a1, bool use_b1,
+                                 inter_merge_cand_t mv_cand[MRG_MAX_NUM_CANDS],
+                                 lcu_t *lcu);
 #endif

kvazaar-0.7.2.tar.gz/src/intra.c -> kvazaar-0.8.1.tar.gz/src/intra.c Changed

@@ -18,11 +18,6 @@
  * with Kvazaar.  If not, see <http://www.gnu.org/licenses/>.
  ****************************************************************************/
 
-/**
- * \file
- * \brief Functions for handling intra frames.
- */
-
 #include "intra.h"
 
 #include <assert.h>
@@ -32,6 +27,7 @@
 #include "encoder.h"
 #include "transform.h"
 #include "strategies/strategies-intra.h"
+#include "strategies/strategies-picture.h"
 
 
 int8_t kvz_intra_get_dir_luma_predictor(
@@ -142,52 +138,6 @@
 
 
 /**
- * \brief Generage planar prediction.
- * \param log2_width    Log2 of width, range 2..5.
- * \param in_ref_above  Pointer to -1 index of above reference, length=width*2+1.
- * \param in_ref_left   Pointer to -1 index of left reference, length=width*2+1.
- * \param dst           Buffer of size width*width.
- */
-static void intra_pred_planar(
-  const int_fast8_t log2_width,
-  const kvz_pixel *const ref_top,
-  const kvz_pixel *const ref_left,
-  kvz_pixel *const dst)
-{
-  assert(log2_width >= 2 && log2_width <= 5);
-
-  const int_fast8_t width = 1 << log2_width;
-  const kvz_pixel top_right = ref_top[width + 1];
-  const kvz_pixel bottom_left = ref_left[width + 1];
-
-#if 0
-  // Unoptimized version for reference.
-  for (int y = 0; y < width; ++y) {
-    for (int x = 0; x < width; ++x) {
-      int_fast16_t hor = (width - 1 - x) * ref_left[y + 1] + (x + 1) * top_right;
-      int_fast16_t ver = (width - 1 - y) * ref_top[x + 1] + (y + 1) * bottom_left;
-      dst[y * width + x] = (ver + hor + width) >> (log2_width + 1);
-    }
-  }
-#else
-  int_fast16_t top[32];
-  for (int i = 0; i < width; ++i) {
-    top[i] = ref_top[i + 1] << log2_width;
-  }
-
-  for (int y = 0; y < width; ++y) {
-    int_fast16_t hor = (ref_left[y + 1] << log2_width) + width;
-    for (int x = 0; x < width; ++x) {
-      hor += top_right - ref_left[y + 1];
-      top[x] += bottom_left - ref_top[x + 1];
-      dst[y * width + x] = (hor + top[x]) >> (log2_width + 1);
-    }
-  }
-#endif
-}
-
-
-/**
 * \brief Generage planar prediction.
 * \param log2_width    Log2 of width, range 2..5.
 * \param in_ref_above  Pointer to -1 index of above reference, length=width*2+1.
@@ -289,7 +239,7 @@
   }
 
   if (mode == 0) {
-    intra_pred_planar(log2_width, used_ref->top, used_ref->left, dst);
+    kvz_intra_pred_planar(log2_width, used_ref->top, used_ref->left, dst);
   } else if (mode == 1) {
     // Do extra post filtering for edge pixels of luma DC mode.
     if (color == COLOR_Y && width < 32) {
@@ -484,9 +434,9 @@
   cu_info_t *cur_cu,
   lcu_t *lcu)
 {
-  const vector2d_t lcu_px = { x & 0x3f, y & 0x3f };
+  const vector2d_t lcu_px = { SUB_SCU(x), SUB_SCU(y) };
   if (cur_cu == NULL) {
-    cur_cu = &lcu->cu[LCU_CU_OFFSET + (lcu_px.x >> 3) + (lcu_px.y >> 3)*LCU_T_CU_WIDTH];
+    cur_cu = LCU_GET_CU_AT_PX(lcu, lcu_px.x, lcu_px.y);
   }
   const int8_t width = LCU_WIDTH >> depth;
 
@@ -499,9 +449,9 @@
     kvz_intra_recon_lcu_luma(state, x + offset, y + offset, depth+1, intra_mode, NULL, lcu);
 
     if (depth < MAX_DEPTH) {
-      cu_info_t *cu_a = &lcu->cu[LCU_CU_OFFSET + ((lcu_px.x + offset) >> 3) + (lcu_px.y >> 3)        *LCU_T_CU_WIDTH];
-      cu_info_t *cu_b = &lcu->cu[LCU_CU_OFFSET + (lcu_px.x >> 3) + ((lcu_px.y + offset) >> 3)*LCU_T_CU_WIDTH];
-      cu_info_t *cu_c = &lcu->cu[LCU_CU_OFFSET + ((lcu_px.x + offset) >> 3) + ((lcu_px.y + offset) >> 3)*LCU_T_CU_WIDTH];
+      cu_info_t *cu_a = LCU_GET_CU_AT_PX(lcu, lcu_px.x + offset, lcu_px.y);
+      cu_info_t *cu_b = LCU_GET_CU_AT_PX(lcu, lcu_px.x,          lcu_px.y + offset);
+      cu_info_t *cu_c = LCU_GET_CU_AT_PX(lcu, lcu_px.x + offset, lcu_px.y + offset);
       if (cbf_is_set(cu_a->cbf.y, depth+1) || cbf_is_set(cu_b->cbf.y, depth+1) || cbf_is_set(cu_c->cbf.y, depth+1)) {
         cbf_set(&cur_cu->cbf.y, depth);
       }
@@ -536,12 +486,12 @@
   cu_info_t *cur_cu,
   lcu_t *lcu)
 {
-  const vector2d_t lcu_px = { x & 0x3f, y & 0x3f };
+  const vector2d_t lcu_px = { SUB_SCU(x), SUB_SCU(y) };
   const int8_t width = LCU_WIDTH >> depth;
   const int8_t width_c = (depth == MAX_PU_DEPTH ? width : width / 2);
 
   if (cur_cu == NULL) {
-    cur_cu = &lcu->cu[LCU_CU_OFFSET + (lcu_px.x >> 3) + (lcu_px.y >> 3)*LCU_T_CU_WIDTH];
+    cur_cu = LCU_GET_CU_AT_PX(lcu, lcu_px.x, lcu_px.y);
   }
 
   if (depth == 0 || cur_cu->tr_depth > depth) {
@@ -553,9 +503,9 @@
     kvz_intra_recon_lcu_chroma(state, x + offset, y + offset, depth+1, intra_mode, NULL, lcu);
 
     if (depth < MAX_DEPTH) {
-      cu_info_t *cu_a = &lcu->cu[LCU_CU_OFFSET + ((lcu_px.x + offset) >> 3) + (lcu_px.y >> 3)        *LCU_T_CU_WIDTH];
-      cu_info_t *cu_b = &lcu->cu[LCU_CU_OFFSET + (lcu_px.x >> 3) + ((lcu_px.y + offset) >> 3)*LCU_T_CU_WIDTH];
-      cu_info_t *cu_c = &lcu->cu[LCU_CU_OFFSET + ((lcu_px.x + offset) >> 3) + ((lcu_px.y + offset) >> 3)*LCU_T_CU_WIDTH];
+      cu_info_t *cu_a = LCU_GET_CU_AT_PX(lcu, lcu_px.x + offset, lcu_px.y);
+      cu_info_t *cu_b = LCU_GET_CU_AT_PX(lcu, lcu_px.x,          lcu_px.y + offset);
+      cu_info_t *cu_c = LCU_GET_CU_AT_PX(lcu, lcu_px.x + offset, lcu_px.y + offset);
       if (cbf_is_set(cu_a->cbf.u, depth+1) || cbf_is_set(cu_b->cbf.u, depth+1) || cbf_is_set(cu_c->cbf.u, depth+1)) {
         cbf_set(&cur_cu->cbf.u, depth);
       }

kvazaar-0.7.2.tar.gz/src/intra.h -> kvazaar-0.8.1.tar.gz/src/intra.h Changed

kvazaar-0.7.2.tar.gz/src/kvazaar.h -> kvazaar-0.8.1.tar.gz/src/kvazaar.h Changed

@@ -20,9 +20,10 @@
 * with Kvazaar.  If not, see <http://www.gnu.org/licenses/>.
 ****************************************************************************/
 
-/**
+/** 
+ * \ingroup Control
  * \file
- * \brief This file defines the public API of Kvazaar when used as a library.
+ * This file defines the public API of Kvazaar when used as a library.
  */
 
 #include <stddef.h>
@@ -34,22 +35,30 @@
 extern "C" {
 #endif
 
-#if defined(KVZ_STATIC_LIB)
-  // Using or building kvazaar as a static library.
-  #define KVZ_PUBLIC
-#elif defined(_WIN32) || defined(__CYGWIN__)
-  #ifdef KVZ_DLL_EXPORTS
-    // Building kvazaar on windows.
+#if defined(KVZ_DLL_EXPORTS)
+  #if !defined(PIC)
+    // Building static kvazaar library.
+    #define KVZ_PUBLIC
+  #elif defined(_WIN32) || defined(__CYGWIN__)
+    // Building kvazaar DLL on Windows.
     #define KVZ_PUBLIC __declspec(dllexport)
+  #elif defined(__GNUC__)
+    // Building kvazaar shared library with GCC.
+    #define KVZ_PUBLIC __attribute__ ((visibility ("default")))
   #else
-    // Using kvazaar as a DLL on windows.
-    #define KVZ_PUBLIC __declspec(dllimport)
+    #define KVZ_PUBLIC
   #endif
-#elif defined(__GNUC__)
-  // Using GCC and not on windows.
-  #define KVZ_PUBLIC __attribute__ ((visibility ("default")))
 #else
-  #define KVZ_PUBLIC
+  #if defined(KVZ_STATIC_LIB)
+    // Using static kvazaar library.
+    #define KVZ_PUBLIC
+  #elif defined(_WIN32) || defined(__CYGWIN__)
+    // Using kvazaar DLL on Windows.
+    #define KVZ_PUBLIC __declspec(dllimport)
+  #else
+    // Using kvazaar shared library and not on Windows.
+    #define KVZ_PUBLIC
+  #endif
 #endif
 
 /**
@@ -80,6 +89,7 @@
 enum kvz_ime_algorithm {
   KVZ_IME_HEXBS = 0,
   KVZ_IME_TZ = 1,
+  KVZ_IME_FULL = 2,
 };
 
 /**
@@ -120,11 +130,15 @@
 
   int32_t width;   /*!< \brief frame width, must be a multiple of 8 */
   int32_t height;  /*!< \brief frame height, must be a multiple of 8 */
-  double framerate; /*!< \brief Input framerate */
+  double framerate; /*!< \brief Deprecated, will be removed. */
+  int32_t framerate_num; /*!< \brief Framerate numerator */
+  int32_t framerate_denom; /*!< \brief Framerate denominator */
   int32_t deblock_enable; /*!< \brief Flag to enable deblocking filter */
   int32_t sao_enable;     /*!< \brief Flag to enable sample adaptive offset filter */
   int32_t rdoq_enable;    /*!< \brief Flag to enable RD optimized quantization. */
   int32_t signhide_enable;   /*!< \brief Flag to enable sign hiding. */
+  int32_t smp_enable;   /*!< \brief Flag to enable SMP blocks. */
+  int32_t amp_enable;   /*!< \brief Flag to enable AMP blocks. */
   int32_t rdo;            /*!< \brief RD-calculation level (0..2) */
   int32_t full_intra_search; /*!< \brief If true, don't skip modes in intra search. */
   int32_t trskip_enable;    /*!< \brief Flag to enable transform skip (for 4x4 blocks). */
@@ -172,9 +186,12 @@
 
   int32_t add_encoder_info;
   int8_t gop_len;            /*!< \brief length of GOP for the video sequence */
+  int8_t gop_lowdelay;       /*!< \brief specifies that the GOP does not use future pictures */
   kvz_gop_config gop[KVZ_MAX_GOP_LENGTH];  /*!< \brief Array of GOP settings */
 
   int32_t target_bitrate;
+
+  int8_t mv_rdo;            /*!< \brief MV RDO calculation in search (0: estimation, 1: RDO). */
 } kvz_config;
 
 /**

kvazaar-0.7.2.tar.gz/src/kvazaar.pc.in -> kvazaar-0.8.1.tar.gz/src/kvazaar.pc.in Changed

kvazaar-0.7.2.tar.gz/src/kvazaar_internal.h -> kvazaar-0.8.1.tar.gz/src/kvazaar_internal.h Changed

kvazaar-0.7.2.tar.gz/src/kvazaar_version.h -> kvazaar-0.8.1.tar.gz/src/kvazaar_version.h Changed

kvazaar-0.7.2.tar.gz/src/nal.c -> kvazaar-0.8.1.tar.gz/src/nal.c Changed

kvazaar-0.7.2.tar.gz/src/nal.h -> kvazaar-0.8.1.tar.gz/src/nal.h Changed

kvazaar-0.7.2.tar.gz/src/rate_control.c -> kvazaar-0.8.1.tar.gz/src/rate_control.c Changed

@@ -157,19 +157,30 @@
 double kvz_select_picture_lambda_from_qp(encoder_state_t const * const state)
 {
   const int gop_len = state->encoder_control->cfg->gop_len;
-  const double qp_temp = state->global->QP - 12;
+  const int intra_period = state->encoder_control->cfg->intra_period;
+  const int keyframe_period = gop_len > 0 ? gop_len : intra_period;
+  
+  double lambda = pow(2.0, (state->global->QP - 12) / 3.0);
 
-  double qp_factor;
   if (state->global->slicetype == KVZ_SLICE_I) {
-    const double lambda_scale = 1.0 - CLIP(0.0, 0.5, 0.05 * gop_len);
-    qp_factor = 0.57 * lambda_scale;
+    lambda *= 0.57;
+    
+    // Reduce lambda for I-frames according to the number of references.
+    if (keyframe_period == 0) {
+      lambda *= 0.5;
+    } else {
+      lambda *= 1.0 - CLIP(0.0, 0.5, 0.05 * (keyframe_period - 1));
+    }
   } else if (gop_len > 0) {
-    qp_factor = 0.95 * state->global->QP_factor;
+    lambda *= state->global->QP_factor;
   } else {
-    // default QP factor from HM config
-    qp_factor = 0.95 * 0.4624;
+    lambda *= 0.4624;
   }
 
-  const double lambda = qp_factor * pow(2.0, qp_temp / 3.0);
+  // Increase lambda if not key-frame.
+  if (keyframe_period > 0 && state->global->poc % keyframe_period != 0) {
+    lambda *= CLIP(2.0, 4.0, (state->global->QP - 12) / 6.0);
+  }
+  
   return lambda;
 }

kvazaar-0.7.2.tar.gz/src/rate_control.h -> kvazaar-0.8.1.tar.gz/src/rate_control.h Changed

kvazaar-0.7.2.tar.gz/src/rdo.c -> kvazaar-0.8.1.tar.gz/src/rdo.c Changed

@@ -18,10 +18,6 @@
  * with Kvazaar.  If not, see <http://www.gnu.org/licenses/>.
  ****************************************************************************/
 
-/*
- * \file
- */
-
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -32,6 +28,7 @@
 #include "cabac.h"
 #include "transform.h"
 #include "strategies/strategies-quant.h"
+#include "inter.h"
 
 
 #define QUANT_SHIFT          14
@@ -890,3 +887,221 @@
                      width, coef, dest_coeff);
   }
 }
+
+/** MVD cost calculation with CABAC
+* \returns int
+* Calculates cost of actual motion vectors using CABAC coding
+*/
+uint32_t kvz_get_mvd_coding_cost_cabac(vector2d_t *mvd, cabac_data_t* cabac) {
+  uint32_t bitcost = 0;
+  const int32_t mvd_hor = mvd->x;
+  const int32_t mvd_ver = mvd->y;
+  const int8_t hor_abs_gr0 = mvd_hor != 0;
+  const int8_t ver_abs_gr0 = mvd_ver != 0;
+  const uint32_t mvd_hor_abs = abs(mvd_hor);
+  const uint32_t mvd_ver_abs = abs(mvd_ver);
+
+  cabac_data_t cabac_copy;
+  memcpy(&cabac_copy, cabac, sizeof(cabac_data_t));
+  cabac->only_count = 1;
+
+  cabac->cur_ctx = &(cabac->ctx.cu_mvd_model[0]);
+  CABAC_BIN(cabac, (mvd_hor != 0), "abs_mvd_greater0_flag_hor");
+  CABAC_BIN(cabac, (mvd_ver != 0), "abs_mvd_greater0_flag_ver");
+  cabac->cur_ctx = &(cabac->ctx.cu_mvd_model[1]);
+  if (hor_abs_gr0) {
+    CABAC_BIN(cabac, (mvd_hor_abs > 1), "abs_mvd_greater1_flag_hor");
+  }
+  if (ver_abs_gr0) {
+    CABAC_BIN(cabac, (mvd_ver_abs > 1), "abs_mvd_greater1_flag_ver");
+  }
+  if (hor_abs_gr0) {
+    if (mvd_hor_abs > 1) {
+      kvz_cabac_write_ep_ex_golomb(cabac, mvd_hor_abs - 2, 1);
+    }
+    CABAC_BIN_EP(cabac, (mvd_hor > 0) ? 0 : 1, "mvd_sign_flag_hor");
+  }
+  if (ver_abs_gr0) {
+    if (mvd_ver_abs > 1) {
+      kvz_cabac_write_ep_ex_golomb(cabac, mvd_ver_abs - 2, 1);
+    }
+    CABAC_BIN_EP(cabac, (mvd_ver > 0) ? 0 : 1, "mvd_sign_flag_ver");
+  }
+  bitcost = ((23 - cabac->bits_left) + (cabac->num_buffered_bytes << 3)) - ((23 - cabac_copy.bits_left) + (cabac_copy.num_buffered_bytes << 3));
+
+  memcpy(cabac, &cabac_copy, sizeof(cabac_data_t));
+
+  return bitcost;
+}
+
+/** MVD cost calculation with CABAC
+* \returns int
+* Calculates Motion Vector cost and related costs using CABAC coding
+*/
+int kvz_calc_mvd_cost_cabac(const encoder_state_t * const state, int x, int y, int mv_shift,
+  int16_t mv_cand[2][2], inter_merge_cand_t merge_cand[MRG_MAX_NUM_CANDS],
+  int16_t num_cand, int32_t ref_idx, uint32_t *bitcost) {
+
+  cabac_data_t state_cabac_copy;
+  cabac_data_t* cabac;
+  uint32_t merge_idx;
+  int cand1_cost, cand2_cost;
+  vector2d_t mvd_temp1, mvd_temp2, mvd = { 0, 0 };
+  int8_t merged = 0;
+  int8_t cur_mv_cand = 0;
+
+  x <<= mv_shift;
+  y <<= mv_shift;
+
+  // Check every candidate to find a match
+  for (merge_idx = 0; merge_idx < (uint32_t)num_cand; merge_idx++) {
+    if (merge_cand[merge_idx].dir == 3) continue;
+    if (merge_cand[merge_idx].mv[merge_cand[merge_idx].dir - 1][0] == x &&
+      merge_cand[merge_idx].mv[merge_cand[merge_idx].dir - 1][1] == y &&
+      merge_cand[merge_idx].ref[merge_cand[merge_idx].dir - 1] == ref_idx) {
+      merged = 1;
+      break;
+    }
+  }
+
+  // Store cabac state and contexts
+  memcpy(&state_cabac_copy, &state->cabac, sizeof(cabac_data_t));
+
+  // Clear bytes and bits and set mode to "count"
+  state_cabac_copy.only_count = 1;
+  state_cabac_copy.num_buffered_bytes = 0;
+  state_cabac_copy.bits_left = 23;
+
+  cabac = &state_cabac_copy;
+
+  if (!merged) {
+    mvd_temp1.x = x - mv_cand[0][0];
+    mvd_temp1.y = y - mv_cand[0][1];
+    cand1_cost = kvz_get_mvd_coding_cost_cabac(&mvd_temp1, cabac);
+
+    mvd_temp2.x = x - mv_cand[1][0];
+    mvd_temp2.y = y - mv_cand[1][1];
+    cand2_cost = kvz_get_mvd_coding_cost_cabac(&mvd_temp2, cabac);
+
+    // Select candidate 1 if it has lower cost
+    if (cand2_cost < cand1_cost) {
+      cur_mv_cand = 1;
+      mvd = mvd_temp2;
+    } else {
+      mvd = mvd_temp1;
+    }
+  }
+
+  cabac->cur_ctx = &(cabac->ctx.cu_merge_flag_ext_model);
+
+  CABAC_BIN(cabac, merged, "MergeFlag");
+  num_cand = MRG_MAX_NUM_CANDS;
+  if (merged) {
+    if (num_cand > 1) {
+      int32_t ui;
+      for (ui = 0; ui < num_cand - 1; ui++) {
+        int32_t symbol = (ui != merge_idx);
+        if (ui == 0) {
+          cabac->cur_ctx = &(cabac->ctx.cu_merge_idx_ext_model);
+          CABAC_BIN(cabac, symbol, "MergeIndex");
+        } else {
+          CABAC_BIN_EP(cabac, symbol, "MergeIndex");
+        }
+        if (symbol == 0) break;
+      }
+    }
+  } else {
+    uint32_t ref_list_idx;
+    uint32_t j;
+    int ref_list[2] = { 0, 0 };
+    for (j = 0; j < state->global->ref->used_size; j++) {
+      if (state->global->ref->pocs[j] < state->global->poc) {
+        ref_list[0]++;
+      } else {
+        ref_list[1]++;
+      }
+    }
+
+    //ToDo: bidir mv support
+    for (ref_list_idx = 0; ref_list_idx < 2; ref_list_idx++) {
+      if (/*cur_cu->inter.mv_dir*/ 1 & (1 << ref_list_idx)) {
+        if (ref_list[ref_list_idx] > 1) {
+          // parseRefFrmIdx
+          int32_t ref_frame = ref_idx;
+
+          cabac->cur_ctx = &(cabac->ctx.cu_ref_pic_model[0]);
+          CABAC_BIN(cabac, (ref_frame != 0), "ref_idx_lX");
+
+          if (ref_frame > 0) {
+            int32_t i;
+            int32_t ref_num = ref_list[ref_list_idx] - 2;
+
+            cabac->cur_ctx = &(cabac->ctx.cu_ref_pic_model[1]);
+            ref_frame--;
+
+            for (i = 0; i < ref_num; ++i) {
+              const uint32_t symbol = (i == ref_frame) ? 0 : 1;
+
+              if (i == 0) {
+                CABAC_BIN(cabac, symbol, "ref_idx_lX");
+              } else {
+                CABAC_BIN_EP(cabac, symbol, "ref_idx_lX");
+              }
+              if (symbol == 0) break;
+            }
+          }
+        }
+
+        // ToDo: Bidir vector support
+        if (!(state->global->ref_list == REF_PIC_LIST_1 && /*cur_cu->inter.mv_dir == 3*/ 0)) {
+          const int32_t mvd_hor = mvd.x;
+          const int32_t mvd_ver = mvd.y;
+          const int8_t hor_abs_gr0 = mvd_hor != 0;
+          const int8_t ver_abs_gr0 = mvd_ver != 0;
+          const uint32_t mvd_hor_abs = abs(mvd_hor);
+          const uint32_t mvd_ver_abs = abs(mvd_ver);
+
+          cabac->cur_ctx = &(cabac->ctx.cu_mvd_model[0]);
+          CABAC_BIN(cabac, (mvd_hor != 0), "abs_mvd_greater0_flag_hor");
+          CABAC_BIN(cabac, (mvd_ver != 0), "abs_mvd_greater0_flag_ver");
+
+          cabac->cur_ctx = &(cabac->ctx.cu_mvd_model[1]);
+
+          if (hor_abs_gr0) {
+            CABAC_BIN(cabac, (mvd_hor_abs > 1), "abs_mvd_greater1_flag_hor");
+          }
+
+          if (ver_abs_gr0) {
+            CABAC_BIN(cabac, (mvd_ver_abs > 1), "abs_mvd_greater1_flag_ver");
+          }
+
+          if (hor_abs_gr0) {
+            if (mvd_hor_abs > 1) {
+              kvz_cabac_write_ep_ex_golomb(cabac, mvd_hor_abs - 2, 1);
+            }
+
+            CABAC_BIN_EP(cabac, (mvd_hor > 0) ? 0 : 1, "mvd_sign_flag_hor");
+          }
+
+          if (ver_abs_gr0) {
+            if (mvd_ver_abs > 1) {
+              kvz_cabac_write_ep_ex_golomb(cabac, mvd_ver_abs - 2, 1);
+            }
+
+            CABAC_BIN_EP(cabac, (mvd_ver > 0) ? 0 : 1, "mvd_sign_flag_ver");
+          }
+        }
+
+        // Signal which candidate MV to use
+        kvz_cabac_write_unary_max_symbol(cabac, cabac->ctx.mvp_idx_model, cur_mv_cand, 1,
+          AMVP_MAX_NUM_CANDS - 1);
+      }
+
+    }
+  }
+  
+  *bitcost = (23 - state_cabac_copy.bits_left) + (state_cabac_copy.num_buffered_bytes << 3);
+
+  // Store bitcost before restoring cabac
+  return *bitcost * (int32_t)(state->global->cur_lambda_cost_sqrt + 0.5);
+}

kvazaar-0.7.2.tar.gz/src/rdo.h -> kvazaar-0.8.1.tar.gz/src/rdo.h Changed

@@ -20,15 +20,17 @@
  * with Kvazaar.  If not, see <http://www.gnu.org/licenses/>.
  ****************************************************************************/
 
-/*
+/**
+ * \ingroup Compression
  * \file
- * \brief Handling Rate-Distortion Optimization related functionality
+ * Rate-Distortion Optimization related functionality.
  */
 
 #include "global.h"
 
 #include "encoder.h"
 #include "encoderstate.h"
+#include "inter.h"
 
 
 extern const uint32_t kvz_g_go_rice_range[5];
@@ -52,6 +54,11 @@
                          uint32_t c1_idx, uint32_t c2_idx,
                          int32_t q_bits,double temp, int8_t last, int8_t type);
 
+int kvz_calc_mvd_cost_cabac(const encoder_state_t * const state, int x, int y, int mv_shift,
+  int16_t mv_cand[2][2], inter_merge_cand_t merge_cand[MRG_MAX_NUM_CANDS],
+  int16_t num_cand, int32_t ref_idx, uint32_t *bitcost);
+uint32_t kvz_get_mvd_coding_cost_cabac(vector2d_t *mvd, cabac_data_t* cabac);
+
 extern const float kvz_f_entropy_bits[128];
 #define CTX_ENTROPY_FBITS(ctx,val) kvz_f_entropy_bits[(ctx)->uc_state ^ (val)]

kvazaar-0.7.2.tar.gz/src/sao.c -> kvazaar-0.8.1.tar.gz/src/sao.c Changed

kvazaar-0.7.2.tar.gz/src/sao.h -> kvazaar-0.8.1.tar.gz/src/sao.h Changed

kvazaar-0.7.2.tar.gz/src/scalinglist.h -> kvazaar-0.8.1.tar.gz/src/scalinglist.h Changed

kvazaar-0.7.2.tar.gz/src/search.c -> kvazaar-0.8.1.tar.gz/src/search.c Changed

@@ -18,10 +18,6 @@
  * with Kvazaar.  If not, see <http://www.gnu.org/licenses/>.
  ****************************************************************************/
 
-/*
- * \file
- */
-
 #include "search.h"
 
 #include <stdio.h>
@@ -35,6 +31,7 @@
 #include "transform.h"
 #include "search_inter.h"
 #include "search_intra.h"
+#include "strategies/strategies-picture.h"
 
 #define IN_FRAME(x, y, width, height, block_width, block_height) \
   ((x) >= 0 && (y) >= 0 \
@@ -46,12 +43,6 @@
 # define INTRA_TRESHOLD 20
 #endif
 
-// Extra cost for CU split.
-// Compensates for missing or incorrect bit costs. Must be recalculated if
-// bits are added or removed from cu-tree search.
-#ifndef CU_COST
-#  define CU_COST 3
-#endif
 // Disable early cu-split pruning.
 #ifndef FULL_CU_SPLIT_SEARCH
 #  define FULL_CU_SPLIT_SEARCH false
@@ -81,8 +72,8 @@
     int x, y;
     for (y = y_cu; y < y_cu + width_cu; ++y) {
       for (x = x_cu; x < x_cu + width_cu; ++x) {
-        const cu_info_t *from_cu = &work_tree[depth + 1].cu[LCU_CU_OFFSET + x + y * LCU_T_CU_WIDTH];
-        cu_info_t *to_cu = &work_tree[depth].cu[LCU_CU_OFFSET + x + y * LCU_T_CU_WIDTH];
+        const cu_info_t *from_cu = LCU_GET_CU(&work_tree[depth + 1], x, y);
+        cu_info_t *to_cu = LCU_GET_CU(&work_tree[depth], x, y);
         memcpy(to_cu, from_cu, sizeof(*to_cu));
       }
     }
@@ -141,8 +132,8 @@
     int x, y;
     for (y = y_cu; y < y_cu + width_cu; ++y) {
       for (x = x_cu; x < x_cu + width_cu; ++x) {
-        const cu_info_t *from_cu = &work_tree[depth].cu[LCU_CU_OFFSET + x + y * LCU_T_CU_WIDTH];
-        cu_info_t *to_cu = &work_tree[d].cu[LCU_CU_OFFSET + x + y * LCU_T_CU_WIDTH];
+        const cu_info_t *from_cu = LCU_GET_CU(&work_tree[depth], x, y);
+        cu_info_t *to_cu = LCU_GET_CU(&work_tree[d], x, y);
         memcpy(to_cu, from_cu, sizeof(*to_cu));
       }
     }
@@ -172,16 +163,15 @@
 void kvz_lcu_set_trdepth(lcu_t *lcu, int x_px, int y_px, int depth, int tr_depth)
 {
   const int width_cu = LCU_CU_WIDTH >> depth;
-  const vector2d_t lcu_cu = { (x_px & (LCU_WIDTH - 1)) / 8, (y_px & (LCU_WIDTH - 1)) / 8 };
-  cu_info_t *const cur_cu = &lcu->cu[lcu_cu.x + lcu_cu.y * LCU_T_CU_WIDTH + LCU_CU_OFFSET];
+  const vector2d_t lcu_cu = { SUB_SCU(x_px) / 8, SUB_SCU(y_px) / 8 };
   int x, y;
 
   // Depth 4 doesn't go inside the loop. Set the top-left CU.
-  cur_cu->tr_depth = tr_depth;
+  LCU_GET_CU(lcu, lcu_cu.x, lcu_cu.y)->tr_depth = tr_depth;
 
   for (y = 0; y < width_cu; ++y) {
     for (x = 0; x < width_cu; ++x) {
-      cu_info_t *cu = &cur_cu[x + y * LCU_T_CU_WIDTH];
+      cu_info_t *cu = LCU_GET_CU(lcu, lcu_cu.x + x, lcu_cu.y + y);
       cu->tr_depth = tr_depth;
     }
   }
@@ -193,12 +183,11 @@
   const int width_cu = LCU_CU_WIDTH >> depth;
   const int x_cu = SUB_SCU(x_px) >> MAX_DEPTH;
   const int y_cu = SUB_SCU(y_px) >> MAX_DEPTH;
-  cu_info_t *const lcu_cu = &lcu->cu[LCU_CU_OFFSET];
   int x, y;
 
   // NxN can only be applied to a single CU at a time.
   if (part_mode == SIZE_NxN) {
-    cu_info_t *cu = &lcu_cu[x_cu + y_cu * LCU_T_CU_WIDTH];
+    cu_info_t *cu = LCU_GET_CU(lcu, x_cu, y_cu);
     cu->depth = MAX_DEPTH;
     cu->type = CU_INTRA;
     cu->intra[PU_INDEX(x_px / 4, y_px / 4)].mode = pred_mode;
@@ -210,7 +199,7 @@
   // Set mode in every CU covered by part_mode in this depth.
   for (y = y_cu; y < y_cu + width_cu; ++y) {
     for (x = x_cu; x < x_cu + width_cu; ++x) {
-      cu_info_t *cu = &lcu_cu[x + y * LCU_T_CU_WIDTH];
+      cu_info_t *cu = LCU_GET_CU(lcu, x, y);
       cu->depth = depth;
       cu->type = CU_INTRA;
       cu->intra[0].mode = pred_mode;
@@ -225,48 +214,61 @@
 }
 
 
-static void lcu_set_inter(lcu_t *lcu, int x_px, int y_px, int depth, cu_info_t *cur_cu)
+static void lcu_set_inter_pu(lcu_t *lcu, int x_pu, int y_pu, int width_pu, int height_pu, cu_info_t *cur_pu)
 {
-  const int width_cu = LCU_CU_WIDTH >> depth;
-  const int x_cu = SUB_SCU(x_px) >> MAX_DEPTH;
-  const int y_cu = SUB_SCU(y_px) >> MAX_DEPTH;
-  cu_info_t *const lcu_cu = &lcu->cu[LCU_CU_OFFSET];
-  int x, y;
   // Set mode in every CU covered by part_mode in this depth.
-  for (y = y_cu; y < y_cu + width_cu; ++y) {
-    for (x = x_cu; x < x_cu + width_cu; ++x) {
-      cu_info_t *cu = &lcu_cu[x + y * LCU_T_CU_WIDTH];
+  for (int y = y_pu; y < y_pu + height_pu; ++y) {
+    for (int x = x_pu; x < x_pu + width_pu; ++x) {
+      cu_info_t *cu = LCU_GET_CU(lcu, x, y);
       //Check if this could be moved inside the if
       cu->coded    = 1;
-      if (cu != cur_cu) {
-        cu->depth    = cur_cu->depth;
-        cu->type     = CU_INTER;
-        cu->tr_depth = cur_cu->tr_depth;
-        cu->merged   = cur_cu->merged;
-        cu->skipped  = cur_cu->skipped;
-        memcpy(&cu->inter, &cur_cu->inter, sizeof(cur_cu->inter));
+      if (cu != cur_pu) {
+        cu->depth     = cur_pu->depth;
+        cu->part_size = cur_pu->part_size;
+        cu->type      = CU_INTER;
+        cu->tr_depth  = cur_pu->tr_depth;
+        cu->merged    = cur_pu->merged;
+        cu->skipped   = cur_pu->skipped;
+        memcpy(&cu->inter, &cur_pu->inter, sizeof(cur_pu->inter));
       }
     }
   }
 }
 
 
+static void lcu_set_inter(lcu_t *lcu, int x_px, int y_px, int depth, cu_info_t *cur_cu)
+{
+  const int width_cu = LCU_CU_WIDTH >> depth;
+  const int x_cu = SUB_SCU(x_px) >> MAX_DEPTH;
+  const int y_cu = SUB_SCU(y_px) >> MAX_DEPTH;
+  const int num_pu = kvz_part_mode_num_parts[cur_cu->part_size];
+
+  for (int i = 0; i < num_pu; ++i) {
+    const int x_pu      = PU_GET_X(cur_cu->part_size, width_cu, x_cu, i);
+    const int y_pu      = PU_GET_Y(cur_cu->part_size, width_cu, y_cu, i);
+    const int width_pu  = PU_GET_W(cur_cu->part_size, width_cu, i);
+    const int height_pu = PU_GET_H(cur_cu->part_size, width_cu, i);
+    cu_info_t *cur_pu   = LCU_GET_CU(lcu, x_pu, y_pu);
+    lcu_set_inter_pu(lcu, x_pu, y_pu, width_pu, height_pu, cur_pu);
+  }
+}
+
+
 static void lcu_set_coeff(lcu_t *lcu, int x_px, int y_px, int depth, cu_info_t *cur_cu)
 {
   const int width_cu = LCU_CU_WIDTH >> depth;
   const int x_cu = SUB_SCU(x_px) >> MAX_DEPTH;
   const int y_cu = SUB_SCU(y_px) >> MAX_DEPTH;
-  cu_info_t *const lcu_cu = &lcu->cu[LCU_CU_OFFSET];
   int x, y;
   int tr_split = cur_cu->tr_depth-cur_cu->depth;
 
   // Set coeff flags in every CU covered by part_mode in this depth.
   for (y = y_cu; y < y_cu + width_cu; ++y) {
     for (x = x_cu; x < x_cu + width_cu; ++x) {
-      cu_info_t *cu = &lcu_cu[x + y * LCU_T_CU_WIDTH];
+      cu_info_t *cu = LCU_GET_CU(lcu, x, y);
       // Use TU top-left CU to propagate coeff flags
       uint32_t mask = ~((width_cu>>tr_split)-1);
-      cu_info_t *cu_from = &lcu_cu[(x & mask) + (y & mask) * LCU_T_CU_WIDTH];
+      cu_info_t *cu_from = LCU_GET_CU(lcu, x & mask, y & mask);
       if (cu != cu_from) {
         // Chroma coeff data is not used, luma is needed for deblocking
         cu->cbf.y = cu_from->cbf.y;
@@ -294,7 +296,7 @@
   const uint8_t pu_index = PU_INDEX(x_px / 4, y_px / 4);
 
   // cur_cu is used for TU parameters.
-  cu_info_t *const tr_cu = &lcu->cu[LCU_CU_OFFSET + (x_px / 8) + (y_px / 8) * LCU_T_CU_WIDTH];
+  cu_info_t *const tr_cu = LCU_GET_CU_AT_PX(lcu, x_px, y_px);
 
   double coeff_bits = 0;
   double tr_tree_bits = 0;
@@ -367,7 +369,7 @@
 {
   const vector2d_t lcu_px = { x_px / 2, y_px / 2 };
   const int width = (depth <= MAX_DEPTH) ? LCU_WIDTH >> (depth + 1) : LCU_WIDTH >> depth;
-  cu_info_t *const tr_cu = &lcu->cu[LCU_CU_OFFSET + (lcu_px.x / 4) + (lcu_px.y / 4)*LCU_T_CU_WIDTH];
+  cu_info_t *const tr_cu = LCU_GET_CU(lcu, lcu_px.x / 4, lcu_px.y / 4);
 
   double tr_tree_bits = 0;
   double coeff_bits = 0;
@@ -449,8 +451,8 @@
   } else {
     int8_t candidate_modes[3];
     {
-      const cu_info_t *left_cu = ((x > 8) ? &cur_cu[-1] : NULL);
-      const cu_info_t *above_cu = ((y > 8) ? &cur_cu[-LCU_T_CU_WIDTH] : NULL);
+      const cu_info_t *left_cu  = ((x > 8) ? CU_GET_CU(cur_cu, -1,  0) : NULL);
+      const cu_info_t *above_cu = ((y > 8) ? CU_GET_CU(cur_cu,  0, -1) : NULL);
       kvz_intra_get_dir_luma_predictor(x, y, candidate_modes, cur_cu, left_cu, above_cu);
     }
 
@@ -466,10 +468,9 @@
 
 static uint8_t get_ctx_cu_split_model(const lcu_t *lcu, int x, int y, int depth)
 {
-  vector2d_t lcu_cu = { (x & 0x3f) / 8, (y & 0x3f) / 8 };
-  const cu_info_t *cu_array = &(lcu)->cu[LCU_CU_OFFSET];
-  bool condA = x >= 8 && cu_array[(lcu_cu.x - 1) + lcu_cu.y * LCU_T_CU_WIDTH].depth > depth;
-  bool condL = y >= 8 && cu_array[lcu_cu.x + (lcu_cu.y - 1) * LCU_T_CU_WIDTH].depth > depth;
+  vector2d_t lcu_cu = { SUB_SCU(x) / 8, SUB_SCU(y) / 8 };
+  bool condA = x >= 8 && LCU_GET_CU(lcu, lcu_cu.x - 1, lcu_cu.y    )->depth > depth;
+  bool condL = y >= 8 && LCU_GET_CU(lcu, lcu_cu.x,     lcu_cu.y - 1)->depth > depth;
   return condA + condL;
 }
 
@@ -493,7 +494,8 @@
 
   lcu_t *const lcu = &work_tree[depth];
 
-  int x_local = (x&0x3f), y_local = (y&0x3f);
+  int x_local = SUB_SCU(x);
+  int y_local = SUB_SCU(y);
 #ifdef KVZ_DEBUG
   int debug_split = 0;
 #endif
@@ -505,26 +507,55 @@
     return 0;
   }
 
-  cur_cu = &(&work_tree[depth])->cu[LCU_CU_OFFSET+(x_local>>3) + (y_local>>3)*LCU_T_CU_WIDTH];
+  cur_cu = LCU_GET_CU_AT_PX(&work_tree[depth], x_local, y_local);
   // Assign correct depth
   cur_cu->depth = depth > MAX_DEPTH ? MAX_DEPTH : depth;
   cur_cu->tr_depth = depth > 0 ? depth : 1;
   cur_cu->type = CU_NOTSET;
-  cur_cu->part_size = depth > MAX_DEPTH ? SIZE_NxN : SIZE_2Nx2N;
+  cur_cu->part_size = SIZE_2Nx2N;
   // If the CU is completely inside the frame at this depth, search for
   // prediction modes at this depth.
   if (x + cu_width <= frame->width &&
       y + cu_width <= frame->height)
   {
 
-    if (state->global->slicetype != KVZ_SLICE_I &&
-        WITHIN(depth, ctrl->pu_depth_inter.min, ctrl->pu_depth_inter.max))
-    {
+    bool can_use_inter =
+        state->global->slicetype != KVZ_SLICE_I
+        && WITHIN(depth, ctrl->pu_depth_inter.min, ctrl->pu_depth_inter.max);
+
+    if (can_use_inter) {
       int mode_cost = kvz_search_cu_inter(state, x, y, depth, &work_tree[depth]);
       if (mode_cost < cost) {
         cost = mode_cost;
         cur_cu->type = CU_INTER;
       }
+
+      if (depth < MAX_DEPTH) {
+        // Try SMP and AMP partitioning.
+        static const part_mode_t mp_modes[] = {
+          // SMP
+          SIZE_2NxN, SIZE_Nx2N,
+          // AMP
+          SIZE_2NxnU, SIZE_2NxnD,
+          SIZE_nLx2N, SIZE_nRx2N,
+        };
+
+        const int first_mode = ctrl->cfg->smp_enable ? 0 : 2;
+        const int last_mode  = (ctrl->cfg->amp_enable && cu_width >= 32) ? 5 : 1;
+        for (int i = first_mode; i <= last_mode; ++i) {
+          mode_cost = kvz_search_cu_smp(state,
+                                        x, y,
+                                        depth,
+                                        mp_modes[i],
+                                        &work_tree[depth + 1]);
+          // TODO: take cost of coding part mode into account
+          if (mode_cost < cost) {
+            cost = mode_cost;
+            // TODO: only copy inter prediction info, not pixels
+            work_tree_copy_up(x, y, depth, work_tree);
+          }
+        }
+      }
     }
 
     // Try to skip intra search in rd==0 mode.
@@ -540,12 +571,14 @@
       if (mode_cost < cost) {
         cost = mode_cost;
         cur_cu->type = CU_INTRA;
+        cur_cu->part_size = depth > MAX_DEPTH ? SIZE_NxN : SIZE_2Nx2N;
       }
     }
 
     // Reconstruct best mode because we need the reconstructed pixels for
     // mode search of adjacent CUs.
     if (cur_cu->type == CU_INTRA) {
+      assert(cur_cu->part_size == SIZE_2Nx2N || cur_cu->part_size == SIZE_NxN);
       int8_t intra_mode = cur_cu->intra[PU_INDEX(x >> 2, y >> 2)].mode;
       lcu_set_intra_mode(&work_tree[depth], x, y, depth,
                          intra_mode,
@@ -575,10 +608,40 @@
       int tr_depth = depth > 0 ? depth : 1;
       kvz_lcu_set_trdepth(&work_tree[depth], x, y, depth, tr_depth);
 
-      if (cur_cu->inter.mv_dir == 3) {
-        kvz_inter_recon_lcu_bipred(state, state->global->ref->images[cur_cu->inter.mv_ref[0]], state->global->ref->images[cur_cu->inter.mv_ref[1]], x, y, LCU_WIDTH >> depth, cur_cu->inter.mv, &work_tree[depth]);
-      } else {
-        kvz_inter_recon_lcu(state, state->global->ref->images[cur_cu->inter.mv_ref[cur_cu->inter.mv_dir - 1]], x, y, LCU_WIDTH >> depth, cur_cu->inter.mv[cur_cu->inter.mv_dir - 1], &work_tree[depth], 0);
+      const int cu_width = LCU_WIDTH >> depth;
+      const int num_pu = kvz_part_mode_num_parts[cur_cu->part_size];
+
+      for (int i = 0; i < num_pu; ++i) {
+        const int pu_x = PU_GET_X(cur_cu->part_size, cu_width, x, i);
+        const int pu_y = PU_GET_Y(cur_cu->part_size, cu_width, y, i);
+        const int pu_w = PU_GET_W(cur_cu->part_size, cu_width, i);
+        const int pu_h = PU_GET_H(cur_cu->part_size, cu_width, i);
+
+        cu_info_t *cur_pu = LCU_GET_CU_AT_PX(lcu, SUB_SCU(pu_x), SUB_SCU(pu_y));
+
+        if (cur_pu->inter.mv_dir == 3) {
+          const kvz_picture *const refs[2] = {
+            state->global->ref->images[cur_pu->inter.mv_ref[0]],
+            state->global->ref->images[cur_pu->inter.mv_ref[1]],
+          };
+          kvz_inter_recon_lcu_bipred(state,
+                                     refs[0], refs[1],
+                                     pu_x, pu_y,
+                                     pu_w, pu_h,
+                                     cur_pu->inter.mv,
+                                     &work_tree[depth]);
+        } else {
+          const int mv_idx = cur_pu->inter.mv_dir - 1;
+          const kvz_picture *const ref =
+              state->global->ref->images[cur_pu->inter.mv_ref[mv_idx]];
+          kvz_inter_recon_lcu(state,
+                              ref,
+                              pu_x, pu_y,
+                              pu_w, pu_h,
+                              cur_pu->inter.mv[mv_idx],
+                              &work_tree[depth],
+                              0);
+        }
       }
 
       kvz_quantize_lcu_luma_residual(state, x, y, depth, NULL, &work_tree[depth]);
@@ -586,7 +649,7 @@
 
       int cbf = cbf_is_set(cur_cu->cbf.y, depth) || cbf_is_set(cur_cu->cbf.u, depth) || cbf_is_set(cur_cu->cbf.v, depth);
 
-      if(cur_cu->merged && !cbf) {
+      if(cur_cu->merged && !cbf && cur_cu->part_size == SIZE_2Nx2N) {
         cur_cu->merged = 0;
         cur_cu->skipped = 1;
         // Selecting skip reduces bits needed to code the CU
@@ -608,22 +671,22 @@
   // Recursively split all the way to max search depth.
   if (depth < ctrl->pu_depth_intra.max || (depth < ctrl->pu_depth_inter.max && state->global->slicetype != KVZ_SLICE_I)) {
     int half_cu = cu_width / 2;
-    // Using Cost = lambda * 9 to compensate on the price of the split
-    double split_cost = state->global->cur_lambda_cost * CU_COST;
+    double split_cost = 0.0;
     int cbf = cbf_is_set(cur_cu->cbf.y, depth) || cbf_is_set(cur_cu->cbf.u, depth) || cbf_is_set(cur_cu->cbf.v, depth);
         
     if (depth < MAX_DEPTH) {
+      // Add cost of cu_split_flag.
       uint8_t split_model = get_ctx_cu_split_model(lcu, x, y, depth);
-
       const cabac_ctx_t *ctx = &(state->cabac.ctx.split_flag_model[split_model]);
-      cost += CTX_ENTROPY_FBITS(ctx, 0);
-      split_cost += CTX_ENTROPY_FBITS(ctx, 1);
+      cost += CTX_ENTROPY_FBITS(ctx, 0) * state->global->cur_lambda_cost;
+      split_cost += CTX_ENTROPY_FBITS(ctx, 1) * state->global->cur_lambda_cost;
     }
 
     if (cur_cu->type == CU_INTRA && depth == MAX_DEPTH) {
+      // Add cost of intra part_size.
       const cabac_ctx_t *ctx = &(state->cabac.ctx.part_size_model[0]);
-      cost += CTX_ENTROPY_FBITS(ctx, 1);  // 2Nx2N
-      split_cost += CTX_ENTROPY_FBITS(ctx, 0);  // NxN
+      cost += CTX_ENTROPY_FBITS(ctx, 1) * state->global->cur_lambda_cost;  // 2Nx2N
+      split_cost += CTX_ENTROPY_FBITS(ctx, 0) * state->global->cur_lambda_cost;  // NxN
     }
 
     // If skip mode was selected for the block, skip further search.
@@ -646,8 +709,7 @@
         && x + cu_width <= frame->width && y + cu_width <= frame->height)
     {
       vector2d_t lcu_cu = { x_local / 8, y_local / 8 };
-      cu_info_t *cu_array_d1 = &(&work_tree[depth + 1])->cu[LCU_CU_OFFSET];
-      cu_info_t *cu_d1 = &cu_array_d1[(lcu_cu.x + lcu_cu.y * LCU_T_CU_WIDTH)];
+      cu_info_t *cu_d1 = LCU_GET_CU(&work_tree[depth + 1], lcu_cu.x, lcu_cu.y);
 
       // If the best CU in depth+1 is intra and the biggest it can be, try it.
       if (cu_d1->type == CU_INTRA && cu_d1->depth == depth + 1) {
@@ -655,6 +717,7 @@
 
         cur_cu->intra[0] = cu_d1->intra[0];
         cur_cu->type = CU_INTRA;
+        cur_cu->part_size = depth > MAX_DEPTH ? SIZE_NxN : SIZE_2Nx2N;
 
         kvz_lcu_set_trdepth(&work_tree[depth], x, y, depth, cur_cu->tr_depth);
         lcu_set_intra_mode(&work_tree[depth], x, y, depth,
@@ -665,10 +728,12 @@
         cost += kvz_cu_rd_cost_luma(state, x_local, y_local, depth, cur_cu, &work_tree[depth]);
         cost += kvz_cu_rd_cost_chroma(state, x_local, y_local, depth, cur_cu, &work_tree[depth]);
 
+        // Add the cost of coding no-split.
         uint8_t split_model = get_ctx_cu_split_model(lcu, x, y, depth);
         const cabac_ctx_t *ctx = &(state->cabac.ctx.split_flag_model[split_model]);
-        cost += CTX_ENTROPY_FBITS(ctx, 0);
+        cost += CTX_ENTROPY_FBITS(ctx, 0) * state->global->cur_lambda_cost;
 
+        // Add the cost of coding intra mode only once.
         double mode_bits = calc_mode_bits(state, cur_cu, x, y);
         cost += mode_bits * state->global->cur_lambda_cost;
       }
@@ -686,8 +751,12 @@
       // search.
       work_tree_copy_down(x, y, depth, work_tree);
     }
+  } else if (depth >= 0 && depth < MAX_PU_DEPTH) {
+    // Need to copy modes down since the lower level of the work tree is used
+    // when searching SMP and AMP blocks.
+    work_tree_copy_down(x, y, depth, work_tree);
   }
-  
+
   PERFORMANCE_MEASURE_END(KVZ_PERF_SEARCHCU, state->encoder_control->threadqueue, "type=search_cu,frame=%d,tile=%d,slice=%d,px_x=%d-%d,px_y=%d-%d,depth=%d,split=%d,cur_cu_is_intra=%d", state->global->frame, state->tile->id, state->slice->id,
                           (state->tile->lcu_offset_x * LCU_WIDTH) + x,
                           (state->tile->lcu_offset_x * LCU_WIDTH) + x + (LCU_WIDTH >> depth), 
@@ -714,16 +783,12 @@
     const int x_cu = x >> MAX_DEPTH;
     const int y_cu = y >> MAX_DEPTH;
 
-    // Use top-left sub-cu of LCU as pointer to lcu->cu array to make things
-    // simpler.
-    cu_info_t *lcu_cu = &lcu->cu[LCU_CU_OFFSET];
-
     // Copy top CU row.
     if (y_cu > 0) {
       int i;
       for (i = 0; i < LCU_CU_WIDTH; ++i) {
         const cu_info_t *from_cu = kvz_videoframe_get_cu_const(frame, x_cu + i, y_cu - 1);
-        cu_info_t *to_cu = &lcu_cu[i - LCU_T_CU_WIDTH];
+        cu_info_t *to_cu = LCU_GET_CU(lcu, i, -1);
         memcpy(to_cu, from_cu, sizeof(*to_cu));
       }
     }
@@ -732,21 +797,21 @@
       int i;
       for (i = 0; i < LCU_CU_WIDTH; ++i) {
         const cu_info_t *from_cu = kvz_videoframe_get_cu_const(frame, x_cu - 1, y_cu + i);
-        cu_info_t *to_cu = &lcu_cu[-1 + i * LCU_T_CU_WIDTH];
+        cu_info_t *to_cu = LCU_GET_CU(lcu, -1, i);
         memcpy(to_cu, from_cu, sizeof(*to_cu));
       }
     }
     // Copy top-left CU.
     if (x_cu > 0 && y_cu > 0) {
       const cu_info_t *from_cu = kvz_videoframe_get_cu_const(frame, x_cu - 1, y_cu - 1);
-      cu_info_t *to_cu = &lcu_cu[-1 - LCU_T_CU_WIDTH];
+      cu_info_t *to_cu = LCU_GET_CU(lcu, -1, -1);
       memcpy(to_cu, from_cu, sizeof(*to_cu));
     }
 
     // Copy top-right CU.
     if (y_cu > 0 && x + LCU_WIDTH < frame->width) {
       const cu_info_t *from_cu = kvz_videoframe_get_cu_const(frame, x_cu + LCU_CU_WIDTH, y_cu - 1);
-      cu_info_t *to_cu = &lcu->cu[LCU_T_CU_WIDTH*LCU_T_CU_WIDTH];
+      cu_info_t *to_cu = LCU_GET_TOP_RIGHT_CU(lcu);
       memcpy(to_cu, from_cu, sizeof(*to_cu));
     }
   }
@@ -805,14 +870,10 @@
     const int y_cu = y_px >> MAX_DEPTH;
     videoframe_t * const frame = state->tile->frame;
 
-    // Use top-left sub-cu of LCU as pointer to lcu->cu array to make things
-    // simpler.
-    const cu_info_t *const lcu_cu = &lcu->cu[LCU_CU_OFFSET];
-
     int x, y;
     for (y = 0; y < LCU_CU_WIDTH; ++y) {
       for (x = 0; x < LCU_CU_WIDTH; ++x) {
-        const cu_info_t *from_cu = &lcu_cu[x + y * LCU_T_CU_WIDTH];
+        const cu_info_t *from_cu = LCU_GET_CU(lcu, x, y);
         cu_info_t *to_cu = kvz_videoframe_get_cu(frame, x_cu + x, y_cu + y);
         memcpy(to_cu, from_cu, sizeof(*to_cu));
       }

kvazaar-0.7.2.tar.gz/src/search.h -> kvazaar-0.8.1.tar.gz/src/search.h Changed

kvazaar-0.7.2.tar.gz/src/search_inter.c -> kvazaar-0.8.1.tar.gz/src/search_inter.c Changed

@@ -18,10 +18,6 @@
 * with Kvazaar.  If not, see <http://www.gnu.org/licenses/>.
 ****************************************************************************/
 
-/*
-* \file
-*/
-
 #include "search_inter.h"
 
 #include <stdlib.h>
@@ -29,10 +25,7 @@
 #include "inter.h"
 #include "strategies/strategies-picture.h"
 #include "strategies/strategies-ipol.h"
-
-
-// Temporarily for debugging.
-#define SEARCH_MV_FULL_RADIUS 0
+#include "rdo.h"
 
 
 static uint32_t get_ep_ex_golomb_bitcost(uint32_t symbol, uint32_t count)
@@ -49,7 +42,7 @@
 }
 
 
-static uint32_t get_mvd_coding_cost(vector2d_t *mvd)
+static uint32_t get_mvd_coding_cost(vector2d_t *mvd, cabac_data_t* cabac)
 {
   uint32_t bitcost = 0;
   const int32_t mvd_hor = mvd->x;
@@ -112,11 +105,11 @@
   if(!merged) {
     mvd_temp1.x = x - mv_cand[0][0];
     mvd_temp1.y = y - mv_cand[0][1];
-    cand1_cost = get_mvd_coding_cost(&mvd_temp1);
+    cand1_cost = get_mvd_coding_cost(&mvd_temp1, NULL);
 
     mvd_temp2.x = x - mv_cand[1][0];
     mvd_temp2.y = y - mv_cand[1][1];
-    cand2_cost = get_mvd_coding_cost(&mvd_temp2);
+    cand2_cost = get_mvd_coding_cost(&mvd_temp2, NULL);
 
     // Select candidate 1 if it has lower cost
     if (cand2_cost < cand1_cost) {
@@ -132,7 +125,7 @@
 unsigned kvz_tz_pattern_search(const encoder_state_t * const state, const kvz_picture *pic, const kvz_picture *ref, unsigned pattern_type,
                            const vector2d_t *orig, const int iDist, vector2d_t *mv, unsigned best_cost, int *best_dist,
                            int16_t mv_cand[2][2], inter_merge_cand_t merge_cand[MRG_MAX_NUM_CANDS], int16_t num_cand, int32_t ref_idx, uint32_t *best_bitcost,
-                           int block_width, int max_lcu_below)
+                           int width, int height, int max_px_below_lcu)
 {
   int n_points;
   int best_index = -1;
@@ -140,6 +133,14 @@
   
   vector2d_t mv_best = { 0, 0 };
 
+
+  int(*calc_mvd)(const encoder_state_t * const, int, int, int,
+    int16_t[2][2], inter_merge_cand_t[MRG_MAX_NUM_CANDS],
+    int16_t, int32_t, uint32_t *) = calc_mvd_cost;
+  if (state->encoder_control->cfg->mv_rdo) {
+    calc_mvd = kvz_calc_mvd_cost_cabac;
+  }
+
   assert(pattern_type < 4);
 
   //implemented search patterns
@@ -250,14 +251,14 @@
       cost = kvz_image_calc_sad(pic, ref, orig->x, orig->y,
                             (state->tile->lcu_offset_x * LCU_WIDTH) + orig->x + mv->x + current->x,
                             (state->tile->lcu_offset_y * LCU_WIDTH) + orig->y + mv->y + current->y,
-                            block_width, block_width, max_lcu_below);
-      cost += calc_mvd_cost(state, mv->x + current->x, mv->y + current->y, 2, mv_cand, merge_cand, num_cand, ref_idx, &bitcost);
+                            width, height, max_px_below_lcu);
+      cost += calc_mvd(state, mv->x + current->x, mv->y + current->y, 2, mv_cand, merge_cand, num_cand, ref_idx, &bitcost);
 
-      PERFORMANCE_MEASURE_END(KVZ_PERF_SEARCHPX, state->encoder_control->threadqueue, "type=sad,step=large_hexbs,frame=%d,tile=%d,px_x=%d-%d,px_y=%d-%d,ref_px_x=%d-%d,ref_px_y=%d-%d", state->global->frame, state->tile->id, orig->x, orig->x + block_width, orig->y, orig->y + block_width,
+      PERFORMANCE_MEASURE_END(KVZ_PERF_SEARCHPX, state->encoder_control->threadqueue, "type=sad,step=large_hexbs,frame=%d,tile=%d,px_x=%d-%d,px_y=%d-%d,ref_px_x=%d-%d,ref_px_y=%d-%d", state->global->frame, state->tile->id, orig->x, orig->x + width, orig->y, orig->y + height,
         (state->tile->lcu_offset_x * LCU_WIDTH) + orig->x + mv->x + current->x,
-        (state->tile->lcu_offset_x * LCU_WIDTH) + orig->x + mv->x + current->x + block_width,
+        (state->tile->lcu_offset_x * LCU_WIDTH) + orig->x + mv->x + current->x + width,
         (state->tile->lcu_offset_y * LCU_WIDTH) + orig->y + mv->y + current->y,
-        (state->tile->lcu_offset_y * LCU_WIDTH) + orig->y + mv->y + current->y + block_width);
+        (state->tile->lcu_offset_y * LCU_WIDTH) + orig->y + mv->y + current->y + height);
     }
 
     if (cost < best_cost)
@@ -286,12 +287,19 @@
 unsigned kvz_tz_raster_search(const encoder_state_t * const state, const kvz_picture *pic, const kvz_picture *ref,
                           const vector2d_t *orig, vector2d_t *mv, unsigned best_cost,
                           int16_t mv_cand[2][2], inter_merge_cand_t merge_cand[MRG_MAX_NUM_CANDS], int16_t num_cand, int32_t ref_idx, uint32_t *best_bitcost,
-                          int block_width, int iSearchRange, int iRaster, int max_lcu_below)
+                          int width, int height, int iSearchRange, int iRaster, int max_px_below_lcu)
 {
   int i;
   int k;
 
   vector2d_t mv_best = { 0, 0 };
+
+  int(*calc_mvd)(const encoder_state_t * const, int, int, int,
+    int16_t[2][2], inter_merge_cand_t[MRG_MAX_NUM_CANDS],
+    int16_t, int32_t, uint32_t *) = calc_mvd_cost;
+  if (state->encoder_control->cfg->mv_rdo) {
+    calc_mvd = kvz_calc_mvd_cost_cabac;
+  }
   
   //compute SAD values for every point in the iRaster downsampled version of the current search area
   for (i = iSearchRange; i >= -iSearchRange; i -= iRaster)
@@ -307,14 +315,14 @@
         cost = kvz_image_calc_sad(pic, ref, orig->x, orig->y,
           (state->tile->lcu_offset_x * LCU_WIDTH) + orig->x + mv->x + k,
           (state->tile->lcu_offset_y * LCU_WIDTH) + orig->y + mv->y + i,
-          block_width, block_width, max_lcu_below);
-        cost += calc_mvd_cost(state, mv->x + k, mv->y + i, 2, mv_cand, merge_cand, num_cand, ref_idx, &bitcost);
+          width, height, max_px_below_lcu);
+        cost += calc_mvd(state, mv->x + k, mv->y + i, 2, mv_cand, merge_cand, num_cand, ref_idx, &bitcost);
 
-        PERFORMANCE_MEASURE_END(KVZ_PERF_SEARCHPX, state->encoder_control->threadqueue, "type=sad,step=large_hexbs,frame=%d,tile=%d,px_x=%d-%d,px_y=%d-%d,ref_px_x=%d-%d,ref_px_y=%d-%d", state->global->frame, state->tile->id, orig->x, orig->x + block_width, orig->y, orig->y + block_width,
+        PERFORMANCE_MEASURE_END(KVZ_PERF_SEARCHPX, state->encoder_control->threadqueue, "type=sad,step=large_hexbs,frame=%d,tile=%d,px_x=%d-%d,px_y=%d-%d,ref_px_x=%d-%d,ref_px_y=%d-%d", state->global->frame, state->tile->id, orig->x, orig->x + width, orig->y, orig->y + height,
           (state->tile->lcu_offset_x * LCU_WIDTH) + orig->x + mv->x + k,
-          (state->tile->lcu_offset_x * LCU_WIDTH) + orig->x + mv->x + k + block_width,
+          (state->tile->lcu_offset_x * LCU_WIDTH) + orig->x + mv->x + k + width,
           (state->tile->lcu_offset_y * LCU_WIDTH) + orig->y + mv->y + i,
-          (state->tile->lcu_offset_y * LCU_WIDTH) + orig->y + mv->y + i + block_width);
+          (state->tile->lcu_offset_y * LCU_WIDTH) + orig->y + mv->y + i + height);
       }
 
       if (cost < best_cost)
@@ -335,7 +343,8 @@
 }
 
 
-static unsigned tz_search(const encoder_state_t * const state, unsigned depth,
+static unsigned tz_search(const encoder_state_t * const state,
+                          unsigned width, unsigned height,
                           const kvz_picture *pic, const kvz_picture *ref,
                           const vector2d_t *orig, vector2d_t *mv_in_out,
                           int16_t mv_cand[2][2], inter_merge_cand_t merge_cand[MRG_MAX_NUM_CANDS],
@@ -349,8 +358,6 @@
   const unsigned step4_type = 0;
   const bool bRasterRefinementEnable = true;  // enable step 4 mode 1
   const bool bStarRefinementEnable = false;   // enable step 4 mode 2 (only one mode will be executed)
-  
-  const int block_width = CU_WIDTH_FROM_DEPTH(depth);
 
   vector2d_t mv = { mv_in_out->x >> 2, mv_in_out->y >> 2 };
 
@@ -359,10 +366,25 @@
   int iDist;
   int best_dist = 0;
   unsigned best_index = num_cand;
-  int max_lcu_below = -1;
+  int max_px_below_lcu = -1;
+
+  int(*calc_mvd)(const encoder_state_t * const, int, int, int,
+    int16_t[2][2], inter_merge_cand_t[MRG_MAX_NUM_CANDS],
+    int16_t, int32_t, uint32_t *) = calc_mvd_cost;
+  if (state->encoder_control->cfg->mv_rdo) {
+    calc_mvd = kvz_calc_mvd_cost_cabac;
+  }
 
   if (state->encoder_control->owf) {
-    max_lcu_below = 1;
+    max_px_below_lcu = LCU_WIDTH;
+    if (state->encoder_control->fme_level > 0) {
+      // Fractional motion estimation can change the mv by at most 1 pixel.
+      max_px_below_lcu -= 1;
+    }
+    if (state->encoder_control->deblock_enable) {
+      // Strong deblock filter modifies 3 pixels.
+      max_px_below_lcu -= 3;
+    }
   }
 
   //step 1, compare (0,0) vector to predicted vectors
@@ -375,14 +397,14 @@
     best_cost = kvz_image_calc_sad(pic, ref, orig->x, orig->y,
                                         (state->tile->lcu_offset_x * LCU_WIDTH) + orig->x + mv.x,
                                         (state->tile->lcu_offset_y * LCU_WIDTH) + orig->y + mv.y,
-                                        block_width, block_width, max_lcu_below);
-    best_cost += calc_mvd_cost(state, mv.x, mv.y, 2, mv_cand, merge_cand, num_cand, ref_idx, &best_bitcost);
+                                        width, height, max_px_below_lcu);
+    best_cost += calc_mvd(state, mv.x, mv.y, 2, mv_cand, merge_cand, num_cand, ref_idx, &best_bitcost);
 
-    PERFORMANCE_MEASURE_END(KVZ_PERF_SEARCHPX, state->encoder_control->threadqueue, "type=sad,step=large_hexbs,frame=%d,tile=%d,px_x=%d-%d,px_y=%d-%d,ref_px_x=%d-%d,ref_px_y=%d-%d", state->global->frame, state->tile->id, orig->x, orig->x + block_width, orig->y, orig->y + block_width,
+    PERFORMANCE_MEASURE_END(KVZ_PERF_SEARCHPX, state->encoder_control->threadqueue, "type=sad,step=large_hexbs,frame=%d,tile=%d,px_x=%d-%d,px_y=%d-%d,ref_px_x=%d-%d,ref_px_y=%d-%d", state->global->frame, state->tile->id, orig->x, orig->x + width, orig->y, orig->y + height,
                             (state->tile->lcu_offset_x * LCU_WIDTH) + orig->x + mv.x,
-                            (state->tile->lcu_offset_x * LCU_WIDTH) + orig->x + mv.x + block_width,
+                            (state->tile->lcu_offset_x * LCU_WIDTH) + orig->x + mv.x + width,
                             (state->tile->lcu_offset_y * LCU_WIDTH) + orig->y + mv.y,
-                            (state->tile->lcu_offset_y * LCU_WIDTH) + orig->y + mv.y + block_width);
+                            (state->tile->lcu_offset_y * LCU_WIDTH) + orig->y + mv.y + height);
   }
 
   int i;
@@ -400,14 +422,14 @@
     unsigned cost = kvz_image_calc_sad(pic, ref, orig->x, orig->y,
                                    (state->tile->lcu_offset_x * LCU_WIDTH) + orig->x + mv.x,
                                    (state->tile->lcu_offset_y * LCU_WIDTH) + orig->y + mv.y,
-                                   block_width, block_width, max_lcu_below);
-    cost += calc_mvd_cost(state, mv.x, mv.y, 2, mv_cand, merge_cand, num_cand, ref_idx, &bitcost);
+                                   width, height, max_px_below_lcu);
+    cost += calc_mvd(state, mv.x, mv.y, 2, mv_cand, merge_cand, num_cand, ref_idx, &bitcost);
 
-    PERFORMANCE_MEASURE_END(KVZ_PERF_SEARCHPX, state->encoder_control->threadqueue, "type=sad,step=large_hexbs,frame=%d,tile=%d,px_x=%d-%d,px_y=%d-%d,ref_px_x=%d-%d,ref_px_y=%d-%d", state->global->frame, state->tile->id, orig->x, orig->x + block_width, orig->y, orig->y + block_width,
+    PERFORMANCE_MEASURE_END(KVZ_PERF_SEARCHPX, state->encoder_control->threadqueue, "type=sad,step=large_hexbs,frame=%d,tile=%d,px_x=%d-%d,px_y=%d-%d,ref_px_x=%d-%d,ref_px_y=%d-%d", state->global->frame, state->tile->id, orig->x, orig->x + width, orig->y, orig->y + height,
                             (state->tile->lcu_offset_x * LCU_WIDTH) + orig->x + mv.x,
-                            (state->tile->lcu_offset_x * LCU_WIDTH) + orig->x + mv.x + block_width,
+                            (state->tile->lcu_offset_x * LCU_WIDTH) + orig->x + mv.x + width,
                             (state->tile->lcu_offset_y * LCU_WIDTH) + orig->y + mv.y,
-                            (state->tile->lcu_offset_y * LCU_WIDTH) + orig->y + mv.y + block_width);
+                            (state->tile->lcu_offset_y * LCU_WIDTH) + orig->y + mv.y + height);
 
     if (cost < best_cost) {
       best_cost = cost;
@@ -428,7 +450,7 @@
   for (iDist = 1; iDist <= iSearchRange; iDist *= 2)
   {
     best_cost = kvz_tz_pattern_search(state, pic, ref, step2_type, orig, iDist, &mv, best_cost, &best_dist,
-                                  mv_cand, merge_cand, num_cand, ref_idx, &best_bitcost, block_width, max_lcu_below);
+                                  mv_cand, merge_cand, num_cand, ref_idx, &best_bitcost, width, height, max_px_below_lcu);
   }
 
   //step 3, raster scan
@@ -436,8 +458,8 @@
   {
     best_dist = iRaster;
 
-    best_cost = kvz_tz_raster_search(state, pic, ref, orig, &mv, best_cost, mv_cand, merge_cand, 
-                                 num_cand, ref_idx, &best_bitcost, block_width, iSearchRange, iRaster, max_lcu_below);
+    best_cost = kvz_tz_raster_search(state, pic, ref, orig, &mv, best_cost, mv_cand, merge_cand,
+                                 num_cand, ref_idx, &best_bitcost, width, height, iSearchRange, iRaster, max_px_below_lcu);
   }
 
   //step 4
@@ -449,7 +471,7 @@
     while (iDist > 0)
     {
       best_cost = kvz_tz_pattern_search(state, pic, ref, step4_type, orig, iDist, &mv, best_cost, &best_dist,
-                                   mv_cand, merge_cand, num_cand, ref_idx, &best_bitcost, block_width, max_lcu_below);
+                                   mv_cand, merge_cand, num_cand, ref_idx, &best_bitcost, width, height, max_px_below_lcu);
 
       iDist = iDist >> 1;
     }
@@ -461,7 +483,7 @@
     for (iDist = 1; iDist <= iSearchRange; iDist *= 2)
     {
       best_cost = kvz_tz_pattern_search(state, pic, ref, step4_type, orig, iDist, &mv, best_cost, &best_dist,
-                                   mv_cand, merge_cand, num_cand, ref_idx, &best_bitcost, block_width, max_lcu_below);
+                                   mv_cand, merge_cand, num_cand, ref_idx, &best_bitcost, width, height, max_px_below_lcu);
     }
   }
 
@@ -478,7 +500,8 @@
 /**
  * \brief Do motion search using the HEXBS algorithm.
  *
- * \param depth      log2 depth of the search
+ * \param width      width of the block to search
+ * \param height     height of the block to search
  * \param pic        Picture motion vector is searched for.
  * \param ref        Picture motion vector is searched from.
  * \param orig       Top left corner of the searched for block.
@@ -495,7 +518,8 @@
  * the predicted motion vector is way off. In the future even more additional
  * points like 0,0 might be used, such as vectors from top or left.
  */
-static unsigned hexagon_search(const encoder_state_t * const state, unsigned depth,
+static unsigned hexagon_search(const encoder_state_t * const state,
+                               unsigned width, unsigned height,
                                const kvz_picture *pic, const kvz_picture *ref,
                                const vector2d_t *orig, vector2d_t *mv_in_out,
                                int16_t mv_cand[2][2], inter_merge_cand_t merge_cand[MRG_MAX_NUM_CANDS],
@@ -524,15 +548,30 @@
   };
 
   vector2d_t mv = { mv_in_out->x >> 2, mv_in_out->y >> 2 };
-  int block_width = CU_WIDTH_FROM_DEPTH(depth);
   unsigned best_cost = UINT32_MAX;
   uint32_t best_bitcost = 0, bitcost;
   unsigned i;
   unsigned best_index = 0; // Index of large_hexbs or finally small_hexbs.
-  int max_lcu_below = -1;
+  int max_px_below_lcu = -1;
+
+  int (*calc_mvd)(const encoder_state_t * const, int, int, int,
+    int16_t[2][2], inter_merge_cand_t[MRG_MAX_NUM_CANDS],
+    int16_t, int32_t, uint32_t *) = calc_mvd_cost;
+  if (state->encoder_control->cfg->mv_rdo) {
+    calc_mvd = kvz_calc_mvd_cost_cabac;
+  }
+
   
   if (state->encoder_control->owf) {
-    max_lcu_below = 1;
+    max_px_below_lcu = LCU_WIDTH;
+    if (state->encoder_control->fme_level > 0) {
+      // Fractional motion estimation can change the mv by at most 1 pixel.
+      max_px_below_lcu -= 1;
+    }
+    if (state->encoder_control->deblock_enable) {
+      // Strong deblock filter modifies 3 pixels.
+      max_px_below_lcu -= 3;
+    }
   }
 
   // Check mv_in, if it's not in merge candidates.
@@ -552,16 +591,16 @@
     best_cost = kvz_image_calc_sad(pic, ref, orig->x, orig->y,
                                         (state->tile->lcu_offset_x * LCU_WIDTH) + orig->x + mv.x,
                                         (state->tile->lcu_offset_y * LCU_WIDTH) + orig->y + mv.y,
-                                        block_width, block_width, max_lcu_below);
-    best_cost += calc_mvd_cost(state, mv.x, mv.y, 2, mv_cand, merge_cand, num_cand, ref_idx, &bitcost);
+                                        width, height, max_px_below_lcu);
+    best_cost += calc_mvd(state, mv.x, mv.y, 2, mv_cand, merge_cand, num_cand, ref_idx, &bitcost);
     best_bitcost = bitcost;
     best_index = num_cand; 
 
-    PERFORMANCE_MEASURE_END(KVZ_PERF_SEARCHPX, state->encoder_control->threadqueue, "type=sad,step=large_hexbs,frame=%d,tile=%d,px_x=%d-%d,px_y=%d-%d,ref_px_x=%d-%d,ref_px_y=%d-%d", state->global->frame, state->tile->id, orig->x, orig->x + block_width, orig->y, orig->y + block_width,
+    PERFORMANCE_MEASURE_END(KVZ_PERF_SEARCHPX, state->encoder_control->threadqueue, "type=sad,step=large_hexbs,frame=%d,tile=%d,px_x=%d-%d,px_y=%d-%d,ref_px_x=%d-%d,ref_px_y=%d-%d", state->global->frame, state->tile->id, orig->x, orig->x + width, orig->y, orig->y + height,
                             (state->tile->lcu_offset_x * LCU_WIDTH) + orig->x + mv.x,
-                            (state->tile->lcu_offset_x * LCU_WIDTH) + orig->x + mv.x + block_width,
+                            (state->tile->lcu_offset_x * LCU_WIDTH) + orig->x + mv.x + width,
                             (state->tile->lcu_offset_y * LCU_WIDTH) + orig->y + mv.y,
-                            (state->tile->lcu_offset_y * LCU_WIDTH) + orig->y + mv.y + block_width);
+                            (state->tile->lcu_offset_y * LCU_WIDTH) + orig->y + mv.y + height);
   }
 
   // Select starting point from among merge candidates. These should include
@@ -576,14 +615,14 @@
     unsigned cost = kvz_image_calc_sad(pic, ref, orig->x, orig->y,
                                    (state->tile->lcu_offset_x * LCU_WIDTH) + orig->x + mv.x,
                                    (state->tile->lcu_offset_y * LCU_WIDTH) + orig->y + mv.y,
-                                   block_width, block_width, max_lcu_below);
-    cost += calc_mvd_cost(state, mv.x, mv.y, 2, mv_cand, merge_cand, num_cand, ref_idx, &bitcost);
+                                   width, height, max_px_below_lcu);
+    cost += calc_mvd(state, mv.x, mv.y, 2, mv_cand, merge_cand, num_cand, ref_idx, &bitcost);
 
-    PERFORMANCE_MEASURE_END(KVZ_PERF_SEARCHPX, state->encoder_control->threadqueue, "type=sad,step=large_hexbs,frame=%d,tile=%d,px_x=%d-%d,px_y=%d-%d,ref_px_x=%d-%d,ref_px_y=%d-%d", state->global->frame, state->tile->id, orig->x, orig->x + block_width, orig->y, orig->y + block_width,
+    PERFORMANCE_MEASURE_END(KVZ_PERF_SEARCHPX, state->encoder_control->threadqueue, "type=sad,step=large_hexbs,frame=%d,tile=%d,px_x=%d-%d,px_y=%d-%d,ref_px_x=%d-%d,ref_px_y=%d-%d", state->global->frame, state->tile->id, orig->x, orig->x + width, orig->y, orig->y + height,
                             (state->tile->lcu_offset_x * LCU_WIDTH) + orig->x + mv.x,
-                            (state->tile->lcu_offset_x * LCU_WIDTH) + orig->x + mv.x + block_width,
+                            (state->tile->lcu_offset_x * LCU_WIDTH) + orig->x + mv.x + width,
                             (state->tile->lcu_offset_y * LCU_WIDTH) + orig->y + mv.y,
-                            (state->tile->lcu_offset_y * LCU_WIDTH) + orig->y + mv.y + block_width);
+                            (state->tile->lcu_offset_y * LCU_WIDTH) + orig->y + mv.y + height);
 
     if (cost < best_cost) {
       best_cost = cost;
@@ -609,14 +648,14 @@
       cost = kvz_image_calc_sad(pic, ref, orig->x, orig->y,
                              (state->tile->lcu_offset_x * LCU_WIDTH) + orig->x + mv.x + pattern->x, 
                              (state->tile->lcu_offset_y * LCU_WIDTH) + orig->y + mv.y + pattern->y,
-                             block_width, block_width, max_lcu_below);
-      cost += calc_mvd_cost(state, mv.x + pattern->x, mv.y + pattern->y, 2, mv_cand,merge_cand,num_cand,ref_idx, &bitcost);
+                             width, height, max_px_below_lcu);
+      cost += calc_mvd(state, mv.x + pattern->x, mv.y + pattern->y, 2, mv_cand, merge_cand, num_cand, ref_idx, &bitcost);
 
-      PERFORMANCE_MEASURE_END(KVZ_PERF_SEARCHPX, state->encoder_control->threadqueue, "type=sad,step=large_hexbs,frame=%d,tile=%d,px_x=%d-%d,px_y=%d-%d,ref_px_x=%d-%d,ref_px_y=%d-%d", state->global->frame, state->tile->id, orig->x, orig->x + block_width, orig->y, orig->y + block_width,
+      PERFORMANCE_MEASURE_END(KVZ_PERF_SEARCHPX, state->encoder_control->threadqueue, "type=sad,step=large_hexbs,frame=%d,tile=%d,px_x=%d-%d,px_y=%d-%d,ref_px_x=%d-%d,ref_px_y=%d-%d", state->global->frame, state->tile->id, orig->x, orig->x + width, orig->y, orig->y + height,
                               (state->tile->lcu_offset_x * LCU_WIDTH) + orig->x + mv.x + pattern->x, 
-                              (state->tile->lcu_offset_x * LCU_WIDTH) + orig->x + mv.x + pattern->x + block_width, 
+                              (state->tile->lcu_offset_x * LCU_WIDTH) + orig->x + mv.x + pattern->x + width,
                               (state->tile->lcu_offset_y * LCU_WIDTH) + orig->y + mv.y + pattern->y, 
-                              (state->tile->lcu_offset_y * LCU_WIDTH) + orig->y + mv.y + pattern->y + block_width);
+                              (state->tile->lcu_offset_y * LCU_WIDTH) + orig->y + mv.y + pattern->y + height);
     }
 
     if (cost < best_cost) {
@@ -652,13 +691,13 @@
         cost = kvz_image_calc_sad(pic, ref, orig->x, orig->y,
                                (state->tile->lcu_offset_x * LCU_WIDTH) + orig->x + mv.x + offset->x,
                                (state->tile->lcu_offset_y * LCU_WIDTH) + orig->y + mv.y + offset->y,
-                               block_width, block_width, max_lcu_below);
-        cost += calc_mvd_cost(state, mv.x + offset->x, mv.y + offset->y, 2, mv_cand,merge_cand,num_cand,ref_idx, &bitcost);
-        PERFORMANCE_MEASURE_END(KVZ_PERF_SEARCHPX, state->encoder_control->threadqueue, "type=sad,step=large_hexbs_iterative,frame=%d,tile=%d,px_x=%d-%d,px_y=%d-%d,ref_px_x=%d-%d,ref_px_y=%d-%d", state->global->frame, state->tile->id, orig->x, orig->x + block_width, orig->y, orig->y + block_width,
+                               width, height, max_px_below_lcu);
+        cost += calc_mvd(state, mv.x + offset->x, mv.y + offset->y, 2, mv_cand, merge_cand, num_cand, ref_idx, &bitcost);
+        PERFORMANCE_MEASURE_END(KVZ_PERF_SEARCHPX, state->encoder_control->threadqueue, "type=sad,step=large_hexbs_iterative,frame=%d,tile=%d,px_x=%d-%d,px_y=%d-%d,ref_px_x=%d-%d,ref_px_y=%d-%d", state->global->frame, state->tile->id, orig->x, orig->x + width, orig->y, orig->y + height,
               (state->tile->lcu_offset_x * LCU_WIDTH) + orig->x + mv.x + offset->x, 
-              (state->tile->lcu_offset_x * LCU_WIDTH) + orig->x + mv.x + offset->x + block_width, 
+              (state->tile->lcu_offset_x * LCU_WIDTH) + orig->x + mv.x + offset->x + width,
               (state->tile->lcu_offset_y * LCU_WIDTH) + orig->y + mv.y + offset->y, 
-              (state->tile->lcu_offset_y * LCU_WIDTH) + orig->y + mv.y + offset->y + block_width);
+              (state->tile->lcu_offset_y * LCU_WIDTH) + orig->y + mv.y + offset->y + height);
       }
 
       if (cost < best_cost) {
@@ -684,13 +723,13 @@
       cost = kvz_image_calc_sad(pic, ref, orig->x, orig->y,
                              (state->tile->lcu_offset_x * LCU_WIDTH) + orig->x + mv.x + offset->x,
                              (state->tile->lcu_offset_y * LCU_WIDTH) + orig->y + mv.y + offset->y,
-                             block_width, block_width, max_lcu_below);
-      cost += calc_mvd_cost(state, mv.x + offset->x, mv.y + offset->y, 2, mv_cand,merge_cand,num_cand,ref_idx, &bitcost);
-      PERFORMANCE_MEASURE_END(KVZ_PERF_SEARCHPX, state->encoder_control->threadqueue, "type=sad,step=small_hexbs,frame=%d,tile=%d,px_x=%d-%d,px_y=%d-%d,ref_px_x=%d-%d,ref_px_y=%d-%d", state->global->frame, state->tile->id, orig->x, orig->x + block_width, orig->y, orig->y + block_width,
+                             width, height, max_px_below_lcu);
+      cost += calc_mvd(state, mv.x + offset->x, mv.y + offset->y, 2, mv_cand, merge_cand, num_cand, ref_idx, &bitcost);
+      PERFORMANCE_MEASURE_END(KVZ_PERF_SEARCHPX, state->encoder_control->threadqueue, "type=sad,step=small_hexbs,frame=%d,tile=%d,px_x=%d-%d,px_y=%d-%d,ref_px_x=%d-%d,ref_px_y=%d-%d", state->global->frame, state->tile->id, orig->x, orig->x + width, orig->y, orig->y + height,
             (state->tile->lcu_offset_x * LCU_WIDTH) + orig->x + mv.x + offset->x, 
-            (state->tile->lcu_offset_x * LCU_WIDTH) + orig->x + mv.x + offset->x + block_width, 
+            (state->tile->lcu_offset_x * LCU_WIDTH) + orig->x + mv.x + offset->x + width,
             (state->tile->lcu_offset_y * LCU_WIDTH) + orig->y + mv.y + offset->y, 
-            (state->tile->lcu_offset_y * LCU_WIDTH) + orig->y + mv.y + offset->y + block_width);
+            (state->tile->lcu_offset_y * LCU_WIDTH) + orig->y + mv.y + offset->y + height);
     }
 
     if (cost > 0 && cost < best_cost) {
@@ -714,21 +753,26 @@
 }
 
 
-#if SEARCH_MV_FULL_RADIUS
-static unsigned search_mv_full(unsigned depth,
-                               const picture *pic, const picture *ref,
-                               const vector2d *orig, vector2d *mv_in_out,
-                               int16_t mv_cand[2][2], int16_t merge_cand[MRG_MAX_NUM_CANDS][3],
+#define IME_FULL_SEARCH_RADIUS 32
+static unsigned search_mv_full(const encoder_state_t * const state,
+                               unsigned width, unsigned height,
+                               const kvz_picture *pic, const kvz_picture *ref,
+                               const vector2d_t *orig, vector2d_t *mv_in_out,
+                               int16_t mv_cand[2][2], inter_merge_cand_t merge_cand[MRG_MAX_NUM_CANDS],
                                int16_t num_cand, int32_t ref_idx, uint32_t *bitcost_out)
 {
-  vector2d mv = { mv_in_out->x >> 2, mv_in_out->y >> 2 };
-  int block_width = CU_WIDTH_FROM_DEPTH(depth);
+  vector2d_t mv = { mv_in_out->x >> 2, mv_in_out->y >> 2 };
   unsigned best_cost = UINT32_MAX;
-  int x, y;
   uint32_t best_bitcost = 0, bitcost;
-  vector2d min_mv, max_mv;
+  const int max_lcu_below = state->encoder_control->owf ? 1 : -1;
 
-  /*if (abs(mv.x) > SEARCH_MV_FULL_RADIUS || abs(mv.y) > SEARCH_MV_FULL_RADIUS) {
+  int (*calc_mvd)(const encoder_state_t * const,
+                  int, int, int,
+                  int16_t[2][2], inter_merge_cand_t[MRG_MAX_NUM_CANDS],
+                  int16_t, int32_t, uint32_t *) =
+    state->encoder_control->cfg->mv_rdo ? kvz_calc_mvd_cost_cabac : calc_mvd_cost;
+
+  /*if (abs(mv.x) > IME_FULL_SEARCH_RADIUS || abs(mv.y) > IME_FULL_SEARCH_RADIUS) {
     best_cost = calc_sad(pic, ref, orig->x, orig->y,
                          orig->x, orig->y,
                          block_width, block_width);
@@ -736,18 +780,23 @@
     mv.y = 0;
   }*/
 
-  min_mv.x = mv.x - SEARCH_MV_FULL_RADIUS;
-  min_mv.y = mv.y - SEARCH_MV_FULL_RADIUS;
-  max_mv.x = mv.x + SEARCH_MV_FULL_RADIUS;
-  max_mv.y = mv.y + SEARCH_MV_FULL_RADIUS;
-
-  for (y = min_mv.y; y < max_mv.y; ++y) {
-    for (x = min_mv.x; x < max_mv.x; ++x) {
-      unsigned cost = calc_sad(pic, ref, orig->x, orig->y,
-                               orig->x + x,
-                               orig->y + y,
-                               block_width, block_width);
-      cost += calc_mvd_cost(x, y, mv_cand,merge_cand,num_cand,ref_idx, &bitcost);
+  vector2d_t min_mv = {
+    mv.x - IME_FULL_SEARCH_RADIUS,
+    mv.y - IME_FULL_SEARCH_RADIUS,
+  };
+  vector2d_t max_mv = {
+    mv.x + IME_FULL_SEARCH_RADIUS,
+    mv.y + IME_FULL_SEARCH_RADIUS,
+  };
+
+  for (int y = min_mv.y; y < max_mv.y; ++y) {
+    for (int x = min_mv.x; x < max_mv.x; ++x) {
+      unsigned cost = kvz_image_calc_sad(pic, ref, orig->x, orig->y,
+                                         orig->x + x,
+                                         orig->y + y,
+                                         width, height,
+                                         max_lcu_below);
+      cost += calc_mvd(state, x, y, 2, mv_cand, merge_cand, num_cand, ref_idx, &bitcost);
       if (cost < best_cost) {
         best_cost    = cost;
         best_bitcost = bitcost;
@@ -764,13 +813,13 @@
 
   return best_cost;
 }
-#endif
 
 
 /**
  * \brief Do fractional motion estimation
  *
- * \param depth      log2 depth of the search
+ * \param width      width of the block
+ * \param height     height of the block
  * \param pic        Picture motion vector is searched for.
  * \param ref        Picture motion vector is searched from.
  * \param orig       Top left corner of the searched for block.
@@ -782,7 +831,7 @@
  * refines the search by searching best 1/4-pel postion around best 1/2-pel position.
  */
 static unsigned search_frac(const encoder_state_t * const state,
-                            unsigned depth,
+                            unsigned width, unsigned height,
                             const kvz_picture *pic, const kvz_picture *ref,
                             const vector2d_t *orig, vector2d_t *mv_in_out,
                             int16_t mv_cand[2][2], inter_merge_cand_t merge_cand[MRG_MAX_NUM_CANDS],
@@ -800,7 +849,6 @@
 
   //Set mv to halfpel precision
   vector2d_t mv = { mv_in_out->x >> 2, mv_in_out->y >> 2 };
-  int block_width = CU_WIDTH_FROM_DEPTH(depth);
   unsigned best_cost = UINT32_MAX;
   uint32_t best_bitcost = 0, bitcost;
   unsigned i;
@@ -808,8 +856,6 @@
 
   unsigned cost = 0;
 
-  cost_pixel_nxn_func *satd = kvz_pixels_get_satd_func(block_width);
-
   vector2d_t halfpel_offset;
 
   #define FILTER_SIZE 8
@@ -818,17 +864,24 @@
   kvz_extended_block src = { 0, 0, 0 };
 
   //destination buffer for interpolation
-  int dst_stride = (block_width+1)*4;
+  int dst_stride = (width + 1) * 4;
   kvz_pixel dst[(LCU_WIDTH+1) * (LCU_WIDTH+1) * 16];
   kvz_pixel* dst_off = &dst[dst_stride*4+4];
 
+  int(*calc_mvd)(const encoder_state_t * const, int, int, int,
+    int16_t[2][2], inter_merge_cand_t[MRG_MAX_NUM_CANDS],
+    int16_t, int32_t, uint32_t *) = calc_mvd_cost;
+  if (state->encoder_control->cfg->mv_rdo) {
+    calc_mvd = kvz_calc_mvd_cost_cabac;
+  }
+
   kvz_get_extended_block(orig->x, orig->y, mv.x-1, mv.y-1,
                 state->tile->lcu_offset_x * LCU_WIDTH,
                 state->tile->lcu_offset_y * LCU_WIDTH,
-                ref->y, ref->width, ref->height, FILTER_SIZE, block_width+1, block_width+1, &src);
+                ref->y, ref->width, ref->height, FILTER_SIZE, width+1, height+1, &src);
 
-  kvz_filter_inter_quarterpel_luma(state->encoder_control, src.orig_topleft, src.stride, block_width+1,
-      block_width+1, dst, dst_stride, 1, 1);
+  kvz_filter_inter_quarterpel_luma(state->encoder_control, src.orig_topleft, src.stride, width+1,
+      height+1, dst, dst_stride, 1, 1);
 
   if (src.malloc_used) free(src.buffer);
 
@@ -838,24 +891,26 @@
 
   kvz_pixel tmp_filtered[LCU_WIDTH*LCU_WIDTH];
   kvz_pixel tmp_pic[LCU_WIDTH*LCU_WIDTH];
-  kvz_pixels_blit(pic->y + orig->y*pic->width + orig->x, tmp_pic, block_width, block_width, pic->stride, block_width);
+  kvz_pixels_blit(pic->y + orig->y*pic->width + orig->x, tmp_pic, width, height, pic->stride, width);
 
   // Search halfpel positions around best integer mv
   for (i = 0; i < 9; ++i) {
     const vector2d_t *pattern = &square[i];
 
     int y,x;
-    for(y = 0; y < block_width; ++y) {
+    for(y = 0; y < height; ++y) {
       int dst_y = y*4+pattern->y*2;
-      for(x = 0; x < block_width; ++x) {
+      for(x = 0; x < width; ++x) {
         int dst_x = x*4+pattern->x*2;
-        tmp_filtered[y*block_width+x] = dst_off[dst_y*dst_stride+dst_x];
+        tmp_filtered[y*width+x] = dst_off[dst_y*dst_stride+dst_x];
       }
     }
 
-    cost = satd(tmp_pic,tmp_filtered);
+    cost = kvz_satd_any_size(width, height,
+                             tmp_pic, width,
+                             tmp_filtered, width);
 
-    cost += calc_mvd_cost(state, mv.x + pattern->x, mv.y + pattern->y, 1, mv_cand,merge_cand,num_cand,ref_idx, &bitcost);
+    cost += calc_mvd(state, mv.x + pattern->x, mv.y + pattern->y, 1, mv_cand, merge_cand, num_cand, ref_idx, &bitcost);
 
     if (cost < best_cost) {
       best_cost    = cost;
@@ -881,17 +936,19 @@
     const vector2d_t *pattern = &square[i];
 
     int y,x;
-    for(y = 0; y < block_width; ++y) {
+    for(y = 0; y < height; ++y) {
       int dst_y = y*4+halfpel_offset.y+pattern->y;
-      for(x = 0; x < block_width; ++x) {
+      for(x = 0; x < width; ++x) {
         int dst_x = x*4+halfpel_offset.x+pattern->x;
-        tmp_filtered[y*block_width+x] = dst_off[dst_y*dst_stride+dst_x];
+        tmp_filtered[y*width+x] = dst_off[dst_y*dst_stride+dst_x];
       }
     }
 
-    cost = satd(tmp_pic,tmp_filtered);
+    cost = kvz_satd_any_size(width, height,
+                             tmp_pic, width,
+                             tmp_filtered, width);
 
-    cost += calc_mvd_cost(state, mv.x + pattern->x, mv.y + pattern->y, 0, mv_cand,merge_cand,num_cand,ref_idx, &bitcost);
+    cost += calc_mvd(state, mv.x + pattern->x, mv.y + pattern->y, 0, mv_cand, merge_cand, num_cand, ref_idx, &bitcost);
 
     if (cost < best_cost) {
       best_cost    = cost;
@@ -914,151 +971,272 @@
 
 
 /**
- * Update lcu to have best modes at this depth.
- * \return Cost of best mode.
+ * \brief Perform inter search for a single reference frame.
  */
-int kvz_search_cu_inter(const encoder_state_t * const state, int x, int y, int depth, lcu_t *lcu)
+static void search_pu_inter_ref(const encoder_state_t * const state,
+                                int x, int y,
+                                int width, int height,
+                                int depth,
+                                lcu_t *lcu, cu_info_t *cur_cu,
+                                int16_t mv_cand[2][2],
+                                inter_merge_cand_t merge_cand[MRG_MAX_NUM_CANDS],
+                                int16_t num_cand,
+                                unsigned ref_idx,
+                                uint32_t(*get_mvd_cost)(vector2d_t *, cabac_data_t*))
 {
+  const int x_cu = x >> 3;
+  const int y_cu = y >> 3;
   const videoframe_t * const frame = state->tile->frame;
-  uint32_t ref_idx = 0;
-  int x_local = (x&0x3f), y_local = (y&0x3f);
-  int x_cu = x>>3;
-  int y_cu = y>>3;
-  int cu_pos = LCU_CU_OFFSET+(x_local>>3) + (y_local>>3)*LCU_T_CU_WIDTH;
+  kvz_picture *ref_image = state->global->ref->images[ref_idx];
+  uint32_t temp_bitcost = 0;
+  uint32_t temp_cost = 0;
+  vector2d_t orig, mvd;
+  int32_t merged = 0;
+  uint8_t cu_mv_cand = 0;
+  int8_t merge_idx = 0;
+  int8_t ref_list = state->global->refmap[ref_idx].list-1;
+  int8_t temp_ref_idx = cur_cu->inter.mv_ref[ref_list];
+  orig.x = x_cu * CU_MIN_SIZE_PIXELS;
+  orig.y = y_cu * CU_MIN_SIZE_PIXELS;
+  // Get MV candidates
+  cur_cu->inter.mv_ref[ref_list] = ref_idx;
+  kvz_inter_get_mv_cand(state, x, y, width, height, mv_cand, cur_cu, lcu, ref_list);
+  cur_cu->inter.mv_ref[ref_list] = temp_ref_idx;
+
+
+  vector2d_t mv = { 0, 0 };
+  {
+    // Take starting point for MV search from previous frame.
+    // When temporal motion vector candidates are added, there is probably
+    // no point to this anymore, but for now it helps.
+    // TODO: Update this to work with SMP/AMP blocks.
+    int mid_x_cu = (x + (width >> 1)) / 8;
+    int mid_y_cu = (y + (height >> 1)) / 8;
+    cu_info_t *ref_cu = &state->global->ref->cu_arrays[ref_idx]->data[mid_x_cu + mid_y_cu * (frame->width_in_lcu << MAX_DEPTH)];
+    if (ref_cu->type == CU_INTER) {
+      if (ref_cu->inter.mv_dir & 1) {
+        mv.x = ref_cu->inter.mv[0][0];
+        mv.y = ref_cu->inter.mv[0][1];
+      } else {
+        mv.x = ref_cu->inter.mv[1][0];
+        mv.y = ref_cu->inter.mv[1][1];
+      }
+    }
+  }
 
-  cu_info_t *cur_cu = &lcu->cu[cu_pos];
+  switch (state->encoder_control->cfg->ime_algorithm) {
+    case KVZ_IME_TZ:
+      temp_cost += tz_search(state,
+                             width, height,
+                             frame->source,
+                             ref_image,
+                             &orig,
+                             &mv,
+                             mv_cand,
+                             merge_cand,
+                             num_cand,
+                             ref_idx,
+                             &temp_bitcost);
+      break;
 
-  int16_t mv_cand[2][2];
-  // Search for merge mode candidate
-  inter_merge_cand_t merge_cand[MRG_MAX_NUM_CANDS];
-  // Get list of candidates
-  int16_t num_cand = kvz_inter_get_merge_cand(state, x, y, depth, merge_cand, lcu);
+    case KVZ_IME_FULL:
+      temp_cost += search_mv_full(state,
+                                  width, height,
+                                  frame->source,
+                                  ref_image,
+                                  &orig,
+                                  &mv,
+                                  mv_cand,
+                                  merge_cand,
+                                  num_cand,
+                                  ref_idx,
+                                  &temp_bitcost);
+      break;
 
-  int max_lcu_below = -1;
-  
-  if (state->encoder_control->owf) {
-    max_lcu_below = 1;
+    default:
+      temp_cost += hexagon_search(state,
+                                  width, height,
+                                  frame->source,
+                                  ref_image,
+                                  &orig,
+                                  &mv,
+                                  mv_cand,
+                                  merge_cand,
+                                  num_cand,
+                                  ref_idx,
+                                  &temp_bitcost);
+      break;
   }
 
-  // Default to candidate 0
-  cur_cu->inter.mv_cand[0] = 0;
-  cur_cu->inter.mv_cand[1] = 0;
+  if (state->encoder_control->cfg->fme_level > 0) {
+    temp_cost = search_frac(state,
+                            width, height,
+                            frame->source,
+                            ref_image,
+                            &orig,
+                            &mv,
+                            mv_cand,
+                            merge_cand,
+                            num_cand,
+                            ref_idx,
+                            &temp_bitcost);
+  }
 
-  cur_cu->inter.cost = UINT_MAX;
+  merged = 0;
+  // Check every candidate to find a match
+  for(merge_idx = 0; merge_idx < num_cand; merge_idx++) {
+    if (merge_cand[merge_idx].dir != 3 &&
+        merge_cand[merge_idx].mv[merge_cand[merge_idx].dir - 1][0] == mv.x &&
+        merge_cand[merge_idx].mv[merge_cand[merge_idx].dir - 1][1] == mv.y &&
+        (uint32_t)merge_cand[merge_idx].ref[merge_cand[merge_idx].dir - 1] == ref_idx) {
+      merged = 1;
+      break;
+    }
+  }
 
-  for (ref_idx = 0; ref_idx < state->global->ref->used_size; ref_idx++) {
-    kvz_picture *ref_image = state->global->ref->images[ref_idx];
-    uint32_t temp_bitcost = 0;
-    uint32_t temp_cost = 0;
-    vector2d_t orig, mvd;
-    int32_t merged = 0;
-    uint8_t cu_mv_cand = 0;
-    int8_t merge_idx = 0;
-    int8_t ref_list = state->global->refmap[ref_idx].list-1;
-    int8_t temp_ref_idx = cur_cu->inter.mv_ref[ref_list];
-    orig.x = x_cu * CU_MIN_SIZE_PIXELS;
-    orig.y = y_cu * CU_MIN_SIZE_PIXELS;
-    // Get MV candidates
-    cur_cu->inter.mv_ref[ref_list] = ref_idx;
-    kvz_inter_get_mv_cand(state, x, y, depth, mv_cand, cur_cu, lcu, ref_list);
-    cur_cu->inter.mv_ref[ref_list] = temp_ref_idx;
+  // Only check when candidates are different
+  if (!merged && (mv_cand[0][0] != mv_cand[1][0] || mv_cand[0][1] != mv_cand[1][1])) {
+    vector2d_t mvd_temp1, mvd_temp2;
+    int cand1_cost,cand2_cost;
 
-    vector2d_t mv = { 0, 0 };
-    {
-      // Take starting point for MV search from previous frame.
-      // When temporal motion vector candidates are added, there is probably
-      // no point to this anymore, but for now it helps.
-      int mid_x_cu = (x + (LCU_WIDTH >> (depth+1))) / 8;
-      int mid_y_cu = (y + (LCU_WIDTH >> (depth+1))) / 8;
-      cu_info_t *ref_cu = &state->global->ref->cu_arrays[ref_idx]->data[mid_x_cu + mid_y_cu * (frame->width_in_lcu << MAX_DEPTH)];
-      if (ref_cu->type == CU_INTER) {
-        if (ref_cu->inter.mv_dir & 1) {
-          mv.x = ref_cu->inter.mv[0][0];
-          mv.y = ref_cu->inter.mv[0][1];
-        } else {
-          mv.x = ref_cu->inter.mv[1][0];
-          mv.y = ref_cu->inter.mv[1][1];
-        }
-      }
-    }
+    mvd_temp1.x = mv.x - mv_cand[0][0];
+    mvd_temp1.y = mv.y - mv_cand[0][1];
+    cand1_cost = get_mvd_cost(&mvd_temp1, (cabac_data_t*)&state->cabac);
 
-#if SEARCH_MV_FULL_RADIUS
-    temp_cost += search_mv_full(depth, frame, ref_pic, &orig, &mv, mv_cand, merge_cand, num_cand, ref_idx, &temp_bitcost);
-#else
-    switch (state->encoder_control->cfg->ime_algorithm) {
-      case KVZ_IME_TZ:
-        temp_cost += tz_search(state, depth, frame->source, ref_image, &orig, &mv, mv_cand, merge_cand, num_cand, ref_idx, &temp_bitcost);
-        break;
+    mvd_temp2.x = mv.x - mv_cand[1][0];
+    mvd_temp2.y = mv.y - mv_cand[1][1];
+    cand2_cost = get_mvd_cost(&mvd_temp2, (cabac_data_t*)&state->cabac);
 
-      default:
-        temp_cost += hexagon_search(state, depth, frame->source, ref_image, &orig, &mv, mv_cand, merge_cand, num_cand, ref_idx, &temp_bitcost);
-        break;
-      }
-#endif
-    if (state->encoder_control->cfg->fme_level > 0) {
-      temp_cost = search_frac(state, depth, frame->source, ref_image, &orig, &mv, mv_cand, merge_cand, num_cand, ref_idx, &temp_bitcost);
+    // Select candidate 1 if it has lower cost
+    if (cand2_cost < cand1_cost) {
+      cu_mv_cand = 1;
     }
+  }
+  mvd.x = mv.x - mv_cand[cu_mv_cand][0];
+  mvd.y = mv.y - mv_cand[cu_mv_cand][1];
 
-    merged = 0;
-    // Check every candidate to find a match
-    for(merge_idx = 0; merge_idx < num_cand; merge_idx++) {
-      if (merge_cand[merge_idx].dir != 3 &&
-          merge_cand[merge_idx].mv[merge_cand[merge_idx].dir - 1][0] == mv.x &&
-          merge_cand[merge_idx].mv[merge_cand[merge_idx].dir - 1][1] == mv.y &&          
-          (uint32_t)merge_cand[merge_idx].ref[merge_cand[merge_idx].dir - 1] == ref_idx) {
-        merged = 1;
-        break;
-      }
-    }
+  if(temp_cost < cur_cu->inter.cost) {
 
-    // Only check when candidates are different
-    if (!merged && (mv_cand[0][0] != mv_cand[1][0] || mv_cand[0][1] != mv_cand[1][1])) {
-      vector2d_t mvd_temp1, mvd_temp2;
-      int cand1_cost,cand2_cost;
+    // Map reference index to L0/L1 pictures
+    cur_cu->inter.mv_dir = ref_list+1;
+    cur_cu->inter.mv_ref_coded[ref_list] = state->global->refmap[ref_idx].idx;
 
-      mvd_temp1.x = mv.x - mv_cand[0][0];
-      mvd_temp1.y = mv.y - mv_cand[0][1];
-      cand1_cost = get_mvd_coding_cost(&mvd_temp1);
+    cur_cu->merged        = merged;
+    cur_cu->merge_idx     = merge_idx;
+    cur_cu->inter.mv_ref[ref_list] = ref_idx;
+    cur_cu->inter.mv[ref_list][0] = (int16_t)mv.x;
+    cur_cu->inter.mv[ref_list][1] = (int16_t)mv.y;
+    cur_cu->inter.mvd[ref_list][0] = (int16_t)mvd.x;
+    cur_cu->inter.mvd[ref_list][1] = (int16_t)mvd.y;
+    cur_cu->inter.cost    = temp_cost;
+    cur_cu->inter.bitcost = temp_bitcost + cur_cu->inter.mv_dir - 1 + cur_cu->inter.mv_ref_coded[ref_list];
+    cur_cu->inter.mv_cand[ref_list] = cu_mv_cand;
+  }
+}
 
-      mvd_temp2.x = mv.x - mv_cand[1][0];
-      mvd_temp2.y = mv.y - mv_cand[1][1];
-      cand2_cost = get_mvd_coding_cost(&mvd_temp2);
 
-      // Select candidate 1 if it has lower cost
-      if (cand2_cost < cand1_cost) {
-        cu_mv_cand = 1;
-      }
+/**
+ * \brief Update PU to have best modes at this depth.
+ *
+ * \param state       encoder state
+ * \param x_cu        x-coordinate of the containing CU
+ * \param y_cu        y-coordinate of the containing CU
+ * \param depth       depth of the CU in the quadtree
+ * \param part_mode   partition mode of the CU
+ * \param i_pu        index of the PU in the CU
+ * \param lcu         containing LCU
+ *
+ * \return            cost of the best mode
+ */
+static int search_pu_inter(const encoder_state_t * const state,
+                           int x_cu, int y_cu,
+                           int depth,
+                           part_mode_t part_mode,
+                           int i_pu,
+                           lcu_t *lcu)
+{
+  const videoframe_t * const frame = state->tile->frame;
+  const int width_cu  = LCU_WIDTH >> depth;
+  const int x         = PU_GET_X(part_mode, width_cu, x_cu, i_pu);
+  const int y         = PU_GET_Y(part_mode, width_cu, y_cu, i_pu);
+  const int width     = PU_GET_W(part_mode, width_cu, i_pu);
+  const int height    = PU_GET_H(part_mode, width_cu, i_pu);
+
+  // Merge candidate A1 may not be used for the second PU of Nx2N, nLx2N and
+  // nRx2N partitions.
+  const bool merge_a1 = i_pu == 0 || width >= height;
+  // Merge candidate B1 may not be used for the second PU of 2NxN, 2NxnU and
+  // 2NxnD partitions.
+  const bool merge_b1 = i_pu == 0 || width <= height;
+
+  const int x_local   = SUB_SCU(x);
+  const int y_local   = SUB_SCU(y);
+  cu_info_t *cur_cu   = LCU_GET_CU_AT_PX(lcu, x_local, y_local);
+
+  int16_t mv_cand[2][2];
+  // Search for merge mode candidate
+  inter_merge_cand_t merge_cand[MRG_MAX_NUM_CANDS];
+  // Get list of candidates
+  int16_t num_cand = kvz_inter_get_merge_cand(state,
+                                              x, y,
+                                              width, height,
+                                              merge_a1, merge_b1,
+                                              merge_cand,
+                                              lcu);
+
+  uint32_t(*get_mvd_cost)(vector2d_t *, cabac_data_t*) = get_mvd_coding_cost;
+  if (state->encoder_control->cfg->mv_rdo) {
+    get_mvd_cost = kvz_get_mvd_coding_cost_cabac;
+  }
+
+  int max_px_below_lcu = -1;
+  if (state->encoder_control->owf) {
+    max_px_below_lcu = LCU_WIDTH;
+    if (state->encoder_control->fme_level > 0) {
+      // Fractional motion estimation can change the mv by at most 1 pixel.
+      max_px_below_lcu -= 1;
     }
-    mvd.x = mv.x - mv_cand[cu_mv_cand][0];
-    mvd.y = mv.y - mv_cand[cu_mv_cand][1];
-
-    if(temp_cost < cur_cu->inter.cost) {
-
-      // Map reference index to L0/L1 pictures
-      cur_cu->inter.mv_dir = ref_list+1;
-      cur_cu->inter.mv_ref_coded[ref_list] = state->global->refmap[ref_idx].idx;
-
-      cur_cu->merged        = merged;
-      cur_cu->merge_idx     = merge_idx;
-      cur_cu->inter.mv_ref[ref_list] = ref_idx;
-      cur_cu->inter.mv[ref_list][0] = (int16_t)mv.x;
-      cur_cu->inter.mv[ref_list][1] = (int16_t)mv.y;
-      cur_cu->inter.mvd[ref_list][0] = (int16_t)mvd.x;
-      cur_cu->inter.mvd[ref_list][1] = (int16_t)mvd.y;
-      cur_cu->inter.cost    = temp_cost;
-      cur_cu->inter.bitcost = temp_bitcost + cur_cu->inter.mv_dir - 1 + cur_cu->inter.mv_ref_coded[ref_list];
-      cur_cu->inter.mv_cand[ref_list] = cu_mv_cand;
+    if (state->encoder_control->deblock_enable) {
+      // Strong deblock filter modifies 3 pixels.
+      max_px_below_lcu -= 3;
     }
   }
 
+  // Default to candidate 0
+  cur_cu->inter.mv_cand[0] = 0;
+  cur_cu->inter.mv_cand[1] = 0;
+
+  cur_cu->inter.cost = UINT_MAX;
+
+  uint32_t ref_idx;
+  for (ref_idx = 0; ref_idx < state->global->ref->used_size; ref_idx++) {
+    search_pu_inter_ref(state,
+                        x, y,
+                        width, height,
+                        depth,
+                        lcu, cur_cu,
+                        mv_cand, merge_cand, num_cand,
+                        ref_idx,
+                        get_mvd_cost);
+  }
+
   // Search bi-pred positions
   if (state->global->slicetype == KVZ_SLICE_B && state->encoder_control->cfg->bipred) {
     lcu_t *templcu = MALLOC(lcu_t, 1);
-    cost_pixel_nxn_func *satd = kvz_pixels_get_satd_func(LCU_WIDTH >> depth);
+    unsigned cu_width = LCU_WIDTH >> depth;
     #define NUM_PRIORITY_LIST 12;
     static const uint8_t priorityList0[] = { 0, 1, 0, 2, 1, 2, 0, 3, 1, 3, 2, 3 };
     static const uint8_t priorityList1[] = { 1, 0, 2, 0, 2, 1, 3, 0, 3, 1, 3, 2 };
     uint8_t cutoff = num_cand;
+
+
+    int(*calc_mvd)(const encoder_state_t * const, int, int, int,
+      int16_t[2][2], inter_merge_cand_t[MRG_MAX_NUM_CANDS],
+      int16_t, int32_t, uint32_t *) = calc_mvd_cost;
+    if (state->encoder_control->cfg->mv_rdo) {
+      calc_mvd = kvz_calc_mvd_cost_cabac;
+    }
+
     for (int32_t idx = 0; idx<cutoff*(cutoff - 1); idx++) {
       uint8_t i = priorityList0[idx];
       uint8_t j = priorityList1[idx];
@@ -1084,7 +1262,7 @@
           mv[1][1] = merge_cand[j].mv[1][1];
 
           // Check boundaries when using owf to process multiple frames at the same time
-          if (max_lcu_below >= 0) {
+          if (max_px_below_lcu >= 0) {
             // When SAO is off, row is considered reconstructed when the last LCU
             // is done, although the bottom 2 pixels might still need deblocking.
             // To work around this, add 2 luma pixels to the reach of the mv
@@ -1092,25 +1270,33 @@
             int mv_lcu_row_reach_1 = ((y+(mv[0][1]>>2)) + (LCU_WIDTH >> depth) - 1 + 2) / LCU_WIDTH;
             int mv_lcu_row_reach_2 = ((y+(mv[1][1]>>2)) + (LCU_WIDTH >> depth) - 1 + 2) / LCU_WIDTH;
             int cur_lcu_row = y / LCU_WIDTH;
-            if (mv_lcu_row_reach_1 > cur_lcu_row + max_lcu_below || mv_lcu_row_reach_2 > cur_lcu_row + max_lcu_below) {
+            if (mv_lcu_row_reach_1 > cur_lcu_row + max_px_below_lcu || mv_lcu_row_reach_2 > cur_lcu_row + max_px_below_lcu) {
               continue;
             }
           }
 
-          kvz_inter_recon_lcu_bipred(state, state->global->ref->images[merge_cand[i].ref[0]], state->global->ref->images[merge_cand[j].ref[1]], x, y, LCU_WIDTH >> depth, mv, templcu);
-
-          for (int ypos = 0; ypos < LCU_WIDTH >> depth; ++ypos) {
-            int dst_y = ypos*(LCU_WIDTH >> depth);
-            for (int xpos = 0; xpos < (LCU_WIDTH >> depth); ++xpos) {
-              tmp_block[dst_y + xpos] = templcu->rec.y[((y + ypos)&(LCU_WIDTH - 1))*LCU_WIDTH + ((x + xpos)&(LCU_WIDTH - 1))];              
+          kvz_inter_recon_lcu_bipred(state,
+                                     state->global->ref->images[merge_cand[i].ref[0]],
+                                     state->global->ref->images[merge_cand[j].ref[1]],
+                                     x, y,
+                                     width,
+                                     height,
+                                     mv,
+                                     templcu);
+
+          for (int ypos = 0; ypos < height; ++ypos) {
+            int dst_y = ypos * width;
+            for (int xpos = 0; xpos < width; ++xpos) {
+              tmp_block[dst_y + xpos] = templcu->rec.y[
+                SUB_SCU(y + ypos) * LCU_WIDTH + SUB_SCU(x + xpos)];
               tmp_pic[dst_y + xpos] = frame->source->y[x + xpos + (y + ypos)*frame->source->width];
             }
           }
 
-          cost = satd(tmp_pic, tmp_block);
+          cost = kvz_satd_any_size(cu_width, cu_width, tmp_pic, cu_width, tmp_block, cu_width);
 
-          cost += calc_mvd_cost(state, merge_cand[i].mv[0][0], merge_cand[i].mv[0][1], 0, mv_cand, merge_cand, 0, ref_idx, &bitcost[0]);
-          cost += calc_mvd_cost(state, merge_cand[i].mv[1][0], merge_cand[i].mv[1][1], 0, mv_cand, merge_cand, 0, ref_idx, &bitcost[1]);
+          cost += calc_mvd(state, merge_cand[i].mv[0][0], merge_cand[i].mv[0][1], 0, mv_cand, merge_cand, 0, ref_idx, &bitcost[0]);
+          cost += calc_mvd(state, merge_cand[i].mv[1][0], merge_cand[i].mv[1][1], 0, mv_cand, merge_cand, 0, ref_idx, &bitcost[1]);
 
           if (cost < cur_cu->inter.cost) {
 
@@ -1147,18 +1333,18 @@
             // Each motion vector has its own candidate
             for (int reflist = 0; reflist < 2; reflist++) {
               cu_mv_cand = 0;
-              kvz_inter_get_mv_cand(state, x, y, depth, mv_cand, cur_cu, lcu, reflist);
+              kvz_inter_get_mv_cand(state, x, y, width, height, mv_cand, cur_cu, lcu, reflist);
               if ((mv_cand[0][0] != mv_cand[1][0] || mv_cand[0][1] != mv_cand[1][1])) {
                 vector2d_t mvd_temp1, mvd_temp2;
                 int cand1_cost, cand2_cost;
 
                 mvd_temp1.x = cur_cu->inter.mv[reflist][0] - mv_cand[0][0];
                 mvd_temp1.y = cur_cu->inter.mv[reflist][1] - mv_cand[0][1];
-                cand1_cost = get_mvd_coding_cost(&mvd_temp1);
+                cand1_cost = get_mvd_cost(&mvd_temp1, (cabac_data_t*)&state->cabac);
 
                 mvd_temp2.x = cur_cu->inter.mv[reflist][0] - mv_cand[1][0];
                 mvd_temp2.y = cur_cu->inter.mv[reflist][1] - mv_cand[1][1];
-                cand2_cost = get_mvd_coding_cost(&mvd_temp2);
+                cand2_cost = get_mvd_cost(&mvd_temp2, (cabac_data_t*)&state->cabac);
 
                 // Select candidate 1 if it has lower cost
                 if (cand2_cost < cand1_cost) {
@@ -1180,3 +1366,74 @@
 
   return cur_cu->inter.cost;
 }
+
+
+/**
+ * \brief Update CU to have best modes at this depth.
+ *
+ * Only searches the 2Nx2N partition mode.
+ *
+ * \param state       encoder state
+ * \param x           x-coordinate of the CU
+ * \param y           y-coordinate of the CU
+ * \param depth       depth of the CU in the quadtree
+ * \param lcu         containing LCU
+ *
+ * \return            cost of the best mode
+ */
+int kvz_search_cu_inter(const encoder_state_t * const state, int x, int y, int depth, lcu_t *lcu)
+{
+  return search_pu_inter(state, x, y, depth, SIZE_2Nx2N, 0, lcu);
+}
+
+
+/**
+ * \brief Update CU to have best modes at this depth.
+ *
+ * Only searches the given partition mode.
+ *
+ * \param state       encoder state
+ * \param x           x-coordinate of the CU
+ * \param y           y-coordinate of the CU
+ * \param depth       depth of the CU in the quadtree
+ * \param part_mode   partition mode to search
+ * \param lcu         containing LCU
+ *
+ * \return            cost of the best mode
+ */
+int kvz_search_cu_smp(const encoder_state_t * const state,
+                      int x, int y,
+                      int depth,
+                      part_mode_t part_mode,
+                      lcu_t *lcu)
+{
+  const int num_pu    = kvz_part_mode_num_parts[part_mode];
+  const int width_scu = (LCU_WIDTH >> depth) >> MAX_DEPTH;
+  const int y_scu     = SUB_SCU(y) >> MAX_DEPTH;
+  const int x_scu     = SUB_SCU(x) >> MAX_DEPTH;
+
+  int cost = 0;
+  for (int i = 0; i < num_pu; ++i) {
+    const int x_pu      = PU_GET_X(part_mode, width_scu, x_scu, i);
+    const int y_pu      = PU_GET_Y(part_mode, width_scu, y_scu, i);
+    const int width_pu  = PU_GET_W(part_mode, width_scu, i);
+    const int height_pu = PU_GET_H(part_mode, width_scu, i);
+    cu_info_t *cur_pu   = LCU_GET_CU(lcu, x_pu, y_pu);
+
+    cur_pu->type = CU_INTER;
+    cur_pu->part_size = part_mode;
+    cur_pu->depth = depth;
+
+    cost += search_pu_inter(state, x, y, depth, part_mode, i, lcu);
+
+    for (int y = y_pu; y < y_pu + height_pu; ++y) {
+      for (int x = x_pu; x < x_pu + width_pu; ++x) {
+        cu_info_t *scu = LCU_GET_CU(lcu, x, y);
+        scu->type = CU_INTER;
+        memcpy(&scu->inter, &cur_pu->inter, sizeof(cur_pu->inter));
+      }
+    }
+  }
+
+  return cost;
+}

kvazaar-0.7.2.tar.gz/src/search_inter.h -> kvazaar-0.8.1.tar.gz/src/search_inter.h Changed

kvazaar-0.7.2.tar.gz/src/search_intra.c -> kvazaar-0.8.1.tar.gz/src/search_intra.c Changed

@@ -18,10 +18,6 @@
 * with Kvazaar.  If not, see <http://www.gnu.org/licenses/>.
 ****************************************************************************/
 
-/*
-* \file
-*/
-
 #include "search_intra.h"
 
 #include "encoderstate.h"
@@ -122,6 +118,51 @@
 
 
 /**
+ * \brief Calculate quality of the reconstruction.
+ *
+ * \param a  bc
+ *
+ * \return  
+ */
+static void get_cost_dual(encoder_state_t * const state, 
+                       const pred_buffer preds, const kvz_pixel *orig_block,
+                       cost_pixel_nxn_multi_func *satd_twin_func,
+                       cost_pixel_nxn_multi_func *sad_twin_func,
+                       int width, double *costs_out)
+{
+  #define PARALLEL_BLKS 2
+  unsigned satd_costs[PARALLEL_BLKS] = { 0 };
+  satd_twin_func(preds, orig_block, PARALLEL_BLKS, satd_costs);
+  costs_out[0] = (double)satd_costs[0];
+  costs_out[1] = (double)satd_costs[1];
+
+  if (TRSKIP_RATIO != 0 && width == 4 && state->encoder_control->trskip_enable) {
+    // If the mode looks better with SAD than SATD it might be a good
+    // candidate for transform skip. How much better SAD has to be is
+    // controlled by TRSKIP_RATIO.
+
+    // Add the offset bit costs of signaling 'luma and chroma use trskip',
+    // versus signaling 'luma and chroma don't use trskip' to the SAD cost.
+    const cabac_ctx_t *ctx = &state->cabac.ctx.transform_skip_model_luma;
+    double trskip_bits = CTX_ENTROPY_FBITS(ctx, 1) - CTX_ENTROPY_FBITS(ctx, 0);
+    ctx = &state->cabac.ctx.transform_skip_model_chroma;
+    trskip_bits += 2.0 * (CTX_ENTROPY_FBITS(ctx, 1) - CTX_ENTROPY_FBITS(ctx, 0));
+
+    unsigned unsigned_sad_costs[PARALLEL_BLKS] = { 0 };
+    double sad_costs[PARALLEL_BLKS] = { 0 };
+    sad_twin_func(preds, orig_block, PARALLEL_BLKS, unsigned_sad_costs);
+    for (int i = 0; i < PARALLEL_BLKS; ++i) {
+      sad_costs[i] = TRSKIP_RATIO * (double)unsigned_sad_costs[i] + state->global->cur_lambda_cost_sqrt * trskip_bits;
+      if (sad_costs[i] < (double)satd_costs[i]) {
+        costs_out[i] = sad_costs[i];
+      }
+    }
+  }
+
+  #undef PARALLEL_BLKS
+}
+
+/**
 * \brief Perform search for best intra transform split configuration.
 *
 * This function does a recursive search for the best intra transform split
@@ -145,8 +186,8 @@
   const int width_c = width > TR_MIN_WIDTH ? width / 2 : width;
 
   const int offset = width / 2;
-  const vector2d_t lcu_px = { x_px & 0x3f, y_px & 0x3f };
-  cu_info_t *const tr_cu = &lcu->cu[LCU_CU_OFFSET + (lcu_px.x >> 3) + (lcu_px.y >> 3)*LCU_T_CU_WIDTH];
+  const vector2d_t lcu_px = { SUB_SCU(x_px), SUB_SCU(y_px) };
+  cu_info_t *const tr_cu = LCU_GET_CU_AT_PX(lcu, lcu_px.x, lcu_px.y);
 
   const bool reconstruct_chroma = !(x_px & 4 || y_px & 4);
 
@@ -314,12 +355,14 @@
 
 
 /**
- * \brief  Order the intra prediction modes according to a fast criteria.
+ * \brief  Order the intra prediction modes according to a fast criteria. 
  *
  * This function uses SATD to order the intra prediction modes. For 4x4 modes
  * SAD might be used instead, if the cost given by SAD is much better than the
  * one given by SATD, to take into account that 4x4 modes can be coded with
- * transform skip.
+ * transform skip. This version of the function calculates two costs
+ * simultaneously to better utilize large SIMD registers with AVX and newer
+ * extensions.
  *
  * The modes are searched using halving search and the total number of modes
  * that are tried is dependent on size of the predicted block. More modes
@@ -327,7 +370,7 @@
  *
  * \param orig  Pointer to the top-left corner of current CU in the picture
  *     being encoded.
- * \param orig_stride  Stride of param orig.
+ * \param orig_stride  Stride of param orig..
  * \param rec  Pointer to the top-left corner of current CU in the picture
  *     being encoded.
  * \param rec_stride  Stride of param rec.
@@ -347,14 +390,17 @@
                                  int log2_width, int8_t *intra_preds,
                                  int8_t modes[35], double costs[35])
 {
+  #define PARALLEL_BLKS 2 // TODO: use 4 for AVX-512 in the future?
   assert(log2_width >= 2 && log2_width <= 5);
   int_fast8_t width = 1 << log2_width;
   cost_pixel_nxn_func *satd_func = kvz_pixels_get_satd_func(width);
   cost_pixel_nxn_func *sad_func = kvz_pixels_get_sad_func(width);
+  cost_pixel_nxn_multi_func *satd_dual_func = kvz_pixels_get_satd_dual_func(width);
+  cost_pixel_nxn_multi_func *sad_dual_func = kvz_pixels_get_sad_dual_func(width);
 
   // Temporary block arrays
-  kvz_pixel _pred[32 * 32 + SIMD_ALIGNMENT];
-  kvz_pixel *pred = ALIGNED_POINTER(_pred, SIMD_ALIGNMENT);
+  kvz_pixel _preds[PARALLEL_BLKS * 32 * 32 + SIMD_ALIGNMENT];
+  pred_buffer preds = ALIGNED_POINTER(_preds, SIMD_ALIGNMENT);
   
   kvz_pixel _orig_block[32 * 32 + SIMD_ALIGNMENT];
   kvz_pixel *orig_block = ALIGNED_POINTER(_orig_block, SIMD_ALIGNMENT);
@@ -378,15 +424,25 @@
 
   // Calculate SAD for evenly spaced modes to select the starting point for 
   // the recursive search.
-  for (int mode = 2; mode <= 34; mode += offset) {
-    kvz_intra_predict(refs, log2_width, mode, COLOR_Y, pred);
-    costs[modes_selected] = get_cost(state, pred, orig_block, satd_func, sad_func, width);
-    modes[modes_selected] = mode;
-
-    min_cost = MIN(min_cost, costs[modes_selected]);
-    max_cost = MAX(max_cost, costs[modes_selected]);
-
-    ++modes_selected;
+  for (int mode = 2; mode <= 34; mode += PARALLEL_BLKS * offset) {
+    
+    double costs_out[PARALLEL_BLKS] = { 0 };
+    for (int i = 0; i < PARALLEL_BLKS; ++i) {
+      if (mode + i * offset <= 34) kvz_intra_predict(refs, log2_width, mode + i * offset, COLOR_Y, preds[i]);
+    }
+    
+    //TODO: add generic version of get cost  multi
+    get_cost_dual(state, preds, orig_block, satd_dual_func, sad_dual_func, width, costs_out);
+
+    for (int i = 0; i < PARALLEL_BLKS; ++i) {
+      if (mode + i * offset <= 34) {
+        costs[modes_selected] = costs_out[i];
+        modes[modes_selected] = mode + i * offset;
+        min_cost = MIN(min_cost, costs[modes_selected]);
+        max_cost = MAX(max_cost, costs[modes_selected]);
+        ++modes_selected;
+      }
+    }
   }
 
   int8_t best_mode = modes[select_best_mode_index(modes, costs, modes_selected)];
@@ -400,28 +456,32 @@
       offset >>= 1;
 
       int8_t center_node = best_mode;
-      int8_t mode = center_node - offset;
-      if (mode >= 2) {
-        kvz_intra_predict(refs, log2_width, mode, COLOR_Y, pred);
-        costs[modes_selected] = get_cost(state, pred, orig_block, satd_func, sad_func, width);
-        modes[modes_selected] = mode;
-        if (costs[modes_selected] < best_cost) {
-          best_cost = costs[modes_selected];
-          best_mode = modes[modes_selected];
+      int8_t test_modes[] = { center_node - offset, center_node + offset };
+
+      double costs_out[PARALLEL_BLKS] = { 0 };
+      char mode_in_range = 0;
+
+      for (int i = 0; i < PARALLEL_BLKS; ++i) mode_in_range |= (test_modes[i] >= 2 && test_modes[i] <= 34);
+
+      if (mode_in_range) {
+        for (int i = 0; i < PARALLEL_BLKS; ++i) {
+          if (test_modes[i] >= 2 && test_modes[i] <= 34) kvz_intra_predict(refs, log2_width, test_modes[i], COLOR_Y, preds[i]);
         }
-        ++modes_selected;
-      }
 
-      mode = center_node + offset;
-      if (mode <= 34) {
-        kvz_intra_predict(refs, log2_width, mode, COLOR_Y, pred);
-        costs[modes_selected] = get_cost(state, pred, orig_block, satd_func, sad_func, width);
-        modes[modes_selected] = mode;
-        if (costs[modes_selected] < best_cost) {
-          best_cost = costs[modes_selected];
-          best_mode = modes[modes_selected];
+        //TODO: add generic version of get cost multi
+        get_cost_dual(state, preds, orig_block, satd_dual_func, sad_dual_func, width, costs_out);
+
+        for (int i = 0; i < PARALLEL_BLKS; ++i) {
+          if (test_modes[i] >= 2 && test_modes[i] <= 34) {
+            costs[modes_selected] = costs_out[i];
+            modes[modes_selected] = test_modes[i];
+            if (costs[modes_selected] < best_cost) {
+              best_cost = costs[modes_selected];
+              best_mode = modes[modes_selected];
+            }
+            ++modes_selected;
+          }
         }
-        ++modes_selected;
       }
     }
   }
@@ -441,8 +501,8 @@
     }
 
     if (!has_mode) {
-      kvz_intra_predict(refs, log2_width, mode, COLOR_Y, pred);
-      costs[modes_selected] = get_cost(state, pred, orig_block, satd_func, sad_func, width);
+      kvz_intra_predict(refs, log2_width, mode, COLOR_Y, preds[0]);
+      costs[modes_selected] = get_cost(state, preds[0], orig_block, satd_func, sad_func, width);
       modes[modes_selected] = mode;
       ++modes_selected;
     }
@@ -455,10 +515,11 @@
     costs[mode_i] += lambda_cost * kvz_luma_mode_bits(state, modes[mode_i], intra_preds);
   }
 
+  #undef PARALLEL_BLKS
+
   return modes_selected;
 }
 
-
 /**
  * \brief  Find best intra mode out of the ones listed in parameter modes.
  *
@@ -609,8 +670,8 @@
   const bool reconstruct_chroma = !(x_px & 4 || y_px & 4);
 
   if (reconstruct_chroma) {
-    const vector2d_t lcu_px = { x_px & 0x3f, y_px & 0x3f };
-    cu_info_t *const tr_cu = &lcu->cu[LCU_CU_OFFSET + (lcu_px.x >> 3) + (lcu_px.y >> 3)*LCU_T_CU_WIDTH];
+    const vector2d_t lcu_px = { SUB_SCU(x_px), SUB_SCU(y_px) };
+    cu_info_t *const tr_cu = LCU_GET_CU_AT_PX(lcu, lcu_px.x, lcu_px.y);
 
     struct {
       double cost;
@@ -645,11 +706,10 @@
                               const int x_px, const int y_px,
                               const int depth, lcu_t *lcu)
 {
-  const vector2d_t lcu_px = { x_px & 0x3f, y_px & 0x3f };
+  const vector2d_t lcu_px = { SUB_SCU(x_px), SUB_SCU(y_px) };
   const vector2d_t lcu_cu = { lcu_px.x >> 3, lcu_px.y >> 3 };
-  const int cu_index = LCU_CU_OFFSET + lcu_cu.x + lcu_cu.y * LCU_T_CU_WIDTH;
 
-  cu_info_t *cur_cu = &lcu->cu[cu_index];
+  cu_info_t *cur_cu = LCU_GET_CU(lcu, lcu_cu.x, lcu_cu.y);
   int8_t intra_mode = cur_cu->intra[PU_INDEX(x_px >> 2, y_px >> 2)].mode;
 
   double costs[5];
@@ -710,13 +770,12 @@
                            const int x_px, const int y_px,
                            const int depth, lcu_t *lcu)
 {
-  const vector2d_t lcu_px = { x_px & 0x3f, y_px & 0x3f };
+  const vector2d_t lcu_px = { SUB_SCU(x_px), SUB_SCU(y_px) };
   const vector2d_t lcu_cu = { lcu_px.x >> 3, lcu_px.y >> 3 };
   const int8_t cu_width = (LCU_WIDTH >> (depth));
-  const int cu_index = LCU_CU_OFFSET + lcu_cu.x + lcu_cu.y * LCU_T_CU_WIDTH;
   const int_fast8_t log2_width = LOG2_LCU_WIDTH - depth;
 
-  cu_info_t *cur_cu = &lcu->cu[cu_index];
+  cu_info_t *cur_cu = LCU_GET_CU(lcu, lcu_cu.x, lcu_cu.y);
 
   kvz_intra_references refs;
 
@@ -728,10 +787,10 @@
   // Select left and top CUs if they are available.
   // Top CU is not available across LCU boundary.
   if ((x_px >> 3) > 0) {
-    left_cu = &lcu->cu[cu_index - 1];
+    left_cu = LCU_GET_CU(lcu, lcu_cu.x - 1, lcu_cu.y);
   }
   if ((y_px >> 3) > 0 && lcu_cu.y != 0) {
-    above_cu = &lcu->cu[cu_index - LCU_T_CU_WIDTH];
+    above_cu = LCU_GET_CU(lcu, lcu_cu.x, lcu_cu.y - 1);
   }
   kvz_intra_get_dir_luma_predictor(x_px, y_px, candidate_modes, cur_cu, left_cu, above_cu);

kvazaar-0.7.2.tar.gz/src/search_intra.h -> kvazaar-0.8.1.tar.gz/src/search_intra.h Changed

kvazaar-0.7.2.tar.gz/src/strategies/altivec/picture-altivec.c -> kvazaar-0.8.1.tar.gz/src/strategies/altivec/picture-altivec.c Changed

kvazaar-0.7.2.tar.gz/src/strategies/altivec/picture-altivec.h -> kvazaar-0.8.1.tar.gz/src/strategies/altivec/picture-altivec.h Changed

kvazaar-0.7.2.tar.gz/src/strategies/avx2/dct-avx2.h -> kvazaar-0.8.1.tar.gz/src/strategies/avx2/dct-avx2.h Changed

kvazaar-0.7.2.tar.gz/src/strategies/avx2/intra-avx2.c -> kvazaar-0.8.1.tar.gz/src/strategies/avx2/intra-avx2.c Changed

@@ -18,10 +18,6 @@
  * with Kvazaar.  If not, see <http://www.gnu.org/licenses/>.
  ****************************************************************************/
 
-/*
- * \file
- */
-
 #include <stdlib.h>
 
 #include "intra-avx2.h"
@@ -60,7 +56,7 @@
  * \param sample_disp   Sample displacement per row
  * \param vertical_mode Mode direction, true if vertical
  */
-void filter_4x4_avx2(kvz_pixel *dst, const kvz_pixel *ref_main, int sample_disp, bool vertical_mode){
+static void filter_4x4_avx2(kvz_pixel *dst, const kvz_pixel *ref_main, int sample_disp, bool vertical_mode){
 
   __m128i row0 = filter_4x1_avx2(ref_main, 1 * sample_disp, 0);
   __m128i row1 = filter_4x1_avx2(ref_main, 2 * sample_disp, 0);
@@ -199,7 +195,7 @@
  * \param sample_disp   Sample displacement per row
  * \param vertical_mode Mode direction, true if vertical
  */
-void filter_16x16_avx2(kvz_pixel *dst, const kvz_pixel *ref_main, int sample_disp, bool vertical_mode){
+static void filter_16x16_avx2(kvz_pixel *dst, const kvz_pixel *ref_main, int sample_disp, bool vertical_mode){
   for (int y = 0; y < 16; y += 8) {
     __m256i row0 = filter_16x1_avx2(ref_main, (y + 1) * sample_disp, 0);
     __m256i row1 = filter_16x1_avx2(ref_main, (y + 2) * sample_disp, 0);
@@ -291,7 +287,7 @@
  * \param vertical_mode Mode direction, true if vertical
  * \param width         Block width
  */
-void filter_NxN_avx2(kvz_pixel *dst, const kvz_pixel *ref_main, int sample_disp, bool vertical_mode, int width){
+static void filter_NxN_avx2(kvz_pixel *dst, const kvz_pixel *ref_main, int sample_disp, bool vertical_mode, int width){
   for (int y = 0; y < width; y += 8) {
     for (int x = 0; x < width; x += 16) {
       __m256i row0 = filter_16x1_avx2(ref_main, (y + 1) * sample_disp, x);
@@ -464,6 +460,67 @@
   }
 }
 
+
+/**
+ * \brief Generate planar prediction.
+ * \param log2_width    Log2 of width, range 2..5.
+ * \param in_ref_above  Pointer to -1 index of above reference, length=width*2+1.
+ * \param in_ref_left   Pointer to -1 index of left reference, length=width*2+1.
+ * \param dst           Buffer of size width*width.
+ */
+static void kvz_intra_pred_planar_avx2(
+  const int_fast8_t log2_width,
+  const kvz_pixel *const ref_top,
+  const kvz_pixel *const ref_left,
+  kvz_pixel *const dst)
+{
+  assert(log2_width >= 2 && log2_width <= 5);
+
+  const int_fast8_t width = 1 << log2_width;
+  const kvz_pixel top_right = ref_top[width + 1];
+  const kvz_pixel bottom_left = ref_left[width + 1];
+
+  if (log2_width > 2) {
+    
+    __m128i v_width = _mm_set1_epi16(width);
+    __m128i v_top_right = _mm_set1_epi16(top_right);
+    __m128i v_bottom_left = _mm_set1_epi16(bottom_left);
+
+    for (int y = 0; y < width; ++y) {
+
+      __m128i x_plus_1 = _mm_setr_epi16(-7, -6, -5, -4, -3, -2, -1, 0);
+      __m128i v_ref_left = _mm_set1_epi16(ref_left[y + 1]);
+      __m128i y_plus_1 = _mm_set1_epi16(y + 1);
+
+      for (int x = 0; x < width; x += 8) {
+        x_plus_1 = _mm_add_epi16(x_plus_1, _mm_set1_epi16(8));
+        __m128i v_ref_top = _mm_loadl_epi64((__m128i*)&(ref_top[x + 1]));
+        v_ref_top = _mm_cvtepu8_epi16(v_ref_top);
+
+        __m128i hor = _mm_add_epi16(_mm_mullo_epi16(_mm_sub_epi16(v_width, x_plus_1), v_ref_left), _mm_mullo_epi16(x_plus_1, v_top_right));
+        __m128i ver = _mm_add_epi16(_mm_mullo_epi16(_mm_sub_epi16(v_width, y_plus_1), v_ref_top), _mm_mullo_epi16(y_plus_1, v_bottom_left));
+
+        //dst[y * width + x] = ho
+
+        __m128i chunk = _mm_srli_epi16(_mm_add_epi16(_mm_add_epi16(ver, hor), v_width), (log2_width + 1));
+        chunk = _mm_packus_epi16(chunk, chunk);
+        _mm_storel_epi64((__m128i*)&(dst[y * width + x]), chunk);
+      }
+    }
+
+  } else {
+    // Unoptimized version for reference.
+    for (int y = 0; y < width; ++y) {
+      for (int x = 0; x < width; ++x) {
+        int_fast16_t hor = (width - 1 - x) * ref_left[y + 1] + (x + 1) * top_right;
+        int_fast16_t ver = (width - 1 - y) * ref_top[x + 1] + (y + 1) * bottom_left;
+        dst[y * width + x] = (ver + hor + width) >> (log2_width + 1);
+      }
+    }
+  }
+}
+
+
 #endif //COMPILE_INTEL_AVX2 && defined X86_64
 
 int kvz_strategy_register_intra_avx2(void* opaque, uint8_t bitdepth)
@@ -472,6 +529,7 @@
 #if COMPILE_INTEL_AVX2 && defined X86_64
   if (bitdepth == 8) {
     success &= kvz_strategyselector_register(opaque, "angular_pred", "avx2", 40, &kvz_angular_pred_avx2);
+    success &= kvz_strategyselector_register(opaque, "intra_pred_planar", "avx2", 40, &kvz_intra_pred_planar_avx2);
   }
 #endif //COMPILE_INTEL_AVX2 && defined X86_64
   return success;

kvazaar-0.7.2.tar.gz/src/strategies/avx2/intra-avx2.h -> kvazaar-0.8.1.tar.gz/src/strategies/avx2/intra-avx2.h Changed

kvazaar-0.7.2.tar.gz/src/strategies/avx2/ipol-avx2.c -> kvazaar-0.8.1.tar.gz/src/strategies/avx2/ipol-avx2.c Changed

@@ -44,17 +44,17 @@
 extern int8_t kvz_g_luma_filter[4][8];
 extern int8_t kvz_g_chroma_filter[8][4];
 
-void kvz_eight_tap_filter_x8_and_flip(__m128i data01, __m128i data23, __m128i data45, __m128i data67, __m128i* filter, __m128i* dst)
+void kvz_eight_tap_filter_x8_and_flip(__m128i *data01, __m128i *data23, __m128i *data45, __m128i *data67, __m128i *filter, __m128i *dst)
 {
   __m128i a, b, c, d;
   __m128i fir = _mm_broadcastq_epi64(_mm_loadl_epi64(filter));
 
-  a = _mm_maddubs_epi16(data01, fir);
-  b = _mm_maddubs_epi16(data23, fir);
+  a = _mm_maddubs_epi16(*data01, fir);
+  b = _mm_maddubs_epi16(*data23, fir);
   a = _mm_hadd_epi16(a, b);
 
-  c = _mm_maddubs_epi16(data45, fir);
-  d = _mm_maddubs_epi16(data67, fir);
+  c = _mm_maddubs_epi16(*data45, fir);
+  d = _mm_maddubs_epi16(*data67, fir);
   c = _mm_hadd_epi16(c, d);
 
   a = _mm_hadd_epi16(a, c);
@@ -62,17 +62,17 @@
   _mm_storeu_si128(dst, a);
 }
 
-__m128i kvz_eight_tap_filter_x4_and_flip_16bit(__m128i data0, __m128i data1, __m128i data2, __m128i data3, __m128i* filter)
+__m128i kvz_eight_tap_filter_x4_and_flip_16bit(__m128i *data0, __m128i *data1, __m128i *data2, __m128i *data3, __m128i *filter)
 {
   __m128i a, b, c, d;
   __m128i fir = _mm_cvtepi8_epi16(_mm_loadu_si128((__m128i*)(filter)));
 
-  a = _mm_madd_epi16(data0, fir);
-  b = _mm_madd_epi16(data1, fir);
+  a = _mm_madd_epi16(*data0, fir);
+  b = _mm_madd_epi16(*data1, fir);
   a = _mm_hadd_epi32(a, b);
 
-  c = _mm_madd_epi16(data2, fir);
-  d = _mm_madd_epi16(data3, fir);
+  c = _mm_madd_epi16(*data2, fir);
+  d = _mm_madd_epi16(*data3, fir);
   c = _mm_hadd_epi32(c, d);
 
   a = _mm_hadd_epi32(a, c);
@@ -98,10 +98,10 @@
 
   //Filter rows
   const int dst_stride = MAX_WIDTH;
-  kvz_eight_tap_filter_x8_and_flip(rows01, rows23, rows45, rows67, (__m128i*)(&filter[0]), (__m128i*)(dst + 0));
-  kvz_eight_tap_filter_x8_and_flip(rows01, rows23, rows45, rows67, (__m128i*)(&filter[1]), (__m128i*)(dst + 1 * dst_stride));
-  kvz_eight_tap_filter_x8_and_flip(rows01, rows23, rows45, rows67, (__m128i*)(&filter[2]), (__m128i*)(dst + 2 * dst_stride));
-  kvz_eight_tap_filter_x8_and_flip(rows01, rows23, rows45, rows67, (__m128i*)(&filter[3]), (__m128i*)(dst + 3 * dst_stride));
+  kvz_eight_tap_filter_x8_and_flip(&rows01, &rows23, &rows45, &rows67, (__m128i*)(&filter[0]), (__m128i*)(dst + 0));
+  kvz_eight_tap_filter_x8_and_flip(&rows01, &rows23, &rows45, &rows67, (__m128i*)(&filter[1]), (__m128i*)(dst + 1 * dst_stride));
+  kvz_eight_tap_filter_x8_and_flip(&rows01, &rows23, &rows45, &rows67, (__m128i*)(&filter[2]), (__m128i*)(dst + 2 * dst_stride));
+  kvz_eight_tap_filter_x8_and_flip(&rows01, &rows23, &rows45, &rows67, (__m128i*)(&filter[3]), (__m128i*)(dst + 3 * dst_stride));
 }
 
 static INLINE void eight_tap_filter_and_flip_16bit_avx2(int8_t filter[4][8], int16_t *src, int16_t src_stride, int offset, int combined_shift, kvz_pixel* __restrict dst, int16_t dst_stride)
@@ -119,10 +119,10 @@
     int32_t array[4];
   } temp[4];
 
-  temp[0].vector = kvz_eight_tap_filter_x4_and_flip_16bit(row0, row1, row2, row3, (__m128i*)(&filter[0]));
-  temp[1].vector = kvz_eight_tap_filter_x4_and_flip_16bit(row0, row1, row2, row3, (__m128i*)(&filter[1]));
-  temp[2].vector = kvz_eight_tap_filter_x4_and_flip_16bit(row0, row1, row2, row3, (__m128i*)(&filter[2]));
-  temp[3].vector = kvz_eight_tap_filter_x4_and_flip_16bit(row0, row1, row2, row3, (__m128i*)(&filter[3]));
+  temp[0].vector = kvz_eight_tap_filter_x4_and_flip_16bit(&row0, &row1, &row2, &row3, (__m128i*)(&filter[0]));
+  temp[1].vector = kvz_eight_tap_filter_x4_and_flip_16bit(&row0, &row1, &row2, &row3, (__m128i*)(&filter[1]));
+  temp[2].vector = kvz_eight_tap_filter_x4_and_flip_16bit(&row0, &row1, &row2, &row3, (__m128i*)(&filter[2]));
+  temp[3].vector = kvz_eight_tap_filter_x4_and_flip_16bit(&row0, &row1, &row2, &row3, (__m128i*)(&filter[3]));
 
   __m128i packed_offset = _mm_set1_epi32(offset);
 
@@ -502,7 +502,7 @@
   int sample_out_of_bounds = out_of_bounds_y || out_of_bounds_x;
 
   if (sample_out_of_bounds){
-    out->buffer = MALLOC(kvz_pixel, (width + filter_size) * (width + filter_size));
+    out->buffer = MALLOC(kvz_pixel, (width + filter_size) * (height + filter_size));
     if (!out->buffer){
       fprintf(stderr, "Memory allocation failed!\n");
       assert(0);
@@ -521,7 +521,7 @@
       coord_y *= ref_width;
 
       if (!out_of_bounds_x){
-        memcpy(&out->buffer[dst_y*(width + filter_size) + 0], &ref[coord_y + min_x], (width + filter_size) * sizeof(kvz_pixel));
+        memcpy(&out->buffer[dst_y * out->stride + 0], &ref[coord_y + min_x], out->stride * sizeof(kvz_pixel));
       } else {
         for (dst_x = 0, x = (xpos)-half_filter_size; x < ((xpos + width)) + half_filter_size; dst_x++, x++) {
 
@@ -529,7 +529,7 @@
           coord_x = CLIP(0, (ref_width)-1, coord_x);
 
           // Store source block data (with extended borders)
-          out->buffer[dst_y*(width + filter_size) + dst_x] = ref[coord_y + coord_x];
+          out->buffer[dst_y * out->stride + dst_x] = ref[coord_y + coord_x];
         }
       }
     }

kvazaar-0.7.2.tar.gz/src/strategies/avx2/ipol-avx2.h -> kvazaar-0.8.1.tar.gz/src/strategies/avx2/ipol-avx2.h Changed

kvazaar-0.7.2.tar.gz/src/strategies/avx2/picture-avx2.c -> kvazaar-0.8.1.tar.gz/src/strategies/avx2/picture-avx2.c Changed

@@ -137,7 +137,7 @@
   return m256i_horizontal_sum(sum0);
 }
 
-static unsigned satd_8bit_4x4_avx2(const kvz_pixel *org, const kvz_pixel *cur)
+static unsigned satd_4x4_8bit_avx2(const kvz_pixel *org, const kvz_pixel *cur)
 {
 
   __m128i original = _mm_cvtepu8_epi16(_mm_loadl_epi64((__m128i*)org));
@@ -181,39 +181,152 @@
   return satd;
 }
 
-static void hor_add_sub_avx2(__m128i *row0, __m128i *row1){
 
-  __m128i a = _mm_hadd_epi16(*row0, *row1);
-  __m128i b = _mm_hsub_epi16(*row0, *row1);
+static void satd_8bit_4x4_dual_avx2(
+  const pred_buffer preds, const kvz_pixel * const orig, unsigned num_modes, unsigned *satds_out) 
+{
+
+  __m256i original = _mm256_broadcastsi128_si256(_mm_cvtepu8_epi16(_mm_loadl_epi64((__m128i*)orig)));
+  __m256i pred = _mm256_cvtepu8_epi16(_mm_loadl_epi64((__m128i*)preds[0]));
+  pred = _mm256_inserti128_si256(pred, _mm_cvtepu8_epi16(_mm_loadl_epi64((__m128i*)preds[1])), 1);
+
+  __m256i diff_lo = _mm256_sub_epi16(pred, original);
+
+  original = _mm256_broadcastsi128_si256(_mm_cvtepu8_epi16(_mm_loadl_epi64((__m128i*)(orig + 8))));
+  pred = _mm256_cvtepu8_epi16(_mm_loadl_epi64((__m128i*)(preds[0] + 8)));
+  pred = _mm256_inserti128_si256(pred, _mm_cvtepu8_epi16(_mm_loadl_epi64((__m128i*)(preds[1] + 8))), 1);
+
+  __m256i diff_hi = _mm256_sub_epi16(pred, original);
+
+  //Hor
+  __m256i row0 = _mm256_hadd_epi16(diff_lo, diff_hi);
+  __m256i row1 = _mm256_hsub_epi16(diff_lo, diff_hi);
+
+  __m256i row2 = _mm256_hadd_epi16(row0, row1);
+  __m256i row3 = _mm256_hsub_epi16(row0, row1);
+
+  //Ver
+  row0 = _mm256_hadd_epi16(row2, row3);
+  row1 = _mm256_hsub_epi16(row2, row3);
 
-  __m128i c = _mm_hadd_epi16(a, b);
-  __m128i d = _mm_hsub_epi16(a, b);
+  row2 = _mm256_hadd_epi16(row0, row1);
+  row3 = _mm256_hsub_epi16(row0, row1);
 
-  *row0 = _mm_hadd_epi16(c, d);
-  *row1 = _mm_hsub_epi16(c, d);
+  //Abs and sum
+  row2 = _mm256_abs_epi16(row2);
+  row3 = _mm256_abs_epi16(row3);
+
+  row3 = _mm256_add_epi16(row2, row3);
+
+  row3 = _mm256_add_epi16(row3, _mm256_shuffle_epi32(row3, KVZ_PERMUTE(2, 3, 0, 1) ));
+  row3 = _mm256_add_epi16(row3, _mm256_shuffle_epi32(row3, KVZ_PERMUTE(1, 0, 1, 0) ));
+  row3 = _mm256_add_epi16(row3, _mm256_shufflelo_epi16(row3, KVZ_PERMUTE(1, 0, 1, 0) ));
+
+  unsigned sum1 = _mm_extract_epi16(_mm256_castsi256_si128(row3), 0);
+  sum1 = (sum1 + 1) >> 1;
+
+  unsigned sum2 = _mm_extract_epi16(_mm256_extracti128_si256(row3, 1), 0);
+  sum2 = (sum2 + 1) >> 1;
+
+  satds_out[0] = sum1;
+  satds_out[1] = sum2;
 }
 
-static INLINE void ver_add_sub_avx2(__m128i temp_hor[8], __m128i temp_ver[8]){
+static INLINE void hor_transform_row_avx2(__m128i* row){
+  
+  __m128i mask_pos = _mm_set1_epi16(1);
+  __m128i mask_neg = _mm_set1_epi16(-1);
+  __m128i sign_mask = _mm_unpacklo_epi64(mask_pos, mask_neg);
+  __m128i temp = _mm_shuffle_epi32(*row, KVZ_PERMUTE(2, 3, 0, 1));
+  *row = _mm_sign_epi16(*row, sign_mask);
+  *row = _mm_add_epi16(*row, temp);
+
+  sign_mask = _mm_unpacklo_epi32(mask_pos, mask_neg);
+  temp = _mm_shuffle_epi32(*row, KVZ_PERMUTE(1, 0, 3, 2));
+  *row = _mm_sign_epi16(*row, sign_mask);
+  *row = _mm_add_epi16(*row, temp);
+
+  sign_mask = _mm_unpacklo_epi16(mask_pos, mask_neg);
+  temp = _mm_shufflelo_epi16(*row, KVZ_PERMUTE(1,0,3,2));
+  temp = _mm_shufflehi_epi16(temp, KVZ_PERMUTE(1,0,3,2));
+  *row = _mm_sign_epi16(*row, sign_mask);
+  *row = _mm_add_epi16(*row, temp);
+}
 
-  // First stage
-  for (int i = 0; i < 8; i += 2){
-    temp_ver[i+0] = _mm_hadd_epi16(temp_hor[i + 0], temp_hor[i + 1]);
-    temp_ver[i+1] = _mm_hsub_epi16(temp_hor[i + 0], temp_hor[i + 1]);
-  }
+static INLINE void hor_transform_row_dual_avx2(__m256i* row){
+  
+  __m256i mask_pos = _mm256_set1_epi16(1);
+  __m256i mask_neg = _mm256_set1_epi16(-1);
+  __m256i sign_mask = _mm256_unpacklo_epi64(mask_pos, mask_neg);
+  __m256i temp = _mm256_shuffle_epi32(*row, KVZ_PERMUTE(2, 3, 0, 1));
+  *row = _mm256_sign_epi16(*row, sign_mask);
+  *row = _mm256_add_epi16(*row, temp);
+
+  sign_mask = _mm256_unpacklo_epi32(mask_pos, mask_neg);
+  temp = _mm256_shuffle_epi32(*row, KVZ_PERMUTE(1, 0, 3, 2));
+  *row = _mm256_sign_epi16(*row, sign_mask);
+  *row = _mm256_add_epi16(*row, temp);
+
+  sign_mask = _mm256_unpacklo_epi16(mask_pos, mask_neg);
+  temp = _mm256_shufflelo_epi16(*row, KVZ_PERMUTE(1,0,3,2));
+  temp = _mm256_shufflehi_epi16(temp, KVZ_PERMUTE(1,0,3,2));
+  *row = _mm256_sign_epi16(*row, sign_mask);
+  *row = _mm256_add_epi16(*row, temp);
+}
 
-  // Second stage
-  for (int i = 0; i < 8; i += 4){
-    temp_hor[i + 0] = _mm_add_epi16(temp_ver[i + 0], temp_ver[i + 2]);
-    temp_hor[i + 1] = _mm_add_epi16(temp_ver[i + 1], temp_ver[i + 3]);
-    temp_hor[i + 2] = _mm_sub_epi16(temp_ver[i + 0], temp_ver[i + 2]);
-    temp_hor[i + 3] = _mm_sub_epi16(temp_ver[i + 1], temp_ver[i + 3]);
-  }
+static INLINE void add_sub_avx2(__m128i *out, __m128i *in, unsigned out_idx0, unsigned out_idx1, unsigned in_idx0, unsigned in_idx1)
+{
+  out[out_idx0] = _mm_add_epi16(in[in_idx0], in[in_idx1]);
+  out[out_idx1] = _mm_sub_epi16(in[in_idx0], in[in_idx1]);
+}
 
-  // Third stage
-  for (int i = 0; i < 4; ++i){
-    temp_ver[i + 0] = _mm_add_epi16(temp_hor[0 + i], temp_hor[4 + i]);
-    temp_ver[i + 4] = _mm_sub_epi16(temp_hor[0 + i], temp_hor[4 + i]);
-  }
+static INLINE void ver_transform_block_avx2(__m128i (*rows)[8]){
+
+  __m128i temp0[8];
+  add_sub_avx2(temp0, (*rows), 0, 1, 0, 1);
+  add_sub_avx2(temp0, (*rows), 2, 3, 2, 3);
+  add_sub_avx2(temp0, (*rows), 4, 5, 4, 5);
+  add_sub_avx2(temp0, (*rows), 6, 7, 6, 7);
+
+  __m128i temp1[8];
+  add_sub_avx2(temp1, temp0, 0, 1, 0, 2);
+  add_sub_avx2(temp1, temp0, 2, 3, 1, 3);
+  add_sub_avx2(temp1, temp0, 4, 5, 4, 6);
+  add_sub_avx2(temp1, temp0, 6, 7, 5, 7);
+
+  add_sub_avx2((*rows), temp1, 0, 1, 0, 4);
+  add_sub_avx2((*rows), temp1, 2, 3, 1, 5);
+  add_sub_avx2((*rows), temp1, 4, 5, 2, 6);
+  add_sub_avx2((*rows), temp1, 6, 7, 3, 7);
+  
+}
+
+static INLINE void add_sub_dual_avx2(__m256i *out, __m256i *in, unsigned out_idx0, unsigned out_idx1, unsigned in_idx0, unsigned in_idx1)
+{
+  out[out_idx0] = _mm256_add_epi16(in[in_idx0], in[in_idx1]);
+  out[out_idx1] = _mm256_sub_epi16(in[in_idx0], in[in_idx1]);
+}
+
+
+static INLINE void ver_transform_block_dual_avx2(__m256i (*rows)[8]){
+
+  __m256i temp0[8];
+  add_sub_dual_avx2(temp0, (*rows), 0, 1, 0, 1);
+  add_sub_dual_avx2(temp0, (*rows), 2, 3, 2, 3);
+  add_sub_dual_avx2(temp0, (*rows), 4, 5, 4, 5);
+  add_sub_dual_avx2(temp0, (*rows), 6, 7, 6, 7);
+
+  __m256i temp1[8];
+  add_sub_dual_avx2(temp1, temp0, 0, 1, 0, 2);
+  add_sub_dual_avx2(temp1, temp0, 2, 3, 1, 3);
+  add_sub_dual_avx2(temp1, temp0, 4, 5, 4, 6);
+  add_sub_dual_avx2(temp1, temp0, 6, 7, 5, 7);
+
+  add_sub_dual_avx2((*rows), temp1, 0, 1, 0, 4);
+  add_sub_dual_avx2((*rows), temp1, 2, 3, 1, 5);
+  add_sub_dual_avx2((*rows), temp1, 4, 5, 2, 6);
+  add_sub_dual_avx2((*rows), temp1, 6, 7, 3, 7);
+  
 }
 
 INLINE static void haddwd_accumulate_avx2(__m128i *accumulate, __m128i *ver_row)
@@ -222,6 +335,12 @@
   *accumulate = _mm_add_epi32(*accumulate, _mm_madd_epi16(abs_value, _mm_set1_epi16(1)));
 }
 
+INLINE static void haddwd_accumulate_dual_avx2(__m256i *accumulate, __m256i *ver_row)
+{
+  __m256i abs_value = _mm256_abs_epi16(*ver_row);
+  *accumulate = _mm256_add_epi32(*accumulate, _mm256_madd_epi16(abs_value, _mm256_set1_epi16(1)));
+}
+
 INLINE static unsigned sum_block_avx2(__m128i *ver_row)
 {
   __m128i sad = _mm_setzero_si128();
@@ -240,6 +359,25 @@
   return _mm_cvtsi128_si32(sad);
 }
 
+INLINE static void sum_block_dual_avx2(__m256i *ver_row, unsigned *sum0, unsigned *sum1)
+{
+  __m256i sad = _mm256_setzero_si256();
+  haddwd_accumulate_dual_avx2(&sad, ver_row + 0);
+  haddwd_accumulate_dual_avx2(&sad, ver_row + 1);
+  haddwd_accumulate_dual_avx2(&sad, ver_row + 2);
+  haddwd_accumulate_dual_avx2(&sad, ver_row + 3); 
+  haddwd_accumulate_dual_avx2(&sad, ver_row + 4);
+  haddwd_accumulate_dual_avx2(&sad, ver_row + 5);
+  haddwd_accumulate_dual_avx2(&sad, ver_row + 6);
+  haddwd_accumulate_dual_avx2(&sad, ver_row + 7);
+
+  sad = _mm256_add_epi32(sad, _mm256_shuffle_epi32(sad, KVZ_PERMUTE(2, 3, 0, 1)));
+  sad = _mm256_add_epi32(sad, _mm256_shuffle_epi32(sad, KVZ_PERMUTE(1, 0, 1, 0)));
+
+  *sum0 = _mm_cvtsi128_si32(_mm256_extracti128_si256(sad, 0));
+  *sum1 = _mm_cvtsi128_si32(_mm256_extracti128_si256(sad, 1));
+}
+
 INLINE static __m128i diff_row_avx2(const kvz_pixel *buf1, const kvz_pixel *buf2)
 {
   __m128i buf1_row = _mm_cvtepu8_epi16(_mm_loadl_epi64((__m128i*)buf1));
@@ -247,76 +385,241 @@
   return _mm_sub_epi16(buf1_row, buf2_row);
 }
 
-INLINE static void diff_blocks_and_hor_transform_avx2(__m128i row_diff[8], const kvz_pixel * buf1, unsigned stride1, const kvz_pixel * buf2, unsigned stride2)
+INLINE static __m256i diff_row_dual_avx2(const kvz_pixel *buf1, const kvz_pixel *buf2, const kvz_pixel *orig)
 {
-  row_diff[0] = diff_row_avx2(buf1 + 0 * stride1, buf2 + 0 * stride2);
-  row_diff[1] = diff_row_avx2(buf1 + 1 * stride1, buf2 + 1 * stride2);
-  hor_add_sub_avx2(row_diff + 0, row_diff + 1);
+  __m128i temp1 = _mm_loadl_epi64((__m128i*)buf1);
+  __m128i temp2 = _mm_loadl_epi64((__m128i*)buf2);
+  __m128i temp3 = _mm_loadl_epi64((__m128i*)orig);
+  __m256i buf1_row = _mm256_cvtepu8_epi16(_mm_unpacklo_epi64(temp1, temp2));
+  __m256i buf2_row = _mm256_cvtepu8_epi16(_mm_broadcastq_epi64(temp3));
 
-  row_diff[2] = diff_row_avx2(buf1 + 2 * stride1, buf2 + 2 * stride2);
-  row_diff[3] = diff_row_avx2(buf1 + 3 * stride1, buf2 + 3 * stride2);
-  hor_add_sub_avx2(row_diff + 2, row_diff + 3);
+  return _mm256_sub_epi16(buf1_row, buf2_row);
+}
 
-  row_diff[4] = diff_row_avx2(buf1 + 4 * stride1, buf2 + 4 * stride2);
-  row_diff[5] = diff_row_avx2(buf1 + 5 * stride1, buf2 + 5 * stride2);
-  hor_add_sub_avx2(row_diff + 4, row_diff + 5);
+INLINE static void diff_blocks_avx2(__m128i (*row_diff)[8],
+                                                           const kvz_pixel * buf1, unsigned stride1,
+                                                           const kvz_pixel * orig, unsigned stride_orig)
+{
+  (*row_diff)[0] = diff_row_avx2(buf1 + 0 * stride1, orig + 0 * stride_orig);
+  (*row_diff)[1] = diff_row_avx2(buf1 + 1 * stride1, orig + 1 * stride_orig);
+  (*row_diff)[2] = diff_row_avx2(buf1 + 2 * stride1, orig + 2 * stride_orig);
+  (*row_diff)[3] = diff_row_avx2(buf1 + 3 * stride1, orig + 3 * stride_orig);
+  (*row_diff)[4] = diff_row_avx2(buf1 + 4 * stride1, orig + 4 * stride_orig);
+  (*row_diff)[5] = diff_row_avx2(buf1 + 5 * stride1, orig + 5 * stride_orig);
+  (*row_diff)[6] = diff_row_avx2(buf1 + 6 * stride1, orig + 6 * stride_orig);
+  (*row_diff)[7] = diff_row_avx2(buf1 + 7 * stride1, orig + 7 * stride_orig);
 
-  row_diff[6] = diff_row_avx2(buf1 + 6 * stride1, buf2 + 6 * stride2);
-  row_diff[7] = diff_row_avx2(buf1 + 7 * stride1, buf2 + 7 * stride2);
-  hor_add_sub_avx2(row_diff + 6, row_diff + 7);
 }
 
-static unsigned kvz_satd_8bit_8x8_general_avx2(const kvz_pixel * buf1, unsigned stride1, const kvz_pixel * buf2, unsigned stride2)
+INLINE static void diff_blocks_dual_avx2(__m256i (*row_diff)[8],
+                                                           const kvz_pixel * buf1, unsigned stride1,
+                                                           const kvz_pixel * buf2, unsigned stride2,
+                                                           const kvz_pixel * orig, unsigned stride_orig)
 {
-  __m128i temp_hor[8];
-  __m128i temp_ver[8];
+  (*row_diff)[0] = diff_row_dual_avx2(buf1 + 0 * stride1, buf2 + 0 * stride2, orig + 0 * stride_orig);
+  (*row_diff)[1] = diff_row_dual_avx2(buf1 + 1 * stride1, buf2 + 1 * stride2, orig + 1 * stride_orig);
+  (*row_diff)[2] = diff_row_dual_avx2(buf1 + 2 * stride1, buf2 + 2 * stride2, orig + 2 * stride_orig);
+  (*row_diff)[3] = diff_row_dual_avx2(buf1 + 3 * stride1, buf2 + 3 * stride2, orig + 3 * stride_orig);
+  (*row_diff)[4] = diff_row_dual_avx2(buf1 + 4 * stride1, buf2 + 4 * stride2, orig + 4 * stride_orig);
+  (*row_diff)[5] = diff_row_dual_avx2(buf1 + 5 * stride1, buf2 + 5 * stride2, orig + 5 * stride_orig);
+  (*row_diff)[6] = diff_row_dual_avx2(buf1 + 6 * stride1, buf2 + 6 * stride2, orig + 6 * stride_orig);
+  (*row_diff)[7] = diff_row_dual_avx2(buf1 + 7 * stride1, buf2 + 7 * stride2, orig + 7 * stride_orig);
 
-  diff_blocks_and_hor_transform_avx2(temp_hor, buf1, stride1, buf2, stride2);
+}
 
-  ver_add_sub_avx2(temp_hor, temp_ver);
+INLINE static void hor_transform_block_avx2(__m128i (*row_diff)[8])
+{
+  hor_transform_row_avx2((*row_diff) + 0);
+  hor_transform_row_avx2((*row_diff) + 1);
+  hor_transform_row_avx2((*row_diff) + 2);
+  hor_transform_row_avx2((*row_diff) + 3);
+  hor_transform_row_avx2((*row_diff) + 4);
+  hor_transform_row_avx2((*row_diff) + 5);
+  hor_transform_row_avx2((*row_diff) + 6);
+  hor_transform_row_avx2((*row_diff) + 7);
+}
+
+INLINE static void hor_transform_block_dual_avx2(__m256i (*row_diff)[8])
+{
+  hor_transform_row_dual_avx2((*row_diff) + 0);
+  hor_transform_row_dual_avx2((*row_diff) + 1);
+  hor_transform_row_dual_avx2((*row_diff) + 2);
+  hor_transform_row_dual_avx2((*row_diff) + 3);
+  hor_transform_row_dual_avx2((*row_diff) + 4);
+  hor_transform_row_dual_avx2((*row_diff) + 5);
+  hor_transform_row_dual_avx2((*row_diff) + 6);
+  hor_transform_row_dual_avx2((*row_diff) + 7);
+}
+
+static unsigned satd_8x8_subblock_8bit_avx2(const kvz_pixel * buf1, unsigned stride1, const kvz_pixel * buf2, unsigned stride2)
+{
+  __m128i temp[8];
+
+  diff_blocks_avx2(&temp, buf1, stride1, buf2, stride2);
+  hor_transform_block_avx2(&temp);
+  ver_transform_block_avx2(&temp);
   
-  unsigned sad = sum_block_avx2(temp_ver);
+  unsigned sad = sum_block_avx2(temp);
 
   unsigned result = (sad + 2) >> 2;
   return result;
 }
 
+
+SATD_NxN(8bit_avx2,  8)
+SATD_NxN(8bit_avx2, 16)
+SATD_NxN(8bit_avx2, 32)
+SATD_NxN(8bit_avx2, 64)
+SATD_ANY_SIZE(8bit_avx2)
+
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+static void kvz_satd_8bit_8x8_general_dual_avx2(const kvz_pixel * buf1, unsigned stride1,
+                                                const kvz_pixel * buf2, unsigned stride2,
+                                                const kvz_pixel * orig, unsigned stride_orig,
+                                                unsigned *sum0, unsigned *sum1)
+{
+  __m256i temp[8];
+
+  diff_blocks_dual_avx2(&temp, buf1, stride1, buf2, stride2, orig, stride_orig);
+  hor_transform_block_dual_avx2(&temp);
+  ver_transform_block_dual_avx2(&temp);
+  
+  sum_block_dual_avx2(temp, sum0, sum1);
+
+  *sum0 = (*sum0 + 2) >> 2;
+  *sum1 = (*sum1 + 2) >> 2;
+}
+
 // Function macro for defining hadamard calculating functions
 // for fixed size blocks. They calculate hadamard for integer
 // multiples of 8x8 with the 8x8 hadamard function.
-#define SATD_NXN_AVX2(n) \
-static unsigned satd_8bit_ ## n ## x ## n ## _avx2( \
-  const kvz_pixel * const block1, const kvz_pixel * const block2) \
+#define SATD_NXN_DUAL_AVX2(n) \
+static void satd_8bit_ ## n ## x ## n ## _dual_avx2( \
+  const pred_buffer preds, const kvz_pixel * const orig, unsigned num_modes, unsigned *satds_out)  \
 { \
   unsigned x, y; \
-  unsigned sum = 0; \
+  satds_out[0] = 0; \
+  satds_out[1] = 0; \
+  unsigned sum1 = 0; \
+  unsigned sum2 = 0; \
   for (y = 0; y < (n); y += 8) { \
   unsigned row = y * (n); \
   for (x = 0; x < (n); x += 8) { \
-  sum += kvz_satd_8bit_8x8_general_avx2(&block1[row + x], (n), &block2[row + x], (n)); \
+  kvz_satd_8bit_8x8_general_dual_avx2(&preds[0][row + x], (n), &preds[1][row + x], (n), &orig[row + x], (n), &sum1, &sum2); \
+  satds_out[0] += sum1; \
+  satds_out[1] += sum2; \
     } \
     } \
-  return sum>>(KVZ_BIT_DEPTH-8); \
+  satds_out[0] >>= (KVZ_BIT_DEPTH-8); \
+  satds_out[1] >>= (KVZ_BIT_DEPTH-8); \
 }
 
-static unsigned satd_8bit_8x8_avx2(
-  const kvz_pixel * const block1, const kvz_pixel * const block2) 
+static void satd_8bit_8x8_dual_avx2(
+  const pred_buffer preds, const kvz_pixel * const orig, unsigned num_modes, unsigned *satds_out) 
 { 
   unsigned x, y; 
-  unsigned sum = 0; 
+  satds_out[0] = 0;
+  satds_out[1] = 0;
+  unsigned sum1 = 0;
+  unsigned sum2 = 0;
   for (y = 0; y < (8); y += 8) { 
   unsigned row = y * (8); 
   for (x = 0; x < (8); x += 8) { 
-  sum += kvz_satd_8bit_8x8_general_avx2(&block1[row + x], (8), &block2[row + x], (8)); 
+  kvz_satd_8bit_8x8_general_dual_avx2(&preds[0][row + x], (8), &preds[1][row + x], (8), &orig[row + x], (8), &sum1, &sum2); 
+  satds_out[0] += sum1;
+  satds_out[1] += sum2;
       } 
       } 
-  return sum>>(KVZ_BIT_DEPTH-8); \
+  satds_out[0] >>= (KVZ_BIT_DEPTH-8);
+  satds_out[1] >>= (KVZ_BIT_DEPTH-8);
 }
 
-//SATD_NXN_AVX2(8) //Use the non-macro version
-SATD_NXN_AVX2(16)
-SATD_NXN_AVX2(32)
-SATD_NXN_AVX2(64)
+//SATD_NXN_DUAL_AVX2(8) //Use the non-macro version
+SATD_NXN_DUAL_AVX2(16)
+SATD_NXN_DUAL_AVX2(32)
+SATD_NXN_DUAL_AVX2(64)
+
+void kvz_pixels_blit_avx2(const kvz_pixel * const orig, kvz_pixel * const dst,
+                         const unsigned width, const unsigned height,
+                         const unsigned orig_stride, const unsigned dst_stride)
+{
+  unsigned y;
+  //There is absolutely no reason to have a width greater than the source or the destination stride.
+  assert(width <= orig_stride);
+  assert(width <= dst_stride);
+
+#ifdef CHECKPOINTS
+  char *buffer = malloc((3 * width + 1) * sizeof(char));
+  for (y = 0; y < height; ++y) {
+    int p;
+    for (p = 0; p < width; ++p) {
+      sprintf((buffer + 3*p), "%02X ", orig[y*orig_stride]);
+    }
+    buffer[3*width] = 0;
+    CHECKPOINT("kvz_pixels_blit_avx2: %04d: %s", y, buffer);
+  }
+  FREE_POINTER(buffer);
+#endif //CHECKPOINTS
+
+  if (width == orig_stride && width == dst_stride) {
+    memcpy(dst, orig, width * height * sizeof(kvz_pixel));
+    return;
+  }
+
+  int nxn_width = (width == height) ? width : 0;
+  switch (nxn_width) {
+    case 4:
+      *(int32_t*)&dst[dst_stride*0] = *(int32_t*)&orig[orig_stride*0];
+      *(int32_t*)&dst[dst_stride*1] = *(int32_t*)&orig[orig_stride*1];
+      *(int32_t*)&dst[dst_stride*2] = *(int32_t*)&orig[orig_stride*2];
+      *(int32_t*)&dst[dst_stride*3] = *(int32_t*)&orig[orig_stride*3];
+      break;
+    case 8:
+      *(int64_t*)&dst[dst_stride*0] = *(int64_t*)&orig[orig_stride*0];
+      *(int64_t*)&dst[dst_stride*1] = *(int64_t*)&orig[orig_stride*1];
+      *(int64_t*)&dst[dst_stride*2] = *(int64_t*)&orig[orig_stride*2];
+      *(int64_t*)&dst[dst_stride*3] = *(int64_t*)&orig[orig_stride*3];
+      *(int64_t*)&dst[dst_stride*4] = *(int64_t*)&orig[orig_stride*4];
+      *(int64_t*)&dst[dst_stride*5] = *(int64_t*)&orig[orig_stride*5];
+      *(int64_t*)&dst[dst_stride*6] = *(int64_t*)&orig[orig_stride*6];
+      *(int64_t*)&dst[dst_stride*7] = *(int64_t*)&orig[orig_stride*7];
+       break;
+    case 16:
+      for (int i = 0; i < 16; ++i) {
+        __m128i temp = _mm_loadu_si128((__m128i*)(orig + i * orig_stride));
+        _mm_storeu_si128((__m128i*)(dst + i * dst_stride), temp);
+      }
+      break;
+    case 32:
+      for (int i = 0; i < 32; ++i) {
+        __m256i temp = _mm256_loadu_si256((__m256i*)(orig + i * orig_stride));
+        _mm256_storeu_si256((__m256i*)(dst + i * dst_stride), temp);
+      }
+    break;
+    case 64:
+      for (int i = 0; i < 64; ++i) {
+        __m256i temp0 = _mm256_loadu_si256((__m256i*)(orig + i * orig_stride));
+        _mm256_storeu_si256((__m256i*)(dst + i * dst_stride), temp0);
+        __m256i temp1 = _mm256_loadu_si256((__m256i*)(orig + i * orig_stride + sizeof(__m256)));
+        _mm256_storeu_si256((__m256i*)(dst + i * dst_stride + sizeof(__m256)), temp1);
+      }
+    break;
+  default:
+
+    if (orig == dst) {
+      //If we have the same array, then we should have the same stride
+      assert(orig_stride == dst_stride);
+      return;
+    }
+    assert(orig != dst || orig_stride == dst_stride);
+
+    for (y = 0; y < height; ++y) {
+      memcpy(&dst[y*dst_stride], &orig[y*orig_stride], width * sizeof(kvz_pixel));
+    }
+    break;
+  }
+}
 
 #endif //COMPILE_INTEL_AVX2
 
@@ -335,11 +638,20 @@
     success &= kvz_strategyselector_register(opaque, "sad_32x32", "avx2", 40, &sad_8bit_32x32_avx2);
     success &= kvz_strategyselector_register(opaque, "sad_64x64", "avx2", 40, &sad_8bit_64x64_avx2);
 
-    success &= kvz_strategyselector_register(opaque, "satd_4x4", "avx2", 40, &satd_8bit_4x4_avx2);
-    success &= kvz_strategyselector_register(opaque, "satd_8x8", "avx2", 40, &satd_8bit_8x8_avx2);
-    success &= kvz_strategyselector_register(opaque, "satd_16x16", "avx2", 40, &satd_8bit_16x16_avx2);
-    success &= kvz_strategyselector_register(opaque, "satd_32x32", "avx2", 40, &satd_8bit_32x32_avx2);
-    success &= kvz_strategyselector_register(opaque, "satd_64x64", "avx2", 40, &satd_8bit_64x64_avx2);
+    success &= kvz_strategyselector_register(opaque, "satd_4x4", "avx2", 40, &satd_4x4_8bit_avx2);
+    success &= kvz_strategyselector_register(opaque, "satd_8x8", "avx2", 40, &satd_8x8_8bit_avx2);
+    success &= kvz_strategyselector_register(opaque, "satd_16x16", "avx2", 40, &satd_16x16_8bit_avx2);
+    success &= kvz_strategyselector_register(opaque, "satd_32x32", "avx2", 40, &satd_32x32_8bit_avx2);
+    success &= kvz_strategyselector_register(opaque, "satd_64x64", "avx2", 40, &satd_64x64_8bit_avx2);
+
+    success &= kvz_strategyselector_register(opaque, "satd_4x4_dual", "avx2", 40, &satd_8bit_4x4_dual_avx2);
+    success &= kvz_strategyselector_register(opaque, "satd_8x8_dual", "avx2", 40, &satd_8bit_8x8_dual_avx2);
+    success &= kvz_strategyselector_register(opaque, "satd_16x16_dual", "avx2", 40, &satd_8bit_16x16_dual_avx2);
+    success &= kvz_strategyselector_register(opaque, "satd_32x32_dual", "avx2", 40, &satd_8bit_32x32_dual_avx2);
+    success &= kvz_strategyselector_register(opaque, "satd_64x64_dual", "avx2", 40, &satd_8bit_64x64_dual_avx2);
+    success &= kvz_strategyselector_register(opaque, "satd_any_size", "avx2", 40, &satd_any_size_8bit_avx2);
+
+    success &= kvz_strategyselector_register(opaque, "pixels_blit", "avx2", 40, &kvz_pixels_blit_avx2);
   }
 #endif
   return success;

kvazaar-0.7.2.tar.gz/src/strategies/avx2/picture-avx2.h -> kvazaar-0.8.1.tar.gz/src/strategies/avx2/picture-avx2.h Changed

kvazaar-0.7.2.tar.gz/src/strategies/avx2/quant-avx2.c -> kvazaar-0.8.1.tar.gz/src/strategies/avx2/quant-avx2.c Changed

@@ -104,11 +104,44 @@
 
   int32_t delta_u[LCU_WIDTH*LCU_WIDTH >> 2];
 
-  for (int32_t n = 0; n < width * height; n++) {
-    int32_t level;
-    level = coef[n];
-    level = ((int64_t)abs(level) * quant_coeff[n] + add) >> q_bits;
-    delta_u[n] = (int32_t)(((int64_t)abs(coef[n]) * quant_coeff[n] - (level << q_bits)) >> q_bits8);
+  for (int32_t n = 0; n < width * height; n += 16) {
+
+    __m256i v_level = _mm256_loadu_si256((__m256i*)&(coef[n]));
+
+    v_level = _mm256_abs_epi16(v_level);
+    __m256i low_a = _mm256_unpacklo_epi16(v_level, _mm256_set1_epi16(0));
+    __m256i high_a = _mm256_unpackhi_epi16(v_level, _mm256_set1_epi16(0));
+
+    __m256i low_b = _mm256_unpacklo_epi16(v_quant_coeff, _mm256_set1_epi16(0));
+    __m256i high_b = _mm256_unpackhi_epi16(v_quant_coeff, _mm256_set1_epi16(0));
+
+    __m256i v_level32_a = _mm256_madd_epi16(low_a, low_b);
+    __m256i v_level32_b = _mm256_madd_epi16(high_a, high_b);
+
+    v_level32_a = _mm256_add_epi32(v_level32_a, _mm256_set1_epi32(add));
+    v_level32_b = _mm256_add_epi32(v_level32_b, _mm256_set1_epi32(add));
+
+    v_level32_a = _mm256_srai_epi32(v_level32_a, q_bits);
+    v_level32_b = _mm256_srai_epi32(v_level32_b, q_bits);
+
+    v_level = _mm256_packs_epi32(v_level32_a, v_level32_b);
+
+    __m256i v_coef = _mm256_loadu_si256((__m256i*)&(coef[n]));
+    __m256i v_coef_a = _mm256_unpacklo_epi16(_mm256_abs_epi16(v_coef), _mm256_set1_epi16(0));
+    __m256i v_coef_b = _mm256_unpackhi_epi16(_mm256_abs_epi16(v_coef), _mm256_set1_epi16(0));
+    __m256i v_quant_coeff_a = _mm256_unpacklo_epi16(v_quant_coeff, _mm256_set1_epi16(0));
+    __m256i v_quant_coeff_b = _mm256_unpackhi_epi16(v_quant_coeff, _mm256_set1_epi16(0));
+    v_coef_a = _mm256_madd_epi16(v_coef_a, v_quant_coeff_a);
+    v_coef_b = _mm256_madd_epi16(v_coef_b, v_quant_coeff_b);
+    v_coef_a = _mm256_sub_epi32(v_coef_a, _mm256_slli_epi32(_mm256_unpacklo_epi16(v_level, _mm256_set1_epi16(0)), q_bits) );
+    v_coef_b = _mm256_sub_epi32(v_coef_b, _mm256_slli_epi32(_mm256_unpackhi_epi16(v_level, _mm256_set1_epi16(0)), q_bits) );
+    v_coef_a = _mm256_srai_epi32(v_coef_a, q_bits8);
+    v_coef_b = _mm256_srai_epi32(v_coef_b, q_bits8);
+    
+    _mm_storeu_si128((__m128i*)&(delta_u[n+0*4]), _mm256_castsi256_si128(v_coef_a));
+    _mm_storeu_si128((__m128i*)&(delta_u[n+2*4]), _mm256_extracti128_si256(v_coef_a, 1));
+    _mm_storeu_si128((__m128i*)&(delta_u[n+1*4]), _mm256_castsi256_si128(v_coef_b));
+    _mm_storeu_si128((__m128i*)&(delta_u[n+3*4]), _mm256_extracti128_si256(v_coef_b, 1));
   }
 
   if (ac_sum >= 2) {

kvazaar-0.7.2.tar.gz/src/strategies/avx2/quant-avx2.h -> kvazaar-0.8.1.tar.gz/src/strategies/avx2/quant-avx2.h Changed

kvazaar-0.7.2.tar.gz/src/strategies/generic/dct-generic.c -> kvazaar-0.8.1.tar.gz/src/strategies/generic/dct-generic.c Changed

kvazaar-0.7.2.tar.gz/src/strategies/generic/dct-generic.h -> kvazaar-0.8.1.tar.gz/src/strategies/generic/dct-generic.h Changed

kvazaar-0.7.2.tar.gz/src/strategies/generic/intra-generic.c -> kvazaar-0.8.1.tar.gz/src/strategies/generic/intra-generic.c Changed

@@ -18,10 +18,6 @@
  * with Kvazaar.  If not, see <http://www.gnu.org/licenses/>.
  ****************************************************************************/
 
-/*
- * \file
- */
-
 #include <stdlib.h>
 
 #include "intra-generic.h"
@@ -144,11 +140,58 @@
   }
 }
 
+
+/**
+ * \brief Generate planar prediction.
+ * \param log2_width    Log2 of width, range 2..5.
+ * \param in_ref_above  Pointer to -1 index of above reference, length=width*2+1.
+ * \param in_ref_left   Pointer to -1 index of left reference, length=width*2+1.
+ * \param dst           Buffer of size width*width.
+ */
+static void kvz_intra_pred_planar_generic(
+  const int_fast8_t log2_width,
+  const kvz_pixel *const ref_top,
+  const kvz_pixel *const ref_left,
+  kvz_pixel *const dst)
+{
+  assert(log2_width >= 2 && log2_width <= 5);
+
+  const int_fast8_t width = 1 << log2_width;
+  const kvz_pixel top_right = ref_top[width + 1];
+  const kvz_pixel bottom_left = ref_left[width + 1];
+
+#if 0
+  // Unoptimized version for reference.
+  for (int y = 0; y < width; ++y) {
+    for (int x = 0; x < width; ++x) {
+      int_fast16_t hor = (width - 1 - x) * ref_left[y + 1] + (x + 1) * top_right;
+      int_fast16_t ver = (width - 1 - y) * ref_top[x + 1] + (y + 1) * bottom_left;
+      dst[y * width + x] = (ver + hor + width) >> (log2_width + 1);
+    }
+  }
+#else
+  int_fast16_t top[32];
+  for (int i = 0; i < width; ++i) {
+    top[i] = ref_top[i + 1] << log2_width;
+  }
+
+  for (int y = 0; y < width; ++y) {
+    int_fast16_t hor = (ref_left[y + 1] << log2_width) + width;
+    for (int x = 0; x < width; ++x) {
+      hor += top_right - ref_left[y + 1];
+      top[x] += bottom_left - ref_top[x + 1];
+      dst[y * width + x] = (hor + top[x]) >> (log2_width + 1);
+    }
+  }
+#endif
+}
+
 int kvz_strategy_register_intra_generic(void* opaque, uint8_t bitdepth)
 {
   bool success = true;
 
   success &= kvz_strategyselector_register(opaque, "angular_pred", "generic", 0, &kvz_angular_pred_generic);
+  success &= kvz_strategyselector_register(opaque, "intra_pred_planar", "generic", 0, &kvz_intra_pred_planar_generic);
 
   return success;
 }

kvazaar-0.7.2.tar.gz/src/strategies/generic/intra-generic.h -> kvazaar-0.8.1.tar.gz/src/strategies/generic/intra-generic.h Changed

kvazaar-0.7.2.tar.gz/src/strategies/generic/ipol-generic.c -> kvazaar-0.8.1.tar.gz/src/strategies/generic/ipol-generic.c Changed

@@ -18,10 +18,6 @@
  * with Kvazaar.  If not, see <http://www.gnu.org/licenses/>.
  ****************************************************************************/
 
-/*
- * \file
- */
-
 #include <stdlib.h>
 
 #include "ipol-generic.h"
@@ -503,7 +499,7 @@
   int sample_out_of_bounds = out_of_bounds_y || out_of_bounds_x;
 
   if (sample_out_of_bounds){
-    out->buffer = MALLOC(kvz_pixel, (width + filter_size) * (width + filter_size));
+    out->buffer = MALLOC(kvz_pixel, (width + filter_size) * (height + filter_size));
     if (!out->buffer){
       fprintf(stderr, "Memory allocation failed!\n");
       assert(0);
@@ -522,7 +518,7 @@
       coord_y *= ref_width;
 
       if (!out_of_bounds_x){
-        memcpy(&out->buffer[dst_y*(width + filter_size) + 0], &ref[coord_y + min_x], (width + filter_size) * sizeof(kvz_pixel));
+        memcpy(&out->buffer[dst_y * out->stride + 0], &ref[coord_y + min_x], out->stride * sizeof(kvz_pixel));
       } else {
         for (dst_x = 0, x = (xpos)-half_filter_size; x < ((xpos + width)) + half_filter_size; dst_x++, x++) {
 
@@ -530,7 +526,7 @@
           coord_x = CLIP(0, (ref_width)-1, coord_x);
 
           // Store source block data (with extended borders)
-          out->buffer[dst_y*(width + filter_size) + dst_x] = ref[coord_y + coord_x];
+          out->buffer[dst_y * out->stride + dst_x] = ref[coord_y + coord_x];
         }
       }
     }

kvazaar-0.7.2.tar.gz/src/strategies/generic/ipol-generic.h -> kvazaar-0.8.1.tar.gz/src/strategies/generic/ipol-generic.h Changed

kvazaar-0.7.2.tar.gz/src/strategies/generic/nal-generic.c -> kvazaar-0.8.1.tar.gz/src/strategies/generic/nal-generic.c Changed

kvazaar-0.7.2.tar.gz/src/strategies/generic/nal-generic.h -> kvazaar-0.8.1.tar.gz/src/strategies/generic/nal-generic.h Changed

kvazaar-0.7.2.tar.gz/src/strategies/generic/picture-generic.c -> kvazaar-0.8.1.tar.gz/src/strategies/generic/picture-generic.c Changed

@@ -18,10 +18,6 @@
  * with Kvazaar.  If not, see <http://www.gnu.org/licenses/>.
  ****************************************************************************/
 
-/*
- * \file
- */
-
 #include <stdlib.h>
 
 #include "strategyselector.h"
@@ -191,7 +187,7 @@
 /**
 * \brief  Calculate SATD between two 8x8 blocks inside bigger arrays.
 */
-unsigned kvz_satd_8x8_general(const kvz_pixel * piOrg, const int32_t iStrideOrg,
+static unsigned satd_8x8_subblock_generic(const kvz_pixel * piOrg, const int32_t iStrideOrg,
   const kvz_pixel * piCur, const int32_t iStrideCur)
 {
   int32_t k, i, j, jj, sad = 0;
@@ -281,36 +277,55 @@
   return sad;
 }
 
-// Function macro for defining hadamard calculating functions
-// for fixed size blocks. They calculate hadamard for integer
-// multiples of 8x8 with the 8x8 hadamard function.
-#define SATD_NXN(n, pixel_type) \
-static unsigned satd_ ## n ## x ## n ## _generic( \
-  const pixel_type * const block1, const pixel_type * const block2) \
+// These macros define sadt_16bit_NxN for N = 8, 16, 32, 64
+SATD_NxN(generic,  8)
+SATD_NxN(generic, 16)
+SATD_NxN(generic, 32)
+SATD_NxN(generic, 64)
+SATD_ANY_SIZE(generic)
+
+
+// Declare these functions to make sure the signature of the macro matches.
+static cost_pixel_nxn_multi_func satd_4x4_dual_generic;
+static cost_pixel_nxn_multi_func satd_8x8_dual_generic;
+static cost_pixel_nxn_multi_func satd_16x16_dual_generic;
+static cost_pixel_nxn_multi_func satd_32x32_dual_generic;
+static cost_pixel_nxn_multi_func satd_64x64_dual_generic;
+
+#define SATD_DUAL_NXN(n, pixel_type) \
+static void satd_ ## n ## x ## n ## _dual_generic( \
+  const pred_buffer preds, const pixel_type * const orig, unsigned num_modes, unsigned *costs_out) \
 { \
   unsigned x, y; \
   unsigned sum = 0; \
   for (y = 0; y < (n); y += 8) { \
   unsigned row = y * (n); \
   for (x = 0; x < (n); x += 8) { \
-  sum += kvz_satd_8x8_general(&block1[row + x], (n), &block2[row + x], (n)); \
+  sum += satd_8x8_subblock_generic(&preds[0][row + x], (n), &orig[row + x], (n)); \
   } \
   } \
-  return sum>>(KVZ_BIT_DEPTH-8); \
+  costs_out[0] = sum>>(KVZ_BIT_DEPTH-8); \
+  \
+  sum = 0; \
+  for (y = 0; y < (n); y += 8) { \
+  unsigned row = y * (n); \
+  for (x = 0; x < (n); x += 8) { \
+  sum += satd_8x8_subblock_generic(&preds[1][row + x], (n), &orig[row + x], (n)); \
+  } \
+  } \
+  costs_out[1] = sum>>(KVZ_BIT_DEPTH-8); \
 }
 
-// Declare these functions to make sure the signature of the macro matches.
-static cost_pixel_nxn_func satd_4x4_generic;
-static cost_pixel_nxn_func satd_8x8_generic;
-static cost_pixel_nxn_func satd_16x16_generic;
-static cost_pixel_nxn_func satd_32x32_generic;
-static cost_pixel_nxn_func satd_64x64_generic;
+static void satd_4x4_dual_generic(const pred_buffer preds, const kvz_pixel * const orig, unsigned num_modes, unsigned *costs_out)
+{
+  costs_out[0] = satd_4x4_generic(orig, preds[0]);
+  costs_out[1] = satd_4x4_generic(orig, preds[1]);
+}
 
-// These macros define sadt_16bit_NxN for N = 8, 16, 32, 64
-SATD_NXN(8, kvz_pixel)
-SATD_NXN(16, kvz_pixel)
-SATD_NXN(32, kvz_pixel)
-SATD_NXN(64, kvz_pixel)
+SATD_DUAL_NXN(8, kvz_pixel)
+SATD_DUAL_NXN(16, kvz_pixel)
+SATD_DUAL_NXN(32, kvz_pixel)
+SATD_DUAL_NXN(64, kvz_pixel)
 
 // Function macro for defining SAD calculating functions
 // for fixed size blocks.
@@ -342,8 +357,90 @@
 SAD_NXN(32, kvz_pixel)
 SAD_NXN(64, kvz_pixel)
 
+// Declare these functions to make sure the signature of the macro matches.
+static cost_pixel_nxn_multi_func sad_4x4_dual_generic;
+static cost_pixel_nxn_multi_func sad_8x8_dual_generic;
+static cost_pixel_nxn_multi_func sad_16x16_dual_generic;
+static cost_pixel_nxn_multi_func sad_32x32_dual_generic;
+static cost_pixel_nxn_multi_func sad_64x64_dual_generic;
 
-int kvz_strategy_register_picture_generic(void* opaque)
+// Function macro for defining SAD calculating functions
+// for fixed size blocks.
+#define SAD_DUAL_NXN(n, pixel_type) \
+static void sad_ ##  n ## x ## n ## _dual_generic( \
+  const pred_buffer preds, const pixel_type * const orig, unsigned num_modes, unsigned *costs_out) \
+{ \
+  unsigned i; \
+  unsigned sum = 0; \
+  for (i = 0; i < (n)*(n); ++i) { \
+  sum += abs(preds[0][i] - orig[i]); \
+  } \
+  costs_out[0] = sum>>(KVZ_BIT_DEPTH-8); \
+  \
+  sum = 0; \
+  for (i = 0; i < (n)*(n); ++i) { \
+  sum += abs(preds[1][i] - orig[i]); \
+  } \
+  costs_out[1] = sum>>(KVZ_BIT_DEPTH-8); \
+}
+
+SAD_DUAL_NXN(4, kvz_pixel)
+SAD_DUAL_NXN(8, kvz_pixel)
+SAD_DUAL_NXN(16, kvz_pixel)
+SAD_DUAL_NXN(32, kvz_pixel)
+SAD_DUAL_NXN(64, kvz_pixel)
+
+/**
+ * \brief BLock Image Transfer from one buffer to another.
+ *
+ * It's a stupidly simple loop that copies pixels.
+ *
+ * \param orig  Start of the originating buffer.
+ * \param dst  Start of the destination buffer.
+ * \param width  Width of the copied region.
+ * \param height  Height of the copied region.
+ * \param orig_stride  Width of a row in the originating buffer.
+ * \param dst_stride  Width of a row in the destination buffer.
+ *
+ * This should be inlined, but it's defined here for now to see if Visual
+ * Studios LTCG will inline it.
+ */
+void kvz_pixels_blit_generic(const kvz_pixel * const orig, kvz_pixel * const dst,
+                         const unsigned width, const unsigned height,
+                         const unsigned orig_stride, const unsigned dst_stride)
+{
+  unsigned y;
+  //There is absolutely no reason to have a width greater than the source or the destination stride.
+  assert(width <= orig_stride);
+  assert(width <= dst_stride);
+
+#ifdef CHECKPOINTS
+  char *buffer = malloc((3 * width + 1) * sizeof(char));
+  for (y = 0; y < height; ++y) {
+    int p;
+    for (p = 0; p < width; ++p) {
+      sprintf((buffer + 3*p), "%02X ", orig[y*orig_stride]);
+    }
+    buffer[3*width] = 0;
+    CHECKPOINT("kvz_pixels_blit: %04d: %s", y, buffer);
+  }
+  FREE_POINTER(buffer);
+#endif //CHECKPOINTS
+
+  if (orig == dst) {
+    //If we have the same array, then we should have the same stride
+    assert(orig_stride == dst_stride);
+    return;
+  }
+  assert(orig != dst || orig_stride == dst_stride);
+
+  for (y = 0; y < height; ++y) {
+    memcpy(&dst[y*dst_stride], &orig[y*orig_stride], width * sizeof(kvz_pixel));
+  }
+}
+
+
+int kvz_strategy_register_picture_generic(void* opaque, uint8_t bitdepth)
 {
   bool success = true;
 
@@ -361,5 +458,20 @@
   success &= kvz_strategyselector_register(opaque, "satd_32x32", "generic", 0, &satd_32x32_generic);
   success &= kvz_strategyselector_register(opaque, "satd_64x64", "generic", 0, &satd_64x64_generic);
 
+  success &= kvz_strategyselector_register(opaque, "sad_4x4_dual", "generic", 0, &sad_4x4_dual_generic);
+  success &= kvz_strategyselector_register(opaque, "sad_8x8_dual", "generic", 0, &sad_8x8_dual_generic);
+  success &= kvz_strategyselector_register(opaque, "sad_16x16_dual", "generic", 0, &sad_16x16_dual_generic);
+  success &= kvz_strategyselector_register(opaque, "sad_32x32_dual", "generic", 0, &sad_32x32_dual_generic);
+  success &= kvz_strategyselector_register(opaque, "sad_64x64_dual", "generic", 0, &sad_64x64_dual_generic);
+
+  success &= kvz_strategyselector_register(opaque, "satd_4x4_dual", "generic", 0, &satd_4x4_dual_generic);
+  success &= kvz_strategyselector_register(opaque, "satd_8x8_dual", "generic", 0, &satd_8x8_dual_generic);
+  success &= kvz_strategyselector_register(opaque, "satd_16x16_dual", "generic", 0, &satd_16x16_dual_generic);
+  success &= kvz_strategyselector_register(opaque, "satd_32x32_dual", "generic", 0, &satd_32x32_dual_generic);
+  success &= kvz_strategyselector_register(opaque, "satd_64x64_dual", "generic", 0, &satd_64x64_dual_generic);
+  success &= kvz_strategyselector_register(opaque, "satd_any_size", "generic", 0, &satd_any_size_generic);
+
+  success &= kvz_strategyselector_register(opaque, "pixels_blit", "generic", 0, &kvz_pixels_blit_generic);
+
   return success;
 }

kvazaar-0.7.2.tar.gz/src/strategies/generic/picture-generic.h -> kvazaar-0.8.1.tar.gz/src/strategies/generic/picture-generic.h Changed

kvazaar-0.7.2.tar.gz/src/strategies/generic/quant-generic.c -> kvazaar-0.8.1.tar.gz/src/strategies/generic/quant-generic.c Changed

kvazaar-0.7.2.tar.gz/src/strategies/generic/quant-generic.h -> kvazaar-0.8.1.tar.gz/src/strategies/generic/quant-generic.h Changed

kvazaar-0.7.2.tar.gz/src/strategies/sse2/picture-sse2.c -> kvazaar-0.8.1.tar.gz/src/strategies/sse2/picture-sse2.c Changed

kvazaar-0.7.2.tar.gz/src/strategies/sse2/picture-sse2.h -> kvazaar-0.8.1.tar.gz/src/strategies/sse2/picture-sse2.h Changed

kvazaar-0.7.2.tar.gz/src/strategies/sse41/picture-sse41.c -> kvazaar-0.8.1.tar.gz/src/strategies/sse41/picture-sse41.c Changed

kvazaar-0.7.2.tar.gz/src/strategies/sse41/picture-sse41.h -> kvazaar-0.8.1.tar.gz/src/strategies/sse41/picture-sse41.h Changed

kvazaar-0.7.2.tar.gz/src/strategies/strategies-common.h -> kvazaar-0.8.1.tar.gz/src/strategies/strategies-common.h Changed

kvazaar-0.7.2.tar.gz/src/strategies/strategies-dct.h -> kvazaar-0.8.1.tar.gz/src/strategies/strategies-dct.h Changed

kvazaar-0.7.2.tar.gz/src/strategies/strategies-intra.c -> kvazaar-0.8.1.tar.gz/src/strategies/strategies-intra.c Changed

kvazaar-0.7.2.tar.gz/src/strategies/strategies-intra.h -> kvazaar-0.8.1.tar.gz/src/strategies/strategies-intra.h Changed

@@ -19,7 +19,13 @@
  * You should have received a copy of the GNU General Public License along
  * with Kvazaar.  If not, see <http://www.gnu.org/licenses/>.
  ****************************************************************************/
- 
+
+/**
+ * \ingroup Optimization
+ * \file
+ * Interface for intra prediction functions.
+ */
+
 #include "encoderstate.h"
 
 typedef void (angular_pred_func)(
@@ -29,14 +35,22 @@
   const kvz_pixel *const in_ref_left,
   kvz_pixel *const dst);
 
+typedef void (intra_pred_planar_func)(
+  const int_fast8_t log2_width,
+  const kvz_pixel *const ref_top,
+  const kvz_pixel *const ref_left,
+  kvz_pixel *const dst);
+
 // Declare function pointers.
 extern angular_pred_func * kvz_angular_pred;
+extern intra_pred_planar_func * kvz_intra_pred_planar;
 
 int kvz_strategy_register_intra(void* opaque, uint8_t bitdepth);
 
 
 #define STRATEGIES_INTRA_EXPORTS \
   {"angular_pred", (void**) &kvz_angular_pred}, \
+  {"intra_pred_planar", (void**) &kvz_intra_pred_planar}, \

kvazaar-0.7.2.tar.gz/src/strategies/strategies-ipol.h -> kvazaar-0.8.1.tar.gz/src/strategies/strategies-ipol.h Changed

kvazaar-0.7.2.tar.gz/src/strategies/strategies-nal.h -> kvazaar-0.8.1.tar.gz/src/strategies/strategies-nal.h Changed

kvazaar-0.7.2.tar.gz/src/strategies/strategies-picture.c -> kvazaar-0.8.1.tar.gz/src/strategies/strategies-picture.c Changed

@@ -36,6 +36,22 @@
 cost_pixel_nxn_func * kvz_satd_32x32 = 0;
 cost_pixel_nxn_func * kvz_satd_64x64 = 0;
 
+cost_pixel_nxn_multi_func * kvz_sad_4x4_dual = 0;
+cost_pixel_nxn_multi_func * kvz_sad_8x8_dual = 0;
+cost_pixel_nxn_multi_func * kvz_sad_16x16_dual = 0;
+cost_pixel_nxn_multi_func * kvz_sad_32x32_dual = 0;
+cost_pixel_nxn_multi_func * kvz_sad_64x64_dual = 0;
+
+cost_pixel_nxn_multi_func * kvz_satd_4x4_dual = 0;
+cost_pixel_nxn_multi_func * kvz_satd_8x8_dual = 0;
+cost_pixel_nxn_multi_func * kvz_satd_16x16_dual = 0;
+cost_pixel_nxn_multi_func * kvz_satd_32x32_dual = 0;
+cost_pixel_nxn_multi_func * kvz_satd_64x64_dual = 0;
+
+cost_pixel_any_size_func * kvz_satd_any_size = 0;
+
+pixels_blit_func * kvz_pixels_blit = 0;
+
 
 // Headers for platform optimizations.
 #include "generic/picture-generic.h"
@@ -121,3 +137,54 @@
     return NULL;
   }
 }
+
+/**
+* \brief  Get a function that calculates SATDs for 2 NxN blocks.
+*
+* \param n  Width of the region for which SATD is calculated.
+*
+* \returns  Pointer to cost_pixel_nxn_multi_func.
+*/
+cost_pixel_nxn_multi_func * kvz_pixels_get_satd_dual_func(unsigned n)
+{
+  switch (n) {
+  case 4:
+    return kvz_satd_4x4_dual;
+  case 8:
+    return kvz_satd_8x8_dual;
+  case 16:
+    return kvz_satd_16x16_dual;
+  case 32:
+    return kvz_satd_32x32_dual;
+  case 64:
+    return kvz_satd_64x64_dual;
+  default:
+    return NULL;
+  }
+}
+
+
+/**
+* \brief  Get a function that calculates SADs for 2 NxN blocks.
+*
+* \param n  Width of the region for which SAD is calculated.
+*
+* \returns  Pointer to cost_pixel_nxn_multi_func.
+*/
+cost_pixel_nxn_multi_func * kvz_pixels_get_sad_dual_func(unsigned n)
+{
+  switch (n) {
+  case 4:
+    return kvz_sad_4x4_dual;
+  case 8:
+    return kvz_sad_8x8_dual;
+  case 16:
+    return kvz_sad_16x16_dual;
+  case 32:
+    return kvz_sad_32x32_dual;
+  case 64:
+    return kvz_sad_64x64_dual;
+  default:
+    return NULL;
+  }
+}

kvazaar-0.7.2.tar.gz/src/strategies/strategies-picture.h -> kvazaar-0.8.1.tar.gz/src/strategies/strategies-picture.h Changed

@@ -20,13 +20,75 @@
  * with Kvazaar.  If not, see <http://www.gnu.org/licenses/>.
  ****************************************************************************/
 
+/**
+ * \ingroup Optimization
+ * \file
+ * Interface for distortion metric functions.
+ */
+
 #include "../image.h"
 
+typedef kvz_pixel (*pred_buffer)[32 * 32];
+
+
+// Function macro for defining hadamard calculating functions
+// for fixed size blocks. They calculate hadamard for integer
+// multiples of 8x8 with the 8x8 hadamard function.
+#define SATD_NxN(suffix, n) \
+/* Declare the function in advance, hopefully reducing the probability that the
+ * macro expands to something unexpected and silently breaks things. */ \
+static cost_pixel_nxn_func satd_ ## n ## x ## n ## _ ## suffix;\
+static unsigned satd_ ## n ## x ## n ## _ ## suffix ( \
+    const kvz_pixel * const block1, \
+    const kvz_pixel * const block2) \
+{ \
+  unsigned sum = 0; \
+  for (unsigned y = 0; y < (n); y += 8) { \
+    unsigned row = y * (n); \
+    for (unsigned x = 0; x < (n); x += 8) { \
+      sum += satd_8x8_subblock_ ## suffix(&block1[row + x], (n), &block2[row + x], (n)); \
+    } \
+  } \
+  return sum >> (KVZ_BIT_DEPTH - 8); \
+}
+
+
+// Function macro for defining hadamard calculating functions for dynamic size
+// blocks. They calculate hadamard for integer multiples of 8x8 with the 8x8
+// hadamard function.
+#define SATD_ANY_SIZE(suffix) \
+  static cost_pixel_any_size_func satd_any_size_ ## suffix; \
+  static unsigned satd_any_size_ ## suffix ( \
+      int width, int height, \
+      const kvz_pixel *block1, int stride1, \
+      const kvz_pixel *block2, int stride2) \
+  { \
+    unsigned sum = 0; \
+    for (int y = 0; y < height; y += 8) { \
+      const kvz_pixel *row1 = &block1[y * stride1]; \
+      const kvz_pixel *row2 = &block2[y * stride2]; \
+      for (int x = 0; x < width; x += 8) { \
+        sum += satd_8x8_subblock_ ## suffix(&row1[x], stride1, &row2[x], stride2); \
+      } \
+    } \
+    return sum >> (KVZ_BIT_DEPTH - 8); \
+  }
+
 
 typedef unsigned(reg_sad_func)(const kvz_pixel *const data1, const kvz_pixel *const data2,
   const int width, const int height,
   const unsigned stride1, const unsigned stride2);
 typedef unsigned (cost_pixel_nxn_func)(const kvz_pixel *block1, const kvz_pixel *block2);
+typedef unsigned (cost_pixel_any_size_func)(
+    int width, int height,
+    const kvz_pixel *block1, int stride1,
+    const kvz_pixel *block2, int stride2
+);
+typedef void (cost_pixel_nxn_multi_func)(const pred_buffer preds, const kvz_pixel *orig, unsigned num_modes, unsigned *costs_out);
+
+typedef void pixels_blit_func(const kvz_pixel* orig, kvz_pixel *dst,
+                         unsigned width, unsigned height,
+                         unsigned orig_stride, unsigned dst_stride);
 
 
 // Declare function pointers.
@@ -43,12 +105,28 @@
 extern cost_pixel_nxn_func * kvz_satd_16x16;
 extern cost_pixel_nxn_func * kvz_satd_32x32;
 extern cost_pixel_nxn_func * kvz_satd_64x64;
+extern cost_pixel_any_size_func *kvz_satd_any_size;
+
+extern cost_pixel_nxn_multi_func * kvz_sad_4x4_dual;
+extern cost_pixel_nxn_multi_func * kvz_sad_8x8_dual;
+extern cost_pixel_nxn_multi_func * kvz_sad_16x16_dual;
+extern cost_pixel_nxn_multi_func * kvz_sad_32x32_dual;
+extern cost_pixel_nxn_multi_func * kvz_sad_64x64_dual;
+
+extern cost_pixel_nxn_multi_func * kvz_satd_4x4_dual;
+extern cost_pixel_nxn_multi_func * kvz_satd_8x8_dual;
+extern cost_pixel_nxn_multi_func * kvz_satd_16x16_dual;
+extern cost_pixel_nxn_multi_func * kvz_satd_32x32_dual;
+extern cost_pixel_nxn_multi_func * kvz_satd_64x64_dual;
+
+extern pixels_blit_func * kvz_pixels_blit;
 
 
 int kvz_strategy_register_picture(void* opaque, uint8_t bitdepth);
 cost_pixel_nxn_func * kvz_pixels_get_satd_func(unsigned n);
 cost_pixel_nxn_func * kvz_pixels_get_sad_func(unsigned n);
-
+cost_pixel_nxn_multi_func * kvz_pixels_get_satd_dual_func(unsigned n);
+cost_pixel_nxn_multi_func * kvz_pixels_get_sad_dual_func(unsigned n);
 
 #define STRATEGIES_PICTURE_EXPORTS \
   {"reg_sad", (void**) &kvz_reg_sad}, \
@@ -62,6 +140,18 @@
   {"satd_16x16", (void**) &kvz_satd_16x16}, \
   {"satd_32x32", (void**) &kvz_satd_32x32}, \
   {"satd_64x64", (void**) &kvz_satd_64x64}, \
+  {"satd_any_size", (void**) &kvz_satd_any_size}, \
+  {"sad_4x4_dual", (void**) &kvz_sad_4x4_dual}, \
+  {"sad_8x8_dual", (void**) &kvz_sad_8x8_dual}, \
+  {"sad_16x16_dual", (void**) &kvz_sad_16x16_dual}, \
+  {"sad_32x32_dual", (void**) &kvz_sad_32x32_dual}, \
+  {"sad_64x64_dual", (void**) &kvz_sad_64x64_dual}, \
+  {"satd_4x4_dual", (void**) &kvz_satd_4x4_dual}, \
+  {"satd_8x8_dual", (void**) &kvz_satd_8x8_dual}, \
+  {"satd_16x16_dual", (void**) &kvz_satd_16x16_dual}, \
+  {"satd_32x32_dual", (void**) &kvz_satd_32x32_dual}, \
+  {"satd_64x64_dual", (void**) &kvz_satd_64x64_dual}, \
+  {"pixels_blit", (void**) &kvz_pixels_blit}, \

kvazaar-0.7.2.tar.gz/src/strategies/strategies-quant.h -> kvazaar-0.8.1.tar.gz/src/strategies/strategies-quant.h Changed

kvazaar-0.7.2.tar.gz/src/strategies/x86_asm/picture-x86-asm-sad.h -> kvazaar-0.8.1.tar.gz/src/strategies/x86_asm/picture-x86-asm-sad.h Changed

kvazaar-0.7.2.tar.gz/src/strategies/x86_asm/picture-x86-asm-satd.h -> kvazaar-0.8.1.tar.gz/src/strategies/x86_asm/picture-x86-asm-satd.h Changed

kvazaar-0.7.2.tar.gz/src/strategies/x86_asm/picture-x86-asm.c -> kvazaar-0.8.1.tar.gz/src/strategies/x86_asm/picture-x86-asm.c Changed

kvazaar-0.7.2.tar.gz/src/strategies/x86_asm/picture-x86-asm.h -> kvazaar-0.8.1.tar.gz/src/strategies/x86_asm/picture-x86-asm.h Changed

kvazaar-0.7.2.tar.gz/src/strategyselector.c -> kvazaar-0.8.1.tar.gz/src/strategyselector.c Changed

kvazaar-0.7.2.tar.gz/src/strategyselector.h -> kvazaar-0.8.1.tar.gz/src/strategyselector.h Changed

kvazaar-0.7.2.tar.gz/src/tables.h -> kvazaar-0.8.1.tar.gz/src/tables.h Changed

kvazaar-0.7.2.tar.gz/src/threadqueue.c -> kvazaar-0.8.1.tar.gz/src/threadqueue.c Changed

@@ -82,7 +82,7 @@
   threadqueue_job_t * next_job = NULL;
   
 #ifdef KVZ_DEBUG
-  GET_TIME(&threadqueue->debug_clock_thread_start[threadqueue_worker_spec->worker_id]);
+  KVZ_GET_TIME(&threadqueue->debug_clock_thread_start[threadqueue_worker_spec->worker_id]);
 #endif //KVZ_DEBUG
 
   for(;;) {
@@ -150,14 +150,14 @@
       
 #ifdef KVZ_DEBUG
       job->debug_worker_id = threadqueue_worker_spec->worker_id;
-      GET_TIME(&job->debug_clock_start);
+      KVZ_GET_TIME(&job->debug_clock_start);
 #endif //KVZ_DEBUG
       
       job->fptr(job->arg);
       
 #ifdef KVZ_DEBUG
       job->debug_worker_id = threadqueue_worker_spec->worker_id;
-      GET_TIME(&job->debug_clock_stop);
+      KVZ_GET_TIME(&job->debug_clock_stop);
 #endif //KVZ_DEBUG
       
       //Re-lock the job to update its status and treat its dependencies
@@ -217,9 +217,9 @@
   --threadqueue->threads_running;
   
 #ifdef KVZ_DEBUG
-  GET_TIME(&threadqueue->debug_clock_thread_end[threadqueue_worker_spec->worker_id]);
+  KVZ_GET_TIME(&threadqueue->debug_clock_thread_end[threadqueue_worker_spec->worker_id]);
   
-  fprintf(threadqueue->debug_log, "\t%d\t-\t%lf\t+%lf\t-\tthread\n", threadqueue_worker_spec->worker_id, CLOCK_T_AS_DOUBLE(threadqueue->debug_clock_thread_start[threadqueue_worker_spec->worker_id]), CLOCK_T_DIFF(threadqueue->debug_clock_thread_start[threadqueue_worker_spec->worker_id], threadqueue->debug_clock_thread_end[threadqueue_worker_spec->worker_id]));
+  fprintf(threadqueue->debug_log, "\t%d\t-\t%lf\t+%lf\t-\tthread\n", threadqueue_worker_spec->worker_id, KVZ_CLOCK_T_AS_DOUBLE(threadqueue->debug_clock_thread_start[threadqueue_worker_spec->worker_id]), KVZ_CLOCK_T_DIFF(threadqueue->debug_clock_thread_start[threadqueue_worker_spec->worker_id], threadqueue->debug_clock_thread_end[threadqueue_worker_spec->worker_id]));
 #endif //KVZ_DEBUG
   
   PTHREAD_UNLOCK(&threadqueue->lock);
@@ -260,9 +260,9 @@
     return 0;
   }
 #ifdef KVZ_DEBUG
-  threadqueue->debug_clock_thread_start = MALLOC(CLOCK_T, thread_count);
+  threadqueue->debug_clock_thread_start = MALLOC(KVZ_CLOCK_T, thread_count);
   assert(threadqueue->debug_clock_thread_start);
-  threadqueue->debug_clock_thread_end = MALLOC(CLOCK_T, thread_count);
+  threadqueue->debug_clock_thread_end = MALLOC(KVZ_CLOCK_T, thread_count);
   assert(threadqueue->debug_clock_thread_end);
   threadqueue->debug_log = fopen("threadqueue.log", "w");
 #endif //KVZ_DEBUG
@@ -309,8 +309,8 @@
 #ifdef KVZ_DEBUG
 #if KVZ_DEBUG & KVZ_PERF_JOB
   int j;
-  GET_TIME(&threadqueue->queue[i]->debug_clock_dequeue);
-  fprintf(threadqueue->debug_log, "%p\t%d\t%lf\t+%lf\t+%lf\t+%lf\t%s\n", threadqueue->queue[i], threadqueue->queue[i]->debug_worker_id, CLOCK_T_AS_DOUBLE(threadqueue->queue[i]->debug_clock_enqueue), CLOCK_T_DIFF(threadqueue->queue[i]->debug_clock_enqueue, threadqueue->queue[i]->debug_clock_start), CLOCK_T_DIFF(threadqueue->queue[i]->debug_clock_start, threadqueue->queue[i]->debug_clock_stop), CLOCK_T_DIFF(threadqueue->queue[i]->debug_clock_stop, threadqueue->queue[i]->debug_clock_dequeue), threadqueue->queue[i]->debug_description);
+  KVZ_GET_TIME(&threadqueue->queue[i]->debug_clock_dequeue);
+  fprintf(threadqueue->debug_log, "%p\t%d\t%lf\t+%lf\t+%lf\t+%lf\t%s\n", threadqueue->queue[i], threadqueue->queue[i]->debug_worker_id, KVZ_CLOCK_T_AS_DOUBLE(threadqueue->queue[i]->debug_clock_enqueue), KVZ_CLOCK_T_DIFF(threadqueue->queue[i]->debug_clock_enqueue, threadqueue->queue[i]->debug_clock_start), KVZ_CLOCK_T_DIFF(threadqueue->queue[i]->debug_clock_start, threadqueue->queue[i]->debug_clock_stop), KVZ_CLOCK_T_DIFF(threadqueue->queue[i]->debug_clock_stop, threadqueue->queue[i]->debug_clock_dequeue), threadqueue->queue[i]->debug_description);
 
   for (j = 0; j < threadqueue->queue[i]->rdepends_count; ++j) {
     fprintf(threadqueue->debug_log, "%p->%p\n", threadqueue->queue[i], threadqueue->queue[i]->rdepends[j]);
@@ -336,10 +336,10 @@
 #ifdef KVZ_DEBUG
 #if KVZ_DEBUG & KVZ_PERF_JOB
   {
-    CLOCK_T time;
-    GET_TIME(&time);
+    KVZ_CLOCK_T time;
+    KVZ_GET_TIME(&time);
    
-    fprintf(threadqueue->debug_log, "\t\t-\t-\t%lf\t-\tFLUSH\n", CLOCK_T_AS_DOUBLE(time));
+    fprintf(threadqueue->debug_log, "\t\t-\t-\t%lf\t-\tFLUSH\n", KVZ_CLOCK_T_AS_DOUBLE(time));
   }
 #endif
 #endif
@@ -439,7 +439,7 @@
       int ret;
       PTHREAD_COND_BROADCAST(&(threadqueue->cond));
       PTHREAD_UNLOCK(&threadqueue->lock);
-      SLEEP();
+      KVZ_SLEEP();
       PTHREAD_LOCK(&threadqueue->lock);
       ret = pthread_cond_timedwait(&threadqueue->cb_cond, &threadqueue->lock, &kvz_time_to_wait);
       if (ret != 0 && ret != ETIMEDOUT) {
@@ -477,7 +477,7 @@
       int ret;
       PTHREAD_COND_BROADCAST(&(threadqueue->cond));
       PTHREAD_UNLOCK(&threadqueue->lock);
-      SLEEP();
+      KVZ_SLEEP();
       PTHREAD_LOCK(&threadqueue->lock);
       ret = pthread_cond_timedwait(&threadqueue->cb_cond, &threadqueue->lock, &kvz_time_to_wait);
       if (ret != 0 && ret != ETIMEDOUT) {
@@ -541,7 +541,7 @@
     
     job->debug_description = desc;
   }
-  GET_TIME(&job->debug_clock_enqueue);
+  KVZ_GET_TIME(&job->debug_clock_enqueue);
 #endif //KVZ_DEBUG
   
   if (!job) {
@@ -647,7 +647,7 @@
 }
 
 #ifdef KVZ_DEBUG
-int threadqueue_log(threadqueue_queue_t * threadqueue, const CLOCK_T *start, const CLOCK_T *stop, const char* debug_description) {
+int threadqueue_log(threadqueue_queue_t * threadqueue, const KVZ_CLOCK_T *start, const KVZ_CLOCK_T *stop, const char* debug_description) {
   int i, thread_id = -1;
   FILE* output;
   
@@ -673,15 +673,15 @@
   
   if (thread_id >= 0) {
     if (stop) {
-      fprintf(output, "\t%d\t-\t%lf\t+%lf\t-\t%s\n", thread_id, CLOCK_T_AS_DOUBLE(*start), CLOCK_T_DIFF(*start, *stop), debug_description);
+      fprintf(output, "\t%d\t-\t%lf\t+%lf\t-\t%s\n", thread_id, KVZ_CLOCK_T_AS_DOUBLE(*start), KVZ_CLOCK_T_DIFF(*start, *stop), debug_description);
     } else {
-      fprintf(output, "\t%d\t-\t%lf\t-\t-\t%s\n", thread_id, CLOCK_T_AS_DOUBLE(*start), debug_description);
+      fprintf(output, "\t%d\t-\t%lf\t-\t-\t%s\n", thread_id, KVZ_CLOCK_T_AS_DOUBLE(*start), debug_description);
     }
   } else {
     if (stop) {
-      fprintf(output, "\t\t-\t%lf\t+%lf\t-\t%s\n", CLOCK_T_AS_DOUBLE(*start), CLOCK_T_DIFF(*start, *stop), debug_description);
+      fprintf(output, "\t\t-\t%lf\t+%lf\t-\t%s\n", KVZ_CLOCK_T_AS_DOUBLE(*start), KVZ_CLOCK_T_DIFF(*start, *stop), debug_description);
     } else {
-      fprintf(output, "\t\t-\t%lf\t-\t-\t%s\n", CLOCK_T_AS_DOUBLE(*start), debug_description);
+      fprintf(output, "\t\t-\t%lf\t-\t-\t%s\n", KVZ_CLOCK_T_AS_DOUBLE(*start), debug_description);
     }
   }

kvazaar-0.7.2.tar.gz/src/threadqueue.h -> kvazaar-0.8.1.tar.gz/src/threadqueue.h Changed

@@ -20,6 +20,12 @@
  * with Kvazaar.  If not, see <http://www.gnu.org/licenses/>.
  ****************************************************************************/
 
+/**
+ * \ingroup Threading
+ * \file
+ * Container for worker tasks.
+ */
+
 #include "global.h"
 
 #include <pthread.h>
@@ -51,10 +57,10 @@
   
   int debug_worker_id;
   
-  CLOCK_T debug_clock_enqueue;
-  CLOCK_T debug_clock_start;
-  CLOCK_T debug_clock_stop;
-  CLOCK_T debug_clock_dequeue;
+  KVZ_CLOCK_T debug_clock_enqueue;
+  KVZ_CLOCK_T debug_clock_start;
+  KVZ_CLOCK_T debug_clock_stop;
+  KVZ_CLOCK_T debug_clock_dequeue;
 #endif
 } threadqueue_job_t;
 
@@ -91,8 +97,8 @@
 
   FILE *debug_log;
   
-  CLOCK_T *debug_clock_thread_start;
-  CLOCK_T *debug_clock_thread_end;
+  KVZ_CLOCK_T *debug_clock_thread_start;
+  KVZ_CLOCK_T *debug_clock_thread_end;
 #endif
 } threadqueue_queue_t;
 
@@ -117,7 +123,7 @@
 int kvz_threadqueue_finalize(threadqueue_queue_t * threadqueue);
 
 #ifdef KVZ_DEBUG
-int threadqueue_log(threadqueue_queue_t * threadqueue, const CLOCK_T *start, const CLOCK_T *stop, const char* debug_description);
+int threadqueue_log(threadqueue_queue_t * threadqueue, const KVZ_CLOCK_T *start, const KVZ_CLOCK_T *stop, const char* debug_description);
 
 // Bitmasks for PERFORMANCE_MEASURE_START and PERFORMANCE_MEASURE_END.
 #define KVZ_PERF_FRAME    (1 << 0)
@@ -128,7 +134,7 @@
 #define KVZ_PERF_SEARCHCU (1 << 5)
 #define KVZ_PERF_SEARCHPX (1 << 6)
 
-#define IMPL_PERFORMANCE_MEASURE_START(mask) CLOCK_T start, stop; if ((KVZ_DEBUG) & mask) { GET_TIME(&start); }
+#define IMPL_PERFORMANCE_MEASURE_START(mask) KVZ_CLOCK_T start, stop; if ((KVZ_DEBUG) & mask) { GET_TIME(&start); }
 #define IMPL_PERFORMANCE_MEASURE_END(mask, threadqueue, str, ...) { if ((KVZ_DEBUG) & mask) { GET_TIME(&stop); {char job_description[256]; sprintf(job_description, (str), __VA_ARGS__); threadqueue_log((threadqueue), &start, &stop, job_description);}} } \
 
 #ifdef _MSC_VER

kvazaar-0.7.2.tar.gz/src/threads.h -> kvazaar-0.8.1.tar.gz/src/threads.h Changed

@@ -20,6 +20,12 @@
  * with Kvazaar.  If not, see <http://www.gnu.org/licenses/>.
  ****************************************************************************/
 
+/**
+ * \ingroup Threading
+ * \file
+ * Abstractions for operating system specific stuff.
+ */
+
 #include "global.h"
 
 #include <pthread.h>
@@ -28,13 +34,13 @@
 #include <unistd.h>
 #include <time.h>
 
-#define CLOCK_T struct timespec
+#define KVZ_CLOCK_T struct timespec
 
 #ifdef __MACH__
 // Workaround Mac OS not having clock_gettime.
 #include <mach/clock.h>
 #include <mach/mach.h>
-#define GET_TIME(clock_t) { \
+#define KVZ_GET_TIME(clock_t) { \
   clock_serv_t cclock; \
   mach_timespec_t mts; \
   host_get_clock_service(mach_host_self(), SYSTEM_CLOCK, &cclock); \
@@ -44,33 +50,33 @@
   (clock_t)->tv_nsec = mts.tv_nsec; \
 }
 #else
-#define GET_TIME(clock_t) clock_gettime(CLOCK_MONOTONIC, (clock_t))
+#define KVZ_GET_TIME(clock_t) { clock_gettime(CLOCK_MONOTONIC, (clock_t)); }
 #endif
 
-#define CLOCK_T_AS_DOUBLE(ts) ((double)((ts).tv_sec) + (double)((ts).tv_nsec) / (double)1000000000L)
-#define CLOCK_T_DIFF(start, stop) ((double)((stop).tv_sec - (start).tv_sec) + (double)((stop).tv_nsec - (start).tv_nsec) / (double)1000000000L)
+#define KVZ_CLOCK_T_AS_DOUBLE(ts) ((double)((ts).tv_sec) + (double)((ts).tv_nsec) / (double)1000000000L)
+#define KVZ_CLOCK_T_DIFF(start, stop) ((double)((stop).tv_sec - (start).tv_sec) + (double)((stop).tv_nsec - (start).tv_nsec) / (double)1000000000L)
 
-#define ATOMIC_INC(ptr)                     __sync_add_and_fetch((volatile int32_t*)ptr, 1)
-#define ATOMIC_DEC(ptr)                     __sync_add_and_fetch((volatile int32_t*)ptr, -1)
-#define SLEEP()                             usleep(0)
+#define KVZ_ATOMIC_INC(ptr)                     __sync_add_and_fetch((volatile int32_t*)ptr, 1)
+#define KVZ_ATOMIC_DEC(ptr)                     __sync_add_and_fetch((volatile int32_t*)ptr, -1)
+#define KVZ_SLEEP()                             usleep(0)
 
 #else //__GNUC__
 //TODO: we assume !GCC => Windows... this may be bad
-#include <Windows.h>
+#include <windows.h>
 
-#define CLOCK_T struct _FILETIME
-#define GET_TIME(clock_t) GetSystemTimeAsFileTime(clock_t)
+#define KVZ_CLOCK_T struct _FILETIME
+#define KVZ_GET_TIME(clock_t) { GetSystemTimeAsFileTime(clock_t); }
 // _FILETIME has 32bit low and high part of 64bit 100ns resolution timestamp (since 12:00 AM January 1, 1601)
-#define CLOCK_T_AS_DOUBLE(ts) ((double)(((uint64_t)(ts).dwHighDateTime)<<32 | (uint64_t)(ts).dwLowDateTime) / (double)10000000L)
-#define CLOCK_T_DIFF(start, stop) ((double)((((uint64_t)(stop).dwHighDateTime)<<32 | (uint64_t)(stop).dwLowDateTime) - \
+#define KVZ_CLOCK_T_AS_DOUBLE(ts) ((double)(((uint64_t)(ts).dwHighDateTime)<<32 | (uint64_t)(ts).dwLowDateTime) / (double)10000000L)
+#define KVZ_CLOCK_T_DIFF(start, stop) ((double)((((uint64_t)(stop).dwHighDateTime)<<32 | (uint64_t)(stop).dwLowDateTime) - \
                                   (((uint64_t)(start).dwHighDateTime)<<32 | (uint64_t)(start).dwLowDateTime)) / (double)10000000L)
 
 
-#define ATOMIC_INC(ptr)                     InterlockedIncrement((volatile LONG*)ptr)
-#define ATOMIC_DEC(ptr)                     InterlockedDecrement((volatile LONG*)ptr)
+#define KVZ_ATOMIC_INC(ptr)                     InterlockedIncrement((volatile LONG*)ptr)
+#define KVZ_ATOMIC_DEC(ptr)                     InterlockedDecrement((volatile LONG*)ptr)
 // Sleep(0) results in bad performance on Windows for some reason,
 // As a work around sleep for 10ms.
-#define SLEEP()                             Sleep(10)
+#define KVZ_SLEEP()                             Sleep(10)
 
 #endif //__GNUC__

kvazaar-0.7.2.tar.gz/src/transform.c -> kvazaar-0.8.1.tar.gz/src/transform.c Changed

@@ -18,10 +18,6 @@
  * with Kvazaar.  If not, see <http://www.gnu.org/licenses/>.
  ****************************************************************************/
 
-/*
- * \file
- */
-
 #include "transform.h"
 
 #include <string.h>
@@ -35,6 +31,7 @@
 #include "strategies/strategies-dct.h"
 #include "strategies/strategies-quant.h"
 #include "strategies/generic/quant-generic.h"
+#include "strategies/strategies-picture.h"
 
 //////////////////////////////////////////////////////////////////////////
 // INITIALIZATIONS
@@ -219,10 +216,10 @@
 void kvz_quantize_lcu_luma_residual(encoder_state_t * const state, int32_t x, int32_t y, const uint8_t depth, cu_info_t *cur_cu, lcu_t* lcu)
 {
   // we have 64>>depth transform size
-  const vector2d_t lcu_px = {x & 0x3f, y & 0x3f};
+  const vector2d_t lcu_px = { SUB_SCU(x), SUB_SCU(y) };
   const int pu_index = PU_INDEX(lcu_px.x / 4, lcu_px.y / 4);
   if (cur_cu == NULL) {
-    cur_cu = &lcu->cu[LCU_CU_OFFSET + (lcu_px.x >> 3) + (lcu_px.y >> 3)*LCU_T_CU_WIDTH];
+    cur_cu = LCU_GET_CU_AT_PX(lcu, lcu_px.x, lcu_px.y);
   }
   const int8_t width = LCU_WIDTH>>depth;
   
@@ -240,9 +237,9 @@
 
     // Propagate coded block flags from child CUs to parent CU.
     if (depth < MAX_DEPTH) {
-      cu_info_t *cu_a = &lcu->cu[LCU_CU_OFFSET + ((lcu_px.x + offset) >> 3) + (lcu_px.y >> 3)        *LCU_T_CU_WIDTH];
-      cu_info_t *cu_b = &lcu->cu[LCU_CU_OFFSET + (lcu_px.x >> 3) + ((lcu_px.y + offset) >> 3)*LCU_T_CU_WIDTH];
-      cu_info_t *cu_c = &lcu->cu[LCU_CU_OFFSET + ((lcu_px.x + offset) >> 3) + ((lcu_px.y + offset) >> 3)*LCU_T_CU_WIDTH];
+      cu_info_t *cu_a = LCU_GET_CU_AT_PX(lcu, lcu_px.x + offset, lcu_px.y);
+      cu_info_t *cu_b = LCU_GET_CU_AT_PX(lcu, lcu_px.x,          lcu_px.y + offset);
+      cu_info_t *cu_c = LCU_GET_CU_AT_PX(lcu, lcu_px.x + offset, lcu_px.y + offset);
       if (cbf_is_set(cu_a->cbf.y, depth+1) || cbf_is_set(cu_b->cbf.y, depth+1) || cbf_is_set(cu_c->cbf.y, depth+1)) {
         cbf_set(&cur_cu->cbf.y, depth);
       }
@@ -303,11 +300,11 @@
 void kvz_quantize_lcu_chroma_residual(encoder_state_t * const state, int32_t x, int32_t y, const uint8_t depth, cu_info_t *cur_cu, lcu_t* lcu)
 {
   // we have 64>>depth transform size
-  const vector2d_t lcu_px = {x & 0x3f, y & 0x3f};
+  const vector2d_t lcu_px = { SUB_SCU(x), SUB_SCU(y) };
   const int pu_index = PU_INDEX(lcu_px.x / 4, lcu_px.y / 4);
   const int8_t width = LCU_WIDTH>>depth;
   if (cur_cu == NULL) {
-    cur_cu = &lcu->cu[LCU_CU_OFFSET + (lcu_px.x >> 3) + (lcu_px.y >> 3)*LCU_T_CU_WIDTH];
+    cur_cu = LCU_GET_CU_AT_PX(lcu, lcu_px.x, lcu_px.y);
   }
   
   // Tell clang-analyzer what is up. For some reason it can't figure out from
@@ -324,9 +321,9 @@
 
     // Propagate coded block flags from child CUs to parent CU.
     if (depth < MAX_DEPTH) {
-      cu_info_t *cu_a = &lcu->cu[LCU_CU_OFFSET + ((lcu_px.x + offset) >> 3) + (lcu_px.y >> 3)        *LCU_T_CU_WIDTH];
-      cu_info_t *cu_b = &lcu->cu[LCU_CU_OFFSET + (lcu_px.x >> 3) + ((lcu_px.y + offset) >> 3)*LCU_T_CU_WIDTH];
-      cu_info_t *cu_c = &lcu->cu[LCU_CU_OFFSET + ((lcu_px.x + offset) >> 3) + ((lcu_px.y + offset) >> 3)*LCU_T_CU_WIDTH];
+      cu_info_t *cu_a = LCU_GET_CU_AT_PX(lcu, lcu_px.x + offset, lcu_px.y);
+      cu_info_t *cu_b = LCU_GET_CU_AT_PX(lcu, lcu_px.x,          lcu_px.y + offset);
+      cu_info_t *cu_c = LCU_GET_CU_AT_PX(lcu, lcu_px.x + offset, lcu_px.y + offset);
       if (cbf_is_set(cu_a->cbf.u, depth+1) || cbf_is_set(cu_b->cbf.u, depth+1) || cbf_is_set(cu_c->cbf.u, depth+1)) {
         cbf_set(&cur_cu->cbf.u, depth);
       }

kvazaar-0.7.2.tar.gz/src/transform.h -> kvazaar-0.8.1.tar.gz/src/transform.h Changed

kvazaar-0.7.2.tar.gz/src/videoframe.c -> kvazaar-0.8.1.tar.gz/src/videoframe.c Changed

@@ -18,13 +18,8 @@
  * with Kvazaar.  If not, see <http://www.gnu.org/licenses/>.
  ****************************************************************************/
 
-/*
- * \file
- */
-
 #include <stdlib.h>
 #include <string.h>
-#include <math.h>
 
 #include "sao.h"
 #include "threads.h"
@@ -109,42 +104,3 @@
   
   return &frame->cu_array->data[x_in_scu + y_in_scu * (frame->width_in_lcu << MAX_DEPTH)];
 }
-
-#if KVZ_BIT_DEPTH == 8
-#define PSNRMAX (255.0 * 255.0)
-#else
-  #define PSNRMAX ((double)PIXEL_MAX * (double)PIXEL_MAX)
-#endif
-
-/**
- * \brief Calculates image PSNR value
- *
- * \param src   source picture
- * \param rec   reconstructed picture
- * \prama psnr  returns the PSNR
- */
-void kvz_videoframe_compute_psnr(const kvz_picture *const src,
-                                 const kvz_picture *const rec,
-                                 double psnr[NUM_COLORS])
-{
-  assert(src->width  == rec->width);
-  assert(src->height == rec->height);
-
-  int32_t pixels = src->width * src->height;
-
-  for (int32_t c = 0; c < NUM_COLORS; ++c) {
-    int32_t num_pixels = pixels;
-    if (c != COLOR_Y) {
-      num_pixels >>= 2;
-    }
-    psnr[c] = 0;
-    for (int32_t i = 0; i < num_pixels; ++i) {
-      const int32_t error = src->data[c][i] - rec->data[c][i];
-      psnr[c] += error * error;
-    }
-
-    // Avoid division by zero
-    if (psnr[c] == 0) psnr[c] = 99.0;
-    psnr[c] = 10 * log10((num_pixels * PSNRMAX) / ((double)psnr[c]));;
-  }
-}

kvazaar-0.7.2.tar.gz/src/videoframe.h -> kvazaar-0.8.1.tar.gz/src/videoframe.h Changed

kvazaar-0.8.1.tar.gz/tests/Makefile.am Added

kvazaar-0.8.1.tar.gz/tests/mv_cand_tests.c Added

@@ -0,0 +1,62 @@
+/*****************************************************************************
+ * This file is part of Kvazaar HEVC encoder.
+ *
+ * Copyright (C) 2013-2015 Tampere University of Technology and others (see
+ * COPYING file).
+ *
+ * Kvazaar is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 2.1 as
+ * published by the Free Software Foundation.
+ *
+ * Kvazaar 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Kvazaar.  If not, see <http://www.gnu.org/licenses/>.
+ ****************************************************************************/
+
+#include <string.h>
+
+#include "greatest/greatest.h"
+
+#include "src/cu.h"
+#include "src/inter.h"
+
+TEST test_get_spatial_merge_cand(void)
+{
+  lcu_t lcu;
+  memset(&lcu, 0, sizeof(lcu));
+  for (int i = 0; i < sizeof(lcu.cu) / sizeof(cu_info_t); i++) {
+    lcu.cu[i].coded = 1;
+    lcu.cu[i].type = CU_INTER;
+  }
+  lcu.cu[20].coded = 1;
+  lcu.cu[22].coded = 1;
+  lcu.cu[23].coded = 1;
+  lcu.cu[56].coded = 1;
+  lcu.cu[65].coded = 1;
+
+  cu_info_t *mv_cand[5] = { NULL };
+  kvz_inter_get_spatial_merge_candidates(16, 16, // x, y
+                                         16, 32, // width, height
+                                         &mv_cand[0], // b0
+                                         &mv_cand[1], // b1
+                                         &mv_cand[2], // b2
+                                         &mv_cand[3], // a0
+                                         &mv_cand[4], // a1
+                                         &lcu);
+
+  ASSERT_EQ(mv_cand[0], &lcu.cu[23]); // b0
+  ASSERT_EQ(mv_cand[1], &lcu.cu[22]); // b1
+  ASSERT_EQ(mv_cand[2], &lcu.cu[20]); // b2
+  ASSERT_EQ(mv_cand[3], &lcu.cu[65]); // a0
+  ASSERT_EQ(mv_cand[4], &lcu.cu[56]); // a1
+
+  PASS();
+}
+
+SUITE(mv_cand_tests) {
+  RUN_TEST(test_get_spatial_merge_cand);
+}

kvazaar-0.7.2.tar.gz/tests/speed_tests.c -> kvazaar-0.8.1.tar.gz/tests/speed_tests.c Changed

@@ -99,14 +99,14 @@
 {
   const int size = width * width;
   uint64_t call_cnt = 0;
-  CLOCK_T clock_now;
-  GET_TIME(&clock_now);
-  double test_end = CLOCK_T_AS_DOUBLE(clock_now) + TIME_PER_TEST;
+  KVZ_CLOCK_T clock_now;
+  KVZ_GET_TIME(&clock_now);
+  double test_end = KVZ_CLOCK_T_AS_DOUBLE(clock_now) + TIME_PER_TEST;
 
   // Loop until time allocated for test has passed.
   for (unsigned i = 0; 
-      test_end > CLOCK_T_AS_DOUBLE(clock_now);
-      ++i, GET_TIME(&clock_now))
+      test_end > KVZ_CLOCK_T_AS_DOUBLE(clock_now);
+      ++i)
   {
     int test = i % NUM_TESTS;
     uint64_t sum = 0;
@@ -123,6 +123,7 @@
     }
 
     ASSERT(sum > 0);
+    KVZ_GET_TIME(&clock_now)
   }
 
   sprintf(test_env.msg, "%.3fM x %s:%s",
@@ -137,14 +138,14 @@
 {
   const int size = width * width;
   unsigned call_cnt = 0;
-  CLOCK_T clock_now;
-  GET_TIME(&clock_now);
-  double test_end = CLOCK_T_AS_DOUBLE(clock_now) + TIME_PER_TEST;
+  KVZ_CLOCK_T clock_now;
+  KVZ_GET_TIME(&clock_now);
+  double test_end = KVZ_CLOCK_T_AS_DOUBLE(clock_now) + TIME_PER_TEST;
 
   // Loop until time allocated for test has passed.
   for (unsigned i = 0;
-      test_end > CLOCK_T_AS_DOUBLE(clock_now);
-      ++i, GET_TIME(&clock_now))
+      test_end > KVZ_CLOCK_T_AS_DOUBLE(clock_now);
+      ++i)
   {
     int test = i % NUM_TESTS;
     uint64_t sum = 0;
@@ -166,6 +167,7 @@
       }
     }
     ASSERT(sum > 0);
+    KVZ_GET_TIME(&clock_now)
   }
 
   sprintf(test_env.msg, "%.3fM x %s(%ix%i):%s",
@@ -184,9 +186,9 @@
   uint64_t call_cnt = 0;
   dct_func * tested_func = test_env.strategy->fptr;
 
-  CLOCK_T clock_now;
-  GET_TIME(&clock_now);
-  double test_end = CLOCK_T_AS_DOUBLE(clock_now) + TIME_PER_TEST;
+  KVZ_CLOCK_T clock_now;
+  KVZ_GET_TIME(&clock_now);
+  double test_end = KVZ_CLOCK_T_AS_DOUBLE(clock_now) + TIME_PER_TEST;
 
   int16_t _tmp_residual[32 * 32 + SIMD_ALIGNMENT];
   int16_t _tmp_coeffs[32 * 32 + SIMD_ALIGNMENT];
@@ -195,8 +197,8 @@
   
   // Loop until time allocated for test has passed.
   for (unsigned i = 0;
-    test_end > CLOCK_T_AS_DOUBLE(clock_now);
-    ++i, GET_TIME(&clock_now))
+    test_end > KVZ_CLOCK_T_AS_DOUBLE(clock_now);
+    ++i)
   {
     int test = i % NUM_TESTS;
     uint64_t sum = 0;
@@ -216,6 +218,7 @@
     }
 
     ASSERT(sum > 0);
+    KVZ_GET_TIME(&clock_now)
   }
   
   sprintf(test_env.msg, "%.3fM x %s:%s",

kvazaar-0.7.2.tar.gz/tests/tests_main.c -> kvazaar-0.8.1.tar.gz/tests/tests_main.c Changed

Overview

Request 2403 (accepted)

Request History