resize_test.cc 20.1 KB
Newer Older
1 2 3 4 5 6 7 8 9
/*
 *  Copyright (c) 2012 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 <stdio.h>

12 13
#include <climits>
#include <vector>
14 15
#include "third_party/googletest/src/include/gtest/gtest.h"
#include "test/codec_factory.h"
16
#include "test/encode_test_driver.h"
17
#include "test/i420_video_source.h"
18
#include "test/video_source.h"
19
#include "test/util.h"
20

21 22 23
// Enable(1) or Disable(0) writing of the compressed bitstream.
#define WRITE_COMPRESSED_STREAM 0

24 25
namespace {

26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46
#if WRITE_COMPRESSED_STREAM
static void mem_put_le16(char *const mem, const unsigned int val) {
  mem[0] = val;
  mem[1] = val >> 8;
}

static void mem_put_le32(char *const mem, const unsigned int val) {
  mem[0] = val;
  mem[1] = val >> 8;
  mem[2] = val >> 16;
  mem[3] = val >> 24;
}

static void write_ivf_file_header(const vpx_codec_enc_cfg_t *const cfg,
                                  int frame_cnt, FILE *const outfile) {
  char header[32];

  header[0] = 'D';
  header[1] = 'K';
  header[2] = 'I';
  header[3] = 'F';
clang-format's avatar
clang-format committed
47 48 49
  mem_put_le16(header + 4, 0);                    /* version */
  mem_put_le16(header + 6, 32);                   /* headersize */
  mem_put_le32(header + 8, 0x30395056);           /* fourcc (vp9) */
50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70
  mem_put_le16(header + 12, cfg->g_w);            /* width */
  mem_put_le16(header + 14, cfg->g_h);            /* height */
  mem_put_le32(header + 16, cfg->g_timebase.den); /* rate */
  mem_put_le32(header + 20, cfg->g_timebase.num); /* scale */
  mem_put_le32(header + 24, frame_cnt);           /* length */
  mem_put_le32(header + 28, 0);                   /* unused */

  (void)fwrite(header, 1, 32, outfile);
}

static void write_ivf_frame_size(FILE *const outfile, const size_t size) {
  char header[4];
  mem_put_le32(header, static_cast<unsigned int>(size));
  (void)fwrite(header, 1, 4, outfile);
}

static void write_ivf_frame_header(const vpx_codec_cx_pkt_t *const pkt,
                                   FILE *const outfile) {
  char header[12];
  vpx_codec_pts_t pts;

clang-format's avatar
clang-format committed
71
  if (pkt->kind != VPX_CODEC_CX_FRAME_PKT) return;
72 73 74 75 76 77 78 79 80 81

  pts = pkt->data.frame.pts;
  mem_put_le32(header, static_cast<unsigned int>(pkt->data.frame.sz));
  mem_put_le32(header + 4, pts & 0xFFFFFFFF);
  mem_put_le32(header + 8, pts >> 32);

  (void)fwrite(header, 1, 12, outfile);
}
#endif  // WRITE_COMPRESSED_STREAM

82 83 84
const unsigned int kInitialWidth = 320;
const unsigned int kInitialHeight = 240;

85 86 87 88 89 90 91 92 93
struct FrameInfo {
  FrameInfo(vpx_codec_pts_t _pts, unsigned int _w, unsigned int _h)
      : pts(_pts), w(_w), h(_h) {}

  vpx_codec_pts_t pts;
  unsigned int w;
  unsigned int h;
};

