Use explicit flush for ArcVideoAccelerator.

chrome/gpu/arc_gpu_video_decode_accelerator.cc

 // Copyright 2016 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 "chrome/gpu/arc_gpu_video_decode_accelerator.h"
 
 #include "base/callback_helpers.h"
 #include "base/logging.h"
 #include "base/run_loop.h"
 #include "content/public/gpu/gpu_video_decode_accelerator_factory.h"
@@ skipping 15 matching lines @@
 
 ArcGpuVideoDecodeAccelerator::InputBufferInfo::InputBufferInfo(
     InputBufferInfo&& other)
     : handle(std::move(other.handle)),
       offset(other.offset),
       length(other.length) {}
 
 ArcGpuVideoDecodeAccelerator::InputBufferInfo::~InputBufferInfo() {}
 
 ArcGpuVideoDecodeAccelerator::ArcGpuVideoDecodeAccelerator()
-    : pending_eos_output_buffer_(false),
-      arc_client_(nullptr),
+    : arc_client_(nullptr),
       next_bitstream_buffer_id_(0),
       output_buffer_size_(0) {}
 
 ArcGpuVideoDecodeAccelerator::~ArcGpuVideoDecodeAccelerator() {}
 
 namespace {
 
 // An arbitrary chosen limit of the number of buffers. The number of
 // buffers used is requested from the untrusted client side.
 const size_t kMaxBufferCount = 128;
@@ skipping 153 matching lines @@
       int dup_fd = HANDLE_EINTR(dup(input_info->handle.get()));
       if (dup_fd < 0) {
         DLOG(ERROR) << "dup() failed.";
         arc_client_->OnError(PLATFORM_FAILURE);
         return;
       }
       CreateInputRecord(bitstream_buffer_id, index, metadata.timestamp);
       vda_->Decode(media::BitstreamBuffer(
           bitstream_buffer_id, base::SharedMemoryHandle(dup_fd, true),
           metadata.bytes_used, input_info->offset));
-      if (metadata.flags & BUFFER_FLAG_EOS) {
-        vda_->Flush();
+      break;
+    }
+    case PORT_OUTPUT: {
+      // is_valid() is true for the first time the buffer is passed to the VDA.
+      // In that case, VDA needs to import the buffer first.
+      if (buffers_pending_import_[index].is_valid()) {
+        gfx::GpuMemoryBufferHandle handle;
+#if defined(USE_OZONE)
+        handle.native_pixmap_handle.fd = base::FileDescriptor(
+            buffers_pending_import_[index].release(), true);
+#endif
+        vda_->ImportBufferForPicture(index, {handle});
+      } else {
+        vda_->ReusePictureBuffer(index);
       }
       break;
     }
-    case PORT_OUTPUT: {
-      SendEosIfNeededOrReusePicture(index);
-      break;
-    }
     default:
       NOTREACHED();
   }
 }
 
 void ArcGpuVideoDecodeAccelerator::Reset() {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!vda_) {
     DLOG(ERROR) << "VDA not initialized";
     return;
   }
   vda_->Reset();
 }
 
