RTCVideoDecoder: Fixes for high resolutions and high pressure cases.

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 "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/metrics/histogram.h"
@@ skipping 14 matching lines @@
 
 const int32 RTCVideoDecoder::ID_LAST = 0x3FFFFFFF;
 const int32 RTCVideoDecoder::ID_HALF = 0x20000000;
 const int32 RTCVideoDecoder::ID_INVALID = -1;
 
 // 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;
 
-// Size of shared-memory segments we allocate.  Since we reuse them we let them
-// be on the beefy side.
-static const size_t kSharedMemorySegmentBytes = 100 << 10;
+// Number of allocated shared memory segments.
+static const size_t kNumSharedMemorySegments = 16;
 
-// Maximum number of allocated shared-memory segments.
-static const int kMaxNumSharedMemorySegments = 16;
-
-// Maximum number of pending WebRTC buffers that are waiting for the shared
-// memory. 10 seconds for 30 fps.
-static const size_t kMaxNumOfPendingBuffers = 300;
+// Maximum number of pending WebRTC buffers that are waiting for shared memory.
+static const size_t kMaxNumOfPendingBuffers = 8;
 
 // A shared memory segment and its allocated size. This class has the ownership
 // of |shm|.
 class RTCVideoDecoder::SHMBuffer {
  public:
   SHMBuffer(scoped_ptr<base::SharedMemory> shm, size_t size);
   ~SHMBuffer();
   scoped_ptr<base::SharedMemory> const shm;
   const size_t size;
 };
@@ skipping 37 matching lines @@
   DVLOG(2) << "~RTCVideoDecoder";
   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
   DestroyVDA();
 
   // Delete all shared memories.
   STLDeleteElements(&available_shm_segments_);
   STLDeleteValues(&bitstream_buffers_in_decoder_);
   STLDeleteContainerPairFirstPointers(decode_buffers_.begin(),
                                       decode_buffers_.end());
   decode_buffers_.clear();
-
-  // Delete WebRTC input buffers.
-  for (std::deque<std::pair<webrtc::EncodedImage, BufferData> >::iterator it =
-           pending_buffers_.begin();
-       it != pending_buffers_.end();
-       ++it) {
-    delete[] it->first._buffer;
-  }
+  ClearPendingBuffers();
 }
 
 // static
 scoped_ptr<RTCVideoDecoder> RTCVideoDecoder::Create(
     webrtc::VideoCodecType type,
     const scoped_refptr<media::GpuVideoAcceleratorFactories>& factories) {
   scoped_ptr<RTCVideoDecoder> decoder;
   // Convert WebRTC codec type to media codec profile.
   media::VideoCodecProfile profile;
   switch (type) {
@@ skipping 34 matching lines @@
       codecSettings->codecSpecific.VP8.feedbackModeOn) {
     LOG(ERROR) << "Feedback mode not supported";
     return RecordInitDecodeUMA(WEBRTC_VIDEO_CODEC_ERROR);
   }
 
   base::AutoLock auto_lock(lock_);
   if (state_ == UNINITIALIZED || state_ == DECODE_ERROR) {
     LOG(ERROR) << "VDA is not initialized. state=" << state_;
     return RecordInitDecodeUMA(WEBRTC_VIDEO_CODEC_UNINITIALIZED);
   }
-  // Create some shared memory if the queue is empty.
-  if (available_shm_segments_.size() == 0) {
-    factories_->GetTaskRunner()->PostTask(
-        FROM_HERE,
-        base::Bind(&RTCVideoDecoder::CreateSHM,
-                   weak_factory_.GetWeakPtr(),
-                   kMaxInFlightDecodes,
-                   kSharedMemorySegmentBytes));
-  }
+
   return RecordInitDecodeUMA(WEBRTC_VIDEO_CODEC_OK);
 }
 
 int32_t RTCVideoDecoder::Decode(
     const webrtc::EncodedImage& inputImage,
     bool missingFrames,
     const webrtc::RTPFragmentationHeader* /*fragmentation*/,
     const webrtc::CodecSpecificInfo* /*codecSpecificInfo*/,
     int64_t /*renderTimeMs*/) {
   DVLOG(3) << "Decode";
@@ skipping 59 matching lines @@
   BufferData buffer_data(next_bitstream_buffer_id_,
                          inputImage._timeStamp,
                          inputImage._length);
   // Mask against 30 bits, to avoid (undefined) wraparound on signed integer.
   next_bitstream_buffer_id_ = (next_bitstream_buffer_id_ + 1) & ID_LAST;
 
   // If a shared memory segment is available, there are no pending buffers, and
   // this isn't a mid-stream resolution change, then send the buffer for decode
   // immediately. Otherwise, save the buffer in the queue for later decode.
   scoped_ptr<SHMBuffer> shm_buffer;
-  if (!need_to_reset_for_midstream_resize && pending_buffers_.size() == 0)
+  if (!need_to_reset_for_midstream_resize && pending_buffers_.empty())
     shm_buffer = GetSHM_Locked(inputImage._length);
   if (!shm_buffer) {
-    if (!SaveToPendingBuffers_Locked(inputImage, buffer_data))
+    if (!SaveToPendingBuffers_Locked(inputImage, buffer_data)) {
+      // We have exceeded the pending buffers count, we are severely behind.
+      // Since we are returning ERROR, WebRTC will not be interested in the
+      // remaining buffers, and will provide us with a new keyframe instead.
+      // Better to drop any pending buffers and start afresh to catch up faster.
+      DVLOG(1) << "Exceeded maximum pending buffer count, dropping";
+      ClearPendingBuffers();
       return WEBRTC_VIDEO_CODEC_ERROR;
+    }
+
     if (need_to_reset_for_midstream_resize) {
       base::AutoUnlock auto_unlock(lock_);
       Reset();
     }
+
     return WEBRTC_VIDEO_CODEC_OK;
   }
 
   SaveToDecodeBuffers_Locked(inputImage, shm_buffer.Pass(), buffer_data);
   factories_->GetTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&RTCVideoDecoder::RequestBufferDecode,
                  weak_factory_.GetWeakPtr()));
   return WEBRTC_VIDEO_CODEC_OK;
 }
