media/capture: Adding WebmMuxer class and unittests

media/capture/webm_muxer.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 "media/capture/webm_muxer.h"
+
+#include <limits>
+
+namespace media {
+
+// Template to +1 a non-negative Natural number to make a strictly positive one.
+template <typename NonNegativeNaturalType>
+class PositiveInteger{
+ public:
+  explicit PositiveInteger(NonNegativeNaturalType value)
+      : value_(value + static_cast<NonNegativeNaturalType>(1)) {
+    static_assert(std::numeric_limits<NonNegativeNaturalType>::is_integer &&
+                     !std::numeric_limits<NonNegativeNaturalType>::is_signed,
+                  "NonNegativeNaturalType must be an unsigned integer type");
+  }
+  NonNegativeNaturalType Value() const { return value_; }
+
+ private:
+  const NonNegativeNaturalType value_;
+
+  DISALLOW_IMPLICIT_CONSTRUCTORS(PositiveInteger);
+};
+
+WebmMuxer::WebmMuxer(const WriteDataCB& write_data_callback)
+    : write_data_callback_(write_data_callback),
+      position_(0),
+      segment_(new mkvmuxer::Segment()) {
+  DVLOG(2) << __FUNCTION__;
+  DCHECK(thread_checker_.CalledOnValidThread());
+  segment_->Init(this);
+  segment_->set_mode(mkvmuxer::Segment::kLive);
+  segment_->OutputCues(false);
+
+  mkvmuxer::SegmentInfo* const info = segment_->GetSegmentInfo();
+  info->set_writing_app("Chrome");
+  info->set_muxing_app("Chrome");
+}
+
+WebmMuxer::~WebmMuxer() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DVLOG(2) << __FUNCTION__;
+  segment_->Finalize();
+}
+
+void WebmMuxer::OnEncodedVideo(uint32_t track_number,
+                               const std::string& encoded_data,
+                               const base::TimeDelta& timedelta_us,
+                               bool keyframe,
+                               const gfx::Size& frame_size,
+                               double frame_rate) {
+  DVLOG(2) << __FUNCTION__;
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  // |track_number|, a caller-side identifier, cannot be zero (!), see
+  // http://www.matroska.org/technical/specs/index.html#Tracks
+  const PositiveInteger<uint32_t> nonzero_track_number(track_number);
+
+  // Add the video track the first time we see it.
+  if (!segment_->GetTrackByNumber(nonzero_track_number.Value()))
+    AddVideoTrack(nonzero_track_number.Value(), frame_size, frame_rate);
+  DCHECK(segment_->GetTrackByNumber(nonzero_track_number.Value()));
+
+  segment_->AddFrame(reinterpret_cast<const uint8_t*>(encoded_data.data()),
+                     encoded_data.size(),
+                     nonzero_track_number.Value(),
+                     timedelta_us.InMicroseconds(),
+                     keyframe);
+}
+
+bool WebmMuxer::AddVideoTrack(uint32_t track_number,
+                              const gfx::Size& frame_size,
+                              double frame_rate) {
+  DVLOG(2) << "AddVideoTrack: " << frame_size.ToString() << "@"
+           << frame_rate << "fps, number: " << track_number;
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK_GT(track_number, 0u) << "Track number must be (strictly) positive.";
+
+  segment_->AddVideoTrack(frame_size.width(),
+                          frame_size.height(),
+                          track_number);
+  mkvmuxer::VideoTrack* const video_track =
+      reinterpret_cast<mkvmuxer::VideoTrack*>(
+          segment_->GetTrackByNumber(track_number));
+  DCHECK(video_track);
+  video_track->set_codec_id(mkvmuxer::Tracks::kVp8CodecId);
+  DCHECK_EQ(video_track->crop_right(), 0ull);
+  DCHECK_EQ(video_track->crop_left(), 0ull);
+  DCHECK_EQ(video_track->crop_top(), 0ull);
+  DCHECK_EQ(video_track->crop_bottom(), 0ull);
+
+  video_track->set_frame_rate(frame_rate);
+  video_track->set_default_duration(base::Time::kMicrosecondsPerSecond /
+                                    frame_rate);
+  // Change segment's timestamps to microseconds instead of milliseconds:
+  // http://matroska.org/technical/specs/index.html#TimecodeScale
+  segment_->GetSegmentInfo()->set_timecode_scale(1000000000ull);

[miu, 2015/07/17 22:23:18]

IIUC, this be 1000 instead?  Better yet: base::Time::kNanosecondsPerMicrosecond.

[mcasas, 2015/07/18 00:05:22]

Yeah, done.

+  return true;
+}
+
+mkvmuxer::int32 WebmMuxer::Write(const void* buf, mkvmuxer::uint32 len) {
+  DVLOG(3) << __FUNCTION__ << " length=" << len;
+  DCHECK(thread_checker_.CalledOnValidThread());
+  write_data_callback_.Run(static_cast<const char*>(buf), len);
+  position_ += len;
+  return 0;
+}
+
+mkvmuxer::int64 WebmMuxer::Position() const {
+  return position_.ValueOrDie();
+}
+
+mkvmuxer::int32 WebmMuxer::Position(mkvmuxer::int64 position) {
+  // The stream is not Seekable() so indicate we cannot set the position.
+  return -1;
+}
+
+bool WebmMuxer::Seekable() const {
+  return false;
+}
+
+void WebmMuxer::ElementStartNotify(mkvmuxer::uint64 element_id,
+                                   mkvmuxer::int64 position) {
+  // This method gets pinged before items are sent to |write_data_callback_|.
+  DCHECK_GE(position, position_.ValueOrDefault(0))
+      << "Can't go back in a Live Mkv stream.";
+}
+
+}  // namespace media