1/*
2 * Copyright (C) 2008 The Android Open Source Project
3 * Copyright (c) 2011-2012, 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 GR_H_
19#define GR_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
28#include <cutils/native_handle.h>
29#include <utils/Singleton.h>
30
31/*****************************************************************************/
32
33struct private_module_t;
34struct private_handle_t;
35
36inline size_t roundUpToPageSize(size_t x) {
37    return (x + (PAGE_SIZE-1)) & ~(PAGE_SIZE-1);
38}
39
40template <class Type>
41inline Type ALIGN(Type x, Type align) {
42    return (x + align-1) & ~(align-1);
43}
44
45#define FALSE 0
46#define TRUE  1
47
48int mapFrameBufferLocked(struct private_module_t* module);
49int terminateBuffer(gralloc_module_t const* module, private_handle_t* hnd);
50size_t getBufferSizeAndDimensions(int width, int height, int format, int usage,
51                                  int& alignedw, int &alignedh);
52size_t getBufferSizeAndDimensions(int width, int height, int format,
53                                  int& alignedw, int &alignedh);
54
55
56// Attributes include aligned width, aligned height, tileEnabled and size of the buffer
57void getBufferAttributes(int width, int height, int format, int usage,
58                           int& alignedw, int &alignedh,
59                           int& tileEnabled, size_t &size);
60
61
62bool isMacroTileEnabled(int format, int usage);
63
64int decideBufferHandlingMechanism(int format, const char *compositionUsed,
65                                  int hasBlitEngine, int *needConversion,
66                                  int *useBufferDirectly);
67
68// Allocate buffer from width, height, format into a private_handle_t
69// It is the responsibility of the caller to free the buffer
70int alloc_buffer(private_handle_t **pHnd, int w, int h, int format, int usage);
71void free_buffer(private_handle_t *hnd);
72int getYUVPlaneInfo(private_handle_t* pHnd, struct android_ycbcr* ycbcr);
73
74/*****************************************************************************/
75
76class Locker {
77    pthread_mutex_t mutex;
78    pthread_cond_t cond;
79    public:
80    class Autolock {
81        Locker& locker;
82        public:
83        inline Autolock(Locker& locker) : locker(locker) {  locker.lock(); }
84        inline ~Autolock() { locker.unlock(); }
85    };
86    inline Locker()        {
87        pthread_mutex_init(&mutex, 0);
88        pthread_cond_init(&cond, 0);
89    }
90    inline ~Locker()       {
91        pthread_mutex_destroy(&mutex);
92        pthread_cond_destroy(&cond);
93    }
94    inline void lock()     { pthread_mutex_lock(&mutex); }
95    inline void wait()     { pthread_cond_wait(&cond, &mutex); }
96    inline void unlock()   { pthread_mutex_unlock(&mutex); }
97    inline void signal()   { pthread_cond_signal(&cond); }
98};
99
100
101class AdrenoMemInfo : public android::Singleton <AdrenoMemInfo>
102{
103    public:
104    AdrenoMemInfo();
105
106    ~AdrenoMemInfo();
107
108    /*
109     * Function to compute the adreno aligned width and aligned height
110     * based on the width and format.
111     *
112     * @return aligned width, aligned height
113     */
114    void getAlignedWidthAndHeight(int width, int height, int format,
115                            int tileEnabled, int& alignedw, int &alignedh);
116
117    /*
118     * Function to return whether GPU support MacroTile feature
119     *
120     * @return >0 : supported
121     *          0 : not supported
122     */
123    int isMacroTilingSupportedByGPU();
124
125    private:
126        // Pointer to the padding library.
127        void *libadreno_utils;
128
129        // link(s)to adreno surface padding library.
130        int (*LINK_adreno_compute_padding) (int width, int bpp,
131                                                int surface_tile_height,
132                                                int screen_tile_height,
133                                                int padding_threshold);
134
135        void (*LINK_adreno_compute_aligned_width_and_height) (int width,
136                                                int height,
137                                                int bpp,
138                                                int tile_mode,
139                                                int raster_mode,
140                                                int padding_threshold,
141                                                int *aligned_w,
142                                                int *aligned_h);
143
144        int (*LINK_adreno_isMacroTilingSupportedByGpu) (void);
145
146        void(*LINK_adreno_compute_compressedfmt_aligned_width_and_height)(
147                                                int width,
148                                                int height,
149                                                int format,
150                                                int tile_mode,
151                                                int raster_mode,
152                                                int padding_threshold,
153                                                int *aligned_w,
154                                                int *aligned_h,
155                                                int *bpp);
156};
157#endif /* GR_H_ */
158