Set the texture to cleared in VideoDecodeAccelerator::PictureReady.

content/common/gpu/media/exynos_video_decode_accelerator.cc

 // Copyright (c) 2012 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 <dlfcn.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <linux/videodev2.h>
 #include <poll.h>
 #include <sys/eventfd.h>
@@ skipping 86 matching lines @@
   std::vector<PictureBufferRef> picture_buffers;
 };
 
 struct ExynosVideoDecodeAccelerator::EGLSyncKHRRef {
   EGLSyncKHRRef(EGLDisplay egl_display, EGLSyncKHR egl_sync);
   ~EGLSyncKHRRef();
   EGLDisplay const egl_display;
   EGLSyncKHR egl_sync;
 };
 
+struct ExynosVideoDecodeAccelerator::PictureRecord {
+  PictureRecord(bool cleared, const media::Picture& picture);
+  ~PictureRecord();
+  bool cleared;  // Whether the texture is cleared and safe to render from.
+  media::Picture picture;  // The decoded picture.
+};
+
 ExynosVideoDecodeAccelerator::BitstreamBufferRef::BitstreamBufferRef(
     base::WeakPtr<Client>& client,
     scoped_refptr<base::MessageLoopProxy>& client_message_loop_proxy,
     base::SharedMemory* shm, size_t size, int32 input_id)
     : client(client),
       client_message_loop_proxy(client_message_loop_proxy),
       shm(shm),
       size(size),
       bytes_used(0),
       input_id(input_id) {
@@ skipping 71 matching lines @@
 
 ExynosVideoDecodeAccelerator::GscInputRecord::~GscInputRecord() {
 }
 
 ExynosVideoDecodeAccelerator::GscOutputRecord::GscOutputRecord()
     : at_device(false),
       at_client(false),
       fd(-1),
       egl_image(EGL_NO_IMAGE_KHR),
       egl_sync(EGL_NO_SYNC_KHR),
-      picture_id(-1) {
-}
+      picture_id(-1),
+      cleared(false) {}
 
 ExynosVideoDecodeAccelerator::GscOutputRecord::~GscOutputRecord() {
 }
 
+ExynosVideoDecodeAccelerator::PictureRecord::PictureRecord(
+    bool cleared,
+    const media::Picture& picture)
+    : cleared(cleared), picture(picture) {}
+
+ExynosVideoDecodeAccelerator::PictureRecord::~PictureRecord() {}
+
 ExynosVideoDecodeAccelerator::ExynosVideoDecodeAccelerator(
     EGLDisplay egl_display,
     EGLContext egl_context,
     Client* client,
     const base::WeakPtr<Client>& io_client,
     const base::Callback<bool(void)>& make_context_current,
     const scoped_refptr<base::MessageLoopProxy>& io_message_loop_proxy)
     : child_message_loop_proxy_(base::MessageLoopProxy::current()),
       io_message_loop_proxy_(io_message_loop_proxy),
       weak_this_(base::AsWeakPtr(this)),
@@ skipping 15 matching lines @@
       mfc_input_buffer_queued_count_(0),
       mfc_output_streamon_(false),
       mfc_output_buffer_queued_count_(0),
       mfc_output_buffer_pixelformat_(0),
       mfc_output_dpb_size_(0),
       gsc_fd_(-1),
       gsc_input_streamon_(false),
       gsc_input_buffer_queued_count_(0),
       gsc_output_streamon_(false),
       gsc_output_buffer_queued_count_(0),
+      picture_clearing_count_(0),
       device_poll_thread_("ExynosDevicePollThread"),
       device_poll_interrupt_fd_(-1),
       make_context_current_(make_context_current),
       egl_display_(egl_display),
       egl_context_(egl_context),
       video_profile_(media::VIDEO_CODEC_PROFILE_UNKNOWN) {}
 
 ExynosVideoDecodeAccelerator::~ExynosVideoDecodeAccelerator() {
   DCHECK(!decoder_thread_.IsRunning());
   DCHECK(!device_poll_thread_.IsRunning());
@@ skipping 796 matching lines @@
   }
 
   DCHECK_EQ(pic_buffers->picture_buffers.size(), gsc_output_buffer_map_.size());
   for (size_t i = 0; i < gsc_output_buffer_map_.size(); ++i) {
     // We should be blank right now.
     GscOutputRecord& output_record = gsc_output_buffer_map_[i];
     DCHECK_EQ(output_record.fd, -1);
     DCHECK_EQ(output_record.egl_image, EGL_NO_IMAGE_KHR);
     DCHECK_EQ(output_record.egl_sync, EGL_NO_SYNC_KHR);
     DCHECK_EQ(output_record.picture_id, -1);
+    DCHECK_EQ(output_record.cleared, false);
     PictureBufferArrayRef::PictureBufferRef& buffer =
         pic_buffers->picture_buffers[i];
     output_record.fd = buffer.egl_image_fd;
     output_record.egl_image = buffer.egl_image;
     output_record.picture_id = buffer.client_id;
 
     // Take ownership of the EGLImage and fd.
     buffer.egl_image = EGL_NO_IMAGE_KHR;
     buffer.egl_image_fd = -1;
     // And add this buffer to the free list.
@@ skipping 343 matching lines @@
     }
     GscOutputRecord& output_record = gsc_output_buffer_map_[dqbuf.index];
     DCHECK(output_record.at_device);
     DCHECK(!output_record.at_client);
     DCHECK_EQ(output_record.egl_sync, EGL_NO_SYNC_KHR);
     output_record.at_device = false;
     output_record.at_client = true;
     gsc_output_buffer_queued_count_--;
     DVLOG(3) << "DequeueGsc(): returning input_id=" << dqbuf.timestamp.tv_sec
              << " as picture_id=" << output_record.picture_id;
-    io_message_loop_proxy_->PostTask(FROM_HERE, base::Bind(
-        &Client::PictureReady, io_client_, media::Picture(
-            output_record.picture_id, dqbuf.timestamp.tv_sec)));
+    const media::Picture& picture =
+        media::Picture(output_record.picture_id, dqbuf.timestamp.tv_sec);
+    pending_picture_ready_.push(PictureRecord(output_record.cleared, picture));
+    SendPictureReady();
+    output_record.cleared = true;
     decoder_frames_at_client_++;
   }
 
   NotifyFlushDoneIfNeeded();
 }
 
 bool ExynosVideoDecodeAccelerator::EnqueueMfcInputRecord() {
   DVLOG(3) << "EnqueueMfcInputRecord()";
   DCHECK(!mfc_input_ready_queue_.empty());
 
@@ skipping 191 matching lines @@
   }
 
   // We don't support stacked flushing.
   DCHECK(!decoder_flushing_);
 
   // Queue up an empty buffer -- this triggers the flush.
   decoder_input_queue_.push_back(linked_ptr<BitstreamBufferRef>(
       new BitstreamBufferRef(io_client_, io_message_loop_proxy_, NULL, 0,
                              kFlushBufferId)));
   decoder_flushing_ = true;
