vpx_temporal_svc_encoder

00001 /*
00002  *  Copyright (c) 2012 The WebM project authors. All Rights Reserved.
00003  *
00004  *  Use of this source code is governed by a BSD-style license
00005  *  that can be found in the LICENSE file in the root of the source
00006  *  tree. An additional intellectual property rights grant can be found
00007  *  in the file PATENTS.  All contributing project authors may
00008  *  be found in the AUTHORS file in the root of the source tree.
00009  */
00010 
00011 //  This is an example demonstrating how to implement a multi-layer VPx
00012 //  encoding scheme based on temporal scalability for video applications
00013 //  that benefit from a scalable bitstream.
00014 
00015 #include <assert.h>
00016 #include <math.h>
00017 #include <stdio.h>
00018 #include <stdlib.h>
00019 #include <string.h>
00020 
00021 #include "./vpx_config.h"
00022 #include "../vpx_ports/vpx_timer.h"
00023 #include "vpx/vp8cx.h"
00024 #include "vpx/vpx_encoder.h"
00025 
00026 #include "../tools_common.h"
00027 #include "../video_writer.h"
00028 
00029 static const char *exec_name;
00030 
00031 void usage_exit(void) { exit(EXIT_FAILURE); }
00032 
00033 // Denoiser states, for temporal denoising.
00034 enum denoiserState {
00035   kDenoiserOff,
00036   kDenoiserOnYOnly,
00037   kDenoiserOnYUV,
00038   kDenoiserOnYUVAggressive,
00039   kDenoiserOnAdaptive
00040 };
00041 
00042 static int mode_to_num_layers[13] = { 1, 2, 2, 3, 3, 3, 3, 5, 2, 3, 3, 3, 3 };
00043 
00044 // For rate control encoding stats.
00045 struct RateControlMetrics {
00046   // Number of input frames per layer.
00047   int layer_input_frames[VPX_TS_MAX_LAYERS];
00048   // Total (cumulative) number of encoded frames per layer.
00049   int layer_tot_enc_frames[VPX_TS_MAX_LAYERS];
00050   // Number of encoded non-key frames per layer.
00051   int layer_enc_frames[VPX_TS_MAX_LAYERS];
00052   // Framerate per layer layer (cumulative).
00053   double layer_framerate[VPX_TS_MAX_LAYERS];
00054   // Target average frame size per layer (per-frame-bandwidth per layer).
00055   double layer_pfb[VPX_TS_MAX_LAYERS];
00056   // Actual average frame size per layer.
00057   double layer_avg_frame_size[VPX_TS_MAX_LAYERS];
00058   // Average rate mismatch per layer (|target - actual| / target).
00059   double layer_avg_rate_mismatch[VPX_TS_MAX_LAYERS];
00060   // Actual encoding bitrate per layer (cumulative).
00061   double layer_encoding_bitrate[VPX_TS_MAX_LAYERS];
00062   // Average of the short-time encoder actual bitrate.
00063   // TODO(marpan): Should we add these short-time stats for each layer?
00064   double avg_st_encoding_bitrate;
00065   // Variance of the short-time encoder actual bitrate.
00066   double variance_st_encoding_bitrate;
00067   // Window (number of frames) for computing short-timee encoding bitrate.
00068   int window_size;
00069   // Number of window measurements.
00070   int window_count;
00071   int layer_target_bitrate[VPX_MAX_LAYERS];
00072 };
00073 
00074 // Note: these rate control metrics assume only 1 key frame in the
00075 // sequence (i.e., first frame only). So for temporal pattern# 7
00076 // (which has key frame for every frame on base layer), the metrics
00077 // computation will be off/wrong.
00078 // TODO(marpan): Update these metrics to account for multiple key frames
00079 // in the stream.
00080 static void set_rate_control_metrics(struct RateControlMetrics *rc,
00081                                      vpx_codec_enc_cfg_t *cfg) {
00082   unsigned int i = 0;
00083   // Set the layer (cumulative) framerate and the target layer (non-cumulative)
00084   // per-frame-bandwidth, for the rate control encoding stats below.
00085   const double framerate = cfg->g_timebase.den / cfg->g_timebase.num;
00086   rc->layer_framerate[0] = framerate / cfg->ts_rate_decimator[0];
00087   rc->layer_pfb[0] =
00088       1000.0 * rc->layer_target_bitrate[0] / rc->layer_framerate[0];
00089   for (i = 0; i < cfg->ts_number_layers; ++i) {
00090     if (i > 0) {
00091       rc->layer_framerate[i] = framerate / cfg->ts_rate_decimator[i];
00092       rc->layer_pfb[i] = 1000.0 * (rc->layer_target_bitrate[i] -
00093                                    rc->layer_target_bitrate[i - 1]) /
00094                          (rc->layer_framerate[i] - rc->layer_framerate[i - 1]);
00095     }
00096     rc->layer_input_frames[i] = 0;
00097     rc->layer_enc_frames[i] = 0;
00098     rc->layer_tot_enc_frames[i] = 0;
00099     rc->layer_encoding_bitrate[i] = 0.0;
00100     rc->layer_avg_frame_size[i] = 0.0;
00101     rc->layer_avg_rate_mismatch[i] = 0.0;
00102   }
00103   rc->window_count = 0;
00104   rc->window_size = 15;
00105   rc->avg_st_encoding_bitrate = 0.0;
00106   rc->variance_st_encoding_bitrate = 0.0;
00107 }
00108 
00109 static void printout_rate_control_summary(struct RateControlMetrics *rc,
00110                                           vpx_codec_enc_cfg_t *cfg,
00111                                           int frame_cnt) {
00112   unsigned int i = 0;
00113   int tot_num_frames = 0;
00114   double perc_fluctuation = 0.0;
00115   printf("Total number of processed frames: %d\n\n", frame_cnt - 1);
00116   printf("Rate control layer stats for %d layer(s):\n\n",
00117          cfg->ts_number_layers);
00118   for (i = 0; i < cfg->ts_number_layers; ++i) {
00119     const int num_dropped =
00120         (i > 0) ? (rc->layer_input_frames[i] - rc->layer_enc_frames[i])
00121                 : (rc->layer_input_frames[i] - rc->layer_enc_frames[i] - 1);
00122     tot_num_frames += rc->layer_input_frames[i];
00123     rc->layer_encoding_bitrate[i] = 0.001 * rc->layer_framerate[i] *
00124                                     rc->layer_encoding_bitrate[i] /
00125                                     tot_num_frames;
00126     rc->layer_avg_frame_size[i] =
00127         rc->layer_avg_frame_size[i] / rc->layer_enc_frames[i];
00128     rc->layer_avg_rate_mismatch[i] =
00129         100.0 * rc->layer_avg_rate_mismatch[i] / rc->layer_enc_frames[i];
00130     printf("For layer#: %d \n", i);
00131     printf("Bitrate (target vs actual): %d %f \n", rc->layer_target_bitrate[i],
00132            rc->layer_encoding_bitrate[i]);
00133     printf("Average frame size (target vs actual): %f %f \n", rc->layer_pfb[i],
00134            rc->layer_avg_frame_size[i]);
00135     printf("Average rate_mismatch: %f \n", rc->layer_avg_rate_mismatch[i]);
00136     printf(
00137         "Number of input frames, encoded (non-key) frames, "
00138         "and perc dropped frames: %d %d %f \n",
00139         rc->layer_input_frames[i], rc->layer_enc_frames[i],
00140         100.0 * num_dropped / rc->layer_input_frames[i]);
00141     printf("\n");
00142   }
00143   rc->avg_st_encoding_bitrate = rc->avg_st_encoding_bitrate / rc->window_count;
00144   rc->variance_st_encoding_bitrate =
00145       rc->variance_st_encoding_bitrate / rc->window_count -
00146       (rc->avg_st_encoding_bitrate * rc->avg_st_encoding_bitrate);
00147   perc_fluctuation = 100.0 * sqrt(rc->variance_st_encoding_bitrate) /
00148                      rc->avg_st_encoding_bitrate;
00149   printf("Short-time stats, for window of %d frames: \n", rc->window_size);
00150   printf("Average, rms-variance, and percent-fluct: %f %f %f \n",
00151          rc->avg_st_encoding_bitrate, sqrt(rc->variance_st_encoding_bitrate),
00152          perc_fluctuation);
00153   if ((frame_cnt - 1) != tot_num_frames)
00154     die("Error: Number of input frames not equal to output! \n");
00155 }
00156 
00157 // Temporal scaling parameters:
00158 // NOTE: The 3 prediction frames cannot be used interchangeably due to
00159 // differences in the way they are handled throughout the code. The
00160 // frames should be allocated to layers in the order LAST, GF, ARF.
00161 // Other combinations work, but may produce slightly inferior results.
00162 static void set_temporal_layer_pattern(int layering_mode,
00163                                        vpx_codec_enc_cfg_t *cfg,
00164                                        int *layer_flags,
00165                                        int *flag_periodicity) {
00166   switch (layering_mode) {
00167     case 0: {
00168       // 1-layer.
00169       int ids[1] = { 0 };
00170       cfg->ts_periodicity = 1;
00171       *flag_periodicity = 1;
00172       cfg->ts_number_layers = 1;
00173       cfg->ts_rate_decimator[0] = 1;
00174       memcpy(cfg->ts_layer_id, ids, sizeof(ids));
00175       // Update L only.
00176       layer_flags[0] =
00177           VPX_EFLAG_FORCE_KF | VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF;
00178       break;
00179     }
00180     case 1: {
00181       // 2-layers, 2-frame period.
00182       int ids[2] = { 0, 1 };
00183       cfg->ts_periodicity = 2;
00184       *flag_periodicity = 2;
00185       cfg->ts_number_layers = 2;
00186       cfg->ts_rate_decimator[0] = 2;
00187       cfg->ts_rate_decimator[1] = 1;
00188       memcpy(cfg->ts_layer_id, ids, sizeof(ids));
00189 #if 1
00190       // 0=L, 1=GF, Intra-layer prediction enabled.
00191       layer_flags[0] = VPX_EFLAG_FORCE_KF | VP8_EFLAG_NO_UPD_GF |
00192                        VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_REF_GF |
00193                        VP8_EFLAG_NO_REF_ARF;
00194       layer_flags[1] =
00195           VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_REF_ARF;
00196 #else
00197       // 0=L, 1=GF, Intra-layer prediction disabled.
00198       layer_flags[0] = VPX_EFLAG_FORCE_KF | VP8_EFLAG_NO_UPD_GF |
00199                        VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_REF_GF |
00200                        VP8_EFLAG_NO_REF_ARF;
00201       layer_flags[1] = VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST |
00202                        VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_REF_LAST;
00203 #endif
00204       break;
00205     }
00206     case 2: {
00207       // 2-layers, 3-frame period.
00208       int ids[3] = { 0, 1, 1 };
00209       cfg->ts_periodicity = 3;
00210       *flag_periodicity = 3;
00211       cfg->ts_number_layers = 2;
00212       cfg->ts_rate_decimator[0] = 3;
00213       cfg->ts_rate_decimator[1] = 1;
00214       memcpy(cfg->ts_layer_id, ids, sizeof(ids));
00215       // 0=L, 1=GF, Intra-layer prediction enabled.
00216       layer_flags[0] = VPX_EFLAG_FORCE_KF | VP8_EFLAG_NO_REF_GF |
00217                        VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_UPD_GF |
00218                        VP8_EFLAG_NO_UPD_ARF;
00219       layer_flags[1] = layer_flags[2] =
00220           VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_UPD_ARF |
00221           VP8_EFLAG_NO_UPD_LAST;
00222       break;
00223     }
00224     case 3: {
00225       // 3-layers, 6-frame period.
00226       int ids[6] = { 0, 2, 2, 1, 2, 2 };
00227       cfg->ts_periodicity = 6;
00228       *flag_periodicity = 6;
00229       cfg->ts_number_layers = 3;
00230       cfg->ts_rate_decimator[0] = 6;
00231       cfg->ts_rate_decimator[1] = 3;
00232       cfg->ts_rate_decimator[2] = 1;
00233       memcpy(cfg->ts_layer_id, ids, sizeof(ids));
00234       // 0=L, 1=GF, 2=ARF, Intra-layer prediction enabled.
00235       layer_flags[0] = VPX_EFLAG_FORCE_KF | VP8_EFLAG_NO_REF_GF |
00236                        VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_UPD_GF |
00237                        VP8_EFLAG_NO_UPD_ARF;
00238       layer_flags[3] =
00239           VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST;
00240       layer_flags[1] = layer_flags[2] = layer_flags[4] = layer_flags[5] =
00241           VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_LAST;
00242       break;
00243     }
00244     case 4: {
00245       // 3-layers, 4-frame period.
00246       int ids[4] = { 0, 2, 1, 2 };
00247       cfg->ts_periodicity = 4;
00248       *flag_periodicity = 4;
00249       cfg->ts_number_layers = 3;
00250       cfg->ts_rate_decimator[0] = 4;
00251       cfg->ts_rate_decimator[1] = 2;
00252       cfg->ts_rate_decimator[2] = 1;
00253       memcpy(cfg->ts_layer_id, ids, sizeof(ids));
00254       // 0=L, 1=GF, 2=ARF, Intra-layer prediction disabled.
00255       layer_flags[0] = VPX_EFLAG_FORCE_KF | VP8_EFLAG_NO_REF_GF |
00256                        VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_UPD_GF |
00257                        VP8_EFLAG_NO_UPD_ARF;
00258       layer_flags[2] = VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF |
00259                        VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST;
00260       layer_flags[1] = layer_flags[3] =
00261           VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF |
00262           VP8_EFLAG_NO_UPD_ARF;
00263       break;
00264     }
00265     case 5: {
00266       // 3-layers, 4-frame period.
00267       int ids[4] = { 0, 2, 1, 2 };
00268       cfg->ts_periodicity = 4;
00269       *flag_periodicity = 4;
00270       cfg->ts_number_layers = 3;
00271       cfg->ts_rate_decimator[0] = 4;
00272       cfg->ts_rate_decimator[1] = 2;
00273       cfg->ts_rate_decimator[2] = 1;
00274       memcpy(cfg->ts_layer_id, ids, sizeof(ids));
00275       // 0=L, 1=GF, 2=ARF, Intra-layer prediction enabled in layer 1, disabled
00276       // in layer 2.
00277       layer_flags[0] = VPX_EFLAG_FORCE_KF | VP8_EFLAG_NO_REF_GF |
00278                        VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_UPD_GF |
00279                        VP8_EFLAG_NO_UPD_ARF;
00280       layer_flags[2] =
00281           VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_ARF;
00282       layer_flags[1] = layer_flags[3] =
00283           VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF |
00284           VP8_EFLAG_NO_UPD_ARF;
00285       break;
00286     }
00287     case 6: {
00288       // 3-layers, 4-frame period.
00289       int ids[4] = { 0, 2, 1, 2 };
00290       cfg->ts_periodicity = 4;
00291       *flag_periodicity = 4;
00292       cfg->ts_number_layers = 3;
00293       cfg->ts_rate_decimator[0] = 4;
00294       cfg->ts_rate_decimator[1] = 2;
00295       cfg->ts_rate_decimator[2] = 1;
00296       memcpy(cfg->ts_layer_id, ids, sizeof(ids));
00297       // 0=L, 1=GF, 2=ARF, Intra-layer prediction enabled.
00298       layer_flags[0] = VPX_EFLAG_FORCE_KF | VP8_EFLAG_NO_REF_GF |
00299                        VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_UPD_GF |
00300                        VP8_EFLAG_NO_UPD_ARF;
00301       layer_flags[2] =
00302           VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_ARF;
00303       layer_flags[1] = layer_flags[3] =
00304           VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF;
00305       break;
00306     }
00307     case 7: {
00308       // NOTE: Probably of academic interest only.
00309       // 5-layers, 16-frame period.
00310       int ids[16] = { 0, 4, 3, 4, 2, 4, 3, 4, 1, 4, 3, 4, 2, 4, 3, 4 };
00311       cfg->ts_periodicity = 16;
00312       *flag_periodicity = 16;
00313       cfg->ts_number_layers = 5;
00314       cfg->ts_rate_decimator[0] = 16;
00315       cfg->ts_rate_decimator[1] = 8;
00316       cfg->ts_rate_decimator[2] = 4;
00317       cfg->ts_rate_decimator[3] = 2;
00318       cfg->ts_rate_decimator[4] = 1;
00319       memcpy(cfg->ts_layer_id, ids, sizeof(ids));
00320       layer_flags[0] = VPX_EFLAG_FORCE_KF;
00321       layer_flags[1] = layer_flags[3] = layer_flags[5] = layer_flags[7] =
00322           layer_flags[9] = layer_flags[11] = layer_flags[13] = layer_flags[15] =
00323               VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF |
00324               VP8_EFLAG_NO_UPD_ARF;
00325       layer_flags[2] = layer_flags[6] = layer_flags[10] = layer_flags[14] =
00326           VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_GF;
00327       layer_flags[4] = layer_flags[12] =
00328           VP8_EFLAG_NO_REF_LAST | VP8_EFLAG_NO_UPD_ARF;
00329       layer_flags[8] = VP8_EFLAG_NO_REF_LAST | VP8_EFLAG_NO_REF_GF;
00330       break;
00331     }
00332     case 8: {
00333       // 2-layers, with sync point at first frame of layer 1.
00334       int ids[2] = { 0, 1 };
00335       cfg->ts_periodicity = 2;
00336       *flag_periodicity = 8;
00337       cfg->ts_number_layers = 2;
00338       cfg->ts_rate_decimator[0] = 2;
00339       cfg->ts_rate_decimator[1] = 1;
00340       memcpy(cfg->ts_layer_id, ids, sizeof(ids));
00341       // 0=L, 1=GF.
00342       // ARF is used as predictor for all frames, and is only updated on
00343       // key frame. Sync point every 8 frames.
00344 
00345       // Layer 0: predict from L and ARF, update L and G.
00346       layer_flags[0] =
00347           VPX_EFLAG_FORCE_KF | VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_UPD_ARF;
00348       // Layer 1: sync point: predict from L and ARF, and update G.
00349       layer_flags[1] =
00350           VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_ARF;
00351       // Layer 0, predict from L and ARF, update L.
00352       layer_flags[2] =
00353           VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF;
00354       // Layer 1: predict from L, G and ARF, and update G.
00355       layer_flags[3] = VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST |
00356                        VP8_EFLAG_NO_UPD_ENTROPY;
00357       // Layer 0.
00358       layer_flags[4] = layer_flags[2];
00359       // Layer 1.
00360       layer_flags[5] = layer_flags[3];
00361       // Layer 0.
00362       layer_flags[6] = layer_flags[4];
00363       // Layer 1.
00364       layer_flags[7] = layer_flags[5];
00365       break;
00366     }
00367     case 9: {
00368       // 3-layers: Sync points for layer 1 and 2 every 8 frames.
00369       int ids[4] = { 0, 2, 1, 2 };
00370       cfg->ts_periodicity = 4;
00371       *flag_periodicity = 8;
00372       cfg->ts_number_layers = 3;
00373       cfg->ts_rate_decimator[0] = 4;
00374       cfg->ts_rate_decimator[1] = 2;
00375       cfg->ts_rate_decimator[2] = 1;
00376       memcpy(cfg->ts_layer_id, ids, sizeof(ids));
00377       // 0=L, 1=GF, 2=ARF.
00378       layer_flags[0] = VPX_EFLAG_FORCE_KF | VP8_EFLAG_NO_REF_GF |
00379                        VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_UPD_GF |
00380                        VP8_EFLAG_NO_UPD_ARF;
00381       layer_flags[1] = VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF |
00382                        VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF;
00383       layer_flags[2] = VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF |
00384                        VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_ARF;
00385       layer_flags[3] = layer_flags[5] =
00386           VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF;
00387       layer_flags[4] = VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF |
00388                        VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF;
00389       layer_flags[6] =
00390           VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_ARF;
00391       layer_flags[7] = VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF |
00392                        VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_ENTROPY;
00393       break;
00394     }
00395     case 10: {
00396       // 3-layers structure where ARF is used as predictor for all frames,
00397       // and is only updated on key frame.
00398       // Sync points for layer 1 and 2 every 8 frames.
00399 
00400       int ids[4] = { 0, 2, 1, 2 };
00401       cfg->ts_periodicity = 4;
00402       *flag_periodicity = 8;
00403       cfg->ts_number_layers = 3;
00404       cfg->ts_rate_decimator[0] = 4;
00405       cfg->ts_rate_decimator[1] = 2;
00406       cfg->ts_rate_decimator[2] = 1;
00407       memcpy(cfg->ts_layer_id, ids, sizeof(ids));
00408       // 0=L, 1=GF, 2=ARF.
00409       // Layer 0: predict from L and ARF; update L and G.
00410       layer_flags[0] =
00411           VPX_EFLAG_FORCE_KF | VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_REF_GF;
00412       // Layer 2: sync point: predict from L and ARF; update none.
00413       layer_flags[1] = VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_UPD_GF |
00414                        VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST |
00415                        VP8_EFLAG_NO_UPD_ENTROPY;
00416       // Layer 1: sync point: predict from L and ARF; update G.
00417       layer_flags[2] =
00418           VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST;
00419       // Layer 2: predict from L, G, ARF; update none.
00420       layer_flags[3] = VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF |
00421                        VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_ENTROPY;
00422       // Layer 0: predict from L and ARF; update L.
00423       layer_flags[4] =
00424           VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_REF_GF;
00425       // Layer 2: predict from L, G, ARF; update none.
00426       layer_flags[5] = layer_flags[3];
00427       // Layer 1: predict from L, G, ARF; update G.
00428       layer_flags[6] = VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST;
00429       // Layer 2: predict from L, G, ARF; update none.
00430       layer_flags[7] = layer_flags[3];
00431       break;
00432     }
00433     case 11: {
00434       // 3-layers structure with one reference frame.
00435       // This works same as temporal_layering_mode 3.
00436       // This was added to compare with vp9_spatial_svc_encoder.
00437 
00438       // 3-layers, 4-frame period.
00439       int ids[4] = { 0, 2, 1, 2 };
00440       cfg->ts_periodicity = 4;
00441       *flag_periodicity = 4;
00442       cfg->ts_number_layers = 3;
00443       cfg->ts_rate_decimator[0] = 4;
00444       cfg->ts_rate_decimator[1] = 2;
00445       cfg->ts_rate_decimator[2] = 1;
00446       memcpy(cfg->ts_layer_id, ids, sizeof(ids));
00447       // 0=L, 1=GF, 2=ARF, Intra-layer prediction disabled.
00448       layer_flags[0] = VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF |
00449                        VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF;
00450       layer_flags[2] = VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF |
00451                        VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST;
00452       layer_flags[1] = VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF |
00453                        VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF;
00454       layer_flags[3] = VP8_EFLAG_NO_REF_LAST | VP8_EFLAG_NO_REF_ARF |
00455                        VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF;
00456       break;
00457     }
00458     case 12:
00459     default: {
00460       // 3-layers structure as in case 10, but no sync/refresh points for
00461       // layer 1 and 2.
00462       int ids[4] = { 0, 2, 1, 2 };
00463       cfg->ts_periodicity = 4;
00464       *flag_periodicity = 8;
00465       cfg->ts_number_layers = 3;
00466       cfg->ts_rate_decimator[0] = 4;
00467       cfg->ts_rate_decimator[1] = 2;
00468       cfg->ts_rate_decimator[2] = 1;
00469       memcpy(cfg->ts_layer_id, ids, sizeof(ids));
00470       // 0=L, 1=GF, 2=ARF.
00471       // Layer 0: predict from L and ARF; update L.
00472       layer_flags[0] =
00473           VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_REF_GF;
00474       layer_flags[4] = layer_flags[0];
00475       // Layer 1: predict from L, G, ARF; update G.
00476       layer_flags[2] = VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST;
00477       layer_flags[6] = layer_flags[2];
00478       // Layer 2: predict from L, G, ARF; update none.
00479       layer_flags[1] = VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF |
00480                        VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_ENTROPY;
00481       layer_flags[3] = layer_flags[1];
00482       layer_flags[5] = layer_flags[1];
00483       layer_flags[7] = layer_flags[1];
00484       break;
00485     }
00486   }
00487 }
00488 
00489 int main(int argc, char **argv) {
00490   VpxVideoWriter *outfile[VPX_TS_MAX_LAYERS] = { NULL };
00491   vpx_codec_ctx_t codec;
00492   vpx_codec_enc_cfg_t cfg;
00493   int frame_cnt = 0;
00494   vpx_image_t raw;
00495   vpx_codec_err_t res;
00496   unsigned int width;
00497   unsigned int height;
00498   int speed;
00499   int frame_avail;
00500   int got_data;
00501   int flags = 0;
00502   unsigned int i;
00503   int pts = 0;             // PTS starts at 0.
00504   int frame_duration = 1;  // 1 timebase tick per frame.
00505   int layering_mode = 0;
00506   int layer_flags[VPX_TS_MAX_PERIODICITY] = { 0 };
00507   int flag_periodicity = 1;
00508 #if VPX_ENCODER_ABI_VERSION > (4 + VPX_CODEC_ABI_VERSION)
00509   vpx_svc_layer_id_t layer_id = { 0, 0 };
00510 #else
00511   vpx_svc_layer_id_t layer_id = { 0 };
00512 #endif
00513   const VpxInterface *encoder = NULL;
00514   FILE *infile = NULL;
00515   struct RateControlMetrics rc;
00516   int64_t cx_time = 0;
00517   const int min_args_base = 12;
00518 #if CONFIG_VP9_HIGHBITDEPTH
00519   vpx_bit_depth_t bit_depth = VPX_BITS_8;
00520   int input_bit_depth = 8;
00521   const int min_args = min_args_base + 1;
00522 #else
00523   const int min_args = min_args_base;
00524 #endif  // CONFIG_VP9_HIGHBITDEPTH
00525   double sum_bitrate = 0.0;
00526   double sum_bitrate2 = 0.0;
00527   double framerate = 30.0;
00528 
00529   exec_name = argv[0];
00530   // Check usage and arguments.
00531   if (argc < min_args) {
00532 #if CONFIG_VP9_HIGHBITDEPTH
00533     die("Usage: %s <infile> <outfile> <codec_type(vp8/vp9)> <width> <height> "
00534         "<rate_num> <rate_den> <speed> <frame_drop_threshold> <threads> <mode> "
00535         "<Rate_0> ... <Rate_nlayers-1> <bit-depth> \n",
00536         argv[0]);
00537 #else
00538     die("Usage: %s <infile> <outfile> <codec_type(vp8/vp9)> <width> <height> "
00539         "<rate_num> <rate_den> <speed> <frame_drop_threshold> <threads> <mode> "
00540         "<Rate_0> ... <Rate_nlayers-1> \n",
00541         argv[0]);
00542 #endif  // CONFIG_VP9_HIGHBITDEPTH
00543   }
00544 
00545   encoder = get_vpx_encoder_by_name(argv[3]);
00546   if (!encoder) die("Unsupported codec.");
00547 
00548   printf("Using %s\n", vpx_codec_iface_name(encoder->codec_interface()));
00549 
00550   width = (unsigned int)strtoul(argv[4], NULL, 0);
00551   height = (unsigned int)strtoul(argv[5], NULL, 0);
00552   if (width < 16 || width % 2 || height < 16 || height % 2) {
00553     die("Invalid resolution: %d x %d", width, height);
00554   }
00555 
00556   layering_mode = (int)strtol(argv[11], NULL, 0);
00557   if (layering_mode < 0 || layering_mode > 13) {
00558     die("Invalid layering mode (0..12) %s", argv[11]);
00559   }
00560 
00561   if (argc != min_args + mode_to_num_layers[layering_mode]) {
00562     die("Invalid number of arguments");
00563   }
00564 
00565 #if CONFIG_VP9_HIGHBITDEPTH
00566   switch (strtol(argv[argc - 1], NULL, 0)) {
00567     case 8:
00568       bit_depth = VPX_BITS_8;
00569       input_bit_depth = 8;
00570       break;
00571     case 10:
00572       bit_depth = VPX_BITS_10;
00573       input_bit_depth = 10;
00574       break;
00575     case 12:
00576       bit_depth = VPX_BITS_12;
00577       input_bit_depth = 12;
00578       break;
00579     default: die("Invalid bit depth (8, 10, 12) %s", argv[argc - 1]);
00580   }
00581   if (!vpx_img_alloc(
00582           &raw, bit_depth == VPX_BITS_8 ? VPX_IMG_FMT_I420 : VPX_IMG_FMT_I42016,
00583           width, height, 32)) {
00584     die("Failed to allocate image", width, height);
00585   }
00586 #else
00587   if (!vpx_img_alloc(&raw, VPX_IMG_FMT_I420, width, height, 32)) {
00588     die("Failed to allocate image", width, height);
00589   }
00590 #endif  // CONFIG_VP9_HIGHBITDEPTH
00591 
00592   // Populate encoder configuration.
00593   res = vpx_codec_enc_config_default(encoder->codec_interface(), &cfg, 0);
00594   if (res) {
00595     printf("Failed to get config: %s\n", vpx_codec_err_to_string(res));
00596     return EXIT_FAILURE;
00597   }
00598 
00599   // Update the default configuration with our settings.
00600   cfg.g_w = width;
00601   cfg.g_h = height;
00602 
00603 #if CONFIG_VP9_HIGHBITDEPTH
00604   if (bit_depth != VPX_BITS_8) {
00605     cfg.g_bit_depth = bit_depth;
00606     cfg.g_input_bit_depth = input_bit_depth;
00607     cfg.g_profile = 2;
00608   }
00609 #endif  // CONFIG_VP9_HIGHBITDEPTH
00610 
00611   // Timebase format e.g. 30fps: numerator=1, demoninator = 30.
00612   cfg.g_timebase.num = (int)strtol(argv[6], NULL, 0);
00613   cfg.g_timebase.den = (int)strtol(argv[7], NULL, 0);
00614 
00615   speed = (int)strtol(argv[8], NULL, 0);
00616   if (speed < 0) {
00617     die("Invalid speed setting: must be positive");
00618   }
00619 
00620   for (i = min_args_base;
00621        (int)i < min_args_base + mode_to_num_layers[layering_mode]; ++i) {
00622     rc.layer_target_bitrate[i - 12] = (int)strtol(argv[i], NULL, 0);
00623     if (strncmp(encoder->name, "vp8", 3) == 0)
00624       cfg.ts_target_bitrate[i - 12] = rc.layer_target_bitrate[i - 12];
00625     else if (strncmp(encoder->name, "vp9", 3) == 0)
00626       cfg.layer_target_bitrate[i - 12] = rc.layer_target_bitrate[i - 12];
00627   }
00628 
00629   // Real time parameters.
00630   cfg.rc_dropframe_thresh = (unsigned int)strtoul(argv[9], NULL, 0);
00631   cfg.rc_end_usage = VPX_CBR;
00632   cfg.rc_min_quantizer = 2;
00633   cfg.rc_max_quantizer = 56;
00634   if (strncmp(encoder->name, "vp9", 3) == 0) cfg.rc_max_quantizer = 52;
00635   cfg.rc_undershoot_pct = 50;
00636   cfg.rc_overshoot_pct = 50;
00637   cfg.rc_buf_initial_sz = 500;
00638   cfg.rc_buf_optimal_sz = 600;
00639   cfg.rc_buf_sz = 1000;
00640 
00641   // Disable dynamic resizing by default.
00642   cfg.rc_resize_allowed = 0;
00643 
00644   // Use 1 thread as default.
00645   cfg.g_threads = (unsigned int)strtoul(argv[10], NULL, 0);
00646 
00647   // Enable error resilient mode.
00648   cfg.g_error_resilient = 1;
00649   cfg.g_lag_in_frames = 0;
00650   cfg.kf_mode = VPX_KF_AUTO;
00651 
00652   // Disable automatic keyframe placement.
00653   cfg.kf_min_dist = cfg.kf_max_dist = 3000;
00654 
00655   cfg.temporal_layering_mode = VP9E_TEMPORAL_LAYERING_MODE_BYPASS;
00656 
00657   set_temporal_layer_pattern(layering_mode, &cfg, layer_flags,
00658                              &flag_periodicity);
00659 
00660   set_rate_control_metrics(&rc, &cfg);
00661 
00662   // Target bandwidth for the whole stream.
00663   // Set to layer_target_bitrate for highest layer (total bitrate).
00664   cfg.rc_target_bitrate = rc.layer_target_bitrate[cfg.ts_number_layers - 1];
00665 
00666   // Open input file.
00667   if (!(infile = fopen(argv[1], "rb"))) {
00668     die("Failed to open %s for reading", argv[1]);
00669   }
00670 
00671   framerate = cfg.g_timebase.den / cfg.g_timebase.num;
00672   // Open an output file for each stream.
00673   for (i = 0; i < cfg.ts_number_layers; ++i) {
00674     char file_name[PATH_MAX];
00675     VpxVideoInfo info;
00676     info.codec_fourcc = encoder->fourcc;
00677     info.frame_width = cfg.g_w;
00678     info.frame_height = cfg.g_h;
00679     info.time_base.numerator = cfg.g_timebase.num;
00680     info.time_base.denominator = cfg.g_timebase.den;
00681 
00682     snprintf(file_name, sizeof(file_name), "%s_%d.ivf", argv[2], i);
00683     outfile[i] = vpx_video_writer_open(file_name, kContainerIVF, &info);
00684     if (!outfile[i]) die("Failed to open %s for writing", file_name);
00685 
00686     assert(outfile[i] != NULL);
00687   }
00688   // No spatial layers in this encoder.
00689   cfg.ss_number_layers = 1;
00690 
00691 // Initialize codec.
00692 #if CONFIG_VP9_HIGHBITDEPTH
00693   if (vpx_codec_enc_init(
00694           &codec, encoder->codec_interface(), &cfg,
00695           bit_depth == VPX_BITS_8 ? 0 : VPX_CODEC_USE_HIGHBITDEPTH))
00696 #else
00697   if (vpx_codec_enc_init(&codec, encoder->codec_interface(), &cfg, 0))
00698 #endif  // CONFIG_VP9_HIGHBITDEPTH
00699     die_codec(&codec, "Failed to initialize encoder");
00700 
00701   if (strncmp(encoder->name, "vp8", 3) == 0) {
00702     vpx_codec_control(&codec, VP8E_SET_CPUUSED, -speed);
00703     vpx_codec_control(&codec, VP8E_SET_NOISE_SENSITIVITY, kDenoiserOff);
00704     vpx_codec_control(&codec, VP8E_SET_STATIC_THRESHOLD, 1);
00705     vpx_codec_control(&codec, VP8E_SET_GF_CBR_BOOST_PCT, 0);
00706   } else if (strncmp(encoder->name, "vp9", 3) == 0) {
00707     vpx_svc_extra_cfg_t svc_params;
00708     memset(&svc_params, 0, sizeof(svc_params));
00709     vpx_codec_control(&codec, VP8E_SET_CPUUSED, speed);
00710     vpx_codec_control(&codec, VP9E_SET_AQ_MODE, 3);
00711     vpx_codec_control(&codec, VP9E_SET_GF_CBR_BOOST_PCT, 0);
00712     vpx_codec_control(&codec, VP9E_SET_FRAME_PARALLEL_DECODING, 0);
00713     vpx_codec_control(&codec, VP9E_SET_FRAME_PERIODIC_BOOST, 0);
00714     vpx_codec_control(&codec, VP9E_SET_NOISE_SENSITIVITY, kDenoiserOff);
00715     vpx_codec_control(&codec, VP8E_SET_STATIC_THRESHOLD, 1);
00716     vpx_codec_control(&codec, VP9E_SET_TUNE_CONTENT, 0);
00717     vpx_codec_control(&codec, VP9E_SET_TILE_COLUMNS, (cfg.g_threads >> 1));
00718     if (vpx_codec_control(&codec, VP9E_SET_SVC, layering_mode > 0 ? 1 : 0))
00719       die_codec(&codec, "Failed to set SVC");
00720     for (i = 0; i < cfg.ts_number_layers; ++i) {
00721       svc_params.max_quantizers[i] = cfg.rc_max_quantizer;
00722       svc_params.min_quantizers[i] = cfg.rc_min_quantizer;
00723     }
00724     svc_params.scaling_factor_num[0] = cfg.g_h;
00725     svc_params.scaling_factor_den[0] = cfg.g_h;
00726     vpx_codec_control(&codec, VP9E_SET_SVC_PARAMETERS, &svc_params);
00727   }
00728   if (strncmp(encoder->name, "vp8", 3) == 0) {
00729     vpx_codec_control(&codec, VP8E_SET_SCREEN_CONTENT_MODE, 0);
00730   }
00731   vpx_codec_control(&codec, VP8E_SET_TOKEN_PARTITIONS, 1);
00732   // This controls the maximum target size of the key frame.
00733   // For generating smaller key frames, use a smaller max_intra_size_pct
00734   // value, like 100 or 200.
00735   {
00736     const int max_intra_size_pct = 900;
00737     vpx_codec_control(&codec, VP8E_SET_MAX_INTRA_BITRATE_PCT,
00738                       max_intra_size_pct);
00739   }
00740 
00741   frame_avail = 1;
00742   while (frame_avail || got_data) {
00743     struct vpx_usec_timer timer;
00744     vpx_codec_iter_t iter = NULL;
00745     const vpx_codec_cx_pkt_t *pkt;
00746 #if VPX_ENCODER_ABI_VERSION > (4 + VPX_CODEC_ABI_VERSION)
00747     // Update the temporal layer_id. No spatial layers in this test.
00748     layer_id.spatial_layer_id = 0;
00749 #endif
00750     layer_id.temporal_layer_id =
00751         cfg.ts_layer_id[frame_cnt % cfg.ts_periodicity];
00752     if (strncmp(encoder->name, "vp9", 3) == 0) {
00753       vpx_codec_control(&codec, VP9E_SET_SVC_LAYER_ID, &layer_id);
00754     } else if (strncmp(encoder->name, "vp8", 3) == 0) {
00755       vpx_codec_control(&codec, VP8E_SET_TEMPORAL_LAYER_ID,
00756                         layer_id.temporal_layer_id);
00757     }
00758     flags = layer_flags[frame_cnt % flag_periodicity];
00759     if (layering_mode == 0) flags = 0;
00760     frame_avail = vpx_img_read(&raw, infile);
00761     if (frame_avail) ++rc.layer_input_frames[layer_id.temporal_layer_id];
00762     vpx_usec_timer_start(&timer);
00763     if (vpx_codec_encode(&codec, frame_avail ? &raw : NULL, pts, 1, flags,
00764                          VPX_DL_REALTIME)) {
00765       die_codec(&codec, "Failed to encode frame");
00766     }
00767     vpx_usec_timer_mark(&timer);
00768     cx_time += vpx_usec_timer_elapsed(&timer);
00769     // Reset KF flag.
00770     if (layering_mode != 7) {
00771       layer_flags[0] &= ~VPX_EFLAG_FORCE_KF;
00772     }
00773     got_data = 0;
00774     while ((pkt = vpx_codec_get_cx_data(&codec, &iter))) {
00775       got_data = 1;
00776       switch (pkt->kind) {
00777         case VPX_CODEC_CX_FRAME_PKT:
00778           for (i = cfg.ts_layer_id[frame_cnt % cfg.ts_periodicity];
00779                i < cfg.ts_number_layers; ++i) {
00780             vpx_video_writer_write_frame(outfile[i], pkt->data.frame.buf,
00781                                          pkt->data.frame.sz, pts);
00782             ++rc.layer_tot_enc_frames[i];
00783             rc.layer_encoding_bitrate[i] += 8.0 * pkt->data.frame.sz;
00784             // Keep count of rate control stats per layer (for non-key frames).
00785             if (i == cfg.ts_layer_id[frame_cnt % cfg.ts_periodicity] &&
00786                 !(pkt->data.frame.flags & VPX_FRAME_IS_KEY)) {
00787               rc.layer_avg_frame_size[i] += 8.0 * pkt->data.frame.sz;
00788               rc.layer_avg_rate_mismatch[i] +=
00789                   fabs(8.0 * pkt->data.frame.sz - rc.layer_pfb[i]) /
00790                   rc.layer_pfb[i];
00791               ++rc.layer_enc_frames[i];
00792             }
00793           }
00794           // Update for short-time encoding bitrate states, for moving window
00795           // of size rc->window, shifted by rc->window / 2.
00796           // Ignore first window segment, due to key frame.
00797           if (frame_cnt > rc.window_size) {
00798             sum_bitrate += 0.001 * 8.0 * pkt->data.frame.sz * framerate;
00799             if (frame_cnt % rc.window_size == 0) {
00800               rc.window_count += 1;
00801               rc.avg_st_encoding_bitrate += sum_bitrate / rc.window_size;
00802               rc.variance_st_encoding_bitrate +=
00803                   (sum_bitrate / rc.window_size) *
00804                   (sum_bitrate / rc.window_size);
00805               sum_bitrate = 0.0;
00806             }
00807           }
00808           // Second shifted window.
00809           if (frame_cnt > rc.window_size + rc.window_size / 2) {
00810             sum_bitrate2 += 0.001 * 8.0 * pkt->data.frame.sz * framerate;
00811             if (frame_cnt > 2 * rc.window_size &&
00812                 frame_cnt % rc.window_size == 0) {
00813               rc.window_count += 1;
00814               rc.avg_st_encoding_bitrate += sum_bitrate2 / rc.window_size;
00815               rc.variance_st_encoding_bitrate +=
00816                   (sum_bitrate2 / rc.window_size) *
00817                   (sum_bitrate2 / rc.window_size);
00818               sum_bitrate2 = 0.0;
00819             }
00820           }
00821           break;
00822         default: break;
00823       }
00824     }
00825     ++frame_cnt;
00826     pts += frame_duration;
00827   }
00828   fclose(infile);
00829   printout_rate_control_summary(&rc, &cfg, frame_cnt);
00830   printf("\n");
00831   printf("Frame cnt and encoding time/FPS stats for encoding: %d %f %f \n",
00832          frame_cnt, 1000 * (float)cx_time / (double)(frame_cnt * 1000000),
00833          1000000 * (double)frame_cnt / (double)cx_time);
00834 
00835   if (vpx_codec_destroy(&codec)) die_codec(&codec, "Failed to destroy codec");
00836 
00837   // Try to rewrite the output file headers with the actual frame count.
00838   for (i = 0; i < cfg.ts_number_layers; ++i) vpx_video_writer_close(outfile[i]);
00839 
00840   vpx_img_free(&raw);
00841   return EXIT_SUCCESS;
00842 }

Generated on 16 Jun 2017 for WebM Codec SDK by  doxygen 1.6.1