OLD | NEW |
---|---|
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "media/filters/chunk_demuxer.h" | 5 #include "media/filters/chunk_demuxer.h" |
6 | 6 |
7 #include <algorithm> | 7 #include <algorithm> |
8 #include <limits> | 8 #include <limits> |
9 #include <list> | 9 #include <list> |
10 #include <utility> | 10 #include <utility> |
(...skipping 20 matching lines...) Expand all Loading... | |
31 namespace media { | 31 namespace media { |
32 | 32 |
33 ChunkDemuxerStream::ChunkDemuxerStream(Type type, | 33 ChunkDemuxerStream::ChunkDemuxerStream(Type type, |
34 bool splice_frames_enabled, | 34 bool splice_frames_enabled, |
35 MediaTrack::Id media_track_id) | 35 MediaTrack::Id media_track_id) |
36 : type_(type), | 36 : type_(type), |
37 liveness_(DemuxerStream::LIVENESS_UNKNOWN), | 37 liveness_(DemuxerStream::LIVENESS_UNKNOWN), |
38 media_track_id_(media_track_id), | 38 media_track_id_(media_track_id), |
39 state_(UNINITIALIZED), | 39 state_(UNINITIALIZED), |
40 splice_frames_enabled_(splice_frames_enabled), | 40 splice_frames_enabled_(splice_frames_enabled), |
41 partial_append_window_trimming_enabled_(false) {} | 41 partial_append_window_trimming_enabled_(false), |
42 is_enabled_(true) {} | |
42 | 43 |
43 void ChunkDemuxerStream::StartReturningData() { | 44 void ChunkDemuxerStream::StartReturningData() { |
44 DVLOG(1) << "ChunkDemuxerStream::StartReturningData()"; | 45 DVLOG(1) << "ChunkDemuxerStream::StartReturningData()"; |
45 base::AutoLock auto_lock(lock_); | 46 base::AutoLock auto_lock(lock_); |
46 DCHECK(read_cb_.is_null()); | 47 DCHECK(read_cb_.is_null()); |
47 ChangeState_Locked(RETURNING_DATA_FOR_READS); | 48 ChangeState_Locked(RETURNING_DATA_FOR_READS); |
48 } | 49 } |
49 | 50 |
50 void ChunkDemuxerStream::AbortReads() { | 51 void ChunkDemuxerStream::AbortReads() { |
51 DVLOG(1) << "ChunkDemuxerStream::AbortReads()"; | 52 DVLOG(1) << "ChunkDemuxerStream::AbortReads()"; |
(...skipping 185 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
237 stream_->UnmarkEndOfStream(); | 238 stream_->UnmarkEndOfStream(); |
238 } | 239 } |
239 | 240 |
240 // DemuxerStream methods. | 241 // DemuxerStream methods. |
241 void ChunkDemuxerStream::Read(const ReadCB& read_cb) { | 242 void ChunkDemuxerStream::Read(const ReadCB& read_cb) { |
242 base::AutoLock auto_lock(lock_); | 243 base::AutoLock auto_lock(lock_); |
243 DCHECK_NE(state_, UNINITIALIZED); | 244 DCHECK_NE(state_, UNINITIALIZED); |
244 DCHECK(read_cb_.is_null()); | 245 DCHECK(read_cb_.is_null()); |
245 | 246 |
246 read_cb_ = BindToCurrentLoop(read_cb); | 247 read_cb_ = BindToCurrentLoop(read_cb); |
248 | |
249 if (!is_enabled_) { | |
250 DVLOG(1) << "Read from disabled stream, returning EOS"; | |
251 base::ResetAndReturn(&read_cb_).Run(kOk, | |
252 StreamParserBuffer::CreateEOSBuffer()); | |
253 return; | |
254 } | |
255 | |
247 CompletePendingReadIfPossible_Locked(); | 256 CompletePendingReadIfPossible_Locked(); |
248 } | 257 } |
249 | 258 |
250 DemuxerStream::Type ChunkDemuxerStream::type() const { return type_; } | 259 DemuxerStream::Type ChunkDemuxerStream::type() const { return type_; } |
251 | 260 |
252 DemuxerStream::Liveness ChunkDemuxerStream::liveness() const { | 261 DemuxerStream::Liveness ChunkDemuxerStream::liveness() const { |
253 base::AutoLock auto_lock(lock_); | 262 base::AutoLock auto_lock(lock_); |
254 return liveness_; | 263 return liveness_; |
255 } | 264 } |
256 | 265 |
257 AudioDecoderConfig ChunkDemuxerStream::audio_decoder_config() { | 266 AudioDecoderConfig ChunkDemuxerStream::audio_decoder_config() { |
258 CHECK_EQ(type_, AUDIO); | 267 CHECK_EQ(type_, AUDIO); |
259 base::AutoLock auto_lock(lock_); | 268 base::AutoLock auto_lock(lock_); |
260 return stream_->GetCurrentAudioDecoderConfig(); | 269 return stream_->GetCurrentAudioDecoderConfig(); |
261 } | 270 } |
262 | 271 |
263 VideoDecoderConfig ChunkDemuxerStream::video_decoder_config() { | 272 VideoDecoderConfig ChunkDemuxerStream::video_decoder_config() { |
264 CHECK_EQ(type_, VIDEO); | 273 CHECK_EQ(type_, VIDEO); |
265 base::AutoLock auto_lock(lock_); | 274 base::AutoLock auto_lock(lock_); |
266 return stream_->GetCurrentVideoDecoderConfig(); | 275 return stream_->GetCurrentVideoDecoderConfig(); |
267 } | 276 } |
268 | 277 |
269 bool ChunkDemuxerStream::SupportsConfigChanges() { return true; } | 278 bool ChunkDemuxerStream::SupportsConfigChanges() { return true; } |
270 | 279 |
271 VideoRotation ChunkDemuxerStream::video_rotation() { | 280 VideoRotation ChunkDemuxerStream::video_rotation() { |
272 return VIDEO_ROTATION_0; | 281 return VIDEO_ROTATION_0; |
273 } | 282 } |
274 | 283 |
284 bool ChunkDemuxerStream::enabled() const { | |
285 base::AutoLock auto_lock(lock_); | |
286 return is_enabled_; | |
287 } | |
288 | |
289 void ChunkDemuxerStream::set_enabled(bool enabled, base::TimeDelta timestamp) { | |
290 base::AutoLock auto_lock(lock_); | |
291 | |
292 if (enabled == is_enabled_) | |
293 return; | |
294 | |
295 is_enabled_ = enabled; | |
296 if (enabled) { | |
297 DCHECK(stream_); | |
298 stream_->Seek(timestamp); | |
299 if (!stream_restarted_cb_.is_null()) | |
300 stream_restarted_cb_.Run(this, timestamp); | |
301 } else if (!read_cb_.is_null()) { | |
302 DVLOG(1) << "Read from disabled stream, returning EOS"; | |
303 base::ResetAndReturn(&read_cb_).Run(kOk, | |
304 StreamParserBuffer::CreateEOSBuffer()); | |
305 } | |
306 } | |
307 | |
308 void ChunkDemuxerStream::SetStreamRestartedCB(const StreamRestartedCB& cb) { | |
309 DCHECK(!cb.is_null()); | |
310 stream_restarted_cb_ = cb; | |
311 } | |
312 | |
275 TextTrackConfig ChunkDemuxerStream::text_track_config() { | 313 TextTrackConfig ChunkDemuxerStream::text_track_config() { |
276 CHECK_EQ(type_, TEXT); | 314 CHECK_EQ(type_, TEXT); |
277 base::AutoLock auto_lock(lock_); | 315 base::AutoLock auto_lock(lock_); |
278 return stream_->GetCurrentTextTrackConfig(); | 316 return stream_->GetCurrentTextTrackConfig(); |
279 } | 317 } |
280 | 318 |
281 void ChunkDemuxerStream::SetStreamMemoryLimit(size_t memory_limit) { | 319 void ChunkDemuxerStream::SetStreamMemoryLimit(size_t memory_limit) { |
282 stream_->set_memory_limit(memory_limit); | 320 stream_->set_memory_limit(memory_limit); |
283 } | 321 } |
284 | 322 |
(...skipping 301 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
586 Ranges<TimeDelta> ChunkDemuxer::GetBufferedRanges(const std::string& id) const { | 624 Ranges<TimeDelta> ChunkDemuxer::GetBufferedRanges(const std::string& id) const { |
587 base::AutoLock auto_lock(lock_); | 625 base::AutoLock auto_lock(lock_); |
588 DCHECK(!id.empty()); | 626 DCHECK(!id.empty()); |
589 | 627 |
590 MediaSourceStateMap::const_iterator itr = source_state_map_.find(id); | 628 MediaSourceStateMap::const_iterator itr = source_state_map_.find(id); |
591 | 629 |
592 DCHECK(itr != source_state_map_.end()); | 630 DCHECK(itr != source_state_map_.end()); |
593 return itr->second->GetBufferedRanges(duration_, state_ == ENDED); | 631 return itr->second->GetBufferedRanges(duration_, state_ == ENDED); |
594 } | 632 } |
595 | 633 |
634 void ChunkDemuxer::OnEnabledAudioTracksChanged( | |
635 const std::vector<MediaTrack::Id>& track_ids, | |
636 base::TimeDelta currTime) { | |
637 // Note: We intentionally don't lock here, since we are not accessing any | |
chcunningham
2016/06/24 23:32:55
You are locking though ;)
servolk
2016/06/25 00:36:33
But only while accessing |track_id_to_demux_stream
| |
638 // members directly. | |
639 DemuxerStream* audio_stream = GetStream(DemuxerStream::AUDIO); | |
640 bool enabled = false; | |
641 CHECK(audio_stream); | |
642 if (track_ids.size() > 0) { | |
chcunningham
2016/06/24 23:32:55
IIUC size should never exceed 1 as currently imple
servolk
2016/06/25 00:36:33
Done.
| |
643 base::AutoLock auto_lock(lock_); | |
chcunningham
2016/06/24 23:32:55
Seems you're not settled on this part. I wonder if
servolk
2016/06/25 00:36:33
Done.
| |
644 // DCHECK(track_id_to_demux_stream_map_[track_ids[0]] == audio_stream); | |
645 enabled = true; | |
646 } | |
647 audio_stream->set_enabled(enabled, currTime); | |
648 } | |
649 | |
650 void ChunkDemuxer::OnSelectedVideoTrackChanged( | |
651 const std::vector<MediaTrack::Id>& track_ids, | |
652 base::TimeDelta currTime) { | |
653 // Note: We intentionally don't lock here, since we are not accessing any | |
chcunningham
2016/06/24 23:32:55
This method has the same unsettled state around th
servolk
2016/06/25 00:36:33
Done.
| |
654 // members directly. | |
655 DemuxerStream* video_stream = GetStream(DemuxerStream::VIDEO); | |
656 bool enabled = false; | |
657 CHECK(video_stream); | |
658 if (track_ids.size() > 0) { | |
659 base::AutoLock auto_lock(lock_); | |
660 // DCHECK(track_id_to_demux_stream_map_[track_ids[0]] == video_stream); | |
661 enabled = true; | |
662 } | |
663 video_stream->set_enabled(enabled, currTime); | |
664 } | |
665 | |
596 bool ChunkDemuxer::EvictCodedFrames(const std::string& id, | 666 bool ChunkDemuxer::EvictCodedFrames(const std::string& id, |
597 base::TimeDelta currentMediaTime, | 667 base::TimeDelta currentMediaTime, |
598 size_t newDataSize) { | 668 size_t newDataSize) { |
599 DVLOG(1) << __FUNCTION__ << "(" << id << ")" | 669 DVLOG(1) << __FUNCTION__ << "(" << id << ")" |
600 << " media_time=" << currentMediaTime.InSecondsF() | 670 << " media_time=" << currentMediaTime.InSecondsF() |
601 << " newDataSize=" << newDataSize; | 671 << " newDataSize=" << newDataSize; |
602 base::AutoLock auto_lock(lock_); | 672 base::AutoLock auto_lock(lock_); |
603 | 673 |
604 // Note: The direct conversion from PTS to DTS is safe here, since we don't | 674 // Note: The direct conversion from PTS to DTS is safe here, since we don't |
605 // need to know currentTime precisely for GC. GC only needs to know which GOP | 675 // need to know currentTime precisely for GC. GC only needs to know which GOP |
(...skipping 555 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1161 } | 1231 } |
1162 | 1232 |
1163 void ChunkDemuxer::ShutdownAllStreams() { | 1233 void ChunkDemuxer::ShutdownAllStreams() { |
1164 for (MediaSourceStateMap::iterator itr = source_state_map_.begin(); | 1234 for (MediaSourceStateMap::iterator itr = source_state_map_.begin(); |
1165 itr != source_state_map_.end(); ++itr) { | 1235 itr != source_state_map_.end(); ++itr) { |
1166 itr->second->Shutdown(); | 1236 itr->second->Shutdown(); |
1167 } | 1237 } |
1168 } | 1238 } |
1169 | 1239 |
1170 } // namespace media | 1240 } // namespace media |
OLD | NEW |