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