| OLD | NEW |
|---|
| (Empty) |
| 1 /* | |
| 2 * Copyright (c) 2013 The WebRTC 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 // This test doesn't actually verify the output since it's just printed | |
| 12 // to stdout by void functions, but it's still useful as it executes the code. | |
| 13 | |
| 14 #include <stdio.h> | |
| 15 #include <fstream> | |
| 16 #include <string> | |
| 17 | |
| 18 #include "webrtc/test/gtest.h" | |
| 19 #include "webrtc/test/testsupport/fileutils.h" | |
| 20 #include "webrtc/tools/frame_analyzer/video_quality_analysis.h" | |
| 21 | |
| 22 namespace webrtc { | |
| 23 namespace test { | |
| 24 | |
| 25 // Setup a log file to write the output to instead of stdout because we don't | |
| 26 // want those numbers to be picked up as perf numbers. | |
| 27 class VideoQualityAnalysisTest : public ::testing::Test { | |
| 28 protected: | |
| 29 void SetUp() { | |
| 30 std::string log_filename = TempFilename(webrtc::test::OutputPath(), | |
| 31 "VideoQualityAnalysisTest.log"); | |
| 32 logfile_ = fopen(log_filename.c_str(), "w"); | |
| 33 ASSERT_TRUE(logfile_ != NULL); | |
| 34 | |
| 35 stats_filename_ref_ = TempFilename(OutputPath(), "stats-1.txt"); | |
| 36 stats_filename_ = TempFilename(OutputPath(), "stats-2.txt"); | |
| 37 } | |
| 38 void TearDown() { ASSERT_EQ(0, fclose(logfile_)); } | |
| 39 FILE* logfile_; | |
| 40 std::string stats_filename_ref_; | |
| 41 std::string stats_filename_; | |
| 42 }; | |
| 43 | |
| 44 TEST_F(VideoQualityAnalysisTest, MatchExtractedY4mFrame) { | |
| 45 std::string video_file = | |
| 46 webrtc::test::ResourcePath("reference_less_video_test_file", "y4m"); | |
| 47 | |
| 48 std::string extracted_frame_from_video_file = | |
| 49 webrtc::test::ResourcePath("video_quality_analysis_frame", "txt"); | |
| 50 | |
| 51 int frame_height = 720, frame_width = 1280; | |
| 52 int frame_number = 2; | |
| 53 int size = GetI420FrameSize(frame_width, frame_height); | |
| 54 uint8_t* result_frame = new uint8_t[size]; | |
| 55 uint8_t* expected_frame = new uint8_t[size]; | |
| 56 | |
| 57 FILE* input_file = fopen(extracted_frame_from_video_file.c_str(), "rb"); | |
| 58 fread(expected_frame, 1, size, input_file); | |
| 59 | |
| 60 ExtractFrameFromY4mFile(video_file.c_str(), | |
| 61 frame_width, frame_height, | |
| 62 frame_number, result_frame); | |
| 63 | |
| 64 EXPECT_EQ(*expected_frame, *result_frame); | |
| 65 fclose(input_file); | |
| 66 delete[] result_frame; | |
| 67 delete[] expected_frame; | |
| 68 } | |
| 69 | |
| 70 TEST_F(VideoQualityAnalysisTest, PrintAnalysisResultsEmpty) { | |
| 71 ResultsContainer result; | |
| 72 PrintAnalysisResults(logfile_, "Empty", &result); | |
| 73 } | |
| 74 | |
| 75 TEST_F(VideoQualityAnalysisTest, PrintAnalysisResultsOneFrame) { | |
| 76 ResultsContainer result; | |
| 77 result.frames.push_back(AnalysisResult(0, 35.0, 0.9)); | |
| 78 PrintAnalysisResults(logfile_, "OneFrame", &result); | |
| 79 } | |
| 80 | |
| 81 TEST_F(VideoQualityAnalysisTest, PrintAnalysisResultsThreeFrames) { | |
| 82 ResultsContainer result; | |
| 83 result.frames.push_back(AnalysisResult(0, 35.0, 0.9)); | |
| 84 result.frames.push_back(AnalysisResult(1, 34.0, 0.8)); | |
| 85 result.frames.push_back(AnalysisResult(2, 33.0, 0.7)); | |
| 86 PrintAnalysisResults(logfile_, "ThreeFrames", &result); | |
| 87 } | |
| 88 | |
| 89 TEST_F(VideoQualityAnalysisTest, PrintMaxRepeatedAndSkippedFramesInvalidFile) { | |
| 90 remove(stats_filename_.c_str()); | |
| 91 PrintMaxRepeatedAndSkippedFrames(logfile_, "NonExistingStatsFile", | |
| 92 stats_filename_ref_, stats_filename_); | |
| 93 } | |
| 94 | |
| 95 TEST_F(VideoQualityAnalysisTest, | |
| 96 PrintMaxRepeatedAndSkippedFramesEmptyStatsFile) { | |
| 97 std::ofstream stats_file; | |
| 98 stats_file.open(stats_filename_ref_.c_str()); | |
| 99 stats_file.close(); | |
| 100 stats_file.open(stats_filename_.c_str()); | |
| 101 stats_file.close(); | |
| 102 PrintMaxRepeatedAndSkippedFrames(logfile_, "EmptyStatsFile", | |
| 103 stats_filename_ref_, stats_filename_); | |
| 104 } | |
| 105 | |
| 106 TEST_F(VideoQualityAnalysisTest, PrintMaxRepeatedAndSkippedFramesNormalFile) { | |
| 107 std::ofstream stats_file; | |
| 108 | |
| 109 stats_file.open(stats_filename_ref_.c_str()); | |
| 110 stats_file << "frame_0001 0100\n"; | |
| 111 stats_file << "frame_0002 0101\n"; | |
| 112 stats_file << "frame_0003 0102\n"; | |
| 113 stats_file << "frame_0004 0103\n"; | |
| 114 stats_file << "frame_0005 0106\n"; | |
| 115 stats_file << "frame_0006 0107\n"; | |
| 116 stats_file << "frame_0007 0108\n"; | |
| 117 stats_file.close(); | |
| 118 | |
| 119 stats_file.open(stats_filename_.c_str()); | |
| 120 stats_file << "frame_0001 0100\n"; | |
| 121 stats_file << "frame_0002 0101\n"; | |
| 122 stats_file << "frame_0003 0101\n"; | |
| 123 stats_file << "frame_0004 0106\n"; | |
| 124 stats_file.close(); | |
| 125 | |
| 126 PrintMaxRepeatedAndSkippedFrames(logfile_, "NormalStatsFile", | |
| 127 stats_filename_ref_, stats_filename_); | |
| 128 } | |
| 129 | |
| 130 namespace { | |
| 131 void VerifyLogOutput(const std::string& log_filename, | |
| 132 const std::vector<std::string>& expected_out) { | |
| 133 std::ifstream logf(log_filename); | |
| 134 std::string line; | |
| 135 | |
| 136 std::size_t i; | |
| 137 for (i = 0; i < expected_out.size() && getline(logf, line); ++i) { | |
| 138 ASSERT_EQ(expected_out.at(i), line); | |
| 139 } | |
| 140 ASSERT_TRUE(i == expected_out.size()) << "Not enough input data"; | |
| 141 } | |
| 142 } // unnamed namespace | |
| 143 | |
| 144 TEST_F(VideoQualityAnalysisTest, | |
| 145 PrintMaxRepeatedAndSkippedFramesSkippedFrames) { | |
| 146 std::ofstream stats_file; | |
| 147 | |
| 148 std::string log_filename = | |
| 149 TempFilename(webrtc::test::OutputPath(), "log.log"); | |
| 150 FILE* logfile = fopen(log_filename.c_str(), "w"); | |
| 151 ASSERT_TRUE(logfile != NULL); | |
| 152 stats_file.open(stats_filename_ref_.c_str()); | |
| 153 stats_file << "frame_0001 0100\n"; | |
| 154 stats_file << "frame_0002 0101\n"; | |
| 155 stats_file << "frame_0002 0101\n"; | |
| 156 stats_file << "frame_0003 0103\n"; | |
| 157 stats_file << "frame_0004 0103\n"; | |
| 158 stats_file << "frame_0005 0106\n"; | |
| 159 stats_file << "frame_0006 0106\n"; | |
| 160 stats_file << "frame_0007 0108\n"; | |
| 161 stats_file << "frame_0008 0110\n"; | |
| 162 stats_file << "frame_0009 0112\n"; | |
| 163 stats_file.close(); | |
| 164 | |
| 165 stats_file.open(stats_filename_.c_str()); | |
| 166 stats_file << "frame_0001 0101\n"; | |
| 167 stats_file << "frame_0002 0101\n"; | |
| 168 stats_file << "frame_0003 0101\n"; | |
| 169 stats_file << "frame_0004 0108\n"; | |
| 170 stats_file << "frame_0005 0108\n"; | |
| 171 stats_file << "frame_0006 0112\n"; | |
| 172 stats_file.close(); | |
| 173 | |
| 174 PrintMaxRepeatedAndSkippedFrames(logfile, "NormalStatsFile", | |
| 175 stats_filename_ref_, stats_filename_); | |
| 176 ASSERT_EQ(0, fclose(logfile)); | |
| 177 | |
| 178 std::vector<std::string> expected_out = { | |
| 179 "RESULT Max_repeated: NormalStatsFile= 2", | |
| 180 "RESULT Max_skipped: NormalStatsFile= 2", | |
| 181 "RESULT Total_skipped: NormalStatsFile= 3", | |
| 182 "RESULT Decode_errors_reference: NormalStatsFile= 0", | |
| 183 "RESULT Decode_errors_test: NormalStatsFile= 0"}; | |
| 184 VerifyLogOutput(log_filename, expected_out); | |
| 185 } | |
| 186 | |
| 187 TEST_F(VideoQualityAnalysisTest, | |
| 188 PrintMaxRepeatedAndSkippedFramesDecodeErrorInTest) { | |
| 189 std::ofstream stats_file; | |
| 190 | |
| 191 std::string log_filename = | |
| 192 TempFilename(webrtc::test::OutputPath(), "log.log"); | |
| 193 FILE* logfile = fopen(log_filename.c_str(), "w"); | |
| 194 ASSERT_TRUE(logfile != NULL); | |
| 195 stats_file.open(stats_filename_ref_.c_str()); | |
| 196 stats_file << "frame_0001 0100\n"; | |
| 197 stats_file << "frame_0002 0100\n"; | |
| 198 stats_file << "frame_0002 0101\n"; | |
| 199 stats_file << "frame_0003 0103\n"; | |
| 200 stats_file << "frame_0004 0103\n"; | |
| 201 stats_file << "frame_0005 0106\n"; | |
| 202 stats_file << "frame_0006 0107\n"; | |
| 203 stats_file << "frame_0007 0107\n"; | |
| 204 stats_file << "frame_0008 0110\n"; | |
| 205 stats_file << "frame_0009 0112\n"; | |
| 206 stats_file.close(); | |
| 207 | |
| 208 stats_file.open(stats_filename_.c_str()); | |
| 209 stats_file << "frame_0001 0101\n"; | |
| 210 stats_file << "frame_0002 Barcode error\n"; | |
| 211 stats_file << "frame_0003 Barcode error\n"; | |
| 212 stats_file << "frame_0004 Barcode error\n"; | |
| 213 stats_file << "frame_0005 0107\n"; | |
| 214 stats_file << "frame_0006 0110\n"; | |
| 215 stats_file.close(); | |
| 216 | |
| 217 PrintMaxRepeatedAndSkippedFrames(logfile, "NormalStatsFile", | |
| 218 stats_filename_ref_, stats_filename_); | |
| 219 ASSERT_EQ(0, fclose(logfile)); | |
| 220 | |
| 221 std::vector<std::string> expected_out = { | |
| 222 "RESULT Max_repeated: NormalStatsFile= 1", | |
| 223 "RESULT Max_skipped: NormalStatsFile= 0", | |
| 224 "RESULT Total_skipped: NormalStatsFile= 0", | |
| 225 "RESULT Decode_errors_reference: NormalStatsFile= 0", | |
| 226 "RESULT Decode_errors_test: NormalStatsFile= 3"}; | |
| 227 VerifyLogOutput(log_filename, expected_out); | |
| 228 } | |
| 229 | |
| 230 TEST_F(VideoQualityAnalysisTest, CalculateFrameClustersOneValue) { | |
| 231 std::ofstream stats_file; | |
| 232 | |
| 233 stats_file.open(stats_filename_.c_str()); | |
| 234 stats_file << "frame_0001 0101\n"; | |
| 235 stats_file.close(); | |
| 236 | |
| 237 FILE* stats_filef = fopen(stats_filename_.c_str(), "r"); | |
| 238 ASSERT_TRUE(stats_filef != NULL); | |
| 239 | |
| 240 auto clusters = CalculateFrameClusters(stats_filef, nullptr); | |
| 241 ASSERT_EQ(0, fclose(stats_filef)); | |
| 242 decltype(clusters) expected = {std::make_pair(101, 1)}; | |
| 243 ASSERT_EQ(expected, clusters); | |
| 244 } | |
| 245 | |
| 246 TEST_F(VideoQualityAnalysisTest, CalculateFrameClustersOneOneTwo) { | |
| 247 std::ofstream stats_file; | |
| 248 | |
| 249 stats_file.open(stats_filename_.c_str()); | |
| 250 stats_file << "frame_0001 0101\n"; | |
| 251 stats_file << "frame_0002 0101\n"; | |
| 252 stats_file << "frame_0003 0102\n"; | |
| 253 stats_file.close(); | |
| 254 | |
| 255 FILE* stats_filef = fopen(stats_filename_.c_str(), "r"); | |
| 256 ASSERT_TRUE(stats_filef != NULL); | |
| 257 | |
| 258 auto clusters = CalculateFrameClusters(stats_filef, nullptr); | |
| 259 ASSERT_EQ(0, fclose(stats_filef)); | |
| 260 decltype(clusters) expected = {std::make_pair(101, 2), | |
| 261 std::make_pair(102, 1)}; | |
| 262 ASSERT_EQ(expected, clusters); | |
| 263 } | |
| 264 | |
| 265 TEST_F(VideoQualityAnalysisTest, CalculateFrameClustersOneOneErrErrThree) { | |
| 266 std::ofstream stats_file; | |
| 267 | |
| 268 stats_file.open(stats_filename_.c_str()); | |
| 269 stats_file << "frame_0001 0101\n"; | |
| 270 stats_file << "frame_0002 0101\n"; | |
| 271 stats_file << "frame_0003 Barcode error\n"; | |
| 272 stats_file << "frame_0004 Barcode error\n"; | |
| 273 stats_file << "frame_0005 0103\n"; | |
| 274 stats_file.close(); | |
| 275 | |
| 276 FILE* stats_filef = fopen(stats_filename_.c_str(), "r"); | |
| 277 ASSERT_TRUE(stats_filef != NULL); | |
| 278 | |
| 279 auto clusters = CalculateFrameClusters(stats_filef, nullptr); | |
| 280 ASSERT_EQ(0, fclose(stats_filef)); | |
| 281 decltype(clusters) expected = {std::make_pair(101, 2), | |
| 282 std::make_pair(DECODE_ERROR, 2), | |
| 283 std::make_pair(103, 1)}; | |
| 284 ASSERT_EQ(expected, clusters); | |
| 285 } | |
| 286 | |
| 287 TEST_F(VideoQualityAnalysisTest, CalculateFrameClustersErrErr) { | |
| 288 std::ofstream stats_file; | |
| 289 | |
| 290 stats_file.open(stats_filename_.c_str()); | |
| 291 stats_file << "frame_0001 Barcode error\n"; | |
| 292 stats_file << "frame_0002 Barcode error\n"; | |
| 293 stats_file.close(); | |
| 294 | |
| 295 FILE* stats_filef = fopen(stats_filename_.c_str(), "r"); | |
| 296 ASSERT_TRUE(stats_filef != NULL); | |
| 297 | |
| 298 auto clusters = CalculateFrameClusters(stats_filef, nullptr); | |
| 299 ASSERT_EQ(0, fclose(stats_filef)); | |
| 300 decltype(clusters) expected = {std::make_pair(DECODE_ERROR, 2)}; | |
| 301 ASSERT_EQ(expected, clusters); | |
| 302 } | |
| 303 | |
| 304 TEST_F(VideoQualityAnalysisTest, CalculateFrameClustersOneOneErrErrOneOne) { | |
| 305 std::ofstream stats_file; | |
| 306 | |
| 307 stats_file.open(stats_filename_.c_str()); | |
| 308 stats_file << "frame_0001 0101\n"; | |
| 309 stats_file << "frame_0002 0101\n"; | |
| 310 stats_file << "frame_0003 Barcode error\n"; | |
| 311 stats_file << "frame_0004 Barcode error\n"; | |
| 312 stats_file << "frame_0005 0101\n"; | |
| 313 stats_file << "frame_0006 0101\n"; | |
| 314 stats_file.close(); | |
| 315 | |
| 316 FILE* stats_filef = fopen(stats_filename_.c_str(), "r"); | |
| 317 ASSERT_TRUE(stats_filef != NULL); | |
| 318 | |
| 319 auto clusters = CalculateFrameClusters(stats_filef, nullptr); | |
| 320 ASSERT_EQ(0, fclose(stats_filef)); | |
| 321 decltype(clusters) expected = {std::make_pair(101, 6)}; | |
| 322 ASSERT_EQ(expected, clusters); | |
| 323 } | |
| 324 | |
| 325 TEST_F(VideoQualityAnalysisTest, CalculateFrameClustersEmpty) { | |
| 326 std::ofstream stats_file; | |
| 327 | |
| 328 stats_file.open(stats_filename_.c_str()); | |
| 329 stats_file.close(); | |
| 330 | |
| 331 FILE* stats_filef = fopen(stats_filename_.c_str(), "r"); | |
| 332 ASSERT_TRUE(stats_filef != NULL); | |
| 333 | |
| 334 auto clusters = CalculateFrameClusters(stats_filef, nullptr); | |
| 335 ASSERT_EQ(0, fclose(stats_filef)); | |
| 336 decltype(clusters) expected; | |
| 337 ASSERT_EQ(expected, clusters); | |
| 338 } | |
| 339 } // namespace test | |
| 340 } // namespace webrtc | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2965593002:
Move webrtc/{tools => rtc_tools} (Closed)
