remoting/client/plugin/media_source_video_renderer.cc

   1 // Copyright 2014 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 "remoting/client/plugin/media_source_video_renderer.h"
   6
   7 #include <string.h>
   8
   9 #include "base/callback_helpers.h"
  10 #include "base/logging.h"
  11 #include "base/time/time.h"
  12 #include "remoting/proto/video.pb.h"
  13 #include "remoting/protocol/session_config.h"
  14 #include "third_party/libwebm/source/mkvmuxer.hpp"
  15
  16 namespace remoting {
  17
  18 static int kFrameIntervalNs = 1000000;
  19
  20 class MediaSourceVideoRenderer::VideoWriter : public mkvmuxer::IMkvWriter {
  21  public:
  22   typedef std::vector<uint8_t> DataBuffer;
  23
  24   VideoWriter(const webrtc::DesktopSize& frame_size, const char* codec_id);
  25   ~VideoWriter() override;
  26
  27   const webrtc::DesktopSize& size() { return frame_size_; }
  28   int64_t last_frame_timestamp() { return timecode_ - kFrameIntervalNs; }
  29
  30   // IMkvWriter interface.
  31   mkvmuxer::int32 Write(const void* buf, mkvmuxer::uint32 len) override;
  32   mkvmuxer::int64 Position() const override;
  33   mkvmuxer::int32 Position(mkvmuxer::int64 position) override;
  34   bool Seekable() const override;
  35   void ElementStartNotify(mkvmuxer::uint64 element_id,
  36                           mkvmuxer::int64 position) override;
  37
  38   scoped_ptr<DataBuffer> OnVideoFrame(const std::string& video_data,
  39                                       bool keyframe);
  40
  41  private:
  42   webrtc::DesktopSize frame_size_;
  43   const char* codec_id_;
  44
  45   scoped_ptr<DataBuffer> output_data_;
  46   int64_t position_;
  47   scoped_ptr<mkvmuxer::Segment> segment_;
  48   int64_t timecode_;
  49 };
  50
  51 MediaSourceVideoRenderer::VideoWriter::VideoWriter(
  52     const webrtc::DesktopSize& frame_size,
  53     const char* codec_id)
  54     : frame_size_(frame_size),
  55       codec_id_(codec_id),
  56       position_(0),
  57       timecode_(0) {
  58   segment_.reset(new mkvmuxer::Segment());
  59   segment_->Init(this);
  60   segment_->set_mode(mkvmuxer::Segment::kLive);
  61
  62   // DateUTC is specified in nanoseconds from 0:00 on January 1st, 2001.
  63   base::Time::Exploded millennium_exploded;
  64   memset(&millennium_exploded, 0, sizeof(millennium_exploded));
  65   millennium_exploded.year = 2001;
  66   millennium_exploded.month = 1;
  67   millennium_exploded.day_of_month = 1;
  68   segment_->GetSegmentInfo()->set_date_utc(
  69       (base::Time::Now() - base::Time::FromUTCExploded(millennium_exploded))
  70           .InMicroseconds() *
  71       base::Time::kNanosecondsPerMicrosecond);
  72
  73   uint64 crop_right = 0;
  74   int width = frame_size_.width();
  75   if (width % 2 == 1) {
  76     ++width;
  77     crop_right = 1;
  78   }
  79
  80   uint64 crop_bottom = 0;
  81   int height = frame_size_.height();
  82   if (height % 2 == 1) {
  83     ++height;
  84     crop_bottom = 1;
  85   }
  86
  87   segment_->AddVideoTrack(width, height, 1);
  88   mkvmuxer::VideoTrack* video_track =
  89       reinterpret_cast<mkvmuxer::VideoTrack*>(segment_->GetTrackByNumber(1));
  90   video_track->set_codec_id(codec_id_);
  91   video_track->set_crop_right(crop_right);
  92   video_track->set_crop_bottom(crop_bottom);
  93   video_track->set_frame_rate(base::Time::kNanosecondsPerSecond /
  94                               kFrameIntervalNs);
  95   video_track->set_default_duration(kFrameIntervalNs);
  96   mkvmuxer::SegmentInfo* const info = segment_->GetSegmentInfo();
  97   info->set_writing_app("ChromotingViewer");
  98   info->set_muxing_app("ChromotingViewer");
  99 }
 100
 101 MediaSourceVideoRenderer::VideoWriter::~VideoWriter() {}
 102
 103 mkvmuxer::int32 MediaSourceVideoRenderer::VideoWriter::Write(
 104     const void* buf,
 105     mkvmuxer::uint32 len) {
 106   output_data_->insert(output_data_->end(),
 107                        reinterpret_cast<const char*>(buf),
 108                        reinterpret_cast<const char*>(buf) + len);
 109   position_ += len;
 110   return 0;
 111 }
 112
 113 mkvmuxer::int64 MediaSourceVideoRenderer::VideoWriter::Position() const {
 114   return position_;
 115 }
 116
 117 mkvmuxer::int32 MediaSourceVideoRenderer::VideoWriter::Position(
 118     mkvmuxer::int64 position) {
 119   return -1;
 120 }
 121
 122 bool MediaSourceVideoRenderer::VideoWriter::Seekable() const {
 123   return false;
 124 }
 125
 126 void MediaSourceVideoRenderer::VideoWriter::ElementStartNotify(
 127     mkvmuxer::uint64 element_id,
 128     mkvmuxer::int64 position) {
 129 }
 130
 131 scoped_ptr<MediaSourceVideoRenderer::VideoWriter::DataBuffer>
 132 MediaSourceVideoRenderer::VideoWriter::OnVideoFrame(
 133     const std::string& video_data,
 134     bool keyframe) {
 135   DCHECK(!output_data_);
 136
 137   output_data_.reset(new DataBuffer());
 138   segment_->AddFrame(reinterpret_cast<const uint8_t*>(video_data.data()),
 139                      video_data.size(), 1, timecode_, keyframe);
 140   timecode_ += kFrameIntervalNs;
 141   return output_data_.Pass();
 142 }
 143
 144 MediaSourceVideoRenderer::MediaSourceVideoRenderer(Delegate* delegate)
 145     : delegate_(delegate),
 146       codec_id_(mkvmuxer::Tracks::kVp8CodecId),
 147       latest_sequence_number_(0) {
 148 }
 149
 150 MediaSourceVideoRenderer::~MediaSourceVideoRenderer() {}
 151
 152 void MediaSourceVideoRenderer::Initialize(
 153     const protocol::SessionConfig& config) {
 154   switch (config.video_config().codec) {
 155     case protocol::ChannelConfig::CODEC_VP8:
 156       format_string_ = "video/webm; codecs=\"vp8\"";
 157       codec_id_ = mkvmuxer::Tracks::kVp8CodecId;
 158       break;
 159     case protocol::ChannelConfig::CODEC_VP9:
 160       format_string_ = "video/webm; codecs=\"vp9\"";
 161       codec_id_ = mkvmuxer::Tracks::kVp9CodecId;
 162       break;
 163     default:
 164       NOTREACHED();
 165   }
 166 }
 167
 168 ChromotingStats* MediaSourceVideoRenderer::GetStats() {
 169   return &stats_;
 170 }
 171
 172 void MediaSourceVideoRenderer::ProcessVideoPacket(
 173     scoped_ptr<VideoPacket> packet,
 174     const base::Closure& done) {
 175   base::ScopedClosureRunner done_runner(done);
 176
 177   // Don't need to do anything if the packet is empty. Host sends empty video
 178   // packets when the screen is not changing.
 179   if (!packet->data().size())
 180     return;
 181
 182   // Update statistics.
 183   stats_.video_frame_rate()->Record(1);
 184   stats_.video_bandwidth()->Record(packet->data().size());
 185   if (packet->has_capture_time_ms())
 186     stats_.video_capture_ms()->Record(packet->capture_time_ms());
 187   if (packet->has_encode_time_ms())
 188     stats_.video_encode_ms()->Record(packet->encode_time_ms());
 189   if (packet->has_client_sequence_number() &&
 190       packet->client_sequence_number() > latest_sequence_number_) {
 191     latest_sequence_number_ = packet->client_sequence_number();
 192     base::TimeDelta round_trip_latency =
 193         base::Time::Now() -
 194         base::Time::FromInternalValue(packet->client_sequence_number());
 195     stats_.round_trip_ms()->Record(round_trip_latency.InMilliseconds());
 196   }
 197
 198   bool media_source_needs_reset = false;
 199
 200   webrtc::DesktopSize frame_size(packet->format().screen_width(),
 201                                  packet->format().screen_height());
 202   if (!writer_ ||
 203       (!writer_->size().equals(frame_size) && !frame_size.is_empty())) {
 204     media_source_needs_reset = true;
 205     writer_.reset(new VideoWriter(frame_size, codec_id_));
 206     delegate_->OnMediaSourceReset(format_string_);
 207   }
 208
 209   webrtc::DesktopVector frame_dpi(packet->format().x_dpi(),
 210                                   packet->format().y_dpi());
 211   if (media_source_needs_reset || !frame_dpi_.equals(frame_dpi)) {
 212     frame_dpi_ = frame_dpi;
 213     delegate_->OnMediaSourceSize(frame_size, frame_dpi);
 214   }
 215
 216   // Update the desktop shape region.
 217   webrtc::DesktopRegion desktop_shape;
 218   if (packet->has_use_desktop_shape()) {
 219     for (int i = 0; i < packet->desktop_shape_rects_size(); ++i) {
 220       Rect remoting_rect = packet->desktop_shape_rects(i);
 221       desktop_shape.AddRect(webrtc::DesktopRect::MakeXYWH(
 222           remoting_rect.x(), remoting_rect.y(),
 223           remoting_rect.width(), remoting_rect.height()));
 224     }
 225   } else {
 226     // Fallback for the case when the host didn't include the desktop shape.
 227     desktop_shape =
 228         webrtc::DesktopRegion(webrtc::DesktopRect::MakeSize(frame_size));
 229   }
 230
 231   if (!desktop_shape_.Equals(desktop_shape)) {
 232     desktop_shape_.Swap(&desktop_shape);
 233     delegate_->OnMediaSourceShape(desktop_shape_);
 234   }
 235
 236   // First bit is set to 0 for key frames.
 237   bool keyframe = (packet->data()[0] & 1) == 0;
 238
 239   scoped_ptr<VideoWriter::DataBuffer> buffer =
 240       writer_->OnVideoFrame(packet->data(), keyframe);
 241   delegate_->OnMediaSourceData(&(*(buffer->begin())), buffer->size(), keyframe);
 242 }
 243
 244 }  // namespace remoting