Add an additional VDA::Flush() mode to return all allocated buffers.

content/common/gpu/media/fake_video_decode_accelerator.cc

 // Copyright 2014 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/common/gpu/media/fake_video_decode_accelerator.h"
 
 #include <stddef.h>
 #include <string.h>
 
 #include "base/bind.h"
@@ skipping 35 matching lines @@
   DCHECK(child_task_runner_->BelongsToCurrentThread());
   if (config.profile == media::VIDEO_CODEC_PROFILE_UNKNOWN) {
     LOG(ERROR) << "unknown codec profile";
     return false;
   }
   if (config.is_encrypted) {
     NOTREACHED() << "encrypted streams are not supported";
     return false;
   }
 
+  if (config.flush_mode != Config::FlushMode::KEEP_OUTPUT_BUFFERS &&
+      config.flush_mode != Config::FlushMode::RETURN_OUTPUT_BUFFERS) {
+    NOTIMPLEMENTED() << "Unsupported Config::FlushMode";
+    return false;
+  }
+
+  config_ = config;
+
   // V4L2VideoDecodeAccelerator waits until first decode call to ask for buffers
   // This class asks for it on initialization instead.
   client_ = client;
   client_->ProvidePictureBuffers(kNumBuffers, 1, frame_buffer_size_,
                                  kDefaultTextureTarget);
   return true;
 }
 
 void FakeVideoDecodeAccelerator::Decode(
     const media::BitstreamBuffer& bitstream_buffer) {
   // We won't really read from the bitstream_buffer, close the handle.
   if (base::SharedMemory::IsHandleValid(bitstream_buffer.handle()))
     base::SharedMemory::CloseHandle(bitstream_buffer.handle());
 
   if (bitstream_buffer.id() < 0) {
     LOG(ERROR) << "Invalid bitstream: id=" << bitstream_buffer.id();
     client_->NotifyError(INVALID_ARGUMENT);
     return;
   }
 
   int bitstream_buffer_id = bitstream_buffer.id();
   queued_bitstream_ids_.push(bitstream_buffer_id);
   child_task_runner_->PostTask(
       FROM_HERE, base::Bind(&FakeVideoDecodeAccelerator::DoPictureReady,
                             weak_this_factory_.GetWeakPtr()));
 }
 
-// Similar to UseOutputBitstreamBuffer for the encode accelerator.
 void FakeVideoDecodeAccelerator::AssignPictureBuffers(
     const std::vector<media::PictureBuffer>& buffers) {
-  DCHECK(buffers.size() == kNumBuffers);
-  DCHECK(!(buffers.size()%2));
+  DCHECK_GE(buffers.size(), kNumBuffers);
 
   // Save buffers and mark all buffers as ready for use.
   std::unique_ptr<uint8_t[]> white_data(
       new uint8_t[frame_buffer_size_.width() * frame_buffer_size_.height() *
                   4]);
   memset(white_data.get(),
          UINT8_MAX,
          frame_buffer_size_.width() * frame_buffer_size_.height() * 4);
   std::unique_ptr<uint8_t[]> black_data(
       new uint8_t[frame_buffer_size_.width() * frame_buffer_size_.height() *
@@ skipping 60 matching lines @@
   }
   delete this;
 }
 
 bool FakeVideoDecodeAccelerator::TryToSetupDecodeOnSeparateThread(
     const base::WeakPtr<Client>& decode_client,
     const scoped_refptr<base::SingleThreadTaskRunner>& decode_task_runner) {
   return false;
 }
 
+void FakeVideoDecodeAccelerator::ReturnPicture(int32_t picture_buffer_id,
+                                               int32_t bitstream_buffer_id) {
+  const media::Picture picture =
+      media::Picture(picture_buffer_id, bitstream_buffer_id,
+                     gfx::Rect(frame_buffer_size_), false);
+
+  client_->PictureReady(picture);
+}
+
 void FakeVideoDecodeAccelerator::DoPictureReady() {
+  while (!free_output_buffers_.empty() && !queued_bitstream_ids_.empty()) {
+    int bitstream_id = queued_bitstream_ids_.front();
+    queued_bitstream_ids_.pop();
+
+    int buffer_id = free_output_buffers_.front();
+    free_output_buffers_.pop();
+
+    ReturnPicture(buffer_id, bitstream_id);
+    client_->NotifyEndOfBitstreamBuffer(bitstream_id);
+  }
+
   if (flushing_ && queued_bitstream_ids_.empty()) {
+    if (config_.flush_mode == Config::FlushMode::RETURN_OUTPUT_BUFFERS) {
+      while (!free_output_buffers_.empty()) {
+        int32_t picture_buffer_id = free_output_buffers_.front();
+        free_output_buffers_.pop();
+        ReturnPicture(picture_buffer_id, -1);
+      }
+    }
+
     flushing_ = false;
     client_->NotifyFlushDone();
   }
-  while (!free_output_buffers_.empty() && !queued_bitstream_ids_.empty()) {
-    int bitstream_id = queued_bitstream_ids_.front();
-    queued_bitstream_ids_.pop();
-    int buffer_id = free_output_buffers_.front();
-    free_output_buffers_.pop();
-
-    const media::Picture picture =
-        media::Picture(buffer_id,
-                       bitstream_id,
-                       gfx::Rect(frame_buffer_size_),
-                       false);
-    client_->PictureReady(picture);
-    // Bitstream no longer needed.
-    client_->NotifyEndOfBitstreamBuffer(bitstream_id);
-    if (flushing_ && queued_bitstream_ids_.empty()) {
-      flushing_ = false;
-      client_->NotifyFlushDone();
-    }
-  }
 }
 
 }  // namespace content