Home | History | Annotate | Download | only in include 
      1 /*
      2  * Copyright (C) 2008 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 #ifndef GRALLOC_PRIV_H_
     18 #define GRALLOC_PRIV_H_
     19 
     20 #include <stdint.h>
     21 #include <limits.h>
     22 #include <sys/cdefs.h>
     23 #include <hardware/gralloc.h>
     24 #include <pthread.h>
     25 #include <errno.h>
     26 #include <unistd.h>
     27 
     28 #include <cutils/native_handle.h>
     29 
     30 #include <linux/fb.h>
     31 
     32 /*****************************************************************************/
     33 
     34 struct private_module_t;
     35 struct private_handle_t;
     36 
     37 struct private_module_t {
     38     gralloc_module_t base;
     39 
     40     private_handle_t* framebuffer;
     41     uint32_t flags;
     42     uint32_t numBuffers;
     43     uint32_t bufferMask;
     44     pthread_mutex_t lock;
     45     buffer_handle_t currentBuffer;
     46     int ionfd;
     47 
     48     int xres;
     49     int yres;
     50     int line_length;
     51     float xdpi;
     52     float ydpi;
     53     float fps;
     54     void *queue;
     55     pthread_mutex_t queue_lock;
     56 
     57 };
     58 
     59 /*****************************************************************************/
     60 
     61 #ifdef __cplusplus
     62 struct private_handle_t : public native_handle {
     63 #else
     64 struct private_handle_t {
     65     struct native_handle nativeHandle;
     66 #endif
     67 
     68     enum {
     69         PRIV_FLAGS_FRAMEBUFFER = 0x00000001,
     70         PRIV_FLAGS_USES_UMP    = 0x00000002,
     71         PRIV_FLAGS_USES_ION    = 0x00000020
     72     };
     73 
     74     // file-descriptors
     75     int     fd;
     76     int     fd1;
     77     int     fd2;
     78     // ints
     79     int     magic;
     80     int     flags;
     81     int     size;
     82     int     offset;
     83 
     84     int     format;
     85     int     width;
     86     int     height;
     87     int     stride;
     88     int     vstride;
     89 
     90     // FIXME: the attributes below should be out-of-line
     91     void    *base;
     92     void    *base1;
     93     void    *base2;
     94     struct ion_handle *handle;
     95     struct ion_handle *handle1;
     96     struct ion_handle *handle2;
     97 
     98 #ifdef __cplusplus
     99     static const int sNumFds = 3;
    100     static const int sNumInts = 15;
    101     static const int sMagic = 0x3141592;
    102 
    103 
    104     private_handle_t(int fd, int size, int flags, int w,
    105 		     int h, int format, int stride, int vstride) :
    106         fd(fd), fd1(-1), fd2(-1), magic(sMagic), flags(flags), size(size),
    107         offset(0), format(format), width(w), height(h), stride(stride),
    108         vstride(vstride), base(0), handle(0), handle1(0), handle2(0)
    109     {
    110         version = sizeof(native_handle);
    111         numInts = sNumInts + 2;
    112         numFds = sNumFds - 2;
    113     }
    114 
    115     private_handle_t(int fd, int fd1, int size, int flags, int w,
    116 		     int h, int format, int stride, int vstride) :
    117         fd(fd), fd1(fd1), fd2(-1), magic(sMagic), flags(flags), size(size),
    118         offset(0), format(format), width(w), height(h), stride(stride),
    119         vstride(vstride), base(0), base1(0), base2(0), handle(0), handle1(0),
    120         handle2(0)
    121     {
    122         version = sizeof(native_handle);
    123         numInts = sNumInts + 1;
    124         numFds = sNumFds - 1;
    125     }
    126 
    127     private_handle_t(int fd, int fd1, int fd2, int size, int flags, int w,
    128 		     int h, int format, int stride, int vstride) :
    129         fd(fd), fd1(fd1), fd2(fd2), magic(sMagic), flags(flags), size(size),
    130         offset(0), format(format), width(w), height(h), stride(stride),
    131         vstride(vstride), base(0), base1(0), base2(0), handle(0), handle1(0),
    132         handle2(0)
    133     {
    134         version = sizeof(native_handle);
    135         numInts = sNumInts;
    136         numFds = sNumFds;
    137     }
    138     ~private_handle_t() {
    139         magic = 0;
    140     }
    141 
    142     static int validate(const native_handle* h) {
    143         const private_handle_t* hnd = (const private_handle_t*)h;
    144         if (!h || h->version != sizeof(native_handle) ||
    145             hnd->numInts + hnd->numFds != sNumInts + sNumFds ||
    146             hnd->magic != sMagic)
    147         {
    148             ALOGE("invalid gralloc handle (at %p)", reinterpret_cast<void *>(const_cast<native_handle *>(h)));
    149             return -EINVAL;
    150         }
    151         return 0;
    152     }
    153 
    154     static private_handle_t* dynamicCast(const native_handle* in)
    155     {
    156         if (validate(in) == 0)
    157             return (private_handle_t*) in;
    158 
    159         return NULL;
    160     }
    161 
    162 #endif
    163 };
    164 
    165 #endif /* GRALLOC_PRIV_H_ */
    166