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..215b81903373327d6e4d96d59850e4eb6e8dc38b
--- /dev/null
+++ b/chrome/gpu/arc_video_accelerator.h
@@ -0,0 +1,156 @@
+// 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 {

[kcwu, 2016/03/10 07:27:26]

How about to use "Non-Static Class Member Initializers" in this and other
structs?
https://chromium-cpp.appspot.com/

struct BufferMetadata {
  int64_t timestamp = 0;
  uint32_t flags = 0;
  uint32_t bytes_used = 0;
};

[Owen Lin, 2016/03/14 08:46:59]

Nice.

+  int64_t timestamp;  // in microseconds
+  uint32_t flags;
+  uint32_t bytes_used;
+
+  BufferMetadata() : timestamp(0), flags(0), bytes_used(0) {}
+};
+
+struct VideoFormat {
+  uint32_t pixel_format;
+  uint32_t image_size;

[kcwu, 2016/03/04 13:32:59]

buffer_size ?

[Owen Lin, 2016/03/14 08:46:59]

Done.

+
+  // 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,
+  };
+
+  struct Config {
+    DeviceType device_type;
+    size_t num_input_buffers;
+    uint32_t input_pixel_format;
+
+    Config()
+        : device_type(DEVICE_DECODER),
+          num_input_buffers(0),
+          input_pixel_format(0) {}
+  };
+
+  // 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(const Config& 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 void BindSharedMemory(PortType port,
+                                uint32_t index,
+                                int ashmem_fd,
+                                off_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 void 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 output 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 void SetNumberOfOutputBuffers(size_t number) = 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;
+
+  virtual ~ArcVideoAccelerator() {}
+};
+
+}  // namespace arc
+}  // namespace chromeos
+
+#endif  // CHROME_GPU_ARC_VIDEO_ACCELERATOR_H_