/* *  Copyright (c) 2012 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. */ /* * This is an example demonstrating how to implement a multi-layer * VP9 encoding scheme based on spatial scalability for video applications * that benefit from a scalable bitstream. */ #include <math.h>#include <stdarg.h>#include <stdlib.h>#include <string.h>#include <time.h> #include "../args.h"#include "../tools_common.h"#include "../video_writer.h" #include "../vpx_ports/vpx_timer.h"#include "./svc_context.h"#include "vpx/vp8cx.h"#include "vpx/vpx_encoder.h"#include "../vpxstats.h"#include "vp9/encoder/vp9_encoder.h"#include "./y4minput.h" #define OUTPUT_RC_STATS 1 #define SIMULCAST_MODE 0 static const arg_def_t outputfile =    ARG_DEF("o", "output", 1, "Output filename");static const arg_def_t skip_frames_arg =    ARG_DEF("s", "skip-frames", 1, "input frames to skip");static const arg_def_t frames_arg =    ARG_DEF("f", "frames", 1, "number of frames to encode");static const arg_def_t threads_arg =    ARG_DEF("th", "threads", 1, "number of threads to use");#if OUTPUT_RC_STATSstatic const arg_def_t output_rc_stats_arg =    ARG_DEF("rcstat", "output_rc_stats", 1, "output rc stats");#endifstatic const arg_def_t width_arg = ARG_DEF("w", "width", 1, "source width");static const arg_def_t height_arg = ARG_DEF("h", "height", 1, "source height");static const arg_def_t timebase_arg =    ARG_DEF("t", "timebase", 1, "timebase (num/den)");static const arg_def_t bitrate_arg = ARG_DEF(    "b", "target-bitrate", 1, "encoding bitrate, in kilobits per second");static const arg_def_t spatial_layers_arg =    ARG_DEF("sl", "spatial-layers", 1, "number of spatial SVC layers");static const arg_def_t temporal_layers_arg =    ARG_DEF("tl", "temporal-layers", 1, "number of temporal SVC layers");static const arg_def_t temporal_layering_mode_arg =    ARG_DEF("tlm", "temporal-layering-mode", 1,            "temporal layering scheme."            "VP9E_TEMPORAL_LAYERING_MODE");static const arg_def_t kf_dist_arg =    ARG_DEF("k", "kf-dist", 1, "number of frames between keyframes");static const arg_def_t scale_factors_arg =    ARG_DEF("r", "scale-factors", 1, "scale factors (lowest to highest layer)");static const arg_def_t min_q_arg =    ARG_DEF(NULL, "min-q", 1, "Minimum quantizer");static const arg_def_t max_q_arg =    ARG_DEF(NULL, "max-q", 1, "Maximum quantizer");static const arg_def_t min_bitrate_arg =    ARG_DEF(NULL, "min-bitrate", 1, "Minimum bitrate");static const arg_def_t max_bitrate_arg =    ARG_DEF(NULL, "max-bitrate", 1, "Maximum bitrate");static const arg_def_t lag_in_frame_arg =    ARG_DEF(NULL, "lag-in-frames", 1,            "Number of frame to input before "            "generating any outputs");static const arg_def_t rc_end_usage_arg =    ARG_DEF(NULL, "rc-end-usage", 1, "0 - 3: VBR, CBR, CQ, Q");static const arg_def_t speed_arg =    ARG_DEF("sp", "speed", 1, "speed configuration");static const arg_def_t aqmode_arg =    ARG_DEF("aq", "aqmode", 1, "aq-mode off/on");static const arg_def_t bitrates_arg =    ARG_DEF("bl", "bitrates", 1, "bitrates[sl * num_tl + tl]");static const arg_def_t dropframe_thresh_arg =    ARG_DEF(NULL, "drop-frame", 1, "Temporal resampling threshold (buf %)");static const struct arg_enum_list tune_content_enum[] = {  { "default", VP9E_CONTENT_DEFAULT },  { "screen", VP9E_CONTENT_SCREEN },  { "film", VP9E_CONTENT_FILM },  { NULL, 0 }}; static const arg_def_t tune_content_arg = ARG_DEF_ENUM(    NULL, "tune-content", 1, "Tune content type", tune_content_enum);static const arg_def_t inter_layer_pred_arg = ARG_DEF(    NULL, "inter-layer-pred", 1, "0 - 3: On, Off, Key-frames, Constrained"); #if CONFIG_VP9_HIGHBITDEPTHstatic const struct arg_enum_list bitdepth_enum[] = {  { "8", VPX_BITS_8 }, { "10", VPX_BITS_10 }, { "12", VPX_BITS_12 }, { NULL, 0 }}; static const arg_def_t bitdepth_arg = ARG_DEF_ENUM(    "d", "bit-depth", 1, "Bit depth for codec 8, 10 or 12. ", bitdepth_enum);#endif  // CONFIG_VP9_HIGHBITDEPTH static const arg_def_t *svc_args[] = { &frames_arg,                                       &outputfile,                                       &width_arg,                                       &height_arg,                                       &timebase_arg,                                       &bitrate_arg,                                       &skip_frames_arg,                                       &spatial_layers_arg,                                       &kf_dist_arg,                                       &scale_factors_arg,                                       &min_q_arg,                                       &max_q_arg,                                       &min_bitrate_arg,                                       &max_bitrate_arg,                                       &temporal_layers_arg,                                       &temporal_layering_mode_arg,                                       &lag_in_frame_arg,                                       &threads_arg,                                       &aqmode_arg,#if OUTPUT_RC_STATS                                       &output_rc_stats_arg,#endif #if CONFIG_VP9_HIGHBITDEPTH                                       &bitdepth_arg,#endif                                       &speed_arg,                                       &rc_end_usage_arg,                                       &bitrates_arg,                                       &dropframe_thresh_arg,                                       &tune_content_arg,                                       &inter_layer_pred_arg,                                       NULL }; static const uint32_t default_frames_to_skip = 0;static const uint32_t default_frames_to_code = 60 * 60;static const uint32_t default_width = 1920;static const uint32_t default_height = 1080;static const uint32_t default_timebase_num = 1;static const uint32_t default_timebase_den = 60;static const uint32_t default_bitrate = 1000;static const uint32_t default_spatial_layers = 5;static const uint32_t default_temporal_layers = 1;static const uint32_t default_kf_dist = 100;static const uint32_t default_temporal_layering_mode = 0;static const uint32_t default_output_rc_stats = 0;static const int32_t default_speed = -1;    // -1 means use library default.static const uint32_t default_threads = 0;  // zero means use library default. typedef struct {  const char *output_filename;  uint32_t frames_to_code;  uint32_t frames_to_skip;  struct VpxInputContext input_ctx;  stats_io_t rc_stats;  int tune_content;  int inter_layer_pred;} AppInput; static const char *exec_name; void usage_exit(void) {  fprintf(stderr, "Usage: %s <options> input_filename -o output_filename\n",          exec_name);  fprintf(stderr, "Options:\n");  arg_show_usage(stderr, svc_args);  exit(EXIT_FAILURE);} static void parse_command_line(int argc, const char **argv_,                               AppInput *app_input, SvcContext *svc_ctx,                               vpx_codec_enc_cfg_t *enc_cfg) {  struct arg arg;  char **argv = NULL;  char **argi = NULL;  char **argj = NULL;  vpx_codec_err_t res;  unsigned int min_bitrate = 0;  unsigned int max_bitrate = 0;  char string_options[1024] = { 0 };   // initialize SvcContext with parameters that will be passed to vpx_svc_init  svc_ctx->log_level = SVC_LOG_DEBUG;  svc_ctx->spatial_layers = default_spatial_layers;  svc_ctx->temporal_layers = default_temporal_layers;  svc_ctx->temporal_layering_mode = default_temporal_layering_mode;#if OUTPUT_RC_STATS  svc_ctx->output_rc_stat = default_output_rc_stats;#endif  svc_ctx->speed = default_speed;  svc_ctx->threads = default_threads;   // start with default encoder configuration  res = vpx_codec_enc_config_default(vpx_codec_vp9_cx(), enc_cfg, 0);  if (res) {    die("Failed to get config: %s\n", vpx_codec_err_to_string(res));  }  // update enc_cfg with app default values  enc_cfg->g_w = default_width;  enc_cfg->g_h = default_height;  enc_cfg->g_timebase.num = default_timebase_num;  enc_cfg->g_timebase.den = default_timebase_den;  enc_cfg->rc_target_bitrate = default_bitrate;  enc_cfg->kf_min_dist = default_kf_dist;  enc_cfg->kf_max_dist = default_kf_dist;  enc_cfg->rc_end_usage = VPX_CQ;   // initialize AppInput with default values  app_input->frames_to_code = default_frames_to_code;  app_input->frames_to_skip = default_frames_to_skip;   // process command line options  argv = argv_dup(argc - 1, argv_ + 1);  for (argi = argj = argv; (*argj = *argi); argi += arg.argv_step) {    arg.argv_step = 1;     if (arg_match(&arg, &frames_arg, argi)) {      app_input->frames_to_code = arg_parse_uint(&arg);    } else if (arg_match(&arg, &outputfile, argi)) {      app_input->output_filename = arg.val;    } else if (arg_match(&arg, &width_arg, argi)) {      enc_cfg->g_w = arg_parse_uint(&arg);    } else if (arg_match(&arg, &height_arg, argi)) {      enc_cfg->g_h = arg_parse_uint(&arg);    } else if (arg_match(&arg, &timebase_arg, argi)) {      enc_cfg->g_timebase = arg_parse_rational(&arg);    } else if (arg_match(&arg, &bitrate_arg, argi)) {      enc_cfg->rc_target_bitrate = arg_parse_uint(&arg);    } else if (arg_match(&arg, &skip_frames_arg, argi)) {      app_input->frames_to_skip = arg_parse_uint(&arg);    } else if (arg_match(&arg, &spatial_layers_arg, argi)) {      svc_ctx->spatial_layers = arg_parse_uint(&arg);    } else if (arg_match(&arg, &temporal_layers_arg, argi)) {      svc_ctx->temporal_layers = arg_parse_uint(&arg);#if OUTPUT_RC_STATS    } else if (arg_match(&arg, &output_rc_stats_arg, argi)) {      svc_ctx->output_rc_stat = arg_parse_uint(&arg);#endif    } else if (arg_match(&arg, &speed_arg, argi)) {      svc_ctx->speed = arg_parse_uint(&arg);      if (svc_ctx->speed > 9) {        warn("Mapping speed %d to speed 9.\n", svc_ctx->speed);      }    } else if (arg_match(&arg, &aqmode_arg, argi)) {      svc_ctx->aqmode = arg_parse_uint(&arg);    } else if (arg_match(&arg, &threads_arg, argi)) {      svc_ctx->threads = arg_parse_uint(&arg);    } else if (arg_match(&arg, &temporal_layering_mode_arg, argi)) {      svc_ctx->temporal_layering_mode = enc_cfg->temporal_layering_mode =          arg_parse_int(&arg);      if (svc_ctx->temporal_layering_mode) {        enc_cfg->g_error_resilient = 1;      }    } else if (arg_match(&arg, &kf_dist_arg, argi)) {      enc_cfg->kf_min_dist = arg_parse_uint(&arg);      enc_cfg->kf_max_dist = enc_cfg->kf_min_dist;    } else if (arg_match(&arg, &scale_factors_arg, argi)) {      strncat(string_options, " scale-factors=",              sizeof(string_options) - strlen(string_options) - 1);      strncat(string_options, arg.val,              sizeof(string_options) - strlen(string_options) - 1);    } else if (arg_match(&arg, &bitrates_arg, argi)) {      strncat(string_options, " bitrates=",              sizeof(string_options) - strlen(string_options) - 1);      strncat(string_options, arg.val,              sizeof(string_options) - strlen(string_options) - 1);    } else if (arg_match(&arg, &min_q_arg, argi)) {      strncat(string_options, " min-quantizers=",              sizeof(string_options) - strlen(string_options) - 1);      strncat(string_options, arg.val,              sizeof(string_options) - strlen(string_options) - 1);    } else if (arg_match(&arg, &max_q_arg, argi)) {      strncat(string_options, " max-quantizers=",              sizeof(string_options) - strlen(string_options) - 1);      strncat(string_options, arg.val,              sizeof(string_options) - strlen(string_options) - 1);    } else if (arg_match(&arg, &min_bitrate_arg, argi)) {      min_bitrate = arg_parse_uint(&arg);    } else if (arg_match(&arg, &max_bitrate_arg, argi)) {      max_bitrate = arg_parse_uint(&arg);    } else if (arg_match(&arg, &lag_in_frame_arg, argi)) {      enc_cfg->g_lag_in_frames = arg_parse_uint(&arg);    } else if (arg_match(&arg, &rc_end_usage_arg, argi)) {      enc_cfg->rc_end_usage = arg_parse_uint(&arg);#if CONFIG_VP9_HIGHBITDEPTH    } else if (arg_match(&arg, &bitdepth_arg, argi)) {      enc_cfg->g_bit_depth = arg_parse_enum_or_int(&arg);      switch (enc_cfg->g_bit_depth) {        case VPX_BITS_8:          enc_cfg->g_input_bit_depth = 8;          enc_cfg->g_profile = 0;          break;        case VPX_BITS_10:          enc_cfg->g_input_bit_depth = 10;          enc_cfg->g_profile = 2;          break;        case VPX_BITS_12:          enc_cfg->g_input_bit_depth = 12;          enc_cfg->g_profile = 2;          break;        default:          die("Error: Invalid bit depth selected (%d)\n", enc_cfg->g_bit_depth);          break;      }#endif  // CONFIG_VP9_HIGHBITDEPTH    } else if (arg_match(&arg, &dropframe_thresh_arg, argi)) {      enc_cfg->rc_dropframe_thresh = arg_parse_uint(&arg);    } else if (arg_match(&arg, &tune_content_arg, argi)) {      app_input->tune_content = arg_parse_uint(&arg);    } else if (arg_match(&arg, &inter_layer_pred_arg, argi)) {      app_input->inter_layer_pred = arg_parse_uint(&arg);    } else {      ++argj;    }  }   // There will be a space in front of the string options  if (strlen(string_options) > 0)    vpx_svc_set_options(svc_ctx, string_options + 1);   enc_cfg->g_pass = VPX_RC_ONE_PASS;   if (enc_cfg->rc_target_bitrate > 0) {    if (min_bitrate > 0) {      enc_cfg->rc_2pass_vbr_minsection_pct =          min_bitrate * 100 / enc_cfg->rc_target_bitrate;    }    if (max_bitrate > 0) {      enc_cfg->rc_2pass_vbr_maxsection_pct =          max_bitrate * 100 / enc_cfg->rc_target_bitrate;    }  }   // Check for unrecognized options  for (argi = argv; *argi; ++argi)    if (argi[0][0] == '-' && strlen(argi[0]) > 1)      die("Error: Unrecognized option %s\n", *argi);   if (argv[0] == NULL) {    usage_exit();  }  app_input->input_ctx.filename = argv[0];  free(argv);   open_input_file(&app_input->input_ctx);  if (app_input->input_ctx.file_type == FILE_TYPE_Y4M) {    enc_cfg->g_w = app_input->input_ctx.width;    enc_cfg->g_h = app_input->input_ctx.height;  }   if (enc_cfg->g_w < 16 || enc_cfg->g_w % 2 || enc_cfg->g_h < 16 ||      enc_cfg->g_h % 2)    die("Invalid resolution: %d x %d\n", enc_cfg->g_w, enc_cfg->g_h);   printf(      "Codec %s\nframes: %d, skip: %d\n"      "layers: %d\n"      "width %d, height: %d,\n"      "num: %d, den: %d, bitrate: %d,\n"      "gop size: %d\n",      vpx_codec_iface_name(vpx_codec_vp9_cx()), app_input->frames_to_code,      app_input->frames_to_skip, svc_ctx->spatial_layers, enc_cfg->g_w,      enc_cfg->g_h, enc_cfg->g_timebase.num, enc_cfg->g_timebase.den,      enc_cfg->rc_target_bitrate, enc_cfg->kf_max_dist);} #if OUTPUT_RC_STATS// For rate control encoding stats.struct RateControlStats {  // Number of input frames per layer.  int layer_input_frames[VPX_MAX_LAYERS];  // Total (cumulative) number of encoded frames per layer.  int layer_tot_enc_frames[VPX_MAX_LAYERS];  // Number of encoded non-key frames per layer.  int layer_enc_frames[VPX_MAX_LAYERS];  // Framerate per layer (cumulative).  double layer_framerate[VPX_MAX_LAYERS];  // Target average frame size per layer (per-frame-bandwidth per layer).  double layer_pfb[VPX_MAX_LAYERS];  // Actual average frame size per layer.  double layer_avg_frame_size[VPX_MAX_LAYERS];  // Average rate mismatch per layer (|target - actual| / target).  double layer_avg_rate_mismatch[VPX_MAX_LAYERS];  // Actual encoding bitrate per layer (cumulative).  double layer_encoding_bitrate[VPX_MAX_LAYERS];  // Average of the short-time encoder actual bitrate.  // TODO(marpan): Should we add these short-time stats for each layer?  double avg_st_encoding_bitrate;  // Variance of the short-time encoder actual bitrate.  double variance_st_encoding_bitrate;  // Window (number of frames) for computing short-time encoding bitrate.  int window_size;  // Number of window measurements.  int window_count;}; // Note: these rate control stats assume only 1 key frame in the// sequence (i.e., first frame only).static void set_rate_control_stats(struct RateControlStats *rc,                                   vpx_codec_enc_cfg_t *cfg) {  unsigned int sl, tl;  // Set the layer (cumulative) framerate and the target layer (non-cumulative)  // per-frame-bandwidth, for the rate control encoding stats below.  const double framerate = cfg->g_timebase.den / cfg->g_timebase.num;   for (sl = 0; sl < cfg->ss_number_layers; ++sl) {    for (tl = 0; tl < cfg->ts_number_layers; ++tl) {      const int layer = sl * cfg->ts_number_layers + tl;      if (cfg->ts_number_layers == 1)        rc->layer_framerate[layer] = framerate;      else        rc->layer_framerate[layer] = framerate / cfg->ts_rate_decimator[tl];      if (tl > 0) {        rc->layer_pfb[layer] =            1000.0 *            (cfg->layer_target_bitrate[layer] -             cfg->layer_target_bitrate[layer - 1]) /            (rc->layer_framerate[layer] - rc->layer_framerate[layer - 1]);      } else {        rc->layer_pfb[layer] = 1000.0 * cfg->layer_target_bitrate[layer] /                               rc->layer_framerate[layer];      }      rc->layer_input_frames[layer] = 0;      rc->layer_enc_frames[layer] = 0;      rc->layer_tot_enc_frames[layer] = 0;      rc->layer_encoding_bitrate[layer] = 0.0;      rc->layer_avg_frame_size[layer] = 0.0;      rc->layer_avg_rate_mismatch[layer] = 0.0;    }  }  rc->window_count = 0;  rc->window_size = 15;  rc->avg_st_encoding_bitrate = 0.0;  rc->variance_st_encoding_bitrate = 0.0;} static void printout_rate_control_summary(struct RateControlStats *rc,                                          vpx_codec_enc_cfg_t *cfg,                                          int frame_cnt) {  unsigned int sl, tl;  double perc_fluctuation = 0.0;  int tot_num_frames = 0;  printf("Total number of processed frames: %d\n\n", frame_cnt - 1);  printf("Rate control layer stats for sl%d tl%d layer(s):\n\n",         cfg->ss_number_layers, cfg->ts_number_layers);  for (sl = 0; sl < cfg->ss_number_layers; ++sl) {    tot_num_frames = 0;    for (tl = 0; tl < cfg->ts_number_layers; ++tl) {      const int layer = sl * cfg->ts_number_layers + tl;      const int num_dropped =          (tl > 0)              ? (rc->layer_input_frames[layer] - rc->layer_enc_frames[layer])              : (rc->layer_input_frames[layer] - rc->layer_enc_frames[layer] -                 1);      tot_num_frames += rc->layer_input_frames[layer];      rc->layer_encoding_bitrate[layer] = 0.001 * rc->layer_framerate[layer] *                                          rc->layer_encoding_bitrate[layer] /                                          tot_num_frames;      rc->layer_avg_frame_size[layer] =          rc->layer_avg_frame_size[layer] / rc->layer_enc_frames[layer];      rc->layer_avg_rate_mismatch[layer] = 100.0 *                                           rc->layer_avg_rate_mismatch[layer] /                                           rc->layer_enc_frames[layer];      printf("For layer#: sl%d tl%d \n", sl, tl);      printf("Bitrate (target vs actual): %d %f.0 kbps\n",             cfg->layer_target_bitrate[layer],             rc->layer_encoding_bitrate[layer]);      printf("Average frame size (target vs actual): %f %f bits\n",             rc->layer_pfb[layer], rc->layer_avg_frame_size[layer]);      printf("Average rate_mismatch: %f\n", rc->layer_avg_rate_mismatch[layer]);      printf(          "Number of input frames, encoded (non-key) frames, "          "and percent dropped frames: %d %d %f.0 \n",          rc->layer_input_frames[layer], rc->layer_enc_frames[layer],          100.0 * num_dropped / rc->layer_input_frames[layer]);      printf("\n");    }  }  rc->avg_st_encoding_bitrate = rc->avg_st_encoding_bitrate / rc->window_count;  rc->variance_st_encoding_bitrate =      rc->variance_st_encoding_bitrate / rc->window_count -      (rc->avg_st_encoding_bitrate * rc->avg_st_encoding_bitrate);  perc_fluctuation = 100.0 * sqrt(rc->variance_st_encoding_bitrate) /                     rc->avg_st_encoding_bitrate;  printf("Short-time stats, for window of %d frames: \n", rc->window_size);  printf("Average, rms-variance, and percent-fluct: %f %f %f \n",         rc->avg_st_encoding_bitrate, sqrt(rc->variance_st_encoding_bitrate),         perc_fluctuation);  printf("Num of input, num of encoded (super) frames: %d %d \n", frame_cnt,

Lines 1–500 of 1205. Load more