MediaResource refactoring to support multiple streams

media/filters/ffmpeg_demuxer.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/filters/ffmpeg_demuxer.h"
 
 #include <algorithm>
 #include <memory>
 #include <set>
 #include <utility>
@@ skipping 724 matching lines @@
   is_enabled_ = enabled;
   if (is_enabled_) {
     waiting_for_keyframe_ = true;
   }
   if (!is_enabled_ && !read_cb_.is_null()) {
     DVLOG(1) << "Read from disabled stream, returning EOS";
     base::ResetAndReturn(&read_cb_).Run(kOk, DecoderBuffer::CreateEOSBuffer());
     return;
   }
   if (!stream_status_change_cb_.is_null())
-    stream_status_change_cb_.Run(is_enabled_, timestamp);
+    stream_status_change_cb_.Run(this, is_enabled_, timestamp);
 }
 
 void FFmpegDemuxerStream::SetStreamStatusChangeCB(
     const StreamStatusChangeCB& cb) {
   DCHECK(!cb.is_null());
   stream_status_change_cb_ = cb;
 }
 
 void FFmpegDemuxerStream::SetLiveness(Liveness liveness) {
   DCHECK(task_runner_->BelongsToCurrentThread());
@@ skipping 228 matching lines @@
   // Additionally, to workaround limitations in how we expose seekable ranges to
   // Blink (http://crbug.com/137275), we also want to clamp seeks before the
   // start time to the start time.
   base::TimeDelta seek_time = start_time_ < base::TimeDelta()
                                   ? time + start_time_
                                   : time < start_time_ ? start_time_ : time;
 
   // When seeking in an opus stream we need to ensure we deliver enough data to
   // satisfy the seek preroll; otherwise the audio at the actual seek time will
   // not be entirely accurate.
-  FFmpegDemuxerStream* audio_stream = GetFFmpegStream(DemuxerStream::AUDIO);
+  FFmpegDemuxerStream* audio_stream =
+      GetFirstEnabledFFmpegStream(DemuxerStream::AUDIO);
   if (audio_stream) {
     const AudioDecoderConfig& config = audio_stream->audio_decoder_config();
     if (config.codec() == kCodecOpus)
       seek_time = std::max(start_time_, seek_time - config.seek_preroll());
   }
 
   // Choose the seeking stream based on whether it contains the seek time, if no
   // match can be found prefer the preferred stream.
   //
   // TODO(dalecurtis): Currently FFmpeg does not ensure that all streams in a
@@ skipping 14 matching lines @@
                  ConvertToTimeBase(seeking_stream->time_base, seek_time),
                  // Always seek to a timestamp <= to the desired timestamp.
                  AVSEEK_FLAG_BACKWARD),
       base::Bind(&FFmpegDemuxer::OnSeekFrameDone, weak_factory_.GetWeakPtr()));
 }
 
 base::Time FFmpegDemuxer::GetTimelineOffset() const {
   return timeline_offset_;
 }
 
-DemuxerStream* FFmpegDemuxer::GetStream(DemuxerStream::Type type) {
+std::vector<DemuxerStream*> FFmpegDemuxer::GetStreams() {
   DCHECK(task_runner_->BelongsToCurrentThread());
-  return GetFFmpegStream(type);
+  std::vector<DemuxerStream*> result;
+  for (const auto& stream : streams_) {
+    if (stream)
+      result.push_back(stream.get());
+  }
+  return result;
 }
 
-FFmpegDemuxerStream* FFmpegDemuxer::GetFFmpegStream(
+void FFmpegDemuxer::SetStreamStatusChangeCB(const StreamStatusChangeCB& cb) {
+  for (const auto& stream : streams_) {
+    if (stream)
+      stream->SetStreamStatusChangeCB(cb);
+  }
+}
+
+FFmpegDemuxerStream* FFmpegDemuxer::GetFirstEnabledFFmpegStream(
     DemuxerStream::Type type) const {
   for (const auto& stream : streams_) {
     if (stream && stream->type() == type && stream->enabled()) {
       return stream.get();
     }
   }
   return NULL;
 }
 
 base::TimeDelta FFmpegDemuxer::GetStartTime() const {
@@ skipping 36 matching lines @@
 }
 
 void FFmpegDemuxer::NotifyCapacityAvailable() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   ReadFrameIfNeeded();
 }
 
 void FFmpegDemuxer::NotifyBufferingChanged() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   Ranges<base::TimeDelta> buffered;
-  FFmpegDemuxerStream* audio = GetFFmpegStream(DemuxerStream::AUDIO);
-  FFmpegDemuxerStream* video = GetFFmpegStream(DemuxerStream::VIDEO);
-  if (audio && video) {
-    buffered =
-        audio->GetBufferedRanges().IntersectionWith(video->GetBufferedRanges());
-  } else if (audio) {
-    buffered = audio->GetBufferedRanges();
-  } else if (video) {
-    buffered = video->GetBufferedRanges();
+  bool initialized_buffered_ranges = false;
+  for (const auto& stream : streams_) {
+    if (!stream)
+      continue;
+    if (initialized_buffered_ranges) {
+      buffered = buffered.IntersectionWith(stream->GetBufferedRanges());
+    } else {
+      buffered = stream->GetBufferedRanges();
+      initialized_buffered_ranges = true;
+    }
   }
   host_->OnBufferedTimeRangesChanged(buffered);
 }
 
 // Helper for calculating the bitrate of the media based on information stored
 // in |format_context| or failing that the size and duration of the media.
 //
 // Returns 0 if a bitrate could not be determined.
 static int CalculateBitrate(AVFormatContext* format_context,
                             const base::TimeDelta& duration,
@@ skipping 706 matching lines @@
 
 void FFmpegDemuxer::SetLiveness(DemuxerStream::Liveness liveness) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   for (const auto& stream : streams_) {
     if (stream)
       stream->SetLiveness(liveness);
   }
 }
 
 }  // namespace media