+  SendPictureReady();  // Send all pending PictureReady.
 
   ScheduleDecodeBufferTaskIfNeeded();
 }
 
 void ExynosVideoDecodeAccelerator::NotifyFlushDoneIfNeeded() {
   if (!decoder_flushing_)
     return;
 
   // Pipeline is empty when:
   // * Decoder input queue is empty of non-delayed buffers.
@@ skipping 73 matching lines @@
 
   decoder_current_input_buffer_ = -1;
 
   // If we were flushing, we'll never return any more BitstreamBuffers or
   // PictureBuffers; they have all been dropped and returned by now.
   NotifyFlushDoneIfNeeded();
 
   // Mark that we're resetting, then enqueue a ResetDoneTask().  All intervening
   // jobs will early-out in the kResetting state.
   decoder_state_ = kResetting;
+  SendPictureReady();  // Send all pending PictureReady.
   decoder_thread_.message_loop()->PostTask(FROM_HERE, base::Bind(
       &ExynosVideoDecodeAccelerator::ResetDoneTask, base::Unretained(this)));
 }
 
 void ExynosVideoDecodeAccelerator::ResetDoneTask() {
   DVLOG(3) << "ResetDoneTask()";
   DCHECK_EQ(decoder_thread_.message_loop(), base::MessageLoop::current());
   TRACE_EVENT0("Video Decoder", "EVDA::ResetDoneTask");
 
   if (decoder_state_ == kError) {
@@ skipping 708 matching lines @@
   DestroyGscInputBuffers();
   DestroyGscOutputBuffers();
   DestroyMfcOutputBuffers();
 
   // Finish resolution change on decoder thread.
   decoder_thread_.message_loop()->PostTask(FROM_HERE, base::Bind(
       &ExynosVideoDecodeAccelerator::FinishResolutionChange,
       base::Unretained(this)));
 }
 
+void ExynosVideoDecodeAccelerator::SendPictureReady() {
+  DCHECK_EQ(decoder_thread_.message_loop(), base::MessageLoop::current());
+  bool resetting_or_flushing =
+      (decoder_state_ == kResetting || decoder_flushing_);
+  while (pending_picture_ready_.size() > 0) {
+    bool cleared = pending_picture_ready_.front().cleared;
+    const media::Picture& picture = pending_picture_ready_.front().picture;
+    if (cleared && picture_clearing_count_ == 0) {
+      // This picture is cleared. Post it to IO thread to reduce latency. This
+      // should be the case after all pictures are cleared at the beginning.
+      io_message_loop_proxy_->PostTask(
+          FROM_HERE, base::Bind(&Client::PictureReady, io_client_, picture));
+      pending_picture_ready_.pop();
+    } else if (!cleared || resetting_or_flushing) {
+      DVLOG(3) << "SendPictureReady()"
+               << ". cleared=" << pending_picture_ready_.front().cleared
+               << ", decoder_state_=" << decoder_state_
+               << ", decoder_flushing_=" << decoder_flushing_
+               << ", picture_clearing_count_=" << picture_clearing_count_;
+      // If the picture is not cleared, post it to the child thread because it
+      // has to be cleared in the child thread. A picture only needs to be
+      // cleared once. If the decoder is resetting or flushing, send all
+      // pictures to ensure PictureReady arrive before reset or flush done.
+      child_message_loop_proxy_->PostTaskAndReply(
+          FROM_HERE,
+          base::Bind(&Client::PictureReady, client_, picture),
+          // Unretained is safe. If Client::PictureReady gets to run, |this| is
+          // alive. Destroy() will wait the decode thread to finish.
+          base::Bind(&ExynosVideoDecodeAccelerator::PictureCleared,
+                     base::Unretained(this)));
+      picture_clearing_count_++;
+      pending_picture_ready_.pop();
+    } else {
+      // This picture is cleared. But some pictures are about to be cleared on
+      // the child thread. To preserve the order, do not send this until those
+      // pictures are cleared.
+      break;
+    }
+  }
+}
+
+void ExynosVideoDecodeAccelerator::PictureCleared() {
+  DVLOG(3) << "PictureCleared(). clearing count=" << picture_clearing_count_;
+  DCHECK_EQ(decoder_thread_.message_loop(), base::MessageLoop::current());
+  DCHECK_GT(picture_clearing_count_, 0);
+  picture_clearing_count_--;
+  SendPictureReady();
+}
+
 }  // namespace content