vp9_svc_layercontext.c 12.4 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
/*
 *  Copyright (c) 2014 The WebM project authors. All Rights Reserved.
 *
 *  Use of this source code is governed by a BSD-style license
 *  that can be found in the LICENSE file in the root of the source
 *  tree. An additional intellectual property rights grant can be found
 *  in the file PATENTS.  All contributing project authors may
 *  be found in the AUTHORS file in the root of the source tree.
 */

#include <math.h>

Dmitry Kovalev's avatar
Dmitry Kovalev committed
13
#include "vp9/encoder/vp9_encoder.h"
14
#include "vp9/encoder/vp9_svc_layercontext.h"
15
#include "vp9/encoder/vp9_extend.h"
16
17

void vp9_init_layer_context(VP9_COMP *const cpi) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
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

Dmitry Kovalev's avatar
Dmitry Kovalev committed
24
25
  svc->spatial_layer_id = 0;
  svc->temporal_layer_id = 0;
26

Dmitry Kovalev's avatar
Dmitry Kovalev committed
27
28
  if (svc->number_temporal_layers > 1) {
    layer_end = svc->number_temporal_layers;
29
  } else {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
30
    layer_end = svc->number_spatial_layers;
31
32
33
  }

  for (layer = 0; layer < layer_end; ++layer) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
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
41
42
43
44
45
46
47
    lrc->total_actual_bits = 0;
    lrc->total_target_vs_actual = 0;
    lrc->ni_tot_qi = 0;
    lrc->tot_q = 0.0;
    lrc->avg_q = 0.0;
    lrc->ni_frames = 0;
    lrc->decimation_count = 0;
    lrc->decimation_factor = 0;
48
49
50
51

    for (i = 0; i < RATE_FACTOR_LEVELS; ++i) {
      lrc->rate_correction_factors[i] = 1.0;
    }
52

Dmitry Kovalev's avatar
Dmitry Kovalev committed
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
60
      lrc->last_q[KEY_FRAME] = oxcf->best_allowed_q;
      lrc->last_q[INTER_FRAME] = oxcf->best_allowed_q;
61
62
63
64
65
66
67
68
      lrc->avg_frame_qindex[KEY_FRAME] = (oxcf->worst_allowed_q +
                                          oxcf->best_allowed_q) / 2;
      lrc->avg_frame_qindex[INTER_FRAME] = (oxcf->worst_allowed_q +
                                            oxcf->best_allowed_q) / 2;
      if (oxcf->ss_play_alternate[layer])
        lc->alt_ref_idx = alt_ref_idx++;
      else
        lc->alt_ref_idx = -1;
69
      lc->gold_ref_idx = -1;
70
71
    }

Dmitry Kovalev's avatar
Dmitry Kovalev committed
72
73
    lrc->buffer_level = oxcf->starting_buffer_level_ms *
                            lc->target_bandwidth / 1000;
74
75
    lrc->bits_off_target = lrc->buffer_level;
  }
76
77
78
79

  // Still have extra buffer for base layer golden frame
  if (svc->number_spatial_layers > 1 && alt_ref_idx < REF_FRAMES)
    svc->layer_context[0].gold_ref_idx = alt_ref_idx;
80
81
82
83
84
}

// Update the layer context from a change_config() call.
void vp9_update_layer_context_change_config(VP9_COMP *const cpi,
                                            const int target_bandwidth) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
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

Dmitry Kovalev's avatar
Dmitry Kovalev committed
92
93
  if (svc->number_temporal_layers > 1) {
    layer_end = svc->number_temporal_layers;
94
  } else {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
95
    layer_end = svc->number_spatial_layers;
96
97
98
  }

  for (layer = 0; layer < layer_end; ++layer) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
99
    LAYER_CONTEXT *const lc = &svc->layer_context[layer];
100
    RATE_CONTROL *const lrc = &lc->rc;
101

Dmitry Kovalev's avatar
Dmitry Kovalev committed
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
110
111
112
113
114
    lrc->starting_buffer_level =
        (int64_t)(rc->starting_buffer_level * bitrate_alloc);
    lrc->optimal_buffer_level =
        (int64_t)(rc->optimal_buffer_level * bitrate_alloc);
    lrc->maximum_buffer_size =
        (int64_t)(rc->maximum_buffer_size * bitrate_alloc);
115
116
    lrc->bits_off_target = MIN(lrc->bits_off_target, lrc->maximum_buffer_size);
    lrc->buffer_level = MIN(lrc->buffer_level, lrc->maximum_buffer_size);
117
    // Update framerate-related quantities.
Dmitry Kovalev's avatar
Dmitry Kovalev committed
118
    if (svc->number_temporal_layers > 1) {
119
      lc->framerate = cpi->framerate / oxcf->ts_rate_decimator[layer];
120
    } else {
121
      lc->framerate = cpi->framerate;
122
    }
