media/filters/vp9_parser_unittest.cc

   1 // Copyright 2015 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/files/memory_mapped_file.h"
   6 #include "base/logging.h"
   7 #include "media/base/test_data_util.h"
   8 #include "media/filters/ivf_parser.h"
   9 #include "media/filters/vp9_parser.h"
  10 #include "testing/gtest/include/gtest/gtest.h"
  11
  12 namespace media {
  13
  14 class Vp9ParserTest : public ::testing::Test {
  15  protected:
  16   void SetUp() override {
  17     base::FilePath file_path = GetTestDataFilePath("test-25fps.vp9");
  18
  19     stream_.reset(new base::MemoryMappedFile());
  20     ASSERT_TRUE(stream_->Initialize(file_path)) << "Couldn't open stream file: "
  21                                                 << file_path.MaybeAsASCII();
  22
  23     IvfFileHeader ivf_file_header;
  24     ASSERT_TRUE(ivf_parser_.Initialize(stream_->data(), stream_->length(),
  25                                        &ivf_file_header));
  26     ASSERT_EQ(ivf_file_header.fourcc, 0x30395056u);  // VP90
  27   }
  28
  29   void TearDown() override { stream_.reset(); }
  30
  31   IvfParser ivf_parser_;
  32   scoped_ptr<base::MemoryMappedFile> stream_;
  33 };
  34
  35 TEST_F(Vp9ParserTest, StreamFileParsing) {
  36   // Number of frames in the test stream to be parsed.
  37   const int num_frames = 250;
  38
  39   Vp9Parser vp9_parser;
  40   IvfFrameHeader ivf_frame_header;
  41   int num_parsed_frames = 0;
  42   const uint8_t* ivf_payload;
  43
  44   // Parse until the end of stream/unsupported stream/error in stream is found.
  45   while (ivf_parser_.ParseNextFrame(&ivf_frame_header, &ivf_payload)) {
  46     Vp9FrameHeader fhdr;
  47
  48     ASSERT_TRUE(
  49         vp9_parser.ParseFrame(ivf_payload, ivf_frame_header.frame_size, &fhdr));
  50     ++num_parsed_frames;
  51   }
  52
  53   DVLOG(1) << "Number of successfully parsed frames before EOS: "
  54            << num_parsed_frames;
  55
  56   EXPECT_EQ(num_frames, num_parsed_frames);
  57 }
  58
  59 TEST_F(Vp9ParserTest, VerifyFirstFrame) {
  60   Vp9Parser vp9_parser;
  61   IvfFrameHeader ivf_frame_header;
  62   const uint8_t* ivf_payload;
  63
  64   ASSERT_TRUE(ivf_parser_.ParseNextFrame(&ivf_frame_header, &ivf_payload));
  65   Vp9FrameHeader fhdr;
  66
  67   ASSERT_TRUE(
  68       vp9_parser.ParseFrame(ivf_payload, ivf_frame_header.frame_size, &fhdr));
  69
  70   EXPECT_EQ(0, fhdr.profile);
  71   EXPECT_FALSE(fhdr.show_existing_frame);
  72   EXPECT_EQ(Vp9FrameHeader::KEYFRAME, fhdr.frame_type);
  73   EXPECT_TRUE(fhdr.show_frame);
  74   EXPECT_FALSE(fhdr.error_resilient_mode);
  75
  76   EXPECT_EQ(8, fhdr.bit_depth);
  77   EXPECT_EQ(Vp9ColorSpace::UNKNOWN, fhdr.color_space);
  78   EXPECT_FALSE(fhdr.yuv_range);
  79   EXPECT_EQ(1, fhdr.subsampling_x);
  80   EXPECT_EQ(1, fhdr.subsampling_y);
  81
  82   EXPECT_EQ(320u, fhdr.width);
  83   EXPECT_EQ(240u, fhdr.height);
  84   EXPECT_EQ(320u, fhdr.display_width);
  85   EXPECT_EQ(240u, fhdr.display_height);
  86
  87   EXPECT_TRUE(fhdr.refresh_frame_context);
  88   EXPECT_TRUE(fhdr.frame_parallel_decoding_mode);
  89   EXPECT_EQ(0, fhdr.frame_context_idx);
  90
  91   EXPECT_EQ(9, fhdr.loop_filter.filter_level);
  92   EXPECT_EQ(0, fhdr.loop_filter.sharpness_level);
  93
  94   const Vp9LoopFilter& lf = fhdr.loop_filter;
  95   EXPECT_TRUE(lf.mode_ref_delta_enabled);
  96   EXPECT_TRUE(lf.mode_ref_delta_update);
  97   EXPECT_TRUE(lf.update_ref_deltas[0]);
  98   EXPECT_EQ(1, lf.ref_deltas[0]);
  99   EXPECT_EQ(-1, lf.ref_deltas[2]);
 100   EXPECT_EQ(-1, lf.ref_deltas[3]);
 101
 102   const Vp9QuantizationParams& qp = fhdr.quant_params;
 103   EXPECT_EQ(65, qp.base_qindex);
 104   EXPECT_FALSE(qp.y_dc_delta);
 105   EXPECT_FALSE(qp.uv_dc_delta);
 106   EXPECT_FALSE(qp.uv_ac_delta);
 107   EXPECT_FALSE(qp.IsLossless());
 108
 109   const Vp9Segmentation& seg = fhdr.segment;
 110   EXPECT_FALSE(seg.enabled);
 111
 112   EXPECT_EQ(0, fhdr.log2_tile_cols);
 113   EXPECT_EQ(0, fhdr.log2_tile_rows);
 114
 115   EXPECT_EQ(120u, fhdr.first_partition_size);
 116   EXPECT_EQ(18u, fhdr.uncompressed_header_size);
 117 }
 118
 119 TEST_F(Vp9ParserTest, VerifyInterFrame) {
 120   Vp9Parser vp9_parser;
 121   Vp9FrameHeader fhdr;
 122
 123   // To verify the second frame.
 124   for (int i = 0; i < 2; i++) {
 125     IvfFrameHeader ivf_frame_header;
 126     const uint8_t* ivf_payload;
 127     ASSERT_TRUE(ivf_parser_.ParseNextFrame(&ivf_frame_header, &ivf_payload));
 128     ASSERT_TRUE(
 129         vp9_parser.ParseFrame(ivf_payload, ivf_frame_header.frame_size, &fhdr));
 130   }
 131
 132   EXPECT_EQ(Vp9FrameHeader::INTERFRAME, fhdr.frame_type);
 133   EXPECT_FALSE(fhdr.show_frame);
 134   EXPECT_FALSE(fhdr.intra_only);
 135   EXPECT_FALSE(fhdr.reset_context);
 136   EXPECT_TRUE(fhdr.refresh_flag[5]);
 137   EXPECT_EQ(0, fhdr.frame_refs[0]);
 138   EXPECT_EQ(1, fhdr.frame_refs[1]);
 139   EXPECT_EQ(2, fhdr.frame_refs[2]);
 140   EXPECT_TRUE(fhdr.allow_high_precision_mv);
 141   EXPECT_EQ(Vp9InterpFilter::EIGHTTAP, fhdr.interp_filter);
 142
 143   EXPECT_EQ(48u, fhdr.first_partition_size);
 144   EXPECT_EQ(11u, fhdr.uncompressed_header_size);
 145 }
 146
 147 }  // namespace media