Allow muting/unmuting audio through media track API

media/filters/media_source_state.cc

 // Copyright (c) 2016 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/media_source_state.h"
 
 #include "base/callback_helpers.h"
 #include "base/stl_util.h"
 #include "media/base/media_track.h"
 #include "media/base/media_tracks.h"
@@ skipping 462 matching lines @@
   return false;
 }
 
 bool MediaSourceState::OnNewConfigs(
     bool allow_audio,
     bool allow_video,
     scoped_ptr<MediaTracks> tracks,
     const StreamParser::TextTrackConfigMap& text_configs) {
   DCHECK_GE(state_, PENDING_PARSER_CONFIG);
   DCHECK(tracks.get());
   media_tracks_ = std::move(tracks);

[wolenetz, 2016/04/15 22:47:18]

minor nit: might we not want to replace our cache until we confirm success later
in this method?

[servolk, 2016/04/15 23:26:31]

In fact it turns out that we don't need to store the MediaTracks in
MediaSourceState at all for now, so I've removed |media_tracks_| in MSS
completely.

[wolenetz, 2016/04/15 23:52:17]

Acknowledged.

-  const AudioDecoderConfig& audio_config = media_tracks_->getFirstAudioConfig();
-  const VideoDecoderConfig& video_config = media_tracks_->getFirstVideoConfig();
+
+  const MediaTrack* audio_track = nullptr;
+  const MediaTrack* video_track = nullptr;
+  AudioDecoderConfig audio_config;
+  VideoDecoderConfig video_config;
+  for (const auto& track : media_tracks_->tracks()) {
+    if (!audio_track && track->type() == MediaTrack::Audio &&
+        media_tracks_->getAudioConfig(track->id()).IsValidConfig()) {
+      audio_config = media_tracks_->getAudioConfig(track->id());
+      audio_track = track.get();
+    } else if (!video_track && track->type() == MediaTrack::Video &&
+               media_tracks_->getVideoConfig(track->id()).IsValidConfig()) {
+      video_config = media_tracks_->getVideoConfig(track->id());
+      video_track = track.get();
+    }
+  }
 
   DVLOG(1) << "OnNewConfigs(" << allow_audio << ", " << allow_video << ", "
            << audio_config.IsValidConfig() << ", "
            << video_config.IsValidConfig() << ")";
   // MSE spec allows new configs to be emitted only during Append, but not
   // during Flush or parser reset operations.
   CHECK(append_in_progress_);
 
   if (!audio_config.IsValidConfig() && !video_config.IsValidConfig()) {
     DVLOG(1) << "OnNewConfigs() : Audio & video config are not valid!";
@@ skipping 27 matching lines @@
     if (!audio_) {
       media_log_->SetBooleanProperty("found_audio_stream", true);
     }
     if (!audio_ ||
         audio_->audio_decoder_config().codec() != audio_config.codec()) {
       media_log_->SetStringProperty("audio_codec_name",
                                     GetCodecName(audio_config.codec()));
     }
 
     if (!audio_) {
-      audio_ = create_demuxer_stream_cb_.Run(DemuxerStream::AUDIO);
+      DCHECK(audio_track);
+      audio_ = create_demuxer_stream_cb_.Run(*audio_track);
 
       if (!audio_) {
         DVLOG(1) << "Failed to create an audio stream.";
         return false;
       }
 
       if (!frame_processor_->AddTrack(FrameProcessor::kAudioTrackId, audio_)) {
         DVLOG(1) << "Failed to add audio track to frame processor.";
         return false;
       }
     }
 
     frame_processor_->OnPossibleAudioConfigUpdate(audio_config);
     success &= audio_->UpdateAudioConfig(audio_config, media_log_);
   }
 
   if (video_config.IsValidConfig()) {
     if (!video_) {
       media_log_->SetBooleanProperty("found_video_stream", true);
     }
     if (!video_ ||
         video_->video_decoder_config().codec() != video_config.codec()) {
       media_log_->SetStringProperty("video_codec_name",
                                     GetCodecName(video_config.codec()));
     }
 
     if (!video_) {
-      video_ = create_demuxer_stream_cb_.Run(DemuxerStream::VIDEO);
+      DCHECK(video_track);
+      video_ = create_demuxer_stream_cb_.Run(*video_track);
 
       if (!video_) {
         DVLOG(1) << "Failed to create a video stream.";
         return false;
       }
 
       if (!frame_processor_->AddTrack(FrameProcessor::kVideoTrackId, video_)) {
         DVLOG(1) << "Failed to add video track to frame processor.";
         return false;
       }
     }
 
     success &= video_->UpdateVideoConfig(video_config, media_log_);
   }
 
   typedef StreamParser::TextTrackConfigMap::const_iterator TextConfigItr;
   if (text_stream_map_.empty()) {
     for (TextConfigItr itr = text_configs.begin(); itr != text_configs.end();
          ++itr) {
+      // TODO(servolk): Look into unifying text tracks code path with audio and
+      // video track code paths.
+      MediaTrack dummy_text_track(MediaTrack::Text, "", "", "", "");
       ChunkDemuxerStream* const text_stream =
-          create_demuxer_stream_cb_.Run(DemuxerStream::TEXT);
+          create_demuxer_stream_cb_.Run(dummy_text_track);
       if (!frame_processor_->AddTrack(itr->first, text_stream)) {
         success &= false;
         MEDIA_LOG(ERROR, media_log_) << "Failed to add text track ID "
                                      << itr->first << " to frame processor.";
         break;
       }
       text_stream->UpdateTextConfig(itr->second, media_log_);
       text_stream_map_[itr->first] = text_stream;
       new_text_track_cb_.Run(text_stream, itr->second);
     }
@@ skipping 51 matching lines @@
                                        << config_itr->first
                                        << " does not match old one.";
           break;
         }
       }
     }
   }
 
   frame_processor_->SetAllTrackBuffersNeedRandomAccessPoint();
 