clang-format's avatar
clang-format committed
94 95 96
void ScaleForFrameNumber(unsigned int frame, unsigned int initial_w,
                         unsigned int initial_h, unsigned int *w,
                         unsigned int *h, int flag_codec) {
97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 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 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217
  if (frame < 10) {
    *w = initial_w;
    *h = initial_h;
    return;
  }
  if (frame < 20) {
    *w = initial_w * 3 / 4;
    *h = initial_h * 3 / 4;
    return;
  }
  if (frame < 30) {
    *w = initial_w / 2;
    *h = initial_h / 2;
    return;
  }
  if (frame < 40) {
    *w = initial_w;
    *h = initial_h;
    return;
  }
  if (frame < 50) {
    *w = initial_w * 3 / 4;
    *h = initial_h * 3 / 4;
    return;
  }
  if (frame < 60) {
    *w = initial_w / 2;
    *h = initial_h / 2;
    return;
  }
  if (frame < 70) {
    *w = initial_w;
    *h = initial_h;
    return;
  }
  if (frame < 80) {
    *w = initial_w * 3 / 4;
    *h = initial_h * 3 / 4;
    return;
  }
  if (frame < 90) {
    *w = initial_w / 2;
    *h = initial_h / 2;
    return;
  }
  if (frame < 100) {
    *w = initial_w * 3 / 4;
    *h = initial_h * 3 / 4;
    return;
  }
  if (frame < 110) {
    *w = initial_w;
    *h = initial_h;
    return;
  }
  if (frame < 120) {
    *w = initial_w * 3 / 4;
    *h = initial_h * 3 / 4;
    return;
  }
  if (frame < 130) {
    *w = initial_w / 2;
    *h = initial_h / 2;
    return;
  }
  if (frame < 140) {
    *w = initial_w * 3 / 4;
    *h = initial_h * 3 / 4;
    return;
  }
  if (frame < 150) {
    *w = initial_w;
    *h = initial_h;
    return;
  }
  if (frame < 160) {
    *w = initial_w * 3 / 4;
    *h = initial_h * 3 / 4;
    return;
  }
  if (frame < 170) {
    *w = initial_w / 2;
    *h = initial_h / 2;
    return;
  }
  if (frame < 180) {
    *w = initial_w * 3 / 4;
    *h = initial_h * 3 / 4;
    return;
  }
  if (frame < 190) {
    *w = initial_w;
    *h = initial_h;
    return;
  }
  if (frame < 200) {
    *w = initial_w * 3 / 4;
    *h = initial_h * 3 / 4;
    return;
  }
  if (frame < 210) {
    *w = initial_w / 2;
    *h = initial_h / 2;
    return;
  }
  if (frame < 220) {
    *w = initial_w * 3 / 4;
    *h = initial_h * 3 / 4;
    return;
  }
  if (frame < 230) {
    *w = initial_w;
    *h = initial_h;
    return;
  }
  if (frame < 240) {
    *w = initial_w * 3 / 4;
    *h = initial_h * 3 / 4;
    return;
  }
  if (frame < 250) {
clang-format's avatar
clang-format committed
218
    *w = initial_w / 2;
219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243
    *h = initial_h / 2;
    return;
  }
  if (frame < 260) {
    *w = initial_w;
    *h = initial_h;
    return;
  }
  // Go down very low.
  if (frame < 270) {
    *w = initial_w / 4;
    *h = initial_h / 4;
    return;
  }
  if (flag_codec == 1) {
    // Cases that only works for VP9.
    // For VP9: Swap width and height of original.
    if (frame < 320) {
      *w = initial_h;
      *h = initial_w;
      return;
    }
  }
  *w = initial_w;
  *h = initial_h;
244 245 246 247 248 249
}

class ResizingVideoSource : public ::libvpx_test::DummyVideoSource {
 public:
  ResizingVideoSource() {
    SetSize(kInitialWidth, kInitialHeight);
250
    limit_ = 350;
251
  }
252
  int flag_codec_;
253 254
  virtual ~ResizingVideoSource() {}

255 256 257
 protected:
  virtual void Next() {
    ++frame_;
258 259 260 261 262
    unsigned int width;
    unsigned int height;
    ScaleForFrameNumber(frame_, kInitialWidth, kInitialHeight, &width, &height,
                        flag_codec_);
    SetSize(width, height);
263 264 265 266
    FillFrame();
  }
};

