Implement disabling and enabling media tracks

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 <utility>
 
@@ skipping 254 matching lines @@
       task_runner_(base::ThreadTaskRunnerHandle::Get()),
       stream_(stream),
       audio_config_(audio_config.release()),
       video_config_(video_config.release()),
       type_(UNKNOWN),
       liveness_(LIVENESS_UNKNOWN),
       end_of_stream_(false),
       last_packet_timestamp_(kNoTimestamp()),
       last_packet_duration_(kNoTimestamp()),
       video_rotation_(VIDEO_ROTATION_0),
+      is_enabled_(true),
+      waiting_for_keyframe_(false),
       fixup_negative_timestamps_(false) {
   DCHECK(demuxer_);
 
   bool is_encrypted = false;
   int rotation = 0;
   AVDictionaryEntry* rotation_entry = NULL;
 
   // Determine our media format.
   switch (stream->codec->codec_type) {
     case AVMEDIA_TYPE_AUDIO:
@@ skipping 66 matching lines @@
 }
 
 void FFmpegDemuxerStream::EnqueuePacket(ScopedAVPacket packet) {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   if (!demuxer_ || end_of_stream_) {
     NOTREACHED() << "Attempted to enqueue packet on a stopped stream";
     return;
   }
 
+  if (waiting_for_keyframe_) {
+    if (packet.get()->flags & AV_PKT_FLAG_KEY)
+      waiting_for_keyframe_ = false;
+    else {
+      DVLOG(3) << "Dropped non-keyframe pts=" << packet->pts;
+      return;
+    }
+  }
+
 #if defined(USE_PROPRIETARY_CODECS)
   // Convert the packet if there is a bitstream filter.
   if (packet->data && bitstream_converter_ &&
       !bitstream_converter_->ConvertPacket(packet.get())) {
     LOG(ERROR) << "Format conversion failed.";
   }
 #endif
 
   // Get side data if any. For now, the only type of side_data is VP8 Alpha. We
   // keep this generic so that other side_data types in the future can be
@@ skipping 240 matching lines @@
   // Don't accept any additional reads if we've been told to stop.
   // The |demuxer_| may have been destroyed in the pipeline thread.
   //
   // TODO(scherkus): it would be cleaner to reply with an error message.
   if (!demuxer_) {
     base::ResetAndReturn(&read_cb_).Run(
         DemuxerStream::kOk, DecoderBuffer::CreateEOSBuffer());
     return;
   }
 
+  if (!is_enabled_) {
+    DVLOG(1) << "Read from disabled stream, returning EOS";
+    base::ResetAndReturn(&read_cb_).Run(kOk, DecoderBuffer::CreateEOSBuffer());
+    return;
+  }
+
   SatisfyPendingRead();
 }
 
 void FFmpegDemuxerStream::EnableBitstreamConverter() {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
 #if defined(USE_PROPRIETARY_CODECS)
   InitBitstreamConverter();
 #else
   NOTREACHED() << "Proprietary codecs not enabled.";
@@ skipping 43 matching lines @@
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(type_, VIDEO);
   DCHECK(video_config_.get());
   return *video_config_;
 }
 
 VideoRotation FFmpegDemuxerStream::video_rotation() {
   return video_rotation_;
 }
 
+bool FFmpegDemuxerStream::enabled() const {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+  return is_enabled_;
+}
+
+void FFmpegDemuxerStream::set_enabled(bool enabled, base::TimeDelta timestamp) {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+  if (enabled == is_enabled_)
+    return;
+
+  is_enabled_ = enabled;
+  if (is_enabled_) {
+    waiting_for_keyframe_ = true;
+    if (!stream_restarted_cb_.is_null())
+      stream_restarted_cb_.Run(this, timestamp);
+  }
+  if (!is_enabled_ && !read_cb_.is_null()) {
+    DVLOG(1) << "Read from disabled stream, returning EOS";
+    base::ResetAndReturn(&read_cb_).Run(kOk, DecoderBuffer::CreateEOSBuffer());
+    return;
+  }
+}
+
+void FFmpegDemuxerStream::SetStreamRestartedCB(const StreamRestartedCB& cb) {
+  DCHECK(!cb.is_null());
+  stream_restarted_cb_ = cb;
+}
+
 void FFmpegDemuxerStream::SetLiveness(Liveness liveness) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(liveness_, LIVENESS_UNKNOWN);
   liveness_ = liveness;
 }
 
 base::TimeDelta FFmpegDemuxerStream::GetElapsedTime() const {
   return ConvertStreamTimestamp(stream_->time_base, stream_->cur_dts);
 }
 
@@ skipping 430 matching lines @@
       packet_buffer = packet_buffer->next;
     }
   }
 
   std::unique_ptr<MediaTracks> media_tracks(new MediaTracks());
   AVStream* audio_stream = NULL;
   AudioDecoderConfig audio_config;
   AVStream* video_stream = NULL;
   VideoDecoderConfig video_config;
 
