Reduce MediaLog spam and add a note about unsupported statuses.

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 157 matching lines @@
 
 static const char* GetCodecName(const AVCodecContext* context) {
   if (context->codec_descriptor)
     return context->codec_descriptor->name;
   const AVCodecDescriptor* codec_descriptor =
       avcodec_descriptor_get(context->codec_id);
   // If the codec name can't be determined, return none for tracking.
   return codec_descriptor ? codec_descriptor->name : kCodecNone;
 }
 
+static void SetTimeProperty(MediaLogEvent* event,
+                            const std::string& key,
+                            base::TimeDelta value) {
+  if (value.is_max())
+    event->params.SetString(key, "unknown");
+  else
+    event->params.SetDouble(key, value.InSecondsF());
+}

[xhwang, 2016/03/18 17:31:35]

OOC, when will we set the max TimeDelta?

We do use kNoTimeStamp() in our code base. Is it possible that we report that?
What will it look like in media-internals page?

[DaleCurtis, 2016/03/18 17:36:49]

kInfiniteDuration() return TimeDelta::Max(). We could say kInifiniteDuration
here?

[xhwang, 2016/03/18 17:40:09]

Yeah, that makes sense for the duration, but for timestamp (e.g. start_time),
will we ever see kNoTimeStamp()?

[DaleCurtis, 2016/03/18 18:01:30]

We DCHECK() that it doesn't happen in a lot of cases, but I suppose that doesn't
prevent in field reports of that value. I've added both cases to the time
conversion.

+
 scoped_ptr<FFmpegDemuxerStream> FFmpegDemuxerStream::Create(
     FFmpegDemuxer* demuxer,
     AVStream* stream,
     const scoped_refptr<MediaLog>& media_log) {
   if (!demuxer || !stream)
     return nullptr;
 
   scoped_ptr<FFmpegDemuxerStream> demuxer_stream;
   scoped_ptr<AudioDecoderConfig> audio_config;
   scoped_ptr<VideoDecoderConfig> video_config;
@@ skipping 1122 matching lines @@
   // initializing.
   host_->SetDuration(max_duration);
   duration_known_ = (max_duration != kInfiniteDuration());
 
   int64_t filesize_in_bytes = 0;
   url_protocol_->GetSize(&filesize_in_bytes);
   bitrate_ = CalculateBitrate(format_context, max_duration, filesize_in_bytes);
   if (bitrate_ > 0)
     data_source_->SetBitrate(bitrate_);
 
-  // Audio logging
+  // Use a single MediaLogEvent to batch all parameter updates at once; this
+  // prevents throttling of events due to the large number of updates here.
+  scoped_ptr<MediaLogEvent> metadata_event =
+      media_log_->CreateEvent(MediaLogEvent::PROPERTY_CHANGE);
+
+  // Audio logging.
+  metadata_event->params.SetBoolean("found_audio_stream", !!audio_stream);
   if (audio_stream) {
-    AVCodecContext* audio_codec = audio_stream->codec;
-    media_log_->SetBooleanProperty("found_audio_stream", true);
-
-    SampleFormat sample_format = audio_config.sample_format();
-    std::string sample_name = SampleFormatToString(sample_format);
-
-    media_log_->SetStringProperty("audio_sample_format", sample_name);
-    media_log_->SetStringProperty("audio_codec_name",
-                                  GetCodecName(audio_codec));
-    media_log_->SetIntegerProperty("audio_channels_count",
-                                   audio_codec->channels);
-    media_log_->SetIntegerProperty("audio_samples_per_second",
-                                   audio_config.samples_per_second());
-  } else {
-    media_log_->SetBooleanProperty("found_audio_stream", false);
+    const AVCodecContext* audio_codec = audio_stream->codec;
+    metadata_event->params.SetString("audio_codec_name",
+                                     GetCodecName(audio_codec));
+    metadata_event->params.SetInteger("audio_channels_count",
+                                      audio_codec->channels);
+    metadata_event->params.SetString(
+        "audio_sample_format",
+        SampleFormatToString(audio_config.sample_format()));
+    metadata_event->params.SetInteger("audio_samples_per_second",
+                                      audio_config.samples_per_second());
   }
 
   // Video logging
+  metadata_event->params.SetBoolean("found_video_stream", !!video_stream);
   if (video_stream) {
-    AVCodecContext* video_codec = video_stream->codec;
-    media_log_->SetBooleanProperty("found_video_stream", true);
-    media_log_->SetStringProperty("video_codec_name",
-                                  GetCodecName(video_codec));
-    media_log_->SetIntegerProperty("width", video_codec->width);
-    media_log_->SetIntegerProperty("height", video_codec->height);
-    media_log_->SetIntegerProperty("coded_width", video_codec->coded_width);
-    media_log_->SetIntegerProperty("coded_height", video_codec->coded_height);
-    media_log_->SetStringProperty(
+    const AVCodecContext* video_codec = video_stream->codec;
+    metadata_event->params.SetString("video_codec_name",
+                                     GetCodecName(video_codec));
+    metadata_event->params.SetInteger("width", video_codec->width);
+    metadata_event->params.SetInteger("height", video_codec->height);
+    metadata_event->params.SetInteger("coded_width", video_codec->coded_width);
+    metadata_event->params.SetInteger("coded_height",
+                                      video_codec->coded_height);
+    metadata_event->params.SetString(
         "time_base", base::StringPrintf("%d/%d", video_codec->time_base.num,
                                         video_codec->time_base.den));
-    media_log_->SetStringProperty(
+    metadata_event->params.SetString(
         "video_format", VideoPixelFormatToString(video_config.format()));
-    media_log_->SetBooleanProperty("video_is_encrypted",
-                                   video_config.is_encrypted());
-  } else {
-    media_log_->SetBooleanProperty("found_video_stream", false);
+    metadata_event->params.SetBoolean("video_is_encrypted",
+                                      video_config.is_encrypted());
   }
 
-  media_log_->SetTimeProperty("max_duration", max_duration);
-  media_log_->SetTimeProperty("start_time", start_time_);
-  media_log_->SetIntegerProperty("bitrate", bitrate_);
+  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_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 165 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