MediaRecorder: support recording with no multiplexing

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"
@@ skipping 29 matching lines @@
       return media::kCodecVP8;
     case VideoTrackRecorder::CodecId::VP9:
       return media::kCodecVP9;
     case VideoTrackRecorder::CodecId::H264:
       return media::kCodecH264;
   }
   NOTREACHED() << "Unsupported codec";
   return media::kUnknownVideoCodec;
 }
 
+// Extracts the MIME subtype from an incoming |content_type|, or empty.
+std::string getSubtypeFromContentType(const std::string& content_type) {
+  base::StringTokenizer web_type_tokens(content_type, "/");
+  if (!web_type_tokens.GetNext() || !web_type_tokens.GetNext())
+    return std::string();
+  return web_type_tokens.token();
+}
+
+bool findCodecInList(const std::string& codec,
+                     const char* const* codecs,
+                     size_t codecs_count) {
+  auto* const* found = std::find_if(
+      &codecs[0], &codecs[codecs_count], [&codec](const char* name) {
+        return base::EqualsCaseInsensitiveASCII(codec, name);
+      });
+  return found != &codecs[codecs_count];
+}
+
 }  // anonymous namespace
 
 MediaRecorderHandler::MediaRecorderHandler()
     : video_bits_per_second_(0),
       audio_bits_per_second_(0),
+      use_container_(true),
       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) {
   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 video =
+      base::StartsWith(type, "video/", base::CompareCase::INSENSITIVE_ASCII);
   const bool audio =
-      video ? false : base::EqualsCaseInsensitiveASCII(type, "audio/webm");
+      video ? false : base::StartsWith(type, "audio/",
+                                       base::CompareCase::INSENSITIVE_ASCII);
   if (!video && !audio)
     return false;
 
   // Both |video| and |audio| support empty |codecs|; |type| == "video" supports
-  // vp8, vp9 or opus; |type| = "audio", supports only opus.
+  // vp8, vp9, H264 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", "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);
 
+  // Check for the container or the codec following video/ or audio/. "webm"
+  // container is supported,; so are any of the |codecs| as non-contained.
+  const std::string mime_subtype = getSubtypeFromContentType(type);
+  if (!base::EqualsCaseInsensitiveASCII(mime_subtype, "webm"))
+    return findCodecInList(mime_subtype, codecs, codecs_count);
+
   std::vector<std::string> codecs_list;
   media::ParseCodecString(web_codecs.utf8(), &codecs_list, true /* strip */);
   for (const auto& codec : codecs_list) {
-    auto* const* found = std::find_if(
-        &codecs[0], &codecs[codecs_count], [&codec](const char* name) {
-          return base::EqualsCaseInsensitiveASCII(codec, name);
-        });
-    if (found == &codecs[codecs_count])
+    if (!findCodecInList(codec, codecs, codecs_count))
       return false;
   }
   return true;
 }
 
 bool MediaRecorderHandler::initialize(
     blink::WebMediaRecorderHandlerClient* client,
     const blink::WebMediaStream& media_stream,
     const blink::WebString& type,
     const blink::WebString& codecs,
     int32_t audio_bits_per_second,
     int32_t video_bits_per_second) {
   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;
   }
 
+  const std::string mime_subtype = getSubtypeFromContentType(type.utf8());
+  use_container_ =
+      type.isEmpty() || base::EqualsCaseInsensitiveASCII(mime_subtype, "webm");
+
+  const std::string& codecs_str =
+      use_container_ ? ToLowerASCII(codecs.utf8()) : ToLowerASCII(mime_subtype);
+
   // 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;
@@ skipping 38 matching lines @@
       !audio_tracks.isEmpty() && MediaStreamAudioTrack::From(audio_tracks[0]) &&
       audio_tracks[0].isEnabled() &&
       audio_tracks[0].source().getReadyState() !=
           blink::WebMediaStreamSource::ReadyStateEnded;
 
   if (!use_video_tracks && !use_audio_tracks) {
     LOG(WARNING) << __func__ << ": no tracks to be recorded.";
     return false;
   }
 
-  webm_muxer_.reset(new media::WebmMuxer(
-      CodecIdToMediaVideoCodec(codec_id_), use_video_tracks, use_audio_tracks,
-      base::Bind(&MediaRecorderHandler::WriteData,
-                 weak_factory_.GetWeakPtr())));
+  if (use_container_) {
+    webm_muxer_.reset(new media::WebmMuxer(
+        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;
@@ skipping 40 matching lines @@
 }
 
 void MediaRecorderHandler::pause() {
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
   DCHECK(recording_);
   recording_ = false;
   for (auto* video_recorder : video_recorders_)
     video_recorder->Pause();
   for (auto* audio_recorder : audio_recorders_)
     audio_recorder->Pause();
-  webm_muxer_->Pause();
+  if (webm_muxer_)
+    webm_muxer_->Pause();
 }
 
 void MediaRecorderHandler::resume() {
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
   DCHECK(!recording_);
   recording_ = true;
   for (auto* video_recorder : video_recorders_)
     video_recorder->Resume();
   for (auto* audio_recorder : audio_recorders_)
     audio_recorder->Resume();
-  webm_muxer_->Resume();
+  if (webm_muxer_)
+    webm_muxer_->Resume();
 }
 
 void MediaRecorderHandler::OnEncodedVideo(
     const scoped_refptr<media::VideoFrame>& video_frame,
     std::unique_ptr<std::string> encoded_data,
     TimeTicks timestamp,
     bool is_key_frame) {
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
-  if (!webm_muxer_)
-    return;
-  webm_muxer_->OnEncodedVideo(video_frame, std::move(encoded_data), timestamp,
-                              is_key_frame);
+  if (webm_muxer_) {
+    return webm_muxer_->OnEncodedVideo(video_frame, std::move(encoded_data),
+                                       timestamp, is_key_frame);
+  }
+  DCHECK(!use_container_);
+  WriteData(base::StringPiece(*encoded_data.get()));
 }
 
 void MediaRecorderHandler::OnEncodedAudio(
     const media::AudioParameters& params,
     std::unique_ptr<std::string> encoded_data,
     base::TimeTicks timestamp) {
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
   if (webm_muxer_)
     webm_muxer_->OnEncodedAudio(params, std::move(encoded_data), timestamp);
 }
@@ skipping 28 matching lines @@
     recorder->OnData(audio_bus, timestamp);
 }
 
 void MediaRecorderHandler::SetAudioFormatForTesting(
     const media::AudioParameters& params) {
   for (auto* recorder : audio_recorders_)
     recorder->OnSetFormat(params);
 }
 
 }  // namespace content