| /* |
| * Copyright (c) 2017-2019, The Linux Foundation. All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions are |
| * met: |
| * * Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * * Redistributions in binary form must reproduce the above |
| * copyright notice, this list of conditions and the following |
| * disclaimer in the documentation and/or other materials provided |
| * with the distribution. |
| * * Neither the name of The Linux Foundation nor the names of its |
| * contributors may be used to endorse or promote products derived |
| * from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED |
| * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
| * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT |
| * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS |
| * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
| * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
| * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR |
| * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, |
| * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE |
| * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN |
| * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| #include <cutils/properties.h> |
| #include <sys/mman.h> |
| #include <sys/types.h> |
| #include <sys/stat.h> |
| #include <utils/constants.h> |
| #include <utils/debug.h> |
| #include <utils/formats.h> |
| #include <algorithm> |
| #include <array> |
| #include <sstream> |
| #include <string> |
| #include <fstream> |
| |
| #include "hwc_display_pluggable_test.h" |
| #include "hwc_debugger.h" |
| |
| #define __CLASS__ "HWCDisplayPluggableTest" |
| |
| namespace sdm { |
| |
| using std::array; |
| |
| int HWCDisplayPluggableTest::Create(CoreInterface *core_intf, HWCBufferAllocator *buffer_allocator, |
| HWCCallbacks *callbacks, HWCDisplayEventHandler *event_handler, |
| qService::QService *qservice, hwc2_display_t id, |
| int32_t sdm_id, uint32_t panel_bpp, uint32_t pattern_type, |
| HWCDisplay **hwc_display) { |
| HWCDisplay *hwc_pluggable_test = new HWCDisplayPluggableTest(core_intf, buffer_allocator, |
| callbacks, event_handler, qservice, |
| id, sdm_id, panel_bpp, pattern_type); |
| |
| int status = hwc_pluggable_test->Init(); |
| if (status) { |
| delete hwc_pluggable_test; |
| return status; |
| } |
| |
| *hwc_display = hwc_pluggable_test; |
| |
| DLOGD("Pluggable panel_bpp %d, pattern_type %d", panel_bpp, pattern_type); |
| |
| return status; |
| } |
| |
| void HWCDisplayPluggableTest::Destroy(HWCDisplay *hwc_display) { |
| // Flush the display to have outstanding fences signaled. |
| hwc_display->Flush(); |
| hwc_display->Deinit(); |
| |
| delete hwc_display; |
| } |
| |
| HWCDisplayPluggableTest::HWCDisplayPluggableTest(CoreInterface *core_intf, |
| HWCBufferAllocator *buffer_allocator, |
| HWCCallbacks *callbacks, |
| HWCDisplayEventHandler *event_handler, |
| qService::QService *qservice, hwc2_display_t id, |
| int32_t sdm_id, uint32_t panel_bpp, |
| uint32_t pattern_type) |
| : HWCDisplay(core_intf, buffer_allocator, callbacks, event_handler, qservice, kPluggable, id, |
| sdm_id, DISPLAY_CLASS_PLUGGABLE), |
| panel_bpp_(panel_bpp), pattern_type_(pattern_type) { |
| } |
| |
| int HWCDisplayPluggableTest::Init() { |
| uint32_t pluggable_width = 0; |
| uint32_t pluggable_height = 0; |
| |
| int status = HWCDisplay::Init(); |
| if (status) { |
| DLOGE("HWCDisplayPluggableTest::Init status = %d ", status); |
| return status; |
| } |
| |
| status = CreateLayerStack(); |
| if (status) { |
| Deinit(); |
| return status; |
| } |
| |
| DisplayError error = HWCDisplay::GetMixerResolution(&pluggable_width, &pluggable_height); |
| if (error != kErrorNone) { |
| Deinit(); |
| return -EINVAL; |
| } |
| |
| status = HWCDisplay::SetFrameBufferResolution(pluggable_width, pluggable_height); |
| if (status) { |
| Deinit(); |
| DLOGE("HWCDisplayPluggableTest:: set fb resolution status = %d ", status); |
| return status; |
| } |
| |
| return status; |
| } |
| |
| int HWCDisplayPluggableTest::Deinit() { |
| DestroyLayerStack(); |
| return HWCDisplay::Deinit(); |
| } |
| |
| |
| HWC2::Error HWCDisplayPluggableTest::Validate(uint32_t *out_num_types, uint32_t *out_num_requests) { |
| auto status = HWC2::Error::None; |
| if (active_secure_sessions_[kSecureDisplay] || display_paused_) { |
| MarkLayersForGPUBypass(); |
| return status; |
| } |
| |
| if (layer_set_.empty()) { |
| flush_ = true; |
| return status; |
| } |
| |
| if (shutdown_pending_) { |
| return status; |
| } |
| DisplayError error = display_intf_->Prepare(&layer_stack_); |
| if (error != kErrorNone) { |
| if (error == kErrorShutDown) { |
| shutdown_pending_ = true; |
| } else if (error != kErrorPermission) { |
| DLOGE("Prepare failed. Error = %d", error); |
| // To prevent surfaceflinger infinite wait, flush the previous frame during Commit() |
| // so that previous buffer and fences are released, and override the error. |
| flush_ = true; |
| } |
| } |
| |
| MarkLayersForGPUBypass(); |
| |
| return status; |
| } |
| |
| HWC2::Error HWCDisplayPluggableTest::Present(int32_t *out_retire_fence) { |
| auto status = HWC2::Error::None; |
| |
| if (active_secure_sessions_[kSecureDisplay]) { |
| return status; |
| } |
| |
| if (display_paused_) { |
| DisplayError error = display_intf_->Flush(&layer_stack_); |
| validated_ = false; |
| if (error != kErrorNone) { |
| DLOGE("Flush failed. Error = %d", error); |
| } |
| } |
| |
| if (shutdown_pending_) { |
| return status; |
| } |
| |
| DumpInputBuffer(); |
| |
| if (!flush_) { |
| DisplayError error = kErrorUndefined; |
| error = display_intf_->Commit(&layer_stack_); |
| if (error == kErrorNone) { |
| // A commit is successfully submitted, start flushing on failure now onwards. |
| flush_on_error_ = true; |
| } else if (error == kErrorShutDown) { |
| shutdown_pending_ = true; |
| status = HWC2::Error::Unsupported; |
| } else if (error == kErrorNotValidated) { |
| status = HWC2::Error::NotValidated; |
| } else if (error != kErrorPermission) { |
| DLOGE("Commit failed. Error = %d", error); |
| // To prevent surfaceflinger infinite wait, flush the previous frame during Commit() |
| // so that previous buffer and fences are released, and override the error. |
| flush_ = true; |
| } |
| } |
| PostCommit(out_retire_fence); |
| return status; |
| } |
| |
| int HWCDisplayPluggableTest::Perform(uint32_t operation, ...) { |
| return 0; |
| } |
| |
| void HWCDisplayPluggableTest::DumpInputBuffer() { |
| if (!dump_frame_count_ || flush_ || !dump_input_layers_) { |
| return; |
| } |
| |
| const char *dir_path = "/data/vendor/display/frame_dump_external"; |
| uint32_t width = buffer_info_.alloc_buffer_info.aligned_width; |
| uint32_t height = buffer_info_.alloc_buffer_info.aligned_height; |
| string format_str = GetFormatString(buffer_info_.buffer_config.format); |
| |
| char *buffer = reinterpret_cast<char *>(mmap(NULL, buffer_info_.alloc_buffer_info.size, |
| PROT_READ|PROT_WRITE, MAP_SHARED, |
| buffer_info_.alloc_buffer_info.fd, 0)); |
| if (buffer == MAP_FAILED) { |
| DLOGW("mmap failed. err = %d", errno); |
| return; |
| } |
| |
| if (mkdir(dir_path, 0777) != 0 && errno != EEXIST) { |
| DLOGW("Failed to create %s directory errno = %d, desc = %s", dir_path, errno, strerror(errno)); |
| return; |
| } |
| |
| // if directory exists already, need to explicitly change the permission. |
| if (errno == EEXIST && chmod(dir_path, 0777) != 0) { |
| DLOGW("Failed to change permissions on %s directory", dir_path); |
| return; |
| } |
| |
| if (buffer) { |
| std::stringstream dump_file_name; |
| dump_file_name << dir_path; |
| dump_file_name << "/input_layer_" << width << "x" << height << "_" << format_str << ".raw"; |
| |
| std::fstream fs; |
| fs.open(dump_file_name.str().c_str(), std::fstream::in | std::fstream::out | std::fstream::app); |
| if (!fs.is_open()) { |
| DLOGI("File open failed %s", dump_file_name.str().c_str()); |
| return; |
| } |
| |
| fs.write(buffer, (std::streamsize)buffer_info_.alloc_buffer_info.size); |
| fs.close(); |
| |
| DLOGI("Frame Dump %s: is successful", dump_file_name.str().c_str()); |
| } |
| |
| // Dump only once as the content is going to be same for all draw cycles |
| if (dump_frame_count_) { |
| dump_frame_count_ = 0; |
| } |
| |
| if (munmap(buffer, buffer_info_.alloc_buffer_info.size) != 0) { |
| DLOGW("munmap failed. err = %d", errno); |
| return; |
| } |
| } |
| |
| void HWCDisplayPluggableTest::CalcCRC(uint32_t color_val, std::bitset<16> *crc_data) { |
| std::bitset<16> color = {}; |
| std::bitset<16> temp_crc = {}; |
| |
| switch (panel_bpp_) { |
| case kDisplayBpp18: |
| color = (color_val & 0xFC) << 8; |
| break; |
| case kDisplayBpp24: |
| color = color_val << 8; |
| break; |
| case kDisplayBpp30: |
| color = color_val << 6; |
| break; |
| default: |
| return; |
| } |
| |
| temp_crc[15] = (*crc_data)[0] ^ (*crc_data)[1] ^ (*crc_data)[2] ^ (*crc_data)[3] ^ |
| (*crc_data)[4] ^ (*crc_data)[5] ^ (*crc_data)[6] ^ (*crc_data)[7] ^ |
| (*crc_data)[8] ^ (*crc_data)[9] ^ (*crc_data)[10] ^ (*crc_data)[11] ^ |
| (*crc_data)[12] ^ (*crc_data)[14] ^ (*crc_data)[15] ^ color[0] ^ color[1] ^ |
| color[2] ^ color[3] ^ color[4] ^ color[5] ^ color[6] ^ color[7] ^ color[8] ^ |
| color[9] ^ color[10] ^ color[11] ^ color[12] ^ color[14] ^ color[15]; |
| |
| temp_crc[14] = (*crc_data)[12] ^ (*crc_data)[13] ^ color[12] ^ color[13]; |
| temp_crc[13] = (*crc_data)[11] ^ (*crc_data)[12] ^ color[11] ^ color[12]; |
| temp_crc[12] = (*crc_data)[10] ^ (*crc_data)[11] ^ color[10] ^ color[11]; |
| temp_crc[11] = (*crc_data)[9] ^ (*crc_data)[10] ^ color[9] ^ color[10]; |
| temp_crc[10] = (*crc_data)[8] ^ (*crc_data)[9] ^ color[8] ^ color[9]; |
| temp_crc[9] = (*crc_data)[7] ^ (*crc_data)[8] ^ color[7] ^ color[8]; |
| temp_crc[8] = (*crc_data)[6] ^ (*crc_data)[7] ^ color[6] ^ color[7]; |
| temp_crc[7] = (*crc_data)[5] ^ (*crc_data)[6] ^ color[5] ^ color[6]; |
| temp_crc[6] = (*crc_data)[4] ^ (*crc_data)[5] ^ color[4] ^ color[5]; |
| temp_crc[5] = (*crc_data)[3] ^ (*crc_data)[4] ^ color[3] ^ color[4]; |
| temp_crc[4] = (*crc_data)[2] ^ (*crc_data)[3] ^ color[2] ^ color[3]; |
| temp_crc[3] = (*crc_data)[1] ^ (*crc_data)[2] ^ (*crc_data)[15] ^ color[1] ^ color[2] ^ color[15]; |
| temp_crc[2] = (*crc_data)[0] ^ (*crc_data)[1] ^ (*crc_data)[14] ^ color[0] ^ color[1] ^ color[14]; |
| |
| temp_crc[1] = (*crc_data)[1] ^ (*crc_data)[2] ^ (*crc_data)[3] ^ (*crc_data)[4] ^ (*crc_data)[5] ^ |
| (*crc_data)[6] ^ (*crc_data)[7] ^ (*crc_data)[8] ^ (*crc_data)[9] ^ |
| (*crc_data)[10] ^ (*crc_data)[11] ^ (*crc_data)[12] ^ (*crc_data)[13] ^ |
| (*crc_data)[14] ^ color[1] ^ color[2] ^ color[3] ^ color[4] ^ color[5] ^ color[6] ^ |
| color[7] ^ color[8] ^ color[9] ^ color[10] ^ color[11] ^ color[12] ^ color[13] ^ |
| color[14]; |
| |
| temp_crc[0] = (*crc_data)[0] ^ (*crc_data)[1] ^ (*crc_data)[2] ^ (*crc_data)[3] ^ (*crc_data)[4] ^ |
| (*crc_data)[5] ^ (*crc_data)[6] ^ (*crc_data)[7] ^ (*crc_data)[8] ^ (*crc_data)[9] ^ |
| (*crc_data)[10] ^ (*crc_data)[11] ^ (*crc_data)[12] ^ (*crc_data)[13] ^ |
| (*crc_data)[15] ^ color[0] ^ color[1] ^ color[2] ^ color[3] ^ color[4] ^ color[5] ^ |
| color[6] ^ color[7] ^ color[8] ^ color[9] ^ color[10] ^ color[11] ^ color[12] ^ |
| color[13] ^ color[15]; |
| |
| (*crc_data) = temp_crc; |
| } |
| |
| int HWCDisplayPluggableTest::FillBuffer() { |
| uint8_t *buffer = reinterpret_cast<uint8_t *>(mmap(NULL, buffer_info_.alloc_buffer_info.size, |
| PROT_READ|PROT_WRITE, MAP_SHARED, |
| buffer_info_.alloc_buffer_info.fd, 0)); |
| if (buffer == MAP_FAILED) { |
| DLOGE("mmap failed. err = %d", errno); |
| return -EFAULT; |
| } |
| |
| switch (pattern_type_) { |
| case kPatternColorRamp: |
| GenerateColorRamp(buffer); |
| break; |
| case kPatternBWVertical: |
| GenerateBWVertical(buffer); |
| break; |
| case kPatternColorSquare: |
| GenerateColorSquare(buffer); |
| break; |
| default: |
| DLOGW("Invalid Pattern type %d", pattern_type_); |
| return -EINVAL; |
| } |
| |
| if (munmap(buffer, buffer_info_.alloc_buffer_info.size) != 0) { |
| DLOGE("munmap failed. err = %d", errno); |
| return -EFAULT; |
| } |
| |
| return 0; |
| } |
| |
| int HWCDisplayPluggableTest::GetStride(LayerBufferFormat format, uint32_t width, uint32_t *stride) { |
| switch (format) { |
| case kFormatRGBA8888: |
| case kFormatRGBA1010102: |
| *stride = width * 4; |
| break; |
| case kFormatRGB888: |
| *stride = width * 3; |
| break; |
| default: |
| DLOGW("Unsupported format type %d", format); |
| return -EINVAL; |
| } |
| |
| return 0; |
| } |
| |
| void HWCDisplayPluggableTest::PixelCopy(uint32_t red, uint32_t green, uint32_t blue, uint32_t alpha, |
| uint8_t **buffer) { |
| LayerBufferFormat format = buffer_info_.buffer_config.format; |
| |
| switch (format) { |
| case kFormatRGBA8888: |
| *(*buffer)++ = UINT8(red & 0xFF); |
| *(*buffer)++ = UINT8(green & 0xFF); |
| *(*buffer)++ = UINT8(blue & 0xFF); |
| *(*buffer)++ = UINT8(alpha & 0xFF); |
| break; |
| case kFormatRGB888: |
| *(*buffer)++ = UINT8(red & 0xFF); |
| *(*buffer)++ = UINT8(green & 0xFF); |
| *(*buffer)++ = UINT8(blue & 0xFF); |
| break; |
| case kFormatRGBA1010102: |
| // Lower 8 bits of red |
| *(*buffer)++ = UINT8(red & 0xFF); |
| |
| // Upper 2 bits of Red + Lower 6 bits of green |
| *(*buffer)++ = UINT8(((green & 0x3F) << 2) | ((red >> 0x8) & 0x3)); |
| |
| // Upper 4 bits of green + Lower 4 bits of blue |
| *(*buffer)++ = UINT8(((blue & 0xF) << 4) | ((green >> 6) & 0xF)); |
| |
| // Upper 6 bits of blue + Lower 2 bits of alpha |
| *(*buffer)++ = UINT8(((alpha & 0x3) << 6) | ((blue >> 4) & 0x3F)); |
| break; |
| default: |
| DLOGW("format not supported format = %d", format); |
| break; |
| } |
| } |
| |
| void HWCDisplayPluggableTest::GenerateColorRamp(uint8_t *buffer) { |
| uint32_t width = buffer_info_.buffer_config.width; |
| uint32_t height = buffer_info_.buffer_config.height; |
| LayerBufferFormat format = buffer_info_.buffer_config.format; |
| uint32_t aligned_width = buffer_info_.alloc_buffer_info.aligned_width; |
| uint32_t buffer_stride = 0; |
| |
| uint32_t color_ramp = 0; |
| uint32_t start_color_val = 0; |
| uint32_t step_size = 1; |
| uint32_t ramp_width = 0; |
| uint32_t ramp_height = 0; |
| uint32_t shift_by = 0; |
| |
| std::bitset<16> crc_red = {}; |
| std::bitset<16> crc_green = {}; |
| std::bitset<16> crc_blue = {}; |
| |
| switch (panel_bpp_) { |
| case kDisplayBpp18: |
| ramp_height = 64; |
| ramp_width = 64; |
| shift_by = 2; |
| break; |
| case kDisplayBpp24: |
| ramp_height = 64; |
| ramp_width = 256; |
| break; |
| case kDisplayBpp30: |
| ramp_height = 32; |
| ramp_width = 256; |
| start_color_val = 0x180; |
| break; |
| default: |
| return; |
| } |
| |
| GetStride(format, aligned_width, &buffer_stride); |
| |
| for (uint32_t loop_height = 0; loop_height < height; loop_height++) { |
| uint32_t color_value = start_color_val; |
| uint8_t *temp = buffer + (loop_height * buffer_stride); |
| |
| for (uint32_t loop_width = 0; loop_width < width; loop_width++) { |
| if (color_ramp == kColorRedRamp) { |
| PixelCopy(color_value, 0, 0, 0, &temp); |
| CalcCRC(color_value, &crc_red); |
| CalcCRC(0, &crc_green); |
| CalcCRC(0, &crc_blue); |
| } |
| if (color_ramp == kColorGreenRamp) { |
| PixelCopy(0, color_value, 0, 0, &temp); |
| CalcCRC(0, &crc_red); |
| CalcCRC(color_value, &crc_green); |
| CalcCRC(0, &crc_blue); |
| } |
| if (color_ramp == kColorBlueRamp) { |
| PixelCopy(0, 0, color_value, 0, &temp); |
| CalcCRC(0, &crc_red); |
| CalcCRC(0, &crc_green); |
| CalcCRC(color_value, &crc_blue); |
| } |
| if (color_ramp == kColorWhiteRamp) { |
| PixelCopy(color_value, color_value, color_value, 0, &temp); |
| CalcCRC(color_value, &crc_red); |
| CalcCRC(color_value, &crc_green); |
| CalcCRC(color_value, &crc_blue); |
| } |
| |
| color_value = (start_color_val + (((loop_width + 1) % ramp_width) * step_size)) << shift_by; |
| } |
| |
| if (panel_bpp_ == kDisplayBpp30 && ((loop_height + 1) % ramp_height) == 0) { |
| if (start_color_val == 0x180) { |
| start_color_val = 0; |
| step_size = 4; |
| } else { |
| start_color_val = 0x180; |
| step_size = 1; |
| color_ramp = (color_ramp + 1) % 4; |
| } |
| continue; |
| } |
| |
| if (((loop_height + 1) % ramp_height) == 0) { |
| color_ramp = (color_ramp + 1) % 4; |
| } |
| } |
| |
| DLOGI("CRC red %x", crc_red.to_ulong()); |
| DLOGI("CRC green %x", crc_green.to_ulong()); |
| DLOGI("CRC blue %x", crc_blue.to_ulong()); |
| } |
| |
| void HWCDisplayPluggableTest::GenerateBWVertical(uint8_t *buffer) { |
| uint32_t width = buffer_info_.buffer_config.width; |
| uint32_t height = buffer_info_.buffer_config.height; |
| LayerBufferFormat format = buffer_info_.buffer_config.format; |
| uint32_t aligned_width = buffer_info_.alloc_buffer_info.aligned_width; |
| uint32_t buffer_stride = 0; |
| uint32_t bits_per_component = panel_bpp_ / 3; |
| uint32_t max_color_val = (1 << bits_per_component) - 1; |
| |
| std::bitset<16> crc_red = {}; |
| std::bitset<16> crc_green = {}; |
| std::bitset<16> crc_blue = {}; |
| |
| if (panel_bpp_ == kDisplayBpp18) { |
| max_color_val <<= 2; |
| } |
| |
| GetStride(format, aligned_width, &buffer_stride); |
| |
| for (uint32_t loop_height = 0; loop_height < height; loop_height++) { |
| uint32_t color = 0; |
| uint8_t *temp = buffer + (loop_height * buffer_stride); |
| |
| for (uint32_t loop_width = 0; loop_width < width; loop_width++) { |
| if (color == kColorBlack) { |
| PixelCopy(0, 0, 0, 0, &temp); |
| CalcCRC(0, &crc_red); |
| CalcCRC(0, &crc_green); |
| CalcCRC(0, &crc_blue); |
| } |
| if (color == kColorWhite) { |
| PixelCopy(max_color_val, max_color_val, max_color_val, 0, &temp); |
| CalcCRC(max_color_val, &crc_red); |
| CalcCRC(max_color_val, &crc_green); |
| CalcCRC(max_color_val, &crc_blue); |
| } |
| |
| color = (color + 1) % 2; |
| } |
| } |
| |
| DLOGI("CRC red %x", crc_red.to_ulong()); |
| DLOGI("CRC green %x", crc_green.to_ulong()); |
| DLOGI("CRC blue %x", crc_blue.to_ulong()); |
| } |
| |
| void HWCDisplayPluggableTest::GenerateColorSquare(uint8_t *buffer) { |
| uint32_t width = buffer_info_.buffer_config.width; |
| uint32_t height = buffer_info_.buffer_config.height; |
| LayerBufferFormat format = buffer_info_.buffer_config.format; |
| uint32_t aligned_width = buffer_info_.alloc_buffer_info.aligned_width; |
| uint32_t buffer_stride = 0; |
| uint32_t max_color_val = 0; |
| uint32_t min_color_val = 0; |
| |
| std::bitset<16> crc_red = {}; |
| std::bitset<16> crc_green = {}; |
| std::bitset<16> crc_blue = {}; |
| |
| switch (panel_bpp_) { |
| case kDisplayBpp18: |
| max_color_val = 63 << 2; // CEA Dynamic range for 18bpp 0 - 63 |
| min_color_val = 0; |
| break; |
| case kDisplayBpp24: |
| max_color_val = 235; // CEA Dynamic range for 24bpp 16 - 235 |
| min_color_val = 16; |
| break; |
| case kDisplayBpp30: |
| max_color_val = 940; // CEA Dynamic range for 30bpp 64 - 940 |
| min_color_val = 64; |
| break; |
| default: |
| return; |
| } |
| |
| array<array<uint32_t, 3>, 8> colors = {{ |
| {{max_color_val, max_color_val, max_color_val}}, // White Color |
| {{max_color_val, max_color_val, min_color_val}}, // Yellow Color |
| {{min_color_val, max_color_val, max_color_val}}, // Cyan Color |
| {{min_color_val, max_color_val, min_color_val}}, // Green Color |
| {{max_color_val, min_color_val, max_color_val}}, // Megenta Color |
| {{max_color_val, min_color_val, min_color_val}}, // Red Color |
| {{min_color_val, min_color_val, max_color_val}}, // Blue Color |
| {{min_color_val, min_color_val, min_color_val}}, // Black Color |
| }}; |
| |
| GetStride(format, aligned_width, &buffer_stride); |
| |
| for (uint32_t loop_height = 0; loop_height < height; loop_height++) { |
| uint32_t color = 0; |
| uint8_t *temp = buffer + (loop_height * buffer_stride); |
| |
| for (uint32_t loop_width = 0; loop_width < width; loop_width++) { |
| PixelCopy(colors[color][0], colors[color][1], colors[color][2], 0, &temp); |
| CalcCRC(colors[color][0], &crc_red); |
| CalcCRC(colors[color][1], &crc_green); |
| CalcCRC(colors[color][2], &crc_blue); |
| |
| if (((loop_width + 1) % 64) == 0) { |
| color = (color + 1) % colors.size(); |
| } |
| } |
| |
| if (((loop_height + 1) % 64) == 0) { |
| std::reverse(colors.begin(), (colors.end() - 1)); |
| } |
| } |
| |
| DLOGI("CRC red %x", crc_red.to_ulong()); |
| DLOGI("CRC green %x", crc_green.to_ulong()); |
| DLOGI("CRC blue %x", crc_blue.to_ulong()); |
| } |
| |
| int HWCDisplayPluggableTest::InitLayer(Layer *layer) { |
| uint32_t active_config = 0; |
| DisplayConfigVariableInfo var_info = {}; |
| |
| GetActiveDisplayConfig(&active_config); |
| |
| GetDisplayAttributesForConfig(INT32(active_config), &var_info); |
| |
| layer->flags.updating = 1; |
| layer->src_rect = LayerRect(0, 0, var_info.x_pixels, var_info.y_pixels); |
| layer->dst_rect = layer->src_rect; |
| layer->frame_rate = var_info.fps; |
| layer->blending = kBlendingPremultiplied; |
| |
| layer->input_buffer.unaligned_width = var_info.x_pixels; |
| layer->input_buffer.unaligned_height = var_info.y_pixels; |
| buffer_info_.buffer_config.format = kFormatRGBA8888; |
| |
| if (layer->composition != kCompositionGPUTarget) { |
| buffer_info_.buffer_config.width = var_info.x_pixels; |
| buffer_info_.buffer_config.height = var_info.y_pixels; |
| switch (panel_bpp_) { |
| case kDisplayBpp18: |
| case kDisplayBpp24: |
| buffer_info_.buffer_config.format = kFormatRGB888; |
| break; |
| case kDisplayBpp30: |
| buffer_info_.buffer_config.format = kFormatRGBA1010102; |
| break; |
| default: |
| DLOGW("panel bpp not supported %d", panel_bpp_); |
| return -EINVAL; |
| } |
| buffer_info_.buffer_config.buffer_count = 1; |
| |
| int ret = buffer_allocator_->AllocateBuffer(&buffer_info_); |
| if (ret != 0) { |
| DLOGE("Buffer allocation failed. ret: %d", ret); |
| return -ENOMEM; |
| } |
| |
| ret = FillBuffer(); |
| if (ret != 0) { |
| buffer_allocator_->FreeBuffer(&buffer_info_); |
| return ret; |
| } |
| |
| layer->input_buffer.width = buffer_info_.alloc_buffer_info.aligned_width; |
| layer->input_buffer.height = buffer_info_.alloc_buffer_info.aligned_height; |
| layer->input_buffer.size = buffer_info_.alloc_buffer_info.size; |
| layer->input_buffer.planes[0].fd = buffer_info_.alloc_buffer_info.fd; |
| layer->input_buffer.planes[0].stride = buffer_info_.alloc_buffer_info.stride; |
| layer->input_buffer.format = buffer_info_.buffer_config.format; |
| |
| DLOGI("Input buffer WxH %dx%d format %s size %d fd %d stride %d", layer->input_buffer.width, |
| layer->input_buffer.height, GetFormatString(layer->input_buffer.format), |
| layer->input_buffer.size, layer->input_buffer.planes[0].fd, |
| layer->input_buffer.planes[0].stride); |
| } |
| |
| return 0; |
| } |
| |
| int HWCDisplayPluggableTest::DeinitLayer(Layer *layer) { |
| if (layer->composition != kCompositionGPUTarget) { |
| int ret = buffer_allocator_->FreeBuffer(&buffer_info_); |
| if (ret != 0) { |
| DLOGE("Buffer deallocation failed. ret: %d", ret); |
| return -ENOMEM; |
| } |
| } |
| |
| return 0; |
| } |
| |
| int HWCDisplayPluggableTest::CreateLayerStack() { |
| for (uint32_t i = 0; i < (kTestLayerCnt + 1 /* one dummy gpu_target layer */); i++) { |
| Layer *layer = new Layer(); |
| |
| if (i == kTestLayerCnt) { |
| layer->composition = kCompositionGPUTarget; |
| } |
| DLOGD("External :: CreateLayerStack %d", i); |
| int ret = InitLayer(layer); |
| if (ret != 0) { |
| delete layer; |
| return ret; |
| } |
| layer_stack_.layers.push_back(layer); |
| } |
| |
| return 0; |
| } |
| |
| int HWCDisplayPluggableTest::DestroyLayerStack() { |
| for (uint32_t i = 0; i < UINT32(layer_stack_.layers.size()); i++) { |
| Layer *layer = layer_stack_.layers.at(i); |
| int ret = DeinitLayer(layer); |
| if (ret != 0) { |
| return ret; |
| } |
| delete layer; |
| } |
| layer_stack_.layers = {}; |
| |
| return 0; |
| } |
| |
| HWC2::Error HWCDisplayPluggableTest::PostCommit(int32_t *out_retire_fence) { |
| auto status = HWC2::Error::None; |
| // Do no call flush on errors, if a successful buffer is never submitted. |
| if (flush_ && flush_on_error_) { |
| display_intf_->Flush(&layer_stack_); |
| } |
| if (!flush_) { |
| for (size_t i = 0; i < layer_stack_.layers.size(); i++) { |
| Layer *layer = layer_stack_.layers.at(i); |
| LayerBuffer &layer_buffer = layer->input_buffer; |
| |
| close(layer_buffer.release_fence_fd); |
| layer_buffer.release_fence_fd = -1; |
| } |
| close(layer_stack_.retire_fence_fd); |
| layer_stack_.retire_fence_fd = -1; |
| *out_retire_fence = -1; |
| } |
| flush_ = false; |
| |
| return status; |
| } |
| |
| } // namespace sdm |
| |
