| /* |
| * Copyright (C) 2016 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #include <cutils/log.h> |
| #include <tegra_adf.h> |
| #include <inttypes.h> |
| |
| #include <sstream> |
| #include <cstdlib> |
| #include <map> |
| #include <vector> |
| #include <array> |
| |
| #include "hwc2.h" |
| |
| uint64_t hwc2_display::display_cnt = 0; |
| |
| hwc2_display::hwc2_display(hwc2_display_t id, int adf_intf_fd, |
| const struct adf_device &adf_dev, hwc2_connection_t connection, |
| hwc2_display_type_t type, hwc2_power_mode_t power_mode) |
| : id(id), |
| name(), |
| connection(connection), |
| type(type), |
| display_state(modified), |
| client_target_used(false), |
| windows(), |
| client_target(), |
| layers(), |
| vsync_enabled(HWC2_VSYNC_DISABLE), |
| changed_comp_types(), |
| configs(), |
| active_config(0), |
| power_mode(power_mode), |
| color_matrix(), |
| color_hint(HAL_COLOR_TRANSFORM_IDENTITY), |
| release_fence(-1), |
| adf_intf_fd(adf_intf_fd), |
| adf_dev(adf_dev) |
| { |
| init_name(); |
| init_windows(); |
| } |
| |
| hwc2_display::~hwc2_display() |
| { |
| close(adf_intf_fd); |
| adf_device_close(&adf_dev); |
| } |
| |
| std::string hwc2_display::dump() const |
| { |
| std::stringstream dmp; |
| |
| dmp << "Display [" << id << "] " << getDisplayTypeName(type) << ":\n"; |
| |
| dmp << " Power Mode: " << getPowerModeName(power_mode) << "\n"; |
| |
| dmp << " Active Config:"; |
| |
| auto it = configs.begin(); |
| if (configs.size() > 0 || it != configs.end()) |
| dmp << "\n" << configs.at(active_config).dump(); |
| else |
| dmp << " None\n"; |
| |
| if (power_mode == HWC2_POWER_MODE_OFF) |
| return dmp.str(); |
| |
| size_t idx = 0; |
| for (auto &win: windows) { |
| dmp << " Window [" << idx << "]:"; |
| |
| if (win.contains_layer()) { |
| dmp << " Layer\n"; |
| dmp << layers.at(win.get_layer()).dump(); |
| |
| } else if (win.contains_client_target()) { |
| dmp << " Client Target\n"; |
| dmp << client_target.dump(); |
| |
| } else |
| dmp << " Unused\n"; |
| |
| idx++; |
| } |
| |
| return dmp.str(); |
| } |
| |
| hwc2_error_t hwc2_display::set_connection(hwc2_connection_t connection) |
| { |
| if (connection == HWC2_CONNECTION_INVALID) { |
| ALOGE("dpy %" PRIu64 ": invalid connection", id); |
| return HWC2_ERROR_BAD_PARAMETER; |
| } |
| |
| display_state = modified; |
| this->connection = connection; |
| return HWC2_ERROR_NONE; |
| } |
| |
| hwc2_error_t hwc2_display::get_name(uint32_t *out_size, char *out_name) const |
| { |
| if (!out_name) { |
| *out_size = name.size(); |
| return HWC2_ERROR_NONE; |
| } |
| |
| /* out_name does not require a NULL terminator so strncpy can truncate |
| * the output safely */ |
| strncpy(out_name, name.c_str(), *out_size); |
| *out_size = (*out_size < name.size())? *out_size: name.size(); |
| return HWC2_ERROR_NONE; |
| } |
| |
| void hwc2_display::init_name() |
| { |
| name.append("dpy-"); |
| if (HWC2_DISPLAY_TYPE_PHYSICAL) |
| name.append("phys-"); |
| else |
| name.append("virt-"); |
| name.append(std::to_string(id)); |
| } |
| |
| hwc2_error_t hwc2_display::set_power_mode(hwc2_power_mode_t mode) |
| { |
| int drm_mode; |
| |
| switch (mode) { |
| case HWC2_POWER_MODE_ON: |
| drm_mode = DRM_MODE_DPMS_ON; |
| break; |
| case HWC2_POWER_MODE_OFF: |
| drm_mode = DRM_MODE_DPMS_OFF; |
| break; |
| case HWC2_POWER_MODE_DOZE: |
| case HWC2_POWER_MODE_DOZE_SUSPEND: |
| ALOGE("dpy %" PRIu64 ": unsupported power mode: %u", id, mode); |
| return HWC2_ERROR_UNSUPPORTED; |
| default: |
| ALOGE("dpy %" PRIu64 ": invalid power mode: %u", id, mode); |
| return HWC2_ERROR_BAD_PARAMETER; |
| } |
| |
| adf_interface_blank(adf_intf_fd, drm_mode); |
| power_mode = mode; |
| |
| return HWC2_ERROR_NONE; |
| } |
| |
| hwc2_error_t hwc2_display::get_doze_support(int32_t *out_support) const |
| { |
| *out_support = 0; |
| return HWC2_ERROR_NONE; |
| } |
| |
| hwc2_error_t hwc2_display::set_vsync_enabled(hwc2_vsync_t enabled) |
| { |
| if (enabled == HWC2_VSYNC_INVALID) { |
| ALOGE("dpy %" PRIu64 ": invalid vsync enabled", id); |
| return HWC2_ERROR_BAD_PARAMETER; |
| } |
| |
| this->vsync_enabled = enabled; |
| return HWC2_ERROR_NONE; |
| } |
| |
| hwc2_error_t hwc2_display::validate_display(uint32_t *out_num_types, |
| uint32_t *out_num_requests) |
| { |
| if (display_state == valid) { |
| *out_num_types = 0; |
| *out_num_requests = 0; |
| return HWC2_ERROR_NONE; |
| } |
| |
| clear_windows(); |
| changed_comp_types.clear(); |
| |
| if (color_hint != HAL_COLOR_TRANSFORM_IDENTITY) |
| force_client_composition(); |
| else |
| assign_composition(); |
| |
| *out_num_requests = 0; |
| *out_num_types = changed_comp_types.size(); |
| |
| for (auto &lyr: layers) |
| lyr.second.set_modified(false); |
| |
| if (*out_num_types > 0) { |
| display_state = invalid; |
| return HWC2_ERROR_HAS_CHANGES; |
| } |
| |
| display_state = valid; |
| return HWC2_ERROR_NONE; |
| } |
| |
| void hwc2_display::force_client_composition() |
| { |
| for (auto &lyr: layers) { |
| hwc2_composition_t comp_type = lyr.second.get_comp_type(); |
| if (comp_type != HWC2_COMPOSITION_CLIENT) |
| changed_comp_types.emplace(lyr.second.get_id(), comp_type); |
| } |
| } |
| |
| void hwc2_display::assign_composition() |
| { |
| hwc2_error_t ret; |
| |
| std::map<uint32_t, hwc2_layer_t> ordered_layers; |
| for (auto &lyr: layers) |
| ordered_layers.emplace(lyr.second.get_z_order(), lyr.second.get_id()); |
| |
| bool client_target_assigned = false; |
| |
| /* If there will definitely be a client target, assign it to the front most |
| * window */ |
| if (layers.size() > windows.size()) { |
| ret = assign_client_target_window(0); |
| ALOG_ASSERT(ret == HWC2_ERROR_NONE, "No valid client target window"); |
| |
| client_target_assigned = true; |
| } |
| |
| bool retry_assignment; |
| |
| do { |
| retry_assignment = false; |
| /* The display controller uses a different z order than SurfaceFlinger */ |
| uint32_t z_order = windows.size() - 1; |
| client_target_used = false; |
| |
| /* Iterate over the layers from the back to the front. |
| * assign windows to device layers. Upon reaching a layer that must |
| * be composed by the client all subsequent layers will be assigned |
| * client composition */ |
| for (auto &ordered_layer: ordered_layers) { |
| hwc2_layer_t lyr_id = ordered_layer.second; |
| hwc2_composition_t comp_type = layers.find( |
| lyr_id)->second.get_comp_type(); |
| |
| if (comp_type == HWC2_COMPOSITION_INVALID) { |
| ALOGW("dpy %" PRIu64 " lyr %" PRIu64 ": invalid composition" |
| " type %u", id, lyr_id, comp_type); |
| continue; |
| } |
| |
| /* If the layer is not overlapped and can be assigned a window, |
| assign it and continue to the next layer */ |
| if (comp_type == HWC2_COMPOSITION_DEVICE && !client_target_used |
| && assign_layer_window(z_order, lyr_id) == HWC2_ERROR_NONE) { |
| z_order--; |
| continue; |
| } |
| |
| /* The layer will be composited into a client target buffer so |
| * find a window for the client target */ |
| if (!client_target_assigned) { |
| |
| ret = assign_client_target_window(0); |
| if (ret != HWC2_ERROR_NONE) { |
| /* If no client target can be assigned, clear all the |
| * windows, assign a client target and retry assigning |
| * windows */ |
| retry_assignment = true; |
| |
| changed_comp_types.clear(); |
| clear_windows(); |
| |
| ret = assign_client_target_window(0); |
| ALOG_ASSERT(ret == HWC2_ERROR_NONE, "No valid client target" |
| " window"); |
| |
| client_target_assigned = true; |
| break; |
| } |
| |
| client_target_assigned = true; |
| } |
| |
| /* Assign the layer to client composition */ |
| if (comp_type != HWC2_COMPOSITION_CLIENT) |
| changed_comp_types.emplace(lyr_id, HWC2_COMPOSITION_CLIENT); |
| |
| client_target_used = true; |
| } |
| } while (retry_assignment); |
| } |
| |
| hwc2_error_t hwc2_display::get_changed_composition_types( |
| uint32_t *out_num_elements, hwc2_layer_t *out_layers, |
| hwc2_composition_t *out_types) const |
| { |
| if (display_state == modified) { |
| ALOGE("dpy %" PRIu64 ": display has been modified since last call to" |
| " validate_display", id); |
| return HWC2_ERROR_NOT_VALIDATED; |
| } |
| |
| if (!out_layers || !out_types) { |
| *out_num_elements = changed_comp_types.size(); |
| return HWC2_ERROR_NONE; |
| } |
| |
| size_t idx = 0; |
| for (auto &changed: changed_comp_types) { |
| out_layers[idx] = changed.first; |
| out_types[idx] = changed.second; |
| idx++; |
| } |
| |
| *out_num_elements = changed_comp_types.size(); |
| return HWC2_ERROR_NONE; |
| } |
| |
| hwc2_error_t hwc2_display::get_display_requests( |
| hwc2_display_request_t *out_display_requests, |
| uint32_t *out_num_elements, hwc2_layer_t* /*out_layers*/, |
| hwc2_layer_request_t* /*out_layer_requests*/) const |
| { |
| if (display_state == modified) { |
| ALOGE("dpy %" PRIu64 ": display has been modified since last call to" |
| " validate_display", id); |
| return HWC2_ERROR_NOT_VALIDATED; |
| } |
| |
| *out_display_requests = static_cast<hwc2_display_request_t>(0); |
| *out_num_elements = 0; |
| |
| return HWC2_ERROR_NONE; |
| } |
| |
| hwc2_error_t hwc2_display::accept_display_changes() |
| { |
| if (display_state == modified) { |
| ALOGE("dpy %" PRIu64 ": display has been modified since last call to" |
| " validate_display", id); |
| return HWC2_ERROR_NOT_VALIDATED; |
| } |
| |
| for (auto &changed: changed_comp_types) |
| layers.find(changed.first)->second.set_comp_type(changed.second); |
| |
| display_state = valid; |
| |
| return HWC2_ERROR_NONE; |
| } |
| |
| hwc2_error_t hwc2_display::present_display(int32_t *out_present_fence) |
| { |
| std::vector<struct adf_buffer_config> adf_bufs(windows.size()); |
| std::array<adf_id_t, 1> interfaces = {{0}}; |
| int new_release_fence = -1, err; |
| |
| hwc2_error_t ret = prepare_present_display(); |
| if (ret != HWC2_ERROR_NONE) { |
| ALOGE("dpy %" PRIu64 ": failed to prepare display for presenting", id); |
| *out_present_fence = -1; |
| return ret; |
| } |
| |
| tegra_adf_flip *args; |
| size_t args_size = sizeof(*args) + windows.size() * sizeof(args->win[0]); |
| |
| args = static_cast<tegra_adf_flip *>(calloc(1, args_size)); |
| if (!args) { |
| ALOGE("dpy %" PRIu64 ": failed to alloc tegra_adf_flip", id); |
| *out_present_fence = -1; |
| return HWC2_ERROR_NO_RESOURCES; |
| } |
| |
| args->win_num = windows.size(); |
| |
| size_t win_idx = 0, buf_idx = 0; |
| for (auto &win: windows) { |
| if (win.contains_client_target()) { |
| |
| ret = client_target.get_adf_post_props(&args->win[win_idx], |
| &adf_bufs[buf_idx], win_idx, buf_idx, win.get_z_order()); |
| if (ret != HWC2_ERROR_NONE) { |
| ALOGE("dpy %" PRIu64 ": failed to get client target adf props", id); |
| goto done; |
| } |
| buf_idx++; |
| |
| } else if (win.contains_layer()) { |
| hwc2_layer_t lyr_id = win.get_layer(); |
| |
| ret = layers.find(lyr_id)->second.get_adf_post_props( |
| &args->win[win_idx], &adf_bufs[buf_idx], win_idx, |
| buf_idx, win.get_z_order()); |
| if (ret != HWC2_ERROR_NONE) { |
| ALOGE("dpy %" PRIu64 " lyr %" PRIu64 ": failed to get layer adf" |
| " props", id, lyr_id); |
| goto done; |
| } |
| buf_idx++; |
| |
| } else { |
| struct tegra_adf_flip_windowattr *win_attr = &args->win[win_idx]; |
| win_attr->win_index = win_idx; |
| win_attr->buf_index = -1; |
| win_attr->z = win.get_z_order(); |
| win_attr->blend = TEGRA_ADF_BLEND_NONE; |
| win_attr->flags = 0; |
| } |
| |
| win_idx++; |
| } |
| |
| err = adf_device_post_v2(&adf_dev, interfaces.data(), interfaces.size(), |
| adf_bufs.data(), buf_idx, args, args_size, ADF_COMPLETE_FENCE_PRESENT, |
| &new_release_fence); |
| if (err < 0) { |
| ALOGE("dpy %" PRIu64 ": adf_device_post_v2 failed %s", id, strerror(err)); |
| err = HWC2_ERROR_NO_RESOURCES; |
| new_release_fence = -1; |
| } |
| |
| release_fence.reset(new_release_fence); |
| |
| close_acquire_fences(); |
| |
| for (size_t idx = 0; idx < buf_idx; idx++) |
| if (adf_bufs[idx].fd[0] >= 0) |
| close(adf_bufs[idx].fd[0]); |
| |
| done: |
| free(args); |
| *out_present_fence = dup(release_fence.get()); |
| return ret; |
| } |
| |
| hwc2_error_t hwc2_display::prepare_present_display() |
| { |
| if (display_state != valid) { |
| ALOGE("dpy %" PRIu64 ": display not validated: %d", id, display_state); |
| return HWC2_ERROR_NOT_VALIDATED; |
| } |
| |
| if (connection != HWC2_CONNECTION_CONNECTED) { |
| ALOGW("dpy %" PRIu64 ": invalid connection: %d", id, connection); |
| return HWC2_ERROR_BAD_DISPLAY; |
| } |
| |
| if (power_mode == HWC2_POWER_MODE_OFF) { |
| ALOGW("dpy %" PRIu64 ": invalid power mode: %d", id, power_mode); |
| return HWC2_ERROR_BAD_DISPLAY; |
| } |
| |
| hwc2_error_t ret = decompress_window_buffers(); |
| if (ret != HWC2_ERROR_NONE) { |
| ALOGE("dpy %" PRIu64 ": failed to decompress buffers", id); |
| return ret; |
| } |
| |
| return HWC2_ERROR_NONE; |
| } |
| |
| |
| void hwc2_display::close_acquire_fences() |
| { |
| for (auto &lyr: layers) |
| lyr.second.close_acquire_fence(); |
| |
| if (client_target_used) |
| client_target.close_acquire_fence(); |
| } |
| |
| hwc2_error_t hwc2_display::get_release_fences(uint32_t *out_num_elements, |
| hwc2_layer_t *out_layers, int32_t *out_fences) const |
| { |
| if (release_fence.get() < 0) { |
| *out_num_elements = 0; |
| return HWC2_ERROR_NONE; |
| } |
| |
| size_t num = 0; |
| |
| if (!out_layers || !out_fences) { |
| for (auto &window: windows) |
| if (window.contains_layer()) |
| num++; |
| *out_num_elements = num; |
| return HWC2_ERROR_NONE; |
| } |
| |
| for (auto it = windows.begin(); num < *out_num_elements, |
| it != windows.end(); it++) { |
| if (it->contains_layer()) { |
| out_layers[num] = it->get_layer(); |
| out_fences[num] = dup(release_fence.get()); |
| num++; |
| } |
| } |
| |
| *out_num_elements = num; |
| return HWC2_ERROR_NONE; |
| } |
| |
| void hwc2_display::init_windows() |
| { |
| for (auto it = windows.begin(); it != windows.end(); it++) |
| it->set_capabilities(window_capabilities[it - windows.begin()]); |
| } |
| |
| void hwc2_display::clear_windows() |
| { |
| for (auto &window: windows) |
| window.clear(); |
| } |
| |
| hwc2_error_t hwc2_display::assign_client_target_window(uint32_t z_order) |
| { |
| for (auto &window: windows) |
| if (window.assign_client_target(z_order) == HWC2_ERROR_NONE) |
| return HWC2_ERROR_NONE; |
| |
| return HWC2_ERROR_NO_RESOURCES; |
| } |
| |
| hwc2_error_t hwc2_display::assign_layer_window(uint32_t z_order, |
| hwc2_layer_t lyr_id) |
| { |
| auto& lyr = layers.find(lyr_id)->second; |
| |
| if (!hwc2_window::is_supported(lyr)) |
| return HWC2_ERROR_UNSUPPORTED; |
| |
| for (auto &window: windows) |
| if (window.assign_layer(z_order, lyr) == HWC2_ERROR_NONE) |
| return HWC2_ERROR_NONE; |
| |
| return HWC2_ERROR_NO_RESOURCES; |
| } |
| |
| hwc2_error_t hwc2_display::decompress_window_buffers() |
| { |
| hwc2_error_t ret; |
| |
| for (auto &win: windows) { |
| if (win.contains_client_target()) { |
| ret = client_target.decompress(); |
| if (ret != HWC2_ERROR_NONE) { |
| ALOGE("dpy %" PRIu64 ": failed to decompress client target" |
| " buffer", id); |
| return ret; |
| } |
| } else if (win.contains_layer()) { |
| ret = layers.at(win.get_layer()).decompress_buffer(); |
| if (ret != HWC2_ERROR_NONE) { |
| ALOGE("dpy %" PRIu64 " lyr %" PRIu64 ": failed to decompress" |
| " layer buffer", id, win.get_layer()); |
| return ret; |
| } |
| } |
| } |
| return HWC2_ERROR_NONE; |
| } |
| |
| int hwc2_display::retrieve_display_configs(struct adf_hwc_helper *adf_helper) |
| { |
| size_t num_configs = 0; |
| |
| int ret = adf_getDisplayConfigs(adf_helper, id, nullptr, &num_configs); |
| if (ret < 0 || num_configs == 0) { |
| ALOGE("dpy %" PRIu64 ": failed to get display configs: %s", id, |
| strerror(ret)); |
| return ret; |
| } |
| |
| std::vector<uint32_t> config_handles(num_configs); |
| |
| ret = adf_getDisplayConfigs(adf_helper, id, config_handles.data(), |
| &num_configs); |
| if (ret < 0) { |
| ALOGE("dpy %" PRIu64 ": failed to get display configs: %s", id, |
| strerror(ret)); |
| return ret; |
| } |
| |
| active_config = config_handles[0]; |
| |
| std::array<uint32_t, 6> attributes = {{ |
| HWC2_ATTRIBUTE_WIDTH, |
| HWC2_ATTRIBUTE_HEIGHT, |
| HWC2_ATTRIBUTE_VSYNC_PERIOD, |
| HWC2_ATTRIBUTE_DPI_X, |
| HWC2_ATTRIBUTE_DPI_Y, |
| HWC2_ATTRIBUTE_INVALID }}; |
| std::array<int32_t, 5> values; |
| |
| for (auto config_handle: config_handles) { |
| ret = adf_getDisplayAttributes_hwc2(adf_helper, id, config_handle, |
| attributes.data(), values.data()); |
| if (ret < 0) { |
| ALOGW("dpy %" PRIu64 ": failed to get display attributes for config" |
| " %u: %s", id, config_handle, strerror(ret)); |
| continue; |
| } |
| |
| configs.emplace(config_handle, hwc2_config()); |
| |
| for (size_t attr = 0; attr < attributes.size() - 1; attr++) { |
| ret = configs[config_handle].set_attribute( |
| static_cast<hwc2_attribute_t>(attributes[attr]), |
| values[attr]); |
| if (ret < 0) |
| ALOGW("dpy %" PRIu64 ": failed to set attribute", id); |
| } |
| } |
| |
| return ret; |
| } |
| |
| hwc2_error_t hwc2_display::get_display_attribute(hwc2_config_t config, |
| hwc2_attribute_t attribute, int32_t *out_value) const |
| { |
| auto it = configs.find(config); |
| if (it == configs.end()) { |
| ALOGE("dpy %" PRIu64 ": bad config", id); |
| return HWC2_ERROR_BAD_CONFIG; |
| } |
| |
| *out_value = it->second.get_attribute(attribute); |
| return HWC2_ERROR_NONE; |
| } |
| |
| hwc2_error_t hwc2_display::get_display_configs(uint32_t *out_num_configs, |
| hwc2_config_t *out_configs) const |
| { |
| if (!out_configs) { |
| *out_num_configs = configs.size(); |
| return HWC2_ERROR_NONE; |
| } |
| |
| size_t idx = 0; |
| for (auto it = configs.begin(); it != configs.end() |
| && idx < *out_num_configs; it++, idx++) |
| out_configs[idx] = it->first; |
| |
| *out_num_configs = idx; |
| return HWC2_ERROR_NONE; |
| } |
| |
| hwc2_error_t hwc2_display::get_active_config(hwc2_config_t *out_config) const |
| { |
| if (!configs.size()) { |
| ALOGE("dpy %" PRIu64 ": no active config", id); |
| return HWC2_ERROR_BAD_CONFIG; |
| } |
| |
| *out_config = active_config; |
| |
| return HWC2_ERROR_NONE; |
| } |
| |
| hwc2_error_t hwc2_display::set_active_config( |
| struct adf_hwc_helper *adf_helper, hwc2_config_t config) |
| { |
| if (config >= configs.size()) { |
| ALOGE("dpy %" PRIu64 ": bad config", id); |
| return HWC2_ERROR_BAD_CONFIG; |
| } |
| |
| int ret = adf_set_active_config_hwc2(adf_helper, id, config); |
| if (ret < 0) { |
| ALOGE("dpy %" PRIu64 ": failed to set mode: %s", id, strerror(ret)); |
| return HWC2_ERROR_BAD_CONFIG; |
| } |
| |
| active_config = config; |
| set_client_target_properties(); |
| |
| return HWC2_ERROR_NONE; |
| } |
| |
| hwc2_error_t hwc2_display::get_color_modes(uint32_t *out_num_modes, |
| android_color_mode_t *out_modes) const |
| { |
| *out_num_modes = 1; |
| if (out_modes) |
| *out_modes = HAL_COLOR_MODE_NATIVE; |
| |
| return HWC2_ERROR_NONE; |
| } |
| |
| hwc2_error_t hwc2_display::set_color_mode(android_color_mode_t mode) |
| { |
| switch (mode) { |
| case HAL_COLOR_MODE_NATIVE: |
| return HWC2_ERROR_NONE; |
| case HAL_COLOR_MODE_STANDARD_BT601_625: |
| case HAL_COLOR_MODE_STANDARD_BT601_625_UNADJUSTED: |
| case HAL_COLOR_MODE_STANDARD_BT601_525: |
| case HAL_COLOR_MODE_STANDARD_BT601_525_UNADJUSTED: |
| case HAL_COLOR_MODE_STANDARD_BT709: |
| case HAL_COLOR_MODE_DCI_P3: |
| case HAL_COLOR_MODE_SRGB: |
| case HAL_COLOR_MODE_ADOBE_RGB: |
| ALOGE("dpy %" PRIu64 ": unsupported color mode", id); |
| return HWC2_ERROR_UNSUPPORTED; |
| default: |
| ALOGE("dpy %" PRIu64 ": invalid color mode", id); |
| return HWC2_ERROR_BAD_PARAMETER; |
| } |
| |
| } |
| |
| hwc2_error_t hwc2_display::get_hdr_capabilities(uint32_t *out_num_types, |
| android_hdr_t* /*out_types*/, float* /*out_max_luminance*/, |
| float* /*out_max_average_luminance*/, |
| float* /*out_min_luminance*/) const |
| { |
| *out_num_types = 0; |
| return HWC2_ERROR_NONE; |
| } |
| |
| hwc2_error_t hwc2_display::set_color_transform(const float *color_matrix, |
| android_color_transform_t color_hint) |
| { |
| switch (color_hint) { |
| case HAL_COLOR_TRANSFORM_IDENTITY: |
| case HAL_COLOR_TRANSFORM_ARBITRARY_MATRIX: |
| case HAL_COLOR_TRANSFORM_VALUE_INVERSE: |
| case HAL_COLOR_TRANSFORM_GRAYSCALE: |
| case HAL_COLOR_TRANSFORM_CORRECT_PROTANOPIA: |
| case HAL_COLOR_TRANSFORM_CORRECT_DEUTERANOPIA: |
| case HAL_COLOR_TRANSFORM_CORRECT_TRITANOPIA: |
| memcpy(this->color_matrix.data(), color_matrix, |
| this->color_matrix.size()); |
| this->color_hint = color_hint; |
| return HWC2_ERROR_NONE; |
| default: |
| ALOGE("dpy %" PRIu64 ": invalid color transform hint", id); |
| return HWC2_ERROR_BAD_PARAMETER; |
| } |
| } |
| |
| hwc2_error_t hwc2_display::get_client_target_support(uint32_t width, |
| uint32_t height, android_pixel_format_t format, |
| android_dataspace_t dataspace) |
| { |
| if (active_config >= configs.size()) { |
| ALOGE("dpy %" PRIu64 ": no active_config", id); |
| return HWC2_ERROR_UNSUPPORTED; |
| } |
| |
| int32_t cnfg_width = configs[active_config].get_attribute( |
| HWC2_ATTRIBUTE_WIDTH); |
| int32_t cnfg_height = configs[active_config].get_attribute( |
| HWC2_ATTRIBUTE_HEIGHT); |
| |
| if (cnfg_width < 0 || width != static_cast<uint32_t>(cnfg_width)) { |
| ALOGE("dpy %" PRIu64 ": unsupported client target width", id); |
| return HWC2_ERROR_UNSUPPORTED; |
| } |
| |
| if (cnfg_height < 0 || height != static_cast<uint32_t>(cnfg_height)) { |
| ALOGE("dpy %" PRIu64 ": unsupported client target height", id); |
| return HWC2_ERROR_UNSUPPORTED; |
| } |
| |
| if (format != HAL_PIXEL_FORMAT_RGBA_8888) { |
| ALOGE("dpy %" PRIu64 ": unsupported client target format", id); |
| return HWC2_ERROR_UNSUPPORTED; |
| } |
| |
| if (dataspace != HAL_DATASPACE_UNKNOWN) { |
| ALOGE("dpy %" PRIu64 ": unsupported client target dataspace", id); |
| return HWC2_ERROR_UNSUPPORTED; |
| } |
| |
| return HWC2_ERROR_NONE; |
| } |
| |
| hwc2_error_t hwc2_display::set_client_target(buffer_handle_t handle, |
| int32_t acquire_fence, android_dataspace_t dataspace, |
| const hwc_region_t &surface_damage) |
| { |
| hwc2_error_t ret = client_target.set_buffer(handle, acquire_fence); |
| if (ret != HWC2_ERROR_NONE) |
| return ret; |
| |
| ret = client_target.set_dataspace(dataspace); |
| if (ret != HWC2_ERROR_NONE) |
| return ret; |
| |
| return client_target.set_surface_damage(surface_damage); |
| } |
| |
| hwc2_error_t hwc2_display::set_client_target_properties() |
| { |
| int32_t width = configs.at(active_config).get_attribute(HWC2_ATTRIBUTE_WIDTH); |
| int32_t height = configs.at(active_config).get_attribute(HWC2_ATTRIBUTE_HEIGHT); |
| |
| hwc_rect_t frame; |
| frame.left = 0; |
| frame.top = 0; |
| frame.right = width; |
| frame.bottom = height; |
| client_target.set_display_frame(frame); |
| |
| hwc_frect_t crop; |
| crop.left = 0.0; |
| crop.top = 0.0; |
| crop.right = static_cast<float>(width); |
| crop.bottom = static_cast<float>(height); |
| client_target.set_source_crop(crop); |
| |
| client_target.set_blend_mode(HWC2_BLEND_MODE_PREMULTIPLIED); |
| client_target.set_z_order(UINT32_MAX); |
| |
| return HWC2_ERROR_NONE; |
| } |
| |
| hwc2_error_t hwc2_display::create_layer(hwc2_layer_t *out_layer) |
| { |
| display_state = modified; |
| |
| hwc2_layer_t lyr_id = hwc2_layer::get_next_id(); |
| layers.emplace(std::piecewise_construct, std::forward_as_tuple(lyr_id), |
| std::forward_as_tuple(lyr_id)); |
| |
| *out_layer = lyr_id; |
| return HWC2_ERROR_NONE; |
| } |
| |
| hwc2_error_t hwc2_display::destroy_layer(hwc2_layer_t lyr_id) |
| { |
| auto it = layers.find(lyr_id); |
| if (it == layers.end()) { |
| ALOGE("dpy %" PRIu64 ": lyr %" PRIu64 ": bad layer handle", id, lyr_id); |
| return HWC2_ERROR_BAD_LAYER; |
| } |
| |
| display_state = modified; |
| layers.erase(lyr_id); |
| return HWC2_ERROR_NONE; |
| } |
| |
| hwc2_error_t hwc2_display::set_layer_composition_type(hwc2_layer_t lyr_id, |
| hwc2_composition_t comp_type) |
| { |
| auto it = layers.find(lyr_id); |
| if (it == layers.end()) { |
| ALOGE("dpy %" PRIu64 ": lyr %" PRIu64 ": bad layer handle", id, lyr_id); |
| return HWC2_ERROR_BAD_LAYER; |
| } |
| |
| hwc2_error_t ret = it->second.set_comp_type(comp_type); |
| |
| if (it->second.get_modified()) |
| display_state = modified; |
| |
| return ret; |
| } |
| |
| hwc2_error_t hwc2_display::set_layer_buffer(hwc2_layer_t lyr_id, |
| buffer_handle_t handle, int32_t acquire_fence) |
| { |
| auto it = layers.find(lyr_id); |
| if (it == layers.end()) { |
| ALOGE("dpy %" PRIu64 ": lyr %" PRIu64 ": bad layer handle", id, lyr_id); |
| return HWC2_ERROR_BAD_LAYER; |
| } |
| |
| hwc2_error_t ret = it->second.set_buffer(handle, acquire_fence); |
| |
| if (it->second.get_modified()) |
| display_state = modified; |
| |
| return ret; |
| } |
| |
| hwc2_error_t hwc2_display::set_layer_dataspace(hwc2_layer_t lyr_id, |
| android_dataspace_t dataspace) |
| { |
| auto it = layers.find(lyr_id); |
| if (it == layers.end()) { |
| ALOGE("dpy %" PRIu64 ": lyr %" PRIu64 ": bad layer handle", id, lyr_id); |
| return HWC2_ERROR_BAD_LAYER; |
| } |
| |
| hwc2_error_t ret = it->second.set_dataspace(dataspace); |
| |
| if (it->second.get_modified()) |
| display_state = modified; |
| |
| return ret; |
| } |
| |
| hwc2_error_t hwc2_display::set_layer_display_frame(hwc2_layer_t lyr_id, |
| const hwc_rect_t &display_frame) |
| { |
| auto it = layers.find(lyr_id); |
| if (it == layers.end()) { |
| ALOGE("dpy %" PRIu64 ": lyr %" PRIu64 ": bad layer handle", id, lyr_id); |
| return HWC2_ERROR_BAD_LAYER; |
| } |
| |
| hwc2_error_t ret = it->second.set_display_frame(display_frame); |
| |
| if (it->second.get_modified()) |
| display_state = modified; |
| |
| return ret; |
| } |
| |
| hwc2_error_t hwc2_display::set_layer_source_crop(hwc2_layer_t lyr_id, |
| const hwc_frect_t &source_crop) |
| { |
| auto it = layers.find(lyr_id); |
| if (it == layers.end()) { |
| ALOGE("dpy %" PRIu64 ": lyr %" PRIu64 ": bad layer handle", id, lyr_id); |
| return HWC2_ERROR_BAD_LAYER; |
| } |
| |
| hwc2_error_t ret = it->second.set_source_crop(source_crop); |
| |
| if (it->second.get_modified()) |
| display_state = modified; |
| |
| return ret; |
| } |
| |
| hwc2_error_t hwc2_display::set_layer_z_order(hwc2_layer_t lyr_id, uint32_t z_order) |
| { |
| auto it = layers.find(lyr_id); |
| if (it == layers.end()) { |
| ALOGE("dpy %" PRIu64 ": lyr %" PRIu64 ": bad layer handle", id, lyr_id); |
| return HWC2_ERROR_BAD_LAYER; |
| } |
| |
| hwc2_error_t ret = it->second.set_z_order(z_order); |
| |
| if (it->second.get_modified()) |
| display_state = modified; |
| |
| return ret; |
| } |
| |
| hwc2_error_t hwc2_display::set_layer_surface_damage(hwc2_layer_t lyr_id, |
| const hwc_region_t &surface_damage) |
| { |
| auto it = layers.find(lyr_id); |
| if (it == layers.end()) { |
| ALOGE("dpy %" PRIu64 ": lyr %" PRIu64 ": bad layer handle", id, lyr_id); |
| return HWC2_ERROR_BAD_LAYER; |
| } |
| |
| return it->second.set_surface_damage(surface_damage); |
| } |
| |
| hwc2_error_t hwc2_display::set_layer_blend_mode(hwc2_layer_t lyr_id, |
| hwc2_blend_mode_t blend_mode) |
| { |
| auto it = layers.find(lyr_id); |
| if (it == layers.end()) { |
| ALOGE("dpy %" PRIu64 ": lyr %" PRIu64 ": bad layer handle", id, lyr_id); |
| return HWC2_ERROR_BAD_LAYER; |
| } |
| |
| hwc2_error_t ret = it->second.set_blend_mode(blend_mode); |
| |
| if (it->second.get_modified()) |
| display_state = modified; |
| |
| return ret; |
| } |
| |
| hwc2_error_t hwc2_display::set_layer_plane_alpha(hwc2_layer_t lyr_id, float plane_alpha) |
| { |
| auto it = layers.find(lyr_id); |
| if (it == layers.end()) { |
| ALOGE("dpy %" PRIu64 ": lyr %" PRIu64 ": bad layer handle", id, lyr_id); |
| return HWC2_ERROR_BAD_LAYER; |
| } |
| |
| hwc2_error_t ret = it->second.set_plane_alpha(plane_alpha); |
| |
| if (it->second.get_modified()) |
| display_state = modified; |
| |
| return ret; |
| } |
| |
| hwc2_error_t hwc2_display::set_layer_transform(hwc2_layer_t lyr_id, |
| const hwc_transform_t transform) |
| { |
| auto it = layers.find(lyr_id); |
| if (it == layers.end()) { |
| ALOGE("dpy %" PRIu64 ": lyr %" PRIu64 ": bad layer handle", id, lyr_id); |
| return HWC2_ERROR_BAD_LAYER; |
| } |
| |
| hwc2_error_t ret = it->second.set_transform(transform); |
| |
| if (it->second.get_modified()) |
| display_state = modified; |
| |
| return ret; |
| } |
| |
| hwc2_error_t hwc2_display::set_layer_visible_region(hwc2_layer_t lyr_id, |
| const hwc_region_t &visible_region) |
| { |
| auto it = layers.find(lyr_id); |
| if (it == layers.end()) { |
| ALOGE("dpy %" PRIu64 ": lyr %" PRIu64 ": bad layer handle", id, lyr_id); |
| return HWC2_ERROR_BAD_LAYER; |
| } |
| |
| hwc2_error_t ret = it->second.set_visible_region(visible_region); |
| |
| if (it->second.get_modified()) |
| display_state = modified; |
| |
| return ret; |
| } |
| |
| hwc2_error_t hwc2_display::set_layer_color(hwc2_layer_t lyr_id, |
| const hwc_color_t& /*color*/) |
| { |
| auto it = layers.find(lyr_id); |
| if (it == layers.end()) { |
| ALOGE("dpy %" PRIu64 ": lyr %" PRIu64 ": bad layer handle", id, lyr_id); |
| return HWC2_ERROR_BAD_LAYER; |
| } |
| |
| /* Layer colors are not supported on flounder. During validate, any layers |
| * marked HWC2_COMPOSITION_SOLID_COLOR will be changed to |
| * HWC2_COMPOSITION_CLIENT. No need to store the layer color. */ |
| return HWC2_ERROR_NONE; |
| } |
| |
| hwc2_error_t hwc2_display::set_cursor_position(hwc2_layer_t lyr_id, |
| int32_t /*x*/, int32_t /*y*/) |
| { |
| auto it = layers.find(lyr_id); |
| if (it == layers.end()) { |
| ALOGE("dpy %" PRIu64 ": lyr %" PRIu64 ": bad layer handle", id, lyr_id); |
| return HWC2_ERROR_BAD_LAYER; |
| } |
| |
| /* Cursors are not supported on flounder. During validate, any layers marked |
| * HWC2_COMPOSITION_CURSOR will be changed to HWC2_COMPOSITION_CLIENT. |
| * No need to store the cursor position. */ |
| return HWC2_ERROR_NONE; |
| } |
| |
| hwc2_display_t hwc2_display::get_next_id() |
| { |
| return display_cnt++; |
| } |
