Emit Media Source codec names as media_log events.

media/filters/chunk_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/chunk_demuxer.h"
 
 #include <algorithm>
 #include <limits>
 #include <list>
 
@@ skipping 80 matching lines @@
       DemuxerStream::Type)> CreateDemuxerStreamCB;
 
   typedef ChunkDemuxer::InitSegmentReceivedCB InitSegmentReceivedCB;
 
   typedef base::Callback<void(
       ChunkDemuxerStream*, const TextTrackConfig&)> NewTextTrackCB;
 
   SourceState(
       scoped_ptr<StreamParser> stream_parser,
       scoped_ptr<FrameProcessor> frame_processor, const LogCB& log_cb,
-      const CreateDemuxerStreamCB& create_demuxer_stream_cb);
+      const CreateDemuxerStreamCB& create_demuxer_stream_cb,
+      const scoped_refptr<MediaLog>& media_log);
 
   ~SourceState();
 
   void Init(const StreamParser::InitCB& init_cb,
             bool allow_audio,
             bool allow_video,
             const StreamParser::NeedKeyCB& need_key_cb,
             const NewTextTrackCB& new_text_track_cb);
 
   // Appends new data to the StreamParser.
@@ skipping 116 matching lines @@
   scoped_ptr<StreamParser> stream_parser_;
 
   ChunkDemuxerStream* audio_;  // Not owned by |this|.
   ChunkDemuxerStream* video_;  // Not owned by |this|.
 
   typedef std::map<StreamParser::TrackId, ChunkDemuxerStream*> TextStreamMap;
   TextStreamMap text_stream_map_;  // |this| owns the map's stream pointers.
 
   scoped_ptr<FrameProcessor> frame_processor_;
   LogCB log_cb_;
+  scoped_refptr<MediaLog> media_log_;
   StreamParser::InitCB init_cb_;
 
   // During Append(), OnNewConfigs() will trigger the initialization segment
   // received algorithm. This callback is only non-NULL during the lifetime of
   // an Append() call. Note, the MSE spec explicitly disallows this algorithm
   // during an Abort(), since Abort() is allowed only to emit coded frames, and
   // only if the parser is PARSING_MEDIA_SEGMENT (not an INIT segment).
   InitSegmentReceivedCB init_segment_received_cb_;
 
   // Indicates that timestampOffset should be updated automatically during
   // OnNewBuffers() based on the earliest end timestamp of the buffers provided.
   // TODO(wolenetz): Refactor this function while integrating April 29, 2014
   // changes to MSE spec. See http://crbug.com/371499.
   bool auto_update_timestamp_offset_;
 
   DISALLOW_COPY_AND_ASSIGN(SourceState);
 };
 
 SourceState::SourceState(scoped_ptr<StreamParser> stream_parser,
                          scoped_ptr<FrameProcessor> frame_processor,
                          const LogCB& log_cb,
-                         const CreateDemuxerStreamCB& create_demuxer_stream_cb)
+                         const CreateDemuxerStreamCB& create_demuxer_stream_cb,
+                         const scoped_refptr<MediaLog>& media_log)
     : create_demuxer_stream_cb_(create_demuxer_stream_cb),
       timestamp_offset_during_append_(NULL),
       new_media_segment_(false),
       parsing_media_segment_(false),
       stream_parser_(stream_parser.release()),
       audio_(NULL),
       video_(NULL),
       frame_processor_(frame_processor.release()),
       log_cb_(log_cb),
+      media_log_(media_log),
       auto_update_timestamp_offset_(false) {
   DCHECK(!create_demuxer_stream_cb_.is_null());
   DCHECK(frame_processor_);
 }
 
 SourceState::~SourceState() {
   Shutdown();
 
   STLDeleteValues(&text_stream_map_);
 }
