1 /*
2 * Copyright (C) 2008 The Android Open Source Project
3 * Copyright (c) 2010-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 OVERLAY_MDP_H
19 #define OVERLAY_MDP_H
20
21 #include <linux/msm_mdp.h>
22
23 #include "overlayUtils.h"
24 #include "mdpWrapper.h"
25 #include "qdMetaData.h"
26 #ifdef USES_POST_PROCESSING
27 #include "lib-postproc.h"
28 #endif
29
30 namespace overlay{
31
32 /*
33 * Mdp Ctrl holds corresponding fd and MDP related struct.
34 * It is simple wrapper to MDP services
35 * */
36 class MdpCtrl {
37 public:
38 /* ctor reset */
39 explicit MdpCtrl(const int& dpy);
40 /* dtor close */
41 ~MdpCtrl();
42 /* init underlying device using fbnum for dpy */
43 bool init(const int& dpy);
44 /* unset overlay, reset and close fd */
45 bool close();
46 /* reset and set ov id to -1 / MSMFB_NEW_REQUEST */
47 void reset();
48 /* calls overlay set
49 * Set would always consult last good known ov instance.
50 * Only if it is different, set would actually exectue ioctl.
51 * On a sucess ioctl. last good known ov instance is updated */
52 bool set();
53 /* Sets the source total width, height, format */
54 void setSource(const utils::PipeArgs& pargs);
55 /*
56 * Sets ROI, the unpadded region, for source buffer.
57 * Dim - ROI dimensions.
58 */
59 void setCrop(const utils::Dim& d);
60 /* set color for mdp pipe */
61 void setColor(const uint32_t color);
62 void setTransform(const utils::eTransform& orient);
63 /* given a dim and w/h, set overlay dim */
64 void setPosition(const utils::Dim& dim);
65 /* using user_data, sets/unsets roationvalue in mdp flags */
66 void setRotationFlags();
67 /* Update the src format with rotator's dest*/
68 void updateSrcFormat(const uint32_t& rotDstFormat);
69 /* dump state of the object */
70 void dump() const;
71 /* Return the dump in the specified buffer */
72 void getDump(char *buf, size_t len);
73 /* returns session id */
74 int getPipeId() const;
75 /* returns the fd associated to ctrl*/
76 int getFd() const;
77 /* returns a copy ro dst rect dim */
78 utils::Dim getDstRectDim() const;
79 /* returns a copy to src rect dim */
80 utils::Dim getSrcRectDim() const;
81 /* return pipe priority */
82 uint8_t getPriority() const;
83 /* setVisualParam */
84 bool setVisualParams(const MetaData_t& data);
85 /* sets pipe type RGB/DMA/VG */
86 void setPipeType(const utils::eMdpPipeType& pType);
87
88 static bool validateAndSet(MdpCtrl* mdpCtrlArray[], const int& count,
89 const int& fbFd);
90 private:
91 /* Perform transformation calculations */
92 void doTransform();
93 void doDownscale();
94 /* get orient / user_data[0] */
95 int getOrient() const;
96 /* returns flags from mdp structure */
97 int getFlags() const;
98 /* set flags to mdp structure */
99 void setFlags(int f);
100 /* set z order */
101 void setZ(utils::eZorder z);
102 /* set isFg flag */
103 void setIsFg(utils::eIsFg isFg);
104 /* return a copy of src whf*/
105 utils::Whf getSrcWhf() const;
106 /* set plane alpha */
107 void setPlaneAlpha(int planeAlpha);
108 /* set blending method */
109 void setBlending(overlay::utils::eBlending blending);
110
111 /* set src whf */
112 void setSrcWhf(const utils::Whf& whf);
113 /* set src/dst rect dim */
114 void setSrcRectDim(const utils::Dim d);
115 void setDstRectDim(const utils::Dim d);
116 /* returns user_data[0]*/
117 int getUserData() const;
118 /* sets user_data[0] */
119 void setUserData(int v);
120
121 utils::eTransform mOrientation; //Holds requested orientation
122 /* Actual overlay mdp structure */
123 mdp_overlay mOVInfo;
124 /* FD for the mdp fbnum */
125 OvFD mFd;
126 int mDpy;
127
128 #ifdef USES_POST_PROCESSING
129 /* PP Compute Params */
130 struct compute_params mParams;
131 #endif
132 };
133
134 /* MDP data */
135 class MdpData {
136 public:
137 /* ctor reset data */
138 explicit MdpData(const int& dpy);
139 /* dtor close*/
140 ~MdpData();
141 /* init FD */
142 bool init(const int& dpy);
143 /* memset0 the underlying mdp object */
144 void reset();
145 /* close fd, and reset */
146 bool close();
147 /* set id of mdp data */
148 void setPipeId(int id);
149 /* return ses id of data */
150 int getPipeId() const;
151 /* get underlying fd*/
152 int getFd() const;
153 /* get memory_id */
154 int getSrcMemoryId() const;
155 /* calls wrapper play */
156 bool play(int fd, uint32_t offset);
157 /* dump state of the object */
158 void dump() const;
159 /* Return the dump in the specified buffer */
160 void getDump(char *buf, size_t len);
161
162 private:
163
164 /* actual overlay mdp data */
165 msmfb_overlay_data mOvData;
166 /* fd to mdp fbnum */
167 OvFD mFd;
168 };
169
170 //--------------Inlines---------------------------------
171
172 ///// MdpCtrl //////
173
MdpCtrl(const int & dpy)174 inline MdpCtrl::MdpCtrl(const int& dpy) {
175 reset();
176 init(dpy);
177 }
178
~MdpCtrl()179 inline MdpCtrl::~MdpCtrl() {
180 close();
181 }
182
getOrient()183 inline int MdpCtrl::getOrient() const {
184 return getUserData();
185 }
186
getPipeId()187 inline int MdpCtrl::getPipeId() const {
188 return mOVInfo.id;
189 }
190
getFd()191 inline int MdpCtrl::getFd() const {
192 return mFd.getFD();
193 }
194
getFlags()195 inline int MdpCtrl::getFlags() const {
196 return mOVInfo.flags;
197 }
198
setFlags(int f)199 inline void MdpCtrl::setFlags(int f) {
200 mOVInfo.flags = f;
201 }
202
setZ(overlay::utils::eZorder z)203 inline void MdpCtrl::setZ(overlay::utils::eZorder z) {
204 mOVInfo.z_order = z;
205 }
206
setIsFg(overlay::utils::eIsFg isFg)207 inline void MdpCtrl::setIsFg(overlay::utils::eIsFg isFg) {
208 mOVInfo.is_fg = isFg;
209 }
210
setPlaneAlpha(int planeAlpha)211 inline void MdpCtrl::setPlaneAlpha(int planeAlpha) {
212 mOVInfo.alpha = planeAlpha;
213 }
214
setBlending(overlay::utils::eBlending blending)215 inline void MdpCtrl::setBlending(overlay::utils::eBlending blending) {
216 switch((int) blending) {
217 case utils::OVERLAY_BLENDING_OPAQUE:
218 mOVInfo.blend_op = BLEND_OP_OPAQUE;
219 break;
220 case utils::OVERLAY_BLENDING_PREMULT:
221 mOVInfo.blend_op = BLEND_OP_PREMULTIPLIED;
222 break;
223 case utils::OVERLAY_BLENDING_COVERAGE:
224 default:
225 mOVInfo.blend_op = BLEND_OP_COVERAGE;
226 }
227 }
228
getSrcWhf()229 inline overlay::utils::Whf MdpCtrl::getSrcWhf() const {
230 return utils::Whf( mOVInfo.src.width,
231 mOVInfo.src.height,
232 mOVInfo.src.format);
233 }
234
setSrcWhf(const overlay::utils::Whf & whf)235 inline void MdpCtrl::setSrcWhf(const overlay::utils::Whf& whf) {
236 mOVInfo.src.width = whf.w;
237 mOVInfo.src.height = whf.h;
238 mOVInfo.src.format = whf.format;
239 }
240
getSrcRectDim()241 inline overlay::utils::Dim MdpCtrl::getSrcRectDim() const {
242 return utils::Dim( mOVInfo.src_rect.x,
243 mOVInfo.src_rect.y,
244 mOVInfo.src_rect.w,
245 mOVInfo.src_rect.h);
246 }
247
setSrcRectDim(const overlay::utils::Dim d)248 inline void MdpCtrl::setSrcRectDim(const overlay::utils::Dim d) {
249 mOVInfo.src_rect.x = d.x;
250 mOVInfo.src_rect.y = d.y;
251 mOVInfo.src_rect.w = d.w;
252 mOVInfo.src_rect.h = d.h;
253 }
254
getDstRectDim()255 inline overlay::utils::Dim MdpCtrl::getDstRectDim() const {
256 return utils::Dim( mOVInfo.dst_rect.x,
257 mOVInfo.dst_rect.y,
258 mOVInfo.dst_rect.w,
259 mOVInfo.dst_rect.h);
260 }
261
setDstRectDim(const overlay::utils::Dim d)262 inline void MdpCtrl::setDstRectDim(const overlay::utils::Dim d) {
263 mOVInfo.dst_rect.x = d.x;
264 mOVInfo.dst_rect.y = d.y;
265 mOVInfo.dst_rect.w = d.w;
266 mOVInfo.dst_rect.h = d.h;
267 }
268
getUserData()269 inline int MdpCtrl::getUserData() const { return mOVInfo.user_data[0]; }
270
setUserData(int v)271 inline void MdpCtrl::setUserData(int v) { mOVInfo.user_data[0] = v; }
272
setRotationFlags()273 inline void MdpCtrl::setRotationFlags() {
274 const int u = getUserData();
275 if (u & MDP_ROT_90)
276 mOVInfo.flags |= MDP_SOURCE_ROTATED_90;
277 }
278
getPriority()279 inline uint8_t MdpCtrl::getPriority() const {
280 return mOVInfo.priority;
281 }
282
283 /////// MdpData //////
284
MdpData(const int & dpy)285 inline MdpData::MdpData(const int& dpy) {
286 reset();
287 init(dpy);
288 }
289
~MdpData()290 inline MdpData::~MdpData() { close(); }
291
reset()292 inline void MdpData::reset() {
293 overlay::utils::memset0(mOvData);
294 mOvData.data.memory_id = -1;
295 }
296
close()297 inline bool MdpData::close() {
298 reset();
299 return mFd.close();
300 }
301
getSrcMemoryId()302 inline int MdpData::getSrcMemoryId() const { return mOvData.data.memory_id; }
303
setPipeId(int id)304 inline void MdpData::setPipeId(int id) { mOvData.id = id; }
305
getPipeId()306 inline int MdpData::getPipeId() const { return mOvData.id; }
307
getFd()308 inline int MdpData::getFd() const { return mFd.getFD(); }
309
play(int fd,uint32_t offset)310 inline bool MdpData::play(int fd, uint32_t offset) {
311 mOvData.data.memory_id = fd;
312 mOvData.data.offset = offset;
313 if(!mdp_wrapper::play(mFd.getFD(), mOvData)){
314 ALOGE("MdpData failed to play");
315 dump();
316 return false;
317 }
318 return true;
319 }
320
321 } // overlay
322
323 #endif // OVERLAY_MDP_H
324