Detect errors in audio output and report them upstream.

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 "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 271 matching lines @@
     : message_loop_(message_loop),
       local_source_(local_source),
       format_context_(NULL),
       read_event_(false, false),
       read_has_failed_(false),
       last_read_bytes_(0),
       read_position_(0),
       max_duration_(base::TimeDelta::FromMicroseconds(-1)),
       deferred_status_(PIPELINE_OK),
       first_seek_hack_(true),
-      start_time_(kNoTimestamp()) {
+      start_time_(kNoTimestamp()),
+      audio_disabled_(false) {
   DCHECK(message_loop_);
 }
 
 FFmpegDemuxer::~FFmpegDemuxer() {
   // In this destructor, we clean up resources held by FFmpeg. It is ugly to
   // close the codec contexts here because the corresponding codecs are opened
   // in the decoder filters. By reaching this point, all filters should have
   // stopped, so this is the only safe place to do the global clean up.
   // TODO(hclam): close the codecs in the corresponding decoders.
   if (!format_context_)
@@ skipping 352 matching lines @@
   // 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>(streams_.size()));
 
   // Defend against ffmpeg giving us a bad stream index.
   if (packet->stream_index >= 0 &&
       packet->stream_index < static_cast<int>(streams_.size()) &&
-      streams_[packet->stream_index]) {
+      streams_[packet->stream_index] &&
+      (!audio_disabled_ ||
+       streams_[packet->stream_index]->type() != DemuxerStream::AUDIO)) {
     FFmpegDemuxerStream* demuxer_stream = streams_[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());
 
@@ skipping 16 matching lines @@
   }
   if (data_source_) {
     data_source_->Stop(callback);
   } else {
     callback.Run();
   }
 }
 
 void FFmpegDemuxer::DisableAudioStreamTask() {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
+  audio_disabled_ = true;

[scherkus (not reviewing), 2012/01/26 21:46:13]

any reason not to use FFmpegDemuxerStream::stopped_ as the signal for dropping
packets / detecting end of stream?

[Ami GONE FROM CHROMIUM, 2012/01/26 22:11:01]

Just that that would be a more intrusive change, since it would have the demuxer
query the streams for their status, which is counter to the way most information
& control flows today.

   StreamVector::iterator iter;
   for (iter = streams_.begin(); iter != streams_.end(); ++iter) {
     if (*iter && (*iter)->type() == DemuxerStream::AUDIO) {
       (*iter)->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;
     }
   }
   return false;
 }
 
 void FFmpegDemuxer::StreamHasEnded() {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   StreamVector::iterator iter;
   for (iter = streams_.begin(); iter != streams_.end(); ++iter) {
-    if (!*iter)
+    if (!*iter ||
+        (audio_disabled_ && (*iter)->type() == DemuxerStream::AUDIO)) {
       continue;
+    }
     scoped_ptr_malloc<AVPacket, ScopedPtrAVFreePacket> packet(new AVPacket());
     memset(packet.get(), 0, sizeof(*packet.get()));
     (*iter)->EnqueuePacket(packet.Pass());
   }
 }
 
 void FFmpegDemuxer::OnReadCompleted(size_t size) {
   SignalReadCompleted(size);
 }
 
 size_t FFmpegDemuxer::WaitForRead() {
   read_event_.Wait();
   return last_read_bytes_;
 }
 
 void FFmpegDemuxer::SignalReadCompleted(size_t size) {
   last_read_bytes_ = size;
   read_event_.Signal();
 }
 
 }  // namespace media