Add ArcGpuVideoDecodeAccelerator.

chrome/gpu/arc_video_accelerator.h

Index: chrome/gpu/arc_video_accelerator.h
diff --git a/chrome/gpu/arc_video_accelerator.h b/chrome/gpu/arc_video_accelerator.h
new file mode 100644
index 0000000000000000000000000000000000000000..107d0a59ed974eccb2fdaaa1602d932a52bfb951
--- /dev/null
+++ b/chrome/gpu/arc_video_accelerator.h
@@ -0,0 +1,155 @@
+// 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.
+
+#ifndef CHROME_GPU_ARC_VIDEO_ACCELERATOR_H_
+#define CHROME_GPU_ARC_VIDEO_ACCELERATOR_H_
+
+namespace chromeos {
+namespace arc {
+
+enum HalPixelFormatExtension {
+  HAL_PIXEL_FORMAT_H264 = 0x34363248,
+  HAL_PIXEL_FORMAT_VP8 = 0x00385056,
+};
+
+enum PortType {
+  PORT_INPUT = 0,
+  PORT_OUTPUT = 1,
+  PORT_COUNT = 2,
+};
+
+enum DeviceType {
+  DEVICE_ENCODER = 0,
+  DEVICE_DECODER = 1,
+};
+
+enum MemoryType {
+  MEMORY_SHARED_MEMORY = 0,
+  MEMORY_DMABUF = 1,
+};
+
+enum BufferFlag {
+  BUFFER_FLAG_EOS = 1,
+};
+
+struct BufferMetadata {
+  int64_t timestamp;  // in microseconds
+  uint32_t flags;
+  uint32_t bytes_used;
+
+  BufferMetadata() : timestamp(0), flags(0), bytes_used(0) {}
+};
+
+struct BufferFormat {
+  uint32_t pixel_format;  // the fourcc pixel format format
+  MemoryType memory_type;
+
+  BufferFormat() : pixel_format(0), memory_type(MEMORY_SHARED_MEMORY) {}
+};
+
+struct VideoFormat {
+  uint32_t pixel_format;
+  uint32_t image_size;
+
+  // minimal number of buffers required to process the video.
+  uint32_t min_num_buffers;
+  uint32_t coded_width;
+  uint32_t coded_height;
+  uint32_t crop_left;
+  uint32_t crop_width;
+  uint32_t crop_top;
+  uint32_t crop_height;
+
+  VideoFormat()
+      : pixel_format(0),
+        image_size(0),
+        min_num_buffers(0),
+        coded_width(0),
+        coded_height(0),
+        crop_left(0),
+        crop_width(0),
+        crop_top(0),
+        crop_height(0) {}
+};
+
+// ArcVideoAccelerator is a component of ArcCodec to deal with video
+// buffers. It is also an IPC interface between Android and Chromium.
+// So that the video buffers are sent to Chromium side and decoded.
+// ArcCodec implements ArcVideoAccelerator::Client and is responsible for
+// rendering and interacting with the Android media framework.
+class ArcVideoAccelerator {
+ public:
+  enum Error {
+    ILLEGAL_STATE = 1,
+    INVALID_ARGUMENT = 2,
+    UNREADABLE_INPUT = 3,
+    PLATFORM_FAILURE = 4,
+  };
+
+  // The callbacks of the ArcVideoAccelerator. ArcCodec implmenets this
+  // interface.
+  class Client {
+   public:
+    virtual ~Client() {}
+
+    // Called when an asynchronous error happens. Asynchronous errors happen
+    // only when the accelerator processes the input buffer and tried to
+    // generate the output to the output buffer.
+    virtual void OnError(Error error) = 0;
+
+    // Called when a buffer with the specified |index| and |port| has been
+    // processed and is no longer used in the accelerator. For input buffer,
+    // it can be filled with new content. For output buffer, it is ready to
+    // be consumed by the client.
+    virtual void OnBufferDone(PortType port,
+                              uint32_t index,
+                              const BufferMetadata& metadata) = 0;
+
+    // Called when the output format has changed or the output format
+    // becomes available at beginning of the stream after initial parsing.
+    virtual void OnOutputFormatChanged(const VideoFormat& format) = 0;
+  };
+
+  virtual bool Initialize(DeviceType device, Client* client) = 0;
+
+  // Assigns a shared memory to be used for the accelerator at the specified
+  // port and index. A buffer must be bound before asking the accelerator to
+  // use it via useBuffer().
+  virtual bool BindSharedMemory(PortType port,
+                                uint32_t index,
+                                int ashmem_fd,
+                                size_t offset,
+                                size_t length) = 0;
+
+  // Assigns a graphic buffer to be used for the accelerator at the specified
+  // port and index. A buffer must be bound before asking the accelerator to
+  // use it via useBuffer().
+  virtual bool BindDmabuf(PortType port, uint32_t index, int dmabuf_fd) = 0;
+
+  // Passes a buffer to the accelerator. For input buffer, the accelerator
+  // will process it. For output buffer, the accelerator will output content
+  // to it.
+  virtual void UseBuffer(PortType port,
+                         uint32_t index,
+                         const BufferMetadata& metadata) = 0;
+
+  // Sets the number of requested buffers. The accelerator may change the
+  // count due to hardware limitation. The caller is responsible to check
+  // the returned value to see if it is acceptable.
+  virtual bool SetBufferCount(PortType port, size_t* count) = 0;
+
+  // Resets the accelerator. After this function, all buffers won't be
+  // accessed by the accelerator and there won't be more callbacks.
+  virtual void Reset() = 0;
+
+  // Sets the buffer format of the given port.
+  virtual bool SetBufferFormat(PortType port, const BufferFormat& format) = 0;
+
+  virtual ~ArcVideoAccelerator() {}
+};
+
+}  // namespace arc
+}  // namespace chromeos
+
+#endif  // CHROME_GPU_ARC_VIDEO_ACCELERATOR_H_