hwc_mdpcomp.h revision 218456e025e792c12124c8d7a9e35c9df0fc1f5d 
1/*
2 * Copyright (C) 2012-2013, The Linux Foundation. All rights reserved.
3 *
4 * Not a Contribution, Apache license notifications and license are retained
5 * for attribution purposes only.
6 *
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
10 *
11 *      http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 */
19
20#ifndef HWC_MDP_COMP
21#define HWC_MDP_COMP
22
23#include <hwc_utils.h>
24#include <idle_invalidator.h>
25#include <cutils/properties.h>
26#include <overlay.h>
27
28#define DEFAULT_IDLE_TIME 2000
29#define MAX_PIPES_PER_MIXER 4
30
31namespace overlay {
32class Rotator;
33};
34
35namespace qhwc {
36namespace ovutils = overlay::utils;
37
38class MDPComp {
39public:
40    explicit MDPComp(int);
41    virtual ~MDPComp(){};
42    /*sets up mdp comp for the current frame */
43    int prepare(hwc_context_t *ctx, hwc_display_contents_1_t* list);
44    /* draw */
45    virtual bool draw(hwc_context_t *ctx, hwc_display_contents_1_t *list) = 0;
46    /* dumpsys */
47    void dump(android::String8& buf);
48
49    static MDPComp* getObject(const int& width, const int& rightSplit,
50            const int& dpy);
51    /* Handler to invoke frame redraw on Idle Timer expiry */
52    static void timeout_handler(void *udata);
53    /* Initialize MDP comp*/
54    static bool init(hwc_context_t *ctx);
55    static void resetIdleFallBack() { sIdleFallBack = false; }
56
57protected:
58    enum { MAX_SEC_LAYERS = 1 }; //TODO add property support
59
60    enum ePipeType {
61        MDPCOMP_OV_RGB = ovutils::OV_MDP_PIPE_RGB,
62        MDPCOMP_OV_VG = ovutils::OV_MDP_PIPE_VG,
63        MDPCOMP_OV_DMA = ovutils::OV_MDP_PIPE_DMA,
64        MDPCOMP_OV_ANY,
65    };
66
67    /* mdp pipe data */
68    struct MdpPipeInfo {
69        int zOrder;
70        virtual ~MdpPipeInfo(){};
71    };
72
73    /* per layer data */
74    struct PipeLayerPair {
75        MdpPipeInfo *pipeInfo;
76        overlay::Rotator* rot;
77        int listIndex;
78    };
79
80    /* per frame data */
81    struct FrameInfo {
82        /* maps layer list to mdp list */
83        int layerCount;
84        int layerToMDP[MAX_NUM_APP_LAYERS];
85
86        /* maps mdp list to layer list */
87        int mdpCount;
88        struct PipeLayerPair mdpToLayer[MAX_PIPES_PER_MIXER];
89
90        /* layer composing on FB? */
91        int fbCount;
92        bool isFBComposed[MAX_NUM_APP_LAYERS];
93
94        bool needsRedraw;
95        int fbZ;
96
97        /* c'tor */
98        FrameInfo();
99        /* clear old frame data */
100        void reset(const int& numLayers);
101        void map();
102    };
103
104    /* cached data */
105    struct LayerCache {
106        int layerCount;
107        int mdpCount;
108        int fbCount;
109        int fbZ;
110        buffer_handle_t hnd[MAX_NUM_APP_LAYERS];
111
112        /* c'tor */
113        LayerCache();
114        /* clear caching info*/
115        void reset();
116        void cacheAll(hwc_display_contents_1_t* list);
117        void updateCounts(const FrameInfo&);
118    };
119
120    /* allocates pipe from pipe book */
121    virtual bool allocLayerPipes(hwc_context_t *ctx,
122                                 hwc_display_contents_1_t* list) = 0;
123    /* allocate MDP pipes from overlay */
124    ovutils::eDest getMdpPipe(hwc_context_t *ctx, ePipeType type, int mixer);
125    /* configures MPD pipes */
126    virtual int configure(hwc_context_t *ctx, hwc_layer_1_t *layer,
127                          PipeLayerPair& pipeLayerPair) = 0;
128    /* Checks for pipes needed versus pipes available */
129    virtual bool arePipesAvailable(hwc_context_t *ctx,
130            hwc_display_contents_1_t* list) = 0;
131
132    /* set/reset flags for MDPComp */
133    void setMDPCompLayerFlags(hwc_context_t *ctx,
134                              hwc_display_contents_1_t* list);
135    /* checks for conditions where mdpcomp is not possible */
136    bool isFrameDoable(hwc_context_t *ctx);
137    /* checks for conditions where RGB layers cannot be bypassed */
138    bool isFullFrameDoable(hwc_context_t *ctx, hwc_display_contents_1_t* list);
139    /* checks if full MDP comp can be done */
140    bool fullMDPComp(hwc_context_t *ctx, hwc_display_contents_1_t* list);
141    /* check if we can use layer cache to do at least partial MDP comp */
142    bool partialMDPComp(hwc_context_t *ctx, hwc_display_contents_1_t* list);
143    /* checks for conditions where only video can be bypassed */
144    bool isOnlyVideoDoable(hwc_context_t *ctx, hwc_display_contents_1_t* list);
145    /* checks for conditions where YUV layers cannot be bypassed */
146    bool isYUVDoable(hwc_context_t* ctx, hwc_layer_1_t* layer);
147
148    /* Is debug enabled */
149    static bool isDebug() { return sDebugLogs ? true : false; };
150    /* Is feature enabled */
151    static bool isEnabled() { return sEnabled; };
152    /* checks for mdp comp dimension limitation */
153    bool isValidDimension(hwc_context_t *ctx, hwc_layer_1_t *layer);
154    /* tracks non updating layers*/
155    void updateLayerCache(hwc_context_t* ctx, hwc_display_contents_1_t* list);
156    /* optimize layers for mdp comp*/
157    bool batchLayers(hwc_context_t *ctx, hwc_display_contents_1_t* list);
158    /* updates cache map with YUV info */
159    void updateYUV(hwc_context_t* ctx, hwc_display_contents_1_t* list);
160    bool programMDP(hwc_context_t *ctx, hwc_display_contents_1_t* list);
161    bool programYUV(hwc_context_t *ctx, hwc_display_contents_1_t* list);
162    void reset(const int& numAppLayers, hwc_display_contents_1_t* list);
163    bool isSupportedForMDPComp(hwc_context_t *ctx, hwc_layer_1_t* layer);
164
165    int mDpy;
166    static bool sEnabled;
167    static bool sEnableMixedMode;
168    static bool sDebugLogs;
169    static bool sIdleFallBack;
170    static int sMaxPipesPerMixer;
171    static IdleInvalidator *idleInvalidator;
172    struct FrameInfo mCurrentFrame;
173    struct LayerCache mCachedFrame;
174};
175
176class MDPCompLowRes : public MDPComp {
177public:
178    explicit MDPCompLowRes(int dpy):MDPComp(dpy){};
179    virtual ~MDPCompLowRes(){};
180    virtual bool draw(hwc_context_t *ctx, hwc_display_contents_1_t *list);
181
182private:
183    struct MdpPipeInfoLowRes : public MdpPipeInfo {
184        ovutils::eDest index;
185        virtual ~MdpPipeInfoLowRes() {};
186    };
187
188    /* configure's overlay pipes for the frame */
189    virtual int configure(hwc_context_t *ctx, hwc_layer_1_t *layer,
190                          PipeLayerPair& pipeLayerPair);
191
192    /* allocates pipes to selected candidates */
193    virtual bool allocLayerPipes(hwc_context_t *ctx,
194                                 hwc_display_contents_1_t* list);
195
196    /* Checks for pipes needed versus pipes available */
197    virtual bool arePipesAvailable(hwc_context_t *ctx,
198            hwc_display_contents_1_t* list);
199};
200
201class MDPCompHighRes : public MDPComp {
202public:
203    explicit MDPCompHighRes(int dpy):MDPComp(dpy){};
204    virtual ~MDPCompHighRes(){};
205    virtual bool draw(hwc_context_t *ctx, hwc_display_contents_1_t *list);
206private:
207    struct MdpPipeInfoHighRes : public MdpPipeInfo {
208        ovutils::eDest lIndex;
209        ovutils::eDest rIndex;
210        virtual ~MdpPipeInfoHighRes() {};
211    };
212
213    bool acquireMDPPipes(hwc_context_t *ctx, hwc_layer_1_t* layer,
214                         MdpPipeInfoHighRes& pipe_info, ePipeType type);
215
216    /* configure's overlay pipes for the frame */
217    virtual int configure(hwc_context_t *ctx, hwc_layer_1_t *layer,
218                          PipeLayerPair& pipeLayerPair);
219
220    /* allocates pipes to selected candidates */
221    virtual bool allocLayerPipes(hwc_context_t *ctx,
222                                 hwc_display_contents_1_t* list);
223
224    /* Checks for pipes needed versus pipes available */
225    virtual bool arePipesAvailable(hwc_context_t *ctx,
226            hwc_display_contents_1_t* list);
227
228    int pipesNeeded(hwc_context_t *ctx, hwc_display_contents_1_t* list,
229            int mixer);
230};
231
232}; //namespace
233#endif
234