Revert 235128 "Remove GSC usage from ExynosVideoDecodeAccelerator."

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 <queue>
+#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;
 
 // This class handles Exynos video acceleration directly through the V4L2
-// device exported by the Multi Format Codec hardware block.
+// devices exported by the Multi Format Codec and GScaler hardware blocks.
 //
 // The threading model of this class is driven by the fact that it needs to
 // interface two fundamentally different event queues -- the one Chromium
 // provides through MessageLoop, and the one driven by the V4L2 devices which
 // is waited on with epoll().  There are three threads involved in this class:
 //
 // * The child thread, which is the main GPU process thread which calls the
 //   media::VideoDecodeAccelerator entry points.  Calls from this thread
 //   generally do not block (with the exception of Initialize() and Destroy()).
 //   They post tasks to the decoder_thread_, which actually services the task
@@ skipping 30 matching lines @@
   virtual void AssignPictureBuffers(
       const std::vector<media::PictureBuffer>& buffers) OVERRIDE;
   virtual void ReusePictureBuffer(int32 picture_buffer_id) OVERRIDE;
   virtual void Flush() OVERRIDE;
   virtual void Reset() OVERRIDE;
   virtual void Destroy() OVERRIDE;
 
   // VideoDecodeAcceleratorImpl implementation.
   virtual bool CanDecodeOnIOThread() OVERRIDE;
 
+  // Do any necessary initialization before the sandbox is enabled.
+  static void PreSandboxInitialization();
+
+  // Lazily initialize static data after sandbox is enabled.  Return false on
+  // init failure.
+  static bool PostSandboxInitialization();
+
  private:
   // These are rather subjectively tuned.
   enum {
     kMfcInputBufferCount = 8,
     // TODO(posciak): determine MFC input buffer size based on level limits.
     // See http://crbug.com/255116.
     kMfcInputBufferMaxSize = 1024 * 1024,
+    kGscInputBufferCount = 4,
     // Number of output buffers to use for each VDA stage above what's required
     // by the decoder (e.g. DPB size, in H264).  We need
     // media::limits::kMaxVideoFrames to fill up the GpuVideoDecode pipeline,
     // and +1 for a frame in transit.
     kDpbOutputBufferExtraCount = media::limits::kMaxVideoFrames + 1,
   };
 
   // Internal state of the decoder.
   enum State {
     kUninitialized,      // Initialize() not yet called.
     kInitialized,        // Initialize() returned true; ready to start decoding.
     kDecoding,           // DecodeBufferInitial() successful; decoding frames.
     kResetting,          // Presently resetting.
     kAfterReset,         // After Reset(), ready to start decoding again.
     kChangingResolution, // Performing resolution change, all remaining
                          // pre-change frames decoded and processed.
     kError,              // Error in kDecoding state.
   };
 
   enum BufferId {
     kFlushBufferId = -2  // Buffer id for flush buffer, queued by FlushTask().
   };
 
   // File descriptors we need to poll.
   enum PollFds {
     kPollMfc = (1 << 0),
+    kPollGsc = (1 << 1),
   };
 
   // Auto-destruction reference for BitstreamBuffer, for message-passing from
   // 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().
+    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().
   };
 
   // Record for MFC output buffers.
   struct MfcOutputRecord {
     MfcOutputRecord();
     ~MfcOutputRecord();
-    bool at_device;         // held by device.
-    bool at_client;         // held by client.
-    int fds[2];             // file descriptors for each plane.
-    EGLImageKHR egl_image;  // EGLImageKHR for the output buffer.
-    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 is cleared and safe to render
-                            // from. See TextureManager for details.
+    bool at_device;        // held by device.
+    size_t bytes_used[2];  // bytes used in each dmabuf.
+    void* address[2];      // mmap() address for each plane.
+    size_t length[2];      // mmap() length for each plane.
+    int32 input_id;        // triggering input_id as given to Decode().
+  };
+
+  // Record for GSC input buffers.
+  struct GscInputRecord {
+    GscInputRecord();
+    ~GscInputRecord();
+    bool at_device;        // held by device.
+    int mfc_output;        // MFC output buffer index to recycle when this input
+                           // is complete.
+  };
+
+  // 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 is cleared and safe to render
+                           // from. See TextureManager for details.
   };
 
   //
   // 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 23 matching lines @@
   // buffers.
   void AssignPictureBuffersTask(scoped_ptr<PictureBufferArrayRef> pic_buffers);
 
   // Service I/O on the V4L2 devices.  This task should only be scheduled from
   // DevicePollTask().  If |mfc_event_pending| is true, one or more events
   // on MFC file descriptor are pending.
   void ServiceDeviceTask(bool mfc_event_pending);
   // Handle the various device queues.
   void EnqueueMfc();
   void DequeueMfc();
+  void EnqueueGsc();
+  void DequeueGsc();
   // Handle incoming MFC events.
   void DequeueMfcEvents();
   // Enqueue a buffer on the corresponding queue.
   bool EnqueueMfcInputRecord();
   bool EnqueueMfcOutputRecord();
