| OLD | NEW |
|---|
| (Empty) |
| 1 /* | |
| 2 * Copyright (c) 2012 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 #include <stdio.h> | |
| 12 #include <stdlib.h> | |
| 13 | |
| 14 #include <fstream> | |
| 15 #include <memory> | |
| 16 | |
| 17 #include "webrtc/common_video/libyuv/include/webrtc_libyuv.h" | |
| 18 #include "webrtc/test/gtest.h" | |
| 19 #include "webrtc/test/testsupport/fileutils.h" | |
| 20 #include "webrtc/tools/frame_editing/frame_editing_lib.h" | |
| 21 | |
| 22 namespace webrtc { | |
| 23 namespace test { | |
| 24 | |
| 25 const int kWidth = 352; | |
| 26 const int kHeight = 288; | |
| 27 const size_t kFrameSize = CalcBufferSize(VideoType::kI420, kWidth, kHeight); | |
| 28 | |
| 29 class FrameEditingTest : public ::testing::Test { | |
| 30 protected: | |
| 31 virtual void SetUp() { | |
| 32 reference_video_ = ResourcePath("foreman_cif", "yuv"); | |
| 33 test_video_ = webrtc::test::TempFilename(webrtc::test::OutputPath(), | |
| 34 "frame_editing_unittest.yuv"); | |
| 35 | |
| 36 original_fid_ = fopen(reference_video_.c_str(), "rb"); | |
| 37 ASSERT_TRUE(original_fid_ != NULL); | |
| 38 | |
| 39 // Ensure the output file exists on disk. | |
| 40 std::ofstream(test_video_.c_str(), std::ios::out); | |
| 41 // Open the output file for reading. | |
| 42 // TODO(holmer): Figure out why this file has to be opened here (test fails | |
| 43 // if it's opened after the write operation performed in EditFrames). | |
| 44 edited_fid_ = fopen(test_video_.c_str(), "rb"); | |
| 45 ASSERT_TRUE(edited_fid_ != NULL); | |
| 46 | |
| 47 original_buffer_.reset(new int[kFrameSize]); | |
| 48 edited_buffer_.reset(new int[kFrameSize]); | |
| 49 num_frames_read_ = 0; | |
| 50 } | |
| 51 virtual void TearDown() { | |
| 52 fclose(original_fid_); | |
| 53 fclose(edited_fid_); | |
| 54 remove(test_video_.c_str()); | |
| 55 } | |
| 56 // Compares the frames in both streams to the end of one of the streams. | |
| 57 void CompareToTheEnd(FILE* test_video_fid, | |
| 58 FILE* ref_video_fid, | |
| 59 std::unique_ptr<int[]>* ref_buffer, | |
| 60 std::unique_ptr<int[]>* test_buffer) { | |
| 61 while (!feof(test_video_fid) && !feof(ref_video_fid)) { | |
| 62 num_bytes_read_ = fread(ref_buffer->get(), 1, kFrameSize, ref_video_fid); | |
| 63 if (!feof(ref_video_fid)) { | |
| 64 EXPECT_EQ(kFrameSize, num_bytes_read_); | |
| 65 } | |
| 66 num_bytes_read_ = fread(test_buffer->get(), 1, kFrameSize, | |
| 67 test_video_fid); | |
| 68 if (!feof(test_video_fid)) { | |
| 69 EXPECT_EQ(kFrameSize, num_bytes_read_); | |
| 70 } | |
| 71 if (!feof(test_video_fid) && !feof(test_video_fid)) { | |
| 72 EXPECT_EQ(0, memcmp(ref_buffer->get(), test_buffer->get(), | |
| 73 kFrameSize)); | |
| 74 } | |
| 75 } | |
| 76 // There should not be anything left in either stream. | |
| 77 EXPECT_EQ(!feof(test_video_fid), !feof(ref_video_fid)); | |
| 78 } | |
| 79 std::string reference_video_; | |
| 80 std::string test_video_; | |
| 81 FILE* original_fid_; | |
| 82 FILE* edited_fid_; | |
| 83 size_t num_bytes_read_; | |
| 84 std::unique_ptr<int[]> original_buffer_; | |
| 85 std::unique_ptr<int[]> edited_buffer_; | |
| 86 int num_frames_read_; | |
| 87 }; | |
| 88 | |
| 89 TEST_F(FrameEditingTest, ValidInPath) { | |
| 90 const int kFirstFrameToProcess = 160; | |
| 91 const int kInterval = -1; | |
| 92 const int kLastFrameToProcess = 240; | |
| 93 | |
| 94 int result = EditFrames(reference_video_, kWidth, kHeight, | |
| 95 kFirstFrameToProcess, kInterval, kLastFrameToProcess, | |
| 96 test_video_); | |
| 97 EXPECT_EQ(0, result); | |
| 98 | |
| 99 for (int i = 1; i < kFirstFrameToProcess; ++i) { | |
| 100 num_bytes_read_ = fread(original_buffer_.get(), 1, kFrameSize, | |
| 101 original_fid_); | |
| 102 EXPECT_EQ(kFrameSize, num_bytes_read_); | |
| 103 | |
| 104 num_bytes_read_ = fread(edited_buffer_.get(), 1, kFrameSize, edited_fid_); | |
| 105 EXPECT_EQ(kFrameSize, num_bytes_read_); | |
| 106 | |
| 107 EXPECT_EQ(0, memcmp(original_buffer_.get(), edited_buffer_.get(), | |
| 108 kFrameSize)); | |
| 109 } | |
| 110 // Do not compare the frames that have been cut. | |
| 111 for (int i = kFirstFrameToProcess; i <= kLastFrameToProcess; ++i) { | |
| 112 num_bytes_read_ = fread(original_buffer_.get(), 1, kFrameSize, | |
| 113 original_fid_); | |
| 114 EXPECT_EQ(kFrameSize, num_bytes_read_); | |
| 115 } | |
| 116 CompareToTheEnd(edited_fid_, original_fid_, &original_buffer_, | |
| 117 &edited_buffer_); | |
| 118 } | |
| 119 | |
| 120 TEST_F(FrameEditingTest, EmptySetToCut) { | |
| 121 const int kFirstFrameToProcess = 2; | |
| 122 const int kInterval = -1; | |
| 123 const int kLastFrameToProcess = 1; | |
| 124 | |
| 125 int result = EditFrames(reference_video_, kWidth, kHeight, | |
| 126 kFirstFrameToProcess, kInterval, kLastFrameToProcess, | |
| 127 test_video_); | |
| 128 EXPECT_EQ(-10, result); | |
| 129 } | |
| 130 | |
| 131 TEST_F(FrameEditingTest, InValidInPath) { | |
| 132 const std::string kRefVideo_ = "PATH/THAT/DOES/NOT/EXIST"; | |
| 133 | |
| 134 const int kFirstFrameToProcess = 30; | |
| 135 const int kInterval = 1; | |
| 136 const int kLastFrameToProcess = 120; | |
| 137 | |
| 138 int result = EditFrames(kRefVideo_, kWidth, kHeight, kFirstFrameToProcess, | |
| 139 kInterval, kLastFrameToProcess, test_video_); | |
| 140 EXPECT_EQ(-11, result); | |
| 141 } | |
| 142 | |
| 143 TEST_F(FrameEditingTest, DeletingEverySecondFrame) { | |
| 144 const int kFirstFrameToProcess = 1; | |
| 145 const int kInterval = -2; | |
| 146 const int kLastFrameToProcess = 10000; | |
| 147 // Set kLastFrameToProcess to a large value so that all frame are processed. | |
| 148 int result = EditFrames(reference_video_, kWidth, kHeight, | |
| 149 kFirstFrameToProcess, kInterval, kLastFrameToProcess, | |
| 150 test_video_); | |
| 151 EXPECT_EQ(0, result); | |
| 152 | |
| 153 while (!feof(original_fid_) && !feof(edited_fid_)) { | |
| 154 num_bytes_read_ = | |
| 155 fread(original_buffer_.get(), 1, kFrameSize, original_fid_); | |
| 156 if (!feof(original_fid_)) { | |
| 157 EXPECT_EQ(kFrameSize, num_bytes_read_); | |
| 158 num_frames_read_++; | |
| 159 } | |
| 160 // We want to compare every second frame of the original to the edited. | |
| 161 // kInterval=-2 and (num_frames_read_ - 1) % kInterval will be -1 for | |
| 162 // every second frame. | |
| 163 // num_frames_read_ - 1 because we have deleted frame number 2, 4 , 6 etc. | |
| 164 if ((num_frames_read_ - 1) % kInterval == -1) { | |
| 165 num_bytes_read_ = fread(edited_buffer_.get(), 1, kFrameSize, | |
| 166 edited_fid_); | |
| 167 if (!feof(edited_fid_)) { | |
| 168 EXPECT_EQ(kFrameSize, num_bytes_read_); | |
| 169 } | |
| 170 if (!feof(original_fid_) && !feof(edited_fid_)) { | |
| 171 EXPECT_EQ(0, memcmp(original_buffer_.get(), | |
| 172 edited_buffer_.get(), kFrameSize)); | |
| 173 } | |
| 174 } | |
| 175 } | |
| 176 } | |
| 177 | |
| 178 TEST_F(FrameEditingTest, RepeatFrames) { | |
| 179 const int kFirstFrameToProcess = 160; | |
| 180 const int kInterval = 2; | |
| 181 const int kLastFrameToProcess = 240; | |
| 182 | |
| 183 int result = EditFrames(reference_video_, kWidth, kHeight, | |
| 184 kFirstFrameToProcess, kInterval, kLastFrameToProcess, | |
| 185 test_video_); | |
| 186 EXPECT_EQ(0, result); | |
| 187 | |
| 188 for (int i = 1; i < kFirstFrameToProcess; ++i) { | |
| 189 num_bytes_read_ = fread(original_buffer_.get(), 1, kFrameSize, | |
| 190 original_fid_); | |
| 191 EXPECT_EQ(kFrameSize, num_bytes_read_); | |
| 192 | |
| 193 num_bytes_read_ = fread(edited_buffer_.get(), 1, kFrameSize, edited_fid_); | |
| 194 EXPECT_EQ(kFrameSize, num_bytes_read_); | |
| 195 | |
| 196 EXPECT_EQ(0, memcmp(original_buffer_.get(), edited_buffer_.get(), | |
| 197 kFrameSize)); | |
| 198 } | |
| 199 // Do not compare the frames that have been repeated. | |
| 200 for (int i = kFirstFrameToProcess; i <= kLastFrameToProcess; ++i) { | |
| 201 num_bytes_read_ = fread(original_buffer_.get(), 1, kFrameSize, | |
| 202 original_fid_); | |
| 203 EXPECT_EQ(kFrameSize, num_bytes_read_); | |
| 204 for (int i = 1; i <= kInterval; ++i) { | |
| 205 num_bytes_read_ = fread(edited_buffer_.get(), 1, kFrameSize, | |
| 206 edited_fid_); | |
| 207 EXPECT_EQ(kFrameSize, num_bytes_read_); | |
| 208 EXPECT_EQ(0, memcmp(original_buffer_.get(), edited_buffer_.get(), | |
| 209 kFrameSize)); | |
| 210 } | |
| 211 } | |
| 212 CompareToTheEnd(edited_fid_, original_fid_, &original_buffer_, | |
| 213 &edited_buffer_); | |
| 214 } | |
| 215 } // namespace test | |
| 216 } // namespace webrtc | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2965593002:
Move webrtc/{tools => rtc_tools} (Closed)
