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 "demuxer_plugin_manager_test.h"
17
18 #include "gtest/gtest.h"
19 #include "demuxer_plugin_manager.h"
20
21 #define LOCAL true
22
23 using namespace OHOS;
24 using namespace OHOS::Media;
25 using namespace testing::ext;
26 using namespace testing;
27 using namespace std;
28
29 namespace OHOS {
30 namespace Media {
31 static const int BUFFER_PADDING_SIZE = 1024;
32 static const int DEF_PROB_SIZE = 16 * 1024;
33
34 static const std::string DEMUXER_PLUGIN_NAME_AAC = "avdemux_aac";
35 static const std::string DEMUXER_PLUGIN_NAME_AMR = "avdemux_amr";
36 static const std::string DEMUXER_PLUGIN_NAME_AMRNB = "avdemux_amrnb";
37 static const std::string DEMUXER_PLUGIN_NAME_AMRWB = "avdemux_amrwb";
38 static const std::string DEMUXER_PLUGIN_NAME_APE = "avdemux_ape";
39 static const std::string DEMUXER_PLUGIN_NAME_FLAC = "avdemux_flac";
40 static const std::string DEMUXER_PLUGIN_NAME_FLV = "avdemux_flv";
41 static const std::string DEMUXER_PLUGIN_NAME_MATROSKA = "avdemux_matroska,webm";
42 static const std::string DEMUXER_PLUGIN_NAME_MOV_S = "avdemux_mov,mp4,m4a,3gp,3g2,mj2";
43 static const std::string DEMUXER_PLUGIN_NAME_MP3 = "avdemux_mp3";
44 static const std::string DEMUXER_PLUGIN_NAME_MPEG = "avdemux_mpeg";
45 static const std::string DEMUXER_PLUGIN_NAME_MPEGTS = "avdemux_mpegts";
46 static const std::string DEMUXER_PLUGIN_NAME_AVI = "avdemux_avi";
47 static const std::string DEMUXER_PLUGIN_NAME_SRT = "avdemux_srt";
48 static const std::string DEMUXER_PLUGIN_NAME_WEBVTT = "avdemux_webvtt";
49 static const std::string DEMUXER_PLUGIN_NAME_OGG = "avdemux_ogg";
50 static const std::string DEMUXER_PLUGIN_NAME_WAV = "avdemux_wav";
51 static const std::string DEMUXER_PLUGIN_NAME_RM = "avdemux_rm";
52 static const std::string DEMUXER_PLUGIN_NAME_AC3 = "avdemux_ac3";
53 static const std::string DEMUXER_PLUGIN_NAME_ERR = "avdemux_err";
54
55 static const string TEST_FILE_PATH = "/data/test/media/";
56 static const string TEST_FILE_URI_AAC = TEST_FILE_PATH + "audio/aac_44100_1.aac";
57 static const string TEST_FILE_URI_AMR = TEST_FILE_PATH + "audio/amr_nb_8000_1.amr";
58 static const string TEST_FILE_URI_AMRNB = TEST_FILE_PATH + "audio/amr_nb_8000_1.amr";
59 static const string TEST_FILE_URI_AMRWB = TEST_FILE_PATH + "audio/amr_wb_16000_1.amr";
60 static const string TEST_FILE_URI_APE = TEST_FILE_PATH + "ape_test.ape";
61 static const string TEST_FILE_URI_FLAC = TEST_FILE_PATH + "audio/flac_48000_1_cover.flac";
62 static const string TEST_FILE_URI_FLV = TEST_FILE_PATH + "h264.flv";
63 static const string TEST_FILE_URI_MATROSKA = TEST_FILE_PATH + "h264_opus_4sec.mkv";
64 static const string TEST_FILE_URI_MOV = TEST_FILE_PATH + "h264_aac.mov";
65 static const string TEST_FILE_URI_MP4 = TEST_FILE_PATH + "5_1_4_16bit_32000Hz_704kbps.mp4";
66 static const string TEST_FILE_URI_FMP4 = TEST_FILE_PATH + "h265_fmp4.mp4";
67 static const string TEST_FILE_URI_M4A = TEST_FILE_PATH + "audio/h264_fmp4.m4a";
68 static const string TEST_FILE_URI_MP3 = TEST_FILE_PATH + "audio/mp3_48000_1_cover.mp3";
69 static const string TEST_FILE_URI_MPEG = TEST_FILE_PATH + "mpeg_h264_mp2.mpeg";
70 static const string TEST_FILE_URI_MPEGTS = TEST_FILE_PATH + "test_mpeg2_Gop25_4sec.ts";
71 static const string TEST_FILE_URI_AVI = TEST_FILE_PATH + "h264_aac.avi";
72 static const string TEST_FILE_URI_SRT = TEST_FILE_PATH + "subtitle.srt";
73 static const string TEST_FILE_URI_WEBVTT = TEST_FILE_PATH + "webvtt_test.vtt";
74 static const string TEST_FILE_URI_OGG = TEST_FILE_PATH + "audio/ogg_48000_1.ogg";
75 static const string TEST_FILE_URI_WAV = TEST_FILE_PATH + "audio/wav_48000_1.wav";
76 static const string TEST_FILE_URI_RM = TEST_FILE_PATH + "rv40_cook.rmvb";
77 static const string TEST_FILE_URI_AC3 = TEST_FILE_PATH + "audio/ac3_test.ac3";
78
SetUpTestCase(void)79 void DemuxerPluginManagerUnitTest::SetUpTestCase(void) {}
80
TearDownTestCase(void)81 void DemuxerPluginManagerUnitTest::TearDownTestCase(void) {}
82
SetUp(void)83 void DemuxerPluginManagerUnitTest::SetUp(void)
84 {
85 demuxerPluginManager_ = std::make_shared<DemuxerPluginManager>();
86 streamDemuxer_ = std::make_shared<MockBaseStreamDemuxer>();
87 int32_t streamId = 0;
88 dataSourceImpl_ = std::make_shared<DataSourceImpl>(streamDemuxer_, streamId);
89 dataSourceImpl_->stream_ = streamDemuxer_;
90 }
91
TearDown(void)92 void DemuxerPluginManagerUnitTest::TearDown(void)
93 {
94 demuxerPluginManager_ = nullptr;
95 streamDemuxer_ = nullptr;
96 dataSourceImpl_ = nullptr;
97 }
98
99 HWTEST_F(DemuxerPluginManagerUnitTest, SetStreamID_001, TestSize.Level1)
100 {
101 // 1. Set up the test environment
102 ASSERT_NE(dataSourceImpl_, nullptr);
103
104 // 2. Call the function to be tested
105 Status status = dataSourceImpl_->SetStreamID(1);
106
107 // 3. Verify the result
108 EXPECT_EQ(status, Status::OK);
109 EXPECT_EQ(dataSourceImpl_->streamID_, 1);
110 EXPECT_EQ(dataSourceImpl_->GetStreamID(), 1);
111 }
112
113 HWTEST_F(DemuxerPluginManagerUnitTest, GetStreamCount_001, TestSize.Level1)
114 {
115 size_t streamCount = demuxerPluginManager_->GetStreamCount();
116
117 EXPECT_EQ(streamCount, demuxerPluginManager_->streamInfoMap_.size());
118 }
119
120 HWTEST_F(DemuxerPluginManagerUnitTest, LoadCurrentSubtitlePlugin_001, TestSize.Level1)
121 {
122 demuxerPluginManager_->curSubTitleStreamID_ = -1;
123 Plugins::MediaInfo mediaInfo;
124 Status status = demuxerPluginManager_->LoadCurrentSubtitlePlugin(streamDemuxer_, mediaInfo);
125
126 EXPECT_EQ(status, Status::ERROR_UNKNOWN);
127 }
128
129 HWTEST_F(DemuxerPluginManagerUnitTest, GetInnerTrackIDByTrackID_001, TestSize.Level1)
130 {
131 int32_t trackId = 1;
132 demuxerPluginManager_->trackInfoMap_[trackId].innerTrackIndex = 2;
133
134 // 2. Call the function to be tested
135 int32_t innerTrackId = demuxerPluginManager_->GetInnerTrackIDByTrackID(trackId);
136
137 // 3. Verify the result
138 EXPECT_EQ(innerTrackId, 2);
139 }
140
141 HWTEST_F(DemuxerPluginManagerUnitTest, GetInnerTrackIDByTrackID_002, TestSize.Level1)
142 {
143 int32_t trackId = 1;
144
145 // 2. Call the function to be tested
146 int32_t innerTrackId = demuxerPluginManager_->GetInnerTrackIDByTrackID(trackId);
147
148 // 3. Verify the result
149 EXPECT_EQ(innerTrackId, -1);
150 }
151
152 HWTEST_F(DemuxerPluginManagerUnitTest, AddExternalSubtitle_001, TestSize.Level1)
153 {
154 // 1. Set up the test environment
155 demuxerPluginManager_->curSubTitleStreamID_ = -1;
156 // 2. Call the function to be tested
157 int32_t result = demuxerPluginManager_->AddExternalSubtitle();
158 // 3. Verify the result
159 EXPECT_EQ(result, 0);
160 EXPECT_EQ(demuxerPluginManager_->curSubTitleStreamID_, 0);
161
162 // 1. Set up the test environment
163 demuxerPluginManager_->curSubTitleStreamID_ = 0;
164 // 2. Call the function to be tested
165 result = demuxerPluginManager_->AddExternalSubtitle();
166 }
167
168 HWTEST_F(DemuxerPluginManagerUnitTest, IsSubtitleMime_001, TestSize.Level1)
169 {
170 // 1. Set up the test environment
171 std::string mime = "application/x-subrip";
172 // 2. Call the function to be tested
173 bool result = demuxerPluginManager_->IsSubtitleMime(mime);
174 // 3. Verify the result
175 EXPECT_EQ(result, true);
176
177 // 1. Set up the test environment
178 mime = "text/vtt";
179 // 2. Call the function to be tested
180 result = demuxerPluginManager_->IsSubtitleMime(mime);
181 // 3. Verify the result
182 EXPECT_EQ(result, true);
183
184 // 1. Set up the test environment
185 mime = "video/mp4";
186 // 2. Call the function to be tested
187 result = demuxerPluginManager_->IsSubtitleMime(mime);
188 // 3. Verify the result
189 EXPECT_EQ(result, false);
190 }
191
192 HWTEST_F(DemuxerPluginManagerUnitTest, GetTrackTypeByTrackID_001, TestSize.Level1)
193 {
194 // 1. Set up the test environment
195 int32_t trackId = 0;
196 std::vector<Meta> tracks;
197 Meta meta;
198 meta.SetData(Tag::MIME_TYPE, "audio/mpeg");
199 tracks.push_back(meta);
200 Plugins::MediaInfo mediaInfo;
201 mediaInfo.tracks = tracks;
202 demuxerPluginManager_->curMediaInfo_ = mediaInfo;
203
204 // 2. Call the function to be tested
205 TrackType result = demuxerPluginManager_->GetTrackTypeByTrackID(trackId);
206
207 // 3. Verify the result
208 EXPECT_EQ(result, TRACK_AUDIO);
209 }
210
211 HWTEST_F(DemuxerPluginManagerUnitTest, GetTrackTypeByTrackID_002, TestSize.Level1)
212 {
213 // 1. Set up the test environment
214 int32_t trackId = 0;
215 std::vector<Meta> tracks;
216 Meta meta;
217 meta.SetData(Tag::MIME_TYPE, "video/mpeg");
218 tracks.push_back(meta);
219 Plugins::MediaInfo mediaInfo;
220 mediaInfo.tracks = tracks;
221 demuxerPluginManager_->curMediaInfo_ = mediaInfo;
222
223 // 2. Call the function to be tested
224 TrackType result = demuxerPluginManager_->GetTrackTypeByTrackID(trackId);
225
226 // 3. Verify the result
227 EXPECT_EQ(result, TRACK_VIDEO);
228 }
229
230 HWTEST_F(DemuxerPluginManagerUnitTest, GetTrackTypeByTrackID_003, TestSize.Level1)
231 {
232 // 1. Set up the test environment
233 int32_t trackId = 0;
234 std::vector<Meta> tracks;
235 Meta meta;
236 meta.SetData(Tag::MIME_TYPE, "application/x-subrip");
237 tracks.push_back(meta);
238 Plugins::MediaInfo mediaInfo;
239 mediaInfo.tracks = tracks;
240 demuxerPluginManager_->curMediaInfo_ = mediaInfo;
241
242 // 2. Call the function to be tested
243 TrackType result = demuxerPluginManager_->GetTrackTypeByTrackID(trackId);
244
245 // 3. Verify the result
246 EXPECT_EQ(result, TRACK_SUBTITLE);
247 }
248
249 HWTEST_F(DemuxerPluginManagerUnitTest, GetTrackTypeByTrackID_004, TestSize.Level1)
250 {
251 // 1. Set up the test environment
252 int32_t trackId = 0;
253 std::vector<Meta> tracks;
254 Meta meta;
255 meta.SetData(Tag::MIME_TYPE, "unknown/type");
256 tracks.push_back(meta);
257 Plugins::MediaInfo mediaInfo;
258 mediaInfo.tracks = tracks;
259 demuxerPluginManager_->curMediaInfo_ = mediaInfo;
260
261 // 2. Call the function to be tested
262 TrackType result = demuxerPluginManager_->GetTrackTypeByTrackID(trackId);
263
264 // 3. Verify the result
265 EXPECT_EQ(result, TRACK_INVALID);
266 }
267
268 HWTEST_F(DemuxerPluginManagerUnitTest, GetStreamTypeByTrackID_001, TestSize.Level1)
269 {
270 int32_t trackId = 1;
271 std::map<int32_t, MediaTrackMap> mediaTrackMap;
272 mediaTrackMap[1].streamID = 1;
273 demuxerPluginManager_->trackInfoMap_ = mediaTrackMap;
274 demuxerPluginManager_->streamInfoMap_[1].type = StreamType::VIDEO;
275 // 2. Call the function to be tested
276 StreamType result = demuxerPluginManager_->GetStreamTypeByTrackID(trackId);
277
278 // 3. Verify the result
279 EXPECT_EQ(result, StreamType::VIDEO);
280 }
281
282 HWTEST_F(DemuxerPluginManagerUnitTest, UpdateDefaultStreamID_001, TestSize.Level1)
283 {
284 // 1. Set up the test environment
285 Plugins::MediaInfo mediaInfo;
286 int32_t newStreamID = 1; // Assuming streamID 1 is valid
287
288 // 2. Call the function to be tested
289 Status result = demuxerPluginManager_->UpdateDefaultStreamID(mediaInfo, StreamType::AUDIO, newStreamID);
290
291 // 3. Verify the result
292 EXPECT_EQ(demuxerPluginManager_->curAudioStreamID_, newStreamID);
293 EXPECT_EQ(result, Status::OK);
294 }
295
296 HWTEST_F(DemuxerPluginManagerUnitTest, UpdateDefaultStreamID_002, TestSize.Level1)
297 {
298 // 1. Set up the test environment
299 Plugins::MediaInfo mediaInfo;
300 int32_t newStreamID = 1; // Assuming streamID 1 is valid
301
302 // 2. Call the function to be tested
303 Status result = demuxerPluginManager_->UpdateDefaultStreamID(mediaInfo, StreamType::SUBTITLE, newStreamID);
304
305 // 3. Verify the result
306 EXPECT_EQ(demuxerPluginManager_->curSubTitleStreamID_, newStreamID);
307 EXPECT_EQ(result, Status::OK);
308 }
309
310 HWTEST_F(DemuxerPluginManagerUnitTest, UpdateDefaultStreamID_003, TestSize.Level1)
311 {
312 // 1. Set up the test environment
313 Plugins::MediaInfo mediaInfo;
314 int32_t newStreamID = 1; // Assuming streamID 1 is valid
315
316 // 2. Call the function to be tested
317 Status result = demuxerPluginManager_->UpdateDefaultStreamID(mediaInfo, StreamType::VIDEO, newStreamID);
318
319 // 3. Verify the result
320 EXPECT_EQ(demuxerPluginManager_->curVideoStreamID_, newStreamID);
321 EXPECT_EQ(result, Status::OK);
322 }
323
324 HWTEST_F(DemuxerPluginManagerUnitTest, SetResetEosStatus_001, TestSize.Level1)
325 {
326 // 1. Set up the test environment
327 bool flag = true;
328
329 // 2. Call the function to be tested
330 demuxerPluginManager_->SetResetEosStatus(flag);
331
332 // 3. Verify the result
333 EXPECT_EQ(demuxerPluginManager_->needResetEosStatus_, flag);
334 }
335
336 HWTEST_F(DemuxerPluginManagerUnitTest, ReadAt_001, TestSize.Level1)
337 {
338 int64_t offset = 1;
339 std::shared_ptr<Buffer> buffer = nullptr;
340 size_t expectedLen = 0;
341 dataSourceImpl_->stream_->seekable_ = Plugins::Seekable::UNSEEKABLE;
342 dataSourceImpl_->stream_->mediaDataSize_ = 0;
343 EXPECT_CALL(*streamDemuxer_, CallbackReadAt).WillRepeatedly(Return(Status::OK));
344 EXPECT_EQ(dataSourceImpl_->ReadAt(offset, buffer, expectedLen), Status::ERROR_UNKNOWN);
345 buffer = std::shared_ptr<Buffer>();
346 EXPECT_EQ(dataSourceImpl_->ReadAt(offset, buffer, expectedLen), Status::ERROR_UNKNOWN);
347 buffer = nullptr;
348 dataSourceImpl_->stream_->seekable_ = Plugins::Seekable::SEEKABLE;
349 dataSourceImpl_->stream_->mediaDataSize_ = 0;
350 offset = 1;
351 EXPECT_EQ(dataSourceImpl_->ReadAt(offset, buffer, expectedLen), Status::ERROR_UNKNOWN);
352 }
353
354 HWTEST_F(DemuxerPluginManagerUnitTest, UpdateTempTrackMapInfo_001, TestSize.Level1)
355 {
356 int32_t oldTrackId = 0;
357 int32_t newTrackId = 0;
358 int32_t newInnerTrackIndex = 0;
359 demuxerPluginManager_->temp2TrackInfoMap_[oldTrackId] = MediaTrackMap();
360 demuxerPluginManager_->temp2TrackInfoMap_[oldTrackId].streamID = 0;
361 demuxerPluginManager_->temp2TrackInfoMap_[oldTrackId].innerTrackIndex = 0;
362 demuxerPluginManager_->temp2TrackInfoMap_[newTrackId] = MediaTrackMap();
363 demuxerPluginManager_->temp2TrackInfoMap_[newTrackId].streamID = 0;
364 demuxerPluginManager_->temp2TrackInfoMap_[newTrackId].innerTrackIndex = 0;
365 demuxerPluginManager_->UpdateTempTrackMapInfo(oldTrackId, newTrackId, newInnerTrackIndex);
366 EXPECT_EQ(demuxerPluginManager_->temp2TrackInfoMap_[oldTrackId].innerTrackIndex, newInnerTrackIndex);
367 }
368
369 HWTEST_F(DemuxerPluginManagerUnitTest, SingleStreamSeekTo_001, TestSize.Level1)
370 {
371 Plugins::SeekMode mode = Plugins::SeekMode::SEEK_NEXT_SYNC;
372 int64_t seekTime = 0;
373 int32_t streamID = 0;
374 int64_t realSeekTime = 0;
375 demuxerPluginManager_->streamInfoMap_[0] = MediaStreamInfo();
376 demuxerPluginManager_->streamInfoMap_[0].plugin = nullptr;
377 // 110
378 EXPECT_EQ(demuxerPluginManager_->SingleStreamSeekTo(seekTime, mode, streamID, realSeekTime), Status::OK);
379 // 100
380 streamID = 2;
381 EXPECT_EQ(demuxerPluginManager_->SingleStreamSeekTo(seekTime, mode, streamID, realSeekTime), Status::OK);
382 // 000
383 streamID = -1;
384 EXPECT_EQ(demuxerPluginManager_->SingleStreamSeekTo(seekTime, mode, streamID, realSeekTime), Status::OK);
385 }
386
387 HWTEST_F(DemuxerPluginManagerUnitTest, GetCurrentBitRate_001, TestSize.Level1)
388 {
389 uint32_t bitRate = 10;
390 uint32_t ret = 0;
391 demuxerPluginManager_->curVideoStreamID_ = 1;
392 demuxerPluginManager_->streamInfoMap_[demuxerPluginManager_->curVideoStreamID_] = MediaStreamInfo();
393 demuxerPluginManager_->streamInfoMap_[demuxerPluginManager_->curVideoStreamID_].bitRate = bitRate;
394 demuxerPluginManager_->isDash_ = true;
395 // 11
396 EXPECT_EQ(demuxerPluginManager_->GetCurrentBitRate(), bitRate);
397 // 10
398 demuxerPluginManager_->curVideoStreamID_ = -1;
399 EXPECT_EQ(demuxerPluginManager_->GetCurrentBitRate(), ret);
400 // 00
401 demuxerPluginManager_->isDash_ = false;
402 EXPECT_EQ(demuxerPluginManager_->GetCurrentBitRate(), ret);
403 // 01
404 demuxerPluginManager_->curVideoStreamID_ = 1;
405 EXPECT_EQ(demuxerPluginManager_->GetCurrentBitRate(), ret);
406 }
407
408 HWTEST_F(DemuxerPluginManagerUnitTest, RebootPlugin_001, TestSize.Level1)
409 {
410 int32_t streamId = 0;
411 TrackType trackType = TRACK_AUDIO;
412 bool isRebooted;
413 demuxerPluginManager_->streamInfoMap_[0] = MediaStreamInfo();
414 demuxerPluginManager_->streamInfoMap_[1] = MediaStreamInfo();
415 EXPECT_CALL(*streamDemuxer_, ResetCache).WillRepeatedly(Return(Status::OK));
416 EXPECT_CALL(*streamDemuxer_, SetDemuxerState).WillRepeatedly(Return());
417 std::string str = "";
418 EXPECT_CALL(*streamDemuxer_, SnifferMediaType).WillRepeatedly(Return(str));
419 streamId = 1;
420 EXPECT_EQ(demuxerPluginManager_->RebootPlugin(streamId, trackType, streamDemuxer_, isRebooted),
421 Status::ERROR_INVALID_PARAMETER);
422 trackType = TRACK_INVALID;
423 EXPECT_EQ(demuxerPluginManager_->RebootPlugin(streamId, trackType, streamDemuxer_, isRebooted),
424 Status::ERROR_INVALID_PARAMETER);
425 streamId = 0;
426 EXPECT_EQ(demuxerPluginManager_->RebootPlugin(streamId, trackType, streamDemuxer_, isRebooted),
427 Status::ERROR_INVALID_PARAMETER);
428 }
429
430 HWTEST_F(DemuxerPluginManagerUnitTest, GetStreamDemuxerNewStreamID_001, TestSize.Level1)
431 {
432 int32_t newStreamID = 1;
433 EXPECT_CALL(*streamDemuxer_, GetNewAudioStreamID()).WillRepeatedly(Return(newStreamID));
434 EXPECT_CALL(*streamDemuxer_, GetNewSubtitleStreamID()).WillRepeatedly(Return(newStreamID));
435 EXPECT_CALL(*streamDemuxer_, GetNewVideoStreamID()).WillRepeatedly(Return(newStreamID));
436 EXPECT_EQ(streamDemuxer_->GetNewAudioStreamID(), newStreamID);
437 TrackType trackType = TRACK_AUDIO;
438 EXPECT_EQ(demuxerPluginManager_->GetStreamDemuxerNewStreamID(trackType, streamDemuxer_), newStreamID);
439 trackType = TRACK_SUBTITLE;
440 EXPECT_EQ(demuxerPluginManager_->GetStreamDemuxerNewStreamID(trackType, streamDemuxer_), newStreamID);
441 trackType = TRACK_VIDEO;
442 EXPECT_EQ(demuxerPluginManager_->GetStreamDemuxerNewStreamID(trackType, streamDemuxer_), newStreamID);
443 }
444
445 HWTEST_F(DemuxerPluginManagerUnitTest, StartPlugin_001, TestSize.Level1)
446 {
447 int32_t streamId = 0;
448 EXPECT_EQ(demuxerPluginManager_->StartPlugin(streamId, streamDemuxer_), Status::OK);
449 }
450
451 HWTEST_F(DemuxerPluginManagerUnitTest, StopPlugin_001, TestSize.Level1)
452 {
453 int32_t streamId = 0;
454 EXPECT_CALL(*streamDemuxer_, ResetCache).WillRepeatedly(Return(Status::OK));
455 EXPECT_EQ(demuxerPluginManager_->StopPlugin(streamId, streamDemuxer_), Status::OK);
456 demuxerPluginManager_->streamInfoMap_[streamId] = MediaStreamInfo();
457 demuxerPluginManager_->streamInfoMap_[streamId].plugin = nullptr;
458 EXPECT_EQ(demuxerPluginManager_->StopPlugin(streamId, streamDemuxer_), Status::OK);
459 }
460
461 HWTEST_F(DemuxerPluginManagerUnitTest, GetStreamIDByTrackType_001, TestSize.Level1)
462 {
463 TrackType trackType = TRACK_VIDEO;
464 demuxerPluginManager_->curVideoStreamID_ = 1;
465 EXPECT_EQ(demuxerPluginManager_->GetStreamIDByTrackType(trackType), demuxerPluginManager_->curVideoStreamID_);
466 trackType = TRACK_AUDIO;
467 demuxerPluginManager_->curAudioStreamID_ = 2;
468 EXPECT_EQ(demuxerPluginManager_->GetStreamIDByTrackType(trackType), demuxerPluginManager_->curAudioStreamID_);
469 trackType = TRACK_SUBTITLE;
470 demuxerPluginManager_->curSubTitleStreamID_ = 3;
471 EXPECT_EQ(demuxerPluginManager_->GetStreamIDByTrackType(trackType), demuxerPluginManager_->curSubTitleStreamID_);
472 trackType = TRACK_INVALID;
473 EXPECT_EQ(demuxerPluginManager_->GetStreamIDByTrackType(trackType), -1);
474 }
475
476 HWTEST_F(DemuxerPluginManagerUnitTest, SnifferMediaType_Timeout, TestSize.Level1)
477 {
478 int32_t streamId = 0;
479 EXPECT_CALL(*streamDemuxer_, SnifferMediaType(_))
__anon3ea81c660102(int32_t streamID) 480 .WillRepeatedly([](int32_t streamID) {
481 std::this_thread::sleep_for(std::chrono::milliseconds(300));
482 return "DEMUXER";
483 });
484 ASSERT_NE(demuxerPluginManager_->LoadDemuxerPlugin(streamId, streamDemuxer_), Status::OK);
485 }
486
CreateDataSource(const std::string & filePath)487 bool DemuxerPluginManagerUnitTest::CreateDataSource(const std::string& filePath)
488 {
489 mediaSource_ = std::make_shared<MediaSource>(filePath);
490 realSource_ = std::make_shared<Source>();
491 realSource_->SetSource(mediaSource_);
492
493 realStreamDemuxer_ = std::make_shared<StreamDemuxer>();
494 realStreamDemuxer_->SetSourceType(Plugins::SourceType::SOURCE_TYPE_URI);
495 realStreamDemuxer_->SetSource(realSource_);
496 realStreamDemuxer_->Init(filePath);
497
498 realStreamDemuxer_->SetDemuxerState(streamId_, DemuxerState::DEMUXER_STATE_PARSE_HEADER);
499 dataSourceImpl_ = std::make_shared<DataSourceImpl>(realStreamDemuxer_, streamId_);
500 realSource_->NotifyInitSuccess();
501
502 return true;
503 }
504
CreateDemuxerPluginByName(const std::string & typeName,const std::string & filePath,int probSize)505 bool DemuxerPluginManagerUnitTest::CreateDemuxerPluginByName(
506 const std::string& typeName, const std::string& filePath, int probSize)
507 {
508 if (!CreateDataSource(filePath)) {
509 printf("CreateDataSource failed for file: %s\n", filePath.c_str());
510 return false;
511 }
512 pluginBase_ = Plugins::PluginManagerV2::Instance().CreatePluginByName(typeName);
513 if (pluginBase_ == nullptr) {
514 printf("CreatePluginByName failed for type: %s\n", typeName.c_str());
515 return false;
516 }
517 auto demuxerPlugin = std::static_pointer_cast<Plugins::DemuxerPlugin>(pluginBase_);
518 if (demuxerPlugin->SetDataSourceWithProbSize(dataSourceImpl_, probSize) != Status::OK) {
519 printf("SetDataSourceWithProbSize failed for type: %s\n", typeName.c_str());
520 return false;
521 }
522
523 realStreamDemuxer_->SetDemuxerState(streamId_, DemuxerState::DEMUXER_STATE_PARSE_FIRST_FRAME);
524
525 return true;
526 }
527
PluginSelectTracks()528 bool DemuxerPluginManagerUnitTest::PluginSelectTracks()
529 {
530 MediaInfo mediaInfo;
531 auto demuxerPlugin = std::static_pointer_cast<Plugins::DemuxerPlugin>(pluginBase_);
532 if (demuxerPlugin->GetMediaInfo(mediaInfo) != Status::OK) {
533 printf("GetMediaInfo failed for plugin\n");
534 return false;
535 }
536
537 for (size_t i = 0; i < mediaInfo.tracks.size(); i++) {
538 std::string mime;
539 mediaInfo.tracks[i].GetData(Tag::MIME_TYPE, mime);
540 if (mime.find("video/") == 0 || mime.find("audio/") == 0 ||
541 mime.find("application/") == 0 || mime.find("text/vtt") == 0) {
542 demuxerPlugin->SelectTrack(static_cast<uint32_t>(i));
543 selectedTrackIds_.push_back(static_cast<uint32_t>(i));
544 frames_[i] = 0;
545 keyFrames_[i] = 0;
546 eosFlag_[i] = false;
547 }
548 }
549
550 return true;
551 }
552
PluginReadSample(uint32_t idx,uint32_t & flag)553 bool DemuxerPluginManagerUnitTest::PluginReadSample(uint32_t idx, uint32_t& flag)
554 {
555 int bufSize = 0;
556 auto demuxerPlugin = std::static_pointer_cast<Plugins::DemuxerPlugin>(pluginBase_);
557 demuxerPlugin->GetNextSampleSize(idx, bufSize);
558 if (static_cast<uint32_t>(bufSize) > buffer_.size()) {
559 buffer_.resize(bufSize + BUFFER_PADDING_SIZE);
560 }
561
562 auto avBuf = AVBuffer::CreateAVBuffer(buffer_.data(), bufSize, bufSize);
563 if (avBuf == nullptr) {
564 printf("CreateAVBuffer failed for index: %u\n", idx);
565 return false;
566 }
567
568 demuxerPlugin->ReadSample(idx, avBuf);
569 flag = avBuf->flag_;
570
571 return true;
572 }
573
CountFrames(uint32_t index,uint32_t flag)574 void DemuxerPluginManagerUnitTest::CountFrames(uint32_t index, uint32_t flag)
575 {
576 if (flag & static_cast<uint32_t>(AVBufferFlag::EOS)) {
577 eosFlag_[index] = true;
578 return;
579 }
580
581 if (flag & static_cast<uint32_t>(AVBufferFlag::SYNC_FRAME)) {
582 keyFrames_[index]++;
583 frames_[index]++;
584 } else if ((flag & static_cast<uint32_t>(AVBufferFlag::NONE)) == static_cast<uint32_t>(AVBufferFlag::NONE)) {
585 frames_[index]++;
586 } else {
587 SetEosValue();
588 printf("flag is unknown, read sample break");
589 }
590 }
591
isEOS(map<uint32_t,bool> & countFlag)592 bool DemuxerPluginManagerUnitTest::isEOS(map<uint32_t, bool>& countFlag)
593 {
594 auto ret = std::find_if(countFlag.begin(), countFlag.end(), [](const pair<uint32_t, bool>& p) {
595 return p.second == false;
596 });
597
598 return ret == countFlag.end();
599 }
600
SetEosValue()601 void DemuxerPluginManagerUnitTest::SetEosValue()
602 {
603 std::for_each(selectedTrackIds_.begin(), selectedTrackIds_.end(), [this](uint32_t idx) {
604 eosFlag_[idx] = true;
605 });
606 }
607
RemoveValue()608 void DemuxerPluginManagerUnitTest::RemoveValue()
609 {
610 if (!frames_.empty()) {
611 frames_.clear();
612 }
613 if (!keyFrames_.empty()) {
614 keyFrames_.clear();
615 }
616 if (!eosFlag_.empty()) {
617 eosFlag_.clear();
618 }
619 }
620
ResultAssert(uint32_t frames0,uint32_t frames1,uint32_t keyFrames0,uint32_t keyFrames1)621 bool DemuxerPluginManagerUnitTest::ResultAssert(
622 uint32_t frames0, uint32_t frames1, uint32_t keyFrames0, uint32_t keyFrames1)
623 {
624 printf("frames_[0]=%d | kFrames[0]=%d\n", frames_[0], keyFrames_[0]);
625 printf("frames_[1]=%d | kFrames[1]=%d\n", frames_[1], keyFrames_[1]);
626 if (frames_[0] != frames0) {
627 printf("Expected frames_[0] = %d, but got %d\n", frames0, frames_[0]);
628 return false;
629 }
630 if (frames_[1] != frames1) {
631 printf("Expected frames_[1] = %d, but got %d\n", frames1, frames_[1]);
632 return false;
633 }
634 if (keyFrames_[0] != keyFrames0) {
635 printf("Expected keyFrames_[0] = %d, but got %d\n", keyFrames0, keyFrames_[0]);
636 return false;
637 }
638 if (keyFrames_[1] != keyFrames1) {
639 printf("Expected keyFrames_[1] = %d, but got %d\n", keyFrames1, keyFrames_[1]);
640 return false;
641 }
642
643 return true;
644 }
645
PluginReadAllSample()646 bool DemuxerPluginManagerUnitTest::PluginReadAllSample()
647 {
648 while (!isEOS(eosFlag_)) {
649 for (auto idx : selectedTrackIds_) {
650 uint32_t flag = 0;
651 if (!PluginReadSample(idx, flag)) {
652 printf("PluginReadSample failed for index: %u\n", idx);
653 return false;
654 }
655 CountFrames(idx, flag);
656 }
657 }
658
659 return true;
660 }
661
662 HWTEST_F(DemuxerPluginManagerUnitTest, CreateDemuxerPluginByName_0001, TestSize.Level1)
663 {
664 ASSERT_EQ(CreateDemuxerPluginByName(DEMUXER_PLUGIN_NAME_AAC, TEST_FILE_URI_AAC, DEF_PROB_SIZE), true);
665 ASSERT_EQ(PluginSelectTracks(), true);
666 ASSERT_EQ(PluginReadAllSample(), true);
667 ASSERT_EQ(ResultAssert(1293, 0, 1293, 0), true);
668 RemoveValue();
669 }
670
671 HWTEST_F(DemuxerPluginManagerUnitTest, CreateDemuxerPluginByName_0002, TestSize.Level1)
672 {
673 ASSERT_EQ(CreateDemuxerPluginByName(DEMUXER_PLUGIN_NAME_AMR, TEST_FILE_URI_AMR, DEF_PROB_SIZE), true);
674 ASSERT_EQ(PluginSelectTracks(), true);
675 ASSERT_EQ(PluginReadAllSample(), true);
676 ASSERT_EQ(ResultAssert(1501, 0, 1501, 0), true);
677 RemoveValue();
678 }
679
680 HWTEST_F(DemuxerPluginManagerUnitTest, CreateDemuxerPluginByName_0003, TestSize.Level1)
681 {
682 ASSERT_EQ(CreateDemuxerPluginByName(DEMUXER_PLUGIN_NAME_AMR, TEST_FILE_URI_AMRNB, DEF_PROB_SIZE), true);
683 ASSERT_EQ(PluginSelectTracks(), true);
684 ASSERT_EQ(PluginReadAllSample(), true);
685 ASSERT_EQ(ResultAssert(1501, 0, 1501, 0), true);
686 RemoveValue();
687 }
688
689 HWTEST_F(DemuxerPluginManagerUnitTest, CreateDemuxerPluginByName_0004, TestSize.Level1)
690 {
691 ASSERT_EQ(CreateDemuxerPluginByName(DEMUXER_PLUGIN_NAME_AMR, TEST_FILE_URI_AMRWB, DEF_PROB_SIZE), true);
692 ASSERT_EQ(PluginSelectTracks(), true);
693 ASSERT_EQ(PluginReadAllSample(), true);
694 ASSERT_EQ(ResultAssert(1500, 0, 1500, 0), true);
695 RemoveValue();
696 }
697
698 HWTEST_F(DemuxerPluginManagerUnitTest, CreateDemuxerPluginByName_0005, TestSize.Level1)
699 {
700 ASSERT_EQ(CreateDemuxerPluginByName(DEMUXER_PLUGIN_NAME_APE, TEST_FILE_URI_APE, DEF_PROB_SIZE), true);
701 ASSERT_EQ(PluginSelectTracks(), true);
702 ASSERT_EQ(PluginReadAllSample(), true);
703 ASSERT_EQ(ResultAssert(7, 0, 7, 0), true);
704 RemoveValue();
705 }
706
707 HWTEST_F(DemuxerPluginManagerUnitTest, CreateDemuxerPluginByName_0006, TestSize.Level1)
708 {
709 ASSERT_EQ(CreateDemuxerPluginByName(DEMUXER_PLUGIN_NAME_FLAC, TEST_FILE_URI_FLAC, DEF_PROB_SIZE), true);
710 ASSERT_EQ(PluginSelectTracks(), true);
711 ASSERT_EQ(PluginReadAllSample(), true);
712 ASSERT_EQ(ResultAssert(313, 0, 313, 0), true);
713 RemoveValue();
714 }
715
716 HWTEST_F(DemuxerPluginManagerUnitTest, CreateDemuxerPluginByName_0007, TestSize.Level1)
717 {
718 ASSERT_EQ(CreateDemuxerPluginByName(DEMUXER_PLUGIN_NAME_FLV, TEST_FILE_URI_FLV, DEF_PROB_SIZE), true);
719 ASSERT_EQ(PluginSelectTracks(), true);
720 ASSERT_EQ(PluginReadAllSample(), true);
721 ASSERT_EQ(ResultAssert(76, 113, 1, 113), true);
722 RemoveValue();
723 }
724
725 HWTEST_F(DemuxerPluginManagerUnitTest, CreateDemuxerPluginByName_0008, TestSize.Level1)
726 {
727 ASSERT_EQ(CreateDemuxerPluginByName(DEMUXER_PLUGIN_NAME_MATROSKA, TEST_FILE_URI_MATROSKA, DEF_PROB_SIZE), true);
728 ASSERT_EQ(PluginSelectTracks(), true);
729 ASSERT_EQ(PluginReadAllSample(), true);
730 ASSERT_EQ(ResultAssert(240, 199, 4, 199), true);
731 RemoveValue();
732 }
733
734 HWTEST_F(DemuxerPluginManagerUnitTest, CreateDemuxerPluginByName_0009, TestSize.Level1)
735 {
736 ASSERT_EQ(CreateDemuxerPluginByName(DEMUXER_PLUGIN_NAME_MOV_S, TEST_FILE_URI_MOV, DEF_PROB_SIZE), true);
737 ASSERT_EQ(PluginSelectTracks(), true);
738 ASSERT_EQ(PluginReadAllSample(), true);
739 ASSERT_EQ(ResultAssert(602, 434, 3, 434), true);
740 RemoveValue();
741 }
742
743 HWTEST_F(DemuxerPluginManagerUnitTest, CreateDemuxerPluginByName_0010, TestSize.Level1)
744 {
745 ASSERT_EQ(CreateDemuxerPluginByName(DEMUXER_PLUGIN_NAME_MP3, TEST_FILE_URI_MP3, DEF_PROB_SIZE), true);
746 ASSERT_EQ(PluginSelectTracks(), true);
747 ASSERT_EQ(PluginReadAllSample(), true);
748 ASSERT_EQ(ResultAssert(1251, 0, 1251, 0), true);
749 RemoveValue();
750 }
751
752 HWTEST_F(DemuxerPluginManagerUnitTest, CreateDemuxerPluginByName_0011, TestSize.Level1)
753 {
754 ASSERT_EQ(CreateDemuxerPluginByName(DEMUXER_PLUGIN_NAME_MPEG, TEST_FILE_URI_MPEG, DEF_PROB_SIZE), true);
755 ASSERT_EQ(PluginSelectTracks(), true);
756 ASSERT_EQ(PluginReadAllSample(), true);
757 ASSERT_EQ(ResultAssert(1253, 2164, 19, 2164), true);
758 RemoveValue();
759 }
760
761 HWTEST_F(DemuxerPluginManagerUnitTest, CreateDemuxerPluginByName_0012, TestSize.Level1)
762 {
763 ASSERT_EQ(CreateDemuxerPluginByName(DEMUXER_PLUGIN_NAME_MPEGTS, TEST_FILE_URI_MPEGTS, DEF_PROB_SIZE), true);
764 ASSERT_EQ(PluginSelectTracks(), true);
765 ASSERT_EQ(PluginReadAllSample(), true);
766 ASSERT_EQ(ResultAssert(103, 174, 5, 174), true);
767 RemoveValue();
768 }
769
770 HWTEST_F(DemuxerPluginManagerUnitTest, CreateDemuxerPluginByName_0013, TestSize.Level1)
771 {
772 ASSERT_EQ(CreateDemuxerPluginByName(DEMUXER_PLUGIN_NAME_AVI, TEST_FILE_URI_AVI, DEF_PROB_SIZE), true);
773 ASSERT_EQ(PluginSelectTracks(), true);
774 ASSERT_EQ(PluginReadAllSample(), true);
775 ASSERT_EQ(ResultAssert(602, 433, 3, 433), true);
776 RemoveValue();
777 }
778
779 HWTEST_F(DemuxerPluginManagerUnitTest, CreateDemuxerPluginByName_0014, TestSize.Level1)
780 {
781 ASSERT_EQ(CreateDemuxerPluginByName(DEMUXER_PLUGIN_NAME_SRT, TEST_FILE_URI_SRT, DEF_PROB_SIZE), true);
782 ASSERT_EQ(PluginSelectTracks(), true);
783 ASSERT_EQ(PluginReadAllSample(), true);
784 ASSERT_EQ(ResultAssert(5, 0, 5, 0), true);
785 RemoveValue();
786 }
787
788 HWTEST_F(DemuxerPluginManagerUnitTest, CreateDemuxerPluginByName_0015, TestSize.Level1)
789 {
790 ASSERT_EQ(CreateDemuxerPluginByName(DEMUXER_PLUGIN_NAME_WEBVTT, TEST_FILE_URI_WEBVTT, DEF_PROB_SIZE), true);
791 ASSERT_EQ(PluginSelectTracks(), true);
792 ASSERT_EQ(PluginReadAllSample(), true);
793 ASSERT_EQ(ResultAssert(4, 0, 4, 0), true);
794 RemoveValue();
795 }
796
797 HWTEST_F(DemuxerPluginManagerUnitTest, CreateDemuxerPluginByName_0016, TestSize.Level1)
798 {
799 ASSERT_EQ(CreateDemuxerPluginByName(DEMUXER_PLUGIN_NAME_OGG, TEST_FILE_URI_OGG, DEF_PROB_SIZE), true);
800 ASSERT_EQ(PluginSelectTracks(), true);
801 ASSERT_EQ(PluginReadAllSample(), true);
802 ASSERT_EQ(ResultAssert(1598, 0, 1598, 0), true);
803 RemoveValue();
804 }
805
806 HWTEST_F(DemuxerPluginManagerUnitTest, CreateDemuxerPluginByName_0017, TestSize.Level1)
807 {
808 ASSERT_EQ(CreateDemuxerPluginByName(DEMUXER_PLUGIN_NAME_WAV, TEST_FILE_URI_WAV, DEF_PROB_SIZE), true);
809 ASSERT_EQ(PluginSelectTracks(), true);
810 ASSERT_EQ(PluginReadAllSample(), true);
811 ASSERT_EQ(ResultAssert(704, 0, 704, 0), true);
812 RemoveValue();
813 }
814
815 HWTEST_F(DemuxerPluginManagerUnitTest, CreateDemuxerPluginByName_0018, TestSize.Level1)
816 {
817 ASSERT_EQ(CreateDemuxerPluginByName(DEMUXER_PLUGIN_NAME_RM, TEST_FILE_URI_RM, DEF_PROB_SIZE), false);
818 ASSERT_EQ(CreateDemuxerPluginByName(DEMUXER_PLUGIN_NAME_AC3, TEST_FILE_URI_AC3, DEF_PROB_SIZE), true);
819 }
820
821
822 HWTEST_F(DemuxerPluginManagerUnitTest, CreateDemuxerPluginByName_0019, TestSize.Level1)
823 {
824 ASSERT_EQ(CreateDemuxerPluginByName(DEMUXER_PLUGIN_NAME_MOV_S, TEST_FILE_URI_MP4, DEF_PROB_SIZE), true);
825 ASSERT_EQ(PluginSelectTracks(), true);
826 ASSERT_EQ(PluginReadAllSample(), true);
827 ASSERT_EQ(ResultAssert(1875, 0, 1875, 0), true);
828 RemoveValue();
829 }
830
831 HWTEST_F(DemuxerPluginManagerUnitTest, CreateDemuxerPluginByName_0020, TestSize.Level1)
832 {
833 ASSERT_EQ(CreateDemuxerPluginByName(DEMUXER_PLUGIN_NAME_MOV_S, TEST_FILE_URI_FMP4, DEF_PROB_SIZE), true);
834 ASSERT_EQ(PluginSelectTracks(), true);
835 ASSERT_EQ(PluginReadAllSample(), true);
836 ASSERT_EQ(ResultAssert(604, 433, 3, 433), true);
837 RemoveValue();
838 }
839
840 HWTEST_F(DemuxerPluginManagerUnitTest, CreateDemuxerPluginByName_0021, TestSize.Level1)
841 {
842 ASSERT_EQ(CreateDemuxerPluginByName(DEMUXER_PLUGIN_NAME_MOV_S, TEST_FILE_URI_M4A, DEF_PROB_SIZE), true);
843 ASSERT_EQ(PluginSelectTracks(), true);
844 ASSERT_EQ(PluginReadAllSample(), true);
845 ASSERT_EQ(ResultAssert(433, 0, 433, 0), true);
846 RemoveValue();
847 }
848
849 HWTEST_F(DemuxerPluginManagerUnitTest, CreateDemuxerPluginByName_0022, TestSize.Level1)
850 {
851 ASSERT_EQ(CreateDemuxerPluginByName(DEMUXER_PLUGIN_NAME_MOV_S, TEST_FILE_URI_MP4, 0), false);
852 ASSERT_EQ(CreateDemuxerPluginByName(DEMUXER_PLUGIN_NAME_MOV_S, TEST_FILE_URI_MP4, 4), false);
853 ASSERT_EQ(CreateDemuxerPluginByName(DEMUXER_PLUGIN_NAME_MOV_S, TEST_FILE_URI_MP4, 512), true);
854 ASSERT_EQ(CreateDemuxerPluginByName(DEMUXER_PLUGIN_NAME_MOV_S, TEST_FILE_URI_MP4, DEF_PROB_SIZE), true);
855 RemoveValue();
856 }
857
858 HWTEST_F(DemuxerPluginManagerUnitTest, CreateDemuxerPluginByName_0023, TestSize.Level1)
859 {
860 ASSERT_EQ(CreateDemuxerPluginByName(DEMUXER_PLUGIN_NAME_AAC, TEST_FILE_URI_AMR, DEF_PROB_SIZE), false);
861 ASSERT_EQ(CreateDemuxerPluginByName(DEMUXER_PLUGIN_NAME_AMR, TEST_FILE_URI_APE, DEF_PROB_SIZE), false);
862 ASSERT_EQ(CreateDemuxerPluginByName(DEMUXER_PLUGIN_NAME_MP3, TEST_FILE_URI_MP4, DEF_PROB_SIZE), false);
863 ASSERT_EQ(CreateDemuxerPluginByName(DEMUXER_PLUGIN_NAME_MOV_S, TEST_FILE_URI_FLV, DEF_PROB_SIZE), false);
864 RemoveValue();
865 }
866
867 HWTEST_F(DemuxerPluginManagerUnitTest, CreateDemuxerPluginByName_0024, TestSize.Level1)
868 {
869 ASSERT_EQ(CreateDemuxerPluginByName(DEMUXER_PLUGIN_NAME_ERR, TEST_FILE_URI_AAC, DEF_PROB_SIZE), false);
870 RemoveValue();
871 }
872
873 HWTEST_F(DemuxerPluginManagerUnitTest, CreateDemuxerPluginByName_0025, TestSize.Level1)
874 {
875 ASSERT_EQ(CreateDemuxerPluginByName(DEMUXER_PLUGIN_NAME_AAC, TEST_FILE_URI_AAC, DEF_PROB_SIZE), true);
876 auto demuxerPlugin = std::static_pointer_cast<Plugins::DemuxerPlugin>(pluginBase_);
877 ASSERT_EQ(demuxerPlugin->SetDataSourceWithProbSize(dataSourceImpl_, DEF_PROB_SIZE), Status::ERROR_WRONG_STATE);
878 RemoveValue();
879 }
880
881 }
882 }