Allow muting/unmuting audio through media track API

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 <utility>
 
 #include "base/base64.h"
@@ skipping 1094 matching lines @@
         const base::TimeDelta packet_pts =
             ConvertFromTimeBase(stream->time_base, packet_buffer->pkt.pts);
         if (packet_pts < start_time_estimates[stream->index])
           start_time_estimates[stream->index] = packet_pts;
       }
       packet_buffer = packet_buffer->next;
     }
   }
 
   scoped_ptr<MediaTracks> media_tracks(new MediaTracks());
+  MediaTracks::TrackToDemuxStreamMap track_to_demux_stream_map;
   AVStream* audio_stream = NULL;
   AudioDecoderConfig audio_config;
   AVStream* video_stream = NULL;
   VideoDecoderConfig video_config;
 
   // 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;
@@ skipping 89 matching lines @@
     if (strstr(format_context->iformat->name, "webm") ||
         strstr(format_context->iformat->name, "matroska")) {
       // TODO(servolk): FFmpeg doesn't set stream->id correctly for webm files.
       // Need to fix that and use it as track id. crbug.com/323183
       track_id = base::UintToString(media_tracks->tracks().size() + 1);
       track_label = streams_[i]->GetMetadata("title");
     }
 
     // Note when we find our audio/video stream (we only want one of each) and
     // record src= playback UMA stats for the stream's decoder config.
+    const 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_tracks->AddAudioTrack(audio_config, track_id, "main", track_label,
-                                  track_language);
+      media_track = media_tracks->AddAudioTrack(audio_config, track_id, "main",
+                                                track_label, track_language);
+      track_to_demux_stream_map[media_track] = 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_tracks->AddVideoTrack(video_config, track_id, "main", track_label,
-                                  track_language);
+      media_track = media_tracks->AddVideoTrack(video_config, track_id, "main",
+                                                track_label, track_language);
+      track_to_demux_stream_map[media_track] = 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 155 matching lines @@
         "video_format", VideoPixelFormatToString(video_config.format()));
     metadata_event->params.SetBoolean("video_is_encrypted",
                                       video_config.is_encrypted());
   }
 
   SetTimeProperty(metadata_event.get(), "max_duration", max_duration);
   SetTimeProperty(metadata_event.get(), "start_time", start_time_);
   metadata_event->params.SetInteger("bitrate", bitrate_);
   media_log_->AddEvent(std::move(metadata_event));
 
+  media_tracks->set_track_to_demux_stream_map(track_to_demux_stream_map);
   media_tracks_updated_cb_.Run(std::move(media_tracks));
 
   status_cb.Run(PIPELINE_OK);
 }
 
 void FFmpegDemuxer::OnSeekFrameDone(const PipelineStatusCB& cb, int result) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   CHECK(pending_seek_);
   pending_seek_ = false;
 
@@ skipping 163 matching lines @@
 }
 
 void FFmpegDemuxer::SetLiveness(DemuxerStream::Liveness liveness) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   for (const auto& stream : streams_) {  // |stream| is a ref to a pointer.
     if (stream)
       stream->SetLiveness(liveness);
   }
 }
 
+void FFmpegDemuxer::OnTrackIdsAssigned(const MediaTracks& tracks,
+                                       const std::vector<unsigned>& track_ids) {
+  DCHECK_EQ(tracks.tracks().size(), track_ids.size());

[wolenetz, 2016/04/14 20:43:39]

Similarly, these two DCHECK_EQs need to be CHECK_EQs, to force fail instead of
out-of-range access.

[servolk, 2016/04/15 02:23:25]

Done.

+  const auto& track_to_demux_stream = tracks.track_to_demux_stream_map();
+  DCHECK_EQ(track_to_demux_stream.size(), tracks.tracks().size());
+  for (size_t i = 0; i < track_ids.size(); ++i) {
+    const MediaTrack* track = tracks.tracks()[i].get();
+    DCHECK(track);
+    const auto& it = track_to_demux_stream.find(track);
+    DCHECK(it != track_to_demux_stream.end());
+    DVLOG(3) << "OnTrackIdsAssigned track_id=" << track_ids[i]
+             << " DemuxerStream=" << it->second;
+    track_id_to_demux_stream_[track_ids[i]] = it->second;
+  }
+}
+
+const DemuxerStream* FFmpegDemuxer::GetDemuxerStreamByTrackId(
+    unsigned track_id) const {
+  const auto& it = track_id_to_demux_stream_.find(track_id);
+  CHECK(it != track_id_to_demux_stream_.end());
+  return it->second;
+}
+
 }  // namespace media