Home | History | Annotate | Download | only in libgralloc1 
      1 /*
      2  * Copyright (c) 2011-2017, 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 <string.h>
     31 
     32 #include <cutils/log.h>
     33 #include <cutils/properties.h>
     34 #include <dlfcn.h>
     35 
     36 #include "gralloc_priv.h"
     37 #include "gr_adreno_info.h"
     38 #include "gr_utils.h"
     39 
     40 namespace gralloc1 {
     41 
     42 AdrenoMemInfo::AdrenoMemInfo() {
     43 }
     44 
     45 bool AdrenoMemInfo::Init() {
     46   libadreno_utils_ = ::dlopen("libadreno_utils.so", RTLD_NOW);
     47   if (libadreno_utils_) {
     48     *reinterpret_cast<void **>(&LINK_adreno_compute_aligned_width_and_height) =
     49         ::dlsym(libadreno_utils_, "compute_aligned_width_and_height");
     50     *reinterpret_cast<void **>(&LINK_adreno_compute_padding) =
     51         ::dlsym(libadreno_utils_, "compute_surface_padding");
     52     *reinterpret_cast<void **>(&LINK_adreno_compute_compressedfmt_aligned_width_and_height) =
     53         ::dlsym(libadreno_utils_, "compute_compressedfmt_aligned_width_and_height");
     54     *reinterpret_cast<void **>(&LINK_adreno_isUBWCSupportedByGpu) =
     55         ::dlsym(libadreno_utils_, "isUBWCSupportedByGpu");
     56     *reinterpret_cast<void **>(&LINK_adreno_get_gpu_pixel_alignment) =
     57         ::dlsym(libadreno_utils_, "get_gpu_pixel_alignment");
     58   } else {
     59     ALOGE(" Failed to load libadreno_utils.so");
     60     return false;
     61   }
     62 
     63   // Check if the overriding property debug.gralloc.gfx_ubwc_disable_
     64   // that disables UBWC allocations for the graphics stack is set
     65   char property[PROPERTY_VALUE_MAX];
     66   property_get("debug.gralloc.gfx_ubwc_disable_", property, "0");
     67   if (!(strncmp(property, "1", PROPERTY_VALUE_MAX)) ||
     68       !(strncmp(property, "true", PROPERTY_VALUE_MAX))) {
     69     gfx_ubwc_disable_ = true;
     70   }
     71 
     72   if ((property_get("debug.gralloc.map_fb_memory", property, NULL) > 0) &&
     73       (!strncmp(property, "1", PROPERTY_VALUE_MAX) ||
     74        (!strncasecmp(property, "true", PROPERTY_VALUE_MAX)))) {
     75     map_fb_ = true;
     76   }
     77 
     78   return true;
     79 }
     80 
     81 AdrenoMemInfo::~AdrenoMemInfo() {
     82   if (libadreno_utils_) {
     83     ::dlclose(libadreno_utils_);
     84   }
     85 }
     86 
     87 void AdrenoMemInfo::AlignUnCompressedRGB(int width, int height, int format, int tile_enabled,
     88                                          unsigned int *aligned_w, unsigned int *aligned_h) {
     89   *aligned_w = (unsigned int)ALIGN(width, 32);
     90   *aligned_h = (unsigned int)ALIGN(height, 32);
     91 
     92   // Don't add any additional padding if debug.gralloc.map_fb_memory
     93   // is enabled
     94   if (map_fb_) {
     95     return;
     96   }
     97 
     98   int bpp = 4;
     99   switch (format) {
    100     case HAL_PIXEL_FORMAT_RGB_888:
    101       bpp = 3;
    102       break;
    103     case HAL_PIXEL_FORMAT_RGB_565:
    104     case HAL_PIXEL_FORMAT_BGR_565:
    105     case HAL_PIXEL_FORMAT_RGBA_5551:
    106     case HAL_PIXEL_FORMAT_RGBA_4444:
    107       bpp = 2;
    108       break;
    109     default:
    110       break;
    111   }
    112 
    113   int raster_mode = 0;          // Adreno unknown raster mode.
    114   int padding_threshold = 512;  // Threshold for padding surfaces.
    115   // the function below computes aligned width and aligned height
    116   // based on linear or macro tile mode selected.
    117   if (LINK_adreno_compute_aligned_width_and_height) {
    118     LINK_adreno_compute_aligned_width_and_height(
    119         width, height, bpp, tile_enabled, raster_mode, padding_threshold,
    120         reinterpret_cast<int *>(aligned_w), reinterpret_cast<int *>(aligned_h));
    121   } else if (LINK_adreno_compute_padding) {
    122     int surface_tile_height = 1;  // Linear surface
    123     *aligned_w = UINT(LINK_adreno_compute_padding(width, bpp, surface_tile_height, raster_mode,
    124                                                   padding_threshold));
    125     ALOGW("%s: Warning!! Old GFX API is used to calculate stride", __FUNCTION__);
    126   } else {
    127     ALOGW(
    128         "%s: Warning!! Symbols compute_surface_padding and "
    129         "compute_aligned_width_and_height not found",
    130         __FUNCTION__);
    131   }
    132 }
    133 
    134 void AdrenoMemInfo::AlignCompressedRGB(int width, int height, int format, unsigned int *aligned_w,
    135                                        unsigned int *aligned_h) {
    136   if (LINK_adreno_compute_compressedfmt_aligned_width_and_height) {
    137     int bytesPerPixel = 0;
    138     int raster_mode = 0;          // Adreno unknown raster mode.
    139     int padding_threshold = 512;  // Threshold for padding
    140     // surfaces.
    141 
    142     LINK_adreno_compute_compressedfmt_aligned_width_and_height(
    143         width, height, format, 0, raster_mode, padding_threshold,
    144         reinterpret_cast<int *>(aligned_w), reinterpret_cast<int *>(aligned_h), &bytesPerPixel);
    145   } else {
    146     ALOGW("%s: Warning!! compute_compressedfmt_aligned_width_and_height not found", __FUNCTION__);
    147   }
    148 }
    149 
    150 bool AdrenoMemInfo::IsUBWCSupportedByGPU(int format) {
    151   if (!gfx_ubwc_disable_ && LINK_adreno_isUBWCSupportedByGpu) {
    152     ADRENOPIXELFORMAT gpu_format = GetGpuPixelFormat(format);
    153     return LINK_adreno_isUBWCSupportedByGpu(gpu_format);
    154   }
    155 
    156   return false;
    157 }
    158 
    159 uint32_t AdrenoMemInfo::GetGpuPixelAlignment() {
    160   if (LINK_adreno_get_gpu_pixel_alignment) {
    161     return LINK_adreno_get_gpu_pixel_alignment();
    162   }
    163 
    164   return 1;
    165 }
    166 
    167 ADRENOPIXELFORMAT AdrenoMemInfo::GetGpuPixelFormat(int hal_format) {
    168   switch (hal_format) {
    169     case HAL_PIXEL_FORMAT_RGBA_8888:
    170       return ADRENO_PIXELFORMAT_R8G8B8A8;
    171     case HAL_PIXEL_FORMAT_RGBX_8888:
    172       return ADRENO_PIXELFORMAT_R8G8B8X8;
    173     case HAL_PIXEL_FORMAT_RGB_565:
    174       return ADRENO_PIXELFORMAT_B5G6R5;
    175     case HAL_PIXEL_FORMAT_BGR_565:
    176       return ADRENO_PIXELFORMAT_R5G6B5;
    177     case HAL_PIXEL_FORMAT_NV12_ENCODEABLE:
    178       return ADRENO_PIXELFORMAT_NV12;
    179     case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS:
    180     case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS_UBWC:
    181       return ADRENO_PIXELFORMAT_NV12_EXT;
    182     case HAL_PIXEL_FORMAT_RGBA_1010102:
    183        return ADRENO_PIXELFORMAT_R10G10B10A2_UNORM;
    184     case HAL_PIXEL_FORMAT_RGBX_1010102:
    185        return ADRENO_PIXELFORMAT_R10G10B10X2_UNORM;
    186     case HAL_PIXEL_FORMAT_ABGR_2101010:
    187        return ADRENO_PIXELFORMAT_A2B10G10R10_UNORM;
    188     default:
    189       ALOGE("%s: No map for format: 0x%x", __FUNCTION__, hal_format);
    190       break;
    191   }
    192 
    193   return ADRENO_PIXELFORMAT_UNKNOWN;
    194 }
    195 
    196 }  // namespace gralloc1
    197