test/svc_end_to_end_test.cc

   1 /*
   2  *  Copyright (c) 2018 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 #include "./vpx_config.h"
  11 #include "third_party/googletest/src/include/gtest/gtest.h"
  12 #include "test/codec_factory.h"
  13 #include "test/encode_test_driver.h"
  14 #include "test/i420_video_source.h"
  15 #include "test/svc_test.h"
  16 #include "test/util.h"
  17 #include "test/y4m_video_source.h"
  18 #include "vp9/common/vp9_onyxc_int.h"
  19 #include "vpx/vpx_codec.h"
  20 #include "vpx_ports/bitops.h"
  21
  22 namespace svc_test {
  23 namespace {
  24
  25 typedef enum {
  26   // Inter-layer prediction is on on all frames.
  27   INTER_LAYER_PRED_ON,
  28   // Inter-layer prediction is off on all frames.
  29   INTER_LAYER_PRED_OFF,
  30   // Inter-layer prediction is off on non-key frames and non-sync frames.
  31   INTER_LAYER_PRED_OFF_NONKEY,
  32   // Inter-layer prediction is on on all frames, but constrained such
  33   // that any layer S (> 0) can only predict from previous spatial
  34   // layer S-1, from the same superframe.
  35   INTER_LAYER_PRED_ON_CONSTRAINED
  36 } INTER_LAYER_PRED;
  37
  38 class ScalePartitionOnePassCbrSvc
  39     : public OnePassCbrSvc,
  40       public ::testing::TestWithParam<const ::libvpx_test::CodecFactory *> {
  41  public:
  42   ScalePartitionOnePassCbrSvc()
  43       : OnePassCbrSvc(GetParam()), mismatch_nframes_(0), num_nonref_frames_(0) {
  44     SetMode(::libvpx_test::kRealTime);
  45   }
  46
  47  protected:
  48   virtual ~ScalePartitionOnePassCbrSvc() {}
  49
  50   virtual void SetUp() {
  51     InitializeConfig();
  52     speed_setting_ = 7;
  53   }
  54
  55   virtual void PreEncodeFrameHook(::libvpx_test::VideoSource *video,
  56                                   ::libvpx_test::Encoder *encoder) {
  57     PreEncodeFrameHookSetup(video, encoder);
  58   }
  59
  60   virtual void FramePktHook(const vpx_codec_cx_pkt_t *pkt) {
  61     // Keep track of number of non-reference frames, needed for mismatch check.
  62     // Non-reference frames are top spatial and temporal layer frames,
  63     // for TL > 0.
  64     if (temporal_layer_id_ == number_temporal_layers_ - 1 &&
  65         temporal_layer_id_ > 0 &&
  66         pkt->data.frame.spatial_layer_encoded[number_spatial_layers_ - 1])
  67       num_nonref_frames_++;
  68   }
  69
  70   virtual void MismatchHook(const vpx_image_t * /*img1*/,
  71                             const vpx_image_t * /*img2*/) {
  72     ++mismatch_nframes_;
  73   }
  74
  75   virtual void SetConfig(const int /*num_temporal_layer*/) {}
  76
  77   unsigned int GetMismatchFrames() const { return mismatch_nframes_; }
  78   unsigned int GetNonRefFrames() const { return num_nonref_frames_; }
  79
  80  private:
  81   unsigned int mismatch_nframes_;
  82   unsigned int num_nonref_frames_;
  83 };
  84
  85 TEST_P(ScalePartitionOnePassCbrSvc, OnePassCbrSvc3SL3TL1080P) {
  86   SetSvcConfig(3, 3);
  87   cfg_.rc_buf_initial_sz = 500;
  88   cfg_.rc_buf_optimal_sz = 500;
  89   cfg_.rc_buf_sz = 1000;
  90   cfg_.rc_min_quantizer = 0;
  91   cfg_.rc_max_quantizer = 63;
  92   cfg_.g_threads = 1;
  93   cfg_.rc_dropframe_thresh = 10;
  94   cfg_.rc_target_bitrate = 800;
  95   cfg_.kf_max_dist = 9999;
  96   cfg_.rc_end_usage = VPX_CBR;
  97   cfg_.g_lag_in_frames = 0;
  98   cfg_.g_error_resilient = 1;
  99   cfg_.ts_rate_decimator[0] = 4;
 100   cfg_.ts_rate_decimator[1] = 2;
 101   cfg_.ts_rate_decimator[2] = 1;
 102   cfg_.temporal_layering_mode = 3;
 103   ::libvpx_test::I420VideoSource video(
 104       "slides_code_term_web_plot.1920_1080.yuv", 1920, 1080, 30, 1, 0, 100);
 105   // For this 3 temporal layer case, pattern repeats every 4 frames, so choose
 106   // 4 key neighboring key frame periods (so key frame will land on 0-2-1-2).
 107   AssignLayerBitrates();
 108   ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
 109 #if CONFIG_VP9_DECODER
 110   // The non-reference frames are expected to be mismatched frames as the
 111   // encoder will avoid loopfilter on these frames.
 112   EXPECT_EQ(GetNonRefFrames(), GetMismatchFrames());
 113 #endif
 114 }
 115
 116 // Params: Inter layer prediction modes.
 117 class SyncFrameOnePassCbrSvc : public OnePassCbrSvc,
 118                                public ::libvpx_test::CodecTestWithParam<int> {
 119  public:
 120   SyncFrameOnePassCbrSvc()
 121       : OnePassCbrSvc(GET_PARAM(0)), current_video_frame_(0),
 122         frame_to_start_decode_(0), frame_to_sync_(0),
 123         inter_layer_pred_mode_(GET_PARAM(1)), decode_to_layer_before_sync_(-1),
 124         decode_to_layer_after_sync_(-1), denoiser_on_(0),
 125         intra_only_test_(false), loopfilter_off_(0), mismatch_nframes_(0),
 126         num_nonref_frames_(0) {
 127     SetMode(::libvpx_test::kRealTime);
 128     memset(&svc_layer_sync_, 0, sizeof(svc_layer_sync_));
 129   }
 130
 131  protected:
 132   virtual ~SyncFrameOnePassCbrSvc() {}
 133
 134   virtual void SetUp() {
 135     InitializeConfig();
 136     speed_setting_ = 7;
 137   }
 138
 139   virtual bool DoDecode() const {
 140     return current_video_frame_ >= frame_to_start_decode_;
 141   }
 142
 143   // Example pattern for spatial layers and 2 temporal layers used in the
 144   // bypass/flexible mode. The pattern corresponds to the pattern
 145   // VP9E_TEMPORAL_LAYERING_MODE_0101 (temporal_layering_mode == 2) used in
 146   // non-flexible mode.
 147   void set_frame_flags_bypass_mode(
 148       int tl, int num_spatial_layers, int is_key_frame,
 149       vpx_svc_ref_frame_config_t *ref_frame_config) {
 150     int sl;
 151     for (sl = 0; sl < num_spatial_layers; ++sl)
 152       ref_frame_config->update_buffer_slot[sl] = 0;
 153
 154     for (sl = 0; sl < num_spatial_layers; ++sl) {
 155       // Set the buffer idx.
 156       if (tl == 0) {
 157         ref_frame_config->lst_fb_idx[sl] = sl;
 158         if (sl) {
 159           if (is_key_frame) {
 160             ref_frame_config->lst_fb_idx[sl] = sl - 1;
 161             ref_frame_config->gld_fb_idx[sl] = sl;
 162           } else {
 163             ref_frame_config->gld_fb_idx[sl] = sl - 1;
 164           }
 165         } else {
 166           ref_frame_config->gld_fb_idx[sl] = 0;
 167         }
 168         ref_frame_config->alt_fb_idx[sl] = 0;
 169       } else if (tl == 1) {
 170         ref_frame_config->lst_fb_idx[sl] = sl;
 171         ref_frame_config->gld_fb_idx[sl] =
 172             (sl == 0) ? 0 : num_spatial_layers + sl - 1;
 173         ref_frame_config->alt_fb_idx[sl] = num_spatial_layers + sl;
 174       }
 175       // Set the reference and update flags.
 176       if (!tl) {
 177         if (!sl) {
 178           // Base spatial and base temporal (sl = 0, tl = 0)
 179           ref_frame_config->reference_last[sl] = 1;
 180           ref_frame_config->reference_golden[sl] = 0;
 181           ref_frame_config->reference_alt_ref[sl] = 0;
 182           ref_frame_config->update_buffer_slot[sl] |=
 183               1 << ref_frame_config->lst_fb_idx[sl];
 184         } else {
 185           if (is_key_frame) {
 186             ref_frame_config->reference_last[sl] = 1;
 187             ref_frame_config->reference_golden[sl] = 0;
 188             ref_frame_config->reference_alt_ref[sl] = 0;
 189             ref_frame_config->update_buffer_slot[sl] |=
 190                 1 << ref_frame_config->gld_fb_idx[sl];
 191           } else {
 192             // Non-zero spatiall layer.
 193             ref_frame_config->reference_last[sl] = 1;
 194             ref_frame_config->reference_golden[sl] = 1;
 195             ref_frame_config->reference_alt_ref[sl] = 1;
 196             ref_frame_config->update_buffer_slot[sl] |=
 197                 1 << ref_frame_config->lst_fb_idx[sl];
 198           }
 199         }
 200       } else if (tl == 1) {
 201         if (!sl) {
 202           // Base spatial and top temporal (tl = 1)
 203           ref_frame_config->reference_last[sl] = 1;
 204           ref_frame_config->reference_golden[sl] = 0;
 205           ref_frame_config->reference_alt_ref[sl] = 0;
 206           ref_frame_config->update_buffer_slot[sl] |=
 207               1 << ref_frame_config->alt_fb_idx[sl];
 208         } else {
 209           // Non-zero spatial.
 210           if (sl < num_spatial_layers - 1) {
 211             ref_frame_config->reference_last[sl] = 1;
 212             ref_frame_config->reference_golden[sl] = 1;
 213             ref_frame_config->reference_alt_ref[sl] = 0;
 214             ref_frame_config->update_buffer_slot[sl] |=
 215                 1 << ref_frame_config->alt_fb_idx[sl];
 216           } else if (sl == num_spatial_layers - 1) {
 217             // Top spatial and top temporal (non-reference -- doesn't
 218             // update any reference buffers).
 219             ref_frame_config->reference_last[sl] = 1;
 220             ref_frame_config->reference_golden[sl] = 1;
 221             ref_frame_config->reference_alt_ref[sl] = 0;
 222           }
 223         }
 224       }
 225     }
 226   }
 227
 228   virtual void PreEncodeFrameHook(::libvpx_test::VideoSource *video,
 229                                   ::libvpx_test::Encoder *encoder) {
 230     current_video_frame_ = video->frame();
 231     PreEncodeFrameHookSetup(video, encoder);
 232     if (video->frame() == 0) {
 233       // Do not turn off inter-layer pred completely because simulcast mode
 234       // fails.
 235       if (inter_layer_pred_mode_ != INTER_LAYER_PRED_OFF)
 236         encoder->Control(VP9E_SET_SVC_INTER_LAYER_PRED, inter_layer_pred_mode_);
 237       encoder->Control(VP9E_SET_NOISE_SENSITIVITY, denoiser_on_);
 238       if (intra_only_test_)
 239         // Decoder sets the color_space for Intra-only frames
 240         // to BT_601 (see line 1810 in vp9_decodeframe.c).
 241         // So set it here in these tess to avoid encoder-decoder
 242         // mismatch check on color space setting.
 243         encoder->Control(VP9E_SET_COLOR_SPACE, VPX_CS_BT_601);
 244
 245       encoder->Control(VP9E_SET_DISABLE_LOOPFILTER, loopfilter_off_);
 246     }
 247     if (flexible_mode_) {
 248       vpx_svc_layer_id_t layer_id;
 249       layer_id.spatial_layer_id = 0;
 250       layer_id.temporal_layer_id = (video->frame() % 2 != 0);
 251       temporal_layer_id_ = layer_id.temporal_layer_id;
 252       for (int i = 0; i < number_spatial_layers_; i++) {
 253         layer_id.temporal_layer_id_per_spatial[i] = temporal_layer_id_;
 254         ref_frame_config_.duration[i] = 1;
 255       }
 256       encoder->Control(VP9E_SET_SVC_LAYER_ID, &layer_id);
 257       set_frame_flags_bypass_mode(layer_id.temporal_layer_id,
 258                                   number_spatial_layers_, 0,
 259                                   &ref_frame_config_);
 260       encoder->Control(VP9E_SET_SVC_REF_FRAME_CONFIG, &ref_frame_config_);
 261     }
 262     if (video->frame() == frame_to_sync_) {
 263       encoder->Control(VP9E_SET_SVC_SPATIAL_LAYER_SYNC, &svc_layer_sync_);
 264     }
 265   }
 266
 267 #if CONFIG_VP9_DECODER
 268   virtual void PreDecodeFrameHook(::libvpx_test::VideoSource *video,
 269                                   ::libvpx_test::Decoder *decoder) {
 270     if (video->frame() < frame_to_sync_) {
 271       if (decode_to_layer_before_sync_ >= 0)
 272         decoder->Control(VP9_DECODE_SVC_SPATIAL_LAYER,
 273                          decode_to_layer_before_sync_);
 274     } else {
 275       if (decode_to_layer_after_sync_ >= 0) {
 276         int decode_to_layer = decode_to_layer_after_sync_;
 277         // Overlay frame is additional layer for intra-only.
 278         if (video->frame() == frame_to_sync_ && intra_only_test_ &&
 279             decode_to_layer_after_sync_ == 0 && number_spatial_layers_ > 1)
 280           decode_to_layer += 1;
 281         decoder->Control(VP9_DECODE_SVC_SPATIAL_LAYER, decode_to_layer);
 282       }
 283     }
 284   }
 285 #endif
 286
 287   virtual void FramePktHook(const vpx_codec_cx_pkt_t *pkt) {
 288     // Keep track of number of non-reference frames, needed for mismatch check.
 289     // Non-reference frames are top spatial and temporal layer frames,
 290     // for TL > 0.
 291     if (temporal_layer_id_ == number_temporal_layers_ - 1 &&
 292         temporal_layer_id_ > 0 &&
 293         pkt->data.frame.spatial_layer_encoded[number_spatial_layers_ - 1] &&
 294         current_video_frame_ >= frame_to_sync_)
 295       num_nonref_frames_++;
 296
 297     if (intra_only_test_ && current_video_frame_ == frame_to_sync_) {
 298       // Intra-only frame is only generated for spatial layers > 1 and <= 3,
 299       // among other conditions (see constraint in set_intra_only_frame(). If
 300       // intra-only is no allowed then encoder will insert key frame instead.
 301       const bool key_frame =
 302           (pkt->data.frame.flags & VPX_FRAME_IS_KEY) ? true : false;
 303       if (number_spatial_layers_ == 1 || number_spatial_layers_ > 3)
 304         ASSERT_TRUE(key_frame);
 305       else
 306         ASSERT_FALSE(key_frame);
 307     }
 308   }
 309
 310   virtual void MismatchHook(const vpx_image_t * /*img1*/,
 311                             const vpx_image_t * /*img2*/) {
 312     if (current_video_frame_ >= frame_to_sync_) ++mismatch_nframes_;
 313   }
 314
 315   unsigned int GetMismatchFrames() const { return mismatch_nframes_; }
 316   unsigned int GetNonRefFrames() const { return num_nonref_frames_; }
 317
 318   unsigned int current_video_frame_;
 319   unsigned int frame_to_start_decode_;
 320   unsigned int frame_to_sync_;
 321   int inter_layer_pred_mode_;
 322   int decode_to_layer_before_sync_;
 323   int decode_to_layer_after_sync_;
 324   int denoiser_on_;
 325   bool intra_only_test_;
 326   int loopfilter_off_;
 327   vpx_svc_spatial_layer_sync_t svc_layer_sync_;
 328   unsigned int mismatch_nframes_;
 329   unsigned int num_nonref_frames_;
 330   bool flexible_mode_;
 331   vpx_svc_ref_frame_config_t ref_frame_config_;
 332
 333  private:
 334   virtual void SetConfig(const int num_temporal_layer) {
 335     cfg_.rc_buf_initial_sz = 500;
 336     cfg_.rc_buf_optimal_sz = 500;
 337     cfg_.rc_buf_sz = 1000;
 338     cfg_.rc_min_quantizer = 0;
 339     cfg_.rc_max_quantizer = 63;
 340     cfg_.rc_end_usage = VPX_CBR;
 341     cfg_.g_lag_in_frames = 0;
 342     cfg_.g_error_resilient = 1;
 343     cfg_.g_threads = 1;
 344     cfg_.rc_dropframe_thresh = 30;
 345     cfg_.kf_max_dist = 9999;
 346     if (num_temporal_layer == 3) {
 347       cfg_.ts_rate_decimator[0] = 4;
 348       cfg_.ts_rate_decimator[1] = 2;
 349       cfg_.ts_rate_decimator[2] = 1;
 350       cfg_.temporal_layering_mode = 3;
 351     } else if (num_temporal_layer == 2) {
 352       cfg_.ts_rate_decimator[0] = 2;
 353       cfg_.ts_rate_decimator[1] = 1;
 354       cfg_.temporal_layering_mode = 2;
 355     } else if (num_temporal_layer == 1) {
 356       cfg_.ts_rate_decimator[0] = 1;
 357       cfg_.temporal_layering_mode = 0;
 358     }
 359   }
 360 };
 361
 362 // Test for sync layer for 1 pass CBR SVC: 3 spatial layers and
 363 // 3 temporal layers. Only start decoding on the sync layer.
 364 // Full sync: insert key frame on base layer.
 365 TEST_P(SyncFrameOnePassCbrSvc, OnePassCbrSvc3SL3TLFullSync) {
 366   SetSvcConfig(3, 3);
 367   // Sync is on base layer so the frame to sync and the frame to start decoding
 368   // is the same.
 369   frame_to_start_decode_ = 20;
 370   frame_to_sync_ = 20;
 371   decode_to_layer_before_sync_ = -1;
 372   decode_to_layer_after_sync_ = 2;
 373
 374   // Set up svc layer sync structure.
 375   svc_layer_sync_.base_layer_intra_only = 0;
 376   svc_layer_sync_.spatial_layer_sync[0] = 1;
 377
 378   ::libvpx_test::Y4mVideoSource video("niklas_1280_720_30.y4m", 0, 60);
 379
 380   cfg_.rc_target_bitrate = 600;
 381   flexible_mode_ = false;
 382   AssignLayerBitrates();
 383   ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
 384 #if CONFIG_VP9_DECODER
 385   // The non-reference frames are expected to be mismatched frames as the
 386   // encoder will avoid loopfilter on these frames.
 387   EXPECT_EQ(GetNonRefFrames(), GetMismatchFrames());
 388 #endif
 389 }
 390
 391 // Test for sync layer for 1 pass CBR SVC: 2 spatial layers and
 392 // 3 temporal layers. Decoding QVGA before sync frame and decode up to
 393 // VGA on and after sync.
 394 TEST_P(SyncFrameOnePassCbrSvc, OnePassCbrSvc2SL3TLSyncToVGA) {
 395   SetSvcConfig(2, 3);
 396   frame_to_start_decode_ = 0;
 397   frame_to_sync_ = 100;
 398   decode_to_layer_before_sync_ = 0;
 399   decode_to_layer_after_sync_ = 1;
 400
 401   // Set up svc layer sync structure.
 402   svc_layer_sync_.base_layer_intra_only = 0;
 403   svc_layer_sync_.spatial_layer_sync[0] = 0;
 404   svc_layer_sync_.spatial_layer_sync[1] = 1;
 405
 406   ::libvpx_test::I420VideoSource video("niklas_640_480_30.yuv", 640, 480, 30, 1,
 407                                        0, 400);
 408   cfg_.rc_target_bitrate = 400;
 409   flexible_mode_ = false;
 410   AssignLayerBitrates();
 411   ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
 412 #if CONFIG_VP9_DECODER
 413   // The non-reference frames are expected to be mismatched frames as the
 414   // encoder will avoid loopfilter on these frames.
 415   EXPECT_EQ(GetNonRefFrames(), GetMismatchFrames());
 416 #endif
 417 }
 418
 419 // Test for sync layer for 1 pass CBR SVC: 3 spatial layers and
 420 // 3 temporal layers. Decoding QVGA and VGA before sync frame and decode up to
 421 // HD on and after sync.
 422 TEST_P(SyncFrameOnePassCbrSvc, OnePassCbrSvc3SL3TLSyncToHD) {
 423   SetSvcConfig(3, 3);
 424   frame_to_start_decode_ = 0;
 425   frame_to_sync_ = 20;
 426   decode_to_layer_before_sync_ = 1;
 427   decode_to_layer_after_sync_ = 2;
 428
 429   // Set up svc layer sync structure.
 430   svc_layer_sync_.base_layer_intra_only = 0;
 431   svc_layer_sync_.spatial_layer_sync[0] = 0;
 432   svc_layer_sync_.spatial_layer_sync[1] = 0;
 433   svc_layer_sync_.spatial_layer_sync[2] = 1;
 434
 435   ::libvpx_test::Y4mVideoSource video("niklas_1280_720_30.y4m", 0, 60);
 436   cfg_.rc_target_bitrate = 600;
 437   flexible_mode_ = false;
 438   AssignLayerBitrates();
 439   ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
 440 #if CONFIG_VP9_DECODER
 441   // The non-reference frames are expected to be mismatched frames as the
 442   // encoder will avoid loopfilter on these frames.
 443   EXPECT_EQ(GetNonRefFrames(), GetMismatchFrames());
 444 #endif
 445 }
 446
 447 // Test for sync layer for 1 pass CBR SVC: 3 spatial layers and
 448 // 3 temporal layers. Decoding QVGA before sync frame and decode up to
 449 // HD on and after sync.
 450 TEST_P(SyncFrameOnePassCbrSvc, OnePassCbrSvc3SL3TLSyncToVGAHD) {
 451   SetSvcConfig(3, 3);
 452   frame_to_start_decode_ = 0;
 453   frame_to_sync_ = 20;
 454   decode_to_layer_before_sync_ = 0;
 455   decode_to_layer_after_sync_ = 2;
 456
 457   // Set up svc layer sync structure.
 458   svc_layer_sync_.base_layer_intra_only = 0;
 459   svc_layer_sync_.spatial_layer_sync[0] = 0;
 460   svc_layer_sync_.spatial_layer_sync[1] = 1;
 461   svc_layer_sync_.spatial_layer_sync[2] = 1;
 462
 463   ::libvpx_test::Y4mVideoSource video("niklas_1280_720_30.y4m", 0, 60);
 464   cfg_.rc_target_bitrate = 600;
 465   flexible_mode_ = false;
 466   AssignLayerBitrates();
 467   ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
 468 #if CONFIG_VP9_DECODER
 469   // The non-reference frames are expected to be mismatched frames as the
 470   // encoder will avoid loopfilter on these frames.
 471   EXPECT_EQ(GetNonRefFrames(), GetMismatchFrames());
 472 #endif
 473 }
 474
 475 #if CONFIG_VP9_TEMPORAL_DENOISING
 476 // Test for sync layer for 1 pass CBR SVC: 2 spatial layers and
 477 // 3 temporal layers. Decoding QVGA before sync frame and decode up to
 478 // VGA on and after sync.
 479 TEST_P(SyncFrameOnePassCbrSvc, OnePassCbrSvc2SL3TLSyncFrameVGADenoise) {
 480   SetSvcConfig(2, 3);
 481   frame_to_start_decode_ = 0;
 482   frame_to_sync_ = 100;
 483   decode_to_layer_before_sync_ = 0;
 484   decode_to_layer_after_sync_ = 1;
 485
 486   denoiser_on_ = 1;
 487   // Set up svc layer sync structure.
 488   svc_layer_sync_.base_layer_intra_only = 0;
 489   svc_layer_sync_.spatial_layer_sync[0] = 0;
 490   svc_layer_sync_.spatial_layer_sync[1] = 1;
 491
 492   ::libvpx_test::I420VideoSource video("niklas_640_480_30.yuv", 640, 480, 30, 1,
 493                                        0, 400);
 494   cfg_.rc_target_bitrate = 400;
 495   flexible_mode_ = false;
 496   AssignLayerBitrates();
 497   ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
 498 #if CONFIG_VP9_DECODER
 499   // The non-reference frames are expected to be mismatched frames as the
 500   // encoder will avoid loopfilter on these frames.
 501   EXPECT_EQ(GetNonRefFrames(), GetMismatchFrames());
 502 #endif
 503 }
 504 #endif
 505
 506 // Encode 3 spatial, 2 temporal layer in flexible mode but don't
 507 // start decoding. During the sequence insert intra-only on base/qvga
 508 // layer at frame 20 and start decoding only QVGA layer from there.
 509 TEST_P(SyncFrameOnePassCbrSvc,
 510        OnePassCbrSvc3SL3TLSyncFrameStartDecodeOnIntraOnlyQVGAFlex) {
 511   SetSvcConfig(3, 2);
 512   frame_to_start_decode_ = 20;
 513   frame_to_sync_ = 20;
 514   decode_to_layer_before_sync_ = 2;
 515   decode_to_layer_after_sync_ = 0;
 516   intra_only_test_ = true;
 517
 518   // Set up svc layer sync structure.
 519   svc_layer_sync_.base_layer_intra_only = 1;
 520   svc_layer_sync_.spatial_layer_sync[0] = 1;
 521   svc_layer_sync_.spatial_layer_sync[1] = 0;
 522   svc_layer_sync_.spatial_layer_sync[2] = 0;
 523
 524   ::libvpx_test::Y4mVideoSource video("niklas_1280_720_30.y4m", 0, 60);
 525   cfg_.rc_target_bitrate = 600;
 526   flexible_mode_ = true;
 527   AssignLayerBitrates();
 528   cfg_.temporal_layering_mode = VP9E_TEMPORAL_LAYERING_MODE_BYPASS;
 529   ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
 530   // Can't check mismatch here because only base is decoded at
 531   // frame sync, whereas encoder continues encoding all layers.
 532 }
 533
 534 // Encode 3 spatial, 3 temporal layer but don't start decoding.
 535 // During the sequence insert intra-only on base/qvga layer at frame 20
 536 // and start decoding only QVGA layer from there.
 537 TEST_P(SyncFrameOnePassCbrSvc,
 538        OnePassCbrSvc3SL3TLSyncFrameStartDecodeOnIntraOnlyQVGA) {
 539   SetSvcConfig(3, 3);
 540   frame_to_start_decode_ = 20;
 541   frame_to_sync_ = 20;
 542   decode_to_layer_before_sync_ = 2;
 543   decode_to_layer_after_sync_ = 0;
 544   intra_only_test_ = true;
 545
 546   // Set up svc layer sync structure.
 547   svc_layer_sync_.base_layer_intra_only = 1;
 548   svc_layer_sync_.spatial_layer_sync[0] = 1;
 549   svc_layer_sync_.spatial_layer_sync[1] = 0;
 550   svc_layer_sync_.spatial_layer_sync[2] = 0;
 551
 552   ::libvpx_test::Y4mVideoSource video("niklas_1280_720_30.y4m", 0, 60);
 553   cfg_.rc_target_bitrate = 600;
 554   flexible_mode_ = false;
 555   AssignLayerBitrates();
 556   ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
 557   // Can't check mismatch here because only base is decoded at
 558   // frame sync, whereas encoder continues encoding all layers.
 559 }
 560
 561 // Start decoding from beginning of sequence, during sequence insert intra-only
 562 // on base/qvga layer. Decode all layers.
 563 TEST_P(SyncFrameOnePassCbrSvc, OnePassCbrSvc3SL3TLSyncFrameIntraOnlyQVGA) {
 564   SetSvcConfig(3, 3);
 565   frame_to_start_decode_ = 0;
 566   frame_to_sync_ = 20;
 567   decode_to_layer_before_sync_ = 2;
 568   // The superframe containing intra-only layer will have +1 frames. Thus set
 569   // the layer to decode after sync frame to +1 from
 570   // decode_to_layer_before_sync.
 571   decode_to_layer_after_sync_ = 3;
 572   intra_only_test_ = true;
 573
 574   // Set up svc layer sync structure.
 575   svc_layer_sync_.base_layer_intra_only = 1;
 576   svc_layer_sync_.spatial_layer_sync[0] = 1;
 577   svc_layer_sync_.spatial_layer_sync[1] = 0;
 578   svc_layer_sync_.spatial_layer_sync[2] = 0;
 579
 580   ::libvpx_test::Y4mVideoSource video("niklas_1280_720_30.y4m", 0, 60);
 581   cfg_.rc_target_bitrate = 600;
 582   flexible_mode_ = false;
 583   AssignLayerBitrates();
 584   ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
 585 #if CONFIG_VP9_DECODER
 586   // The non-reference frames are expected to be mismatched frames as the
 587   // encoder will avoid loopfilter on these frames.
 588   EXPECT_EQ(GetNonRefFrames(), GetMismatchFrames());
 589 #endif
 590 }
 591
 592 // Start decoding from beginning of sequence, during sequence insert intra-only
 593 // on base/qvga layer and sync_layer on middle/VGA layer. Decode all layers.
 594 TEST_P(SyncFrameOnePassCbrSvc, OnePassCbrSvc3SL3TLSyncFrameIntraOnlyVGA) {
 595   SetSvcConfig(3, 3);
 596   frame_to_start_decode_ = 0;
 597   frame_to_sync_ = 20;
 598   decode_to_layer_before_sync_ = 2;
 599   // The superframe containing intra-only layer will have +1 frames. Thus set
 600   // the layer to decode after sync frame to +1 from
 601   // decode_to_layer_before_sync.
 602   decode_to_layer_after_sync_ = 3;
 603   intra_only_test_ = true;
 604
 605   // Set up svc layer sync structure.
 606   svc_layer_sync_.base_layer_intra_only = 1;
 607   svc_layer_sync_.spatial_layer_sync[0] = 1;
 608   svc_layer_sync_.spatial_layer_sync[1] = 1;
 609   svc_layer_sync_.spatial_layer_sync[2] = 0;
 610
 611   ::libvpx_test::Y4mVideoSource video("niklas_1280_720_30.y4m", 0, 60);
 612   cfg_.rc_target_bitrate = 600;
 613   flexible_mode_ = false;
 614   AssignLayerBitrates();
 615   ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
 616 #if CONFIG_VP9_DECODER
 617   // The non-reference frames are expected to be mismatched frames as the
 618   // encoder will avoid loopfilter on these frames.
 619   EXPECT_EQ(GetNonRefFrames(), GetMismatchFrames());
 620 #endif
 621 }
 622
 623 // Start decoding from sync frame, insert intra-only on base/qvga layer. Decode
 624 // all layers. For 1 spatial layer, it inserts a key frame.
 625 TEST_P(SyncFrameOnePassCbrSvc, OnePassCbrSvc1SL3TLSyncFrameIntraOnlyQVGA) {
 626   SetSvcConfig(1, 3);
 627   frame_to_start_decode_ = 20;
 628   frame_to_sync_ = 20;
 629   decode_to_layer_before_sync_ = 0;
 630   decode_to_layer_after_sync_ = 0;
 631   intra_only_test_ = true;
 632
 633   // Set up svc layer sync structure.
 634   svc_layer_sync_.base_layer_intra_only = 1;
 635   svc_layer_sync_.spatial_layer_sync[0] = 1;
 636
 637   ::libvpx_test::Y4mVideoSource video("niklas_1280_720_30.y4m", 0, 60);
 638   cfg_.rc_target_bitrate = 600;
 639   flexible_mode_ = false;
 640   AssignLayerBitrates();
 641   ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
 642 #if CONFIG_VP9_DECODER
 643   // The non-reference frames are expected to be mismatched frames as the
 644   // encoder will avoid loopfilter on these frames.
 645   EXPECT_EQ(GetNonRefFrames(), GetMismatchFrames());
 646 #endif
 647 }
 648
 649 // Params: Loopfilter modes.
 650 class LoopfilterOnePassCbrSvc : public OnePassCbrSvc,
 651                                 public ::libvpx_test::CodecTestWithParam<int> {
 652  public:
 653   LoopfilterOnePassCbrSvc()
 654       : OnePassCbrSvc(GET_PARAM(0)), loopfilter_off_(GET_PARAM(1)),
 655         mismatch_nframes_(0), num_nonref_frames_(0) {
 656     SetMode(::libvpx_test::kRealTime);
 657   }
 658
 659  protected:
 660   virtual ~LoopfilterOnePassCbrSvc() {}
 661
 662   virtual void SetUp() {
 663     InitializeConfig();
 664     speed_setting_ = 7;
 665   }
 666
 667   virtual void PreEncodeFrameHook(::libvpx_test::VideoSource *video,
 668                                   ::libvpx_test::Encoder *encoder) {
 669     PreEncodeFrameHookSetup(video, encoder);
 670     if (number_temporal_layers_ > 1 || number_spatial_layers_ > 1) {
 671       // Consider 3 cases:
 672       if (loopfilter_off_ == 0) {
 673         // loopfilter is on for all spatial layers on every superrframe.
 674         for (int i = 0; i < VPX_SS_MAX_LAYERS; ++i) {
 675           svc_params_.loopfilter_ctrl[i] = 0;
 676         }
 677       } else if (loopfilter_off_ == 1) {
 678         // loopfilter is off for non-reference frames for all spatial layers.
 679         for (int i = 0; i < VPX_SS_MAX_LAYERS; ++i) {
 680           svc_params_.loopfilter_ctrl[i] = 1;
 681         }
 682       } else {
 683         // loopfilter is off for all SL0 frames, and off only for non-reference
 684         // frames for SL > 0.
 685         svc_params_.loopfilter_ctrl[0] = 2;
 686         for (int i = 1; i < VPX_SS_MAX_LAYERS; ++i) {
 687           svc_params_.loopfilter_ctrl[i] = 1;
 688         }
 689       }
 690       encoder->Control(VP9E_SET_SVC_PARAMETERS, &svc_params_);
 691     } else if (number_temporal_layers_ == 1 && number_spatial_layers_ == 1) {
 692       // For non-SVC mode use the single layer control.
 693       encoder->Control(VP9E_SET_DISABLE_LOOPFILTER, loopfilter_off_);
 694     }
 695   }
 696
 697   virtual void FramePktHook(const vpx_codec_cx_pkt_t *pkt) {
 698     // Keep track of number of non-reference frames, needed for mismatch check.
 699     // Non-reference frames are top spatial and temporal layer frames,
 700     // for TL > 0.
 701     if (temporal_layer_id_ == number_temporal_layers_ - 1 &&
 702         temporal_layer_id_ > 0 &&
 703         pkt->data.frame.spatial_layer_encoded[number_spatial_layers_ - 1])
 704       num_nonref_frames_++;
 705   }
 706
 707   virtual void MismatchHook(const vpx_image_t * /*img1*/,
 708                             const vpx_image_t * /*img2*/) {
 709     ++mismatch_nframes_;
 710   }
 711
 712   virtual void SetConfig(const int /*num_temporal_layer*/) {}
 713
 714   int GetMismatchFrames() const { return mismatch_nframes_; }
 715   int GetNonRefFrames() const { return num_nonref_frames_; }
 716
 717   int loopfilter_off_;
 718
 719  private:
 720   int mismatch_nframes_;
 721   int num_nonref_frames_;
 722 };
 723
 724 TEST_P(LoopfilterOnePassCbrSvc, OnePassCbrSvc1SL1TLLoopfilterOff) {
 725   SetSvcConfig(1, 1);
 726   cfg_.rc_buf_initial_sz = 500;
 727   cfg_.rc_buf_optimal_sz = 500;
 728   cfg_.rc_buf_sz = 1000;
 729   cfg_.rc_min_quantizer = 0;
 730   cfg_.rc_max_quantizer = 63;
 731   cfg_.g_threads = 1;
 732   cfg_.rc_dropframe_thresh = 0;
 733   cfg_.rc_target_bitrate = 800;
 734   cfg_.kf_max_dist = 9999;
 735   cfg_.rc_end_usage = VPX_CBR;
 736   cfg_.g_lag_in_frames = 0;
 737   cfg_.g_error_resilient = 1;
 738   cfg_.ts_rate_decimator[0] = 1;
 739   cfg_.temporal_layering_mode = 0;
 740   ::libvpx_test::I420VideoSource video("niklas_640_480_30.yuv", 640, 480, 30, 1,
 741                                        0, 400);
 742   cfg_.rc_target_bitrate = 600;
 743   AssignLayerBitrates();
 744   ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
 745 #if CONFIG_VP9_DECODER
 746   if (loopfilter_off_ == 0)
 747     EXPECT_EQ(GetNonRefFrames(), GetMismatchFrames());
 748   else
 749     EXPECT_EQ(GetMismatchFrames(), 0);
 750 #endif
 751 }
 752
 753 TEST_P(LoopfilterOnePassCbrSvc, OnePassCbrSvc1SL3TLLoopfilterOff) {
 754   SetSvcConfig(1, 3);
 755   cfg_.rc_buf_initial_sz = 500;
 756   cfg_.rc_buf_optimal_sz = 500;
 757   cfg_.rc_buf_sz = 1000;
 758   cfg_.rc_min_quantizer = 0;
 759   cfg_.rc_max_quantizer = 63;
 760   cfg_.g_threads = 1;
 761   cfg_.rc_dropframe_thresh = 0;
 762   cfg_.rc_target_bitrate = 800;
 763   cfg_.kf_max_dist = 9999;
 764   cfg_.rc_end_usage = VPX_CBR;
 765   cfg_.g_lag_in_frames = 0;
 766   cfg_.g_error_resilient = 1;
 767   cfg_.ts_rate_decimator[0] = 4;
 768   cfg_.ts_rate_decimator[1] = 2;
 769   cfg_.ts_rate_decimator[2] = 1;
 770   cfg_.temporal_layering_mode = 3;
 771   ::libvpx_test::I420VideoSource video("niklas_640_480_30.yuv", 640, 480, 30, 1,
 772                                        0, 400);
 773   cfg_.rc_target_bitrate = 600;
 774   AssignLayerBitrates();
 775   ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
 776 #if CONFIG_VP9_DECODER
 777   if (loopfilter_off_ == 0)
 778     EXPECT_EQ(GetNonRefFrames(), GetMismatchFrames());
 779   else
 780     EXPECT_EQ(GetMismatchFrames(), 0);
 781 #endif
 782 }
 783
 784 TEST_P(LoopfilterOnePassCbrSvc, OnePassCbrSvc3SL3TLLoopfilterOff) {
 785   SetSvcConfig(3, 3);
 786   cfg_.rc_buf_initial_sz = 500;
 787   cfg_.rc_buf_optimal_sz = 500;
 788   cfg_.rc_buf_sz = 1000;
 789   cfg_.rc_min_quantizer = 0;
 790   cfg_.rc_max_quantizer = 63;
 791   cfg_.g_threads = 1;
 792   cfg_.rc_dropframe_thresh = 0;
 793   cfg_.rc_target_bitrate = 800;
 794   cfg_.kf_max_dist = 9999;
 795   cfg_.rc_end_usage = VPX_CBR;
 796   cfg_.g_lag_in_frames = 0;
 797   cfg_.g_error_resilient = 1;
 798   cfg_.ts_rate_decimator[0] = 4;
 799   cfg_.ts_rate_decimator[1] = 2;
 800   cfg_.ts_rate_decimator[2] = 1;
 801   cfg_.temporal_layering_mode = 3;
 802   ::libvpx_test::I420VideoSource video("niklas_640_480_30.yuv", 640, 480, 30, 1,
 803                                        0, 400);
 804   cfg_.rc_target_bitrate = 600;
 805   AssignLayerBitrates();
 806   ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
 807 #if CONFIG_VP9_DECODER
 808   if (loopfilter_off_ == 0)
 809     EXPECT_EQ(GetNonRefFrames(), GetMismatchFrames());
 810   else
 811     EXPECT_EQ(GetMismatchFrames(), 0);
 812 #endif
 813 }
 814
 815 VP9_INSTANTIATE_TEST_SUITE(SyncFrameOnePassCbrSvc, ::testing::Range(0, 3));
 816
 817 VP9_INSTANTIATE_TEST_SUITE(LoopfilterOnePassCbrSvc, ::testing::Range(0, 3));
 818
 819 INSTANTIATE_TEST_SUITE_P(
 820     VP9, ScalePartitionOnePassCbrSvc,
 821     ::testing::Values(
 822         static_cast<const libvpx_test::CodecFactory *>(&libvpx_test::kVP9)));
 823
 824 }  // namespace
 825 }  // namespace svc_test