Request 5653 (accepted)

Overview

Request 5653 (accepted)

Update to 2.2.0

Created by Aloysius over 1 year ago
In state accepted
Package maintainer: Aloysius

Submit kvazaar

Submit package home:Aloysius:branches:Essentials / kvazaar to package Essentials / kvazaar

kvazaar.changes Changed

@@ -1,4 +1,40 @@
 -------------------------------------------------------------------
+Wed Jan  4 11:29:30 UTC 2023 - Luigi Baldoni <aloisio@gmx.com>
+
+- Update to version 2.2.0
+  Features:
+  * Updated Region of Interest (ROI) functionality to allow
+    separate ROI map for each frame
+  * Improve inter search
+  * Update cabac context during search to improve the accuracy
+    of bit cost estimation
+  * Move intra chroma search option from --rd 3 to its own
+    option --(no-)intra-chroma-search and fast bipred to
+    --(no-)fast-bipred
+  * Change maximum rd level to 4, where 3 performs more rd
+    search for inter and 4 performs full intra search
+  * Add --(no-)combine-intra-cus for controlling whether the
+    larger intra blocks are tried even when search at current
+    depth is disabled
+  * Add --force-inter for debugging purposes to force all PUs in
+    inter slices to use best inter mode
+  Optimizations:
+  * AVX2 implementations of bidirectional blending
+  Fixes:
+  * Make sure the dpb is more than max_num_reorder_pics 899c672
+  * Compute proper count of buffered frames for vps and sps. Use
+    common function d4880be
+  * Fix some strategy function pointer signatures a400504
+  External contributors:
+  * build: fix automake warning by @bradh
+  * cli: add missing newlines in usage by @bradh
+  * refactor SEI by @bradh
+  * cli: minor api doc fix by @bradh
+  * add sudo ldconfig by @binbinzhm
+  * Enable -mpopcnt and -mlzcnt on AVX2 by @klondi
+- Bump sover to 7
+
+-------------------------------------------------------------------
 Wed Oct 13 15:32:42 UTC 2021 - Luigi Baldoni <aloisio@gmx.com>
 
 - Update to version 2.1.0

kvazaar.spec Changed

kvazaar-2.1.0.tar.gz/LICENSE -> kvazaar-2.2.0.tar.gz/LICENSE Changed

kvazaar-2.2.0.tar.gz/LICENSE.EXT.greatest Changed

kvazaar-2.2.0.tar.gz/LICENSE.EXT.x264asm Changed

kvazaar-2.1.0.tar.gz/Makefile.am -> kvazaar-2.2.0.tar.gz/Makefile.am Changed

kvazaar-2.1.0.tar.gz/README.md -> kvazaar-2.2.0.tar.gz/README.md Changed

@@ -2,7 +2,7 @@
 =======
 An open-source HEVC encoder licensed under 3-clause BSD
 
-Join channel #ultravideo(https://web.libera.chat/#ultravideo) in Libera.Chat(https://libera.chat/) IRC network to contact us.
+Join channel #ultravideo(https://web.libera.chat/#ultravideo) in Libera.Chat(https://libera.chat/) IRC network to contact us or come to our Discord !Discord(https://img.shields.io/discord/973260924288901140?style=plastic)(https://discord.gg/fZpub7BPUA)
 
 Kvazaar is still under development. Speed and RD-quality will continue to improve.
 
@@ -49,7 +49,7 @@
 
 ### Parameters
 
-comment: # (BEGIN KVAZAAR HELP MESSAGE)
+comment: # "BEGIN KVAZAAR HELP MESSAGE"
 ```
 Usage:
 kvazaar -i <input> --input-res <width>x<height> -o <output>
@@ -156,11 +156,20 @@
                                    - frametile: Constrain within the tile.
                                    - frametilemargin: Constrain even more.
       --roi <filename>       : Use a delta QP map for region of interest.
-                               Reads an array of delta QP values from a text
-                               file. The file format is: width and height of
-                               the QP delta map followed by width*height delta
-                               QP values in raster order. The map can be of any
-                               size and will be scaled to the video size.
+                               Reads an array of delta QP values from a file.
+                               Text and binary files are supported and detected
+                               from the file extension (.txt/.bin). If a known
+                               extension is not found, the file is treated as
+                               a text file. The file can include one or many
+                               ROI frames each in the following format:
+                               width and height of the QP delta map followed
+                               by width * height delta QP values in raster
+                               order. In binary format, width and height are
+                               32-bit integers whereas the delta QP values are
+                               signed 8-bit values. The map can be of any size
+                               and will be scaled to the video size. The file
+                               reading will loop if end of the file is reached.
+                               See roi.txt in the examples folder.
       --set-qp-in-cu         : Set QP at CU level keeping pic_init_qp_minus26.
                                in PPS and slice_qp_delta in slize header zero.
       --(no-)erp-aqp         : Use adaptive QP for 360 degree video with
@@ -191,18 +200,22 @@
       --(no-)signhide        : Sign hiding disabled
       --(no-)smp             : Symmetric motion partition disabled
       --(no-)amp             : Asymmetric motion partition disabled
-      --rd <integer>         : Intra mode search complexity 0
+      --rd <integer>         : Mode search complexity 0
                                    - 0: Skip intra if inter is good enough.
                                    - 1: Rough intra mode search with SATD.
-                                   - 2: Refine intra mode search with SSE.
-                                   - 3: Try all intra modes and enable intra
-                                        chroma mode search.
+                                   - 2: Refine mode search with SSE.
+                                   - 3: More SSE candidates for inter and
+                                        chroma mode search for 4x4 intra.
+                                   - 4: Even more SSE candidates for both.
+                                   - 5: Try all intra modes.
       --(no-)mv-rdo          : Rate-distortion optimized motion vector costs
                                disabled
       --(no-)zero-coeff-rdo  : If a CU is set inter, check if forcing zero
                                residual improves the RD cost. enabled
       --(no-)full-intra-search : Try all intra modes during rough search.
                                disabled
+      --(no-)intra-chroma-search : Test non-derived intra chroma modes.
+                                   disabled
       --(no-)transform-skip  : Try transform skip disabled
       --me <string>          : Integer motion estimation algorithm hexbs
                                    - hexbs: Hexagon Based Search
@@ -218,6 +231,7 @@
                                    - 2: + 1/2-pixel diagonal
                                    - 3: + 1/4-pixel horizontal and vertical
                                    - 4: + 1/4-pixel diagonal
+      --(no-)fast-bipred     : Only perform fast bipred search. enabled
       --pu-depth-inter <int>-<int> : Inter prediction units sizes 0-3
                                    - 0, 1, 2, 3: from 64x64 to 8x8
                                    - Accepts a list of values separated by ','
@@ -233,6 +247,16 @@
       --ml-pu-depth-intra    : Predict the pu-depth-intra using machine
                                 learning trees, overrides the
                                 --pu-depth-intra parameter. disabled
+      --(no-)combine-intra-cus: Whether the encoder tries to code a cu
+                                   on lower depth even when search is not
+                                   performed on said depth. Should only
+                                   be disabled if cus absolutely must not
+                                   be larger than limited by the search.
+                                   enabled
+      --force-inter          : Force the encoder to use inter always.
+                               This is mostly for debugging and is not
+                               guaranteed to produce sensible bitstream or
+                               work at all. disabled
       --tr-depth-intra <int> : Transform split depth for intra blocks 0
       --(no-)bipred          : Bi-prediction disabled
       --cu-split-termination <string> : CU split search termination zero
@@ -287,8 +311,8 @@
                                    - u<int>: Number of tile columns of uniform
                                              width.
       --tiles-height-split <string>|u<int> :
-                                   - <string>: A comma-separated list of tile row
-                                               column pixel coordinates.
+                                   - <string>: A comma-separated list of tile
+                                               row column pixel coordinates.
                                    - u<int>: Number of tile rows of uniform
                                              height.
       --slices <string>      : Control how slices are used.
@@ -328,7 +352,7 @@
   -w, --width <integer>       : Use --input-res.
   -h, --height <integer>      : Use --input-res.
 ```
-comment: # (END KVAZAAR HELP MESSAGE)
+comment: # "END KVAZAAR HELP MESSAGE"
 
 
 ### LP-GOP syntax
@@ -410,6 +434,7 @@
     ./configure
     make
     sudo make install
+    sudo ldconfig
 
 See `./configure --help` for more options.

kvazaar-2.1.0.tar.gz/appveyor.yml -> kvazaar-2.2.0.tar.gz/appveyor.yml Changed

kvazaar-2.1.0.tar.gz/configure.ac -> kvazaar-2.2.0.tar.gz/configure.ac Changed

kvazaar-2.1.0.tar.gz/doc/kvazaar.1 -> kvazaar-2.2.0.tar.gz/doc/kvazaar.1 Changed

@@ -1,4 +1,4 @@
-.TH KVAZAAR "1" "October 2021" "kvazaar v2.1.0" "User Commands"
+.TH KVAZAAR "1" "January 2023" "kvazaar v2.2.0" "User Commands"
 .SH NAME
 kvazaar \- open source HEVC encoder
 .SH SYNOPSIS
@@ -180,11 +180,20 @@
 .TP
 \fB\-\-roi <filename>      
 Use a delta QP map for region of interest.
-Reads an array of delta QP values from a text
-file. The file format is: width and height of
-the QP delta map followed by width*height delta
-QP values in raster order. The map can be of any
-size and will be scaled to the video size.
+Reads an array of delta QP values from a file.
+Text and binary files are supported and detected
+from the file extension (.txt/.bin). If a known
+extension is not found, the file is treated as
+a text file. The file can include one or many
+ROI frames each in the following format:
+width and height of the QP delta map followed
+by width * height delta QP values in raster
+order. In binary format, width and height are
+32\-bit integers whereas the delta QP values are
+signed 8\-bit values. The map can be of any size
+and will be scaled to the video size. The file
+reading will loop if end of the file is reached.
+See roi.txt in the examples folder.
 .TP
 \fB\-\-set\-qp\-in\-cu        
 Set QP at CU level keeping pic_init_qp_minus26.
@@ -243,12 +252,14 @@
 Asymmetric motion partition disabled
 .TP
 \fB\-\-rd <integer>        
-Intra mode search complexity 0
+Mode search complexity 0
     \- 0: Skip intra if inter is good enough.
     \- 1: Rough intra mode search with SATD.
-    \- 2: Refine intra mode search with SSE.
-    \- 3: Try all intra modes and enable intra
-         chroma mode search.
+    \- 2: Refine mode search with SSE.
+    \- 3: More SSE candidates for inter and
+         chroma mode search for 4x4 intra.
+    \- 4: Even more SSE candidates for both.
+    \- 5: Try all intra modes.
 .TP
 \fB\-\-(no\-)mv\-rdo         
 Rate\-distortion optimized motion vector costs
@@ -262,6 +273,10 @@
 Try all intra modes during rough search.
 disabled
 .TP
+\fB\-\-(no\-)intra\-chroma\-search
+Test non\-derived intra chroma modes.
+    disabled
+.TP
 \fB\-\-(no\-)transform\-skip 
 Try transform skip disabled
 .TP
@@ -285,6 +300,9 @@
     \- 3: + 1/4\-pixel horizontal and vertical
     \- 4: + 1/4\-pixel diagonal
 .TP
+\fB\-\-(no\-)fast\-bipred    
+Only perform fast bipred search. enabled
+.TP
 \fB\-\-pu\-depth\-inter <int>\-<int>
 Inter prediction units sizes 0\-3
     \- 0, 1, 2, 3: from 64x64 to 8x8
@@ -306,6 +324,19 @@
  learning trees, overrides the
  \-\-pu\-depth\-intra parameter. disabled
 .TP
+\fB\-\-(no\-)combine\-intra\-cus: Whether the encoder tries to code a cu
+    on lower depth even when search is not
+    performed on said depth. Should only
+    be disabled if cus absolutely must not
+    be larger than limited by the search.
+    enabled
+.TP
+\fB\-\-force\-inter         
+Force the encoder to use inter always.
+This is mostly for debugging and is not
+guaranteed to produce sensible bitstream or
+work at all. disabled
+.TP
 \fB\-\-tr\-depth\-intra <int>
 Transform split depth for intra blocks 0
 .TP
@@ -398,8 +429,8 @@
               width.
 .TP
 \fB\-\-tiles\-height\-split <string>|u<int>
-    \- <string>: A comma\-separated list of tile row
-                column pixel coordinates.
+    \- <string>: A comma\-separated list of tile
+                row column pixel coordinates.
     \- u<int>: Number of tile rows of uniform
               height.
 .TP

kvazaar-2.1.0.tar.gz/src/Makefile.am -> kvazaar-2.2.0.tar.gz/src/Makefile.am Changed

kvazaar-2.1.0.tar.gz/src/bitstream.c -> kvazaar-2.2.0.tar.gz/src/bitstream.c Changed

kvazaar-2.1.0.tar.gz/src/cabac.c -> kvazaar-2.2.0.tar.gz/src/cabac.c Changed

@@ -95,6 +95,7 @@
   data->num_buffered_bytes = 0;
   data->buffered_byte = 0xff;
   data->only_count = 0; // By default, write bits out
+  data->update = 0; 
 }
 
 /**
@@ -103,8 +104,7 @@
 void kvz_cabac_encode_bin(cabac_data_t * const data, const uint32_t bin_value)
 {
   uint32_t lps;
-
-
+  
   lps = kvz_g_auc_lpst_tableCTX_STATE(data->cur_ctx)(data->range >> 6) & 3;
   data->range -= lps;
 
@@ -272,15 +272,19 @@
  * \param symbol Value of coeff_abs_level_minus3.
  * \param r_param Reference to Rice parameter.
  */
-void kvz_cabac_write_coeff_remain(cabac_data_t * const cabac, const uint32_t symbol, const uint32_t r_param)
+int kvz_cabac_write_coeff_remain(cabac_data_t* const cabac, const uint32_t symbol, const uint32_t r_param)
 {
   int32_t code_number = symbol;
   uint32_t length;
 
+  int bits = 0;
+
   if (code_number < (3 << r_param)) {
     length = code_number >> r_param;
     CABAC_BINS_EP(cabac, (1 << (length + 1)) - 2 , length + 1, "coeff_abs_level_remaining");
+    bits += length + 1;
     CABAC_BINS_EP(cabac, (code_number % (1 << r_param)), r_param, "coeff_abs_level_remaining");
+    bits += r_param;
   } else {
     length = r_param;
     code_number = code_number - (3 << r_param);
@@ -289,8 +293,11 @@
       ++length;
     }
     CABAC_BINS_EP(cabac, (1 << (3 + length + 1 - r_param)) - 2, 3 + length + 1 - r_param, "coeff_abs_level_remaining");
+    bits += 3 + length + 1 - r_param;
     CABAC_BINS_EP(cabac, code_number, length, "coeff_abs_level_remaining");
+    bits += length;
   }
+  return bits;
 }
 
 void kvz_cabac_write_coeff_remain_encry(struct encoder_state_t * const state, cabac_data_t * const cabac,const uint32_t symbol, const uint32_t r_param, int32_t base_level)
@@ -488,26 +495,28 @@
 /**
  * \brief
  */
-void kvz_cabac_write_unary_max_symbol(cabac_data_t * const data, cabac_ctx_t * const ctx, uint32_t symbol, const int32_t offset, const uint32_t max_symbol)
+void kvz_cabac_write_unary_max_symbol(cabac_data_t * const data, 
+  cabac_ctx_t * const ctx, 
+  uint32_t symbol,
+  const int32_t offset,
+  const uint32_t max_symbol, 
+  double* bits_out)
 {
   int8_t code_last = max_symbol > symbol;
 
   assert(symbol <= max_symbol);
 
   if (!max_symbol) return;
-
-  data->cur_ctx = &ctx0;
-  CABAC_BIN(data, symbol, "ums");
+  
+  CABAC_FBITS_UPDATE(data, &ctx0, symbol, *bits_out, "ums");
 
   if (!symbol) return;
 
   while (--symbol) {
-    data->cur_ctx = &ctxoffset;
-    CABAC_BIN(data, 1, "ums");
+    CABAC_FBITS_UPDATE(data, &ctxoffset, 1, *bits_out, "ums");
   }
   if (code_last) {
-    data->cur_ctx = &ctxoffset;
-    CABAC_BIN(data, 0, "ums");
+    CABAC_FBITS_UPDATE(data, &ctxoffset, 0,*bits_out, "ums");
   }
 }
 
@@ -544,7 +553,7 @@
 /**
  * \brief
  */
-void kvz_cabac_write_ep_ex_golomb(encoder_state_t * const state,
+uint32_t kvz_cabac_write_ep_ex_golomb(encoder_state_t * const state,
                                   cabac_data_t * const data,
                                   uint32_t symbol,
                                   uint32_t count)
@@ -572,5 +581,6 @@
       bins                     = ( (bins >> (num_bins >>1) ) << (num_bins >>1) ) | state->crypto_prev_pos;
     }
   }
-  kvz_cabac_encode_bins_ep(data, bins, num_bins);
+  CABAC_BINS_EP(data, bins, num_bins, "ep_ex_golomb");
+  return num_bins;
 }

kvazaar-2.1.0.tar.gz/src/cabac.h -> kvazaar-2.2.0.tar.gz/src/cabac.h Changed

@@ -58,7 +58,8 @@
   uint32_t   buffered_byte;
   int32_t    num_buffered_bytes;
   int32_t    bits_left;
-  int8_t     only_count;
+  int8_t     only_count : 4;
+  int8_t     update : 4;
   bitstream_t *stream;
 
   // CONTEXTS
@@ -115,17 +116,27 @@
 void kvz_cabac_encode_bin_trm(cabac_data_t *data, uint8_t bin_value);
 void kvz_cabac_write(cabac_data_t *data);
 void kvz_cabac_finish(cabac_data_t *data);
-void kvz_cabac_write_coeff_remain(cabac_data_t *cabac, uint32_t symbol,
-                              uint32_t r_param);
+int kvz_cabac_write_coeff_remain(cabac_data_t* cabac, uint32_t symbol,
+                                 uint32_t r_param);
 void kvz_cabac_write_coeff_remain_encry(struct encoder_state_t * const state, cabac_data_t * const cabac, const uint32_t symbol,
                                         const uint32_t r_param, int32_t base_level);
-void kvz_cabac_write_ep_ex_golomb(struct encoder_state_t * const state, cabac_data_t *data,
+uint32_t kvz_cabac_write_ep_ex_golomb(struct encoder_state_t * const state, cabac_data_t *data,
                                   uint32_t symbol, uint32_t count);
 void kvz_cabac_write_unary_max_symbol(cabac_data_t *data, cabac_ctx_t *ctx,
-                                  uint32_t symbol, int32_t offset,
-                                  uint32_t max_symbol);
+                                      uint32_t symbol, int32_t offset,
+                                      uint32_t max_symbol, double* bits_out);
 void kvz_cabac_write_unary_max_symbol_ep(cabac_data_t *data, unsigned int symbol, unsigned int max_symbol);
 
+extern const float kvz_f_entropy_bits128;
+#define CTX_ENTROPY_FBITS(ctx, val) kvz_f_entropy_bits(ctx)->uc_state ^ (val)
+
+#define CABAC_FBITS_UPDATE(cabac, ctx, val, bits, name) do { \
+  if((cabac)->only_count) (bits) += kvz_f_entropy_bits(ctx)->uc_state ^ (val); \
+  if((cabac)->update) {\
+    (cabac)->cur_ctx = ctx;\
+    CABAC_BIN((cabac), (val), (name));\
+  } \
+} while(0)
 
 // Macros
 #define CTX_STATE(ctx) ((ctx)->uc_state >> 1)
@@ -133,24 +144,25 @@
 #define CTX_UPDATE_LPS(ctx) { (ctx)->uc_state = kvz_g_auc_next_state_lps (ctx)->uc_state ; }
 #define CTX_UPDATE_MPS(ctx) { (ctx)->uc_state = kvz_g_auc_next_state_mps (ctx)->uc_state ; }
 
+
 #ifdef VERBOSE
   #define CABAC_BIN(data, value, name) { \
-    uint32_t prev_state = (data)->ctx->uc_state; \
-    kvz_cabac_encode_bin((data), (value)) \
-    printf("%s = %u, state = %u -> %u\n", \
-           (name), (uint32_t)(value), prev_state, (data)->ctx->uc_state); }
+    uint32_t prev_state = (data)->cur_ctx->uc_state; \
+    kvz_cabac_encode_bin((data), (value)); \
+    if(!(data)->only_count)  printf("%s = %u, state = %u -> %u MPS = %u\n", \
+           (name), (uint32_t)(value), prev_state, (data)->cur_ctx->uc_state, CTX_MPS((data)->cur_ctx)); }
 
   #define CABAC_BINS_EP(data, value, bins, name) { \
-    uint32_t prev_state = (data)->ctx->uc_state; \
+    uint32_t prev_state = (data)->cur_ctx->uc_state; \
     kvz_cabac_encode_bins_ep((data), (value), (bins)); \
-    printf("%s = %u(%u bins), state = %u -> %u\n", \
-           (name), (uint32_t)(value), (bins), prev_state, (data)->ctx->uc_state); }
+    if(!(data)->only_count) printf("%s = %u(%u bins), state = %u -> %u\n", \
+           (name), (uint32_t)(value), (bins), prev_state, (data)->cur_ctx->uc_state); }
 
   #define CABAC_BIN_EP(data, value, name) { \
-    uint32_t prev_state = (data)->ctx->uc_state; \
+    uint32_t prev_state = (data)->cur_ctx->uc_state; \
     kvz_cabac_encode_bin_ep((data), (value)); \
-    printf("%s = %u, state = %u -> %u\n", \
-           (name), (uint32_t)(value), prev_state, (data)->ctx->uc_state); }
+    if(!(data)->only_count) printf("%s = %u, state = %u -> %u\n", \
+           (name), (uint32_t)(value), prev_state, (data)->cur_ctx->uc_state); }
 #else
   #define CABAC_BIN(data, value, name) \
     kvz_cabac_encode_bin((data), (value));

kvazaar-2.1.0.tar.gz/src/cfg.c -> kvazaar-2.2.0.tar.gz/src/cfg.c Changed

@@ -139,9 +139,9 @@
   cfg->gop_lp_definition.t = 1;
   cfg->open_gop = true;
 
-  cfg->roi.width = 0;
-  cfg->roi.height = 0;
-  cfg->roi.dqps = NULL;
+  cfg->roi.file_path = NULL;
+  cfg->roi.format = KVZ_ROI_TXT;
+
   cfg->set_qp_in_cu = false;
 
   cfg->erp_aqp = false;
@@ -183,6 +183,11 @@
   cfg->fastrd_sampling_on = 0;
   cfg->fastrd_accuracy_check_on = 0;
   cfg->fastrd_learning_outdir_fn = NULL;
+
+  cfg->combine_intra_cus = 1;
+  cfg->force_inter = 0;
+  cfg->intra_chroma_search = 0;
+  cfg->fast_bipred = 1;
   return 1;
 }
 
@@ -190,11 +195,11 @@
 {
   if (cfg) {
     FREE_POINTER(cfg->cqmfile);
+    FREE_POINTER(cfg->roi.file_path);
     FREE_POINTER(cfg->fast_coeff_table_fn);
     FREE_POINTER(cfg->tiles_width_split);
     FREE_POINTER(cfg->tiles_height_split);
     FREE_POINTER(cfg->slice_addresses_in_ts);
-    FREE_POINTER(cfg->roi.dqps);
     FREE_POINTER(cfg->optional_key);
     FREE_POINTER(cfg->fastrd_learning_outdir_fn);
   }
@@ -700,7 +705,7 @@
       },
       {
         "veryslow",
-        "rd", "2",
+        "rd", "3",
         "pu-depth-intra", "1-4",
         "pu-depth-inter", "0-3",
         "me", "tz",
@@ -728,7 +733,7 @@
       },
       {
         "placebo",
-        "rd", "2",
+        "rd", "3",
         "pu-depth-intra", "1-4",
         "pu-depth-inter", "0-3",
         "me", "tz",
@@ -1241,60 +1246,29 @@
   }
   else if OPT("implicit-rdpcm")
     cfg->implicit_rdpcm = (bool)atobool(value);
-  else if OPT("roi") {
-    // The ROI description is as follows:
-    // First number is width, second number is height,
-    // then follows width * height number of dqp values.
-    FILE* f = fopen(value, "rb");
-    if (!f) {
-      fprintf(stderr, "Could not open ROI file.\n");
-      return 0;
-    }
-
-    int width = 0;
-    int height = 0;
-    if (!fscanf(f, "%d", &width) || !fscanf(f, "%d", &height)) {
-      fprintf(stderr, "Failed to read ROI size.\n");
-      fclose(f);
-      return 0;
-    }
-
-    if (width <= 0 || height <= 0) {
-      fprintf(stderr, "Invalid ROI size: %dx%d.\n", width, height);
-      fclose(f);
-      return 0;
-    }
 
-    if (width > 10000 || height > 10000) {
-      fprintf(stderr, "ROI dimensions exceed arbitrary value of 10000.\n");
-      fclose(f);
-      return 0;
-    }
+  else if OPT("roi") {
+    static enum kvz_roi_format const formats = { KVZ_ROI_TXT, KVZ_ROI_BIN };
+    static const char * const format_names = { "txt", "bin", NULL };
 
-    const unsigned size = width * height;
-    int8_t *dqp_array  = calloc((size_t)size, sizeof(cfg->roi.dqps0));
-    if (!dqp_array) {
-      fprintf(stderr, "Failed to allocate memory for ROI table.\n");
-      fclose(f);
+    char *roi_file = strdup(value);
+    if (!roi_file) {
+      fprintf(stderr, "Failed to allocate memory for ROI file name.\n");
       return 0;
     }
+    FREE_POINTER(cfg->roi.file_path);
+    cfg->roi.file_path = roi_file;
 
-    FREE_POINTER(cfg->roi.dqps);
-    cfg->roi.dqps   = dqp_array;
-    cfg->roi.width  = width;
-    cfg->roi.height = height;
-
-    for (int i = 0; i < size; ++i) {
-      int number; // Need a pointer to int for fscanf
-      if (fscanf(f, "%d", &number) != 1) {
-        fprintf(stderr, "Reading ROI file failed.\n");
-        fclose(f);
-        return 0;
-      }
-      dqp_arrayi = CLIP(-51, 51, number);
+    // Get file extension or the substring after the last dot
+    char *maybe_extension = strrchr(cfg->roi.file_path, '.');
+    if (!maybe_extension) {
+      cfg->roi.format = KVZ_ROI_TXT;
+    } else {
+      maybe_extension++;
+      int8_t format;
+      bool unknown_format = !parse_enum(maybe_extension, format_names, &format);
+      cfg->roi.format = unknown_format ? KVZ_ROI_TXT : formatsformat;
     }
-
-    fclose(f);
   }
   else if OPT("set-qp-in-cu") {
     cfg->set_qp_in_cu = (bool)atobool(value);
@@ -1421,6 +1395,18 @@
   else if OPT("stats-file-prefix") {
     cfg->stats_file_prefix = strdup(value);
   }
+  else if OPT("combine-intra-cus") {
+    cfg->combine_intra_cus = atobool(value);
+  }
+  else if OPT("force-inter") {
+    cfg->force_inter = atobool(value);
+  }
+  else if OPT("intra-chroma-search") {
+    cfg->intra_chroma_search = atobool(value);
+  }
+  else if OPT("fast-bipred") {
+    cfg->fast_bipred = atobool(value);
+  }
   else {
     return 0;
   }
@@ -1612,8 +1598,8 @@
     error = 1;
   }
 
-  if (cfg->rdo < 0 || cfg->rdo > 3) {
-    fprintf(stderr, "Input error: --rd parameter out of range 0..3\n");
+  if (cfg->rdo < 0 || cfg->rdo > 6) {
+    fprintf(stderr, "Input error: --rd parameter out of range 0..5\n");
     error = 1;
   }

kvazaar-2.1.0.tar.gz/src/cli.c -> kvazaar-2.2.0.tar.gz/src/cli.c Changed

@@ -141,6 +141,7 @@
   { "force-level",        required_argument, NULL, 0 },
   { "high-tier",                no_argument, NULL, 0 },
   { "me-steps",           required_argument, NULL, 0 },
+  { "roi-file",           required_argument, NULL, 0 },
   { "fast-residual-cost", required_argument, NULL, 0 },
   { "set-qp-in-cu",             no_argument, NULL, 0 },
   { "open-gop",                 no_argument, NULL, 0 },
@@ -167,6 +168,14 @@
   { "fastrd-sampling",          no_argument, NULL, 0 },
   { "fastrd-accuracy-check",    no_argument, NULL, 0 },
   { "fastrd-outdir",      required_argument, NULL, 0 },
+  { "combine-intra-cus",        no_argument, NULL, 0 },
+  { "no-combine-intra-cus",     no_argument, NULL, 0 },
+  { "force-inter",              no_argument, NULL, 0 },
+  { "no-force-inter",           no_argument, NULL, 0 },
+  { "intra-chroma-search",      no_argument, NULL, 0 },
+  { "no-intra-chroma-search",   no_argument, NULL, 0 },
+  { "fast-bipred",              no_argument, NULL, 0 },
+  { "no-fast-bipred",           no_argument, NULL, 0 },
   {0, 0, 0, 0}
 };
 
@@ -500,11 +509,20 @@
     "                                   - frametile: Constrain within the tile.\n"
     "                                   - frametilemargin: Constrain even more.\n"
     "      --roi <filename>       : Use a delta QP map for region of interest.\n"
-    "                               Reads an array of delta QP values from a text\n"
-    "                               file. The file format is: width and height of\n"
-    "                               the QP delta map followed by width*height delta\n"
-    "                               QP values in raster order. The map can be of any\n"
-    "                               size and will be scaled to the video size.\n"
+    "                               Reads an array of delta QP values from a file.\n"
+    "                               Text and binary files are supported and detected\n"
+    "                               from the file extension (.txt/.bin). If a known\n"
+    "                               extension is not found, the file is treated as\n"
+    "                               a text file. The file can include one or many\n"
+    "                               ROI frames each in the following format:\n"
+    "                               width and height of the QP delta map followed\n"
+    "                               by width * height delta QP values in raster\n"
+    "                               order. In binary format, width and height are\n"
+    "                               32-bit integers whereas the delta QP values are\n"
+    "                               signed 8-bit values. The map can be of any size\n"
+    "                               and will be scaled to the video size. The file\n"
+    "                               reading will loop if end of the file is reached.\n"
+    "                               See roi.txt in the examples folder.\n"
     "      --set-qp-in-cu         : Set QP at CU level keeping pic_init_qp_minus26.\n"
     "                               in PPS and slice_qp_delta in slize header zero.\n"
     "      --(no-)erp-aqp         : Use adaptive QP for 360 degree video with\n"
@@ -536,18 +554,22 @@
     "      --(no-)signhide        : Sign hiding disabled\n"
     "      --(no-)smp             : Symmetric motion partition disabled\n"
     "      --(no-)amp             : Asymmetric motion partition disabled\n"
-    "      --rd <integer>         : Intra mode search complexity 0\n"
+    "      --rd <integer>         : Mode search complexity 0\n"
     "                                   - 0: Skip intra if inter is good enough.\n"
     "                                   - 1: Rough intra mode search with SATD.\n"
-    "                                   - 2: Refine intra mode search with SSE.\n"
-    "                                   - 3: Try all intra modes and enable intra\n"
-    "                                        chroma mode search.\n"
+    "                                   - 2: Refine mode search with SSE.\n"
+    "                                   - 3: More SSE candidates for inter and\n"
+    "                                        chroma mode search for 4x4 intra.\n"
+    "                                   - 4: Even more SSE candidates for both.\n"
+    "                                   - 5: Try all intra modes.\n"
     "      --(no-)mv-rdo          : Rate-distortion optimized motion vector costs\n"
     "                               disabled\n"
     "      --(no-)zero-coeff-rdo  : If a CU is set inter, check if forcing zero\n"
     "                               residual improves the RD cost. enabled\n"
     "      --(no-)full-intra-search : Try all intra modes during rough search.\n"
     "                               disabled\n"
+    "      --(no-)intra-chroma-search : Test non-derived intra chroma modes.\n"
+    "                                   disabled\n"
     "      --(no-)transform-skip  : Try transform skip disabled\n"
     "      --me <string>          : Integer motion estimation algorithm hexbs\n"
     "                                   - hexbs: Hexagon Based Search\n"
@@ -563,6 +585,7 @@
     "                                   - 2: + 1/2-pixel diagonal\n"
     "                                   - 3: + 1/4-pixel horizontal and vertical\n"
     "                                   - 4: + 1/4-pixel diagonal\n"
+    "      --(no-)fast-bipred     : Only perform fast bipred search. enabled\n"
     "      --pu-depth-inter <int>-<int> : Inter prediction units sizes 0-3\n"
     "                                   - 0, 1, 2, 3: from 64x64 to 8x8\n"
     "                                   - Accepts a list of values separated by ','\n"
@@ -578,6 +601,16 @@
     "      --ml-pu-depth-intra    : Predict the pu-depth-intra using machine\n"
     "                                learning trees, overrides the\n"
     "                                --pu-depth-intra parameter. disabled\n"
+    "      --(no-)combine-intra-cus: Whether the encoder tries to code a cu\n"
+    "                                   on lower depth even when search is not\n"
+    "                                   performed on said depth. Should only\n"
+    "                                   be disabled if cus absolutely must not\n"
+    "                                   be larger than limited by the search.\n"
+    "                                   enabled\n"
+    "      --force-inter          : Force the encoder to use inter always.\n"
+    "                               This is mostly for debugging and is not\n"
+    "                               guaranteed to produce sensible bitstream or\n"
+    "                               work at all. disabled\n"
     "      --tr-depth-intra <int> : Transform split depth for intra blocks 0\n"
     "      --(no-)bipred          : Bi-prediction disabled\n"
     "      --cu-split-termination <string> : CU split search termination zero\n"
@@ -633,8 +666,8 @@
     "                                   - u<int>: Number of tile columns of uniform\n"
     "                                             width.\n"
     "      --tiles-height-split <string>|u<int> :\n"
-    "                                   - <string>: A comma-separated list of tile row\n"
-    "                                               column pixel coordinates.\n"
+    "                                   - <string>: A comma-separated list of tile\n"
+    "                                               row column pixel coordinates.\n"
     "                                   - u<int>: Number of tile rows of uniform\n"
     "                                             height.\n"
     "      --slices <string>      : Control how slices are used.\n"

kvazaar-2.1.0.tar.gz/src/cli.h -> kvazaar-2.2.0.tar.gz/src/cli.h Changed

kvazaar-2.1.0.tar.gz/src/encmain.c -> kvazaar-2.2.0.tar.gz/src/encmain.c Changed

kvazaar-2.1.0.tar.gz/src/encode_coding_tree.c -> kvazaar-2.2.0.tar.gz/src/encode_coding_tree.c Changed

@@ -63,11 +63,12 @@
 void kvz_encode_last_significant_xy(cabac_data_t * const cabac,
                                     uint8_t lastpos_x, uint8_t lastpos_y,
                                     uint8_t width, uint8_t height,
-                                    uint8_t type, uint8_t scan)
+                                    uint8_t type, uint8_t scan, double* bits_out)
 {
   const int index = kvz_math_floor_log2(width) - 2;
   uint8_t ctx_offset = type ? 0 : (index * 3 + (index + 1) / 4);
   uint8_t shift = type ? index : (index + 3) / 4;
+  double bits = 0;
 
   cabac_ctx_t *base_ctx_x = (type ? cabac->ctx.cu_ctx_last_x_chroma : cabac->ctx.cu_ctx_last_x_luma);
   cabac_ctx_t *base_ctx_y = (type ? cabac->ctx.cu_ctx_last_y_chroma : cabac->ctx.cu_ctx_last_y_luma);
@@ -81,37 +82,36 @@
 
   // x prefix
   for (int last_x = 0; last_x < group_idx_x; last_x++) {
-    cabac->cur_ctx = &base_ctx_xctx_offset + (last_x >> shift);
-    CABAC_BIN(cabac, 1, "last_sig_coeff_x_prefix");
+    CABAC_FBITS_UPDATE(cabac, &base_ctx_xctx_offset + (last_x >> shift), 1, bits, "last_sig_coeff_x_prefix");
   }
   if (group_idx_x < g_group_idxwidth - 1) {
-    cabac->cur_ctx = &base_ctx_xctx_offset + (group_idx_x >> shift);
-    CABAC_BIN(cabac, 0, "last_sig_coeff_x_prefix");
+    CABAC_FBITS_UPDATE(cabac, &base_ctx_xctx_offset + (group_idx_x >> shift), 0, bits, "last_sig_coeff_x_prefix");
   }
 
   // y prefix
   for (int last_y = 0; last_y < group_idx_y; last_y++) {
-    cabac->cur_ctx = &base_ctx_yctx_offset + (last_y >> shift);
-    CABAC_BIN(cabac, 1, "last_sig_coeff_y_prefix");
+    CABAC_FBITS_UPDATE(cabac, &base_ctx_yctx_offset + (last_y >> shift), 1, bits, "last_sig_coeff_y_prefix");
   }
   if (group_idx_y < g_group_idxheight - 1) {
-    cabac->cur_ctx = &base_ctx_yctx_offset + (group_idx_y >> shift);
-    CABAC_BIN(cabac, 0, "last_sig_coeff_y_prefix");
+    CABAC_FBITS_UPDATE(cabac, &base_ctx_yctx_offset + (group_idx_y >> shift), 0, bits, "last_sig_coeff_y_prefix");
   }
 
   // last_sig_coeff_x_suffix
   if (group_idx_x > 3) {
     const int suffix = lastpos_x - g_min_in_groupgroup_idx_x;
-    const int bits = (group_idx_x - 2) / 2;
-    CABAC_BINS_EP(cabac, suffix, bits, "last_sig_coeff_x_suffix");
+    const int write_bits = (group_idx_x - 2) / 2;
+    CABAC_BINS_EP(cabac, suffix, write_bits, "last_sig_coeff_x_suffix");
+    if (cabac->only_count) bits += write_bits;
   }
 
   // last_sig_coeff_y_suffix
   if (group_idx_y > 3) {
     const int suffix = lastpos_y - g_min_in_groupgroup_idx_y;
-    const int bits = (group_idx_y - 2) / 2;
-    CABAC_BINS_EP(cabac, suffix, bits, "last_sig_coeff_y_suffix");
+    const int write_bits = (group_idx_y - 2) / 2;
+    CABAC_BINS_EP(cabac, suffix, write_bits, "last_sig_coeff_y_suffix");
+    if (cabac->only_count) bits += write_bits;
   }
+  if (cabac->only_count && bits_out) *bits_out += bits;
 }
 
 static void encode_transform_unit(encoder_state_t * const state,
@@ -142,7 +142,7 @@
                          width,
                          0,
                          scan_idx,
-                         cur_pu->tr_skip);
+                         cur_pu->tr_skip, NULL);
   }
 
   if (depth == MAX_DEPTH + 1) {
@@ -172,11 +172,11 @@
     const coeff_t *coeff_v = &state->coeff->vxy_to_zorder(LCU_WIDTH_C, x_local, y_local);
 
     if (cbf_is_set(cur_pu->cbf, depth, COLOR_U)) {
-      kvz_encode_coeff_nxn(state, &state->cabac, coeff_u, width_c, 2, scan_idx, 0);
+      kvz_encode_coeff_nxn(state, &state->cabac, coeff_u, width_c, 2, scan_idx, 0, NULL);
     }
 
     if (cbf_is_set(cur_pu->cbf, depth, COLOR_V)) {
-      kvz_encode_coeff_nxn(state, &state->cabac, coeff_v, width_c, 2, scan_idx, 0);
+      kvz_encode_coeff_nxn(state, &state->cabac, coeff_v, width_c, 2, scan_idx, 0, NULL);
     }
   }
 }
@@ -290,7 +290,7 @@
 
       // cu_qp_delta_abs prefix
       cabac->cur_ctx = &cabac->ctx.cu_qp_delta_abs0;
-      kvz_cabac_write_unary_max_symbol(cabac, cabac->ctx.cu_qp_delta_abs, MIN(qp_delta_abs, 5), 1, 5);
+      kvz_cabac_write_unary_max_symbol(cabac, cabac->ctx.cu_qp_delta_abs, MIN(qp_delta_abs, 5), 1, 5, NULL);
 
       if (qp_delta_abs >= 5) {
         // cu_qp_delta_abs suffix
@@ -308,16 +308,18 @@
   }
 }
 
-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, int y, int width, int height,
-                                         int depth)
+void kvz_encode_inter_prediction_unit(encoder_state_t * const state,
+                                      cabac_data_t * const cabac,
+                                      const cu_info_t * const cur_cu,
+                                      int x, int y, int width, int height,
+                                      int depth, lcu_t* lcu, double* bits_out)
 {
   // Mergeflag
   int16_t num_cand = 0;
-  cabac->cur_ctx = &(cabac->ctx.cu_merge_flag_ext_model);
-  CABAC_BIN(cabac, cur_cu->merged, "MergeFlag");
+  double bits = 0;
+
+  CABAC_FBITS_UPDATE(cabac, &(cabac->ctx.cu_merge_flag_ext_model), cur_cu->merged, bits, "MergeFlag");
+
   num_cand = state->encoder_control->cfg.max_merge;
   if (cur_cu->merged) { //merge
     if (num_cand > 1) {
@@ -325,10 +327,10 @@
       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");
+          CABAC_FBITS_UPDATE(cabac, &(cabac->ctx.cu_merge_idx_ext_model), symbol, bits, "MergeIndex");
         } else {
           CABAC_BIN_EP(cabac,symbol,"MergeIndex");
+          if(cabac->only_count) bits += 1;
         }
         if (symbol == 0) break;
       }
@@ -339,12 +341,10 @@
       uint8_t inter_dir = cur_cu->inter.mv_dir-1;
 
       if (cur_cu->part_size == SIZE_2Nx2N || (LCU_WIDTH >> depth) != 8) {
-        cabac->cur_ctx = &(cabac->ctx.inter_dirdepth);
-        CABAC_BIN(cabac, (inter_dir == 2), "inter_pred_idc");
+        CABAC_FBITS_UPDATE(cabac, &(cabac->ctx.inter_dirdepth), inter_dir == 2, bits, "inter_pred_idc");
       }
       if (inter_dir < 2) {
-        cabac->cur_ctx = &(cabac->ctx.inter_dir4);
-        CABAC_BIN(cabac, inter_dir, "inter_pred_idc");
+        CABAC_FBITS_UPDATE(cabac, &(cabac->ctx.inter_dir4), inter_dir, bits, "inter_pred_idc");
       }
     }
 
@@ -359,9 +359,8 @@
       if (ref_LX_size > 1) {
         // parseRefFrmIdx
         int32_t ref_frame = cur_cu->inter.mv_refref_list_idx;
-
-        cabac->cur_ctx = &(cabac->ctx.cu_ref_pic_model0);
-        CABAC_BIN(cabac, (ref_frame != 0), "ref_idx_lX");
+        
+        CABAC_FBITS_UPDATE(cabac, &(cabac->ctx.cu_ref_pic_model0), (ref_frame != 0), bits, "ref_idx_lX");
 
         if (ref_frame > 0) {
           ref_frame--;
@@ -373,9 +372,10 @@
 
             if (i == 0) {
               cabac->cur_ctx = &cabac->ctx.cu_ref_pic_model1;
-              CABAC_BIN(cabac, symbol, "ref_idx_lX");
+              CABAC_FBITS_UPDATE(cabac, &cabac->ctx.cu_ref_pic_model1, symbol, bits, "ref_idx_lX");
             } else {
               CABAC_BIN_EP(cabac, symbol, "ref_idx_lX");
+              if (cabac->only_count) bits += 1;
             }
             if (symbol == 0) break;
           }
@@ -385,16 +385,26 @@
       if (state->frame->ref_list != REF_PIC_LIST_1 || cur_cu->inter.mv_dir != 3) {
 
         int16_t mv_cand22;
-        kvz_inter_get_mv_cand_cua(
+        if (lcu) {
+          kvz_inter_get_mv_cand(
+            state, 
+            x, y, width, height,
+            mv_cand, cur_cu, 
+            lcu, ref_list_idx);
+        }
+        else {
+          kvz_inter_get_mv_cand_cua(
             state,
             x, y, width, height,
-            mv_cand, cur_cu, ref_list_idx);
+            mv_cand, cur_cu, ref_list_idx
+          );
+        }
 
         uint8_t cu_mv_cand = CU_GET_MV_CAND(cur_cu, ref_list_idx);
         const int32_t mvd_hor = cur_cu->inter.mvref_list_idx0 - mv_candcu_mv_cand0;
         const int32_t mvd_ver = cur_cu->inter.mvref_list_idx1 - mv_candcu_mv_cand1;
 
-        kvz_encode_mvd(state, cabac, mvd_hor, mvd_ver);
+        kvz_encode_mvd(state, cabac, mvd_hor, mvd_ver, bits_out);
       }
 
       // Signal which candidate MV to use
@@ -402,10 +412,11 @@
                                        cabac->ctx.mvp_idx_model,
                                        CU_GET_MV_CAND(cur_cu, ref_list_idx),
                                        1,
-                                       AMVP_MAX_NUM_CANDS - 1);
+                                       AMVP_MAX_NUM_CANDS - 1, bits_out);
 
     } // for ref_list
   } // if !merge
+  if(bits_out) *bits_out += bits;
 }
 
 
@@ -456,7 +467,7 @@
 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, int y, int depth)
+                                     int x, int y, int depth, lcu_t* lcu, double* bits_out)
 {
   const videoframe_t * const frame = state->tile->frame;
   uint8_t intra_pred_mode_actual4;
@@ -495,19 +506,19 @@
   for (int j = 0; j < num_pred_units; ++j) {
     const int pu_x = PU_GET_X(cur_cu->part_size, cu_width, x, j);
     const int pu_y = PU_GET_Y(cur_cu->part_size, cu_width, y, j);
-    const cu_info_t *cur_pu = kvz_cu_array_at_const(frame->cu_array, pu_x, pu_y);
+    const cu_info_t *cur_pu = lcu ? LCU_GET_CU_AT_PX(lcu, SUB_SCU(pu_x), SUB_SCU(pu_y)) : kvz_cu_array_at_const(frame->cu_array, pu_x, pu_y);
 
     const cu_info_t *left_pu = NULL;
     const cu_info_t *above_pu = NULL;
 
     if (pu_x > 0) {
       assert(pu_x >> 2 > 0);
-      left_pu = kvz_cu_array_at_const(frame->cu_array, pu_x - 1, pu_y);
+      left_pu = lcu ? LCU_GET_CU_AT_PX(lcu, SUB_SCU(pu_x -1), SUB_SCU(pu_y)) : kvz_cu_array_at_const(frame->cu_array, pu_x - 1, pu_y);
     }
     // Don't take the above PU across the LCU boundary.
     if (pu_y % LCU_WIDTH > 0 && pu_y > 0) {
       assert(pu_y >> 2 > 0);
-      above_pu = kvz_cu_array_at_const(frame->cu_array, pu_x, pu_y - 1);
+      above_pu = lcu ? LCU_GET_CU_AT_PX(lcu, SUB_SCU(pu_x), SUB_SCU(pu_y - 1)) : kvz_cu_array_at_const(frame->cu_array, pu_x, pu_y - 1);
     }
 
     if (do_crypto) {
@@ -559,18 +570,19 @@
     }
 #endif
   }
-
-  cabac->cur_ctx = &(cabac->ctx.intra_mode_model);
+  
   for (int j = 0; j < num_pred_units; ++j) {
-    CABAC_BIN(cabac, flagj, "prev_intra_luma_pred_flag");
+    CABAC_FBITS_UPDATE(cabac, &(cabac->ctx.intra_mode_model),flagj, *bits_out, "prev_intra_luma_pred_flag");
   }
 
   for (int j = 0; j < num_pred_units; ++j) {
     // Signal index of the prediction mode in the prediction list.
     if (flagj) {
       CABAC_BIN_EP(cabac, (mpm_predsj == 0 ? 0 : 1), "mpm_idx");
+      if (cabac->only_count) *bits_out += 1;
       if (mpm_predsj != 0) {
         CABAC_BIN_EP(cabac, (mpm_predsj == 1 ? 0 : 1), "mpm_idx");
+        if (cabac->only_count) *bits_out += 1;
       }
     } else {
       // Signal the actual prediction mode.
@@ -589,6 +601,7 @@
       }
 
       CABAC_BINS_EP(cabac, tmp_pred, 5, "rem_intra_luma_pred_mode");
+      if (cabac->only_count) *bits_out += 5;
     }
   }
 
@@ -629,17 +642,21 @@
      */
     cabac->cur_ctx = &(cabac->ctx.chroma_pred_model0);
     if (pred_mode == 4) {
-      CABAC_BIN(cabac, 0, "intra_chroma_pred_mode");
+      CABAC_FBITS_UPDATE(cabac, &(cabac->ctx.chroma_pred_model0), 0, *bits_out,"intra_chroma_pred_mode");
     } else {
-      CABAC_BIN(cabac, 1, "intra_chroma_pred_mode");
+      CABAC_FBITS_UPDATE(cabac, &(cabac->ctx.chroma_pred_model0), 1, *bits_out,"intra_chroma_pred_mode");
       CABAC_BINS_EP(cabac, pred_mode, 2, "intra_chroma_pred_mode");
+      if (cabac->only_count) *bits_out += 2;
     }
   }
 
-  encode_transform_coeff(state, x, y, depth, 0, 0, 0);
+  // if we are counting bits, the cost for transform coeffs is done separately
+  // To get the distortion at the same time
+  if(!cabac->only_count) 
+    encode_transform_coeff(state, x, y, depth, 0, 0, 0);
 }
 
-static void encode_part_mode(encoder_state_t * const state,
+double kvz_encode_part_mode(encoder_state_t * const state,
                              cabac_data_t * const cabac,
                              const cu_info_t * const cur_cu,
                              int depth)
@@ -674,32 +691,32 @@
   //  log2CbSize == MinCbLog2SizeY |  0  1  2  bypass
   //  log2CbSize >  MinCbLog2SizeY |  0  1  3  bypass
   // ------------------------------+------------------
-
+  double bits = 0;
   if (cur_cu->type == CU_INTRA) {
     if (depth == MAX_DEPTH) {
       cabac->cur_ctx = &(cabac->ctx.part_size_model0);
       if (cur_cu->part_size == SIZE_2Nx2N) {
-        CABAC_BIN(cabac, 1, "part_mode 2Nx2N");
+        CABAC_FBITS_UPDATE(cabac, &(cabac->ctx.part_size_model0), 1, bits, "part_mode 2Nx2N");
       } else {
-        CABAC_BIN(cabac, 0, "part_mode NxN");
+        CABAC_FBITS_UPDATE(cabac, &(cabac->ctx.part_size_model0), 0, bits, "part_mode NxN");
       }
     }
   } else {
 
     cabac->cur_ctx = &(cabac->ctx.part_size_model0);
     if (cur_cu->part_size == SIZE_2Nx2N) {
-      CABAC_BIN(cabac, 1, "part_mode 2Nx2N");
-      return;
+      CABAC_FBITS_UPDATE(cabac, &(cabac->ctx.part_size_model0), 1, bits, "part_mode 2Nx2N");
+      return bits;
     }
-    CABAC_BIN(cabac, 0, "part_mode split");
+    CABAC_FBITS_UPDATE(cabac, &(cabac->ctx.part_size_model0), 0, bits, "part_mode split");
 
     cabac->cur_ctx = &(cabac->ctx.part_size_model1);
     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");
+      CABAC_FBITS_UPDATE(cabac, &(cabac->ctx.part_size_model1), 1, bits, "part_mode vertical");
     } else {
-      CABAC_BIN(cabac, 0, "part_mode horizontal");
+      CABAC_FBITS_UPDATE(cabac, &(cabac->ctx.part_size_model1), 0, bits, "part_mode horizontal");
     }
 
     if (state->encoder_control->cfg.amp_enable && depth < MAX_DEPTH) {
@@ -707,19 +724,22 @@
 
       if (cur_cu->part_size == SIZE_2NxN ||
           cur_cu->part_size == SIZE_Nx2N) {
-        CABAC_BIN(cabac, 1, "part_mode SMP");
-        return;
+        CABAC_FBITS_UPDATE(cabac, &(cabac->ctx.part_size_model3), 1, bits, "part_mode SMP");
+        return bits;
       }
-      CABAC_BIN(cabac, 0, "part_mode AMP");
+      CABAC_FBITS_UPDATE(cabac, &(cabac->ctx.part_size_model3), 0, bits, "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");
+        if(cabac->only_count) bits += 1;
       } else {
         CABAC_BINS_EP(cabac, 1, 1, "part_mode AMP");
+        if(cabac->only_count) bits += 1;
       }
     }
   }
+  return bits;
 }
 
 void kvz_encode_coding_tree(encoder_state_t * const state,
@@ -758,7 +778,7 @@
   bool border_split_y = ctrl->in.height >= abs_y + (LCU_WIDTH >> MAX_DEPTH) + half_cu;
   bool border = border_x || border_y; /*!< are we in any border CU */
 
-  if (depth <= ctrl->max_qp_delta_depth) {
+  if (depth <= state->frame->max_qp_delta_depth) {
     state->must_code_qp_delta = true;
   }
 
@@ -843,7 +863,7 @@
   }
 
   // part_mode
-  encode_part_mode(state, cabac, cur_cu, depth);
+  kvz_encode_part_mode(state, cabac, cur_cu, depth);
 
   if (cur_cu->type == CU_INTER) {
     const int num_pu = kvz_part_mode_num_partscur_cu->part_size;
@@ -855,7 +875,7 @@
       const int pu_h = PU_GET_H(cur_cu->part_size, cu_width, i);
       const cu_info_t *cur_pu = kvz_cu_array_at_const(frame->cu_array, pu_x, pu_y);
 
-      encode_inter_prediction_unit(state, cabac, cur_pu, pu_x, pu_y, pu_w, pu_h, depth);
+      kvz_encode_inter_prediction_unit(state, cabac, cur_pu, pu_x, pu_y, pu_w, pu_h, depth, NULL, NULL);
     }
 
     {
@@ -873,7 +893,7 @@
       }
     }
   } else if (cur_cu->type == CU_INTRA) {
-    encode_intra_coding_unit(state, cabac, cur_cu, x, y, depth);
+    encode_intra_coding_unit(state, cabac, cur_cu, x, y, depth, NULL, NULL);
   }
 
 #if ENABLE_PCM
@@ -925,11 +945,124 @@
   }
 }
 
+double kvz_mock_encode_coding_unit(
+  encoder_state_t* const state,
+  cabac_data_t* cabac,
+  int x, int y, int depth,
+  lcu_t* lcu, cu_info_t* cur_cu) {
+  double bits = 0;
+  const encoder_control_t* const ctrl = state->encoder_control;
+
+  int x_local = SUB_SCU(x);
+  int y_local = SUB_SCU(y);
+
+  const int cu_width = LCU_WIDTH >> depth;
+  
+  const cu_info_t* left_cu = NULL, *above_cu = NULL;
+  if (x) {
+    left_cu = LCU_GET_CU_AT_PX(lcu, x_local - 1, y_local);
+  }
+  if (y) {
+    above_cu = LCU_GET_CU_AT_PX(lcu, x_local, y_local-1);
+  }
+  uint8_t split_model = 0;
+
+  // Absolute coordinates
+  uint16_t abs_x = x + state->tile->offset_x;
+  uint16_t abs_y = y + state->tile->offset_y;
+
+  // Check for slice border
+  bool border_x = ctrl->in.width < abs_x + cu_width;
+  bool border_y = ctrl->in.height < abs_y + cu_width;
+  bool border = border_x || border_y; /*!< are we in any border CU */
+
+  if (depth <= state->frame->max_qp_delta_depth) {
+    state->must_code_qp_delta = true;
+  }
+
+  // When not in MAX_DEPTH, insert split flag and split the blocks if needed
+  if (depth != MAX_DEPTH) {
+    // Implicit split flag when on border
+    if (!border) {
+      // Get left and top block split_flags and if they are present and true, increase model number
+      if (left_cu && GET_SPLITDATA(left_cu, depth) == 1) {
+        split_model++;
+      }
+
+      if (above_cu && GET_SPLITDATA(above_cu, depth) == 1) {
+        split_model++;
+      }
+
+      // This mocks encoding the current CU so it should be never split
+      CABAC_FBITS_UPDATE(cabac, &(cabac->ctx.split_flag_modelsplit_model), 0, bits, "SplitFlag");
+    }
+  }
+
+  // Encode skip flag
+  if (state->frame->slicetype != KVZ_SLICE_I) {
+    int8_t ctx_skip = 0;
+
+    if (left_cu && left_cu->skipped) {
+      ctx_skip++;
+    }
+    if (above_cu && above_cu->skipped) {
+      ctx_skip++;
+    }
+    
+    CABAC_FBITS_UPDATE(cabac, &(cabac->ctx.cu_skip_flag_modelctx_skip), cur_cu->skipped, bits, "SkipFlag");
+
+    if (cur_cu->skipped) {
+      int16_t num_cand = state->encoder_control->cfg.max_merge;
+      if (num_cand > 1) {
+        for (int ui = 0; ui < num_cand - 1; ui++) {
+          int32_t symbol = (ui != cur_cu->merge_idx);
+          if (ui == 0) {
+            CABAC_FBITS_UPDATE(cabac, &(cabac->ctx.cu_merge_idx_ext_model), symbol, bits, "MergeIndex");
+          }
+          else {
+            CABAC_BIN_EP(cabac, symbol, "MergeIndex");
+            if(cabac->only_count) bits += 1;
+          }
+          if (symbol == 0) {
+            break;
+          }
+        }
+      }
+      return bits;
+    }
+  }
+  // Prediction mode
+  if (state->frame->slicetype != KVZ_SLICE_I) {
+    CABAC_FBITS_UPDATE(cabac, &(cabac->ctx.cu_pred_mode_model), (cur_cu->type == CU_INTRA), bits, "PredMode");
+  }
+
+  // part_mode
+  bits += kvz_encode_part_mode(state, cabac, cur_cu, depth);
+
+  if (cur_cu->type == CU_INTER) {
+    const int num_pu = kvz_part_mode_num_partscur_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);
+      const cu_info_t* cur_pu = LCU_GET_CU_AT_PX(lcu, SUB_SCU(pu_x), SUB_SCU(pu_y));
+
+      kvz_encode_inter_prediction_unit(state, cabac, cur_pu, pu_x, pu_y, pu_w, pu_h, depth, lcu, &bits);
+    }
+  }
+  else if (cur_cu->type == CU_INTRA) {
+    encode_intra_coding_unit(state, cabac, cur_cu, x, y, depth, lcu, &bits);
+  }
+  return bits;
+}
+
 
 void kvz_encode_mvd(encoder_state_t * const state,
                     cabac_data_t *cabac,
                     int32_t mvd_hor,
-                    int32_t mvd_ver)
+                    int32_t mvd_ver, double* bits_out)
 {
   const int8_t hor_abs_gr0 = mvd_hor != 0;
   const int8_t ver_abs_gr0 = mvd_ver != 0;
@@ -937,20 +1070,21 @@
   const uint32_t mvd_ver_abs = abs(mvd_ver);
 
   cabac->cur_ctx = &cabac->ctx.cu_mvd_model0;
-  CABAC_BIN(cabac, (mvd_hor != 0), "abs_mvd_greater0_flag_hor");
-  CABAC_BIN(cabac, (mvd_ver != 0), "abs_mvd_greater0_flag_ver");
+  CABAC_FBITS_UPDATE(cabac, &cabac->ctx.cu_mvd_model0, (mvd_hor != 0), *bits_out, "abs_mvd_greater0_flag_hor");
+  CABAC_FBITS_UPDATE(cabac, &cabac->ctx.cu_mvd_model0, (mvd_ver != 0), *bits_out, "abs_mvd_greater0_flag_ver");
 
   cabac->cur_ctx = &cabac->ctx.cu_mvd_model1;
   if (hor_abs_gr0) {
-    CABAC_BIN(cabac, (mvd_hor_abs>1), "abs_mvd_greater1_flag_hor");
+    CABAC_FBITS_UPDATE(cabac, &cabac->ctx.cu_mvd_model1, (mvd_hor_abs>1), *bits_out,"abs_mvd_greater1_flag_hor");
   }
   if (ver_abs_gr0) {
-    CABAC_BIN(cabac, (mvd_ver_abs>1), "abs_mvd_greater1_flag_ver");
+    CABAC_FBITS_UPDATE(cabac, &cabac->ctx.cu_mvd_model1, (mvd_ver_abs>1), *bits_out, "abs_mvd_greater1_flag_ver");
   }
 
   if (hor_abs_gr0) {
     if (mvd_hor_abs > 1) {
-      kvz_cabac_write_ep_ex_golomb(state, cabac, mvd_hor_abs - 2, 1);
+      uint32_t bits = kvz_cabac_write_ep_ex_golomb(state, cabac, mvd_hor_abs - 2, 1);
+      if(cabac->only_count) *bits_out += bits;
     }
     uint32_t mvd_hor_sign = (mvd_hor > 0) ? 0 : 1;
     if (!state->cabac.only_count &&
@@ -959,10 +1093,12 @@
       mvd_hor_sign = mvd_hor_sign ^ kvz_crypto_get_key(state->crypto_hdl, 1);
     }
     CABAC_BIN_EP(cabac, mvd_hor_sign, "mvd_sign_flag_hor");
+    if (cabac->only_count) *bits_out += 1;
   }
   if (ver_abs_gr0) {
     if (mvd_ver_abs > 1) {
-      kvz_cabac_write_ep_ex_golomb(state, cabac, mvd_ver_abs - 2, 1);
+      uint32_t bits = kvz_cabac_write_ep_ex_golomb(state, cabac, mvd_ver_abs - 2, 1);
+      if (cabac->only_count) *bits_out += bits;
     }
     uint32_t mvd_ver_sign = mvd_ver > 0 ? 0 : 1;
     if (!state->cabac.only_count &&
@@ -971,5 +1107,6 @@
       mvd_ver_sign = mvd_ver_sign^kvz_crypto_get_key(state->crypto_hdl, 1);
     }
     CABAC_BIN_EP(cabac, mvd_ver_sign, "mvd_sign_flag_ver");
+    if (cabac->only_count) *bits_out += 1;
   }
 }

kvazaar-2.1.0.tar.gz/src/encode_coding_tree.h -> kvazaar-2.2.0.tar.gz/src/encode_coding_tree.h Changed

@@ -49,11 +49,31 @@
 void kvz_encode_mvd(encoder_state_t * const state,
                     cabac_data_t *cabac,
                     int32_t mvd_hor,
-                    int32_t mvd_ver);
+                    int32_t mvd_ver,
+                    double* bits_out);
+
+double kvz_mock_encode_coding_unit(
+  encoder_state_t* const state,
+  cabac_data_t* cabac,
+  int x, int y, int depth,
+  lcu_t* lcu, cu_info_t* cur_cu);
+
+double kvz_encode_part_mode(encoder_state_t* const state,
+  cabac_data_t* const cabac,
+  const cu_info_t* const cur_cu,
+  int depth);
+
+void kvz_encode_inter_prediction_unit(encoder_state_t* const state,
+                                      cabac_data_t* const cabac,
+                                      const cu_info_t* const cur_cu,
+                                      int x, int y, int width, int height,
+                                      int depth, 
+                                      lcu_t* lcu,
+                                      double* bits_out);
 
 void kvz_encode_last_significant_xy(cabac_data_t * const cabac,
                                     uint8_t lastpos_x, uint8_t lastpos_y,
                                     uint8_t width, uint8_t height,
-                                    uint8_t type, uint8_t scan);
+                                    uint8_t type, uint8_t scan, double* bits_out);
 
 #endif // ENCODE_CODING_TREE_H_

kvazaar-2.1.0.tar.gz/src/encoder.c -> kvazaar-2.2.0.tar.gz/src/encoder.c Changed

@@ -32,9 +32,6 @@
 
 #include "encoder.h"
 
-// This define is required for M_PI on Windows.
-#define _USE_MATH_DEFINES
-#include <math.h>
 #include <stdio.h>
 #include <stdlib.h>
 
@@ -45,14 +42,6 @@
 #include "kvz_math.h"
 #include "fast_coeff_cost.h"
 
-/**
- * \brief Strength of QP adjustments when using adaptive QP for 360 video.
- *
- * Determined empirically.
- */
-static const double ERP_AQP_STRENGTH = 3.0;
-
-
 static int encoder_control_init_gop_layer_weights(encoder_control_t * const);
 
 static unsigned cfg_num_threads(void)
@@ -137,82 +126,6 @@
 
 
 /**
- * \brief Return weight for 360 degree ERP video
- *
- * Returns the scaling factor of area from equirectangular projection to
- * spherical surface.
- *
- * \param y   y-coordinate of the pixel
- * \param h   height of the picture
- */
-static double ws_weight(int y, int h)
-{
-  return cos((y - 0.5 * h + 0.5) * (M_PI / h));
-}
-
-
-
-/**
- * \brief Update ROI QPs for 360 video with equirectangular projection.
- *
- * Writes updated ROI parameters to encoder->cfg.roi.
- *
- * \param encoder       encoder control
- * \param orig_roi      original delta QPs or NULL
- * \param orig_width    width of orig_roi
- * \param orig_height   height of orig_roi
- */
-static void init_erp_aqp_roi(encoder_control_t* encoder,
-                             int8_t *orig_roi,
-                             int32_t orig_width,
-                             int32_t orig_height)
-{
-  // Update ROI with WS-PSNR delta QPs.
-  int height = encoder->in.height_in_lcu;
-  int width  = orig_roi ? orig_width : 1;
-
-  int frame_height = encoder->in.real_height;
-
-  encoder->cfg.roi.width  = width;
-  encoder->cfg.roi.height = height;
-  encoder->cfg.roi.dqps   = calloc(width * height, sizeof(orig_roi0));
-
-  double total_weight = 0.0;
-  for (int y = 0; y < frame_height; y++) {
-    total_weight += ws_weight(y, frame_height);
-  }
-
-  for (int y_lcu = 0; y_lcu < height; y_lcu++) {
-    int y_orig = LCU_WIDTH * y_lcu;
-    int lcu_height = MIN(LCU_WIDTH, frame_height - y_orig);
-
-    double lcu_weight = 0.0;
-    for (int y = y_orig; y < y_orig + lcu_height; y++) {
-      lcu_weight += ws_weight(y, frame_height);
-    }
-    // Normalize.
-    lcu_weight = (lcu_weight * frame_height) / (total_weight * lcu_height);
-
-    int8_t qp_delta = round(-ERP_AQP_STRENGTH * log2(lcu_weight));
-
-    if (orig_roi) {
-      // If a ROI array already exists, we copy the existing values to the
-      // new array while adding qp_delta to each.
-      int y_roi = y_lcu * orig_height / height;
-      for (int x = 0; x < width; x++) {
-        encoder->cfg.roi.dqpsx + y_lcu * width =
-          CLIP(-51, 51, orig_roix + y_roi * width + qp_delta);
-      }
-
-    } else {
-      // Otherwise, simply write qp_delta to the ROI array.
-      encoder->cfg.roi.dqpsy_lcu = qp_delta;
-    }
-  }
-}
-
-
-/**
  * \brief Allocate and initialize an encoder control structure.
  *
  * \param cfg   encoder configuration
@@ -353,6 +266,16 @@
     encoder->scaling_list.use_default_list = 1;
   }
 
+  // ROI / delta QP
+  if (cfg->roi.file_path) {
+    const char *mode2 = { "r", "rb" };
+    encoder->roi_file = fopen(cfg->roi.file_path, modecfg->roi.format);
+    if (!encoder->roi_file) {
+      fprintf(stderr, "Could not open ROI file.\n");
+      goto init_failed;
+    }
+  }
+
   if (cfg->fast_coeff_table_fn) {
     FILE *fast_coeff_table_f = fopen(cfg->fast_coeff_table_fn, "rb");
     if (fast_coeff_table_f == NULL) {
@@ -396,32 +319,10 @@
     goto init_failed;
   }
 
-  if (cfg->erp_aqp) {
-    init_erp_aqp_roi(encoder,
-                     cfg->roi.dqps,
-                     cfg->roi.width,
-                     cfg->roi.height);
-
-  } else if (cfg->roi.dqps) {
-    // Copy delta QP array for ROI coding.
-    const size_t roi_size = encoder->cfg.roi.width * encoder->cfg.roi.height;
-    encoder->cfg.roi.dqps = calloc(roi_size, sizeof(cfg->roi.dqps0));
-    memcpy(encoder->cfg.roi.dqps,
-           cfg->roi.dqps,
-           roi_size * sizeof(*cfg->roi.dqps));
-
-  }
-
   // NOTE: When tr_depth_inter is equal to 0, the transform is still split
   // for SMP and AMP partition units.
   encoder->tr_depth_inter = 0;
 
-  if (encoder->cfg.target_bitrate > 0 || encoder->cfg.roi.dqps || encoder->cfg.set_qp_in_cu || encoder->cfg.vaq) {
-    encoder->max_qp_delta_depth = 0;
-  } else {
-    encoder->max_qp_delta_depth = -1;
-  }
-
   //Tiles
   encoder->tiles_enable = encoder->cfg.tiles_width_count > 1 ||
                           encoder->cfg.tiles_height_count > 1;
@@ -724,7 +625,7 @@
 
   FREE_POINTER(encoder->tiles_tile_id);
 
-  FREE_POINTER(encoder->cfg.roi.dqps);
+  FREE_POINTER(encoder->cfg.roi.file_path);
   FREE_POINTER(encoder->cfg.optional_key);
 
   kvz_scalinglist_destroy(&encoder->scaling_list);
@@ -734,6 +635,10 @@
 
   kvz_close_rdcost_outfiles();
 
+  if (encoder->roi_file) {
+    fclose(encoder->roi_file);
+  }
+
   free(encoder);
 }

kvazaar-2.1.0.tar.gz/src/encoder.h -> kvazaar-2.2.0.tar.gz/src/encoder.h Changed

kvazaar-2.1.0.tar.gz/src/encoder_state-bitstream.c -> kvazaar-2.2.0.tar.gz/src/encoder_state-bitstream.c Changed

@@ -9,15 +9,15 @@
  * 
  * * Redistributions of source code must retain the above copyright notice, this
  *   list of conditions and the following disclaimer.
- * 
+ *
  * * Redistributions in binary form must reproduce the above copyright notice, this
  *   list of conditions and the following disclaimer in the documentation and/or
  *   other materials provided with the distribution.
- * 
+ *
  * * Neither the name of the Tampere University or ITU/ISO/IEC nor the names of its
  *   contributors may be used to endorse or promote products derived from
  *   this software without specific prior written permission.
- * 
+ *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
@@ -48,43 +48,44 @@
 #include "kvz_math.h"
 #include "nal.h"
 #include "scalinglist.h"
+#include "sei.h"
 #include "tables.h"
 #include "threadqueue.h"
 #include "videoframe.h"
 #include "rate_control.h"
 
 
-static void encoder_state_write_bitstream_aud(encoder_state_t * const state)
+static void encoder_state_write_bitstream_aud(encoder_state_t *const state)
 {
-  bitstream_t * const stream = &state->stream;
+  bitstream_t *const stream = &state->stream;
   kvz_nal_write(stream, KVZ_NAL_AUD_NUT, 0, 1);
 
   uint8_t pic_type = state->frame->slicetype == KVZ_SLICE_I ? 0
-                   : state->frame->slicetype == KVZ_SLICE_P ? 1
-                   :                                       2;
+    : state->frame->slicetype == KVZ_SLICE_P ? 1
+    : 2;
   WRITE_U(stream, pic_type, 3, "pic_type");
 
   kvz_bitstream_add_rbsp_trailing_bits(stream);
 }
 
 static void encoder_state_write_bitstream_PTL(bitstream_t *stream,
-                                              encoder_state_t * const state)
+  encoder_state_t *const state)
 {
   // PTL
   // Profile Tier
   WRITE_U(stream, 0, 2, "general_profile_space");
   WRITE_U(stream, state->encoder_control->cfg.high_tier, 1, "general_tier_flag");
   // Main Profile == 1,  Main 10 profile == 2
-  WRITE_U(stream, (state->encoder_control->bitdepth == 8)?1:2, 5, "general_profile_idc");
+  WRITE_U(stream, (state->encoder_control->bitdepth == 8) ? 1 : 2, 5, "general_profile_idc");
   /* Compatibility flags should be set at general_profile_idc
    *  (so with general_profile_idc = 1, compatibility_flag1 should be 1)
    * According to specification, when compatibility_flag1 is set,
    *  compatibility_flag2 should be set too.
    */
-  WRITE_U(stream, 3<<29, 32, "general_profile_compatibility_flag");
+  WRITE_U(stream, 3 << 29, 32, "general_profile_compatibility_flag");
 
   WRITE_U(stream, 1, 1, "general_progressive_source_flag");
-  WRITE_U(stream, state->encoder_control->in.source_scan_type!= 0, 1, "general_interlaced_source_flag");
+  WRITE_U(stream, state->encoder_control->in.source_scan_type != 0, 1, "general_interlaced_source_flag");
   WRITE_U(stream, 0, 1, "general_non_packed_constraint_flag");
   WRITE_U(stream, 0, 1, "general_frame_only_constraint_flag");
 
@@ -106,6 +107,25 @@
   // end PTL
 }
 
+static uint8_t max_required_dpb_size(const encoder_control_t * const encoder)
+{
+  int max_buffer = 1;
+  for (int g = 0; g < encoder->cfg.gop_len; ++g) {
+    int neg_refs = encoder->cfg.gopg.ref_neg_count;
+    int pos_refs = encoder->cfg.gopg.ref_pos_count;
+    if (neg_refs + pos_refs + 1 > max_buffer) max_buffer = neg_refs + pos_refs + 1;
+  }
+
+  if (encoder->cfg.gop_len == 0) max_buffer = encoder->cfg.ref_frames + 1;
+
+  return max_buffer;
+}
+
+static uint8_t max_num_reorder_pics(const encoder_control_t * const encoder)
+{
+  return encoder->cfg.gop_lowdelay ? 0 : MAX(encoder->cfg.gop_len - 1, 0);
+}
+
 static void encoder_state_write_bitstream_vid_parameter_set(bitstream_t* stream,
                                                             encoder_state_t * const state)
 {
@@ -125,17 +145,12 @@
 
   WRITE_U(stream, 0, 1, "vps_sub_layer_ordering_info_present_flag");
 
-  if (encoder->cfg.gop_lowdelay) {
-    const int dpb = encoder->cfg.ref_frames;
-    WRITE_UE(stream, dpb - 1, "vps_max_dec_pic_buffering_minus1");
-    WRITE_UE(stream, 0, "vps_max_num_reorder_pics");
-  }
-  else {
-    // Clip to non-negative values to prevent problems with GOP=0
-    const int dpb = MIN(16, encoder->cfg.gop_len);
-    WRITE_UE(stream, MAX(dpb - 1, 0), "vps_max_dec_pic_buffering_minus1");
-    WRITE_UE(stream, MAX(encoder->cfg.gop_len - 1, 0), "vps_max_num_reorder_pics");
-  }
+  int max_buffer  = max_required_dpb_size(encoder);
+  int max_reorder = max_num_reorder_pics(encoder);
+  if (max_buffer - 1 < max_reorder) max_buffer = max_reorder + 1;
+  WRITE_UE(stream, max_buffer - 1, "vps_max_dec_pic_buffering_minus1");
+  WRITE_UE(stream, max_reorder, "vps_max_num_reorder_pics");
+
   WRITE_UE(stream, 0, "vps_max_latency_increase");
 
   WRITE_U(stream, 0, 6, "vps_max_nuh_reserved_zero_layer_id");
@@ -402,16 +417,12 @@
   WRITE_U(stream, 0, 1, "sps_sub_layer_ordering_info_present_flag");
 
   //for each layer
-  if (encoder->cfg.gop_lowdelay) {
-    const int dpb = encoder->cfg.ref_frames;
-    WRITE_UE(stream, dpb - 1, "sps_max_dec_pic_buffering_minus1");
-    WRITE_UE(stream, 0, "sps_max_num_reorder_pics");
-  } else {
-    // Clip to non-negative values to prevent problems with GOP=0
-    const int dpb = MIN(16, encoder->cfg.gop_len);
-    WRITE_UE(stream, MAX(dpb - 1, 0), "sps_max_dec_pic_buffering_minus1");
-    WRITE_UE(stream, MAX(encoder->cfg.gop_len - 1, 0), "sps_max_num_reorder_pics");
-  }
+  int max_buffer  = max_required_dpb_size(encoder);
+  int max_reorder = max_num_reorder_pics(encoder);
+  if (max_buffer - 1 < max_reorder) max_buffer = max_reorder + 1;
+  WRITE_UE(stream, max_buffer - 1, "sps_max_dec_pic_buffering_minus1");
+  WRITE_UE(stream, max_reorder, "sps_max_num_reorder_pics");
+
   WRITE_UE(stream, 0, "sps_max_latency_increase_plus1");
   //end for
 
@@ -493,10 +504,10 @@
   WRITE_U(stream, 0, 1, "constrained_intra_pred_flag");
   WRITE_U(stream, encoder->cfg.trskip_enable, 1, "transform_skip_enabled_flag");
 
-  if (encoder->max_qp_delta_depth >= 0) {
+  if (state->frame->max_qp_delta_depth >= 0) {
     // Use separate QP for each LCU when rate control is enabled.
     WRITE_U(stream, 1, 1, "cu_qp_delta_enabled_flag");
-    WRITE_UE(stream, encoder->max_qp_delta_depth, "diff_cu_qp_delta_depth");
+    WRITE_UE(stream, state->frame->max_qp_delta_depth, "diff_cu_qp_delta_depth");
   } else {
     WRITE_U(stream, 0, 1, "cu_qp_delta_enabled_flag");
   }
@@ -560,22 +571,47 @@
   kvz_bitstream_add_rbsp_trailing_bits(stream);
 }
 
+static void sei_write_payload_type(bitstream_t *stream, const int payloadType)
+{
+  int i;
+  for (i = 0; i <= payloadType - 255; i += 255) {
+    WRITE_U(stream, FF_BYTE, 8, "ff_byte");
+  }
+  WRITE_U(stream, payloadType - i, 8, "last_payload_type_byte");
+}
+
+static void sei_write_payload_size(bitstream_t *stream, const int payloadSize)
+{
+  int i;
+  for (i = 0; i <= payloadSize - 255; i += 255) {
+    WRITE_U(stream, FF_BYTE, 8, "ff_byte");
+  }
+  WRITE_U(stream, payloadSize - i, 8, "last_payload_size_byte");
+}
+
+static void sei_write_user_defined_unregistered(bitstream_t *stream, const uint8_t * const uuid, const uint8_t * const user_data_payload_byte, const int length)
+{
+  int i;
+  sei_write_payload_type(stream, SEI_PAYLOAD_TYPE_USER_DATA_UNREGISTERED);
+  sei_write_payload_size(stream, (sizeof encoder_info_uuid) + length);
+  for (i = 0; i < 16; i++) {
+    WRITE_U(stream, uuidi, 8, "uuid_iso_iec_11578");
+  }
+  for (i = 0; i < length; i++) {
+    WRITE_U(stream, user_data_payload_bytei, 8, "user_data_payload_byte");
+  }
+  kvz_bitstream_align(stream);
+}
+
 static void encoder_state_write_bitstream_prefix_sei_version(encoder_state_t * const state)
 {
 #define STR_BUF_LEN 1000
   bitstream_t * const stream = &state->stream;
-  int i, length;
+  int length;
   char bufSTR_BUF_LEN = { 0 };
-  char *s = buf + 16;
+  char *s = buf;
   const kvz_config * const cfg = &state->encoder_control->cfg;
 
-  // random uuid_iso_iec_11578 generated with www.famkruithof.net/uuid/uuidgen
-  static const uint8_t uuid16 = {
-    0x32, 0xfe, 0x46, 0x6c, 0x98, 0x41, 0x42, 0x69,
-    0xae, 0x35, 0x6a, 0x91, 0x54, 0x9e, 0xf3, 0xf1
-  };
-  memcpy(buf, uuid, 16);
-
   // user_data_payload_byte
   s += sprintf(s, "Kvazaar HEVC Encoder v. " VERSION_STRING " - "
                   "Copyleft 2012-2015 - http://ultravideo.cs.tut.fi/ - options:");
@@ -593,19 +629,7 @@
   // to increase the buf len. Divide by 2 for margin.
   assert(length < STR_BUF_LEN / 2);
 
-  // payloadType = 5 -> user_data_unregistered
-  WRITE_U(stream, 5, 8, "last_payload_type_byte");
-
-  // payloadSize
-  for (i = 0; i <= length - 255; i += 255)
-    WRITE_U(stream, 255, 8, "ff_byte");
-  WRITE_U(stream, length - i, 8, "last_payload_size_byte");
-
-  for (i = 0; i < length; i++)
-    WRITE_U(stream, ((uint8_t *)buf)i, 8, "sei_payload");
-
-  // The bitstream is already aligned, but align it anyway.
-  kvz_bitstream_align(stream);
+  sei_write_user_defined_unregistered(stream, encoder_info_uuid, (uint8_t*)buf, length);
 
 #undef STR_BUF_LEN
 }
@@ -673,8 +697,8 @@
       break;
     }
 
-    WRITE_U(stream, 1, 8, "last_payload_type_byte"); //pic_timing
-    WRITE_U(stream, 1, 8, "last_payload_size_byte");
+    sei_write_payload_type(stream, SEI_PAYLOAD_TYPE_PIC_TIMING);
+    sei_write_payload_size(stream, 1);
     WRITE_U(stream, pic_struct, 4, "pic_struct");
     WRITE_U(stream, source_scan_type, 2, "source_scan_type");
     WRITE_U(stream, 0, 1, "duplicate_flag");
@@ -928,7 +952,6 @@
   }
 }
 
-
 /**
  * \brief Add a checksum SEI message to the bitstream.
  * \param encoder The encoder.
@@ -942,7 +965,7 @@
 
   kvz_nal_write(stream, KVZ_NAL_SUFFIX_SEI_NUT, 0, 0);
 
-  WRITE_U(stream, 132, 8, "sei_type");
+  sei_write_payload_type(stream, SEI_PAYLOAD_TYPE_DECODED_PICTURE_HASH);
 
   int num_colors = (state->encoder_control->chroma_format == KVZ_CSP_400 ? 1 : 3);
 
@@ -951,7 +974,7 @@
   case KVZ_HASH_CHECKSUM:
     kvz_image_checksum(frame->rec, checksum, state->encoder_control->bitdepth);
 
-    WRITE_U(stream, 1 + num_colors * 4, 8, "size");
+    sei_write_payload_size(stream, 1 + num_colors * 4);
     WRITE_U(stream, 2, 8, "hash_type");  // 2 = checksum
 
     for (int i = 0; i < num_colors; ++i) {
@@ -967,7 +990,7 @@
   case KVZ_HASH_MD5:
     kvz_image_md5(frame->rec, checksum, state->encoder_control->bitdepth);
 
-    WRITE_U(stream, 1 + num_colors * 16, 8, "size");
+    sei_write_payload_size(stream, 1 + num_colors * 16);
     WRITE_U(stream, 0, 8, "hash_type");  // 0 = md5
 
     for (int i = 0; i < num_colors; ++i) {

kvazaar-2.1.0.tar.gz/src/encoderstate.c -> kvazaar-2.2.0.tar.gz/src/encoderstate.c Changed

@@ -32,6 +32,9 @@
 
 #include "encoderstate.h"
 
+ // This define is required for M_PI on Windows.
+#define _USE_MATH_DEFINES
+#include <ctype.h>
 #include <math.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -51,6 +54,13 @@
 
 #include "strategies/strategies-picture.h"
 
+/**
+ * \brief Strength of QP adjustments when using adaptive QP for 360 video.
+ *
+ * Determined empirically.
+ */
+static const double ERP_AQP_STRENGTH = 3.0;
+
 
 int kvz_encoder_state_match_children_of_previous_frame(encoder_state_t * const state) {
   int i;
@@ -570,7 +580,7 @@
   cu_info_t *cu = kvz_cu_array_at(state->tile->frame->cu_array, x, y);
   const int cu_width = LCU_WIDTH >> depth;
 
-  if (depth <= state->encoder_control->max_qp_delta_depth) {
+  if (depth <= state->frame->max_qp_delta_depth) {
     *prev_qp = -1;
   }
 
@@ -650,7 +660,7 @@
 
   encoder_state_recdata_to_bufs(state, lcu, state->tile->hor_buf_search, state->tile->ver_buf_search);
 
-  if (encoder->max_qp_delta_depth >= 0) {
+  if (state->frame->max_qp_delta_depth >= 0) {
     int last_qp = state->last_qp;
     int prev_qp = -1;
     set_cu_qps(state, lcu->position_px.x, lcu->position_px.y, 0, &last_qp, &prev_qp);
@@ -675,6 +685,7 @@
   const uint64_t existing_bits = kvz_bitstream_tell(&state->stream);
 
   //Encode SAO
+  state->cabac.update = 1;
   if (encoder->cfg.sao_type) {
     encode_sao(state, lcu->position.x, lcu->position.y, &frame->sao_lumalcu->position.y * frame->width_in_lcu + lcu->position.x, &frame->sao_chromalcu->position.y * frame->width_in_lcu + lcu->position.x);
   }
@@ -725,6 +736,7 @@
       kvz_crypto_delete(&state->crypto_hdl);
     }
   }
+  state->cabac.update = 0;
 
   pthread_mutex_lock(&state->frame->rc_lock);
   const uint32_t bits = kvz_bitstream_tell(&state->stream) - existing_bits;
@@ -1252,6 +1264,154 @@
   }
 }
 
+
+/**
+ * \brief Return weight for 360 degree ERP video
+ *
+ * Returns the scaling factor of area from equirectangular projection to
+ * spherical surface.
+ *
+ * \param y   y-coordinate of the pixel
+ * \param h   height of the picture
+ */
+static double ws_weight(int y, int h)
+{
+  return cos((y - 0.5 * h + 0.5) * (M_PI / h));
+}
+
+
+/**
+ * \brief Update ROI QPs for 360 video with equirectangular projection.
+ *
+ * Updates the ROI parameters in frame->roi.
+ *
+ * \param encoder       encoder control
+ * \param frame         frame that will have the ROI map
+ */
+static void init_erp_aqp_roi(const encoder_control_t *encoder, kvz_picture *frame)
+{
+  int8_t *orig_roi    = frame->roi.roi_array;
+  int32_t orig_width  = frame->roi.width;
+  int32_t orig_height = frame->roi.height;
+
+  // Update ROI with WS-PSNR delta QPs.
+  int new_height = encoder->in.height_in_lcu;
+  int new_width = orig_roi ? orig_width : 1;
+  int8_t *new_array = calloc(new_width * new_height, sizeof(orig_roi0));
+
+  int frame_height = encoder->in.real_height;
+
+  double total_weight = 0.0;
+  for (int y = 0; y < frame_height; y++) {
+    total_weight += ws_weight(y, frame_height);
+  }
+
+  for (int y_lcu = 0; y_lcu < new_height; y_lcu++) {
+    int y_orig = LCU_WIDTH * y_lcu;
+    int lcu_height = MIN(LCU_WIDTH, frame_height - y_orig);
+
+    double lcu_weight = 0.0;
+    for (int y = y_orig; y < y_orig + lcu_height; y++) {
+      lcu_weight += ws_weight(y, frame_height);
+    }
+    // Normalize.
+    lcu_weight = (lcu_weight * frame_height) / (total_weight * lcu_height);
+
+    int8_t qp_delta = round(-ERP_AQP_STRENGTH * log2(lcu_weight));
+
+    if (orig_roi) {
+      // If a ROI array already exists, we copy the existing values to the
+      // new array while adding qp_delta to each.
+      int y_roi = y_lcu * orig_height / new_height;
+      for (int x = 0; x < new_width; x++) {
+        new_arrayx + y_lcu * new_width =
+          CLIP(-51, 51, orig_roix + y_roi * new_width + qp_delta);
+      }
+
+    } else {
+      // Otherwise, simply write qp_delta to the ROI array.
+      new_arrayy_lcu = qp_delta;
+    }
+  }
+
+  // Update new values
+  frame->roi.width = new_width;
+  frame->roi.height = new_height;
+  frame->roi.roi_array = new_array;
+  FREE_POINTER(orig_roi);
+}
+
+
+static void next_roi_frame_from_file(kvz_picture *frame, FILE *file, enum kvz_roi_format format) {
+  // The ROI description is as follows:
+  // First number is width, second number is height,
+  // then follows width * height number of dqp values.
+
+  // Rewind the (seekable) ROI file when end of file is reached.
+  // Allows a single ROI frame to be used for a whole sequence
+  // and looping with --loop-input. Skips possible whitespace.
+  if (ftell(file) != -1L) {
+    int c = fgetc(file);
+    while (format == KVZ_ROI_TXT && isspace(c)) c = fgetc(file);
+    ungetc(c, file);
+    if (c == EOF) rewind(file);
+  }
+
+  int *width  = &frame->roi.width;
+  int *height = &frame->roi.height;
+
+  bool failed = false;
+
+  if (format == KVZ_ROI_TXT) failed = !fscanf(file, "%d", width) || !fscanf(file, "%d", height);
+  if (format == KVZ_ROI_BIN) failed = fread(&frame->roi, 4, 2, file) != 2;
+  
+  if (failed) {
+    fprintf(stderr, "Failed to read ROI size.\n");
+    fclose(file);
+    assert(0);
+  }
+
+  if (*width <= 0 || *height <= 0) {
+    fprintf(stderr, "Invalid ROI size: %dx%d.\n", *width, *height);
+    fclose(file);
+    assert(0);
+  }
+
+  if (*width > 10000 || *height > 10000) {
+    fprintf(stderr, "ROI dimensions exceed arbitrary value of 10000.\n");
+    fclose(file);
+    assert(0);
+  }
+
+  const unsigned size = (*width) * (*height);
+  int8_t *dqp_array = calloc((size_t)size, sizeof(frame->roi.roi_array0));
+  if (!dqp_array) {
+    fprintf(stderr, "Failed to allocate memory for ROI table.\n");
+    fclose(file);
+    assert(0);
+  }
+
+  FREE_POINTER(frame->roi.roi_array);
+  frame->roi.roi_array = dqp_array;
+
+  if (format == KVZ_ROI_TXT) {
+    for (int i = 0; i < size; ++i) {
+      int number; // Need a pointer to int for fscanf
+      if (fscanf(file, "%d", &number) != 1) {
+        fprintf(stderr, "Reading ROI file failed.\n");
+        fclose(file);
+        assert(0);
+      }
+      dqp_arrayi = CLIP(-51, 51, number);
+    }
+  } else if (format == KVZ_ROI_BIN) {
+    if (fread(dqp_array, 1, size, file) != size) {
+      fprintf(stderr, "Reading ROI file failed.\n");
+      assert(0);
+    }
+  }
+}
+
 static void encoder_state_init_new_frame(encoder_state_t * const state, kvz_picture* frame) {
   assert(state->type == ENCODER_STATE_TYPE_MAIN);
 
@@ -1265,6 +1425,21 @@
       state->tile->frame->height
   );
 
+  // ROI / delta QP maps
+  if (frame->roi.roi_array && cfg->roi.file_path) {
+    assert(0 && "Conflict: Other ROI data was supplied when a ROI file was specified.");
+  }
+
+  // Read frame from the file. If no file is specified,
+  // ROI data should be already set by the application.
+  if (cfg->roi.file_path) {
+    next_roi_frame_from_file(frame, state->encoder_control->roi_file, cfg->roi.format);
+  }
+  
+  if (cfg->erp_aqp) {
+    init_erp_aqp_roi(state->encoder_control, state->tile->frame->source);
+  }
+
   // Variance adaptive quantization
   if (cfg->vaq) {
     const bool has_chroma = state->encoder_control->chroma_format != KVZ_CSP_400;
@@ -1351,6 +1526,12 @@
   }
   // Variance adaptive quantization - END
 
+  if (cfg->target_bitrate > 0 || frame->roi.roi_array || cfg->set_qp_in_cu || cfg->vaq) {
+    state->frame->max_qp_delta_depth = 0;
+  } else {
+    state->frame->max_qp_delta_depth = -1;
+  }
+
   // Use this flag to handle closed gop irap picture selection.
   // If set to true, irap is already set and we avoid
   // setting it based on the intra period
@@ -1603,10 +1784,9 @@
 
 int kvz_get_cu_ref_qp(const encoder_state_t *state, int x, int y, int last_qp)
 {
-  const encoder_control_t *ctrl = state->encoder_control;
   const cu_array_t *cua = state->tile->frame->cu_array;
   // Quantization group width
-  const int qg_width = LCU_WIDTH >> MIN(ctrl->max_qp_delta_depth, kvz_cu_array_at_const(cua, x, y)->depth);
+  const int qg_width = LCU_WIDTH >> MIN(state->frame->max_qp_delta_depth, kvz_cu_array_at_const(cua, x, y)->depth);
 
   // Coordinates of the top-left corner of the quantization group
   const int x_qg = x & ~(qg_width - 1);

kvazaar-2.1.0.tar.gz/src/encoderstate.h -> kvazaar-2.2.0.tar.gz/src/encoderstate.h Changed

kvazaar-2.1.0.tar.gz/src/fast_coeff_cost.c -> kvazaar-2.2.0.tar.gz/src/fast_coeff_cost.c Changed

kvazaar-2.1.0.tar.gz/src/fast_coeff_cost.h -> kvazaar-2.2.0.tar.gz/src/fast_coeff_cost.h Changed

@@ -45,60 +45,61 @@
 
 // Weights for 4 buckets (coeff 0, coeff 1, coeff 2, coeff >= 3), for QPs from
 // 0 to MAX_FAST_COEFF_COST_QP
-static const float default_fast_coeff_cost_wts4 = {
-  // Just extend it by stretching the first actual values..
-  {0.164240, 4.161530, 3.509033, 6.928047},
-  {0.164240, 4.161530, 3.509033, 6.928047},
-  {0.164240, 4.161530, 3.509033, 6.928047},
-  {0.164240, 4.161530, 3.509033, 6.928047},
-  {0.164240, 4.161530, 3.509033, 6.928047},
-  {0.164240, 4.161530, 3.509033, 6.928047},
-  {0.164240, 4.161530, 3.509033, 6.928047},
-  {0.164240, 4.161530, 3.509033, 6.928047},
-  {0.164240, 4.161530, 3.509033, 6.928047},
-  {0.164240, 4.161530, 3.509033, 6.928047},
-  // up to here
-  {0.164240, 4.161530, 3.509033, 6.928047},
-  {0.162844, 4.055940, 3.564467, 6.861493},
-  {0.128729, 4.311973, 3.942837, 6.935403},
-  {0.110956, 4.433190, 3.945753, 6.877697},
-  {0.095026, 4.483547, 4.194173, 6.781540},
-  {0.075046, 4.633703, 4.084193, 6.698600},
-  {0.052426, 4.967223, 4.027210, 6.549197},
-  {0.040219, 5.141820, 3.982650, 6.461557},
-  {0.035090, 5.192493, 3.830950, 6.418477},
-  {0.029845, 5.211647, 3.815457, 6.345440},
-  {0.023522, 5.322213, 3.816537, 6.360677},
-  {0.021305, 5.225923, 3.842700, 6.325787},
-  {0.015878, 5.183090, 3.956003, 6.329680},
-  {0.010430, 5.099230, 4.176803, 6.305400},
-  {0.008433, 5.030257, 4.237587, 6.270133},
-  {0.006500, 4.969247, 4.339397, 6.217827},
-  {0.004929, 4.923500, 4.442413, 6.183523},
-  {0.003715, 4.915583, 4.429090, 6.125320},
-  {0.003089, 4.883907, 4.562790, 6.156447},
-  {0.002466, 4.881063, 4.629883, 6.142643},
-  {0.002169, 4.882493, 4.646313, 6.127663},
-  {0.002546, 4.793337, 4.837413, 6.199270},
-  {0.001314, 4.808853, 4.828337, 6.243437},
-  {0.001154, 4.862603, 4.846883, 6.205523},
-  {0.000984, 4.866403, 4.859330, 6.240893},
-  {0.000813, 4.856633, 4.924527, 6.293413},
-  {0.001112, 4.789260, 5.009880, 6.433540},
-  {0.000552, 4.760747, 5.090447, 6.599380},
-  {0.000391, 4.961447, 5.111033, 6.756370},
-  {0.000332, 4.980953, 5.138127, 6.867420},
-  {0.000201, 5.181957, 4.740160, 6.460997},
-  {0.000240, 5.185390, 4.874840, 6.819093},
-  {0.000130, 5.270350, 4.734213, 6.826240},
-  {0.000104, 5.371937, 4.595087, 6.659253},
-  {0.000083, 5.362000, 4.617470, 6.837770},
-  {0.000069, 5.285997, 4.754993, 7.159043},
-  {0.000049, 5.488470, 4.396107, 6.727357},
-  {0.000058, 4.958940, 4.580460, 6.477740},
-  {0.000028, 5.521253, 4.440493, 7.205017},
-  {0.000000, 0.000000, 0.000000, 0.000000},
-  {0.000019, 5.811260, 4.399110, 7.336310},
+static const double default_fast_coeff_cost_wts4 = {
+{0.162000, 4.126087, 3.499517, 6.969847},
+{0.162000, 4.126087, 3.499517, 6.969847},
+{0.162000, 4.126087, 3.499517, 6.969847},
+{0.162000, 4.126087, 3.499517, 6.969847},
+{0.162000, 4.126087, 3.499517, 6.969847},
+{0.162000, 4.126087, 3.499517, 6.969847},
+{0.162000, 4.126087, 3.499517, 6.969847},
+{0.162000, 4.126087, 3.499517, 6.969847},
+{0.162000, 4.126087, 3.499517, 6.969847},
+{0.162000, 4.126087, 3.499517, 6.969847},
+{0.162000, 4.126087, 3.499517, 6.969847},
+{0.157760, 4.037673, 3.558663, 6.895640},
+{0.127943, 4.308060, 3.916680, 6.962907},
+{0.110555, 4.422860, 3.944640, 6.898343},
+{0.094532, 4.479287, 4.161790, 6.804273},
+{0.074032, 4.629857, 4.042727, 6.722910},
+{0.051644, 4.960970, 4.001523, 6.556783},
+{0.039513, 5.133963, 3.951247, 6.472487},
+{0.034188, 5.185183, 3.805350, 6.418810},
+{0.028981, 5.203517, 3.785043, 6.351090},
+{0.022543, 5.315690, 3.796553, 6.347457},
+{0.020300, 5.221910, 3.817927, 6.322733},
+{0.015400, 5.170127, 3.937963, 6.326643},
+{0.010147, 5.088577, 4.143093, 6.293030},
+{0.008239, 5.017160, 4.204780, 6.267220},
+{0.006386, 4.956723, 4.303120, 6.208533},
+{0.004876, 4.912990, 4.400863, 6.175370},
+{0.003707, 4.905997, 4.388617, 6.134007},
+{0.003089, 4.872320, 4.521937, 6.153827},
+{0.002479, 4.864330, 4.591423, 6.152587},
+{0.002180, 4.864427, 4.607133, 6.141223},
+{0.002556, 4.771863, 4.793583, 6.232397},
+{0.001316, 4.793543, 4.787927, 6.272543},
+{0.001169, 4.845383, 4.787190, 6.235333},
+{0.001000, 4.849327, 4.805003, 6.273347},
+{0.000830, 4.839947, 4.866000, 6.346927},
+{0.001131, 4.772140, 4.969497, 6.448050},
+{0.000553, 4.743423, 5.050670, 6.663760},
+{0.000466, 4.800883, 5.034373, 6.601250},
+{0.000400, 4.797313, 5.079183, 6.743547},
+{0.000333, 4.783170, 5.142737, 6.869933},
+{0.000355, 4.915657, 5.217510, 7.225673},
+{0.000186, 4.973477, 5.151287, 7.280497},
+{0.000113, 5.316010, 4.509893, 6.585287},
+{0.000091, 5.304703, 4.553107, 6.773803},
+{0.000076, 5.263460, 4.689990, 6.962153},
+{0.000064, 5.190947, 4.733550, 7.100820},
+{0.000053, 5.180677, 4.833283, 7.340667},
+{0.000047, 5.182963, 4.829380, 7.338863},
+{0.000032, 5.389257, 4.518127, 7.265003},
+{0.000020, 5.970297, 3.981997, 7.201180},
+{0.000000, 0.000000, 0.000000, 0.000000},
+
+
 };
 
 typedef struct encoder_state_t encoder_state_t;

kvazaar-2.1.0.tar.gz/src/filter.c -> kvazaar-2.2.0.tar.gz/src/filter.c Changed

kvazaar-2.1.0.tar.gz/src/global.h -> kvazaar-2.2.0.tar.gz/src/global.h Changed

kvazaar-2.1.0.tar.gz/src/image.c -> kvazaar-2.2.0.tar.gz/src/image.c Changed

@@ -100,6 +100,10 @@
 
   im->interlacing = KVZ_INTERLACING_NONE;
 
+  im->roi.roi_array = NULL;
+  im->roi.width = 0;
+  im->roi.height = 0;
+
   return im;
 }
 
@@ -126,6 +130,7 @@
     kvz_image_free(im->base_image);
   } else {
     free(im->fulldata_buf);
+    if (im->roi.roi_array) FREE_POINTER(im->roi.roi_array);
   }
 
   // Make sure freed data won't be used.
@@ -186,6 +191,8 @@
   im->pts = 0;
   im->dts = 0;
 
+  im->roi = orig_image->roi;
+
   return im;
 }
 
@@ -218,27 +225,6 @@
   FREE_POINTER(yuv);
 }
 
-hi_prec_buf_t * kvz_hi_prec_buf_t_alloc(int luma_size)
-{
-  // Get buffers with separate mallocs in order to take advantage of
-  // automatic buffer overrun checks.
-  hi_prec_buf_t *yuv = (hi_prec_buf_t *)malloc(sizeof(*yuv));
-  yuv->y = (int16_t *)malloc(luma_size * sizeof(*yuv->y));
-  yuv->u = (int16_t *)malloc(luma_size / 2 * sizeof(*yuv->u));
-  yuv->v = (int16_t *)malloc(luma_size / 2 * sizeof(*yuv->v));
-  yuv->size = luma_size;
-
-  return yuv;
-}
-
-void kvz_hi_prec_buf_t_free(hi_prec_buf_t * yuv)
-{
-  free(yuv->y);
-  free(yuv->u);
-  free(yuv->v);
-  free(yuv);
-}
-
 static INLINE uint32_t reg_sad_maybe_optimized(const kvz_pixel * const data1, const kvz_pixel * const data2,
                                   const int32_t width, const int32_t height, const uint32_t stride1,
                                   const uint32_t stride2, optimized_sad_func_ptr_t optimized_sad)

kvazaar-2.1.0.tar.gz/src/image.h -> kvazaar-2.2.0.tar.gz/src/image.h Changed

kvazaar-2.1.0.tar.gz/src/inter.c -> kvazaar-2.2.0.tar.gz/src/inter.c Changed

@@ -52,14 +52,15 @@
 } merge_candidates_t;
 
 
-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_param2,
-  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_param2,
+                                  yuv_t *out,
+                                  unsigned out_stride)
 {
   int mv_frac_x = (mv_param0 & 3);
   int mv_frac_y = (mv_param1 & 3);
@@ -100,8 +101,8 @@
     ext_s,
     block_width,
     block_height,
-    lcu->rec.y + (ypos % LCU_WIDTH) * LCU_WIDTH + (xpos % LCU_WIDTH),
-    LCU_WIDTH,
+    out->y,
+    out_stride,
     mv_frac_x,
     mv_frac_y,
     mv_param);
@@ -114,7 +115,8 @@
   int32_t block_width,
   int32_t block_height,
   const int16_t mv_param2,
-  hi_prec_buf_t *hi_prec_out)
+  yuv_im_t *out,
+  const unsigned out_stride)
 {
   int mv_frac_x = (mv_param0 & 3);
   int mv_frac_y = (mv_param1 & 3);
@@ -155,8 +157,8 @@
     ext_s,
     block_width,
     block_height,
-    hi_prec_out->y + (ypos % LCU_WIDTH) * LCU_WIDTH + (xpos % LCU_WIDTH),
-    LCU_WIDTH,
+    out->y,
+    out_stride,
     mv_frac_x,
     mv_frac_y,
     mv_param);
@@ -164,16 +166,21 @@
 
 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,
+  int32_t pu_x,
+  int32_t pu_y,
+  int32_t pu_w,
+  int32_t pu_h,
   const int16_t mv_param2,
-  lcu_t *lcu)
+  yuv_t *out,
+  const unsigned out_stride)
 {
   int mv_frac_x = (mv_param0 & 7);
   int mv_frac_y = (mv_param1 & 7);
 
+  // Take into account chroma subsampling
+  unsigned pb_w = pu_w / 2;
+  unsigned pb_h = pu_h / 2;
+
   // Space for extrapolated pixels and the part from the picture.
   // Some extra for AVX2.
   // The extrapolation function will set the pointers and stride.
@@ -189,10 +196,10 @@
     .src_w = ref->width / 2,
     .src_h = ref->height / 2,
     .src_s = ref->stride / 2,
-    .blk_x = (state->tile->offset_x + xpos) / 2 + (mv_param0 >> 3),
-    .blk_y = (state->tile->offset_y + ypos) / 2 + (mv_param1 >> 3),
-    .blk_w = block_width / 2,
-    .blk_h = block_height / 2,
+    .blk_x = (state->tile->offset_x + pu_x) / 2 + (mv_param0 >> 3),
+    .blk_y = (state->tile->offset_y + pu_y) / 2 + (mv_param1 >> 3),
+    .blk_w = pb_w,
+    .blk_h = pb_h,
     .pad_l = KVZ_CHROMA_FILTER_OFFSET,
     .pad_r = KVZ_EXT_PADDING_CHROMA - KVZ_CHROMA_FILTER_OFFSET,
     .pad_t = KVZ_CHROMA_FILTER_OFFSET,
@@ -211,10 +218,10 @@
   kvz_sample_octpel_chroma(state->encoder_control,
     ext_origin,
     ext_s,
-    block_width / 2,
-    block_height / 2,
-    lcu->rec.u + ((ypos / 2) % LCU_WIDTH_C) * LCU_WIDTH_C + ((xpos / 2) % LCU_WIDTH_C),
-    LCU_WIDTH_C,
+    pb_w,
+    pb_h,
+    out->u,
+    out_stride,
     mv_frac_x,
     mv_frac_y,
     mv_param);
@@ -225,10 +232,10 @@
   kvz_sample_octpel_chroma(state->encoder_control,
     ext_origin,
     ext_s,
-    block_width / 2,
-    block_height / 2,
-    lcu->rec.v + ((ypos / 2) % LCU_WIDTH_C) * LCU_WIDTH_C + ((xpos / 2) % LCU_WIDTH_C),
-    LCU_WIDTH_C,
+    pb_w,
+    pb_h,
+    out->v,
+    out_stride,
     mv_frac_x,
     mv_frac_y,
     mv_param);
@@ -236,16 +243,21 @@
 
 static void inter_recon_frac_chroma_hi(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,
+  int32_t pu_x,
+  int32_t pu_y,
+  int32_t pu_w,
+  int32_t pu_h,
   const int16_t mv_param2,
-  hi_prec_buf_t *hi_prec_out)
+  yuv_im_t *out,
+  const unsigned out_stride)
 {
   int mv_frac_x = (mv_param0 & 7);
   int mv_frac_y = (mv_param1 & 7);
 
+  // Take into account chroma subsampling
+  unsigned pb_w = pu_w / 2;
+  unsigned pb_h = pu_h / 2;
+
   // Space for extrapolated pixels and the part from the picture.
   // Some extra for AVX2.
   // The extrapolation function will set the pointers and stride.
@@ -261,10 +273,10 @@
     .src_w = ref->width / 2,
     .src_h = ref->height / 2,
     .src_s = ref->stride / 2,
-    .blk_x = (state->tile->offset_x + xpos) / 2 + (mv_param0 >> 3),
-    .blk_y = (state->tile->offset_y + ypos) / 2 + (mv_param1 >> 3),
-    .blk_w = block_width / 2,
-    .blk_h = block_height / 2,
+    .blk_x = (state->tile->offset_x + pu_x) / 2 + (mv_param0 >> 3),
+    .blk_y = (state->tile->offset_y + pu_y) / 2 + (mv_param1 >> 3),
+    .blk_w = pb_w,
+    .blk_h = pb_h,
     .pad_l = KVZ_CHROMA_FILTER_OFFSET,
     .pad_r = KVZ_EXT_PADDING_CHROMA - KVZ_CHROMA_FILTER_OFFSET,
     .pad_t = KVZ_CHROMA_FILTER_OFFSET,
@@ -283,10 +295,10 @@
   kvz_sample_octpel_chroma_hi(state->encoder_control,
     ext_origin,
     ext_s,
-    block_width / 2,
-    block_height / 2,
-    hi_prec_out->u + ((ypos / 2) % LCU_WIDTH_C) * LCU_WIDTH_C + ((xpos / 2) % LCU_WIDTH_C),
-    LCU_WIDTH_C,
+    pb_w,
+    pb_h,
+    out->u,
+    out_stride,
     mv_frac_x,
     mv_frac_y,
     mv_param);
@@ -297,10 +309,10 @@
   kvz_sample_octpel_chroma_hi(state->encoder_control,
     ext_origin,
     ext_s,
-    block_width / 2,
-    block_height / 2,
-    hi_prec_out->v + ((ypos / 2) % LCU_WIDTH_C) * LCU_WIDTH_C + ((xpos / 2) % LCU_WIDTH_C),
-    LCU_WIDTH_C,
+    pb_w,
+    pb_h,
+    out->v,
+    out_stride,
     mv_frac_x,
     mv_frac_y,
     mv_param);
@@ -349,130 +361,130 @@
  *
  * \param state          encoder state
  * \param ref            picture to copy the data from
- * \param xpos           PU x position
- * \param ypos           PU y position
+ * \param pu_x           PU x position
+ * \param pu_y           PU y position
  * \param width          PU width
  * \param height         PU height
  * \param mv_param       motion vector
- * \param lcu            destination lcu
- * \param hi_prec_out    destination of high precision output, or NULL if not needed
+ * \param yuv_px         destination buffer for pixel precision
+ * \param yuv_im         destination buffer for high-precision, or NULL if not needed
  * \param predict_luma   Enable or disable luma prediction for this call.
  * \param predict_chroma Enable or disable chroma prediction for this call.
 */
-static void inter_recon_unipred(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_param2,
-                                lcu_t *lcu,
-                                hi_prec_buf_t *hi_prec_out,
-                                bool predict_luma,
-                                bool predict_chroma)
+static unsigned inter_recon_unipred(const encoder_state_t * const state,
+                                    const kvz_picture * const ref,
+                                    int32_t pu_x,
+                                    int32_t pu_y,
+                                    int32_t pu_w,
+                                    int32_t pu_h,
+                                    int32_t out_stride_luma,
+                                    const int16_t mv_param2,
+                                    yuv_t *yuv_px,
+                                    yuv_im_t *yuv_im,
+                                    bool predict_luma,
+                                    bool predict_chroma)
 {
-  const vector2d_t pu_in_tile = { xpos, ypos };
-  const vector2d_t pu_in_lcu = { xpos % LCU_WIDTH, ypos % LCU_WIDTH };
-
-  const vector2d_t mv_in_pu = { mv_param0 >> 2, mv_param1 >> 2 };
-  const vector2d_t mv_in_frame = {
-    mv_in_pu.x + pu_in_tile.x + state->tile->offset_x,
-    mv_in_pu.y + pu_in_tile.y + state->tile->offset_y
+  const vector2d_t int_mv = { mv_param0 >> 2, mv_param1 >> 2 };
+  const vector2d_t int_mv_in_frame = {
+    int_mv.x + pu_x + state->tile->offset_x,
+    int_mv.y + pu_y + state->tile->offset_y
   };
 
-  const bool mv_is_outside_frame = mv_in_frame.x < 0 ||
-      mv_in_frame.y < 0 ||
-      mv_in_frame.x + width > ref->width ||
-      mv_in_frame.y + height > ref->height;
+  const bool int_mv_outside_frame = int_mv_in_frame.x < 0 ||
+    int_mv_in_frame.y < 0 ||
+    int_mv_in_frame.x + pu_w > ref->width ||
+    int_mv_in_frame.y + pu_h > ref->height;
 
   // With 420, odd coordinates need interpolation.
-  const int8_t fractional_chroma = (mv_in_pu.x & 1) || (mv_in_pu.y & 1);
-  const int8_t fractional_luma = ((mv_param0 & 3) || (mv_param1 & 3));
+  const bool fractional_chroma = (int_mv.x & 1) || (int_mv.y & 1);
+  const bool fractional_luma = (mv_param0 & 3) || (mv_param1 & 3);
 
   // Generate prediction for luma.
   if (predict_luma) {
     if (fractional_luma) {
       // With a fractional MV, do interpolation.
-      if (state->encoder_control->cfg.bipred && hi_prec_out) {
+      if (state->encoder_control->cfg.bipred && yuv_im) {
         inter_recon_frac_luma_hi(state, ref,
-          pu_in_tile.x, pu_in_tile.y,
-          width, height,
-          mv_param, hi_prec_out);
+          pu_x, pu_y,
+          pu_w, pu_h,
+          mv_param, yuv_im, out_stride_luma);
       }
       else {
         inter_recon_frac_luma(state, ref,
-          pu_in_tile.x, pu_in_tile.y,
-          width, height,
-          mv_param, lcu);
+          pu_x, pu_y,
+          pu_w, pu_h,
+          mv_param, yuv_px, out_stride_luma);
       }
     }
     else {
       // With an integer MV, copy pixels directly from the reference.
-      const int lcu_pu_index = pu_in_lcu.y * LCU_WIDTH + pu_in_lcu.x;
-      if (mv_is_outside_frame) {
+      if (int_mv_outside_frame) {
         inter_cp_with_ext_border(ref->y, ref->width,
           ref->width, ref->height,
-          &lcu->rec.ylcu_pu_index, LCU_WIDTH,
-          width, height,
-          &mv_in_frame);
+          yuv_px->y, out_stride_luma,
+          pu_w, pu_h,
+          &int_mv_in_frame);
       }
       else {
-        const int frame_mv_index = mv_in_frame.y * ref->width + mv_in_frame.x;
+        const int frame_mv_index = int_mv_in_frame.y * ref->width + int_mv_in_frame.x;
         kvz_pixels_blit(&ref->yframe_mv_index,
-          &lcu->rec.ylcu_pu_index,
-          width, height,
-          ref->width, LCU_WIDTH);
+          yuv_px->y,
+          pu_w, pu_h,
+          ref->width, out_stride_luma);
       }
     }
   }
 
   if (!predict_chroma) {
-    return;
+    return fractional_luma;
   }
 
+  const unsigned out_stride_c = out_stride_luma / 2;
+
   // Generate prediction for chroma.
   if (fractional_luma || fractional_chroma) {
     // With a fractional MV, do interpolation.
-    if (state->encoder_control->cfg.bipred && hi_prec_out) {
+    if (state->encoder_control->cfg.bipred && yuv_im) {
       inter_recon_frac_chroma_hi(state, ref,
-                                    pu_in_tile.x, pu_in_tile.y,
-                                    width, height,
-                                    mv_param, hi_prec_out);
+                                    pu_x, pu_y,
+                                    pu_w, pu_h, 
+                                    mv_param, yuv_im, out_stride_c);
     } else {
       inter_recon_frac_chroma(state, ref,
-                              pu_in_tile.x, pu_in_tile.y,
-                              width, height,
-                              mv_param, lcu);
+                              pu_x, pu_y,
+                              pu_w, pu_h,
+                              mv_param, yuv_px, out_stride_c);
     }
   } else {
     // With an integer MV, copy pixels directly from the reference.
-    const int lcu_pu_index_c = pu_in_lcu.y / 2 * LCU_WIDTH_C + pu_in_lcu.x / 2;
-    const vector2d_t mv_in_frame_c = { mv_in_frame.x / 2, mv_in_frame.y / 2 };
+    const vector2d_t int_mv_in_frame_c = { int_mv_in_frame.x / 2, int_mv_in_frame.y / 2 };
 
-    if (mv_is_outside_frame) {
+    if (int_mv_outside_frame) {
       inter_cp_with_ext_border(ref->u, ref->width / 2,
                                ref->width / 2, ref->height / 2,
-                               &lcu->rec.ulcu_pu_index_c, LCU_WIDTH_C,
-                               width / 2, height / 2,
-                               &mv_in_frame_c);
+                               yuv_px->u, out_stride_c,
+                               pu_w / 2, pu_h / 2,
+                               &int_mv_in_frame_c);
       inter_cp_with_ext_border(ref->v, ref->width / 2,
                                ref->width / 2, ref->height / 2,
-                               &lcu->rec.vlcu_pu_index_c, LCU_WIDTH_C,
-                               width / 2, height / 2,
-                               &mv_in_frame_c);
+                               yuv_px->v, out_stride_c,
+                               pu_w / 2, pu_h / 2,
+                               &int_mv_in_frame_c);
     } else {
-      const int frame_mv_index = mv_in_frame_c.y * ref->width / 2 + mv_in_frame_c.x;
+      const int frame_mv_index = int_mv_in_frame_c.y * ref->width / 2 + int_mv_in_frame_c.x;
 
       kvz_pixels_blit(&ref->uframe_mv_index,
-                      &lcu->rec.ulcu_pu_index_c,
-                      width / 2, height / 2,
-                      ref->width / 2, LCU_WIDTH_C);
+                      yuv_px->u,
+                      pu_w / 2, pu_h / 2,
+                      ref->width / 2, out_stride_c);
       kvz_pixels_blit(&ref->vframe_mv_index,
-                      &lcu->rec.vlcu_pu_index_c,
-                      width / 2, height / 2,
-                      ref->width / 2, LCU_WIDTH_C);
+                      yuv_px->v,
+                      pu_w / 2, pu_h / 2,
+                      ref->width / 2, out_stride_c);
     }
   }
+
+  return fractional_luma | ((fractional_luma || fractional_chroma) << 1);
 }
 /**
  * \brief Reconstruct bi-pred inter PU
@@ -480,8 +492,8 @@
  * \param state          encoder state
  * \param ref1           reference picture to copy the data from
  * \param ref2           other reference picture to copy the data from
- * \param xpos           PU x position
- * \param ypos           PU y position
+ * \param pu_x           PU x position
+ * \param pu_y           PU y position
  * \param width          PU width
  * \param height         PU height
  * \param mv_param       motion vectors
@@ -489,56 +501,60 @@
  * \param predict_luma   Enable or disable luma prediction for this call.
  * \param predict_chroma Enable or disable chroma prediction for this call.
  */
-void kvz_inter_recon_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_param22,
-                            lcu_t* lcu,
-                            bool predict_luma,
-                            bool predict_chroma)
+void kvz_inter_recon_bipred(const encoder_state_t *const state,
+  const kvz_picture *ref1,
+  const kvz_picture *ref2,
+  int32_t pu_x,
+  int32_t pu_y,
+  int32_t pu_w,
+  int32_t pu_h,
+  int16_t mv_param22,
+  lcu_t *lcu,
+  bool predict_luma,
+  bool predict_chroma)
 {
-  kvz_pixel temp_lcu_yLCU_WIDTH*LCU_WIDTH;
-  kvz_pixel temp_lcu_uLCU_WIDTH_C*LCU_WIDTH_C;
-  kvz_pixel temp_lcu_vLCU_WIDTH_C*LCU_WIDTH_C;
-
-  const int hi_prec_luma_rec0 = mv_param00 & 3 || mv_param01 & 3;
-  const int hi_prec_luma_rec1 = mv_param10 & 3 || mv_param11 & 3;
-
-  const int hi_prec_chroma_rec0 = mv_param00 & 7 || mv_param01 & 7;
-  const int hi_prec_chroma_rec1 = mv_param10 & 7 || mv_param11 & 7;
-
-  hi_prec_buf_t* high_precision_rec0 = 0;
-  hi_prec_buf_t* high_precision_rec1 = 0;
-  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
-  inter_recon_unipred(state, ref1, xpos, ypos, width, height, mv_param0, lcu, high_precision_rec0,
-                      predict_luma, predict_chroma);
-  if (!hi_prec_luma_rec0){
-    memcpy(temp_lcu_y, lcu->rec.y, sizeof(kvz_pixel) * 64 * 64); // copy to temp_lcu_y
-  }
-  if (!hi_prec_chroma_rec0){
-    memcpy(temp_lcu_u, lcu->rec.u, sizeof(kvz_pixel) * 32 * 32); // copy to temp_lcu_u
-    memcpy(temp_lcu_v, lcu->rec.v, sizeof(kvz_pixel) * 32 * 32); // copy to temp_lcu_v
-  }
-  inter_recon_unipred(state, ref2, xpos, ypos, width, height, mv_param1, lcu, high_precision_rec1,
-                      predict_luma, predict_chroma);
+  // Allocate maximum size arrays for interpolated and copied samples
+  ALIGNED(64) kvz_pixel px_buf_L0LCU_LUMA_SIZE + 2 * LCU_CHROMA_SIZE;
+  ALIGNED(64) kvz_pixel px_buf_L1LCU_LUMA_SIZE + 2 * LCU_CHROMA_SIZE;
+  ALIGNED(64) kvz_pixel_im im_buf_L0LCU_LUMA_SIZE + 2 * LCU_CHROMA_SIZE;
+  ALIGNED(64) kvz_pixel_im im_buf_L1LCU_LUMA_SIZE + 2 * LCU_CHROMA_SIZE;
+
+  yuv_t px_L0;
+  px_L0.size = pu_w * pu_h;
+  px_L0.y = &px_buf_L00;
+  px_L0.u = &px_buf_L0LCU_LUMA_SIZE;
+  px_L0.v = &px_buf_L0LCU_LUMA_SIZE + LCU_CHROMA_SIZE;
+
+  yuv_t px_L1;
+  px_L1.size = pu_w * pu_h;
+  px_L1.y = &px_buf_L10;
+  px_L1.u = &px_buf_L1LCU_LUMA_SIZE;
+  px_L1.v = &px_buf_L1LCU_LUMA_SIZE + LCU_CHROMA_SIZE;
+
+  yuv_im_t im_L0;
+  im_L0.size = pu_w * pu_h;
+  im_L0.y = &im_buf_L00;
+  im_L0.u = &im_buf_L0LCU_LUMA_SIZE;
+  im_L0.v = &im_buf_L0LCU_LUMA_SIZE + LCU_CHROMA_SIZE;
+
+  yuv_im_t im_L1;
+  im_L1.size = pu_w * pu_h;
+  im_L1.y = &im_buf_L10;
+  im_L1.u = &im_buf_L1LCU_LUMA_SIZE;
+  im_L1.v = &im_buf_L1LCU_LUMA_SIZE + LCU_CHROMA_SIZE;
+
+  // Sample blocks from both reference picture lists.
+  // Flags state if the outputs were written to high-precision / interpolated sample buffers.
+  unsigned im_flags_L0 = inter_recon_unipred(state, ref1, pu_x, pu_y, pu_w, pu_h, pu_w, mv_param0,
+                                             &px_L0, &im_L0, predict_luma, predict_chroma);
+  unsigned im_flags_L1 = inter_recon_unipred(state, ref2, pu_x, pu_y, pu_w, pu_h, pu_w, mv_param1,
+                                             &px_L1, &im_L1, predict_luma, predict_chroma);
 
   // After reconstruction, merge the predictors by taking an average of each pixel
-  kvz_inter_recon_bipred_blend(hi_prec_luma_rec0, hi_prec_luma_rec1, 
-                               hi_prec_chroma_rec0, hi_prec_chroma_rec1,
-                               height, width, ypos, xpos,
-                               high_precision_rec0, high_precision_rec1,
-                               lcu, temp_lcu_y, temp_lcu_u, temp_lcu_v, predict_luma, predict_chroma);
- 
-  if (high_precision_rec0 != 0) kvz_hi_prec_buf_t_free(high_precision_rec0);
-  if (high_precision_rec1 != 0) kvz_hi_prec_buf_t_free(high_precision_rec1);
+  kvz_bipred_average(lcu, &px_L0, &px_L1, &im_L0, &im_L1,
+                     pu_x, pu_y, pu_w, pu_h,
+                     im_flags_L0, im_flags_L1,
+                     predict_luma, predict_chroma);
 }
 
 
@@ -626,12 +642,21 @@
         state->frame->ref_LXmv_idx
           pu->inter.mv_refmv_idx;
 
+    const unsigned offset_luma = SUB_SCU(pu_y) * LCU_WIDTH + SUB_SCU(pu_x);
+    const unsigned offset_chroma = SUB_SCU(pu_y) / 2 * LCU_WIDTH_C + SUB_SCU(pu_x) / 2;
+    yuv_t lcu_adapter;
+    lcu_adapter.size = pu_w * pu_h;
+    lcu_adapter.y = lcu->rec.y + offset_luma,
+    lcu_adapter.u = lcu->rec.u + offset_chroma,
+    lcu_adapter.v = lcu->rec.v + offset_chroma,
+
     inter_recon_unipred(state,
       ref,
       pu_x, pu_y,
       pu_w, pu_h,
+      LCU_WIDTH,
       pu->inter.mvmv_idx,
-      lcu,
+      &lcu_adapter,
       NULL,
       predict_luma, predict_chroma);
   }
@@ -1203,7 +1228,7 @@
                                         int32_t width,
                                         int32_t height,
                                         const merge_candidates_t *merge_cand,
-                                        const cu_info_t *cur_cu,
+                                        const cu_info_t * const cur_cu,
                                         int8_t reflist,
                                         int16_t mv_cand22)
 {
@@ -1310,7 +1335,7 @@
                            int32_t width,
                            int32_t height,
                            int16_t mv_cand22,
-                           cu_info_t* cur_cu,
+                           const cu_info_t  * const cur_cu,
                            lcu_t *lcu,
                            int8_t reflist)
 {

kvazaar-2.1.0.tar.gz/src/inter.h -> kvazaar-2.2.0.tar.gz/src/inter.h Changed

kvazaar-2.1.0.tar.gz/src/kvazaar.h -> kvazaar-2.2.0.tar.gz/src/kvazaar.h Changed

@@ -97,6 +97,8 @@
 typedef uint16_t kvz_pixel;
 #endif
 
+typedef int16_t kvz_pixel_im;  // For intermediate precision (interpolation/bipred).
+
 /**
  * \brief Opaque data structure representing one instance of the encoder.
  */
@@ -248,6 +250,11 @@
   KVZ_FORMAT_YUV = 2
 };
 
+enum kvz_roi_format
+{
+  KVZ_ROI_TXT = 0,
+  KVZ_ROI_BIN = 1
+};
 
 // Map from input format to chroma format.
 #define KVZ_FORMAT2CSP(format) ((enum kvz_chroma_format)"\0\1\2\3"format)
@@ -386,10 +393,9 @@
   int32_t implicit_rdpcm; /*!< \brief Enable implicit residual DPCM. */
 
   struct {
-    int32_t width;
-    int32_t height;
-    int8_t *dqps;
-  } roi; /*!< \since 3.14.0 \brief Map of delta QPs for region of interest coding. */
+    char *file_path;
+    enum kvz_roi_format format;
+  } roi; /*!< \brief Specify delta QPs for region of interest coding. */
 
   unsigned slices; /*!< \since 3.15.0 \brief How to map slices to frame. */
 
@@ -477,6 +483,15 @@
 
   char *fastrd_learning_outdir_fn;
 
+  /** \brief whether to try combining intra cus at the lower depth when search
+   *         is not performed at said depth*/
+  uint8_t combine_intra_cus;
+
+  uint8_t force_inter;
+
+  uint8_t intra_chroma_search;
+
+  uint8_t fast_bipred;
 } kvz_config;
 
 /**
@@ -508,6 +523,14 @@
   enum kvz_chroma_format chroma_format;
 
   int32_t ref_pocs16;
+
+  struct
+  {
+    int width;
+    int height;
+    int8_t *roi_array;
+  } roi;
+
 } kvz_picture;
 
 /**
@@ -752,6 +775,9 @@
    * the bitstream, length of the bitstream, the reconstructed frame, the
    * original frame and frame info in data_out, len_out, pic_out, src_out and
    * info_out, respectively. Otherwise, set the output parameters to NULL.
+   * 
+   * Region of interest (ROI) / delta QP map can be specified in the input
+   * picture's ROI field but only when a ROI file is not used.
    *
    * After passing all of the input frames, the caller should keep calling this
    * function with pic_in set to NULL, until no more data is returned in the

kvazaar-2.1.0.tar.gz/src/rate_control.c -> kvazaar-2.2.0.tar.gz/src/rate_control.c Changed

@@ -1085,21 +1085,23 @@
   const encoder_control_t * const ctrl = state->encoder_control;
   lcu_stats_t *lcu = kvz_get_lcu_stats(state, pos.x, pos.y);
 
-  if (ctrl->cfg.roi.dqps != NULL) {
-    vector2d_t lcu = {
+  if (state->tile->frame->source->roi.roi_array) {
+    vector2d_t lcu_vec = {
       pos.x + state->tile->lcu_offset_x,
       pos.y + state->tile->lcu_offset_y
     };
     vector2d_t roi = {
-      lcu.x * ctrl->cfg.roi.width / ctrl->in.width_in_lcu,
-      lcu.y * ctrl->cfg.roi.height / ctrl->in.height_in_lcu
+      lcu_vec.x * state->tile->frame->source->roi.width / ctrl->in.width_in_lcu,
+      lcu_vec.y * state->tile->frame->source->roi.height / ctrl->in.height_in_lcu
     };
-    int roi_index = roi.x + roi.y * ctrl->cfg.roi.width;
-    int dqp = ctrl->cfg.roi.dqpsroi_index;
+    int roi_index = roi.x + roi.y * state->tile->frame->source->roi.width;
+    int dqp = state->tile->frame->source->roi.roi_arrayroi_index;
+    if(dqp != 0) {
+      pos.x = 0;
+    }
     state->qp = CLIP_TO_QP(state->frame->QP + dqp);
     state->lambda = qp_to_lambda(state, state->qp);
     state->lambda_sqrt = sqrt(state->lambda);
-
   }
   else if (ctrl->cfg.target_bitrate > 0) {
     const uint32_t pixels    = MIN(LCU_WIDTH, state->tile->frame->width  - LCU_WIDTH * pos.x) *

kvazaar-2.1.0.tar.gz/src/rdo.c -> kvazaar-2.2.0.tar.gz/src/rdo.c Changed

@@ -165,17 +165,17 @@
 {
 #define RD_SAMPLING_MAX_FN_LENGTH 4095
   static const char *basename_tmpl = "/%02i.txt";
-  char fn_templateRD_SAMPLING_MAX_FN_LENGTH + 1;
+  char fn_templateRD_SAMPLING_MAX_FN_LENGTH + 1 = {0};
   char fnRD_SAMPLING_MAX_FN_LENGTH + 1;
   int rv = 0, qp;
 
   // As long as QP is a two-digit number, template and produced string should
   // be equal in length ("%i" -> "22")
   assert(RD_SAMPLING_MAX_LAST_QP <= 99);
-  assert(strlen(fn_template) <= RD_SAMPLING_MAX_FN_LENGTH);
 
   strncpy(fn_template, dir_path, RD_SAMPLING_MAX_FN_LENGTH);
   strncat(fn_template, basename_tmpl, RD_SAMPLING_MAX_FN_LENGTH - strlen(dir_path));
+  assert(strlen(fn_template) <= RD_SAMPLING_MAX_FN_LENGTH);
 
   for (qp = 0; qp <= RD_SAMPLING_MAX_LAST_QP; qp++) {
     pthread_mutex_t *curr = outfile_mutex + qp;
@@ -233,7 +233,7 @@
  *
  * \returns bits needed to code input coefficients
  */
-static INLINE uint32_t get_coeff_cabac_cost(
+static INLINE double get_coeff_cabac_cost(
     const encoder_state_t * const state,
     const coeff_t *coeff,
     int32_t width,
@@ -253,12 +253,11 @@
   // Take a copy of the CABAC so that we don't overwrite the contexts when
   // counting the bits.
   cabac_data_t cabac_copy;
-  memcpy(&cabac_copy, &state->cabac, sizeof(cabac_copy));
+  memcpy(&cabac_copy, &state->search_cabac, sizeof(cabac_copy));
 
   // Clear bytes and bits and set mode to "count"
   cabac_copy.only_count = 1;
-  cabac_copy.num_buffered_bytes = 0;
-  cabac_copy.bits_left = 23;
+  double bits = 0;
 
   // Execute the coding function.
   // It is safe to drop the const modifier since state won't be modified
@@ -269,12 +268,15 @@
                        width,
                        type,
                        scan_mode,
-                       0);
-
-  return (23 - cabac_copy.bits_left) + (cabac_copy.num_buffered_bytes << 3);
+                       0,
+                       &bits);
+  if(cabac_copy.update) {
+    memcpy((cabac_data_t *)&state->search_cabac, &cabac_copy, sizeof(cabac_copy));
+  }
+  return bits;
 }
 
-static INLINE void save_ccc(int qp, const coeff_t *coeff, int32_t size, uint32_t ccc)
+static INLINE void save_ccc(int qp, const coeff_t *coeff, int32_t size, double ccc)
 {
   pthread_mutex_t *mtx = outfile_mutex + qp;
 
@@ -290,14 +292,14 @@
   pthread_mutex_unlock(mtx);
 }
 
-static INLINE void save_accuracy(int qp, uint32_t ccc, uint32_t fast_cost)
+static INLINE void save_accuracy(int qp, double ccc, double fast_cost)
 {
   pthread_mutex_t *mtx = outfile_mutex + qp;
 
   assert(qp <= RD_SAMPLING_MAX_LAST_QP);
 
   pthread_mutex_lock(mtx);
-  fprintf(fastrd_learning_outfileqp, "%u %u\n", fast_cost, ccc);
+  fprintf(fastrd_learning_outfileqp, "%f %f\n", fast_cost, ccc);
   pthread_mutex_unlock(mtx);
 }
 
@@ -310,7 +312,7 @@
  *
  * \returns       number of bits needed to code coefficients
  */
-uint32_t kvz_get_coeff_cost(const encoder_state_t * const state,
+double kvz_get_coeff_cost(const encoder_state_t * const state,
                             const coeff_t *coeff,
                             int32_t width,
                             int32_t type,
@@ -329,15 +331,15 @@
       return UINT32_MAX; // Hush little compiler don't you cry, not really gonna return anything after assert(0)
     } else {
       uint64_t weights = kvz_fast_coeff_get_weights(state);
-      uint32_t fast_cost = kvz_fast_coeff_cost(coeff, width, weights);
+      double fast_cost = kvz_fast_coeff_cost(coeff, width, weights);
       if (check_accuracy) {
-        uint32_t ccc = get_coeff_cabac_cost(state, coeff, width, type, scan_mode);
+        double ccc = get_coeff_cabac_cost(state, coeff, width, type, scan_mode);
         save_accuracy(state->qp, ccc, fast_cost);
       }
       return fast_cost;
     }
   } else {
-    uint32_t ccc = get_coeff_cabac_cost(state, coeff, width, type, scan_mode);
+    double ccc = get_coeff_cabac_cost(state, coeff, width, type, scan_mode);
     if (save_cccs) {
       save_ccc(state->qp, coeff, width * width, ccc);
     }
@@ -1007,37 +1009,33 @@
 /**
  * Calculate cost of actual motion vectors using CABAC coding
  */
-uint32_t kvz_get_mvd_coding_cost_cabac(const encoder_state_t *state,
-                                       const cabac_data_t* cabac,
-                                       const int32_t mvd_hor,
-                                       const int32_t mvd_ver)
+double kvz_get_mvd_coding_cost_cabac(const encoder_state_t* state,
+                                     const cabac_data_t* cabac,
+                                     const int32_t mvd_hor,
+                                     const int32_t mvd_ver)
 {
   cabac_data_t cabac_copy = *cabac;
   cabac_copy.only_count = 1;
-
+  double bits = 0;
   // It is safe to drop const here because cabac->only_count is set.
-  kvz_encode_mvd((encoder_state_t*) state, &cabac_copy, mvd_hor, mvd_ver);
-
-  uint32_t bitcost =
-    ((23 - cabac_copy.bits_left) + (cabac_copy.num_buffered_bytes << 3)) -
-    ((23 - cabac->bits_left)     + (cabac->num_buffered_bytes << 3));
+  kvz_encode_mvd((encoder_state_t*) state, &cabac_copy, mvd_hor, mvd_ver, &bits);
 
-  return bitcost;
+  return bits;
 }
 
 /** MVD cost calculation with CABAC
 * \returns int
 * Calculates Motion Vector cost and related costs using CABAC coding
 */
-uint32_t kvz_calc_mvd_cost_cabac(const encoder_state_t * state,
-                                 int x,
-                                 int y,
-                                 int mv_shift,
-                                 int16_t mv_cand22,
-                                 inter_merge_cand_t merge_candMRG_MAX_NUM_CANDS,
-                                 int16_t num_cand,
-                                 int32_t ref_idx,
-                                 uint32_t *bitcost)
+double kvz_calc_mvd_cost_cabac(const encoder_state_t * state,
+                               int x,
+                               int y,
+                               int mv_shift,
+                               int16_t mv_cand22,
+                               inter_merge_cand_t merge_candMRG_MAX_NUM_CANDS,
+                               int16_t num_cand,
+                               int32_t ref_idx,
+                               double* bitcost)
 {
   cabac_data_t state_cabac_copy;
   cabac_data_t* cabac;
@@ -1064,14 +1062,13 @@
   }
 
   // Store cabac state and contexts
-  memcpy(&state_cabac_copy, &state->cabac, sizeof(cabac_data_t));
+  memcpy(&state_cabac_copy, &state->search_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;
+  double bits = 0;
 
   if (!merged) {
     vector2d_t mvd1 = {
@@ -1082,8 +1079,8 @@
       x - mv_cand10,
       y - mv_cand11,
     };
-    uint32_t cand1_cost = kvz_get_mvd_coding_cost_cabac(state, cabac, mvd1.x, mvd1.y);
-    uint32_t cand2_cost = kvz_get_mvd_coding_cost_cabac(state, cabac, mvd2.x, mvd2.y);
+    double cand1_cost = kvz_get_mvd_coding_cost_cabac(state, cabac, mvd1.x, mvd1.y);
+    double cand2_cost = kvz_get_mvd_coding_cost_cabac(state, cabac, mvd2.x, mvd2.y);
 
     // Select candidate 1 if it has lower cost
     if (cand2_cost < cand1_cost) {
@@ -1096,7 +1093,7 @@
 
   cabac->cur_ctx = &(cabac->ctx.cu_merge_flag_ext_model);
 
-  CABAC_BIN(cabac, merged, "MergeFlag");
+  CABAC_FBITS_UPDATE(cabac, &(cabac->ctx.cu_merge_flag_ext_model), merged, bits, "MergeFlag");
   num_cand = state->encoder_control->cfg.max_merge;
   if (merged) {
     if (num_cand > 1) {
@@ -1104,10 +1101,10 @@
       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");
+          CABAC_FBITS_UPDATE(cabac, &(cabac->ctx.cu_merge_idx_ext_model), symbol, bits, "MergeIndex");
         } else {
           CABAC_BIN_EP(cabac, symbol, "MergeIndex");
+          bits += 1;
         }
         if (symbol == 0) break;
       }
@@ -1130,24 +1127,23 @@
         if (ref_listref_list_idx > 1) {
           // parseRefFrmIdx
           int32_t ref_frame = ref_idx;
-
-          cabac->cur_ctx = &(cabac->ctx.cu_ref_pic_model0);
-          CABAC_BIN(cabac, (ref_frame != 0), "ref_idx_lX");
+          
+          CABAC_FBITS_UPDATE(cabac, &(cabac->ctx.cu_ref_pic_model0), (ref_frame != 0), bits, "ref_idx_lX");
 
           if (ref_frame > 0) {
             int32_t i;
             int32_t ref_num = ref_listref_list_idx - 2;
-
-            cabac->cur_ctx = &(cabac->ctx.cu_ref_pic_model1);
+            
             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");
+                CABAC_FBITS_UPDATE(cabac, &(cabac->ctx.cu_ref_pic_model1), symbol, bits, "ref_idx_lX");
               } else {
                 CABAC_BIN_EP(cabac, symbol, "ref_idx_lX");
+                bits += 1;
               }
               if (symbol == 0) break;
             }
@@ -1157,24 +1153,25 @@
         // ToDo: Bidir vector support
         if (!(state->frame->ref_list == REF_PIC_LIST_1 && /*cur_cu->inter.mv_dir == 3*/ 0)) {
           // It is safe to drop const here because cabac->only_count is set.
-          kvz_encode_mvd((encoder_state_t*) state, cabac, mvd.x, mvd.y);
+          kvz_encode_mvd((encoder_state_t*) state, cabac, mvd.x, mvd.y, &bits);
         }
 
         // 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);
+          cabac,
+          cabac->ctx.mvp_idx_model,
+          cur_mv_cand,
+          1,
+          AMVP_MAX_NUM_CANDS - 1,
+          &bits);
       }
     }
   }
 
-  *bitcost = (23 - state_cabac_copy.bits_left) + (state_cabac_copy.num_buffered_bytes << 3);
+  *bitcost = bits;
 
   // Store bitcost before restoring cabac
-  return *bitcost * (uint32_t)(state->lambda_sqrt + 0.5);
+  return *bitcost * state->lambda_sqrt;
 }
 
 void kvz_close_rdcost_outfiles(void)

kvazaar-2.1.0.tar.gz/src/rdo.h -> kvazaar-2.2.0.tar.gz/src/rdo.h Changed

@@ -54,7 +54,7 @@
 void  kvz_rdoq(encoder_state_t *state, coeff_t *coef, coeff_t *dest_coeff, int32_t width,
            int32_t height, int8_t type, int8_t scan_mode, int8_t block_type, int8_t tr_depth);
 
-uint32_t kvz_get_coeff_cost(const encoder_state_t * const state,
+double kvz_get_coeff_cost(const encoder_state_t * const state,
                             const coeff_t *coeff,
                             int32_t width,
                             int32_t type,
@@ -71,10 +71,10 @@
 
 kvz_mvd_cost_func kvz_calc_mvd_cost_cabac;
 
-uint32_t kvz_get_mvd_coding_cost_cabac(const encoder_state_t *state,
-                                       const cabac_data_t* cabac,
-                                       int32_t mvd_hor,
-                                       int32_t mvd_ver);
+double kvz_get_mvd_coding_cost_cabac(const encoder_state_t* state,
+                                     const cabac_data_t* cabac,
+                                     int32_t mvd_hor,
+                                     int32_t mvd_ver);
 
 // Number of fixed point fractional bits used in the fractional bit table.
 #define CTX_FRAC_BITS 15
@@ -85,7 +85,5 @@
 #define CTX_ENTROPY_BITS(ctx, val) kvz_entropy_bits(ctx)->uc_state ^ (val)
 
 // Floating point fractional bits, derived from kvz_entropy_bits
-extern const float kvz_f_entropy_bits128;
-#define CTX_ENTROPY_FBITS(ctx, val) kvz_f_entropy_bits(ctx)->uc_state ^ (val)
 
 #endif

kvazaar-2.1.0.tar.gz/src/sao.c -> kvazaar-2.2.0.tar.gz/src/sao.c Changed

@@ -49,63 +49,64 @@
 }
 
 
-static float sao_mode_bits_none(const encoder_state_t * const state, sao_info_t *sao_top, sao_info_t *sao_left)
+static double sao_mode_bits_none(const encoder_state_t * const state, sao_info_t *sao_top, sao_info_t *sao_left)
 {
-  float mode_bits = 0.0;
-  const cabac_data_t * const cabac = &state->cabac;
-  const cabac_ctx_t *ctx = NULL;
+  double mode_bits = 0.0;
+  cabac_data_t * cabac = (cabac_data_t*)&state->search_cabac;
+  cabac_ctx_t *ctx = NULL;
   // FL coded merges.
   if (sao_left != NULL) {
     ctx = &(cabac->ctx.sao_merge_flag_model);
-    mode_bits += CTX_ENTROPY_FBITS(ctx, 0);
+    CABAC_FBITS_UPDATE(cabac, ctx, 0, mode_bits, "sao_merge_flag");
   }
   if (sao_top != NULL) {    
     ctx = &(cabac->ctx.sao_merge_flag_model);
-    mode_bits += CTX_ENTROPY_FBITS(ctx, 0);
+    CABAC_FBITS_UPDATE(cabac, ctx, 0, mode_bits, "sao_merge_flag");
   }
 
   // TR coded type_idx_, none = 0
   ctx = &(cabac->ctx.sao_type_idx_model);
-  mode_bits += CTX_ENTROPY_FBITS(ctx, 0);
+  CABAC_FBITS_UPDATE(cabac, ctx, 0, mode_bits, "sao_type");
 
   return mode_bits;
 }
 
-static float sao_mode_bits_merge(const encoder_state_t * const state,
+static double sao_mode_bits_merge(const encoder_state_t * const state,
                                  int8_t merge_cand) {
-  float mode_bits = 0.0;
-  const cabac_data_t * const cabac = &state->cabac;
-  const cabac_ctx_t *ctx = NULL;
+  double mode_bits = 0.0;
+  cabac_data_t * cabac = (cabac_data_t*)&state->search_cabac;
+  cabac_ctx_t *ctx = NULL;
   // FL coded merges.
   ctx = &(cabac->ctx.sao_merge_flag_model);
 
-  mode_bits += CTX_ENTROPY_FBITS(ctx, merge_cand == 1);
+  CABAC_FBITS_UPDATE(cabac, ctx, merge_cand == 1, mode_bits, "sao_merge_flag");
   if (merge_cand == 1) return mode_bits;
-  mode_bits += CTX_ENTROPY_FBITS(ctx, merge_cand == 2);
+  CABAC_FBITS_UPDATE(cabac, ctx, merge_cand == 2, mode_bits, "sao_merge_flag");
   return mode_bits;
 }
 
 
-static float sao_mode_bits_edge(const encoder_state_t * const state,
+static double sao_mode_bits_edge(const encoder_state_t * const state,
                               int edge_class, int offsetsNUM_SAO_EDGE_CATEGORIES,
                               sao_info_t *sao_top, sao_info_t *sao_left, unsigned buf_cnt)
 {
-  float mode_bits = 0.0;
-  const cabac_data_t * const cabac = &state->cabac;
-  const cabac_ctx_t *ctx = NULL;
+  double mode_bits = 0.0;
+  cabac_data_t * cabac = (cabac_data_t*)&state->search_cabac;
+  cabac_ctx_t *ctx = NULL;
   // FL coded merges.
   if (sao_left != NULL) {
-    ctx = &(cabac->ctx.sao_merge_flag_model);   
-    mode_bits += CTX_ENTROPY_FBITS(ctx, 0);
+    ctx = &(cabac->ctx.sao_merge_flag_model);
+    CABAC_FBITS_UPDATE(cabac, ctx, 0, mode_bits, "sao_merge_flag");
   }
   if (sao_top != NULL) {
     ctx = &(cabac->ctx.sao_merge_flag_model);
-    mode_bits += CTX_ENTROPY_FBITS(ctx, 0);
+    CABAC_FBITS_UPDATE(cabac, ctx, 0, mode_bits, "sao_merge_flag");
   }
 
   // TR coded type_idx_, edge = 2 = cMax
   ctx = &(cabac->ctx.sao_type_idx_model);
-  mode_bits += CTX_ENTROPY_FBITS(ctx, 1) + 1.0;
+  CABAC_FBITS_UPDATE(cabac, ctx, 1, mode_bits, "sao_type");
+  mode_bits += 1.0;
 
   // TR coded offsets.
   for (unsigned buf_index = 0; buf_index < buf_cnt; buf_index++) {
@@ -126,26 +127,27 @@
 }
 
 
-static float sao_mode_bits_band(const encoder_state_t * const state,
+static double sao_mode_bits_band(const encoder_state_t * const state,
                               int band_position2, int offsets10,
                               sao_info_t *sao_top, sao_info_t *sao_left, unsigned buf_cnt)
 {
-  float mode_bits = 0.0;
-  const cabac_data_t * const cabac = &state->cabac;
-  const cabac_ctx_t *ctx = NULL;
+  double mode_bits = 0.0;
+  cabac_data_t * cabac = (cabac_data_t*)&state->search_cabac;
+  cabac_ctx_t *ctx = NULL;
   // FL coded merges.
   if (sao_left != NULL) {
     ctx = &(cabac->ctx.sao_merge_flag_model);
-    mode_bits += CTX_ENTROPY_FBITS(ctx, 0);
+    CABAC_FBITS_UPDATE(cabac, ctx, 0, mode_bits, "sao_merge_flag");
   }
   if (sao_top != NULL) {
     ctx = &(cabac->ctx.sao_merge_flag_model);
-    mode_bits += CTX_ENTROPY_FBITS(ctx, 0);
+    CABAC_FBITS_UPDATE(cabac, ctx, 0, mode_bits, "sao_merge_flag");
   }
 
   // TR coded sao_type_idx_, band = 1
   ctx = &(cabac->ctx.sao_type_idx_model);
-  mode_bits += CTX_ENTROPY_FBITS(ctx, 1) + 1.0;
+  CABAC_FBITS_UPDATE(cabac, ctx, 1, mode_bits, "sao_type");
+  mode_bits += 1.0;
 
   // TR coded offsets and possible FL coded offset signs.
   for (unsigned buf_index = 0; buf_index < buf_cnt; buf_index++)
@@ -552,7 +554,8 @@
   // Choose between SAO and doing nothing, taking into account the
   // rate-distortion cost of coding do nothing.
   {
-    int cost_of_nothing = (int)(sao_mode_bits_none(state, sao_top, sao_left) * state->lambda + 0.5);
+    float mode_bits_none = sao_mode_bits_none(state, sao_top, sao_left);
+    int cost_of_nothing = (int)(mode_bits_none * state->lambda + 0.5);
     if (sao_out->ddistortion >= cost_of_nothing) {
       sao_out->type = SAO_TYPE_NONE;
       merge_cost0 = cost_of_nothing;

kvazaar-2.1.0.tar.gz/src/search.c -> kvazaar-2.2.0.tar.gz/src/search.c Changed

@@ -37,6 +37,7 @@
 
 #include "cabac.h"
 #include "encoder.h"
+#include "encode_coding_tree.h"
 #include "imagelist.h"
 #include "inter.h"
 #include "intra.h"
@@ -59,14 +60,6 @@
 // Cost threshold for doing intra search in inter frames with --rd=0.
 static const int INTRA_THRESHOLD = 8;
 
-// Modify weight of luma SSD.
-#ifndef LUMA_MULT
-# define LUMA_MULT 0.8
-#endif
-// Modify weight of chroma SSD.
-#ifndef CHROMA_MULT
-# define CHROMA_MULT 1.5
-#endif
 
 static INLINE void copy_cu_info(int x_local, int y_local, int width, lcu_t *from, lcu_t *to)
 {
@@ -215,16 +208,16 @@
   const int chroma_index = (y_local / 2) * LCU_WIDTH_C + (x_local / 2);
 
   double ssd = 0.0;
-  ssd += LUMA_MULT * kvz_pixels_calc_ssd(
+  ssd += KVZ_LUMA_MULT * kvz_pixels_calc_ssd(
     &lcu->ref.yluma_index, &lcu->rec.yluma_index,
     LCU_WIDTH, LCU_WIDTH, cu_width
     );
   if (x % 8 == 0 && y % 8 == 0 && state->encoder_control->chroma_format != KVZ_CSP_400) {
-    ssd += CHROMA_MULT * kvz_pixels_calc_ssd(
+    ssd += KVZ_CHROMA_MULT * kvz_pixels_calc_ssd(
       &lcu->ref.uchroma_index, &lcu->rec.uchroma_index,
       LCU_WIDTH_C, LCU_WIDTH_C, cu_width / 2
       );
-    ssd += CHROMA_MULT * kvz_pixels_calc_ssd(
+    ssd += KVZ_CHROMA_MULT * kvz_pixels_calc_ssd(
       &lcu->ref.vchroma_index, &lcu->rec.vchroma_index,
       LCU_WIDTH_C, LCU_WIDTH_C, cu_width / 2
       );
@@ -246,11 +239,12 @@
 * prediction unit data needs to be coded.
 */
 double kvz_cu_rd_cost_luma(const encoder_state_t *const state,
-                       const int x_px, const int y_px, const int depth,
-                       const cu_info_t *const pred_cu,
-                       lcu_t *const lcu)
+                           const int x_px, const int y_px, const int depth,
+                           const cu_info_t *const pred_cu,
+                           lcu_t *const lcu)
 {
   const int width = LCU_WIDTH >> depth;
+  const int skip_residual_coding = pred_cu->skipped || (pred_cu->type == CU_INTER && pred_cu->cbf == 0);
 
   // cur_cu is used for TU parameters.
   cu_info_t *const tr_cu = LCU_GET_CU_AT_PX(lcu, x_px, y_px);
@@ -264,14 +258,25 @@
 
   const uint8_t tr_depth = tr_cu->tr_depth - depth;
 
+  cabac_data_t* cabac = (cabac_data_t *)&state->search_cabac;
+
   // Add transform_tree split_transform_flag bit cost.
   bool intra_split_flag = pred_cu->type == CU_INTRA && pred_cu->part_size == SIZE_NxN && depth == 3;
+  int max_tr_depth;
+  if (pred_cu->type == CU_INTRA) {
+    max_tr_depth = state->encoder_control->cfg.tr_depth_intra + intra_split_flag;
+  }
+  else {
+    max_tr_depth = state->encoder_control->tr_depth_inter;
+  }
   if (width <= TR_MAX_WIDTH
       && width > TR_MIN_WIDTH
-      && !intra_split_flag)
+      && !intra_split_flag
+      && MIN(tr_cu->tr_depth, depth) - tr_cu->depth < max_tr_depth
+      && !skip_residual_coding)
   {
-    const cabac_ctx_t *ctx = &(state->cabac.ctx.trans_subdiv_model5 - (6 - depth));
-    tr_tree_bits += CTX_ENTROPY_FBITS(ctx, tr_depth > 0);
+    cabac_ctx_t *ctx = &(cabac->ctx.trans_subdiv_model5 - (6 - depth));
+    CABAC_FBITS_UPDATE(cabac, ctx, tr_depth > 0, tr_tree_bits, "tr_split_search");
   }
 
   if (tr_depth > 0) {
@@ -286,14 +291,35 @@
     return sum + tr_tree_bits * state->lambda;
   }
 
+
+  if (cabac->update && tr_cu->tr_depth == tr_cu->depth && !skip_residual_coding) {
+    // Because these need to be coded before the luma cbf they also need to be counted
+    // before the cabac state changes. However, since this branch is only executed when
+    // calculating the last RD cost it is not problem to include the chroma cbf costs in
+    // luma, because the chroma cost is calculated right after the luma cost.
+    // However, if we have different tr_depth, the bits cannot be written in correct
+    // order anyways so do not touch the chroma cbf here.
+    if (state->encoder_control->chroma_format != KVZ_CSP_400) {
+      cabac_ctx_t* cr_ctx = &(cabac->ctx.qt_cbf_model_chromadepth - tr_cu->depth);
+      cabac->cur_ctx = cr_ctx;
+      int u_is_set = cbf_is_set(pred_cu->cbf, depth, COLOR_U);
+      int v_is_set = cbf_is_set(pred_cu->cbf, depth, COLOR_V);
+      CABAC_FBITS_UPDATE(cabac, cr_ctx, u_is_set, tr_tree_bits, "cbf_cb_search");
+      CABAC_FBITS_UPDATE(cabac, cr_ctx, v_is_set, tr_tree_bits, "cbf_cb_search");
+    }
+  }
+
   // Add transform_tree cbf_luma bit cost.
+  const int is_tr_split = tr_cu->tr_depth - tr_cu->depth;
+  int is_set = cbf_is_set(pred_cu->cbf, depth, COLOR_Y);
   if (pred_cu->type == CU_INTRA ||
-      tr_depth > 0 ||
+      is_tr_split ||
       cbf_is_set(tr_cu->cbf, depth, COLOR_U) ||
       cbf_is_set(tr_cu->cbf, depth, COLOR_V))
   {
-    const cabac_ctx_t *ctx = &(state->cabac.ctx.qt_cbf_model_luma!tr_depth);
-    tr_tree_bits += CTX_ENTROPY_FBITS(ctx, cbf_is_set(pred_cu->cbf, depth, COLOR_Y));
+    cabac_ctx_t *ctx = &(cabac->ctx.qt_cbf_model_luma!is_tr_split);
+
+    CABAC_FBITS_UPDATE(cabac, ctx, is_set, tr_tree_bits, "cbf_y_search");
   }
 
   // SSD between reconstruction and original
@@ -305,26 +331,29 @@
                                         width);
   }
 
-  {
+
+  if (!skip_residual_coding) {
     int8_t luma_scan_mode = kvz_get_scan_order(pred_cu->type, pred_cu->intra.mode, depth);
     const coeff_t *coeffs = &lcu->coeff.yxy_to_zorder(LCU_WIDTH, x_px, y_px);
 
-    coeff_bits += kvz_get_coeff_cost(state, coeffs, width, 0, luma_scan_mode);
+    if(is_set)
+      coeff_bits += kvz_get_coeff_cost(state, coeffs, width, 0, luma_scan_mode);
   }
 
   double bits = tr_tree_bits + coeff_bits;
-  return (double)ssd * LUMA_MULT + bits * state->lambda;
+  return (double)ssd * KVZ_LUMA_MULT + bits * state->lambda;
 }
 
 
 double kvz_cu_rd_cost_chroma(const encoder_state_t *const state,
-                         const int x_px, const int y_px, const int depth,
-                         const cu_info_t *const pred_cu,
-                         lcu_t *const lcu)
+                             const int x_px, const int y_px, const int depth,
+                             const cu_info_t *const pred_cu,
+                             lcu_t *const lcu)
 {
   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_GET_CU_AT_PX(lcu, x_px, y_px);
+  const int skip_residual_coding = pred_cu->skipped || (pred_cu->type == CU_INTER && pred_cu->cbf == 0);
 
   double tr_tree_bits = 0;
   double coeff_bits = 0;
@@ -338,20 +367,25 @@
     return 0;
   }
 
-  if (depth < MAX_PU_DEPTH) {
+  int u_is_set = cbf_is_set(pred_cu->cbf, depth, COLOR_U);
+  int v_is_set = cbf_is_set(pred_cu->cbf, depth, COLOR_V);
+  // See luma for why the second condition
+  if (depth < MAX_PU_DEPTH && (!state->search_cabac.update || tr_cu->tr_depth != tr_cu->depth) && !skip_residual_coding) {
     const int tr_depth = depth - pred_cu->depth;
-    const cabac_ctx_t *ctx = &(state->cabac.ctx.qt_cbf_model_chromatr_depth);
+    cabac_data_t* cabac = (cabac_data_t*)&state->search_cabac;
+    cabac_ctx_t *ctx = &(cabac->ctx.qt_cbf_model_chromatr_depth);
+    cabac->cur_ctx = ctx;
     if (tr_depth == 0 || cbf_is_set(pred_cu->cbf, depth - 1, COLOR_U)) {
-      tr_tree_bits += CTX_ENTROPY_FBITS(ctx, cbf_is_set(pred_cu->cbf, depth, COLOR_U));
+      CABAC_FBITS_UPDATE(cabac, ctx, u_is_set, tr_tree_bits, "cbf_cb_search");
     }
     if (tr_depth == 0 || cbf_is_set(pred_cu->cbf, depth - 1, COLOR_V)) {
-      tr_tree_bits += CTX_ENTROPY_FBITS(ctx, cbf_is_set(pred_cu->cbf, depth, COLOR_V));
+      CABAC_FBITS_UPDATE(cabac, ctx, v_is_set, tr_tree_bits, "cbf_cb_search");
     }
   }
 
   if (tr_cu->tr_depth > depth) {
     int offset = LCU_WIDTH >> (depth + 1);
-    int sum = 0;
+    double sum = 0;
 
     sum += kvz_cu_rd_cost_chroma(state, x_px, y_px, depth + 1, pred_cu, lcu);
     sum += kvz_cu_rd_cost_chroma(state, x_px + offset, y_px, depth + 1, pred_cu, lcu);
@@ -374,16 +408,147 @@
     ssd = ssd_u + ssd_v;
   }
 
+  if (!skip_residual_coding)
   {
     int8_t scan_order = kvz_get_scan_order(pred_cu->type, pred_cu->intra.mode_chroma, depth);
     const int index = xy_to_zorder(LCU_WIDTH_C, lcu_px.x, lcu_px.y);
 
-    coeff_bits += kvz_get_coeff_cost(state, &lcu->coeff.uindex, width, 2, scan_order);
-    coeff_bits += kvz_get_coeff_cost(state, &lcu->coeff.vindex, width, 2, scan_order);
+    if(u_is_set)coeff_bits += kvz_get_coeff_cost(state, &lcu->coeff.uindex, width, 2, scan_order);
+    if(v_is_set)coeff_bits += kvz_get_coeff_cost(state, &lcu->coeff.vindex, width, 2, scan_order);
   }
 
   double bits = tr_tree_bits + coeff_bits;
-  return (double)ssd * CHROMA_MULT + bits * state->lambda;
+  return (double)ssd * KVZ_CHROMA_MULT + bits * state->lambda;
+}
+
+static double cu_rd_cost_tr_split_accurate(const encoder_state_t* const state,
+                                           const int x_px, const int y_px, const int depth,
+                                           const cu_info_t* const pred_cu,
+                                           lcu_t* const lcu) {
+  const int width = LCU_WIDTH >> depth;
+
+  const int skip_residual_coding = pred_cu->skipped || (pred_cu->type == CU_INTER && pred_cu->cbf == 0);
+  // cur_cu is used for TU parameters.
+  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;
+
+  // Check that lcu is not in 
+  assert(x_px >= 0 && x_px < LCU_WIDTH);
+  assert(y_px >= 0 && y_px < LCU_WIDTH);
+
+  const uint8_t tr_depth = tr_cu->tr_depth - depth;
+
+  const int cb_flag_u = cbf_is_set(tr_cu->cbf, depth, COLOR_U);
+  const int cb_flag_v = cbf_is_set(tr_cu->cbf, depth, COLOR_V);
+
+  cabac_data_t* cabac = (cabac_data_t*)&state->search_cabac;
+
+  {
+    int cbf = cbf_is_set_any(pred_cu->cbf, depth);
+    // Only need to signal coded block flag if not skipped or merged
+    // skip = no coded residual, merge = coded residual
+    if (pred_cu->type == CU_INTER && (pred_cu->part_size != SIZE_2Nx2N || !pred_cu->merged)) {
+      CABAC_FBITS_UPDATE(cabac, &(cabac->ctx.cu_qt_root_cbf_model), cbf, tr_tree_bits, "rqt_root_cbf");
+    }
+
+  }
+  // Add transform_tree split_transform_flag bit cost.
+  bool intra_split_flag = pred_cu->type == CU_INTRA && pred_cu->part_size == SIZE_NxN && depth == 3;
+  int max_tr_depth;
+  if (pred_cu->type == CU_INTRA) {
+    max_tr_depth = state->encoder_control->cfg.tr_depth_intra + intra_split_flag;
+  }
+  else {
+    max_tr_depth = state->encoder_control->tr_depth_inter;
+  }
+  if (width <= TR_MAX_WIDTH
+    && width > TR_MIN_WIDTH
+    && !intra_split_flag
+    && MIN(tr_cu->tr_depth, depth) - tr_cu->depth < max_tr_depth
+    && !skip_residual_coding)
+  {
+    cabac_ctx_t* ctx = &(cabac->ctx.trans_subdiv_model5 - (6 - depth));
+    CABAC_FBITS_UPDATE(cabac, ctx, tr_depth > 0, tr_tree_bits, "tr_split_search");
+  }
+
+  if(state->encoder_control->chroma_format != KVZ_CSP_400 && !skip_residual_coding) {
+    if(tr_cu->depth == depth || cbf_is_set(pred_cu->cbf, depth - 1, COLOR_U)) {
+      CABAC_FBITS_UPDATE(cabac, &(cabac->ctx.qt_cbf_model_chromadepth - tr_cu->depth), cb_flag_u, tr_tree_bits, "cbf_cb");
+    } 
+    if(tr_cu->depth == depth || cbf_is_set(pred_cu->cbf, depth - 1, COLOR_V)) {
+      CABAC_FBITS_UPDATE(cabac, &(cabac->ctx.qt_cbf_model_chromadepth - tr_cu->depth), cb_flag_v, tr_tree_bits, "cbf_cr");
+    } 
+  }
+
+  if (tr_depth > 0) {
+    int offset = LCU_WIDTH >> (depth + 1);
+    double sum = 0;
+
+    sum += cu_rd_cost_tr_split_accurate(state, x_px, y_px, depth + 1, pred_cu, lcu);
+    sum += cu_rd_cost_tr_split_accurate(state, x_px + offset, y_px, depth + 1, pred_cu, lcu);
+    sum += cu_rd_cost_tr_split_accurate(state, x_px, y_px + offset, depth + 1, pred_cu, lcu);
+    sum += cu_rd_cost_tr_split_accurate(state, x_px + offset, y_px + offset, depth + 1, pred_cu, lcu);
+    return sum + tr_tree_bits * state->lambda;
+  }
+  const int cb_flag_y = cbf_is_set(tr_cu->cbf, depth, COLOR_Y) ;
+
+  // Add transform_tree cbf_luma bit cost.
+  const int is_tr_split = depth - tr_cu->depth;
+  if ((pred_cu->type == CU_INTRA ||
+    is_tr_split ||
+    cb_flag_u ||
+    cb_flag_v) 
+      && !skip_residual_coding)
+  {
+    cabac_ctx_t* ctx = &(cabac->ctx.qt_cbf_model_luma!is_tr_split);
+
+    CABAC_FBITS_UPDATE(cabac, ctx, cb_flag_y, tr_tree_bits, "cbf_y_search");
+  }
+  // SSD between reconstruction and original
+  unsigned luma_ssd = 0;
+  if (!state->encoder_control->cfg.lossless) {
+    int index = y_px * LCU_WIDTH + x_px;
+    luma_ssd = kvz_pixels_calc_ssd(&lcu->ref.yindex, &lcu->rec.yindex,
+      LCU_WIDTH, LCU_WIDTH,
+      width);
+  }
+
+  {
+    int8_t luma_scan_mode = kvz_get_scan_order(pred_cu->type, pred_cu->intra.mode, depth);
+    const coeff_t* coeffs = &lcu->coeff.yxy_to_zorder(LCU_WIDTH, x_px, y_px);
+
+    if(cb_flag_y)
+      coeff_bits += kvz_get_coeff_cost(state, coeffs, width, 0, luma_scan_mode);
+  }
+
+  unsigned chroma_ssd = 0;
+  if(state->encoder_control->chroma_format != KVZ_CSP_400 && x_px % 8 == 0 && y_px % 8 == 0) {
+    const vector2d_t lcu_px = { x_px / 2, y_px / 2 };
+    const int chroma_width = (depth <= MAX_DEPTH) ? LCU_WIDTH >> (depth + 1) : LCU_WIDTH >> depth;
+    if (!state->encoder_control->cfg.lossless) {
+      int index = lcu_px.y * LCU_WIDTH_C + lcu_px.x;
+      unsigned ssd_u = kvz_pixels_calc_ssd(&lcu->ref.uindex, &lcu->rec.uindex,
+        LCU_WIDTH_C, LCU_WIDTH_C,
+        chroma_width);
+      unsigned ssd_v = kvz_pixels_calc_ssd(&lcu->ref.vindex, &lcu->rec.vindex,
+        LCU_WIDTH_C, LCU_WIDTH_C,
+        chroma_width);
+      chroma_ssd = ssd_u + ssd_v;
+    }
+
+     {
+      int8_t scan_order = kvz_get_scan_order(pred_cu->type, pred_cu->intra.mode_chroma, depth);
+      const unsigned index = xy_to_zorder(LCU_WIDTH_C, lcu_px.x, lcu_px.y);
+
+      if(cb_flag_u)coeff_bits += kvz_get_coeff_cost(state, &lcu->coeff.uindex, chroma_width, 2, scan_order);
+      if (cb_flag_v)coeff_bits += kvz_get_coeff_cost(state, &lcu->coeff.vindex, chroma_width, 2, scan_order);
+    }
+  }
+
+  double bits = tr_tree_bits + coeff_bits;
+  return luma_ssd * KVZ_LUMA_MULT + chroma_ssd * KVZ_CHROMA_MULT + bits * state->lambda;
 }
 
 
@@ -415,6 +580,7 @@
 }
 
 
+// TODO: replace usages of this by the kvz_sort_indices_by_cost function.
 /**
  * \brief Sort modes and costs to ascending order according to costs.
  */
@@ -439,6 +605,25 @@
 }
 
 
+/**
+ * \brief Sort keys (indices) to ascending order according to costs.
+ */
+void kvz_sort_keys_by_cost(unit_stats_map_t *__restrict map)
+{
+  // Size of sorted arrays is expected to be "small". No need for faster algorithm.
+  for (uint8_t i = 1; i < map->size; ++i) {
+    const int8_t cur_indx = map->keysi;
+    const double cur_cost = map->costcur_indx;
+    uint8_t j = i;
+    while (j > 0 && cur_cost < map->costmap->keysj - 1) {
+      map->keysj = map->keysj - 1;
+      --j;
+    }
+    map->keysj = cur_indx;
+  }
+}
+
+
 static uint8_t get_ctx_cu_split_model(const lcu_t *lcu, int x, int y, int depth)
 {
   vector2d_t lcu_cu = { SUB_SCU(x), SUB_SCU(y) };
@@ -462,10 +647,12 @@
   const encoder_control_t* ctrl = state->encoder_control;
   const videoframe_t * const frame = state->tile->frame;
   int cu_width = LCU_WIDTH >> depth;
-  double cost = MAX_INT;
-  double inter_zero_coeff_cost = MAX_INT;
-  uint32_t inter_bitcost = MAX_INT;
+  double cost = MAX_DOUBLE;
+  double inter_zero_coeff_cost = MAX_DOUBLE;
+  double inter_bitcost = MAX_INT;
   cu_info_t *cur_cu;
+  cabac_data_t pre_search_cabac;
+  memcpy(&pre_search_cabac, &state->search_cabac, sizeof(pre_search_cabac));
 
   struct {
     int32_t min;
@@ -487,7 +674,7 @@
 
   // Assign correct depth limit
   constraint_t* constr = state->constraint;
- if(constr->ml_intra_depth_ctu) {
+  if(constr->ml_intra_depth_ctu) {
     pu_depth_intra.min = constr->ml_intra_depth_ctu->_mat_upper_depth(x_local >> 3) + (y_local >> 3) * 8;
     pu_depth_intra.max = constr->ml_intra_depth_ctu->_mat_lower_depth(x_local >> 3) + (y_local >> 3) * 8;
   }
@@ -526,7 +713,7 @@
 
     if (can_use_inter) {
       double mode_cost;
-      uint32_t mode_bitcost;
+      double mode_bitcost;
       kvz_search_cu_inter(state,
                           x, y,
                           depth,
@@ -577,23 +764,36 @@
 
     int32_t cu_width_intra_min = LCU_WIDTH >> pu_depth_intra.max;
     bool can_use_intra =
-        WITHIN(depth, pu_depth_intra.min, pu_depth_intra.max) ||
+      (WITHIN(depth, pu_depth_intra.min, pu_depth_intra.max) ||
         // When the split was forced because the CTU is partially outside
         // the frame, we permit intra coding even if pu_depth_intra would
         // otherwise forbid it.
         (x & ~(cu_width_intra_min - 1)) + cu_width_intra_min > frame->width ||
-        (y & ~(cu_width_intra_min - 1)) + cu_width_intra_min > frame->height;
+        (y & ~(cu_width_intra_min - 1)) + cu_width_intra_min > frame->height) &&
+      !(state->encoder_control->cfg.force_inter && state->frame->slicetype != KVZ_SLICE_I);
 
     if (can_use_intra && !skip_intra) {
       int8_t intra_mode;
       double intra_cost;
       kvz_search_cu_intra(state, x, y, depth, lcu,
                           &intra_mode, &intra_cost);
+#ifdef COMPLETE_PRED_MODE_BITS
+      // Technically counting these bits would be correct, however counting
+      // them universally degrades quality so this block is disabled by default
+      if(state->frame->slicetype != KVZ_SLICE_I) {
+        double pred_mode_type_bits = 0;
+        CABAC_FBITS_UPDATE(&state->search_cabac, &state->search_cabac.ctx.cu_pred_mode_model, 1, pred_mode_type_bits, "pred_mode_flag");
+        CABAC_FBITS_UPDATE(&state->search_cabac, &state->search_cabac.ctx.cu_skip_flag_modelkvz_get_skip_context(x, y, lcu, NULL), 0, pred_mode_type_bits, "skip_flag");
+        intra_cost += pred_mode_type_bits * state->lambda;
+      }
+#endif
       if (intra_cost < cost) {
         cost = intra_cost;
         cur_cu->type = CU_INTRA;
         cur_cu->part_size = depth > MAX_DEPTH ? SIZE_NxN : SIZE_2Nx2N;
         cur_cu->intra.mode = intra_mode;
+        cur_cu->skipped = 0;
+        cur_cu->merged = 0;
       }
     }
 
@@ -614,7 +814,7 @@
         // rd2. Possibly because the luma mode search already takes chroma
         // into account, so there is less of a chanse of luma mode being
         // really bad for chroma.
-        if (ctrl->cfg.rdo == 3) {
+        if (ctrl->cfg.rdo >= 2 && ctrl->cfg.intra_chroma_search) {
           cur_cu->intra.mode_chroma = kvz_search_cu_intra_chroma(state, x, y, depth, lcu);
           lcu_fill_cu_info(lcu, x_local, y_local, cu_width, cu_width, cur_cu);
         }
@@ -658,9 +858,10 @@
           cur_cu->merged = 0;
           cur_cu->skipped = 1;
           // Selecting skip reduces bits needed to code the CU
-          if (inter_bitcost > 1) {
-            inter_bitcost -= 1;
-          }
+          int skip_ctx = kvz_get_skip_context(x, y, lcu, NULL);
+          inter_bitcost = CTX_ENTROPY_FBITS(&state->search_cabac.ctx.cu_skip_flag_modelskip_ctx, 1);
+          inter_bitcost += CTX_ENTROPY_FBITS(&(state->search_cabac.ctx.cu_merge_idx_ext_model), cur_cu->merge_idx != 0);
+          inter_bitcost += cur_cu->merge_idx;        
         }
       }
       lcu_fill_inter(lcu, x_local, y_local, cu_width);
@@ -669,20 +870,31 @@
   }
 
   if (cur_cu->type == CU_INTRA || cur_cu->type == CU_INTER) {
-    cost = kvz_cu_rd_cost_luma(state, x_local, y_local, depth, cur_cu, lcu);
-    if (state->encoder_control->chroma_format != KVZ_CSP_400) {
-      cost += kvz_cu_rd_cost_chroma(state, x_local, y_local, depth, cur_cu, lcu);
+    double bits = 0;
+    cabac_data_t* cabac  = &state->search_cabac;
+    cabac->update = 1;
+
+    if(cur_cu->type != CU_INTRA || cur_cu->part_size == SIZE_2Nx2N) {
+      bits += kvz_mock_encode_coding_unit(
+        state,
+        cabac,
+        x, y, depth,
+        lcu,
+        cur_cu);
     }
-
-    double mode_bits;
-    if (cur_cu->type == CU_INTRA) {
-      mode_bits = calc_mode_bits(state, lcu, cur_cu, x, y);
-    } else {
-      mode_bits = inter_bitcost;
+    else {
+      // Intra 4×4 PUs
+      if (state->frame->slicetype != KVZ_SLICE_I) {
+        cabac_ctx_t* ctx = &(cabac->ctx.cu_pred_mode_model);
+        CABAC_FBITS_UPDATE(cabac, ctx, 1, bits, "pred_mode_flag");
+      }
+      bits += calc_mode_bits(state, lcu, cur_cu, x, y);
     }
+    
+    cost = bits * state->lambda;
 
-    cost += mode_bits * state->lambda;
-
+    cost += cu_rd_cost_tr_split_accurate(state, x_local, y_local, depth, cur_cu, lcu);
+    
     if (ctrl->cfg.zero_coeff_rdo && inter_zero_coeff_cost <= cost) {
       cost = inter_zero_coeff_cost;
 
@@ -704,13 +916,14 @@
       cur_cu->cbf = 0;
       lcu_fill_cbf(lcu, x_local, y_local, cu_width, cur_cu);
     }
-  }
+    cabac->update = 0;
+  } 
 
   bool can_split_cu =
     // If the CU is partially outside the frame, we need to split it even
     // if pu_depth_intra and pu_depth_inter would not permit it.
     cur_cu->type == CU_NOTSET ||
-    depth < pu_depth_intra.max ||
+    (depth < pu_depth_intra.max && !(state->encoder_control->cfg.force_inter&& state->frame->slicetype != KVZ_SLICE_I)) ||
     (state->frame->slicetype != KVZ_SLICE_I &&
       depth < pu_depth_inter.max);
 
@@ -719,21 +932,27 @@
     int half_cu = cu_width / 2;
     double split_cost = 0.0;
     int cbf = cbf_is_set_any(cur_cu->cbf, depth);
+    cabac_data_t post_seach_cabac;
+    memcpy(&post_seach_cabac, &state->search_cabac, sizeof(post_seach_cabac));
+    memcpy(&state->search_cabac, &pre_search_cabac, sizeof(post_seach_cabac));
+    state->search_cabac.update = 1;
+
+    double split_bits = 0;
 
     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_modelsplit_model);
-      cost += CTX_ENTROPY_FBITS(ctx, 0) * state->lambda;
-      split_cost += CTX_ENTROPY_FBITS(ctx, 1) * state->lambda;
+      cabac_ctx_t *ctx = &(state->search_cabac.ctx.split_flag_modelsplit_model);
+      CABAC_FBITS_UPDATE(&state->search_cabac, ctx, 1, split_bits, "split_search");
     }
 
     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_model0);
-      cost += CTX_ENTROPY_FBITS(ctx, 1) * state->lambda;  // 2Nx2N
-      split_cost += CTX_ENTROPY_FBITS(ctx, 0) * state->lambda;  // NxN
+      cabac_ctx_t *ctx = &(state->search_cabac.ctx.part_size_model0);
+      CABAC_FBITS_UPDATE(&state->search_cabac, ctx, 0, split_bits, "split_search");
     }
+    state->search_cabac.update = 0;
+    split_cost += split_bits * state->lambda;
 
     // If skip mode was selected for the block, skip further search.
     // Skip mode means there's no coefficients in the block, so splitting
@@ -754,13 +973,29 @@
     // gets used, at least in the most obvious cases, while avoiding any
     // searching.
     if (cur_cu->type == CU_NOTSET && depth < MAX_PU_DEPTH
-        && x + cu_width <= frame->width && y + cu_width <= frame->height)
+        && x + cu_width <= frame->width && y + cu_width <= frame->height 
+        && state->encoder_control->cfg.combine_intra_cus)
     {
+
       cu_info_t *cu_d1 = LCU_GET_CU_AT_PX(&work_treedepth + 1, x_local, y_local);
 
       // 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) {
+        cabac_data_t temp_cabac;
+        memcpy(&temp_cabac, &state->search_cabac, sizeof(temp_cabac));
+        memcpy(&state->search_cabac, &pre_search_cabac, sizeof(pre_search_cabac));
         cost = 0;
+        double bits = 0;
+        if (depth < MAX_DEPTH) {
+          uint8_t split_model = get_ctx_cu_split_model(lcu, x, y, depth);
+          cabac_ctx_t* ctx = &(state->search_cabac.ctx.split_flag_modelsplit_model);
+          CABAC_FBITS_UPDATE(&state->search_cabac, ctx, 0, bits, "no_split_search");
+        }
+        else if (depth == MAX_DEPTH && cur_cu->type == CU_INTRA) {
+          // Add cost of intra part_size.
+          cabac_ctx_t* ctx = &(state->search_cabac.ctx.part_size_model0);
+          CABAC_FBITS_UPDATE(&state->search_cabac, ctx, 1, bits, "no_split_search");
+        }
 
         cur_cu->intra = cu_d1->intra;
         cur_cu->type = CU_INTRA;
@@ -777,19 +1012,13 @@
                            cur_cu->intra.mode, mode_chroma,
                            NULL, lcu);
 
-        cost += kvz_cu_rd_cost_luma(state, x_local, y_local, depth, cur_cu, lcu);
-        if (has_chroma) {
-          cost += kvz_cu_rd_cost_chroma(state, x_local, y_local, depth, cur_cu, lcu);
-        }
+        double mode_bits = calc_mode_bits(state, lcu, cur_cu, x, y) + bits;
+        cost += mode_bits * state->lambda;
 
-        // 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_modelsplit_model);
-        cost += CTX_ENTROPY_FBITS(ctx, 0) * state->lambda;
+        cost += cu_rd_cost_tr_split_accurate(state, x_local, y_local, depth, cur_cu, lcu);
 
-        // Add the cost of coding intra mode only once.
-        double mode_bits = calc_mode_bits(state, lcu, cur_cu, x, y);
-        cost += mode_bits * state->lambda;
+        memcpy(&post_seach_cabac, &state->search_cabac, sizeof(post_seach_cabac));
+        memcpy(&state->search_cabac, &temp_cabac, sizeof(temp_cabac));
       }
     }
 
@@ -803,6 +1032,7 @@
     } else if (depth > 0) {
       // Copy this CU's mode all the way down for use in adjacent CUs mode
       // search.
+      memcpy(&state->search_cabac, &post_seach_cabac, sizeof(post_seach_cabac));
       work_tree_copy_down(x_local, y_local, depth, work_tree);
     }
   } else if (depth >= 0 && depth < MAX_PU_DEPTH) {
@@ -957,6 +1187,8 @@
  */
 void kvz_search_lcu(encoder_state_t * const state, const int x, const int y, const yuv_t * const hor_buf, const yuv_t * const ver_buf)
 {
+  memcpy(&state->search_cabac, &state->cabac, sizeof(cabac_data_t));
+  state->search_cabac.only_count = 1;
   assert(x % LCU_WIDTH == 0);
   assert(y % LCU_WIDTH == 0);

kvazaar-2.1.0.tar.gz/src/search.h -> kvazaar-2.2.0.tar.gz/src/search.h Changed

@@ -44,18 +44,48 @@
 #include "image.h"
 #include "constraint.h"
 
+#define MAX_UNIT_STATS_MAP_SIZE MAX(MAX_REF_PIC_COUNT, MRG_MAX_NUM_CANDS)
+
+ // Modify weight of luma SSD.
+#ifndef KVZ_LUMA_MULT
+# define KVZ_LUMA_MULT 0.8
+#endif
+// Modify weight of chroma SSD.
+#ifndef KVZ_CHROMA_MULT
+# define KVZ_CHROMA_MULT 1.5
+#endif
+
+ /**
+  *  \brief Data collected during search processes.
+  * 
+  *         The intended use is to collect statistics of the
+  *         searched coding/prediction units. Data related to
+  *         a specific unit is found at index i. The arrays
+  *         should be indexed by elements of the "keys" array
+  *         that will be sorted by the RD costs of the units.         
+  */
+typedef struct unit_stats_map_t {
+
+  cu_info_t unitMAX_UNIT_STATS_MAP_SIZE; //!< list of searched units
+  double    costMAX_UNIT_STATS_MAP_SIZE; //!< list of matching RD costs
+  double    bitsMAX_UNIT_STATS_MAP_SIZE; //!< list of matching bit costs  
+  int8_t    keysMAX_UNIT_STATS_MAP_SIZE; //!< list of keys (indices) to elements in the other arrays
+  int       size;                    //!< number of active elements in the lists
+} unit_stats_map_t;
+
 void kvz_sort_modes(int8_t *__restrict modes, double *__restrict costs, uint8_t length);
+void kvz_sort_keys_by_cost(unit_stats_map_t *__restrict map);
 
 void kvz_search_lcu(encoder_state_t *state, int x, int y, const yuv_t *hor_buf, const yuv_t *ver_buf);
 
 double kvz_cu_rd_cost_luma(const encoder_state_t *const state,
-                       const int x_px, const int y_px, const int depth,
-                       const cu_info_t *const pred_cu,
-                       lcu_t *const lcu);
+                           const int x_px, const int y_px, const int depth,
+                           const cu_info_t *const pred_cu,
+                           lcu_t *const lcu);
 double kvz_cu_rd_cost_chroma(const encoder_state_t *const state,
-                         const int x_px, const int y_px, const int depth,
-                         const cu_info_t *const pred_cu,
-                         lcu_t *const lcu);
+                             const int x_px, const int y_px, const int depth,
+                             const cu_info_t *const pred_cu,
+                             lcu_t *const lcu);
 void kvz_lcu_fill_trdepth(lcu_t *lcu, int x_px, int y_px, int depth, int tr_depth);
 
 void kvz_intra_recon_lcu_luma(encoder_state_t * const state, int x, int y, int depth, int8_t intra_mode, cu_info_t *cur_cu, lcu_t *lcu);

kvazaar-2.1.0.tar.gz/src/search_inter.c -> kvazaar-2.2.0.tar.gz/src/search_inter.c Changed

@@ -37,6 +37,7 @@
 
 #include "cabac.h"
 #include "encoder.h"
+#include "encode_coding_tree.h"
 #include "image.h"
 #include "imagelist.h"
 #include "inter.h"
@@ -68,7 +69,7 @@
   /**
    * \brief Top-left corner of the PU
    */
-  const vector2d_t origin;
+  vector2d_t origin;
   int32_t width;
   int32_t height;
 
@@ -79,19 +80,6 @@
   kvz_mvd_cost_func *mvd_cost_func;
 
   /**
-   * \brief Best motion vector among the ones tested so far
-   */
-  vector2d_t best_mv;
-  /**
-   * \brief Cost of best_mv
-   */
-  uint32_t best_cost;
-  /**
-   * \brief Bit cost of best_mv
-   */
-  uint32_t best_bitcost;
-
-  /**
    * \brief Possible optimized SAD implementation for the width, leave as
    *        NULL for arbitrary-width blocks
    */
@@ -203,20 +191,25 @@
 /**
  * \brief Calculate cost for an integer motion vector.
  *
- * Updates info->best_mv, info->best_cost and info->best_bitcost to the new
+ * Updates best_mv, best_cost and best_bitcost to the new
  * motion vector if it yields a lower cost than the current one.
  *
  * If the motion vector violates the MV constraints for tiles or WPP, the
  * cost is not set.
  *
- * \return true if info->best_mv was changed, false otherwise
+ * \return true if best_mv was changed, false otherwise
  */
-static bool check_mv_cost(inter_search_info_t *info, int x, int y)
+static bool check_mv_cost(inter_search_info_t *info,
+                          int x,
+                          int y,
+                          double *best_cost,
+                          double* best_bits,
+                          vector2d_t *best_mv)
 {
   if (!intmv_within_tile(info, x, y)) return false;
 
-  uint32_t bitcost = 0;
-  uint32_t cost = kvz_image_calc_sad(
+  double bitcost = 0;
+  double cost = kvz_image_calc_sad(
       info->pic,
       info->ref,
       info->origin.x,
@@ -228,25 +221,25 @@
       info->optimized_sad
   );
 
-  if (cost >= info->best_cost) return false;
+  if (cost >= *best_cost) return false;
 
   cost += info->mvd_cost_func(
       info->state,
       x, y, 2,
       info->mv_cand,
-      info->merge_cand,
-      info->num_merge_cand,
+      NULL,
+      0,
       info->ref_idx,
       &bitcost
   );
 
-  if (cost >= info->best_cost) return false;
+  if (cost >= *best_cost) return false;
 
   // Set to motion vector in quarter pixel precision.
-  info->best_mv.x = x * 4;
-  info->best_mv.y = y * 4;
-  info->best_cost = cost;
-  info->best_bitcost = bitcost;
+  best_mv->x = x * 4;
+  best_mv->y = y * 4;
+  *best_cost = cost;
+  *best_bits = bitcost;
 
   return true;
 }
@@ -254,10 +247,10 @@
 
 static unsigned get_ep_ex_golomb_bitcost(unsigned symbol)
 {
-  // Calculate 2 * log2(symbol + 2)
+  // Calculate 2 * log2(symbol )
 
   unsigned bins = 0;
-  symbol += 2;
+  symbol += 0;
   if (symbol >= 1 << 8) { bins += 16; symbol >>= 8; }
   if (symbol >= 1 << 4) { bins += 8; symbol >>= 4; }
   if (symbol >= 1 << 2) { bins += 4; symbol >>= 2; }
@@ -297,12 +290,16 @@
  * \brief Select starting point for integer motion estimation search.
  *
  * Checks the zero vector, extra_mv and merge candidates and updates
- * info->best_mv to the best one.
+ * best_mv to the best one.
  */
-static void select_starting_point(inter_search_info_t *info, vector2d_t extra_mv)
+static void select_starting_point(inter_search_info_t *info,
+                                  vector2d_t extra_mv,
+                                  double *best_cost,
+                                  double* best_bits,
+                                  vector2d_t *best_mv)
 {
   // Check the 0-vector, so we can ignore all 0-vectors in the merge cand list.
-  check_mv_cost(info, 0, 0);
+  check_mv_cost(info, 0, 0, best_cost, best_bits, best_mv);
 
   // Change to integer precision.
   extra_mv.x >>= 2;
@@ -310,7 +307,7 @@
 
   // Check mv_in if it's not one of the merge candidates.
   if ((extra_mv.x != 0 || extra_mv.y != 0) && !mv_in_merge(info, extra_mv)) {
-    check_mv_cost(info, extra_mv.x, extra_mv.y);
+    check_mv_cost(info, extra_mv.x, extra_mv.y, best_cost, best_bits, best_mv);
   }
 
   // Go through candidates
@@ -322,24 +319,26 @@
 
     if (x == 0 && y == 0) continue;
 
-    check_mv_cost(info, x, y);
+    check_mv_cost(info, x, y, best_cost, best_bits, best_mv);
   }
 }
 
 
-static uint32_t get_mvd_coding_cost(const encoder_state_t *state,
-                                    const cabac_data_t* cabac,
-                                    const int32_t mvd_hor,
-                                    const int32_t mvd_ver)
+static double get_mvd_coding_cost(const encoder_state_t* state,
+  const cabac_data_t* cabac,
+  const int32_t mvd_hor,
+  const int32_t mvd_ver)
 {
-  unsigned bitcost = 0;
+  double bitcost = 4 << CTX_FRAC_BITS;
   const vector2d_t abs_mvd = { abs(mvd_hor), abs(mvd_ver) };
+  bitcost += abs_mvd.x == 1 ? 1 << CTX_FRAC_BITS : (0 * (1 << CTX_FRAC_BITS));
+  bitcost += abs_mvd.y == 1 ? 1 << CTX_FRAC_BITS : (0 * (1 << CTX_FRAC_BITS));
 
   bitcost += get_ep_ex_golomb_bitcost(abs_mvd.x) << CTX_FRAC_BITS;
   bitcost += get_ep_ex_golomb_bitcost(abs_mvd.y) << CTX_FRAC_BITS;
 
   // Round and shift back to integer bits.
-  return (bitcost + CTX_FRAC_HALF_BIT) >> CTX_FRAC_BITS;
+  return bitcost / (1 << CTX_FRAC_BITS);
 }
 
 
@@ -347,7 +346,7 @@
                           int16_t mv_cand22,
                           int32_t mv_x,
                           int32_t mv_y,
-                          uint32_t *cost_out)
+                          double*cost_out)
 {
   const bool same_cand =
     (mv_cand00 == mv_cand10 && mv_cand01 == mv_cand11);
@@ -357,7 +356,7 @@
     return 0;
   }
 
-  uint32_t (*mvd_coding_cost)(const encoder_state_t * const state,
+  double (*mvd_coding_cost)(const encoder_state_t * const state,
                               const cabac_data_t*,
                               int32_t, int32_t);
   if (state->encoder_control->cfg.mv_rdo) {
@@ -366,12 +365,12 @@
     mvd_coding_cost = get_mvd_coding_cost;
   }
 
-  uint32_t cand1_cost = mvd_coding_cost(
+  double cand1_cost = mvd_coding_cost(
       state, &state->cabac,
       mv_x - mv_cand00,
       mv_y - mv_cand01);
 
-  uint32_t cand2_cost;
+  double cand2_cost;
   if (same_cand) {
     cand2_cost = cand1_cost;
   } else {
@@ -390,17 +389,17 @@
 }
 
 
-static uint32_t calc_mvd_cost(const encoder_state_t *state,
-                              int x,
-                              int y,
-                              int mv_shift,
-                              int16_t mv_cand22,
-                              inter_merge_cand_t merge_candMRG_MAX_NUM_CANDS,
-                              int16_t num_cand,
-                              int32_t ref_idx,
-                              uint32_t *bitcost)
+static double calc_mvd_cost(const encoder_state_t *state,
+                            int x,
+                            int y,
+                            int mv_shift,
+                            int16_t mv_cand22,
+                            inter_merge_cand_t merge_candMRG_MAX_NUM_CANDS,
+                            int16_t num_cand,
+                            int32_t ref_idx,
+                            double* bitcost)
 {
-  uint32_t temp_bitcost = 0;
+  double temp_bitcost = 0;
   uint32_t merge_idx;
   int8_t merged      = 0;
 
@@ -423,23 +422,26 @@
 
   // Check mvd cost only if mv is not merged
   if (!merged) {
-    uint32_t mvd_cost = 0;
+    double mvd_cost = 0;
     select_mv_cand(state, mv_cand, x, y, &mvd_cost);
     temp_bitcost += mvd_cost;
   }
   *bitcost = temp_bitcost;
-  return temp_bitcost*(int32_t)(state->lambda_sqrt + 0.5);
+  return temp_bitcost * state->lambda_sqrt;
 }
 
 
-static bool early_terminate(inter_search_info_t *info)
+static bool early_terminate(inter_search_info_t *info,
+                            double *best_cost,
+                            double* best_bits,
+                            vector2d_t *best_mv)
 {
   static const vector2d_t small_hexbs7 = {
       { 0, -1 }, { -1, 0 }, { 0, 1 }, { 1, 0 },
       { 0, -1 }, { -1, 0 }, { 0, 0 },
   };
 
-  vector2d_t mv = { info->best_mv.x >> 2, info->best_mv.y >> 2 };
+  vector2d_t mv = { best_mv->x >> 2, best_mv->y >> 2 };
 
   int first_index = 0;
   int last_index = 3;
@@ -449,9 +451,9 @@
     if (info->state->encoder_control->cfg.me_early_termination ==
         KVZ_ME_EARLY_TERMINATION_SENSITIVE)
     {
-      threshold = info->best_cost * 0.95;
+      threshold = *best_cost * 0.95;
     } else {
-      threshold = info->best_cost;
+      threshold = *best_cost;
     }
 
     int best_index = 6;
@@ -459,7 +461,7 @@
       int x = mv.x + small_hexbsi.x;
       int y = mv.y + small_hexbsi.y;
 
-      if (check_mv_cost(info, x, y)) {
+      if (check_mv_cost(info, x, y, best_cost, best_bits, best_mv)) {
         best_index = i;
       }
     }
@@ -469,7 +471,7 @@
     mv.y += small_hexbsbest_index.y;
 
     // If best match is not better than threshold, we stop the search.
-    if (info->best_cost >= threshold) {
+    if (*best_cost >= threshold) {
       return true;
     }
 
@@ -484,7 +486,10 @@
                            unsigned pattern_type,
                            const int iDist,
                            vector2d_t mv,
-                           int *best_dist)
+                           int *best_dist,
+                           double *best_cost,
+                           double* best_bits,
+                           vector2d_t *best_mv)
 {
   assert(pattern_type < 4);
 
@@ -586,7 +591,7 @@
     int x = mv.x + offset.x;
     int y = mv.y + offset.y;
 
-    if (check_mv_cost(info, x, y)) {
+    if (check_mv_cost(info, x, y, best_cost, best_bits, best_mv)) {
       best_index = i;
     }
   }
@@ -599,20 +604,27 @@
 
 void kvz_tz_raster_search(inter_search_info_t *info,
                           int iSearchRange,
-                          int iRaster)
+                          int iRaster,
+                          double *best_cost,
+                          double* best_bits,
+                          vector2d_t *best_mv)
 {
-  const vector2d_t mv = { info->best_mv.x >> 2, info->best_mv.y >> 2 };
+  const vector2d_t mv = { best_mv->x >> 2, best_mv->y >> 2 };
 
   //compute SAD values for every point in the iRaster downsampled version of the current search area
   for (int y = iSearchRange; y >= -iSearchRange; y -= iRaster) {
     for (int x = -iSearchRange; x <= iSearchRange; x += iRaster) {
-      check_mv_cost(info, mv.x + x, mv.y + y);
+      check_mv_cost(info, mv.x + x, mv.y + y, best_cost, best_bits, best_mv);
     }
   }
 }
 
 
-static void tz_search(inter_search_info_t *info, vector2d_t extra_mv)
+static void tz_search(inter_search_info_t *info,
+                      vector2d_t extra_mv,
+                      double *best_cost,
+                      double* best_bits,
+                      vector2d_t *best_mv)
 {
   //TZ parameters
   const int iSearchRange = 96;  // search range for each stage
@@ -624,25 +636,13 @@
   const bool use_star_refinement = true;   // enable step 4 mode 2 (only one mode will be executed)
 
   int best_dist = 0;
-  info->best_cost = UINT32_MAX;
-
-  // Select starting point from among merge candidates. These should
-  // include both mv_cand vectors and (0, 0).
-  select_starting_point(info, extra_mv);
-
-  // Check if we should stop search
-  if (info->state->encoder_control->cfg.me_early_termination &&
-      early_terminate(info))
-  {
-    return;
-  }
-
-  vector2d_t start = { info->best_mv.x >> 2, info->best_mv.y >> 2 };
+  
+  vector2d_t start = { best_mv->x >> 2, best_mv->y >> 2 };
 
   // step 2, grid search
   int rounds_without_improvement = 0;
   for (int iDist = 1; iDist <= iSearchRange; iDist *= 2) {
-    kvz_tz_pattern_search(info, step2_type, iDist, start, &best_dist);
+    kvz_tz_pattern_search(info, step2_type, iDist, start, &best_dist, best_cost, best_bits, best_mv);
 
     // Break the loop if the last three rounds didn't produce a better MV.
     if (best_dist != iDist) rounds_without_improvement++;
@@ -655,7 +655,7 @@
     start.y = 0;
     rounds_without_improvement = 0;
     for (int iDist = 1; iDist <= iSearchRange/2; iDist *= 2) {
-      kvz_tz_pattern_search(info, step2_type, iDist, start, &best_dist);
+      kvz_tz_pattern_search(info, step2_type, iDist, start, &best_dist, best_cost, best_bits, best_mv);
 
       if (best_dist != iDist) rounds_without_improvement++;
       if (rounds_without_improvement >= 3) break;
@@ -665,7 +665,7 @@
   //step 3, raster scan
   if (use_raster_scan && best_dist > iRaster) {
     best_dist = iRaster;
-    kvz_tz_raster_search(info, iSearchRange, iRaster);
+    kvz_tz_raster_search(info, iSearchRange, iRaster, best_cost, best_bits, best_mv);
   }
 
   //step 4
@@ -673,19 +673,19 @@
   //raster refinement
   if (use_raster_refinement && best_dist > 0) {
     for (int iDist = best_dist >> 1; iDist > 0; iDist >>= 1) {
-      start.x = info->best_mv.x >> 2;
-      start.y = info->best_mv.y >> 2;
-      kvz_tz_pattern_search(info, step4_type, iDist, start, &best_dist);
+      start.x = best_mv->x >> 2;
+      start.y = best_mv->y >> 2;
+      kvz_tz_pattern_search(info, step4_type, iDist, start, &best_dist, best_cost, best_bits, best_mv);
     }
   }
 
   //star refinement (repeat step 2 for the current starting point)
   while (use_star_refinement && best_dist > 0) {
     best_dist = 0;
-    start.x = info->best_mv.x >> 2;
-    start.y = info->best_mv.y >> 2;
+    start.x = best_mv->x >> 2;
+    start.y = best_mv->y >> 2;
     for (int iDist = 1; iDist <= iSearchRange; iDist *= 2) {
-      kvz_tz_pattern_search(info, step4_type, iDist, start, &best_dist);
+      kvz_tz_pattern_search(info, step4_type, iDist, start, &best_dist, best_cost, best_bits, best_mv);
     }
   }
 }
@@ -707,7 +707,12 @@
  * 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 void hexagon_search(inter_search_info_t *info, vector2d_t extra_mv, uint32_t steps)
+static void hexagon_search(inter_search_info_t *info,
+                           vector2d_t extra_mv,
+                           uint32_t steps,
+                           double *best_cost,
+                           double* best_bits,
+                           vector2d_t *best_mv)
 {
   // The start of the hexagonal pattern has been repeated at the end so that
   // the indices between 1-6 can be used as the start of a 3-point list of new
@@ -732,27 +737,14 @@
       { -1, -1 }, { 1, -1 }, { -1, 1 }, { 1, 1 }
   };
 
-  info->best_cost = UINT32_MAX;
-
-  // Select starting point from among merge candidates. These should
-  // include both mv_cand vectors and (0, 0).
-  select_starting_point(info, extra_mv);
-
-  // Check if we should stop search
-  if (info->state->encoder_control->cfg.me_early_termination &&
-      early_terminate(info))
-  {
-    return;
-  }
-
-  vector2d_t mv = { info->best_mv.x >> 2, info->best_mv.y >> 2 };
+  vector2d_t mv = { best_mv->x >> 2, best_mv->y >> 2 };
 
   // Current best index, either to merge_cands, large_hexbs or small_hexbs.
   int best_index = 0;
 
   // Search the initial 7 points of the hexagon.
   for (int i = 1; i < 7; ++i) {
-    if (check_mv_cost(info, mv.x + large_hexbsi.x, mv.y + large_hexbsi.y)) {
+    if (check_mv_cost(info, mv.x + large_hexbsi.x, mv.y + large_hexbsi.y, best_cost, best_bits, best_mv)) {
       best_index = i;
     }
   }
@@ -781,7 +773,7 @@
     // Iterate through the next 3 points.
     for (int i = 0; i < 3; ++i) {
       vector2d_t offset = large_hexbsstart + i;
-      if (check_mv_cost(info, mv.x + offset.x, mv.y + offset.y)) {
+      if (check_mv_cost(info, mv.x + offset.x, mv.y + offset.y, best_cost, best_bits, best_mv)) {
         best_index = start + i;
       }
     }
@@ -793,7 +785,7 @@
 
   // Do the final step of the search with a small pattern.
   for (int i = 1; i < 9; ++i) {
-    check_mv_cost(info, mv.x + small_hexbsi.x, mv.y + small_hexbsi.y);
+    check_mv_cost(info, mv.x + small_hexbsi.x, mv.y + small_hexbsi.y, best_cost, best_bits, best_mv);
   }
 }
 
@@ -813,7 +805,12 @@
 * 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 void diamond_search(inter_search_info_t *info, vector2d_t extra_mv, uint32_t steps) 
+static void diamond_search(inter_search_info_t *info,
+                           vector2d_t extra_mv,
+                           uint32_t steps,
+                           double *best_cost,
+                           double* best_bits,
+                           vector2d_t *best_mv)
 {
   enum diapos {
     DIA_UP = 0,
@@ -831,29 +828,16 @@
     {0, -1}, {1, 0}, {0, 1}, {-1, 0},
     {0, 0}
   };
-
-  info->best_cost = UINT32_MAX;
-
-  // Select starting point from among merge candidates. These should
-  // include both mv_cand vectors and (0, 0).
-  select_starting_point(info, extra_mv);
-
-  // Check if we should stop search
-  if (info->state->encoder_control->cfg.me_early_termination &&
-    early_terminate(info))
-  {
-    return;
-  }
   
   // current motion vector
-  vector2d_t mv = { info->best_mv.x >> 2, info->best_mv.y >> 2 };
+  vector2d_t mv = { best_mv->x >> 2, best_mv->y >> 2 };
 
   // current best index
   enum diapos best_index = DIA_CENTER;
 
   // initial search of the points of the diamond
   for (int i = 0; i < 5; ++i) {
-    if (check_mv_cost(info, mv.x + diamondi.x, mv.y + diamondi.y)) {
+    if (check_mv_cost(info, mv.x + diamondi.x, mv.y + diamondi.y, best_cost, best_bits, best_mv)) {
       best_index = i;
     }
   }
@@ -883,7 +867,7 @@
       // this is where we came from so it's checked already
       if (i == from_dir) continue;
 
-      if (check_mv_cost(info, mv.x + diamondi.x, mv.y + diamondi.y)) {
+      if (check_mv_cost(info, mv.x + diamondi.x, mv.y + diamondi.y, best_cost, best_bits, best_mv)) {
         best_index = i;
         better_found = 1;
       }
@@ -905,12 +889,15 @@
 
 static void search_mv_full(inter_search_info_t *info,
                            int32_t search_range,
-                           vector2d_t extra_mv)
+                           vector2d_t extra_mv,
+                           double *best_cost,
+                           double* best_bits,
+                           vector2d_t *best_mv)
 {
   // Search around the 0-vector.
   for (int y = -search_range; y <= search_range; y++) {
     for (int x = -search_range; x <= search_range; x++) {
-      check_mv_cost(info, x, y);
+      check_mv_cost(info, x, y, best_cost, best_bits, best_mv);
     }
   }
 
@@ -922,7 +909,7 @@
   if (!mv_in_merge(info, extra_mv)) {
     for (int y = -search_range; y <= search_range; y++) {
       for (int x = -search_range; x <= search_range; x++) {
-        check_mv_cost(info, extra_mv.x + x, extra_mv.y + y);
+        check_mv_cost(info, extra_mv.x + x, extra_mv.y + y, best_cost, best_bits, best_mv);
       }
     }
   }
@@ -969,7 +956,7 @@
         }
         if (already_tested) continue;
 
-        check_mv_cost(info, x, y);
+        check_mv_cost(info, x, y, best_cost, best_bits, best_mv);
       }
     }
   }
@@ -982,7 +969,10 @@
  * Algoritm first searches 1/2-pel positions around integer mv and after best match is found,
  * refines the search by searching best 1/4-pel postion around best 1/2-pel position.
  */
-static void search_frac(inter_search_info_t *info)
+static void search_frac(inter_search_info_t *info,
+                        double *best_cost,
+                        double *best_bits,
+                        vector2d_t *best_mv)
 {
   // Map indexes to relative coordinates in the following way:
   // 5 3 6
@@ -995,13 +985,14 @@
   };
 
   // Set mv to pixel precision
-  vector2d_t mv = { info->best_mv.x >> 2, info->best_mv.y >> 2 };
+  vector2d_t mv = { best_mv->x >> 2, best_mv->y >> 2 };
 
-  unsigned best_cost = UINT32_MAX;
-  uint32_t best_bitcost = 0;
-  uint32_t bitcosts4 = { 0 };
+  double cost = MAX_DOUBLE;
+  double bitcost = 0;
+  double bitcosts4 = { 0 };
   unsigned best_index = 0;
 
+// Keep this as unsigned until SAD / SATD functions are updated
   unsigned costs4 = { 0 };
 
   ALIGNED(64) kvz_pixel filtered4LCU_LUMA_SIZE;
@@ -1067,12 +1058,12 @@
   costs0 += info->mvd_cost_func(state,
                                   mv.x, mv.y, 2,
                                   info->mv_cand,
-                                  info->merge_cand,
-                                  info->num_merge_cand,
+                                  NULL,
+                                  0,
                                   info->ref_idx,
                                   &bitcosts0);
-  best_cost = costs0;
-  best_bitcost = bitcosts0;
+  cost = costs0;
+  bitcost = bitcosts0;
   
   //Set mv to half-pixel precision
   mv.x *= 2;
@@ -1127,8 +1118,8 @@
             mv.y + patternj->y,
             mv_shift,
             info->mv_cand,
-            info->merge_cand,
-            info->num_merge_cand,
+            NULL,
+            0,
             info->ref_idx,
             &bitcostsj
         );
@@ -1136,9 +1127,9 @@
     }
 
     for (int j = 0; j < 4; ++j) {
-      if (within_tilej && costsj < best_cost) {
-        best_cost = costsj;
-        best_bitcost = bitcostsj;
+      if (within_tilej && costsj < cost) {
+        cost = costsj;
+        bitcost = bitcostsj;
         best_index = i + j;
       }
     }
@@ -1164,9 +1155,33 @@
     }
   }
 
-  info->best_mv = mv;
-  info->best_cost = best_cost;
-  info->best_bitcost = best_bitcost;
+  *best_mv = mv;
+  *best_cost = cost;
+  *best_bits = bitcost;
+}
+
+int kvz_get_skip_context(int x, int y, lcu_t* const lcu, cu_array_t* const cu_a) {
+  assert(!(lcu && cu_a));
+  int context = 0;
+  if(lcu) {
+    int x_local = SUB_SCU(x);
+    int y_local = SUB_SCU(y);
+    if (x) {
+      context += LCU_GET_CU_AT_PX(lcu, x_local - 1, y_local)->skipped;
+    }
+    if (y) {
+      context += LCU_GET_CU_AT_PX(lcu, x_local, y_local - 1)->skipped;
+    }
+  }
+  else {
+    if (x > 0) {
+      context += kvz_cu_array_at_const(cu_a, x - 1, y)->skipped;
+    }
+    if (y > 0) {
+      context += kvz_cu_array_at_const(cu_a, x, y - 1)->skipped;
+    }
+  }
+  return context;
 }
 
 /**
@@ -1214,46 +1229,37 @@
  */
 static void search_pu_inter_ref(inter_search_info_t *info,
   int depth,
-  lcu_t *lcu, cu_info_t *cur_cu,
-  double *inter_cost,
-  uint32_t *inter_bitcost,
-  double *best_LX_cost,
-  cu_info_t *unipred_LX)
+  lcu_t *lcu,
+  cu_info_t *cur_cu,
+  unit_stats_map_t *amvp)
 {
   const kvz_config *cfg = &info->state->encoder_control->cfg;
 
-  // which list, L0 or L1, ref_idx is in and in what index
-  int8_t ref_list = -1;
-  // the index of the ref_idx in L0 or L1 list
-  int8_t LX_idx;
-  // max value of LX_idx plus one
-  const int8_t LX_IDX_MAX_PLUS_1 = MAX(info->state->frame->ref_LX_size0,
-    info->state->frame->ref_LX_size1);
-
-  for (LX_idx = 0; LX_idx < LX_IDX_MAX_PLUS_1; LX_idx++)
-  {
-    // check if ref_idx is in L0
-    if (LX_idx < info->state->frame->ref_LX_size0 &&
-      info->state->frame->ref_LX0LX_idx == info->ref_idx) {
-      ref_list = 0;
-      break;
-    }
-
-    // check if ref_idx is in L1
-    if (LX_idx < info->state->frame->ref_LX_size1 &&
-      info->state->frame->ref_LX1LX_idx == info->ref_idx) {
-      ref_list = 1;
-      break;
+  // Reference picture might be in both lists
+  bool ref_list_active2 = { false, false };
+  // Reference picture indices in L0 and L1 lists
+  int8_t ref_list_idx2 = { -1, -1 };
+
+  // Check if ref picture is present in the lists
+  for (int ref_list = 0; ref_list < 2; ++ref_list) {
+    for (int i = 0; i < info->state->frame->ref_LX_sizeref_list; ++i) {
+      if (info->state->frame->ref_LXref_listi == info->ref_idx) {
+        ref_list_activeref_list = true;
+        ref_list_idxref_list = i;
+        break;
+      }
     }
   }
-  // ref_idx has to be found in either L0 or L1
-  assert(LX_idx < LX_IDX_MAX_PLUS_1);
 
-  // store temp values to be stored back later
-  int8_t temp_ref_idx = cur_cu->inter.mv_refref_list;
+  // Must find at least one reference picture
+  assert(ref_list_active0 || ref_list_active1);
+
+  // Does not matter which list is used, if in both.
+  int ref_list = ref_list_active0 ? 0 : 1;
+  int LX_idx = ref_list_idxref_list;
 
   // Get MV candidates
-  cur_cu->inter.mv_refref_list = LX_idx;
+  cur_cu->inter.mv_refref_list = ref_list_idxref_list;
 
   kvz_inter_get_mv_cand(info->state,
     info->origin.x,
@@ -1265,10 +1271,7 @@
     lcu,
     ref_list);
 
-  // store old values back
-  cur_cu->inter.mv_refref_list = temp_ref_idx;
-
-  vector2d_t mv = { 0, 0 };
+  vector2d_t best_mv = { 0, 0 };
 
   // Take starting point for MV search from previous frame.
   // When temporal motion vector candidates are added, there is probably
@@ -1282,8 +1285,7 @@
     if (ref_cu->inter.mv_dir & 1) {
       mv_previous.x = ref_cu->inter.mv00;
       mv_previous.y = ref_cu->inter.mv01;
-    }
-    else {
+    } else {
       mv_previous.x = ref_cu->inter.mv10;
       mv_previous.y = ref_cu->inter.mv11;
     }
@@ -1316,16 +1318,16 @@
         info->state->frame->ref->pocsneighbor_poc_index,
         info->state->frame->ref->imagesneighbor_poc_index->ref_pocs
           info->state->frame->ref->ref_LXsneighbor_poc_index
-          col_list
+            col_list
           ref_cu->inter.mv_refcol_list
         ,
         &mv_previous
-      );
+          );
     }
 
     // Check if the mv is valid after scaling
     if (fracmv_within_tile(info, mv_previous.x, mv_previous.y)) {
-      mv = mv_previous;
+      best_mv = mv_previous;
     }
   }
 
@@ -1338,102 +1340,90 @@
     default: break;
   }
 
-  info->best_cost = UINT32_MAX;
-
-  switch (cfg->ime_algorithm) {
-    case KVZ_IME_TZ:
-      tz_search(info, mv);
-      break;
-
-    case KVZ_IME_FULL64:
-    case KVZ_IME_FULL32:
-    case KVZ_IME_FULL16:
-    case KVZ_IME_FULL8:
-    case KVZ_IME_FULL:
-      search_mv_full(info, search_range, mv);
-      break;
+  double best_cost = MAX_DOUBLE;
+  double best_bits = MAX_INT;
 
-    case KVZ_IME_DIA:
-      diamond_search(info, mv, info->state->encoder_control->cfg.me_max_steps);
-      break;
+  // Select starting point from among merge candidates. These should
+  // include both mv_cand vectors and (0, 0).
+  select_starting_point(info, best_mv, &best_cost, &best_bits, &best_mv);
+  bool skip_me = early_terminate(info, &best_cost, &best_bits, &best_mv);
+      
+  if (!(info->state->encoder_control->cfg.me_early_termination && skip_me)) {
+
+    switch (cfg->ime_algorithm) {
+      case KVZ_IME_TZ:
+        tz_search(info, best_mv, &best_cost, &best_bits, &best_mv);
+        break;
 
-    default:
-      hexagon_search(info, mv, info->state->encoder_control->cfg.me_max_steps);
-      break;
-  }
+      case KVZ_IME_FULL64:
+      case KVZ_IME_FULL32:
+      case KVZ_IME_FULL16:
+      case KVZ_IME_FULL8:
+      case KVZ_IME_FULL:
+        search_mv_full(info, search_range, best_mv, &best_cost, &best_bits, &best_mv);
+        break;
 
-  if (cfg->fme_level > 0 && info->best_cost < *inter_cost) {
-    search_frac(info);
+      case KVZ_IME_DIA:
+        diamond_search(info, best_mv, info->state->encoder_control->cfg.me_max_steps,
+                       &best_cost, &best_bits, &best_mv);
+        break;
 
-  } else if (info->best_cost < UINT32_MAX) {
-    // Recalculate inter cost with SATD.
-    info->best_cost = kvz_image_calc_satd(
-        info->state->tile->frame->source,
-        info->ref,
-        info->origin.x,
-        info->origin.y,
-        info->state->tile->offset_x + info->origin.x + (info->best_mv.x >> 2),
-        info->state->tile->offset_y + info->origin.y + (info->best_mv.y >> 2),
-        info->width,
-        info->height);
-    info->best_cost += info->best_bitcost * (int)(info->state->lambda_sqrt + 0.5);
-  }
-
-  mv = info->best_mv;
-
-  int merged = 0;
-  int merge_idx = 0;
-  // Check every candidate to find a match
-  for (merge_idx = 0; merge_idx < info->num_merge_cand; merge_idx++) {
-    if (info->merge_candmerge_idx.dir != 3 &&
-        info->merge_candmerge_idx.mvinfo->merge_candmerge_idx.dir - 10 == mv.x &&
-        info->merge_candmerge_idx.mvinfo->merge_candmerge_idx.dir - 11 == mv.y &&
-        (uint32_t)info->state->frame->ref_LXinfo->merge_candmerge_idx.dir - 1
-        info->merge_candmerge_idx.refinfo->merge_candmerge_idx.dir - 1 == info->ref_idx)
-    {
-      merged = 1;
-      break;
+      default:
+        hexagon_search(info, best_mv, info->state->encoder_control->cfg.me_max_steps,
+                       &best_cost, &best_bits, &best_mv);
+        break;
     }
   }
 
-  // Only check when candidates are different
-  int cu_mv_cand = 0;
-  if (!merged) {
-    cu_mv_cand =
-      select_mv_cand(info->state, info->mv_cand, mv.x, mv.y, NULL);
+  if (cfg->fme_level == 0 && best_cost < MAX_DOUBLE) {
+    // Recalculate inter cost with SATD.
+    best_cost = kvz_image_calc_satd(
+      info->state->tile->frame->source,
+      info->ref,
+      info->origin.x,
+      info->origin.y,
+      info->state->tile->offset_x + info->origin.x + (best_mv.x >> 2),
+      info->state->tile->offset_y + info->origin.y + (best_mv.y >> 2),
+      info->width,
+      info->height);
+    best_cost += best_bits * info->state->lambda_sqrt;
   }
 
-  if (info->best_cost < *inter_cost) {
-    // Map reference index to L0/L1 pictures
-    cur_cu->inter.mv_dir = ref_list+1;
-    uint8_t mv_ref_coded = LX_idx;
-
-    cur_cu->merged                  = merged;
-    cur_cu->merge_idx               = merge_idx;
-    cur_cu->inter.mv_refref_list  = LX_idx;
-    cur_cu->inter.mvref_list0   = (int16_t)mv.x;
-    cur_cu->inter.mvref_list1   = (int16_t)mv.y;
+  double LX_cost2 = { best_cost, best_cost };
+  double LX_bits2 = { best_bits, best_bits };
 
-    CU_SET_MV_CAND(cur_cu, ref_list, cu_mv_cand);
+  // Compute costs and add entries for both lists, if necessary
+  for (; ref_list < 2 && ref_list_activeref_list; ++ref_list) {
 
-    *inter_cost = info->best_cost;
-    *inter_bitcost = info->best_bitcost + cur_cu->inter.mv_dir - 1 + mv_ref_coded;
-  }
+    LX_idx = ref_list_idxref_list;
+    uint8_t mv_ref_coded = LX_idx;
+    int cu_mv_cand = select_mv_cand(info->state, info->mv_cand, best_mv.x, best_mv.y, NULL);
+    const int extra_bits = ref_list + mv_ref_coded; // TODO: check if mv_dir bits are missing
+    LX_costref_list += extra_bits * info->state->lambda_sqrt;
+    LX_bitsref_list += extra_bits;
 
+    // Update best unipreds for biprediction
+    bool valid_mv = fracmv_within_tile(info, best_mv.x, best_mv.y);
+    if (valid_mv && best_cost < MAX_DOUBLE) {
 
-  // Update best unipreds for biprediction
-  if (info->best_cost < best_LX_costref_list) {
-    bool valid_mv = fracmv_within_tile(info, mv.x, mv.y);
-    if (valid_mv) {
       // Map reference index to L0/L1 pictures
-      unipred_LXref_list.inter.mv_dir = ref_list + 1;
-      unipred_LXref_list.inter.mv_refref_list = LX_idx;
-      unipred_LXref_list.inter.mvref_list0 = (int16_t)mv.x;
-      unipred_LXref_list.inter.mvref_list1 = (int16_t)mv.y;
-
-      CU_SET_MV_CAND(&unipred_LXref_list, ref_list, cu_mv_cand);
-
-      best_LX_costref_list = info->best_cost;
+      unit_stats_map_t *cur_map = &amvpref_list;
+      int entry = cur_map->size;
+      cu_info_t *unipred_pu = &cur_map->unitentry;
+      *unipred_pu = *cur_cu;
+      unipred_pu->type = CU_INTER;
+      unipred_pu->merged  = false;
+      unipred_pu->skipped = false;
+      unipred_pu->inter.mv_dir = ref_list + 1;
+      unipred_pu->inter.mv_refref_list = LX_idx;
+      unipred_pu->inter.mvref_list0 = (int16_t)best_mv.x;
+      unipred_pu->inter.mvref_list1 = (int16_t)best_mv.y;
+      CU_SET_MV_CAND(unipred_pu, ref_list, cu_mv_cand);
+
+      cur_map->costentry = best_cost;
+      cur_map->bitsentry = best_bits;
+      cur_map->keysentry = entry;
+      cur_map->size++;
     }
   }
 }
@@ -1444,9 +1434,8 @@
  */
 static void search_pu_inter_bipred(inter_search_info_t *info,
                                    int depth,
-                                   lcu_t *lcu, cu_info_t *cur_cu,
-                                   double *inter_cost,
-                                   uint32_t *inter_bitcost)
+                                   lcu_t *lcu,
+                                   unit_stats_map_t *amvp_bipred)
 {
   const image_list_t *const ref = info->state->frame->ref;
   uint8_t (*ref_LX)16 = info->state->frame->ref_LX;
@@ -1478,11 +1467,26 @@
       continue;
     }
 
-    int16_t mv22;
+    cu_info_t *bipred_pu = &amvp_bipred->unitamvp_bipred->size;
+    *bipred_pu = *LCU_GET_CU_AT_PX(lcu, SUB_SCU(x), SUB_SCU(y));
+
+    bipred_pu->inter.mv_dir = 3;
+
+    bipred_pu->inter.mv_ref0 = merge_candi.ref0;
+    bipred_pu->inter.mv_ref1 = merge_candj.ref1;
+
+    int16_t(*mv)2 = bipred_pu->inter.mv;
     mv00 = merge_candi.mv00;
     mv01 = merge_candi.mv01;
     mv10 = merge_candj.mv10;
     mv11 = merge_candj.mv11;
+    
+    bipred_pu->merged  = false;
+    bipred_pu->skipped = false;
+
+    for (int reflist = 0; reflist < 2; reflist++) {
+      kvz_inter_get_mv_cand(info->state, x, y, width, height, info->mv_cand, bipred_pu, lcu, reflist);
+    }
 
     // Don't try merge candidates that don't satisfy mv constraints.
     if (!fracmv_within_tile(info, mv00, mv01) ||
@@ -1504,10 +1508,10 @@
 
     const kvz_pixel *rec = &lcu->rec.ySUB_SCU(y) * LCU_WIDTH + SUB_SCU(x);
     const kvz_pixel *src = &frame->source->yx + y * frame->source->width;
-    uint32_t cost =
+    double cost =
       kvz_satd_any_size(width, height, rec, LCU_WIDTH, src, frame->source->width);
 
-    uint32_t bitcost2 = { 0, 0 };
+    double bitcost2 = { 0, 0 };
 
     cost += info->mvd_cost_func(info->state,
                                merge_candi.mv00,
@@ -1529,50 +1533,25 @@
       merge_candj.ref1
     };
     const int extra_bits = mv_ref_coded0 + mv_ref_coded1 + 2 /* mv dir cost */;
-    cost += info->state->lambda_sqrt * extra_bits + 0.5;
-
-    if (cost < *inter_cost) {
-      cur_cu->inter.mv_dir = 3;
-
-      cur_cu->inter.mv_ref0 = merge_candi.ref0;
-      cur_cu->inter.mv_ref1 = merge_candj.ref1;
-
-      cur_cu->inter.mv00 = merge_candi.mv00;
-      cur_cu->inter.mv01 = merge_candi.mv01;
-      cur_cu->inter.mv10 = merge_candj.mv10;
-      cur_cu->inter.mv11 = merge_candj.mv11;
-      cur_cu->merged = 0;
-
-      // Check every candidate to find a match
-      for (int merge_idx = 0; merge_idx < info->num_merge_cand; merge_idx++) {
-        if (merge_candmerge_idx.mv00 == cur_cu->inter.mv00 &&
-            merge_candmerge_idx.mv01 == cur_cu->inter.mv01 &&
-            merge_candmerge_idx.mv10 == cur_cu->inter.mv10 &&
-            merge_candmerge_idx.mv11 == cur_cu->inter.mv11 &&
-            merge_candmerge_idx.ref0 == cur_cu->inter.mv_ref0 &&
-            merge_candmerge_idx.ref1 == cur_cu->inter.mv_ref1)
-        {
-          cur_cu->merged = 1;
-          cur_cu->merge_idx = merge_idx;
-          break;
-        }
-      }
+    cost += info->state->lambda_sqrt * extra_bits;
+
+    // Each motion vector has its own candidate
+    for (int reflist = 0; reflist < 2; reflist++) {
+      int cu_mv_cand = select_mv_cand(
+        info->state,
+        info->mv_cand,
+        bipred_pu->inter.mvreflist0,
+        bipred_pu->inter.mvreflist1,
+        NULL);
+      CU_SET_MV_CAND(bipred_pu, reflist, cu_mv_cand);
+    }
 
-      // Each motion vector has its own candidate
-      for (int reflist = 0; reflist < 2; reflist++) {
-        kvz_inter_get_mv_cand(info->state, x, y, width, height, info->mv_cand, cur_cu, lcu, reflist);
-        int cu_mv_cand = select_mv_cand(
-            info->state,
-            info->mv_cand,
-            cur_cu->inter.mvreflist0,
-            cur_cu->inter.mvreflist1,
-            NULL);
-        CU_SET_MV_CAND(cur_cu, reflist, cu_mv_cand);
-      }
+    bipred_pu->type = CU_INTER;
 
-      *inter_cost = cost;
-      *inter_bitcost = bitcost0 + bitcost1 + extra_bits;
-    }
+    amvp_bipred->costamvp_bipred->size = cost;
+    amvp_bipred->bitsamvp_bipred->size = bitcost0 + bitcost1 + extra_bits;
+    amvp_bipred->keysamvp_bipred->size = amvp_bipred->size;
+    amvp_bipred->size++;
   }
 }
 
@@ -1586,14 +1565,14 @@
  *
  * \return                Does an identical candidate exist in list
  */
-static bool merge_candidate_in_list(inter_merge_cand_t * all_cands,
-                                    inter_merge_cand_t * cand_to_add,
-                                    int8_t * added_idx_list,
-                                    int list_size)
+static bool merge_candidate_in_list(inter_merge_cand_t *all_cands,
+                                    inter_merge_cand_t *cand_to_add,
+                                    unit_stats_map_t *merge)
 {
   bool found = false;
-  for (int i = 0; i < list_size && !found; ++i) {
-    inter_merge_cand_t * list_cand = &all_candsadded_idx_listi;
+  for (int i = 0; i < merge->size && !found; ++i) {
+    int key = merge->keysi;
+    inter_merge_cand_t * list_cand = &all_candsmerge->unitkey.merge_idx;
 
     found = cand_to_add->dir == list_cand->dir &&
         cand_to_add->ref0 == list_cand->ref0 &&
@@ -1608,7 +1587,7 @@
 }
 
 /**
- * \brief Update PU to have best modes at this depth.
+ * \brief Collect PU parameters and costs at this depth.
  *
  * \param state       encoder state
  * \param x_cu        x-coordinate of the containing CU
@@ -1618,28 +1597,26 @@
  * \param i_pu        index of the PU in the CU
  * \param lcu         containing LCU
  *
- * \param inter_cost    Return inter cost of the best mode
- * \param inter_bitcost Return inter bitcost of the best mode
+ * \param amvp        Return searched AMVP PUs sorted by costs
+ * \param merge       Return searched Merge PUs sorted by costs
  */
 static void search_pu_inter(encoder_state_t * const state,
-                            int x_cu, int y_cu,
-                            int depth,
-                            part_mode_t part_mode,
-                            int i_pu,
-                            lcu_t *lcu,
-                            double *inter_cost,
-                            uint32_t *inter_bitcost)
+  int x_cu, int y_cu,
+  int depth,
+  part_mode_t part_mode,
+  int i_pu,
+  lcu_t *lcu,
+  unit_stats_map_t *amvp,
+  unit_stats_map_t *merge,
+  inter_search_info_t *info)
 {
-  *inter_cost = MAX_INT;
-  *inter_bitcost = MAX_INT;
-
   const kvz_config *cfg = &state->encoder_control->cfg;
   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);
+  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.
@@ -1648,127 +1625,161 @@
   // 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);
-
-  inter_search_info_t info = {
-    .state          = state,
-    .pic            = frame->source,
-    .origin         = { x, y },
-    .width          = width,
-    .height         = height,
-    .mvd_cost_func  = cfg->mv_rdo ? kvz_calc_mvd_cost_cabac : calc_mvd_cost,
-    .optimized_sad  = kvz_get_optimized_sad(width),
-  };
+  const int x_local = SUB_SCU(x);
+  const int y_local = SUB_SCU(y);
+  cu_info_t *cur_pu = LCU_GET_CU_AT_PX(lcu, x_local, y_local);
+  cur_pu->type = CU_NOTSET;
+  cur_pu->part_size = part_mode;
+  cur_pu->depth = depth;
+  cur_pu->qp = state->qp;
+
+  // Default to candidate 0
+  CU_SET_MV_CAND(cur_pu, 0, 0);
+  CU_SET_MV_CAND(cur_pu, 1, 0);
+
+  FILL(*info, 0);
+
+  info->state          = state;
+  info->pic            = frame->source;
+  info->origin.x       = x;
+  info->origin.y       = y;
+  info->width          = width;
+  info->height         = height;
+  info->mvd_cost_func  = cfg->mv_rdo ? kvz_calc_mvd_cost_cabac : calc_mvd_cost;
+  info->optimized_sad  = kvz_get_optimized_sad(width);
 
   // Search for merge mode candidates
-  info.num_merge_cand = kvz_inter_get_merge_cand(
+  info->num_merge_cand = kvz_inter_get_merge_cand(
       state,
       x, y,
       width, height,
       merge_a1, merge_b1,
-      info.merge_cand,
+      info->merge_cand,
       lcu
   );
 
-  // Default to candidate 0
-  CU_SET_MV_CAND(cur_cu, 0, 0);
-  CU_SET_MV_CAND(cur_cu, 1, 0);
-
   // Merge Analysis starts here
-  int8_t mrg_candsMRG_MAX_NUM_CANDS;
-  double mrg_costsMRG_MAX_NUM_CANDS;
+  merge->size = 0;
   for (int i = 0; i < MRG_MAX_NUM_CANDS; ++i) {
-    mrg_candsi = -1;
-    mrg_costsi = MAX_DOUBLE;
+    merge->keysi = -1;
+    merge->costi = MAX_DOUBLE;
   }
 
-  int num_rdo_cands = 0;
-
+  const double merge_flag_cost = CTX_ENTROPY_FBITS(&state->search_cabac.ctx.cu_merge_flag_ext_model, 1);
+#ifdef COMPLETE_PRED_MODE_BITS
+  // Technically counting these bits would be correct, however counting
+  // them universally degrades quality so this block is disabled by default
+  const double no_skip_flag = CTX_ENTROPY_FBITS(&state->search_cabac.ctx.cu_skip_flag_modelkvz_get_skip_context(x, y, lcu, NULL), 0);
+#else
+  const double no_skip_flag = 0;
+#endif
   // Check motion vector constraints and perform rough search
-  for (int merge_idx = 0; merge_idx < info.num_merge_cand; ++merge_idx) {
+  for (int merge_idx = 0; merge_idx < info->num_merge_cand; ++merge_idx) {
 
-    inter_merge_cand_t *cur_cand = &info.merge_candmerge_idx;
-    cur_cu->inter.mv_dir = cur_cand->dir;
-    cur_cu->inter.mv_ref0 = cur_cand->ref0;
-    cur_cu->inter.mv_ref1 = cur_cand->ref1;
-    cur_cu->inter.mv00 = cur_cand->mv00;
-    cur_cu->inter.mv01 = cur_cand->mv01;
-    cur_cu->inter.mv10 = cur_cand->mv10;
-    cur_cu->inter.mv11 = cur_cand->mv11;
+    inter_merge_cand_t *cur_cand = &info->merge_candmerge_idx;
+    cur_pu->inter.mv_dir = cur_cand->dir;
+    cur_pu->inter.mv_ref0 = cur_cand->ref0;
+    cur_pu->inter.mv_ref1 = cur_cand->ref1;
+    cur_pu->inter.mv00 = cur_cand->mv00;
+    cur_pu->inter.mv01 = cur_cand->mv01;
+    cur_pu->inter.mv10 = cur_cand->mv10;
+    cur_pu->inter.mv11 = cur_cand->mv11;
 
     // If bipred is not enabled, do not try candidates with mv_dir == 3.
     // Bipred is also forbidden for 4x8 and 8x4 blocks by the standard. 
-    if (cur_cu->inter.mv_dir == 3 && !state->encoder_control->cfg.bipred) continue;
-    if (cur_cu->inter.mv_dir == 3 && !(width + height > 12)) continue;
+    if (cur_pu->inter.mv_dir == 3 && !state->encoder_control->cfg.bipred) continue;
+    if (cur_pu->inter.mv_dir == 3 && !(width + height > 12)) continue;
 
-    bool is_duplicate = merge_candidate_in_list(info.merge_cand, cur_cand,
-      mrg_cands, 
-      num_rdo_cands);
+    bool is_duplicate = merge_candidate_in_list(info->merge_cand, cur_cand, merge);
 
     // Don't try merge candidates that don't satisfy mv constraints.
     // Don't add duplicates to list
-    if (!fracmv_within_tile(&info, cur_cu->inter.mv00, cur_cu->inter.mv01) ||
-        !fracmv_within_tile(&info, cur_cu->inter.mv10, cur_cu->inter.mv11) ||
+    bool active_L0 = cur_pu->inter.mv_dir & 1;
+    bool active_L1 = cur_pu->inter.mv_dir & 2;
+    if ((active_L0 && !fracmv_within_tile(info, cur_pu->inter.mv00, cur_pu->inter.mv01)) ||
+        (active_L1 && !fracmv_within_tile(info, cur_pu->inter.mv10, cur_pu->inter.mv11)) ||
         is_duplicate)
     {
       continue;
     }
 
     kvz_inter_pred_pu(state, lcu, x_cu, y_cu, width_cu, true, false, i_pu);
-    mrg_costsnum_rdo_cands = kvz_satd_any_size(width, height,
-      lcu->rec.y + y_local * LCU_WIDTH + x_local, LCU_WIDTH,
-      lcu->ref.y + y_local * LCU_WIDTH + x_local, LCU_WIDTH);
-    
+    merge->unitmerge->size = *cur_pu;
+    merge->unitmerge->size.type = CU_INTER;
+    merge->unitmerge->size.merge_idx = merge_idx;
+    merge->unitmerge->size.merged = true;
+    merge->unitmerge->size.skipped = false;
+
+    double bits = merge_flag_cost + merge_idx + CTX_ENTROPY_FBITS(&(state->search_cabac.ctx.cu_merge_idx_ext_model), merge_idx != 0);
+    if(state->encoder_control->cfg.rdo >= 3 && cur_pu->part_size == SIZE_2Nx2N) {
+      kvz_cu_cost_inter_rd2(state, x, y, depth, &merge->unitmerge->size, lcu, &merge->costmerge->size, &bits);
+    }
+    else {
+      merge->costmerge->size = kvz_satd_any_size(width, height,
+        lcu->rec.y + y_local * LCU_WIDTH + x_local, LCU_WIDTH,
+        lcu->ref.y + y_local * LCU_WIDTH + x_local, LCU_WIDTH);
+      bits += no_skip_flag;
+      merge->costmerge->size += bits * info->state->lambda_sqrt;
+    }
     // Add cost of coding the merge index
-    mrg_costsnum_rdo_cands += merge_idx * info.state->lambda_sqrt;
+    merge->bitsmerge->size = bits;
+    merge->keysmerge->size = merge->size;
+
 
-    mrg_candsnum_rdo_cands = merge_idx;
-    num_rdo_cands++;
+    merge->size++;
   }
 
-  // Sort candidates by cost
-  kvz_sort_modes(mrg_cands, mrg_costs, num_rdo_cands);
+  assert(merge->size <= MAX_UNIT_STATS_MAP_SIZE);
+  kvz_sort_keys_by_cost(merge);
 
-  // Limit by availability
-  // TODO: Do not limit to just 1
-  num_rdo_cands = MIN(1, num_rdo_cands);
+  // Try early skip decision on just one merge candidate if available
+  int num_rdo_cands = MIN(1, merge->size);
     
   // Early Skip Mode Decision
   bool has_chroma = state->encoder_control->chroma_format != KVZ_CSP_400;
-  if (cfg->early_skip && cur_cu->part_size == SIZE_2Nx2N) {
-    for (int merge_rdo_idx = 0; merge_rdo_idx < num_rdo_cands; ++merge_rdo_idx) {
-
-      // Reconstruct blocks with merge candidate.
-      // Check luma CBF. Then, check chroma CBFs if luma CBF is not set
-      // and chroma exists.
-      // Early terminate if merge candidate with zero CBF is found.
-      int merge_idx = mrg_candsmerge_rdo_idx;
-      cur_cu->inter.mv_dir = info.merge_candmerge_idx.dir;
-      cur_cu->inter.mv_ref0 = info.merge_candmerge_idx.ref0;
-      cur_cu->inter.mv_ref1 = info.merge_candmerge_idx.ref1;
-      cur_cu->inter.mv00 = info.merge_candmerge_idx.mv00;
-      cur_cu->inter.mv01 = info.merge_candmerge_idx.mv01;
-      cur_cu->inter.mv10 = info.merge_candmerge_idx.mv10;
-      cur_cu->inter.mv11 = info.merge_candmerge_idx.mv11;
-      kvz_lcu_fill_trdepth(lcu, x, y, depth, MAX(1, depth));
-      kvz_inter_recon_cu(state, lcu, x, y, width, true, false);
-      kvz_quantize_lcu_residual(state, true, false, x, y, depth, cur_cu, lcu, true);
-
-      if (cbf_is_set(cur_cu->cbf, depth, COLOR_Y)) {
-        continue;
+  if (cfg->early_skip && cur_pu->part_size == SIZE_2Nx2N) {
+    for (int merge_key = 0; merge_key < num_rdo_cands; ++merge_key) {
+      if(cfg->rdo >= 3 && merge->unitmerge->keysmerge_key.skipped) {
+        merge->size = 1;
+        merge->bits0 = merge->bitsmerge->keysmerge_key;
+        merge->cost0 = merge->costmerge->keysmerge_key;
+        merge->unit0 = merge->unitmerge->keysmerge_key;
+        merge->keys0 = 0;
       }
-      else if (has_chroma) {
-        kvz_inter_recon_cu(state, lcu, x, y, width, false, has_chroma);
-        kvz_quantize_lcu_residual(state, false, has_chroma, x, y, depth, cur_cu, lcu, true);
-        if (!cbf_is_set_any(cur_cu->cbf, depth)) {
-          cur_cu->type = CU_INTER;
-          cur_cu->merge_idx = merge_idx;
-          cur_cu->skipped = true;
-          *inter_cost = 0.0;  // TODO: Check this
-          *inter_bitcost = merge_idx; // TODO: Check this
-          return;
+      else if(cfg->rdo < 3) {
+        // Reconstruct blocks with merge candidate.
+        // Check luma CBF. Then, check chroma CBFs if luma CBF is not set
+        // and chroma exists.
+        // Early terminate if merge candidate with zero CBF is found.
+        int merge_idx           = merge->unitmerge->keysmerge_key.merge_idx;
+        cur_pu->inter.mv_dir    = info->merge_candmerge_idx.dir;
+        cur_pu->inter.mv_ref0 = info->merge_candmerge_idx.ref0;
+        cur_pu->inter.mv_ref1 = info->merge_candmerge_idx.ref1;
+        cur_pu->inter.mv00  = info->merge_candmerge_idx.mv00;
+        cur_pu->inter.mv01  = info->merge_candmerge_idx.mv01;
+        cur_pu->inter.mv10  = info->merge_candmerge_idx.mv10;
+        cur_pu->inter.mv11  = info->merge_candmerge_idx.mv11;
+        kvz_lcu_fill_trdepth(lcu, x, y, depth, MAX(1, depth));
+        kvz_inter_recon_cu(state, lcu, x, y, width, true, false);
+        kvz_quantize_lcu_residual(state, true, false, x, y, depth, cur_pu, lcu, true);
+
+        if (cbf_is_set(cur_pu->cbf, depth, COLOR_Y)) {
+          continue;
+        }
+        else if (has_chroma) {
+          kvz_inter_recon_cu(state, lcu, x, y, width, false, has_chroma);
+          kvz_quantize_lcu_residual(state, false, has_chroma, x, y, depth, cur_pu, lcu, true);
+          if (!cbf_is_set_any(cur_pu->cbf, depth)) {
+            cur_pu->type = CU_INTER;
+            cur_pu->merge_idx = merge_idx;
+            cur_pu->skipped = true;
+
+            merge->size = 1;
+            merge->cost0 = 0.0; // TODO: Check this
+            merge->bits0 = merge_idx; // TODO: Check this
+            merge->unit0 = *cur_pu;
+            return;
+          }
         }
       }
     }
@@ -1776,16 +1787,139 @@
 
   // AMVP search starts here
 
-  // Store unipred information of L0 and L1 for biprediction
-  // Best cost will be left at MAX_DOUBLE if no valid CU is found
-  double best_cost_LX2 = { MAX_DOUBLE, MAX_DOUBLE };
-  cu_info_t unipreds2;
+  amvp0.size = 0;
+  amvp1.size = 0;
+  amvp2.size = 0;
+
+  for (int mv_dir = 1; mv_dir < 4; ++mv_dir) {
+    for (int i = 0; i < state->frame->ref->used_size; ++i) {
+      amvpmv_dir - 1.costi = MAX_DOUBLE;
+    }
+  }
 
   for (int ref_idx = 0; ref_idx < state->frame->ref->used_size; ref_idx++) {
-    info.ref_idx = ref_idx;
-    info.ref = state->frame->ref->imagesref_idx;
+    info->ref_idx = ref_idx;
+    info->ref = state->frame->ref->imagesref_idx;
+
+    search_pu_inter_ref(info, depth, lcu, cur_pu, amvp);
+  }
+
+  assert(amvp0.size <= MAX_UNIT_STATS_MAP_SIZE);
+  assert(amvp1.size <= MAX_UNIT_STATS_MAP_SIZE);
+  kvz_sort_keys_by_cost(&amvp0);
+  kvz_sort_keys_by_cost(&amvp1);
+
+  int best_keys2 = { 
+    amvp0.size > 0 ? amvp0.keys0 : 0, 
+    amvp1.size > 0 ? amvp1.keys0 : 0
+  };
+
+  cu_info_t *best_unipred2 = {
+    &amvp0.unitbest_keys0,
+    &amvp1.unitbest_keys1
+  };
+
+  // Prevent using the same ref picture with both lists.
+  // TODO: allow searching two MVs from the same reference picture.
+  if (cfg->bipred && amvp0.size > 0 && amvp1.size > 0) {
+
+    uint8_t(*ref_LX)16 = info->state->frame->ref_LX;
 
-    search_pu_inter_ref(&info, depth, lcu, cur_cu, inter_cost, inter_bitcost, best_cost_LX, unipreds);
+    int L0_idx = best_unipred0->inter.mv_ref0;
+    int L1_idx = best_unipred1->inter.mv_ref1;
+    
+    int L0_ref_idx = ref_LX0L0_idx;
+    int L1_ref_idx = ref_LX1L1_idx;
+
+    if (L0_ref_idx == L1_ref_idx) {
+      // Invalidate the other based the list that has the 2nd best PU
+      double L0_2nd_cost = amvp0.size > 1 ? amvp0.costamvp0.keys1 : MAX_DOUBLE;
+      double L1_2nd_cost = amvp1.size > 1 ? amvp1.costamvp1.keys1 : MAX_DOUBLE;
+      int list = (L0_2nd_cost <= L1_2nd_cost) ? 1 : 0;
+      amvplist.costbest_keyslist = MAX_DOUBLE;
+      kvz_sort_keys_by_cost(&amvplist);
+      amvplist.size--;
+      best_keyslist    =  amvplist.keys0;
+      best_unipredlist = &amvplist.unitbest_keyslist;
+    }
+  }
+
+  // Fractional-pixel motion estimation.
+  // Refine the best PUs so far from both lists, if available.
+  for (int list = 0; list < 2; ++list) {
+
+    // TODO: make configurable
+    int n_best = MIN(state->encoder_control->cfg.rdo >= 4 ? 2 : 1, amvplist.size);
+    if (cfg->fme_level > 0) {
+
+      for (int i = 0; i < n_best; ++i) {
+
+        int key = amvplist.keysi;
+        cu_info_t *unipred_pu = &amvplist.unitkey;
+
+        // Find the reference picture
+        const image_list_t *const ref = info->state->frame->ref;
+        uint8_t(*ref_LX)16 = info->state->frame->ref_LX;
+
+        int LX_idx = unipred_pu->inter.mv_reflist;
+        info->ref_idx = ref_LXlistLX_idx;
+        info->ref = ref->imagesinfo->ref_idx;
+
+        kvz_inter_get_mv_cand(info->state,
+          info->origin.x,
+          info->origin.y,
+          info->width,
+          info->height,
+          info->mv_cand,
+          unipred_pu,
+          lcu,
+          list);
+
+        double     frac_cost = MAX_DOUBLE;
+        double   frac_bits = MAX_INT;
+        vector2d_t frac_mv = { unipred_pu->inter.mvlist0, unipred_pu->inter.mvlist1 };
+
+        search_frac(info, &frac_cost, &frac_bits, &frac_mv);
+
+        uint8_t mv_ref_coded = LX_idx;
+        int cu_mv_cand = select_mv_cand(info->state, info->mv_cand, frac_mv.x, frac_mv.y, NULL);
+        const int extra_bits = list + mv_ref_coded; // TODO: check if mv_dir bits are missing
+        frac_cost += extra_bits * info->state->lambda_sqrt;
+        frac_bits += extra_bits;
+
+        bool valid_mv = fracmv_within_tile(info, frac_mv.x, frac_mv.y);
+        if (valid_mv) {
+
+          unipred_pu->inter.mvlist0 = frac_mv.x;
+          unipred_pu->inter.mvlist1 = frac_mv.y;
+          CU_SET_MV_CAND(unipred_pu, list, cu_mv_cand);
+
+          if (state->encoder_control->cfg.rdo >= 3 && cur_pu->part_size == SIZE_2Nx2N) {
+            kvz_cu_cost_inter_rd2(state, x, y, depth, unipred_pu, lcu, &frac_cost, &frac_bits);
+          }
+
+          amvplist.costkey = frac_cost;
+          amvplist.bitskey = frac_bits;
+        }
+      }
+
+      // Invalidate PUs with SAD-based costs. (FME not performed).
+      // TODO: Recalculate SAD costs with SATD for further processing.
+      for (int i = n_best; i < amvplist.size; ++i) {
+        int key = amvplist.keysi;
+        amvplist.costkey = MAX_DOUBLE;
+      }
+    }
+
+    // Costs are now, SATD-based. Omit PUs with SAD-based costs.
+    // TODO: Recalculate SAD costs with SATD for further processing.
+    kvz_sort_keys_by_cost(&amvplist);
+    amvplist.size = n_best;
+  }
+
+  if (state->encoder_control->cfg.rdo >= 3 && cur_pu->part_size == SIZE_2Nx2N && cfg->fme_level == 0) {
+    if (amvp0.size) kvz_cu_cost_inter_rd2(state, x, y, depth, &amvp0.unitbest_keys0, lcu, &amvp0.costbest_keys0, &amvp0.bitsbest_keys0);
+    if (amvp1.size) kvz_cu_cost_inter_rd2(state, x, y, depth, &amvp1.unitbest_keys1, lcu, &amvp1.costbest_keys1, &amvp1.bitsbest_keys1);
   }
 
   // Search bi-pred positions
@@ -1795,25 +1929,39 @@
 
   if (can_use_bipred) {
 
+    cu_info_t *bipred_pu = &amvp2.unit0;
+    *bipred_pu = *cur_pu;
+    double   best_bipred_cost = MAX_DOUBLE;
+
     // Try biprediction from valid acquired unipreds.
-    if (best_cost_LX0 != MAX_DOUBLE && best_cost_LX1 != MAX_DOUBLE) {
+    if (amvp0.size > 0 && amvp1.size > 0) {
 
       // TODO: logic is copy paste from search_pu_inter_bipred.
       // Get rid of duplicate code asap.
-      const image_list_t *const ref = info.state->frame->ref;
-      uint8_t(*ref_LX)16 = info.state->frame->ref_LX;
+      const image_list_t *const ref = info->state->frame->ref;
+      uint8_t(*ref_LX)16 = info->state->frame->ref_LX;
+
+      bipred_pu->inter.mv_dir = 3;
 
-      inter_merge_cand_t *merge_cand = info.merge_cand;
+      bipred_pu->inter.mv_ref0 = best_unipred0->inter.mv_ref0;
+      bipred_pu->inter.mv_ref1 = best_unipred1->inter.mv_ref1;
 
-      int16_t mv22;
-      mv00 = unipreds0.inter.mv00;
-      mv01 = unipreds0.inter.mv01;
-      mv10 = unipreds1.inter.mv10;
-      mv11 = unipreds1.inter.mv11;
+      int16_t (*mv)2 = bipred_pu->inter.mv;
+      mv00 = best_unipred0->inter.mv00;
+      mv01 = best_unipred0->inter.mv01;
+      mv10 = best_unipred1->inter.mv10;
+      mv11 = best_unipred1->inter.mv11;
+      
+      bipred_pu->merged  = false;
+      bipred_pu->skipped = false;
 
-      kvz_inter_recon_bipred(info.state,
-        ref->imagesref_LX0unipreds0.inter.mv_ref0,
-        ref->imagesref_LX1unipreds1.inter.mv_ref1,
+      for (int reflist = 0; reflist < 2; reflist++) {
+        kvz_inter_get_mv_cand(info->state, x, y, width, height, info->mv_cand, bipred_pu, lcu, reflist);
+      }
+
+      kvz_inter_recon_bipred(info->state,
+        ref->imagesref_LX0bipred_pu->inter.mv_ref0,
+        ref->imagesref_LX1bipred_pu->inter.mv_ref1,
         x, y,
         width,
         height,
@@ -1824,103 +1972,77 @@
 
       const kvz_pixel *rec = &lcu->rec.ySUB_SCU(y) * LCU_WIDTH + SUB_SCU(x);
       const kvz_pixel *src = &lcu->ref.ySUB_SCU(y) * LCU_WIDTH + SUB_SCU(x);
-      uint32_t cost =
+
+      best_bipred_cost =
         kvz_satd_any_size(width, height, rec, LCU_WIDTH, src, LCU_WIDTH);
 
-      uint32_t bitcost2 = { 0, 0 };
+      double bitcost2 = { 0, 0 };
 
-      cost += info.mvd_cost_func(info.state,
-        unipreds0.inter.mv00,
-        unipreds0.inter.mv01,
+      best_bipred_cost += info->mvd_cost_func(info->state,
+        bipred_pu->inter.mv00,
+        bipred_pu->inter.mv01,
         0,
-        info.mv_cand,
+        info->mv_cand,
         NULL, 0, 0,
         &bitcost0);
-      cost += info.mvd_cost_func(info.state,
-        unipreds1.inter.mv10,
-        unipreds1.inter.mv11,
+      best_bipred_cost += info->mvd_cost_func(info->state,
+        bipred_pu->inter.mv10,
+        bipred_pu->inter.mv11,
         0,
-        info.mv_cand,
+        info->mv_cand,
         NULL, 0, 0,
         &bitcost1);
 
       const uint8_t mv_ref_coded2 = {
-        unipreds0.inter.mv_ref0,
-        unipreds1.inter.mv_ref1
+        bipred_pu->inter.mv_ref0,
+        bipred_pu->inter.mv_ref1
       };
       const int extra_bits = mv_ref_coded0 + mv_ref_coded1 + 2 /* mv dir cost */;
-      cost += info.state->lambda_sqrt * extra_bits + 0.5;
-
-      if (cost < *inter_cost) {
-        cur_cu->inter.mv_dir = 3;
-
-        cur_cu->inter.mv_ref0 = unipreds0.inter.mv_ref0;
-        cur_cu->inter.mv_ref1 = unipreds1.inter.mv_ref1;
-
-        cur_cu->inter.mv00 = unipreds0.inter.mv00;
-        cur_cu->inter.mv01 = unipreds0.inter.mv01;
-        cur_cu->inter.mv10 = unipreds1.inter.mv10;
-        cur_cu->inter.mv11 = unipreds1.inter.mv11;
-        cur_cu->merged = 0;
-
-        // Check every candidate to find a match
-        for (int merge_idx = 0; merge_idx < info.num_merge_cand; merge_idx++) {
-          if (merge_candmerge_idx.mv00 == cur_cu->inter.mv00 &&
-            merge_candmerge_idx.mv01 == cur_cu->inter.mv01 &&
-            merge_candmerge_idx.mv10 == cur_cu->inter.mv10 &&
-            merge_candmerge_idx.mv11 == cur_cu->inter.mv11 &&
-            merge_candmerge_idx.ref0 == cur_cu->inter.mv_ref0 &&
-            merge_candmerge_idx.ref1 == cur_cu->inter.mv_ref1)
-          {
-            cur_cu->merged = 1;
-            cur_cu->merge_idx = merge_idx;
-            break;
-          }
-        }
+      best_bipred_cost += info->state->lambda_sqrt * extra_bits;
+
+      if (best_bipred_cost < MAX_DOUBLE) {
 
         // Each motion vector has its own candidate
         for (int reflist = 0; reflist < 2; reflist++) {
-          kvz_inter_get_mv_cand(info.state, x, y, width, height, info.mv_cand, cur_cu, lcu, reflist);
           int cu_mv_cand = select_mv_cand(
-            info.state,
-            info.mv_cand,
-            cur_cu->inter.mvreflist0,
-            cur_cu->inter.mvreflist1,
+            info->state,
+            info->mv_cand,
+            bipred_pu->inter.mvreflist0,
+            bipred_pu->inter.mvreflist1,
             NULL);
-          CU_SET_MV_CAND(cur_cu, reflist, cu_mv_cand);
+          CU_SET_MV_CAND(bipred_pu, reflist, cu_mv_cand);
         }
 
-        *inter_cost = cost;
-        *inter_bitcost = bitcost0 + bitcost1 + extra_bits;
+        amvp2.costamvp2.size = best_bipred_cost;
+        amvp2.bitsamvp2.size = bitcost0 + bitcost1 + extra_bits;
+        amvp2.keysamvp2.size = amvp2.size;
+        amvp2.size++;
       }
     }
-
-    // TODO: this probably should have a separate command line option
-    if (cfg->rdo == 3) {
-      search_pu_inter_bipred(&info, depth, lcu, cur_cu, inter_cost, inter_bitcost);
+    
+    if (!cfg->fast_bipred) search_pu_inter_bipred(info, depth, lcu, &amvp2);
+    
+    assert(amvp2.size <= MAX_UNIT_STATS_MAP_SIZE);
+    kvz_sort_keys_by_cost(&amvp2);
+    if (amvp2.size > 0 && state->encoder_control->cfg.rdo >= 3 && cur_pu->part_size == SIZE_2Nx2N) {
+      kvz_cu_cost_inter_rd2(state, x, y, depth, &amvp2.unitamvp2.keys0, lcu, &amvp2.costamvp2.keys0, &amvp2.bitsamvp2.keys0);
     }
   }
-
-  // Compare best merge cost to amvp cost
-  if (mrg_costs0 < *inter_cost) {
-    *inter_cost = mrg_costs0;
-    *inter_bitcost = 0; // TODO: Check this
-    int merge_idx = mrg_cands0;
-    cur_cu->type = CU_INTER;
-    cur_cu->merge_idx = merge_idx;
-    cur_cu->inter.mv_dir = info.merge_candmerge_idx.dir;
-    cur_cu->inter.mv_ref0 = info.merge_candmerge_idx.ref0;
-    cur_cu->inter.mv_ref1 = info.merge_candmerge_idx.ref1;
-    cur_cu->inter.mv00 = info.merge_candmerge_idx.mv00;
-    cur_cu->inter.mv01 = info.merge_candmerge_idx.mv01;
-    cur_cu->inter.mv10 = info.merge_candmerge_idx.mv10;
-    cur_cu->inter.mv11 = info.merge_candmerge_idx.mv11;
-    cur_cu->merged = true;
-    cur_cu->skipped = false;
-  }
-
-  if (*inter_cost < INT_MAX && cur_cu->inter.mv_dir == 1) {
-    assert(fracmv_within_tile(&info, cur_cu->inter.mv00, cur_cu->inter.mv01));
+  if(cfg->rdo < 2) {
+    const int skip_contest = kvz_get_skip_context(x, y, lcu, NULL);
+    const double no_skip_flag = CTX_ENTROPY_FBITS(&state->search_cabac.ctx.cu_skip_flag_modelskip_contest, 0);
+    const double part_mode_bits = state->encoder_control->cfg.smp_enable || state->encoder_control->cfg.amp_enable ?
+      CTX_ENTROPY_FBITS(&state->search_cabac.ctx.part_size_model0, 1)
+        : 0;
+    const double pred_mode_bits = CTX_ENTROPY_FBITS(&state->search_cabac.ctx.cu_pred_mode_model, 0);
+    const double total_bits = no_skip_flag + part_mode_bits + pred_mode_bits;
+    for(int i = 0; i < 3; i++) {
+      if(amvpi.size > 0) {
+        const uint8_t best_key = amvpi.keys0;
+        amvpi.bitsbest_key += total_bits;
+        amvpi.costbest_key += (total_bits)* state->lambda_sqrt;
+      }
+    }
   }
 }
 
@@ -1944,32 +2066,92 @@
 * \param inter_bitcost Return inter bitcost
 */
 void kvz_cu_cost_inter_rd2(encoder_state_t * const state,
-  int x, int y, int depth,
-  lcu_t *lcu,
-  double   *inter_cost,
-  uint32_t *inter_bitcost){
-
-  cu_info_t *cur_cu = LCU_GET_CU_AT_PX(lcu, SUB_SCU(x), SUB_SCU(y));
+                           int x, int y, int depth,
+                           cu_info_t* cur_cu,
+                           lcu_t *lcu,
+                           double   *inter_cost,
+                           double* inter_bitcost){
+  
   int tr_depth = MAX(1, depth);
   if (cur_cu->part_size != SIZE_2Nx2N) {
     tr_depth = depth + 1;
   }
   kvz_lcu_fill_trdepth(lcu, x, y, depth, tr_depth);
 
+  const int x_px = SUB_SCU(x);
+  const int y_px = SUB_SCU(y);
+  const int width = LCU_WIDTH >> depth;
+  cabac_data_t cabac_copy;
+  memcpy(&cabac_copy, &state->search_cabac, sizeof(cabac_copy));
+  cabac_copy.update = 1;
+
+  cu_info_t* cur_pu = LCU_GET_CU_AT_PX(lcu, x_px, y_px);
+  *cur_pu = *cur_cu;
+
   const bool reconstruct_chroma = state->encoder_control->chroma_format != KVZ_CSP_400;
   kvz_inter_recon_cu(state, lcu, x, y, CU_WIDTH_FROM_DEPTH(depth), true, reconstruct_chroma);
-  kvz_quantize_lcu_residual(state, true, reconstruct_chroma,
-    x, y, depth,
-    NULL,
-    lcu,
-    false);
 
-  *inter_cost = kvz_cu_rd_cost_luma(state, SUB_SCU(x), SUB_SCU(y), depth, cur_cu, lcu);
+  int index = y_px * LCU_WIDTH + x_px;
+  double ssd = kvz_pixels_calc_ssd(&lcu->ref.yindex, &lcu->rec.yindex,
+                                   LCU_WIDTH, LCU_WIDTH,
+                                   width) * KVZ_LUMA_MULT;
   if (reconstruct_chroma) {
-    *inter_cost += kvz_cu_rd_cost_chroma(state, SUB_SCU(x), SUB_SCU(y), depth, cur_cu, lcu);
+    int index = y_px / 2 * LCU_WIDTH_C + x_px / 2;
+    double ssd_u = kvz_pixels_calc_ssd(&lcu->ref.uindex, &lcu->rec.uindex,
+                                       LCU_WIDTH_C, LCU_WIDTH_C,
+                                       width / 2);
+    double ssd_v = kvz_pixels_calc_ssd(&lcu->ref.vindex, &lcu->rec.vindex,
+                                       LCU_WIDTH_C, LCU_WIDTH_C,
+                                       width / 2);
+    ssd += (ssd_u + ssd_v) * KVZ_CHROMA_MULT;
+  }
+  double no_cbf_bits;
+  double bits = 0;
+  const int skip_context = kvz_get_skip_context(x, y, lcu, NULL);
+  if (cur_cu->merged && cur_cu->part_size == SIZE_2Nx2N) {
+    no_cbf_bits = CTX_ENTROPY_FBITS(&state->cabac.ctx.cu_skip_flag_modelskip_context, 1) + *inter_bitcost;
+    bits += kvz_mock_encode_coding_unit(state, &cabac_copy, x, y, depth, lcu, cur_cu);
+  }
+  else {
+    no_cbf_bits = kvz_mock_encode_coding_unit(state, &cabac_copy, x, y, depth, lcu, cur_cu);
+    bits += no_cbf_bits - CTX_ENTROPY_FBITS(&cabac_copy.ctx.cu_qt_root_cbf_model, 0) + CTX_ENTROPY_FBITS(&cabac_copy.ctx.cu_qt_root_cbf_model, 1);
+  }
+  double no_cbf_cost = ssd + no_cbf_bits * state->lambda;
+
+  kvz_quantize_lcu_residual(state, true, reconstruct_chroma,
+                            x, y, depth,
+                            cur_cu,
+                            lcu,
+                            false);
+
+  int cbf = cbf_is_set_any(cur_cu->cbf, depth);
+  
+  if(cbf) {
+    *inter_cost = kvz_cu_rd_cost_luma(state, x_px, y_px, depth, cur_cu, lcu);
+    if (reconstruct_chroma) {
+      *inter_cost += kvz_cu_rd_cost_chroma(state, x_px, y_px, depth, cur_cu, lcu);
+    }
   }
+  else {
+    // If we have no coeffs after quant we already have the cost calculated
+    *inter_cost = no_cbf_cost;
+    cur_cu->cbf = 0;
+    *inter_bitcost = no_cbf_bits;
+    return;
+  }
+  
+  *inter_cost += (bits)* state->lambda;
+  *inter_bitcost = bits;
 
-  *inter_cost += *inter_bitcost * state->lambda;
+  if(no_cbf_cost < *inter_cost) {
+    cur_cu->cbf = 0;
+    if (cur_cu->merged && cur_cu->part_size == SIZE_2Nx2N) {
+      cur_cu->skipped = 1;
+    }
+    *inter_cost = no_cbf_cost;
+    *inter_bitcost = no_cbf_bits;
+    
+  }
 }
 
 
@@ -1991,22 +2173,92 @@
                          int x, int y, int depth,
                          lcu_t *lcu,
                          double   *inter_cost,
-                         uint32_t *inter_bitcost)
+                         double* inter_bitcost)
 {
+  *inter_cost = MAX_DOUBLE;
+  *inter_bitcost = MAX_INT;
+
+  // Store information of L0, L1, and bipredictions.
+  // Best cost will be left at MAX_DOUBLE if no valid CU is found.
+  // These will be initialized by the following function.
+  unit_stats_map_t amvp3;
+  unit_stats_map_t merge;
+  inter_search_info_t info;
+
   search_pu_inter(state,
                   x, y, depth,
                   SIZE_2Nx2N, 0,
                   lcu,
-                  inter_cost,
-                  inter_bitcost);
+                  amvp,
+                  &merge,
+                  &info);
+
+  // Early Skip CU decision
+  if (merge.size == 1 && merge.unit0.skipped) {
+    *inter_cost    = merge.cost0;
+    *inter_bitcost = merge.bits0;
+    return;
+  }
+
+  cu_info_t *best_inter_pu = NULL;
+
+  // Find best AMVP PU
+  for (int mv_dir = 1; mv_dir < 4; ++mv_dir) {
 
+    int best_key = amvpmv_dir - 1.keys0;
+
+    if (amvpmv_dir - 1.size > 0 &&
+        amvpmv_dir - 1.costbest_key < *inter_cost) {
+
+      best_inter_pu  = &amvpmv_dir - 1.unitbest_key;
+      *inter_cost    =  amvpmv_dir - 1.costbest_key;
+      *inter_bitcost =  amvpmv_dir - 1.bitsbest_key;
+    }
+  }
+
+  // Compare best AMVP against best Merge mode
+  int best_merge_key = merge.keys0;
+
+  if (merge.size > 0 && merge.costbest_merge_key < *inter_cost) {
+
+    best_inter_pu  = &merge.unitbest_merge_key;
+    *inter_cost    =  merge.costbest_merge_key;
+    *inter_bitcost =  0; // TODO: Check this
+  }
+
+  if (*inter_cost == MAX_DOUBLE) {
+    // Could not find any motion vector.
+    *inter_cost = MAX_DOUBLE;
+    *inter_bitcost = MAX_INT;
+    return;
+  }
+
+  const int x_local = SUB_SCU(x);
+  const int y_local = SUB_SCU(y);
+  cu_info_t *cur_pu = LCU_GET_CU_AT_PX(lcu, x_local, y_local);
+  *cur_pu = *best_inter_pu;
   // Calculate more accurate cost when needed
-  if (state->encoder_control->cfg.rdo >= 2) {
+  if (state->encoder_control->cfg.rdo == 2) {
     kvz_cu_cost_inter_rd2(state,
       x, y, depth,
+      cur_pu,
       lcu,
       inter_cost,
       inter_bitcost);
+    kvz_inter_recon_cu(state, lcu, x, y, CU_WIDTH_FROM_DEPTH(depth),
+      true, state->encoder_control->chroma_format != KVZ_CSP_400);
+  }
+  else {
+    kvz_inter_recon_cu(state, lcu, x, y, CU_WIDTH_FROM_DEPTH(depth),
+      true, state->encoder_control->chroma_format != KVZ_CSP_400);
+  }
+
+  if (*inter_cost < MAX_DOUBLE && cur_pu->inter.mv_dir & 1) {
+    assert(fracmv_within_tile(&info, cur_pu->inter.mv00, cur_pu->inter.mv01));
+  }
+
+  if (*inter_cost < MAX_DOUBLE && cur_pu->inter.mv_dir & 2) {
+    assert(fracmv_within_tile(&info, cur_pu->inter.mv10, cur_pu->inter.mv11));
   }
 }
 
@@ -2026,14 +2278,24 @@
  * \param inter_cost    Return inter cost
  * \param inter_bitcost Return inter bitcost
  */
-void kvz_search_cu_smp(encoder_state_t * const state,
+void kvz_search_cu_smp(encoder_state_t* const state,
                        int x, int y,
                        int depth,
                        part_mode_t part_mode,
                        lcu_t *lcu,
                        double *inter_cost,
-                       uint32_t *inter_bitcost)
+                       double* inter_bitcost)
 {
+  *inter_cost = MAX_DOUBLE;
+  *inter_bitcost = MAX_INT;
+
+  // Store information of L0, L1, and bipredictions.
+  // Best cost will be left at MAX_DOUBLE if no valid CU is found.
+  // These will be initialized by the following function.
+  unit_stats_map_t amvp3;
+  unit_stats_map_t merge;
+  inter_search_info_t info;
+
   const int num_pu  = kvz_part_mode_num_partspart_mode;
   const int width   = LCU_WIDTH >> depth;
   const int y_local = SUB_SCU(y);
@@ -2047,58 +2309,94 @@
     const int y_pu      = PU_GET_Y(part_mode, width, y_local, i);
     const int width_pu  = PU_GET_W(part_mode, width, i);
     const int height_pu = PU_GET_H(part_mode, width, i);
-    cu_info_t *cur_pu   = LCU_GET_CU_AT_PX(lcu, x_pu, y_pu);
 
-    cur_pu->type      = CU_INTER;
-    cur_pu->part_size = part_mode;
-    cur_pu->depth     = depth;
-    cur_pu->qp        = state->qp;
+    double cost    = MAX_DOUBLE;
+    double bitcost = MAX_INT;
+
+    search_pu_inter(state, x, y, depth, part_mode, i, lcu, amvp, &merge, &info);
+
+    cu_info_t* best_inter_pu = NULL;
+
+    // Find best AMVP PU
+    for (int mv_dir = 1; mv_dir < 4; ++mv_dir) {
+
+      int best_key = amvpmv_dir - 1.keys0;
+
+      if (amvpmv_dir - 1.size > 0 &&
+        amvpmv_dir - 1.costbest_key < cost) {
 
-    double cost      = MAX_INT;
-    uint32_t bitcost = MAX_INT;
+        best_inter_pu  = &amvpmv_dir - 1.unitbest_key;
+        cost           =  amvpmv_dir - 1.costbest_key;
+        bitcost        =  amvpmv_dir - 1.bitsbest_key;
+      }
+    }
+
+    // Compare best AMVP against best Merge mode
+    int best_merge_key = merge.keys0;
+
+    if (merge.size > 0 && merge.costbest_merge_key < cost) {
 
-    search_pu_inter(state, x, y, depth, part_mode, i, lcu, &cost, &bitcost);
+      best_inter_pu = &merge.unitbest_merge_key;
+      cost          =  merge.costbest_merge_key;
+      bitcost       =  0; // TODO: Check this
+    }
 
-    if (cost >= MAX_INT) {
+    if (cost == MAX_DOUBLE) {
       // Could not find any motion vector.
-      *inter_cost    = MAX_INT;
+      *inter_cost = MAX_DOUBLE;
       *inter_bitcost = MAX_INT;
       return;
     }
 
-    *inter_cost    += cost;
+    *inter_cost += cost;
     *inter_bitcost += bitcost;
 
+    cu_info_t* cur_pu = LCU_GET_CU_AT_PX(lcu, x_pu, y_pu);
+    *cur_pu = *best_inter_pu;
+
     for (int y = y_pu; y < y_pu + height_pu; y += SCU_WIDTH) {
       for (int x = x_pu; x < x_pu + width_pu; x += SCU_WIDTH) {
-        cu_info_t *scu = LCU_GET_CU_AT_PX(lcu, x, y);
+        cu_info_t* scu = LCU_GET_CU_AT_PX(lcu, x, y);
         scu->type = CU_INTER;
         scu->inter = cur_pu->inter;
       }
     }
+
+    if (cost < MAX_DOUBLE && cur_pu->inter.mv_dir & 1) {
+      assert(fracmv_within_tile(&info, cur_pu->inter.mv00, cur_pu->inter.mv01));
+    }
+
+    if (cost < MAX_DOUBLE && cur_pu->inter.mv_dir & 2) {
+      assert(fracmv_within_tile(&info, cur_pu->inter.mv10, cur_pu->inter.mv11));
+    }
+  }
+  double smp_extra_bits = 0;
+  if (state->encoder_control->cfg.rdo < 2) {
+    smp_extra_bits = kvz_encode_part_mode(
+      state,
+      &state->search_cabac,
+      LCU_GET_CU_AT_PX(lcu, x_local, y_local),
+      depth
+    );
+
+    CABAC_FBITS_UPDATE(&state->search_cabac, &state->search_cabac.ctx.cu_skip_flag_modelkvz_get_skip_context(x, y, lcu, NULL), 0, smp_extra_bits, "skip_flag");
+
+    // The transform is split for SMP and AMP blocks so we need more bits for
+    // coding the CBF.
+    smp_extra_bits += 6;
+
+    *inter_bitcost += smp_extra_bits;
   }
 
   // Calculate more accurate cost when needed
   if (state->encoder_control->cfg.rdo >= 2) {
     kvz_cu_cost_inter_rd2(state,
-      x, y, depth,
-      lcu,
-      inter_cost,
-      inter_bitcost);
-  }
-
-  // Count bits spent for coding the partition mode.
-  int smp_extra_bits = 1; // horizontal or vertical
-  if (state->encoder_control->cfg.amp_enable) {
-    smp_extra_bits += 1; // symmetric or asymmetric
-    if (part_mode != SIZE_2NxN && part_mode != SIZE_Nx2N) {
-      smp_extra_bits += 1; // U,L or D,R
-    }
+                          x, y, depth, 
+                          LCU_GET_CU_AT_PX(lcu, x_local, y_local),
+                          lcu,
+                          inter_cost,
+                          inter_bitcost);
+  } else {
+    *inter_cost += state->lambda_sqrt * smp_extra_bits;
   }
-  // The transform is split for SMP and AMP blocks so we need more bits for
-  // coding the CBF.
-  smp_extra_bits += 6;
-
-  *inter_cost += (state->encoder_control->cfg.rdo >= 2 ? state->lambda : state->lambda_sqrt) * smp_extra_bits;
-  *inter_bitcost += smp_extra_bits;
 }

kvazaar-2.1.0.tar.gz/src/search_inter.h -> kvazaar-2.2.0.tar.gz/src/search_inter.h Changed

@@ -64,20 +64,20 @@
   HPEL_POS_DIA = 2
 };
 
-typedef uint32_t kvz_mvd_cost_func(const encoder_state_t *state,
+typedef double kvz_mvd_cost_func(const encoder_state_t *state,
                                   int x, int y,
                                   int mv_shift,
                                   int16_t mv_cand22,
                                   inter_merge_cand_t merge_candMRG_MAX_NUM_CANDS,
                                   int16_t num_cand,
                                   int32_t ref_idx,
-                                  uint32_t *bitcost);
+                                  double *bitcost);
 
 void kvz_search_cu_inter(encoder_state_t * const state,
                          int x, int y, int depth,
                          lcu_t *lcu,
                          double *inter_cost,
-                         uint32_t *inter_bitcost);
+                         double* inter_bitcost);
 
 void kvz_search_cu_smp(encoder_state_t * const state,
                        int x, int y,
@@ -85,12 +85,20 @@
                        part_mode_t part_mode,
                        lcu_t *lcu,
                        double *inter_cost,
-                       uint32_t *inter_bitcost);
+                       double* inter_bitcost);
 
 
 unsigned kvz_inter_satd_cost(const encoder_state_t* state,
                              const lcu_t *lcu,
                              int x,
                              int y);
+void kvz_cu_cost_inter_rd2(encoder_state_t* const state,
+  int x, int y, int depth,
+  cu_info_t* cur_cu,
+  lcu_t* lcu,
+  double* inter_cost,
+  double* inter_bitcost);
+
+int kvz_get_skip_context(int x, int y, lcu_t* const lcu, cu_array_t* const cu_a);
 
 #endif // SEARCH_INTER_H_

kvazaar-2.1.0.tar.gz/src/search_intra.c -> kvazaar-2.2.0.tar.gz/src/search_intra.c Changed

@@ -98,11 +98,11 @@
 
     // 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;
+    const cabac_ctx_t *ctx = &state->search_cabac.ctx.transform_skip_model_luma;
     double trskip_bits = CTX_ENTROPY_FBITS(ctx, 1) - CTX_ENTROPY_FBITS(ctx, 0);
 
     if (state->encoder_control->chroma_format != KVZ_CSP_400) {
-      ctx = &state->cabac.ctx.transform_skip_model_chroma;
+      ctx = &state->search_cabac.ctx.transform_skip_model_chroma;
       trskip_bits += 2.0 * (CTX_ENTROPY_FBITS(ctx, 1) - CTX_ENTROPY_FBITS(ctx, 0));
     }
 
@@ -248,7 +248,7 @@
   //     max_depth.
   // - Min transform size hasn't been reached (MAX_PU_DEPTH).
   if (depth < max_depth && depth < MAX_PU_DEPTH) {
-    split_cost = 3 * state->lambda;
+    split_cost = 0;
 
     split_cost += search_intra_trdepth(state, x_px, y_px, depth + 1, max_depth, intra_mode, nosplit_cost, pred_cu, lcu);
     if (split_cost < nosplit_cost) {
@@ -267,8 +267,8 @@
     // Add bits for split_transform_flag = 1, because transform depth search bypasses
     // the normal recursion in the cost functions.
     if (depth >= 1 && depth <= 3) {
-      const cabac_ctx_t *ctx = &(state->cabac.ctx.trans_subdiv_model5 - (6 - depth));
-      tr_split_bit += CTX_ENTROPY_FBITS(ctx, 1);
+      cabac_ctx_t *ctx = &(state->search_cabac.ctx.trans_subdiv_model5 - (6 - depth));
+      CABAC_FBITS_UPDATE(&state->search_cabac, ctx, 1, tr_split_bit, "tr_split");
     }
 
     // Add cost of cbf chroma bits on transform tree.
@@ -280,12 +280,12 @@
     if (state->encoder_control->chroma_format != KVZ_CSP_400) {
       const uint8_t tr_depth = depth - pred_cu->depth;
 
-      const cabac_ctx_t *ctx = &(state->cabac.ctx.qt_cbf_model_chromatr_depth);
+      cabac_ctx_t *ctx = &(state->search_cabac.ctx.qt_cbf_model_chromatr_depth);
       if (tr_depth == 0 || cbf_is_set(pred_cu->cbf, depth - 1, COLOR_U)) {
-        cbf_bits += CTX_ENTROPY_FBITS(ctx, cbf_is_set(pred_cu->cbf, depth, COLOR_U));
+        CABAC_FBITS_UPDATE(&state->search_cabac, ctx, cbf_is_set(pred_cu->cbf, depth, COLOR_U), cbf_bits, "cbf_cb");
       }
       if (tr_depth == 0 || cbf_is_set(pred_cu->cbf, depth - 1, COLOR_V)) {
-        cbf_bits += CTX_ENTROPY_FBITS(ctx, cbf_is_set(pred_cu->cbf, depth, COLOR_V));
+        CABAC_FBITS_UPDATE(&state->search_cabac, ctx, cbf_is_set(pred_cu->cbf, depth, COLOR_V), cbf_bits, "cbf_cr");
       }
     }
 
@@ -524,9 +524,8 @@
 
   // Add prediction mode coding cost as the last thing. We don't want this
   // affecting the halving search.
-  int lambda_cost = (int)(state->lambda_sqrt + 0.5);
   for (int mode_i = 0; mode_i < modes_selected; ++mode_i) {
-    costsmode_i += lambda_cost * kvz_luma_mode_bits(state, modesmode_i, intra_preds);
+    costsmode_i += state->lambda_sqrt * kvz_luma_mode_bits(state, modesmode_i, intra_preds);
   }
 
   #undef PARALLEL_BLKS
@@ -594,21 +593,23 @@
   }
 
   for(int rdo_mode = 0; rdo_mode < modes_to_check; rdo_mode ++) {
-    int rdo_bitcost = kvz_luma_mode_bits(state, modesrdo_mode, intra_preds);
-    costsrdo_mode = rdo_bitcost * (int)(state->lambda + 0.5);
+    double rdo_bitcost = kvz_luma_mode_bits(state, modesrdo_mode, intra_preds);
+    costsrdo_mode = rdo_bitcost * state->lambda;
 
     // Perform transform split search and save mode RD cost for the best one.
     cu_info_t pred_cu;
     pred_cu.depth = depth;
     pred_cu.type = CU_INTRA;
     pred_cu.part_size = ((depth == MAX_PU_DEPTH) ? SIZE_NxN : SIZE_2Nx2N);
+    pred_cu.skipped = 0;
+    pred_cu.merged = 0;
     pred_cu.intra.mode = modesrdo_mode;
     pred_cu.intra.mode_chroma = modesrdo_mode;
     FILL(pred_cu.cbf, 0);
 
     // Reset transform split data in lcu.cu for this area.
     kvz_lcu_fill_trdepth(lcu, x_px, y_px, depth, depth);
-
+    
     double mode_cost = search_intra_trdepth(state, x_px, y_px, depth, tr_depth, modesrdo_mode, MAX_INT, &pred_cu, lcu);
     costsrdo_mode += mode_cost;
 
@@ -622,6 +623,7 @@
   // Update order according to new costs
   kvz_sort_modes(modes, costs, modes_to_check);
 
+
   // The best transform split hierarchy is not saved anywhere, so to get the
   // transform split hierarchy the search has to be performed again with the
   // best mode.
@@ -642,7 +644,8 @@
 
 double kvz_luma_mode_bits(const encoder_state_t *state, int8_t luma_mode, const int8_t *intra_preds)
 {
-  double mode_bits;
+  cabac_data_t* cabac = (cabac_data_t *)&state->search_cabac;
+  double mode_bits = 0;
 
   bool mode_in_preds = false;
   for (int i = 0; i < 3; ++i) {
@@ -651,8 +654,21 @@
     }
   }
 
-  const cabac_ctx_t *ctx = &(state->cabac.ctx.intra_mode_model);
-  mode_bits = CTX_ENTROPY_FBITS(ctx, mode_in_preds);
+  cabac_ctx_t *ctx = &(cabac->ctx.intra_mode_model);
+  CABAC_FBITS_UPDATE(cabac, ctx, mode_in_preds, mode_bits, "prev_intra_luma_pred_flag_search");
+  if (state->search_cabac.update) {
+    if(mode_in_preds) {
+      CABAC_BIN_EP(cabac, !(luma_mode == intra_preds0), "mpm_idx");
+      if(luma_mode != intra_preds0) {
+        CABAC_BIN_EP(cabac, !(luma_mode == intra_preds1), "mpm_idx");        
+      }
+    }
+    else {
+      // This value should be transformed for actual coding,
+      // but here the value does not actually matter, just that we write 5 bits
+      CABAC_BINS_EP(cabac, luma_mode, 5, "rem_intra_luma_pred_mode");
+    }
+  }
 
   if (mode_in_preds) {
     mode_bits += ((luma_mode == intra_preds0) ? 1 : 2);
@@ -666,12 +682,20 @@
 
 double kvz_chroma_mode_bits(const encoder_state_t *state, int8_t chroma_mode, int8_t luma_mode)
 {
-  const cabac_ctx_t *ctx = &(state->cabac.ctx.chroma_pred_model0);
-  double mode_bits;
-  if (chroma_mode == luma_mode) {
-    mode_bits = CTX_ENTROPY_FBITS(ctx, 0);
-  } else {
-    mode_bits = 2.0 + CTX_ENTROPY_FBITS(ctx, 1);
+  cabac_data_t* cabac = (cabac_data_t*)&state->search_cabac;
+  cabac_ctx_t *ctx = &(cabac->ctx.chroma_pred_model0);
+
+  double mode_bits = 0;
+  CABAC_FBITS_UPDATE(cabac, ctx, chroma_mode != luma_mode, mode_bits, "intra_chroma_pred_mode");
+  if (chroma_mode != luma_mode) {
+    mode_bits += 2.0;
+  }
+
+  if(cabac->update) {
+    if(chroma_mode != luma_mode) {
+      // Again it does not matter what we actually write here
+      CABAC_BINS_EP(cabac, 0, 2, "intra_chroma_pred_mode");      
+    }
   }
 
   return mode_bits;
@@ -706,9 +730,11 @@
                          depth,
                          -1, chroma.mode, // skip luma
                          NULL, lcu);
+      double bits = 0;
       chroma.cost = kvz_cu_rd_cost_chroma(state, lcu_px.x, lcu_px.y, depth, tr_cu, lcu);
 
       double mode_bits = kvz_chroma_mode_bits(state, chroma.mode, intra_mode);
+      bits += mode_bits;
       chroma.cost += mode_bits * state->lambda;
 
       if (chroma.cost < best_chroma.cost) {
@@ -742,10 +768,11 @@
   // is always one of the modes, so 2 means the final decision is made
   // between luma mode and one other mode that looks the best
   // according to search_intra_chroma_rough.
-  const int8_t modes_in_depth5 = { 1, 1, 1, 1, 2 };
-  int num_modes = modes_in_depthdepth;
-
-  if (state->encoder_control->cfg.rdo == 3) {
+  int num_modes = 2;
+  if(state->encoder_control->cfg.rdo >= 4 && depth == 4) {
+    num_modes = 5;
+  }
+  if (state->encoder_control->cfg.rdo >= 5) {
     num_modes = 5;
   }
 
@@ -792,7 +819,6 @@
                          int8_t *mode_out, double *cost_out)
 {
   const vector2d_t lcu_px = { SUB_SCU(x_px), SUB_SCU(y_px) };
-  const int8_t cu_width = LCU_WIDTH >> depth;
   const int_fast8_t log2_width = LOG2_LCU_WIDTH - depth;
 
   cu_info_t *cur_cu = LCU_GET_CU_AT_PX(lcu, lcu_px.x, lcu_px.y);
@@ -827,7 +853,7 @@
   kvz_pixel *ref_pixels = &lcu->ref.ylcu_px.x + lcu_px.y * LCU_WIDTH;
 
   int8_t number_of_modes;
-  bool skip_rough_search = (depth == 0 || state->encoder_control->cfg.rdo >= 3);
+  bool skip_rough_search = (depth == 0 || state->encoder_control->cfg.rdo >= 5);
   if (!skip_rough_search) {
     number_of_modes = search_intra_rough(state,
                                          ref_pixels, LCU_WIDTH,
@@ -848,10 +874,14 @@
   const int32_t rdo_level = state->encoder_control->cfg.rdo;
   if (rdo_level >= 2 || skip_rough_search) {
     int number_of_modes_to_search;
-    if (rdo_level == 3) {
+    if (rdo_level == 5) {
       number_of_modes_to_search = 35;
-    } else if (rdo_level == 2) {
-      number_of_modes_to_search = (cu_width == 4) ? 3 : 2;
+    } else if(rdo_level >= 4) {
+      const int rdo_candidate_modes = { 5, 5, 5, 6, 7 };
+      assert(depth >= 0 && depth <= 4);
+      number_of_modes_to_search = rdo_candidate_modesdepth;
+    } else if (rdo_level >= 2) {
+      number_of_modes_to_search = depth == 4 ? 3 : 2;
     } else {
       // Check only the predicted modes.
       number_of_modes_to_search = 0;

kvazaar-2.2.0.tar.gz/src/sei.h Added

@@ -0,0 +1,55 @@
+#ifndef UDU_SEI_H_
+#define UDU_SEI_H_
+/*****************************************************************************
+ * This file is part of Kvazaar HEVC encoder.
+ *
+ * Copyright (c) 2022, Tampere University, ITU/ISO/IEC, project contributors
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * * Redistributions of source code must retain the above copyright notice, this
+ *   list of conditions and the following disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above copyright notice, this
+ *   list of conditions and the following disclaimer in the documentation and/or
+ *   other materials provided with the distribution.
+ *
+ * * Neither the name of the Tampere University or ITU/ISO/IEC nor the names of its
+ *   contributors may be used to endorse or promote products derived from
+ *   this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * INCLUDING NEGLIGENCE OR OTHERWISE ARISING IN ANY WAY OUT OF THE USE OF THIS
+ ****************************************************************************/
+
+/**
+ * \file
+ * Supplemental Enhancement Information (SEI)
+ */
+
+#include "global.h" // IWYU pragma: keep
+
+#define SEI_PAYLOAD_TYPE_PIC_TIMING 1
+#define SEI_PAYLOAD_TYPE_USER_DATA_UNREGISTERED 5
+#define SEI_PAYLOAD_TYPE_DECODED_PICTURE_HASH 132
+
+// Flag value used for length / value extension.
+#define FF_BYTE 0xFF
+
+// UUID for the encoder info user defined unregistered message
+// random uuid_iso_iec_11578 generated with www.famkruithof.net/uuid/uuidgen
+static const uint8_t encoder_info_uuid16 = {
+    0x32, 0xfe, 0x46, 0x6c, 0x98, 0x41, 0x42, 0x69,
+    0xae, 0x35, 0x6a, 0x91, 0x54, 0x9e, 0xf3, 0xf1};
+
+#endif // UDU_SEI_H_

kvazaar-2.1.0.tar.gz/src/strategies/avx2/encode_coding_tree-avx2.c -> kvazaar-2.2.0.tar.gz/src/strategies/avx2/encode_coding_tree-avx2.c Changed

@@ -252,7 +252,8 @@
                                uint8_t width,
                                uint8_t type,
                                int8_t scan_mode,
-                               int8_t tr_skip)
+                               int8_t tr_skip,
+                               double* bits_out)
 {
   const encoder_control_t * const encoder = state->encoder_control;
   int c1 = 1;
@@ -260,6 +261,7 @@
   uint8_t last_coeff_y = 0;
   int32_t i;
   uint32_t sig_coeffgroup_nzs8 * 8 = { 0 };
+  double bits = 0;
 
   int8_t be_valid = encoder->cfg.signhide_enable;
   int32_t scan_pos_sig;
@@ -361,7 +363,7 @@
   // transform skip flag
   if(width == 4 && encoder->cfg.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");
+    CABAC_FBITS_UPDATE(cabac, cabac->cur_ctx, tr_skip, bits, "transform_skip_flag");
   }
 
   last_coeff_x = pos_last & (width - 1);
@@ -374,7 +376,8 @@
                                  width,
                                  width,
                                  type,
-                                 scan_mode);
+                                 scan_mode,
+                                 bits_out);
 
   scan_pos_sig = scan_pos_last;
 
@@ -406,8 +409,7 @@
       uint32_t sig_coeff_group   = (sig_coeffgroup_nzscg_blk_pos != 0);
       uint32_t ctx_sig  = kvz_context_get_sig_coeff_group(sig_coeffgroup_nzs, cg_pos_x,
                                                       cg_pos_y, width);
-      cabac->cur_ctx = &base_coeff_group_ctxctx_sig;
-      CABAC_BIN(cabac, sig_coeff_group, "coded_sub_block_flag");
+      CABAC_FBITS_UPDATE(cabac, &base_coeff_group_ctxctx_sig, sig_coeff_group, bits, "coded_sub_block_flag");
     }
 
     if (sig_coeffgroup_nzscg_blk_pos) {
@@ -464,8 +466,7 @@
 
         if (curr_esc_flag | num_non_zero) {
           ctx_sig = ctx_sig_bufid;
-          cabac->cur_ctx = &baseCtxctx_sig;
-          CABAC_BIN(cabac, curr_sig, "sig_coeff_flag");
+          CABAC_FBITS_UPDATE(cabac, &baseCtxctx_sig, curr_sig, bits, "sig_coeff_flag");
         }
 
         if (curr_sig) {
@@ -519,8 +520,7 @@
         uint32_t shift = idx << 1;
         uint32_t symbol = (coeffs_gt1_bits >> shift) & 1;
 
-        cabac->cur_ctx = &base_ctx_modc1;
-        CABAC_BIN(cabac, symbol, "coeff_abs_level_greater1_flag");
+        CABAC_FBITS_UPDATE(cabac, &base_ctx_modc1, symbol, bits, "coeff_abs_level_greater1_flag");
 
         c1 = (c1s_nextiter >> shift) & 3;
       }
@@ -532,9 +532,7 @@
         if (first_c2_flag_idx != -1) {
           uint32_t shift = (first_c2_flag_idx << 1) + 1;
           uint8_t symbol = (coeffs_gt2_bits >> shift) & 1;
-          cabac->cur_ctx = &base_ctx_mod0;
-
-          CABAC_BIN(cabac, symbol, "coeff_abs_level_greater2_flag");
+          CABAC_FBITS_UPDATE(cabac, &base_ctx_mod0, symbol, bits, "coeff_abs_level_greater2_flag");
         }
       }
       int32_t shiftamt = (be_valid && sign_hidden) ? 1 : 0;
@@ -546,6 +544,7 @@
         }
       }
       CABAC_BINS_EP(cabac, coeff_signs, nnz, "coeff_sign_flag");
+      if (cabac->only_count) bits += nnz;
 
       if (c1 == 0 || num_non_zero > C1FLAG_NUMBER) {
 
@@ -586,7 +585,7 @@
             if (!cabac->only_count && (encoder->cfg.crypto_features & KVZ_CRYPTO_TRANSF_COEFFS)) {
               kvz_cabac_write_coeff_remain_encry(state, cabac, level_diff, go_rice_param, base_level);
             } else {
-              kvz_cabac_write_coeff_remain(cabac, level_diff, go_rice_param);
+              bits += kvz_cabac_write_coeff_remain(cabac, level_diff, go_rice_param);
             }
 
             if (curr_abs_coeff > 3 * (1 << go_rice_param)) {
@@ -602,6 +601,7 @@
     num_non_zero = 0;
     coeff_signs = 0;
   }
+  if (cabac->only_count) *bits_out += bits;
 }
 #endif // COMPILE_INTEL_AVX2

kvazaar-2.1.0.tar.gz/src/strategies/avx2/encode_coding_tree-avx2.h -> kvazaar-2.2.0.tar.gz/src/strategies/avx2/encode_coding_tree-avx2.h Changed

kvazaar-2.1.0.tar.gz/src/strategies/avx2/picture-avx2.c -> kvazaar-2.2.0.tar.gz/src/strategies/avx2/picture-avx2.c Changed

@@ -769,238 +769,704 @@
   }
 }
 
-static void inter_recon_bipred_avx2(const int hi_prec_luma_rec0,
- const int hi_prec_luma_rec1,
- const int hi_prec_chroma_rec0,
- const int hi_prec_chroma_rec1,
- const int height,
- const int width,
- const int ypos,
- const int xpos,
- const hi_prec_buf_t*high_precision_rec0,
- const hi_prec_buf_t*high_precision_rec1,
- lcu_t* lcu,
- uint8_t* temp_lcu_y,
- uint8_t* temp_lcu_u,
- uint8_t* temp_lcu_v,
-bool predict_luma,
-bool predict_chroma)
+static INLINE void scatter_ymm_4x8_8bit(kvz_pixel * dst, __m256i ymm, unsigned dst_stride)
 {
-  int y_in_lcu, x_in_lcu;
-  int shift = 15 - KVZ_BIT_DEPTH;
-  int offset = 1 << (shift - 1);
-  __m256i temp_epi8, temp_y_epi32, sample0_epi32, sample1_epi32, temp_epi16;
-  int32_t * pointer = 0;
-  __m256i offset_epi32 = _mm256_set1_epi32(offset);
-
-  for (int temp_y = 0; temp_y < height; ++temp_y) {
-
-   y_in_lcu = ((ypos + temp_y) & ((LCU_WIDTH)-1));
-
-   for (int temp_x = 0; temp_x < width; temp_x += 8) {
-    x_in_lcu = ((xpos + temp_x) & ((LCU_WIDTH)-1));
+  __m128i ymm_lo = _mm256_castsi256_si128(ymm);
+  __m128i ymm_hi = _mm256_extracti128_si256(ymm, 1);
+  *(uint32_t *)dst = _mm_cvtsi128_si32(ymm_lo); dst += dst_stride;
+  *(uint32_t *)dst = _mm_extract_epi32(ymm_lo, 1); dst += dst_stride;
+  *(uint32_t *)dst = _mm_extract_epi32(ymm_lo, 2); dst += dst_stride;
+  *(uint32_t *)dst = _mm_extract_epi32(ymm_lo, 3); dst += dst_stride;
+  *(uint32_t *)dst = _mm_cvtsi128_si32(ymm_hi); dst += dst_stride;
+  *(uint32_t *)dst = _mm_extract_epi32(ymm_hi, 1); dst += dst_stride;
+  *(uint32_t *)dst = _mm_extract_epi32(ymm_hi, 2); dst += dst_stride;
+  *(uint32_t *)dst = _mm_extract_epi32(ymm_hi, 3);
+}
 
-    if (predict_luma) {
-      bool use_8_elements = ((temp_x + 8) <= width);
+static INLINE void scatter_ymm_8x4_8bit(kvz_pixel *dst, __m256i ymm, unsigned dst_stride)
+{
+  __m256d ymm_as_m256d = _mm256_castsi256_pd(ymm);
+  __m128d ymm_lo = _mm256_castpd256_pd128(ymm_as_m256d);
+  __m128d ymm_hi = _mm256_extractf128_pd(ymm_as_m256d, 1);
+  _mm_storel_pd((double*)dst, ymm_lo); dst += dst_stride;
+  _mm_storeh_pd((double*)dst, ymm_lo); dst += dst_stride;
+  _mm_storel_pd((double*)dst, ymm_hi); dst += dst_stride;
+  _mm_storeh_pd((double*)dst, ymm_hi);
+}
 
-      if (!use_8_elements) {
-        if (width < 4) {
-          // If width is smaller than 4 there's no need to use SIMD
-          for (int temp_i = 0; temp_i < width; ++temp_i) {
-            x_in_lcu = ((xpos + temp_i) & ((LCU_WIDTH)-1));
+static INLINE void scatter_ymm_16x2_8bit(kvz_pixel *dst, __m256i ymm, unsigned dst_stride)
+{
+  __m128i ymm_lo = _mm256_castsi256_si128(ymm);
+  __m128i ymm_hi = _mm256_extracti128_si256(ymm, 1);
+  _mm_storeu_si128((__m128i *)dst, ymm_lo); dst += dst_stride;
+  _mm_storeu_si128((__m128i *)dst, ymm_hi);
+}
 
-            int sample0_y = (hi_prec_luma_rec0 ? high_precision_rec0->yy_in_lcu * LCU_WIDTH + x_in_lcu : (temp_lcu_yy_in_lcu * LCU_WIDTH + x_in_lcu << (14 - KVZ_BIT_DEPTH)));
-            int sample1_y = (hi_prec_luma_rec1 ? high_precision_rec1->yy_in_lcu * LCU_WIDTH + x_in_lcu : (lcu->rec.yy_in_lcu * LCU_WIDTH + x_in_lcu << (14 - KVZ_BIT_DEPTH)));
+static INLINE void scatter_ymm_12x2_8bit(kvz_pixel *dst, __m256i ymm, unsigned dst_stride)
+{
+  __m256i mask_a = _mm256_setr_epi32(-1, -1, -1, 0, 0, 0, 0, 0);
+  __m256i mask_b = _mm256_setr_epi32(0, 0, 0, -1, -1, -1, 0, 0);
+  _mm256_maskstore_epi32((int32_t*)dst, mask_a, ymm); dst += dst_stride - 3 * 4;
+  _mm256_maskstore_epi32((int32_t*)dst, mask_b, ymm);
+}
 
-            lcu->rec.yy_in_lcu * LCU_WIDTH + x_in_lcu = (uint8_t)kvz_fast_clip_32bit_to_pixel((sample0_y + sample1_y + offset) >> shift);
-          }
+static INLINE void bipred_average_px_px_template_avx2(kvz_pixel *dst,
+  kvz_pixel *px_L0,
+  kvz_pixel *px_L1,
+  unsigned pu_w,
+  unsigned pu_h,
+  unsigned dst_stride)
+{
+  bool has_pow2_width = _mm_popcnt_u32(pu_w) == 1;
+  bool area_mod_32 = (pu_w * pu_h) % 32;
+  assert(!(pu_w == 4 && pu_h == 4) && "Branch for 4x4 not yet implemented.");
+  assert(!(pu_w == 2 && pu_h == 8) && "Branch for 2x8 not yet implemented.");
+
+  if (has_pow2_width && area_mod_32 == 0) {
+    for (int i = 0; i < pu_w * pu_h; i += 32) {
+
+      int y = i / pu_w;
+      int x = i % pu_w;
+
+      __m256i sample_L0 = _mm256_loadu_si256((__m256i*)&px_L0i);
+      __m256i sample_L1 = _mm256_loadu_si256((__m256i*)&px_L1i);
+      __m256i avg       = _mm256_avg_epu8(sample_L0, sample_L1);
+
+      switch (pu_w) {
+        case  4: scatter_ymm_4x8_8bit( &dsty * dst_stride + x, avg, dst_stride); break;
+        case  8: scatter_ymm_8x4_8bit( &dsty * dst_stride + x, avg, dst_stride); break;
+        case 16: scatter_ymm_16x2_8bit(&dsty * dst_stride + x, avg, dst_stride); break;
+        case 32: // Same as case 64
+        case 64: _mm256_storeu_si256((__m256i *)&dsty * dst_stride + x, avg); break;
+        default:
+          assert(0 && "Unexpected block width.");
+          break;
+      }
+    }
+  } else if (area_mod_32 == 0) {
+    for (int i = 0; i < pu_w * pu_h; i += 24) {
+
+      int y = i / pu_w;
+      int x = i % pu_w;
+
+      // Last 64 bits of the 256 are not used to simplify the loop
+      __m256i mask      = _mm256_setr_epi64x(-1, -1, -1, 0);
+      __m256i sample_L0 = _mm256_maskload_epi64((const long long*)&px_L0i, mask);
+      __m256i sample_L1 = _mm256_maskload_epi64((const long long*)&px_L1i, mask);
+      __m256i avg       = _mm256_avg_epu8(sample_L0, sample_L1);
+
+      switch (pu_w) {
+        case 12: scatter_ymm_12x2_8bit(&dsty * dst_stride + x, avg, dst_stride); break;
+        case 24: // Same as case 48
+        case 48: _mm256_maskstore_epi64((long long*)&dsty * dst_stride + x, mask, avg); break;
+        default:
+          assert(0 && "Unexpected block width.");
+          break;
+      }
+    }
+  } else {
+    // 8x2, 8x6, 6x8 blocks (and maybe 2x8 in the future)
+    switch (pu_w) {
+      __m128i sample_L0, sample_L1, avg;
+      case 8: // 8x2, 8x6
+        for (int i = 0; i < pu_w * pu_h; i += 16) {
+
+          int y = i / pu_w;
+
+          sample_L0 = _mm_loadu_si128((__m128i*)&px_L0i);
+          sample_L1 = _mm_loadu_si128((__m128i*)&px_L1i);
+          avg       = _mm_avg_epu8(sample_L0, sample_L1);
+          _mm_storel_epi64((__m128i*)&dsty * dst_stride, avg);
+          _mm_storeh_pd((double*)&dst(y + 1) * dst_stride, _mm_castsi128_pd(avg));
         }
-
-        else {
-          // Load total of 4 elements from memory to vector
-          sample0_epi32 = hi_prec_luma_rec0 ? _mm256_cvtepi16_epi32(_mm_loadl_epi64((__m128i*) &(high_precision_rec0->yy_in_lcu * LCU_WIDTH + x_in_lcu))) :
-            _mm256_slli_epi32(_mm256_cvtepu8_epi32(_mm_cvtsi32_si128(*(int32_t*)&(temp_lcu_yy_in_lcu * LCU_WIDTH + x_in_lcu))), 14 - KVZ_BIT_DEPTH);
-
-
-          sample1_epi32 = hi_prec_luma_rec1 ? _mm256_cvtepi16_epi32(_mm_loadl_epi64((__m128i*) &(high_precision_rec1->yy_in_lcu * LCU_WIDTH + x_in_lcu))) :
-            _mm256_slli_epi32(_mm256_cvtepu8_epi32(_mm_cvtsi32_si128(*(int32_t*) &(lcu->rec.yy_in_lcu * LCU_WIDTH + x_in_lcu))), 14 - KVZ_BIT_DEPTH);
-
-
-          // (sample1 + sample2 + offset)>>shift 
-          temp_y_epi32 = _mm256_add_epi32(sample0_epi32, sample1_epi32);
-          temp_y_epi32 = _mm256_add_epi32(temp_y_epi32, offset_epi32);
-          temp_y_epi32 = _mm256_srai_epi32(temp_y_epi32, shift);
-
-          // Pack the bits from 32-bit to 8-bit
-          temp_epi16 = _mm256_packs_epi32(temp_y_epi32, temp_y_epi32);
-          temp_epi16 = _mm256_permute4x64_epi64(temp_epi16, _MM_SHUFFLE(3, 1, 2, 0));
-          temp_epi8 = _mm256_packus_epi16(temp_epi16, temp_epi16);
-
-          pointer = (int32_t*)&(lcu->rec.y(y_in_lcu)* LCU_WIDTH + x_in_lcu);
-          *pointer = _mm_cvtsi128_si32(_mm256_castsi256_si128(temp_epi8));
-
-
-
-          for (int temp_i = temp_x + 4; temp_i < width; ++temp_i) {
-            x_in_lcu = ((xpos + temp_i) & ((LCU_WIDTH)-1));
-
-            int16_t sample0_y = (hi_prec_luma_rec0 ? high_precision_rec0->yy_in_lcu * LCU_WIDTH + x_in_lcu : (temp_lcu_yy_in_lcu * LCU_WIDTH + x_in_lcu << (14 - KVZ_BIT_DEPTH)));
-            int16_t sample1_y = (hi_prec_luma_rec1 ? high_precision_rec1->yy_in_lcu * LCU_WIDTH + x_in_lcu : (lcu->rec.yy_in_lcu * LCU_WIDTH + x_in_lcu << (14 - KVZ_BIT_DEPTH)));
-
-            lcu->rec.yy_in_lcu * LCU_WIDTH + x_in_lcu = (uint8_t)kvz_fast_clip_32bit_to_pixel((sample0_y + sample1_y + offset) >> shift);
-          }
-
+        break;
+      case 6: // 6x8
+        for (int i = 0; i < pu_w * pu_h; i += 12) {
+
+          int y = i / pu_w;
+
+          __m128i mask      = _mm_setr_epi32(-1, -1, -1, 0);
+          __m128i sample_L0 = _mm_maskload_epi32((const int*)(&px_L0i), mask);
+          __m128i sample_L1 = _mm_maskload_epi32((const int*)(&px_L1i), mask);
+          __m128i avg       = _mm_avg_epu8(sample_L0, sample_L1);
+
+          uint32_t elements_0123 = _mm_cvtsi128_si32(avg);
+          uint16_t elements_45   = _mm_extract_epi16(avg, 2);
+          uint16_t elements_67   = _mm_extract_epi16(avg, 3);
+          uint32_t elements_89ab = _mm_extract_epi32(avg, 2);
+          *(uint32_t*)&dst(y + 0) * dst_stride + 0 = elements_0123;
+          *(uint16_t*)&dst(y + 0) * dst_stride + 4 = elements_45;
+          *(uint16_t*)&dst(y + 1) * dst_stride + 0 = elements_67;
+          *(uint32_t*)&dst(y + 1) * dst_stride + 2 = elements_89ab;
         }
-      } else {
-        // Load total of 8 elements from memory to vector
-        sample0_epi32 = hi_prec_luma_rec0 ? _mm256_cvtepi16_epi32(_mm_loadu_si128((__m128i*) &(high_precision_rec0->yy_in_lcu * LCU_WIDTH + x_in_lcu))) :
-          _mm256_slli_epi32(_mm256_cvtepu8_epi32((_mm_loadl_epi64((__m128i*) &(temp_lcu_yy_in_lcu * LCU_WIDTH + x_in_lcu)))), 14 - KVZ_BIT_DEPTH);
-
-        sample1_epi32 = hi_prec_luma_rec1 ? _mm256_cvtepi16_epi32(_mm_loadu_si128((__m128i*) &(high_precision_rec1->yy_in_lcu * LCU_WIDTH + x_in_lcu))) :
-          _mm256_slli_epi32(_mm256_cvtepu8_epi32((_mm_loadl_epi64((__m128i*) &(lcu->rec.yy_in_lcu * LCU_WIDTH + x_in_lcu)))), 14 - KVZ_BIT_DEPTH);
-
-        // (sample1 + sample2 + offset)>>shift 
-        temp_y_epi32 = _mm256_add_epi32(sample0_epi32, sample1_epi32);
-        temp_y_epi32 = _mm256_add_epi32(temp_y_epi32, offset_epi32);
-        temp_y_epi32 = _mm256_srai_epi32(temp_y_epi32, shift);
-
-        // Pack the bits from 32-bit to 8-bit
-        temp_epi16 = _mm256_packs_epi32(temp_y_epi32, temp_y_epi32);
-        temp_epi16 = _mm256_permute4x64_epi64(temp_epi16, _MM_SHUFFLE(3, 1, 2, 0));
-        temp_epi8 = _mm256_packus_epi16(temp_epi16, temp_epi16);
-
-        // Store 64-bits from vector to memory
-        _mm_storel_epi64((__m128i*)&(lcu->rec.y(y_in_lcu)* LCU_WIDTH + x_in_lcu), _mm256_castsi256_si128(temp_epi8));
-      }
+        break;
+      default:
+        assert(0 && "Unexpected block width.");
+        break;
     }
-   }
   }
-  for (int temp_y = 0; temp_y < height >> 1; ++temp_y) {
-   int y_in_lcu = (((ypos >> 1) + temp_y) & (LCU_WIDTH_C - 1));
-   
-   for (int temp_x = 0; temp_x < width >> 1; temp_x += 8) {
-
-    int x_in_lcu = (((xpos >> 1) + temp_x) & (LCU_WIDTH_C - 1));
-
-    if (predict_chroma) {
-      if ((width >> 1) < 4) {
-        // If width>>1 is smaller than 4 there's no need to use SIMD
-
-        for (int temp_i = 0; temp_i < width >> 1; ++temp_i) {
-          int temp_x_in_lcu = (((xpos >> 1) + temp_i) & (LCU_WIDTH_C - 1));
-          int16_t sample0_u = (hi_prec_chroma_rec0 ? high_precision_rec0->uy_in_lcu * LCU_WIDTH_C + temp_x_in_lcu : (temp_lcu_uy_in_lcu * LCU_WIDTH_C + temp_x_in_lcu << (14 - KVZ_BIT_DEPTH)));
-          int16_t sample1_u = (hi_prec_chroma_rec1 ? high_precision_rec1->uy_in_lcu * LCU_WIDTH_C + temp_x_in_lcu : (lcu->rec.uy_in_lcu * LCU_WIDTH_C + temp_x_in_lcu << (14 - KVZ_BIT_DEPTH)));
-          lcu->rec.uy_in_lcu * LCU_WIDTH_C + temp_x_in_lcu = (uint8_t)kvz_fast_clip_32bit_to_pixel((sample0_u + sample1_u + offset) >> shift);
-
-          int16_t sample0_v = (hi_prec_chroma_rec0 ? high_precision_rec0->vy_in_lcu * LCU_WIDTH_C + temp_x_in_lcu : (temp_lcu_vy_in_lcu * LCU_WIDTH_C + temp_x_in_lcu << (14 - KVZ_BIT_DEPTH)));
-          int16_t sample1_v = (hi_prec_chroma_rec1 ? high_precision_rec1->vy_in_lcu * LCU_WIDTH_C + temp_x_in_lcu : (lcu->rec.vy_in_lcu * LCU_WIDTH_C + temp_x_in_lcu << (14 - KVZ_BIT_DEPTH)));
-          lcu->rec.vy_in_lcu * LCU_WIDTH_C + temp_x_in_lcu = (uint8_t)kvz_fast_clip_32bit_to_pixel((sample0_v + sample1_v + offset) >> shift);
-        }
-      }
-
-      else {
-
-        bool use_8_elements = ((temp_x + 8) <= (width >> 1));
-
-        __m256i temp_u_epi32, temp_v_epi32;
-
-        if (!use_8_elements) {
-          // Load 4 pixels to vector
-          sample0_epi32 = hi_prec_chroma_rec0 ? _mm256_cvtepi16_epi32(_mm_loadl_epi64((__m128i*) &(high_precision_rec0->uy_in_lcu * LCU_WIDTH_C + x_in_lcu))) :
-            _mm256_slli_epi32(_mm256_cvtepu8_epi32(_mm_cvtsi32_si128(*(int32_t*) &(temp_lcu_uy_in_lcu * LCU_WIDTH_C + x_in_lcu))), 14 - KVZ_BIT_DEPTH);
-
-          sample1_epi32 = hi_prec_chroma_rec1 ? _mm256_cvtepi16_epi32(_mm_loadl_epi64((__m128i*) &(high_precision_rec1->uy_in_lcu * LCU_WIDTH_C + x_in_lcu))) :
-            _mm256_slli_epi32(_mm256_cvtepu8_epi32(_mm_cvtsi32_si128(*(int32_t*) &(lcu->rec.uy_in_lcu * LCU_WIDTH_C + x_in_lcu))), 14 - KVZ_BIT_DEPTH);
-
-          // (sample1 + sample2 + offset)>>shift 
-          temp_u_epi32 = _mm256_add_epi32(sample0_epi32, sample1_epi32);
-          temp_u_epi32 = _mm256_add_epi32(temp_u_epi32, offset_epi32);
-          temp_u_epi32 = _mm256_srai_epi32(temp_u_epi32, shift);
-
-
-
-          sample0_epi32 = hi_prec_chroma_rec0 ? _mm256_cvtepi16_epi32(_mm_loadl_epi64((__m128i*) &(high_precision_rec0->vy_in_lcu * LCU_WIDTH_C + x_in_lcu))) :
-            _mm256_slli_epi32(_mm256_cvtepu8_epi32(_mm_cvtsi32_si128(*(int32_t*) &(temp_lcu_vy_in_lcu * LCU_WIDTH_C + x_in_lcu))), 14 - KVZ_BIT_DEPTH);
+}
 
-          sample1_epi32 = hi_prec_chroma_rec1 ? _mm256_cvtepi16_epi32(_mm_loadl_epi64((__m128i*) &(high_precision_rec1->vy_in_lcu * LCU_WIDTH_C + x_in_lcu))) :
-            _mm256_slli_epi32(_mm256_cvtepu8_epi32(_mm_cvtsi32_si128(*(int32_t*) &(lcu->rec.vy_in_lcu * LCU_WIDTH_C + x_in_lcu))), 14 - KVZ_BIT_DEPTH);
+static INLINE void bipred_average_px_px_avx2(kvz_pixel *dst,
+  kvz_pixel *px_L0,
+  kvz_pixel *px_L1,
+  unsigned pu_w,
+  unsigned pu_h,
+  unsigned dst_stride)
+{
+  // Use scalar code for yet unoptimized block sizes (4x4, 2x8)
+  if (!(pu_w == 4 && pu_h == 4) && pu_w > 2) {
+    switch (pu_w) {
+      case  4: bipred_average_px_px_template_avx2(dst, px_L0, px_L1,  4, pu_h, dst_stride); break;
+      case  8: bipred_average_px_px_template_avx2(dst, px_L0, px_L1,  8, pu_h, dst_stride); break;
+      case 16: bipred_average_px_px_template_avx2(dst, px_L0, px_L1, 16, pu_h, dst_stride); break;
+      case 32: bipred_average_px_px_template_avx2(dst, px_L0, px_L1, 32, pu_h, dst_stride); break;
+      case 64: bipred_average_px_px_template_avx2(dst, px_L0, px_L1, 64, pu_h, dst_stride); break;
+
+      case  6: bipred_average_px_px_template_avx2(dst, px_L0, px_L1,  6, pu_h, dst_stride); break;
+      case 12: bipred_average_px_px_template_avx2(dst, px_L0, px_L1, 12, pu_h, dst_stride); break;
+      case 24: bipred_average_px_px_template_avx2(dst, px_L0, px_L1, 24, pu_h, dst_stride); break;
+      case 48: bipred_average_px_px_template_avx2(dst, px_L0, px_L1, 48, pu_h, dst_stride); break;
+      default:
+        assert(0 && "Unexpected block width.");
+        break;
+    }
+  } else {
+    int32_t shift = 15 - KVZ_BIT_DEPTH; // TODO: defines
+    int32_t offset = 1 << (shift - 1);
+
+    for (int i = 0; i < pu_w * pu_h; ++i)
+    {
+      int y = i / pu_w;
+      int x = i % pu_w;
+      int16_t sample_L0 = px_L0i << (14 - KVZ_BIT_DEPTH);
+      int16_t sample_L1 = px_L1i << (14 - KVZ_BIT_DEPTH);
+      int32_t rounded = (sample_L0 + sample_L1 + offset) >> shift;
+      dsty * dst_stride + x = kvz_fast_clip_32bit_to_pixel(rounded);
+    }
+  }
+}
 
+static INLINE void bipred_average_im_im_template_avx2(kvz_pixel *dst,
+  kvz_pixel_im *im_L0,
+  kvz_pixel_im *im_L1,
+  unsigned pu_w,
+  unsigned pu_h,
+  unsigned dst_stride)
+{
+  int32_t shift = 15 - KVZ_BIT_DEPTH; // TODO: defines
+  int32_t scalar_offset = 1 << (shift - 1);
+  __m256i offset = _mm256_set1_epi32(scalar_offset);
+
+  bool has_pow2_width = _mm_popcnt_u32(pu_w) == 1;
+  bool area_mod_32 = (pu_w * pu_h) % 32;
+  assert(!(pu_w == 4 && pu_h == 4) && "Branch for 4x4 not yet implemented.");
+  assert(!(pu_w == 2 && pu_h == 8) && "Branch for 2x8 not yet implemented.");
+
+  if (has_pow2_width && area_mod_32 == 0) {
+    for (int i = 0; i < pu_w * pu_h; i += 32) {
+      int y = i / pu_w;
+      int x = i % pu_w;
+
+      __m256i sample_L0_a_16bit = _mm256_loadu_si256((__m256i*)&im_L0i);
+      __m256i sample_L1_a_16bit = _mm256_loadu_si256((__m256i*)&im_L1i);
+      __m256i sample_L0_b_16bit = _mm256_loadu_si256((__m256i*)&im_L0i + 16);
+      __m256i sample_L1_b_16bit = _mm256_loadu_si256((__m256i*)&im_L1i + 16);
+
+      __m256i sample_L0_L1_a_lo = _mm256_unpacklo_epi16(sample_L0_a_16bit, sample_L1_a_16bit);
+      __m256i sample_L0_L1_a_hi = _mm256_unpackhi_epi16(sample_L0_a_16bit, sample_L1_a_16bit);
+      __m256i sample_L0_L1_b_lo = _mm256_unpacklo_epi16(sample_L0_b_16bit, sample_L1_b_16bit);
+      __m256i sample_L0_L1_b_hi = _mm256_unpackhi_epi16(sample_L0_b_16bit, sample_L1_b_16bit);
+
+      __m256i all_ones = _mm256_set1_epi16(1);
+      __m256i avg_a_lo = _mm256_madd_epi16(sample_L0_L1_a_lo, all_ones);
+      __m256i avg_a_hi = _mm256_madd_epi16(sample_L0_L1_a_hi, all_ones);
+      __m256i avg_b_lo = _mm256_madd_epi16(sample_L0_L1_b_lo, all_ones);
+      __m256i avg_b_hi = _mm256_madd_epi16(sample_L0_L1_b_hi, all_ones);
+
+      avg_a_lo = _mm256_add_epi32(avg_a_lo, offset);
+      avg_a_hi = _mm256_add_epi32(avg_a_hi, offset);
+      avg_b_lo = _mm256_add_epi32(avg_b_lo, offset);
+      avg_b_hi = _mm256_add_epi32(avg_b_hi, offset);
+
+      avg_a_lo = _mm256_srai_epi32(avg_a_lo, shift);
+      avg_a_hi = _mm256_srai_epi32(avg_a_hi, shift);
+      avg_b_lo = _mm256_srai_epi32(avg_b_lo, shift);
+      avg_b_hi = _mm256_srai_epi32(avg_b_hi, shift);
+
+      __m256i avg_01  = _mm256_packus_epi32(avg_a_lo, avg_a_hi);
+      __m256i avg_23  = _mm256_packus_epi32(avg_b_lo, avg_b_hi);
+      __m256i avg0213 = _mm256_packus_epi16(avg_01, avg_23);
+      __m256i avg     = _mm256_permute4x64_epi64(avg0213, _MM_SHUFFLE(3, 1, 2, 0));
+
+      switch (pu_w) {
+        case  4: scatter_ymm_4x8_8bit( &dsty * dst_stride + x, avg, dst_stride); break;
+        case  8: scatter_ymm_8x4_8bit( &dsty * dst_stride + x, avg, dst_stride); break;
+        case 16: scatter_ymm_16x2_8bit(&dsty * dst_stride + x, avg, dst_stride); break;
+        case 32: // Same as case 64
+        case 64: _mm256_storeu_si256((__m256i*)&dsty * dst_stride + x, avg); break;
+        default:
+          assert(0 && "Unexpected block width.");
+          break;
+      }
+    }
+  } else if (area_mod_32 == 0) {
+    for (int i = 0; i < pu_w * pu_h; i += 24) {
+
+      int y = i / pu_w;
+      int x = i % pu_w;
+
+      // Last 64 bits of the 256 are not used to simplify the loop
+      __m256i mask              = _mm256_setr_epi64x(-1, -1, -1, 0);
+      __m256i sample_L0_a_16bit = _mm256_loadu_si256((__m256i*)&im_L0i);
+      __m256i sample_L1_a_16bit = _mm256_loadu_si256((__m256i*)&im_L1i);
+      __m256i sample_L0_b_16bit = _mm256_castsi128_si256(_mm_loadu_si128((__m128i*)&im_L0i + 16));
+      __m256i sample_L1_b_16bit = _mm256_castsi128_si256(_mm_loadu_si128((__m128i*)&im_L1i + 16));
+
+      __m256i sample_L0_L1_a_lo = _mm256_unpacklo_epi16(sample_L0_a_16bit, sample_L1_a_16bit);
+      __m256i sample_L0_L1_a_hi = _mm256_unpackhi_epi16(sample_L0_a_16bit, sample_L1_a_16bit);
+      __m256i sample_L0_L1_b_lo = _mm256_unpacklo_epi16(sample_L0_b_16bit, sample_L1_b_16bit);
+      __m256i sample_L0_L1_b_hi = _mm256_unpackhi_epi16(sample_L0_b_16bit, sample_L1_b_16bit);
+
+      __m256i all_ones = _mm256_set1_epi16(1);
+      __m256i avg_a_lo = _mm256_madd_epi16(sample_L0_L1_a_lo, all_ones);
+      __m256i avg_a_hi = _mm256_madd_epi16(sample_L0_L1_a_hi, all_ones);
+      __m256i avg_b_lo = _mm256_madd_epi16(sample_L0_L1_b_lo, all_ones);
+      __m256i avg_b_hi = _mm256_madd_epi16(sample_L0_L1_b_hi, all_ones);
+
+      avg_a_lo = _mm256_add_epi32(avg_a_lo, offset);
+      avg_a_hi = _mm256_add_epi32(avg_a_hi, offset);
+      avg_b_lo = _mm256_add_epi32(avg_b_lo, offset);
+      avg_b_hi = _mm256_add_epi32(avg_b_hi, offset);
+
+      avg_a_lo = _mm256_srai_epi32(avg_a_lo, shift);
+      avg_a_hi = _mm256_srai_epi32(avg_a_hi, shift);
+      avg_b_lo = _mm256_srai_epi32(avg_b_lo, shift);
+      avg_b_hi = _mm256_srai_epi32(avg_b_hi, shift);
+
+      __m256i avg_01  = _mm256_packus_epi32(avg_a_lo, avg_a_hi);
+      __m256i avg_23  = _mm256_packus_epi32(avg_b_lo, avg_b_hi);
+      __m256i avg0213 = _mm256_packus_epi16(avg_01, avg_23);
+      __m256i avg     = _mm256_permute4x64_epi64(avg0213, _MM_SHUFFLE(3, 1, 2, 0));
+
+      switch (pu_w) {
+        case 12: scatter_ymm_12x2_8bit(&dsty * dst_stride + x, avg, dst_stride); break;
+        case 24: // Same as case 48
+        case 48: _mm256_maskstore_epi64((long long*)&dsty * dst_stride + x, mask, avg); break;
+        default:
+          assert(0 && "Unexpected block width.");
+          break;
+      }
+    }
+  } else {
+    // 8x2, 8x6, 6x8 blocks (and maybe 2x8 in the future)
+    switch (pu_w) {
+      case 8: // 8x2, 8x6
+        for (int i = 0; i < pu_w * pu_h; i += 16) {
 
-          // (sample1 + sample2 + offset)>>shift 
-          temp_v_epi32 = _mm256_add_epi32(sample0_epi32, sample1_epi32);
-          temp_v_epi32 = _mm256_add_epi32(temp_v_epi32, offset_epi32);
-          temp_v_epi32 = _mm256_srai_epi32(temp_v_epi32, shift);
+          int y = i / pu_w;
 
+          __m256i sample_L0_16bit = _mm256_loadu_si256((__m256i*)&im_L0i);
+          __m256i sample_L1_16bit = _mm256_loadu_si256((__m256i*)&im_L1i);
 
-          temp_epi16 = _mm256_packs_epi32(temp_u_epi32, temp_u_epi32);
-          temp_epi16 = _mm256_permute4x64_epi64(temp_epi16, _MM_SHUFFLE(3, 1, 2, 0));
-          temp_epi8 = _mm256_packus_epi16(temp_epi16, temp_epi16);
+          __m256i sample_L0_L1_lo = _mm256_unpacklo_epi16(sample_L0_16bit, sample_L1_16bit);
+          __m256i sample_L0_L1_hi = _mm256_unpackhi_epi16(sample_L0_16bit, sample_L1_16bit);
 
-          pointer = (int32_t*)&(lcu->rec.u(y_in_lcu)* LCU_WIDTH_C + x_in_lcu);
-          *pointer = _mm_cvtsi128_si32(_mm256_castsi256_si128(temp_epi8));
+          __m256i all_ones = _mm256_set1_epi16(1);
+          __m256i avg_lo   = _mm256_madd_epi16(sample_L0_L1_lo, all_ones);
+          __m256i avg_hi   = _mm256_madd_epi16(sample_L0_L1_hi, all_ones);
 
+          avg_lo = _mm256_add_epi32(avg_lo, offset);
+          avg_hi = _mm256_add_epi32(avg_hi, offset);
 
-          temp_epi16 = _mm256_packs_epi32(temp_v_epi32, temp_v_epi32);
-          temp_epi16 = _mm256_permute4x64_epi64(temp_epi16, _MM_SHUFFLE(3, 1, 2, 0));
-          temp_epi8 = _mm256_packus_epi16(temp_epi16, temp_epi16);
+          avg_lo = _mm256_srai_epi32(avg_lo, shift);
+          avg_hi = _mm256_srai_epi32(avg_hi, shift);
 
-          pointer = (int32_t*)&(lcu->rec.v(y_in_lcu)* LCU_WIDTH_C + x_in_lcu);
-          *pointer = _mm_cvtsi128_si32(_mm256_castsi256_si128(temp_epi8));
+          __m256i avg256 = _mm256_packus_epi32(avg_lo, avg_hi);
+          avg256         = _mm256_packus_epi16(avg256, avg256);
+          avg256         = _mm256_permute4x64_epi64(avg256, _MM_SHUFFLE(3, 1, 2, 0));
+          __m128i avg    = _mm256_castsi256_si128(avg256);
 
-          for (int temp_i = 4; temp_i < width >> 1; ++temp_i) {
+          _mm_storel_epi64((__m128i*)&dsty * dst_stride, avg);
+          _mm_storeh_pd((double*)&dst(y + 1) * dst_stride, _mm_castsi128_pd(avg));
+        }
+        break;
+      case 6: // 6x8
+        for (int i = 0; i < pu_w * pu_h; i += 12) {
+
+          int y = i / pu_w;
+
+          __m256i mask            = _mm256_setr_epi64x(-1, -1, -1, 0);
+          __m256i sample_L0_16bit = _mm256_maskload_epi64((const long long*)(&im_L0i), mask);
+          __m256i sample_L1_16bit = _mm256_maskload_epi64((const long long*)(&im_L1i), mask);
+
+          __m256i sample_L0_L1_lo = _mm256_unpacklo_epi16(sample_L0_16bit, sample_L1_16bit);
+          __m256i sample_L0_L1_hi = _mm256_unpackhi_epi16(sample_L0_16bit, sample_L1_16bit);
+
+          __m256i all_ones = _mm256_set1_epi16(1);
+          __m256i avg_a_lo = _mm256_madd_epi16(sample_L0_L1_lo, all_ones);
+          __m256i avg_a_hi = _mm256_madd_epi16(sample_L0_L1_hi, all_ones);
+
+          avg_a_lo = _mm256_add_epi32(avg_a_lo, offset);
+          avg_a_hi = _mm256_add_epi32(avg_a_hi, offset);
+
+          avg_a_lo = _mm256_srai_epi32(avg_a_lo, shift);
+          avg_a_hi = _mm256_srai_epi32(avg_a_hi, shift);
+
+          __m256i avg256 = _mm256_packus_epi32(avg_a_lo, avg_a_hi);
+          avg256         = _mm256_packus_epi16(avg256, avg256);
+          avg256         = _mm256_permute4x64_epi64(avg256, _MM_SHUFFLE(3, 1, 2, 0));
+          __m128i avg    = _mm256_castsi256_si128(avg256);
+
+          uint32_t elements_0123 = _mm_cvtsi128_si32(avg);
+          uint16_t elements_45   = _mm_extract_epi16(avg, 2);
+          uint16_t elements_67   = _mm_extract_epi16(avg, 3);
+          uint32_t elements_89ab = _mm_extract_epi32(avg, 2);
+          *(uint32_t*)&dst(y + 0) * dst_stride + 0 = elements_0123;
+          *(uint16_t*)&dst(y + 0) * dst_stride + 4 = elements_45;
+          *(uint16_t*)&dst(y + 1) * dst_stride + 0 = elements_67;
+          *(uint32_t*)&dst(y + 1) * dst_stride + 2 = elements_89ab;
+        }
+        break;
+      default:
+        assert(0 && "Unexpected block width.");
+        break;
+    }
+  }
+}
 
-            // Use only if width>>1 is not divideble by 4
-            int temp_x_in_lcu = (((xpos >> 1) + temp_i) & (LCU_WIDTH_C - 1));
-            int16_t sample0_u = (hi_prec_chroma_rec0 ? high_precision_rec0->uy_in_lcu * LCU_WIDTH_C + temp_x_in_lcu : (temp_lcu_uy_in_lcu * LCU_WIDTH_C + temp_x_in_lcu << (14 - KVZ_BIT_DEPTH)));
-            int16_t sample1_u = (hi_prec_chroma_rec1 ? high_precision_rec1->uy_in_lcu * LCU_WIDTH_C + temp_x_in_lcu : (lcu->rec.uy_in_lcu * LCU_WIDTH_C + temp_x_in_lcu << (14 - KVZ_BIT_DEPTH)));
-            lcu->rec.uy_in_lcu * LCU_WIDTH_C + temp_x_in_lcu = (uint8_t)kvz_fast_clip_32bit_to_pixel((sample0_u + sample1_u + offset) >> shift);
+static void bipred_average_im_im_avx2(kvz_pixel *dst,
+  kvz_pixel_im *im_L0,
+  kvz_pixel_im *im_L1,
+  unsigned pu_w,
+  unsigned pu_h,
+  unsigned dst_stride)
+{
+  // Use scalar code for yet unoptimized block sizes (4x4, 2x8)
+  if (!(pu_w == 4 && pu_h == 4) && pu_w > 2) {
+    switch (pu_w) {
+      case  4: bipred_average_im_im_template_avx2(dst, im_L0, im_L1,  4, pu_h, dst_stride); break;
+      case  8: bipred_average_im_im_template_avx2(dst, im_L0, im_L1,  8, pu_h, dst_stride); break;
+      case 16: bipred_average_im_im_template_avx2(dst, im_L0, im_L1, 16, pu_h, dst_stride); break;
+      case 32: bipred_average_im_im_template_avx2(dst, im_L0, im_L1, 32, pu_h, dst_stride); break;
+      case 64: bipred_average_im_im_template_avx2(dst, im_L0, im_L1, 64, pu_h, dst_stride); break;
+
+      case  6: bipred_average_im_im_template_avx2(dst, im_L0, im_L1,  6, pu_h, dst_stride); break;
+      case 12: bipred_average_im_im_template_avx2(dst, im_L0, im_L1, 12, pu_h, dst_stride); break;
+      case 24: bipred_average_im_im_template_avx2(dst, im_L0, im_L1, 24, pu_h, dst_stride); break;
+      case 48: bipred_average_im_im_template_avx2(dst, im_L0, im_L1, 48, pu_h, dst_stride); break;
+      default:
+        assert(0 && "Unexpected block width.");
+        break;
+    }
+  } else {
+    int32_t shift = 15 - KVZ_BIT_DEPTH; // TODO: defines
+    int32_t offset = 1 << (shift - 1);
+
+    for (int i = 0; i < pu_w * pu_h; ++i)
+    {
+      int y = i / pu_w;
+      int x = i % pu_w;
+      int16_t sample_L0 = im_L0i;
+      int16_t sample_L1 = im_L1i;
+      int32_t rounded = (sample_L0 + sample_L1 + offset) >> shift;
+      dsty * dst_stride + x = kvz_fast_clip_32bit_to_pixel(rounded);
+    }
+  }
+}
 
-            int16_t sample0_v = (hi_prec_chroma_rec0 ? high_precision_rec0->vy_in_lcu * LCU_WIDTH_C + temp_x_in_lcu : (temp_lcu_vy_in_lcu * LCU_WIDTH_C + temp_x_in_lcu << (14 - KVZ_BIT_DEPTH)));
-            int16_t sample1_v = (hi_prec_chroma_rec1 ? high_precision_rec1->vy_in_lcu * LCU_WIDTH_C + temp_x_in_lcu : (lcu->rec.vy_in_lcu * LCU_WIDTH_C + temp_x_in_lcu << (14 - KVZ_BIT_DEPTH)));
-            lcu->rec.vy_in_lcu * LCU_WIDTH_C + temp_x_in_lcu = (uint8_t)kvz_fast_clip_32bit_to_pixel((sample0_v + sample1_v + offset) >> shift);
-          }
-        } else {
-          // Load 8 pixels to vector
-          sample0_epi32 = hi_prec_chroma_rec0 ? _mm256_cvtepi16_epi32(_mm_loadu_si128((__m128i*) &(high_precision_rec0->uy_in_lcu * LCU_WIDTH_C + x_in_lcu))) :
-            _mm256_slli_epi32(_mm256_cvtepu8_epi32(_mm_loadl_epi64((__m128i*) &(temp_lcu_uy_in_lcu * LCU_WIDTH_C + x_in_lcu))), 14 - KVZ_BIT_DEPTH);
+static INLINE void bipred_average_px_im_template_avx2(kvz_pixel *dst,
+  kvz_pixel *px,
+  kvz_pixel_im *im,
+  unsigned pu_w,
+  unsigned pu_h,
+  unsigned dst_stride)
+{
+  int32_t shift = 15 - KVZ_BIT_DEPTH; // TODO: defines
+  int32_t scalar_offset = 1 << (shift - 1);
+  __m256i offset = _mm256_set1_epi32(scalar_offset);
+
+  bool has_pow2_width = _mm_popcnt_u32(pu_w) == 1;
+  bool area_mod_32 = (pu_w * pu_h) % 32;
+  assert(!(pu_w == 4 && pu_h == 4) && "Branch for 4x4 not yet implemented.");
+  assert(!(pu_w == 2 && pu_h == 8) && "Branch for 2x8 not yet implemented.");
+
+  if (has_pow2_width && area_mod_32 == 0) {
+    for (int i = 0; i < pu_w * pu_h; i += 32) {
+
+      int y = i / pu_w;
+      int x = i % pu_w;
+
+      __m256i sample_px_a_16bit = _mm256_cvtepu8_epi16(_mm_loadu_si128((__m128i*)&pxi));
+      __m256i sample_px_b_16bit = _mm256_cvtepu8_epi16(_mm_loadu_si128((__m128i*)&pxi + 16));
+      sample_px_a_16bit         = _mm256_slli_epi16(sample_px_a_16bit, 14 - KVZ_BIT_DEPTH);
+      sample_px_b_16bit         = _mm256_slli_epi16(sample_px_b_16bit, 14 - KVZ_BIT_DEPTH);
+      __m256i sample_im_a_16bit = _mm256_loadu_si256((__m256i*)&imi);
+      __m256i sample_im_b_16bit = _mm256_loadu_si256((__m256i*)&imi + 16);
+
+      __m256i sample_px_im_a_lo = _mm256_unpacklo_epi16(sample_px_a_16bit, sample_im_a_16bit);
+      __m256i sample_px_im_a_hi = _mm256_unpackhi_epi16(sample_px_a_16bit, sample_im_a_16bit);
+      __m256i sample_px_im_b_lo = _mm256_unpacklo_epi16(sample_px_b_16bit, sample_im_b_16bit);
+      __m256i sample_px_im_b_hi = _mm256_unpackhi_epi16(sample_px_b_16bit, sample_im_b_16bit);
+
+      __m256i all_ones  = _mm256_set1_epi16(1);
+      __m256i avg_a_lo = _mm256_madd_epi16(sample_px_im_a_lo, all_ones);
+      __m256i avg_a_hi = _mm256_madd_epi16(sample_px_im_a_hi, all_ones);
+      __m256i avg_b_lo = _mm256_madd_epi16(sample_px_im_b_lo, all_ones);
+      __m256i avg_b_hi = _mm256_madd_epi16(sample_px_im_b_hi, all_ones);
+
+      avg_a_lo = _mm256_add_epi32(avg_a_lo, offset);
+      avg_a_hi = _mm256_add_epi32(avg_a_hi, offset);
+      avg_b_lo = _mm256_add_epi32(avg_b_lo, offset);
+      avg_b_hi = _mm256_add_epi32(avg_b_hi, offset);
+
+      avg_a_lo = _mm256_srai_epi32(avg_a_lo, shift);
+      avg_a_hi = _mm256_srai_epi32(avg_a_hi, shift);
+      avg_b_lo = _mm256_srai_epi32(avg_b_lo, shift);
+      avg_b_hi = _mm256_srai_epi32(avg_b_hi, shift);
+
+      __m256i avg_01  = _mm256_packus_epi32(avg_a_lo, avg_a_hi);
+      __m256i avg_23  = _mm256_packus_epi32(avg_b_lo, avg_b_hi);
+      __m256i avg0213 = _mm256_packus_epi16(avg_01, avg_23);
+      __m256i avg     = _mm256_permute4x64_epi64(avg0213, _MM_SHUFFLE(3, 1, 2, 0));
+
+      switch (pu_w) {
+        case  4: scatter_ymm_4x8_8bit( &dsty * dst_stride + x, avg, dst_stride); break;
+        case  8: scatter_ymm_8x4_8bit( &dsty * dst_stride + x, avg, dst_stride); break;
+        case 16: scatter_ymm_16x2_8bit(&dsty * dst_stride + x, avg, dst_stride); break;
+        case 32: // Same as case 64
+        case 64: _mm256_storeu_si256((__m256i*)&dsty * dst_stride + x, avg); break;
+        default:
+          assert(0 && "Unexpected block width.");
+          break;
+      }
+    }
+  } else if (area_mod_32 == 0) {
+    for (int i = 0; i < pu_w * pu_h; i += 24) {
+
+      int y = i / pu_w;
+      int x = i % pu_w;
+
+      // Last 64 bits of the 256 / 32 bits of the 128 are not used to simplify the loop
+      __m256i mask              = _mm256_setr_epi64x(-1, -1, -1, 0);
+      __m128i sample_px_a_8bit  = _mm_loadu_si128((__m128i*)&pxi);
+      __m128i sample_px_b_8bit  = _mm_loadl_epi64((__m128i*)&pxi + 16);
+      __m256i sample_px_a_16bit = _mm256_cvtepu8_epi16(sample_px_a_8bit);
+      __m256i sample_px_b_16bit = _mm256_cvtepu8_epi16(sample_px_b_8bit);
+      sample_px_a_16bit         = _mm256_slli_epi16(sample_px_a_16bit, 14 - KVZ_BIT_DEPTH);
+      sample_px_b_16bit         = _mm256_slli_epi16(sample_px_b_16bit, 14 - KVZ_BIT_DEPTH);
+      __m256i sample_im_a_16bit = _mm256_loadu_si256((__m256i*)&imi);
+      __m256i sample_im_b_16bit = _mm256_castsi128_si256(_mm_loadu_si128((__m128i*)&imi + 16));
+
+      __m256i sample_px_im_a_lo = _mm256_unpacklo_epi16(sample_px_a_16bit, sample_im_a_16bit);
+      __m256i sample_px_im_a_hi = _mm256_unpackhi_epi16(sample_px_a_16bit, sample_im_a_16bit);
+      __m256i sample_px_im_b_lo = _mm256_unpacklo_epi16(sample_px_b_16bit, sample_im_b_16bit);
+      __m256i sample_px_im_b_hi = _mm256_unpackhi_epi16(sample_px_b_16bit, sample_im_b_16bit);
+
+      __m256i all_ones = _mm256_set1_epi16(1);
+      __m256i avg_a_lo = _mm256_madd_epi16(sample_px_im_a_lo, all_ones);
+      __m256i avg_a_hi = _mm256_madd_epi16(sample_px_im_a_hi, all_ones);
+      __m256i avg_b_lo = _mm256_madd_epi16(sample_px_im_b_lo, all_ones);
+      __m256i avg_b_hi = _mm256_madd_epi16(sample_px_im_b_hi, all_ones);
+
+      avg_a_lo = _mm256_add_epi32(avg_a_lo, offset);
+      avg_a_hi = _mm256_add_epi32(avg_a_hi, offset);
+      avg_b_lo = _mm256_add_epi32(avg_b_lo, offset);
+      avg_b_hi = _mm256_add_epi32(avg_b_hi, offset);
+
+      avg_a_lo = _mm256_srai_epi32(avg_a_lo, shift);
+      avg_a_hi = _mm256_srai_epi32(avg_a_hi, shift);
+      avg_b_lo = _mm256_srai_epi32(avg_b_lo, shift);
+      avg_b_hi = _mm256_srai_epi32(avg_b_hi, shift);
+
+      __m256i avg_01  = _mm256_packus_epi32(avg_a_lo, avg_a_hi);
+      __m256i avg_23  = _mm256_packus_epi32(avg_b_lo, avg_b_hi);
+      __m256i avg0213 = _mm256_packus_epi16(avg_01, avg_23);
+      __m256i avg     = _mm256_permute4x64_epi64(avg0213, _MM_SHUFFLE(3, 1, 2, 0));
+
+      switch (pu_w) {
+        case 12: scatter_ymm_12x2_8bit(&dsty * dst_stride + x, avg, dst_stride); break;
+        case 24: // Same as case 48
+        case 48: _mm256_maskstore_epi64((long long*)&dsty * dst_stride + x, mask, avg); break;
+        default:
+          assert(0 && "Unexpected block width.");
+          break;
+      }
+    }
+  } else {
+    // 8x2, 8x6, 6x8 blocks (and maybe 2x8 in the future)
+    switch (pu_w) {
+      case 8: // 8x2, 8x6
+        for (int i = 0; i < pu_w * pu_h; i += 16) {
 
-          sample1_epi32 = hi_prec_chroma_rec1 ? _mm256_cvtepi16_epi32(_mm_loadu_si128((__m128i*) &(high_precision_rec1->uy_in_lcu * LCU_WIDTH_C + x_in_lcu))) :
-            _mm256_slli_epi32(_mm256_cvtepu8_epi32(_mm_loadl_epi64((__m128i*) &(lcu->rec.uy_in_lcu * LCU_WIDTH_C + x_in_lcu))), 14 - KVZ_BIT_DEPTH);
+          int y = i / pu_w;
 
-          // (sample1 + sample2 + offset)>>shift 
-          temp_u_epi32 = _mm256_add_epi32(sample0_epi32, sample1_epi32);
-          temp_u_epi32 = _mm256_add_epi32(temp_u_epi32, offset_epi32);
-          temp_u_epi32 = _mm256_srai_epi32(temp_u_epi32, shift);
+          __m128i sample_px_8bit  = _mm_loadu_si128((__m128i*)&pxi);
+          __m256i sample_px_16bit = _mm256_cvtepu8_epi16(sample_px_8bit);
+          sample_px_16bit         = _mm256_slli_epi16(sample_px_16bit, 14 - KVZ_BIT_DEPTH);
+          __m256i sample_im_16bit = _mm256_loadu_si256((__m256i*)&imi);
 
-          sample0_epi32 = hi_prec_chroma_rec0 ? _mm256_cvtepi16_epi32(_mm_loadu_si128((__m128i*) &(high_precision_rec0->vy_in_lcu * LCU_WIDTH_C + x_in_lcu))) :
-            _mm256_slli_epi32(_mm256_cvtepu8_epi32(_mm_loadl_epi64((__m128i*) &(temp_lcu_vy_in_lcu * LCU_WIDTH_C + x_in_lcu))), 14 - KVZ_BIT_DEPTH);
+          __m256i sample_px_im_lo = _mm256_unpacklo_epi16(sample_px_16bit, sample_im_16bit);
+          __m256i sample_px_im_hi = _mm256_unpackhi_epi16(sample_px_16bit, sample_im_16bit);
 
-          sample1_epi32 = hi_prec_chroma_rec1 ? _mm256_cvtepi16_epi32(_mm_loadu_si128((__m128i*) &(high_precision_rec1->vy_in_lcu * LCU_WIDTH_C + x_in_lcu))) :
-            _mm256_slli_epi32(_mm256_cvtepu8_epi32(_mm_loadl_epi64((__m128i*) &(lcu->rec.vy_in_lcu * LCU_WIDTH_C + x_in_lcu))), 14 - KVZ_BIT_DEPTH);
+          __m256i all_ones = _mm256_set1_epi16(1);
+          __m256i avg_lo   = _mm256_madd_epi16(sample_px_im_lo, all_ones);
+          __m256i avg_hi   = _mm256_madd_epi16(sample_px_im_hi, all_ones);
 
+          avg_lo = _mm256_add_epi32(avg_lo, offset);
+          avg_hi = _mm256_add_epi32(avg_hi, offset);
 
-          // (sample1 + sample2 + offset)>>shift 
-          temp_v_epi32 = _mm256_add_epi32(sample0_epi32, sample1_epi32);
-          temp_v_epi32 = _mm256_add_epi32(temp_v_epi32, offset_epi32);
-          temp_v_epi32 = _mm256_srai_epi32(temp_v_epi32, shift);
+          avg_lo = _mm256_srai_epi32(avg_lo, shift);
+          avg_hi = _mm256_srai_epi32(avg_hi, shift);
 
-          temp_epi16 = _mm256_packs_epi32(temp_u_epi32, temp_u_epi32);
-          temp_epi16 = _mm256_permute4x64_epi64(temp_epi16, _MM_SHUFFLE(3, 1, 2, 0));
-          temp_epi8 = _mm256_packus_epi16(temp_epi16, temp_epi16);
+          __m256i avg256 = _mm256_packus_epi32(avg_lo, avg_hi);
+          avg256         = _mm256_packus_epi16(avg256, avg256);
+          avg256         = _mm256_permute4x64_epi64(avg256, _MM_SHUFFLE(3, 1, 2, 0));
+          __m128i avg    = _mm256_castsi256_si128(avg256);
 
-          // Store 64-bit integer into memory
-          _mm_storel_epi64((__m128i*)&(lcu->rec.u(y_in_lcu)* LCU_WIDTH_C + x_in_lcu), _mm256_castsi256_si128(temp_epi8));
+          _mm_storel_epi64((__m128i*)&dsty * dst_stride, avg);
+          _mm_storeh_pd((double*)&dst(y + 1) * dst_stride, _mm_castsi128_pd(avg));
+        }
+        break;
+      case 6: // 6x8
+        for (int i = 0; i < pu_w * pu_h; i += 12) {
+
+          int y = i / pu_w;
+
+          __m128i mask128         = _mm_setr_epi32(-1, -1, -1, 0);
+          __m128i sample_px_8bit  = _mm_maskload_epi32((const int*)(&pxi), mask128);
+
+          __m256i mask            = _mm256_setr_epi64x(-1, -1, -1, 0);
+          __m256i sample_px_16bit = _mm256_cvtepu8_epi16(sample_px_8bit);
+          sample_px_16bit         = _mm256_slli_epi16(sample_px_16bit, 14 - KVZ_BIT_DEPTH);
+          __m256i sample_im_16bit = _mm256_maskload_epi64((const long long*)(&imi), mask);
+
+          __m256i sample_px_im_lo = _mm256_unpacklo_epi16(sample_px_16bit, sample_im_16bit);
+          __m256i sample_px_im_hi = _mm256_unpackhi_epi16(sample_px_16bit, sample_im_16bit);
+
+          __m256i all_ones = _mm256_set1_epi16(1);
+          __m256i avg_lo   = _mm256_madd_epi16(sample_px_im_lo, all_ones);
+          __m256i avg_hi   = _mm256_madd_epi16(sample_px_im_hi, all_ones);
+
+          avg_lo = _mm256_add_epi32(avg_lo, offset);
+          avg_hi = _mm256_add_epi32(avg_hi, offset);
+
+          avg_lo = _mm256_srai_epi32(avg_lo, shift);
+          avg_hi = _mm256_srai_epi32(avg_hi, shift);
+
+          __m256i avg256 = _mm256_packus_epi32(avg_lo, avg_hi);
+          avg256         = _mm256_packus_epi16(avg256, avg256);
+          avg256         = _mm256_permute4x64_epi64(avg256, _MM_SHUFFLE(3, 1, 2, 0));
+          __m128i avg    = _mm256_castsi256_si128(avg256);
+
+          uint32_t elements_0123 = _mm_cvtsi128_si32(avg);
+          uint16_t elements_45   = _mm_extract_epi16(avg, 2);
+          uint16_t elements_67   = _mm_extract_epi16(avg, 3);
+          uint32_t elements_89ab = _mm_extract_epi32(avg, 2);
+          *(uint32_t*)&dst(y + 0) * dst_stride + 0 = elements_0123;
+          *(uint16_t*)&dst(y + 0) * dst_stride + 4 = elements_45;
+          *(uint16_t*)&dst(y + 1) * dst_stride + 0 = elements_67;
+          *(uint32_t*)&dst(y + 1) * dst_stride + 2 = elements_89ab;
+        }
+        break;
+      default:
+        assert(0 && "Unexpected block width.");
+        break;
+    }
+  }
+}
 
-          temp_epi16 = _mm256_packs_epi32(temp_v_epi32, temp_v_epi32);
-          temp_epi16 = _mm256_permute4x64_epi64(temp_epi16, _MM_SHUFFLE(3, 1, 2, 0));
-          temp_epi8 = _mm256_packus_epi16(temp_epi16, temp_epi16);
+static void bipred_average_px_im_avx2(kvz_pixel *dst,
+  kvz_pixel *px,
+  kvz_pixel_im *im,
+  unsigned pu_w,
+  unsigned pu_h,
+  unsigned dst_stride)
+{
+  // Use scalar code for yet unoptimized block sizes (4x4, 2x8)
+  if (!(pu_w == 4 && pu_h == 4) && pu_w > 2) {
+    switch (pu_w) {
+      case  4: bipred_average_px_im_template_avx2(dst, px, im,  4, pu_h, dst_stride); break;
+      case  8: bipred_average_px_im_template_avx2(dst, px, im,  8, pu_h, dst_stride); break;
+      case 16: bipred_average_px_im_template_avx2(dst, px, im, 16, pu_h, dst_stride); break;
+      case 32: bipred_average_px_im_template_avx2(dst, px, im, 32, pu_h, dst_stride); break;
+      case 64: bipred_average_px_im_template_avx2(dst, px, im, 64, pu_h, dst_stride); break;
+
+      case  6: bipred_average_px_im_template_avx2(dst, px, im,  6, pu_h, dst_stride); break;
+      case 12: bipred_average_px_im_template_avx2(dst, px, im, 12, pu_h, dst_stride); break;
+      case 24: bipred_average_px_im_template_avx2(dst, px, im, 24, pu_h, dst_stride); break;
+      case 48: bipred_average_px_im_template_avx2(dst, px, im, 48, pu_h, dst_stride); break;
+      default:
+        assert(0 && "Unexpected block width.");
+        break;
+    }
+  } else {
+    int32_t shift = 15 - KVZ_BIT_DEPTH; // TODO: defines
+    int32_t offset = 1 << (shift - 1);
+
+    for (int i = 0; i < pu_w * pu_h; ++i)
+    {
+      int y = i / pu_w;
+      int x = i % pu_w;
+      int16_t sample_px = pxi << (14 - KVZ_BIT_DEPTH);
+      int16_t sample_im = imi;
+      int32_t rounded = (sample_px + sample_im + offset) >> shift;
+      dsty * dst_stride + x = kvz_fast_clip_32bit_to_pixel(rounded);
+    }
+  }
+}
 
-          // Store 64-bit integer into memory
-          _mm_storel_epi64((__m128i*)&(lcu->rec.v(y_in_lcu)* LCU_WIDTH_C + x_in_lcu), _mm256_castsi256_si128(temp_epi8));
-        }
-      }
+static void bipred_average_avx2(lcu_t *const lcu,
+  const yuv_t *const px_L0,
+  const yuv_t *const px_L1,
+  const yuv_im_t *const im_L0,
+  const yuv_im_t *const im_L1,
+  const unsigned pu_x,
+  const unsigned pu_y,
+  const unsigned pu_w,
+  const unsigned pu_h,
+  const unsigned im_flags_L0,
+  const unsigned im_flags_L1,
+  const bool predict_luma,
+  const bool predict_chroma) {
+
+  //After reconstruction, merge the predictors by taking an average of each pixel
+  if (predict_luma) {
+    unsigned pb_offset = SUB_SCU(pu_y) * LCU_WIDTH + SUB_SCU(pu_x);
+
+    if (!(im_flags_L0 & 1) && !(im_flags_L1 & 1)) {
+      bipred_average_px_px_avx2(lcu->rec.y + pb_offset, px_L0->y, px_L1->y, pu_w, pu_h, LCU_WIDTH);
+
+    } else if ((im_flags_L0 & 1) && (im_flags_L1 & 1)) {
+      bipred_average_im_im_avx2(lcu->rec.y + pb_offset, im_L0->y, im_L1->y, pu_w, pu_h, LCU_WIDTH);
+
+    } else {
+      kvz_pixel *src_px    = (im_flags_L0 & 1) ? px_L1->y : px_L0->y;
+      kvz_pixel_im *src_im = (im_flags_L0 & 1) ? im_L0->y : im_L1->y;
+      bipred_average_px_im_avx2(lcu->rec.y + pb_offset, src_px, src_im, pu_w, pu_h, LCU_WIDTH);
+    }
+  }
+  if (predict_chroma) {
+    unsigned pb_offset = SUB_SCU(pu_y) / 2 * LCU_WIDTH_C + SUB_SCU(pu_x) / 2;
+    unsigned pb_w = pu_w / 2;
+    unsigned pb_h = pu_h / 2;
+
+    if (!(im_flags_L0 & 2) && !(im_flags_L1 & 2)) {
+      bipred_average_px_px_avx2(lcu->rec.u + pb_offset, px_L0->u, px_L1->u, pb_w, pb_h, LCU_WIDTH_C);
+      bipred_average_px_px_avx2(lcu->rec.v + pb_offset, px_L0->v, px_L1->v, pb_w, pb_h, LCU_WIDTH_C);
+
+    } else if ((im_flags_L0 & 2) && (im_flags_L1 & 2)) {
+      bipred_average_im_im_avx2(lcu->rec.u + pb_offset, im_L0->u, im_L1->u, pb_w, pb_h, LCU_WIDTH_C);
+      bipred_average_im_im_avx2(lcu->rec.v + pb_offset, im_L0->v, im_L1->v, pb_w, pb_h, LCU_WIDTH_C);
+
+    } else {
+      kvz_pixel    *src_px_u = (im_flags_L0 & 2) ? px_L1->u : px_L0->u;
+      kvz_pixel_im *src_im_u = (im_flags_L0 & 2) ? im_L0->u : im_L1->u;
+      kvz_pixel    *src_px_v = (im_flags_L0 & 2) ? px_L1->v : px_L0->v;
+      kvz_pixel_im *src_im_v = (im_flags_L0 & 2) ? im_L0->v : im_L1->v;
+      bipred_average_px_im_avx2(lcu->rec.u + pb_offset, src_px_u, src_im_u, pb_w, pb_h, LCU_WIDTH_C);
+      bipred_average_px_im_avx2(lcu->rec.v + pb_offset, src_px_v, src_im_v, pb_w, pb_h, LCU_WIDTH_C);
     }
-   }
   }
 }
 
@@ -1278,7 +1744,7 @@
     success &= kvz_strategyselector_register(opaque, "satd_any_size_quad", "avx2", 40, &satd_any_size_quad_avx2);
 
     success &= kvz_strategyselector_register(opaque, "pixels_calc_ssd", "avx2", 40, &pixels_calc_ssd_avx2);
-    success &= kvz_strategyselector_register(opaque, "inter_recon_bipred", "avx2", 40, &inter_recon_bipred_avx2);
+    success &= kvz_strategyselector_register(opaque, "bipred_average", "avx2", 40, &bipred_average_avx2);
     success &= kvz_strategyselector_register(opaque, "get_optimized_sad", "avx2", 40, &get_optimized_sad_avx2);
     success &= kvz_strategyselector_register(opaque, "ver_sad", "avx2", 40, &ver_sad_avx2);
     success &= kvz_strategyselector_register(opaque, "hor_sad", "avx2", 40, &hor_sad_avx2);

kvazaar-2.1.0.tar.gz/src/strategies/avx2/quant-avx2.c -> kvazaar-2.2.0.tar.gz/src/strategies/avx2/quant-avx2.c Changed

kvazaar-2.1.0.tar.gz/src/strategies/generic/encode_coding_tree-generic.c -> kvazaar-2.2.0.tar.gz/src/strategies/generic/encode_coding_tree-generic.c Changed

@@ -43,9 +43,11 @@
                                   uint8_t width,
                                   uint8_t type,
                                   int8_t scan_mode,
-                                  int8_t tr_skip)
+                                  int8_t tr_skip,
+                                  double* bits_out)
 {
   const encoder_control_t * const encoder = state->encoder_control;
+  double bits = 0;
   int c1 = 1;
   uint8_t last_coeff_x = 0;
   uint8_t last_coeff_y = 0;
@@ -111,7 +113,7 @@
   // transform skip flag
   if(width == 4 && encoder->cfg.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");
+    CABAC_FBITS_UPDATE(cabac, cabac->cur_ctx, tr_skip, bits, "transform_skip_flag");
   }
 
   last_coeff_x = pos_last & (width - 1);
@@ -124,7 +126,8 @@
                                  width,
                                  width,
                                  type,
-                                 scan_mode);
+                                 scan_mode,
+                                 bits_out);
 
   scan_pos_sig  = scan_pos_last;
 
@@ -157,8 +160,7 @@
       uint32_t sig_coeff_group   = (sig_coeffgroup_flagcg_blk_pos != 0);
       uint32_t ctx_sig  = kvz_context_get_sig_coeff_group(sig_coeffgroup_flag, cg_pos_x,
                                                       cg_pos_y, width);
-      cabac->cur_ctx = &base_coeff_group_ctxctx_sig;
-      CABAC_BIN(cabac, sig_coeff_group, "coded_sub_block_flag");
+      CABAC_FBITS_UPDATE(cabac, &base_coeff_group_ctxctx_sig, sig_coeff_group, bits, "coded_sub_block_flag");
     }
 
     if (sig_coeffgroup_flagcg_blk_pos) {
@@ -174,8 +176,7 @@
         if (scan_pos_sig > sub_pos || i == 0 || num_non_zero) {
           ctx_sig  = kvz_context_get_sig_ctx_inc(pattern_sig_ctx, scan_mode, pos_x, pos_y,
                                              log2_block_size, type);
-          cabac->cur_ctx = &baseCtxctx_sig;
-          CABAC_BIN(cabac, sig, "sig_coeff_flag");
+          CABAC_FBITS_UPDATE(cabac, &baseCtxctx_sig, sig, bits, "sig_coeff_flag");
         }
 
         if (sig) {
@@ -214,8 +215,7 @@
 
       for (idx = 0; idx < num_c1_flag; idx++) {
         uint32_t symbol = (abs_coeffidx > 1) ? 1 : 0;
-        cabac->cur_ctx = &base_ctx_modc1;
-        CABAC_BIN(cabac, symbol, "coeff_abs_level_greater1_flag");
+        CABAC_FBITS_UPDATE(cabac, &base_ctx_modc1, symbol, bits, "coeff_abs_level_greater1_flag");
 
         if (symbol) {
           c1 = 0;
@@ -234,8 +234,7 @@
 
         if (first_c2_flag_idx != -1) {
           uint8_t symbol = (abs_coefffirst_c2_flag_idx > 2) ? 1 : 0;
-          cabac->cur_ctx      = &base_ctx_mod0;
-          CABAC_BIN(cabac, symbol, "coeff_abs_level_greater2_flag");
+          CABAC_FBITS_UPDATE(cabac, &base_ctx_mod0, symbol, bits, "coeff_abs_level_greater2_flag");
         }
       }
       if (be_valid && sign_hidden) {
@@ -245,11 +244,13 @@
             coeff_signs = coeff_signs ^ kvz_crypto_get_key(state->crypto_hdl, num_non_zero-1);
           }
         CABAC_BINS_EP(cabac, coeff_signs , (num_non_zero - 1), "coeff_sign_flag");
+        if (cabac->only_count) bits += num_non_zero - 1;
       } else {
         if (!cabac->only_count)
           if (encoder->cfg.crypto_features & KVZ_CRYPTO_TRANSF_COEFF_SIGNS)
             coeff_signs = coeff_signs ^ kvz_crypto_get_key(state->crypto_hdl, num_non_zero);
         CABAC_BINS_EP(cabac, coeff_signs, num_non_zero, "coeff_sign_flag");
+        if (cabac->only_count) bits += num_non_zero;
       }
 
       if (c1 == 0 || num_non_zero > C1FLAG_NUMBER) {
@@ -263,9 +264,9 @@
               if (encoder->cfg.crypto_features & KVZ_CRYPTO_TRANSF_COEFFS)
                 kvz_cabac_write_coeff_remain_encry(state, cabac, abs_coeffidx - base_level, go_rice_param, base_level);
               else
-                kvz_cabac_write_coeff_remain(cabac, abs_coeffidx - base_level, go_rice_param);
+                bits += kvz_cabac_write_coeff_remain(cabac, abs_coeffidx - base_level, go_rice_param);
             } else
-              kvz_cabac_write_coeff_remain(cabac, abs_coeffidx - base_level, go_rice_param);
+              bits += kvz_cabac_write_coeff_remain(cabac, abs_coeffidx - base_level, go_rice_param);
 
             if (abs_coeffidx > 3 * (1 << go_rice_param)) {
               go_rice_param = MIN(go_rice_param + 1, 4);
@@ -279,6 +280,7 @@
       }
     }
   }
+  if (cabac->only_count) *bits_out += bits;
 }
 
 int kvz_strategy_register_encode_generic(void* opaque, uint8_t bitdepth)

kvazaar-2.1.0.tar.gz/src/strategies/generic/encode_coding_tree-generic.h -> kvazaar-2.2.0.tar.gz/src/strategies/generic/encode_coding_tree-generic.h Changed

kvazaar-2.1.0.tar.gz/src/strategies/generic/ipol-generic.c -> kvazaar-2.2.0.tar.gz/src/strategies/generic/ipol-generic.c Changed

@@ -131,7 +131,16 @@
   return temp;
 }
 
-void kvz_sample_quarterpel_luma_generic(const encoder_control_t * const encoder, kvz_pixel *src, int16_t src_stride, int width, int height, kvz_pixel *dst, int16_t dst_stride, int8_t hor_flag, int8_t ver_flag, const int16_t mv2)
+void kvz_sample_quarterpel_luma_generic(const encoder_control_t * const encoder,
+  kvz_pixel *src,
+  int16_t src_stride,
+  int width,
+  int height,
+  kvz_pixel *dst,
+  int16_t dst_stride,
+  int8_t hor_flag,
+  int8_t ver_flag,
+  const int16_t mv2)
 {
   //TODO: horizontal and vertical only filtering
   int32_t x, y;
@@ -669,7 +678,16 @@
   }
 }
 
-void kvz_sample_octpel_chroma_generic(const encoder_control_t * const encoder, kvz_pixel *src, int16_t src_stride, int width, int height,kvz_pixel *dst, int16_t dst_stride, int8_t hor_flag, int8_t ver_flag, const int16_t mv2)
+void kvz_sample_octpel_chroma_generic(const encoder_control_t * const encoder,
+  kvz_pixel *src,
+  int16_t src_stride,
+  int width,
+  int height,
+  kvz_pixel *dst,
+  int16_t dst_stride,
+  int8_t hor_flag,
+  int8_t ver_flag,
+  const int16_t mv2)
 {
   //TODO: horizontal and vertical only filtering
   int32_t x, y;

kvazaar-2.1.0.tar.gz/src/strategies/generic/picture-generic.c -> kvazaar-2.2.0.tar.gz/src/strategies/generic/picture-generic.c Changed

@@ -547,60 +547,121 @@
   return ssd >> (2*(KVZ_BIT_DEPTH-8));
 }
 
-static void inter_recon_bipred_generic(const int hi_prec_luma_rec0,
-  const int hi_prec_luma_rec1,
-  const int hi_prec_chroma_rec0,
-  const int hi_prec_chroma_rec1,
-  int32_t height,
-  int32_t width,
-  int32_t ypos,
-  int32_t xpos,
-  const hi_prec_buf_t*high_precision_rec0,
-  const hi_prec_buf_t*high_precision_rec1,
-  lcu_t* lcu,
-  kvz_pixel* temp_lcu_y,
-  kvz_pixel* temp_lcu_u,
-  kvz_pixel* temp_lcu_v,
-  bool predict_luma,
-  bool predict_chroma) {
-
-  int shift = 15 - KVZ_BIT_DEPTH;
-  int offset = 1 << (shift - 1);
-
-  int y_in_lcu;
-  int x_in_lcu;
-
-  //After reconstruction, merge the predictors by taking an average of each pixel
-  for (int temp_y = 0; temp_y < height; ++temp_y) {
-
+static void bipred_average_px_px(kvz_pixel *dst,
+  kvz_pixel *px_L0,
+  kvz_pixel *px_L1,
+  unsigned pu_w,
+  unsigned pu_h,
+  unsigned dst_stride)
+{
+  int32_t shift = 15 - KVZ_BIT_DEPTH; // TODO: defines
+  int32_t offset = 1 << (shift - 1);
+
+  for (int i = 0; i < pu_w * pu_h; ++i)
+  {
+    int y = i / pu_w;
+    int x = i % pu_w;
+    int16_t sample_L0 = px_L0i << (14 - KVZ_BIT_DEPTH);
+    int16_t sample_L1 = px_L1i << (14 - KVZ_BIT_DEPTH);
+    int32_t rounded = (sample_L0 + sample_L1 + offset) >> shift;
+    dsty * dst_stride + x = kvz_fast_clip_32bit_to_pixel(rounded);
+  }
+}
 
-    for (int temp_x = 0; temp_x < width; ++temp_x) {
-      y_in_lcu = ((ypos + temp_y) & ((LCU_WIDTH)-1));
-      x_in_lcu = ((xpos + temp_x) & ((LCU_WIDTH)-1));
+static void bipred_average_im_im(kvz_pixel *dst,
+  kvz_pixel_im *im_L0,
+  kvz_pixel_im *im_L1,
+  unsigned pu_w,
+  unsigned pu_h,
+  unsigned dst_stride)
+{
+  int32_t shift = 15 - KVZ_BIT_DEPTH; // TODO: defines
+  int32_t offset = 1 << (shift - 1);
+
+  for (int i = 0; i < pu_w * pu_h; ++i)
+  {
+    int y = i / pu_w;
+    int x = i % pu_w;
+    int16_t sample_L0 = im_L0i;
+    int16_t sample_L1 = im_L1i;
+    int32_t rounded = (sample_L0 + sample_L1 + offset) >> shift;
+    dsty * dst_stride + x = kvz_fast_clip_32bit_to_pixel(rounded);
+  }
+}
 
-      if (predict_luma) {
-        int16_t sample0_y = (hi_prec_luma_rec0 ? high_precision_rec0->yy_in_lcu * LCU_WIDTH + x_in_lcu : (temp_lcu_yy_in_lcu * LCU_WIDTH + x_in_lcu << (14 - KVZ_BIT_DEPTH)));
-        int16_t sample1_y = (hi_prec_luma_rec1 ? high_precision_rec1->yy_in_lcu * LCU_WIDTH + x_in_lcu : (lcu->rec.yy_in_lcu * LCU_WIDTH + x_in_lcu << (14 - KVZ_BIT_DEPTH)));
+static void bipred_average_px_im(kvz_pixel *dst,
+  kvz_pixel *px,
+  kvz_pixel_im *im,
+  unsigned pu_w,
+  unsigned pu_h,
+  unsigned dst_stride)
+{
+  int32_t shift = 15 - KVZ_BIT_DEPTH; // TODO: defines
+  int32_t offset = 1 << (shift - 1);
+
+  for (int i = 0; i < pu_w * pu_h; ++i)
+  {
+    int y = i / pu_w;
+    int x = i % pu_w;
+    int16_t sample_px = pxi << (14 - KVZ_BIT_DEPTH);
+    int16_t sample_im = imi;
+    int32_t rounded = (sample_px + sample_im + offset) >> shift;
+    dsty * dst_stride + x = kvz_fast_clip_32bit_to_pixel(rounded);
+  }
+}
 
-        lcu->rec.yy_in_lcu * LCU_WIDTH + x_in_lcu = (kvz_pixel)kvz_fast_clip_32bit_to_pixel((sample0_y + sample1_y + offset) >> shift);
-      }
+static void bipred_average_generic(lcu_t *const lcu,
+  const yuv_t *const px_L0,
+  const yuv_t *const px_L1,
+  const yuv_im_t *const im_L0,
+  const yuv_im_t *const im_L1,
+  const unsigned pu_x,
+  const unsigned pu_y,
+  const unsigned pu_w,
+  const unsigned pu_h,
+  const unsigned im_flags_L0,
+  const unsigned im_flags_L1,
+  const bool predict_luma,
+  const bool predict_chroma) {
 
-      if (predict_chroma && (temp_x < width >> 1 && temp_y < height >> 1)) {
+  //After reconstruction, merge the predictors by taking an average of each pixel
+  if (predict_luma) {
+    unsigned pb_offset = SUB_SCU(pu_y) * LCU_WIDTH + SUB_SCU(pu_x);
 
-        y_in_lcu = (((ypos >> 1) + temp_y) & (LCU_WIDTH_C - 1));
-        x_in_lcu = (((xpos >> 1) + temp_x) & (LCU_WIDTH_C - 1));
+    if (!(im_flags_L0 & 1) && !(im_flags_L1 & 1)) {
+      bipred_average_px_px(lcu->rec.y + pb_offset, px_L0->y, px_L1->y, pu_w, pu_h, LCU_WIDTH);
 
-        int16_t sample0_u = (hi_prec_chroma_rec0 ? high_precision_rec0->uy_in_lcu * LCU_WIDTH_C + x_in_lcu : (temp_lcu_uy_in_lcu * LCU_WIDTH_C + x_in_lcu << (14 - KVZ_BIT_DEPTH)));
-        int16_t sample1_u = (hi_prec_chroma_rec1 ? high_precision_rec1->uy_in_lcu * LCU_WIDTH_C + x_in_lcu : (lcu->rec.uy_in_lcu * LCU_WIDTH_C + x_in_lcu << (14 - KVZ_BIT_DEPTH)));
-        lcu->rec.uy_in_lcu * LCU_WIDTH_C + x_in_lcu = (kvz_pixel)kvz_fast_clip_32bit_to_pixel((sample0_u + sample1_u + offset) >> shift);
+    } else if ((im_flags_L0 & 1) && (im_flags_L1 & 1)) {
+      bipred_average_im_im(lcu->rec.y + pb_offset, im_L0->y, im_L1->y, pu_w, pu_h, LCU_WIDTH);
 
-        int16_t sample0_v = (hi_prec_chroma_rec0 ? high_precision_rec0->vy_in_lcu * LCU_WIDTH_C + x_in_lcu : (temp_lcu_vy_in_lcu * LCU_WIDTH_C + x_in_lcu << (14 - KVZ_BIT_DEPTH)));
-        int16_t sample1_v = (hi_prec_chroma_rec1 ? high_precision_rec1->vy_in_lcu * LCU_WIDTH_C + x_in_lcu : (lcu->rec.vy_in_lcu * LCU_WIDTH_C + x_in_lcu << (14 - KVZ_BIT_DEPTH)));
-        lcu->rec.vy_in_lcu * LCU_WIDTH_C + x_in_lcu = (kvz_pixel)kvz_fast_clip_32bit_to_pixel((sample0_v + sample1_v + offset) >> shift);
-      }
+    } else {
+      kvz_pixel    *src_px = (im_flags_L0 & 1) ? px_L1->y : px_L0->y;
+      kvz_pixel_im *src_im = (im_flags_L0 & 1) ? im_L0->y : im_L1->y;
+      bipred_average_px_im(lcu->rec.y + pb_offset, src_px, src_im, pu_w, pu_h, LCU_WIDTH);
+    }
+  }
+  if (predict_chroma) {
+    unsigned pb_offset = SUB_SCU(pu_y) / 2 * LCU_WIDTH_C + SUB_SCU(pu_x) / 2;
+    unsigned pb_w = pu_w / 2;
+    unsigned pb_h = pu_h / 2;
+
+    if (!(im_flags_L0 & 2) && !(im_flags_L1 & 2)) {
+      bipred_average_px_px(lcu->rec.u + pb_offset, px_L0->u, px_L1->u, pb_w, pb_h, LCU_WIDTH_C);
+      bipred_average_px_px(lcu->rec.v + pb_offset, px_L0->v, px_L1->v, pb_w, pb_h, LCU_WIDTH_C);
+
+    } else if ((im_flags_L0 & 2) && (im_flags_L1 & 2)) {
+      bipred_average_im_im(lcu->rec.u + pb_offset, im_L0->u, im_L1->u, pb_w, pb_h, LCU_WIDTH_C);
+      bipred_average_im_im(lcu->rec.v + pb_offset, im_L0->v, im_L1->v, pb_w, pb_h, LCU_WIDTH_C);
+
+    } else {
+      kvz_pixel    *src_px_u = (im_flags_L0 & 2) ? px_L1->u : px_L0->u;
+      kvz_pixel_im *src_im_u = (im_flags_L0 & 2) ? im_L0->u : im_L1->u;
+      kvz_pixel    *src_px_v = (im_flags_L0 & 2) ? px_L1->v : px_L0->v;
+      kvz_pixel_im *src_im_v = (im_flags_L0 & 2) ? im_L0->v : im_L1->v;
+      bipred_average_px_im(lcu->rec.u + pb_offset, src_px_u, src_im_u, pb_w, pb_h, LCU_WIDTH_C);
+      bipred_average_px_im(lcu->rec.v + pb_offset, src_px_v, src_im_v, pb_w, pb_h, LCU_WIDTH_C);
     }
   }
-
 }
 
 
@@ -746,7 +807,7 @@
   success &= kvz_strategyselector_register(opaque, "satd_any_size_quad", "generic", 0, &satd_any_size_quad_generic);
 
   success &= kvz_strategyselector_register(opaque, "pixels_calc_ssd", "generic", 0, &pixels_calc_ssd_generic);
-  success &= kvz_strategyselector_register(opaque, "inter_recon_bipred", "generic", 0, &inter_recon_bipred_generic);
+  success &= kvz_strategyselector_register(opaque, "bipred_average", "generic", 0, &bipred_average_generic);
 
   success &= kvz_strategyselector_register(opaque, "get_optimized_sad", "generic", 0, &get_optimized_sad_generic);
   success &= kvz_strategyselector_register(opaque, "ver_sad", "generic", 0, &ver_sad_generic);

kvazaar-2.1.0.tar.gz/src/strategies/generic/quant-generic.c -> kvazaar-2.2.0.tar.gz/src/strategies/generic/quant-generic.c Changed

kvazaar-2.1.0.tar.gz/src/strategies/strategies-dct.h -> kvazaar-2.2.0.tar.gz/src/strategies/strategies-dct.h Changed

kvazaar-2.1.0.tar.gz/src/strategies/strategies-encode.h -> kvazaar-2.2.0.tar.gz/src/strategies/strategies-encode.h Changed

kvazaar-2.1.0.tar.gz/src/strategies/strategies-ipol.h -> kvazaar-2.2.0.tar.gz/src/strategies/strategies-ipol.h Changed

@@ -43,15 +43,15 @@
 #include "kvazaar.h"
 #include "search_inter.h"
 
-// AVX2 implementation of horizontal filter reads and
-// writes two rows for luma and four for chroma at a time.
-// Extra vertical padding is added to prevent segfaults.
-// Horizontal padding is not needed even if one extra byte
-// is read because kvz_image_alloc adds enough padding.
-#define KVZ_IPOL_MAX_INPUT_SIZE_LUMA_SIMD ((KVZ_EXT_BLOCK_W_LUMA + 1) * KVZ_EXT_BLOCK_W_LUMA)
-#define KVZ_IPOL_MAX_INPUT_SIZE_CHROMA_SIMD ((KVZ_EXT_BLOCK_W_CHROMA + 3) * KVZ_EXT_BLOCK_W_CHROMA)
-#define KVZ_IPOL_MAX_IM_SIZE_LUMA_SIMD ((KVZ_EXT_BLOCK_W_LUMA + 1) * LCU_WIDTH)
-#define KVZ_IPOL_MAX_IM_SIZE_CHROMA_SIMD ((KVZ_EXT_BLOCK_W_CHROMA + 3) * LCU_WIDTH_C)
+ // AVX2 implementation of horizontal filter reads and
+ // writes two rows for luma and four for chroma at a time.
+ // Extra vertical padding is added to prevent segfaults.
+ // Needs one extra byte for input buffer to prevent ASAN
+ // error because AVX2 reads one extra byte in the end.
+#define KVZ_IPOL_MAX_INPUT_SIZE_LUMA_SIMD   ((KVZ_EXT_BLOCK_W_LUMA   + 1) * KVZ_EXT_BLOCK_W_LUMA   + 1)
+#define KVZ_IPOL_MAX_INPUT_SIZE_CHROMA_SIMD ((KVZ_EXT_BLOCK_W_CHROMA + 3) * KVZ_EXT_BLOCK_W_CHROMA + 1)
+#define KVZ_IPOL_MAX_IM_SIZE_LUMA_SIMD      ((KVZ_EXT_BLOCK_W_LUMA   + 1) * LCU_WIDTH)
+#define KVZ_IPOL_MAX_IM_SIZE_CHROMA_SIMD    ((KVZ_EXT_BLOCK_W_CHROMA + 3) * LCU_WIDTH_C)
 
 // On top of basic interpolation, FME needs one extra
 // column and row for ME (left and up). Adding the
@@ -101,6 +101,28 @@
 typedef void(kvz_sample_quarterpel_luma_hi_func)(const encoder_control_t * const encoder, kvz_pixel *src, int16_t src_stride, int width, int height, int16_t *dst, int16_t dst_stride, int8_t hor_flag, int8_t ver_flag, const int16_t mv2);
 typedef void(kvz_sample_octpel_chroma_hi_func)(const encoder_control_t * const encoder, kvz_pixel *src, int16_t src_stride, int width, int height, int16_t *dst, int16_t dst_stride, int8_t hor_flag, int8_t ver_flag, const int16_t mv2);
 
+typedef void(kvz_sample_14bit_quarterpel_luma_func)(const encoder_control_t * const encoder,
+  kvz_pixel *src,
+  int16_t src_stride,
+  int width,
+  int height,
+  int16_t *dst,
+  int16_t dst_stride,
+  int8_t hor_flag,
+  int8_t ver_flag,
+  const int16_t mv2);
+
+typedef void(kvz_sample_14bit_octpel_chroma_func)(const encoder_control_t *const encoder,
+  kvz_pixel *src,
+  int16_t src_stride,
+  int width,
+  int height,
+  int16_t *dst,
+  int16_t dst_stride,
+  int8_t hor_flag,
+  int8_t ver_flag,
+  const int16_t mv2);
+
 // Declare function pointers.
 extern ipol_blocks_func * kvz_filter_hpel_blocks_hor_ver_luma;
 extern ipol_blocks_func * kvz_filter_hpel_blocks_diag_luma;

kvazaar-2.1.0.tar.gz/src/strategies/strategies-picture.c -> kvazaar-2.2.0.tar.gz/src/strategies/strategies-picture.c Changed

kvazaar-2.1.0.tar.gz/src/strategies/strategies-picture.h -> kvazaar-2.2.0.tar.gz/src/strategies/strategies-picture.h Changed

@@ -133,22 +133,19 @@
                                 int32_t width, int32_t height, uint32_t pic_stride,
                                 uint32_t ref_stride, uint32_t left, uint32_t right);
 
-typedef void (inter_recon_bipred_func)(const int hi_prec_luma_rec0,
-    const int hi_prec_luma_rec1,
-    const int hi_prec_chroma_rec0,
-    const int hi_prec_chroma_rec1,
-    int height,
-    int width,
-    int ypos,
-    int xpos,
-    const hi_prec_buf_t*high_precision_rec0,
-    const hi_prec_buf_t*high_precision_rec1,
-    lcu_t* lcu,
-    kvz_pixel temp_lcu_yLCU_WIDTH*LCU_WIDTH,
-    kvz_pixel temp_lcu_uLCU_WIDTH_C*LCU_WIDTH_C,
-    kvz_pixel temp_lcu_vLCU_WIDTH_C*LCU_WIDTH_C,
-    bool predict_luma,
-    bool predict_chroma);  
+typedef void (inter_recon_bipred_func)(lcu_t * const lcu,
+  const yuv_t *const px_L0,
+  const yuv_t *const px_L1,
+  const yuv_im_t *const im_L0,
+  const yuv_im_t *const im_L1,
+  const unsigned pu_x,
+  const unsigned pu_y,
+  const unsigned pu_w,
+  const unsigned pu_h,
+  const unsigned im_flags_L0,
+  const unsigned im_flags_L1,
+  const bool predict_luma,
+  const bool predict_chroma);
 
 typedef double (pixel_var_func)(const kvz_pixel *buf, const uint32_t len);
 
@@ -184,7 +181,7 @@
 
 extern pixels_calc_ssd_func *kvz_pixels_calc_ssd;
 
-extern inter_recon_bipred_func * kvz_inter_recon_bipred_blend;
+extern inter_recon_bipred_func * kvz_bipred_average;
 
 extern get_optimized_sad_func *kvz_get_optimized_sad;
 extern ver_sad_func *kvz_ver_sad;
@@ -223,7 +220,7 @@
   {"satd_64x64_dual", (void**) &kvz_satd_64x64_dual}, \
   {"satd_any_size_quad", (void**) &kvz_satd_any_size_quad}, \
   {"pixels_calc_ssd", (void**) &kvz_pixels_calc_ssd}, \
-  {"inter_recon_bipred", (void**) &kvz_inter_recon_bipred_blend}, \
+  {"bipred_average", (void**) &kvz_bipred_average}, \
   {"get_optimized_sad", (void**) &kvz_get_optimized_sad}, \
   {"ver_sad", (void**) &kvz_ver_sad}, \
   {"hor_sad", (void**) &kvz_hor_sad}, \

kvazaar-2.1.0.tar.gz/src/strategies/strategies-quant.h -> kvazaar-2.2.0.tar.gz/src/strategies/strategies-quant.h Changed

@@ -45,18 +45,18 @@
 #include "tables.h"
 
 // Declare function pointers.
-typedef unsigned (quant_func)(const encoder_state_t * const state, coeff_t *coef, coeff_t *q_coef, int32_t width,
+typedef void (quant_func)(const encoder_state_t * const state, coeff_t *coef, coeff_t *q_coef, int32_t width,
   int32_t height, int8_t type, int8_t scan_idx, int8_t block_type);
-typedef unsigned (quant_residual_func)(encoder_state_t *const state,
+typedef int32_t (quant_residual_func)(encoder_state_t *const state,
   const cu_info_t *const cur_cu, const int width, const color_t color,
   const coeff_scan_order_t scan_order, const int use_trskip,
   const int in_stride, const int out_stride,
   const kvz_pixel *const ref_in, const kvz_pixel *const pred_in,
   kvz_pixel *rec_out, coeff_t *coeff_out,
   bool early_skip);
-typedef unsigned (dequant_func)(const encoder_state_t * const state, coeff_t *q_coef, coeff_t *coef, int32_t width,
+typedef void (dequant_func)(const encoder_state_t * const state, coeff_t *q_coef, coeff_t *coef, int32_t width,
   int32_t height, int8_t type, int8_t block_type);
-typedef uint32_t (fast_coeff_cost_func)(const coeff_t *coeff, int32_t width, uint64_t weights);
+typedef double (fast_coeff_cost_func)(const coeff_t *coeff, int32_t width, uint64_t weights);
 
 typedef uint32_t (coeff_abs_sum_func)(const coeff_t *coeffs, size_t length);

kvazaar-2.1.0.tar.gz/src/transform.c -> kvazaar-2.2.0.tar.gz/src/transform.c Changed

@@ -250,25 +250,23 @@
   struct {
     kvz_pixel rec4*4;
     coeff_t coeff4*4;
-    uint32_t cost;
+    double cost;
     int has_coeffs;
   } skip, noskip, *best;
-
-  const int bit_cost = (int)(state->lambda + 0.5);
   
   noskip.has_coeffs = kvz_quantize_residual(
       state, cur_cu, width, color, scan_order,
       0, in_stride, 4,
       ref_in, pred_in, noskip.rec, noskip.coeff, false);
   noskip.cost = kvz_pixels_calc_ssd(ref_in, noskip.rec, in_stride, 4, 4);
-  noskip.cost += kvz_get_coeff_cost(state, noskip.coeff, 4, 0, scan_order) * bit_cost;
+  noskip.cost += kvz_get_coeff_cost(state, noskip.coeff, 4, 0, scan_order) * state->lambda;
 
   skip.has_coeffs = kvz_quantize_residual(
     state, cur_cu, width, color, scan_order,
     1, in_stride, 4,
     ref_in, pred_in, skip.rec, skip.coeff, false);
   skip.cost = kvz_pixels_calc_ssd(ref_in, skip.rec, in_stride, 4, 4);
-  skip.cost += kvz_get_coeff_cost(state, skip.coeff, 4, 0, scan_order) * bit_cost;
+  skip.cost += kvz_get_coeff_cost(state, skip.coeff, 4, 0, scan_order) * state->lambda;
 
   if (noskip.cost <= skip.cost) {
     *trskip_out = 0;

kvazaar-2.1.0.tar.gz/tools/appveyor-install.sh -> kvazaar-2.2.0.tar.gz/tools/appveyor-install.sh Changed

Build Results
RPM Lint

Refresh

Comments for request 5653 0

Request History

Aloysius created request over 1 year ago

Update to 2.2.0

Aloysius accepted request over 1 year ago