+  bool EnqueueGscInputRecord();
+  bool EnqueueGscOutputRecord();
 
   // Process a ReusePictureBuffer() API call.  The API call create an EGLSync
   // object on the main (GPU process) thread; we will record this object so we
   // can wait on it before reusing the buffer.
   void ReusePictureBufferTask(int32 picture_buffer_id,
                               scoped_ptr<EGLSyncKHRRef> egl_sync_ref);
 
   // Flush() task.  Child thread should not submit any more buffers until it
   // receives the NotifyFlushDone callback.  This task will schedule an empty
   // BitstreamBufferRef (with input_id == kFlushBufferId) to perform the flush.
@@ skipping 23 matching lines @@
   bool SetDevicePollInterrupt();
   bool ClearDevicePollInterrupt();
 
   void StartResolutionChangeIfNeeded();
   void FinishResolutionChange();
   void ResumeAfterResolutionChange();
 
   // Try to get output format from MFC, detected after parsing the beginning
   // of the stream. Sets |again| to true if more parsing is needed.
   bool GetFormatInfo(struct v4l2_format* format, bool* again);
-  // Create MFC output buffers for the given |format|.
+  // Create MFC output and GSC input and output buffers for the given |format|.
   bool CreateBuffersForFormat(const struct v4l2_format& format);
 
   //
   // Device tasks, to be run on device_poll_thread_.
   //
 
   // The device task.
   void DevicePollTask(unsigned int poll_fds);
 
   //
   // Safe from any thread.
   //
 
   // Error notification (using PostTask() to child thread, if necessary).
   void NotifyError(Error error);
 
   // Set the decoder_thread_ state (using PostTask to decoder thread, if
   // necessary).
   void SetDecoderState(State state);
 
   //
   // Other utility functions.  Called on decoder_thread_, unless
   // decoder_thread_ is not yet started, in which case the child thread can call
   // these (e.g. in Initialize() or Destroy()).
   //
 
   // Create the buffers we need.
   bool CreateMfcInputBuffers();
   bool CreateMfcOutputBuffers();
+  bool CreateGscInputBuffers();
+  bool CreateGscOutputBuffers();
 
   //
   // 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_;
@@ skipping 44 matching lines @@
   // Picture buffers held by the client.
   int decoder_frames_at_client_;
   // Are we flushing?
   bool decoder_flushing_;
   // Got a notification from driver that it reached resolution change point
   // in the stream.
   bool resolution_change_pending_;
   // Got a reset request while we were performing resolution change.
   bool resolution_change_reset_pending_;
   // Input queue for decoder_thread_: BitstreamBuffers in.
-  std::queue<linked_ptr<BitstreamBufferRef> > decoder_input_queue_;
+  std::list<linked_ptr<BitstreamBufferRef> > decoder_input_queue_;
   // For H264 decode, hardware requires that we send it frame-sized chunks.
   // We'll need to parse the stream.
   scoped_ptr<content::H264Parser> decoder_h264_parser_;
   // Set if the decoder has a pending incomplete frame in an input buffer.
   bool decoder_partial_frame_pending_;
 
   //
   // Hardware state and associated queues.  Since decoder_thread_ services
   // the hardware, decoder_thread_ owns these too.
   //
 
   // Completed decode buffers, waiting for MFC.
-  std::queue<int> mfc_input_ready_queue_;
+  std::list<int> mfc_input_ready_queue_;
 
   // MFC decode device.
   int mfc_fd_;
 
   // MFC input buffer state.
   bool mfc_input_streamon_;
   // MFC input buffers enqueued to device.
   int mfc_input_buffer_queued_count_;
   // Input buffers ready to use, as a LIFO since we don't care about ordering.
   std::vector<int> mfc_free_input_buffers_;
   // Mapping of int index to MFC input buffer record.
   std::vector<MfcInputRecord> mfc_input_buffer_map_;
 
   // MFC output buffer state.
   bool mfc_output_streamon_;
   // MFC output buffers enqueued to device.
   int mfc_output_buffer_queued_count_;
-  // Output buffers ready to use, as a FIFO since we want oldest-first to hide
-  // synchronization latency with GL.
-  std::queue<int> mfc_free_output_buffers_;
+  // Output buffers ready to use, as a LIFO since we don't care about ordering.
+  std::vector<int> mfc_free_output_buffers_;
   // Mapping of int index to MFC output buffer record.
   std::vector<MfcOutputRecord> mfc_output_buffer_map_;
-  // MFC output pixel format.
+  // Required size of MFC output buffers.  Two sizes for two planes.
+  size_t mfc_output_buffer_size_[2];
   uint32 mfc_output_buffer_pixelformat_;
   // Required size of DPB for decoding.
   int mfc_output_dpb_size_;
 
+  // Completed MFC outputs, waiting for GSC.
+  std::list<int> mfc_output_gsc_input_queue_;
+
+  // GSC decode device.
+  int gsc_fd_;
+
+  // GSC input buffer state.
+  bool gsc_input_streamon_;
+  // GSC input buffers enqueued to device.
+  int gsc_input_buffer_queued_count_;
+  // Input buffers ready to use, as a LIFO since we don't care about ordering.
+  std::vector<int> gsc_free_input_buffers_;
+  // Mapping of int index to GSC input buffer record.
+  std::vector<GscInputRecord> gsc_input_buffer_map_;
+
+  // 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_;
 
   //
@@ skipping 19 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_