123
    lrc->avg_frame_bandwidth = (int)(lc->target_bandwidth / lc->framerate);
124
125
126
127
128
129
130
    lrc->max_frame_bandwidth = rc->max_frame_bandwidth;
    // Update qp-related quantities.
    lrc->worst_quality = rc->worst_quality;
    lrc->best_quality = rc->best_quality;
  }
}

131
132
133
134
static LAYER_CONTEXT *get_layer_context(SVC *svc) {
  return svc->number_temporal_layers > 1 ?
         &svc->layer_context[svc->temporal_layer_id] :
         &svc->layer_context[svc->spatial_layer_id];
135
136
}

137
void vp9_update_temporal_layer_framerate(VP9_COMP *const cpi) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
138
  SVC *const svc = &cpi->svc;
139
  const VP9EncoderConfig *const oxcf = &cpi->oxcf;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
140
  LAYER_CONTEXT *const lc = get_layer_context(svc);
141
  RATE_CONTROL *const lrc = &lc->rc;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
142
  const int layer = svc->temporal_layer_id;
143

144
  lc->framerate = cpi->framerate / oxcf->ts_rate_decimator[layer];
145
  lrc->avg_frame_bandwidth = (int)(lc->target_bandwidth / lc->framerate);
146
147
  lrc->max_frame_bandwidth = cpi->rc.max_frame_bandwidth;
  // 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
        cpi->framerate / oxcf->ts_rate_decimator[layer - 1];
153
    const int prev_layer_target_bandwidth = oxcf->ts_target_bitrate[layer - 1];
154
155
156
157
158
159
    lc->avg_frame_size =
        (int)((lc->target_bandwidth - prev_layer_target_bandwidth) /
              (lc->framerate - prev_layer_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
164
165
  RATE_CONTROL *const lrc = &lc->rc;

  lc->framerate = framerate;
166
167
  lrc->avg_frame_bandwidth = (int)(lc->target_bandwidth / lc->framerate);
  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
}

174
void vp9_restore_layer_context(VP9_COMP *const cpi) {
175
  LAYER_CONTEXT *const lc = get_layer_context(&cpi->svc);
176
177
178
  const int old_frame_since_key = cpi->rc.frames_since_key;
  const int old_frame_to_key = cpi->rc.frames_to_key;

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
184
  // Reset the frames_since_key and frames_to_key counters to their values
  // before the layer restore. Keep these defined for the stream (not layer).
185
186
187
188
  if (cpi->svc.number_temporal_layers > 1) {
    cpi->rc.frames_since_key = old_frame_since_key;
    cpi->rc.frames_to_key = old_frame_to_key;
  }
189
190
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
201

void vp9_init_second_pass_spatial_svc(VP9_COMP *cpi) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
202
  SVC *const svc = &cpi->svc;
203
204
  int i;

Dmitry Kovalev's avatar
Dmitry Kovalev committed
205
  for (i = 0; i < svc->number_spatial_layers; ++i) {
Paul Wilkins's avatar
Paul Wilkins committed
206
    TWO_PASS *const twopass = &svc->layer_context[i].twopass;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
207
208

    svc->spatial_layer_id = i;
209
210
211
212
213
    vp9_init_second_pass(cpi);

    twopass->total_stats.spatial_layer_id = i;
    twopass->total_left_stats.spatial_layer_id = i;
  }
Dmitry Kovalev's avatar
Dmitry Kovalev committed
214
  svc->spatial_layer_id = 0;
215
}
216
217
218
219
220
221
222

void vp9_inc_frame_in_layer(SVC *svc) {
  LAYER_CONTEXT *const lc = (svc->number_temporal_layers > 1)
      ? &svc->layer_context[svc->temporal_layer_id]
      : &svc->layer_context[svc->spatial_layer_id];
  ++lc->current_video_frame_in_layer;
}
223

224
int vp9_is_upper_layer_key_frame(const VP9_COMP *const cpi) {
225
  return is_spatial_svc(cpi) &&
226
227
         cpi->svc.spatial_layer_id > 0 &&
         cpi->svc.layer_context[cpi->svc.spatial_layer_id].is_key_frame;
228
}
229

230
#if CONFIG_SPATIAL_SVC
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
int 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) {
  struct lookahead_entry *buf;
  int i, index;

  if (vp9_lookahead_push(ctx, src, ts_start, ts_end, flags))
    return 1;

  index = ctx->write_idx - 1;
  if (index < 0)
    index += ctx->max_sz;

  buf = ctx->buf + index;

  if (buf == NULL)
    return 1;

  // Store svc parameters for each layer
  for (i = 0; i < cpi->svc.number_spatial_layers; ++i)
    buf->svc_params[i] = cpi->svc.layer_context[i].svc_params_received;

  return 0;
}

