content/renderer/media/media_recorder_handler.cc

   1 // Copyright 2015 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "content/renderer/media/media_recorder_handler.h"
   6
   7 #include "base/bind.h"
   8 #include "base/location.h"
   9 #include "base/logging.h"
  10 #include "content/renderer/media/video_track_recorder.h"
  11 #include "media/base/bind_to_current_loop.h"
  12 #include "media/capture/webm_muxer.h"
  13 #include "third_party/WebKit/public/platform/WebMediaRecorderHandlerClient.h"
  14 #include "third_party/WebKit/public/platform/WebString.h"
  15
  16 namespace content {
  17
  18 MediaRecorderHandler::MediaRecorderHandler()
  19     : recording_(false), client_(nullptr), weak_factory_(this) {
  20   DVLOG(3) << __FUNCTION__;
  21 }
  22
  23 MediaRecorderHandler::~MediaRecorderHandler() {
  24   DCHECK(main_render_thread_checker_.CalledOnValidThread());
  25   // Send a |last_in_slice| to our |client_|.
  26   if (client_)
  27     client_->writeData(nullptr, 0u, true);
  28 }
  29
  30 bool MediaRecorderHandler::canSupportMimeType(
  31     const blink::WebString& mimeType) {
  32   DCHECK(main_render_thread_checker_.CalledOnValidThread());
  33   // TODO(mcasas): For the time being only empty or "video/vp8" are supported.
  34   return mimeType.isEmpty() || mimeType.utf8().compare("video/vp8") == 0;
  35 }
  36
  37 bool MediaRecorderHandler::initialize(
  38     blink::WebMediaRecorderHandlerClient* client,
  39     const blink::WebMediaStream& media_stream,
  40     const blink::WebString& mimeType) {
  41   DCHECK(main_render_thread_checker_.CalledOnValidThread());
  42   if (!canSupportMimeType(mimeType)) {
  43     DLOG(ERROR) << "Can't support type " << mimeType.utf8();
  44     return false;
  45   }
  46   media_stream_ = media_stream;
  47   DCHECK(client);
  48   client_ = client;
  49
  50   return true;
  51 }
  52
  53 bool MediaRecorderHandler::start() {
  54   DCHECK(main_render_thread_checker_.CalledOnValidThread());
  55   DCHECK(!recording_);
  56   return start(0);
  57 }
  58
  59 bool MediaRecorderHandler::start(int timeslice) {
  60   DCHECK(main_render_thread_checker_.CalledOnValidThread());
  61   DCHECK(!recording_);
  62   DCHECK(!media_stream_.isNull());
  63
  64   webm_muxer_.reset(new media::WebmMuxer(media::BindToCurrentLoop(base::Bind(
  65       &MediaRecorderHandler::WriteData, weak_factory_.GetWeakPtr()))));
  66   DCHECK(webm_muxer_);
  67
  68   blink::WebVector<blink::WebMediaStreamTrack> video_tracks;
  69   media_stream_.videoTracks(video_tracks);
  70
  71   if (video_tracks.isEmpty()) {
  72     // TODO(mcasas): Add audio_tracks and update the code in this function
  73     // correspondingly, see http://crbug.com/528519. As of now, only video
  74     // tracks are supported.
  75     LOG(WARNING) << "Recording no video tracks is not implemented";
  76     return false;
  77   }
  78   // TODO(mcasas): The muxer API supports only one video track. Extend it to
  79   // several video tracks, see http://crbug.com/528523.
  80   LOG_IF(WARNING, video_tracks.size() > 1u) << "Recording multiple video"
  81       << " tracks is not implemented.  Only recording first video track.";
  82   const blink::WebMediaStreamTrack& video_track = video_tracks[0];
  83   if (video_track.isNull())
  84     return false;
  85
  86   const VideoTrackRecorder::OnEncodedVideoCB on_encoded_video_cb =
  87       base::Bind(&media::WebmMuxer::OnEncodedVideo,
  88                  base::Unretained(webm_muxer_.get()));
  89
  90   video_recorders_.push_back(new VideoTrackRecorder(video_track,
  91                                                     on_encoded_video_cb));
  92
  93   recording_ = true;
  94   return true;
  95 }
  96
  97 void MediaRecorderHandler::stop() {
  98   DCHECK(main_render_thread_checker_.CalledOnValidThread());
  99   DCHECK(recording_);
 100
 101   recording_ = false;
 102   video_recorders_.clear();
 103   webm_muxer_.reset(NULL);
 104 }
 105
 106 void MediaRecorderHandler::pause() {
 107   DCHECK(main_render_thread_checker_.CalledOnValidThread());
 108   DCHECK(recording_);
 109   recording_ = false;
 110   NOTIMPLEMENTED();
 111 }
 112
 113 void MediaRecorderHandler::resume() {
 114   DCHECK(main_render_thread_checker_.CalledOnValidThread());
 115   DCHECK(!recording_);
 116   recording_ = true;
 117   NOTIMPLEMENTED();
 118 }
 119
 120 void MediaRecorderHandler::WriteData(const base::StringPiece& data) {
 121   DCHECK(main_render_thread_checker_.CalledOnValidThread());
 122   client_->writeData(data.data(), data.size(), false  /* lastInSlice */);
 123 }
 124
 125 void MediaRecorderHandler::OnVideoFrameForTesting(
 126     const scoped_refptr<media::VideoFrame>& frame,
 127     const base::TimeTicks& timestamp) {
 128   for (auto* recorder : video_recorders_)
 129     recorder->OnVideoFrameForTesting(frame, timestamp);
 130 }
 131
 132 }  // namespace content