clang-format's avatar
clang-format committed
267 268 269
class ResizeTest
    : public ::libvpx_test::EncoderTest,
      public ::libvpx_test::CodecTestWithParam<libvpx_test::TestMode> {
270
 protected:
271 272
  ResizeTest() : EncoderTest(GET_PARAM(0)) {}

273 274
  virtual ~ResizeTest() {}

275 276
  virtual void SetUp() {
    InitializeConfig();
277
    SetMode(GET_PARAM(1));
278 279
  }

280 281 282
  virtual void DecompressedFrameHook(const vpx_image_t &img,
                                     vpx_codec_pts_t pts) {
    frame_info_list_.push_back(FrameInfo(pts, img.d_w, img.d_h));
283 284
  }

clang-format's avatar
clang-format committed
285
  std::vector<FrameInfo> frame_info_list_;
286 287 288 289
};

TEST_P(ResizeTest, TestExternalResizeWorks) {
  ResizingVideoSource video;
290
  video.flag_codec_ = 0;
291
  cfg_.g_lag_in_frames = 0;
292 293
  ASSERT_NO_FATAL_FAILURE(RunLoop(&video));

294
  for (std::vector<FrameInfo>::const_iterator info = frame_info_list_.begin();
295
       info != frame_info_list_.end(); ++info) {
296
    const unsigned int frame = static_cast<unsigned>(info->pts);
297 298
    unsigned int expected_w;
    unsigned int expected_h;
clang-format's avatar
clang-format committed
299 300
    ScaleForFrameNumber(frame, kInitialWidth, kInitialHeight, &expected_w,
                        &expected_h, 0);
clang-format's avatar
clang-format committed
301 302 303 304
    EXPECT_EQ(expected_w, info->w)
        << "Frame " << frame << " had unexpected width";
    EXPECT_EQ(expected_h, info->h)
        << "Frame " << frame << " had unexpected height";
305 306 307
  }
}

308 309 310
const unsigned int kStepDownFrame = 3;
const unsigned int kStepUpFrame = 6;

311 312
class ResizeInternalTest : public ResizeTest {
 protected:
313 314
#if WRITE_COMPRESSED_STREAM
  ResizeInternalTest()
clang-format's avatar
clang-format committed
315
      : ResizeTest(), frame0_psnr_(0.0), outfile_(NULL), out_frames_(0) {}
316
#else
317
  ResizeInternalTest() : ResizeTest(), frame0_psnr_(0.0) {}
318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337
#endif

  virtual ~ResizeInternalTest() {}

  virtual void BeginPassHook(unsigned int /*pass*/) {
#if WRITE_COMPRESSED_STREAM
    outfile_ = fopen("vp90-2-05-resize.ivf", "wb");
#endif
  }

  virtual void EndPassHook() {
#if WRITE_COMPRESSED_STREAM
    if (outfile_) {
      if (!fseek(outfile_, 0, SEEK_SET))
        write_ivf_file_header(&cfg_, out_frames_, outfile_);
      fclose(outfile_);
      outfile_ = NULL;
    }
#endif
  }
338 339 340

  virtual void PreEncodeFrameHook(libvpx_test::VideoSource *video,
                                  libvpx_test::Encoder *encoder) {
341 342 343
    if (change_config_) {
      int new_q = 60;
      if (video->frame() == 0) {
clang-format's avatar
clang-format committed
344
        struct vpx_scaling_mode mode = { VP8E_ONETWO, VP8E_ONETWO };
345 346 347
        encoder->Control(VP8E_SET_SCALEMODE, &mode);
      }
      if (video->frame() == 1) {
clang-format's avatar
clang-format committed
348
        struct vpx_scaling_mode mode = { VP8E_NORMAL, VP8E_NORMAL };
349 350 351 352 353 354
        encoder->Control(VP8E_SET_SCALEMODE, &mode);
        cfg_.rc_min_quantizer = cfg_.rc_max_quantizer = new_q;
        encoder->Config(&cfg_);
      }
    } else {
      if (video->frame() == kStepDownFrame) {
clang-format's avatar
clang-format committed
355
        struct vpx_scaling_mode mode = { VP8E_FOURFIVE, VP8E_THREEFIVE };
356 357 358
        encoder->Control(VP8E_SET_SCALEMODE, &mode);
      }
      if (video->frame() == kStepUpFrame) {
clang-format's avatar
clang-format committed
359
        struct vpx_scaling_mode mode = { VP8E_NORMAL, VP8E_NORMAL };
360 361
        encoder->Control(VP8E_SET_SCALEMODE, &mode);
      }
362
    }
363
  }
364 365

