Home | History | Annotate | Download | only in liboverlay
      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 
     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
     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 
     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 
     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 
     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 
     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 
    110 void MdpCtrl::setCrop(const utils::Dim& d) {
    111     setSrcRectDim(d);
    112 }
    113 
    114 void MdpCtrl::setPosition(const overlay::utils::Dim& d) {
    115     setDstRectDim(d);
    116 }
    117 
    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 
    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 
    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 
    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 
    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.
    181 void MdpCtrl::updateSrcFormat(const uint32_t& rotDestFmt) {
    182     utils::Whf whf = getSrcWhf();
    183     whf.format =  rotDestFmt;
    184     setSrcWhf(whf);
    185 }
    186 
    187 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 
    194 void MdpCtrl::getDump(char *buf, size_t len) {
    195     ovutils::getDump(buf, len, "Ctrl(mdp_overlay)", mOVInfo);
    196 }
    197 
    198 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 
    205 void MdpData::getDump(char *buf, size_t len) {
    206     ovutils::getDump(buf, len, "Data(msmfb_overlay_data)", mOvData);
    207 }
    208 
    209 void MdpCtrl3D::dump() const {
    210     ALOGE("== Dump MdpCtrl start ==");
    211     mFd.dump();
    212     ALOGE("== Dump MdpCtrl end ==");
    213 }
    214 
    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