granicus.if.org Git - libvpx/blob - examples/vpx_temporal_svc_encoder.c

   1 /*
   2  *  Copyright (c) 2012 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 //  This is an example demonstrating how to implement a multi-layer VPx
  12 //  encoding scheme based on temporal scalability for video applications
  13 //  that benefit from a scalable bitstream.
  14
  15 #include <assert.h>
  16 #include <math.h>
  17 #include <stdio.h>
  18 #include <stdlib.h>
  19 #include <string.h>
  20
  21 #include "./vpx_config.h"
  22 #include "../vpx_ports/vpx_timer.h"
  23 #include "vpx/vp8cx.h"
  24 #include "vpx/vpx_encoder.h"
  25
  26 #include "../tools_common.h"
  27 #include "../video_writer.h"
  28
  29 static const char *exec_name;
  30
  31 void usage_exit(void) { exit(EXIT_FAILURE); }
  32
  33 // Denoiser states, for temporal denoising.
  34 enum denoiserState {
  35   kDenoiserOff,
  36   kDenoiserOnYOnly,
  37   kDenoiserOnYUV,
  38   kDenoiserOnYUVAggressive,
  39   kDenoiserOnAdaptive
  40 };
  41
  42 static int mode_to_num_layers[13] = { 1, 2, 2, 3, 3, 3, 3, 5, 2, 3, 3, 3, 3 };
  43
  44 // For rate control encoding stats.
  45 struct RateControlMetrics {
  46   // Number of input frames per layer.
  47   int layer_input_frames[VPX_TS_MAX_LAYERS];
  48   // Total (cumulative) number of encoded frames per layer.
  49   int layer_tot_enc_frames[VPX_TS_MAX_LAYERS];
  50   // Number of encoded non-key frames per layer.
  51   int layer_enc_frames[VPX_TS_MAX_LAYERS];
  52   // Framerate per layer layer (cumulative).
  53   double layer_framerate[VPX_TS_MAX_LAYERS];
  54   // Target average frame size per layer (per-frame-bandwidth per layer).
  55   double layer_pfb[VPX_TS_MAX_LAYERS];
  56   // Actual average frame size per layer.
  57   double layer_avg_frame_size[VPX_TS_MAX_LAYERS];
  58   // Average rate mismatch per layer (|target - actual| / target).
  59   double layer_avg_rate_mismatch[VPX_TS_MAX_LAYERS];
  60   // Actual encoding bitrate per layer (cumulative).
  61   double layer_encoding_bitrate[VPX_TS_MAX_LAYERS];
  62   // Average of the short-time encoder actual bitrate.
  63   // TODO(marpan): Should we add these short-time stats for each layer?
  64   double avg_st_encoding_bitrate;
  65   // Variance of the short-time encoder actual bitrate.
  66   double variance_st_encoding_bitrate;
  67   // Window (number of frames) for computing short-timee encoding bitrate.
  68   int window_size;
  69   // Number of window measurements.
  70   int window_count;
  71   int layer_target_bitrate[VPX_MAX_LAYERS];
  72 };
  73
  74 // Note: these rate control metrics assume only 1 key frame in the
  75 // sequence (i.e., first frame only). So for temporal pattern# 7
  76 // (which has key frame for every frame on base layer), the metrics
  77 // computation will be off/wrong.
  78 // TODO(marpan): Update these metrics to account for multiple key frames
  79 // in the stream.
  80 static void set_rate_control_metrics(struct RateControlMetrics *rc,
  81                                      vpx_codec_enc_cfg_t *cfg) {
  82   unsigned int i = 0;
  83   // Set the layer (cumulative) framerate and the target layer (non-cumulative)
  84   // per-frame-bandwidth, for the rate control encoding stats below.
  85   const double framerate = cfg->g_timebase.den / cfg->g_timebase.num;
  86   rc->layer_framerate[0] = framerate / cfg->ts_rate_decimator[0];
  87   rc->layer_pfb[0] =
  88       1000.0 * rc->layer_target_bitrate[0] / rc->layer_framerate[0];
  89   for (i = 0; i < cfg->ts_number_layers; ++i) {
  90     if (i > 0) {
  91       rc->layer_framerate[i] = framerate / cfg->ts_rate_decimator[i];
  92       rc->layer_pfb[i] = 1000.0 * (rc->layer_target_bitrate[i] -
  93                                    rc->layer_target_bitrate[i - 1]) /
  94                          (rc->layer_framerate[i] - rc->layer_framerate[i - 1]);
  95     }
  96     rc->layer_input_frames[i] = 0;
  97     rc->layer_enc_frames[i] = 0;
  98     rc->layer_tot_enc_frames[i] = 0;
  99     rc->layer_encoding_bitrate[i] = 0.0;
 100     rc->layer_avg_frame_size[i] = 0.0;
 101     rc->layer_avg_rate_mismatch[i] = 0.0;
 102   }
 103   rc->window_count = 0;
 104   rc->window_size = 15;
 105   rc->avg_st_encoding_bitrate = 0.0;
 106   rc->variance_st_encoding_bitrate = 0.0;
 107 }
 108
 109 static void printout_rate_control_summary(struct RateControlMetrics *rc,
 110                                           vpx_codec_enc_cfg_t *cfg,
 111                                           int frame_cnt) {
 112   unsigned int i = 0;
 113   int tot_num_frames = 0;
 114   double perc_fluctuation = 0.0;
 115   printf("Total number of processed frames: %d\n\n", frame_cnt - 1);
 116   printf("Rate control layer stats for %d layer(s):\n\n",
 117          cfg->ts_number_layers);
 118   for (i = 0; i < cfg->ts_number_layers; ++i) {
 119     const int num_dropped =
 120         (i > 0) ? (rc->layer_input_frames[i] - rc->layer_enc_frames[i])
 121                 : (rc->layer_input_frames[i] - rc->layer_enc_frames[i] - 1);
 122     tot_num_frames += rc->layer_input_frames[i];
 123     rc->layer_encoding_bitrate[i] = 0.001 * rc->layer_framerate[i] *
 124                                     rc->layer_encoding_bitrate[i] /
 125                                     tot_num_frames;
 126     rc->layer_avg_frame_size[i] =
 127         rc->layer_avg_frame_size[i] / rc->layer_enc_frames[i];
 128     rc->layer_avg_rate_mismatch[i] =
 129         100.0 * rc->layer_avg_rate_mismatch[i] / rc->layer_enc_frames[i];
 130     printf("For layer#: %d \n", i);
 131     printf("Bitrate (target vs actual): %d %f \n", rc->layer_target_bitrate[i],
 132            rc->layer_encoding_bitrate[i]);
 133     printf("Average frame size (target vs actual): %f %f \n", rc->layer_pfb[i],
 134            rc->layer_avg_frame_size[i]);
 135     printf("Average rate_mismatch: %f \n", rc->layer_avg_rate_mismatch[i]);
 136     printf(
 137         "Number of input frames, encoded (non-key) frames, "
 138         "and perc dropped frames: %d %d %f \n",
 139         rc->layer_input_frames[i], rc->layer_enc_frames[i],
 140         100.0 * num_dropped / rc->layer_input_frames[i]);
 141     printf("\n");
 142   }
 143   rc->avg_st_encoding_bitrate = rc->avg_st_encoding_bitrate / rc->window_count;
 144   rc->variance_st_encoding_bitrate =
 145       rc->variance_st_encoding_bitrate / rc->window_count -
 146       (rc->avg_st_encoding_bitrate * rc->avg_st_encoding_bitrate);
 147   perc_fluctuation = 100.0 * sqrt(rc->variance_st_encoding_bitrate) /
 148                      rc->avg_st_encoding_bitrate;
 149   printf("Short-time stats, for window of %d frames: \n", rc->window_size);
 150   printf("Average, rms-variance, and percent-fluct: %f %f %f \n",
 151          rc->avg_st_encoding_bitrate, sqrt(rc->variance_st_encoding_bitrate),
 152          perc_fluctuation);
 153   if ((frame_cnt - 1) != tot_num_frames)
 154     die("Error: Number of input frames not equal to output! \n");
 155 }
 156
 157 // Temporal scaling parameters:
 158 // NOTE: The 3 prediction frames cannot be used interchangeably due to
 159 // differences in the way they are handled throughout the code. The
 160 // frames should be allocated to layers in the order LAST, GF, ARF.
 161 // Other combinations work, but may produce slightly inferior results.
 162 static void set_temporal_layer_pattern(int layering_mode,
 163                                        vpx_codec_enc_cfg_t *cfg,
 164                                        int *layer_flags,
 165                                        int *flag_periodicity) {
 166   switch (layering_mode) {
 167     case 0: {
 168       // 1-layer.
 169       int ids[1] = { 0 };
 170       cfg->ts_periodicity = 1;
 171       *flag_periodicity = 1;
 172       cfg->ts_number_layers = 1;
 173       cfg->ts_rate_decimator[0] = 1;
 174       memcpy(cfg->ts_layer_id, ids, sizeof(ids));
 175       // Update L only.
 176       layer_flags[0] =
 177           VPX_EFLAG_FORCE_KF | VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF;
 178       break;
 179     }
 180     case 1: {
 181       // 2-layers, 2-frame period.
 182       int ids[2] = { 0, 1 };
 183       cfg->ts_periodicity = 2;
 184       *flag_periodicity = 2;
 185       cfg->ts_number_layers = 2;
 186       cfg->ts_rate_decimator[0] = 2;
 187       cfg->ts_rate_decimator[1] = 1;
 188       memcpy(cfg->ts_layer_id, ids, sizeof(ids));
 189 #if 1
 190       // 0=L, 1=GF, Intra-layer prediction enabled.
 191       layer_flags[0] = VPX_EFLAG_FORCE_KF | VP8_EFLAG_NO_UPD_GF |
 192                        VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_REF_GF |
 193                        VP8_EFLAG_NO_REF_ARF;
 194       layer_flags[1] =
 195           VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_REF_ARF;
 196 #else
 197       // 0=L, 1=GF, Intra-layer prediction disabled.
 198       layer_flags[0] = VPX_EFLAG_FORCE_KF | VP8_EFLAG_NO_UPD_GF |
 199                        VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_REF_GF |
 200                        VP8_EFLAG_NO_REF_ARF;
 201       layer_flags[1] = VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST |
 202                        VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_REF_LAST;
 203 #endif
 204       break;
 205     }
 206     case 2: {
 207       // 2-layers, 3-frame period.
 208       int ids[3] = { 0, 1, 1 };
 209       cfg->ts_periodicity = 3;
 210       *flag_periodicity = 3;
 211       cfg->ts_number_layers = 2;
 212       cfg->ts_rate_decimator[0] = 3;
 213       cfg->ts_rate_decimator[1] = 1;
 214       memcpy(cfg->ts_layer_id, ids, sizeof(ids));
 215       // 0=L, 1=GF, Intra-layer prediction enabled.
 216       layer_flags[0] = VPX_EFLAG_FORCE_KF | VP8_EFLAG_NO_REF_GF |
 217                        VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_UPD_GF |
 218                        VP8_EFLAG_NO_UPD_ARF;
 219       layer_flags[1] = layer_flags[2] =
 220           VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_UPD_ARF |
 221           VP8_EFLAG_NO_UPD_LAST;
 222       break;
 223     }
 224     case 3: {
 225       // 3-layers, 6-frame period.
 226       int ids[6] = { 0, 2, 2, 1, 2, 2 };
 227       cfg->ts_periodicity = 6;
 228       *flag_periodicity = 6;
 229       cfg->ts_number_layers = 3;
 230       cfg->ts_rate_decimator[0] = 6;
 231       cfg->ts_rate_decimator[1] = 3;
 232       cfg->ts_rate_decimator[2] = 1;
 233       memcpy(cfg->ts_layer_id, ids, sizeof(ids));
 234       // 0=L, 1=GF, 2=ARF, Intra-layer prediction enabled.
 235       layer_flags[0] = VPX_EFLAG_FORCE_KF | VP8_EFLAG_NO_REF_GF |
 236                        VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_UPD_GF |
 237                        VP8_EFLAG_NO_UPD_ARF;
 238       layer_flags[3] =
 239           VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST;
 240       layer_flags[1] = layer_flags[2] = layer_flags[4] = layer_flags[5] =
 241           VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_LAST;
 242       break;
 243     }
 244     case 4: {
 245       // 3-layers, 4-frame period.
 246       int ids[4] = { 0, 2, 1, 2 };
 247       cfg->ts_periodicity = 4;
 248       *flag_periodicity = 4;
 249       cfg->ts_number_layers = 3;
 250       cfg->ts_rate_decimator[0] = 4;
 251       cfg->ts_rate_decimator[1] = 2;
 252       cfg->ts_rate_decimator[2] = 1;
 253       memcpy(cfg->ts_layer_id, ids, sizeof(ids));
 254       // 0=L, 1=GF, 2=ARF, Intra-layer prediction disabled.
 255       layer_flags[0] = VPX_EFLAG_FORCE_KF | VP8_EFLAG_NO_REF_GF |
 256                        VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_UPD_GF |
 257                        VP8_EFLAG_NO_UPD_ARF;
 258       layer_flags[2] = VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF |
 259                        VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST;
 260       layer_flags[1] = layer_flags[3] =
 261           VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF |
 262           VP8_EFLAG_NO_UPD_ARF;
 263       break;
 264     }
 265     case 5: {
 266       // 3-layers, 4-frame period.
 267       int ids[4] = { 0, 2, 1, 2 };
 268       cfg->ts_periodicity = 4;
 269       *flag_periodicity = 4;
 270       cfg->ts_number_layers = 3;
 271       cfg->ts_rate_decimator[0] = 4;
 272       cfg->ts_rate_decimator[1] = 2;
 273       cfg->ts_rate_decimator[2] = 1;
 274       memcpy(cfg->ts_layer_id, ids, sizeof(ids));
 275       // 0=L, 1=GF, 2=ARF, Intra-layer prediction enabled in layer 1, disabled
 276       // in layer 2.
 277       layer_flags[0] = VPX_EFLAG_FORCE_KF | VP8_EFLAG_NO_REF_GF |
 278                        VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_UPD_GF |
 279                        VP8_EFLAG_NO_UPD_ARF;
 280       layer_flags[2] =
 281           VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_ARF;
 282       layer_flags[1] = layer_flags[3] =
 283           VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF |
 284           VP8_EFLAG_NO_UPD_ARF;
 285       break;
 286     }
 287     case 6: {
 288       // 3-layers, 4-frame period.
 289       int ids[4] = { 0, 2, 1, 2 };
 290       cfg->ts_periodicity = 4;
 291       *flag_periodicity = 4;
 292       cfg->ts_number_layers = 3;
 293       cfg->ts_rate_decimator[0] = 4;
 294       cfg->ts_rate_decimator[1] = 2;
 295       cfg->ts_rate_decimator[2] = 1;
 296       memcpy(cfg->ts_layer_id, ids, sizeof(ids));
 297       // 0=L, 1=GF, 2=ARF, Intra-layer prediction enabled.
 298       layer_flags[0] = VPX_EFLAG_FORCE_KF | VP8_EFLAG_NO_REF_GF |
 299                        VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_UPD_GF |
 300                        VP8_EFLAG_NO_UPD_ARF;
 301       layer_flags[2] =
 302           VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_ARF;
 303       layer_flags[1] = layer_flags[3] =
 304           VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF;
 305       break;
 306     }
 307     case 7: {
 308       // NOTE: Probably of academic interest only.
 309       // 5-layers, 16-frame period.
 310       int ids[16] = { 0, 4, 3, 4, 2, 4, 3, 4, 1, 4, 3, 4, 2, 4, 3, 4 };
 311       cfg->ts_periodicity = 16;
 312       *flag_periodicity = 16;
 313       cfg->ts_number_layers = 5;
 314       cfg->ts_rate_decimator[0] = 16;
 315       cfg->ts_rate_decimator[1] = 8;
 316       cfg->ts_rate_decimator[2] = 4;
 317       cfg->ts_rate_decimator[3] = 2;
 318       cfg->ts_rate_decimator[4] = 1;
 319       memcpy(cfg->ts_layer_id, ids, sizeof(ids));
 320       layer_flags[0] = VPX_EFLAG_FORCE_KF;
 321       layer_flags[1] = layer_flags[3] = layer_flags[5] = layer_flags[7] =
 322           layer_flags[9] = layer_flags[11] = layer_flags[13] = layer_flags[15] =
 323               VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF |
 324               VP8_EFLAG_NO_UPD_ARF;
 325       layer_flags[2] = layer_flags[6] = layer_flags[10] = layer_flags[14] =
 326           VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_GF;
 327       layer_flags[4] = layer_flags[12] =
 328           VP8_EFLAG_NO_REF_LAST | VP8_EFLAG_NO_UPD_ARF;
 329       layer_flags[8] = VP8_EFLAG_NO_REF_LAST | VP8_EFLAG_NO_REF_GF;
 330       break;
 331     }
 332     case 8: {
 333       // 2-layers, with sync point at first frame of layer 1.
 334       int ids[2] = { 0, 1 };
 335       cfg->ts_periodicity = 2;
 336       *flag_periodicity = 8;
 337       cfg->ts_number_layers = 2;
 338       cfg->ts_rate_decimator[0] = 2;
 339       cfg->ts_rate_decimator[1] = 1;
 340       memcpy(cfg->ts_layer_id, ids, sizeof(ids));
 341       // 0=L, 1=GF.
 342       // ARF is used as predictor for all frames, and is only updated on
 343       // key frame. Sync point every 8 frames.
 344
 345       // Layer 0: predict from L and ARF, update L and G.
 346       layer_flags[0] =
 347           VPX_EFLAG_FORCE_KF | VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_UPD_ARF;
 348       // Layer 1: sync point: predict from L and ARF, and update G.
 349       layer_flags[1] =
 350           VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_ARF;
 351       // Layer 0, predict from L and ARF, update L.
 352       layer_flags[2] =
 353           VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF;
 354       // Layer 1: predict from L, G and ARF, and update G.
 355       layer_flags[3] = VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST |
 356                        VP8_EFLAG_NO_UPD_ENTROPY;
 357       // Layer 0.
 358       layer_flags[4] = layer_flags[2];
 359       // Layer 1.
 360       layer_flags[5] = layer_flags[3];
 361       // Layer 0.
 362       layer_flags[6] = layer_flags[4];
 363       // Layer 1.
 364       layer_flags[7] = layer_flags[5];
 365       break;
 366     }
 367     case 9: {
 368       // 3-layers: Sync points for layer 1 and 2 every 8 frames.
 369       int ids[4] = { 0, 2, 1, 2 };
 370       cfg->ts_periodicity = 4;
 371       *flag_periodicity = 8;
 372       cfg->ts_number_layers = 3;
 373       cfg->ts_rate_decimator[0] = 4;
 374       cfg->ts_rate_decimator[1] = 2;
 375       cfg->ts_rate_decimator[2] = 1;
 376       memcpy(cfg->ts_layer_id, ids, sizeof(ids));
 377       // 0=L, 1=GF, 2=ARF.
 378       layer_flags[0] = VPX_EFLAG_FORCE_KF | VP8_EFLAG_NO_REF_GF |
 379                        VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_UPD_GF |
 380                        VP8_EFLAG_NO_UPD_ARF;
 381       layer_flags[1] = VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF |
 382                        VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF;
 383       layer_flags[2] = VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF |
 384                        VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_ARF;
 385       layer_flags[3] = layer_flags[5] =
 386           VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF;
 387       layer_flags[4] = VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF |
 388                        VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF;
 389       layer_flags[6] =
 390           VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_ARF;
 391       layer_flags[7] = VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF |
 392                        VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_ENTROPY;
 393       break;
 394     }
 395     case 10: {
 396       // 3-layers structure where ARF is used as predictor for all frames,
 397       // and is only updated on key frame.
 398       // Sync points for layer 1 and 2 every 8 frames.
 399
 400       int ids[4] = { 0, 2, 1, 2 };
 401       cfg->ts_periodicity = 4;
 402       *flag_periodicity = 8;
 403       cfg->ts_number_layers = 3;
 404       cfg->ts_rate_decimator[0] = 4;
 405       cfg->ts_rate_decimator[1] = 2;
 406       cfg->ts_rate_decimator[2] = 1;
 407       memcpy(cfg->ts_layer_id, ids, sizeof(ids));
 408       // 0=L, 1=GF, 2=ARF.
 409       // Layer 0: predict from L and ARF; update L and G.
 410       layer_flags[0] =
 411           VPX_EFLAG_FORCE_KF | VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_REF_GF;
 412       // Layer 2: sync point: predict from L and ARF; update none.
 413       layer_flags[1] = VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_UPD_GF |
 414                        VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST |
 415                        VP8_EFLAG_NO_UPD_ENTROPY;
 416       // Layer 1: sync point: predict from L and ARF; update G.
 417       layer_flags[2] =
 418           VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST;
 419       // Layer 2: predict from L, G, ARF; update none.
 420       layer_flags[3] = VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF |
 421                        VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_ENTROPY;
 422       // Layer 0: predict from L and ARF; update L.
 423       layer_flags[4] =
 424           VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_REF_GF;
 425       // Layer 2: predict from L, G, ARF; update none.
 426       layer_flags[5] = layer_flags[3];
 427       // Layer 1: predict from L, G, ARF; update G.
 428       layer_flags[6] = VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST;
 429       // Layer 2: predict from L, G, ARF; update none.
 430       layer_flags[7] = layer_flags[3];
 431       break;
 432     }
 433     case 11: {
 434       // 3-layers structure with one reference frame.
 435       // This works same as temporal_layering_mode 3.
 436       // This was added to compare with vp9_spatial_svc_encoder.
 437
 438       // 3-layers, 4-frame period.
 439       int ids[4] = { 0, 2, 1, 2 };
 440       cfg->ts_periodicity = 4;
 441       *flag_periodicity = 4;
 442       cfg->ts_number_layers = 3;
 443       cfg->ts_rate_decimator[0] = 4;
 444       cfg->ts_rate_decimator[1] = 2;
 445       cfg->ts_rate_decimator[2] = 1;
 446       memcpy(cfg->ts_layer_id, ids, sizeof(ids));
 447       // 0=L, 1=GF, 2=ARF, Intra-layer prediction disabled.
 448       layer_flags[0] = VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF |
 449                        VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF;
 450       layer_flags[2] = VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF |
 451                        VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST;
 452       layer_flags[1] = VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF |
 453                        VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF;
 454       layer_flags[3] = VP8_EFLAG_NO_REF_LAST | VP8_EFLAG_NO_REF_ARF |
 455                        VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF;
 456       break;
 457     }
 458     case 12:
 459     default: {
 460       // 3-layers structure as in case 10, but no sync/refresh points for
 461       // layer 1 and 2.
 462       int ids[4] = { 0, 2, 1, 2 };
 463       cfg->ts_periodicity = 4;
 464       *flag_periodicity = 8;
 465       cfg->ts_number_layers = 3;
 466       cfg->ts_rate_decimator[0] = 4;
 467       cfg->ts_rate_decimator[1] = 2;
 468       cfg->ts_rate_decimator[2] = 1;
 469       memcpy(cfg->ts_layer_id, ids, sizeof(ids));
 470       // 0=L, 1=GF, 2=ARF.
 471       // Layer 0: predict from L and ARF; update L.
 472       layer_flags[0] =
 473           VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_REF_GF;
 474       layer_flags[4] = layer_flags[0];
 475       // Layer 1: predict from L, G, ARF; update G.
 476       layer_flags[2] = VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST;
 477       layer_flags[6] = layer_flags[2];
 478       // Layer 2: predict from L, G, ARF; update none.
 479       layer_flags[1] = VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF |
 480                        VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_ENTROPY;
 481       layer_flags[3] = layer_flags[1];
 482       layer_flags[5] = layer_flags[1];
 483       layer_flags[7] = layer_flags[1];
 484       break;
 485     }
 486   }
 487 }
 488
 489 int main(int argc, char **argv) {
 490   VpxVideoWriter *outfile[VPX_TS_MAX_LAYERS] = { NULL };
 491   vpx_codec_ctx_t codec;
 492   vpx_codec_enc_cfg_t cfg;
 493   int frame_cnt = 0;
 494   vpx_image_t raw;
 495   vpx_codec_err_t res;
 496   unsigned int width;
 497   unsigned int height;
 498   int speed;
 499   int frame_avail;
 500   int got_data;
 501   int flags = 0;
 502   unsigned int i;
 503   int pts = 0;             // PTS starts at 0.
 504   int frame_duration = 1;  // 1 timebase tick per frame.
 505   int layering_mode = 0;
 506   int layer_flags[VPX_TS_MAX_PERIODICITY] = { 0 };
 507   int flag_periodicity = 1;
 508 #if VPX_ENCODER_ABI_VERSION > (4 + VPX_CODEC_ABI_VERSION)
 509   vpx_svc_layer_id_t layer_id = { 0, 0 };
 510 #else
 511   vpx_svc_layer_id_t layer_id = { 0 };
 512 #endif
 513   const VpxInterface *encoder = NULL;
 514   FILE *infile = NULL;
 515   struct RateControlMetrics rc;
 516   int64_t cx_time = 0;
 517   const int min_args_base = 11;
 518 #if CONFIG_VP9_HIGHBITDEPTH
 519   vpx_bit_depth_t bit_depth = VPX_BITS_8;
 520   int input_bit_depth = 8;
 521   const int min_args = min_args_base + 1;
 522 #else
 523   const int min_args = min_args_base;
 524 #endif  // CONFIG_VP9_HIGHBITDEPTH
 525   double sum_bitrate = 0.0;
 526   double sum_bitrate2 = 0.0;
 527   double framerate = 30.0;
 528
 529   exec_name = argv[0];
 530   // Check usage and arguments.
 531   if (argc < min_args) {
 532 #if CONFIG_VP9_HIGHBITDEPTH
 533     die(
 534         "Usage: %s <infile> <outfile> <codec_type(vp8/vp9)> <width> <height> "
 535         "<rate_num> <rate_den> <speed> <frame_drop_threshold> <mode> "
 536         "<Rate_0> ... <Rate_nlayers-1> <bit-depth> \n",
 537         argv[0]);
 538 #else
 539     die(
 540         "Usage: %s <infile> <outfile> <codec_type(vp8/vp9)> <width> <height> "
 541         "<rate_num> <rate_den> <speed> <frame_drop_threshold> <mode> "
 542         "<Rate_0> ... <Rate_nlayers-1> \n",
 543         argv[0]);
 544 #endif  // CONFIG_VP9_HIGHBITDEPTH
 545   }
 546
 547   encoder = get_vpx_encoder_by_name(argv[3]);
 548   if (!encoder) die("Unsupported codec.");
 549
 550   printf("Using %s\n", vpx_codec_iface_name(encoder->codec_interface()));
 551
 552   width = strtol(argv[4], NULL, 0);
 553   height = strtol(argv[5], NULL, 0);
 554   if (width < 16 || width % 2 || height < 16 || height % 2) {
 555     die("Invalid resolution: %d x %d", width, height);
 556   }
 557
 558   layering_mode = strtol(argv[10], NULL, 0);
 559   if (layering_mode < 0 || layering_mode > 13) {
 560     die("Invalid layering mode (0..12) %s", argv[10]);
 561   }
 562
 563   if (argc != min_args + mode_to_num_layers[layering_mode]) {
 564     die("Invalid number of arguments");
 565   }
 566
 567 #if CONFIG_VP9_HIGHBITDEPTH
 568   switch (strtol(argv[argc - 1], NULL, 0)) {
 569     case 8:
 570       bit_depth = VPX_BITS_8;
 571       input_bit_depth = 8;
 572       break;
 573     case 10:
 574       bit_depth = VPX_BITS_10;
 575       input_bit_depth = 10;
 576       break;
 577     case 12:
 578       bit_depth = VPX_BITS_12;
 579       input_bit_depth = 12;
 580       break;
 581     default: die("Invalid bit depth (8, 10, 12) %s", argv[argc - 1]);
 582   }
 583   if (!vpx_img_alloc(
 584           &raw, bit_depth == VPX_BITS_8 ? VPX_IMG_FMT_I420 : VPX_IMG_FMT_I42016,
 585           width, height, 32)) {
 586     die("Failed to allocate image", width, height);
 587   }
 588 #else
 589   if (!vpx_img_alloc(&raw, VPX_IMG_FMT_I420, width, height, 32)) {
 590     die("Failed to allocate image", width, height);
 591   }
 592 #endif  // CONFIG_VP9_HIGHBITDEPTH
 593
 594   // Populate encoder configuration.
 595   res = vpx_codec_enc_config_default(encoder->codec_interface(), &cfg, 0);
 596   if (res) {
 597     printf("Failed to get config: %s\n", vpx_codec_err_to_string(res));
 598     return EXIT_FAILURE;
 599   }
 600
 601   // Update the default configuration with our settings.
 602   cfg.g_w = width;
 603   cfg.g_h = height;
 604
 605 #if CONFIG_VP9_HIGHBITDEPTH
 606   if (bit_depth != VPX_BITS_8) {
 607     cfg.g_bit_depth = bit_depth;
 608     cfg.g_input_bit_depth = input_bit_depth;
 609     cfg.g_profile = 2;
 610   }
 611 #endif  // CONFIG_VP9_HIGHBITDEPTH
 612
 613   // Timebase format e.g. 30fps: numerator=1, demoninator = 30.
 614   cfg.g_timebase.num = strtol(argv[6], NULL, 0);
 615   cfg.g_timebase.den = strtol(argv[7], NULL, 0);
 616
 617   speed = strtol(argv[8], NULL, 0);
 618   if (speed < 0) {
 619     die("Invalid speed setting: must be positive");
 620   }
 621
 622   for (i = min_args_base;
 623        (int)i < min_args_base + mode_to_num_layers[layering_mode]; ++i) {
 624     rc.layer_target_bitrate[i - 11] = strtol(argv[i], NULL, 0);
 625     if (strncmp(encoder->name, "vp8", 3) == 0)
 626       cfg.ts_target_bitrate[i - 11] = rc.layer_target_bitrate[i - 11];
 627     else if (strncmp(encoder->name, "vp9", 3) == 0)
 628       cfg.layer_target_bitrate[i - 11] = rc.layer_target_bitrate[i - 11];
 629   }
 630
 631   // Real time parameters.
 632   cfg.rc_dropframe_thresh = strtol(argv[9], NULL, 0);
 633   cfg.rc_end_usage = VPX_CBR;
 634   cfg.rc_min_quantizer = 2;
 635   cfg.rc_max_quantizer = 56;
 636   if (strncmp(encoder->name, "vp9", 3) == 0) cfg.rc_max_quantizer = 52;
 637   cfg.rc_undershoot_pct = 50;
 638   cfg.rc_overshoot_pct = 50;
 639   cfg.rc_buf_initial_sz = 500;
 640   cfg.rc_buf_optimal_sz = 600;
 641   cfg.rc_buf_sz = 1000;
 642
 643   // Disable dynamic resizing by default.
 644   cfg.rc_resize_allowed = 0;
 645
 646   // Use 1 thread as default.
 647   cfg.g_threads = 1;
 648
 649   // Enable error resilient mode.
 650   cfg.g_error_resilient = 1;
 651   cfg.g_lag_in_frames = 0;
 652   cfg.kf_mode = VPX_KF_AUTO;
 653
 654   // Disable automatic keyframe placement.
 655   cfg.kf_min_dist = cfg.kf_max_dist = 3000;
 656
 657   cfg.temporal_layering_mode = VP9E_TEMPORAL_LAYERING_MODE_BYPASS;
 658
 659   set_temporal_layer_pattern(layering_mode, &cfg, layer_flags,
 660                              &flag_periodicity);
 661
 662   set_rate_control_metrics(&rc, &cfg);
 663
 664   // Target bandwidth for the whole stream.
 665   // Set to layer_target_bitrate for highest layer (total bitrate).
 666   cfg.rc_target_bitrate = rc.layer_target_bitrate[cfg.ts_number_layers - 1];
 667
 668   // Open input file.
 669   if (!(infile = fopen(argv[1], "rb"))) {
 670     die("Failed to open %s for reading", argv[1]);
 671   }
 672
 673   framerate = cfg.g_timebase.den / cfg.g_timebase.num;
 674   // Open an output file for each stream.
 675   for (i = 0; i < cfg.ts_number_layers; ++i) {
 676     char file_name[PATH_MAX];
 677     VpxVideoInfo info;
 678     info.codec_fourcc = encoder->fourcc;
 679     info.frame_width = cfg.g_w;
 680     info.frame_height = cfg.g_h;
 681     info.time_base.numerator = cfg.g_timebase.num;
 682     info.time_base.denominator = cfg.g_timebase.den;
 683
 684     snprintf(file_name, sizeof(file_name), "%s_%d.ivf", argv[2], i);
 685     outfile[i] = vpx_video_writer_open(file_name, kContainerIVF, &info);
 686     if (!outfile[i]) die("Failed to open %s for writing", file_name);
 687
 688     assert(outfile[i] != NULL);
 689   }
 690   // No spatial layers in this encoder.
 691   cfg.ss_number_layers = 1;
 692
 693 // Initialize codec.
 694 #if CONFIG_VP9_HIGHBITDEPTH
 695   if (vpx_codec_enc_init(
 696           &codec, encoder->codec_interface(), &cfg,
 697           bit_depth == VPX_BITS_8 ? 0 : VPX_CODEC_USE_HIGHBITDEPTH))
 698 #else
 699   if (vpx_codec_enc_init(&codec, encoder->codec_interface(), &cfg, 0))
 700 #endif  // CONFIG_VP9_HIGHBITDEPTH
 701     die_codec(&codec, "Failed to initialize encoder");
 702
 703   if (strncmp(encoder->name, "vp8", 3) == 0) {
 704     vpx_codec_control(&codec, VP8E_SET_CPUUSED, -speed);
 705     vpx_codec_control(&codec, VP8E_SET_NOISE_SENSITIVITY, kDenoiserOff);
 706     vpx_codec_control(&codec, VP8E_SET_STATIC_THRESHOLD, 1);
 707   } else if (strncmp(encoder->name, "vp9", 3) == 0) {
 708     vpx_svc_extra_cfg_t svc_params;
 709     vpx_codec_control(&codec, VP8E_SET_CPUUSED, speed);
 710     vpx_codec_control(&codec, VP9E_SET_AQ_MODE, 3);
 711     vpx_codec_control(&codec, VP9E_SET_FRAME_PERIODIC_BOOST, 0);
 712     vpx_codec_control(&codec, VP9E_SET_NOISE_SENSITIVITY, kDenoiserOff);
 713     vpx_codec_control(&codec, VP8E_SET_STATIC_THRESHOLD, 1);
 714     vpx_codec_control(&codec, VP9E_SET_TUNE_CONTENT, 0);
 715     vpx_codec_control(&codec, VP9E_SET_TILE_COLUMNS, (cfg.g_threads >> 1));
 716     if (vpx_codec_control(&codec, VP9E_SET_SVC, layering_mode > 0 ? 1 : 0))
 717       die_codec(&codec, "Failed to set SVC");
 718     for (i = 0; i < cfg.ts_number_layers; ++i) {
 719       svc_params.max_quantizers[i] = cfg.rc_max_quantizer;
 720       svc_params.min_quantizers[i] = cfg.rc_min_quantizer;
 721     }
 722     svc_params.scaling_factor_num[0] = cfg.g_h;
 723     svc_params.scaling_factor_den[0] = cfg.g_h;
 724     vpx_codec_control(&codec, VP9E_SET_SVC_PARAMETERS, &svc_params);
 725   }
 726   if (strncmp(encoder->name, "vp8", 3) == 0) {
 727     vpx_codec_control(&codec, VP8E_SET_SCREEN_CONTENT_MODE, 0);
 728   }
 729   vpx_codec_control(&codec, VP8E_SET_TOKEN_PARTITIONS, 1);
 730   // This controls the maximum target size of the key frame.
 731   // For generating smaller key frames, use a smaller max_intra_size_pct
 732   // value, like 100 or 200.
 733   {
 734     const int max_intra_size_pct = 900;
 735     vpx_codec_control(&codec, VP8E_SET_MAX_INTRA_BITRATE_PCT,
 736                       max_intra_size_pct);
 737   }
 738
 739   frame_avail = 1;
 740   while (frame_avail || got_data) {
 741     struct vpx_usec_timer timer;
 742     vpx_codec_iter_t iter = NULL;
 743     const vpx_codec_cx_pkt_t *pkt;
 744 #if VPX_ENCODER_ABI_VERSION > (4 + VPX_CODEC_ABI_VERSION)
 745     // Update the temporal layer_id. No spatial layers in this test.
 746     layer_id.spatial_layer_id = 0;
 747 #endif
 748     layer_id.temporal_layer_id =
 749         cfg.ts_layer_id[frame_cnt % cfg.ts_periodicity];
 750     if (strncmp(encoder->name, "vp9", 3) == 0) {
 751       vpx_codec_control(&codec, VP9E_SET_SVC_LAYER_ID, &layer_id);
 752     } else if (strncmp(encoder->name, "vp8", 3) == 0) {
 753       vpx_codec_control(&codec, VP8E_SET_TEMPORAL_LAYER_ID,
 754                         layer_id.temporal_layer_id);
 755     }
 756     flags = layer_flags[frame_cnt % flag_periodicity];
 757     if (layering_mode == 0) flags = 0;
 758     frame_avail = vpx_img_read(&raw, infile);
 759     if (frame_avail) ++rc.layer_input_frames[layer_id.temporal_layer_id];
 760     vpx_usec_timer_start(&timer);
 761     if (vpx_codec_encode(&codec, frame_avail ? &raw : NULL, pts, 1, flags,
 762                          VPX_DL_REALTIME)) {
 763       die_codec(&codec, "Failed to encode frame");
 764     }
 765     vpx_usec_timer_mark(&timer);
 766     cx_time += vpx_usec_timer_elapsed(&timer);
 767     // Reset KF flag.
 768     if (layering_mode != 7) {
 769       layer_flags[0] &= ~VPX_EFLAG_FORCE_KF;
 770     }
 771     got_data = 0;
 772     while ((pkt = vpx_codec_get_cx_data(&codec, &iter))) {
 773       got_data = 1;
 774       switch (pkt->kind) {
 775         case VPX_CODEC_CX_FRAME_PKT:
 776           for (i = cfg.ts_layer_id[frame_cnt % cfg.ts_periodicity];
 777                i < cfg.ts_number_layers; ++i) {
 778             vpx_video_writer_write_frame(outfile[i], pkt->data.frame.buf,
 779                                          pkt->data.frame.sz, pts);
 780             ++rc.layer_tot_enc_frames[i];
 781             rc.layer_encoding_bitrate[i] += 8.0 * pkt->data.frame.sz;
 782             // Keep count of rate control stats per layer (for non-key frames).
 783             if (i == cfg.ts_layer_id[frame_cnt % cfg.ts_periodicity] &&
 784                 !(pkt->data.frame.flags & VPX_FRAME_IS_KEY)) {
 785               rc.layer_avg_frame_size[i] += 8.0 * pkt->data.frame.sz;
 786               rc.layer_avg_rate_mismatch[i] +=
 787                   fabs(8.0 * pkt->data.frame.sz - rc.layer_pfb[i]) /
 788                   rc.layer_pfb[i];
 789               ++rc.layer_enc_frames[i];
 790             }
 791           }
 792           // Update for short-time encoding bitrate states, for moving window
 793           // of size rc->window, shifted by rc->window / 2.
 794           // Ignore first window segment, due to key frame.
 795           if (frame_cnt > rc.window_size) {
 796             sum_bitrate += 0.001 * 8.0 * pkt->data.frame.sz * framerate;
 797             if (frame_cnt % rc.window_size == 0) {
 798               rc.window_count += 1;
 799               rc.avg_st_encoding_bitrate += sum_bitrate / rc.window_size;
 800               rc.variance_st_encoding_bitrate +=
 801                   (sum_bitrate / rc.window_size) *
 802                   (sum_bitrate / rc.window_size);
 803               sum_bitrate = 0.0;
 804             }
 805           }
 806           // Second shifted window.
 807           if (frame_cnt > rc.window_size + rc.window_size / 2) {
 808             sum_bitrate2 += 0.001 * 8.0 * pkt->data.frame.sz * framerate;
 809             if (frame_cnt > 2 * rc.window_size &&
 810                 frame_cnt % rc.window_size == 0) {
 811               rc.window_count += 1;
 812               rc.avg_st_encoding_bitrate += sum_bitrate2 / rc.window_size;
 813               rc.variance_st_encoding_bitrate +=
 814                   (sum_bitrate2 / rc.window_size) *
 815                   (sum_bitrate2 / rc.window_size);
 816               sum_bitrate2 = 0.0;
 817             }
 818           }
 819           break;
 820         default: break;
 821       }
 822     }
 823     ++frame_cnt;
 824     pts += frame_duration;
 825   }
 826   fclose(infile);
 827   printout_rate_control_summary(&rc, &cfg, frame_cnt);
 828   printf("\n");
 829   printf("Frame cnt and encoding time/FPS stats for encoding: %d %f %f \n",
 830          frame_cnt, 1000 * (float)cx_time / (double)(frame_cnt * 1000000),
 831          1000000 * (double)frame_cnt / (double)cx_time);
 832
 833   if (vpx_codec_destroy(&codec)) die_codec(&codec, "Failed to destroy codec");
 834
 835   // Try to rewrite the output file headers with the actual frame count.
 836   for (i = 0; i < cfg.ts_number_layers; ++i) vpx_video_writer_close(outfile[i]);
 837
 838   vpx_img_free(&raw);
 839   return EXIT_SUCCESS;
 840 }