  virtual void PSNRPktHook(const vpx_codec_cx_pkt_t *pkt) {
clang-format's avatar
clang-format committed
366
    if (frame0_psnr_ == 0.) frame0_psnr_ = pkt->data.psnr.psnr[0];
367
    EXPECT_NEAR(pkt->data.psnr.psnr[0], frame0_psnr_, 2.0);
368 369
  }

370
#if WRITE_COMPRESSED_STREAM
371
  virtual void FramePktHook(const vpx_codec_cx_pkt_t *pkt) {
372 373 374
    ++out_frames_;

    // Write initial file header if first frame.
clang-format's avatar
clang-format committed
375
    if (pkt->data.frame.pts == 0) write_ivf_file_header(&cfg_, 0, outfile_);
376 377 378 379 380

    // Write frame header and data.
    write_ivf_frame_header(pkt, outfile_);
    (void)fwrite(pkt->data.frame.buf, 1, pkt->data.frame.sz, outfile_);
  }
381
#endif
382

383
  double frame0_psnr_;
384
  bool change_config_;
385 386 387 388
#if WRITE_COMPRESSED_STREAM
  FILE *outfile_;
  unsigned int out_frames_;
#endif
389 390 391 392
};

TEST_P(ResizeInternalTest, TestInternalResizeWorks) {
  ::libvpx_test::I420VideoSource video("hantro_collage_w352h288.yuv", 352, 288,
393 394
                                       30, 1, 0, 10);
  init_flags_ = VPX_CODEC_USE_PSNR;
395
  change_config_ = false;
396

397 398 399
  // q picked such that initial keyframe on this clip is ~30dB PSNR
  cfg_.rc_min_quantizer = cfg_.rc_max_quantizer = 48;

400 401 402 403 404
  // If the number of frames being encoded is smaller than g_lag_in_frames
  // the encoded frame is unavailable using the current API. Comparing
  // frames to detect mismatch would then not be possible. Set
  // g_lag_in_frames = 0 to get around this.
  cfg_.g_lag_in_frames = 0;
405 406
  ASSERT_NO_FATAL_FAILURE(RunLoop(&video));

407
  for (std::vector<FrameInfo>::const_iterator info = frame_info_list_.begin();
408 409
       info != frame_info_list_.end(); ++info) {
    const vpx_codec_pts_t pts = info->pts;
410
    if (pts >= kStepDownFrame && pts < kStepUpFrame) {
411 412 413 414 415 416 417 418 419
      ASSERT_EQ(282U, info->w) << "Frame " << pts << " had unexpected width";
      ASSERT_EQ(173U, info->h) << "Frame " << pts << " had unexpected height";
    } else {
      EXPECT_EQ(352U, info->w) << "Frame " << pts << " had unexpected width";
      EXPECT_EQ(288U, info->h) << "Frame " << pts << " had unexpected height";
    }
  }
}

420 421 422 423 424 425 426 427 428
TEST_P(ResizeInternalTest, TestInternalResizeChangeConfig) {
  ::libvpx_test::I420VideoSource video("hantro_collage_w352h288.yuv", 352, 288,
                                       30, 1, 0, 10);
  cfg_.g_w = 352;
  cfg_.g_h = 288;
  change_config_ = true;
  ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
}

