MediaRecorderHandler and WebmMuxer: add support for H264.

media/muxers/webm_muxer.cc

 // Copyright 2015 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/muxers/webm_muxer.h"
 
 #include "base/bind.h"
 #include "media/audio/audio_parameters.h"
 #include "media/base/limits.h"
 #include "media/base/video_frame.h"
@@ skipping 50 matching lines @@
   double frame_rate = kDefaultFrameRate;
   if (!video_frame->metadata()->GetDouble(VideoFrameMetadata::FRAME_RATE,
                                           &frame_rate) ||
       frame_rate <= kZeroFrameRate ||
       frame_rate > media::limits::kMaxFramesPerSecond) {
     frame_rate = kDefaultFrameRate;
   }
   return frame_rate;
 }
 
+// TODO(mcasas): Change |kH264CodecId| to "V_MPEG4/ISO/AVC" when
+// https://chromium-review.googlesource.com/340298/ is rolled into Chromium.
+static const char kH264CodecId[] = "";
+
+static const char* MkvCodeIcForMediaVideoCodecId(VideoCodec video_codec) {
+  switch (video_codec) {
+    case kCodecVP8:
+      return mkvmuxer::Tracks::kVp8CodecId;
+    case kCodecVP9:
+      return mkvmuxer::Tracks::kVp9CodecId;
+    case kCodecH264:
+      return kH264CodecId;
+    default:

[emircan, 2016/04/25 19:26:15]

ditto

[mcasas, 2016/04/26 18:13:38]

Can't be done in this case because media::VideoCodec
includes many more codecs than these three.

+      NOTREACHED() << "Unsupported codec " << GetCodecName(video_codec);
+      return "";
+  }
+}
+
 }  // anonymous namespace
 
 WebmMuxer::WebmMuxer(VideoCodec codec,
                      bool has_video,
                      bool has_audio,
                      const WriteDataCB& write_data_callback)
-    : use_vp9_(codec == kCodecVP9),
+    : video_codec_(codec),
       video_track_index_(0),
       audio_track_index_(0),
       has_video_(has_video),
       has_audio_(has_audio),
       write_data_callback_(write_data_callback),
       position_(0) {
   DCHECK(has_video_ || has_audio_);
   DCHECK(!write_data_callback_.is_null());
-  DCHECK(codec == kCodecVP8 || codec == kCodecVP9)
-      << " Only Vp8 and VP9 are supported in WebmMuxer";
+  DCHECK(codec == kCodecVP8 || codec == kCodecVP9 || codec == kCodecH264)
+      << " Unsupported codec: " << GetCodecName(codec);
 
   segment_.Init(this);
   segment_.set_mode(mkvmuxer::Segment::kLive);
   segment_.OutputCues(false);
 
   mkvmuxer::SegmentInfo* const info = segment_.GetSegmentInfo();
   info->set_writing_app("Chrome");
   info->set_muxing_app("Chrome");
 
   // Creation is done on a different thread than main activities.
@@ skipping 102 matching lines @@
       << "WebmMuxer can only be initialized once.";
 
   video_track_index_ =
       segment_.AddVideoTrack(frame_size.width(), frame_size.height(), 0);
   DCHECK_GT(video_track_index_, 0u);
 
   mkvmuxer::VideoTrack* const video_track =
       reinterpret_cast<mkvmuxer::VideoTrack*>(
           segment_.GetTrackByNumber(video_track_index_));
   DCHECK(video_track);
-  video_track->set_codec_id(use_vp9_ ? mkvmuxer::Tracks::kVp9CodecId
-                                     : mkvmuxer::Tracks::kVp8CodecId);
+  video_track->set_codec_id(MkvCodeIcForMediaVideoCodecId(video_codec_));
   DCHECK_EQ(0ull, video_track->crop_right());
   DCHECK_EQ(0ull, video_track->crop_left());
   DCHECK_EQ(0ull, video_track->crop_top());
   DCHECK_EQ(0ull, video_track->crop_bottom());
   DCHECK_EQ(0.0f, video_track->frame_rate());
 
   video_track->set_default_duration(base::Time::kNanosecondsPerSecond /
                                     frame_rate);
   // Segment's timestamps should be in milliseconds, DCHECK it. See
   // http://www.webmproject.org/docs/container/#muxer-guidelines
@@ skipping 78 matching lines @@
 }
 
 WebmMuxer::EncodedVideoFrame::EncodedVideoFrame(scoped_ptr<std::string> data,
                                                 base::TimeTicks timestamp,
                                                 bool is_keyframe)
     : data(std::move(data)), timestamp(timestamp), is_keyframe(is_keyframe) {}
 
 WebmMuxer::EncodedVideoFrame::~EncodedVideoFrame() {}
 
 }  // namespace media