DisplayError ResourceDefault::Init() {
DisplayError error = kErrorNone;
num_pipe_ = hw_res_info_.num_vig_pipe + hw_res_info_.num_rgb_pipe + hw_res_info_.num_dma_pipe;
if (!num_pipe_) {
DLOGE("Number of H/W pipes is Zero!");
return kErrorParameters;
}
src_pipes_.resize(num_pipe_);
// Priority order of pipes: VIG, RGB, DMA
uint32_t vig_index = 0;
uint32_t rgb_index = hw_res_info_.num_vig_pipe;
uint32_t dma_index = rgb_index + hw_res_info_.num_rgb_pipe;
for (uint32_t i = 0; i < num_pipe_; i++) {
const HWPipeCaps &pipe_caps = hw_res_info_.hw_pipes.at(i);
if (pipe_caps.type == kPipeTypeVIG) {
src_pipes_[vig_index].type = kPipeTypeVIG;
src_pipes_[vig_index].index = i;
src_pipes_[vig_index].mdss_pipe_id = pipe_caps.id;
vig_index++;
} else if (pipe_caps.type == kPipeTypeRGB) {
src_pipes_[rgb_index].type = kPipeTypeRGB;
src_pipes_[rgb_index].index = i;
src_pipes_[rgb_index].mdss_pipe_id = pipe_caps.id;
rgb_index++;
} else if (pipe_caps.type == kPipeTypeDMA) {
src_pipes_[dma_index].type = kPipeTypeDMA;
src_pipes_[dma_index].index = i;
src_pipes_[dma_index].mdss_pipe_id = pipe_caps.id;
dma_index++;
}
}
for (uint32_t i = 0; i < num_pipe_; i++) {
src_pipes_[i].priority = INT(i);
}
DLOGI("hw_rev=%x, DMA=%d RGB=%d VIG=%d", hw_res_info_.hw_revision, hw_res_info_.num_dma_pipe,
hw_res_info_.num_rgb_pipe, hw_res_info_.num_vig_pipe);
if (hw_res_info_.max_scale_down < 1 || hw_res_info_.max_scale_up < 1) {
DLOGE("Max scaling setting is invalid! max_scale_down = %d, max_scale_up = %d",
hw_res_info_.max_scale_down, hw_res_info_.max_scale_up);
hw_res_info_.max_scale_down = 1;
hw_res_info_.max_scale_up = 1;
}
// TODO(user): clean it up, query from driver for initial pipe status.
#ifndef SDM_VIRTUAL_DRIVER
rgb_index = hw_res_info_.num_vig_pipe;
src_pipes_[rgb_index].owner = kPipeOwnerKernelMode;
src_pipes_[rgb_index + 1].owner = kPipeOwnerKernelMode;
#endif
return error;
}
HWCColorManager *HWCColorManager::CreateColorManager(HWCBufferAllocator * buffer_allocator) {
HWCColorManager *color_mgr = new HWCColorManager(buffer_allocator);
if (color_mgr) {
// Load display API interface library. And retrieve color API function tables.
DynLib &color_apis_lib = color_mgr->color_apis_lib_;
if (color_apis_lib.Open(DISPLAY_API_INTERFACE_LIBRARY_NAME)) {
if (!color_apis_lib.Sym(DISPLAY_API_FUNC_TABLES, &color_mgr->color_apis_)) {
DLOGE("Fail to retrieve = %s from %s", DISPLAY_API_FUNC_TABLES,
DISPLAY_API_INTERFACE_LIBRARY_NAME);
delete color_mgr;
return NULL;
}
} else {
DLOGW("Unable to load = %s", DISPLAY_API_INTERFACE_LIBRARY_NAME);
delete color_mgr;
return NULL;
}
DLOGI("Successfully loaded %s", DISPLAY_API_INTERFACE_LIBRARY_NAME);
// Load diagclient library and invokes its entry point to pass in display APIs.
DynLib &diag_client_lib = color_mgr->diag_client_lib_;
if (diag_client_lib.Open(QDCM_DIAG_CLIENT_LIBRARY_NAME)) {
if (!diag_client_lib.Sym(INIT_QDCM_DIAG_CLIENT_NAME,
reinterpret_cast<void **>(&color_mgr->qdcm_diag_init_)) ||
!diag_client_lib.Sym(DEINIT_QDCM_DIAG_CLIENT_NAME,
reinterpret_cast<void **>(&color_mgr->qdcm_diag_deinit_))) {
DLOGE("Fail to retrieve = %s from %s", INIT_QDCM_DIAG_CLIENT_NAME,
QDCM_DIAG_CLIENT_LIBRARY_NAME);
} else {
// invoke Diag Client entry point to initialize.
color_mgr->qdcm_diag_init_(color_mgr->color_apis_);
DLOGI("Successfully loaded %s and %s and diag_init'ed", DISPLAY_API_INTERFACE_LIBRARY_NAME,
QDCM_DIAG_CLIENT_LIBRARY_NAME);
}
} else {
DLOGW("Unable to load = %s", QDCM_DIAG_CLIENT_LIBRARY_NAME);
// only QDCM Diag client failed to be loaded and system still should function.
}
} else {
DLOGE("Unable to create HWCColorManager");
return NULL;
}
return color_mgr;
}
void d_memory_print_memusage(){
#if __WIN32__ == 1
struct mallinfo info = mallinfo();
DLOGI("used memory %.2f Mo, %.2f Mo with mmap\n",info.arena / 1000000.0f,info.hblkhd / 1000000.0f);
#else
DLOGV("function mallinfo() not available on this platform");
#endif
}
void HWCDisplayPrimary::SetSecureDisplay(bool secure_display_active) {
if (secure_display_active_ != secure_display_active) {
// Skip Prepare and call Flush for null commit
DLOGI("SecureDisplay state changed from %d to %d Needs Flush!!", secure_display_active_,
secure_display_active);
secure_display_active_ = secure_display_active;
skip_prepare_ = true;
}
return;
}
void HWEvents::HandleThermal(char *data) {
int64_t thermal_level = 0;
if (!strncmp(data, "thermal_level=", strlen("thermal_level="))) {
thermal_level = strtoll(data + strlen("thermal_level="), NULL, 0);
}
DLOGI("Received thermal notification with thermal level = %d", thermal_level);
event_handler_->ThermalEvent(thermal_level);
}
void HWCDisplayPrimary::ProcessBootAnimCompleted() {
uint32_t numBootUpLayers = 0;
// TODO(user): Remove this hack
numBootUpLayers = static_cast<uint32_t>(Debug::GetBootAnimLayerCount());
if (numBootUpLayers == 0) {
numBootUpLayers = 2;
}
/* All other checks namely "init.svc.bootanim" or
* HWC_GEOMETRY_CHANGED fail in correctly identifying the
* exact bootup transition to homescreen
*/
char property[PROPERTY_VALUE_MAX];
bool isEncrypted = false;
bool main_class_services_started = false;
property_get("ro.crypto.state", property, "unencrypted");
if (!strcmp(property, "encrypted")) {
property_get("ro.crypto.type", property, "block");
if (!strcmp(property, "block")) {
isEncrypted = true;
property_get("vold.decrypt", property, "");
if (!strcmp(property, "trigger_restart_framework")) {
main_class_services_started = true;
}
}
}
if ((!isEncrypted || (isEncrypted && main_class_services_started)) &&
(layer_set_.size() > numBootUpLayers)) {
DLOGI("Applying default mode");
boot_animation_completed_ = true;
// Applying default mode after bootanimation is finished And
// If Data is Encrypted, it is ready for access.
if (display_intf_)
display_intf_->ApplyDefaultDisplayMode();
}
}
void HWCDisplayPrimary::SetFrameDumpConfig(uint32_t count, uint32_t bit_mask_layer_type) {
HWCDisplay::SetFrameDumpConfig(count, bit_mask_layer_type);
dump_output_to_file_ = bit_mask_layer_type & (1 << OUTPUT_LAYER_DUMP);
DLOGI("output_layer_dump_enable %d", dump_output_to_file_);
if (!count || !dump_output_to_file_) {
return;
}
// Allocate and map output buffer
output_buffer_info_ = {};
// Since we dump DSPP output use Panel resolution.
GetPanelResolution(&output_buffer_info_.buffer_config.width,
&output_buffer_info_.buffer_config.height);
output_buffer_info_.buffer_config.format = kFormatRGB888;
output_buffer_info_.buffer_config.buffer_count = 1;
if (buffer_allocator_->AllocateBuffer(&output_buffer_info_) != 0) {
DLOGE("Buffer allocation failed");
output_buffer_info_ = {};
return;
}
void *buffer = mmap(NULL, output_buffer_info_.alloc_buffer_info.size, PROT_READ | PROT_WRITE,
MAP_SHARED, output_buffer_info_.alloc_buffer_info.fd, 0);
if (buffer == MAP_FAILED) {
DLOGE("mmap failed with err %d", errno);
buffer_allocator_->FreeBuffer(&output_buffer_info_);
output_buffer_info_ = {};
return;
}
output_buffer_base_ = buffer;
post_processed_output_ = true;
DisablePartialUpdateOneFrame();
}
