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 kNumVDAErrorsHandled = 5;

[mcasas, 2016/03/28 18:15:20]

micro-pedantic-nit:
s/kNumVDAErrorsHandled/kNumVDAResetsBeforeGivingUp/ ?

[emircan, 2016/03/29 01:50:50]

kNumVDAResetsBeforeSWFallback?

 
 // 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.
@@ skipping 112 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_ > kNumVDAErrorsHandled) {
+      DVLOG(1) << num_vda_errors_

[mcasas, 2016/03/28 18:15:20]

nit: s/DVLOG(1)/DLOG(ERROR)/

[emircan, 2016/03/29 01:50:50]

Done.

+               << " errors reported by VDA, falling back to software decode";
+      return WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE;
+    }
+    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_++;

[mcasas, 2016/03/28 18:15:20]

nit: prefer pre-increment.
I know, I know, we could debate forever
on the effect of idioms on actual real
performance, but humour me... :)

[emircan, 2016/03/29 01:50:50]

Done.

 }
 
 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_)
+
+  if (vda_) {
     vda_->Reset();
+  } else {
+    CreateVDA(vda_codec_profile_, nullptr);
+  }

[mcasas, 2016/03/28 18:15:20]

No {} for one-liners as I replied to pbos@
(this is also pervasive around Chrome code)

[emircan, 2016/03/29 01:50:50]

Done.

 }
 
 // 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