WebmMuxer: add Pause()/Resume() methods and internal time-in-pause

media/muxers/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/muxers/webm_muxer.h"
 
 #include "base/bind.h"
 #include "media/audio/audio_parameters.h"
 #include "media/base/limits.h"
 #include "media/base/video_frame.h"
@@ skipping 129 matching lines @@
     encoded_frames_queue_.pop_front();
   }
 
   AddFrame(std::move(encoded_data), video_track_index_, timestamp,
            is_key_frame);
 }
 
 void WebmMuxer::OnEncodedAudio(const media::AudioParameters& params,
                                scoped_ptr<std::string> encoded_data,
                                base::TimeTicks timestamp) {
-  DVLOG(1) << __FUNCTION__ << " - " << encoded_data->size() << "B";
+  DVLOG(2) << __FUNCTION__ << " - " << encoded_data->size() << "B";
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!audio_track_index_) {
     AddAudioTrack(params);
     if (first_frame_timestamp_.is_null())
       first_frame_timestamp_ = timestamp;
   }
 
   // TODO(ajose): Don't drop audio data: http://crbug.com/547948
   // TODO(ajose): Support multiple tracks: http://crbug.com/528523
   if (has_video_ && !video_track_index_) {
     DVLOG(1) << __FUNCTION__ << ": delaying until video track ready.";
     return;
   }
 
   // Dump all saved encoded video frames if any.
   while (!encoded_frames_queue_.empty()) {
     AddFrame(std::move(encoded_frames_queue_.front()->data), video_track_index_,
              encoded_frames_queue_.front()->timestamp,
              encoded_frames_queue_.front()->is_keyframe);
     encoded_frames_queue_.pop_front();
   }
 
   AddFrame(std::move(encoded_data), audio_track_index_, timestamp,
            true /* is_key_frame -- always true for audio */);
 }
 
+void WebmMuxer::Pause() {
+  DVLOG(1) << __FUNCTION__;
+  DCHECK(thread_checker_.CalledOnValidThread());
+  if (!elapsed_time_in_pause_)
+    elapsed_time_in_pause_.reset(new base::ElapsedTimer());
+}
+
+void WebmMuxer::Resume() {
+  DVLOG(1) << __FUNCTION__;
+  DCHECK(thread_checker_.CalledOnValidThread());
+  if (elapsed_time_in_pause_) {
+    total_time_in_pause_ += elapsed_time_in_pause_->Elapsed();
+    elapsed_time_in_pause_.reset();
+  }
+}
+
 void WebmMuxer::AddVideoTrack(const gfx::Size& frame_size, double frame_rate) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_EQ(0u, video_track_index_)
       << "WebmMuxer can only be initialized once.";
 
   video_track_index_ =
       segment_.AddVideoTrack(frame_size.width(), frame_size.height(), 0);
   DCHECK_GT(video_track_index_, 0u);
 
   mkvmuxer::VideoTrack* const video_track =
       reinterpret_cast<mkvmuxer::VideoTrack*>(
           segment_.GetTrackByNumber(video_track_index_));
   DCHECK(video_track);
   video_track->set_codec_id(use_vp9_ ? mkvmuxer::Tracks::kVp9CodecId
                                      : mkvmuxer::Tracks::kVp8CodecId);
   DCHECK_EQ(0ull, video_track->crop_right());
   DCHECK_EQ(0ull, video_track->crop_left());
   DCHECK_EQ(0ull, video_track->crop_top());
   DCHECK_EQ(0ull, video_track->crop_bottom());
 
   video_track->set_frame_rate(frame_rate);
   video_track->set_default_duration(base::Time::kNanosecondsPerSecond /
                                     frame_rate);
   // Segment's timestamps should be in milliseconds, DCHECK it. See
   // http://www.webmproject.org/docs/container/#muxer-guidelines
   DCHECK_EQ(1000000ull, segment_.GetSegmentInfo()->timecode_scale());
 }
 
 void WebmMuxer::AddAudioTrack(const media::AudioParameters& params) {
+  DVLOG(1) << __FUNCTION__ << " " << params.AsHumanReadableString();
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_EQ(0u, audio_track_index_)
       << "WebmMuxer audio can only be initialised once.";
 
   audio_track_index_ =
       segment_.AddAudioTrack(params.sample_rate(), params.channels(), 0);
   DCHECK_GT(audio_track_index_, 0u);
 
   mkvmuxer::AudioTrack* const audio_track =
       reinterpret_cast<mkvmuxer::AudioTrack*>(
@@ skipping 46 matching lines @@
 
 void WebmMuxer::AddFrame(scoped_ptr<std::string> encoded_data,
                          uint8_t track_index,
                          base::TimeTicks timestamp,
                          bool is_key_frame) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!has_video_ || video_track_index_);
   DCHECK(!has_audio_ || audio_track_index_);
 
   most_recent_timestamp_ =
-      std::max(most_recent_timestamp_, timestamp - first_frame_timestamp_);
+      std::max(most_recent_timestamp_,
+               timestamp - total_time_in_pause_ - first_frame_timestamp_);
 
   segment_.AddFrame(reinterpret_cast<const uint8_t*>(encoded_data->data()),
                     encoded_data->size(), track_index,
                     most_recent_timestamp_.InMicroseconds() *
                         base::Time::kNanosecondsPerMicrosecond,
                     is_key_frame);
 }
 
 WebmMuxer::EncodedVideoFrame::EncodedVideoFrame(scoped_ptr<std::string> data,
                                                 base::TimeTicks timestamp,
                                                 bool is_keyframe)
     : data(std::move(data)), timestamp(timestamp), is_keyframe(is_keyframe) {}
 
 WebmMuxer::EncodedVideoFrame::~EncodedVideoFrame() {}
 
 }  // namespace media