@@ skipping 233 matching lines @@
 
   MovePendingBuffersToDecodeBuffers();
 
   while (CanMoreDecodeWorkBeDone()) {
     // Get a buffer and data from the queue.
     SHMBuffer* shm_buffer = NULL;
     BufferData buffer_data;
     {
       base::AutoLock auto_lock(lock_);
       // Do not request decode if VDA is resetting.
-      if (decode_buffers_.size() == 0 || state_ == RESETTING)
+      if (decode_buffers_.empty() || state_ == RESETTING)
         return;
       shm_buffer = decode_buffers_.front().first;
       buffer_data = decode_buffers_.front().second;
       decode_buffers_.pop_front();
       // Drop the buffers before Reset or Release is called.
       if (!IsBufferAfterReset(buffer_data.bitstream_buffer_id,
                               reset_bitstream_buffer_id_)) {
         PutSHM_Locked(scoped_ptr<SHMBuffer>(shm_buffer));
         continue;
       }
@@ skipping 200 matching lines @@
   if (vda_)
     vda_.release()->Destroy();
   DestroyTextures();
   base::AutoLock auto_lock(lock_);
   state_ = UNINITIALIZED;
 }
 
 scoped_ptr<RTCVideoDecoder::SHMBuffer> RTCVideoDecoder::GetSHM_Locked(
     size_t min_size) {
   // Reuse a SHM if possible.
-  SHMBuffer* ret = NULL;
   if (!available_shm_segments_.empty() &&
       available_shm_segments_.back()->size >= min_size) {
-    ret = available_shm_segments_.back();
+    scoped_ptr<SHMBuffer> buffer(available_shm_segments_.back());
     available_shm_segments_.pop_back();
+    return buffer;
   }
-  // Post to vda thread to create shared memory if SHM cannot be reused or the
-  // queue is almost empty.
-  if (num_shm_buffers_ < kMaxNumSharedMemorySegments &&
-      (ret == NULL || available_shm_segments_.size() <= 1)) {
-    factories_->GetTaskRunner()->PostTask(
-        FROM_HERE,
-        base::Bind(&RTCVideoDecoder::CreateSHM,
-                   weak_factory_.GetWeakPtr(),
-                   1,
-                   min_size));
+
+  if (available_shm_segments_.size() != num_shm_buffers_) {
+    // Either available_shm_segments_ is empty (and we already have some SHM
+    // buffers allocated), or the size of available segments is not large
+    // enough. In the former case we need to wait for buffers to be returned,
+    // in the latter we need to wait for all buffers to be returned to drop
+    // them and reallocate with a new size.
+    return NULL;
   }
-  return scoped_ptr<SHMBuffer>(ret);
+
+  if (num_shm_buffers_ != 0) {
+    STLDeleteElements(&available_shm_segments_);
+    num_shm_buffers_ = 0;
+  }
+
+  // Create twice as large buffers as required, to avoid frequent reallocation.
+  factories_->GetTaskRunner()->PostTask(
+      FROM_HERE,
+      base::Bind(&RTCVideoDecoder::CreateSHM, weak_factory_.GetWeakPtr(),
+                 kNumSharedMemorySegments, min_size * 2));
+
+  // We'll be called again after the shared memory is created.
+  return NULL;
 }
 
 void RTCVideoDecoder::PutSHM_Locked(scoped_ptr<SHMBuffer> shm_buffer) {
   available_shm_segments_.push_back(shm_buffer.release());
 }
 
-void RTCVideoDecoder::CreateSHM(int number, size_t min_size) {
+void RTCVideoDecoder::CreateSHM(size_t count, size_t size) {
   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
-  DVLOG(2) << "CreateSHM. size=" << min_size;
-  int number_to_allocate;
-  {
+  DVLOG(2) << "CreateSHM. count=" << count << ", size=" << size;
+
+  for (size_t i = 0; i < count; i++) {
+    scoped_ptr<base::SharedMemory> shm = factories_->CreateSharedMemory(size);

[Ville-Mikko Rautio, 2015/07/17 11:26:15]

Earlier it was quaranteed that each buffer would be at least
kSharedMemorySegmentBytes (=100 << 10) bytes. Now we are pushing this floor
potentially down. Was it deliberate change? I don't know what was the original
reasoning for guaranteeing kSharedMemorySegmentBytes buffer.

You seem to have compensated this by requiring min_size * 2 buffer above in
GetSHM_Locked. Overall the determining the size of the buffer seems to contain
quite a bit of heuristics (which is true also on ToT).

[Pawel Osciak, 2015/07/21 07:10:07]

Yes, that was intentional. We may have to reallocate after switching to a higher
resolution, but that will only happen once, after that we'll keep using these
larger buffers.
If it becomes too small, this will reallocate to 2 * new_size again.
The existing ToT has a bug that may prevent it from reallocating when the
buffers are not big enough (please see CL description).

+    if (!shm) {
+      LOG(ERROR) << "Failed allocating shared memory of size=" << size;
+      NotifyError(media::VideoDecodeAccelerator::PLATFORM_FAILURE);
+      return;
+    }
+
     base::AutoLock auto_lock(lock_);
-    number_to_allocate =
-        std::min(kMaxNumSharedMemorySegments - num_shm_buffers_, number);
+    PutSHM_Locked(scoped_ptr<SHMBuffer>(new SHMBuffer(shm.Pass(), size)));
+    ++num_shm_buffers_;
   }
-  size_t size_to_allocate = std::max(min_size, kSharedMemorySegmentBytes);
-  for (int i = 0; i < number_to_allocate; i++) {
-    scoped_ptr<base::SharedMemory> shm =
-        factories_->CreateSharedMemory(size_to_allocate);
-    if (shm) {
-      base::AutoLock auto_lock(lock_);
-      num_shm_buffers_++;
-      PutSHM_Locked(
-          scoped_ptr<SHMBuffer>(new SHMBuffer(shm.Pass(), size_to_allocate)));
-    }
-  }
+
   // Kick off the decoding.
   RequestBufferDecode();
 }
 
 void RTCVideoDecoder::RecordBufferData(const BufferData& buffer_data) {
   input_buffer_data_.push_front(buffer_data);
   // Why this value?  Because why not.  avformat.h:MAX_REORDER_DELAY is 16, but
   // that's too small for some pathological B-frame test videos.  The cost of
   // using too-high a value is low (192 bits per extra slot).
   static const size_t kMaxInputBufferDataSize = 128;
@@ skipping 22 matching lines @@
   bool sample = (status == WEBRTC_VIDEO_CODEC_OK) ? true : false;
   UMA_HISTOGRAM_BOOLEAN("Media.RTCVideoDecoderInitDecodeSuccess", sample);
   return status;
 }
 
 void RTCVideoDecoder::DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent()
     const {
   DCHECK(factories_->GetTaskRunner()->BelongsToCurrentThread());
 }
 
+void RTCVideoDecoder::ClearPendingBuffers() {
+  // Delete WebRTC input buffers.
+  for (std::deque<std::pair<webrtc::EncodedImage, BufferData>>::iterator it =
+           pending_buffers_.begin();
+       it != pending_buffers_.end(); ++it) {
+    delete[] it->first._buffer;
+  }
+
+  pending_buffers_.clear();
+}
+
 }  // namespace content