MediaRecorderHandler and WebmMuxer: add support for H264.

content/renderer/media/media_recorder_handler.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 "content/renderer/media/media_recorder_handler.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/strings/string_tokenizer.h"
 #include "base/strings/string_util.h"
 #include "content/renderer/media/audio_track_recorder.h"
 #include "content/renderer/media/media_stream_audio_track.h"
 #include "content/renderer/media/media_stream_track.h"
-#include "content/renderer/media/video_track_recorder.h"
 #include "content/renderer/media/webrtc_uma_histograms.h"
 #include "media/base/audio_bus.h"
 #include "media/base/audio_parameters.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/mime_util.h"
 #include "media/base/video_frame.h"
 #include "media/muxers/webm_muxer.h"
 #include "third_party/WebKit/public/platform/WebMediaRecorderHandlerClient.h"
 #include "third_party/WebKit/public/platform/WebMediaStreamSource.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 
 using base::TimeDelta;
 using base::TimeTicks;
+using base::ToLowerASCII;
 
 namespace content {
 
+namespace {
+
+media::VideoCodec CodecIdToMediaVideoCodec(VideoTrackRecorder::CodecId id) {
+  switch (id) {
+    case VideoTrackRecorder::CodecId::VP8:
+      return media::kCodecVP8;
+    case VideoTrackRecorder::CodecId::VP9:
+      return media::kCodecVP8;
+#if BUILDFLAG(RTC_USE_H264)
+    case VideoTrackRecorder::CodecId::H264:
+      return media::kCodecH264;
+#endif
+  }
+  NOTREACHED() << "Unsupported codec";
+  return media::kUnknownVideoCodec;
+}
+
+}  // anonymous namespace
+
 MediaRecorderHandler::MediaRecorderHandler()
     : video_bits_per_second_(0),
       audio_bits_per_second_(0),
-      use_vp9_(false),
+      codec_id_(VideoTrackRecorder::CodecId::VP8),
       recording_(false),
       client_(nullptr),
       weak_factory_(this) {}
 
 MediaRecorderHandler::~MediaRecorderHandler() {
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
   // Send a |last_in_slice| to our |client_|.
   if (client_)
     client_->writeData(nullptr, 0u, true);
 }
 
 bool MediaRecorderHandler::canSupportMimeType(
-    const blink::WebString& web_type, const blink::WebString& web_codecs) {
+    const blink::WebString& web_type,
+    const blink::WebString& web_codecs) {
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
   // An empty |web_type| means MediaRecorderHandler can choose its preferred
   // codecs.
   if (web_type.isEmpty())
     return true;
 
   const std::string type(web_type.utf8());
   const bool video = base::EqualsCaseInsensitiveASCII(type, "video/webm");
   const bool audio =
       video ? false : base::EqualsCaseInsensitiveASCII(type, "audio/webm");
   if (!video && !audio)
     return false;
 
   // Both |video| and |audio| support empty |codecs|; |type| == "video" supports
   // vp8, vp9 or opus; |type| = "audio", supports only opus.
   // http://www.webmproject.org/docs/container Sec:"HTML5 Video Type Parameters"
-  static const char* const kVideoCodecs[] = { "vp8", "vp9", "opus" };
+  static const char* const kVideoCodecs[] = { "vp8", "vp9", "h264", "opus" };
   static const char* const kAudioCodecs[] = { "opus" };
   const char* const* codecs = video ? &kVideoCodecs[0] : &kAudioCodecs[0];
   const int codecs_count =
       video ? arraysize(kVideoCodecs) : arraysize(kAudioCodecs);
 
   std::vector<std::string> codecs_list;
   media::ParseCodecString(web_codecs.utf8(), &codecs_list, true /* strip */);
   for (const auto& codec : codecs_list) {
     const auto found = std::find_if(
         &codecs[0], &codecs[codecs_count], [&codec](const char* name) {
@@ skipping 15 matching lines @@
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
   // Save histogram data so we can see how much MediaStream Recorder is used.
   // The histogram counts the number of calls to the JS API.
   UpdateWebRTCMethodCount(WEBKIT_MEDIA_STREAM_RECORDER);
 
   if (!canSupportMimeType(type, codecs)) {
     DLOG(ERROR) << "Can't support " << type.utf8()
                 << ";codecs=" << codecs.utf8();
     return false;
   }
-  use_vp9_ = base::ToLowerASCII(codecs.utf8()).find("vp9") != std::string::npos;
+
+  // Once established that we support the codec(s), hunt then individually.
+  const std::string& codecs_str = ToLowerASCII(codecs.utf8());
+  if (codecs_str.find("vp8") != std::string::npos)
+    codec_id_ = VideoTrackRecorder::CodecId::VP8;
+  else if (codecs_str.find("vp9") != std::string::npos)
+    codec_id_ = VideoTrackRecorder::CodecId::VP9;
+#if BUILDFLAG(RTC_USE_H264)
+  else if (codecs_str.find("h264") != std::string::npos)
+    codec_id_ = VideoTrackRecorder::CodecId::H264;
+#endif
+
   media_stream_ = media_stream;
   DCHECK(client);
   client_ = client;
 
   audio_bits_per_second_ = audio_bits_per_second;
   video_bits_per_second_ = video_bits_per_second;
   return true;
 }
 
 bool MediaRecorderHandler::start() {
@@ skipping 25 matching lines @@
                                 video_tracks[0].isEnabled() &&
                                 video_tracks[0].source().getReadyState() ==
                                     blink::WebMediaStreamSource::ReadyStateLive;
   const bool use_audio_tracks = !audio_tracks.isEmpty() &&
                                 MediaStreamAudioTrack::From(audio_tracks[0]) &&
                                 audio_tracks[0].isEnabled() &&
                                 audio_tracks[0].source().getReadyState() ==
                                     blink::WebMediaStreamSource::ReadyStateLive;
 
   webm_muxer_.reset(new media::WebmMuxer(
-      use_vp9_ ? media::kCodecVP9 : media::kCodecVP8, use_video_tracks,
-      use_audio_tracks, base::Bind(&MediaRecorderHandler::WriteData,
-                                   weak_factory_.GetWeakPtr())));
+      CodecIdToMediaVideoCodec(codec_id_), use_video_tracks, use_audio_tracks,
+      base::Bind(&MediaRecorderHandler::WriteData,
+                 weak_factory_.GetWeakPtr())));
 
   if (use_video_tracks) {
     // TODO(mcasas): The muxer API supports only one video track. Extend it to
     // several video tracks, see http://crbug.com/528523.
     LOG_IF(WARNING, video_tracks.size() > 1u)
         << "Recording multiple video tracks is not implemented. "
         << "Only recording first video track.";
     const blink::WebMediaStreamTrack& video_track = video_tracks[0];
     if (video_track.isNull())
       return false;
 
     const VideoTrackRecorder::OnEncodedVideoCB on_encoded_video_cb =
         media::BindToCurrentLoop(base::Bind(
             &MediaRecorderHandler::OnEncodedVideo, weak_factory_.GetWeakPtr()));
 
     video_recorders_.push_back(new VideoTrackRecorder(
-        use_vp9_ ? VideoTrackRecorder::CodecId::VP9
-                 : VideoTrackRecorder::CodecId::VP8,
-        video_track, on_encoded_video_cb, video_bits_per_second_));
+        codec_id_, video_track, on_encoded_video_cb, video_bits_per_second_));
   }
 
   if (use_audio_tracks) {
     // TODO(ajose): The muxer API supports only one audio track. Extend it to
     // several tracks.
     LOG_IF(WARNING, audio_tracks.size() > 1u)
         << "Recording multiple audio"
         << " tracks is not implemented.  Only recording first audio track.";
     const blink::WebMediaStreamTrack& audio_track = audio_tracks[0];
     if (audio_track.isNull())
@@ skipping 95 matching lines @@
     recorder->OnData(audio_bus, timestamp);
 }
 
 void MediaRecorderHandler::SetAudioFormatForTesting(
     const media::AudioParameters& params) {
   for (auto* recorder : audio_recorders_)
     recorder->OnSetFormat(params);
 }
 
 }  // namespace content