FPMT: Mark the frames for parallel encode
The level of parallelism is set for the frames that
will be encoded in parallel for FPMT. The consecutive
LF_UPDATE frames and the next INTNL_ARF_UPDATE frame are
marked for parallel encode, depending on the maximum
parallelism-level.
Change-Id: Ie0366420008ecfd1f5680915e1c8e2596bdb2a8f
diff --git a/av1/encoder/firstpass.h b/av1/encoder/firstpass.h
index 46c13b3..d9d3b54 100644
--- a/av1/encoder/firstpass.h
+++ b/av1/encoder/firstpass.h
@@ -201,6 +201,17 @@
REFBUF_STATE refbuf_state[MAX_STATIC_GF_GROUP_LENGTH];
int arf_index; // the index in the gf group of ARF, if no arf, then -1
int size; // The total length of a GOP
+#if CONFIG_FRAME_PARALLEL_ENCODE
+ // Indicates the level of parallelism in frame parallel encodes.
+ // 0 : frame is independently encoded (not part of parallel encodes).
+ // 1 : frame is the first in encode order in a given parallel encode set.
+ // 2 : frame occurs later in encode order in a given parallel encode set.
+ int frame_parallel_level[MAX_STATIC_GF_GROUP_LENGTH];
+ // Indicates whether a frame should act as non-reference frame.
+ // 0 : frame is a reference frame.
+ // 1 : frame is a non-reference frame.
+ int is_frame_non_ref[MAX_STATIC_GF_GROUP_LENGTH];
+#endif // CONFIG_FRAME_PARALLEL_ENCODE
/*!\endcond */
} GF_GROUP;
/*!\cond */
diff --git a/av1/encoder/gop_structure.c b/av1/encoder/gop_structure.c
index 2b35657..2540150 100644
--- a/av1/encoder/gop_structure.c
+++ b/av1/encoder/gop_structure.c
@@ -26,13 +26,32 @@
#include "av1/encoder/firstpass.h"
#include "av1/encoder/gop_structure.h"
+#if CONFIG_FRAME_PARALLEL_ENCODE
+// This function sets gf_group->frame_parallel_level for LF_UPDATE frames based
+// on the value of parallel_frame_count.
+static void set_frame_parallel_level(int *frame_parallel_level,
+ int *parallel_frame_count,
+ int max_parallel_frames) {
+ assert(*parallel_frame_count > 0);
+ // parallel_frame_count > 1 indicates subsequent frame(s) in the current
+ // parallel encode set.
+ *frame_parallel_level = 1 + (*parallel_frame_count > 1);
+ // Update the count of no. of parallel frames.
+ (*parallel_frame_count)++;
+ if (*parallel_frame_count > max_parallel_frames) *parallel_frame_count = 1;
+}
+#endif // CONFIG_FRAME_PARALLEL_ENCODE
+
// Set parameters for frames between 'start' and 'end' (excluding both).
-static void set_multi_layer_params(const TWO_PASS *twopass,
- GF_GROUP *const gf_group,
- const PRIMARY_RATE_CONTROL *p_rc,
- RATE_CONTROL *rc, FRAME_INFO *frame_info,
- int start, int end, int *cur_frame_idx,
- int *frame_ind, int layer_depth) {
+static void set_multi_layer_params(
+ const TWO_PASS *twopass, GF_GROUP *const gf_group,
+ const PRIMARY_RATE_CONTROL *p_rc, RATE_CONTROL *rc, FRAME_INFO *frame_info,
+ int start, int end, int *cur_frame_idx, int *frame_ind,
+#if CONFIG_FRAME_PARALLEL_ENCODE
+ int *parallel_frame_count, int max_parallel_frames,
+ int do_frame_parallel_encode,
+#endif // CONFIG_FRAME_PARALLEL_ENCODE
+ int layer_depth) {
const int num_frames_to_process = end - start;
// Either we are at the last level of the pyramid, or we don't have enough
@@ -51,6 +70,15 @@
gf_group->refbuf_state[*frame_ind] = REFBUF_UPDATE;
gf_group->max_layer_depth =
AOMMAX(gf_group->max_layer_depth, layer_depth);
+#if CONFIG_FRAME_PARALLEL_ENCODE
+ // Set the level of parallelism for the LF_UPDATE frame.
+ if (do_frame_parallel_encode) {
+ set_frame_parallel_level(&gf_group->frame_parallel_level[*frame_ind],
+ parallel_frame_count, max_parallel_frames);
+ // Set LF_UPDATE frames as non-reference frames.
+ gf_group->is_frame_non_ref[*frame_ind] = 1;
+ }
+#endif // CONFIG_FRAME_PARALLEL_ENCODE
++(*frame_ind);
++(*cur_frame_idx);
++start;
@@ -66,6 +94,18 @@
gf_group->frame_type[*frame_ind] = INTER_FRAME;
gf_group->refbuf_state[*frame_ind] = REFBUF_UPDATE;
+#if CONFIG_FRAME_PARALLEL_ENCODE
+ if (do_frame_parallel_encode) {
+ // If max_parallel_frames is not exceeded, encode the next internal ARF
+ // frame in parallel.
+ if (*parallel_frame_count > 1 &&
+ *parallel_frame_count <= max_parallel_frames) {
+ gf_group->frame_parallel_level[*frame_ind] = 2;
+ *parallel_frame_count = 1;
+ }
+ }
+#endif // CONFIG_FRAME_PARALLEL_ENCODE
+
// Get the boost factor for intermediate ARF frames.
gf_group->arf_boost[*frame_ind] = av1_calc_arf_boost(
twopass, p_rc, rc, frame_info, m, end - m, m - start, NULL, NULL, 0);
@@ -73,7 +113,12 @@
// Frames displayed before this internal ARF.
set_multi_layer_params(twopass, gf_group, p_rc, rc, frame_info, start, m,
- cur_frame_idx, frame_ind, layer_depth + 1);
+ cur_frame_idx, frame_ind,
+#if CONFIG_FRAME_PARALLEL_ENCODE
+ parallel_frame_count, max_parallel_frames,
+ do_frame_parallel_encode,
+#endif // CONFIG_FRAME_PARALLEL_ENCODE
+ layer_depth + 1);
// Overlay for internal ARF.
gf_group->update_type[*frame_ind] = INTNL_OVERLAY_UPDATE;
@@ -88,7 +133,12 @@
// Frames displayed after this internal ARF.
set_multi_layer_params(twopass, gf_group, p_rc, rc, frame_info, m + 1, end,
- cur_frame_idx, frame_ind, layer_depth + 1);
+ cur_frame_idx, frame_ind,
+#if CONFIG_FRAME_PARALLEL_ENCODE
+ parallel_frame_count, max_parallel_frames,
+ do_frame_parallel_encode,
+#endif // CONFIG_FRAME_PARALLEL_ENCODE
+ layer_depth + 1);
}
}
@@ -105,6 +155,16 @@
first_frame_update_type == OVERLAY_UPDATE ||
first_frame_update_type == GF_UPDATE);
+#if CONFIG_FRAME_PARALLEL_ENCODE
+ // Initialize gf_group->frame_parallel_level and gf_group->is_frame_non_ref to
+ // 0.
+ memset(
+ gf_group->frame_parallel_level, 0,
+ sizeof(gf_group->frame_parallel_level[0]) * MAX_STATIC_GF_GROUP_LENGTH);
+ memset(gf_group->is_frame_non_ref, 0,
+ sizeof(gf_group->is_frame_non_ref[0]) * MAX_STATIC_GF_GROUP_LENGTH);
+#endif
+
if (first_frame_update_type == KF_UPDATE &&
cpi->oxcf.kf_cfg.enable_keyframe_filtering > 1) {
gf_group->update_type[frame_index] = ARF_UPDATE;
@@ -158,10 +218,24 @@
gf_group->arf_index = -1;
}
+#if CONFIG_FRAME_PARALLEL_ENCODE
+ // Running count of no. of frames that is part of a given parallel
+ // encode set in a gf_group. Value of 1 indicates no parallel encode.
+ int parallel_frame_count = 1;
+ // Enable parallel encode of frames if gf_group has a multi-layer pyramid
+ // structure.
+ int do_frame_parallel_encode = (cpi->ppi->num_fp_contexts > 1 && use_altref);
+#endif // CONFIG_FRAME_PARALLEL_ENCODE
+
// Rest of the frames.
set_multi_layer_params(twopass, gf_group, p_rc, rc, frame_info,
cur_frame_index, gf_interval, &cur_frame_index,
- &frame_index, use_altref + 1);
+ &frame_index,
+#if CONFIG_FRAME_PARALLEL_ENCODE
+ ¶llel_frame_count, cpi->ppi->num_fp_contexts,
+ do_frame_parallel_encode,
+#endif // CONFIG_FRAME_PARALLEL_ENCODE
+ use_altref + 1);
if (use_altref) {
gf_group->update_type[frame_index] = OVERLAY_UPDATE;
@@ -186,6 +260,17 @@
++frame_index;
}
}
+#if CONFIG_FRAME_PARALLEL_ENCODE
+ if (do_frame_parallel_encode) {
+ // If frame_parallel_level is set to 1 for the last LF_UPDATE
+ // frame in the gf_group, reset it to zero since there are no subsequent
+ // frames in the gf_group.
+ if (gf_group->frame_parallel_level[frame_index - 2] == 1) {
+ assert(gf_group->update_type[frame_index - 2] == LF_UPDATE);
+ gf_group->frame_parallel_level[frame_index - 2] = 0;
+ }
+ }
+#endif
return frame_index;
}