+  DCHECK(track_id_to_demux_stream_map_.empty());
+
   // If available, |start_time_| will be set to the lowest stream start time.
   start_time_ = kInfiniteDuration();
 
   base::TimeDelta max_duration;
   int detected_audio_track_count = 0;
   int detected_video_track_count = 0;
   int detected_text_track_count = 0;
   for (size_t i = 0; i < format_context->nb_streams; ++i) {
     AVStream* stream = format_context->streams[i];
     const AVCodecContext* codec_context = stream->codec;
@@ skipping 95 matching lines @@
     MediaTrack* media_track = nullptr;
     if (codec_type == AVMEDIA_TYPE_AUDIO) {
       CHECK(!audio_stream);
       audio_stream = stream;
       audio_config = streams_[i]->audio_decoder_config();
       RecordAudioCodecStats(audio_config);
 
       media_track = media_tracks->AddAudioTrack(audio_config, track_id, "main",
                                                 track_label, track_language);
       media_track->set_id(base::UintToString(track_id));
+      DCHECK(track_id_to_demux_stream_map_.find(media_track->id()) ==
+             track_id_to_demux_stream_map_.end());
+      track_id_to_demux_stream_map_[media_track->id()] = streams_[i];
     } else if (codec_type == AVMEDIA_TYPE_VIDEO) {
       CHECK(!video_stream);
       video_stream = stream;
       video_config = streams_[i]->video_decoder_config();
 
       RecordVideoCodecStats(video_config, stream->codec->color_range,
                             media_log_.get());
 
       media_track = media_tracks->AddVideoTrack(video_config, track_id, "main",
                                                 track_label, track_language);
       media_track->set_id(base::UintToString(track_id));
+      DCHECK(track_id_to_demux_stream_map_.find(media_track->id()) ==
+             track_id_to_demux_stream_map_.end());
+      track_id_to_demux_stream_map_[media_track->id()] = streams_[i];
     }
 
     max_duration = std::max(max_duration, streams_[i]->duration());
 
     const base::TimeDelta start_time =
         ExtractStartTime(stream, start_time_estimates[i]);
     const bool has_start_time = start_time != kNoTimestamp();
 
     // Always prefer the video stream for seeking.  If none exists, we'll swap
     // the fallback stream with the preferred stream below.
@@ skipping 192 matching lines @@
       (*iter)->FlushBuffers();
   }
 
   // Resume reading until capacity.
   ReadFrameIfNeeded();
 
   // Notify we're finished seeking.
   cb.Run(PIPELINE_OK);
 }
 
+void FFmpegDemuxer::OnEnabledAudioTracksChanged(
+    const std::vector<MediaTrack::Id>& track_ids,
+    base::TimeDelta currTime) {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+  bool enabled = false;
+  DemuxerStream* audio_stream = GetStream(DemuxerStream::AUDIO);
+  CHECK(audio_stream);
+  if (track_ids.size() > 0) {
+    DCHECK(track_id_to_demux_stream_map_[track_ids[0]] == audio_stream);
+    enabled = true;
+  }
+  DVLOG(1) << __FUNCTION__ << ": " << (enabled ? "enabling" : "disabling")
+           << " audio stream";
+  audio_stream->set_enabled(enabled, currTime);
+}
+
+void FFmpegDemuxer::OnSelectedVideoTrackChanged(
+    const std::vector<MediaTrack::Id>& track_ids,
+    base::TimeDelta currTime) {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+  bool enabled = false;
+  DemuxerStream* video_stream = GetStream(DemuxerStream::VIDEO);
+  CHECK(video_stream);
+  if (track_ids.size() > 0) {
+    DCHECK(track_id_to_demux_stream_map_[track_ids[0]] == video_stream);
+    enabled = true;
+  }
+  DVLOG(1) << __FUNCTION__ << ": " << (enabled ? "enabling" : "disabling")
+           << " video stream";
+  video_stream->set_enabled(enabled, currTime);
+}
+
 void FFmpegDemuxer::ReadFrameIfNeeded() {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   // Make sure we have work to do before reading.
   if (!blocking_thread_.IsRunning() || !StreamsHaveAvailableCapacity() ||
       pending_read_ || pending_seek_) {
     return;
   }
 
   // Allocate and read an AVPacket from the media. Save |packet_ptr| since
@@ skipping 67 matching lines @@
     //
     // https://code.google.com/p/chromium/issues/detail?id=169133#c10
     if (!packet->data) {
       ScopedAVPacket new_packet(new AVPacket());
       av_new_packet(new_packet.get(), 0);
       av_packet_copy_props(new_packet.get(), packet.get());
       packet.swap(new_packet);
     }
 
     FFmpegDemuxerStream* demuxer_stream = streams_[packet->stream_index];
-    demuxer_stream->EnqueuePacket(std::move(packet));
+    if (demuxer_stream->enabled())
+      demuxer_stream->EnqueuePacket(std::move(packet));
   }
 
   // Keep reading until we've reached capacity.
   ReadFrameIfNeeded();
 }
 
 bool FFmpegDemuxer::StreamsHaveAvailableCapacity() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   StreamVector::iterator iter;
   for (iter = streams_.begin(); iter != streams_.end(); ++iter) {
@@ skipping 41 matching lines @@
 
 void FFmpegDemuxer::SetLiveness(DemuxerStream::Liveness liveness) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   for (auto* stream : streams_) {
     if (stream)
       stream->SetLiveness(liveness);
   }
 }
 
 }  // namespace media