Set the texture to cleared in VideoDecodeAccelerator::PictureReady.

content/common/gpu/media/exynos_video_decode_accelerator.h

 // 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.
 //
 // This file contains an implementation of VideoDecoderAccelerator
 // that utilizes the hardware video decoder present on the Exynos SoC.
 
 #ifndef CONTENT_COMMON_GPU_MEDIA_EXYNOS_VIDEO_DECODE_ACCELERATOR_H_
 #define CONTENT_COMMON_GPU_MEDIA_EXYNOS_VIDEO_DECODE_ACCELERATOR_H_
 
 #include <list>
 #include <vector>
 
 #include "base/callback_forward.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/threading/thread.h"
 #include "content/common/content_export.h"
 #include "content/common/gpu/media/video_decode_accelerator_impl.h"
 #include "media/base/limits.h"
 #include "media/base/video_decoder_config.h"
+#include "media/video/picture.h"
 #include "ui/gfx/size.h"
 #include "ui/gl/gl_bindings.h"
 
 namespace base {
 class MessageLoopProxy;
 }
 
 namespace content {
 class H264Parser;
 
@@ skipping 97 matching lines @@
   // Decode() to DecodeTask().
   struct BitstreamBufferRef;
 
   // Auto-destruction reference for an array of PictureBuffer, for
   // message-passing from AssignPictureBuffers() to AssignPictureBuffersTask().
   struct PictureBufferArrayRef;
 
   // Auto-destruction reference for EGLSync (for message-passing).
   struct EGLSyncKHRRef;
 
+  // Record for decoded pictures that can be sent to PictureReady.
+  struct PictureRecord;
+
   // Record for MFC input buffers.
   struct MfcInputRecord {
     MfcInputRecord();
     ~MfcInputRecord();
     bool at_device;        // held by device.
     void* address;         // mmap() address.
     size_t length;         // mmap() length.
     off_t bytes_used;      // bytes filled in the mmap() segment.
     int32 input_id;        // triggering input_id as given to Decode().
   };
@@ skipping 21 matching lines @@
   // Record for GSC output buffers.
   struct GscOutputRecord {
     GscOutputRecord();
     ~GscOutputRecord();
     bool at_device;        // held by device.
     bool at_client;        // held by client.
     int fd;                // file descriptor from backing EGLImage.
     EGLImageKHR egl_image; // backing EGLImage.
     EGLSyncKHR egl_sync;   // sync the compositor's use of the EGLImage.
     int32 picture_id;      // picture buffer id as returned to PictureReady().
+    bool cleared;          // whether the texture has been cleared

[Pawel Osciak, 2013/10/01 07:45:34]

I guess everyone here is familiar with what "cleared" means, but I feel a little
bit more explanation here would help, because it's not exactly "clear" ;) if you
don't know about the texture manager.

[wuchengli, 2013/10/01 13:54:50]

Done.

   };
 
   //
   // Decoding tasks, to be run on decode_thread_.
   //
 
   // Enqueue a BitstreamBuffer to decode.  This will enqueue a buffer to the
   // decoder_input_queue_, then queue a DecodeBufferTask() to actually decode
   // the buffer.
   void DecodeTask(const media::BitstreamBuffer& bitstream_buffer);
@@ skipping 119 matching lines @@
   // Methods run on child thread.
   //
 
   // Destroy buffers.
   void DestroyMfcInputBuffers();
   void DestroyMfcOutputBuffers();
   void DestroyGscInputBuffers();
   void DestroyGscOutputBuffers();
   void ResolutionChangeDestroyBuffers();
 
+  // Send decoded pictures to PictureReady.
+  void SendPictureReady();
+
+  // Callback that indicates a picture has been cleared.
+  void PictureCleared();
+
   // Our original calling message loop for the child thread.
   scoped_refptr<base::MessageLoopProxy> child_message_loop_proxy_;
 
   // Message loop of the IO thread.
   scoped_refptr<base::MessageLoopProxy> io_message_loop_proxy_;
 
   // WeakPtr<> pointing to |this| for use in posting tasks from the decoder or
   // device worker threads back to the child thread.  Because the worker threads
   // are members of this class, any task running on those threads is guaranteed
   // that this object is still alive.  As a result, tasks posted from the child
@@ skipping 101 matching lines @@
 
   // GSC output buffer state.
   bool gsc_output_streamon_;
   // GSC output buffers enqueued to device.
   int gsc_output_buffer_queued_count_;
   // Output buffers ready to use.  We need a FIFO here.
   std::list<int> gsc_free_output_buffers_;
   // Mapping of int index to GSC output buffer record.
   std::vector<GscOutputRecord> gsc_output_buffer_map_;
 
+  // Pictures that are ready but not sent to PictureReady yet.
+  std::queue<PictureRecord> pending_picture_ready_;
+
+  // The number of pictures that are sent to PictureReady and will be cleared.
+  int picture_clearing_count_;
+
   // Output picture size.
   gfx::Size frame_buffer_size_;
 
   //
   // The device polling thread handles notifications of V4L2 device changes.
   //
 
   // The thread.
   base::Thread device_poll_thread_;
   // eventfd fd to signal device poll thread when its poll() should be
@@ skipping 13 matching lines @@
 
   // The codec we'll be decoding for.
   media::VideoCodecProfile video_profile_;
 
   DISALLOW_COPY_AND_ASSIGN(ExynosVideoDecodeAccelerator);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_COMMON_GPU_MEDIA_EXYNOS_VIDEO_DECODE_ACCELERATOR_H_