MSE: Record counts of detected MSE audio, video and text tracks

media/formats/mp4/mp4_stream_parser.cc

 // Copyright 2014 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/formats/mp4/mp4_stream_parser.h"
 
 #include <stddef.h>
 #include <limits>
 #include <utility>
 #include <vector>
@@ skipping 174 matching lines @@
   moov_.reset(new Movie);
   RCHECK(moov_->Parse(reader));
   runs_.reset();
 
   has_audio_ = false;
   has_video_ = false;
 
   scoped_ptr<MediaTracks> media_tracks(new MediaTracks());
   AudioDecoderConfig audio_config;
   VideoDecoderConfig video_config;
+  int detected_audio_track_count = 0;
+  int detected_video_track_count = 0;
+  int detected_text_track_count = 0;
 
   for (std::vector<Track>::const_iterator track = moov_->tracks.begin();
        track != moov_->tracks.end(); ++track) {
     // TODO(strobe): Only the first audio and video track present in a file are
     // used. (Track selection is better accomplished via Source IDs, though, so
     // adding support for track selection within a stream is low-priority.)
     const SampleDescription& samp_descr =
         track->media.information.sample_table.description;
 
     // TODO(strobe): When codec reconfigurations are supported, detect and send
     // a codec reconfiguration for fragments using a sample description index
     // different from the previous one
     size_t desc_idx = 0;
     for (size_t t = 0; t < moov_->extends.tracks.size(); t++) {
       const TrackExtends& trex = moov_->extends.tracks[t];
       if (trex.track_id == track->header.track_id) {
         desc_idx = trex.default_sample_description_index;
         break;
       }
     }
     RCHECK(desc_idx > 0);
     desc_idx -= 1;  // BMFF descriptor index is one-based
 
-    if (track->media.handler.type == kAudio && !audio_config.IsValidConfig()) {
+    if (track->media.handler.type == kAudio) {
+      detected_audio_track_count++;
+      if (audio_config.IsValidConfig())
+        continue;  // Skip other audio tracks once we found a supported one.
+
       RCHECK(!samp_descr.audio_entries.empty());
 
       // It is not uncommon to find otherwise-valid files with incorrect sample
       // description indices, so we fail gracefully in that case.
       if (desc_idx >= samp_descr.audio_entries.size())
         desc_idx = 0;
       const AudioSampleEntry& entry = samp_descr.audio_entries[desc_idx];
       const AAC& aac = entry.esds.aac;
 
       // For encrypted audio streams entry.format is FOURCC_ENCA and actual
@@ skipping 78 matching lines @@
       DVLOG(1) << "is_audio_track_encrypted_: " << is_audio_track_encrypted_;
       audio_config.Initialize(
           codec, sample_format, channel_layout, sample_per_second, extra_data,
           is_audio_track_encrypted_ ? AesCtrEncryptionScheme() : Unencrypted(),
           base::TimeDelta(), 0);
       has_audio_ = true;
       audio_track_id_ = track->header.track_id;
       media_tracks->AddAudioTrack(
           audio_config, base::UintToString(audio_track_id_), "main",
           track->media.handler.name, track->media.header.language());
+      continue;
     }
-    if (track->media.handler.type == kVideo && !video_config.IsValidConfig()) {
+
+    if (track->media.handler.type == kVideo) {
+      detected_video_track_count++;
+      if (video_config.IsValidConfig())
+        continue;  // Skip other video tracks once we found a supported one.
+
       RCHECK(!samp_descr.video_entries.empty());
       if (desc_idx >= samp_descr.video_entries.size())
         desc_idx = 0;
       const VideoSampleEntry& entry = samp_descr.video_entries[desc_idx];
 
       if (!entry.IsFormatValid()) {
         MEDIA_LOG(ERROR, media_log_) << "Unsupported video format 0x"
                                      << std::hex << entry.format
                                      << " in stsd box.";
         return false;
@@ skipping 23 matching lines @@
           COLOR_SPACE_HD_REC709, coded_size, visible_rect, natural_size,
           // No decoder-specific buffer needed for AVC;
           // SPS/PPS are embedded in the video stream
           EmptyExtraData(),
           is_video_track_encrypted_ ? AesCtrEncryptionScheme() : Unencrypted());
       has_video_ = true;
       video_track_id_ = track->header.track_id;
       media_tracks->AddVideoTrack(
           video_config, base::UintToString(video_track_id_), "main",
           track->media.handler.name, track->media.header.language());
+      continue;
     }
+
+    // TODO(wolenetz): Investigate support in MSE and Chrome MSE for CEA 608/708
+    // embedded caption data in video track. At time of init segment parsing, we
+    // don't have this data (unless maybe by SourceBuffer's mimetype).
+    // See https://crbug.com/597073
+    if (track->media.handler.type == kText)
+      detected_text_track_count++;
   }
 
   if (!moov_->pssh.empty())
     OnEncryptedMediaInitData(moov_->pssh);
 
   RCHECK(config_cb_.Run(std::move(media_tracks), TextTrackConfigMap()));
 
   StreamParser::InitParameters params(kInfiniteDuration());
   if (moov_->extends.header.fragment_duration > 0) {
     params.duration = TimeDeltaFromRational(
         moov_->extends.header.fragment_duration, moov_->header.timescale);
     params.liveness = DemuxerStream::LIVENESS_RECORDED;
   } else if (moov_->header.duration > 0 &&
              moov_->header.duration != std::numeric_limits<uint64_t>::max()) {
     params.duration =
         TimeDeltaFromRational(moov_->header.duration, moov_->header.timescale);
     params.liveness = DemuxerStream::LIVENESS_RECORDED;
   } else {
     // In ISO/IEC 14496-12:2005(E), 8.30.2: ".. If an MP4 file is created in
     // real-time, such as used in live streaming, it is not likely that the
     // fragment_duration is known in advance and this (mehd) box may be
     // omitted."
     // TODO(wolenetz): Investigate gating liveness detection on timeline_offset
     // when it's populated. See http://crbug.com/312699
     params.liveness = DemuxerStream::LIVENESS_LIVE;
   }
 
   DVLOG(1) << "liveness: " << params.liveness;
 
-  if (!init_cb_.is_null())
+  if (!init_cb_.is_null()) {
+    params.detected_audio_track_count = detected_audio_track_count;
+    params.detected_video_track_count = detected_video_track_count;
+    params.detected_text_track_count = detected_text_track_count;

[chcunningham, 2016/03/23 23:05:56]

Might be good to add a test for these to mp4_stream_parser_unittest.cc... may be
as simple as adding some params and checks to InitializeParserAndExpectLiveness
(InitializeParserAndExpect(liveness, audio_track_count, ....)

[wolenetz, 2016/03/25 23:25:08]

Yup. I thought you might ask :)
Verification added.
For verifying nonzero *text* tracks related to this and the similar webm
comment, I'm working on getting some content added to this CL. Not there yet.

[wolenetz, 2016/03/29 00:14:42]

Done.

     base::ResetAndReturn(&init_cb_).Run(params);
+  }
 
   return true;
 }
 
 bool MP4StreamParser::ParseMoof(BoxReader* reader) {
   RCHECK(moov_.get());  // Must already have initialization segment
   MovieFragment moof;
   RCHECK(moof.Parse(reader));
   if (!runs_)
     runs_.reset(new TrackRunIterator(moov_.get(), media_log_));
@@ skipping 264 matching lines @@
       runs.AdvanceSample();
     }
     runs.AdvanceRun();
   }
 
   return true;
 }
 
 }  // namespace mp4
 }  // namespace media