Handle HW encoder errors in VideoTrackRecorder

content/renderer/media_recorder/video_track_recorder.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 "content/renderer/media_recorder/video_track_recorder.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 395 matching lines @@
 }
 
 // Class encapsulating VideoEncodeAccelerator interactions.
 // This class is created and destroyed in its owner thread. All other methods
 // operate on the task runner pointed by GpuFactories.
 class VEAEncoder final : public VideoTrackRecorder::Encoder,
                          public media::VideoEncodeAccelerator::Client {
  public:
   VEAEncoder(
       const VideoTrackRecorder::OnEncodedVideoCB& on_encoded_video_callback,
+      const VideoTrackRecorder::OnErrorCB& on_error_callback,
       int32_t bits_per_second,
       media::VideoCodecProfile codec,
       const gfx::Size& size);
 
   // media::VideoEncodeAccelerator::Client implementation.
   void RequireBitstreamBuffers(unsigned int input_count,
                                const gfx::Size& input_coded_size,
                                size_t output_buffer_size) override;
   void BitstreamBufferReady(int32_t bitstream_buffer_id,
                             size_t payload_size,
@@ skipping 39 matching lines @@
   std::unique_ptr<VideoFrameAndTimestamp> last_frame_;
 
   // Size used to initialize encoder.
   gfx::Size input_visible_size_;
 
   // Coded size that encoder requests as input.
   gfx::Size vea_requested_input_coded_size_;
 
   // Frames and corresponding timestamps in encode as FIFO.
   std::queue<VideoParamsAndTimestamp> frames_in_encode_;
+
+  // This callback can be exercised on any thread.
+  const VideoTrackRecorder::OnErrorCB on_error_callback_;
 };
 
 // Class encapsulating all libvpx interactions for VP8/VP9 encoding.
 class VpxEncoder final : public VideoTrackRecorder::Encoder {
  public:
   static void ShutdownEncoder(std::unique_ptr<base::Thread> encoding_thread,
                               ScopedVpxCodecCtxPtr encoder);
 
   VpxEncoder(
       bool use_vp9,
@@ skipping 96 matching lines @@
   // |encoding_thread_|.
   base::TimeTicks first_frame_timestamp_;
 
   DISALLOW_COPY_AND_ASSIGN(H264Encoder);
 };
 
 #endif  // #if BUILDFLAG(RTC_USE_H264)
 
 VEAEncoder::VEAEncoder(
     const VideoTrackRecorder::OnEncodedVideoCB& on_encoded_video_callback,
+    const VideoTrackRecorder::OnErrorCB& on_error_callback,
     int32_t bits_per_second,
     media::VideoCodecProfile codec,
     const gfx::Size& size)
     : Encoder(on_encoded_video_callback,
               bits_per_second > 0 ? bits_per_second
                                   : size.GetArea() * kVEADefaultBitratePerPixel,
               RenderThreadImpl::current()->GetGpuFactories()->GetTaskRunner()),
       gpu_factories_(RenderThreadImpl::current()->GetGpuFactories()),
       codec_(codec),
-      error_notified_(false) {
+      error_notified_(false),
+      on_error_callback_(on_error_callback) {
   DCHECK(gpu_factories_);
   DCHECK_GE(size.width(), kVEAEncoderMinResolutionWidth);
   DCHECK_GE(size.height(), kVEAEncoderMinResolutionHeight);
 
   encoding_task_runner_->PostTask(
       FROM_HERE, base::Bind(&VEAEncoder::ConfigureEncoderOnEncodingTaskRunner,
                             this, size));
 }
 
 VEAEncoder::~VEAEncoder() {
@@ skipping 52 matching lines @@
   origin_task_runner_->PostTask(
       FROM_HERE, base::Bind(OnFrameEncodeCompleted, on_encoded_video_callback_,
                             front_frame.first, base::Passed(&data), nullptr,
                             front_frame.second, keyframe));
   UseOutputBitstreamBufferId(bitstream_buffer_id);
 }
 
 void VEAEncoder::NotifyError(media::VideoEncodeAccelerator::Error error) {
   DVLOG(3) << __func__;
   DCHECK(encoding_task_runner_->BelongsToCurrentThread());
-
-  // TODO(emircan): Notify the owner via a callback.
+  on_error_callback_.Run(false /* allow_vea_encoder */);
   error_notified_ = true;
 }
 
 void VEAEncoder::UseOutputBitstreamBufferId(int32_t bitstream_buffer_id) {
   DVLOG(3) << __func__;
   DCHECK(encoding_task_runner_->BelongsToCurrentThread());
 
   video_encoder_->UseOutputBitstreamBuffer(media::BitstreamBuffer(
       bitstream_buffer_id, output_buffers_[bitstream_buffer_id]->handle(),
       output_buffers_[bitstream_buffer_id]->mapped_size()));
@@ skipping 555 matching lines @@
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
   DCHECK(!track_.isNull());
   DCHECK(track_.getTrackData());
 
   initialize_encoder_callback_ = base::Bind(
       &VideoTrackRecorder::InitializeEncoder, weak_ptr_factory_.GetWeakPtr(),
       codec, on_encoded_video_callback, bits_per_second);
 
   // InitializeEncoder() will be called on Render Main thread.
   MediaStreamVideoSink::ConnectToTrack(
-      track_, media::BindToCurrentLoop(initialize_encoder_callback_), false);
+      track_,
+      media::BindToCurrentLoop(base::Bind(initialize_encoder_callback_,
+                                          true /* allow_vea_encoder */)),
+      false);
 }
 
 VideoTrackRecorder::~VideoTrackRecorder() {
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
   MediaStreamVideoSink::DisconnectFromTrack();
   track_.reset();
 }
 
 void VideoTrackRecorder::Pause() {
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
@@ skipping 11 matching lines @@
     paused_before_init_ = false;
 }
 
 void VideoTrackRecorder::OnVideoFrameForTesting(
     const scoped_refptr<media::VideoFrame>& frame,
     base::TimeTicks timestamp) {
   DVLOG(3) << __func__;
 
   if (!encoder_) {
     DCHECK(!initialize_encoder_callback_.is_null());
-    initialize_encoder_callback_.Run(frame, timestamp);
+    initialize_encoder_callback_.Run(true /* allow_vea_encoder */, frame,
+                                     timestamp);
   }
 
   encoder_->StartFrameEncode(frame, timestamp);
 }
 
 void VideoTrackRecorder::InitializeEncoder(
     CodecId codec,
     const OnEncodedVideoCB& on_encoded_video_callback,
     int32_t bits_per_second,
+    bool allow_vea_encoder,
     const scoped_refptr<media::VideoFrame>& frame,
     base::TimeTicks capture_time) {
   DVLOG(3) << __func__ << frame->visible_rect().size().ToString();
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
 
   // Avoid reinitializing |encoder_| when there are multiple frames sent to the
   // sink to initialize, https://crbug.com/698441.
   if (encoder_)
     return;
 
   MediaStreamVideoSink::DisconnectFromTrack();
 
   const gfx::Size& input_size = frame->visible_rect().size();
   const auto& vea_supported_profile =
       GetCodecEnumerator()->CodecIdToVEAProfile(codec);
-  if (vea_supported_profile != media::VIDEO_CODEC_PROFILE_UNKNOWN &&
+  if (allow_vea_encoder &&
+      vea_supported_profile != media::VIDEO_CODEC_PROFILE_UNKNOWN &&
       input_size.width() >= kVEAEncoderMinResolutionWidth &&
       input_size.height() >= kVEAEncoderMinResolutionHeight) {
-    encoder_ = new VEAEncoder(on_encoded_video_callback, bits_per_second,
-                              vea_supported_profile, input_size);
+    encoder_ = new VEAEncoder(
+        on_encoded_video_callback,
+        media::BindToCurrentLoop(base::Bind(&VideoTrackRecorder::OnError,
+                                            weak_ptr_factory_.GetWeakPtr())),
+        bits_per_second, vea_supported_profile, input_size);
   } else {
     switch (codec) {
 #if BUILDFLAG(RTC_USE_H264)
       case CodecId::H264:
         encoder_ =
             new H264Encoder(on_encoded_video_callback, bits_per_second);
         break;
 #endif
       case CodecId::VP8:
       case CodecId::VP9:
         encoder_ = new VpxEncoder(codec == CodecId::VP9,
                                   on_encoded_video_callback, bits_per_second);
         break;
       default:
         NOTREACHED() << "Unsupported codec " << static_cast<int>(codec);
     }
   }
 
   if (paused_before_init_)
     encoder_->SetPaused(paused_before_init_);
 
   // StartFrameEncode() will be called on Render IO thread.
   MediaStreamVideoSink::ConnectToTrack(
       track_,
       base::Bind(&VideoTrackRecorder::Encoder::StartFrameEncode, encoder_),
       false);
 }
 
+void VideoTrackRecorder::OnError(bool allow_vea_encoder) {
+  DVLOG(3) << __func__;
+  DCHECK(main_render_thread_checker_.CalledOnValidThread());
+
+  // InitializeEncoder() will be called to reinitialize encoder on Render Main
+  // thread.
+  MediaStreamVideoSink::DisconnectFromTrack();
+  encoder_ = nullptr;
+  MediaStreamVideoSink::ConnectToTrack(
+      track_,
+      media::BindToCurrentLoop(
+          base::Bind(initialize_encoder_callback_, allow_vea_encoder)),

[mcasas, 2017/04/05 21:44:33]

...and here
s|allow_vea_encoder|false  /*allow_vea_encoder*/|

[emircan, 2017/04/05 21:52:55]

Done.

+      false);
+}
+
 bool VideoTrackRecorder::CanEncodeAlphaChannelForTesting() {
   DCHECK(encoder_);
   return encoder_->CanEncodeAlphaChannel();
 }
 
 }  // namespace content