+void ArcGpuVideoDecodeAccelerator::Flush() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  if (!vda_) {
+    DLOG(ERROR) << "VDA not initialized";
+    return;
+  }
+  vda_->Flush();
+}
+
 void ArcGpuVideoDecodeAccelerator::ProvidePictureBuffers(
     uint32_t requested_num_of_buffers,
     uint32_t textures_per_buffer,
     const gfx::Size& dimensions,
     uint32_t texture_target) {
   DVLOG(5) << "ProvidePictureBuffers("
            << "requested_num_of_buffers=" << requested_num_of_buffers
            << ", dimensions=" << dimensions.ToString() << ")";
   DCHECK(thread_checker_.CalledOnValidThread());
   coded_size_ = dimensions;
@@ skipping 35 matching lines @@
 void ArcGpuVideoDecodeAccelerator::DismissPictureBuffer(
     int32_t picture_buffer) {
   // no-op
 }
 
 void ArcGpuVideoDecodeAccelerator::PictureReady(const media::Picture& picture) {
   DVLOG(5) << "PictureReady(picture_buffer_id=" << picture.picture_buffer_id()
            << ", bitstream_buffer_id=" << picture.bitstream_buffer_id();
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  // Empty buffer, returned in Flushing.
-  if (picture.bitstream_buffer_id() == -1) {
-    buffers_pending_eos_.push(picture.picture_buffer_id());
-    return;
-  }
   InputRecord* input_record = FindInputRecord(picture.bitstream_buffer_id());
   if (input_record == nullptr) {
     DLOG(ERROR) << "Cannot find for bitstream buffer id: "
                 << picture.bitstream_buffer_id();
     arc_client_->OnError(PLATFORM_FAILURE);
     return;
   }
 
   BufferMetadata metadata;
   metadata.timestamp = input_record->timestamp;
   metadata.bytes_used = output_buffer_size_;
   arc_client_->OnBufferDone(PORT_OUTPUT, picture.picture_buffer_id(), metadata);
 }
 
 void ArcGpuVideoDecodeAccelerator::NotifyEndOfBitstreamBuffer(
     int32_t bitstream_buffer_id) {
   DVLOG(5) << "NotifyEndOfBitstreamBuffer(" << bitstream_buffer_id << ")";
   DCHECK(thread_checker_.CalledOnValidThread());
   InputRecord* input_record = FindInputRecord(bitstream_buffer_id);
   if (input_record == nullptr) {
     arc_client_->OnError(PLATFORM_FAILURE);
     return;
   }
   arc_client_->OnBufferDone(PORT_INPUT, input_record->buffer_index,
                             BufferMetadata());
 }
 
 void ArcGpuVideoDecodeAccelerator::NotifyFlushDone() {
   DCHECK(thread_checker_.CalledOnValidThread());
-  pending_eos_output_buffer_ = true;
-  while (!buffers_pending_eos_.empty()) {
-    SendEosIfNeededOrReusePicture(buffers_pending_eos_.front());
-    buffers_pending_eos_.pop();
-  }
+  arc_client_->OnFlushDone();
 }
 
 void ArcGpuVideoDecodeAccelerator::NotifyResetDone() {
   DCHECK(thread_checker_.CalledOnValidThread());
   arc_client_->OnResetDone();
 }
 
 static ArcVideoAccelerator::Error ConvertErrorCode(
     media::VideoDecodeAccelerator::Error error) {
   switch (error) {
@@ skipping 11 matching lines @@
   }
 }
 
 void ArcGpuVideoDecodeAccelerator::NotifyError(
     media::VideoDecodeAccelerator::Error error) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DLOG(ERROR) << "Error notified: " << error;
   arc_client_->OnError(ConvertErrorCode(error));
 }
 
-void ArcGpuVideoDecodeAccelerator::SendEosIfNeededOrReusePicture(
-    uint32_t index) {
-  if (pending_eos_output_buffer_) {
-    BufferMetadata metadata;
-    metadata.flags = BUFFER_FLAG_EOS;
-    arc_client_->OnBufferDone(PORT_OUTPUT, index, metadata);
-    pending_eos_output_buffer_ = false;
-  } else {
-    if (buffers_pending_import_[index].is_valid()) {
-      std::vector<gfx::GpuMemoryBufferHandle> buffers;
-      buffers.push_back(gfx::GpuMemoryBufferHandle());
-#if defined(USE_OZONE)
-      buffers.back().native_pixmap_handle.fd =
-          base::FileDescriptor(buffers_pending_import_[index].release(), true);
-#endif
-      vda_->ImportBufferForPicture(index, buffers);
-    } else {
-      vda_->ReusePictureBuffer(index);
-    }
-  }
-}
-
 void ArcGpuVideoDecodeAccelerator::CreateInputRecord(
     int32_t bitstream_buffer_id,
     uint32_t buffer_index,
     int64_t timestamp) {
   input_records_.push_front(
       InputRecord(bitstream_buffer_id, buffer_index, timestamp));
 
   // The same value copied from media::GpuVideoDecoder. The input record is
   // needed when the input buffer or the corresponding output buffer are
   // returned from VDA. However there is no guarantee how much buffers will be
@@ skipping 29 matching lines @@
       }
       return true;
     default:
       DLOG(ERROR) << "Invalid port: " << port;
       return false;
   }
 }
 
 }  // namespace arc
 }  // namespace chromeos