media: Record counts of detected src= audio, video, and text tracks

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 96 matching lines @@
 template <class T>  // T has int width() & height() methods.
 static void UmaHistogramAspectRatio(const char* name, const T& size) {
   UMA_HISTOGRAM_CUSTOM_ENUMERATION(
       name,
       // Intentionally use integer division to truncate the result.
       size.height() ? (size.width() * 100) / size.height() : kInfiniteRatio,
       base::CustomHistogram::ArrayToCustomRanges(
           kCommonAspectRatios100, arraysize(kCommonAspectRatios100)));
 }
 
+// Record detected track counts by type corresponding to a src= playback.
+// Counts are split into 50 buckets, capped into [0,100] range.
+static void RecordDetectedTrackTypeStats(int audio_count,
+                                         int video_count,
+                                         int text_count) {
+  UMA_HISTOGRAM_COUNTS_100("Media.DetectedTrackCount.Audio", audio_count);
+  UMA_HISTOGRAM_COUNTS_100("Media.DetectedTrackCount.Video", video_count);
+  UMA_HISTOGRAM_COUNTS_100("Media.DetectedTrackCount.Text", text_count);
+}
+
 // Record audio decoder config UMA stats corresponding to a src= playback.
 static void RecordAudioCodecStats(const AudioDecoderConfig& audio_config) {
   UMA_HISTOGRAM_ENUMERATION("Media.AudioCodec", audio_config.codec(),
                             kAudioCodecMax + 1);
   UMA_HISTOGRAM_ENUMERATION("Media.AudioSampleFormat",
                             audio_config.sample_format(), kSampleFormatMax + 1);
   UMA_HISTOGRAM_ENUMERATION("Media.AudioChannelLayout",
                             audio_config.channel_layout(),
                             CHANNEL_LAYOUT_MAX + 1);
   AudioSampleRate asr;
@@ skipping 966 matching lines @@
   scoped_ptr<MediaTracks> media_tracks(new MediaTracks());
   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;
+  int detected_video_track_count = 0;
+  int detected_text_track_count = 0;
   for (size_t i = 0; i < format_context->nb_streams; ++i) {
     AVStream* stream = format_context->streams[i];
     const AVCodecContext* codec_context = stream->codec;
     const AVMediaType codec_type = codec_context->codec_type;
 
     if (codec_type == AVMEDIA_TYPE_AUDIO) {
+      // Log the codec detected, whether it is supported or not, and whether or
+      // not we have already detected a supported codec in another stream.
+      UMA_HISTOGRAM_SPARSE_SLOWLY("Media.DetectedAudioCodecHash",
+                                  HashCodecName(GetCodecName(codec_context)));
+      detected_audio_track_count++;
+
       if (audio_stream)
         continue;
+    } else if (codec_type == AVMEDIA_TYPE_VIDEO) {
+      // Log the codec detected, whether it is supported or not, and whether or
+      // not we have already detected a supported codec in another stream.
+      UMA_HISTOGRAM_SPARSE_SLOWLY("Media.DetectedVideoCodecHash",
+                                  HashCodecName(GetCodecName(codec_context)));
+      detected_video_track_count++;
 
-      // Log the codec detected, whether it is supported or not.
-      UMA_HISTOGRAM_SPARSE_SLOWLY("Media.DetectedAudioCodecHash",
-                                  HashCodecName(GetCodecName(codec_context)));
-    } else if (codec_type == AVMEDIA_TYPE_VIDEO) {
       if (video_stream)
         continue;
 
 #if BUILDFLAG(ENABLE_HEVC_DEMUXING)
       if (stream->codec->codec_id == AV_CODEC_ID_HEVC) {
         // If ffmpeg is built without HEVC parser/decoder support, it will be
         // able to demux HEVC based solely on container-provided information,
         // but unable to get some of the parameters without parsing the stream
         // (e.g. coded size needs to be read from SPS, pixel format is typically
         // deduced from decoder config in hvcC box). These are not really needed
         // when using external decoder (e.g. hardware decoder), so override them
         // here, to make sure this translates into a valid VideoDecoderConfig.
         if (stream->codec->coded_width == 0 &&
             stream->codec->coded_height == 0) {
           DCHECK(stream->codec->width > 0);
           DCHECK(stream->codec->height > 0);
           stream->codec->coded_width = stream->codec->width;
           stream->codec->coded_height = stream->codec->height;
         }
         if (stream->codec->pix_fmt == AV_PIX_FMT_NONE) {
           stream->codec->pix_fmt = AV_PIX_FMT_YUV420P;
         }
       }
 #endif
-      // Log the codec detected, whether it is supported or not.
-      UMA_HISTOGRAM_SPARSE_SLOWLY("Media.DetectedVideoCodecHash",
-                                  HashCodecName(GetCodecName(codec_context)));
     } else if (codec_type == AVMEDIA_TYPE_SUBTITLE) {
+      detected_text_track_count++;
       if (codec_context->codec_id != AV_CODEC_ID_WEBVTT || !text_enabled_) {
         continue;
       }
     } else {
       continue;
     }
 
     // Attempt to create a FFmpegDemuxerStream from the AVStream. This will
     // return nullptr if the AVStream is invalid. Validity checks will verify
     // things like: codec, channel layout, sample/pixel format, etc...
@@ skipping 57 matching lines @@
 
     if (start_time < start_time_) {
       start_time_ = start_time;
 
       // Choose the stream with the lowest starting time as the fallback stream
       // for seeking.  Video should always be preferred.
       fallback_stream_for_seeking_ = StreamSeekInfo(i, start_time);
     }
   }
 
+  RecordDetectedTrackTypeStats(detected_audio_track_count,
+                               detected_video_track_count,
+                               detected_text_track_count);
+
   if (!audio_stream && !video_stream) {
     MEDIA_LOG(ERROR, media_log_) << GetDisplayName()
                                  << ": no supported streams";
     status_cb.Run(DEMUXER_ERROR_NO_SUPPORTED_STREAMS);
     return;
   }
 
   if (text_enabled_)
     AddTextStreams();
 
@@ skipping 307 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);
   }
 }
 
 }  // namespace media