1 /* 2 * Copyright (C) 2024 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #include "gtest/gtest.h" 17 #include "filter/filter.h" 18 #include "video_sink.h" 19 #include "sink/media_synchronous_sink.h" 20 #include "media_sync_center_mock.h" 21 22 using namespace testing::ext; 23 24 namespace OHOS { 25 namespace Media { 26 namespace Test { 27 using namespace Pipeline; 28 29 class TestEventReceiver : public EventReceiver { 30 public: TestEventReceiver()31 explicit TestEventReceiver() 32 { 33 } 34 OnEvent(const Event & event)35 void OnEvent(const Event &event) 36 { 37 (void)event; 38 } 39 40 private: 41 }; 42 43 class TestVideoSink : public testing::Test { 44 public: 45 // SetUpTestCase: Called before all test cases SetUpTestCase(void)46 static void SetUpTestCase(void) { } 47 // TearDownTestCase: Called after all test case TearDownTestCase(void)48 static void TearDownTestCase(void) { } 49 // SetUp: Called before each test cases SetUp(void)50 void SetUp(void) 51 { 52 videoSink_ = std::make_shared<VideoSink>(); 53 ASSERT_TRUE(videoSink_ != nullptr); 54 } 55 // TearDown: Called after each test cases TearDown(void)56 void TearDown(void) 57 { 58 videoSink_ = nullptr; 59 } 60 public: 61 std::shared_ptr<VideoSink> videoSink_ = nullptr; 62 }; 63 64 HWTEST_F(TestVideoSink, do_sync_write_not_eos, TestSize.Level1) 65 { 66 auto syncCenter = std::make_shared<MediaSyncManager>(); 67 ASSERT_TRUE(syncCenter != nullptr); 68 videoSink_->SetSyncCenter(syncCenter); 69 std::shared_ptr<EventReceiver> testEventReceiver = std::make_shared<TestEventReceiver>(); 70 ASSERT_TRUE(testEventReceiver != nullptr); 71 videoSink_->SetEventReceiver(testEventReceiver); 72 auto meta = std::make_shared<Meta>(); 73 ASSERT_TRUE(meta != nullptr); 74 auto setParam = videoSink_->SetParameter(meta); 75 ASSERT_TRUE(setParam == Status::OK); 76 videoSink_->ResetSyncInfo(); 77 videoSink_->SetLastPts(0); 78 videoSink_->SetFirstPts(HST_TIME_NONE); 79 videoSink_->SetSeekFlag(); 80 uint64_t latency = 0; 81 auto getLatency = videoSink_->GetLatency(latency); 82 ASSERT_TRUE(getLatency == Status::OK); 83 AVBufferConfig config; 84 config.size = 4; 85 config.memoryType = MemoryType::SHARED_MEMORY; 86 const std::shared_ptr<AVBuffer> buffer = AVBuffer::CreateAVBuffer(config); 87 ASSERT_TRUE(buffer != nullptr); 88 buffer->flag_ = 0; // not eos 89 videoSink_->DoSyncWrite(buffer); 90 buffer->flag_ = BUFFER_FLAG_EOS; 91 videoSink_->DoSyncWrite(buffer); 92 buffer->pts_ = 1; 93 videoSink_->lastBufferTime_ = 1; 94 videoSink_->seekFlag_ = false; 95 (void)videoSink_->CheckBufferLatenessMayWait(buffer); 96 float speed = 0; 97 videoSink_->GetSpeed(speed); 98 } 99 100 HWTEST_F(TestVideoSink, do_sync_write_two_frames, TestSize.Level1) 101 { 102 auto syncCenter = std::make_shared<MediaSyncManager>(); 103 ASSERT_TRUE(syncCenter != nullptr); 104 videoSink_->SetSyncCenter(syncCenter); 105 std::shared_ptr<EventReceiver> testEventReceiver = std::make_shared<TestEventReceiver>(); 106 ASSERT_TRUE(testEventReceiver != nullptr); 107 videoSink_->SetEventReceiver(testEventReceiver); 108 auto meta = std::make_shared<Meta>(); 109 ASSERT_TRUE(meta != nullptr); 110 auto setParam = videoSink_->SetParameter(meta); 111 ASSERT_TRUE(setParam == Status::OK); 112 videoSink_->ResetSyncInfo(); 113 videoSink_->SetLastPts(0); 114 videoSink_->SetFirstPts(HST_TIME_NONE); 115 videoSink_->SetSeekFlag(); 116 AVBufferConfig config; 117 config.size = 4; 118 config.memoryType = MemoryType::SHARED_MEMORY; 119 const std::shared_ptr<AVBuffer> buffer = AVBuffer::CreateAVBuffer(config); 120 ASSERT_TRUE(buffer != nullptr); 121 buffer->flag_ = 0; // not eos 122 videoSink_->DoSyncWrite(buffer); 123 const std::shared_ptr<AVBuffer> buffer2 = AVBuffer::CreateAVBuffer(config); 124 ASSERT_TRUE(buffer2 != nullptr); 125 buffer->flag_ = 0; // not eos 126 videoSink_->DoSyncWrite(buffer2); 127 buffer->pts_ = 1; 128 videoSink_->lastBufferTime_ = 1; 129 videoSink_->seekFlag_ = false; 130 (void)videoSink_->CheckBufferLatenessMayWait(buffer); 131 float speed = 0; 132 videoSink_->GetSpeed(speed); 133 } 134 135 HWTEST_F(TestVideoSink, do_sync_write_eos, TestSize.Level1) 136 { 137 auto syncCenter = std::make_shared<MediaSyncManager>(); 138 ASSERT_TRUE(syncCenter != nullptr); 139 videoSink_->SetSyncCenter(syncCenter); 140 std::shared_ptr<EventReceiver> testEventReceiver = std::make_shared<TestEventReceiver>(); 141 ASSERT_TRUE(testEventReceiver != nullptr); 142 videoSink_->SetEventReceiver(testEventReceiver); 143 auto meta = std::make_shared<Meta>(); 144 ASSERT_TRUE(meta != nullptr); 145 auto setParam = videoSink_->SetParameter(meta); 146 ASSERT_TRUE(setParam == Status::OK); 147 videoSink_->ResetSyncInfo(); 148 videoSink_->SetLastPts(0); 149 videoSink_->SetFirstPts(HST_TIME_NONE); 150 videoSink_->SetSeekFlag(); 151 AVBufferConfig config; 152 config.size = 4; 153 config.memoryType = MemoryType::SHARED_MEMORY; 154 const std::shared_ptr<AVBuffer> buffer = AVBuffer::CreateAVBuffer(config); 155 ASSERT_TRUE(buffer != nullptr); 156 buffer->flag_ = 1; // eos 157 videoSink_->DoSyncWrite(buffer); 158 videoSink_->DoSyncWrite(buffer); 159 buffer->flag_ = BUFFER_FLAG_EOS; 160 videoSink_->DoSyncWrite(buffer); 161 buffer->pts_ = 1; 162 videoSink_->lastBufferTime_ = 1; 163 videoSink_->seekFlag_ = false; 164 (void)videoSink_->CheckBufferLatenessMayWait(buffer); 165 float speed = 0; 166 videoSink_->GetSpeed(speed); 167 } 168 169 HWTEST_F(TestVideoSink, CheckBufferLatenessMayWait_001, TestSize.Level1) 170 { 171 AVBufferConfig config; 172 config.size = 4; 173 config.memoryType = MemoryType::SHARED_MEMORY; 174 auto buffer = AVBuffer::CreateAVBuffer(config); 175 ASSERT_TRUE(buffer != nullptr); 176 auto syncCenter = std::make_shared<MockMediaSyncCenter>(); 177 videoSink_->SetSyncCenter(syncCenter); 178 179 syncCenter->returnInt64Queue_.push(Plugins::HST_TIME_NONE); 180 bool result = videoSink_->CheckBufferLatenessMayWait(buffer); 181 EXPECT_EQ(result, 0); 182 } 183 184 HWTEST_F(TestVideoSink, CheckBufferLatenessMayWait_002, TestSize.Level1) 185 { 186 AVBufferConfig config; 187 config.size = 4; 188 config.memoryType = MemoryType::SHARED_MEMORY; 189 auto buffer = AVBuffer::CreateAVBuffer(config); 190 ASSERT_TRUE(buffer != nullptr); 191 auto syncCenter = std::make_shared<MockMediaSyncCenter>(); 192 videoSink_->SetSyncCenter(syncCenter); 193 194 syncCenter->returnInt64Queue_.push(Plugins::HST_TIME_NONE); 195 syncCenter->returnInt64Queue_.push(1000); 196 syncCenter->returnInt64Queue_.push(2000); 197 buffer->pts_ = 1500; 198 bool result = videoSink_->CheckBufferLatenessMayWait(buffer); 199 EXPECT_EQ(result, 0); 200 } 201 202 HWTEST_F(TestVideoSink, CheckBufferLatenessMayWait_003, TestSize.Level1) 203 { 204 AVBufferConfig config; 205 config.size = 4; 206 config.memoryType = MemoryType::SHARED_MEMORY; 207 auto buffer = AVBuffer::CreateAVBuffer(config); 208 ASSERT_TRUE(buffer != nullptr); 209 auto syncCenter = std::make_shared<MockMediaSyncCenter>(); 210 videoSink_->SetSyncCenter(syncCenter); 211 212 syncCenter->returnInt64Queue_.push(Plugins::HST_TIME_NONE); 213 syncCenter->returnInt64Queue_.push(1000); 214 syncCenter->returnInt64Queue_.push(2000); 215 buffer->pts_ = 1500; 216 bool result = videoSink_->CheckBufferLatenessMayWait(buffer); 217 EXPECT_EQ(result, false); 218 } 219 220 // Scenario1: Test when firstPts_ is HST_TIME_NONE, SetFirstPts should set firstPts_ to pts. 221 HWTEST_F(TestVideoSink, SetFirstPts_ShouldSetFirstPts_WhenFirstPtsIsNone, TestSize.Level0) 222 { 223 int64_t pts = 100; 224 videoSink_->SetFirstPts(pts); 225 EXPECT_EQ(videoSink_->firstPts_, pts); 226 } 227 228 // Scenario2: Test when firstPts_ is not HST_TIME_NONE, SetFirstPts should not change firstPts_. 229 HWTEST_F(TestVideoSink, SetFirstPts_ShouldNotChangeFirstPts_WhenFirstPtsIsNotNone, TestSize.Level0) 230 { 231 int64_t pts = 100; 232 videoSink_->firstPts_ = 200; 233 videoSink_->SetFirstPts(pts); 234 EXPECT_EQ(videoSink_->firstPts_, 200); 235 } 236 237 // Scenario1: Test when speed is 0.0f then GetSpeed returns 1.0f. 238 HWTEST_F(TestVideoSink, GetSpeed_ShouldReturn1_WhenSpeedIs0, TestSize.Level0) 239 { 240 float speed = 0.0f; 241 float result = videoSink_->GetSpeed(speed); 242 ASSERT_EQ(result, 1.0f); 243 } 244 245 // Scenario2: Test when speed is not 0.0f then GetSpeed returns the same speed. 246 HWTEST_F(TestVideoSink, GetSpeed_ShouldReturnSameSpeed_WhenSpeedIsNot0, TestSize.Level0) 247 { 248 float speed = 0.5f; 249 float result = videoSink_->GetSpeed(speed); 250 ASSERT_EQ(result, speed); 251 } 252 253 HWTEST_F(TestVideoSink, SetLastPts_001, TestSize.Level0) 254 { 255 auto syncCenter = std::make_shared<MockMediaSyncCenter>(); 256 videoSink_->SetSyncCenter(syncCenter); 257 syncCenter->returnInt64Queue_.push(987654321); 258 int64_t lastPts = 123456789; 259 videoSink_->SetLastPts(lastPts); 260 EXPECT_EQ(videoSink_->lastPts_, lastPts); 261 } 262 263 HWTEST_F(TestVideoSink, SetLastPts_002, TestSize.Level0) 264 { 265 auto syncCenter = std::make_shared<MockMediaSyncCenter>(); 266 videoSink_->SetSyncCenter(nullptr); 267 int64_t lastPts = 123456789; 268 videoSink_->SetLastPts(lastPts); 269 EXPECT_EQ(videoSink_->lastPts_, lastPts); 270 } 271 } // namespace Test 272 } // namespace Media 273 } // namespace OHOS