[Experimental] MediaStreamRecorder playground

media/filters/webm_muxer.cc

Index: media/filters/webm_muxer.cc
diff --git a/media/filters/webm_muxer.cc b/media/filters/webm_muxer.cc
new file mode 100644
index 0000000000000000000000000000000000000000..2acdd3e476428426c1358d95d52fd82ab7ccd628
--- /dev/null
+++ b/media/filters/webm_muxer.cc
@@ -0,0 +1,118 @@
+// 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 "media/filters/webm_muxer.h"
+
+#include "base/time/time.h"
+
+namespace media {
+
+WebmMuxer::WebmMuxer(const WriteDataCB& write_data_callback)
+    : write_data_callback_(write_data_callback),
+      time_start_(base::TimeTicks::Now()),
+      position_(0),
+      segment_(new mkvmuxer::Segment()) {
+  DVLOG(3) << __FUNCTION__;
+  DCHECK(thread_checker_.CalledOnValidThread());
+  segment_->Init(this);
+  segment_->set_mode(mkvmuxer::Segment::kLive);
+
+  // DateUTC is specified in nanoseconds from 0:00 on January 1st, 2001.
+  base::Time::Exploded 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() *
+      base::Time::kNanosecondsPerMicrosecond);
+
+  mkvmuxer::SegmentInfo* const info = segment_->GetSegmentInfo();
+  info->set_writing_app("Chrome");
+  info->set_muxing_app("Chrome");
+}
+
+WebmMuxer::~WebmMuxer() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DVLOG(3) << __FUNCTION__;
+}
+
+void WebmMuxer::OnEncodedVideo(int track_index,
+                               const std::string& encoded_data,
+                               const base::TimeTicks& timestamp,
+                               bool keyframe,
+                               const gfx::Size& frame_size,
+                               double frame_rate) {
+  DVLOG(3) << __FUNCTION__;
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  const int track_index_starting_from_one = track_index + 1;
+
+  if (std::find(track_indexes_.begin(), track_indexes_.end(),
+                track_index_starting_from_one) == track_indexes_.end()) {
+    AddVideoTrack(frame_size, frame_rate, track_index_starting_from_one);
+    track_indexes_.push_back(track_index_starting_from_one);
+  }
+
+  const int64 time_code = (timestamp - time_start_).InMicroseconds() *
+                          base::Time::kNanosecondsPerMicrosecond;
+  segment_->AddFrame(reinterpret_cast<const uint8_t*>(encoded_data.data()),
+                     encoded_data.size(),
+                     track_index_starting_from_one,
+                     time_code,
+                     keyframe);
+
+  DVLOG(3) << __FUNCTION__ << " length=" << encoded_data.size()
+           << (keyframe ? " keyframe" : "") << ", time_code=" << time_code;
+}
+
+bool WebmMuxer::AddVideoTrack(const gfx::Size& frame_size,
+                              double frame_rate,
+                              int track_index_starting_from_one) {
+  DVLOG(3) << __FUNCTION__ << " size=" << frame_size.ToString() << " "
+           << frame_rate << "fps, index: " << track_index_starting_from_one;
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  segment_->AddVideoTrack(frame_size.width(), frame_size.height(),
+                          track_index_starting_from_one);
+  mkvmuxer::VideoTrack* video_track = reinterpret_cast<mkvmuxer::VideoTrack*>(
+      segment_->GetTrackByNumber(track_index_starting_from_one));
+
+  video_track->set_codec_id(mkvmuxer::Tracks::kVp8CodecId);
+  video_track->set_crop_right(0);
+  video_track->set_crop_bottom(0);
+  video_track->set_frame_rate(frame_rate);
+  video_track->set_default_duration(33);  // kFrameIntervalNs / 3);
+
+  return true;
+}
+
+mkvmuxer::int32 WebmMuxer::Write(const void* buf, mkvmuxer::uint32 len) {
+  DVLOG(3) << __FUNCTION__ << " length=" << len;
+  DCHECK(thread_checker_.CalledOnValidThread());
+  // TODO(mcasas): Last parameter is |last_in_slice|, how to calculate it?
+  write_data_callback_.Run(static_cast<const char*>(buf), len, false);
+  position_ += len;
+  return 0;
+}
+
+mkvmuxer::int64 WebmMuxer::Position() const {
+  return position_;
+}
+
+mkvmuxer::int32 WebmMuxer::Position(mkvmuxer::int64 position) {
+  // NOTREACHED();
+  return -1;
+}
+
+bool WebmMuxer::Seekable() const {
+  return false;
+}
+
+void WebmMuxer::ElementStartNotify(mkvmuxer::uint64 element_id,
+                                   mkvmuxer::int64 position) {
+  // NOTIMPLEMENTED();
+}
+
+}  // namespace media