Stop audio FFmpegDemuxerStreams if we get notified that audio rendering is disabled.

media/filters/ffmpeg_demuxer.cc

 // Copyright (c) 2011 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 "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
@@ skipping 135 matching lines @@
     it->Run(scoped_refptr<Buffer>(new DataBuffer(0)));
   }
   read_queue_.clear();
   stopped_ = true;
 }
 
 base::TimeDelta FFmpegDemuxerStream::duration() {
   return duration_;
 }
 
+int FFmpegDemuxerStream::stream_index() {
+  return stream_->index;
+}
+
 DemuxerStream::Type FFmpegDemuxerStream::type() {
   return type_;
 }
 
 void FFmpegDemuxerStream::Read(const ReadCallback& read_callback) {
   DCHECK(!read_callback.is_null());
 
   base::AutoLock auto_lock(lock_);
   // Don't accept any additional reads if we've been told to stop.
   // The demuxer_ may have been destroyed in the pipleine thread.
@@ skipping 317 matching lines @@
   streams_.resize(DemuxerStream::NUM_TYPES);
   base::TimeDelta max_duration;
   bool no_supported_streams = true;
   for (size_t i = 0; i < format_context_->nb_streams; ++i) {
     AVCodecContext* codec_context = format_context_->streams[i]->codec;
     AVMediaType codec_type = codec_context->codec_type;
     if (codec_type == AVMEDIA_TYPE_AUDIO || codec_type == AVMEDIA_TYPE_VIDEO) {
       AVStream* stream = format_context_->streams[i];
       scoped_refptr<FFmpegDemuxerStream> demuxer_stream(
           new FFmpegDemuxerStream(this, stream));
+
       if (!streams_[demuxer_stream->type()]) {
         no_supported_streams = false;
         streams_[demuxer_stream->type()] = demuxer_stream;
         max_duration = std::max(max_duration, demuxer_stream->duration());
 
         if (stream->first_dts != static_cast<int64_t>(AV_NOPTS_VALUE)) {
           const base::TimeDelta first_dts = ConvertFromTimeBase(
               stream->time_base, stream->first_dts);
           if (start_time_ == kNoTimestamp || first_dts < start_time_)
             start_time_ = first_dts;
         }
       }
-      packet_streams_.push_back(demuxer_stream);
-    } else {
-      packet_streams_.push_back(NULL);
     }
   }
   if (no_supported_streams) {
     callback.Run(DEMUXER_ERROR_NO_SUPPORTED_STREAMS);
     return;
   }
   if (format_context_->duration != static_cast<int64_t>(AV_NOPTS_VALUE)) {
     // If there is a duration value in the container use that to find the
     // maximum between it and the duration from A/V streams.
     const AVRational av_time_base = {1, AV_TIME_BASE};
@@ skipping 116 matching lines @@
     // If we have reached the end of stream, tell the downstream filters about
     // the event.
     StreamHasEnded();
     return;
   }
 
   // Queue the packet with the appropriate stream.
   // TODO(scherkus): should we post this back to the pipeline thread?  I'm
   // worried about downstream filters (i.e., decoders) executing on this
   // thread.
-  DCHECK_GE(packet->stream_index, 0);
-  DCHECK_LT(packet->stream_index, static_cast<int>(packet_streams_.size()));
-  FFmpegDemuxerStream* demuxer_stream = NULL;
-  size_t i = packet->stream_index;
-  // Defend against ffmpeg giving us a bad stream index.
-  if (i < packet_streams_.size()) {
-    demuxer_stream = packet_streams_[i];
-  }
-  if (demuxer_stream) {
-    // Queue the packet with the appropriate stream.  The stream takes
-    // ownership of the AVPacket.
-    if (packet.get()) {
+  for (StreamVector::iterator iter = streams_.begin();

[acolwell GONE FROM CHROMIUM, 2011/12/13 16:45:44]

I don't feel good about this iteration happening on every packet. If you want to
only have one vector own the stream, how about just changing packet_streams_ to
an index -> Type vector? Then you could just do something like
streams_[packet_stream_[packet->stream_index]]. When streams are disable you can
just update packet_stream_[packet->stream_index] to UNKNOWN and make sure
streams_[UNKNOWN] is always NULL.

[scherkus (not reviewing), 2011/12/13 17:24:56]

This loop unrolls to checking streams_[AUDIO]->stream_index() and
streams_[VIDEO]->stream_index(). True we're doing one additional comparison but
I'm skeptical doing bounds checking on packet->stream_index + an indirect lookup
is any better -- but we're really splitting hairs here!

Is your concern that |streams_| could change to be large and we wouldn't notice
the performance hit? I could hand unroll the loop as described above -- it would
likely clear things up a bit and also prevent needless looping.

+       iter != streams_.end();
+       ++iter) {
+    if ((*iter) && (*iter)->stream_index() == packet->stream_index) {
       // If a packet is returned by FFmpeg's av_parser_parse2()
       // the packet will reference an inner memory of FFmpeg.
       // In this case, the packet's "destruct" member is NULL,
       // and it MUST be duplicated. This fixes issue with MP3 and possibly
       // other codecs.  It is safe to call this function even if the packet does
       // not refer to inner memory from FFmpeg.
       av_dup_packet(packet.get());
-      demuxer_stream->EnqueuePacket(packet.release());
+
+      // Queue the packet with the appropriate stream.  The stream takes
+      // ownership of the AVPacket.
+      (*iter)->EnqueuePacket(packet.release());
+      break;
     }
   }
 
   // Create a loop by posting another task.  This allows seek and message loop
   // quit tasks to get processed.
   if (StreamsHavePendingReads()) {
     PostDemuxTask();
   }
 }
 
 void FFmpegDemuxer::StopTask(const base::Closure& callback) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   StreamVector::iterator iter;
   for (iter = streams_.begin(); iter != streams_.end(); ++iter) {
     if (*iter)
       (*iter)->Stop();
   }
   if (data_source_) {
     data_source_->Stop(callback);
   } else {
     callback.Run();
   }
 }
 
 void FFmpegDemuxer::DisableAudioStreamTask() {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
 
-  StreamVector::iterator iter;
-  for (size_t i = 0; i < packet_streams_.size(); ++i) {
-    if (!packet_streams_[i])
-      continue;
-
-    // If the codec type is audio, remove the reference. DemuxTask() will
-    // look for such reference, and this will result in deleting the
-    // audio packets after they are demuxed.
-    if (packet_streams_[i]->type() == DemuxerStream::AUDIO) {
-      packet_streams_[i] = NULL;
-    }
+  if (streams_[DemuxerStream::AUDIO]) {
+    streams_[DemuxerStream::AUDIO]->Stop();
   }
 }
 
 bool FFmpegDemuxer::StreamsHavePendingReads() {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   StreamVector::iterator iter;
   for (iter = streams_.begin(); iter != streams_.end(); ++iter) {
     if (*iter && (*iter)->HasPendingReads()) {
       return true;
     }
@@ skipping 21 matching lines @@
   read_event_.Wait();
   return last_read_bytes_;
 }
 
 void FFmpegDemuxer::SignalReadCompleted(size_t size) {
   last_read_bytes_ = size;
   read_event_.Signal();
 }
 
 }  // namespace media