static int copy_svc_params(VP9_COMP *const cpi, struct lookahead_entry *buf) {
  int layer_id;
  vpx_svc_parameters_t *layer_param;
259
  LAYER_CONTEXT *lc;
260
261
262
263
264
265
266
267
268
269
270
271
272

  // Find the next layer to be encoded
  for (layer_id = 0; layer_id < cpi->svc.number_spatial_layers; ++layer_id) {
    if (buf->svc_params[layer_id].spatial_layer >=0)
      break;
  }

  if (layer_id == cpi->svc.number_spatial_layers)
    return 1;

  layer_param = &buf->svc_params[layer_id];
  cpi->svc.spatial_layer_id = layer_param->spatial_layer;
  cpi->svc.temporal_layer_id = layer_param->temporal_layer;
273
274
275
  cpi->ref_frame_flags = VP9_ALT_FLAG | VP9_GOLD_FLAG | VP9_LAST_FLAG;

  lc = &cpi->svc.layer_context[cpi->svc.spatial_layer_id];
276
277
278
279

  cpi->lst_fb_idx = cpi->svc.spatial_layer_id;

  if (cpi->svc.spatial_layer_id < 1)
280
281
      cpi->gld_fb_idx = lc->gold_ref_idx >= 0 ?
                        lc->gold_ref_idx : cpi->lst_fb_idx;
282
283
284
285
  else
    cpi->gld_fb_idx = cpi->svc.spatial_layer_id - 1;

  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
291
      cpi->ref_frame_flags &= (~VP9_LAST_FLAG & ~VP9_ALT_FLAG);
    }
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
  } else {
    if (cpi->oxcf.ss_play_alternate[cpi->svc.spatial_layer_id]) {
      cpi->alt_fb_idx = lc->alt_ref_idx;
      if (!lc->has_alt_frame)
        cpi->ref_frame_flags &= (~VP9_ALT_FLAG);
    } else {
      // Find a proper alt_fb_idx for layers that don't have alt ref frame
      if (cpi->svc.spatial_layer_id == 0) {
        cpi->alt_fb_idx = cpi->lst_fb_idx;
      } else {
        LAYER_CONTEXT *lc_lower =
            &cpi->svc.layer_context[cpi->svc.spatial_layer_id - 1];

        if (cpi->oxcf.ss_play_alternate[cpi->svc.spatial_layer_id - 1] &&
            lc_lower->alt_ref_source != NULL)
          cpi->alt_fb_idx = lc_lower->alt_ref_idx;
        else if (cpi->svc.spatial_layer_id >= 2)
          cpi->alt_fb_idx = cpi->svc.spatial_layer_id - 2;
        else
          cpi->alt_fb_idx = cpi->lst_fb_idx;
      }
    }
  }
315
316
317
318
319
320
321
322
323
324
325
326
327

  if (vp9_set_size_literal(cpi, layer_param->width, layer_param->height) != 0)
    return VPX_CODEC_INVALID_PARAM;

  cpi->oxcf.worst_allowed_q =
      vp9_quantizer_to_qindex(layer_param->max_quantizer);
  cpi->oxcf.best_allowed_q =
      vp9_quantizer_to_qindex(layer_param->min_quantizer);

  vp9_change_config(cpi, &cpi->oxcf);

  vp9_set_high_precision_mv(cpi, 1);

328
  cpi->alt_ref_source = get_layer_context(&cpi->svc)->alt_ref_source;
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363

  return 0;
}

struct lookahead_entry *vp9_svc_lookahead_peek(VP9_COMP *const cpi,
                                               struct lookahead_ctx *ctx,
                                               int index, int copy_params) {
  struct lookahead_entry *buf = vp9_lookahead_peek(ctx, index);

  if (buf != NULL && copy_params != 0) {
    if (copy_svc_params(cpi, buf) != 0)
      return NULL;
  }
  return buf;
}

struct lookahead_entry *vp9_svc_lookahead_pop(VP9_COMP *const cpi,
                                              struct lookahead_ctx *ctx,
                                              int drain) {
  struct lookahead_entry *buf = NULL;

  if (ctx->sz && (drain || ctx->sz == ctx->max_sz - MAX_PRE_FRAMES)) {
    buf = vp9_svc_lookahead_peek(cpi, ctx, 0, 1);
    if (buf != NULL) {
      // Only remove the buffer when pop the highest layer. Simply set the
      // spatial_layer to -1 for lower layers.
      buf->svc_params[cpi->svc.spatial_layer_id].spatial_layer = -1;
      if (cpi->svc.spatial_layer_id == cpi->svc.number_spatial_layers - 1) {
        vp9_lookahead_pop(ctx, drain);
      }
    }
  }

  return buf;
}
364
#endif