1 /*
2  *  Copyright (c) 2014 The WebM project authors. All Rights Reserved.
3  *
4  *  Use of this source code is governed by a BSD-style license
5  *  that can be found in the LICENSE file in the root of the source
6  *  tree. An additional intellectual property rights grant can be found
7  *  in the file PATENTS.  All contributing project authors may
8  *  be found in the AUTHORS file in the root of the source tree.
9  */
10 
11 #include <math.h>
12 
13 #include "vp9/encoder/vp9_aq_cyclicrefresh.h"
14 #include "vp9/encoder/vp9_encoder.h"
15 #include "vp9/encoder/vp9_svc_layercontext.h"
16 #include "vp9/encoder/vp9_extend.h"
17 #include "vpx_dsp/vpx_dsp_common.h"
18 
19 #define SMALL_FRAME_FB_IDX 7
20 #define SMALL_FRAME_WIDTH  32
21 #define SMALL_FRAME_HEIGHT 16
22 
vp9_init_layer_context(VP9_COMP * const cpi)23 void vp9_init_layer_context(VP9_COMP *const cpi) {
24   SVC *const svc = &cpi->svc;
25   const VP9EncoderConfig *const oxcf = &cpi->oxcf;
26   int mi_rows = cpi->common.mi_rows;
27   int mi_cols = cpi->common.mi_cols;
28   int sl, tl;
29   int alt_ref_idx = svc->number_spatial_layers;
30 
31   svc->spatial_layer_id = 0;
32   svc->temporal_layer_id = 0;
33   svc->first_spatial_layer_to_encode = 0;
34 
35   if (cpi->oxcf.error_resilient_mode == 0 && cpi->oxcf.pass == 2) {
36     if (vpx_realloc_frame_buffer(&cpi->svc.empty_frame.img,
37                                  SMALL_FRAME_WIDTH, SMALL_FRAME_HEIGHT,
38                                  cpi->common.subsampling_x,
39                                  cpi->common.subsampling_y,
40 #if CONFIG_VP9_HIGHBITDEPTH
41                                  cpi->common.use_highbitdepth,
42 #endif
43                                  VP9_ENC_BORDER_IN_PIXELS,
44                                  cpi->common.byte_alignment,
45                                  NULL, NULL, NULL))
46       vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
47                          "Failed to allocate empty frame for multiple frame "
48                          "contexts");
49 
50     memset(cpi->svc.empty_frame.img.buffer_alloc, 0x80,
51            cpi->svc.empty_frame.img.buffer_alloc_sz);
52   }
53 
54   for (sl = 0; sl < oxcf->ss_number_layers; ++sl) {
55     for (tl = 0; tl < oxcf->ts_number_layers; ++tl) {
56       int layer = LAYER_IDS_TO_IDX(sl, tl, oxcf->ts_number_layers);
57       LAYER_CONTEXT *const lc = &svc->layer_context[layer];
58       RATE_CONTROL *const lrc = &lc->rc;
59       int i;
60       lc->current_video_frame_in_layer = 0;
61       lc->layer_size = 0;
62       lc->frames_from_key_frame = 0;
63       lc->last_frame_type = FRAME_TYPES;
64       lrc->ni_av_qi = oxcf->worst_allowed_q;
65       lrc->total_actual_bits = 0;
66       lrc->total_target_vs_actual = 0;
67       lrc->ni_tot_qi = 0;
68       lrc->tot_q = 0.0;
69       lrc->avg_q = 0.0;
70       lrc->ni_frames = 0;
71       lrc->decimation_count = 0;
72       lrc->decimation_factor = 0;
73 
74       for (i = 0; i < RATE_FACTOR_LEVELS; ++i) {
75         lrc->rate_correction_factors[i] = 1.0;
76       }
77 
78       if (cpi->oxcf.rc_mode == VPX_CBR) {
79         lc->target_bandwidth = oxcf->layer_target_bitrate[layer];
80         lrc->last_q[INTER_FRAME] = oxcf->worst_allowed_q;
81         lrc->avg_frame_qindex[INTER_FRAME] = oxcf->worst_allowed_q;
82         lrc->avg_frame_qindex[KEY_FRAME] = oxcf->worst_allowed_q;
83       } else {
84         lc->target_bandwidth = oxcf->layer_target_bitrate[layer];
85         lrc->last_q[KEY_FRAME] = oxcf->best_allowed_q;
86         lrc->last_q[INTER_FRAME] = oxcf->best_allowed_q;
87         lrc->avg_frame_qindex[KEY_FRAME] = (oxcf->worst_allowed_q +
88                                             oxcf->best_allowed_q) / 2;
89         lrc->avg_frame_qindex[INTER_FRAME] = (oxcf->worst_allowed_q +
90                                               oxcf->best_allowed_q) / 2;
91         if (oxcf->ss_enable_auto_arf[sl])
92           lc->alt_ref_idx = alt_ref_idx++;
93         else
94           lc->alt_ref_idx = INVALID_IDX;
95         lc->gold_ref_idx = INVALID_IDX;
96       }
97 
98       lrc->buffer_level = oxcf->starting_buffer_level_ms *
99                               lc->target_bandwidth / 1000;
100       lrc->bits_off_target = lrc->buffer_level;
101 
102       // Initialize the cyclic refresh parameters. If spatial layers are used
103       // (i.e., ss_number_layers > 1), these need to be updated per spatial
104       // layer.
105       // Cyclic refresh is only applied on base temporal layer.
106       if (oxcf->ss_number_layers > 1 &&
107           tl == 0) {
108         size_t last_coded_q_map_size;
109         size_t consec_zero_mv_size;
110         lc->sb_index = 0;
111         lc->map = vpx_malloc(mi_rows * mi_cols * sizeof(signed char));
112         memset(lc->map, 0, mi_rows * mi_cols);
113         last_coded_q_map_size = mi_rows * mi_cols * sizeof(uint8_t);
114         lc->last_coded_q_map = vpx_malloc(last_coded_q_map_size);
115         assert(MAXQ <= 255);
116         memset(lc->last_coded_q_map, MAXQ, last_coded_q_map_size);
117         consec_zero_mv_size = mi_rows * mi_cols * sizeof(uint8_t);
118         lc->consec_zero_mv = vpx_malloc(consec_zero_mv_size);
119         memset(lc->consec_zero_mv, 0, consec_zero_mv_size);
120        }
121     }
122   }
123 
124   // Still have extra buffer for base layer golden frame
125   if (!(svc->number_temporal_layers > 1 && cpi->oxcf.rc_mode == VPX_CBR)
126       && alt_ref_idx < REF_FRAMES)
127     svc->layer_context[0].gold_ref_idx = alt_ref_idx;
128 }
129 
130 // Update the layer context from a change_config() call.
vp9_update_layer_context_change_config(VP9_COMP * const cpi,const int target_bandwidth)131 void vp9_update_layer_context_change_config(VP9_COMP *const cpi,
132                                             const int target_bandwidth) {
133   SVC *const svc = &cpi->svc;
134   const VP9EncoderConfig *const oxcf = &cpi->oxcf;
135   const RATE_CONTROL *const rc = &cpi->rc;
136   int sl, tl, layer = 0, spatial_layer_target;
137   float bitrate_alloc = 1.0;
138 
139   if (svc->temporal_layering_mode != VP9E_TEMPORAL_LAYERING_MODE_NOLAYERING) {
140     for (sl = 0; sl < oxcf->ss_number_layers; ++sl) {
141       for (tl = 0; tl < oxcf->ts_number_layers; ++tl) {
142         layer = LAYER_IDS_TO_IDX(sl, tl, oxcf->ts_number_layers);
143         svc->layer_context[layer].target_bandwidth =
144             oxcf->layer_target_bitrate[layer];
145       }
146 
147       layer = LAYER_IDS_TO_IDX(sl, ((oxcf->ts_number_layers - 1) < 0 ?
148           0 : (oxcf->ts_number_layers - 1)), oxcf->ts_number_layers);
149       spatial_layer_target =
150           svc->layer_context[layer].target_bandwidth =
151               oxcf->layer_target_bitrate[layer];
152 
153       for (tl = 0; tl < oxcf->ts_number_layers; ++tl) {
154         LAYER_CONTEXT *const lc =
155             &svc->layer_context[sl * oxcf->ts_number_layers + tl];
156         RATE_CONTROL *const lrc = &lc->rc;
157 
158         lc->spatial_layer_target_bandwidth = spatial_layer_target;
159         bitrate_alloc = (float)lc->target_bandwidth / spatial_layer_target;
160         lrc->starting_buffer_level =
161             (int64_t)(rc->starting_buffer_level * bitrate_alloc);
162         lrc->optimal_buffer_level =
163             (int64_t)(rc->optimal_buffer_level * bitrate_alloc);
164         lrc->maximum_buffer_size =
165             (int64_t)(rc->maximum_buffer_size * bitrate_alloc);
166         lrc->bits_off_target =
167             VPXMIN(lrc->bits_off_target, lrc->maximum_buffer_size);
168         lrc->buffer_level = VPXMIN(lrc->buffer_level, lrc->maximum_buffer_size);
169         lc->framerate = cpi->framerate / oxcf->ts_rate_decimator[tl];
170         lrc->avg_frame_bandwidth = (int)(lc->target_bandwidth / lc->framerate);
171         lrc->max_frame_bandwidth = rc->max_frame_bandwidth;
172         lrc->worst_quality = rc->worst_quality;
173         lrc->best_quality = rc->best_quality;
174       }
175     }
176   } else {
177     int layer_end;
178 
179     if (svc->number_temporal_layers > 1 && cpi->oxcf.rc_mode == VPX_CBR) {
180       layer_end = svc->number_temporal_layers;
181     } else {
182       layer_end = svc->number_spatial_layers;
183     }
184 
185     for (layer = 0; layer < layer_end; ++layer) {
186       LAYER_CONTEXT *const lc = &svc->layer_context[layer];
187       RATE_CONTROL *const lrc = &lc->rc;
188 
189       lc->target_bandwidth = oxcf->layer_target_bitrate[layer];
190 
191       bitrate_alloc = (float)lc->target_bandwidth / target_bandwidth;
192       // Update buffer-related quantities.
193       lrc->starting_buffer_level =
194           (int64_t)(rc->starting_buffer_level * bitrate_alloc);
195       lrc->optimal_buffer_level =
196           (int64_t)(rc->optimal_buffer_level * bitrate_alloc);
197       lrc->maximum_buffer_size =
198           (int64_t)(rc->maximum_buffer_size * bitrate_alloc);
199       lrc->bits_off_target = VPXMIN(lrc->bits_off_target,
200                                     lrc->maximum_buffer_size);
201       lrc->buffer_level = VPXMIN(lrc->buffer_level, lrc->maximum_buffer_size);
202       // Update framerate-related quantities.
203       if (svc->number_temporal_layers > 1 && cpi->oxcf.rc_mode == VPX_CBR) {
204         lc->framerate = cpi->framerate / oxcf->ts_rate_decimator[layer];
205       } else {
206         lc->framerate = cpi->framerate;
207       }
208       lrc->avg_frame_bandwidth = (int)(lc->target_bandwidth / lc->framerate);
209       lrc->max_frame_bandwidth = rc->max_frame_bandwidth;
210       // Update qp-related quantities.
211       lrc->worst_quality = rc->worst_quality;
212       lrc->best_quality = rc->best_quality;
213     }
214   }
215 }
216 
get_layer_context(VP9_COMP * const cpi)217 static LAYER_CONTEXT *get_layer_context(VP9_COMP *const cpi) {
218   if (is_one_pass_cbr_svc(cpi))
219     return &cpi->svc.layer_context[cpi->svc.spatial_layer_id *
220         cpi->svc.number_temporal_layers + cpi->svc.temporal_layer_id];
221   else
222     return (cpi->svc.number_temporal_layers > 1 &&
223             cpi->oxcf.rc_mode == VPX_CBR) ?
224              &cpi->svc.layer_context[cpi->svc.temporal_layer_id] :
225              &cpi->svc.layer_context[cpi->svc.spatial_layer_id];
226 }
227 
vp9_update_temporal_layer_framerate(VP9_COMP * const cpi)228 void vp9_update_temporal_layer_framerate(VP9_COMP *const cpi) {
229   SVC *const svc = &cpi->svc;
230   const VP9EncoderConfig *const oxcf = &cpi->oxcf;
231   LAYER_CONTEXT *const lc = get_layer_context(cpi);
232   RATE_CONTROL *const lrc = &lc->rc;
233   // Index into spatial+temporal arrays.
234   const int st_idx = svc->spatial_layer_id * svc->number_temporal_layers +
235       svc->temporal_layer_id;
236   const int tl = svc->temporal_layer_id;
237 
238   lc->framerate = cpi->framerate / oxcf->ts_rate_decimator[tl];
239   lrc->avg_frame_bandwidth = (int)(lc->target_bandwidth / lc->framerate);
240   lrc->max_frame_bandwidth = cpi->rc.max_frame_bandwidth;
241   // Update the average layer frame size (non-cumulative per-frame-bw).
242   if (tl == 0) {
243     lc->avg_frame_size = lrc->avg_frame_bandwidth;
244   } else {
245     const double prev_layer_framerate =
246         cpi->framerate / oxcf->ts_rate_decimator[tl - 1];
247     const int prev_layer_target_bandwidth =
248         oxcf->layer_target_bitrate[st_idx - 1];
249     lc->avg_frame_size =
250         (int)((lc->target_bandwidth - prev_layer_target_bandwidth) /
251               (lc->framerate - prev_layer_framerate));
252   }
253 }
254 
vp9_update_spatial_layer_framerate(VP9_COMP * const cpi,double framerate)255 void vp9_update_spatial_layer_framerate(VP9_COMP *const cpi, double framerate) {
256   const VP9EncoderConfig *const oxcf = &cpi->oxcf;
257   LAYER_CONTEXT *const lc = get_layer_context(cpi);
258   RATE_CONTROL *const lrc = &lc->rc;
259 
260   lc->framerate = framerate;
261   lrc->avg_frame_bandwidth = (int)(lc->target_bandwidth / lc->framerate);
262   lrc->min_frame_bandwidth = (int)(lrc->avg_frame_bandwidth *
263                                    oxcf->two_pass_vbrmin_section / 100);
264   lrc->max_frame_bandwidth = (int)(((int64_t)lrc->avg_frame_bandwidth *
265                                    oxcf->two_pass_vbrmax_section) / 100);
266   vp9_rc_set_gf_interval_range(cpi, lrc);
267 }
268 
vp9_restore_layer_context(VP9_COMP * const cpi)269 void vp9_restore_layer_context(VP9_COMP *const cpi) {
270   LAYER_CONTEXT *const lc = get_layer_context(cpi);
271   const int old_frame_since_key = cpi->rc.frames_since_key;
272   const int old_frame_to_key = cpi->rc.frames_to_key;
273 
274   cpi->rc = lc->rc;
275   cpi->twopass = lc->twopass;
276   cpi->oxcf.target_bandwidth = lc->target_bandwidth;
277   cpi->alt_ref_source = lc->alt_ref_source;
278   // Reset the frames_since_key and frames_to_key counters to their values
279   // before the layer restore. Keep these defined for the stream (not layer).
280   if (cpi->svc.number_temporal_layers > 1) {
281     cpi->rc.frames_since_key = old_frame_since_key;
282     cpi->rc.frames_to_key = old_frame_to_key;
283   }
284 
285   // For spatial-svc, allow cyclic-refresh to be applied on the spatial layers,
286   // for the base temporal layer.
287   if (cpi->oxcf.aq_mode == CYCLIC_REFRESH_AQ &&
288       cpi->svc.number_spatial_layers > 1 &&
289       cpi->svc.temporal_layer_id == 0) {
290     CYCLIC_REFRESH *const cr = cpi->cyclic_refresh;
291     signed char *temp = cr->map;
292     uint8_t *temp2 = cr->last_coded_q_map;
293     uint8_t *temp3 = cr->consec_zero_mv;
294     cr->map = lc->map;
295     lc->map = temp;
296     cr->last_coded_q_map = lc->last_coded_q_map;
297     lc->last_coded_q_map = temp2;
298     cr->consec_zero_mv = lc->consec_zero_mv;
299     lc->consec_zero_mv = temp3;
300     cr->sb_index = lc->sb_index;
301   }
302 }
303 
vp9_save_layer_context(VP9_COMP * const cpi)304 void vp9_save_layer_context(VP9_COMP *const cpi) {
305   const VP9EncoderConfig *const oxcf = &cpi->oxcf;
306   LAYER_CONTEXT *const lc = get_layer_context(cpi);
307 
308   lc->rc = cpi->rc;
309   lc->twopass = cpi->twopass;
310   lc->target_bandwidth = (int)oxcf->target_bandwidth;
311   lc->alt_ref_source = cpi->alt_ref_source;
312 
313   // For spatial-svc, allow cyclic-refresh to be applied on the spatial layers,
314   // for the base temporal layer.
315   if (cpi->oxcf.aq_mode == CYCLIC_REFRESH_AQ &&
316       cpi->svc.number_spatial_layers > 1 &&
317       cpi->svc.temporal_layer_id == 0) {
318     CYCLIC_REFRESH *const cr = cpi->cyclic_refresh;
319     signed char *temp = lc->map;
320     uint8_t *temp2 = lc->last_coded_q_map;
321     uint8_t *temp3 = lc->consec_zero_mv;
322     lc->map = cr->map;
323     cr->map = temp;
324     lc->last_coded_q_map = cr->last_coded_q_map;
325     cr->last_coded_q_map = temp2;
326     lc->consec_zero_mv = cr->consec_zero_mv;
327     cr->consec_zero_mv = temp3;
328     lc->sb_index = cr->sb_index;
329   }
330 }
331 
vp9_init_second_pass_spatial_svc(VP9_COMP * cpi)332 void vp9_init_second_pass_spatial_svc(VP9_COMP *cpi) {
333   SVC *const svc = &cpi->svc;
334   int i;
335 
336   for (i = 0; i < svc->number_spatial_layers; ++i) {
337     TWO_PASS *const twopass = &svc->layer_context[i].twopass;
338 
339     svc->spatial_layer_id = i;
340     vp9_init_second_pass(cpi);
341 
342     twopass->total_stats.spatial_layer_id = i;
343     twopass->total_left_stats.spatial_layer_id = i;
344   }
345   svc->spatial_layer_id = 0;
346 }
347 
vp9_inc_frame_in_layer(VP9_COMP * const cpi)348 void vp9_inc_frame_in_layer(VP9_COMP *const cpi) {
349   LAYER_CONTEXT *const lc =
350       &cpi->svc.layer_context[cpi->svc.spatial_layer_id *
351                               cpi->svc.number_temporal_layers];
352   ++lc->current_video_frame_in_layer;
353   ++lc->frames_from_key_frame;
354 }
355 
vp9_is_upper_layer_key_frame(const VP9_COMP * const cpi)356 int vp9_is_upper_layer_key_frame(const VP9_COMP *const cpi) {
357   return is_two_pass_svc(cpi) &&
358          cpi->svc.spatial_layer_id > 0 &&
359          cpi->svc.layer_context[cpi->svc.spatial_layer_id *
360                                 cpi->svc.number_temporal_layers +
361                                 cpi->svc.temporal_layer_id].is_key_frame;
362 }
363 
get_layer_resolution(const int width_org,const int height_org,const int num,const int den,int * width_out,int * height_out)364 static void get_layer_resolution(const int width_org, const int height_org,
365                                  const int num, const int den,
366                                  int *width_out, int *height_out) {
367   int w, h;
368 
369   if (width_out == NULL || height_out == NULL || den == 0)
370     return;
371 
372   w = width_org * num / den;
373   h = height_org * num / den;
374 
375   // make height and width even to make chrome player happy
376   w += w % 2;
377   h += h % 2;
378 
379   *width_out = w;
380   *height_out = h;
381 }
382 
383 // The function sets proper ref_frame_flags, buffer indices, and buffer update
384 // variables for temporal layering mode 3 - that does 0-2-1-2 temporal layering
385 // scheme.
set_flags_and_fb_idx_for_temporal_mode3(VP9_COMP * const cpi)386 static void set_flags_and_fb_idx_for_temporal_mode3(VP9_COMP *const cpi) {
387   int frame_num_within_temporal_struct = 0;
388   int spatial_id, temporal_id;
389   spatial_id = cpi->svc.spatial_layer_id = cpi->svc.spatial_layer_to_encode;
390   frame_num_within_temporal_struct =
391       cpi->svc.layer_context[cpi->svc.spatial_layer_id *
392       cpi->svc.number_temporal_layers].current_video_frame_in_layer % 4;
393   temporal_id = cpi->svc.temporal_layer_id =
394       (frame_num_within_temporal_struct & 1) ? 2 :
395       (frame_num_within_temporal_struct >> 1);
396   cpi->ext_refresh_last_frame = cpi->ext_refresh_golden_frame =
397       cpi->ext_refresh_alt_ref_frame = 0;
398   if (!temporal_id) {
399     cpi->ext_refresh_frame_flags_pending = 1;
400     cpi->ext_refresh_last_frame = 1;
401     if (!spatial_id) {
402       cpi->ref_frame_flags = VP9_LAST_FLAG;
403     } else if (cpi->svc.layer_context[temporal_id].is_key_frame) {
404       // base layer is a key frame.
405       cpi->ref_frame_flags = VP9_GOLD_FLAG;
406     } else {
407       cpi->ref_frame_flags = VP9_LAST_FLAG | VP9_GOLD_FLAG;
408     }
409   } else if (temporal_id == 1) {
410     cpi->ext_refresh_frame_flags_pending = 1;
411     cpi->ext_refresh_alt_ref_frame = 1;
412     if (!spatial_id) {
413       cpi->ref_frame_flags = VP9_LAST_FLAG;
414     } else {
415       cpi->ref_frame_flags = VP9_LAST_FLAG | VP9_GOLD_FLAG;
416     }
417   } else {
418     if (frame_num_within_temporal_struct == 1) {
419       // the first tl2 picture
420       if (!spatial_id) {
421         cpi->ext_refresh_frame_flags_pending = 1;
422         cpi->ext_refresh_alt_ref_frame = 1;
423         cpi->ref_frame_flags = VP9_LAST_FLAG;
424       } else if (spatial_id < cpi->svc.number_spatial_layers - 1) {
425         cpi->ext_refresh_frame_flags_pending = 1;
426         cpi->ext_refresh_alt_ref_frame = 1;
427         cpi->ref_frame_flags = VP9_LAST_FLAG | VP9_GOLD_FLAG;
428       } else {  // Top layer
429         cpi->ext_refresh_frame_flags_pending = 0;
430         cpi->ref_frame_flags = VP9_LAST_FLAG | VP9_GOLD_FLAG;
431       }
432     } else {
433       //  The second tl2 picture
434       if (!spatial_id) {
435         cpi->ext_refresh_frame_flags_pending = 1;
436         cpi->ref_frame_flags = VP9_LAST_FLAG;
437         cpi->ext_refresh_last_frame = 1;
438       } else if (spatial_id < cpi->svc.number_spatial_layers - 1) {
439         cpi->ext_refresh_frame_flags_pending = 1;
440         cpi->ref_frame_flags = VP9_LAST_FLAG | VP9_GOLD_FLAG;
441         cpi->ext_refresh_last_frame = 1;
442       } else {  // top layer
443         cpi->ext_refresh_frame_flags_pending = 0;
444         cpi->ref_frame_flags = VP9_LAST_FLAG | VP9_GOLD_FLAG;
445       }
446     }
447   }
448   if (temporal_id == 0) {
449     cpi->lst_fb_idx = spatial_id;
450     if (spatial_id)
451       cpi->gld_fb_idx = spatial_id - 1;
452     else
453       cpi->gld_fb_idx = 0;
454     cpi->alt_fb_idx = 0;
455   } else if (temporal_id == 1) {
456     cpi->lst_fb_idx = spatial_id;
457     cpi->gld_fb_idx = cpi->svc.number_spatial_layers + spatial_id - 1;
458     cpi->alt_fb_idx = cpi->svc.number_spatial_layers + spatial_id;
459   } else if (frame_num_within_temporal_struct == 1) {
460     cpi->lst_fb_idx = spatial_id;
461     cpi->gld_fb_idx = cpi->svc.number_spatial_layers + spatial_id - 1;
462     cpi->alt_fb_idx = cpi->svc.number_spatial_layers + spatial_id;
463   } else {
464     cpi->lst_fb_idx = cpi->svc.number_spatial_layers + spatial_id;
465     cpi->gld_fb_idx = cpi->svc.number_spatial_layers + spatial_id - 1;
466     cpi->alt_fb_idx = 0;
467   }
468 }
469 
470 // The function sets proper ref_frame_flags, buffer indices, and buffer update
471 // variables for temporal layering mode 2 - that does 0-1-0-1 temporal layering
472 // scheme.
set_flags_and_fb_idx_for_temporal_mode2(VP9_COMP * const cpi)473 static void set_flags_and_fb_idx_for_temporal_mode2(VP9_COMP *const cpi) {
474   int spatial_id, temporal_id;
475   spatial_id = cpi->svc.spatial_layer_id = cpi->svc.spatial_layer_to_encode;
476   temporal_id = cpi->svc.temporal_layer_id =
477       cpi->svc.layer_context[cpi->svc.spatial_layer_id *
478       cpi->svc.number_temporal_layers].current_video_frame_in_layer & 1;
479   cpi->ext_refresh_last_frame = cpi->ext_refresh_golden_frame =
480                                 cpi->ext_refresh_alt_ref_frame = 0;
481   if (!temporal_id) {
482     cpi->ext_refresh_frame_flags_pending = 1;
483     cpi->ext_refresh_last_frame = 1;
484     if (!spatial_id) {
485       cpi->ref_frame_flags = VP9_LAST_FLAG;
486     } else if (cpi->svc.layer_context[temporal_id].is_key_frame) {
487       // base layer is a key frame.
488       cpi->ref_frame_flags = VP9_GOLD_FLAG;
489     } else {
490       cpi->ref_frame_flags = VP9_LAST_FLAG | VP9_GOLD_FLAG;
491     }
492   } else if (temporal_id == 1) {
493     cpi->ext_refresh_frame_flags_pending = 1;
494     cpi->ext_refresh_alt_ref_frame = 1;
495     if (!spatial_id) {
496       cpi->ref_frame_flags = VP9_LAST_FLAG;
497     } else {
498       cpi->ref_frame_flags = VP9_LAST_FLAG | VP9_GOLD_FLAG;
499     }
500   }
501 
502   if (temporal_id == 0) {
503     cpi->lst_fb_idx = spatial_id;
504     if (spatial_id)
505       cpi->gld_fb_idx = spatial_id - 1;
506     else
507       cpi->gld_fb_idx = 0;
508     cpi->alt_fb_idx = 0;
509   } else if (temporal_id == 1) {
510     cpi->lst_fb_idx = spatial_id;
511     cpi->gld_fb_idx = cpi->svc.number_spatial_layers + spatial_id - 1;
512     cpi->alt_fb_idx = cpi->svc.number_spatial_layers + spatial_id;
513   }
514 }
515 
516 // The function sets proper ref_frame_flags, buffer indices, and buffer update
517 // variables for temporal layering mode 0 - that has no temporal layering.
set_flags_and_fb_idx_for_temporal_mode_noLayering(VP9_COMP * const cpi)518 static void set_flags_and_fb_idx_for_temporal_mode_noLayering(
519     VP9_COMP *const cpi) {
520   int spatial_id;
521   spatial_id = cpi->svc.spatial_layer_id = cpi->svc.spatial_layer_to_encode;
522   cpi->ext_refresh_last_frame =
523       cpi->ext_refresh_golden_frame = cpi->ext_refresh_alt_ref_frame = 0;
524   cpi->ext_refresh_frame_flags_pending = 1;
525   cpi->ext_refresh_last_frame = 1;
526   if (!spatial_id) {
527     cpi->ref_frame_flags = VP9_LAST_FLAG;
528   } else if (cpi->svc.layer_context[0].is_key_frame) {
529     cpi->ref_frame_flags = VP9_GOLD_FLAG;
530   } else {
531     cpi->ref_frame_flags = VP9_LAST_FLAG | VP9_GOLD_FLAG;
532   }
533   cpi->lst_fb_idx = spatial_id;
534   if (spatial_id)
535     cpi->gld_fb_idx = spatial_id - 1;
536   else
537     cpi->gld_fb_idx = 0;
538 }
539 
vp9_one_pass_cbr_svc_start_layer(VP9_COMP * const cpi)540 int vp9_one_pass_cbr_svc_start_layer(VP9_COMP *const cpi) {
541   int width = 0, height = 0;
542   LAYER_CONTEXT *lc = NULL;
543 
544   if (cpi->svc.temporal_layering_mode == VP9E_TEMPORAL_LAYERING_MODE_0212) {
545     set_flags_and_fb_idx_for_temporal_mode3(cpi);
546   } else if (cpi->svc.temporal_layering_mode ==
547            VP9E_TEMPORAL_LAYERING_MODE_NOLAYERING) {
548     set_flags_and_fb_idx_for_temporal_mode_noLayering(cpi);
549   } else if (cpi->svc.temporal_layering_mode ==
550            VP9E_TEMPORAL_LAYERING_MODE_0101) {
551     set_flags_and_fb_idx_for_temporal_mode2(cpi);
552   } else if (cpi->svc.temporal_layering_mode ==
553       VP9E_TEMPORAL_LAYERING_MODE_BYPASS) {
554     // In the BYPASS/flexible mode, the encoder is relying on the application
555     // to specify, for each spatial layer, the flags and buffer indices for the
556     // layering.
557     // Note that the check (cpi->ext_refresh_frame_flags_pending == 0) is
558     // needed to support the case where the frame flags may be passed in via
559     // vpx_codec_encode(), which can be used for the temporal-only svc case.
560     if (cpi->ext_refresh_frame_flags_pending == 0) {
561       int sl;
562       cpi->svc.spatial_layer_id = cpi->svc.spatial_layer_to_encode;
563       sl = cpi->svc.spatial_layer_id;
564       vp9_apply_encoding_flags(cpi, cpi->svc.ext_frame_flags[sl]);
565       cpi->lst_fb_idx = cpi->svc.ext_lst_fb_idx[sl];
566       cpi->gld_fb_idx = cpi->svc.ext_gld_fb_idx[sl];
567       cpi->alt_fb_idx = cpi->svc.ext_alt_fb_idx[sl];
568     }
569   }
570 
571   lc = &cpi->svc.layer_context[cpi->svc.spatial_layer_id *
572                                cpi->svc.number_temporal_layers +
573                                cpi->svc.temporal_layer_id];
574 
575   // Setting the worst/best_quality via the encoder control: SET_SVC_PARAMETERS,
576   // only for non-BYPASS mode for now.
577   if (cpi->svc.temporal_layering_mode != VP9E_TEMPORAL_LAYERING_MODE_BYPASS) {
578     RATE_CONTROL *const lrc = &lc->rc;
579     lrc->worst_quality = vp9_quantizer_to_qindex(lc->max_q);
580     lrc->best_quality =  vp9_quantizer_to_qindex(lc->min_q);
581   }
582 
583   get_layer_resolution(cpi->oxcf.width, cpi->oxcf.height,
584                        lc->scaling_factor_num, lc->scaling_factor_den,
585                        &width, &height);
586 
587   if (vp9_set_size_literal(cpi, width, height) != 0)
588     return VPX_CODEC_INVALID_PARAM;
589 
590   return 0;
591 }
592 
593 #if CONFIG_SPATIAL_SVC
vp9_svc_start_frame(VP9_COMP * const cpi)594 int vp9_svc_start_frame(VP9_COMP *const cpi) {
595   int width = 0, height = 0;
596   LAYER_CONTEXT *lc;
597   struct lookahead_entry *buf;
598   int count = 1 << (cpi->svc.number_temporal_layers - 1);
599 
600   cpi->svc.spatial_layer_id = cpi->svc.spatial_layer_to_encode;
601   lc = &cpi->svc.layer_context[cpi->svc.spatial_layer_id];
602 
603   cpi->svc.temporal_layer_id = 0;
604   while ((lc->current_video_frame_in_layer % count) != 0) {
605     ++cpi->svc.temporal_layer_id;
606     count >>= 1;
607   }
608 
609   cpi->ref_frame_flags = VP9_ALT_FLAG | VP9_GOLD_FLAG | VP9_LAST_FLAG;
610 
611   cpi->lst_fb_idx = cpi->svc.spatial_layer_id;
612 
613   if (cpi->svc.spatial_layer_id == 0)
614     cpi->gld_fb_idx = (lc->gold_ref_idx >= 0) ?
615                       lc->gold_ref_idx : cpi->lst_fb_idx;
616   else
617     cpi->gld_fb_idx = cpi->svc.spatial_layer_id - 1;
618 
619   if (lc->current_video_frame_in_layer == 0) {
620     if (cpi->svc.spatial_layer_id >= 2) {
621       cpi->alt_fb_idx = cpi->svc.spatial_layer_id - 2;
622     } else {
623       cpi->alt_fb_idx = cpi->lst_fb_idx;
624       cpi->ref_frame_flags &= (~VP9_LAST_FLAG & ~VP9_ALT_FLAG);
625     }
626   } else {
627     if (cpi->oxcf.ss_enable_auto_arf[cpi->svc.spatial_layer_id]) {
628       cpi->alt_fb_idx = lc->alt_ref_idx;
629       if (!lc->has_alt_frame)
630         cpi->ref_frame_flags &= (~VP9_ALT_FLAG);
631     } else {
632       // Find a proper alt_fb_idx for layers that don't have alt ref frame
633       if (cpi->svc.spatial_layer_id == 0) {
634         cpi->alt_fb_idx = cpi->lst_fb_idx;
635       } else {
636         LAYER_CONTEXT *lc_lower =
637             &cpi->svc.layer_context[cpi->svc.spatial_layer_id - 1];
638 
639         if (cpi->oxcf.ss_enable_auto_arf[cpi->svc.spatial_layer_id - 1] &&
640             lc_lower->alt_ref_source != NULL)
641           cpi->alt_fb_idx = lc_lower->alt_ref_idx;
642         else if (cpi->svc.spatial_layer_id >= 2)
643           cpi->alt_fb_idx = cpi->svc.spatial_layer_id - 2;
644         else
645           cpi->alt_fb_idx = cpi->lst_fb_idx;
646       }
647     }
648   }
649 
650   get_layer_resolution(cpi->oxcf.width, cpi->oxcf.height,
651                        lc->scaling_factor_num, lc->scaling_factor_den,
652                        &width, &height);
653 
654   // Workaround for multiple frame contexts. In some frames we can't use prev_mi
655   // since its previous frame could be changed during decoding time. The idea is
656   // we put a empty invisible frame in front of them, then we will not use
657   // prev_mi when encoding these frames.
658 
659   buf = vp9_lookahead_peek(cpi->lookahead, 0);
660   if (cpi->oxcf.error_resilient_mode == 0 && cpi->oxcf.pass == 2 &&
661       cpi->svc.encode_empty_frame_state == NEED_TO_ENCODE &&
662       lc->rc.frames_to_key != 0 &&
663       !(buf != NULL && (buf->flags & VPX_EFLAG_FORCE_KF))) {
664     if ((cpi->svc.number_temporal_layers > 1 &&
665          cpi->svc.temporal_layer_id < cpi->svc.number_temporal_layers - 1) ||
666         (cpi->svc.number_spatial_layers > 1 &&
667          cpi->svc.spatial_layer_id == 0)) {
668       struct lookahead_entry *buf = vp9_lookahead_peek(cpi->lookahead, 0);
669 
670       if (buf != NULL) {
671         cpi->svc.empty_frame.ts_start = buf->ts_start;
672         cpi->svc.empty_frame.ts_end = buf->ts_end;
673         cpi->svc.encode_empty_frame_state = ENCODING;
674         cpi->common.show_frame = 0;
675         cpi->ref_frame_flags = 0;
676         cpi->common.frame_type = INTER_FRAME;
677         cpi->lst_fb_idx =
678             cpi->gld_fb_idx = cpi->alt_fb_idx = SMALL_FRAME_FB_IDX;
679 
680         if (cpi->svc.encode_intra_empty_frame != 0)
681           cpi->common.intra_only = 1;
682 
683         width = SMALL_FRAME_WIDTH;
684         height = SMALL_FRAME_HEIGHT;
685       }
686     }
687   }
688 
689   cpi->oxcf.worst_allowed_q = vp9_quantizer_to_qindex(lc->max_q);
690   cpi->oxcf.best_allowed_q = vp9_quantizer_to_qindex(lc->min_q);
691 
692   vp9_change_config(cpi, &cpi->oxcf);
693 
694   if (vp9_set_size_literal(cpi, width, height) != 0)
695     return VPX_CODEC_INVALID_PARAM;
696 
697   vp9_set_high_precision_mv(cpi, 1);
698 
699   cpi->alt_ref_source = get_layer_context(cpi)->alt_ref_source;
700 
701   return 0;
702 }
703 
704 #endif
705 
vp9_svc_lookahead_pop(VP9_COMP * const cpi,struct lookahead_ctx * ctx,int drain)706 struct lookahead_entry *vp9_svc_lookahead_pop(VP9_COMP *const cpi,
707                                               struct lookahead_ctx *ctx,
708                                               int drain) {
709   struct lookahead_entry *buf = NULL;
710   if (ctx->sz && (drain || ctx->sz == ctx->max_sz - MAX_PRE_FRAMES)) {
711     buf = vp9_lookahead_peek(ctx, 0);
712     if (buf != NULL) {
713       // Only remove the buffer when pop the highest layer.
714       if (cpi->svc.spatial_layer_id == cpi->svc.number_spatial_layers - 1) {
715         vp9_lookahead_pop(ctx, drain);
716       }
717     }
718   }
719   return buf;
720 }
721 
vp9_free_svc_cyclic_refresh(VP9_COMP * const cpi)722 void vp9_free_svc_cyclic_refresh(VP9_COMP *const cpi) {
723   int sl, tl;
724   SVC *const svc = &cpi->svc;
725   const VP9EncoderConfig *const oxcf = &cpi->oxcf;
726   for (sl = 0; sl < oxcf->ss_number_layers; ++sl) {
727     for (tl = 0; tl < oxcf->ts_number_layers; ++tl) {
728       int layer = LAYER_IDS_TO_IDX(sl, tl, oxcf->ts_number_layers);
729       LAYER_CONTEXT *const lc = &svc->layer_context[layer];
730         if (lc->map)
731           vpx_free(lc->map);
732         if (lc->last_coded_q_map)
733           vpx_free(lc->last_coded_q_map);
734         if (lc->consec_zero_mv)
735           vpx_free(lc->consec_zero_mv);
736     }
737   }
738 }
739