test/resize_test.cc

   1 /*
   2  * Copyright (c) 2016, Alliance for Open Media. All rights reserved
   3  *
   4  * This source code is subject to the terms of the BSD 2 Clause License and
   5  * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
   6  * was not distributed with this source code in the LICENSE file, you can
   7  * obtain it at www.aomedia.org/license/software. If the Alliance for Open
   8  * Media Patent License 1.0 was not distributed with this source code in the
   9  * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
  10  */
  11
  12 #include <climits>
  13 #include <vector>
  14 #include "aom_dsp/aom_dsp_common.h"
  15 #include "third_party/googletest/src/googletest/include/gtest/gtest.h"
  16 #include "test/codec_factory.h"
  17 #include "test/encode_test_driver.h"
  18 #include "test/i420_video_source.h"
  19 #include "test/video_source.h"
  20 #include "test/util.h"
  21
  22 // Enable(1) or Disable(0) writing of the compressed bitstream.
  23 #define WRITE_COMPRESSED_STREAM 0
  24
  25 namespace {
  26
  27 #if WRITE_COMPRESSED_STREAM
  28 static void mem_put_le16(char *const mem, unsigned int val) {
  29   mem[0] = val;
  30   mem[1] = val >> 8;
  31 }
  32
  33 static void mem_put_le32(char *const mem, unsigned int val) {
  34   mem[0] = val;
  35   mem[1] = val >> 8;
  36   mem[2] = val >> 16;
  37   mem[3] = val >> 24;
  38 }
  39
  40 static void write_ivf_file_header(const aom_codec_enc_cfg_t *const cfg,
  41                                   int frame_cnt, FILE *const outfile) {
  42   char header[32];
  43
  44   header[0] = 'D';
  45   header[1] = 'K';
  46   header[2] = 'I';
  47   header[3] = 'F';
  48   mem_put_le16(header + 4, 0);                    /* version */
  49   mem_put_le16(header + 6, 32);                   /* headersize */
  50   mem_put_le32(header + 8, 0x30395056);           /* fourcc (av1) */
  51   mem_put_le16(header + 12, cfg->g_w);            /* width */
  52   mem_put_le16(header + 14, cfg->g_h);            /* height */
  53   mem_put_le32(header + 16, cfg->g_timebase.den); /* rate */
  54   mem_put_le32(header + 20, cfg->g_timebase.num); /* scale */
  55   mem_put_le32(header + 24, frame_cnt);           /* length */
  56   mem_put_le32(header + 28, 0);                   /* unused */
  57
  58   (void)fwrite(header, 1, 32, outfile);
  59 }
  60
  61 static void write_ivf_frame_size(FILE *const outfile, const size_t size) {
  62   char header[4];
  63   mem_put_le32(header, static_cast<unsigned int>(size));
  64   (void)fwrite(header, 1, 4, outfile);
  65 }
  66
  67 static void write_ivf_frame_header(const aom_codec_cx_pkt_t *const pkt,
  68                                    FILE *const outfile) {
  69   char header[12];
  70   aom_codec_pts_t pts;
  71
  72   if (pkt->kind != AOM_CODEC_CX_FRAME_PKT) return;
  73
  74   pts = pkt->data.frame.pts;
  75   mem_put_le32(header, static_cast<unsigned int>(pkt->data.frame.sz));
  76   mem_put_le32(header + 4, pts & 0xFFFFFFFF);
  77   mem_put_le32(header + 8, pts >> 32);
  78
  79   (void)fwrite(header, 1, 12, outfile);
  80 }
  81 #endif  // WRITE_COMPRESSED_STREAM
  82
  83 const unsigned int kInitialWidth = 320;
  84 const unsigned int kInitialHeight = 240;
  85
  86 struct FrameInfo {
  87   FrameInfo(aom_codec_pts_t _pts, unsigned int _w, unsigned int _h)
  88       : pts(_pts), w(_w), h(_h) {}
  89
  90   aom_codec_pts_t pts;
  91   unsigned int w;
  92   unsigned int h;
  93 };
  94
  95 void ScaleForFrameNumber(unsigned int frame, unsigned int initial_w,
  96                          unsigned int initial_h, unsigned int *w,
  97                          unsigned int *h, int flag_codec) {
  98   if (frame < 10) {
  99     *w = initial_w;
 100     *h = initial_h;
 101     return;
 102   }
 103   if (frame < 20) {
 104     *w = initial_w * 3 / 4;
 105     *h = initial_h * 3 / 4;
 106     return;
 107   }
 108   if (frame < 30) {
 109     *w = initial_w / 2;
 110     *h = initial_h / 2;
 111     return;
 112   }
 113   if (frame < 40) {
 114     *w = initial_w;
 115     *h = initial_h;
 116     return;
 117   }
 118   if (frame < 50) {
 119     *w = initial_w * 3 / 4;
 120     *h = initial_h * 3 / 4;
 121     return;
 122   }
 123   if (frame < 60) {
 124     *w = initial_w / 2;
 125     *h = initial_h / 2;
 126     return;
 127   }
 128   if (frame < 70) {
 129     *w = initial_w;
 130     *h = initial_h;
 131     return;
 132   }
 133   if (frame < 80) {
 134     *w = initial_w * 3 / 4;
 135     *h = initial_h * 3 / 4;
 136     return;
 137   }
 138   if (frame < 90) {
 139     *w = initial_w / 2;
 140     *h = initial_h / 2;
 141     return;
 142   }
 143   if (frame < 100) {
 144     *w = initial_w * 3 / 4;
 145     *h = initial_h * 3 / 4;
 146     return;
 147   }
 148   if (frame < 110) {
 149     *w = initial_w;
 150     *h = initial_h;
 151     return;
 152   }
 153   // Go down very low
 154   if (frame < 120) {
 155     *w = initial_w / 4;
 156     *h = initial_h / 4;
 157     return;
 158   }
 159   if (flag_codec == 1) {
 160     // Cases that only works for AV1.
 161     // For AV1: Swap width and height of original.
 162     if (frame < 140) {
 163       *w = initial_h;
 164       *h = initial_w;
 165       return;
 166     }
 167   }
 168   *w = initial_w;
 169   *h = initial_h;
 170 }
 171
 172 class ResizingVideoSource : public ::libaom_test::DummyVideoSource {
 173  public:
 174   ResizingVideoSource() {
 175     SetSize(kInitialWidth, kInitialHeight);
 176     limit_ = 150;
 177   }
 178   int flag_codec_;
 179   virtual ~ResizingVideoSource() {}
 180
 181  protected:
 182   virtual void Next() {
 183     ++frame_;
 184     unsigned int width;
 185     unsigned int height;
 186     ScaleForFrameNumber(frame_, kInitialWidth, kInitialHeight, &width, &height,
 187                         flag_codec_);
 188     SetSize(width, height);
 189     FillFrame();
 190   }
 191 };
 192
 193 class ResizeTest
 194     : public ::libaom_test::CodecTestWithParam<libaom_test::TestMode>,
 195       public ::libaom_test::EncoderTest {
 196  protected:
 197   ResizeTest() : EncoderTest(GET_PARAM(0)) {}
 198
 199   virtual ~ResizeTest() {}
 200
 201   virtual void SetUp() {
 202     InitializeConfig();
 203     SetMode(GET_PARAM(1));
 204   }
 205
 206   virtual void DecompressedFrameHook(const aom_image_t &img,
 207                                      aom_codec_pts_t pts) {
 208     frame_info_list_.push_back(FrameInfo(pts, img.d_w, img.d_h));
 209   }
 210
 211   std::vector<FrameInfo> frame_info_list_;
 212 };
 213
 214 TEST_P(ResizeTest, TestExternalResizeWorks) {
 215   ResizingVideoSource video;
 216   video.flag_codec_ = 0;
 217   cfg_.g_lag_in_frames = 0;
 218   // We use max(kInitialWidth, kInitialHeight) because during the test
 219   // the width and height of the frame are swapped
 220   cfg_.g_forced_max_frame_width = cfg_.g_forced_max_frame_height =
 221       AOMMAX(kInitialWidth, kInitialHeight);
 222   ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
 223
 224   // Check we decoded the same number of frames as we attempted to encode
 225   ASSERT_EQ(frame_info_list_.size(), video.limit());
 226
 227   for (std::vector<FrameInfo>::const_iterator info = frame_info_list_.begin();
 228        info != frame_info_list_.end(); ++info) {
 229     const unsigned int frame = static_cast<unsigned>(info->pts);
 230     unsigned int expected_w;
 231     unsigned int expected_h;
 232     ScaleForFrameNumber(frame, kInitialWidth, kInitialHeight, &expected_w,
 233                         &expected_h, 0);
 234     EXPECT_EQ(expected_w, info->w)
 235         << "Frame " << frame << " had unexpected width";
 236     EXPECT_EQ(expected_h, info->h)
 237         << "Frame " << frame << " had unexpected height";
 238   }
 239 }
 240
 241 const unsigned int kStepDownFrame = 3;
 242 const unsigned int kStepUpFrame = 6;
 243
 244 class ResizeInternalTestLarge : public ResizeTest {
 245  protected:
 246 #if WRITE_COMPRESSED_STREAM
 247   ResizeInternalTestLarge()
 248       : ResizeTest(), frame0_psnr_(0.0), outfile_(NULL), out_frames_(0) {}
 249 #else
 250   ResizeInternalTestLarge() : ResizeTest(), frame0_psnr_(0.0) {}
 251 #endif
 252
 253   virtual ~ResizeInternalTestLarge() {}
 254
 255   virtual void BeginPassHook(unsigned int /*pass*/) {
 256 #if WRITE_COMPRESSED_STREAM
 257     outfile_ = fopen("av10-2-05-resize.ivf", "wb");
 258 #endif
 259   }
 260
 261   virtual void EndPassHook() {
 262 #if WRITE_COMPRESSED_STREAM
 263     if (outfile_) {
 264       if (!fseek(outfile_, 0, SEEK_SET))
 265         write_ivf_file_header(&cfg_, out_frames_, outfile_);
 266       fclose(outfile_);
 267       outfile_ = NULL;
 268     }
 269 #endif
 270   }
 271
 272   virtual void PreEncodeFrameHook(libaom_test::VideoSource *video,
 273                                   libaom_test::Encoder *encoder) {
 274     if (change_config_) {
 275       int new_q = 60;
 276       if (video->frame() == 0) {
 277         struct aom_scaling_mode mode = { AOME_ONETWO, AOME_ONETWO };
 278         encoder->Control(AOME_SET_SCALEMODE, &mode);
 279       }
 280       if (video->frame() == 1) {
 281         struct aom_scaling_mode mode = { AOME_NORMAL, AOME_NORMAL };
 282         encoder->Control(AOME_SET_SCALEMODE, &mode);
 283         cfg_.rc_min_quantizer = cfg_.rc_max_quantizer = new_q;
 284         encoder->Config(&cfg_);
 285       }
 286     } else {
 287       if (video->frame() >= kStepDownFrame && video->frame() < kStepUpFrame) {
 288         struct aom_scaling_mode mode = { AOME_FOURFIVE, AOME_THREEFIVE };
 289         encoder->Control(AOME_SET_SCALEMODE, &mode);
 290       }
 291       if (video->frame() >= kStepUpFrame) {
 292         struct aom_scaling_mode mode = { AOME_NORMAL, AOME_NORMAL };
 293         encoder->Control(AOME_SET_SCALEMODE, &mode);
 294       }
 295     }
 296   }
 297
 298   virtual void PSNRPktHook(const aom_codec_cx_pkt_t *pkt) {
 299     if (frame0_psnr_ == 0.) frame0_psnr_ = pkt->data.psnr.psnr[0];
 300     EXPECT_NEAR(pkt->data.psnr.psnr[0], frame0_psnr_, 2.5);
 301   }
 302
 303 #if WRITE_COMPRESSED_STREAM
 304   virtual void FramePktHook(const aom_codec_cx_pkt_t *pkt) {
 305     ++out_frames_;
 306
 307     // Write initial file header if first frame.
 308     if (pkt->data.frame.pts == 0) write_ivf_file_header(&cfg_, 0, outfile_);
 309
 310     // Write frame header and data.
 311     write_ivf_frame_header(pkt, outfile_);
 312     (void)fwrite(pkt->data.frame.buf, 1, pkt->data.frame.sz, outfile_);
 313   }
 314 #endif
 315
 316   double frame0_psnr_;
 317   bool change_config_;
 318 #if WRITE_COMPRESSED_STREAM
 319   FILE *outfile_;
 320   unsigned int out_frames_;
 321 #endif
 322 };
 323
 324 TEST_P(ResizeInternalTestLarge, TestInternalResizeWorks) {
 325   ::libaom_test::I420VideoSource video("hantro_collage_w352h288.yuv", 352, 288,
 326                                        30, 1, 0, 10);
 327   init_flags_ = AOM_CODEC_USE_PSNR;
 328   change_config_ = false;
 329
 330   // q picked such that initial keyframe on this clip is ~30dB PSNR
 331   cfg_.rc_min_quantizer = cfg_.rc_max_quantizer = 48;
 332
 333   // If the number of frames being encoded is smaller than g_lag_in_frames
 334   // the encoded frame is unavailable using the current API. Comparing
 335   // frames to detect mismatch would then not be possible. Set
 336   // g_lag_in_frames = 0 to get around this.
 337   cfg_.g_lag_in_frames = 0;
 338   ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
 339
 340   for (std::vector<FrameInfo>::const_iterator info = frame_info_list_.begin();
 341        info != frame_info_list_.end(); ++info) {
 342   }
 343   for (std::vector<FrameInfo>::const_iterator info = frame_info_list_.begin();
 344        info != frame_info_list_.end(); ++info) {
 345     const aom_codec_pts_t pts = info->pts;
 346     if (pts >= kStepDownFrame && pts < kStepUpFrame) {
 347       ASSERT_EQ(282U, info->w) << "Frame " << pts << " had unexpected width";
 348       ASSERT_EQ(173U, info->h) << "Frame " << pts << " had unexpected height";
 349     } else {
 350       EXPECT_EQ(352U, info->w) << "Frame " << pts << " had unexpected width";
 351       EXPECT_EQ(288U, info->h) << "Frame " << pts << " had unexpected height";
 352     }
 353   }
 354 }
 355
 356 TEST_P(ResizeInternalTestLarge, TestInternalResizeChangeConfig) {
 357   ::libaom_test::I420VideoSource video("hantro_collage_w352h288.yuv", 352, 288,
 358                                        30, 1, 0, 10);
 359   cfg_.g_w = 352;
 360   cfg_.g_h = 288;
 361   change_config_ = true;
 362   ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
 363 }
 364
 365 class ResizeRealtimeTest
 366     : public ::libaom_test::CodecTestWith2Params<libaom_test::TestMode, int>,
 367       public ::libaom_test::EncoderTest {
 368  protected:
 369   ResizeRealtimeTest() : EncoderTest(GET_PARAM(0)) {}
 370   virtual ~ResizeRealtimeTest() {}
 371
 372   virtual void PreEncodeFrameHook(libaom_test::VideoSource *video,
 373                                   libaom_test::Encoder *encoder) {
 374     if (video->frame() == 0) {
 375       encoder->Control(AV1E_SET_AQ_MODE, 3);
 376       encoder->Control(AOME_SET_CPUUSED, set_cpu_used_);
 377     }
 378
 379     if (change_bitrate_ && video->frame() == 120) {
 380       change_bitrate_ = false;
 381       cfg_.rc_target_bitrate = 500;
 382       encoder->Config(&cfg_);
 383     }
 384   }
 385
 386   virtual void SetUp() {
 387     InitializeConfig();
 388     SetMode(GET_PARAM(1));
 389     set_cpu_used_ = GET_PARAM(2);
 390   }
 391
 392   virtual void DecompressedFrameHook(const aom_image_t &img,
 393                                      aom_codec_pts_t pts) {
 394     frame_info_list_.push_back(FrameInfo(pts, img.d_w, img.d_h));
 395   }
 396
 397   virtual void MismatchHook(const aom_image_t *img1, const aom_image_t *img2) {
 398     double mismatch_psnr = compute_psnr(img1, img2);
 399     mismatch_psnr_ += mismatch_psnr;
 400     ++mismatch_nframes_;
 401   }
 402
 403   unsigned int GetMismatchFrames() { return mismatch_nframes_; }
 404
 405   void DefaultConfig() {
 406     cfg_.rc_buf_initial_sz = 500;
 407     cfg_.rc_buf_optimal_sz = 600;
 408     cfg_.rc_buf_sz = 1000;
 409     cfg_.rc_min_quantizer = 2;
 410     cfg_.rc_max_quantizer = 56;
 411     cfg_.rc_undershoot_pct = 50;
 412     cfg_.rc_overshoot_pct = 50;
 413     cfg_.rc_end_usage = AOM_CBR;
 414     cfg_.kf_mode = AOM_KF_AUTO;
 415     cfg_.g_lag_in_frames = 0;
 416     cfg_.kf_min_dist = cfg_.kf_max_dist = 3000;
 417     // Enable dropped frames.
 418     cfg_.rc_dropframe_thresh = 1;
 419     // Disable error_resilience mode.
 420     cfg_.g_error_resilient = 0;
 421     // Run at low bitrate.
 422     cfg_.rc_target_bitrate = 200;
 423     // We use max(kInitialWidth, kInitialHeight) because during the test
 424     // the width and height of the frame are swapped
 425     cfg_.g_forced_max_frame_width = cfg_.g_forced_max_frame_height =
 426         AOMMAX(kInitialWidth, kInitialHeight);
 427   }
 428
 429   std::vector<FrameInfo> frame_info_list_;
 430   int set_cpu_used_;
 431   bool change_bitrate_;
 432   double mismatch_psnr_;
 433   int mismatch_nframes_;
 434 };
 435
 436 TEST_P(ResizeRealtimeTest, TestExternalResizeWorks) {
 437   ResizingVideoSource video;
 438   video.flag_codec_ = 1;
 439   DefaultConfig();
 440   change_bitrate_ = false;
 441   mismatch_psnr_ = 0.0;
 442   mismatch_nframes_ = 0;
 443   ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
 444
 445   // Check we decoded the same number of frames as we attempted to encode
 446   ASSERT_EQ(frame_info_list_.size(), video.limit());
 447
 448   for (std::vector<FrameInfo>::const_iterator info = frame_info_list_.begin();
 449        info != frame_info_list_.end(); ++info) {
 450     const unsigned int frame = static_cast<unsigned>(info->pts);
 451     unsigned int expected_w;
 452     unsigned int expected_h;
 453     ScaleForFrameNumber(frame, kInitialWidth, kInitialHeight, &expected_w,
 454                         &expected_h, 1);
 455     EXPECT_EQ(expected_w, info->w)
 456         << "Frame " << frame << " had unexpected width";
 457     EXPECT_EQ(expected_h, info->h)
 458         << "Frame " << frame << " had unexpected height";
 459     EXPECT_EQ(static_cast<unsigned int>(0), GetMismatchFrames());
 460   }
 461 }
 462
 463 // Verify the dynamic resizer behavior for real time, 1 pass CBR mode.
 464 // Run at low bitrate, with resize_allowed = 1, and verify that we get
 465 // one resize down event.
 466 TEST_P(ResizeRealtimeTest, DISABLED_TestInternalResizeDown) {
 467   ::libaom_test::I420VideoSource video("hantro_collage_w352h288.yuv", 352, 288,
 468                                        30, 1, 0, 299);
 469   DefaultConfig();
 470   cfg_.g_w = 352;
 471   cfg_.g_h = 288;
 472   change_bitrate_ = false;
 473   mismatch_psnr_ = 0.0;
 474   mismatch_nframes_ = 0;
 475   ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
 476
 477   unsigned int last_w = cfg_.g_w;
 478   unsigned int last_h = cfg_.g_h;
 479   int resize_count = 0;
 480   for (std::vector<FrameInfo>::const_iterator info = frame_info_list_.begin();
 481        info != frame_info_list_.end(); ++info) {
 482     if (info->w != last_w || info->h != last_h) {
 483       // Verify that resize down occurs.
 484       ASSERT_LT(info->w, last_w);
 485       ASSERT_LT(info->h, last_h);
 486       last_w = info->w;
 487       last_h = info->h;
 488       resize_count++;
 489     }
 490   }
 491
 492 #if CONFIG_AV1_DECODER
 493   // Verify that we get 1 resize down event in this test.
 494   ASSERT_EQ(1, resize_count) << "Resizing should occur.";
 495   EXPECT_EQ(static_cast<unsigned int>(0), GetMismatchFrames());
 496 #else
 497   printf("Warning: AV1 decoder unavailable, unable to check resize count!\n");
 498 #endif
 499 }
 500
 501 // Verify the dynamic resizer behavior for real time, 1 pass CBR mode.
 502 // Start at low target bitrate, raise the bitrate in the middle of the clip,
 503 // scaling-up should occur after bitrate changed.
 504 TEST_P(ResizeRealtimeTest, DISABLED_TestInternalResizeDownUpChangeBitRate) {
 505   ::libaom_test::I420VideoSource video("hantro_collage_w352h288.yuv", 352, 288,
 506                                        30, 1, 0, 359);
 507   DefaultConfig();
 508   cfg_.g_w = 352;
 509   cfg_.g_h = 288;
 510   change_bitrate_ = true;
 511   mismatch_psnr_ = 0.0;
 512   mismatch_nframes_ = 0;
 513   // Disable dropped frames.
 514   cfg_.rc_dropframe_thresh = 0;
 515   // Starting bitrate low.
 516   cfg_.rc_target_bitrate = 80;
 517   ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
 518
 519   unsigned int last_w = cfg_.g_w;
 520   unsigned int last_h = cfg_.g_h;
 521   int resize_count = 0;
 522   for (std::vector<FrameInfo>::const_iterator info = frame_info_list_.begin();
 523        info != frame_info_list_.end(); ++info) {
 524     if (info->w != last_w || info->h != last_h) {
 525       resize_count++;
 526       if (resize_count == 1) {
 527         // Verify that resize down occurs.
 528         ASSERT_LT(info->w, last_w);
 529         ASSERT_LT(info->h, last_h);
 530       } else if (resize_count == 2) {
 531         // Verify that resize up occurs.
 532         ASSERT_GT(info->w, last_w);
 533         ASSERT_GT(info->h, last_h);
 534       }
 535       last_w = info->w;
 536       last_h = info->h;
 537     }
 538   }
 539
 540 #if CONFIG_AV1_DECODER
 541   // Verify that we get 2 resize events in this test.
 542   ASSERT_EQ(resize_count, 2) << "Resizing should occur twice.";
 543   EXPECT_EQ(static_cast<unsigned int>(0), GetMismatchFrames());
 544 #else
 545   printf("Warning: AV1 decoder unavailable, unable to check resize count!\n");
 546 #endif
 547 }
 548
 549 aom_img_fmt_t CspForFrameNumber(int frame) {
 550   if (frame < 10) return AOM_IMG_FMT_I420;
 551   if (frame < 20) return AOM_IMG_FMT_I444;
 552   return AOM_IMG_FMT_I420;
 553 }
 554
 555 class ResizeCspTest : public ResizeTest {
 556  protected:
 557 #if WRITE_COMPRESSED_STREAM
 558   ResizeCspTest()
 559       : ResizeTest(), frame0_psnr_(0.0), outfile_(NULL), out_frames_(0) {}
 560 #else
 561   ResizeCspTest() : ResizeTest(), frame0_psnr_(0.0) {}
 562 #endif
 563
 564   virtual ~ResizeCspTest() {}
 565
 566   virtual void BeginPassHook(unsigned int /*pass*/) {
 567 #if WRITE_COMPRESSED_STREAM
 568     outfile_ = fopen("av11-2-05-cspchape.ivf", "wb");
 569 #endif
 570   }
 571
 572   virtual void EndPassHook() {
 573 #if WRITE_COMPRESSED_STREAM
 574     if (outfile_) {
 575       if (!fseek(outfile_, 0, SEEK_SET))
 576         write_ivf_file_header(&cfg_, out_frames_, outfile_);
 577       fclose(outfile_);
 578       outfile_ = NULL;
 579     }
 580 #endif
 581   }
 582
 583   virtual void PreEncodeFrameHook(libaom_test::VideoSource *video,
 584                                   libaom_test::Encoder *encoder) {
 585     if (CspForFrameNumber(video->frame()) != AOM_IMG_FMT_I420 &&
 586         cfg_.g_profile != 1) {
 587       cfg_.g_profile = 1;
 588       encoder->Config(&cfg_);
 589     }
 590     if (CspForFrameNumber(video->frame()) == AOM_IMG_FMT_I420 &&
 591         cfg_.g_profile != 0) {
 592       cfg_.g_profile = 0;
 593       encoder->Config(&cfg_);
 594     }
 595   }
 596
 597   virtual void PSNRPktHook(const aom_codec_cx_pkt_t *pkt) {
 598     if (frame0_psnr_ == 0.) frame0_psnr_ = pkt->data.psnr.psnr[0];
 599     EXPECT_NEAR(pkt->data.psnr.psnr[0], frame0_psnr_, 2.0);
 600   }
 601
 602 #if WRITE_COMPRESSED_STREAM
 603   virtual void FramePktHook(const aom_codec_cx_pkt_t *pkt) {
 604     ++out_frames_;
 605
 606     // Write initial file header if first frame.
 607     if (pkt->data.frame.pts == 0) write_ivf_file_header(&cfg_, 0, outfile_);
 608
 609     // Write frame header and data.
 610     write_ivf_frame_header(pkt, outfile_);
 611     (void)fwrite(pkt->data.frame.buf, 1, pkt->data.frame.sz, outfile_);
 612   }
 613 #endif
 614
 615   double frame0_psnr_;
 616 #if WRITE_COMPRESSED_STREAM
 617   FILE *outfile_;
 618   unsigned int out_frames_;
 619 #endif
 620 };
 621
 622 class ResizingCspVideoSource : public ::libaom_test::DummyVideoSource {
 623  public:
 624   ResizingCspVideoSource() {
 625     SetSize(kInitialWidth, kInitialHeight);
 626     limit_ = 30;
 627   }
 628
 629   virtual ~ResizingCspVideoSource() {}
 630
 631  protected:
 632   virtual void Next() {
 633     ++frame_;
 634     SetImageFormat(CspForFrameNumber(frame_));
 635     FillFrame();
 636   }
 637 };
 638
 639 #if (defined(DISABLE_TRELLISQ_SEARCH) && DISABLE_TRELLISQ_SEARCH)
 640 TEST_P(ResizeCspTest, DISABLED_TestResizeCspWorks) {
 641 #else
 642 TEST_P(ResizeCspTest, TestResizeCspWorks) {
 643 #endif
 644   ResizingCspVideoSource video;
 645   init_flags_ = AOM_CODEC_USE_PSNR;
 646   cfg_.rc_min_quantizer = cfg_.rc_max_quantizer = 48;
 647   cfg_.g_lag_in_frames = 0;
 648   ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
 649
 650   // Check we decoded the same number of frames as we attempted to encode
 651   ASSERT_EQ(frame_info_list_.size(), video.limit());
 652 }
 653
 654 AV1_INSTANTIATE_TEST_CASE(ResizeTest,
 655                           ::testing::Values(::libaom_test::kRealTime));
 656 AV1_INSTANTIATE_TEST_CASE(ResizeInternalTestLarge,
 657                           ::testing::Values(::libaom_test::kOnePassGood));
 658 AV1_INSTANTIATE_TEST_CASE(ResizeRealtimeTest,
 659                           ::testing::Values(::libaom_test::kRealTime),
 660                           ::testing::Range(5, 9));
 661 AV1_INSTANTIATE_TEST_CASE(ResizeCspTest,
 662                           ::testing::Values(::libaom_test::kRealTime));
 663 }  // namespace