Home | History | Annotate | Download | only in libgralloc
      1 /*
      2  * Copyright (C) 2008 The Android Open Source Project
      3  * Copyright (c) 2011-2013, The Linux Foundation. All rights reserved.
      4  *
      5  * Licensed under the Apache License, Version 2.0 (the "License");
      6  * you may not use this file except in compliance with the License.
      7  * You may obtain a copy of the License at
      8  *
      9  *      http://www.apache.org/licenses/LICENSE-2.0
     10  *
     11  * Unless required by applicable law or agreed to in writing, software
     12  * distributed under the License is distributed on an "AS IS" BASIS,
     13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     14  * See the License for the specific language governing permissions and
     15  * limitations under the License.
     16  */
     17 
     18 #ifndef GRALLOC_PRIV_H_
     19 #define GRALLOC_PRIV_H_
     20 
     21 #include <stdint.h>
     22 #include <limits.h>
     23 #include <sys/cdefs.h>
     24 #include <hardware/gralloc.h>
     25 #include <pthread.h>
     26 #include <errno.h>
     27 #include <unistd.h>
     28 
     29 #include <cutils/native_handle.h>
     30 
     31 #include <cutils/log.h>
     32 
     33 #define ROUND_UP_PAGESIZE(x) ( (((unsigned long)(x)) + PAGE_SIZE-1)  & \
     34                                (~(PAGE_SIZE-1)) )
     35 
     36 enum {
     37     /* gralloc usage bits indicating the type
     38      * of allocation that should be used */
     39 
     40     /* SYSTEM heap comes from kernel vmalloc,
     41      * can never be uncached, is not secured*/
     42     GRALLOC_USAGE_PRIVATE_SYSTEM_HEAP     =       GRALLOC_USAGE_PRIVATE_0,
     43     /* SF heap is used for application buffers, is not secured */
     44     GRALLOC_USAGE_PRIVATE_UI_CONTIG_HEAP  =       GRALLOC_USAGE_PRIVATE_1,
     45     /* IOMMU heap comes from manually allocated pages,
     46      * can be cached/uncached, is not secured */
     47     GRALLOC_USAGE_PRIVATE_IOMMU_HEAP      =       GRALLOC_USAGE_PRIVATE_2,
     48     /* MM heap is a carveout heap for video, can be secured*/
     49     GRALLOC_USAGE_PRIVATE_MM_HEAP         =       GRALLOC_USAGE_PRIVATE_3,
     50     /* CAMERA heap is a carveout heap for camera, is not secured*/
     51     GRALLOC_USAGE_PRIVATE_CAMERA_HEAP     =       0x01000000,
     52 
     53     /* Set this for allocating uncached memory (using O_DSYNC)
     54      * cannot be used with noncontiguous heaps */
     55     GRALLOC_USAGE_PRIVATE_UNCACHED        =       0x02000000,
     56 
     57     /* Buffer content should be displayed on an external display only */
     58     GRALLOC_USAGE_PRIVATE_EXTERNAL_ONLY   =       0x08000000,
     59 
     60     /* Only this buffer content should be displayed on external, even if
     61      * other EXTERNAL_ONLY buffers are available. Used during suspend.
     62      */
     63     GRALLOC_USAGE_PRIVATE_EXTERNAL_BLOCK  =       0x00100000,
     64 
     65     /* Close Caption displayed on an external display only */
     66     GRALLOC_USAGE_PRIVATE_EXTERNAL_CC     =       0x00200000,
     67 
     68     /* Use this flag to request content protected buffers. Please note
     69      * that this flag is different from the GRALLOC_USAGE_PROTECTED flag
     70      * which can be used for buffers that are not secured for DRM
     71      * but still need to be protected from screen captures
     72      */
     73     GRALLOC_USAGE_PRIVATE_CP_BUFFER       =       0x00400000,
     74 };
     75 
     76 enum {
     77     /* Gralloc perform enums
     78     */
     79     GRALLOC_MODULE_PERFORM_CREATE_HANDLE_FROM_BUFFER = 1,
     80     GRALLOC_MODULE_PERFORM_GET_STRIDE,
     81     GRALLOC_MODULE_PERFORM_GET_CUSTOM_STRIDE_FROM_HANDLE,
     82 };
     83 
     84 #define GRALLOC_HEAP_MASK   (GRALLOC_USAGE_PRIVATE_UI_CONTIG_HEAP |\
     85                              GRALLOC_USAGE_PRIVATE_SYSTEM_HEAP    |\
     86                              GRALLOC_USAGE_PRIVATE_IOMMU_HEAP     |\
     87                              GRALLOC_USAGE_PRIVATE_MM_HEAP        |\
     88                              GRALLOC_USAGE_PRIVATE_CAMERA_HEAP)
     89 
     90 #define INTERLACE_MASK 0x80
     91 #define S3D_FORMAT_MASK 0xFF000
     92 /*****************************************************************************/
     93 enum {
     94     /* OEM specific HAL formats */
     95     HAL_PIXEL_FORMAT_NV12_ENCODEABLE        = 0x102,
     96     HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS     = 0x7FA30C04,
     97     HAL_PIXEL_FORMAT_YCbCr_420_SP_TILED     = 0x7FA30C03,
     98     HAL_PIXEL_FORMAT_YCbCr_420_SP           = 0x109,
     99     HAL_PIXEL_FORMAT_YCrCb_420_SP_ADRENO    = 0x7FA30C01,
    100     HAL_PIXEL_FORMAT_YCrCb_422_SP           = 0x10B,
    101     HAL_PIXEL_FORMAT_R_8                    = 0x10D,
    102     HAL_PIXEL_FORMAT_RG_88                  = 0x10E,
    103     HAL_PIXEL_FORMAT_YCbCr_444_SP           = 0x10F,
    104     HAL_PIXEL_FORMAT_YCrCb_444_SP           = 0x110,
    105     HAL_PIXEL_FORMAT_INTERLACE              = 0x180,
    106 
    107 };
    108 
    109 /* possible formats for 3D content*/
    110 enum {
    111     HAL_NO_3D                         = 0x0000,
    112     HAL_3D_IN_SIDE_BY_SIDE_L_R        = 0x10000,
    113     HAL_3D_IN_TOP_BOTTOM              = 0x20000,
    114     HAL_3D_IN_INTERLEAVE              = 0x40000,
    115     HAL_3D_IN_SIDE_BY_SIDE_R_L        = 0x80000,
    116     HAL_3D_OUT_SIDE_BY_SIDE           = 0x1000,
    117     HAL_3D_OUT_TOP_BOTTOM             = 0x2000,
    118     HAL_3D_OUT_INTERLEAVE             = 0x4000,
    119     HAL_3D_OUT_MONOSCOPIC             = 0x8000
    120 };
    121 
    122 enum {
    123     BUFFER_TYPE_UI = 0,
    124     BUFFER_TYPE_VIDEO
    125 };
    126 
    127 /*****************************************************************************/
    128 
    129 #ifdef __cplusplus
    130 struct private_handle_t : public native_handle {
    131 #else
    132     struct private_handle_t {
    133         native_handle_t nativeHandle;
    134 #endif
    135         enum {
    136             PRIV_FLAGS_FRAMEBUFFER        = 0x00000001,
    137             PRIV_FLAGS_USES_PMEM          = 0x00000002,
    138             PRIV_FLAGS_USES_PMEM_ADSP     = 0x00000004,
    139             PRIV_FLAGS_USES_ION           = 0x00000008,
    140             PRIV_FLAGS_USES_ASHMEM        = 0x00000010,
    141             PRIV_FLAGS_NEEDS_FLUSH        = 0x00000020,
    142             PRIV_FLAGS_DO_NOT_FLUSH       = 0x00000040,
    143             PRIV_FLAGS_SW_LOCK            = 0x00000080,
    144             PRIV_FLAGS_NONCONTIGUOUS_MEM  = 0x00000100,
    145             // Set by HWC when storing the handle
    146             PRIV_FLAGS_HWC_LOCK           = 0x00000200,
    147             PRIV_FLAGS_SECURE_BUFFER      = 0x00000400,
    148             // For explicit synchronization
    149             PRIV_FLAGS_UNSYNCHRONIZED     = 0x00000800,
    150             // Not mapped in userspace
    151             PRIV_FLAGS_NOT_MAPPED         = 0x00001000,
    152             // Display on external only
    153             PRIV_FLAGS_EXTERNAL_ONLY      = 0x00002000,
    154             // Display only this buffer on external
    155             PRIV_FLAGS_EXTERNAL_BLOCK     = 0x00004000,
    156             // Display this buffer on external as close caption
    157             PRIV_FLAGS_EXTERNAL_CC        = 0x00008000,
    158             PRIV_FLAGS_VIDEO_ENCODER      = 0x00010000,
    159             PRIV_FLAGS_CAMERA_WRITE       = 0x00020000,
    160             PRIV_FLAGS_CAMERA_READ        = 0x00040000,
    161             PRIV_FLAGS_HW_COMPOSER        = 0x00080000,
    162             PRIV_FLAGS_HW_TEXTURE         = 0x00100000,
    163             PRIV_FLAGS_ITU_R_601          = 0x00200000,
    164             PRIV_FLAGS_ITU_R_601_FR       = 0x00400000,
    165             PRIV_FLAGS_ITU_R_709          = 0x00800000,
    166         };
    167 
    168         // file-descriptors
    169         int     fd;
    170         int     fd_metadata;          // fd for the meta-data
    171         // ints
    172         int     magic;
    173         int     flags;
    174         int     size;
    175         int     offset;
    176         int     bufferType;
    177         int     base;
    178         int     offset_metadata;
    179         // The gpu address mapped into the mmu.
    180         int     gpuaddr;
    181         int     format;
    182         int     width;
    183         int     height;
    184         int     base_metadata;
    185 
    186 #ifdef __cplusplus
    187         static const int sNumInts = 12;
    188         static const int sNumFds = 2;
    189         static const int sMagic = 'gmsm';
    190 
    191         private_handle_t(int fd, int size, int flags, int bufferType,
    192                          int format,int width, int height, int eFd = -1,
    193                          int eOffset = 0, int eBase = 0) :
    194             fd(fd), fd_metadata(eFd), magic(sMagic),
    195             flags(flags), size(size), offset(0), bufferType(bufferType),
    196             base(0), offset_metadata(eOffset), gpuaddr(0),
    197             format(format), width(width), height(height),
    198             base_metadata(eBase)
    199         {
    200             version = sizeof(native_handle);
    201             numInts = sNumInts;
    202             numFds = sNumFds;
    203         }
    204         ~private_handle_t() {
    205             magic = 0;
    206         }
    207 
    208         bool usesPhysicallyContiguousMemory() {
    209             return (flags & PRIV_FLAGS_USES_PMEM) != 0;
    210         }
    211 
    212         static int validate(const native_handle* h) {
    213             const private_handle_t* hnd = (const private_handle_t*)h;
    214             if (!h || h->version != sizeof(native_handle) ||
    215                 h->numInts != sNumInts || h->numFds != sNumFds ||
    216                 hnd->magic != sMagic)
    217             {
    218                 ALOGD("Invalid gralloc handle (at %p): "
    219                       "ver(%d/%d) ints(%d/%d) fds(%d/%d) magic(%c%c%c%c/%c%c%c%c)",
    220                       h,
    221                       h ? h->version : -1, sizeof(native_handle),
    222                       h ? h->numInts : -1, sNumInts,
    223                       h ? h->numFds : -1, sNumFds,
    224                       hnd ? (((hnd->magic >> 24) & 0xFF)?
    225                              ((hnd->magic >> 24) & 0xFF) : '-') : '?',
    226                       hnd ? (((hnd->magic >> 16) & 0xFF)?
    227                              ((hnd->magic >> 16) & 0xFF) : '-') : '?',
    228                       hnd ? (((hnd->magic >> 8) & 0xFF)?
    229                              ((hnd->magic >> 8) & 0xFF) : '-') : '?',
    230                       hnd ? (((hnd->magic >> 0) & 0xFF)?
    231                              ((hnd->magic >> 0) & 0xFF) : '-') : '?',
    232                       (sMagic >> 24) & 0xFF,
    233                       (sMagic >> 16) & 0xFF,
    234                       (sMagic >> 8) & 0xFF,
    235                       (sMagic >> 0) & 0xFF);
    236                 return -EINVAL;
    237             }
    238             return 0;
    239         }
    240 
    241         static private_handle_t* dynamicCast(const native_handle* in) {
    242             if (validate(in) == 0) {
    243                 return (private_handle_t*) in;
    244             }
    245             return NULL;
    246         }
    247 #endif
    248     };
    249 
    250 #endif /* GRALLOC_PRIV_H_ */
    251