clang-format's avatar
clang-format committed
429 430 431
class ResizeRealtimeTest
    : public ::libvpx_test::EncoderTest,
      public ::libvpx_test::CodecTestWith2Params<libvpx_test::TestMode, int> {
432
 protected:
433 434
  ResizeRealtimeTest() : EncoderTest(GET_PARAM(0)) {}
  virtual ~ResizeRealtimeTest() {}
435 436 437 438 439 440 441

  virtual void PreEncodeFrameHook(libvpx_test::VideoSource *video,
                                  libvpx_test::Encoder *encoder) {
    if (video->frame() == 0) {
      encoder->Control(VP9E_SET_AQ_MODE, 3);
      encoder->Control(VP8E_SET_CPUUSED, set_cpu_used_);
    }
442 443 444 445 446 447

    if (change_bitrate_ && video->frame() == 120) {
      change_bitrate_ = false;
      cfg_.rc_target_bitrate = 500;
      encoder->Config(&cfg_);
    }
448 449 450 451 452 453 454 455 456 457 458 459 460
  }

  virtual void SetUp() {
    InitializeConfig();
    SetMode(GET_PARAM(1));
    set_cpu_used_ = GET_PARAM(2);
  }

  virtual void DecompressedFrameHook(const vpx_image_t &img,
                                     vpx_codec_pts_t pts) {
    frame_info_list_.push_back(FrameInfo(pts, img.d_w, img.d_h));
  }

clang-format's avatar
clang-format committed
461
  virtual void MismatchHook(const vpx_image_t *img1, const vpx_image_t *img2) {
462 463 464 465 466
    double mismatch_psnr = compute_psnr(img1, img2);
    mismatch_psnr_ += mismatch_psnr;
    ++mismatch_nframes_;
  }

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

469 470 471 472 473 474 475 476 477 478 479 480 481 482 483
  void DefaultConfig() {
    cfg_.rc_buf_initial_sz = 500;
    cfg_.rc_buf_optimal_sz = 600;
    cfg_.rc_buf_sz = 1000;
    cfg_.rc_min_quantizer = 2;
    cfg_.rc_max_quantizer = 56;
    cfg_.rc_undershoot_pct = 50;
    cfg_.rc_overshoot_pct = 50;
    cfg_.rc_end_usage = VPX_CBR;
    cfg_.kf_mode = VPX_KF_AUTO;
    cfg_.g_lag_in_frames = 0;
    cfg_.kf_min_dist = cfg_.kf_max_dist = 3000;
    // Enable dropped frames.
    cfg_.rc_dropframe_thresh = 1;
    // Enable error_resilience mode.
clang-format's avatar
clang-format committed
484
    cfg_.g_error_resilient = 1;
485 486 487 488 489 490
    // Enable dynamic resizing.
    cfg_.rc_resize_allowed = 1;
    // Run at low bitrate.
    cfg_.rc_target_bitrate = 200;
  }

clang-format's avatar
clang-format committed
491
  std::vector<FrameInfo> frame_info_list_;
492
  int set_cpu_used_;
493
  bool change_bitrate_;
494 495
  double mismatch_psnr_;
  int mismatch_nframes_;
496 497
};

498 499
TEST_P(ResizeRealtimeTest, TestExternalResizeWorks) {
  ResizingVideoSource video;
500
  video.flag_codec_ = 1;
501
  DefaultConfig();
502 503
  // Disable internal resize for this test.
  cfg_.rc_resize_allowed = 0;
504
  change_bitrate_ = false;
505 506
  mismatch_psnr_ = 0.0;
  mismatch_nframes_ = 0;
507 508 509 510 511
  ASSERT_NO_FATAL_FAILURE(RunLoop(&video));

  for (std::vector<FrameInfo>::const_iterator info = frame_info_list_.begin();
       info != frame_info_list_.end(); ++info) {
    const unsigned int frame = static_cast<unsigned>(info->pts);
512 513
    unsigned int expected_w;
    unsigned int expected_h;
clang-format's avatar
clang-format committed
514 515
    ScaleForFrameNumber(frame, kInitialWidth, kInitialHeight, &expected_w,
                        &expected_h, 1);
clang-format's avatar
clang-format committed
516 517 518 519
    EXPECT_EQ(expected_w, info->w)
        << "Frame " << frame << " had unexpected width";
    EXPECT_EQ(expected_h, info->h)
        << "Frame " << frame << " had unexpected height";
520
    EXPECT_EQ(static_cast<unsigned int>(0), GetMismatchFrames());
521 522 523
  }
}

