1/*
2 *  Copyright (c) 2013 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
11#include <string>
12#include "third_party/googletest/src/include/gtest/gtest.h"
13#include "test/codec_factory.h"
14#include "test/decode_test_driver.h"
15#include "test/i420_video_source.h"
16
17#include "vp9/decoder/vp9_decoder.h"
18
19#include "vpx/svc_context.h"
20#include "vpx/vp8cx.h"
21#include "vpx/vpx_encoder.h"
22
23namespace {
24
25using libvpx_test::CodecFactory;
26using libvpx_test::Decoder;
27using libvpx_test::DxDataIterator;
28using libvpx_test::VP9CodecFactory;
29
30class SvcTest : public ::testing::Test {
31 protected:
32  static const uint32_t kWidth = 352;
33  static const uint32_t kHeight = 288;
34
35  SvcTest()
36      : codec_iface_(0),
37        test_file_name_("hantro_collage_w352h288.yuv"),
38        codec_initialized_(false),
39        decoder_(0) {
40    memset(&svc_, 0, sizeof(svc_));
41    memset(&codec_, 0, sizeof(codec_));
42    memset(&codec_enc_, 0, sizeof(codec_enc_));
43  }
44
45  virtual ~SvcTest() {}
46
47  virtual void SetUp() {
48    svc_.log_level = SVC_LOG_DEBUG;
49    svc_.log_print = 0;
50
51    codec_iface_ = vpx_codec_vp9_cx();
52    const vpx_codec_err_t res =
53        vpx_codec_enc_config_default(codec_iface_, &codec_enc_, 0);
54    EXPECT_EQ(VPX_CODEC_OK, res);
55
56    codec_enc_.g_w = kWidth;
57    codec_enc_.g_h = kHeight;
58    codec_enc_.g_timebase.num = 1;
59    codec_enc_.g_timebase.den = 60;
60    codec_enc_.kf_min_dist = 100;
61    codec_enc_.kf_max_dist = 100;
62
63    vpx_codec_dec_cfg_t dec_cfg = vpx_codec_dec_cfg_t();
64    VP9CodecFactory codec_factory;
65    decoder_ = codec_factory.CreateDecoder(dec_cfg, 0);
66  }
67
68  virtual void TearDown() {
69    ReleaseEncoder();
70    delete(decoder_);
71  }
72
73  void InitializeEncoder() {
74    const vpx_codec_err_t res =
75        vpx_svc_init(&svc_, &codec_, vpx_codec_vp9_cx(), &codec_enc_);
76    EXPECT_EQ(VPX_CODEC_OK, res);
77    vpx_codec_control(&codec_, VP8E_SET_CPUUSED, 4);  // Make the test faster
78    codec_initialized_ = true;
79  }
80
81  void ReleaseEncoder() {
82    vpx_svc_release(&svc_);
83    if (codec_initialized_) vpx_codec_destroy(&codec_);
84    codec_initialized_ = false;
85  }
86
87  void GetStatsData(std::string *const stats_buf) {
88    vpx_codec_iter_t iter = NULL;
89    const vpx_codec_cx_pkt_t *cx_pkt;
90
91    while ((cx_pkt = vpx_codec_get_cx_data(&codec_, &iter)) != NULL) {
92      if (cx_pkt->kind == VPX_CODEC_STATS_PKT) {
93        EXPECT_GT(cx_pkt->data.twopass_stats.sz, 0U);
94        ASSERT_TRUE(cx_pkt->data.twopass_stats.buf != NULL);
95        stats_buf->append(static_cast<char*>(cx_pkt->data.twopass_stats.buf),
96                          cx_pkt->data.twopass_stats.sz);
97      }
98    }
99  }
100
101  void Pass1EncodeNFrames(const int n, const int layers,
102                          std::string *const stats_buf) {
103    vpx_codec_err_t res;
104
105    ASSERT_GT(n, 0);
106    ASSERT_GT(layers, 0);
107    svc_.spatial_layers = layers;
108    codec_enc_.g_pass = VPX_RC_FIRST_PASS;
109    InitializeEncoder();
110
111    libvpx_test::I420VideoSource video(test_file_name_, kWidth, kHeight,
112                                       codec_enc_.g_timebase.den,
113                                       codec_enc_.g_timebase.num, 0, 30);
114    video.Begin();
115
116    for (int i = 0; i < n; ++i) {
117      res = vpx_svc_encode(&svc_, &codec_, video.img(), video.pts(),
118                           video.duration(), VPX_DL_GOOD_QUALITY);
119      ASSERT_EQ(VPX_CODEC_OK, res);
120      GetStatsData(stats_buf);
121      video.Next();
122    }
123
124    // Flush encoder and test EOS packet.
125    res = vpx_svc_encode(&svc_, &codec_, NULL, video.pts(),
126                         video.duration(), VPX_DL_GOOD_QUALITY);
127    ASSERT_EQ(VPX_CODEC_OK, res);
128    GetStatsData(stats_buf);
129
130    ReleaseEncoder();
131  }
132
133  void StoreFrames(const size_t max_frame_received,
134                   struct vpx_fixed_buf *const outputs,
135                   size_t *const frame_received) {
136    vpx_codec_iter_t iter = NULL;
137    const vpx_codec_cx_pkt_t *cx_pkt;
138
139    while ((cx_pkt = vpx_codec_get_cx_data(&codec_, &iter)) != NULL) {
140      if (cx_pkt->kind == VPX_CODEC_CX_FRAME_PKT) {
141        const size_t frame_size = cx_pkt->data.frame.sz;
142
143        EXPECT_GT(frame_size, 0U);
144        ASSERT_TRUE(cx_pkt->data.frame.buf != NULL);
145        ASSERT_LT(*frame_received, max_frame_received);
146
147        if (*frame_received == 0)
148          EXPECT_EQ(1, !!(cx_pkt->data.frame.flags & VPX_FRAME_IS_KEY));
149
150        outputs[*frame_received].buf = malloc(frame_size + 16);
151        ASSERT_TRUE(outputs[*frame_received].buf != NULL);
152        memcpy(outputs[*frame_received].buf, cx_pkt->data.frame.buf,
153               frame_size);
154        outputs[*frame_received].sz = frame_size;
155        ++(*frame_received);
156      }
157    }
158  }
159
160  void Pass2EncodeNFrames(std::string *const stats_buf,
161                          const int n, const int layers,
162                          struct vpx_fixed_buf *const outputs) {
163    vpx_codec_err_t res;
164    size_t frame_received = 0;
165
166    ASSERT_TRUE(outputs != NULL);
167    ASSERT_GT(n, 0);
168    ASSERT_GT(layers, 0);
169    svc_.spatial_layers = layers;
170    codec_enc_.rc_target_bitrate = 500;
171    if (codec_enc_.g_pass == VPX_RC_LAST_PASS) {
172      ASSERT_TRUE(stats_buf != NULL);
173      ASSERT_GT(stats_buf->size(), 0U);
174      codec_enc_.rc_twopass_stats_in.buf = &(*stats_buf)[0];
175      codec_enc_.rc_twopass_stats_in.sz = stats_buf->size();
176    }
177    InitializeEncoder();
178
179    libvpx_test::I420VideoSource video(test_file_name_, kWidth, kHeight,
180                                       codec_enc_.g_timebase.den,
181                                       codec_enc_.g_timebase.num, 0, 30);
182    video.Begin();
183
184    for (int i = 0; i < n; ++i) {
185      res = vpx_svc_encode(&svc_, &codec_, video.img(), video.pts(),
186                           video.duration(), VPX_DL_GOOD_QUALITY);
187      ASSERT_EQ(VPX_CODEC_OK, res);
188      StoreFrames(n, outputs, &frame_received);
189      video.Next();
190    }
191
192    // Flush encoder.
193    res = vpx_svc_encode(&svc_, &codec_, NULL, 0,
194                         video.duration(), VPX_DL_GOOD_QUALITY);
195    EXPECT_EQ(VPX_CODEC_OK, res);
196    StoreFrames(n, outputs, &frame_received);
197
198    EXPECT_EQ(frame_received, static_cast<size_t>(n));
199
200    ReleaseEncoder();
201  }
202
203  void DecodeNFrames(const struct vpx_fixed_buf *const inputs, const int n) {
204    int decoded_frames = 0;
205    int received_frames = 0;
206
207    ASSERT_TRUE(inputs != NULL);
208    ASSERT_GT(n, 0);
209
210    for (int i = 0; i < n; ++i) {
211      ASSERT_TRUE(inputs[i].buf != NULL);
212      ASSERT_GT(inputs[i].sz, 0U);
213      const vpx_codec_err_t res_dec =
214          decoder_->DecodeFrame(static_cast<const uint8_t *>(inputs[i].buf),
215                                inputs[i].sz);
216      ASSERT_EQ(VPX_CODEC_OK, res_dec) << decoder_->DecodeError();
217      ++decoded_frames;
218
219      DxDataIterator dec_iter = decoder_->GetDxData();
220      while (dec_iter.Next() != NULL) {
221        ++received_frames;
222      }
223    }
224    EXPECT_EQ(decoded_frames, n);
225    EXPECT_EQ(received_frames, n);
226  }
227
228  void DropLayersAndMakeItVP9Comaptible(struct vpx_fixed_buf *const inputs,
229                                        const int num_super_frames,
230                                        const int remained_spatial_layers,
231                                        const bool is_multiple_frame_contexts) {
232    ASSERT_TRUE(inputs != NULL);
233    ASSERT_GT(num_super_frames, 0);
234    ASSERT_GT(remained_spatial_layers, 0);
235
236    for (int i = 0; i < num_super_frames; ++i) {
237      uint32_t frame_sizes[8] = {0};
238      int frame_count = 0;
239      int frames_found = 0;
240      int frame;
241      ASSERT_TRUE(inputs[i].buf != NULL);
242      ASSERT_GT(inputs[i].sz, 0U);
243
244      vpx_codec_err_t res =
245          vp9_parse_superframe_index(static_cast<const uint8_t*>(inputs[i].buf),
246                                     inputs[i].sz, frame_sizes, &frame_count,
247                                     NULL, NULL);
248      ASSERT_EQ(VPX_CODEC_OK, res);
249
250      if (frame_count == 0) {
251        // There's no super frame but only a single frame.
252        ASSERT_EQ(1, remained_spatial_layers);
253        if (is_multiple_frame_contexts) {
254          // Make a new super frame.
255          uint8_t marker = 0xc1;
256          unsigned int mask;
257          int mag;
258
259          // Choose the magnitude.
260          for (mag = 0, mask = 0xff; mag < 4; ++mag) {
261            if (inputs[i].sz < mask)
262              break;
263            mask <<= 8;
264            mask |= 0xff;
265          }
266          marker |= mag << 3;
267          int index_sz = 2 + (mag + 1) * 2;
268
269          inputs[i].buf = realloc(inputs[i].buf, inputs[i].sz + index_sz + 16);
270          ASSERT_TRUE(inputs[i].buf != NULL);
271          uint8_t *frame_data = static_cast<uint8_t*>(inputs[i].buf);
272          frame_data[0] &= ~2;      // Set the show_frame flag to 0.
273          frame_data += inputs[i].sz;
274          // Add an one byte frame with show_existing_frame.
275          *frame_data++ = 0x88;
276
277          // Write the super frame index.
278          *frame_data++ = marker;
279
280          frame_sizes[0] = inputs[i].sz;
281          frame_sizes[1] = 1;
282          for (int j = 0; j < 2; ++j) {
283            unsigned int this_sz = frame_sizes[j];
284            for (int k = 0; k <= mag; k++) {
285              *frame_data++ = this_sz & 0xff;
286              this_sz >>= 8;
287            }
288          }
289          *frame_data++ = marker;
290          inputs[i].sz += index_sz + 1;
291        }
292      } else {
293        // Found a super frame.
294        uint8_t *frame_data = static_cast<uint8_t*>(inputs[i].buf);
295        uint8_t *frame_start = frame_data;
296        for (frame = 0; frame < frame_count; ++frame) {
297          // Looking for a visible frame.
298          if (frame_data[0] & 0x02) {
299            ++frames_found;
300            if (frames_found == remained_spatial_layers)
301              break;
302          }
303          frame_data += frame_sizes[frame];
304        }
305        ASSERT_LT(frame, frame_count) << "Couldn't find a visible frame. "
306            << "remained_spatial_layers: " << remained_spatial_layers
307            << "    super_frame: " << i
308            << "    is_multiple_frame_context: " << is_multiple_frame_contexts;
309        if (frame == frame_count - 1 && !is_multiple_frame_contexts)
310          continue;
311
312        frame_data += frame_sizes[frame];
313
314        // We need to add one more frame for multiple frame contexts.
315        if (is_multiple_frame_contexts)
316          ++frame;
317        uint8_t marker =
318            static_cast<const uint8_t*>(inputs[i].buf)[inputs[i].sz - 1];
319        const uint32_t mag = ((marker >> 3) & 0x3) + 1;
320        const size_t index_sz = 2 + mag * frame_count;
321        const size_t new_index_sz = 2 + mag * (frame + 1);
322        marker &= 0x0f8;
323        marker |= frame;
324
325        // Copy existing frame sizes.
326        memmove(frame_data + (is_multiple_frame_contexts ? 2 : 1),
327                frame_start + inputs[i].sz - index_sz + 1, new_index_sz - 2);
328        if (is_multiple_frame_contexts) {
329          // Add a one byte frame with flag show_existing_frame.
330          *frame_data++ = 0x88 | (remained_spatial_layers - 1);
331        }
332        // New marker.
333        frame_data[0] = marker;
334        frame_data += (mag * (frame + 1) + 1);
335
336        if (is_multiple_frame_contexts) {
337          // Write the frame size for the one byte frame.
338          frame_data -= mag;
339          *frame_data++ = 1;
340          for (uint32_t j = 1; j < mag; ++j) {
341            *frame_data++ = 0;
342          }
343        }
344
345        *frame_data++ = marker;
346        inputs[i].sz = frame_data - frame_start;
347
348        if (is_multiple_frame_contexts) {
349          // Change the show frame flag to 0 for all frames.
350          for (int j = 0; j < frame; ++j) {
351            frame_start[0] &= ~2;
352            frame_start += frame_sizes[j];
353          }
354        }
355      }
356    }
357  }
358
359  void FreeBitstreamBuffers(struct vpx_fixed_buf *const inputs, const int n) {
360    ASSERT_TRUE(inputs != NULL);
361    ASSERT_GT(n, 0);
362
363    for (int i = 0; i < n; ++i) {
364      free(inputs[i].buf);
365      inputs[i].buf = NULL;
366      inputs[i].sz = 0;
367    }
368  }
369
370  SvcContext svc_;
371  vpx_codec_ctx_t codec_;
372  struct vpx_codec_enc_cfg codec_enc_;
373  vpx_codec_iface_t *codec_iface_;
374  std::string test_file_name_;
375  bool codec_initialized_;
376  Decoder *decoder_;
377};
378
379TEST_F(SvcTest, SvcInit) {
380  // test missing parameters
381  vpx_codec_err_t res = vpx_svc_init(NULL, &codec_, codec_iface_, &codec_enc_);
382  EXPECT_EQ(VPX_CODEC_INVALID_PARAM, res);
383  res = vpx_svc_init(&svc_, NULL, codec_iface_, &codec_enc_);
384  EXPECT_EQ(VPX_CODEC_INVALID_PARAM, res);
385  res = vpx_svc_init(&svc_, &codec_, NULL, &codec_enc_);
386  EXPECT_EQ(VPX_CODEC_INVALID_PARAM, res);
387
388  res = vpx_svc_init(&svc_, &codec_, codec_iface_, NULL);
389  EXPECT_EQ(VPX_CODEC_INVALID_PARAM, res);
390
391  svc_.spatial_layers = 6;  // too many layers
392  res = vpx_svc_init(&svc_, &codec_, codec_iface_, &codec_enc_);
393  EXPECT_EQ(VPX_CODEC_INVALID_PARAM, res);
394
395  svc_.spatial_layers = 0;  // use default layers
396  InitializeEncoder();
397  EXPECT_EQ(VPX_SS_DEFAULT_LAYERS, svc_.spatial_layers);
398}
399
400TEST_F(SvcTest, InitTwoLayers) {
401  svc_.spatial_layers = 2;
402  InitializeEncoder();
403}
404
405TEST_F(SvcTest, InvalidOptions) {
406  vpx_codec_err_t res = vpx_svc_set_options(&svc_, NULL);
407  EXPECT_EQ(VPX_CODEC_INVALID_PARAM, res);
408
409  res = vpx_svc_set_options(&svc_, "not-an-option=1");
410  EXPECT_EQ(VPX_CODEC_OK, res);
411  res = vpx_svc_init(&svc_, &codec_, vpx_codec_vp9_cx(), &codec_enc_);
412  EXPECT_EQ(VPX_CODEC_INVALID_PARAM, res);
413}
414
415TEST_F(SvcTest, SetLayersOption) {
416  vpx_codec_err_t res = vpx_svc_set_options(&svc_, "spatial-layers=3");
417  EXPECT_EQ(VPX_CODEC_OK, res);
418  InitializeEncoder();
419  EXPECT_EQ(3, svc_.spatial_layers);
420}
421
422TEST_F(SvcTest, SetMultipleOptions) {
423  vpx_codec_err_t res =
424      vpx_svc_set_options(&svc_, "spatial-layers=2 scale-factors=1/3,2/3");
425  EXPECT_EQ(VPX_CODEC_OK, res);
426  InitializeEncoder();
427  EXPECT_EQ(2, svc_.spatial_layers);
428}
429
430TEST_F(SvcTest, SetScaleFactorsOption) {
431  svc_.spatial_layers = 2;
432  vpx_codec_err_t res =
433      vpx_svc_set_options(&svc_, "scale-factors=not-scale-factors");
434  EXPECT_EQ(VPX_CODEC_OK, res);
435  res = vpx_svc_init(&svc_, &codec_, vpx_codec_vp9_cx(), &codec_enc_);
436  EXPECT_EQ(VPX_CODEC_INVALID_PARAM, res);
437
438  res = vpx_svc_set_options(&svc_, "scale-factors=1/3, 3*3");
439  EXPECT_EQ(VPX_CODEC_OK, res);
440  res = vpx_svc_init(&svc_, &codec_, vpx_codec_vp9_cx(), &codec_enc_);
441  EXPECT_EQ(VPX_CODEC_INVALID_PARAM, res);
442
443  res = vpx_svc_set_options(&svc_, "scale-factors=1/3");
444  EXPECT_EQ(VPX_CODEC_OK, res);
445  res = vpx_svc_init(&svc_, &codec_, vpx_codec_vp9_cx(), &codec_enc_);
446  EXPECT_EQ(VPX_CODEC_INVALID_PARAM, res);
447
448  res = vpx_svc_set_options(&svc_, "scale-factors=1/3,2/3");
449  EXPECT_EQ(VPX_CODEC_OK, res);
450  InitializeEncoder();
451}
452
453TEST_F(SvcTest, SetQuantizersOption) {
454  svc_.spatial_layers = 2;
455  vpx_codec_err_t res = vpx_svc_set_options(&svc_, "max-quantizers=nothing");
456  EXPECT_EQ(VPX_CODEC_OK, res);
457  res = vpx_svc_init(&svc_, &codec_, vpx_codec_vp9_cx(), &codec_enc_);
458  EXPECT_EQ(VPX_CODEC_INVALID_PARAM, res);
459
460  res = vpx_svc_set_options(&svc_, "min-quantizers=nothing");
461  EXPECT_EQ(VPX_CODEC_OK, res);
462  res = vpx_svc_init(&svc_, &codec_, vpx_codec_vp9_cx(), &codec_enc_);
463  EXPECT_EQ(VPX_CODEC_INVALID_PARAM, res);
464
465  res = vpx_svc_set_options(&svc_, "max-quantizers=40");
466  EXPECT_EQ(VPX_CODEC_OK, res);
467  res = vpx_svc_init(&svc_, &codec_, vpx_codec_vp9_cx(), &codec_enc_);
468  EXPECT_EQ(VPX_CODEC_INVALID_PARAM, res);
469
470  res = vpx_svc_set_options(&svc_, "min-quantizers=40");
471  EXPECT_EQ(VPX_CODEC_OK, res);
472  res = vpx_svc_init(&svc_, &codec_, vpx_codec_vp9_cx(), &codec_enc_);
473  EXPECT_EQ(VPX_CODEC_INVALID_PARAM, res);
474
475  res = vpx_svc_set_options(&svc_, "max-quantizers=30,30 min-quantizers=40,40");
476  EXPECT_EQ(VPX_CODEC_OK, res);
477  res = vpx_svc_init(&svc_, &codec_, vpx_codec_vp9_cx(), &codec_enc_);
478  EXPECT_EQ(VPX_CODEC_INVALID_PARAM, res);
479
480  res = vpx_svc_set_options(&svc_, "max-quantizers=40,40 min-quantizers=30,30");
481  InitializeEncoder();
482}
483
484TEST_F(SvcTest, SetAutoAltRefOption) {
485  svc_.spatial_layers = 5;
486  vpx_codec_err_t res = vpx_svc_set_options(&svc_, "auto-alt-refs=none");
487  EXPECT_EQ(VPX_CODEC_OK, res);
488  res = vpx_svc_init(&svc_, &codec_, vpx_codec_vp9_cx(), &codec_enc_);
489  EXPECT_EQ(VPX_CODEC_INVALID_PARAM, res);
490
491  res = vpx_svc_set_options(&svc_, "auto-alt-refs=1,1,1,1,0");
492  EXPECT_EQ(VPX_CODEC_OK, res);
493  res = vpx_svc_init(&svc_, &codec_, vpx_codec_vp9_cx(), &codec_enc_);
494  EXPECT_EQ(VPX_CODEC_INVALID_PARAM, res);
495
496  vpx_svc_set_options(&svc_, "auto-alt-refs=0,1,1,1,0");
497  InitializeEncoder();
498}
499
500// Test that decoder can handle an SVC frame as the first frame in a sequence.
501TEST_F(SvcTest, OnePassEncodeOneFrame) {
502  codec_enc_.g_pass = VPX_RC_ONE_PASS;
503  vpx_fixed_buf output = {0};
504  Pass2EncodeNFrames(NULL, 1, 2, &output);
505  DecodeNFrames(&output, 1);
506  FreeBitstreamBuffers(&output, 1);
507}
508
509TEST_F(SvcTest, OnePassEncodeThreeFrames) {
510  codec_enc_.g_pass = VPX_RC_ONE_PASS;
511  vpx_fixed_buf outputs[3];
512  memset(&outputs[0], 0, sizeof(outputs));
513  Pass2EncodeNFrames(NULL, 3, 2, &outputs[0]);
514  DecodeNFrames(&outputs[0], 3);
515  FreeBitstreamBuffers(&outputs[0], 3);
516}
517
518TEST_F(SvcTest, TwoPassEncode10Frames) {
519  // First pass encode
520  std::string stats_buf;
521  Pass1EncodeNFrames(10, 2, &stats_buf);
522
523  // Second pass encode
524  codec_enc_.g_pass = VPX_RC_LAST_PASS;
525  vpx_fixed_buf outputs[10];
526  memset(&outputs[0], 0, sizeof(outputs));
527  Pass2EncodeNFrames(&stats_buf, 10, 2, &outputs[0]);
528  DecodeNFrames(&outputs[0], 10);
529  FreeBitstreamBuffers(&outputs[0], 10);
530}
531
532TEST_F(SvcTest, TwoPassEncode20FramesWithAltRef) {
533  // First pass encode
534  std::string stats_buf;
535  Pass1EncodeNFrames(20, 2, &stats_buf);
536
537  // Second pass encode
538  codec_enc_.g_pass = VPX_RC_LAST_PASS;
539  vpx_svc_set_options(&svc_, "auto-alt-refs=1,1");
540  vpx_fixed_buf outputs[20];
541  memset(&outputs[0], 0, sizeof(outputs));
542  Pass2EncodeNFrames(&stats_buf, 20, 2, &outputs[0]);
543  DecodeNFrames(&outputs[0], 20);
544  FreeBitstreamBuffers(&outputs[0], 20);
545}
546
547TEST_F(SvcTest, TwoPassEncode2SpatialLayersDecodeBaseLayerOnly) {
548  // First pass encode
549  std::string stats_buf;
550  Pass1EncodeNFrames(10, 2, &stats_buf);
551
552  // Second pass encode
553  codec_enc_.g_pass = VPX_RC_LAST_PASS;
554  vpx_svc_set_options(&svc_, "auto-alt-refs=1,1");
555  vpx_fixed_buf outputs[10];
556  memset(&outputs[0], 0, sizeof(outputs));
557  Pass2EncodeNFrames(&stats_buf, 10, 2, &outputs[0]);
558  DropLayersAndMakeItVP9Comaptible(&outputs[0], 10, 1, false);
559  DecodeNFrames(&outputs[0], 10);
560  FreeBitstreamBuffers(&outputs[0], 10);
561}
562
563TEST_F(SvcTest, TwoPassEncode5SpatialLayersDecode54321Layers) {
564  // First pass encode
565  std::string stats_buf;
566  Pass1EncodeNFrames(10, 5, &stats_buf);
567
568  // Second pass encode
569  codec_enc_.g_pass = VPX_RC_LAST_PASS;
570  vpx_svc_set_options(&svc_, "auto-alt-refs=0,1,1,1,0");
571  vpx_fixed_buf outputs[10];
572  memset(&outputs[0], 0, sizeof(outputs));
573  Pass2EncodeNFrames(&stats_buf, 10, 5, &outputs[0]);
574
575  DecodeNFrames(&outputs[0], 10);
576  DropLayersAndMakeItVP9Comaptible(&outputs[0], 10, 4, false);
577  DecodeNFrames(&outputs[0], 10);
578  DropLayersAndMakeItVP9Comaptible(&outputs[0], 10, 3, false);
579  DecodeNFrames(&outputs[0], 10);
580  DropLayersAndMakeItVP9Comaptible(&outputs[0], 10, 2, false);
581  DecodeNFrames(&outputs[0], 10);
582  DropLayersAndMakeItVP9Comaptible(&outputs[0], 10, 1, false);
583  DecodeNFrames(&outputs[0], 10);
584
585  FreeBitstreamBuffers(&outputs[0], 10);
586}
587
588TEST_F(SvcTest, TwoPassEncode2SNRLayers) {
589  // First pass encode
590  std::string stats_buf;
591  vpx_svc_set_options(&svc_, "scale-factors=1/1,1/1");
592  Pass1EncodeNFrames(20, 2, &stats_buf);
593
594  // Second pass encode
595  codec_enc_.g_pass = VPX_RC_LAST_PASS;
596  vpx_svc_set_options(&svc_,
597                      "auto-alt-refs=1,1 scale-factors=1/1,1/1");
598  vpx_fixed_buf outputs[20];
599  memset(&outputs[0], 0, sizeof(outputs));
600  Pass2EncodeNFrames(&stats_buf, 20, 2, &outputs[0]);
601  DecodeNFrames(&outputs[0], 20);
602  FreeBitstreamBuffers(&outputs[0], 20);
603}
604
605TEST_F(SvcTest, TwoPassEncode3SNRLayersDecode321Layers) {
606  // First pass encode
607  std::string stats_buf;
608  vpx_svc_set_options(&svc_, "scale-factors=1/1,1/1,1/1");
609  Pass1EncodeNFrames(20, 3, &stats_buf);
610
611  // Second pass encode
612  codec_enc_.g_pass = VPX_RC_LAST_PASS;
613  vpx_svc_set_options(&svc_,
614                      "auto-alt-refs=1,1,1 scale-factors=1/1,1/1,1/1");
615  vpx_fixed_buf outputs[20];
616  memset(&outputs[0], 0, sizeof(outputs));
617  Pass2EncodeNFrames(&stats_buf, 20, 3, &outputs[0]);
618  DecodeNFrames(&outputs[0], 20);
619  DropLayersAndMakeItVP9Comaptible(&outputs[0], 20, 2, false);
620  DecodeNFrames(&outputs[0], 20);
621  DropLayersAndMakeItVP9Comaptible(&outputs[0], 20, 1, false);
622  DecodeNFrames(&outputs[0], 20);
623
624  FreeBitstreamBuffers(&outputs[0], 20);
625}
626
627TEST_F(SvcTest, SetMultipleFrameContextsOption) {
628  svc_.spatial_layers = 5;
629  vpx_codec_err_t res =
630      vpx_svc_set_options(&svc_, "multi-frame-contexts=1");
631  EXPECT_EQ(VPX_CODEC_OK, res);
632  res = vpx_svc_init(&svc_, &codec_, vpx_codec_vp9_cx(), &codec_enc_);
633  EXPECT_EQ(VPX_CODEC_INVALID_PARAM, res);
634
635  svc_.spatial_layers = 2;
636  res = vpx_svc_set_options(&svc_, "multi-frame-contexts=1");
637  InitializeEncoder();
638}
639
640TEST_F(SvcTest, TwoPassEncode2SpatialLayersWithMultipleFrameContexts) {
641  // First pass encode
642  std::string stats_buf;
643  Pass1EncodeNFrames(10, 2, &stats_buf);
644
645  // Second pass encode
646  codec_enc_.g_pass = VPX_RC_LAST_PASS;
647  codec_enc_.g_error_resilient = 0;
648  vpx_svc_set_options(&svc_, "auto-alt-refs=1,1 multi-frame-contexts=1");
649  vpx_fixed_buf outputs[10];
650  memset(&outputs[0], 0, sizeof(outputs));
651  Pass2EncodeNFrames(&stats_buf, 10, 2, &outputs[0]);
652  DropLayersAndMakeItVP9Comaptible(&outputs[0], 10, 2, true);
653  DecodeNFrames(&outputs[0], 10);
654  FreeBitstreamBuffers(&outputs[0], 10);
655}
656
657TEST_F(SvcTest,
658       TwoPassEncode2SpatialLayersWithMultipleFrameContextsDecodeBaselayer) {
659  // First pass encode
660  std::string stats_buf;
661  Pass1EncodeNFrames(10, 2, &stats_buf);
662
663  // Second pass encode
664  codec_enc_.g_pass = VPX_RC_LAST_PASS;
665  codec_enc_.g_error_resilient = 0;
666  vpx_svc_set_options(&svc_, "auto-alt-refs=1,1 multi-frame-contexts=1");
667  vpx_fixed_buf outputs[10];
668  memset(&outputs[0], 0, sizeof(outputs));
669  Pass2EncodeNFrames(&stats_buf, 10, 2, &outputs[0]);
670  DropLayersAndMakeItVP9Comaptible(&outputs[0], 10, 1, true);
671  DecodeNFrames(&outputs[0], 10);
672  FreeBitstreamBuffers(&outputs[0], 10);
673}
674
675TEST_F(SvcTest, TwoPassEncode2SNRLayersWithMultipleFrameContexts) {
676  // First pass encode
677  std::string stats_buf;
678  vpx_svc_set_options(&svc_, "scale-factors=1/1,1/1");
679  Pass1EncodeNFrames(10, 2, &stats_buf);
680
681  // Second pass encode
682  codec_enc_.g_pass = VPX_RC_LAST_PASS;
683  codec_enc_.g_error_resilient = 0;
684  vpx_svc_set_options(&svc_, "auto-alt-refs=1,1 scale-factors=1/1,1/1 "
685                      "multi-frame-contexts=1");
686  vpx_fixed_buf outputs[10];
687  memset(&outputs[0], 0, sizeof(outputs));
688  Pass2EncodeNFrames(&stats_buf, 10, 2, &outputs[0]);
689  DropLayersAndMakeItVP9Comaptible(&outputs[0], 10, 2, true);
690  DecodeNFrames(&outputs[0], 10);
691  FreeBitstreamBuffers(&outputs[0], 10);
692}
693
694TEST_F(SvcTest,
695       TwoPassEncode3SNRLayersWithMultipleFrameContextsDecode321Layer) {
696  // First pass encode
697  std::string stats_buf;
698  vpx_svc_set_options(&svc_, "scale-factors=1/1,1/1,1/1");
699  Pass1EncodeNFrames(10, 3, &stats_buf);
700
701  // Second pass encode
702  codec_enc_.g_pass = VPX_RC_LAST_PASS;
703  codec_enc_.g_error_resilient = 0;
704  vpx_svc_set_options(&svc_, "auto-alt-refs=1,1,1 scale-factors=1/1,1/1,1/1 "
705                      "multi-frame-contexts=1");
706  vpx_fixed_buf outputs[10];
707  memset(&outputs[0], 0, sizeof(outputs));
708  Pass2EncodeNFrames(&stats_buf, 10, 3, &outputs[0]);
709
710  vpx_fixed_buf outputs_new[10];
711  for (int i = 0; i < 10; ++i) {
712    outputs_new[i].buf = malloc(outputs[i].sz + 16);
713    ASSERT_TRUE(outputs_new[i].buf != NULL);
714    memcpy(outputs_new[i].buf, outputs[i].buf, outputs[i].sz);
715    outputs_new[i].sz = outputs[i].sz;
716  }
717  DropLayersAndMakeItVP9Comaptible(&outputs_new[0], 10, 3, true);
718  DecodeNFrames(&outputs_new[0], 10);
719
720  for (int i = 0; i < 10; ++i) {
721    memcpy(outputs_new[i].buf, outputs[i].buf, outputs[i].sz);
722    outputs_new[i].sz = outputs[i].sz;
723  }
724  DropLayersAndMakeItVP9Comaptible(&outputs_new[0], 10, 2, true);
725  DecodeNFrames(&outputs_new[0], 10);
726
727  for (int i = 0; i < 10; ++i) {
728    memcpy(outputs_new[i].buf, outputs[i].buf, outputs[i].sz);
729    outputs_new[i].sz = outputs[i].sz;
730  }
731  DropLayersAndMakeItVP9Comaptible(&outputs_new[0], 10, 1, true);
732  DecodeNFrames(&outputs_new[0], 10);
733
734  FreeBitstreamBuffers(&outputs[0], 10);
735  FreeBitstreamBuffers(&outputs_new[0], 10);
736}
737
738TEST_F(SvcTest, TwoPassEncode2TemporalLayers) {
739  // First pass encode
740  std::string stats_buf;
741  vpx_svc_set_options(&svc_, "scale-factors=1/1");
742  svc_.temporal_layers = 2;
743  Pass1EncodeNFrames(10, 1, &stats_buf);
744
745  // Second pass encode
746  codec_enc_.g_pass = VPX_RC_LAST_PASS;
747  svc_.temporal_layers = 2;
748  vpx_svc_set_options(&svc_, "auto-alt-refs=1 scale-factors=1/1");
749  vpx_fixed_buf outputs[10];
750  memset(&outputs[0], 0, sizeof(outputs));
751  Pass2EncodeNFrames(&stats_buf, 10, 1, &outputs[0]);
752  DecodeNFrames(&outputs[0], 10);
753  FreeBitstreamBuffers(&outputs[0], 10);
754}
755
756TEST_F(SvcTest, TwoPassEncode2TemporalLayersWithMultipleFrameContexts) {
757  // First pass encode
758  std::string stats_buf;
759  vpx_svc_set_options(&svc_, "scale-factors=1/1");
760  svc_.temporal_layers = 2;
761  Pass1EncodeNFrames(10, 1, &stats_buf);
762
763  // Second pass encode
764  codec_enc_.g_pass = VPX_RC_LAST_PASS;
765  svc_.temporal_layers = 2;
766  codec_enc_.g_error_resilient = 0;
767  vpx_svc_set_options(&svc_, "auto-alt-refs=1 scale-factors=1/1 "
768                      "multi-frame-contexts=1");
769  vpx_fixed_buf outputs[10];
770  memset(&outputs[0], 0, sizeof(outputs));
771  Pass2EncodeNFrames(&stats_buf, 10, 1, &outputs[0]);
772  DropLayersAndMakeItVP9Comaptible(&outputs[0], 10, 1, true);
773  DecodeNFrames(&outputs[0], 10);
774  FreeBitstreamBuffers(&outputs[0], 10);
775}
776
777TEST_F(SvcTest, TwoPassEncode2TemporalLayersDecodeBaseLayer) {
778  // First pass encode
779  std::string stats_buf;
780  vpx_svc_set_options(&svc_, "scale-factors=1/1");
781  svc_.temporal_layers = 2;
782  Pass1EncodeNFrames(10, 1, &stats_buf);
783
784  // Second pass encode
785  codec_enc_.g_pass = VPX_RC_LAST_PASS;
786  svc_.temporal_layers = 2;
787  vpx_svc_set_options(&svc_, "auto-alt-refs=1 scale-factors=1/1");
788  vpx_fixed_buf outputs[10];
789  memset(&outputs[0], 0, sizeof(outputs));
790  Pass2EncodeNFrames(&stats_buf, 10, 1, &outputs[0]);
791
792  vpx_fixed_buf base_layer[5];
793  for (int i = 0; i < 5; ++i)
794    base_layer[i] = outputs[i * 2];
795
796  DecodeNFrames(&base_layer[0], 5);
797  FreeBitstreamBuffers(&outputs[0], 10);
798}
799
800TEST_F(SvcTest,
801       TwoPassEncode2TemporalLayersWithMultipleFrameContextsDecodeBaseLayer) {
802  // First pass encode
803  std::string stats_buf;
804  vpx_svc_set_options(&svc_, "scale-factors=1/1");
805  svc_.temporal_layers = 2;
806  Pass1EncodeNFrames(10, 1, &stats_buf);
807
808  // Second pass encode
809  codec_enc_.g_pass = VPX_RC_LAST_PASS;
810  svc_.temporal_layers = 2;
811  codec_enc_.g_error_resilient = 0;
812  vpx_svc_set_options(&svc_, "auto-alt-refs=1 scale-factors=1/1 "
813                      "multi-frame-contexts=1");
814  vpx_fixed_buf outputs[10];
815  memset(&outputs[0], 0, sizeof(outputs));
816  Pass2EncodeNFrames(&stats_buf, 10, 1, &outputs[0]);
817  DropLayersAndMakeItVP9Comaptible(&outputs[0], 10, 1, true);
818
819  vpx_fixed_buf base_layer[5];
820  for (int i = 0; i < 5; ++i)
821    base_layer[i] = outputs[i * 2];
822
823  DecodeNFrames(&base_layer[0], 5);
824  FreeBitstreamBuffers(&outputs[0], 10);
825}
826
827}  // namespace
828