1 /*
2 * Copyright (c) 2025 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 <string>
17 #include <malloc.h>
18 #include <sys/stat.h>
19 #include <cinttypes>
20 #include <fcntl.h>
21 #include <thread>
22 #include <chrono>
23 #include "mock/source.h"
24 #include "media_demuxer_pts_functions_unittest.h"
25
26 #define LOCAL true
27 namespace OHOS::Media {
28 using namespace std;
29 using namespace testing;
30 using namespace testing::ext;
31 const static int32_t NUM_TEST = 0;
32 const static int32_t NUM_TEST2 = 2;
33 const static int32_t ID_TEST = 1;
34 const static int32_t INVALID_PTS_DATA = -1;
35 const static int64_t MAX_PTS_DIFFER_THRESHOLD_US = 10000000;
SetUpTestCase(void)36 void MediaDemuxerPtsUnitTest::SetUpTestCase(void)
37 {
38 }
39
TearDownTestCase(void)40 void MediaDemuxerPtsUnitTest::TearDownTestCase(void)
41 {
42 }
43
SetUp()44 void MediaDemuxerPtsUnitTest::SetUp()
45 {
46 demuxerPtr_ = std::make_shared<MediaDemuxer>();
47 demuxerPtr_->source_ = std::make_shared<Source>();
48 demuxerPtr_->demuxerPluginManager_ = std::make_shared<DemuxerPluginManager>();
49 }
50
TearDown()51 void MediaDemuxerPtsUnitTest::TearDown()
52 {
53 demuxerPtr_ = nullptr;
54 }
55
56 /**
57 * @tc.name: Test HandleAutoMaintainPts API
58 * @tc.number: HandleAutoMaintainPts_001
59 * @tc.desc: Test isAutoMaintainPts_ == false
60 * Test baseInfo == nullptr
61 */
62 HWTEST_F(MediaDemuxerPtsUnitTest, HandleAutoMaintainPts_001, TestSize.Level0)
63 {
64 ASSERT_NE(demuxerPtr_, nullptr);
65 auto mockAvbuffer = std::make_shared<AVBuffer>();
66 int32_t trackId = NUM_TEST;
67 demuxerPtr_->isAutoMaintainPts_ = false;
68 demuxerPtr_->HandleAutoMaintainPts(NUM_TEST, mockAvbuffer);
69 demuxerPtr_->isAutoMaintainPts_ = true;
70 demuxerPtr_->maintainBaseInfos_[trackId] = nullptr;
71 demuxerPtr_->HandleAutoMaintainPts(NUM_TEST, mockAvbuffer);
72 EXPECT_EQ(demuxerPtr_->maintainBaseInfos_[trackId], nullptr);
73 }
74
75 /**
76 * @tc.name: Test HandleAutoMaintainPts API
77 * @tc.number: HandleAutoMaintainPts_002
78 * @tc.desc: Test diff < 0
79 * Test baseInfo->segmentOffset == INVALID_PTS_DATA
80 * Test baseInfo->segmentOffset != offset
81 */
82 HWTEST_F(MediaDemuxerPtsUnitTest, HandleAutoMaintainPts_002, TestSize.Level0)
83 {
84 ASSERT_NE(demuxerPtr_, nullptr);
85 auto mockAvbuffer = std::make_shared<AVBuffer>();
86 int32_t trackId = NUM_TEST;
87 mockAvbuffer->pts_ = NUM_TEST;
88 demuxerPtr_->isAutoMaintainPts_ = true;
89 auto maintainBaseInfo = std::make_shared<MediaDemuxer::MaintainBaseInfo>();
90 maintainBaseInfo->lastPts = ID_TEST;
91 maintainBaseInfo->segmentOffset = INVALID_PTS_DATA;
92 maintainBaseInfo->basePts = NUM_TEST;
93 EXPECT_CALL(*(demuxerPtr_->source_), GetSegmentOffset()).WillRepeatedly(Return(ID_TEST));
94 demuxerPtr_->maintainBaseInfos_[trackId] = maintainBaseInfo;
95 demuxerPtr_->HandleAutoMaintainPts(trackId, mockAvbuffer);
96 EXPECT_EQ(maintainBaseInfo->segmentOffset, NUM_TEST);
97 }
98
99 /**
100 * @tc.name: Test HandleAutoMaintainPts API
101 * @tc.number: HandleAutoMaintainPts_003
102 * @tc.desc: Test baseInfo->segmentOffset != INVALID_PTS_DATA
103 * Test diff > MAX_PTS_DIFFER_THRESHOLD_US
104 * Test baseInfo->isLastPtsChange == true
105 * Test baseInfo->segmentOffset != offset
106 * Test Test baseInfo->isLastPtsChange == false
107 */
108 HWTEST_F(MediaDemuxerPtsUnitTest, HandleAutoMaintainPts_003, TestSize.Level0)
109 {
110 ASSERT_NE(demuxerPtr_, nullptr);
111 auto mockAvbuffer = std::make_shared<AVBuffer>();
112 mockAvbuffer->pts_ = MAX_PTS_DIFFER_THRESHOLD_US;
113 int32_t trackId = NUM_TEST;
114 demuxerPtr_->isAutoMaintainPts_ = true;
115 auto maintainBaseInfo = std::make_shared<MediaDemuxer::MaintainBaseInfo>();
116 maintainBaseInfo->lastPts = INVALID_PTS_DATA;
117 maintainBaseInfo->segmentOffset = NUM_TEST2;
118 maintainBaseInfo->isLastPtsChange = true;
119 EXPECT_CALL(*(demuxerPtr_->source_), GetSegmentOffset()).WillRepeatedly(Return(ID_TEST));
120 demuxerPtr_->maintainBaseInfos_[trackId] = maintainBaseInfo;
121 demuxerPtr_->HandleAutoMaintainPts(trackId, mockAvbuffer);
122 EXPECT_EQ(maintainBaseInfo->isLastPtsChange, false);
123
124 // Test baseInfo->isLastPtsChange == false
125 maintainBaseInfo->isLastPtsChange = false;
126 maintainBaseInfo->lastPts = INVALID_PTS_DATA;
127 maintainBaseInfo->segmentOffset = NUM_TEST2;
128 maintainBaseInfo->lastPtsModifyedMax = ID_TEST;
129 demuxerPtr_->HandleAutoMaintainPts(trackId, mockAvbuffer);
130 EXPECT_NE(maintainBaseInfo->lastPtsModifyedMax, ID_TEST);
131 }
132
133 /**
134 * @tc.name: Test HandleAutoMaintainPts API
135 * @tc.number: HandleAutoMaintainPts_004
136 * @tc.desc: Test baseInfo->segmentOffset != INVALID_PTS_DATA && diff <= MAX_PTS_DIFFER_THRESHOLD_US
137 */
138 HWTEST_F(MediaDemuxerPtsUnitTest, HandleAutoMaintainPts_004, TestSize.Level0)
139 {
140 ASSERT_NE(demuxerPtr_, nullptr);
141 auto mockAvbuffer = std::make_shared<AVBuffer>();
142 int32_t trackId = NUM_TEST;
143 demuxerPtr_->isAutoMaintainPts_ = true;
144 auto maintainBaseInfo = std::make_shared<MediaDemuxer::MaintainBaseInfo>();
145 maintainBaseInfo->lastPts = INVALID_PTS_DATA;
146 maintainBaseInfo->segmentOffset = NUM_TEST;
147 maintainBaseInfo->lastPtsModifyedMax = ID_TEST;
148 maintainBaseInfo->isLastPtsChange = true;
149 EXPECT_CALL(*(demuxerPtr_->source_), GetSegmentOffset()).WillRepeatedly(Return(ID_TEST));
150 demuxerPtr_->maintainBaseInfos_[trackId] = maintainBaseInfo;
151 demuxerPtr_->HandleAutoMaintainPts(trackId, mockAvbuffer);
152 EXPECT_EQ(maintainBaseInfo->isLastPtsChange, false);
153 }
154
155 /**
156 * @tc.name: Test InitPtsInfo API
157 * @tc.number: InitPtsInfo_001
158 * @tc.desc: Test source_->GetHLSDiscontinuity() == false
159 */
160 HWTEST_F(MediaDemuxerPtsUnitTest, InitPtsInfo_001, TestSize.Level0)
161 {
162 ASSERT_NE(demuxerPtr_, nullptr);
163 auto mockAvbuffer = std::make_shared<AVBuffer>();
164 int32_t trackId = NUM_TEST;
165 std::shared_ptr<MediaDemuxer::MaintainBaseInfo> maintainBaseInfo = nullptr;
166 demuxerPtr_->maintainBaseInfos_[trackId] = maintainBaseInfo;
167 demuxerPtr_->InitPtsInfo();
168 EXPECT_EQ(demuxerPtr_->source_->GetHLSDiscontinuity(), false);
169 }
170
171 /**
172 * @tc.name: Test InitMediaStartPts API
173 * @tc.number: InitMediaStartPts_001
174 * @tc.desc: Test trackInfo == nullptr
175 * Test trackInfo->GetData(Tag::MIME_TYPE, mime) == false
176 */
177 HWTEST_F(MediaDemuxerPtsUnitTest, InitMediaStartPts_001, TestSize.Level0)
178 {
179 ASSERT_NE(demuxerPtr_, nullptr);
180 std::string mime;
181 demuxerPtr_->mediaMetaData_.trackMetas.push_back(nullptr);
182 auto realMeta = std::make_shared<Meta>();
183 demuxerPtr_->mediaMetaData_.trackMetas.push_back(realMeta);
184 demuxerPtr_->InitMediaStartPts();
185 EXPECT_EQ(demuxerPtr_->mediaMetaData_.trackMetas[ID_TEST]->GetData(Tag::MIME_TYPE, mime), false);
186 }
187
188 /**
189 * @tc.name: Test TranscoderInitMediaStartPts API
190 * @tc.number: TranscoderInitMediaStartPts_001
191 * @tc.desc: Test trackInfo == nullptr
192 * Test trackInfo->GetData(Tag::MIME_TYPE, mime) == false
193 */
194 HWTEST_F(MediaDemuxerPtsUnitTest, TranscoderInitMediaStartPts_001, TestSize.Level0)
195 {
196 ASSERT_NE(demuxerPtr_, nullptr);
197 std::string mime;
198 demuxerPtr_->mediaMetaData_.trackMetas.push_back(nullptr);
199 auto realMeta = std::make_shared<Meta>();
200 demuxerPtr_->mediaMetaData_.trackMetas.push_back(realMeta);
201 demuxerPtr_->TranscoderInitMediaStartPts();
202 EXPECT_EQ(demuxerPtr_->mediaMetaData_.trackMetas[ID_TEST]->GetData(Tag::MIME_TYPE, mime), false);
203 }
204 } // OHOS::Media