Handle HW decode failures in RTCVideoDecoder

content/renderer/media/rtc_video_decoder.cc

 // Copyright 2013 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/rtc_video_decoder.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 10 matching lines @@
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/webrtc/base/bind.h"
 #include "third_party/webrtc/base/refcount.h"
 #include "third_party/webrtc/video_frame.h"
 
 namespace content {
 
 const int32_t RTCVideoDecoder::ID_LAST = 0x3FFFFFFF;
 const int32_t RTCVideoDecoder::ID_HALF = 0x20000000;
 const int32_t RTCVideoDecoder::ID_INVALID = -1;
+const uint32_t kNumVDAResetsBeforeSWFallback = 5;
 
 // Maximum number of concurrent VDA::Decode() operations RVD will maintain.
 // Higher values allow better pipelining in the GPU, but also require more
 // resources.
 static const size_t kMaxInFlightDecodes = 8;
 
 // Number of allocated shared memory segments.
 static const size_t kNumSharedMemorySegments = 16;
 
 // Maximum number of pending WebRTC buffers that are waiting for shared memory.
 static const size_t kMaxNumOfPendingBuffers = 8;
 
 RTCVideoDecoder::BufferData::BufferData(int32_t bitstream_buffer_id,
                                         uint32_t timestamp,
                                         size_t size,
                                         const gfx::Rect& visible_rect)
     : bitstream_buffer_id(bitstream_buffer_id),
       timestamp(timestamp),
       size(size),
       visible_rect(visible_rect) {}
 
 RTCVideoDecoder::BufferData::BufferData() {}
 
 RTCVideoDecoder::BufferData::~BufferData() {}
 
 RTCVideoDecoder::RTCVideoDecoder(webrtc::VideoCodecType type,
                                  media::GpuVideoAcceleratorFactories* factories)
-    : video_codec_type_(type),
+    : num_vda_errors_(0),
+      video_codec_type_(type),
       factories_(factories),
       decoder_texture_target_(0),
       next_picture_buffer_id_(0),
       state_(UNINITIALIZED),
       decode_complete_callback_(nullptr),
       num_shm_buffers_(0),
       next_bitstream_buffer_id_(0),
       reset_bitstream_buffer_id_(ID_INVALID),
       weak_factory_(this) {
   DCHECK(!factories_->GetTaskRunner()->BelongsToCurrentThread());
@@ skipping 84 matching lines @@
 
   base::AutoLock auto_lock(lock_);
 
   if (state_ == UNINITIALIZED || !decode_complete_callback_) {
     LOG(ERROR) << "The decoder has not initialized.";
     return WEBRTC_VIDEO_CODEC_UNINITIALIZED;
   }
 
   if (state_ == DECODE_ERROR) {
     LOG(ERROR) << "Decoding error occurred.";
+    // Try reseting the session |kNumVDAErrorsHandled| times.
+    if (num_vda_errors_ > kNumVDAResetsBeforeSWFallback) {
+      DLOG(ERROR) << num_vda_errors_
+                  << " errors reported by VDA, falling back to software decode";
+      return WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE;

[hbos_chromium, 2016/03/29 12:28:19]

What if there is no SW decoder available? Would it continue to use this decoder
and get stuck in the DECODE_ERROR state?

Also, I don't know what causes decode errors, but if decode errors periodically
happen, for whatever reason, we might sooner or later always end up with SW
decoder for longer video sessions.
In a bug of mine (crbug.com/583704) decode errors happen seemingly randomly on
some machines, but not often enough that it wouldn't make sense to recover (if
possible).

[emircan, 2016/03/29 19:37:55]

That logic is handled in the WebRTC side:
https://code.google.com/p/chromium/codesearch#chromium/src/third_party/webrtc...

AFAIU, it will try to use a SW encoder if there is and stop things with an error
message otherwise. 

If HW errors are happening periodically, maybe we can increase the limit of 5.
But, I think falling back to SW is a safer bet then?

[hbos_chromium, 2016/03/30 16:43:39]

Yeah, makes sense. Let's not assume HW errors occur periodically. Hopefully
there is a root cause that can be addressed. I'm still debugging my bug.
I wanted to try this out today in combination with my SW decoder but I've been
unable to reliably reproduce the decode error on my mac :/ I'll try again
tomorrow on my windows laptop.

+    }
+    state_ = RESETTING;
+    factories_->GetTaskRunner()->PostTask(
+        FROM_HERE, base::Bind(&RTCVideoDecoder::ResetInternal,
+                              weak_factory_.GetWeakPtr()));
     return WEBRTC_VIDEO_CODEC_ERROR;
   }
 
   if (missingFrames || !inputImage._completeFrame) {
     DLOG(ERROR) << "Missing or incomplete frames.";
     // Unlike the SW decoder in libvpx, hw decoder cannot handle broken frames.
     // Return an error to request a key frame.
     return WEBRTC_VIDEO_CODEC_ERROR;
   }
 
@@ skipping 296 matching lines @@
     return;
 
   LOG(ERROR) << "VDA Error:" << error;
   UMA_HISTOGRAM_ENUMERATION("Media.RTCVideoDecoderError",
                             error,
                             media::VideoDecodeAccelerator::LARGEST_ERROR_ENUM);
   DestroyVDA();
 
   base::AutoLock auto_lock(lock_);
   state_ = DECODE_ERROR;
+  ++num_vda_errors_;
 }
 
 void RTCVideoDecoder::RequestBufferDecode() {
   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
   if (!vda_)
     return;
 
   MovePendingBuffersToDecodeBuffers();
 
   while (CanMoreDecodeWorkBeDone()) {
@@ skipping 109 matching lines @@
         GetSHM_Locked(input_image._length);
     if (!shm_buffer)
       return;
     SaveToDecodeBuffers_Locked(input_image, std::move(shm_buffer), buffer_data);
     delete[] input_image._buffer;
     pending_buffers_.pop_front();
   }
 }
 
 void RTCVideoDecoder::ResetInternal() {
+  DVLOG(2) << __FUNCTION__;
   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
-  DVLOG(2) << "ResetInternal";
+
   if (vda_)
     vda_->Reset();
+  else
+    CreateVDA(vda_codec_profile_, nullptr);
 }
 
 // static
 void RTCVideoDecoder::ReleaseMailbox(
     base::WeakPtr<RTCVideoDecoder> decoder,
     media::GpuVideoAcceleratorFactories* factories,
     int64_t picture_buffer_id,
     uint32_t texture_id,
     const gpu::SyncToken& release_sync_token) {
   DCHECK(factories->GetTaskRunner()->BelongsToCurrentThread());
@@ skipping 51 matching lines @@
   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
 
   if (!IsProfileSupported(profile)) {
     DVLOG(1) << "Unsupported profile " << profile;
   } else {
     vda_ = factories_->CreateVideoDecodeAccelerator();
 
     media::VideoDecodeAccelerator::Config config(profile);
     if (vda_ && !vda_->Initialize(config, this))
       vda_.release()->Destroy();
+    vda_codec_profile_ = profile;
   }
 
-  waiter->Signal();
+  if (waiter)
+    waiter->Signal();
 }
 
 void RTCVideoDecoder::DestroyTextures() {
   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
 
   // Not destroying PictureBuffers in |picture_buffers_at_display_| yet, since
   // their textures may still be in use by the user of this RTCVideoDecoder.
   for (const auto& picture_buffer_at_display : picture_buffers_at_display_)
     assigned_picture_buffers_.erase(picture_buffer_at_display.first);
 
   for (const auto& assigned_picture_buffer : assigned_picture_buffers_)
     factories_->DeleteTexture(assigned_picture_buffer.second.texture_id());
 
   assigned_picture_buffers_.clear();
 }
 
 void RTCVideoDecoder::DestroyVDA() {
   DVLOG(2) << "DestroyVDA";
   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
   if (vda_)
     vda_.release()->Destroy();
   DestroyTextures();
+
   base::AutoLock auto_lock(lock_);
+
+  // Put the buffers back in case we restart the decoder.
+  for (const auto& buffer : bitstream_buffers_in_decoder_)
+    PutSHM_Locked(scoped_ptr<base::SharedMemory>(buffer.second));
+  bitstream_buffers_in_decoder_.clear();
+
   state_ = UNINITIALIZED;
 }
 
 scoped_ptr<base::SharedMemory> RTCVideoDecoder::GetSHM_Locked(size_t min_size) {
   // Reuse a SHM if possible.
   if (!available_shm_segments_.empty() &&
       available_shm_segments_.back()->mapped_size() >= min_size) {
     scoped_ptr<base::SharedMemory> buffer(available_shm_segments_.back());
     available_shm_segments_.pop_back();
     return buffer;
@@ skipping 88 matching lines @@
 }
 
 void RTCVideoDecoder::ClearPendingBuffers() {
   // Delete WebRTC input buffers.
   for (const auto& pending_buffer : pending_buffers_)
     delete[] pending_buffer.first._buffer;
   pending_buffers_.clear();
 }
 
 }  // namespace content