524 525 526
// Verify the dynamic resizer behavior for real time, 1 pass CBR mode.
// Run at low bitrate, with resize_allowed = 1, and verify that we get
// one resize down event.
527
TEST_P(ResizeRealtimeTest, TestInternalResizeDown) {
528 529 530
  ::libvpx_test::I420VideoSource video("hantro_collage_w352h288.yuv", 352, 288,
                                       30, 1, 0, 299);
  DefaultConfig();
531 532
  cfg_.g_w = 352;
  cfg_.g_h = 288;
533
  change_bitrate_ = false;
534 535
  mismatch_psnr_ = 0.0;
  mismatch_nframes_ = 0;
536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552
  ASSERT_NO_FATAL_FAILURE(RunLoop(&video));

  unsigned int last_w = cfg_.g_w;
  unsigned int last_h = cfg_.g_h;
  int resize_count = 0;
  for (std::vector<FrameInfo>::const_iterator info = frame_info_list_.begin();
       info != frame_info_list_.end(); ++info) {
    if (info->w != last_w || info->h != last_h) {
      // Verify that resize down occurs.
      ASSERT_LT(info->w, last_w);
      ASSERT_LT(info->h, last_h);
      last_w = info->w;
      last_h = info->h;
      resize_count++;
    }
  }

553
#if CONFIG_VP9_DECODER
554 555
  // Verify that we get 1 resize down event in this test.
  ASSERT_EQ(1, resize_count) << "Resizing should occur.";
556
  EXPECT_EQ(static_cast<unsigned int>(0), GetMismatchFrames());
557 558 559
#else
  printf("Warning: VP9 decoder unavailable, unable to check resize count!\n");
#endif
560 561
}

562 563 564
// Verify the dynamic resizer behavior for real time, 1 pass CBR mode.
// Start at low target bitrate, raise the bitrate in the middle of the clip,
// scaling-up should occur after bitrate changed.
565
TEST_P(ResizeRealtimeTest, TestInternalResizeDownUpChangeBitRate) {
566
  ::libvpx_test::I420VideoSource video("hantro_collage_w352h288.yuv", 352, 288,
567
                                       30, 1, 0, 359);
568
  DefaultConfig();
569 570
  cfg_.g_w = 352;
  cfg_.g_h = 288;
571
  change_bitrate_ = true;
572 573
  mismatch_psnr_ = 0.0;
  mismatch_nframes_ = 0;
574 575 576
  // Disable dropped frames.
  cfg_.rc_dropframe_thresh = 0;
  // Starting bitrate low.
577
  cfg_.rc_target_bitrate = 80;
578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600
  ASSERT_NO_FATAL_FAILURE(RunLoop(&video));

  unsigned int last_w = cfg_.g_w;
  unsigned int last_h = cfg_.g_h;
  int resize_count = 0;
  for (std::vector<FrameInfo>::const_iterator info = frame_info_list_.begin();
       info != frame_info_list_.end(); ++info) {
    if (info->w != last_w || info->h != last_h) {
      resize_count++;
      if (resize_count == 1) {
        // Verify that resize down occurs.
        ASSERT_LT(info->w, last_w);
        ASSERT_LT(info->h, last_h);
      } else if (resize_count == 2) {
        // Verify that resize up occurs.
        ASSERT_GT(info->w, last_w);
        ASSERT_GT(info->h, last_h);
      }
      last_w = info->w;
      last_h = info->h;
    }
  }

601
#if CONFIG_VP9_DECODER
602 603
  // Verify that we get 2 resize events in this test.
  ASSERT_EQ(resize_count, 2) << "Resizing should occur twice.";
604
  EXPECT_EQ(static_cast<unsigned int>(0), GetMismatchFrames());
605 606 607
#else
  printf("Warning: VP9 decoder unavailable, unable to check resize count!\n");
#endif
608 609
}

610
vpx_img_fmt_t CspForFrameNumber(int frame) {
clang-format's avatar
clang-format committed
611 612
  if (frame < 10) return VPX_IMG_FMT_I420;
  if (frame < 20) return VPX_IMG_FMT_I444;
613 614 615 616 617 618 619
  return VPX_IMG_FMT_I420;
}

