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
22namespace {
23
24#if WRITE_COMPRESSED_STREAM
25static void mem_put_le16(char *const mem, const unsigned int val) {
26  mem[0] = val;
27  mem[1] = val >> 8;
28}
29
30static 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
37static 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
58static 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
64static 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
81const unsigned int kInitialWidth = 320;
82const unsigned int kInitialHeight = 240;
83
84unsigned int ScaleForFrameNumber(unsigned int frame, unsigned int val) {
85  if (frame < 10)
86    return val;
87  if (frame < 20)
88    return val / 2;
89  if (frame < 30)
90    return val * 2 / 3;
91  if (frame < 40)
92    return val / 4;
93  if (frame < 50)
94    return val * 7 / 8;
95  return val;
96}
97
98class ResizingVideoSource : public ::libvpx_test::DummyVideoSource {
99 public:
100  ResizingVideoSource() {
101    SetSize(kInitialWidth, kInitialHeight);
102    limit_ = 60;
103  }
104
105  virtual ~ResizingVideoSource() {}
106
107 protected:
108  virtual void Next() {
109    ++frame_;
110    SetSize(ScaleForFrameNumber(frame_, kInitialWidth),
111            ScaleForFrameNumber(frame_, kInitialHeight));
112    FillFrame();
113  }
114};
115
116class ResizeTest : public ::libvpx_test::EncoderTest,
117  public ::libvpx_test::CodecTestWithParam<libvpx_test::TestMode> {
118 protected:
119  ResizeTest() : EncoderTest(GET_PARAM(0)) {}
120
121  virtual ~ResizeTest() {}
122
123  struct FrameInfo {
124    FrameInfo(vpx_codec_pts_t _pts, unsigned int _w, unsigned int _h)
125        : pts(_pts), w(_w), h(_h) {}
126
127    vpx_codec_pts_t pts;
128    unsigned int w;
129    unsigned int h;
130  };
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
145TEST_P(ResizeTest, TestExternalResizeWorks) {
146  ResizingVideoSource video;
147  ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
148
149  for (std::vector<FrameInfo>::const_iterator info = frame_info_list_.begin();
150       info != frame_info_list_.end(); ++info) {
151    const unsigned int frame = static_cast<unsigned>(info->pts);
152    const unsigned int expected_w = ScaleForFrameNumber(frame, kInitialWidth);
153    const unsigned int expected_h = ScaleForFrameNumber(frame, kInitialHeight);
154
155    EXPECT_EQ(expected_w, info->w)
156        << "Frame " << frame << "had unexpected width";
157    EXPECT_EQ(expected_h, info->h)
158        << "Frame " << frame << "had unexpected height";
159  }
160}
161
162const unsigned int kStepDownFrame = 3;
163const unsigned int kStepUpFrame = 6;
164
165class ResizeInternalTest : public ResizeTest {
166 protected:
167#if WRITE_COMPRESSED_STREAM
168  ResizeInternalTest()
169      : ResizeTest(),
170        frame0_psnr_(0.0),
171        outfile_(NULL),
172        out_frames_(0) {}
173#else
174  ResizeInternalTest() : ResizeTest(), frame0_psnr_(0.0) {}
175#endif
176
177  virtual ~ResizeInternalTest() {}
178
179  virtual void BeginPassHook(unsigned int /*pass*/) {
180#if WRITE_COMPRESSED_STREAM
181    outfile_ = fopen("vp90-2-05-resize.ivf", "wb");
182#endif
183  }
184
185  virtual void EndPassHook() {
186#if WRITE_COMPRESSED_STREAM
187    if (outfile_) {
188      if (!fseek(outfile_, 0, SEEK_SET))
189        write_ivf_file_header(&cfg_, out_frames_, outfile_);
190      fclose(outfile_);
191      outfile_ = NULL;
192    }
193#endif
194  }
195
196  virtual void PreEncodeFrameHook(libvpx_test::VideoSource *video,
197                                  libvpx_test::Encoder *encoder) {
198    if (video->frame() == kStepDownFrame) {
199      struct vpx_scaling_mode mode = {VP8E_FOURFIVE, VP8E_THREEFIVE};
200      encoder->Control(VP8E_SET_SCALEMODE, &mode);
201    }
202    if (video->frame() == kStepUpFrame) {
203      struct vpx_scaling_mode mode = {VP8E_NORMAL, VP8E_NORMAL};
204      encoder->Control(VP8E_SET_SCALEMODE, &mode);
205    }
206  }
207
208  virtual void PSNRPktHook(const vpx_codec_cx_pkt_t *pkt) {
209    if (!frame0_psnr_)
210      frame0_psnr_ = pkt->data.psnr.psnr[0];
211    EXPECT_NEAR(pkt->data.psnr.psnr[0], frame0_psnr_, 2.0);
212  }
213
214  virtual void FramePktHook(const vpx_codec_cx_pkt_t *pkt) {
215#if WRITE_COMPRESSED_STREAM
216    ++out_frames_;
217
218    // Write initial file header if first frame.
219    if (pkt->data.frame.pts == 0)
220      write_ivf_file_header(&cfg_, 0, outfile_);
221
222    // Write frame header and data.
223    write_ivf_frame_header(pkt, outfile_);
224    (void)fwrite(pkt->data.frame.buf, 1, pkt->data.frame.sz, outfile_);
225#endif
226  }
227
228  double frame0_psnr_;
229#if WRITE_COMPRESSED_STREAM
230  FILE *outfile_;
231  unsigned int out_frames_;
232#endif
233};
234
235TEST_P(ResizeInternalTest, TestInternalResizeWorks) {
236  ::libvpx_test::I420VideoSource video("hantro_collage_w352h288.yuv", 352, 288,
237                                       30, 1, 0, 10);
238  init_flags_ = VPX_CODEC_USE_PSNR;
239
240  // q picked such that initial keyframe on this clip is ~30dB PSNR
241  cfg_.rc_min_quantizer = cfg_.rc_max_quantizer = 48;
242
243  // If the number of frames being encoded is smaller than g_lag_in_frames
244  // the encoded frame is unavailable using the current API. Comparing
245  // frames to detect mismatch would then not be possible. Set
246  // g_lag_in_frames = 0 to get around this.
247  cfg_.g_lag_in_frames = 0;
248  ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
249
250  for (std::vector<FrameInfo>::const_iterator info = frame_info_list_.begin();
251       info != frame_info_list_.end(); ++info) {
252    const vpx_codec_pts_t pts = info->pts;
253    if (pts >= kStepDownFrame && pts < kStepUpFrame) {
254      ASSERT_EQ(282U, info->w) << "Frame " << pts << " had unexpected width";
255      ASSERT_EQ(173U, info->h) << "Frame " << pts << " had unexpected height";
256    } else {
257      EXPECT_EQ(352U, info->w) << "Frame " << pts << " had unexpected width";
258      EXPECT_EQ(288U, info->h) << "Frame " << pts << " had unexpected height";
259    }
260  }
261}
262
263VP8_INSTANTIATE_TEST_CASE(ResizeTest, ONE_PASS_TEST_MODES);
264VP9_INSTANTIATE_TEST_CASE(ResizeInternalTest,
265                          ::testing::Values(::libvpx_test::kOnePassBest));
266}  // namespace
267