OLD | NEW |
---|---|
(Empty) | |
1 // Copyright (c) 2017 The Chromium Authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 | |
5 #include "media/test/mock_media_source.h" | |
6 | |
7 #include "base/threading/thread_task_runner_handle.h" | |
8 #include "media/base/test_data_util.h" | |
9 #include "media/base/timestamp_constants.h" | |
10 | |
11 namespace media { | |
12 | |
13 constexpr char kSourceId[] = "SourceId"; | |
14 const size_t kAppendWholeFile = std::numeric_limits<size_t>::max(); | |
15 | |
16 MockMediaSource::MockMediaSource(const std::string& filename, | |
17 const std::string& mimetype, | |
18 size_t initial_append_size) | |
19 : current_position_(0), | |
20 initial_append_size_(initial_append_size), | |
21 mimetype_(mimetype), | |
22 chunk_demuxer_(new ChunkDemuxer( | |
23 base::Bind(&MockMediaSource::DemuxerOpened, base::Unretained(this)), | |
24 base::Bind(&MockMediaSource::OnEncryptedMediaInitData, | |
25 base::Unretained(this)), | |
26 &media_log_)), | |
27 owned_chunk_demuxer_(chunk_demuxer_) { | |
28 file_data_ = ReadTestDataFile(filename); | |
29 | |
30 if (initial_append_size_ == kAppendWholeFile) | |
31 initial_append_size_ = file_data_->data_size(); | |
32 | |
33 DCHECK_GT(initial_append_size_, 0u); | |
34 DCHECK_LE(initial_append_size_, file_data_->data_size()); | |
35 } | |
36 | |
37 MockMediaSource::~MockMediaSource() {} | |
38 | |
39 std::unique_ptr<Demuxer> MockMediaSource::GetDemuxer() { | |
40 return std::move(owned_chunk_demuxer_); | |
41 } | |
42 | |
43 void MockMediaSource::set_encrypted_media_init_data_cb( | |
DaleCurtis
2017/04/20 21:40:25
hacker_style() must be inline so keep this in the
xjz
2017/04/20 22:07:45
Done.
| |
44 const Demuxer::EncryptedMediaInitDataCB& encrypted_media_init_data_cb) { | |
45 encrypted_media_init_data_cb_ = encrypted_media_init_data_cb; | |
46 } | |
47 | |
48 void MockMediaSource::set_demuxer_failure_cb( | |
DaleCurtis
2017/04/20 21:40:25
Ditto.
xjz
2017/04/20 22:07:45
Done.
| |
49 const PipelineStatusCB& demuxer_failure_cb) { | |
50 demuxer_failure_cb_ = demuxer_failure_cb; | |
51 } | |
52 | |
53 void MockMediaSource::Seek(base::TimeDelta seek_time, | |
54 size_t new_position, | |
55 size_t seek_append_size) { | |
56 chunk_demuxer_->StartWaitingForSeek(seek_time); | |
57 | |
58 chunk_demuxer_->ResetParserState(kSourceId, base::TimeDelta(), | |
59 kInfiniteDuration, &last_timestamp_offset_); | |
60 | |
61 DCHECK_LT(new_position, file_data_->data_size()); | |
62 current_position_ = new_position; | |
63 | |
64 AppendData(seek_append_size); | |
65 } | |
66 | |
67 void MockMediaSource::Seek(base::TimeDelta seek_time) { | |
68 chunk_demuxer_->StartWaitingForSeek(seek_time); | |
69 } | |
70 | |
71 void MockMediaSource::AppendData(size_t size) { | |
72 DCHECK(chunk_demuxer_); | |
73 DCHECK_LT(current_position_, file_data_->data_size()); | |
74 DCHECK_LE(current_position_ + size, file_data_->data_size()); | |
75 | |
76 ASSERT_TRUE(chunk_demuxer_->AppendData( | |
77 kSourceId, file_data_->data() + current_position_, size, | |
78 base::TimeDelta(), kInfiniteDuration, &last_timestamp_offset_)); | |
79 current_position_ += size; | |
80 } | |
81 | |
82 bool MockMediaSource::AppendAtTime(base::TimeDelta timestamp_offset, | |
83 const uint8_t* pData, | |
84 int size) { | |
85 CHECK(!chunk_demuxer_->IsParsingMediaSegment(kSourceId)); | |
86 bool success = | |
87 chunk_demuxer_->AppendData(kSourceId, pData, size, base::TimeDelta(), | |
88 kInfiniteDuration, ×tamp_offset); | |
89 last_timestamp_offset_ = timestamp_offset; | |
90 return success; | |
91 } | |
92 | |
93 void MockMediaSource::AppendAtTimeWithWindow( | |
94 base::TimeDelta timestamp_offset, | |
95 base::TimeDelta append_window_start, | |
96 base::TimeDelta append_window_end, | |
97 const uint8_t* pData, | |
98 int size) { | |
99 CHECK(!chunk_demuxer_->IsParsingMediaSegment(kSourceId)); | |
100 ASSERT_TRUE(chunk_demuxer_->AppendData(kSourceId, pData, size, | |
101 append_window_start, append_window_end, | |
102 ×tamp_offset)); | |
103 last_timestamp_offset_ = timestamp_offset; | |
104 } | |
105 | |
106 void MockMediaSource::SetMemoryLimits(size_t limit_bytes) { | |
107 chunk_demuxer_->SetMemoryLimitsForTest(DemuxerStream::AUDIO, limit_bytes); | |
108 chunk_demuxer_->SetMemoryLimitsForTest(DemuxerStream::VIDEO, limit_bytes); | |
109 } | |
110 | |
111 void MockMediaSource::EvictCodedFrames(base::TimeDelta currentMediaTime, | |
112 size_t newDataSize) { | |
113 chunk_demuxer_->EvictCodedFrames(kSourceId, currentMediaTime, newDataSize); | |
114 } | |
115 | |
116 void MockMediaSource::RemoveRange(base::TimeDelta start, base::TimeDelta end) { | |
117 chunk_demuxer_->Remove(kSourceId, start, end); | |
118 } | |
119 | |
120 void MockMediaSource::EndOfStream() { | |
121 chunk_demuxer_->MarkEndOfStream(PIPELINE_OK); | |
122 } | |
123 | |
124 void MockMediaSource::Shutdown() { | |
125 if (!chunk_demuxer_) | |
126 return; | |
127 chunk_demuxer_->ResetParserState(kSourceId, base::TimeDelta(), | |
128 kInfiniteDuration, &last_timestamp_offset_); | |
129 chunk_demuxer_->Shutdown(); | |
130 chunk_demuxer_ = NULL; | |
131 } | |
132 | |
133 void MockMediaSource::DemuxerOpened() { | |
134 base::ThreadTaskRunnerHandle::Get()->PostTask( | |
135 FROM_HERE, | |
136 base::Bind(&MockMediaSource::DemuxerOpenedTask, base::Unretained(this))); | |
137 } | |
138 | |
139 void MockMediaSource::DemuxerOpenedTask() { | |
140 ChunkDemuxer::Status status = AddId(); | |
141 if (status != ChunkDemuxer::kOk) { | |
142 CHECK(!demuxer_failure_cb_.is_null()); | |
143 demuxer_failure_cb_.Run(DEMUXER_ERROR_COULD_NOT_OPEN); | |
144 return; | |
145 } | |
146 chunk_demuxer_->SetTracksWatcher( | |
147 kSourceId, base::Bind(&MockMediaSource::InitSegmentReceived, | |
148 base::Unretained(this))); | |
149 | |
150 AppendData(initial_append_size_); | |
151 } | |
152 | |
153 ChunkDemuxer::Status MockMediaSource::AddId() { | |
154 // This code assumes that |mimetype_| is one of the following forms. | |
155 // 1. audio/mpeg | |
156 // 2. video/webm;codec="vorbis,vp8". | |
157 size_t semicolon = mimetype_.find(";"); | |
158 std::string type = mimetype_; | |
159 std::string codecs_param = ""; | |
160 if (semicolon != std::string::npos) { | |
161 type = mimetype_.substr(0, semicolon); | |
162 size_t codecs_param_start = mimetype_.find("codecs=\"", semicolon); | |
163 | |
164 CHECK_NE(codecs_param_start, std::string::npos); | |
165 | |
166 codecs_param_start += 8; // Skip over the codecs=". | |
167 | |
168 size_t codecs_param_end = mimetype_.find("\"", codecs_param_start); | |
169 | |
170 CHECK_NE(codecs_param_end, std::string::npos); | |
171 | |
172 codecs_param = mimetype_.substr(codecs_param_start, | |
173 codecs_param_end - codecs_param_start); | |
174 } | |
175 | |
176 return chunk_demuxer_->AddId(kSourceId, type, codecs_param); | |
177 } | |
178 | |
179 void MockMediaSource::OnEncryptedMediaInitData( | |
180 EmeInitDataType init_data_type, | |
181 const std::vector<uint8_t>& init_data) { | |
182 DCHECK(!init_data.empty()); | |
183 CHECK(!encrypted_media_init_data_cb_.is_null()); | |
184 encrypted_media_init_data_cb_.Run(init_data_type, init_data); | |
185 } | |
186 | |
187 base::TimeDelta MockMediaSource::last_timestamp_offset() const { | |
188 return last_timestamp_offset_; | |
189 } | |
190 | |
191 void MockMediaSource::InitSegmentReceived(std::unique_ptr<MediaTracks> tracks) { | |
192 CHECK(tracks.get()); | |
193 EXPECT_GT(tracks->tracks().size(), 0u); | |
194 CHECK(chunk_demuxer_); | |
195 // Verify that track ids are unique. | |
196 std::set<MediaTrack::Id> track_ids; | |
197 for (const auto& track : tracks->tracks()) { | |
198 EXPECT_EQ(track_ids.end(), track_ids.find(track->id())); | |
199 track_ids.insert(track->id()); | |
200 } | |
201 InitSegmentReceivedMock(tracks); | |
202 } | |
203 | |
204 } // namespace media | |
OLD | NEW |