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