error_resilience_test.cc 19.5 KB
Newer Older
1
/*
Frank Galligan's avatar
Frank Galligan committed
2 3 4 5 6 7 8 9
 *  Copyright (c) 2013 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.
 */
10

11
#include "third_party/googletest/src/include/gtest/gtest.h"
12
#include "test/codec_factory.h"
13 14
#include "test/encode_test_driver.h"
#include "test/i420_video_source.h"
15
#include "test/util.h"
16 17 18

namespace {

19 20
const int kMaxErrorFrames = 12;
const int kMaxDroppableFrames = 12;
21

clang-format's avatar
clang-format committed
22
class ErrorResilienceTestLarge
Yaowu Xu's avatar
Yaowu Xu committed
23 24
    : public ::libaom_test::EncoderTest,
      public ::libaom_test::CodecTestWith2Params<libaom_test::TestMode, bool> {
25
 protected:
26
  ErrorResilienceTestLarge()
clang-format's avatar
clang-format committed
27 28
      : EncoderTest(GET_PARAM(0)), svc_support_(GET_PARAM(2)), psnr_(0.0),
        nframes_(0), mismatch_psnr_(0.0), mismatch_nframes_(0),
29
        encoding_mode_(GET_PARAM(1)) {
30 31
    Reset();
  }
32

33
  virtual ~ErrorResilienceTestLarge() {}
34

35 36 37
  void Reset() {
    error_nframes_ = 0;
    droppable_nframes_ = 0;
Marco's avatar
Marco committed
38
    pattern_switch_ = 0;
39 40
  }

41 42 43 44 45 46 47 48
  virtual void SetUp() {
    InitializeConfig();
    SetMode(encoding_mode_);
  }

  virtual void BeginPassHook(unsigned int /*pass*/) {
    psnr_ = 0.0;
    nframes_ = 0;
49 50
    mismatch_psnr_ = 0.0;
    mismatch_nframes_ = 0;
51 52 53 54 55 56 57
  }

  virtual void PSNRPktHook(const vpx_codec_cx_pkt_t *pkt) {
    psnr_ += pkt->data.psnr.psnr[0];
    nframes_++;
  }

58 59 60 61 62 63
  //
  // Frame flags and layer id for temporal layers.
  // For two layers, test pattern is:
  //   1     3
  // 0    2     .....
  // LAST is updated on base/layer 0, GOLDEN  updated on layer 1.
Marco's avatar
Marco committed
64 65
  // Non-zero pattern_switch parameter means pattern will switch to
  // not using LAST for frame_num >= pattern_switch.
clang-format's avatar
clang-format committed
66
  int SetFrameFlags(int frame_num, int num_temp_layers, int pattern_switch) {
67 68
    int frame_flags = 0;
    if (num_temp_layers == 2) {
clang-format's avatar
clang-format committed
69 70 71 72 73
      if (frame_num % 2 == 0) {
        if (frame_num < pattern_switch || pattern_switch == 0) {
          // Layer 0: predict from LAST and ARF, update LAST.
          frame_flags =
              VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF;
Marco's avatar
Marco committed
74
        } else {
clang-format's avatar
clang-format committed
75 76 77 78 79 80 81 82 83 84 85 86
          // Layer 0: predict from GF and ARF, update GF.
          frame_flags = VP8_EFLAG_NO_REF_LAST | VP8_EFLAG_NO_UPD_LAST |
                        VP8_EFLAG_NO_UPD_ARF;
        }
      } else {
        if (frame_num < pattern_switch || pattern_switch == 0) {
          // Layer 1: predict from L, GF, and ARF, update GF.
          frame_flags = VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST;
        } else {
          // Layer 1: predict from GF and ARF, update GF.
          frame_flags = VP8_EFLAG_NO_REF_LAST | VP8_EFLAG_NO_UPD_LAST |
                        VP8_EFLAG_NO_UPD_ARF;
Marco's avatar
Marco committed
87
        }
clang-format's avatar
clang-format committed
88
      }
89 90 91 92
    }
    return frame_flags;
  }

Yaowu Xu's avatar
Yaowu Xu committed
93 94
  virtual void PreEncodeFrameHook(libaom_test::VideoSource *video,
                                  ::libaom_test::Encoder *encoder) {
clang-format's avatar
clang-format committed
95 96
    frame_flags_ &=
        ~(VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF);
97 98
    // For temporal layer case.
    if (cfg_.ts_number_layers > 1) {
clang-format's avatar
clang-format committed
99 100
      frame_flags_ =
          SetFrameFlags(video->frame(), cfg_.ts_number_layers, pattern_switch_);
101
      for (unsigned int i = 0; i < droppable_nframes_; ++i) {
102
        if (droppable_frames_[i] == video->frame()) {
clang-format's avatar
clang-format committed
103 104
          std::cout << "Encoding droppable frame: " << droppable_frames_[i]
                    << "\n";
105 106
        }
      }
107
    } else {
clang-format's avatar
clang-format committed
108 109 110 111 112 113 114 115 116 117 118 119
      if (droppable_nframes_ > 0 &&
          (cfg_.g_pass == VPX_RC_LAST_PASS || cfg_.g_pass == VPX_RC_ONE_PASS)) {
        for (unsigned int i = 0; i < droppable_nframes_; ++i) {
          if (droppable_frames_[i] == video->frame()) {
            std::cout << "Encoding droppable frame: " << droppable_frames_[i]
                      << "\n";
            frame_flags_ |= (VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF |
                             VP8_EFLAG_NO_UPD_ARF);
            return;
          }
        }
      }
120 121 122
    }
  }

123
  double GetAveragePsnr() const {
clang-format's avatar
clang-format committed
124
    if (nframes_) return psnr_ / nframes_;
125 126 127
    return 0.0;
  }

128
  double GetAverageMismatchPsnr() const {
clang-format's avatar
clang-format committed
129
    if (mismatch_nframes_) return mismatch_psnr_ / mismatch_nframes_;
130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146
    return 0.0;
  }

  virtual bool DoDecode() const {
    if (error_nframes_ > 0 &&
        (cfg_.g_pass == VPX_RC_LAST_PASS || cfg_.g_pass == VPX_RC_ONE_PASS)) {
      for (unsigned int i = 0; i < error_nframes_; ++i) {
        if (error_frames_[i] == nframes_ - 1) {
          std::cout << "             Skipping decoding frame: "
                    << error_frames_[i] << "\n";
          return 0;
        }
      }
    }
    return 1;
  }

clang-format's avatar
clang-format committed
147
  virtual void MismatchHook(const vpx_image_t *img1, const vpx_image_t *img2) {
148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173
    double mismatch_psnr = compute_psnr(img1, img2);
    mismatch_psnr_ += mismatch_psnr;
    ++mismatch_nframes_;
    // std::cout << "Mismatch frame psnr: " << mismatch_psnr << "\n";
  }

  void SetErrorFrames(int num, unsigned int *list) {
    if (num > kMaxErrorFrames)
      num = kMaxErrorFrames;
    else if (num < 0)
      num = 0;
    error_nframes_ = num;
    for (unsigned int i = 0; i < error_nframes_; ++i)
      error_frames_[i] = list[i];
  }

  void SetDroppableFrames(int num, unsigned int *list) {
    if (num > kMaxDroppableFrames)
      num = kMaxDroppableFrames;
    else if (num < 0)
      num = 0;
    droppable_nframes_ = num;
    for (unsigned int i = 0; i < droppable_nframes_; ++i)
      droppable_frames_[i] = list[i];
  }

clang-format's avatar
clang-format committed
174
  unsigned int GetMismatchFrames() { return mismatch_nframes_; }
175

clang-format's avatar
clang-format committed
176
  void SetPatternSwitch(int frame_switch) { pattern_switch_ = frame_switch; }
Marco's avatar
Marco committed
177

178 179
  bool svc_support_;

180 181 182
 private:
  double psnr_;
  unsigned int nframes_;
183 184
  unsigned int error_nframes_;
  unsigned int droppable_nframes_;
Marco's avatar
Marco committed
185
  unsigned int pattern_switch_;
186 187 188 189
  double mismatch_psnr_;
  unsigned int mismatch_nframes_;
  unsigned int error_frames_[kMaxErrorFrames];
  unsigned int droppable_frames_[kMaxDroppableFrames];
Yaowu Xu's avatar
Yaowu Xu committed
190
  libaom_test::TestMode encoding_mode_;
191 192
};

193
TEST_P(ErrorResilienceTestLarge, OnVersusOff) {
194 195 196
  const vpx_rational timebase = { 33333333, 1000000000 };
  cfg_.g_timebase = timebase;
  cfg_.rc_target_bitrate = 2000;
197
  cfg_.g_lag_in_frames = 10;
198 199 200

  init_flags_ = VPX_CODEC_USE_PSNR;

Yaowu Xu's avatar
Yaowu Xu committed
201
  libaom_test::I420VideoSource video("hantro_collage_w352h288.yuv", 352, 288,
202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223
                                     timebase.den, timebase.num, 0, 30);

  // Error resilient mode OFF.
  cfg_.g_error_resilient = 0;
  ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
  const double psnr_resilience_off = GetAveragePsnr();
  EXPECT_GT(psnr_resilience_off, 25.0);

  // Error resilient mode ON.
  cfg_.g_error_resilient = 1;
  ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
  const double psnr_resilience_on = GetAveragePsnr();
  EXPECT_GT(psnr_resilience_on, 25.0);

  // Test that turning on error resilient mode hurts by 10% at most.
  if (psnr_resilience_off > 0.0) {
    const double psnr_ratio = psnr_resilience_on / psnr_resilience_off;
    EXPECT_GE(psnr_ratio, 0.9);
    EXPECT_LE(psnr_ratio, 1.1);
  }
}

224 225 226 227
// Check for successful decoding and no encoder/decoder mismatch
// if we lose (i.e., drop before decoding) a set of droppable
// frames (i.e., frames that don't update any reference buffers).
// Check both isolated and consecutive loss.
228
TEST_P(ErrorResilienceTestLarge, DropFramesWithoutRecovery) {
229 230
  const vpx_rational timebase = { 33333333, 1000000000 };
  cfg_.g_timebase = timebase;
231
  cfg_.rc_target_bitrate = 500;
232 233 234
  // FIXME(debargha): Fix this to work for any lag.
  // Currently this test only works for lag = 0
  cfg_.g_lag_in_frames = 0;
235 236 237

  init_flags_ = VPX_CODEC_USE_PSNR;

Yaowu Xu's avatar
Yaowu Xu committed
238
  libaom_test::I420VideoSource video("hantro_collage_w352h288.yuv", 352, 288,
239
                                     timebase.den, timebase.num, 0, 40);
240 241 242

  // Error resilient mode ON.
  cfg_.g_error_resilient = 1;
243 244 245 246 247 248
  cfg_.kf_mode = VPX_KF_DISABLED;

  // Set an arbitrary set of error frames same as droppable frames.
  // In addition to isolated loss/drop, add a long consecutive series
  // (of size 9) of dropped frames.
  unsigned int num_droppable_frames = 11;
clang-format's avatar
clang-format committed
249 250
  unsigned int droppable_frame_list[] = { 5,  16, 22, 23, 24, 25,
                                          26, 27, 28, 29, 30 };
251 252 253 254
  SetDroppableFrames(num_droppable_frames, droppable_frame_list);
  SetErrorFrames(num_droppable_frames, droppable_frame_list);
  ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
  // Test that no mismatches have been found
clang-format's avatar
clang-format committed
255 256
  std::cout << "             Mismatch frames: " << GetMismatchFrames() << "\n";
  EXPECT_EQ(GetMismatchFrames(), (unsigned int)0);
257

258
  // Reset previously set of error/droppable frames.
259 260
  Reset();

261 262 263 264 265
#if 0
  // TODO(jkoleszar): This test is disabled for the time being as too
  // sensitive. It's not clear how to set a reasonable threshold for
  // this behavior.

266 267 268 269 270
  // Now set an arbitrary set of error frames that are non-droppable
  unsigned int num_error_frames = 3;
  unsigned int error_frame_list[] = {3, 10, 20};
  SetErrorFrames(num_error_frames, error_frame_list);
  ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
271

272 273 274 275 276 277 278 279
  // Test that dropping an arbitrary set of inter frames does not hurt too much
  // Note the Average Mismatch PSNR is the average of the PSNR between
  // decoded frame and encoder's version of the same frame for all frames
  // with mismatch.
  const double psnr_resilience_mismatch = GetAverageMismatchPsnr();
  std::cout << "             Mismatch PSNR: "
            << psnr_resilience_mismatch << "\n";
  EXPECT_GT(psnr_resilience_mismatch, 20.0);
280
#endif
281 282
}

283 284 285 286 287
// Check for successful decoding and no encoder/decoder mismatch
// if we lose (i.e., drop before decoding) the enhancement layer frames for a
// two layer temporal pattern. The base layer does not predict from the top
// layer, so successful decoding is expected.
TEST_P(ErrorResilienceTestLarge, 2LayersDropEnhancement) {
288
  // This test doesn't run if SVC is not supported.
clang-format's avatar
clang-format committed
289
  if (!svc_support_) return;
290

291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307
  const vpx_rational timebase = { 33333333, 1000000000 };
  cfg_.g_timebase = timebase;
  cfg_.rc_target_bitrate = 500;
  cfg_.g_lag_in_frames = 0;

  cfg_.rc_end_usage = VPX_CBR;
  // 2 Temporal layers, no spatial layers, CBR mode.
  cfg_.ss_number_layers = 1;
  cfg_.ts_number_layers = 2;
  cfg_.ts_rate_decimator[0] = 2;
  cfg_.ts_rate_decimator[1] = 1;
  cfg_.ts_periodicity = 2;
  cfg_.ts_target_bitrate[0] = 60 * cfg_.rc_target_bitrate / 100;
  cfg_.ts_target_bitrate[1] = cfg_.rc_target_bitrate;

  init_flags_ = VPX_CODEC_USE_PSNR;

Yaowu Xu's avatar
Yaowu Xu committed
308
  libaom_test::I420VideoSource video("hantro_collage_w352h288.yuv", 352, 288,
309 310 311 312 313
                                     timebase.den, timebase.num, 0, 40);

  // Error resilient mode ON.
  cfg_.g_error_resilient = 1;
  cfg_.kf_mode = VPX_KF_DISABLED;
Marco's avatar
Marco committed
314
  SetPatternSwitch(0);
315 316 317 318

  // The odd frames are the enhancement layer for 2 layer pattern, so set
  // those frames as droppable. Drop the last 7 frames.
  unsigned int num_droppable_frames = 7;
clang-format's avatar
clang-format committed
319
  unsigned int droppable_frame_list[] = { 27, 29, 31, 33, 35, 37, 39 };
320 321 322 323
  SetDroppableFrames(num_droppable_frames, droppable_frame_list);
  SetErrorFrames(num_droppable_frames, droppable_frame_list);
  ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
  // Test that no mismatches have been found
clang-format's avatar
clang-format committed
324 325
  std::cout << "             Mismatch frames: " << GetMismatchFrames() << "\n";
  EXPECT_EQ(GetMismatchFrames(), (unsigned int)0);
326 327

  // Reset previously set of error/droppable frames.
Marco's avatar
Marco committed
328 329 330 331 332 333 334
  Reset();
}

// Check for successful decoding and no encoder/decoder mismatch
// for a two layer temporal pattern, where at some point in the
// sequence, the LAST ref is not used anymore.
TEST_P(ErrorResilienceTestLarge, 2LayersNoRefLast) {
335
  // This test doesn't run if SVC is not supported.
clang-format's avatar
clang-format committed
336
  if (!svc_support_) return;
337

Marco's avatar
Marco committed
338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354
  const vpx_rational timebase = { 33333333, 1000000000 };
  cfg_.g_timebase = timebase;
  cfg_.rc_target_bitrate = 500;
  cfg_.g_lag_in_frames = 0;

  cfg_.rc_end_usage = VPX_CBR;
  // 2 Temporal layers, no spatial layers, CBR mode.
  cfg_.ss_number_layers = 1;
  cfg_.ts_number_layers = 2;
  cfg_.ts_rate_decimator[0] = 2;
  cfg_.ts_rate_decimator[1] = 1;
  cfg_.ts_periodicity = 2;
  cfg_.ts_target_bitrate[0] = 60 * cfg_.rc_target_bitrate / 100;
  cfg_.ts_target_bitrate[1] = cfg_.rc_target_bitrate;

  init_flags_ = VPX_CODEC_USE_PSNR;

Yaowu Xu's avatar
Yaowu Xu committed
355
  libaom_test::I420VideoSource video("hantro_collage_w352h288.yuv", 352, 288,
Marco's avatar
Marco committed
356 357 358 359 360 361 362 363 364
                                     timebase.den, timebase.num, 0, 100);

  // Error resilient mode ON.
  cfg_.g_error_resilient = 1;
  cfg_.kf_mode = VPX_KF_DISABLED;
  SetPatternSwitch(60);

  ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
  // Test that no mismatches have been found
clang-format's avatar
clang-format committed
365 366
  std::cout << "             Mismatch frames: " << GetMismatchFrames() << "\n";
  EXPECT_EQ(GetMismatchFrames(), (unsigned int)0);
Marco's avatar
Marco committed
367 368

  // Reset previously set of error/droppable frames.
369 370 371
  Reset();
}

clang-format's avatar
clang-format committed
372
class ErrorResilienceTestLargeCodecControls
Yaowu Xu's avatar
Yaowu Xu committed
373 374
    : public ::libaom_test::EncoderTest,
      public ::libaom_test::CodecTestWithParam<libaom_test::TestMode> {
Marco's avatar
Marco committed
375 376
 protected:
  ErrorResilienceTestLargeCodecControls()
clang-format's avatar
clang-format committed
377
      : EncoderTest(GET_PARAM(0)), encoding_mode_(GET_PARAM(1)) {
Marco's avatar
Marco committed
378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415
    Reset();
  }

  virtual ~ErrorResilienceTestLargeCodecControls() {}

  void Reset() {
    last_pts_ = 0;
    tot_frame_number_ = 0;
    // For testing up to 3 layers.
    for (int i = 0; i < 3; ++i) {
      bits_total_[i] = 0;
    }
    duration_ = 0.0;
  }

  virtual void SetUp() {
    InitializeConfig();
    SetMode(encoding_mode_);
  }

  //
  // Frame flags and layer id for temporal layers.
  //

  // For two layers, test pattern is:
  //   1     3
  // 0    2     .....
  // For three layers, test pattern is:
  //   1      3    5      7
  //      2           6
  // 0          4            ....
  // LAST is always update on base/layer 0, GOLDEN is updated on layer 1,
  // and ALTREF is updated on top layer for 3 layer pattern.
  int SetFrameFlags(int frame_num, int num_temp_layers) {
    int frame_flags = 0;
    if (num_temp_layers == 2) {
      if (frame_num % 2 == 0) {
        // Layer 0: predict from L and ARF, update L.
clang-format's avatar
clang-format committed
416 417
        frame_flags =
            VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF;
Marco's avatar
Marco committed
418 419 420 421 422 423 424 425 426 427 428 429
      } else {
        // Layer 1: predict from L, G and ARF, and update G.
        frame_flags = VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST |
                      VP8_EFLAG_NO_UPD_ENTROPY;
      }
    } else if (num_temp_layers == 3) {
      if (frame_num % 4 == 0) {
        // Layer 0: predict from L, update L.
        frame_flags = VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF |
                      VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF;
      } else if ((frame_num - 2) % 4 == 0) {
        // Layer 1: predict from L, G,  update G.
clang-format's avatar
clang-format committed
430 431 432
        frame_flags =
            VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_REF_ARF;
      } else if ((frame_num - 1) % 2 == 0) {
Marco's avatar
Marco committed
433 434 435 436 437 438 439 440 441 442 443 444 445
        // Layer 2: predict from L, G, ARF; update ARG.
        frame_flags = VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_LAST;
      }
    }
    return frame_flags;
  }

  int SetLayerId(int frame_num, int num_temp_layers) {
    int layer_id = 0;
    if (num_temp_layers == 2) {
      if (frame_num % 2 == 0) {
        layer_id = 0;
      } else {
clang-format's avatar
clang-format committed
446
        layer_id = 1;
Marco's avatar
Marco committed
447 448 449 450 451 452 453 454 455 456 457 458 459
      }
    } else if (num_temp_layers == 3) {
      if (frame_num % 4 == 0) {
        layer_id = 0;
      } else if ((frame_num - 2) % 4 == 0) {
        layer_id = 1;
      } else if ((frame_num - 1) % 2 == 0) {
        layer_id = 2;
      }
    }
    return layer_id;
  }

Yaowu Xu's avatar
Yaowu Xu committed
460 461
  virtual void PreEncodeFrameHook(libaom_test::VideoSource *video,
                                  libaom_test::Encoder *encoder) {
Marco's avatar
Marco committed
462
    if (cfg_.ts_number_layers > 1) {
clang-format's avatar
clang-format committed
463 464 465 466 467 468 469 470 471 472
      int layer_id = SetLayerId(video->frame(), cfg_.ts_number_layers);
      int frame_flags = SetFrameFlags(video->frame(), cfg_.ts_number_layers);
      if (video->frame() > 0) {
        encoder->Control(VP8E_SET_TEMPORAL_LAYER_ID, layer_id);
        encoder->Control(VP8E_SET_FRAME_FLAGS, frame_flags);
      }
      const vpx_rational_t tb = video->timebase();
      timebase_ = static_cast<double>(tb.num) / tb.den;
      duration_ = 0;
      return;
Marco's avatar
Marco committed
473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497
    }
  }

  virtual void FramePktHook(const vpx_codec_cx_pkt_t *pkt) {
    // Time since last timestamp = duration.
    vpx_codec_pts_t duration = pkt->data.frame.pts - last_pts_;
    if (duration > 1) {
      // Update counter for total number of frames (#frames input to encoder).
      // Needed for setting the proper layer_id below.
      tot_frame_number_ += static_cast<int>(duration - 1);
    }
    int layer = SetLayerId(tot_frame_number_, cfg_.ts_number_layers);
    const size_t frame_size_in_bits = pkt->data.frame.sz * 8;
    // Update the total encoded bits. For temporal layers, update the cumulative
    // encoded bits per layer.
    for (int i = layer; i < static_cast<int>(cfg_.ts_number_layers); ++i) {
      bits_total_[i] += frame_size_in_bits;
    }
    // Update the most recent pts.
    last_pts_ = pkt->data.frame.pts;
    ++tot_frame_number_;
  }

  virtual void EndPassHook(void) {
    duration_ = (last_pts_ + 1) * timebase_;
clang-format's avatar
clang-format committed
498
    if (cfg_.ts_number_layers > 1) {
Marco's avatar
Marco committed
499
      for (int layer = 0; layer < static_cast<int>(cfg_.ts_number_layers);
clang-format's avatar
clang-format committed
500
           ++layer) {
Marco's avatar
Marco committed
501 502
        if (bits_total_[layer]) {
          // Effective file datarate:
clang-format's avatar
clang-format committed
503 504
          effective_datarate_[layer] =
              (bits_total_[layer] / 1000.0) / duration_;
Marco's avatar
Marco committed
505 506 507 508 509 510
        }
      }
    }
  }

  double effective_datarate_[3];
clang-format's avatar
clang-format committed
511 512

 private:
Yaowu Xu's avatar
Yaowu Xu committed
513
  libaom_test::TestMode encoding_mode_;
clang-format's avatar
clang-format committed
514 515 516 517 518 519
  vpx_codec_pts_t last_pts_;
  double timebase_;
  int64_t bits_total_[3];
  double duration_;
  int tot_frame_number_;
};
Marco's avatar
Marco committed
520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549

// Check two codec controls used for:
// (1) for setting temporal layer id, and (2) for settings encoder flags.
// This test invokes those controls for each frame, and verifies encoder/decoder
// mismatch and basic rate control response.
// TODO(marpan): Maybe move this test to datarate_test.cc.
TEST_P(ErrorResilienceTestLargeCodecControls, CodecControl3TemporalLayers) {
  cfg_.rc_buf_initial_sz = 500;
  cfg_.rc_buf_optimal_sz = 500;
  cfg_.rc_buf_sz = 1000;
  cfg_.rc_dropframe_thresh = 1;
  cfg_.rc_min_quantizer = 2;
  cfg_.rc_max_quantizer = 56;
  cfg_.rc_end_usage = VPX_CBR;
  cfg_.rc_dropframe_thresh = 1;
  cfg_.g_lag_in_frames = 0;
  cfg_.kf_mode = VPX_KF_DISABLED;
  cfg_.g_error_resilient = 1;

  // 3 Temporal layers. Framerate decimation (4, 2, 1).
  cfg_.ts_number_layers = 3;
  cfg_.ts_rate_decimator[0] = 4;
  cfg_.ts_rate_decimator[1] = 2;
  cfg_.ts_rate_decimator[2] = 1;
  cfg_.ts_periodicity = 4;
  cfg_.ts_layer_id[0] = 0;
  cfg_.ts_layer_id[1] = 2;
  cfg_.ts_layer_id[2] = 1;
  cfg_.ts_layer_id[3] = 2;

Yaowu Xu's avatar
Yaowu Xu committed
550
  ::libaom_test::I420VideoSource video("hantro_collage_w352h288.yuv", 352, 288,
Marco's avatar
Marco committed
551 552 553 554 555 556 557 558 559 560 561 562
                                       30, 1, 0, 200);
  for (int i = 200; i <= 800; i += 200) {
    cfg_.rc_target_bitrate = i;
    Reset();
    // 40-20-40 bitrate allocation for 3 temporal layers.
    cfg_.ts_target_bitrate[0] = 40 * cfg_.rc_target_bitrate / 100;
    cfg_.ts_target_bitrate[1] = 60 * cfg_.rc_target_bitrate / 100;
    cfg_.ts_target_bitrate[2] = cfg_.rc_target_bitrate;
    ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
    for (int j = 0; j < static_cast<int>(cfg_.ts_number_layers); ++j) {
      ASSERT_GE(effective_datarate_[j], cfg_.ts_target_bitrate[j] * 0.75)
          << " The datarate for the file is lower than target by too much, "
clang-format's avatar
clang-format committed
563 564
             "for layer: "
          << j;
Marco's avatar
Marco committed
565 566
      ASSERT_LE(effective_datarate_[j], cfg_.ts_target_bitrate[j] * 1.25)
          << " The datarate for the file is greater than target by too much, "
clang-format's avatar
clang-format committed
567 568
             "for layer: "
          << j;
Marco's avatar
Marco committed
569 570 571 572
    }
  }
}

573 574 575
// SVC-related tests don't run for VP10 since SVC is not supported.
VP10_INSTANTIATE_TEST_CASE(ErrorResilienceTestLarge, ONE_PASS_TEST_MODES,
                           ::testing::Values(false));
576
}  // namespace