Integrate from //sandbox/mathias/donut/...@145728
SurfaceFlinger rework for new EGL driver model support.
diff --git a/modules/gralloc/gralloc_priv.h b/modules/gralloc/gralloc_priv.h
new file mode 100644
index 0000000..a6fa69a
--- /dev/null
+++ b/modules/gralloc/gralloc_priv.h
@@ -0,0 +1,209 @@
+/*
+ * 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.
+ */
+
+#ifndef GRALLOC_PRIV_H_
+#define GRALLOC_PRIV_H_
+
+#include <stdint.h>
+#include <asm/page.h>
+#include <limits.h>
+#include <sys/cdefs.h>
+#include <hardware/gralloc.h>
+#include <pthread.h>
+
+#include <cutils/native_handle.h>
+
+#if HAVE_ANDROID_OS
+#include <linux/fb.h>
+#endif
+
+/*****************************************************************************/
+
+inline size_t roundUpToPageSize(size_t x) {
+ return (x + (PAGESIZE-1)) & ~(PAGESIZE-1);
+}
+
+int mapFrameBufferLocked(struct private_module_t* module);
+
+/*****************************************************************************/
+
+struct private_handle_t;
+
+struct private_module_t {
+ gralloc_module_t base;
+
+ private_handle_t* framebuffer;
+ uint32_t flags;
+ uint32_t numBuffers;
+ uint32_t bufferMask;
+ pthread_mutex_t lock;
+ buffer_handle_t currentBuffer;
+ struct fb_var_screeninfo info;
+ struct fb_fix_screeninfo finfo;
+ float xdpi;
+ float ydpi;
+ float fps;
+
+ enum {
+ PRIV_USAGE_LOCKED_FOR_POST = 0x80000000
+ };
+};
+
+/*****************************************************************************/
+
+struct private_handle_t : public native_handle
+{
+ enum {
+ PRIV_FLAGS_FRAMEBUFFER = 0x00000001,
+ PRIV_FLAGS_USES_PMEM = 0x00000002
+ };
+
+ int fd;
+ int magic;
+ int base;
+ int flags;
+ int size;
+
+ static const int sNumInts = 5;
+ static const int sNumFds = 1;
+ static const int sMagic = 0x3141592;
+
+ private_handle_t(int fd, int size, int flags) :
+ fd(fd), magic(sMagic), base(0), flags(flags), size(size) {
+ version = sizeof(native_handle);
+ numInts = sNumInts;
+ numFds = sNumFds;
+ }
+
+ ~private_handle_t() {
+ magic = 0;
+ }
+
+ bool usesPhysicallyContiguousMemory() {
+ return (flags & PRIV_FLAGS_USES_PMEM) != 0;
+ }
+
+ static int validate(const native_handle* h) {
+ if (!h || h->version != sizeof(native_handle) ||
+ h->numInts!=sNumInts || h->numFds!=sNumFds) {
+ return -EINVAL;
+ }
+ const private_handle_t* hnd = (const private_handle_t*)h;
+ if (hnd->magic != sMagic)
+ return -EINVAL;
+ return 0;
+ }
+
+ static private_handle_t* dynamicCast(const native_handle* in) {
+ if (validate(in) == 0) {
+ return (private_handle_t*) in;
+ }
+ return NULL;
+ }
+};
+
+/*****************************************************************************/
+
+template<typename T>
+struct growable_sorted_array_t {
+ int size;
+ int count;
+ T* data;
+
+ growable_sorted_array_t() : size(0), count(0), data(0) {
+ }
+
+ growable_sorted_array_t(int initialSize)
+ : size(initialSize), count(0), data(0)
+ {
+ data = new T[initialSize];
+ }
+
+ ~growable_sorted_array_t() {
+ delete[] data;
+ }
+
+ /** Returns true if we found an exact match.
+ * Argument index is set to the the first index >= key in place.
+ * Index will be in range 0..count inclusive.
+ *
+ */
+ bool find(const T& key, int& index) {
+ return binarySearch(0, count-1, key, index);
+ }
+
+ T* at(int index){
+ if (index >= 0 && index < count) {
+ return data + index;
+ }
+ return 0;
+ }
+
+ void insert(int index, const T& item) {
+ if (index >= 0 && index <= count) {
+ if (count + 1 > size) {
+ int newSize = size * 2;
+ if (newSize < count + 1) {
+ newSize = count + 1;
+ }
+ T* newData = new T[newSize];
+ if (size > 0) {
+ memcpy(newData, data, sizeof(T) * count);
+ }
+ data = newData;
+ size = newSize;
+ }
+ int toMove = count - index;
+ if (toMove > 0) {
+ memmove(data + index + 1, data + index, sizeof(T) * toMove);
+ }
+ count++;
+ data[index] = item;
+ }
+ }
+
+ void remove(int index) {
+ if (index >= 0 && index < count) {
+ int toMove = (count - 1) - index;
+ if (toMove > 0) {
+ memmove(data + index, data + index + 1, sizeof(T) * toMove);
+ }
+ count--;
+ }
+ }
+
+ /** Return the first index >= key. May be in range first..last+1. */
+ int binarySearch(int first, int last, const T& key, int& index)
+ {
+ while (first <= last) {
+ int mid = (first + last) / 2;
+ int cmp = compare(key, data[mid]);
+ if (cmp > 0) {
+ first = mid + 1;
+ } else if (cmp < 0) {
+ last = mid - 1;
+ } else {
+ index = mid;
+ return true;
+ }
+ }
+ index = first;
+ return false;
+ }
+};
+
+
+#endif /* GRALLOC_PRIV_H_ */