+  if (audio_track) {
+    DCHECK(audio_);
+    media_tracks_->SetDemuxerStreamForMediaTrack(audio_track, audio_);

[wolenetz, 2016/04/15 22:47:18]

I think this will now hit DCHECK on repeated init segment for same track (which
can occur).

[servolk, 2016/04/15 23:26:31]

No, it's ok, because for each new init segment a new MediaTracks object is
generated by the stream parser. So we'll set the MediaTrack* -> DemuxerStream*
associations here for the new MediaTracks and will later use it to overwrite the
current track_id -> DemuxerStream* mappings in ChunkDemuxer. So it's fine.

[wolenetz, 2016/04/15 23:52:17]

Acknowledged.

+  }
+  if (video_track) {
+    DCHECK(video_);
+    media_tracks_->SetDemuxerStreamForMediaTrack(video_track, video_);

[wolenetz, 2016/04/15 22:47:18]

ditto.

[servolk, 2016/04/15 23:26:31]

Acknowledged.

+  }
+
   DVLOG(1) << "OnNewConfigs() : " << (success ? "success" : "failed");
   if (success) {
     if (state_ == PENDING_PARSER_CONFIG)
       state_ = PENDING_PARSER_INIT;
     DCHECK(!init_segment_received_cb_.is_null());
     init_segment_received_cb_.Run(std::move(media_tracks_));
   }
 
   return success;
 }
@@ skipping 75 matching lines @@
 
 void MediaSourceState::OnSourceInitDone(
     const StreamParser::InitParameters& params) {
   DCHECK_EQ(state_, PENDING_PARSER_INIT);
   state_ = PARSER_INITIALIZED;
   auto_update_timestamp_offset_ = params.auto_update_timestamp_offset;
   base::ResetAndReturn(&init_cb_).Run(params);
 }
 
 }  // namespace media