@@ skipping 306 matching lines @@
         << (video_config.IsValidConfig() ? " has" : " does not have")
         << " a video track, but the mimetype"
         << (allow_video ? " specifies" : " does not specify")
         << " a video codec.";
     return false;
   }
 
   bool success = true;
   if (audio_config.IsValidConfig()) {
     if (!audio_) {
+      media_log_->SetBooleanProperty("found_audio_stream", true);
+    }
+    if (!audio_ ||
+        audio_->audio_decoder_config().codec() != audio_config.codec()) {
+      media_log_->SetStringProperty("audio_codec_name",
+                                    audio_config.GetHumanReadableCodecName());
+    }
+
+    if (!audio_) {
       audio_ = create_demuxer_stream_cb_.Run(DemuxerStream::AUDIO);
 
       if (!audio_) {
         DVLOG(1) << "Failed to create an audio stream.";
         return false;
       }
 
       if (!frame_processor_->AddTrack(FrameProcessor::kAudioTrackId, audio_)) {
         DVLOG(1) << "Failed to add audio track to frame processor.";
         return false;
       }
     }
 
     frame_processor_->OnPossibleAudioConfigUpdate(audio_config);
     success &= audio_->UpdateAudioConfig(audio_config, log_cb_);
   }
 
   if (video_config.IsValidConfig()) {
     if (!video_) {
+      media_log_->SetBooleanProperty("found_video_stream", true);
+    }
+    if (!video_ ||
+        video_->video_decoder_config().codec() != video_config.codec()) {
+      media_log_->SetStringProperty("video_codec_name",
+                                    video_config.GetHumanReadableCodecName());
+    }
+
+    if (!video_) {
       video_ = create_demuxer_stream_cb_.Run(DemuxerStream::VIDEO);
 
       if (!video_) {
         DVLOG(1) << "Failed to create a video stream.";
         return false;
       }
 
       if (!frame_processor_->AddTrack(FrameProcessor::kVideoTrackId, video_)) {
         DVLOG(1) << "Failed to add video track to frame processor.";
         return false;
@@ skipping 434 matching lines @@
       buffer = StreamParserBuffer::CreateEOSBuffer();
       break;
   }
 
   base::ResetAndReturn(&read_cb_).Run(status, buffer);
 }
 
 ChunkDemuxer::ChunkDemuxer(const base::Closure& open_cb,
                            const NeedKeyCB& need_key_cb,
                            const LogCB& log_cb,
+                           const scoped_refptr<MediaLog>& media_log,
                            bool splice_frames_enabled)
     : state_(WAITING_FOR_INIT),
       cancel_next_seek_(false),
       host_(NULL),
       open_cb_(open_cb),
       need_key_cb_(need_key_cb),
       enable_text_(false),
       log_cb_(log_cb),
+      media_log_(media_log),
       duration_(kNoTimestamp()),
       user_specified_duration_(-1),
       liveness_(DemuxerStream::LIVENESS_UNKNOWN),
       splice_frames_enabled_(splice_frames_enabled) {
   DCHECK(!open_cb_.is_null());
   DCHECK(!need_key_cb_.is_null());
 }
 
 void ChunkDemuxer::Initialize(
     DemuxerHost* host,
@@ skipping 138 matching lines @@
     source_id_video_ = id;
 
   scoped_ptr<FrameProcessor> frame_processor(
       new FrameProcessor(base::Bind(&ChunkDemuxer::IncreaseDurationIfNecessary,
                          base::Unretained(this))));
 
   scoped_ptr<SourceState> source_state(
       new SourceState(stream_parser.Pass(),
                       frame_processor.Pass(), log_cb_,
                       base::Bind(&ChunkDemuxer::CreateDemuxerStream,
-                                 base::Unretained(this))));
+                                 base::Unretained(this)),
+                      media_log_));
 
   SourceState::NewTextTrackCB new_text_track_cb;
 
   if (enable_text_) {
     new_text_track_cb = base::Bind(&ChunkDemuxer::OnNewTextTrack,
                                    base::Unretained(this));
   }
 
   source_state->Init(
       base::Bind(&ChunkDemuxer::OnSourceInitDone, base::Unretained(this)),
@@ skipping 560 matching lines @@
 }
 
 void ChunkDemuxer::ShutdownAllStreams() {
   for (SourceStateMap::iterator itr = source_state_map_.begin();
        itr != source_state_map_.end(); ++itr) {
     itr->second->Shutdown();
   }
 }
 
 }  // namespace media