auto import from //depot/cupcake/@135843
diff --git a/modules/README.android b/modules/README.android
new file mode 100644
index 0000000..57abb72
--- /dev/null
+++ b/modules/README.android
@@ -0,0 +1,23 @@
+Default (and possibly architecture dependents) HAL modules go here.
+
+
+libhardware.so eventually should contain *just* the HAL hub
+(hardware.c), everything in it should be rewritten as modules.
+
+Modules are .so in /system/libs/hw/ and have a well defined naming
+convention:
+
+ /system/libs/hw/<*_HARDWARE_MODULE_ID>.<ro.product.board>.so
+ /system/libs/hw/<*_HARDWARE_MODULE_ID>.<ro.board.platform>.so
+ /system/libs/hw/<*_HARDWARE_MODULE_ID>.<ro.arch>.so
+ /system/libs/hw/<*_HARDWARE_MODULE_ID>.default.so
+
+They also have a well defined interface which lives in include/hardware/.
+
+A module can have several variants: "default", "arch" and "board", and they're
+loaded in the "board", "arch" and "default" order.
+The source code for the "board" variant, usually lives under partners/...
+
+The source code for "default" and "arch" would usually
+live under hardware/modules/.
+
diff --git a/modules/overlay/Android.mk b/modules/overlay/Android.mk
new file mode 100644
index 0000000..44b55af
--- /dev/null
+++ b/modules/overlay/Android.mk
@@ -0,0 +1,26 @@
+# Copyright (C) 2008 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+LOCAL_PATH := $(call my-dir)
+
+# HAL module implemenation, not prelinked and stored in
+# hw/<OVERLAY_HARDWARE_MODULE_ID>.<ro.product.board>.so
+include $(CLEAR_VARS)
+LOCAL_PRELINK_MODULE := false
+LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/hw
+LOCAL_SHARED_LIBRARIES := liblog
+LOCAL_SRC_FILES := overlay.cpp
+LOCAL_MODULE := overlay.trout
+include $(BUILD_SHARED_LIBRARY)
diff --git a/modules/overlay/README.android b/modules/overlay/README.android
new file mode 100644
index 0000000..971d619
--- /dev/null
+++ b/modules/overlay/README.android
@@ -0,0 +1,3 @@
+
+Skeleton for the "overlay" HAL module.
+
diff --git a/modules/overlay/overlay.cpp b/modules/overlay/overlay.cpp
new file mode 100644
index 0000000..0246b5b
--- /dev/null
+++ b/modules/overlay/overlay.cpp
@@ -0,0 +1,321 @@
+/*
+ * Copyright (C) 2008 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define LOG_TAG "Overlay"
+
+#include <hardware/hardware.h>
+#include <hardware/overlay.h>
+
+#include <fcntl.h>
+#include <errno.h>
+
+#include <cutils/log.h>
+#include <cutils/atomic.h>
+
+/*****************************************************************************/
+
+struct overlay_control_context_t {
+ struct overlay_control_device_t device;
+ /* our private state goes below here */
+};
+
+struct overlay_data_context_t {
+ struct overlay_data_device_t device;
+ /* our private state goes below here */
+};
+
+static int overlay_device_open(const struct hw_module_t* module, const char* name,
+ struct hw_device_t** device);
+
+static struct hw_module_methods_t overlay_module_methods = {
+ open: overlay_device_open
+};
+
+const struct overlay_module_t HAL_MODULE_INFO_SYM = {
+ common: {
+ tag: HARDWARE_MODULE_TAG,
+ version_major: 1,
+ version_minor: 0,
+ id: OVERLAY_HARDWARE_MODULE_ID,
+ name: "Sample Overlay module",
+ author: "The Android Open Source Project",
+ methods: &overlay_module_methods,
+ }
+};
+
+/*****************************************************************************/
+
+/*
+ * This is the overlay_t object, it is returned to the user and represents
+ * an overlay.
+ * This handles will be passed across processes and possibly given to other
+ * HAL modules (for instance video decode modules).
+ */
+
+class overlay_object : public overlay_t {
+
+ struct handle_t : public native_handle {
+ /* add the data fields we need here, for instance: */
+ int width;
+ int height;
+ };
+
+ handle_t mHandle;
+
+ static overlay_handle_t getHandleRef(struct overlay_t* overlay) {
+ /* returns a reference to the handle, caller doesn't take ownership */
+ return &(static_cast<overlay_object *>(overlay)->mHandle);
+ }
+
+public:
+ overlay_object() {
+ this->overlay_t::getHandleRef = getHandleRef;
+ mHandle.version = sizeof(native_handle);
+ mHandle.numFds = 0;
+ mHandle.numInts = 2; // extra ints we have in our handle
+ }
+};
+
+// ****************************************************************************
+// Control module
+// ****************************************************************************
+
+static int overlay_get(struct overlay_control_device_t *dev, int name) {
+ int result = -1;
+ switch (name) {
+ case OVERLAY_MINIFICATION_LIMIT:
+ result = 0; // 0 = no limit
+ break;
+ case OVERLAY_MAGNIFICATION_LIMIT:
+ result = 0; // 0 = no limit
+ break;
+ case OVERLAY_SCALING_FRAC_BITS:
+ result = 0; // 0 = infinite
+ break;
+ case OVERLAY_ROTATION_STEP_DEG:
+ result = 90; // 90 rotation steps (for instance)
+ break;
+ case OVERLAY_HORIZONTAL_ALIGNMENT:
+ result = 1; // 1-pixel alignment
+ break;
+ case OVERLAY_VERTICAL_ALIGNMENT:
+ result = 1; // 1-pixel alignment
+ break;
+ case OVERLAY_WIDTH_ALIGNMENT:
+ result = 1; // 1-pixel alignment
+ break;
+ case OVERLAY_HEIGHT_ALIGNMENT:
+ result = 1; // 1-pixel alignment
+ break;
+ }
+ return result;
+}
+
+static overlay_t* overlay_createOverlay(struct overlay_control_device_t *dev,
+ uint32_t w, uint32_t h, int32_t format)
+{
+ /* check the input params, reject if not supported or invalid */
+ switch (format) {
+ case OVERLAY_FORMAT_RGBA_8888:
+ case OVERLAY_FORMAT_RGB_565:
+ case OVERLAY_FORMAT_BGRA_8888:
+ case OVERLAY_FORMAT_YCbCr_422_SP:
+ case OVERLAY_FORMAT_YCbCr_420_SP:
+ case OVERLAY_FORMAT_YCbCr_422_I:
+ case OVERLAY_FORMAT_YCbCr_420_I:
+ break;
+ default:
+ return NULL;
+ }
+
+ /* Create overlay object. Talk to the h/w here and adjust to what it can
+ * do. the overlay_t returned can be a C++ object, subclassing overlay_t
+ * if needed.
+ *
+ * we probably want to keep a list of the overlay_t created so they can
+ * all be cleaned up in overlay_close().
+ */
+ return new overlay_object( /* pass needed params here*/ );
+}
+
+static void overlay_destroyOverlay(struct overlay_control_device_t *dev,
+ overlay_t* overlay)
+{
+ /* free resources associated with this overlay_t */
+ delete overlay;
+}
+
+static int overlay_setPosition(struct overlay_control_device_t *dev,
+ overlay_t* overlay,
+ int x, int y, uint32_t w, uint32_t h) {
+ /* set this overlay's position (talk to the h/w) */
+ return -EINVAL;
+}
+
+static int overlay_getPosition(struct overlay_control_device_t *dev,
+ overlay_t* overlay,
+ int* x, int* y, uint32_t* w, uint32_t* h) {
+ /* get this overlay's position */
+ return -EINVAL;
+}
+
+static int overlay_setParameter(struct overlay_control_device_t *dev,
+ overlay_t* overlay, int param, int value) {
+
+ int result = 0;
+ /* set this overlay's parameter (talk to the h/w) */
+ switch (param) {
+ case OVERLAY_ROTATION_DEG:
+ /* if only 90 rotations are supported, the call fails
+ * for other values */
+ break;
+ case OVERLAY_DITHER:
+ break;
+ case OVERLAY_TRANSFORM:
+ // see OVERLAY_TRANSFORM_*
+ break;
+ default:
+ result = -EINVAL;
+ break;
+ }
+ return result;
+}
+
+static int overlay_control_close(struct hw_device_t *dev)
+{
+ struct overlay_control_context_t* ctx = (struct overlay_control_context_t*)dev;
+ if (ctx) {
+ /* free all resources associated with this device here
+ * in particular the overlay_handle_t, outstanding overlay_t, etc...
+ */
+ free(ctx);
+ }
+ return 0;
+}
+
+// ****************************************************************************
+// Data module
+// ****************************************************************************
+
+int overlay_initialize(struct overlay_data_device_t *dev,
+ overlay_handle_t handle)
+{
+ /*
+ * overlay_handle_t should contain all the information to "inflate" this
+ * overlay. Typically it'll have a file descriptor, informations about
+ * how many buffers are there, etc...
+ * It is also the place to mmap all buffers associated with this overlay
+ * (see getBufferAddress).
+ *
+ * NOTE: this function doesn't take ownership of overlay_handle_t
+ *
+ */
+
+ return -EINVAL;
+}
+
+int overlay_dequeueBuffer(struct overlay_data_device_t *dev,
+ overlay_buffer_t* buf)
+{
+ /* blocks until a buffer is available and return an opaque structure
+ * representing this buffer.
+ */
+ return -EINVAL;
+}
+
+int overlay_queueBuffer(struct overlay_data_device_t *dev,
+ overlay_buffer_t buffer)
+{
+ /* Mark this buffer for posting and recycle or free overlay_buffer_t. */
+ return -EINVAL;
+}
+
+void *overlay_getBufferAddress(struct overlay_data_device_t *dev,
+ overlay_buffer_t buffer)
+{
+ /* this may fail (NULL) if this feature is not supported. In that case,
+ * presumably, there is some other HAL module that can fill the buffer,
+ * using a DSP for instance */
+ return NULL;
+}
+
+static int overlay_data_close(struct hw_device_t *dev)
+{
+ struct overlay_data_context_t* ctx = (struct overlay_data_context_t*)dev;
+ if (ctx) {
+ /* free all resources associated with this device here
+ * in particular all pending overlay_buffer_t if needed.
+ *
+ * NOTE: overlay_handle_t passed in initialize() is NOT freed and
+ * its file descriptors are not closed (this is the responsibility
+ * of the caller).
+ */
+ free(ctx);
+ }
+ return 0;
+}
+
+/*****************************************************************************/
+
+static int overlay_device_open(const struct hw_module_t* module, const char* name,
+ struct hw_device_t** device)
+{
+ int status = -EINVAL;
+ if (!strcmp(name, OVERLAY_HARDWARE_CONTROL)) {
+ struct overlay_control_context_t *dev;
+ dev = (overlay_control_context_t*)malloc(sizeof(*dev));
+
+ /* initialize our state here */
+ memset(dev, 0, sizeof(*dev));
+
+ /* initialize the procs */
+ dev->device.common.tag = HARDWARE_DEVICE_TAG;
+ dev->device.common.version = 0;
+ dev->device.common.module = const_cast<hw_module_t*>(module);
+ dev->device.common.close = overlay_control_close;
+
+ dev->device.get = overlay_get;
+ dev->device.createOverlay = overlay_createOverlay;
+ dev->device.destroyOverlay = overlay_destroyOverlay;
+ dev->device.setPosition = overlay_setPosition;
+ dev->device.getPosition = overlay_getPosition;
+ dev->device.setParameter = overlay_setParameter;
+
+ *device = &dev->device.common;
+ status = 0;
+ } else if (!strcmp(name, OVERLAY_HARDWARE_DATA)) {
+ struct overlay_data_context_t *dev;
+ dev = (overlay_data_context_t*)malloc(sizeof(*dev));
+
+ /* initialize our state here */
+ memset(dev, 0, sizeof(*dev));
+
+ /* initialize the procs */
+ dev->device.common.tag = HARDWARE_DEVICE_TAG;
+ dev->device.common.version = 0;
+ dev->device.common.module = const_cast<hw_module_t*>(module);
+ dev->device.common.close = overlay_data_close;
+
+ dev->device.initialize = overlay_initialize;
+ dev->device.dequeueBuffer = overlay_dequeueBuffer;
+ dev->device.queueBuffer = overlay_queueBuffer;
+ dev->device.getBufferAddress = overlay_getBufferAddress;
+
+ *device = &dev->device.common;
+ status = 0;
+ }
+ return status;
+}