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_encoder.h"
14 #include "vp9/encoder/vp9_svc_layercontext.h"
15 #include "vp9/encoder/vp9_extend.h"
16
vp9_init_layer_context(VP9_COMP * const cpi)17 void vp9_init_layer_context(VP9_COMP *const cpi) {
18 SVC *const svc = &cpi->svc;
19 const VP9EncoderConfig *const oxcf = &cpi->oxcf;
20 int layer;
21 int layer_end;
22 int alt_ref_idx = svc->number_spatial_layers;
23
24 svc->spatial_layer_id = 0;
25 svc->temporal_layer_id = 0;
26
27 if (svc->number_temporal_layers > 1) {
28 layer_end = svc->number_temporal_layers;
29 } else {
30 layer_end = svc->number_spatial_layers;
31 }
32
33 for (layer = 0; layer < layer_end; ++layer) {
34 LAYER_CONTEXT *const lc = &svc->layer_context[layer];
35 RATE_CONTROL *const lrc = &lc->rc;
36 int i;
37 lc->current_video_frame_in_layer = 0;
38 lc->layer_size = 0;
39 lrc->ni_av_qi = oxcf->worst_allowed_q;
40 lrc->total_actual_bits = 0;
41 lrc->total_target_vs_actual = 0;
42 lrc->ni_tot_qi = 0;
43 lrc->tot_q = 0.0;
44 lrc->avg_q = 0.0;
45 lrc->ni_frames = 0;
46 lrc->decimation_count = 0;
47 lrc->decimation_factor = 0;
48
49 for (i = 0; i < RATE_FACTOR_LEVELS; ++i) {
50 lrc->rate_correction_factors[i] = 1.0;
51 }
52
53 if (svc->number_temporal_layers > 1) {
54 lc->target_bandwidth = oxcf->ts_target_bitrate[layer];
55 lrc->last_q[INTER_FRAME] = oxcf->worst_allowed_q;
56 lrc->avg_frame_qindex[INTER_FRAME] = oxcf->worst_allowed_q;
57 } else {
58 lc->target_bandwidth = oxcf->ss_target_bitrate[layer];
59 lrc->last_q[KEY_FRAME] = oxcf->best_allowed_q;
60 lrc->last_q[INTER_FRAME] = oxcf->best_allowed_q;
61 lrc->avg_frame_qindex[KEY_FRAME] = (oxcf->worst_allowed_q +
62 oxcf->best_allowed_q) / 2;
63 lrc->avg_frame_qindex[INTER_FRAME] = (oxcf->worst_allowed_q +
64 oxcf->best_allowed_q) / 2;
65 if (oxcf->ss_play_alternate[layer])
66 lc->alt_ref_idx = alt_ref_idx++;
67 else
68 lc->alt_ref_idx = -1;
69 lc->gold_ref_idx = -1;
70 }
71
72 lrc->buffer_level = vp9_rescale((int)(oxcf->starting_buffer_level_ms),
73 lc->target_bandwidth, 1000);
74 lrc->bits_off_target = lrc->buffer_level;
75 }
76
77 // Still have extra buffer for base layer golden frame
78 if (svc->number_spatial_layers > 1 && alt_ref_idx < REF_FRAMES)
79 svc->layer_context[0].gold_ref_idx = alt_ref_idx;
80 }
81
82 // Update the layer context from a change_config() call.
vp9_update_layer_context_change_config(VP9_COMP * const cpi,const int target_bandwidth)83 void vp9_update_layer_context_change_config(VP9_COMP *const cpi,
84 const int target_bandwidth) {
85 SVC *const svc = &cpi->svc;
86 const VP9EncoderConfig *const oxcf = &cpi->oxcf;
87 const RATE_CONTROL *const rc = &cpi->rc;
88 int layer;
89 int layer_end;
90 float bitrate_alloc = 1.0;
91
92 if (svc->number_temporal_layers > 1) {
93 layer_end = svc->number_temporal_layers;
94 } else {
95 layer_end = svc->number_spatial_layers;
96 }
97
98 for (layer = 0; layer < layer_end; ++layer) {
99 LAYER_CONTEXT *const lc = &svc->layer_context[layer];
100 RATE_CONTROL *const lrc = &lc->rc;
101
102 if (svc->number_temporal_layers > 1) {
103 lc->target_bandwidth = oxcf->ts_target_bitrate[layer];
104 } else {
105 lc->target_bandwidth = oxcf->ss_target_bitrate[layer];
106 }
107 bitrate_alloc = (float)lc->target_bandwidth / target_bandwidth;
108 // Update buffer-related quantities.
109 lrc->starting_buffer_level =
110 (int64_t)(rc->starting_buffer_level * bitrate_alloc);
111 lrc->optimal_buffer_level =
112 (int64_t)(rc->optimal_buffer_level * bitrate_alloc);
113 lrc->maximum_buffer_size =
114 (int64_t)(rc->maximum_buffer_size * bitrate_alloc);
115 lrc->bits_off_target = MIN(lrc->bits_off_target, lrc->maximum_buffer_size);
116 lrc->buffer_level = MIN(lrc->buffer_level, lrc->maximum_buffer_size);
117 // Update framerate-related quantities.
118 if (svc->number_temporal_layers > 1) {
119 lc->framerate = oxcf->framerate / oxcf->ts_rate_decimator[layer];
120 } else {
121 lc->framerate = oxcf->framerate;
122 }
123 lrc->avg_frame_bandwidth = (int)(lc->target_bandwidth / lc->framerate);
124 lrc->max_frame_bandwidth = rc->max_frame_bandwidth;
125 // Update qp-related quantities.
126 lrc->worst_quality = rc->worst_quality;
127 lrc->best_quality = rc->best_quality;
128 }
129 }
130
get_layer_context(SVC * svc)131 static LAYER_CONTEXT *get_layer_context(SVC *svc) {
132 return svc->number_temporal_layers > 1 ?
133 &svc->layer_context[svc->temporal_layer_id] :
134 &svc->layer_context[svc->spatial_layer_id];
135 }
136
vp9_update_temporal_layer_framerate(VP9_COMP * const cpi)137 void vp9_update_temporal_layer_framerate(VP9_COMP *const cpi) {
138 SVC *const svc = &cpi->svc;
139 const VP9EncoderConfig *const oxcf = &cpi->oxcf;
140 LAYER_CONTEXT *const lc = get_layer_context(svc);
141 RATE_CONTROL *const lrc = &lc->rc;
142 const int layer = svc->temporal_layer_id;
143
144 lc->framerate = oxcf->framerate / oxcf->ts_rate_decimator[layer];
145 lrc->avg_frame_bandwidth = (int)(lc->target_bandwidth / lc->framerate);
146 lrc->max_frame_bandwidth = cpi->rc.max_frame_bandwidth;
147 // Update the average layer frame size (non-cumulative per-frame-bw).
148 if (layer == 0) {
149 lc->avg_frame_size = lrc->avg_frame_bandwidth;
150 } else {
151 const double prev_layer_framerate =
152 oxcf->framerate / oxcf->ts_rate_decimator[layer - 1];
153 const int prev_layer_target_bandwidth = oxcf->ts_target_bitrate[layer - 1];
154 lc->avg_frame_size =
155 (int)((lc->target_bandwidth - prev_layer_target_bandwidth) /
156 (lc->framerate - prev_layer_framerate));
157 }
158 }
159
vp9_update_spatial_layer_framerate(VP9_COMP * const cpi,double framerate)160 void vp9_update_spatial_layer_framerate(VP9_COMP *const cpi, double framerate) {
161 const VP9EncoderConfig *const oxcf = &cpi->oxcf;
162 LAYER_CONTEXT *const lc = get_layer_context(&cpi->svc);
163 RATE_CONTROL *const lrc = &lc->rc;
164
165 lc->framerate = framerate;
166 lrc->avg_frame_bandwidth = (int)(lc->target_bandwidth / lc->framerate);
167 lrc->min_frame_bandwidth = (int)(lrc->avg_frame_bandwidth *
168 oxcf->two_pass_vbrmin_section / 100);
169 lrc->max_frame_bandwidth = (int)(((int64_t)lrc->avg_frame_bandwidth *
170 oxcf->two_pass_vbrmax_section) / 100);
171 vp9_rc_set_gf_max_interval(cpi, lrc);
172 }
173
vp9_restore_layer_context(VP9_COMP * const cpi)174 void vp9_restore_layer_context(VP9_COMP *const cpi) {
175 LAYER_CONTEXT *const lc = get_layer_context(&cpi->svc);
176 const int old_frame_since_key = cpi->rc.frames_since_key;
177 const int old_frame_to_key = cpi->rc.frames_to_key;
178
179 cpi->rc = lc->rc;
180 cpi->twopass = lc->twopass;
181 cpi->oxcf.target_bandwidth = lc->target_bandwidth;
182 cpi->alt_ref_source = lc->alt_ref_source;
183 // Reset the frames_since_key and frames_to_key counters to their values
184 // before the layer restore. Keep these defined for the stream (not layer).
185 if (cpi->svc.number_temporal_layers > 1) {
186 cpi->rc.frames_since_key = old_frame_since_key;
187 cpi->rc.frames_to_key = old_frame_to_key;
188 }
189 }
190
vp9_save_layer_context(VP9_COMP * const cpi)191 void vp9_save_layer_context(VP9_COMP *const cpi) {
192 const VP9EncoderConfig *const oxcf = &cpi->oxcf;
193 LAYER_CONTEXT *const lc = get_layer_context(&cpi->svc);
194
195 lc->rc = cpi->rc;
196 lc->twopass = cpi->twopass;
197 lc->target_bandwidth = (int)oxcf->target_bandwidth;
198 lc->alt_ref_source = cpi->alt_ref_source;
199 }
200
vp9_init_second_pass_spatial_svc(VP9_COMP * cpi)201 void vp9_init_second_pass_spatial_svc(VP9_COMP *cpi) {
202 SVC *const svc = &cpi->svc;
203 int i;
204
205 for (i = 0; i < svc->number_spatial_layers; ++i) {
206 TWO_PASS *const twopass = &svc->layer_context[i].twopass;
207
208 svc->spatial_layer_id = i;
209 vp9_init_second_pass(cpi);
210
211 twopass->total_stats.spatial_layer_id = i;
212 twopass->total_left_stats.spatial_layer_id = i;
213 }
214 svc->spatial_layer_id = 0;
215 }
216
vp9_inc_frame_in_layer(SVC * svc)217 void vp9_inc_frame_in_layer(SVC *svc) {
218 LAYER_CONTEXT *const lc = (svc->number_temporal_layers > 1)
219 ? &svc->layer_context[svc->temporal_layer_id]
220 : &svc->layer_context[svc->spatial_layer_id];
221 ++lc->current_video_frame_in_layer;
222 }
223
vp9_is_upper_layer_key_frame(const VP9_COMP * const cpi)224 int vp9_is_upper_layer_key_frame(const VP9_COMP *const cpi) {
225 return is_spatial_svc(cpi) &&
226 cpi->svc.spatial_layer_id > 0 &&
227 cpi->svc.layer_context[cpi->svc.spatial_layer_id].is_key_frame;
228 }
229
230 #if CONFIG_SPATIAL_SVC
vp9_svc_lookahead_push(const VP9_COMP * const cpi,struct lookahead_ctx * ctx,YV12_BUFFER_CONFIG * src,int64_t ts_start,int64_t ts_end,unsigned int flags)231 int vp9_svc_lookahead_push(const VP9_COMP *const cpi, struct lookahead_ctx *ctx,
232 YV12_BUFFER_CONFIG *src, int64_t ts_start,
233 int64_t ts_end, unsigned int flags) {
234 struct lookahead_entry *buf;
235 int i, index;
236
237 if (vp9_lookahead_push(ctx, src, ts_start, ts_end, flags))
238 return 1;
239
240 index = ctx->write_idx - 1;
241 if (index < 0)
242 index += ctx->max_sz;
243
244 buf = ctx->buf + index;
245
246 if (buf == NULL)
247 return 1;
248
249 // Store svc parameters for each layer
250 for (i = 0; i < cpi->svc.number_spatial_layers; ++i)
251 buf->svc_params[i] = cpi->svc.layer_context[i].svc_params_received;
252
253 return 0;
254 }
255
copy_svc_params(VP9_COMP * const cpi,struct lookahead_entry * buf)256 static int copy_svc_params(VP9_COMP *const cpi, struct lookahead_entry *buf) {
257 int layer_id;
258 vpx_svc_parameters_t *layer_param;
259 LAYER_CONTEXT *lc;
260
261 // Find the next layer to be encoded
262 for (layer_id = 0; layer_id < cpi->svc.number_spatial_layers; ++layer_id) {
263 if (buf->svc_params[layer_id].spatial_layer >=0)
264 break;
265 }
266
267 if (layer_id == cpi->svc.number_spatial_layers)
268 return 1;
269
270 layer_param = &buf->svc_params[layer_id];
271 cpi->svc.spatial_layer_id = layer_param->spatial_layer;
272 cpi->svc.temporal_layer_id = layer_param->temporal_layer;
273 cpi->ref_frame_flags = VP9_ALT_FLAG | VP9_GOLD_FLAG | VP9_LAST_FLAG;
274
275 lc = &cpi->svc.layer_context[cpi->svc.spatial_layer_id];
276
277 cpi->lst_fb_idx = cpi->svc.spatial_layer_id;
278
279 if (cpi->svc.spatial_layer_id < 1)
280 cpi->gld_fb_idx = lc->gold_ref_idx >= 0 ?
281 lc->gold_ref_idx : cpi->lst_fb_idx;
282 else
283 cpi->gld_fb_idx = cpi->svc.spatial_layer_id - 1;
284
285 if (lc->current_video_frame_in_layer == 0) {
286 if (cpi->svc.spatial_layer_id >= 2) {
287 cpi->alt_fb_idx = cpi->svc.spatial_layer_id - 2;
288 } else {
289 cpi->alt_fb_idx = cpi->lst_fb_idx;
290 cpi->ref_frame_flags &= (~VP9_LAST_FLAG & ~VP9_ALT_FLAG);
291 }
292 } else {
293 if (cpi->oxcf.ss_play_alternate[cpi->svc.spatial_layer_id]) {
294 cpi->alt_fb_idx = lc->alt_ref_idx;
295 if (!lc->has_alt_frame)
296 cpi->ref_frame_flags &= (~VP9_ALT_FLAG);
297 } else {
298 // Find a proper alt_fb_idx for layers that don't have alt ref frame
299 if (cpi->svc.spatial_layer_id == 0) {
300 cpi->alt_fb_idx = cpi->lst_fb_idx;
301 } else {
302 LAYER_CONTEXT *lc_lower =
303 &cpi->svc.layer_context[cpi->svc.spatial_layer_id - 1];
304
305 if (cpi->oxcf.ss_play_alternate[cpi->svc.spatial_layer_id - 1] &&
306 lc_lower->alt_ref_source != NULL)
307 cpi->alt_fb_idx = lc_lower->alt_ref_idx;
308 else if (cpi->svc.spatial_layer_id >= 2)
309 cpi->alt_fb_idx = cpi->svc.spatial_layer_id - 2;
310 else
311 cpi->alt_fb_idx = cpi->lst_fb_idx;
312 }
313 }
314 }
315
316 if (vp9_set_size_literal(cpi, layer_param->width, layer_param->height) != 0)
317 return VPX_CODEC_INVALID_PARAM;
318
319 cpi->oxcf.worst_allowed_q =
320 vp9_quantizer_to_qindex(layer_param->max_quantizer);
321 cpi->oxcf.best_allowed_q =
322 vp9_quantizer_to_qindex(layer_param->min_quantizer);
323
324 vp9_change_config(cpi, &cpi->oxcf);
325
326 vp9_set_high_precision_mv(cpi, 1);
327
328 cpi->alt_ref_source = get_layer_context(&cpi->svc)->alt_ref_source;
329
330 return 0;
331 }
332
vp9_svc_lookahead_peek(VP9_COMP * const cpi,struct lookahead_ctx * ctx,int index,int copy_params)333 struct lookahead_entry *vp9_svc_lookahead_peek(VP9_COMP *const cpi,
334 struct lookahead_ctx *ctx,
335 int index, int copy_params) {
336 struct lookahead_entry *buf = vp9_lookahead_peek(ctx, index);
337
338 if (buf != NULL && copy_params != 0) {
339 if (copy_svc_params(cpi, buf) != 0)
340 return NULL;
341 }
342 return buf;
343 }
344
vp9_svc_lookahead_pop(VP9_COMP * const cpi,struct lookahead_ctx * ctx,int drain)345 struct lookahead_entry *vp9_svc_lookahead_pop(VP9_COMP *const cpi,
346 struct lookahead_ctx *ctx,
347 int drain) {
348 struct lookahead_entry *buf = NULL;
349
350 if (ctx->sz && (drain || ctx->sz == ctx->max_sz - MAX_PRE_FRAMES)) {
351 buf = vp9_svc_lookahead_peek(cpi, ctx, 0, 1);
352 if (buf != NULL) {
353 // Only remove the buffer when pop the highest layer. Simply set the
354 // spatial_layer to -1 for lower layers.
355 buf->svc_params[cpi->svc.spatial_layer_id].spatial_layer = -1;
356 if (cpi->svc.spatial_layer_id == cpi->svc.number_spatial_layers - 1) {
357 vp9_lookahead_pop(ctx, drain);
358 }
359 }
360 }
361
362 return buf;
363 }
364 #endif
365