OLD | NEW |
(Empty) | |
| 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_onyx_int.h" |
| 14 #include "vp9/encoder/vp9_svc_layercontext.h" |
| 15 |
| 16 void vp9_init_layer_context(VP9_COMP *const cpi) { |
| 17 SVC *const svc = &cpi->svc; |
| 18 const VP9_CONFIG *const oxcf = &cpi->oxcf; |
| 19 int layer; |
| 20 int layer_end; |
| 21 |
| 22 svc->spatial_layer_id = 0; |
| 23 svc->temporal_layer_id = 0; |
| 24 |
| 25 if (svc->number_temporal_layers > 1) { |
| 26 layer_end = svc->number_temporal_layers; |
| 27 } else { |
| 28 layer_end = svc->number_spatial_layers; |
| 29 } |
| 30 |
| 31 for (layer = 0; layer < layer_end; ++layer) { |
| 32 LAYER_CONTEXT *const lc = &svc->layer_context[layer]; |
| 33 RATE_CONTROL *const lrc = &lc->rc; |
| 34 lc->current_video_frame_in_layer = 0; |
| 35 lrc->avg_frame_qindex[INTER_FRAME] = oxcf->worst_allowed_q; |
| 36 lrc->ni_av_qi = oxcf->worst_allowed_q; |
| 37 lrc->total_actual_bits = 0; |
| 38 lrc->total_target_vs_actual = 0; |
| 39 lrc->ni_tot_qi = 0; |
| 40 lrc->tot_q = 0.0; |
| 41 lrc->avg_q = 0.0; |
| 42 lrc->ni_frames = 0; |
| 43 lrc->decimation_count = 0; |
| 44 lrc->decimation_factor = 0; |
| 45 lrc->rate_correction_factor = 1.0; |
| 46 lrc->key_frame_rate_correction_factor = 1.0; |
| 47 |
| 48 if (svc->number_temporal_layers > 1) { |
| 49 lc->target_bandwidth = oxcf->ts_target_bitrate[layer] * 1000; |
| 50 lrc->last_q[INTER_FRAME] = oxcf->worst_allowed_q; |
| 51 } else { |
| 52 lc->target_bandwidth = oxcf->ss_target_bitrate[layer] * 1000; |
| 53 lrc->last_q[0] = oxcf->best_allowed_q; |
| 54 lrc->last_q[1] = oxcf->best_allowed_q; |
| 55 lrc->last_q[2] = oxcf->best_allowed_q; |
| 56 } |
| 57 |
| 58 lrc->buffer_level = vp9_rescale((int)(oxcf->starting_buffer_level), |
| 59 lc->target_bandwidth, 1000); |
| 60 lrc->bits_off_target = lrc->buffer_level; |
| 61 } |
| 62 } |
| 63 |
| 64 // Update the layer context from a change_config() call. |
| 65 void vp9_update_layer_context_change_config(VP9_COMP *const cpi, |
| 66 const int target_bandwidth) { |
| 67 SVC *const svc = &cpi->svc; |
| 68 const VP9_CONFIG *const oxcf = &cpi->oxcf; |
| 69 const RATE_CONTROL *const rc = &cpi->rc; |
| 70 int layer; |
| 71 int layer_end; |
| 72 float bitrate_alloc = 1.0; |
| 73 |
| 74 if (svc->number_temporal_layers > 1) { |
| 75 layer_end = svc->number_temporal_layers; |
| 76 } else { |
| 77 layer_end = svc->number_spatial_layers; |
| 78 } |
| 79 |
| 80 for (layer = 0; layer < layer_end; ++layer) { |
| 81 LAYER_CONTEXT *const lc = &svc->layer_context[layer]; |
| 82 RATE_CONTROL *const lrc = &lc->rc; |
| 83 |
| 84 if (svc->number_temporal_layers > 1) { |
| 85 lc->target_bandwidth = oxcf->ts_target_bitrate[layer] * 1000; |
| 86 } else { |
| 87 lc->target_bandwidth = oxcf->ss_target_bitrate[layer] * 1000; |
| 88 } |
| 89 bitrate_alloc = (float)lc->target_bandwidth / target_bandwidth; |
| 90 // Update buffer-related quantities. |
| 91 lc->starting_buffer_level = |
| 92 (int64_t)(oxcf->starting_buffer_level * bitrate_alloc); |
| 93 lc->optimal_buffer_level = |
| 94 (int64_t)(oxcf->optimal_buffer_level * bitrate_alloc); |
| 95 lc->maximum_buffer_size = |
| 96 (int64_t)(oxcf->maximum_buffer_size * bitrate_alloc); |
| 97 lrc->bits_off_target = MIN(lrc->bits_off_target, lc->maximum_buffer_size); |
| 98 lrc->buffer_level = MIN(lrc->buffer_level, lc->maximum_buffer_size); |
| 99 // Update framerate-related quantities. |
| 100 if (svc->number_temporal_layers > 1) { |
| 101 lc->framerate = oxcf->framerate / oxcf->ts_rate_decimator[layer]; |
| 102 } else { |
| 103 lc->framerate = oxcf->framerate; |
| 104 } |
| 105 lrc->av_per_frame_bandwidth = (int)(lc->target_bandwidth / lc->framerate); |
| 106 lrc->max_frame_bandwidth = rc->max_frame_bandwidth; |
| 107 // Update qp-related quantities. |
| 108 lrc->worst_quality = rc->worst_quality; |
| 109 lrc->best_quality = rc->best_quality; |
| 110 } |
| 111 } |
| 112 |
| 113 static LAYER_CONTEXT *get_layer_context(SVC *svc) { |
| 114 return svc->number_temporal_layers > 1 ? |
| 115 &svc->layer_context[svc->temporal_layer_id] : |
| 116 &svc->layer_context[svc->spatial_layer_id]; |
| 117 } |
| 118 |
| 119 void vp9_update_temporal_layer_framerate(VP9_COMP *const cpi) { |
| 120 SVC *const svc = &cpi->svc; |
| 121 const VP9_CONFIG *const oxcf = &cpi->oxcf; |
| 122 LAYER_CONTEXT *const lc = get_layer_context(svc); |
| 123 RATE_CONTROL *const lrc = &lc->rc; |
| 124 const int layer = svc->temporal_layer_id; |
| 125 |
| 126 lc->framerate = oxcf->framerate / oxcf->ts_rate_decimator[layer]; |
| 127 lrc->av_per_frame_bandwidth = (int)(lc->target_bandwidth / lc->framerate); |
| 128 lrc->max_frame_bandwidth = cpi->rc.max_frame_bandwidth; |
| 129 // Update the average layer frame size (non-cumulative per-frame-bw). |
| 130 if (layer == 0) { |
| 131 lc->avg_frame_size = lrc->av_per_frame_bandwidth; |
| 132 } else { |
| 133 const double prev_layer_framerate = |
| 134 oxcf->framerate / oxcf->ts_rate_decimator[layer - 1]; |
| 135 const int prev_layer_target_bandwidth = |
| 136 oxcf->ts_target_bitrate[layer - 1] * 1000; |
| 137 lc->avg_frame_size = |
| 138 (int)((lc->target_bandwidth - prev_layer_target_bandwidth) / |
| 139 (lc->framerate - prev_layer_framerate)); |
| 140 } |
| 141 } |
| 142 |
| 143 void vp9_update_spatial_layer_framerate(VP9_COMP *const cpi, double framerate) { |
| 144 const VP9_CONFIG *const oxcf = &cpi->oxcf; |
| 145 LAYER_CONTEXT *const lc = get_layer_context(&cpi->svc); |
| 146 RATE_CONTROL *const lrc = &lc->rc; |
| 147 |
| 148 lc->framerate = framerate; |
| 149 lrc->av_per_frame_bandwidth = (int)(lc->target_bandwidth / lc->framerate); |
| 150 lrc->min_frame_bandwidth = (int)(lrc->av_per_frame_bandwidth * |
| 151 oxcf->two_pass_vbrmin_section / 100); |
| 152 lrc->max_frame_bandwidth = (int)(((int64_t)lrc->av_per_frame_bandwidth * |
| 153 oxcf->two_pass_vbrmax_section) / 100); |
| 154 lrc->max_gf_interval = 16; |
| 155 |
| 156 lrc->static_scene_max_gf_interval = cpi->key_frame_frequency >> 1; |
| 157 |
| 158 if (oxcf->play_alternate && oxcf->lag_in_frames) { |
| 159 if (lrc->max_gf_interval > oxcf->lag_in_frames - 1) |
| 160 lrc->max_gf_interval = oxcf->lag_in_frames - 1; |
| 161 |
| 162 if (lrc->static_scene_max_gf_interval > oxcf->lag_in_frames - 1) |
| 163 lrc->static_scene_max_gf_interval = oxcf->lag_in_frames - 1; |
| 164 } |
| 165 |
| 166 if (lrc->max_gf_interval > lrc->static_scene_max_gf_interval) |
| 167 lrc->max_gf_interval = lrc->static_scene_max_gf_interval; |
| 168 } |
| 169 |
| 170 void vp9_restore_layer_context(VP9_COMP *const cpi) { |
| 171 LAYER_CONTEXT *const lc = get_layer_context(&cpi->svc); |
| 172 const int old_frame_since_key = cpi->rc.frames_since_key; |
| 173 const int old_frame_to_key = cpi->rc.frames_to_key; |
| 174 |
| 175 cpi->rc = lc->rc; |
| 176 cpi->twopass = lc->twopass; |
| 177 cpi->oxcf.target_bandwidth = lc->target_bandwidth; |
| 178 cpi->oxcf.starting_buffer_level = lc->starting_buffer_level; |
| 179 cpi->oxcf.optimal_buffer_level = lc->optimal_buffer_level; |
| 180 cpi->oxcf.maximum_buffer_size = lc->maximum_buffer_size; |
| 181 cpi->output_framerate = lc->framerate; |
| 182 // Reset the frames_since_key and frames_to_key counters to their values |
| 183 // before the layer restore. Keep these defined for the stream (not layer). |
| 184 if (cpi->svc.number_temporal_layers > 1) { |
| 185 cpi->rc.frames_since_key = old_frame_since_key; |
| 186 cpi->rc.frames_to_key = old_frame_to_key; |
| 187 } |
| 188 } |
| 189 |
| 190 void vp9_save_layer_context(VP9_COMP *const cpi) { |
| 191 const VP9_CONFIG *const oxcf = &cpi->oxcf; |
| 192 LAYER_CONTEXT *const lc = get_layer_context(&cpi->svc); |
| 193 |
| 194 lc->rc = cpi->rc; |
| 195 lc->twopass = cpi->twopass; |
| 196 lc->target_bandwidth = (int)oxcf->target_bandwidth; |
| 197 lc->starting_buffer_level = oxcf->starting_buffer_level; |
| 198 lc->optimal_buffer_level = oxcf->optimal_buffer_level; |
| 199 lc->maximum_buffer_size = oxcf->maximum_buffer_size; |
| 200 lc->framerate = cpi->output_framerate; |
| 201 } |
| 202 |
| 203 void vp9_init_second_pass_spatial_svc(VP9_COMP *cpi) { |
| 204 SVC *const svc = &cpi->svc; |
| 205 int i; |
| 206 |
| 207 for (i = 0; i < svc->number_spatial_layers; ++i) { |
| 208 struct twopass_rc *const twopass = &svc->layer_context[i].twopass; |
| 209 |
| 210 svc->spatial_layer_id = i; |
| 211 vp9_init_second_pass(cpi); |
| 212 |
| 213 twopass->total_stats.spatial_layer_id = i; |
| 214 twopass->total_left_stats.spatial_layer_id = i; |
| 215 } |
| 216 svc->spatial_layer_id = 0; |
| 217 } |
| 218 |
| 219 void vp9_inc_frame_in_layer(SVC *svc) { |
| 220 LAYER_CONTEXT *const lc = (svc->number_temporal_layers > 1) |
| 221 ? &svc->layer_context[svc->temporal_layer_id] |
| 222 : &svc->layer_context[svc->spatial_layer_id]; |
| 223 ++lc->current_video_frame_in_layer; |
| 224 } |
OLD | NEW |