Fix MediaSource renderer to limit memory consumption.

remoting/client/plugin/media_source_video_renderer.cc

 // Copyright 2014 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 "remoting/client/plugin/media_source_video_renderer.h"
 
 #include <string.h>
 
 #include "base/callback_helpers.h"
 #include "base/logging.h"
@@ skipping 17 matching lines @@
   int64_t last_frame_timestamp() { return timecode_ - kFrameIntervalNs; }
 
   // IMkvWriter interface.
   virtual mkvmuxer::int32 Write(const void* buf, mkvmuxer::uint32 len) OVERRIDE;
   virtual mkvmuxer::int64 Position() const OVERRIDE;
   virtual mkvmuxer::int32 Position(mkvmuxer::int64 position) OVERRIDE;
   virtual bool Seekable() const OVERRIDE;
   virtual void ElementStartNotify(mkvmuxer::uint64 element_id,
                                   mkvmuxer::int64 position) OVERRIDE;
 
-  scoped_ptr<DataBuffer> OnVideoFrame(const std::string& video_data);
+  scoped_ptr<DataBuffer> OnVideoFrame(const std::string& video_data,
+                                      bool keyframe);
 
  private:
   webrtc::DesktopSize frame_size_;
   scoped_ptr<DataBuffer> output_data_;
   int64_t position_;
   scoped_ptr<mkvmuxer::Segment> segment_;
   int64_t timecode_;
 };
 
 MediaSourceVideoRenderer::VideoWriter::VideoWriter(
     const webrtc::DesktopSize& frame_size)
     : frame_size_(frame_size),
       position_(0),
       timecode_(0) {
   segment_.reset(new mkvmuxer::Segment());
   segment_->Init(this);
   segment_->set_mode(mkvmuxer::Segment::kLive);
+  segment_->set_max_cluster_duration(0);
+  segment_->set_max_cluster_size(0);

[Jamie, 2014/06/11 21:41:42]

I don't understand what these lines do. Are they covered by the CL description?

[Sergey Ulanov, 2014/06/11 23:41:12]

That was my attempt to workaround crbug.com/382807, but it didn't work (the
muxer still generates new cluster for each keyframe). Removed now. The bug will
be fixed in chrome by this CL: https://codereview.chromium.org/328653002/

 
   // DateUTC is specified in nanoseconds from 0:00 on January 1st, 2001.
   base::Time::Exploded millennium_exploded;
   memset(&millennium_exploded, 0, sizeof(millennium_exploded));
   millennium_exploded.year = 2001;
   millennium_exploded.month = 1;
   millennium_exploded.day_of_month = 1;
   segment_->GetSegmentInfo()->set_date_utc(
       (base::Time::Now() - base::Time::FromUTCExploded(millennium_exploded))
           .InMicroseconds() *
@@ skipping 13 matching lines @@
     crop_bottom = 1;
   }
 
   segment_->AddVideoTrack(width, height, 1);
   mkvmuxer::VideoTrack* video_track =
       reinterpret_cast<mkvmuxer::VideoTrack*>(segment_->GetTrackByNumber(1));
   video_track->set_crop_right(crop_right);
   video_track->set_crop_bottom(crop_bottom);
   video_track->set_frame_rate(base::Time::kNanosecondsPerSecond /
                               kFrameIntervalNs);
-  video_track->set_default_duration(base::Time::kNanosecondsPerSecond);
+  video_track->set_default_duration(kFrameIntervalNs);
   mkvmuxer::SegmentInfo* const info = segment_->GetSegmentInfo();
   info->set_writing_app("ChromotingViewer");
   info->set_muxing_app("ChromotingViewer");
 }
 
 MediaSourceVideoRenderer::VideoWriter::~VideoWriter() {}
 
 mkvmuxer::int32 MediaSourceVideoRenderer::VideoWriter::Write(
     const void* buf,
     mkvmuxer::uint32 len) {
@@ skipping 17 matching lines @@
   return false;
 }
 
 void MediaSourceVideoRenderer::VideoWriter::ElementStartNotify(
     mkvmuxer::uint64 element_id,
     mkvmuxer::int64 position) {
 }
 
 scoped_ptr<MediaSourceVideoRenderer::VideoWriter::DataBuffer>
 MediaSourceVideoRenderer::VideoWriter::OnVideoFrame(
-    const std::string& video_data) {
+    const std::string& video_data,
+    bool keyframe) {
   DCHECK(!output_data_);
 
   output_data_.reset(new DataBuffer());
-  bool first_frame = (timecode_ == 0);
   segment_->AddFrame(reinterpret_cast<const uint8_t*>(video_data.data()),
-                     video_data.size(), 1, timecode_, first_frame);
+                     video_data.size(), 1, timecode_, keyframe);
   timecode_ += kFrameIntervalNs;
   return output_data_.Pass();
 }
 
 MediaSourceVideoRenderer::MediaSourceVideoRenderer(Delegate* delegate)
     : delegate_(delegate),
       latest_sequence_number_(0) {
 }
 
 MediaSourceVideoRenderer::~MediaSourceVideoRenderer() {}
@@ skipping 64 matching lines @@
     // Fallback for the case when the host didn't include the desktop shape.
     desktop_shape =
         webrtc::DesktopRegion(webrtc::DesktopRect::MakeSize(frame_size));
   }
 
   if (!desktop_shape_.Equals(desktop_shape)) {
     desktop_shape_.Swap(&desktop_shape);
     delegate_->OnMediaSourceShape(desktop_shape_);
   }
 
+  // First bit indicates I-frames.

[Jamie, 2014/06/11 21:41:42]

s/I/key/?

[Sergey Ulanov, 2014/06/11 23:41:12]

Done.

+  bool keyframe = (packet->data()[0] & 1) == 0;
+
   scoped_ptr<VideoWriter::DataBuffer> buffer =
-      writer_->OnVideoFrame(packet->data());
-  delegate_->OnMediaSourceData(&(*(buffer->begin())), buffer->size());
+      writer_->OnVideoFrame(packet->data(), keyframe);
+  delegate_->OnMediaSourceData(&(*(buffer->begin())), buffer->size(), keyframe);
 }
 
 }  // namespace remoting