Revert "[Normative] Move global info to ref buffer"

This reverts commit c9b6f23bc0be2327e1cb5be9391b850c2e02abcb.

Reason for revert: Appears to be responsible for AV1/AVxEncoderThreadLSTest.EncoderResultTest/3 failing on the current tip of tree

Change-Id: I95c9e6eee7af96700ed123f945bc6d5e3b6c348b

av1/common/av1_loopfilter.c

diff --git a/av1/common/av1_loopfilter.c b/av1/common/av1_loopfilter.c
index ff57b0f..937dc5b 100644
--- a/av1/common/av1_loopfilter.c
+++ b/av1/common/av1_loopfilter.c
@@ -655,6 +655,7 @@
 
   // init limits for given sharpness
   update_sharpness(lfi, lf->sharpness_level);
+  lf->last_sharpness_level = lf->sharpness_level;
 
   // init hev threshold const vectors
   for (lvl = 0; lvl <= MAX_LOOP_FILTER; lvl++)
@@ -672,19 +673,9 @@
   const struct segmentation *const seg = &cm->seg;
 
   // update limits if sharpness has changed
-  int last_sharpness_level;
-  if (cm->primary_ref_frame == PRIMARY_REF_NONE) {
-    last_sharpness_level = -1;  // default value
-  } else {
-    const int buf_idx = cm->frame_refs[cm->primary_ref_frame].idx;
-    last_sharpness_level = cm->buffer_pool->frame_bufs[buf_idx].sharpness_level;
-  }
-  if (last_sharpness_level != lf->sharpness_level) {
+  if (lf->last_sharpness_level != lf->sharpness_level) {
     update_sharpness(lfi, lf->sharpness_level);
-    const int buf_idx = cm->frame_refs[cm->primary_ref_frame].idx;
-    if (cm->primary_ref_frame != PRIMARY_REF_NONE && buf_idx >= 0)
-      cm->buffer_pool->frame_bufs[buf_idx].sharpness_level =
-          lf->sharpness_level;
+    lf->last_sharpness_level = lf->sharpness_level;
   }
 
   for (seg_id = 0; seg_id < MAX_SEGMENTS; seg_id++) {

av1/common/av1_loopfilter.h

diff --git a/av1/common/av1_loopfilter.h b/av1/common/av1_loopfilter.h
index 7d17fdf..224e499 100644
--- a/av1/common/av1_loopfilter.h
+++ b/av1/common/av1_loopfilter.h
@@ -27,6 +27,8 @@
 
 #define SIMD_WIDTH 16
 
+#define MAX_MODE_LF_DELTAS 2
+
 enum lf_path {
   LF_PATH_420,
   LF_PATH_444,
@@ -120,6 +122,7 @@
   int filter_level_v;
 
   int sharpness_level;
+  int last_sharpness_level;
 
   uint8_t mode_ref_delta_enabled;
   uint8_t mode_ref_delta_update;
@@ -127,9 +130,11 @@
   // 0 = Intra, Last, Last2+Last3,
   // GF, BRF, ARF2, ARF
   int8_t ref_deltas[TOTAL_REFS_PER_FRAME];
+  int8_t last_ref_deltas[TOTAL_REFS_PER_FRAME];
 
   // 0 = ZERO_MV, MV
   int8_t mode_deltas[MAX_MODE_LF_DELTAS];
+  int8_t last_mode_deltas[MAX_MODE_LF_DELTAS];
 
 #if LOOP_FILTER_BITMASK
   LoopFilterMask *lfm;

av1/common/entropymode.c

diff --git a/av1/common/entropymode.c b/av1/common/entropymode.c
index b7345c6..6d04efd 100644
--- a/av1/common/entropymode.c
+++ b/av1/common/entropymode.c
@@ -1144,32 +1144,24 @@
   av1_copy(fc->intrabc_cdf, default_intrabc_cdf);
 }
 
-void av1_set_default_ref_deltas(int8_t *ref_deltas) {
-  assert(ref_deltas != NULL);
-
-  ref_deltas[INTRA_FRAME] = 1;
-  ref_deltas[LAST_FRAME] = 0;
-  ref_deltas[LAST2_FRAME] = ref_deltas[LAST_FRAME];
-  ref_deltas[LAST3_FRAME] = ref_deltas[LAST_FRAME];
-  ref_deltas[BWDREF_FRAME] = ref_deltas[LAST_FRAME];
-  ref_deltas[GOLDEN_FRAME] = -1;
-  ref_deltas[ALTREF2_FRAME] = -1;
-  ref_deltas[ALTREF_FRAME] = -1;
-}
-
-void av1_set_default_mode_deltas(int8_t *mode_deltas) {
-  assert(mode_deltas != NULL);
-
-  mode_deltas[0] = 0;
-  mode_deltas[0] = 0;
-}
-
 static void set_default_lf_deltas(struct loopfilter *lf) {
   lf->mode_ref_delta_enabled = 1;
   lf->mode_ref_delta_update = 1;
 
-  av1_set_default_ref_deltas(lf->ref_deltas);
-  av1_set_default_mode_deltas(lf->mode_deltas);
+  lf->ref_deltas[INTRA_FRAME] = 1;
+  lf->ref_deltas[LAST_FRAME] = 0;
+  lf->ref_deltas[LAST2_FRAME] = lf->ref_deltas[LAST_FRAME];
+  lf->ref_deltas[LAST3_FRAME] = lf->ref_deltas[LAST_FRAME];
+  lf->ref_deltas[BWDREF_FRAME] = lf->ref_deltas[LAST_FRAME];
+  lf->ref_deltas[GOLDEN_FRAME] = -1;
+  lf->ref_deltas[ALTREF2_FRAME] = -1;
+  lf->ref_deltas[ALTREF_FRAME] = -1;
+
+  lf->mode_deltas[0] = 0;
+  lf->mode_deltas[1] = 0;
+
+  av1_copy(lf->last_ref_deltas, lf->ref_deltas);
+  av1_copy(lf->last_mode_deltas, lf->mode_deltas);
 }
 
 void av1_setup_frame_contexts(AV1_COMMON *cm) {
@@ -1184,6 +1176,8 @@
 void av1_setup_past_independence(AV1_COMMON *cm) {
   // Reset the segment feature data to the default stats:
   // Features disabled, 0, with delta coding (Default state).
+  struct loopfilter *const lf = &cm->lf;
+
   av1_clearall_segfeatures(&cm->seg);
 
 #if CONFIG_SEGMENT_PRED_LAST
@@ -1198,10 +1192,13 @@
   if (cm->current_frame_seg_map)
     memset(cm->current_frame_seg_map, 0, (cm->mi_rows * cm->mi_cols));
 
-  // reset mode ref deltas
-  av1_set_default_ref_deltas(cm->cur_frame->ref_deltas);
-  av1_set_default_mode_deltas(cm->cur_frame->mode_deltas);
-  set_default_lf_deltas(&cm->lf);
+  // Reset the mode ref deltas for loop filter
+  av1_zero(lf->last_ref_deltas);
+  av1_zero(lf->last_mode_deltas);
+  set_default_lf_deltas(lf);
+
+  // To force update of the sharpness
+  lf->last_sharpness_level = -1;
 
   av1_default_coef_probs(cm);
   init_mode_probs(cm->fc);

av1/common/entropymode.h

diff --git a/av1/common/entropymode.h b/av1/common/entropymode.h
index 53430c4..0905516 100644
--- a/av1/common/entropymode.h
+++ b/av1/common/entropymode.h
@@ -292,8 +292,6 @@
   { 9, 10, 11, 12, 13, 14, 15, 0, 1, 2, 4, 5, 3, 6, 7, 8 },
 };
 
-void av1_set_default_ref_deltas(int8_t *ref_deltas);
-void av1_set_default_mode_deltas(int8_t *mode_deltas);
 void av1_setup_frame_contexts(struct AV1Common *cm);
 void av1_setup_past_independence(struct AV1Common *cm);
 

av1/common/enums.h

diff --git a/av1/common/enums.h b/av1/common/enums.h
index 400a238..d2dc31f 100644
--- a/av1/common/enums.h
+++ b/av1/common/enums.h
@@ -78,8 +78,6 @@
 #define II_WEDGE_IDX_ENTROPY_CODING 0
 #endif
 
-#define MAX_MODE_LF_DELTAS 2
-
 typedef enum COMPOUND_DIST_WEIGHT_MODE {
   DIST,
 } COMPOUND_DIST_WEIGHT_MODE;

av1/common/onyxc_int.h

diff --git a/av1/common/onyxc_int.h b/av1/common/onyxc_int.h
index 23d1419..76c5eea 100644
--- a/av1/common/onyxc_int.h
+++ b/av1/common/onyxc_int.h
@@ -156,14 +156,6 @@
   // when the frame is fully decoded.
   int row;
   int col;
-
-  // Inter frame reference frame delta for loop filter
-  int8_t ref_deltas[TOTAL_REFS_PER_FRAME];
-
-  // 0 = ZERO_MV, MV
-  int8_t mode_deltas[MAX_MODE_LF_DELTAS];
-
-  int sharpness_level;
 } RefCntBuffer;
 
 typedef struct BufferPool {

av1/decoder/decodeframe.c

diff --git a/av1/decoder/decodeframe.c b/av1/decoder/decodeframe.c
index 3a9d57e..2d107bd 100644
--- a/av1/decoder/decodeframe.c
+++ b/av1/decoder/decodeframe.c
@@ -1144,10 +1144,6 @@
           lf->mode_deltas[i] = aom_rb_read_inv_signed_literal(rb, 6);
     }
   }
-
-  // write deltas to frame buffer
-  memcpy(cm->cur_frame->ref_deltas, lf->ref_deltas, TOTAL_REFS_PER_FRAME);
-  memcpy(cm->cur_frame->mode_deltas, lf->mode_deltas, MAX_MODE_LF_DELTAS);
 }
 
 static void setup_cdef(AV1_COMMON *cm, struct aom_read_bit_buffer *rb) {

av1/decoder/dthread.c

diff --git a/av1/decoder/dthread.c b/av1/decoder/dthread.c
index c186f466..20724ff 100644
--- a/av1/decoder/dthread.c
+++ b/av1/decoder/dthread.c
@@ -176,7 +176,7 @@
 
   memcpy(dst_cm->lf_info.lfthr, src_cm->lf_info.lfthr,
          (MAX_LOOP_FILTER + 1) * sizeof(loop_filter_thresh));
-  dst_cm->lf.sharpness_level = src_cm->lf.sharpness_level;
+  dst_cm->lf.last_sharpness_level = src_cm->lf.sharpness_level;
   dst_cm->lf.filter_level[0] = src_cm->lf.filter_level[0];
   dst_cm->lf.filter_level[1] = src_cm->lf.filter_level[1];
   memcpy(dst_cm->lf.ref_deltas, src_cm->lf.ref_deltas, TOTAL_REFS_PER_FRAME);

av1/encoder/bitstream.c

diff --git a/av1/encoder/bitstream.c b/av1/encoder/bitstream.c
index 6d2786c..108230d 100644
--- a/av1/encoder/bitstream.c
+++ b/av1/encoder/bitstream.c
@@ -2031,38 +2031,25 @@
 
   if (lf->mode_ref_delta_enabled) {
     aom_wb_write_bit(wb, lf->mode_ref_delta_update);
-
     if (lf->mode_ref_delta_update) {
-      const int prime_idx = cm->primary_ref_frame;
-      const int buf_idx =
-          prime_idx == PRIMARY_REF_NONE ? -1 : cm->frame_refs[prime_idx].idx;
-      int8_t last_ref_deltas[TOTAL_REFS_PER_FRAME];
-      if (prime_idx == PRIMARY_REF_NONE || buf_idx < 0) {
-        av1_set_default_ref_deltas(last_ref_deltas);
-      } else {
-        memcpy(last_ref_deltas, cm->buffer_pool->frame_bufs[buf_idx].ref_deltas,
-               TOTAL_REFS_PER_FRAME);
-      }
       for (i = 0; i < TOTAL_REFS_PER_FRAME; i++) {
         const int delta = lf->ref_deltas[i];
-        const int changed = delta != last_ref_deltas[i];
+        const int changed = delta != lf->last_ref_deltas[i];
         aom_wb_write_bit(wb, changed);
-        if (changed) aom_wb_write_inv_signed_literal(wb, delta, 6);
+        if (changed) {
+          lf->last_ref_deltas[i] = delta;
+          aom_wb_write_inv_signed_literal(wb, delta, 6);
+        }
       }
 
-      int8_t last_mode_deltas[MAX_MODE_LF_DELTAS];
-      if (prime_idx == PRIMARY_REF_NONE || buf_idx < 0) {
-        av1_set_default_mode_deltas(last_mode_deltas);
-      } else {
-        memcpy(last_mode_deltas,
-               cm->buffer_pool->frame_bufs[buf_idx].mode_deltas,
-               MAX_MODE_LF_DELTAS);
-      }
       for (i = 0; i < MAX_MODE_LF_DELTAS; i++) {
         const int delta = lf->mode_deltas[i];
-        const int changed = delta != last_mode_deltas[i];
+        const int changed = delta != lf->last_mode_deltas[i];
         aom_wb_write_bit(wb, changed);
-        if (changed) aom_wb_write_inv_signed_literal(wb, delta, 6);
+        if (changed) {
+          lf->last_mode_deltas[i] = delta;
+          aom_wb_write_inv_signed_literal(wb, delta, 6);
+        }
       }
     }
   }

av1/encoder/encoder.c

diff --git a/av1/encoder/encoder.c b/av1/encoder/encoder.c
index b1f519d..8efcd14 100644
--- a/av1/encoder/encoder.c
+++ b/av1/encoder/encoder.c
@@ -556,24 +556,8 @@
   av1_copy(cc->nmv_costs, cpi->nmv_costs);
   av1_copy(cc->nmv_costs_hp, cpi->nmv_costs_hp);
 
-  const int prime_idx = cm->primary_ref_frame;
-  const int buf_idx =
-      prime_idx == PRIMARY_REF_NONE ? -1 : cm->frame_refs[prime_idx].idx;
-  int8_t last_ref_deltas[TOTAL_REFS_PER_FRAME];
-  int8_t last_mode_deltas[MAX_MODE_LF_DELTAS];
-  if (prime_idx == PRIMARY_REF_NONE || buf_idx < 0) {
-    av1_set_default_ref_deltas(last_ref_deltas);
-    av1_set_default_mode_deltas(last_mode_deltas);
-  } else {
-    assert(cm->buffer_pool->frame_bufs[buf_idx].ref_deltas != NULL);
-    memcpy(last_ref_deltas, cm->buffer_pool->frame_bufs[buf_idx].ref_deltas,
-           TOTAL_REFS_PER_FRAME);
-    assert(cm->buffer_pool->frame_bufs[buf_idx].mode_deltas != NULL);
-    memcpy(last_mode_deltas, cm->buffer_pool->frame_bufs[buf_idx].mode_deltas,
-           MAX_MODE_LF_DELTAS);
-  }
-  av1_copy(cc->last_ref_lf_deltas, last_ref_deltas);
-  av1_copy(cc->last_mode_lf_deltas, last_mode_deltas);
+  av1_copy(cc->last_ref_lf_deltas, cm->lf.last_ref_deltas);
+  av1_copy(cc->last_mode_lf_deltas, cm->lf.last_mode_deltas);
 
   cc->fc = *cm->fc;
 }
@@ -588,15 +572,8 @@
   av1_copy(cpi->nmv_costs, cc->nmv_costs);
   av1_copy(cpi->nmv_costs_hp, cc->nmv_costs_hp);
 
-  const int prime_idx = cm->primary_ref_frame;
-  const int buf_idx =
-      prime_idx == PRIMARY_REF_NONE ? -1 : cm->frame_refs[prime_idx].idx;
-  if (prime_idx != PRIMARY_REF_NONE && buf_idx >= 0) {
-    memcpy(cm->buffer_pool->frame_bufs[buf_idx].ref_deltas,
-           cc->last_ref_lf_deltas, TOTAL_REFS_PER_FRAME);
-    memcpy(cm->buffer_pool->frame_bufs[buf_idx].mode_deltas,
-           cc->last_mode_lf_deltas, MAX_MODE_LF_DELTAS);
-  }
+  av1_copy(cm->lf.last_ref_deltas, cc->last_ref_lf_deltas);
+  av1_copy(cm->lf.last_mode_deltas, cc->last_mode_lf_deltas);
 
   *cm->fc = cc->fc;
 }