test/resize_test.cc

   1 /*
   2  *  Copyright (c) 2012 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 <climits>
  11 #include <vector>
  12 #include "third_party/googletest/src/include/gtest/gtest.h"
  13 #include "test/codec_factory.h"
  14 #include "test/encode_test_driver.h"
  15 #include "test/i420_video_source.h"
  16 #include "test/video_source.h"
  17 #include "test/util.h"
  18
  19 // Enable(1) or Disable(0) writing of the compressed bitstream.
  20 #define WRITE_COMPRESSED_STREAM 0
  21
  22 namespace {
  23
  24 #if WRITE_COMPRESSED_STREAM
  25 static void mem_put_le16(char *const mem, const unsigned int val) {
  26   mem[0] = val;
  27   mem[1] = val >> 8;
  28 }
  29
  30 static void mem_put_le32(char *const mem, const unsigned int val) {
  31   mem[0] = val;
  32   mem[1] = val >> 8;
  33   mem[2] = val >> 16;
  34   mem[3] = val >> 24;
  35 }
  36
  37 static void write_ivf_file_header(const vpx_codec_enc_cfg_t *const cfg,
  38                                   int frame_cnt, FILE *const outfile) {
  39   char header[32];
  40
  41   header[0] = 'D';
  42   header[1] = 'K';
  43   header[2] = 'I';
  44   header[3] = 'F';
  45   mem_put_le16(header + 4,  0);                   /* version */
  46   mem_put_le16(header + 6,  32);                  /* headersize */
  47   mem_put_le32(header + 8,  0x30395056);          /* fourcc (vp9) */
  48   mem_put_le16(header + 12, cfg->g_w);            /* width */
  49   mem_put_le16(header + 14, cfg->g_h);            /* height */
  50   mem_put_le32(header + 16, cfg->g_timebase.den); /* rate */
  51   mem_put_le32(header + 20, cfg->g_timebase.num); /* scale */
  52   mem_put_le32(header + 24, frame_cnt);           /* length */
  53   mem_put_le32(header + 28, 0);                   /* unused */
  54
  55   (void)fwrite(header, 1, 32, outfile);
  56 }
  57
  58 static void write_ivf_frame_size(FILE *const outfile, const size_t size) {
  59   char header[4];
  60   mem_put_le32(header, static_cast<unsigned int>(size));
  61   (void)fwrite(header, 1, 4, outfile);
  62 }
  63
  64 static void write_ivf_frame_header(const vpx_codec_cx_pkt_t *const pkt,
  65                                    FILE *const outfile) {
  66   char header[12];
  67   vpx_codec_pts_t pts;
  68
  69   if (pkt->kind != VPX_CODEC_CX_FRAME_PKT)
  70     return;
  71
  72   pts = pkt->data.frame.pts;
  73   mem_put_le32(header, static_cast<unsigned int>(pkt->data.frame.sz));
  74   mem_put_le32(header + 4, pts & 0xFFFFFFFF);
  75   mem_put_le32(header + 8, pts >> 32);
  76
  77   (void)fwrite(header, 1, 12, outfile);
  78 }
  79 #endif  // WRITE_COMPRESSED_STREAM
  80
  81 const unsigned int kInitialWidth = 320;
  82 const unsigned int kInitialHeight = 240;
  83
  84 struct FrameInfo {
  85   FrameInfo(vpx_codec_pts_t _pts, unsigned int _w, unsigned int _h)
  86       : pts(_pts), w(_w), h(_h) {}
  87
  88   vpx_codec_pts_t pts;
  89   unsigned int w;
  90   unsigned int h;
  91 };
  92
  93 unsigned int ScaleForFrameNumber(unsigned int frame, unsigned int val) {
  94   if (frame < 10)
  95     return val;
  96   if (frame < 20)
  97     return val / 2;
  98   if (frame < 30)
  99     return val * 2 / 3;
 100   if (frame < 40)
 101     return val / 4;
 102   if (frame < 50)
 103     return val * 7 / 8;
 104   return val;
 105 }
 106
 107 class ResizingVideoSource : public ::libvpx_test::DummyVideoSource {
 108  public:
 109   ResizingVideoSource() {
 110     SetSize(kInitialWidth, kInitialHeight);
 111     limit_ = 60;
 112   }
 113
 114   virtual ~ResizingVideoSource() {}
 115
 116  protected:
 117   virtual void Next() {
 118     ++frame_;
 119     SetSize(ScaleForFrameNumber(frame_, kInitialWidth),
 120             ScaleForFrameNumber(frame_, kInitialHeight));
 121     FillFrame();
 122   }
 123 };
 124
 125 class ResizeTest : public ::libvpx_test::EncoderTest,
 126   public ::libvpx_test::CodecTestWithParam<libvpx_test::TestMode> {
 127  protected:
 128   ResizeTest() : EncoderTest(GET_PARAM(0)) {}
 129
 130   virtual ~ResizeTest() {}
 131
 132   virtual void SetUp() {
 133     InitializeConfig();
 134     SetMode(GET_PARAM(1));
 135   }
 136
 137   virtual void DecompressedFrameHook(const vpx_image_t &img,
 138                                      vpx_codec_pts_t pts) {
 139     frame_info_list_.push_back(FrameInfo(pts, img.d_w, img.d_h));
 140   }
 141
 142   std::vector< FrameInfo > frame_info_list_;
 143 };
 144
 145 TEST_P(ResizeTest, TestExternalResizeWorks) {
 146   ResizingVideoSource video;
 147   cfg_.g_lag_in_frames = 0;
 148   ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
 149
 150   for (std::vector<FrameInfo>::const_iterator info = frame_info_list_.begin();
 151        info != frame_info_list_.end(); ++info) {
 152     const unsigned int frame = static_cast<unsigned>(info->pts);
 153     const unsigned int expected_w = ScaleForFrameNumber(frame, kInitialWidth);
 154     const unsigned int expected_h = ScaleForFrameNumber(frame, kInitialHeight);
 155
 156     EXPECT_EQ(expected_w, info->w)
 157         << "Frame " << frame << " had unexpected width";
 158     EXPECT_EQ(expected_h, info->h)
 159         << "Frame " << frame << " had unexpected height";
 160   }
 161 }
 162
 163 const unsigned int kStepDownFrame = 3;
 164 const unsigned int kStepUpFrame = 6;
 165
 166 class ResizeInternalTest : public ResizeTest {
 167  protected:
 168 #if WRITE_COMPRESSED_STREAM
 169   ResizeInternalTest()
 170       : ResizeTest(),
 171         frame0_psnr_(0.0),
 172         outfile_(NULL),
 173         out_frames_(0) {}
 174 #else
 175   ResizeInternalTest() : ResizeTest(), frame0_psnr_(0.0) {}
 176 #endif
 177
 178   virtual ~ResizeInternalTest() {}
 179
 180   virtual void BeginPassHook(unsigned int /*pass*/) {
 181 #if WRITE_COMPRESSED_STREAM
 182     outfile_ = fopen("vp90-2-05-resize.ivf", "wb");
 183 #endif
 184   }
 185
 186   virtual void EndPassHook() {
 187 #if WRITE_COMPRESSED_STREAM
 188     if (outfile_) {
 189       if (!fseek(outfile_, 0, SEEK_SET))
 190         write_ivf_file_header(&cfg_, out_frames_, outfile_);
 191       fclose(outfile_);
 192       outfile_ = NULL;
 193     }
 194 #endif
 195   }
 196
 197   virtual void PreEncodeFrameHook(libvpx_test::VideoSource *video,
 198                                   libvpx_test::Encoder *encoder) {
 199     if (change_config_) {
 200       int new_q = 60;
 201       if (video->frame() == 0) {
 202         struct vpx_scaling_mode mode = {VP8E_ONETWO, VP8E_ONETWO};
 203         encoder->Control(VP8E_SET_SCALEMODE, &mode);
 204       }
 205       if (video->frame() == 1) {
 206         struct vpx_scaling_mode mode = {VP8E_NORMAL, VP8E_NORMAL};
 207         encoder->Control(VP8E_SET_SCALEMODE, &mode);
 208         cfg_.rc_min_quantizer = cfg_.rc_max_quantizer = new_q;
 209         encoder->Config(&cfg_);
 210       }
 211     } else {
 212       if (video->frame() == kStepDownFrame) {
 213         struct vpx_scaling_mode mode = {VP8E_FOURFIVE, VP8E_THREEFIVE};
 214         encoder->Control(VP8E_SET_SCALEMODE, &mode);
 215       }
 216       if (video->frame() == kStepUpFrame) {
 217         struct vpx_scaling_mode mode = {VP8E_NORMAL, VP8E_NORMAL};
 218         encoder->Control(VP8E_SET_SCALEMODE, &mode);
 219       }
 220     }
 221   }
 222
 223   virtual void PSNRPktHook(const vpx_codec_cx_pkt_t *pkt) {
 224     if (!frame0_psnr_)
 225       frame0_psnr_ = pkt->data.psnr.psnr[0];
 226     EXPECT_NEAR(pkt->data.psnr.psnr[0], frame0_psnr_, 2.0);
 227   }
 228
 229 #if WRITE_COMPRESSED_STREAM
 230   virtual void FramePktHook(const vpx_codec_cx_pkt_t *pkt) {
 231     ++out_frames_;
 232
 233     // Write initial file header if first frame.
 234     if (pkt->data.frame.pts == 0)
 235       write_ivf_file_header(&cfg_, 0, outfile_);
 236
 237     // Write frame header and data.
 238     write_ivf_frame_header(pkt, outfile_);
 239     (void)fwrite(pkt->data.frame.buf, 1, pkt->data.frame.sz, outfile_);
 240   }
 241 #endif
 242
 243   double frame0_psnr_;
 244   bool change_config_;
 245 #if WRITE_COMPRESSED_STREAM
 246   FILE *outfile_;
 247   unsigned int out_frames_;
 248 #endif
 249 };
 250
 251 TEST_P(ResizeInternalTest, TestInternalResizeWorks) {
 252   ::libvpx_test::I420VideoSource video("hantro_collage_w352h288.yuv", 352, 288,
 253                                        30, 1, 0, 10);
 254   init_flags_ = VPX_CODEC_USE_PSNR;
 255   change_config_ = false;
 256
 257   // q picked such that initial keyframe on this clip is ~30dB PSNR
 258   cfg_.rc_min_quantizer = cfg_.rc_max_quantizer = 48;
 259
 260   // If the number of frames being encoded is smaller than g_lag_in_frames
 261   // the encoded frame is unavailable using the current API. Comparing
 262   // frames to detect mismatch would then not be possible. Set
 263   // g_lag_in_frames = 0 to get around this.
 264   cfg_.g_lag_in_frames = 0;
 265   ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
 266
 267   for (std::vector<FrameInfo>::const_iterator info = frame_info_list_.begin();
 268        info != frame_info_list_.end(); ++info) {
 269     const vpx_codec_pts_t pts = info->pts;
 270     if (pts >= kStepDownFrame && pts < kStepUpFrame) {
 271       ASSERT_EQ(282U, info->w) << "Frame " << pts << " had unexpected width";
 272       ASSERT_EQ(173U, info->h) << "Frame " << pts << " had unexpected height";
 273     } else {
 274       EXPECT_EQ(352U, info->w) << "Frame " << pts << " had unexpected width";
 275       EXPECT_EQ(288U, info->h) << "Frame " << pts << " had unexpected height";
 276     }
 277   }
 278 }
 279
 280 TEST_P(ResizeInternalTest, TestInternalResizeChangeConfig) {
 281   ::libvpx_test::I420VideoSource video("hantro_collage_w352h288.yuv", 352, 288,
 282                                        30, 1, 0, 10);
 283   cfg_.g_w = 352;
 284   cfg_.g_h = 288;
 285   change_config_ = true;
 286   ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
 287 }
 288
 289 class ResizeRealtimeTest : public ::libvpx_test::EncoderTest,
 290   public ::libvpx_test::CodecTestWith2Params<libvpx_test::TestMode, int> {
 291  protected:
 292   ResizeRealtimeTest() : EncoderTest(GET_PARAM(0)) {}
 293   virtual ~ResizeRealtimeTest() {}
 294
 295   virtual void PreEncodeFrameHook(libvpx_test::VideoSource *video,
 296                                   libvpx_test::Encoder *encoder) {
 297     if (video->frame() == 0) {
 298       encoder->Control(VP9E_SET_AQ_MODE, 3);
 299       encoder->Control(VP8E_SET_CPUUSED, set_cpu_used_);
 300     }
 301
 302     if (change_bitrate_ && video->frame() == 120) {
 303       change_bitrate_ = false;
 304       cfg_.rc_target_bitrate = 500;
 305       encoder->Config(&cfg_);
 306     }
 307   }
 308
 309   virtual void SetUp() {
 310     InitializeConfig();
 311     SetMode(GET_PARAM(1));
 312     set_cpu_used_ = GET_PARAM(2);
 313   }
 314
 315   virtual void DecompressedFrameHook(const vpx_image_t &img,
 316                                      vpx_codec_pts_t pts) {
 317     frame_info_list_.push_back(FrameInfo(pts, img.d_w, img.d_h));
 318   }
 319
 320   void DefaultConfig() {
 321     cfg_.rc_buf_initial_sz = 500;
 322     cfg_.rc_buf_optimal_sz = 600;
 323     cfg_.rc_buf_sz = 1000;
 324     cfg_.rc_min_quantizer = 2;
 325     cfg_.rc_max_quantizer = 56;
 326     cfg_.rc_undershoot_pct = 50;
 327     cfg_.rc_overshoot_pct = 50;
 328     cfg_.rc_end_usage = VPX_CBR;
 329     cfg_.kf_mode = VPX_KF_AUTO;
 330     cfg_.g_lag_in_frames = 0;
 331     cfg_.kf_min_dist = cfg_.kf_max_dist = 3000;
 332     // Enable dropped frames.
 333     cfg_.rc_dropframe_thresh = 1;
 334     // Enable error_resilience mode.
 335     cfg_.g_error_resilient  = 1;
 336     // Enable dynamic resizing.
 337     cfg_.rc_resize_allowed = 1;
 338     // Run at low bitrate.
 339     cfg_.rc_target_bitrate = 200;
 340   }
 341
 342   std::vector< FrameInfo > frame_info_list_;
 343   int set_cpu_used_;
 344   bool change_bitrate_;
 345 };
 346
 347 TEST_P(ResizeRealtimeTest, TestExternalResizeWorks) {
 348   ResizingVideoSource video;
 349   DefaultConfig();
 350   change_bitrate_ = false;
 351   ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
 352
 353   for (std::vector<FrameInfo>::const_iterator info = frame_info_list_.begin();
 354        info != frame_info_list_.end(); ++info) {
 355     const unsigned int frame = static_cast<unsigned>(info->pts);
 356     const unsigned int expected_w = ScaleForFrameNumber(frame, kInitialWidth);
 357     const unsigned int expected_h = ScaleForFrameNumber(frame, kInitialHeight);
 358
 359     EXPECT_EQ(expected_w, info->w)
 360         << "Frame " << frame << " had unexpected width";
 361     EXPECT_EQ(expected_h, info->h)
 362         << "Frame " << frame << " had unexpected height";
 363   }
 364 }
 365
 366 // Verify the dynamic resizer behavior for real time, 1 pass CBR mode.
 367 // Run at low bitrate, with resize_allowed = 1, and verify that we get
 368 // one resize down event.
 369 TEST_P(ResizeRealtimeTest, TestInternalResizeDown) {
 370   ::libvpx_test::I420VideoSource video("hantro_collage_w352h288.yuv", 352, 288,
 371                                        30, 1, 0, 299);
 372   DefaultConfig();
 373   cfg_.g_w = 352;
 374   cfg_.g_h = 288;
 375   change_bitrate_ = false;
 376   ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
 377
 378   unsigned int last_w = cfg_.g_w;
 379   unsigned int last_h = cfg_.g_h;
 380   int resize_count = 0;
 381   for (std::vector<FrameInfo>::const_iterator info = frame_info_list_.begin();
 382        info != frame_info_list_.end(); ++info) {
 383     if (info->w != last_w || info->h != last_h) {
 384       // Verify that resize down occurs.
 385       ASSERT_LT(info->w, last_w);
 386       ASSERT_LT(info->h, last_h);
 387       last_w = info->w;
 388       last_h = info->h;
 389       resize_count++;
 390     }
 391   }
 392
 393   // Verify that we get 1 resize down event in this test.
 394   ASSERT_EQ(1, resize_count) << "Resizing should occur.";
 395 }
 396
 397 // Verify the dynamic resizer behavior for real time, 1 pass CBR mode.
 398 // Start at low target bitrate, raise the bitrate in the middle of the clip,
 399 // scaling-up should occur after bitrate changed.
 400 TEST_P(ResizeRealtimeTest, TestInternalResizeDownUpChangeBitRate) {
 401   ::libvpx_test::I420VideoSource video("hantro_collage_w352h288.yuv", 352, 288,
 402                                        30, 1, 0, 359);
 403   DefaultConfig();
 404   cfg_.g_w = 352;
 405   cfg_.g_h = 288;
 406   change_bitrate_ = true;
 407   // Disable dropped frames.
 408   cfg_.rc_dropframe_thresh = 0;
 409   // Starting bitrate low.
 410   cfg_.rc_target_bitrate = 80;
 411   ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
 412
 413   unsigned int last_w = cfg_.g_w;
 414   unsigned int last_h = cfg_.g_h;
 415   int resize_count = 0;
 416   for (std::vector<FrameInfo>::const_iterator info = frame_info_list_.begin();
 417        info != frame_info_list_.end(); ++info) {
 418     if (info->w != last_w || info->h != last_h) {
 419       resize_count++;
 420       if (resize_count == 1) {
 421         // Verify that resize down occurs.
 422         ASSERT_LT(info->w, last_w);
 423         ASSERT_LT(info->h, last_h);
 424       } else if (resize_count == 2) {
 425         // Verify that resize up occurs.
 426         ASSERT_GT(info->w, last_w);
 427         ASSERT_GT(info->h, last_h);
 428       }
 429       last_w = info->w;
 430       last_h = info->h;
 431     }
 432   }
 433
 434   // Verify that we get 2 resize events in this test.
 435   ASSERT_EQ(resize_count, 2) << "Resizing should occur twice.";
 436 }
 437
 438 vpx_img_fmt_t CspForFrameNumber(int frame) {
 439   if (frame < 10)
 440     return VPX_IMG_FMT_I420;
 441   if (frame < 20)
 442     return VPX_IMG_FMT_I444;
 443   return VPX_IMG_FMT_I420;
 444 }
 445
 446 class ResizeCspTest : public ResizeTest {
 447  protected:
 448 #if WRITE_COMPRESSED_STREAM
 449   ResizeCspTest()
 450       : ResizeTest(),
 451         frame0_psnr_(0.0),
 452         outfile_(NULL),
 453         out_frames_(0) {}
 454 #else
 455   ResizeCspTest() : ResizeTest(), frame0_psnr_(0.0) {}
 456 #endif
 457
 458   virtual ~ResizeCspTest() {}
 459
 460   virtual void BeginPassHook(unsigned int /*pass*/) {
 461 #if WRITE_COMPRESSED_STREAM
 462     outfile_ = fopen("vp91-2-05-cspchape.ivf", "wb");
 463 #endif
 464   }
 465
 466   virtual void EndPassHook() {
 467 #if WRITE_COMPRESSED_STREAM
 468     if (outfile_) {
 469       if (!fseek(outfile_, 0, SEEK_SET))
 470         write_ivf_file_header(&cfg_, out_frames_, outfile_);
 471       fclose(outfile_);
 472       outfile_ = NULL;
 473     }
 474 #endif
 475   }
 476
 477   virtual void PreEncodeFrameHook(libvpx_test::VideoSource *video,
 478                                   libvpx_test::Encoder *encoder) {
 479     if (CspForFrameNumber(video->frame()) != VPX_IMG_FMT_I420 &&
 480         cfg_.g_profile != 1) {
 481       cfg_.g_profile = 1;
 482       encoder->Config(&cfg_);
 483     }
 484     if (CspForFrameNumber(video->frame()) == VPX_IMG_FMT_I420 &&
 485         cfg_.g_profile != 0) {
 486       cfg_.g_profile = 0;
 487       encoder->Config(&cfg_);
 488     }
 489   }
 490
 491   virtual void PSNRPktHook(const vpx_codec_cx_pkt_t *pkt) {
 492     if (!frame0_psnr_)
 493       frame0_psnr_ = pkt->data.psnr.psnr[0];
 494     EXPECT_NEAR(pkt->data.psnr.psnr[0], frame0_psnr_, 2.0);
 495   }
 496
 497 #if WRITE_COMPRESSED_STREAM
 498   virtual void FramePktHook(const vpx_codec_cx_pkt_t *pkt) {
 499     ++out_frames_;
 500
 501     // Write initial file header if first frame.
 502     if (pkt->data.frame.pts == 0)
 503       write_ivf_file_header(&cfg_, 0, outfile_);
 504
 505     // Write frame header and data.
 506     write_ivf_frame_header(pkt, outfile_);
 507     (void)fwrite(pkt->data.frame.buf, 1, pkt->data.frame.sz, outfile_);
 508   }
 509 #endif
 510
 511   double frame0_psnr_;
 512 #if WRITE_COMPRESSED_STREAM
 513   FILE *outfile_;
 514   unsigned int out_frames_;
 515 #endif
 516 };
 517
 518 class ResizingCspVideoSource : public ::libvpx_test::DummyVideoSource {
 519  public:
 520   ResizingCspVideoSource() {
 521     SetSize(kInitialWidth, kInitialHeight);
 522     limit_ = 30;
 523   }
 524
 525   virtual ~ResizingCspVideoSource() {}
 526
 527  protected:
 528   virtual void Next() {
 529     ++frame_;
 530     SetImageFormat(CspForFrameNumber(frame_));
 531     FillFrame();
 532   }
 533 };
 534
 535 TEST_P(ResizeCspTest, TestResizeCspWorks) {
 536   ResizingCspVideoSource video;
 537   init_flags_ = VPX_CODEC_USE_PSNR;
 538   cfg_.rc_min_quantizer = cfg_.rc_max_quantizer = 48;
 539   cfg_.g_lag_in_frames = 0;
 540   ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
 541 }
 542
 543 VP8_INSTANTIATE_TEST_CASE(ResizeTest, ONE_PASS_TEST_MODES);
 544 VP9_INSTANTIATE_TEST_CASE(ResizeTest,
 545                           ::testing::Values(::libvpx_test::kRealTime));
 546 VP9_INSTANTIATE_TEST_CASE(ResizeInternalTest,
 547                           ::testing::Values(::libvpx_test::kOnePassBest));
 548 VP9_INSTANTIATE_TEST_CASE(ResizeRealtimeTest,
 549                           ::testing::Values(::libvpx_test::kRealTime),
 550                           ::testing::Range(5, 9));
 551 VP9_INSTANTIATE_TEST_CASE(ResizeCspTest,
 552                           ::testing::Values(::libvpx_test::kRealTime));
 553 }  // namespace