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

media/formats/webm/webm_tracks_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/webm/webm_tracks_parser.h"
 
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "media/base/media_util.h"
@@ skipping 29 matching lines @@
   mult /= timecode_scale_in_us;
   if (mult == 0)
     return kNoTimestamp();
 
   mult = static_cast<double>(mult) * timecode_scale_in_us;
   return base::TimeDelta::FromMicroseconds(mult);
 }
 
 WebMTracksParser::WebMTracksParser(const scoped_refptr<MediaLog>& media_log,
                                    bool ignore_text_tracks)
-    : track_type_(-1),
-      track_num_(-1),

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

Nit: You might be better off with a private method "reset" method that you can
call here and in the top of ::Parse

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

Agreed. Will be in later patch set.

[wolenetz, 2016/03/28 20:41:46]

I've sent this particular cleanup as a prereq CL [1]. I'll rebase this CL onto
that one, once that one lands.
[1] https://codereview.chromium.org/1842503002

-      seek_preroll_(-1),
-      codec_delay_(-1),
-      default_duration_(-1),
-      audio_track_num_(-1),
-      audio_default_duration_(-1),
-      video_track_num_(-1),
-      video_default_duration_(-1),
-      ignore_text_tracks_(ignore_text_tracks),
+    : ignore_text_tracks_(ignore_text_tracks),
       media_log_(media_log),
       audio_client_(media_log),
-      video_client_(media_log) {
-}
+      video_client_(media_log) {}
 
 WebMTracksParser::~WebMTracksParser() {}
 
 int WebMTracksParser::Parse(const uint8_t* buf, int size) {
   track_type_ =-1;
   track_num_ = -1;
   default_duration_ = -1;
   track_name_.clear();
   track_language_.clear();
   audio_track_num_ = -1;
   audio_default_duration_ = -1;
   audio_decoder_config_ = AudioDecoderConfig();
   video_track_num_ = -1;
   video_default_duration_ = -1;
   video_decoder_config_ = VideoDecoderConfig();
   text_tracks_.clear();
   ignored_tracks_.clear();
+  detected_audio_track_count_ = 0;
+  detected_video_track_count_ = 0;
+  detected_text_track_count_ = 0;
   media_tracks_.reset(new MediaTracks());
 
   WebMListParser parser(kWebMIdTracks, this);
   int result = parser.Parse(buf, size);
 
   if (result <= 0)
     return result;
 
   // For now we do all or nothing parsing.
   return parser.IsParsingComplete() ? result : 0;
@@ skipping 100 matching lines @@
       // If we have multiple ContentEncoding in one track. Always choose the
       // key id in the first ContentEncoding as the key id of the track.
       encryption_key_id = track_content_encodings_client_->
           content_encodings()[0]->encryption_key_id();
     }
 
     EncryptionScheme encryption_scheme =
         encryption_key_id.empty() ? Unencrypted() : AesCtrEncryptionScheme();
 
     if (track_type_ == kWebMTrackTypeAudio) {
+      detected_audio_track_count_++;
       if (audio_track_num_ == -1) {
         audio_track_num_ = track_num_;
         audio_encryption_key_id_ = encryption_key_id;
 
         if (default_duration_ == 0) {
           MEDIA_LOG(ERROR, media_log_) << "Illegal 0ns audio TrackEntry "
                                           "DefaultDuration";
           return false;
         }
         audio_default_duration_ = default_duration_;
 
         DCHECK(!audio_decoder_config_.IsValidConfig());
         if (!audio_client_.InitializeConfig(
                 codec_id_, codec_private_, seek_preroll_, codec_delay_,
                 encryption_scheme, &audio_decoder_config_)) {
           return false;
         }
         media_tracks_->AddAudioTrack(audio_decoder_config_,
                                      base::Uint64ToString(track_num_), "main",
                                      track_name_, track_language_);
       } else {
         MEDIA_LOG(DEBUG, media_log_) << "Ignoring audio track " << track_num_;
         ignored_tracks_.insert(track_num_);
       }
     } else if (track_type_ == kWebMTrackTypeVideo) {
+      detected_video_track_count_++;
       if (video_track_num_ == -1) {
         video_track_num_ = track_num_;
         video_encryption_key_id_ = encryption_key_id;
 
         if (default_duration_ == 0) {
           MEDIA_LOG(ERROR, media_log_) << "Illegal 0ns video TrackEntry "
                                           "DefaultDuration";
           return false;
         }
         video_default_duration_ = default_duration_;
 
         DCHECK(!video_decoder_config_.IsValidConfig());
         if (!video_client_.InitializeConfig(codec_id_, codec_private_,
                                             encryption_scheme,
                                             &video_decoder_config_)) {
           return false;
         }
         media_tracks_->AddVideoTrack(video_decoder_config_,
                                      base::Uint64ToString(track_num_), "main",
                                      track_name_, track_language_);
       } else {
         MEDIA_LOG(DEBUG, media_log_) << "Ignoring video track " << track_num_;
         ignored_tracks_.insert(track_num_);
       }
     } else if (track_type_ == kWebMTrackTypeSubtitlesOrCaptions ||
                track_type_ == kWebMTrackTypeDescriptionsOrMetadata) {
+      detected_text_track_count_++;

[wolenetz, 2016/03/23 01:45:50]

aside: For better data (and similar to ffmpeg_demuxer.cc), we detect and report
even if the actual use later in the parser/pipeline of text track is not
enabled.

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

Acknowledged.

       if (ignore_text_tracks_) {
         MEDIA_LOG(DEBUG, media_log_) << "Ignoring text track " << track_num_;
         ignored_tracks_.insert(track_num_);
       } else {
         std::string track_num = base::Int64ToString(track_num_);
         text_tracks_[track_num_] = TextTrackConfig(
             text_track_kind, track_name_, track_language_, track_num);
       }
     } else {
       MEDIA_LOG(ERROR, media_log_) << "Unexpected TrackType " << track_type_;
@@ skipping 93 matching lines @@
     } else {
       track_language_ = str;
     }
     return true;
   }
 
   return true;
 }
 
 }  // namespace media