OLD | NEW |
---|---|
(Empty) | |
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); | |
Pawel Osciak
2015/08/01 15:22:49
s/base::MemoryMappedFile/base::MemoryMappedFile()/
kcwu
2015/08/03 10:05:53
Done.
| |
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 Vp9ReferenceSlots ref_slots; | |
42 int num_parsed_frames = 0; | |
43 const uint8_t* ivf_payload; | |
44 | |
45 // Parse until the end of stream/unsupported stream/error in stream is found. | |
46 while (ivf_parser_.ParseNextFrame(&ivf_frame_header, &ivf_payload)) { | |
47 Vp9FrameHeader fhdr; | |
48 | |
49 ASSERT_TRUE(vp9_parser.ParseFrame(ivf_payload, ivf_frame_header.frame_size, | |
50 ref_slots, &fhdr)); | |
51 ref_slots.Update(fhdr); | |
52 | |
53 ++num_parsed_frames; | |
54 } | |
55 | |
56 DVLOG(1) << "Number of successfully parsed frames before EOS: " | |
57 << num_parsed_frames; | |
58 | |
59 EXPECT_EQ(num_frames, num_parsed_frames); | |
60 } | |
61 | |
62 TEST_F(Vp9ParserTest, VerifyFirstFrame) { | |
63 Vp9Parser vp9_parser; | |
64 IvfFrameHeader ivf_frame_header; | |
65 const uint8_t* ivf_payload; | |
66 | |
67 ASSERT_TRUE(ivf_parser_.ParseNextFrame(&ivf_frame_header, &ivf_payload)); | |
68 Vp9FrameHeader fhdr; | |
69 Vp9ReferenceSlots ref_slots; | |
70 | |
71 ASSERT_TRUE(vp9_parser.ParseFrame(ivf_payload, ivf_frame_header.frame_size, | |
72 ref_slots, &fhdr)); | |
73 ref_slots.Update(fhdr); | |
74 | |
75 EXPECT_EQ(0, fhdr.profile); | |
76 EXPECT_FALSE(fhdr.show_existing_frame); | |
77 EXPECT_EQ(Vp9FrameHeader::KEYFRAME, fhdr.frame_type); | |
78 EXPECT_TRUE(fhdr.show_frame); | |
79 EXPECT_FALSE(fhdr.error_resilient_mode); | |
80 | |
81 EXPECT_EQ(8, fhdr.bit_depth); | |
82 EXPECT_EQ(Vp9ColorSpace::UNKNOWN, fhdr.color_space); | |
83 EXPECT_FALSE(fhdr.yuv_range); | |
84 EXPECT_EQ(1, fhdr.subsampling_x); | |
85 EXPECT_EQ(1, fhdr.subsampling_y); | |
86 | |
87 EXPECT_EQ(320u, fhdr.width); | |
88 EXPECT_EQ(240u, fhdr.height); | |
89 EXPECT_EQ(320u, fhdr.display_width); | |
90 EXPECT_EQ(240u, fhdr.display_height); | |
91 | |
92 EXPECT_TRUE(fhdr.refresh_frame_context); | |
93 EXPECT_TRUE(fhdr.frame_parallel_decoding_mode); | |
94 EXPECT_EQ(0, fhdr.frame_context_idx); | |
95 | |
96 EXPECT_EQ(9, fhdr.loop_filter.filter_level); | |
97 EXPECT_EQ(0, fhdr.loop_filter.sharpness_level); | |
98 | |
99 const Vp9LoopFilter& lf = fhdr.loop_filter; | |
100 EXPECT_TRUE(lf.mode_ref_delta_enabled); | |
101 EXPECT_TRUE(lf.mode_ref_delta_update); | |
102 EXPECT_TRUE(lf.update_ref_deltas[0]); | |
103 EXPECT_EQ(1, lf.ref_deltas[0]); | |
104 EXPECT_EQ(-1, lf.ref_deltas[2]); | |
105 EXPECT_EQ(-1, lf.ref_deltas[3]); | |
106 | |
107 const Vp9QuantizationParams& qp = fhdr.quant_params; | |
108 EXPECT_EQ(65, qp.base_qindex); | |
109 EXPECT_FALSE(qp.y_dc_delta); | |
110 EXPECT_FALSE(qp.uv_dc_delta); | |
111 EXPECT_FALSE(qp.uv_ac_delta); | |
112 EXPECT_FALSE(qp.IsLossless()); | |
113 | |
114 const Vp9Segmentation& seg = fhdr.segment; | |
115 EXPECT_FALSE(seg.enabled); | |
116 | |
117 EXPECT_EQ(0, fhdr.log2_tile_cols); | |
118 EXPECT_EQ(0, fhdr.log2_tile_rows); | |
119 | |
120 EXPECT_EQ(120u, fhdr.first_partition_size); | |
121 EXPECT_EQ(18u, fhdr.uncompressed_header_size); | |
122 } | |
123 | |
124 TEST_F(Vp9ParserTest, VerifyInterFrame) { | |
125 Vp9Parser vp9_parser; | |
126 Vp9FrameHeader fhdr; | |
127 Vp9ReferenceSlots ref_slots; | |
128 | |
129 // To verify the second frame. | |
130 for (int i = 0; i < 2; i++) { | |
131 IvfFrameHeader ivf_frame_header; | |
132 const uint8_t* ivf_payload; | |
133 ASSERT_TRUE(ivf_parser_.ParseNextFrame(&ivf_frame_header, &ivf_payload)); | |
134 ASSERT_TRUE(vp9_parser.ParseFrame(ivf_payload, ivf_frame_header.frame_size, | |
135 ref_slots, &fhdr)); | |
136 ref_slots.Update(fhdr); | |
137 } | |
138 | |
139 EXPECT_EQ(Vp9FrameHeader::INTERFRAME, fhdr.frame_type); | |
140 EXPECT_FALSE(fhdr.show_frame); | |
141 EXPECT_FALSE(fhdr.intra_only); | |
142 EXPECT_FALSE(fhdr.reset_context); | |
143 EXPECT_TRUE(fhdr.refresh_flag[5]); | |
144 EXPECT_EQ(0, fhdr.frame_refs[0]); | |
145 EXPECT_EQ(1, fhdr.frame_refs[1]); | |
146 EXPECT_EQ(2, fhdr.frame_refs[2]); | |
147 EXPECT_TRUE(fhdr.allow_high_precision_mv); | |
148 EXPECT_EQ(Vp9InterpFilter::EIGHTTAP, fhdr.interp_filter); | |
149 | |
150 EXPECT_EQ(48u, fhdr.first_partition_size); | |
151 EXPECT_EQ(11u, fhdr.uncompressed_header_size); | |
152 } | |
153 | |
154 } // namespace media | |
OLD | NEW |