Added logging calls to FFmpegDemuxer.

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 <string>
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
+#include "base/strings/stringprintf.h"
 #include "base/task_runner_util.h"
 #include "base/time/time.h"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/bind_to_loop.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/decrypt_config.h"
 #include "media/base/limits.h"
 #include "media/base/media_log.h"
 #include "media/base/media_switches.h"
 #include "media/base/video_decoder_config.h"
@@ skipping 454 matching lines @@
     status_cb.Run(DEMUXER_ERROR_COULD_NOT_PARSE);
     return;
   }
 
   // Create demuxer stream entries for each possible AVStream. Each stream
   // is examined to determine if it is supported or not (is the codec enabled
   // for it in this release?). Unsupported streams are skipped, allowing for
   // partial playback. At least one audio or video stream must be playable.
   AVFormatContext* format_context = glue_->format_context();
   streams_.resize(format_context->nb_streams);
+
   bool found_audio_stream = false;

[DaleCurtis, 2013/08/05 19:58:39]

You can remove the bool's now that we can just check for video_stream or
audio_stream

[Ty Overby, 2013/08/05 20:14:59]

???  We still use found_audio_stream and found_video_stream in a few places.  

Should I remove it and replace it with null pointer checks?

[DaleCurtis, 2013/08/05 20:19:22]

Yeah.

+  AVStream* audio_stream = nullptr;

[DaleCurtis, 2013/08/05 19:58:39]

We're still not C++11 enabled, so this should be NULL.

[Ty Overby, 2013/08/05 20:14:59]

Done.

+  AudioDecoderConfig audio_config;
+
   bool found_video_stream = false;
+  AVStream* video_stream = nullptr;

[DaleCurtis, 2013/08/05 19:58:39]

Ditto.

[Ty Overby, 2013/08/05 20:14:59]

Done.

+  VideoDecoderConfig video_config;
 
   base::TimeDelta max_duration;
   for (size_t i = 0; i < format_context->nb_streams; ++i) {
     AVStream* stream = format_context->streams[i];
     AVCodecContext* codec_context = stream->codec;
     AVMediaType codec_type = codec_context->codec_type;
 
     if (codec_type == AVMEDIA_TYPE_AUDIO) {
       if (found_audio_stream)
         continue;
+      audio_stream = stream;
+
       // Log the codec detected, whether it is supported or not.
       UMA_HISTOGRAM_SPARSE_SLOWLY("Media.DetectedAudioCodec",
                                   codec_context->codec_id);
       // Ensure the codec is supported. IsValidConfig() also checks that the
       // channel layout and sample format are valid.
-      AudioDecoderConfig audio_config;
       AVStreamToAudioDecoderConfig(stream, &audio_config, false);
       if (!audio_config.IsValidConfig())
         continue;
       found_audio_stream = true;
     } else if (codec_type == AVMEDIA_TYPE_VIDEO) {
       if (found_video_stream)
         continue;
+      video_stream = stream;
+
       // Log the codec detected, whether it is supported or not.
       UMA_HISTOGRAM_SPARSE_SLOWLY("Media.DetectedVideoCodec",
                                   codec_context->codec_id);
       // Ensure the codec is supported. IsValidConfig() also checks that the
       // frame size and visible size are valid.
-      VideoDecoderConfig video_config;
       AVStreamToVideoDecoderConfig(stream, &video_config, false);
+
       if (!video_config.IsValidConfig())
         continue;
       found_video_stream = true;
     } else {
       continue;
     }
 
     streams_[i] = new FFmpegDemuxerStream(this, stream);
     max_duration = std::max(max_duration, streams_[i]->duration());
 
@@ skipping 36 matching lines @@
   // initializing.
   host_->SetDuration(max_duration);
   duration_known_ = (max_duration != kInfiniteDuration());
 
   int64 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
+  if (found_audio_stream) {
+    AVCodecContext* audio_codec = audio_stream->codec;
+    media_log_->SetBooleanProperty("found_audio_stream", true);

[DaleCurtis, 2013/08/05 19:58:39]

Else set to false?

[Ty Overby, 2013/08/05 20:14:59]

Done.

[Ty Overby, 2013/08/05 20:14:59]

Done.

+    media_log_->SetStringProperty("audio_codec_name",
+                                  audio_codec->codec_name);
+    media_log_->SetIntegerProperty("audio_sample_rate",
+                                   audio_codec->sample_rate);
+    media_log_->SetIntegerProperty("audio_channels_count",
+                                   audio_codec->channels);
+    media_log_->SetIntegerProperty("audio_samples_per_second",
+                                   audio_config.samples_per_second());
+  }
+
+  // Video logging
+  if (found_video_stream) {
+    AVCodecContext* video_codec = video_stream->codec;
+    media_log_->SetBooleanProperty("found_video_stream", true);

[DaleCurtis, 2013/08/05 19:58:39]

Ditto?

[Ty Overby, 2013/08/05 20:14:59]

Done.

+    std::string codec_name = avcodec_get_name(video_codec->codec_id);
+    media_log_->SetStringProperty("video_codec_name", codec_name);
+    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(
+        "time_base",
+        base::StringPrintf("%d/%d",
+                           video_codec->time_base.num,
+                           video_codec->time_base.den));
+    media_log_->SetStringProperty(
+        "video_format", VideoFrame::FormatToString(video_config.format()));
+    media_log_->SetBooleanProperty("video_is_encrypted",
+                                   video_config.is_encrypted());
+  }
+
+  media_log_->SetDoubleProperty("max_duration", max_duration.InSecondsF());
+  media_log_->SetDoubleProperty("start_time", start_time_.InSecondsF());
+  media_log_->SetStringProperty("filesize_in_bytes",
+                          std::to_string(filesize_in_bytes));

[DaleCurtis, 2013/08/05 19:58:39]

Indent.

[Ty Overby, 2013/08/05 20:14:59]

Done.

+  media_log_->SetIntegerProperty("bitrate", bitrate_);
+
   status_cb.Run(PIPELINE_OK);
 }
 
 void FFmpegDemuxer::OnSeekFrameDone(const PipelineStatusCB& cb, int result) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   CHECK(pending_seek_);
   pending_seek_ = false;
 
   if (!blocking_thread_.IsRunning()) {
     cb.Run(PIPELINE_ERROR_ABORT);
@@ skipping 185 matching lines @@
   }
   for (size_t i = 0; i < buffered.size(); ++i)
     host_->AddBufferedTimeRange(buffered.start(i), buffered.end(i));
 }
 
 void FFmpegDemuxer::OnDataSourceError() {
   host_->OnDemuxerError(PIPELINE_ERROR_READ);
 }
 
 }  // namespace media