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 #include <mdp_version.h>
19 #include "overlayUtils.h"
20 #include "overlayMdp.h"
21 #include "mdp_version.h"
22 
23 #define HSIC_SETTINGS_DEBUG 0
24 
isEqual(float f1,float f2)25 static inline bool isEqual(float f1, float f2) {
26         return ((int)(f1*100) == (int)(f2*100)) ? true : false;
27 }
28 
29 namespace ovutils = overlay::utils;
30 namespace overlay {
31 
32 //Helper to even out x,w and y,h pairs
33 //x,y are always evened to ceil and w,h are evened to floor
normalizeCrop(uint32_t & xy,uint32_t & wh)34 static void normalizeCrop(uint32_t& xy, uint32_t& wh) {
35     if(xy & 1) {
36         utils::even_ceil(xy);
37         if(wh & 1)
38             utils::even_floor(wh);
39         else
40             wh -= 2;
41     } else {
42         utils::even_floor(wh);
43     }
44 }
45 
init(uint32_t fbnum)46 bool MdpCtrl::init(uint32_t fbnum) {
47     // FD init
48     if(!utils::openDev(mFd, fbnum,
49                 Res::fbPath, O_RDWR)){
50         ALOGE("Ctrl failed to init fbnum=%d", fbnum);
51         return false;
52     }
53     return true;
54 }
55 
reset()56 void MdpCtrl::reset() {
57     utils::memset0(mOVInfo);
58     utils::memset0(mLkgo);
59     mOVInfo.id = MSMFB_NEW_REQUEST;
60     mLkgo.id = MSMFB_NEW_REQUEST;
61     mOrientation = utils::OVERLAY_TRANSFORM_0;
62     mDownscale = 0;
63 #ifdef USES_POST_PROCESSING
64     mPPChanged = false;
65     memset(&mParams, 0, sizeof(struct compute_params));
66     mParams.params.conv_params.order = hsic_order_hsc_i;
67     mParams.params.conv_params.interface = interface_rec601;
68     mParams.params.conv_params.cc_matrix[0][0] = 1;
69     mParams.params.conv_params.cc_matrix[1][1] = 1;
70     mParams.params.conv_params.cc_matrix[2][2] = 1;
71 #endif
72 }
73 
close()74 bool MdpCtrl::close() {
75     bool result = true;
76     if(MSMFB_NEW_REQUEST != static_cast<int>(mOVInfo.id)) {
77         if(!mdp_wrapper::unsetOverlay(mFd.getFD(), mOVInfo.id)) {
78             ALOGE("MdpCtrl close error in unset");
79             result = false;
80         }
81     }
82 #ifdef USES_POST_PROCESSING
83     /* free allocated memory in PP */
84     if (mOVInfo.overlay_pp_cfg.igc_cfg.c0_c1_data)
85             free(mOVInfo.overlay_pp_cfg.igc_cfg.c0_c1_data);
86 #endif
87     reset();
88 
89     if(!mFd.close()) {
90         result = false;
91     }
92 
93     return result;
94 }
95 
setSource(const utils::PipeArgs & args)96 void MdpCtrl::setSource(const utils::PipeArgs& args) {
97     setSrcWhf(args.whf);
98 
99     //TODO These are hardcoded. Can be moved out of setSource.
100     mOVInfo.transp_mask = 0xffffffff;
101 
102     //TODO These calls should ideally be a part of setPipeParams API
103     setFlags(args.mdpFlags);
104     setZ(args.zorder);
105     setIsFg(args.isFg);
106     setPlaneAlpha(args.planeAlpha);
107     setBlending(args.blending);
108 }
109 
setCrop(const utils::Dim & d)110 void MdpCtrl::setCrop(const utils::Dim& d) {
111     setSrcRectDim(d);
112 }
113 
setPosition(const overlay::utils::Dim & d)114 void MdpCtrl::setPosition(const overlay::utils::Dim& d) {
115     setDstRectDim(d);
116 }
117 
setTransform(const utils::eTransform & orient)118 void MdpCtrl::setTransform(const utils::eTransform& orient) {
119     int rot = utils::getMdpOrient(orient);
120     setUserData(rot);
121     //getMdpOrient will switch the flips if the source is 90 rotated.
122     //Clients in Android dont factor in 90 rotation while deciding the flip.
123     mOrientation = static_cast<utils::eTransform>(rot);
124 }
125 
doTransform()126 void MdpCtrl::doTransform() {
127     setRotationFlags();
128     utils::Whf whf = getSrcWhf();
129     utils::Dim dim = getSrcRectDim();
130     utils::preRotateSource(mOrientation, whf, dim);
131     setSrcWhf(whf);
132     setSrcRectDim(dim);
133 }
134 
doDownscale()135 void MdpCtrl::doDownscale() {
136     mOVInfo.src_rect.x >>= mDownscale;
137     mOVInfo.src_rect.y >>= mDownscale;
138     mOVInfo.src_rect.w >>= mDownscale;
139     mOVInfo.src_rect.h >>= mDownscale;
140 }
141 
set()142 bool MdpCtrl::set() {
143     //deferred calcs, so APIs could be called in any order.
144     doTransform();
145     doDownscale();
146     utils::Whf whf = getSrcWhf();
147     if(utils::isYuv(whf.format)) {
148         normalizeCrop(mOVInfo.src_rect.x, mOVInfo.src_rect.w);
149         normalizeCrop(mOVInfo.src_rect.y, mOVInfo.src_rect.h);
150         utils::even_floor(mOVInfo.dst_rect.w);
151         utils::even_floor(mOVInfo.dst_rect.h);
152     }
153 
154     if(this->ovChanged()) {
155         if(!mdp_wrapper::setOverlay(mFd.getFD(), mOVInfo)) {
156             ALOGE("MdpCtrl failed to setOverlay, restoring last known "
157                   "good ov info");
158             mdp_wrapper::dump("== Bad OVInfo is: ", mOVInfo);
159             mdp_wrapper::dump("== Last good known OVInfo is: ", mLkgo);
160             this->restore();
161             return false;
162         }
163         this->save();
164     }
165 
166     return true;
167 }
168 
get()169 bool MdpCtrl::get() {
170     mdp_overlay ov;
171     ov.id = mOVInfo.id;
172     if (!mdp_wrapper::getOverlay(mFd.getFD(), ov)) {
173         ALOGE("MdpCtrl get failed");
174         return false;
175     }
176     mOVInfo = ov;
177     return true;
178 }
179 
180 //Update src format based on rotator's destination format.
updateSrcFormat(const uint32_t & rotDestFmt)181 void MdpCtrl::updateSrcFormat(const uint32_t& rotDestFmt) {
182     utils::Whf whf = getSrcWhf();
183     whf.format =  rotDestFmt;
184     setSrcWhf(whf);
185 }
186 
dump() const187 void MdpCtrl::dump() const {
188     ALOGE("== Dump MdpCtrl start ==");
189     mFd.dump();
190     mdp_wrapper::dump("mOVInfo", mOVInfo);
191     ALOGE("== Dump MdpCtrl end ==");
192 }
193 
getDump(char * buf,size_t len)194 void MdpCtrl::getDump(char *buf, size_t len) {
195     ovutils::getDump(buf, len, "Ctrl(mdp_overlay)", mOVInfo);
196 }
197 
dump() const198 void MdpData::dump() const {
199     ALOGE("== Dump MdpData start ==");
200     mFd.dump();
201     mdp_wrapper::dump("mOvData", mOvData);
202     ALOGE("== Dump MdpData end ==");
203 }
204 
getDump(char * buf,size_t len)205 void MdpData::getDump(char *buf, size_t len) {
206     ovutils::getDump(buf, len, "Data(msmfb_overlay_data)", mOvData);
207 }
208 
dump() const209 void MdpCtrl3D::dump() const {
210     ALOGE("== Dump MdpCtrl start ==");
211     mFd.dump();
212     ALOGE("== Dump MdpCtrl end ==");
213 }
214 
setVisualParams(const MetaData_t & data)215 bool MdpCtrl::setVisualParams(const MetaData_t& data) {
216 #ifdef USES_POST_PROCESSING
217     bool needUpdate = false;
218     /* calculate the data */
219     if (data.operation & PP_PARAM_HSIC) {
220         if (mParams.params.pa_params.hue != data.hsicData.hue) {
221             ALOGD_IF(HSIC_SETTINGS_DEBUG,
222                 "Hue has changed from %d to %d",
223                 mParams.params.pa_params.hue,data.hsicData.hue);
224             needUpdate = true;
225         }
226 
227         if (!isEqual(mParams.params.pa_params.sat,
228             data.hsicData.saturation)) {
229             ALOGD_IF(HSIC_SETTINGS_DEBUG,
230                 "Saturation has changed from %f to %f",
231                 mParams.params.pa_params.sat,
232                 data.hsicData.saturation);
233             needUpdate = true;
234         }
235 
236         if (mParams.params.pa_params.intensity != data.hsicData.intensity) {
237             ALOGD_IF(HSIC_SETTINGS_DEBUG,
238                 "Intensity has changed from %d to %d",
239                 mParams.params.pa_params.intensity,
240                 data.hsicData.intensity);
241             needUpdate = true;
242         }
243 
244         if (!isEqual(mParams.params.pa_params.contrast,
245             data.hsicData.contrast)) {
246             ALOGD_IF(HSIC_SETTINGS_DEBUG,
247                 "Contrast has changed from %f to %f",
248                 mParams.params.pa_params.contrast,
249                 data.hsicData.contrast);
250             needUpdate = true;
251         }
252 
253         if (needUpdate) {
254             mParams.params.pa_params.hue = data.hsicData.hue;
255             mParams.params.pa_params.sat = data.hsicData.saturation;
256             mParams.params.pa_params.intensity = data.hsicData.intensity;
257             mParams.params.pa_params.contrast = data.hsicData.contrast;
258             mParams.params.pa_params.ops = MDP_PP_OPS_WRITE | MDP_PP_OPS_ENABLE;
259             mParams.operation |= PP_OP_PA;
260         }
261     }
262 
263     if (data.operation & PP_PARAM_SHARP2) {
264         if (mParams.params.sharp_params.strength != data.Sharp2Data.strength) {
265             needUpdate = true;
266         }
267         if (mParams.params.sharp_params.edge_thr != data.Sharp2Data.edge_thr) {
268             needUpdate = true;
269         }
270         if (mParams.params.sharp_params.smooth_thr !=
271                 data.Sharp2Data.smooth_thr) {
272             needUpdate = true;
273         }
274         if (mParams.params.sharp_params.noise_thr !=
275                 data.Sharp2Data.noise_thr) {
276             needUpdate = true;
277         }
278 
279         if (needUpdate) {
280             mParams.params.sharp_params.strength = data.Sharp2Data.strength;
281             mParams.params.sharp_params.edge_thr = data.Sharp2Data.edge_thr;
282             mParams.params.sharp_params.smooth_thr =
283                 data.Sharp2Data.smooth_thr;
284             mParams.params.sharp_params.noise_thr = data.Sharp2Data.noise_thr;
285             mParams.params.sharp_params.ops =
286                 MDP_PP_OPS_WRITE | MDP_PP_OPS_ENABLE;
287             mParams.operation |= PP_OP_SHARP;
288         }
289     }
290 
291     if (data.operation & PP_PARAM_IGC) {
292         if (mOVInfo.overlay_pp_cfg.igc_cfg.c0_c1_data == NULL){
293             uint32_t *igcData
294                 = (uint32_t *)malloc(2 * MAX_IGC_LUT_ENTRIES * sizeof(uint32_t));
295             if (!igcData) {
296                 ALOGE("IGC storage allocated failed");
297                 return false;
298             }
299             mOVInfo.overlay_pp_cfg.igc_cfg.c0_c1_data = igcData;
300             mOVInfo.overlay_pp_cfg.igc_cfg.c2_data
301                 = igcData + MAX_IGC_LUT_ENTRIES;
302         }
303 
304         memcpy(mParams.params.igc_lut_params.c0,
305             data.igcData.c0, sizeof(uint16_t) * MAX_IGC_LUT_ENTRIES);
306         memcpy(mParams.params.igc_lut_params.c1,
307             data.igcData.c1, sizeof(uint16_t) * MAX_IGC_LUT_ENTRIES);
308         memcpy(mParams.params.igc_lut_params.c2,
309             data.igcData.c2, sizeof(uint16_t) * MAX_IGC_LUT_ENTRIES);
310 
311         mParams.params.igc_lut_params.ops
312             = MDP_PP_OPS_WRITE | MDP_PP_OPS_ENABLE;
313         mParams.operation |= PP_OP_IGC;
314         needUpdate = true;
315     }
316 
317     if (data.operation & PP_PARAM_VID_INTFC) {
318         mParams.params.conv_params.interface =
319             (interface_type) data.video_interface;
320         needUpdate = true;
321     }
322 
323     if (needUpdate) {
324         display_pp_compute_params(&mParams, &mOVInfo.overlay_pp_cfg);
325         mPPChanged = true;
326     }
327 #endif
328     return true;
329 }
330 
331 } // overlay
332