MediaRecorder: handle libwebm::Segment::AddFrame() errors and wire up to Blink

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 <algorithm>
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
@@ skipping 88 matching lines @@
 WebmMuxer::WebmMuxer(VideoCodec codec,
                      bool has_video,
                      bool has_audio,
                      const WriteDataCB& write_data_callback)
     : video_codec_(codec),
       video_track_index_(0),
       audio_track_index_(0),
       has_video_(has_video),
       has_audio_(has_audio),
       write_data_callback_(write_data_callback),
-      position_(0) {
+      position_(0),
+      force_one_libwebm_error_(false) {
   DCHECK(has_video_ || has_audio_);
   DCHECK(!write_data_callback_.is_null());
   DCHECK(codec == kCodecVP8 || codec == kCodecVP9 || codec == kCodecH264)
       << " Unsupported codec: " << GetCodecName(codec);
 
   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");
 
   // Creation is done on a different thread than main activities.
   thread_checker_.DetachFromThread();
 }
 
 WebmMuxer::~WebmMuxer() {
   // No need to segment_.Finalize() since is not Seekable(), i.e. a live
   // stream, but is a good practice.
   DCHECK(thread_checker_.CalledOnValidThread());
   segment_.Finalize();
 }
 
-void WebmMuxer::OnEncodedVideo(const VideoParameters& params,
+bool WebmMuxer::OnEncodedVideo(const VideoParameters& params,
                                std::unique_ptr<std::string> encoded_data,
                                base::TimeTicks timestamp,
                                bool is_key_frame) {
   DVLOG(1) << __func__ << " - " << encoded_data->size() << "B";
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!video_track_index_) {
     // |track_index_|, cannot be zero (!), initialize WebmMuxer in that case.
     // http://www.matroska.org/technical/specs/index.html#Tracks
     AddVideoTrack(params.visible_rect_size, GetFrameRate(params));
     if (first_frame_timestamp_video_.is_null())
       first_frame_timestamp_video_ = timestamp;
   }
 
   // TODO(ajose): Support multiple tracks: http://crbug.com/528523
   if (has_audio_ && !audio_track_index_) {
     DVLOG(1) << __func__ << ": delaying until audio track ready.";
     if (is_key_frame)  // Upon Key frame reception, empty the encoded queue.
       encoded_frames_queue_.clear();
 
     encoded_frames_queue_.push_back(base::MakeUnique<EncodedVideoFrame>(
         std::move(encoded_data), timestamp, is_key_frame));
-    return;
+    return true;
   }
 
-  // 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 - first_frame_timestamp_video_,
-        encoded_frames_queue_.front()->is_keyframe);
-    encoded_frames_queue_.pop_front();
-  }
+  // Any saved encoded video frames must have been dumped in OnEncodedAudio();
+  DCHECK(encoded_frames_queue_.empty());
 
-  AddFrame(std::move(encoded_data), video_track_index_,
-           timestamp - first_frame_timestamp_video_, is_key_frame);
+  return AddFrame(std::move(encoded_data), video_track_index_,
+                  timestamp - first_frame_timestamp_video_, is_key_frame);
 }
 
-void WebmMuxer::OnEncodedAudio(const media::AudioParameters& params,
+bool WebmMuxer::OnEncodedAudio(const media::AudioParameters& params,
                                std::unique_ptr<std::string> encoded_data,
                                base::TimeTicks timestamp) {
   DVLOG(2) << __func__ << " - " << encoded_data->size() << "B";
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!audio_track_index_) {
     AddAudioTrack(params);
     if (first_frame_timestamp_audio_.is_null())
       first_frame_timestamp_audio_ = 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) << __func__ << ": delaying until video track ready.";
-    return;
+    return true;
   }
 
   // Dump all saved encoded video frames if any.
   while (!encoded_frames_queue_.empty()) {
-    AddFrame(
-        std::move(encoded_frames_queue_.front()->data), video_track_index_,
+    const bool res = AddFrame(
+        base::MakeUnique<std::string>(*encoded_frames_queue_.front()->data),
+        video_track_index_,
         encoded_frames_queue_.front()->timestamp - first_frame_timestamp_video_,
         encoded_frames_queue_.front()->is_keyframe);
+    if (!res)
+      return false;
     encoded_frames_queue_.pop_front();
   }
 
-  AddFrame(std::move(encoded_data), audio_track_index_,
-           timestamp - first_frame_timestamp_audio_,
-           true /* is_key_frame -- always true for audio */);
+  return AddFrame(std::move(encoded_data), audio_track_index_,
+                  timestamp - first_frame_timestamp_audio_,
+                  true /* is_key_frame -- always true for audio */);
 }
 
 void WebmMuxer::Pause() {
   DVLOG(1) << __func__;
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!elapsed_time_in_pause_)
     elapsed_time_in_pause_.reset(new base::ElapsedTimer());
 }
 
 void WebmMuxer::Resume() {
@@ skipping 88 matching lines @@
   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 WebM stream.";
 }
 
-void WebmMuxer::AddFrame(std::unique_ptr<std::string> encoded_data,
+bool WebmMuxer::AddFrame(std::unique_ptr<std::string> encoded_data,
                          uint8_t track_index,
                          base::TimeDelta 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 - total_time_in_pause_);
 
-  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);
+  if (force_one_libwebm_error_) {
+    DVLOG(1) << "Forcing a libwebm error";
+    force_one_libwebm_error_ = false;
+    return false;
+  }
+
+  DCHECK(encoded_data->data());
+  return 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(
     std::unique_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