Home | History | Annotate | Download | only in hwc2 
      1 /*
      2 * Copyright (c) 2014 - 2016, The Linux Foundation. All rights reserved.
      3 *
      4 * Redistribution and use in source and binary forms, with or without
      5 * modification, are permitted provided that the following conditions are
      6 * met:
      7 *     * Redistributions of source code must retain the above copyright
      8 *       notice, this list of conditions and the following disclaimer.
      9 *     * Redistributions in binary form must reproduce the above
     10 *       copyright notice, this list of conditions and the following
     11 *       disclaimer in the documentation and/or other materials provided
     12 *       with the distribution.
     13 *     * Neither the name of The Linux Foundation nor the names of its
     14 *       contributors may be used to endorse or promote products derived
     15 *       from this software without specific prior written permission.
     16 *
     17 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
     18 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
     19 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
     20 * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
     21 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     22 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     23 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
     24 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
     25 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
     26 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
     27 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     28 */
     29 
     30 #include <cutils/properties.h>
     31 #include <utils/constants.h>
     32 #include <utils/debug.h>
     33 #include <algorithm>
     34 
     35 #include "hwc_display_external.h"
     36 #include "hwc_debugger.h"
     37 
     38 #define __CLASS__ "HWCDisplayExternal"
     39 
     40 namespace sdm {
     41 
     42 int HWCDisplayExternal::Create(CoreInterface *core_intf, HWCBufferAllocator *buffer_allocator,
     43                                HWCCallbacks *callbacks, qService::QService *qservice,
     44                                HWCDisplay **hwc_display) {
     45   return Create(core_intf, buffer_allocator, callbacks, 0, 0, qservice, false, hwc_display);
     46 }
     47 
     48 int HWCDisplayExternal::Create(CoreInterface *core_intf, HWCBufferAllocator *buffer_allocator,
     49                                HWCCallbacks *callbacks,
     50                                uint32_t primary_width, uint32_t primary_height,
     51                                qService::QService *qservice, bool use_primary_res,
     52                                HWCDisplay **hwc_display) {
     53   uint32_t external_width = 0;
     54   uint32_t external_height = 0;
     55   DisplayError error = kErrorNone;
     56 
     57   HWCDisplay *hwc_display_external = new HWCDisplayExternal(core_intf, buffer_allocator, callbacks,
     58                                                             qservice);
     59   int status = hwc_display_external->Init();
     60   if (status) {
     61     delete hwc_display_external;
     62     return status;
     63   }
     64 
     65   error = hwc_display_external->GetMixerResolution(&external_width, &external_height);
     66   if (error != kErrorNone) {
     67     return -EINVAL;
     68   }
     69 
     70   if (primary_width && primary_height) {
     71     // use_primary_res means HWCDisplayExternal should directly set framebuffer resolution to the
     72     // provided primary_width and primary_height
     73     if (use_primary_res) {
     74       external_width = primary_width;
     75       external_height = primary_height;
     76     } else {
     77       int downscale_enabled = 0;
     78       HWCDebugHandler::Get()->GetProperty("sdm.debug.downscale_external", &downscale_enabled);
     79       if (downscale_enabled) {
     80         GetDownscaleResolution(primary_width, primary_height, &external_width, &external_height);
     81       }
     82     }
     83   }
     84 
     85   status = hwc_display_external->SetFrameBufferResolution(external_width, external_height);
     86   if (status) {
     87     Destroy(hwc_display_external);
     88     return status;
     89   }
     90 
     91   *hwc_display = hwc_display_external;
     92 
     93   return status;
     94 }
     95 
     96 void HWCDisplayExternal::Destroy(HWCDisplay *hwc_display) {
     97   hwc_display->Deinit();
     98   delete hwc_display;
     99 }
    100 
    101 HWCDisplayExternal::HWCDisplayExternal(CoreInterface *core_intf,
    102                                        HWCBufferAllocator *buffer_allocator,
    103                                        HWCCallbacks *callbacks,
    104                                        qService::QService *qservice)
    105     : HWCDisplay(core_intf, callbacks, kHDMI, HWC_DISPLAY_EXTERNAL, false, qservice,
    106                  DISPLAY_CLASS_EXTERNAL, buffer_allocator) {
    107 }
    108 
    109 HWC2::Error HWCDisplayExternal::Validate(uint32_t *out_num_types, uint32_t *out_num_requests) {
    110   auto status = HWC2::Error::None;
    111 
    112   if (secure_display_active_) {
    113     MarkLayersForGPUBypass();
    114     return status;
    115   }
    116 
    117   BuildLayerStack();
    118 
    119   if (layer_set_.empty()) {
    120     flush_ = true;
    121     return status;
    122   }
    123 
    124   // TODO(user): SetRefreshRate need to follow new interface when added.
    125 
    126   status = PrepareLayerStack(out_num_types, out_num_requests);
    127   return status;
    128 }
    129 
    130 HWC2::Error HWCDisplayExternal::Present(int32_t *out_retire_fence) {
    131   auto status = HWC2::Error::None;
    132 
    133   if (!secure_display_active_) {
    134     status = HWCDisplay::CommitLayerStack();
    135     if (status == HWC2::Error::None) {
    136       status = HWCDisplay::PostCommitLayerStack(out_retire_fence);
    137     }
    138   }
    139   CloseAcquireFds();
    140   return status;
    141 }
    142 
    143 void HWCDisplayExternal::ApplyScanAdjustment(hwc_rect_t *display_frame) {
    144   if (display_intf_->IsUnderscanSupported()) {
    145     return;
    146   }
    147 
    148   // Read user defined width and height ratio
    149   int width = 0, height = 0;
    150   HWCDebugHandler::Get()->GetProperty("sdm.external_action_safe_width", &width);
    151   float width_ratio = FLOAT(width) / 100.0f;
    152   HWCDebugHandler::Get()->GetProperty("sdm.external_action_safe_height", &height);
    153   float height_ratio = FLOAT(height) / 100.0f;
    154 
    155   if (width_ratio == 0.0f || height_ratio == 0.0f) {
    156     return;
    157   }
    158 
    159   uint32_t mixer_width = 0;
    160   uint32_t mixer_height = 0;
    161   GetMixerResolution(&mixer_width, &mixer_height);
    162 
    163   if (mixer_width == 0 || mixer_height == 0) {
    164     DLOGV("Invalid mixer dimensions (%d, %d)", mixer_width, mixer_height);
    165     return;
    166   }
    167 
    168   uint32_t new_mixer_width = UINT32(mixer_width * FLOAT(1.0f - width_ratio));
    169   uint32_t new_mixer_height = UINT32(mixer_height * FLOAT(1.0f - height_ratio));
    170 
    171   int x_offset = INT((FLOAT(mixer_width) * width_ratio) / 2.0f);
    172   int y_offset = INT((FLOAT(mixer_height) * height_ratio) / 2.0f);
    173 
    174   display_frame->left = (display_frame->left * INT32(new_mixer_width) / INT32(mixer_width))
    175                         + x_offset;
    176   display_frame->top = (display_frame->top * INT32(new_mixer_height) / INT32(mixer_height)) +
    177                        y_offset;
    178   display_frame->right = ((display_frame->right * INT32(new_mixer_width)) / INT32(mixer_width)) +
    179                          x_offset;
    180   display_frame->bottom = ((display_frame->bottom * INT32(new_mixer_height)) / INT32(mixer_height))
    181                           + y_offset;
    182 }
    183 
    184 void HWCDisplayExternal::SetSecureDisplay(bool secure_display_active) {
    185   if (secure_display_active_ != secure_display_active) {
    186     secure_display_active_ = secure_display_active;
    187 
    188     if (secure_display_active_) {
    189       DisplayError error = display_intf_->Flush();
    190       if (error != kErrorNone) {
    191         DLOGE("Flush failed. Error = %d", error);
    192       }
    193     }
    194   }
    195   return;
    196 }
    197 
    198 static void AdjustSourceResolution(uint32_t dst_width, uint32_t dst_height, uint32_t *src_width,
    199                                    uint32_t *src_height) {
    200   *src_height = (dst_width * (*src_height)) / (*src_width);
    201   *src_width = dst_width;
    202 }
    203 
    204 void HWCDisplayExternal::GetDownscaleResolution(uint32_t primary_width, uint32_t primary_height,
    205                                                 uint32_t *non_primary_width,
    206                                                 uint32_t *non_primary_height) {
    207   uint32_t primary_area = primary_width * primary_height;
    208   uint32_t non_primary_area = (*non_primary_width) * (*non_primary_height);
    209 
    210   if (primary_area > non_primary_area) {
    211     if (primary_height > primary_width) {
    212       std::swap(primary_height, primary_width);
    213     }
    214     AdjustSourceResolution(primary_width, primary_height, non_primary_width, non_primary_height);
    215   }
    216 }
    217 
    218 }  // namespace sdm
    219