commit ee55eff573b30825986c241aa502c776c1531b47
author Sarah Parker <sarahparker@google.com> Mon Oct 26 22:40:06 2020 -0700
committer Sarah Parker <sarahparker@google.com> Wed Oct 28 07:46:05 2020 +0000
tree d726e06f3809591d4fff72c21ec3ef4097b3a33d
parent 13b3eabe4fc83c5c35481ad437e660c991b8c2ce

Adjust init_ref_map_pair to help find free index

This moves the functionality previously in
get_free_ref_map_index to init_ref_map_pair in order to
build a correct reference map for the TPL model.

BUG=aomedia:2864

Change-Id: I5ff45dc480a8d94b7e92a2f2a9da2646695c5624

av1/encoder/encode_strategy.c

diff --git a/av1/encoder/encode_strategy.c b/av1/encoder/encode_strategy.c
index 40573f6..5d08d3d 100644
--- a/av1/encoder/encode_strategy.c
+++ b/av1/encoder/encode_strategy.c
@@ -853,23 +853,9 @@
   return;
 }
 
-static int get_free_ref_map_index(const AV1_COMMON *const cm) {
-  for (int idx = 0; idx < REF_FRAMES - 1; ++idx) {
-    // Get reference frame buffer
-    const RefCntBuffer *const buf = cm->ref_frame_map[idx];
-    if (buf == NULL) return idx;
-    // Once the keyframe is coded, the slots in ref_frame_map will all
-    // point to the same frame. In that case, all subsequent pointers
-    // matching the current are considered "free" slots. This will find
-    // the next occurance of the current pointer if ref_count indicates
-    // there are multiple instances of it.
-    if (buf->ref_count > 1) {
-      for (int idx2 = idx + 1; idx2 < REF_FRAMES; ++idx2) {
-        const RefCntBuffer *const buf2 = cm->ref_frame_map[idx2];
-        if (buf2 == buf) return idx2;
-      }
-    }
-  }
+static int get_free_ref_map_index(RefFrameMapPair ref_map_pairs[REF_FRAMES]) {
+  for (int idx = 0; idx < REF_FRAMES; ++idx)
+    if (ref_map_pairs[idx].disp_order == -1) return idx;
   return INVALID_IDX;
 }
 
@@ -1032,7 +1018,7 @@
   }
 
   // Search for the open slot to store the current frame.
-  int free_fb_index = get_free_ref_map_index(cm);
+  int free_fb_index = get_free_ref_map_index(ref_frame_map_pairs);
 
   if (use_subgop_cfg(&cpi->gf_group, gf_index)) {
     return get_refresh_frame_flags_subgop_cfg(cpi, gf_index, cur_disp_order,

av1/encoder/encoder.h

diff --git a/av1/encoder/encoder.h b/av1/encoder/encoder.h
index c37a8a4..4cdeb91 100644
--- a/av1/encoder/encoder.h
+++ b/av1/encoder/encoder.h
@@ -2839,14 +2839,31 @@
 
 static INLINE void init_ref_map_pair(
     AV1_COMP *cpi, RefFrameMapPair ref_frame_map_pairs[REF_FRAMES]) {
-  memset(ref_frame_map_pairs, -1, sizeof(*ref_frame_map_pairs) * REF_FRAMES);
+  memset(ref_frame_map_pairs, 0, sizeof(*ref_frame_map_pairs) * REF_FRAMES);
   for (int map_idx = 0; map_idx < REF_FRAMES; map_idx++) {
     // Get reference frame buffer
     const RefCntBuffer *const buf = cpi->common.ref_frame_map[map_idx];
-    if (buf == NULL) continue;
+    if (ref_frame_map_pairs[map_idx].disp_order == -1) continue;
+    if (buf == NULL) {
+      ref_frame_map_pairs[map_idx].disp_order = -1;
+      ref_frame_map_pairs[map_idx].pyr_level = -1;
+      continue;
+    } else if (buf->ref_count > 1) {
+      // Once the keyframe is coded, the slots in ref_frame_map will all
+      // point to the same frame. In that case, all subsequent pointers
+      // matching the current are considered "free" slots. This will find
+      // the next occurance of the current pointer if ref_count indicates
+      // there are multiple instances of it and mark it as free.
+      for (int idx2 = map_idx + 1; idx2 < REF_FRAMES; ++idx2) {
+        const RefCntBuffer *const buf2 = cpi->common.ref_frame_map[idx2];
+        if (buf2 == buf) {
+          ref_frame_map_pairs[idx2].disp_order = -1;
+          ref_frame_map_pairs[idx2].pyr_level = -1;
+        }
+      }
+    }
     ref_frame_map_pairs[map_idx].disp_order = (int)buf->display_order_hint;
-    const int reference_frame_level = buf->pyramid_level;
-    ref_frame_map_pairs[map_idx].pyr_level = reference_frame_level;
+    ref_frame_map_pairs[map_idx].pyr_level = buf->pyramid_level;
   }
 }