gop_structure.c (40071B)
1 /* 2 * Copyright (c) 2019, Alliance for Open Media. All rights reserved. 3 * 4 * This source code is subject to the terms of the BSD 2 Clause License and 5 * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License 6 * was not distributed with this source code in the LICENSE file, you can 7 * obtain it at www.aomedia.org/license/software. If the Alliance for Open 8 * Media Patent License 1.0 was not distributed with this source code in the 9 * PATENTS file, you can obtain it at www.aomedia.org/license/patent. 10 */ 11 12 #include <stdint.h> 13 14 #include "av1/common/blockd.h" 15 #include "config/aom_config.h" 16 #include "config/aom_scale_rtcd.h" 17 18 #include "aom/aom_codec.h" 19 #include "aom/aom_encoder.h" 20 21 #include "av1/common/av1_common_int.h" 22 23 #include "av1/encoder/encoder.h" 24 #include "av1/encoder/firstpass.h" 25 #include "av1/encoder/gop_structure.h" 26 #include "av1/encoder/pass2_strategy.h" 27 28 // This function sets gf_group->frame_parallel_level for LF_UPDATE frames based 29 // on the value of parallel_frame_count. 30 static void set_frame_parallel_level(int *frame_parallel_level, 31 int *parallel_frame_count, 32 int max_parallel_frames) { 33 assert(*parallel_frame_count > 0); 34 // parallel_frame_count > 1 indicates subsequent frame(s) in the current 35 // parallel encode set. 36 *frame_parallel_level = 1 + (*parallel_frame_count > 1); 37 // Update the count of no. of parallel frames. 38 (*parallel_frame_count)++; 39 if (*parallel_frame_count > max_parallel_frames) *parallel_frame_count = 1; 40 } 41 42 // This function sets gf_group->src_offset based on frame_parallel_level. 43 // Outputs are gf_group->src_offset and first_frame_index 44 static void set_src_offset(GF_GROUP *const gf_group, int *first_frame_index, 45 int cur_frame_idx, int frame_ind) { 46 if (gf_group->frame_parallel_level[frame_ind] > 0) { 47 if (gf_group->frame_parallel_level[frame_ind] == 1) { 48 *first_frame_index = cur_frame_idx; 49 } 50 51 // Obtain the offset of the frame at frame_ind in the lookahead queue by 52 // subtracting the display order hints of the current frame from the display 53 // order hint of the first frame in parallel encoding set (at 54 // first_frame_index). 55 gf_group->src_offset[frame_ind] = 56 (cur_frame_idx + gf_group->arf_src_offset[frame_ind]) - 57 *first_frame_index; 58 } 59 } 60 61 // Sets the GF_GROUP params for LF_UPDATE frames. 62 static inline void set_params_for_leaf_frames( 63 const TWO_PASS *twopass, const TWO_PASS_FRAME *twopass_frame, 64 const PRIMARY_RATE_CONTROL *p_rc, FRAME_INFO *frame_info, 65 GF_GROUP *const gf_group, int *cur_frame_idx, int *frame_ind, 66 int *parallel_frame_count, int max_parallel_frames, 67 int do_frame_parallel_encode, int *first_frame_index, int *cur_disp_index, 68 int layer_depth, int start, int end) { 69 gf_group->update_type[*frame_ind] = LF_UPDATE; 70 gf_group->arf_src_offset[*frame_ind] = 0; 71 gf_group->cur_frame_idx[*frame_ind] = *cur_frame_idx; 72 gf_group->layer_depth[*frame_ind] = MAX_ARF_LAYERS; 73 gf_group->frame_type[*frame_ind] = INTER_FRAME; 74 gf_group->refbuf_state[*frame_ind] = REFBUF_UPDATE; 75 gf_group->max_layer_depth = AOMMAX(gf_group->max_layer_depth, layer_depth); 76 gf_group->display_idx[*frame_ind] = (*cur_disp_index); 77 gf_group->arf_boost[*frame_ind] = 78 av1_calc_arf_boost(twopass, twopass_frame, p_rc, frame_info, start, 79 end - start, 0, NULL, NULL, 0); 80 ++(*cur_disp_index); 81 82 // Set the level of parallelism for the LF_UPDATE frame. 83 if (do_frame_parallel_encode) { 84 set_frame_parallel_level(&gf_group->frame_parallel_level[*frame_ind], 85 parallel_frame_count, max_parallel_frames); 86 // Set LF_UPDATE frames as non-reference frames. 87 gf_group->is_frame_non_ref[*frame_ind] = true; 88 } 89 set_src_offset(gf_group, first_frame_index, *cur_frame_idx, *frame_ind); 90 91 ++(*frame_ind); 92 ++(*cur_frame_idx); 93 } 94 95 // Sets the GF_GROUP params for INTNL_OVERLAY_UPDATE frames. 96 static inline void set_params_for_intnl_overlay_frames( 97 GF_GROUP *const gf_group, int *cur_frame_idx, int *frame_ind, 98 int *first_frame_index, int *cur_disp_index, int layer_depth) { 99 gf_group->update_type[*frame_ind] = INTNL_OVERLAY_UPDATE; 100 gf_group->arf_src_offset[*frame_ind] = 0; 101 gf_group->cur_frame_idx[*frame_ind] = *cur_frame_idx; 102 gf_group->layer_depth[*frame_ind] = layer_depth; 103 gf_group->frame_type[*frame_ind] = INTER_FRAME; 104 gf_group->refbuf_state[*frame_ind] = REFBUF_UPDATE; 105 gf_group->display_idx[*frame_ind] = (*cur_disp_index); 106 ++(*cur_disp_index); 107 108 set_src_offset(gf_group, first_frame_index, *cur_frame_idx, *frame_ind); 109 ++(*frame_ind); 110 ++(*cur_frame_idx); 111 } 112 113 // Sets the GF_GROUP params for INTNL_ARF_UPDATE frames. 114 static inline void set_params_for_internal_arfs( 115 const TWO_PASS *twopass, const TWO_PASS_FRAME *twopass_frame, 116 const PRIMARY_RATE_CONTROL *p_rc, FRAME_INFO *frame_info, 117 GF_GROUP *const gf_group, int *cur_frame_idx, int *frame_ind, 118 int *parallel_frame_count, int max_parallel_frames, 119 int do_frame_parallel_encode, int *first_frame_index, int depth_thr, 120 int *cur_disp_idx, int layer_depth, int arf_src_offset, int offset, 121 int f_frames, int b_frames) { 122 gf_group->update_type[*frame_ind] = INTNL_ARF_UPDATE; 123 gf_group->arf_src_offset[*frame_ind] = arf_src_offset; 124 gf_group->cur_frame_idx[*frame_ind] = *cur_frame_idx; 125 gf_group->layer_depth[*frame_ind] = layer_depth; 126 gf_group->frame_type[*frame_ind] = INTER_FRAME; 127 gf_group->refbuf_state[*frame_ind] = REFBUF_UPDATE; 128 gf_group->display_idx[*frame_ind] = 129 (*cur_disp_idx) + gf_group->arf_src_offset[*frame_ind]; 130 gf_group->arf_boost[*frame_ind] = 131 av1_calc_arf_boost(twopass, twopass_frame, p_rc, frame_info, offset, 132 f_frames, b_frames, NULL, NULL, 0); 133 134 if (do_frame_parallel_encode) { 135 if (depth_thr != INT_MAX) { 136 assert(depth_thr == 3 || depth_thr == 4); 137 assert(IMPLIES(depth_thr == 3, layer_depth == 4)); 138 assert(IMPLIES(depth_thr == 4, layer_depth == 5)); 139 // Set frame_parallel_level of the first frame in the given layer to 1. 140 if (gf_group->layer_depth[(*frame_ind) - 1] != layer_depth) { 141 gf_group->frame_parallel_level[*frame_ind] = 1; 142 } else { 143 // Set frame_parallel_level of the consecutive frame in the same given 144 // layer to 2. 145 assert(gf_group->frame_parallel_level[(*frame_ind) - 1] == 1); 146 gf_group->frame_parallel_level[*frame_ind] = 2; 147 // Store the display order hints of the past 2 INTNL_ARF_UPDATE 148 // frames which would not have been displayed at the time of the encode 149 // of current frame. 150 gf_group->skip_frame_refresh[*frame_ind][0] = 151 gf_group->display_idx[(*frame_ind) - 1]; 152 gf_group->skip_frame_refresh[*frame_ind][1] = 153 gf_group->display_idx[(*frame_ind) - 2]; 154 // Set the display_idx of frame_parallel_level 1 frame in 155 // gf_group->skip_frame_as_ref. 156 gf_group->skip_frame_as_ref[*frame_ind] = 157 gf_group->display_idx[(*frame_ind) - 1]; 158 } 159 } 160 // If max_parallel_frames is not exceeded and if the frame will not be 161 // temporally filtered, encode the next internal ARF frame in parallel. 162 if (*parallel_frame_count > 1 && 163 *parallel_frame_count <= max_parallel_frames) { 164 if (gf_group->arf_src_offset[*frame_ind] < TF_LOOKAHEAD_IDX_THR) 165 gf_group->frame_parallel_level[*frame_ind] = 2; 166 *parallel_frame_count = 1; 167 } 168 } 169 set_src_offset(gf_group, first_frame_index, *cur_frame_idx, *frame_ind); 170 ++(*frame_ind); 171 } 172 173 // Set parameters for frames between 'start' and 'end' (excluding both). 174 static void set_multi_layer_params_for_fp( 175 const TWO_PASS *twopass, const TWO_PASS_FRAME *twopass_frame, 176 GF_GROUP *const gf_group, const PRIMARY_RATE_CONTROL *p_rc, 177 RATE_CONTROL *rc, FRAME_INFO *frame_info, int start, int end, 178 int *cur_frame_idx, int *frame_ind, int *parallel_frame_count, 179 int max_parallel_frames, int do_frame_parallel_encode, 180 int *first_frame_index, int depth_thr, int *cur_disp_idx, int layer_depth) { 181 const int num_frames_to_process = end - start; 182 183 // Either we are at the last level of the pyramid, or we don't have enough 184 // frames between 'l' and 'r' to create one more level. 185 if (layer_depth > gf_group->max_layer_depth_allowed || 186 num_frames_to_process < 3) { 187 // Leaf nodes. 188 while (start < end) { 189 set_params_for_leaf_frames(twopass, twopass_frame, p_rc, frame_info, 190 gf_group, cur_frame_idx, frame_ind, 191 parallel_frame_count, max_parallel_frames, 192 do_frame_parallel_encode, first_frame_index, 193 cur_disp_idx, layer_depth, start, end); 194 ++start; 195 } 196 } else { 197 const int m = (start + end - 1) / 2; 198 199 // Internal ARF. 200 int arf_src_offset = m - start; 201 set_params_for_internal_arfs( 202 twopass, twopass_frame, p_rc, frame_info, gf_group, cur_frame_idx, 203 frame_ind, parallel_frame_count, max_parallel_frames, 204 do_frame_parallel_encode, first_frame_index, INT_MAX, cur_disp_idx, 205 layer_depth, arf_src_offset, m, end - m, m - start); 206 207 // If encode reordering is enabled, configure the multi-layers accordingly 208 // and return. For e.g., the encode order for gf-interval 16 after 209 // reordering would be 0-> 16-> 8-> 4-> 2-> 6-> 1-> 3-> 5-> 7-> 12-> 10-> 210 // 14-> 9-> 11-> 13-> 15. 211 if (layer_depth >= depth_thr) { 212 int m1 = (m + start - 1) / 2; 213 int m2 = (m + 1 + end) / 2; 214 int arf_src_offsets[2] = { m1 - start, m2 - start }; 215 // Parameters to compute arf_boost. 216 int offset[2] = { m1, m2 }; 217 int f_frames[2] = { m - m1, end - m2 }; 218 int b_frames[2] = { m1 - start, m2 - (m + 1) }; 219 220 // Set GF_GROUP params for INTNL_ARF_UPDATE frames which are reordered. 221 for (int i = 0; i < 2; i++) { 222 set_params_for_internal_arfs( 223 twopass, twopass_frame, p_rc, frame_info, gf_group, cur_frame_idx, 224 frame_ind, parallel_frame_count, max_parallel_frames, 225 do_frame_parallel_encode, first_frame_index, depth_thr, 226 cur_disp_idx, layer_depth + 1, arf_src_offsets[i], offset[i], 227 f_frames[i], b_frames[i]); 228 } 229 230 // Initialize the start and end indices to configure LF_UPDATE frames. 231 int start_idx[4] = { start, m1 + 1, m + 1, end - 1 }; 232 int end_idx[4] = { m1, m, m2, end }; 233 int layer_depth_for_intnl_overlay[4] = { layer_depth + 1, layer_depth, 234 layer_depth + 1, INVALID_IDX }; 235 236 // Set GF_GROUP params for the rest of LF_UPDATE and INTNL_OVERLAY_UPDATE 237 // frames after reordering. 238 for (int i = 0; i < 4; i++) { 239 set_multi_layer_params_for_fp( 240 twopass, twopass_frame, gf_group, p_rc, rc, frame_info, 241 start_idx[i], end_idx[i], cur_frame_idx, frame_ind, 242 parallel_frame_count, max_parallel_frames, do_frame_parallel_encode, 243 first_frame_index, depth_thr, cur_disp_idx, layer_depth + 2); 244 if (layer_depth_for_intnl_overlay[i] != INVALID_IDX) 245 set_params_for_intnl_overlay_frames( 246 gf_group, cur_frame_idx, frame_ind, first_frame_index, 247 cur_disp_idx, layer_depth_for_intnl_overlay[i]); 248 } 249 return; 250 } 251 252 // Frames displayed before this internal ARF. 253 set_multi_layer_params_for_fp( 254 twopass, twopass_frame, gf_group, p_rc, rc, frame_info, start, m, 255 cur_frame_idx, frame_ind, parallel_frame_count, max_parallel_frames, 256 do_frame_parallel_encode, first_frame_index, depth_thr, cur_disp_idx, 257 layer_depth + 1); 258 259 // Overlay for internal ARF. 260 set_params_for_intnl_overlay_frames(gf_group, cur_frame_idx, frame_ind, 261 first_frame_index, cur_disp_idx, 262 layer_depth); 263 264 // Frames displayed after this internal ARF. 265 set_multi_layer_params_for_fp( 266 twopass, twopass_frame, gf_group, p_rc, rc, frame_info, m + 1, end, 267 cur_frame_idx, frame_ind, parallel_frame_count, max_parallel_frames, 268 do_frame_parallel_encode, first_frame_index, depth_thr, cur_disp_idx, 269 layer_depth + 1); 270 } 271 } 272 273 // Structure for bookkeeping start, end and display indices to configure 274 // INTNL_ARF_UPDATE frames. 275 typedef struct { 276 int start; 277 int end; 278 int display_index; 279 } FRAME_REORDER_INFO; 280 281 // Updates the stats required to configure the GF_GROUP. 282 static inline void fill_arf_frame_stats(FRAME_REORDER_INFO *arf_frame_stats, 283 int arf_frame_index, int display_idx, 284 int start, int end) { 285 arf_frame_stats[arf_frame_index].start = start; 286 arf_frame_stats[arf_frame_index].end = end; 287 arf_frame_stats[arf_frame_index].display_index = display_idx; 288 } 289 290 // Sets GF_GROUP params for INTNL_ARF_UPDATE frames. Also populates 291 // doh_gf_index_map and arf_frame_stats. 292 static inline void set_params_for_internal_arfs_in_gf14( 293 GF_GROUP *const gf_group, FRAME_REORDER_INFO *arf_frame_stats, 294 int *cur_frame_idx, int *cur_disp_idx, int *frame_ind, 295 int *count_arf_frames, int *doh_gf_index_map, int start, int end, 296 int layer_depth, int layer_with_parallel_encodes) { 297 int index = (start + end - 1) / 2; 298 gf_group->update_type[*frame_ind] = INTNL_ARF_UPDATE; 299 gf_group->arf_src_offset[*frame_ind] = index - 1; 300 gf_group->cur_frame_idx[*frame_ind] = *cur_frame_idx; 301 gf_group->layer_depth[*frame_ind] = layer_depth; 302 gf_group->frame_type[*frame_ind] = INTER_FRAME; 303 gf_group->refbuf_state[*frame_ind] = REFBUF_UPDATE; 304 gf_group->display_idx[*frame_ind] = 305 (*cur_disp_idx) + gf_group->arf_src_offset[*frame_ind]; 306 307 // Update the display index of the current frame with its gf index. 308 doh_gf_index_map[index] = *frame_ind; 309 if (layer_with_parallel_encodes) { 310 assert(layer_depth == 4); 311 // Set frame_parallel_level of the first frame in the given layer depth 312 // to 1. 313 if (gf_group->layer_depth[(*frame_ind) - 1] != layer_depth) { 314 gf_group->frame_parallel_level[*frame_ind] = 1; 315 } else { 316 // Set frame_parallel_level of the consecutive frame in the same given 317 // layer depth to 2. 318 assert(gf_group->frame_parallel_level[(*frame_ind) - 1] == 1); 319 gf_group->frame_parallel_level[*frame_ind] = 2; 320 // Set the display_idx of frame_parallel_level 1 frame in 321 // gf_group->skip_frame_as_ref. 322 gf_group->skip_frame_as_ref[*frame_ind] = 323 gf_group->display_idx[(*frame_ind) - 1]; 324 } 325 } 326 ++(*frame_ind); 327 328 // Update arf_frame_stats. 329 fill_arf_frame_stats(arf_frame_stats, *count_arf_frames, index, start, end); 330 ++(*count_arf_frames); 331 } 332 333 // Sets GF_GROUP params for all INTNL_ARF_UPDATE frames in the given layer 334 // dpeth. 335 static inline void set_params_for_cur_layer_frames( 336 GF_GROUP *const gf_group, FRAME_REORDER_INFO *arf_frame_stats, 337 int *cur_frame_idx, int *cur_disp_idx, int *frame_ind, 338 int *count_arf_frames, int *doh_gf_index_map, int num_dir, int node_start, 339 int node_end, int layer_depth) { 340 assert(num_dir < 3); 341 int start, end; 342 // Iterate through the nodes in the previous layer depth. 343 for (int i = node_start; i < node_end; i++) { 344 // For each node, check if a frame can be coded as INTNL_ARF_UPDATE frame on 345 // either direction. 346 for (int dir = 0; dir < num_dir; dir++) { 347 // Checks for a frame to the left of current node. 348 if (dir == 0) { 349 start = arf_frame_stats[i].start; 350 end = arf_frame_stats[i].display_index; 351 } else { 352 // Checks for a frame to the right of current node. 353 start = arf_frame_stats[i].display_index + 1; 354 end = arf_frame_stats[i].end; 355 } 356 const int num_frames_to_process = end - start; 357 // Checks if a frame can be coded as INTNL_ARF_UPDATE frame. If 358 // num_frames_to_process is less than 3, then there are not enough frames 359 // between 'start' and 'end' to create another level. 360 if (num_frames_to_process >= 3) { 361 // Flag to indicate the lower layer depths for which parallel encoding 362 // is enabled. Currently enabled for layer 4 frames. 363 int layer_with_parallel_encodes = layer_depth == 4; 364 set_params_for_internal_arfs_in_gf14( 365 gf_group, arf_frame_stats, cur_frame_idx, cur_disp_idx, frame_ind, 366 count_arf_frames, doh_gf_index_map, start, end, layer_depth, 367 layer_with_parallel_encodes); 368 } 369 } 370 } 371 } 372 373 // Configures multi-layers of the GF_GROUP when consecutive encode of frames in 374 // the same layer depth is enbaled. 375 static inline void set_multi_layer_params_for_gf14( 376 const TWO_PASS *twopass, const TWO_PASS_FRAME *twopass_frame, 377 const PRIMARY_RATE_CONTROL *p_rc, FRAME_INFO *frame_info, 378 GF_GROUP *const gf_group, FRAME_REORDER_INFO *arf_frame_stats, 379 int *cur_frame_idx, int *frame_ind, int *count_arf_frames, 380 int *doh_gf_index_map, int *parallel_frame_count, int *first_frame_index, 381 int *cur_disp_index, int gf_interval, int layer_depth, 382 int max_parallel_frames) { 383 assert(layer_depth == 2); 384 assert(gf_group->max_layer_depth_allowed >= 4); 385 int layer, node_start, node_end = 0; 386 // Maximum layer depth excluding LF_UPDATE frames is 4 since applicable only 387 // for gf-interval 14. 388 const int max_layer_depth = 4; 389 // Iterate through each layer depth starting from 2 till 'max_layer_depth'. 390 for (layer = layer_depth; layer <= max_layer_depth; layer++) { 391 // 'node_start' and 'node_end' indicate the number of nodes from the 392 // previous layer depth to be considered. It also corresponds to the indices 393 // of arf_frame_stats. 394 node_start = node_end; 395 node_end = (*count_arf_frames); 396 // 'num_dir' indicates the number of directions to traverse w.r.t. a given 397 // node in order to choose an INTNL_ARF_UPDATE frame. Layer depth 2 would 398 // have only one frame and hence needs to traverse only in the left 399 // direction w.r.t the node in the previous layer. 400 int num_dir = layer == 2 ? 1 : 2; 401 set_params_for_cur_layer_frames(gf_group, arf_frame_stats, cur_frame_idx, 402 cur_disp_index, frame_ind, count_arf_frames, 403 doh_gf_index_map, num_dir, node_start, 404 node_end, layer); 405 } 406 407 for (int i = 1; i < gf_interval; i++) { 408 // Since doh_gf_index_map is already populated for all INTNL_ARF_UPDATE 409 // frames in the GF_GROUP, any frame with INVALID_IDX would correspond to an 410 // LF_UPDATE frame. 411 if (doh_gf_index_map[i] == INVALID_IDX) { 412 // LF_UPDATE frames. 413 // TODO(Remya): Correct start and end parameters passed to 414 // set_params_for_leaf_frames() once encode reordering for gf-interval 14 415 // is enbaled for parallel encode of lower layer frames. 416 set_params_for_leaf_frames( 417 twopass, twopass_frame, p_rc, frame_info, gf_group, cur_frame_idx, 418 frame_ind, parallel_frame_count, max_parallel_frames, 1, 419 first_frame_index, cur_disp_index, layer, 0, 0); 420 } else { 421 // In order to obtain the layer depths of INTNL_OVERLAY_UPDATE frames, get 422 // the gf index of corresponding INTNL_ARF_UPDATE frames. 423 int intnl_arf_index = doh_gf_index_map[i]; 424 int ld = gf_group->layer_depth[intnl_arf_index]; 425 set_params_for_intnl_overlay_frames(gf_group, cur_frame_idx, frame_ind, 426 first_frame_index, cur_disp_index, 427 ld); 428 } 429 } 430 } 431 432 // Set parameters for frames between 'start' and 'end' (excluding both). 433 static void set_multi_layer_params( 434 const TWO_PASS *twopass, const TWO_PASS_FRAME *twopass_frame, 435 GF_GROUP *const gf_group, const PRIMARY_RATE_CONTROL *p_rc, 436 RATE_CONTROL *rc, FRAME_INFO *frame_info, int start, int end, 437 int *cur_frame_idx, int *frame_ind, int *parallel_frame_count, 438 int max_parallel_frames, int do_frame_parallel_encode, 439 int *first_frame_index, int *cur_disp_idx, int layer_depth) { 440 const int num_frames_to_process = end - start; 441 442 // Either we are at the last level of the pyramid, or we don't have enough 443 // frames between 'l' and 'r' to create one more level. 444 if (layer_depth > gf_group->max_layer_depth_allowed || 445 num_frames_to_process < 3) { 446 // Leaf nodes. 447 while (start < end) { 448 gf_group->update_type[*frame_ind] = LF_UPDATE; 449 gf_group->arf_src_offset[*frame_ind] = 0; 450 gf_group->cur_frame_idx[*frame_ind] = *cur_frame_idx; 451 gf_group->display_idx[*frame_ind] = *cur_disp_idx; 452 gf_group->layer_depth[*frame_ind] = MAX_ARF_LAYERS; 453 gf_group->arf_boost[*frame_ind] = 454 av1_calc_arf_boost(twopass, twopass_frame, p_rc, frame_info, start, 455 end - start, 0, NULL, NULL, 0); 456 gf_group->frame_type[*frame_ind] = INTER_FRAME; 457 gf_group->refbuf_state[*frame_ind] = REFBUF_UPDATE; 458 gf_group->max_layer_depth = 459 AOMMAX(gf_group->max_layer_depth, layer_depth); 460 // Set the level of parallelism for the LF_UPDATE frame. 461 if (do_frame_parallel_encode) { 462 set_frame_parallel_level(&gf_group->frame_parallel_level[*frame_ind], 463 parallel_frame_count, max_parallel_frames); 464 // Set LF_UPDATE frames as non-reference frames. 465 gf_group->is_frame_non_ref[*frame_ind] = true; 466 } 467 set_src_offset(gf_group, first_frame_index, *cur_frame_idx, *frame_ind); 468 ++(*frame_ind); 469 ++(*cur_frame_idx); 470 ++(*cur_disp_idx); 471 ++start; 472 } 473 } else { 474 const int m = (start + end - 1) / 2; 475 476 // Internal ARF. 477 gf_group->update_type[*frame_ind] = INTNL_ARF_UPDATE; 478 gf_group->arf_src_offset[*frame_ind] = m - start; 479 gf_group->cur_frame_idx[*frame_ind] = *cur_frame_idx; 480 gf_group->display_idx[*frame_ind] = 481 *cur_disp_idx + gf_group->arf_src_offset[*frame_ind]; 482 gf_group->layer_depth[*frame_ind] = layer_depth; 483 gf_group->frame_type[*frame_ind] = INTER_FRAME; 484 gf_group->refbuf_state[*frame_ind] = REFBUF_UPDATE; 485 486 if (do_frame_parallel_encode) { 487 // If max_parallel_frames is not exceeded and if the frame will not be 488 // temporally filtered, encode the next internal ARF frame in parallel. 489 if (*parallel_frame_count > 1 && 490 *parallel_frame_count <= max_parallel_frames) { 491 if (gf_group->arf_src_offset[*frame_ind] < TF_LOOKAHEAD_IDX_THR) 492 gf_group->frame_parallel_level[*frame_ind] = 2; 493 *parallel_frame_count = 1; 494 } 495 } 496 set_src_offset(gf_group, first_frame_index, *cur_frame_idx, *frame_ind); 497 498 // Get the boost factor for intermediate ARF frames. 499 gf_group->arf_boost[*frame_ind] = 500 av1_calc_arf_boost(twopass, twopass_frame, p_rc, frame_info, m, end - m, 501 m - start, NULL, NULL, 0); 502 ++(*frame_ind); 503 504 // Frames displayed before this internal ARF. 505 set_multi_layer_params(twopass, twopass_frame, gf_group, p_rc, rc, 506 frame_info, start, m, cur_frame_idx, frame_ind, 507 parallel_frame_count, max_parallel_frames, 508 do_frame_parallel_encode, first_frame_index, 509 cur_disp_idx, layer_depth + 1); 510 511 // Overlay for internal ARF. 512 gf_group->update_type[*frame_ind] = INTNL_OVERLAY_UPDATE; 513 gf_group->arf_src_offset[*frame_ind] = 0; 514 gf_group->cur_frame_idx[*frame_ind] = *cur_frame_idx; 515 gf_group->display_idx[*frame_ind] = *cur_disp_idx; 516 gf_group->arf_boost[*frame_ind] = 0; 517 gf_group->layer_depth[*frame_ind] = layer_depth; 518 gf_group->frame_type[*frame_ind] = INTER_FRAME; 519 gf_group->refbuf_state[*frame_ind] = REFBUF_UPDATE; 520 521 set_src_offset(gf_group, first_frame_index, *cur_frame_idx, *frame_ind); 522 ++(*frame_ind); 523 ++(*cur_frame_idx); 524 ++(*cur_disp_idx); 525 526 // Frames displayed after this internal ARF. 527 set_multi_layer_params(twopass, twopass_frame, gf_group, p_rc, rc, 528 frame_info, m + 1, end, cur_frame_idx, frame_ind, 529 parallel_frame_count, max_parallel_frames, 530 do_frame_parallel_encode, first_frame_index, 531 cur_disp_idx, layer_depth + 1); 532 } 533 } 534 535 static int construct_multi_layer_gf_structure( 536 AV1_COMP *cpi, TWO_PASS *twopass, GF_GROUP *const gf_group, 537 RATE_CONTROL *rc, FRAME_INFO *const frame_info, int baseline_gf_interval, 538 FRAME_UPDATE_TYPE first_frame_update_type) { 539 PRIMARY_RATE_CONTROL *const p_rc = &cpi->ppi->p_rc; 540 // TODO(angiebird): Why do we need "-1" here? 541 const int gf_interval = baseline_gf_interval - 1; 542 int frame_index = 0; 543 int cur_frame_index = 0; 544 545 // Set the display order hint for the first frame in the GF_GROUP. 546 int cur_disp_index = (first_frame_update_type == KF_UPDATE) 547 ? 0 548 : cpi->common.current_frame.frame_number; 549 550 // Initialize gf_group->frame_parallel_level, gf_group->is_frame_non_ref, 551 // gf_group->src_offset and gf_group->is_frame_dropped with 0. 552 memset(gf_group->frame_parallel_level, 0, 553 sizeof(gf_group->frame_parallel_level)); 554 memset(gf_group->is_frame_non_ref, 0, sizeof(gf_group->is_frame_non_ref)); 555 memset(gf_group->src_offset, 0, sizeof(gf_group->src_offset)); 556 memset(gf_group->is_frame_dropped, 0, sizeof(gf_group->is_frame_dropped)); 557 // Initialize gf_group->skip_frame_refresh and gf_group->skip_frame_as_ref 558 // with INVALID_IDX. 559 memset(gf_group->skip_frame_refresh, INVALID_IDX, 560 sizeof(gf_group->skip_frame_refresh)); 561 memset(gf_group->skip_frame_as_ref, INVALID_IDX, 562 sizeof(gf_group->skip_frame_as_ref)); 563 564 int kf_decomp = cpi->oxcf.kf_cfg.enable_keyframe_filtering > 1; 565 // This is a patch that fixes https://crbug.com/aomedia/3163 566 // enable_keyframe_filtering > 1 will introduce an extra overlay frame at 567 // key frame location. However when 568 // baseline_gf_interval == MAX_STATIC_GF_GROUP_LENGTH, we can't 569 // afford to have an extra overlay frame. Otherwise, the gf_group->size will 570 // become MAX_STATIC_GF_GROUP_LENGTH + 1, which causes memory error. 571 // A cheap solution is to turn of kf_decomp here. 572 // TODO(angiebird): Find a systematic way to solve this issue. 573 if (baseline_gf_interval == MAX_STATIC_GF_GROUP_LENGTH) { 574 kf_decomp = 0; 575 } 576 if (first_frame_update_type == KF_UPDATE) { 577 gf_group->update_type[frame_index] = kf_decomp ? ARF_UPDATE : KF_UPDATE; 578 gf_group->arf_src_offset[frame_index] = 0; 579 gf_group->cur_frame_idx[frame_index] = cur_frame_index; 580 gf_group->layer_depth[frame_index] = 0; 581 gf_group->frame_type[frame_index] = KEY_FRAME; 582 gf_group->refbuf_state[frame_index] = REFBUF_RESET; 583 gf_group->max_layer_depth = 0; 584 gf_group->display_idx[frame_index] = cur_disp_index; 585 if (!kf_decomp) cur_disp_index++; 586 ++frame_index; 587 588 if (kf_decomp) { 589 gf_group->update_type[frame_index] = OVERLAY_UPDATE; 590 gf_group->arf_src_offset[frame_index] = 0; 591 gf_group->cur_frame_idx[frame_index] = cur_frame_index; 592 gf_group->layer_depth[frame_index] = 0; 593 gf_group->frame_type[frame_index] = INTER_FRAME; 594 gf_group->refbuf_state[frame_index] = REFBUF_UPDATE; 595 gf_group->max_layer_depth = 0; 596 gf_group->display_idx[frame_index] = cur_disp_index; 597 cur_disp_index++; 598 ++frame_index; 599 } 600 cur_frame_index++; 601 } 602 603 if (first_frame_update_type == GF_UPDATE) { 604 gf_group->update_type[frame_index] = GF_UPDATE; 605 gf_group->arf_src_offset[frame_index] = 0; 606 gf_group->cur_frame_idx[frame_index] = cur_frame_index; 607 gf_group->layer_depth[frame_index] = 0; 608 gf_group->frame_type[frame_index] = INTER_FRAME; 609 gf_group->refbuf_state[frame_index] = REFBUF_UPDATE; 610 gf_group->max_layer_depth = 0; 611 gf_group->display_idx[frame_index] = cur_disp_index; 612 cur_disp_index++; 613 ++frame_index; 614 ++cur_frame_index; 615 } 616 617 // ALTREF. 618 const int use_altref = gf_group->max_layer_depth_allowed > 0; 619 int is_fwd_kf = rc->frames_to_fwd_kf == gf_interval; 620 621 const int sframe_dist = cpi->oxcf.kf_cfg.sframe_dist; 622 const int sframe_mode = cpi->oxcf.kf_cfg.sframe_mode; 623 const int sframe_enabled = (sframe_mode > 0) && (sframe_dist > 0); 624 625 if (sframe_enabled) { 626 switch (sframe_mode) { 627 case 1: gf_group->is_sframe_due = use_altref; break; 628 case 2: 629 gf_group->is_sframe_due |= 630 (frame_index && !(frame_index % sframe_dist)); 631 break; 632 } 633 } 634 635 if (use_altref) { 636 gf_group->update_type[frame_index] = ARF_UPDATE; 637 gf_group->arf_src_offset[frame_index] = gf_interval - cur_frame_index; 638 gf_group->cur_frame_idx[frame_index] = cur_frame_index; 639 gf_group->layer_depth[frame_index] = 1; 640 gf_group->arf_boost[frame_index] = cpi->ppi->p_rc.gfu_boost; 641 gf_group->frame_type[frame_index] = is_fwd_kf ? KEY_FRAME 642 : gf_group->is_sframe_due ? S_FRAME 643 : INTER_FRAME; 644 gf_group->is_sframe_due = 645 sframe_enabled && gf_group->frame_type[frame_index] != S_FRAME; 646 gf_group->refbuf_state[frame_index] = REFBUF_UPDATE; 647 gf_group->max_layer_depth = 1; 648 gf_group->arf_index = frame_index; 649 gf_group->display_idx[frame_index] = 650 cur_disp_index + gf_group->arf_src_offset[frame_index]; 651 ++frame_index; 652 } else { 653 gf_group->arf_index = -1; 654 } 655 656 // Flag to indicate if multi-layer configuration is complete. 657 int is_multi_layer_configured = 0; 658 659 // Running count of no. of frames that is part of a given parallel 660 // encode set in a gf_group. Value of 1 indicates no parallel encode. 661 int parallel_frame_count = 1; 662 // Enable parallel encode of frames if gf_group has a multi-layer pyramid 663 // structure with minimum 4 layers. 664 int do_frame_parallel_encode = (cpi->ppi->num_fp_contexts > 1 && use_altref && 665 gf_group->max_layer_depth_allowed >= 4); 666 667 int first_frame_index = cur_frame_index; 668 if (do_frame_parallel_encode) { 669 // construct_multi_layer_gf_structure() takes the input parameter 670 // 'gf_interval' as p_rc->baseline_gf_interval - 1 . Below code computes the 671 // actual GF_GROUP length by compensating for this offset. 672 int actual_gf_length = ((first_frame_update_type == KF_UPDATE) || 673 (first_frame_update_type == GF_UPDATE)) 674 ? gf_interval 675 : gf_interval + 1; 676 677 // In order to facilitate parallel encoding of frames in lower layer depths, 678 // encode reordering is done. Currently encode reordering is enabled only 679 // for gf-intervals 16 and 32. NOTE: Since the buffer holding the 680 // reference frames is of size 8 (ref_frame_map[REF_FRAMES]), there is a 681 // limitation on the number of hidden frames possible at any given point and 682 // hence the reordering is enabled only for gf-intervals 16 and 32. 683 // Disabling encode reordering for gf-interval 14 since some cross-frame 684 // dependencies related to temporal filtering for FPMT is currently not 685 // handled. 686 int disable_gf14_reorder = 1; 687 if (actual_gf_length == 14 && !disable_gf14_reorder) { 688 // This array holds the gf index of INTNL_ARF_UPDATE frames in the slot 689 // corresponding to their display order hint. This is used while 690 // configuring the LF_UPDATE frames and INTNL_OVERLAY_UPDATE frames. 691 int doh_gf_index_map[FIXED_GF_INTERVAL]; 692 // Initialize doh_gf_index_map with INVALID_IDX. 693 memset(&doh_gf_index_map[0], INVALID_IDX, 694 (sizeof(doh_gf_index_map[0]) * FIXED_GF_INTERVAL)); 695 696 FRAME_REORDER_INFO arf_frame_stats[REF_FRAMES - 1]; 697 // Store the stats corresponding to layer 1 frame. 698 fill_arf_frame_stats(arf_frame_stats, 0, actual_gf_length, 1, 699 actual_gf_length); 700 int count_arf_frames = 1; 701 702 // Sets multi-layer params for gf-interval 14 to consecutively encode 703 // frames in the same layer depth, i.e., encode order would be 0-> 14-> 704 // 7-> 3-> 10-> 5-> 12-> 1-> 2-> 4-> 6-> 8-> 9-> 11-> 13. 705 // TODO(Remya): Set GF_GROUP param 'arf_boost' for all frames. 706 set_multi_layer_params_for_gf14( 707 twopass, &cpi->twopass_frame, p_rc, frame_info, gf_group, 708 arf_frame_stats, &cur_frame_index, &frame_index, &count_arf_frames, 709 doh_gf_index_map, ¶llel_frame_count, &first_frame_index, 710 &cur_disp_index, actual_gf_length, use_altref + 1, 711 cpi->ppi->num_fp_contexts); 712 713 // Set gf_group->skip_frame_refresh. 714 for (int i = 0; i < actual_gf_length; i++) { 715 int count = 0; 716 if (gf_group->update_type[i] == INTNL_ARF_UPDATE) { 717 for (int j = 0; j < i; j++) { 718 // Store the display order hint of the frames which would not 719 // have been displayed at the encode call of frame 'i'. 720 if ((gf_group->display_idx[j] < gf_group->display_idx[i]) && 721 gf_group->update_type[j] == INTNL_ARF_UPDATE) { 722 gf_group->skip_frame_refresh[i][count++] = 723 gf_group->display_idx[j]; 724 } 725 } 726 } 727 } 728 } else { 729 // Set layer depth threshold for reordering as per the gf length. 730 int depth_thr = (actual_gf_length == 16) ? 3 731 : (actual_gf_length == 32) ? 4 732 : INT_MAX; 733 734 set_multi_layer_params_for_fp( 735 twopass, &cpi->twopass_frame, gf_group, p_rc, rc, frame_info, 736 cur_frame_index, gf_interval, &cur_frame_index, &frame_index, 737 ¶llel_frame_count, cpi->ppi->num_fp_contexts, 738 do_frame_parallel_encode, &first_frame_index, depth_thr, 739 &cur_disp_index, use_altref + 1); 740 } 741 is_multi_layer_configured = 1; 742 } 743 744 // Rest of the frames. 745 if (!is_multi_layer_configured) 746 set_multi_layer_params(twopass, &cpi->twopass_frame, gf_group, p_rc, rc, 747 frame_info, cur_frame_index, gf_interval, 748 &cur_frame_index, &frame_index, 749 ¶llel_frame_count, cpi->ppi->num_fp_contexts, 750 do_frame_parallel_encode, &first_frame_index, 751 &cur_disp_index, use_altref + 1); 752 753 if (use_altref) { 754 gf_group->update_type[frame_index] = OVERLAY_UPDATE; 755 gf_group->arf_src_offset[frame_index] = 0; 756 gf_group->cur_frame_idx[frame_index] = cur_frame_index; 757 gf_group->layer_depth[frame_index] = MAX_ARF_LAYERS; 758 gf_group->arf_boost[frame_index] = NORMAL_BOOST; 759 gf_group->frame_type[frame_index] = INTER_FRAME; 760 gf_group->refbuf_state[frame_index] = 761 is_fwd_kf ? REFBUF_RESET : REFBUF_UPDATE; 762 gf_group->display_idx[frame_index] = cur_disp_index; 763 ++frame_index; 764 } else { 765 for (; cur_frame_index <= gf_interval; ++cur_frame_index) { 766 gf_group->update_type[frame_index] = LF_UPDATE; 767 gf_group->arf_src_offset[frame_index] = 0; 768 gf_group->cur_frame_idx[frame_index] = cur_frame_index; 769 gf_group->layer_depth[frame_index] = MAX_ARF_LAYERS; 770 gf_group->arf_boost[frame_index] = NORMAL_BOOST; 771 gf_group->frame_type[frame_index] = INTER_FRAME; 772 gf_group->refbuf_state[frame_index] = REFBUF_UPDATE; 773 gf_group->max_layer_depth = AOMMAX(gf_group->max_layer_depth, 2); 774 set_src_offset(gf_group, &first_frame_index, cur_frame_index, 775 frame_index); 776 gf_group->display_idx[frame_index] = cur_disp_index; 777 cur_disp_index++; 778 ++frame_index; 779 } 780 } 781 if (do_frame_parallel_encode) { 782 // Iterate through the gf_group and reset frame_parallel_level to 0 in case 783 // a frame is marked as frame_parallel_level 1 with no subsequent 784 // frame_parallel_level 2 frame(s). 785 int level1_frame_idx = INT_MAX; 786 int level2_frame_count = 0; 787 for (int frame_idx = 0; frame_idx < frame_index; frame_idx++) { 788 if (gf_group->frame_parallel_level[frame_idx] == 1) { 789 // Set frame_parallel_level to 0 if only one frame is present in a 790 // parallel encode set. 791 if (level1_frame_idx != INT_MAX && !level2_frame_count) 792 gf_group->frame_parallel_level[level1_frame_idx] = 0; 793 // Book-keep frame_idx of frame_parallel_level 1 frame and reset the 794 // count of frame_parallel_level 2 frames in the corresponding parallel 795 // encode set. 796 level1_frame_idx = frame_idx; 797 level2_frame_count = 0; 798 } 799 if (gf_group->frame_parallel_level[frame_idx] == 2) level2_frame_count++; 800 } 801 // If frame_parallel_level is set to 1 for the last LF_UPDATE 802 // frame in the gf_group, reset it to zero since there are no subsequent 803 // frames in the gf_group. 804 if (gf_group->frame_parallel_level[frame_index - 2] == 1) { 805 assert(gf_group->update_type[frame_index - 2] == LF_UPDATE); 806 gf_group->frame_parallel_level[frame_index - 2] = 0; 807 } 808 } 809 810 for (int gf_idx = frame_index; gf_idx < MAX_STATIC_GF_GROUP_LENGTH; 811 ++gf_idx) { 812 gf_group->update_type[gf_idx] = LF_UPDATE; 813 gf_group->arf_src_offset[gf_idx] = 0; 814 gf_group->cur_frame_idx[gf_idx] = gf_idx; 815 gf_group->layer_depth[gf_idx] = MAX_ARF_LAYERS; 816 gf_group->arf_boost[gf_idx] = NORMAL_BOOST; 817 gf_group->frame_type[gf_idx] = INTER_FRAME; 818 gf_group->refbuf_state[gf_idx] = REFBUF_UPDATE; 819 gf_group->max_layer_depth = AOMMAX(gf_group->max_layer_depth, 2); 820 } 821 822 return frame_index; 823 } 824 825 static void set_ld_layer_depth(GF_GROUP *gf_group, int gop_length) { 826 int log_gop_length = 0; 827 while ((1 << log_gop_length) < gop_length) { 828 ++log_gop_length; 829 } 830 831 for (int gf_index = 0; gf_index < gf_group->size; ++gf_index) { 832 int count = 0; 833 // Find the trailing zeros 834 for (; count < MAX_ARF_LAYERS; ++count) { 835 if ((gf_index >> count) & 0x01) break; 836 } 837 gf_group->layer_depth[gf_index] = AOMMAX(log_gop_length - count, 0); 838 } 839 gf_group->max_layer_depth = AOMMIN(log_gop_length, MAX_ARF_LAYERS); 840 } 841 842 void av1_gop_setup_structure(AV1_COMP *cpi) { 843 RATE_CONTROL *const rc = &cpi->rc; 844 PRIMARY_RATE_CONTROL *const p_rc = &cpi->ppi->p_rc; 845 GF_GROUP *const gf_group = &cpi->ppi->gf_group; 846 TWO_PASS *const twopass = &cpi->ppi->twopass; 847 FRAME_INFO *const frame_info = &cpi->frame_info; 848 const int key_frame = rc->frames_since_key == 0; 849 FRAME_UPDATE_TYPE first_frame_update_type = ARF_UPDATE; 850 851 if (key_frame) { 852 first_frame_update_type = KF_UPDATE; 853 if (cpi->oxcf.kf_max_pyr_height != -1) { 854 gf_group->max_layer_depth_allowed = AOMMIN( 855 cpi->oxcf.kf_max_pyr_height, gf_group->max_layer_depth_allowed); 856 } 857 } else if (!cpi->ppi->gf_state.arf_gf_boost_lst) { 858 first_frame_update_type = GF_UPDATE; 859 } 860 861 if (cpi->oxcf.algo_cfg.sharpness == 3) 862 gf_group->max_layer_depth_allowed = 863 AOMMIN(gf_group->max_layer_depth_allowed, 2); 864 865 gf_group->size = construct_multi_layer_gf_structure( 866 cpi, twopass, gf_group, rc, frame_info, p_rc->baseline_gf_interval, 867 first_frame_update_type); 868 869 if (gf_group->max_layer_depth_allowed == 0) 870 set_ld_layer_depth(gf_group, p_rc->baseline_gf_interval); 871 } 872 873 int av1_gop_check_forward_keyframe(const GF_GROUP *gf_group, 874 int gf_frame_index) { 875 return gf_group->frame_type[gf_frame_index] == KEY_FRAME && 876 gf_group->refbuf_state[gf_frame_index] == REFBUF_UPDATE; 877 } 878 879 int av1_gop_is_second_arf(const GF_GROUP *gf_group, int gf_frame_index) { 880 const int arf_src_offset = gf_group->arf_src_offset[gf_frame_index]; 881 // TODO(angiebird): when gf_group->size == 32, it's possble to 882 // have "two" second arf. Check if this is acceptable. 883 if (gf_group->update_type[gf_frame_index] == INTNL_ARF_UPDATE && 884 arf_src_offset >= TF_LOOKAHEAD_IDX_THR) { 885 return 1; 886 } 887 return 0; 888 }