class ResizeCspTest : public ResizeTest {
 protected:
#if WRITE_COMPRESSED_STREAM
  ResizeCspTest()
clang-format's avatar
clang-format committed
620
      : ResizeTest(), frame0_psnr_(0.0), outfile_(NULL), out_frames_(0) {}
621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658
#else
  ResizeCspTest() : ResizeTest(), frame0_psnr_(0.0) {}
#endif

  virtual ~ResizeCspTest() {}

  virtual void BeginPassHook(unsigned int /*pass*/) {
#if WRITE_COMPRESSED_STREAM
    outfile_ = fopen("vp91-2-05-cspchape.ivf", "wb");
#endif
  }

  virtual void EndPassHook() {
#if WRITE_COMPRESSED_STREAM
    if (outfile_) {
      if (!fseek(outfile_, 0, SEEK_SET))
        write_ivf_file_header(&cfg_, out_frames_, outfile_);
      fclose(outfile_);
      outfile_ = NULL;
    }
#endif
  }

  virtual void PreEncodeFrameHook(libvpx_test::VideoSource *video,
                                  libvpx_test::Encoder *encoder) {
    if (CspForFrameNumber(video->frame()) != VPX_IMG_FMT_I420 &&
        cfg_.g_profile != 1) {
      cfg_.g_profile = 1;
      encoder->Config(&cfg_);
    }
    if (CspForFrameNumber(video->frame()) == VPX_IMG_FMT_I420 &&
        cfg_.g_profile != 0) {
      cfg_.g_profile = 0;
      encoder->Config(&cfg_);
    }
  }

  virtual void PSNRPktHook(const vpx_codec_cx_pkt_t *pkt) {
clang-format's avatar
clang-format committed
659
    if (frame0_psnr_ == 0.) frame0_psnr_ = pkt->data.psnr.psnr[0];
660 661 662 663 664 665 666 667
    EXPECT_NEAR(pkt->data.psnr.psnr[0], frame0_psnr_, 2.0);
  }

#if WRITE_COMPRESSED_STREAM
  virtual void FramePktHook(const vpx_codec_cx_pkt_t *pkt) {
    ++out_frames_;

    // Write initial file header if first frame.
clang-format's avatar
clang-format committed
668
    if (pkt->data.frame.pts == 0) write_ivf_file_header(&cfg_, 0, outfile_);
669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701

    // Write frame header and data.
    write_ivf_frame_header(pkt, outfile_);
    (void)fwrite(pkt->data.frame.buf, 1, pkt->data.frame.sz, outfile_);
  }
#endif

  double frame0_psnr_;
#if WRITE_COMPRESSED_STREAM
  FILE *outfile_;
  unsigned int out_frames_;
#endif
};

class ResizingCspVideoSource : public ::libvpx_test::DummyVideoSource {
 public:
  ResizingCspVideoSource() {
    SetSize(kInitialWidth, kInitialHeight);
    limit_ = 30;
  }

  virtual ~ResizingCspVideoSource() {}

 protected:
  virtual void Next() {
    ++frame_;
    SetImageFormat(CspForFrameNumber(frame_));
    FillFrame();
  }
};

TEST_P(ResizeCspTest, TestResizeCspWorks) {
  ResizingCspVideoSource video;
702
  init_flags_ = VPX_CODEC_USE_PSNR;
703 704 705 706 707
  cfg_.rc_min_quantizer = cfg_.rc_max_quantizer = 48;
  cfg_.g_lag_in_frames = 0;
  ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
}

708
VP8_INSTANTIATE_TEST_CASE(ResizeTest, ONE_PASS_TEST_MODES);
709 710
VP9_INSTANTIATE_TEST_CASE(ResizeTest,
                          ::testing::Values(::libvpx_test::kRealTime));
711 712
VP9_INSTANTIATE_TEST_CASE(ResizeInternalTest,
                          ::testing::Values(::libvpx_test::kOnePassBest));
713
VP9_INSTANTIATE_TEST_CASE(ResizeRealtimeTest,
714 715
                          ::testing::Values(::libvpx_test::kRealTime),
                          ::testing::Range(5, 9));
716 717
VP9_INSTANTIATE_TEST_CASE(ResizeCspTest,
                          ::testing::Values(::libvpx_test::kRealTime));
718
}  // namespace