rk3588-game
/
android13
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
android13/hardware/rockchip/hwcomposer/drmhwc/hwcomposer.cpp

4505 lines
151 KiB
C++
Executable File
Raw Blame History

/*
* Copyright (C) 2018 Fuzhou Rockchip Electronics Co.Ltd.
*
* Modification based on code covered by the Apache License, Version 2.0 (the "License").
* You may not use this software except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS TO YOU ON AN "AS IS" BASIS
* AND ANY AND ALL WARRANTIES AND REPRESENTATIONS WITH RESPECT TO SUCH SOFTWARE, WHETHER EXPRESS,
* IMPLIED, STATUTORY OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY IMPLIED WARRANTIES OF TITLE,
* NON-INFRINGEMENT, MERCHANTABILITY, SATISFACTROY QUALITY, ACCURACY OR FITNESS FOR A PARTICULAR
* PURPOSE 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.
*
* Copyright (C) 2015 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.
*/
#define ATRACE_TAG ATRACE_TAG_GRAPHICS
#define LOG_TAG "hwcomposer-drm"
#include "drmhwcomposer.h"
#include "drmeventlistener.h"
#include "drmresources.h"
#include "platform.h"
#include "virtualcompositorworker.h"
#include "vsyncworker.h"
#include "autolock.h"
#include <stdlib.h>
#include <cinttypes>
#include <map>
#include <vector>
#include <sstream>
#include <stdio.h>
#include <errno.h>
#include <fcntl.h>
#include <pthread.h>
#include <sys/param.h>
#include <sys/resource.h>
#include <xf86drm.h>
#include <xf86drmMode.h>
#ifdef ANDROID_P
#include <log/log.h>
#include <libsync/sw_sync.h>
#include <android/sync.h>
#else
#include <cutils/log.h>
#include <sw_sync.h>
#include <sync/sync.h>
#endif
#include <cutils/properties.h>
#include <hardware/hardware.h>
#include <hardware/hwcomposer.h>
#include <utils/Trace.h>
#include <drm_fourcc.h>
#if RK_DRM_GRALLOC
#include "gralloc_drm_handle.h"
#endif
#include <linux/fb.h>
#include "hwc_util.h"
#include "hwc_rockchip.h"
#include <android/configuration.h>
#define UM_PER_INCH 25400
#if USE_GRALLOC_4
#include "drmgralloc4.h"
#endif
namespace android {
static int hwc_set_active_config(struct hwc_composer_device_1 *dev, int display,
int index);
static int update_display_bestmode(hwc_drm_display_t *hd, int display, DrmConnector *c);
#if SKIP_BOOT
static unsigned int g_boot_cnt = 0;
#endif
static unsigned int g_boot_gles_cnt = 0;
static unsigned int g_extern_gles_cnt = 0;
static bool g_bSkipExtern = false;
#ifdef USE_HWC2
static bool g_hasHotplug = false;
// Must to wait hwc-set to send Hotplug event
// If you don't do this, there will be problems with the hot-plugging device registration and destruction timing.
// In severe cases, the fence fd will leak or the system will not respond.
static bool g_waitHwcSetHotplug = false;
#endif
//#if RK_INVALID_REFRESH
hwc_context_t* g_ctx = NULL;
//#endif
class DummySwSyncTimeline {
public:
int Init() {
int ret = timeline_fd_.Set(sw_sync_timeline_create());
if (ret < 0)
return ret;
return 0;
}
UniqueFd CreateDummyFence() {
int ret = sw_sync_fence_create(timeline_fd_.get(), "dummy fence",
timeline_pt_ + 1);
if (ret < 0) {
ALOGE("Failed to create dummy fence %d", ret);
return ret;
}
UniqueFd ret_fd(ret);
ret = sw_sync_timeline_inc(timeline_fd_.get(), 1);
if (ret) {
ALOGE("Failed to increment dummy sync timeline %d", ret);
return ret;
}
++timeline_pt_;
return ret_fd;
}
private:
UniqueFd timeline_fd_;
int timeline_pt_ = 0;
};
struct CheckedOutputFd {
CheckedOutputFd(int *fd, const char *description,
DummySwSyncTimeline &timeline)
: fd_(fd), description_(description), timeline_(timeline) {
}
CheckedOutputFd(CheckedOutputFd &&rhs)
: description_(rhs.description_), timeline_(rhs.timeline_) {
std::swap(fd_, rhs.fd_);
}
CheckedOutputFd &operator=(const CheckedOutputFd &rhs) = delete;
~CheckedOutputFd() {
if (fd_ == NULL)
return;
if (*fd_ >= 0)
return;
*fd_ = timeline_.CreateDummyFence().Release();
if (*fd_ < 0)
ALOGE("Failed to fill %s (%p == %d) before destruction",
description_.c_str(), fd_, *fd_);
}
private:
int *fd_ = NULL;
std::string description_;
DummySwSyncTimeline &timeline_;
};
// map of display:hwc_drm_display_t
typedef std::map<int, hwc_drm_display_t> DisplayMap;
class DrmHotplugHandler : public DrmEventHandler {
public:
void Init(DisplayMap* displays, DrmResources *drm, const struct hwc_procs *procs) {
displays_ = displays;
drm_ = drm;
procs_ = procs;
int ret = pthread_mutex_init(&lock_, NULL);
if (ret) {
ALOGE("Failed to initialize drm compositor lock %d\n", ret);
return;
}
}
void HandleEvent(uint64_t timestamp_us) {
AutoLock lock(&lock_, __func__);
if (lock.Lock())
return;
DrmConnector *extend = NULL;
DrmConnector *primary = NULL;
for (auto &conn : drm_->connectors()) {
//In sleep mode,we need get raw connector state,otherwise,we will miss the chance
//to handle hotplug event.
//Pg: sleep (force_disconnect will be true)==> plug out HDMI ==> plug in HDMI ==> wake up (force_disconnect still be ture)
//Workround: use raw connector state.
drmModeConnection old_state = conn->raw_state();
conn->UpdateModes();
drmModeConnection cur_state = conn->raw_state();
if (cur_state == old_state)
continue;
ALOGI("hwc_hotplug: %s event @%" PRIu64 " for connector %u type=%s, type_id=%d\n",
cur_state == DRM_MODE_CONNECTED ? "Plug" : "Unplug", timestamp_us,
conn->id(),drm_->connector_type_str(conn->get_type()),conn->type_id());
if (cur_state == DRM_MODE_CONNECTED) {
/*
* if connector is only one , only to use primary. by libin
*/
if (drm_->connectors().size() == 1){
primary = conn.get();
ALOGI("connectors_.size()=%u only primary\n",(uint32_t)drm_->connectors().size());
}else{
if (conn->possible_displays() & HWC_DISPLAY_EXTERNAL_BIT){
ALOGD("hwc_hotplug: find the first connect external type=%s(%d)",
drm_->connector_type_str(conn->get_type()), conn->type_id());
extend = conn.get();
}
else if (conn->possible_displays() & HWC_DISPLAY_PRIMARY_BIT){
ALOGD("hwc_hotplug: find the first connect primary type=%s(%d)",
drm_->connector_type_str(conn->get_type()), conn->type_id());
primary = conn.get();
}
}
}
}
/*
* status changed?
*/
drm_->DisplayChanged();
DrmConnector *old_primary = drm_->GetConnectorFromType(HWC_DISPLAY_PRIMARY);
primary = primary ? primary : old_primary;
if (!primary || primary->raw_state() != DRM_MODE_CONNECTED) {
primary = NULL;
for (auto &conn : drm_->connectors()) {
if (!(conn->possible_displays() & HWC_DISPLAY_PRIMARY_BIT))
continue;
if (conn->raw_state() == DRM_MODE_CONNECTED) {
primary = conn.get();
ALOGD("hwc_hotplug: find the second connect primary type=%s(%d)",
drm_->connector_type_str(conn->get_type()), conn->type_id());
break;
}
}
}
if (!primary) {
for (auto &conn : drm_->connectors()) {
if (!(conn->possible_displays() & HWC_DISPLAY_PRIMARY_BIT))
continue;
ALOGD("hwc_hotplug: find the third primary type=%s(%d)",
drm_->connector_type_str(conn->get_type()), conn->type_id());
primary = conn.get();
}
}
if (!primary) {
ALOGE("hwc_hotplug: %s %d Failed to find primary display\n", __FUNCTION__, __LINE__);
return;
}
//ClearDisplay show be called before display update(SetPrimaryDisplay/SetExtendDisplay).
//It will singal the original disconnect display.
drm_->ClearDisplay();
if (primary != old_primary) {
hwc_drm_display_t *hd = &(*displays_)[primary->display()];
hwc_drm_display_t *old_hd = &(*displays_)[old_primary->display()];
update_display_bestmode(hd, HWC_DISPLAY_PRIMARY, primary);
DrmMode mode = primary->best_mode();
primary->set_current_mode(mode);
hd->framebuffer_width = old_hd->framebuffer_width;
hd->framebuffer_height = old_hd->framebuffer_height;
hd->rel_xres = mode.h_display();
hd->rel_yres = mode.v_display();
hd->v_total = mode.v_total();
//rk: Avoid fb handle is null which lead HDMI display nothing with GLES.
usleep(HOTPLUG_MSLEEP*1000);
procs_->invalidate(procs_);
drm_->SetPrimaryDisplay(primary);
}
DrmConnector *old_extend = drm_->GetConnectorFromType(HWC_DISPLAY_EXTERNAL);
extend = extend ? extend : old_extend;
if (!extend || extend->raw_state() != DRM_MODE_CONNECTED) {
extend = NULL;
for (auto &conn : drm_->connectors()) {
if (!(conn->possible_displays() & HWC_DISPLAY_EXTERNAL_BIT))
continue;
if (conn->id() == primary->id())
continue;
if (conn->raw_state() == DRM_MODE_CONNECTED) {
extend = conn.get();
ALOGD("hwc_hotplug: find the second connect external type=%s(%d)",
drm_->connector_type_str(conn->get_type()), conn->type_id());
break;
}
}
}
drm_->SetExtendDisplay(extend);
if (!extend) {
#ifdef USE_HWC2
g_waitHwcSetHotplug = false;
procs_->invalidate(procs_);
while(!g_waitHwcSetHotplug && g_hasHotplug){
usleep(2000);
}
#endif
procs_->hotplug(procs_, HWC_DISPLAY_EXTERNAL, 0);
/**********************long-running operations should move back of hotplug**************************/
/*
* If Connector changed ,update baseparameter , resolution , color.
*/
hwc_get_baseparameter_config(NULL,0,BP_UPDATE,0);
//When wake up from TV mode, it will bind crtc to TV connector.
//If we also plug in HDMI,and don't bind crtc to HDMI connector,
//the crtc of connected HDMI will be NULL. Which lead HDMI show nothing.
//Pg: Defect #149666
/**************************************************************************/
//2. We should get current mode before UpdateDisplayRoute.
//otherwise, it will lead crtc is disabled when current mode is 0
//when boot system sometimes.
drm_->UpdateDisplayRoute();
//Update LUT from baseparameter when Hot_plug devices conneted
hwc_SetGamma(drm_);
//rk: Avoid fb handle is null which lead HDMI display nothing with GLES.
usleep(HOTPLUG_MSLEEP*1000);
procs_->invalidate(procs_);
return;
}
//if extend is connected at boot time, to upload this hotplug event.
#ifdef USE_HWC2
if( extend != old_extend || (!g_hasHotplug && extend != NULL)){
#else
if( extend != old_extend){
#endif
hwc_drm_display_t *hd = &(*displays_)[extend->display()];
update_display_bestmode(hd, HWC_DISPLAY_EXTERNAL, extend);
DrmMode mode = extend->best_mode();
extend->set_current_mode(mode);
char framebuffer_size[PROPERTY_VALUE_MAX];
uint32_t width = 0, height = 0 , vrefresh = 0 ;
property_get("persist." PROPERTY_TYPE ".framebuffer.aux", framebuffer_size, "use_baseparameter");
/*
* if unset framebuffer_size, get it from baseparameter , by libin
*/
if(hwc_have_baseparameter() && !strcmp(framebuffer_size,"use_baseparameter")){
int res = 0;
res = hwc_get_baseparameter_config(framebuffer_size,HWC_DISPLAY_EXTERNAL,BP_FB_SIZE,0);
if(res)
ALOGW("BP: hwc get baseparameter config err ,res = %d",res);
}
sscanf(framebuffer_size, "%dx%d@%d", &width, &height, &vrefresh);
if (width && height) {
hd->framebuffer_width = width;
hd->framebuffer_height = height;
hd->vrefresh = vrefresh ? vrefresh : 60;
} else if (mode.h_display() && mode.v_display() && mode.v_refresh()) {
hd->framebuffer_width = mode.h_display();
hd->framebuffer_height = mode.v_display();
hd->vrefresh = mode.v_refresh();
/*
* Limit to 1080p if large than 2160p
*/
if (hd->framebuffer_height >= 2160 && hd->framebuffer_width >= hd->framebuffer_height) {
hd->framebuffer_width = hd->framebuffer_width * (1080.0 / hd->framebuffer_height);
hd->framebuffer_height = 1080;
}
} else {
hd->framebuffer_width = 1920;
hd->framebuffer_height = 1080;
hd->vrefresh = 60;
ALOGE("Failed to find available display mode for display %d\n", HWC_DISPLAY_EXTERNAL);
}
hd->rel_xres = mode.h_display();
hd->rel_yres = mode.v_display();
hd->v_total = mode.v_total();
hd->active = false;
g_bSkipExtern = true;
g_extern_gles_cnt = 0;
#ifdef USE_HWC2
g_waitHwcSetHotplug = false;
procs_->invalidate(procs_);
while(!g_waitHwcSetHotplug && g_hasHotplug){
usleep(2000);
}
#endif
procs_->hotplug(procs_, HWC_DISPLAY_EXTERNAL, 0);
usleep(64 * 1000);
hd->active = true;
procs_->hotplug(procs_, HWC_DISPLAY_EXTERNAL, 1);
}
/**********************long-running operations should move back of hotplug**************************/
/*
* If Connector changed ,update baseparameter , resolution , color.
*/
hwc_get_baseparameter_config(NULL,0,BP_UPDATE,0);
//1. When wake up from TV mode, it will bind crtc to TV connector.
//If we also plug in HDMI,and don't bind crtc to HDMI connector,
//the crtc of connected HDMI will be NULL. Which lead HDMI show nothing.
//Pg: Defect #149666
/**************************************************************************/
//2. We should get current mode before UpdateDisplayRoute.
//otherwise, it will lead crtc is disabled when current mode is 0
//when boot system sometimes.
drm_->UpdateDisplayRoute();
//Update LUT from baseparameter when Hot_plug devices conneted
hwc_SetGamma(drm_);
#ifdef USE_HWC2
if(!g_hasHotplug)
g_hasHotplug = true;
#endif
//rk: Avoid fb handle is null which lead HDMI display nothing with GLES.
usleep(HOTPLUG_MSLEEP*1000);
procs_->invalidate(procs_);
}
private:
DrmResources *drm_ = NULL;
const struct hwc_procs *procs_ = NULL;
DisplayMap* displays_ = NULL;
pthread_mutex_t lock_;
};
struct hwc_context_t {
// map of display:hwc_drm_display_t
typedef std::map<int, hwc_drm_display_t> DisplayMap;
~hwc_context_t() {
virtual_compositor_worker.Exit();
}
hwc_composer_device_1_t device;
hwc_procs_t const *procs = NULL;
DisplayMap displays;
DrmResources drm;
std::unique_ptr<Importer> importer;
const gralloc_module_t *gralloc;
DummySwSyncTimeline dummy_timeline;
VirtualCompositorWorker virtual_compositor_worker;
DrmHotplugHandler hotplug_handler;
VSyncWorker primary_vsync_worker;
VSyncWorker extend_vsync_worker;
int fb_fd;
int fb_blanked;
int hdmi_status_fd;
int dp_status_fd;
#if RK_CTS_WORKROUND
FILE* regFile;
#endif
bool isGLESComp;
#if RK_INVALID_REFRESH
bool mOneWinOpt;
threadPamaters mRefresh;
#endif
#if RK_STEREO
bool is_3d;
//int fd_3d;
//threadPamaters mControlStereo;
#endif
bool hdr_video_compose_by_gles = false;
std::vector<DrmCompositionDisplayPlane> comp_plane_group;
std::vector<DrmHwcDisplayContents> layer_contents;
};
static void *hotplug_event_thread(void *arg){
hwc_context_t* ctx = (hwc_context_t*)arg;
ctx->hotplug_handler.HandleEvent(0);
pthread_exit(NULL);
return NULL;
}
/**
* sys.3d_resolution.main 1920x1080p60-114693:148500
* width x height p|i refresh-flag:clock
*/
static int update_display_bestmode(hwc_drm_display_t *hd, int display, DrmConnector *c)
{
char resolution[PROPERTY_VALUE_MAX];
char resolution_3d[PROPERTY_VALUE_MAX];
uint32_t width, height, flags;
uint32_t hsync_start, hsync_end, htotal;
uint32_t vsync_start, vsync_end, vtotal;
uint32_t width_3d, height_3d, vrefresh_3d, flag_3d, clk_3d;
bool interlaced, interlaced_3d;
float vrefresh;
char val,val_3d;
int timeline;
static uint32_t last_mainType,last_auxType;
uint32_t MaxResolution = 0,temp;
timeline = property_get_int32( PROPERTY_TYPE ".display.timeline", -1);
/*
* force update propetry when timeline is zero or not exist.
*/
if (timeline && timeline == hd->display_timeline &&
hd->hotplug_timeline == hd->ctx->drm.timeline())
return 0;
hd->display_timeline = timeline;
hd->hotplug_timeline = hd->ctx->drm.timeline();
if (display == HWC_DISPLAY_PRIMARY)
{
if(hwc_have_baseparameter() && c->get_type() != last_mainType)
{
property_set("persist." PROPERTY_TYPE ".resolution.main","use_baseparameter");
ALOGD("BP:DisplayDevice change type[%d] => type[%d],to update main resolution",last_mainType,c->get_type());
last_mainType = c->get_type();
}
/* if baseparameter exist to use it, if none set to "Auto" */
if(hwc_have_baseparameter()){
property_get("persist." PROPERTY_TYPE ".resolution.main", resolution, "use_baseparameter");
property_get( PROPERTY_TYPE ".3d_resolution.main", resolution_3d, "0x0p0-0:0");
if(!(strcmp(resolution,"use_baseparameter"))){
int res = 0;
res = hwc_get_baseparameter_config(resolution,display,BP_RESOLUTION,c->get_type());
if(res){
ALOGE("BP:Get main BP_RESOLUTION fail, res = %d line =%d",res,__LINE__);
}
}
}else{
property_get("persist." PROPERTY_TYPE ".resolution.main", resolution, "Auto");
property_get( PROPERTY_TYPE ".3d_resolution.main", resolution_3d, "0x0p0-0:0");
}
}
else
{
if(hwc_have_baseparameter() && c->get_type() != last_auxType)
{
property_set("persist." PROPERTY_TYPE ".resolution.aux","use_baseparameter");
ALOGD("BP:DisplayDevice change type[%d] => type[%d],to update aux resolution",last_auxType,c->get_type());
last_auxType = c->get_type();
}
/* if baseparameter exist to use it, if none set to "Auto" */
if(hwc_have_baseparameter()){
property_get("persist." PROPERTY_TYPE ".resolution.aux", resolution, "use_baseparameter");
property_get( PROPERTY_TYPE ".3d_resolution.aux", resolution_3d, "0x0p0-0:0");
if(!(strcmp(resolution,"use_baseparameter"))){
int res = 0;
res = hwc_get_baseparameter_config(resolution,display,BP_RESOLUTION,c->get_type());
if(res){
ALOGE("BP:Get aux BP_RESOLUTION fail, res = %d line =%d",res,__LINE__);
}
}
}else{
property_get("persist." PROPERTY_TYPE ".resolution.aux", resolution, "Auto");
property_get( PROPERTY_TYPE ".3d_resolution.aux", resolution_3d, "0x0p0-0:0");
}
}
hwc_set_baseparameter_config(&hd->ctx->drm);
if(hd->is_3d && strcmp(resolution_3d,"0x0p0-0:0"))
{
ALOGD_IF(log_level(DBG_DEBUG), "Enter 3d resolution=%s",resolution_3d);
sscanf(resolution_3d, "%dx%d%c%d-%d:%d", &width_3d, &height_3d, &val_3d,
&vrefresh_3d, &flag_3d, &clk_3d);
if (val_3d == 'i')
interlaced_3d = true;
else
interlaced_3d = false;
if (width_3d != 0 && height_3d != 0) {
//use raw mode,otherwise it may filter by resolution_white.xml
for (const DrmMode &conn_mode : c->raw_modes()) {
if (conn_mode.equal(width_3d, height_3d, vrefresh_3d, flag_3d, clk_3d, interlaced_3d)) {
ALOGD_IF(log_level(DBG_DEBUG), "Match 3D parameters: w=%d,h=%d,val=%c,vrefresh_3d=%d,flag=%d,clk=%d",
width_3d,height_3d,val_3d,vrefresh_3d,flag_3d,clk_3d);
c->set_best_mode(conn_mode);
return 0;
}
}
}
}
else if (strcmp(resolution,"Auto") != 0)
{
int len = sscanf(resolution, "%dx%d@%f-%d-%d-%d-%d-%d-%d-%x",
&width, &height, &vrefresh, &hsync_start,
&hsync_end, &htotal, &vsync_start,&vsync_end,
&vtotal, &flags);
if (len == 10 && width != 0 && height != 0) {
for (const DrmMode &conn_mode : c->modes()) {
if (conn_mode.equal(width, height, vrefresh, hsync_start, hsync_end,
htotal, vsync_start, vsync_end, vtotal, flags)) {
c->set_best_mode(conn_mode);
return 0;
}
}
}
uint32_t ivrefresh;
len = sscanf(resolution, "%dx%d%c%d", &width, &height, &val, &ivrefresh);
if (val == 'i')
interlaced = true;
else
interlaced = false;
if (len == 4 && width != 0 && height != 0) {
for (const DrmMode &conn_mode : c->modes()) {
if (conn_mode.equal(width, height, ivrefresh, interlaced)) {
c->set_best_mode(conn_mode);
return 0;
}
}
}
}
for (const DrmMode &conn_mode : c->modes()) {
if (conn_mode.type() & DRM_MODE_TYPE_PREFERRED) {
c->set_best_mode(conn_mode);
return 0;
}
else {
temp = conn_mode.h_display()*conn_mode.v_display();
if(MaxResolution <= temp)
MaxResolution = temp;
}
}
for (const DrmMode &conn_mode : c->modes()) {
if(MaxResolution == conn_mode.h_display()*conn_mode.v_display()) {
c->set_best_mode(conn_mode);
return 0;
}
}
//use raw modes to get mode.
for (const DrmMode &conn_mode : c->raw_modes()) {
if (conn_mode.type() & DRM_MODE_TYPE_PREFERRED) {
c->set_best_mode(conn_mode);
return 0;
}
else {
temp = conn_mode.h_display()*conn_mode.v_display();
if(MaxResolution <= temp)
MaxResolution = temp;
}
}
for (const DrmMode &conn_mode : c->raw_modes()) {
if(MaxResolution == conn_mode.h_display()*conn_mode.v_display()) {
c->set_best_mode(conn_mode);
return 0;
}
}
ALOGE("Error: Should not get here display=%d %s %d\n", display, __FUNCTION__, __LINE__);
DrmMode mode;
c->set_best_mode(mode);
return -ENOENT;
}
static native_handle_t *dup_buffer_handle(buffer_handle_t handle) {
native_handle_t *new_handle =
native_handle_create(handle->numFds, handle->numInts);
if (new_handle == NULL)
return NULL;
const int *old_data = handle->data;
int *new_data = new_handle->data;
for (int i = 0; i < handle->numFds; i++) {
*new_data = dup(*old_data);
old_data++;
new_data++;
}
memcpy(new_data, old_data, sizeof(int) * handle->numInts);
return new_handle;
}
static void free_buffer_handle(native_handle_t *handle) {
int ret = native_handle_close(handle);
if (ret)
ALOGE("Failed to close native handle %d", ret);
ret = native_handle_delete(handle);
if (ret)
ALOGE("Failed to delete native handle %d", ret);
}
const hwc_drm_bo *DrmHwcBuffer::operator->() const {
if (importer_ == NULL) {
ALOGE("Access of non-existent BO");
exit(1);
return NULL;
}
return &bo_;
}
void DrmHwcBuffer::Clear() {
if (importer_ != NULL) {
importer_->ReleaseBuffer(&bo_);
importer_ = NULL;
}
}
int DrmHwcBuffer::ImportBuffer(buffer_handle_t handle, Importer *importer
#if RK_VIDEO_SKIP_LINE
, uint32_t SkipLine
#endif
) {
hwc_drm_bo tmp_bo;
int ret = importer->ImportBuffer(handle, &tmp_bo
#if RK_VIDEO_SKIP_LINE
, SkipLine
#endif
);
if (ret)
return ret;
if (importer_ != NULL) {
importer_->ReleaseBuffer(&bo_);
}
importer_ = importer;
bo_ = tmp_bo;
return 0;
}
int DrmHwcNativeHandle::CopyBufferHandle(buffer_handle_t handle,
const gralloc_module_t *gralloc) {
#if USE_GRALLOC_4
/* import 'handle' 得到对应的 新的 imported 的 buffer_handle_t 实例. */
buffer_handle_t handle_copy;
status_t ret = gralloc4::importBuffer(handle, &handle_copy);
if ( ret != NO_ERROR )
{
ALOGE("err. ret : %d", ret);
return ret;
}
#else // USE_GRALLOC_4
native_handle_t *handle_copy = dup_buffer_handle(handle);
if (handle_copy == NULL) {
ALOGE("Failed to duplicate handle");
return -ENOMEM;
}
int ret = gralloc->registerBuffer(gralloc, handle_copy);
if (ret) {
ALOGE("Failed to register buffer handle %d", ret);
free_buffer_handle(handle_copy);
return ret;
}
#endif // USE_GRALLOC_4
Clear();
gralloc_ = gralloc;
handle_ = const_cast<native_handle_t*>(handle_copy);
return 0;
}
DrmHwcNativeHandle::~DrmHwcNativeHandle() {
Clear();
pthread_mutex_destroy(&lock_);
}
void DrmHwcNativeHandle::Clear() {
AutoLock lock(&lock_, "DrmHwcNativeHandle::Clear");
int ret = lock.Lock();
if (ret)
return;
#if USE_GRALLOC_4
if ( handle_ != NULL )
{
gralloc4::freeBuffer(handle_);
gralloc_ = NULL;
handle_ = NULL;
}
#else // USE_GRALLOC_4
if (gralloc_ != NULL && handle_ != NULL) {
gralloc_->unregisterBuffer(gralloc_, handle_);
free_buffer_handle(handle_);
gralloc_ = NULL;
handle_ = NULL;
}
#endif // USE_GRALLOC_4
}
static const char *DrmFormatToString(uint32_t drm_format) {
switch (drm_format) {
case DRM_FORMAT_BGR888:
return "DRM_FORMAT_BGR888";
case DRM_FORMAT_ARGB8888:
return "DRM_FORMAT_ARGB8888";
case DRM_FORMAT_XBGR8888:
return "DRM_FORMAT_XBGR8888";
case DRM_FORMAT_ABGR8888:
return "DRM_FORMAT_ABGR8888";
case DRM_FORMAT_BGR565:
return "DRM_FORMAT_BGR565";
case DRM_FORMAT_YVU420:
return "DRM_FORMAT_YVU420";
case DRM_FORMAT_NV12:
return "DRM_FORMAT_NV12";
default:
return "<invalid>";
}
}
static void DumpBuffer(const DrmHwcBuffer &buffer, std::ostringstream *out) {
if (!buffer) {
*out << "buffer=<invalid>";
return;
}
*out << "buffer[w/h/format]=";
*out << buffer->width << "/" << buffer->height << "/" << DrmFormatToString(buffer->format);
}
static const char *TransformToString(uint32_t transform) {
switch (transform) {
case DrmHwcTransform::kIdentity:
return "IDENTITY";
case DrmHwcTransform::kFlipH:
return "FLIPH";
case DrmHwcTransform::kFlipV:
return "FLIPV";
case DrmHwcTransform::kRotate90:
return "ROTATE90";
case DrmHwcTransform::kRotate180:
return "ROTATE180";
case DrmHwcTransform::kRotate270:
return "ROTATE270";
default:
return "<invalid>";
}
}
const char *BlendingToString(DrmHwcBlending blending) {
switch (blending) {
case DrmHwcBlending::kNone:
return "NONE";
case DrmHwcBlending::kPreMult:
return "PREMULT";
case DrmHwcBlending::kCoverage:
return "COVERAGE";
default:
return "<invalid>";
}
}
void DrmHwcLayer::dump_drm_layer(int index, std::ostringstream *out) const {
*out << "DrmHwcLayer[" << index << "] ";
DumpBuffer(buffer,out);
*out << " transform=" << TransformToString(transform)
<< " blending[a=" << (int)alpha
<< "]=" << BlendingToString(blending) << " source_crop";
source_crop.Dump(out);
*out << " handle parameter";
*out << "[w/h/s]=" << width << "/" << height << "/" << stride;
*out << " display_frame";
display_frame.Dump(out);
*out << "\n";
}
int DrmHwcLayer::InitFromHwcLayer(struct hwc_context_t *ctx, int display, hwc_layer_1_t *sf_layer, Importer *importer,
const gralloc_module_t *gralloc, bool bClone) {
DrmConnector *c;
DrmMode mode;
unsigned int size;
int ret = 0;
int src_w, src_h, dst_w, dst_h;
hwc_region_t * visible_region = &sf_layer->visibleRegionScreen;
hwc_rect_t const * visible_rects = visible_region->rects;
int left_min = 0, top_min = 0, right_max = 0, bottom_max=0;
UN_USED(importer);
bClone_ = bClone;
#if RK_3D_VIDEO
int32_t alreadyStereo = 0;
#ifdef USE_HWC2
if(sf_layer->handle)
{
alreadyStereo = hwc_get_handle_alreadyStereo(ctx->gralloc, sf_layer->handle);
if(alreadyStereo < 0)
{
ALOGE("hwc_get_handle_alreadyStereo fail");
alreadyStereo = 0;
}
}
#else
alreadyStereo = sf_layer->alreadyStereo;
#endif
stereo = alreadyStereo;
#endif
if(sf_layer->compositionType == HWC_FRAMEBUFFER_TARGET)
bFbTarget_ = true;
else
bFbTarget_ = false;
if(sf_layer->flags & HWC_SKIP_LAYER)
bSkipLayer = true;
else
bSkipLayer = false;
#if RK_VIDEO_SKIP_LINE
SkipLine = 0;
#endif
bUse = true;
sf_handle = sf_layer->handle;
raw_sf_layer = sf_layer;
mlayer = sf_layer;
alpha = sf_layer->planeAlpha;
frame_no = get_frame();
DrmConnector *conn = ctx->drm.GetConnectorFromType(display);
if (!conn) {
ALOGE("%s:Failed to get connector for display %d line=%d", __FUNCTION__,display,__LINE__);
return -ENODEV;
}
hwc_drm_display_t *hd = &ctx->displays[conn->display()];
#if DUAL_VIEW_MODE
int dualModeEnable = 0,dualModeTB = 0,dualModeRatioPri = 0,dualModeRatioAux = 0;
char value[PROPERTY_VALUE_MAX];
property_get("persist." PROPERTY_TYPE ".dualModeEnable", value, "0");
dualModeEnable = atoi(value);
property_get("persist." PROPERTY_TYPE ".dualModeTB", value, "0");
dualModeTB = atoi(value);
property_get("persist." PROPERTY_TYPE ".dualModeRatioPri", value, "0");
dualModeRatioPri = atoi(value);
property_get("persist." PROPERTY_TYPE ".dualModeRatioAux", value, "0");
dualModeRatioAux = atoi(value);
//DUAL_VIEW_MODE only support 2 or 3 Ratio
if(dualModeRatioPri == 0 || dualModeRatioAux == 0){
ALOGE_IF(log_level(DBG_ERROR),"DUAL:Not support 0 Ration (%d:%d) , disable DUAL_VIEW_MODE",dualModeRatioPri,dualModeRatioAux);
dualModeEnable = 0;
}
//DUAL_VIEW_MODE Primary framebuffer must equal to Extend
char framebuffer_size_pri[PROPERTY_VALUE_MAX] = {0};
char framebuffer_size_aux[PROPERTY_VALUE_MAX] = {0};
property_get("persist." PROPERTY_TYPE ".framebuffer.main", framebuffer_size_pri, "main");
property_get("persist." PROPERTY_TYPE ".framebuffer.aux", framebuffer_size_aux, "aux");
if(strcmp(framebuffer_size_pri,framebuffer_size_aux)){
ALOGE_IF(log_level(DBG_ERROR),"DUAL:Primary framebuffer is not equal to Extend, disable DUAL_VIEW_MODE");
dualModeEnable = 0;
}
if(dualModeEnable == 1){
hd->bDualViewMode = true;
property_set( PROPERTY_TYPE ".hwc.compose_policy","0");
if(display == 0){
if(dualModeTB == 1)
source_crop = DrmHwcRect<float>(
sf_layer->sourceCropf.left, sf_layer->sourceCropf.top,
sf_layer->sourceCropf.right, sf_layer->sourceCropf.bottom / (dualModeRatioPri + dualModeRatioAux) * dualModeRatioPri);
else
source_crop = DrmHwcRect<float>(
sf_layer->sourceCropf.left, sf_layer->sourceCropf.top,
sf_layer->sourceCropf.right / (dualModeRatioPri + dualModeRatioAux) * dualModeRatioPri , sf_layer->sourceCropf.bottom);
}else if(display == 1){
if(dualModeTB == 1)
source_crop = DrmHwcRect<float>(
sf_layer->sourceCropf.left, sf_layer->sourceCropf.top + sf_layer->sourceCropf.bottom / (dualModeRatioPri + dualModeRatioAux) * dualModeRatioPri,
sf_layer->sourceCropf.right, sf_layer->sourceCropf.bottom);
else
source_crop = DrmHwcRect<float>(
sf_layer->sourceCropf.left + sf_layer->sourceCropf.right / (dualModeRatioPri + dualModeRatioAux) * dualModeRatioPri , sf_layer->sourceCropf.top,
sf_layer->sourceCropf.right, sf_layer->sourceCropf.bottom);
}
}else
#endif
{
source_crop = DrmHwcRect<float>(
sf_layer->sourceCropf.left, sf_layer->sourceCropf.top,
sf_layer->sourceCropf.right, sf_layer->sourceCropf.bottom);
}
if(bClone)
{
//int panle_height = hd->rel_yres + hd->v_total;
//int y_offset = (panle_height - panle_height * 3 / 147) / 2 + panle_height * 3 / 147;
int y_offset = hd->v_total;
display_frame = DrmHwcRect<int>(
hd->w_scale * sf_layer->displayFrame.left, hd->h_scale * sf_layer->displayFrame.top + y_offset,
hd->w_scale * sf_layer->displayFrame.right, hd->h_scale * sf_layer->displayFrame.bottom + y_offset);
}
else
{
if(stereo == FPS_3D)
{
int y_offset = hd->v_total;
display_frame = DrmHwcRect<int>(
hd->w_scale * sf_layer->displayFrame.left, hd->h_scale * sf_layer->displayFrame.top,
hd->w_scale * sf_layer->displayFrame.right, hd->h_scale * sf_layer->displayFrame.bottom + y_offset);
}
else
{
display_frame = DrmHwcRect<int>(
hd->w_scale * sf_layer->displayFrame.left, hd->h_scale * sf_layer->displayFrame.top,
hd->w_scale * sf_layer->displayFrame.right, hd->h_scale * sf_layer->displayFrame.bottom);
}
}
src_w = (int)(source_crop.right - source_crop.left);
src_h = (int)(source_crop.bottom - source_crop.top);
dst_w = (int)(display_frame.right - display_frame.left);
dst_h = (int)(display_frame.bottom - display_frame.top);
if(hd->is_interlaced)
{
//use vop plane scale instead of vop post scale.
char overscan[PROPERTY_VALUE_MAX];
int left_margin, right_margin, top_margin, bottom_margin;
float left_margin_f, right_margin_f, top_margin_f, bottom_margin_f;
float lscale = 0, tscale = 0, rscale = 0, bscale = 0;
int disp_old_l,disp_old_t,disp_old_r,disp_old_b;
if(hd->stereo_mode != NON_3D)
{
left_margin = 100;
top_margin = 100;
right_margin = 100;
bottom_margin = 100;
}
else
{
if (display == HWC_DISPLAY_PRIMARY){
if(hwc_have_baseparameter()){
property_get("persist." PROPERTY_TYPE ".overscan.main", overscan, "use_baseparameter");
if(!strcmp(overscan,"use_baseparameter"))
hwc_get_baseparameter_config(overscan,display,BP_OVERSCAN,0);
}else{
property_get("persist." PROPERTY_TYPE ".overscan.main", overscan, "overscan 100,100,100,100");
}
sscanf(overscan, "overscan %d,%d,%d,%d", &left_margin, &top_margin,
&right_margin, &bottom_margin);
}else{
if(hwc_have_baseparameter()){
property_get("persist." PROPERTY_TYPE ".overscan.aux", overscan, "use_baseparameter");
if(!strcmp(overscan,"use_baseparameter"))
hwc_get_baseparameter_config(overscan,display,BP_OVERSCAN,0);
}else{
property_get("persist." PROPERTY_TYPE ".overscan.aux", overscan, "overscan 100,100,100,100");
}
sscanf(overscan, "overscan %d,%d,%d,%d", &left_margin, &top_margin,
&right_margin, &bottom_margin);
}
}
//limit overscan to (OVERSCAN_MIN_VALUE,OVERSCAN_MAX_VALUE)
if (left_margin < OVERSCAN_MIN_VALUE) left_margin = OVERSCAN_MIN_VALUE;
if (top_margin < OVERSCAN_MIN_VALUE) top_margin = OVERSCAN_MIN_VALUE;
if (right_margin < OVERSCAN_MIN_VALUE) right_margin = OVERSCAN_MIN_VALUE;
if (bottom_margin < OVERSCAN_MIN_VALUE) bottom_margin = OVERSCAN_MIN_VALUE;
if (left_margin > OVERSCAN_MAX_VALUE) left_margin = OVERSCAN_MAX_VALUE;
if (top_margin > OVERSCAN_MAX_VALUE) top_margin = OVERSCAN_MAX_VALUE;
if (right_margin > OVERSCAN_MAX_VALUE) right_margin = OVERSCAN_MAX_VALUE;
if (bottom_margin > OVERSCAN_MAX_VALUE) bottom_margin = OVERSCAN_MAX_VALUE;
left_margin_f = (float)(100 - left_margin ) / 2;
top_margin_f = (float)(100 - top_margin ) / 2;
right_margin_f = (float)(100 - right_margin ) / 2;
bottom_margin_f = (float)(100 - bottom_margin) / 2;
lscale = ((float)left_margin_f / 100);
tscale = ((float)top_margin_f / 100);
rscale = ((float)right_margin_f / 100);
bscale = ((float)bottom_margin_f / 100);
disp_old_l = display_frame.left;
disp_old_t = display_frame.top;
disp_old_r = display_frame.right;
disp_old_b = display_frame.bottom;
display_frame.left = ((int)(display_frame.left * (1.0 - lscale - rscale)) + (int)(hd->rel_xres * lscale));
display_frame.top = ((int)(display_frame.top * (1.0 - tscale - bscale)) + (int)(hd->rel_yres * tscale));
dst_w -= ((int)(dst_w * lscale) + (int)(dst_w * rscale));
dst_h -= ((int)(dst_h * tscale) + (int)(dst_h * bscale));
display_frame.right = display_frame.left + dst_w;
display_frame.bottom = display_frame.top + dst_h;
ALOGD_IF(log_level(DBG_VERBOSE),"vop plane scale overscan, display margin(%f,%f,%f,%f) scale_factor(%f,%f,%f,%f) disp_area(%d,%d,%d,%d) ==> (%d,%d,%d,%d)",
left_margin_f,top_margin_f,right_margin_f,bottom_margin_f,
lscale,tscale,rscale,bscale,
disp_old_l,disp_old_t,disp_old_r,disp_old_b,
display_frame.left,display_frame.top,display_frame.right,display_frame.bottom);
}
c = ctx->drm.GetConnectorFromType(HWC_DISPLAY_PRIMARY);
if (!c) {
ALOGE("Failed to get DrmConnector for display %d", 0);
return -ENODEV;
}
mode = c->active_mode();
if(sf_handle)
{
#if (!RK_PER_MODE && RK_DRM_GRALLOC)
width = hwc_get_handle_attibute(gralloc,sf_layer->handle,ATT_WIDTH);
height = hwc_get_handle_attibute(gralloc,sf_layer->handle,ATT_HEIGHT);
stride = hwc_get_handle_attibute(gralloc,sf_layer->handle,ATT_STRIDE);
format = hwc_get_handle_attibute(gralloc,sf_layer->handle,ATT_FORMAT);
#else
width = hwc_get_handle_width(gralloc,sf_layer->handle);
height = hwc_get_handle_height(gralloc,sf_layer->handle);
stride = hwc_get_handle_stride(gralloc,sf_layer->handle);
format = hwc_get_handle_format(gralloc,sf_layer->handle);
#endif
}
else
{
format = HAL_PIXEL_FORMAT_RGBA_8888;
}
if(format == HAL_PIXEL_FORMAT_YCrCb_NV12 || format == HAL_PIXEL_FORMAT_YCrCb_NV12_10)
is_yuv = true;
else
is_yuv = false;
rect_merge.left = display_frame.left;
rect_merge.top = display_frame.top;
rect_merge.right = display_frame.right;
rect_merge.bottom = display_frame.bottom;
if(visible_rects && format != HAL_PIXEL_FORMAT_YCrCb_NV12_VIDEO
&& format != HAL_PIXEL_FORMAT_YCrCb_NV12){
left_min = visible_rects[0].left;
top_min = visible_rects[0].top;
right_max = visible_rects[0].right;
bottom_max = visible_rects[0].bottom;
for (int r = 0; r < (int) visible_region->numRects; r++) {
int r_left;
int r_top;
int r_right;
int r_bottom;
r_left = hwcMAX(display_frame.left, visible_rects[r].left);
left_min = hwcMIN(r_left, left_min);
r_top = hwcMAX(display_frame.top, visible_rects[r].top);
top_min = hwcMIN(r_top, top_min);
r_right = hwcMIN(display_frame.right, visible_rects[r].right);
right_max = hwcMAX(r_right, right_max);
r_bottom = hwcMIN(display_frame.bottom, visible_rects[r].bottom);
bottom_max = hwcMAX(r_bottom, bottom_max);
}
rect_merge.left = hwcMAX(display_frame.left, left_min);
rect_merge.top = hwcMAX(display_frame.top, top_min);
rect_merge.right = hwcMIN(display_frame.right, right_max);
rect_merge.bottom = hwcMIN(display_frame.bottom, bottom_max);
}
if(hd->hasEotfPlane)
{
if(is_yuv)
{
uint32_t android_colorspace = hwc_get_layer_colorspace(sf_layer);
colorspace = colorspace_convert_to_linux(android_colorspace);
if(colorspace == 0)
{
colorspace = V4L2_COLORSPACE_DEFAULT;
}
if((android_colorspace & HAL_DATASPACE_TRANSFER_MASK) == HAL_DATASPACE_TRANSFER_ST2084)
{
ALOGD_IF(log_level(DBG_VERBOSE),"%s:line=%d has st2084",__FUNCTION__,__LINE__);
eotf = SMPTE_ST2084;
}
else
{
//ALOGE("Unknow etof %d",eotf);
eotf = TRADITIONAL_GAMMA_SDR;
}
}
else
{
//If enter GLES in HDR video,fake the fb target layer to HDR.
if(hd->isHdr && bFbTarget_)
{
colorspace = V4L2_COLORSPACE_BT2020;
eotf = SMPTE_ST2084;
}
else
{
colorspace = V4L2_COLORSPACE_DEFAULT;
eotf = TRADITIONAL_GAMMA_SDR;
}
}
}
else
{
if(is_yuv)
{
uint32_t android_colorspace = hwc_get_layer_colorspace(sf_layer);
colorspace = colorspace_convert_to_linux(android_colorspace);
if(colorspace == 0)
{
colorspace = V4L2_COLORSPACE_DEFAULT;
}
eotf = TRADITIONAL_GAMMA_SDR;
}else{
colorspace = V4L2_COLORSPACE_DEFAULT;
eotf = TRADITIONAL_GAMMA_SDR;
}
}
#if RK_BOX
if(is_yuv){
char value_yuv[PROPERTY_VALUE_MAX];
int scaleMode = 0;
property_get("persist." PROPERTY_TYPE ".video.cvrs",value_yuv, "0");
scaleMode = atoi(value_yuv);
if(scaleMode > 0){
ret = hwc_video_to_area(source_crop,display_frame,scaleMode);
if(ret == false)
ALOGE("hwc video to area fail !! reset to full screen");
}
}
#endif
if((sf_layer->transform == HWC_TRANSFORM_ROT_90)
||(sf_layer->transform == HWC_TRANSFORM_ROT_270)){
if(format == HAL_PIXEL_FORMAT_YCrCb_NV12 || format == HAL_PIXEL_FORMAT_YCrCb_NV12_10)
{
//rga need this alignment.
src_h = ALIGN_DOWN(src_h, 8);
src_w = ALIGN_DOWN(src_w, 2);
}
h_scale_mul = (float) (src_h)/(dst_w);
v_scale_mul = (float) (src_w)/(dst_h);
} else {
h_scale_mul = (float) (src_w)/(dst_w);
v_scale_mul = (float) (src_h)/(dst_h);
}
#if RK_VIDEO_SKIP_LINE
if(format == HAL_PIXEL_FORMAT_YCrCb_NV12 || format == HAL_PIXEL_FORMAT_YCrCb_NV12_10){
if(width >= 3840){
if(h_scale_mul > 1.0 || v_scale_mul > 1.0){
SkipLine = 2;
}
if(format == HAL_PIXEL_FORMAT_YCrCb_NV12_10 && h_scale_mul >= (3840 / 1600)){
SkipLine = 3;
}
}
int video_skipline = property_get_int32("vendor.video.skipline", 0);
if (video_skipline == 2){
SkipLine = 2;
}else if(video_skipline == 3){
SkipLine = 3;
}
}
#endif
is_scale = (h_scale_mul != 1.0) || (v_scale_mul != 1.0);
is_match = false;
is_take = false;
#if USE_AFBC_LAYER
is_afbc = false;
#endif
#if (RK_RGA_COMPSITE_SYNC | RK_RGA_PREPARE_ASYNC)
is_rotate_by_rga = false;
#endif
bMix = false;
bpp = android::bytesPerPixel(format);
size = (source_crop.right - source_crop.left) * (source_crop.bottom - source_crop.top) * bpp;
is_large = (mode.h_display()*mode.v_display()*4*3/4 > size)? true:false;
#if RK_PRINT_LAYER_NAME
char layername[100];
#ifdef USE_HWC2
if(sf_handle)
{
HWC_GET_HANDLE_LAYERNAME(gralloc,sf_layer,sf_handle, layername, 100);
}
#else
strcpy(layername, sf_layer->LayerName);
#endif
name = layername;
#endif
ALOGV("\t sourceCropf(%f,%f,%f,%f)",source_crop.left,source_crop.top,source_crop.right,source_crop.bottom);
ALOGV("h_scale_mul=%f,v_scale_mul=%f,is_scale=%d,is_large=%d",h_scale_mul,v_scale_mul,is_scale,is_large);
transform = 0;
// 270* and 180* cannot be combined with flips. More specifically, they
// already contain both horizontal and vertical flips, so those fields are
// redundant in this case. 90* rotation can be combined with either horizontal
// flip or vertical flip, so treat it differently
if (sf_layer->transform == HWC_TRANSFORM_ROT_270) {
transform = DrmHwcTransform::kRotate270;
} else if (sf_layer->transform == HWC_TRANSFORM_ROT_180) {
transform = DrmHwcTransform::kRotate180;
} else {
if (sf_layer->transform & HWC_TRANSFORM_FLIP_H)
transform |= DrmHwcTransform::kFlipH;
if (sf_layer->transform & HWC_TRANSFORM_FLIP_V)
transform |= DrmHwcTransform::kFlipV;
if (sf_layer->transform & HWC_TRANSFORM_ROT_90)
transform |= DrmHwcTransform::kRotate90;
if(!sf_layer->transform)
transform |= DrmHwcTransform::kRotate0;
}
#if RK_PRINT_LAYER_NAME
#if RK_RGA_TEST
if((format==HAL_PIXEL_FORMAT_RGB_565) && strstr(sf_layer->LayerName,"SurfaceView"))
transform |= DrmHwcTransform::kRotate90;
#endif
#endif
switch (sf_layer->blending) {
case HWC_BLENDING_NONE:
blending = DrmHwcBlending::kNone;
break;
case HWC_BLENDING_PREMULT:
blending = DrmHwcBlending::kPreMult;
break;
case HWC_BLENDING_COVERAGE:
blending = DrmHwcBlending::kCoverage;
break;
default:
ALOGE("Invalid blending in hwc_layer_1_t %d", sf_layer->blending);
return -EINVAL;
}
#if 0
ret = buffer.ImportBuffer(sf_layer->handle, importer
#if RK_VIDEO_SKIP_LINE
, SkipLine
#endif
);
if (ret)
return ret;
#endif
#if USE_AFBC_LAYER
// if(sf_handle)
if ( sf_handle && bFbTarget_ )
{
ALOGD_IF(log_level(DBG_VERBOSE),"we got buffer handle for fb_target_layer, to get internal_format.");
#if USE_GRALLOC_4
internal_format = gralloc4::get_internal_format(sf_handle);
#else // #if USE_GRALLOC_4
#if RK_PER_MODE
struct gralloc_drm_handle_t* drm_hnd = (struct gralloc_drm_handle_t *)sf_handle;
internal_format = drm_hnd->internal_format;
#else
ret = gralloc->perform(gralloc, GRALLOC_MODULE_PERFORM_GET_INTERNAL_FORMAT,
sf_handle, &internal_format);
if (ret) {
ALOGE("Failed to get internal_format for buffer %p (%d)", sf_handle, ret);
return ret;
}
#endif
#endif // #if USE_GRALLOC_4
#if USE_GRALLOC_4
if ( gralloc4::does_use_afbc_format(sf_handle) )
#else
if(isAfbcInternalFormat(internal_format))
#endif
{
ALOGD_IF(log_level(DBG_VERBOSE),"to set 'is_afbc'.");
is_afbc = true;
}
else
{
ALOGD_IF(log_level(DBG_VERBOSE),"not a afbc_buffer.");
}
}
if(bFbTarget_ && !sf_handle)
{
ALOGD_IF(log_level(DBG_VERBOSE),"we could not got buffer handle, and current buffer is for fb_target_layer, to check AFBC in a trick way.");
static int iFbdcSupport = -1;
ALOGD_IF(log_level(DBG_VERBOSE),"iFbdcSupport = %d",iFbdcSupport);
// if(iFbdcSupport == -1)
if(iFbdcSupport <= 0)
{
char fbdc_value[PROPERTY_VALUE_MAX];
int ret = property_get( PROPERTY_TYPE ".gmali.fbdc_target", fbdc_value, "0");
ALOGV("ret = %d",ret);
iFbdcSupport = atoi(fbdc_value);
if(iFbdcSupport > 0 && display == 0)
{
ALOGD_IF(log_level(DBG_VERBOSE),"to set 'is_afbc'.");
is_afbc = true;
}
}
else if(iFbdcSupport > 0 && display == 0)
{
ALOGD_IF(log_level(DBG_VERBOSE),"to set 'is_afbc'.");
is_afbc = true;
}
}
#endif
return 0;
}
int DrmHwcLayer::ImportBuffer(struct hwc_context_t *ctx, hwc_layer_1_t *sf_layer, Importer *importer)
{
#if TARGET_BOARD_PLATFORM_RK3326
/*
* RK3326 VOP not support alpha scale, need to convert layer format
* DRM_FORMAT_ARGB8888 -> DRM_FORMAT_XRGB8888
* DRM_FORMAT_ABGR8888 -> DRM_FORMAT_XBGR8888
*/
if(is_scale)
importer->SetFlag(DrmGenericImporterFlag::VOP_NOT_SUPPORT_ALPHA_SCALE);
else
importer->SetFlag(DrmGenericImporterFlag::NO_FLAG);
#endif
int ret = buffer.ImportBuffer(sf_layer->handle, importer
#if RK_VIDEO_SKIP_LINE
, SkipLine
#endif
);
ret = handle.CopyBufferHandle(sf_layer->handle, ctx->gralloc);
if (ret)
return ret;
gralloc_buffer_usage = hwc_get_handle_usage(ctx->gralloc,sf_layer->handle);
return ret;
}
static void hwc_dump(struct hwc_composer_device_1 *dev, char *buff,
int buff_len) {
struct hwc_context_t *ctx = (struct hwc_context_t *)&dev->common;
std::ostringstream out;
ctx->drm.compositor()->Dump(&out);
std::string out_str = out.str();
strncpy(buff, out_str.c_str(),
std::min((size_t)buff_len, out_str.length() + 1));
buff[buff_len - 1] = '\0';
}
static bool hwc_skip_layer(const std::pair<int, int> &indices, int i) {
return indices.first >= 0 && i >= indices.first && i <= indices.second;
}
static bool is_use_gles_comp(struct hwc_context_t *ctx, DrmConnector *connector, hwc_display_contents_1_t *display_content, int display_id)
{
int num_layers = display_content->numHwLayers;
hwc_drm_display_t *hd = &ctx->displays[display_id];
DrmCrtc *crtc = NULL;
if (!connector) {
ALOGE("%s: Failed to get connector for display %d line=%d", __FUNCTION__,display_id, __LINE__);
}
else
{
crtc = ctx->drm.GetCrtcFromConnector(connector);
if (connector->state() != DRM_MODE_CONNECTED || !crtc) {
ALOGE("Failed to get crtc for display %d line=%d", display_id, __LINE__);
}
}
//force go into GPU
/*
<=0: DISPLAY_PRIMARY & DISPLAY_EXTERNAL both go into GPU.
=1: DISPLAY_PRIMARY go into overlay,DISPLAY_EXTERNAL go into GPU.
=2: DISPLAY_EXTERNAL go into overlay,DISPLAY_PRIMARY go into GPU.
others: DISPLAY_PRIMARY & DISPLAY_EXTERNAL both go into overlay.
*/
int iMode = hwc_get_int_property( PROPERTY_TYPE ".hwc.compose_policy","0");
if( iMode <= 0 || (iMode == 1 && display_id == 2) || (iMode == 2 && display_id == 1) )
{
ALOGD_IF(log_level(DBG_DEBUG), PROPERTY_TYPE ".hwc.compose_policy=%d,go to GPU GLES at line=%d", iMode, __LINE__);
return true;
}
iMode = hwc_get_int_property( PROPERTY_TYPE ".hwc","1");
if( iMode <= 0 )
{
ALOGD_IF(log_level(DBG_DEBUG), PROPERTY_TYPE ".hwc=%d,go to GPU GLES at line=%d", iMode, __LINE__);
return true;
}
#if RK_CTS_WORKROUND
int is_auto_fill = 0;
bool isFind = FindAppHintInFile(ctx->regFile, AUTO_FILL_PROG_NAME, IS_AUTO_FILL, &is_auto_fill, IMG_INT_TYPE);
if(is_auto_fill)
{
if(!hd->bPerfMode)
{
ALOGD_IF(log_level(DBG_DEBUG),"enter perf mode");
ctl_gpu_performance(1);
ctl_cpu_performance(1, 0);
hd->bPerfMode = true;
}
ALOGD_IF(log_level(DBG_DEBUG),"is auto fill program,go to GPU GLES at line=%d", __LINE__);
return true;
}
else
{
if(hd->bPerfMode)
{
ALOGD_IF(log_level(DBG_DEBUG),"exit perf mode");
ctl_gpu_performance(0);
ctl_cpu_performance(0, 0);
hd->bPerfMode = false;
}
}
#endif
if(num_layers == 1)
{
ALOGD_IF(log_level(DBG_DEBUG),"No layer,go to GPU GLES at line=%d", __LINE__);
return true;
}
if(g_boot_gles_cnt < BOOT_GLES_COUNT)
{
ALOGD_IF(log_level(DBG_DEBUG),"g_boot_gles_cnt=%d,go to GPU GLES at line=%d", g_boot_gles_cnt, __LINE__);
g_boot_gles_cnt++;
return true;
}
if(g_bSkipExtern && (g_extern_gles_cnt < BOOT_GLES_COUNT))
{
ALOGD_IF(log_level(DBG_DEBUG),"g_extern_gles_cnt=%d,go to GPU GLES at line=%d", g_extern_gles_cnt, __LINE__);
g_extern_gles_cnt++;
return true;
}
#if RK_INVALID_REFRESH
if(ctx->mOneWinOpt)
{
ALOGD_IF(log_level(DBG_DEBUG),"Enter static screen opt,go to GPU GLES at line=%d", __LINE__);
return true;
}
#endif
#if RK_STEREO
if(ctx->is_3d)
{
ALOGD_IF(log_level(DBG_DEBUG),"Is 3d mode,go to GPU GLES at line=%d", __LINE__);
return true;
}
#endif
//If the transform nv12 layers is bigger than one,then go into GPU GLES.
//If the transform normal layers is bigger than zero,then go into GPU GLES.
hd->transform_nv12 = 0;
hd->transform_normal = 0;
int ret = 0;
int format = 0;
#if USE_AFBC_LAYER
uint64_t internal_format = 0;
int iFbdcCnt = 0;
#endif
int video_4k_cnt = 0;
int large_UI_cnt = 0;
for (int j = 0; j < num_layers-1; j++) {
hwc_layer_1_t *layer = &display_content->hwLayers[j];
if(layer->handle)
{
#if (!RK_PER_MODE && RK_DRM_GRALLOC)
format = hwc_get_handle_attibute(ctx->gralloc,layer->handle,ATT_FORMAT);
#else
format = hwc_get_handle_format(ctx->gralloc,layer->handle);
#endif
}
int src_l=0,src_t=0,src_r=0,src_b=0,src_w=0,src_h=0;
int dst_l=0,dst_t=0,dst_r=0,dst_b=0,dst_w=0,dst_h=0;
hwc_rect_t rect_merge;
int left_min = 0, top_min = 0, right_max = 0, bottom_max=0;
float rga_h_scale=1.0, rga_v_scale=1.0;
src_l = (int)layer->sourceCropf.left;
src_t = (int)layer->sourceCropf.top;
src_r = (int)layer->sourceCropf.right;
src_b = (int)layer->sourceCropf.bottom;
src_w = (int)(layer->sourceCropf.right - layer->sourceCropf.left);
src_h = (int)(layer->sourceCropf.bottom - layer->sourceCropf.top);
dst_w = (int)(layer->displayFrame.right - layer->displayFrame.left);
dst_h = (int)(layer->displayFrame.bottom - layer->displayFrame.top);
src_l = ALIGN_DOWN(src_l, 2);
dst_l = 0;
dst_t = 0;
if(format == HAL_PIXEL_FORMAT_YCrCb_NV12 || format == HAL_PIXEL_FORMAT_YCrCb_NV12_10){
if(src_w >= 3840 && src_h >= 2160 && (src_w != dst_w ||src_h != dst_h))
video_4k_cnt++;
}else if(src_w * src_h >= 1920 * 1080){
large_UI_cnt++;
}
if(hd->isVideo && (layer->transform != 0))
{
#if !RK_RGA_SCALE_AND_ROTATE
if((layer->transform == HWC_TRANSFORM_ROT_90) || (layer->transform == HWC_TRANSFORM_ROT_270))
{
dst_r = (int)(src_b - src_t);
dst_b = (int)(src_r - src_l);
src_h = ALIGN_DOWN(src_h, 8);
src_w = ALIGN_DOWN(src_w, 2);
}
else
{
dst_r = (int)(src_r - src_l);
dst_b = (int)(src_b - src_t);
src_w = ALIGN_DOWN(src_w, 8);
src_h = ALIGN_DOWN(src_h, 2);
}
dst_w = dst_r - dst_l;
dst_h = dst_b - dst_t;
int dst_raw_w = dst_w;
int dst_raw_h = dst_h;
dst_w = ALIGN_DOWN(dst_w, 8);
dst_h = ALIGN_DOWN(dst_h, 2);
#else
UN_USED(dst_r);
UN_USED(dst_b);
rect_merge.left = layer->displayFrame.left;
rect_merge.top = layer->displayFrame.top;
rect_merge.right = layer->displayFrame.right;
rect_merge.bottom = layer->displayFrame.bottom;
#if 0
int left_min = 0, top_min = 0, right_max = 0, bottom_max=0;
hwc_region_t * visible_region = &layer->visibleRegionScreen;
hwc_rect_t const * visible_rects = visible_region->rects;
if(visible_rects){
left_min = visible_rects[0].left;
top_min = visible_rects[0].top;
right_max = visible_rects[0].right;
bottom_max = visible_rects[0].bottom;
for (int r = 0; r < (int) visible_region->numRects; r++) {
int r_left;
int r_top;
int r_right;
int r_bottom;
r_left = hwcMAX(layer->displayFrame.left, visible_rects[r].left);
left_min = hwcMIN(r_left, left_min);
r_top = hwcMAX(layer->displayFrame.top, visible_rects[r].top);
top_min = hwcMIN(r_top, top_min);
r_right = hwcMIN(layer->displayFrame.right, visible_rects[r].right);
right_max = hwcMAX(r_right, right_max);
r_bottom = hwcMIN(layer->displayFrame.bottom, visible_rects[r].bottom);
bottom_max = hwcMAX(r_bottom, bottom_max);
}
if(format == HAL_PIXEL_FORMAT_YCrCb_NV12_VIDEO
|| format == HAL_PIXEL_FORMAT_YCrCb_NV12){
rect_merge.left = layer->displayFrame.left;
rect_merge.top = layer->displayFrame.top;
rect_merge.right = layer->displayFrame.right;
rect_merge.bottom = layer->displayFrame.bottom;
}
else
{
rect_merge.left = hwcMAX(layer->displayFrame.left, left_min);
rect_merge.top = hwcMAX(layer->displayFrame.top, top_min);
rect_merge.right = hwcMIN(layer->displayFrame.right, right_max);
rect_merge.bottom = hwcMIN(layer->displayFrame.bottom, bottom_max);
}
}
#endif
src_w = ALIGN_DOWN(src_w, 2);
src_h = ALIGN_DOWN(src_h, 2);
dst_w = rect_merge.right - rect_merge.left;
dst_h = rect_merge.bottom - rect_merge.top;
dst_w = ALIGN(dst_w, 8);
dst_h = ALIGN(dst_h, 2);
#endif
if(src_w <= 0 || src_h <= 0)
{
ALOGD_IF(log_level(DBG_DEBUG),"layer src sourceCropf(%f,%f,%f,%f) is invalid,go to GPU GLES at line=%d",
layer->sourceCropf.left,layer->sourceCropf.top,layer->sourceCropf.right,layer->sourceCropf.bottom, __LINE__);
return true;
}
if((layer->transform == HWC_TRANSFORM_ROT_90) || (layer->transform == HWC_TRANSFORM_ROT_270))
{
rga_h_scale = (float)dst_h / src_w;
rga_v_scale = (float)dst_w / src_h;
}
else
{
rga_h_scale = (float)dst_w / src_w;
rga_v_scale = (float)dst_h / src_h;
}
#if (RGA_VER == 0 || RGA_VER == 1)
/* Arbitrary non-integer scaling ratio, from 1/2 to 8
RGA1:
RK3066
RK3188
Beetles
Beetlesplus
RGA1_plus:
Audi -> 3128
Granite -> soifa 3gr
*/
if(rga_h_scale < 0.5 || rga_v_scale < 0.5 ||
rga_h_scale > 8.0 || rga_v_scale > 8.0)
{
ALOGD_IF(log_level(DBG_DEBUG),"rga scale(%f,%f) out of range,go to GPU GLES at line=%d",
rga_h_scale,rga_v_scale,__LINE__);
return true;
}
if(src_w >= 1920 || src_h >= 1080)
{
ALOGD_IF(log_level(DBG_DEBUG),"rga1/rga1_plus take more than 20ms when roate 1080p or bigger video(%d,%d),go to GPU GLES at line=%d",
src_w,src_h,__LINE__);
return true;
}
#elif (RGA_VER == 2)
/* Arbitrary non-integer scaling ratio, from 1/8 to 8
RGA2-Lite:
Maybach -> 3368
BMW -> 3366
Benz -> 3228
infiniti ->3228H
rk3328
rk3326
*/
if(rga_h_scale < 0.125 || rga_v_scale < 0.125 ||
rga_h_scale > 8.0 || rga_v_scale > 8.0)
{
ALOGD_IF(log_level(DBG_DEBUG),"rga scale(%f,%f) out of range,go to GPU GLES at line=%d",
rga_h_scale,rga_v_scale,__LINE__);
return true;
}
#else
/* Arbitrary non-integer scaling ratio, from 1/16 to 16
RGA2:
Lincoln -> 3288/3288w
Capricorn -> 3190
RGA2-Enhance
mclaren -> 3399
mercury -> 1108
*/
if(rga_h_scale < 0.0625 || rga_v_scale < 0.0625 ||
rga_h_scale > 16.0 || rga_v_scale > 16.0)
{
ALOGD_IF(log_level(DBG_DEBUG),"rga scale(%f,%f) out of range,go to GPU GLES at line=%d",
rga_h_scale,rga_v_scale,__LINE__);
return true;
}
#endif
if(src_w > src_h && src_h >= 2160)
{
ALOGD_IF(log_level(DBG_DEBUG),"RGA take more than 30ms when roate 4K or bigger video(%d,%d),go to GPU GLES at line=%d",
src_w,src_h,__LINE__);
return true;
}
}
#if 0
if (layer->flags & HWC_SKIP_LAYER)
{
ALOGD_IF(log_level(DBG_DEBUG),"layer is skipped,go to GPU GLES at line=%d", __LINE__);
return true;
}
#endif
if(
#if (RK_RGA_COMPSITE_SYNC | RK_RGA_PREPARE_ASYNC)
!ctx->drm.isSupportRkRga() && layer->transform
#else
layer->transform
#endif
)
{
ALOGD_IF(log_level(DBG_DEBUG),"layer's transform=0x%x,go to GPU GLES at line=%d", layer->transform, __LINE__);
return true;
}
if(layer->transform != HWC_TRANSFORM_ROT_270 && layer->transform & HWC_TRANSFORM_ROT_90)
{
if((layer->transform & HWC_TRANSFORM_FLIP_H) || (layer->transform & HWC_TRANSFORM_FLIP_V) )
{
ALOGD_IF(log_level(DBG_DEBUG),"layer's transform=0x%x,go to GPU GLES at line=%d", layer->transform, __LINE__);
return true;
}
}
#if 0
if( (layer->blending == HWC_BLENDING_PREMULT)&& layer->planeAlpha!=0xFF )
{
ALOGD_IF(log_level(DBG_DEBUG),"layer's blending planeAlpha=0x%x,go to GPU GLES at line=%d", layer->planeAlpha, __LINE__);
return true;
}
#endif
if(layer->handle)
{
char layername[100];
#if RK_PRINT_LAYER_NAME
#ifdef USE_HWC2
HWC_GET_HANDLE_LAYERNAME(ctx->gralloc,layer,layer->handle, layername, 100);
#else
strcpy(layername, layer->LayerName);
#endif
#endif
//DumpLayer(layername,layer->handle);
if(!vop_support_format(format))
{
ALOGD_IF(log_level(DBG_DEBUG),"layer's format=0x%x is not support,go to GPU GLES at line=%d", format, __LINE__);
return true;
}
#if 1 // vendor.hwc.hdr_video_compose_by_gles property to enable/disable hdr_video_compose_by_gles
#if (defined TARGET_BOARD_PLATFORM_RK3399) || (defined TARGET_BOARD_PLATFORM_RK3288)
if(hd->isHdr && ctx->hdr_video_compose_by_gles)
{
if(connector && !connector->is_hdmi_support_hdr()
&& crtc && !ctx->drm.is_plane_support_hdr2sdr(crtc))
{
ALOGD_IF(log_level(DBG_DEBUG), "layer is hdr video,go to GPU GLES at line=%d", __LINE__);
return true;
}
}
#endif
#endif
#if 1
if(format == HAL_PIXEL_FORMAT_YCrCb_NV12 || format == HAL_PIXEL_FORMAT_YCrCb_NV12_10)
{
int src_xoffset = layer->sourceCropf.left * getPixelWidthByAndroidFormat(format);
if(!IS_ALIGN(src_xoffset,16))
{
ALOGD_IF(log_level(DBG_DEBUG),"layer's x offset = %d,vop nedd address should 16 bytes alignment,go to GPU GLES at line=%d", src_xoffset,__LINE__);
return true;
}
}
#endif
#if 1
if(!vop_support_scale(layer,hd))
{
ALOGD_IF(log_level(DBG_DEBUG),"layer's scale is not support,go to GPU GLES at line=%d", __LINE__);
return true;
}
#endif
if(layer->transform)
{
#ifdef TARGET_BOARD_PLATFORM_RK3288
if(format == HAL_PIXEL_FORMAT_YCrCb_NV12_10)
{
ALOGD_IF(log_level(DBG_DEBUG),"rk3288'rga cann't support nv12_10,go to GPU GLES at line=%d", __LINE__);
return true;
}
#endif
if(format == HAL_PIXEL_FORMAT_YCrCb_NV12 || format == HAL_PIXEL_FORMAT_YCrCb_NV12_10)
hd->transform_nv12++;
else if(layer->compositionType != HWC_NODRAW)
hd->transform_normal++;
}
#if USE_AFBC_LAYER
#if USE_GRALLOC_4
internal_format = gralloc4::get_internal_format(layer->handle);
#else // #if USE_GRALLOC_4
#if RK_PER_MODE
struct gralloc_drm_handle_t* drm_hnd = (struct gralloc_drm_handle_t *)layer->handle;
internal_format = drm_hnd->internal_format;
UN_USED(ret);
#else
ret = ctx->gralloc->perform(ctx->gralloc, GRALLOC_MODULE_PERFORM_GET_INTERNAL_FORMAT,
layer->handle, &internal_format);
if (ret) {
ALOGE("Failed to get internal_format for buffer %p (%d)", layer->handle, ret);
return false;
}
#endif
#endif // #if USE_GRALLOC_4
#if USE_GRALLOC_4
if ( gralloc4::does_use_afbc_format(layer->handle) )
#else
if(isAfbcInternalFormat(internal_format))
#endif
iFbdcCnt++;
#else
UN_USED(ret);
#endif
}
}
if(hd->transform_nv12 > 1 || hd->transform_normal > 0)
{
ALOGD_IF(log_level(DBG_DEBUG), "too many rotate layers,go to GPU GLES at line=%d", __LINE__);
return true;
}
if(video_4k_cnt >= 1 && large_UI_cnt >= 2)
{
ALOGD_IF(log_level(DBG_DEBUG), "4k video(%d) and too much large UI(%d),go to GPU GLES at line=%d",video_4k_cnt,
large_UI_cnt, __LINE__);
return true;
}
#if USE_AFBC_LAYER
if(iFbdcCnt > 1)
{
ALOGD_IF(log_level(DBG_DEBUG),"iFbdcCnt=%d,go to GPU GLES line=%d",iFbdcCnt, __LINE__);
return true;
}
#endif
return false;
}
static HDMI_STAT DetectStatus(const char* property)
{
char status[PROPERTY_VALUE_MAX];
property_get(property, status, "on");
ALOGD_IF(log_level(DBG_VERBOSE),"get %s is %s", property, status);
if(!strcmp(status, "off"))
return HDMI_OFF;
else
return HDMI_ON;
}
/*
* Use property on/off to enable/disable display devices
* sys.hdmi_status.aux -> HDMI
* sys.dp_status.aux -> DP
*/
static void DetectAuxStatus(const hwc_context_t *ctx)
{
static HDMI_STAT last_hdmi_status = HDMI_ON;
static HDMI_STAT last_dp_status = HDMI_ON;
char acStatus[10];
int ret = 0;
HDMI_STAT hdmi_status = DetectStatus( PROPERTY_TYPE ".hdmi_status.aux");
if(ctx->hdmi_status_fd > 0 && hdmi_status != last_hdmi_status)
{
if(hdmi_status == HDMI_ON)
strcpy(acStatus,"detect");
else
strcpy(acStatus,"off");
ret = write(ctx->hdmi_status_fd,acStatus,strlen(acStatus)+1);
if(ret < 0)
{
ALOGE("set hdmi status to %s falied, ret = %d", acStatus, ret);
}
last_hdmi_status = hdmi_status;
ALOGD_IF(log_level(DBG_VERBOSE),"set hdmi status to %s",acStatus);
}
HDMI_STAT dp_status = DetectStatus( PROPERTY_TYPE ".dp_status.aux");
if(ctx->dp_status_fd > 0 && dp_status != last_dp_status)
{
if(dp_status == HDMI_ON)
strcpy(acStatus,"detect");
else
strcpy(acStatus,"off");
ret = write(ctx->dp_status_fd,acStatus,strlen(acStatus)+1);
if(ret < 0)
{
ALOGE("set dp status to %s falied, ret = %d", acStatus, ret);
}
ALOGD_IF(log_level(DBG_VERBOSE),"set dp status to %s",acStatus);
last_dp_status = dp_status;
}
return ;
}
static bool parse_hdmi_output_format_prop(char* strprop, drm_hdmi_output_type *format, dw_hdmi_rockchip_color_depth *depth) {
if (!strcmp(strprop, "Auto")) {
*format = DRM_HDMI_OUTPUT_YCBCR_HQ;
*depth = ROCKCHIP_DEPTH_DEFAULT;
return true;
}
if (!strcmp(strprop, "RGB-8bit")) {
*format = DRM_HDMI_OUTPUT_DEFAULT_RGB;
*depth = ROCKCHIP_HDMI_DEPTH_8;
return true;
}
if (!strcmp(strprop, "RGB-10bit")) {
*format = DRM_HDMI_OUTPUT_DEFAULT_RGB;
*depth = ROCKCHIP_HDMI_DEPTH_10;
return true;
}
if (!strcmp(strprop, "YCBCR444-8bit")) {
*format = DRM_HDMI_OUTPUT_YCBCR444;
*depth = ROCKCHIP_HDMI_DEPTH_8;
return true;
}
if (!strcmp(strprop, "YCBCR444-10bit")) {
*format = DRM_HDMI_OUTPUT_YCBCR444;
*depth = ROCKCHIP_HDMI_DEPTH_10;
return true;
}
if (!strcmp(strprop, "YCBCR422-8bit")) {
*format = DRM_HDMI_OUTPUT_YCBCR422;
*depth = ROCKCHIP_HDMI_DEPTH_8;
return true;
}
if (!strcmp(strprop, "YCBCR422-10bit")) {
*format = DRM_HDMI_OUTPUT_YCBCR422;
*depth = ROCKCHIP_HDMI_DEPTH_10;
return true;
}
if (!strcmp(strprop, "YCBCR420-8bit")) {
*format = DRM_HDMI_OUTPUT_YCBCR420;
*depth = ROCKCHIP_HDMI_DEPTH_8;
return true;
}
if (!strcmp(strprop, "YCBCR420-10bit")) {
*format = DRM_HDMI_OUTPUT_YCBCR420;
*depth = ROCKCHIP_HDMI_DEPTH_10;
return true;
}
ALOGE("hdmi output format is invalid. [%s]", strprop);
return false;
}
static bool update_hdmi_output_format(struct hwc_context_t *ctx, DrmConnector *connector, int display,
hwc_drm_display_t *hd) {
int timeline = 0;
drm_hdmi_output_type color_format = DRM_HDMI_OUTPUT_DEFAULT_RGB;
dw_hdmi_rockchip_color_depth color_depth = ROCKCHIP_HDMI_DEPTH_8;
int ret = 0;
int need_change_format = 0;
int need_change_depth = 0;
char prop_format[PROPERTY_VALUE_MAX];
static uint32_t last_mainType,last_auxType;
timeline = property_get_int32( PROPERTY_TYPE ".display.timeline", -1);
drmModeAtomicReqPtr pset = NULL;
/*
* force update propetry when timeline is zero or not exist.
*/
if (timeline && timeline == hd->display_timeline &&
hd->hotplug_timeline == hd->ctx->drm.timeline())
return 0;
//hd->display_timeline = timeline;//let update_display_bestmode function update the value.
//hd->hotplug_timeline = hd->ctx->drm.timeline();//let update_display_bestmode function update the value.
memset(prop_format, 0, sizeof(prop_format));
if (display == HWC_DISPLAY_PRIMARY){
if(hwc_have_baseparameter()){
if(connector->get_type() != last_mainType){
property_set("persist." PROPERTY_TYPE ".color.main","use_baseparameter");
ALOGD("BP:DisplayDevice change type[%d] => type[%d],to update main color",last_mainType,connector->get_type());
last_mainType = connector->get_type();
}
property_get("persist." PROPERTY_TYPE ".color.main", prop_format, "use_baseparameter");
if(!strcmp(prop_format,"use_baseparameter")){
hwc_get_baseparameter_config(prop_format,display,BP_COLOR,connector->get_type());
ret = sscanf(prop_format,"%d-%d",&color_format,&color_depth);
if(ret != 2){
ALOGE("BP: get color fail! to use default ");
color_format = DRM_HDMI_OUTPUT_DEFAULT_RGB;
color_depth = ROCKCHIP_DEPTH_DEFAULT;
}
}else{
/* Can get the persist." PROPERTY_TYPE ".color.main, to use it. */
ret = parse_hdmi_output_format_prop(prop_format, &color_format, &color_depth);
if (ret == false) {
ALOGE("Get color fail! to use default ");
color_format = DRM_HDMI_OUTPUT_DEFAULT_RGB;
color_depth = ROCKCHIP_DEPTH_DEFAULT;
}
}
}else{
/* if resolution is null,set to "Auto" */
property_get("persist." PROPERTY_TYPE ".color.main", prop_format, "Auto");
ret = parse_hdmi_output_format_prop(prop_format, &color_format, &color_depth);
if (ret == false) {
ALOGE("Get color fail! to use default ");
color_format = DRM_HDMI_OUTPUT_DEFAULT_RGB;
color_depth = ROCKCHIP_DEPTH_DEFAULT;
}
}
}else if(display == HWC_DISPLAY_EXTERNAL){
if(hwc_have_baseparameter()){
if(connector->get_type() != last_auxType){
property_set("persist." PROPERTY_TYPE ".color.aux","use_baseparameter");
ALOGD("BP:DisplayDevice change type[%d] => type[%d],to update aux color",last_auxType,connector->get_type());
last_auxType = connector->get_type();
}
property_get("persist." PROPERTY_TYPE ".color.aux", prop_format, "use_baseparameter");
if(!strcmp(prop_format,"use_baseparameter")){
hwc_get_baseparameter_config(prop_format,display,BP_COLOR,connector->get_type());
ret = sscanf(prop_format,"%d-%d",&color_format,&color_depth);
if(ret != 2){
ALOGE("BP: get color fail! to use default ");
color_format = DRM_HDMI_OUTPUT_DEFAULT_RGB;
color_depth = ROCKCHIP_DEPTH_DEFAULT;
}
}else{
/* Can get the persist." PROPERTY_TYPE ".color.aux, to use it. */
ret = parse_hdmi_output_format_prop(prop_format, &color_format, &color_depth);
if (ret == false) {
ALOGE("Get color fail! to use default ");
color_format = DRM_HDMI_OUTPUT_DEFAULT_RGB;
color_depth = ROCKCHIP_DEPTH_DEFAULT;
}
}
}else{
/* if resolution is null,set to "Auto" */
property_get("persist." PROPERTY_TYPE ".color.aux", prop_format, "Auto");
ret = parse_hdmi_output_format_prop(prop_format, &color_format, &color_depth);
if (ret == false) {
ALOGE("Get color fail! to use default ");
color_format = DRM_HDMI_OUTPUT_DEFAULT_RGB;
color_depth = ROCKCHIP_DEPTH_DEFAULT;
}
}
}
if(hd->color_format != color_format) {
need_change_format = 1;
}
if(hd->color_depth != color_depth) {
need_change_depth = 1;
}
if(connector->hdmi_output_format_property().id() > 0 && need_change_format > 0) {
pset = drmModeAtomicAlloc();
if (!pset) {
ALOGE("%s:line=%d Failed to allocate property set", __FUNCTION__, __LINE__);
return false;
}
ALOGD_IF(log_level(DBG_VERBOSE),"%s: change hdmi output format: %d", __FUNCTION__, color_format);
ret = drmModeAtomicAddProperty(pset, connector->id(), connector->hdmi_output_format_property().id(), color_format);
if (ret < 0) {
ALOGE("%s:line=%d Failed to add prop[%d] to [%d]", __FUNCTION__, __LINE__, connector->hdmi_output_format_property().id(), connector->id());
}
if (ret < 0) {
ALOGE("%s:line=%d Failed to commit pset ret=%d\n", __FUNCTION__, __LINE__, ret);
drmModeAtomicFree(pset);
return false;
}
else
{
hd->color_format = color_format;
}
}
if(connector->hdmi_output_depth_property().id() > 0 && need_change_depth > 0) {
if (!pset) {
pset = drmModeAtomicAlloc();
}
if (!pset) {
ALOGE("%s:line=%d Failed to allocate property set", __FUNCTION__, __LINE__);
return false;
}
ALOGD_IF(log_level(DBG_VERBOSE),"%s: change hdmi output depth: %d", __FUNCTION__, color_depth);
ret = drmModeAtomicAddProperty(pset, connector->id(), connector->hdmi_output_depth_property().id(), color_depth);
if (ret < 0) {
ALOGE("%s:line=%d Failed to add prop[%d] to [%d]", __FUNCTION__, __LINE__, connector->hdmi_output_depth_property().id(), connector->id());
}
if (ret < 0) {
ALOGE("%s:line=%d Failed to commit pset ret=%d\n", __FUNCTION__, __LINE__, ret);
drmModeAtomicFree(pset);
return false;
}
else
{
hd->color_depth = color_depth;
}
}
if (pset != NULL) {
drmModeAtomicCommit(ctx->drm.fd(), pset, DRM_MODE_ATOMIC_ALLOW_MODESET, &ctx->drm);
drmModeAtomicFree(pset);
pset = NULL;
}
return true;
}
/**
* @brief set hdr_metadata and colorimetry.
*
* @param hdr_metadata [IN] hdr metadata
* @param android_colorspace [IN] colorspace
* @return
* true: set successfully.
* false: set fail.
*/
static bool set_hdmi_hdr_meta(struct hwc_context_t *ctx, DrmConnector *connector,
hdr_metadata_s* hdr_metadata, hwc_drm_display_t *hd,
uint32_t android_colorspace)
{
uint32_t blob_id = 0;
int ret = -1;
int colorimetry = 0;
if(!ctx || !connector || !hdr_metadata)
{
ALOGE("%s:line=%d parameter is null", __FUNCTION__, __LINE__);
return false;
}
if(connector->hdr_metadata_property().id())
{
ALOGD_IF(log_level(DBG_VERBOSE),"%s: android_colorspace = 0x%x", __FUNCTION__, android_colorspace);
drmModeAtomicReqPtr pset = drmModeAtomicAlloc();
if (!pset) {
ALOGE("%s:line=%d Failed to allocate property set", __FUNCTION__, __LINE__);
return false;
}
if(!memcmp(&hd->last_hdr_metadata, hdr_metadata, sizeof(hdr_metadata_s)))
{
ALOGD_IF(log_level(DBG_VERBOSE),"%s: no need to update metadata", __FUNCTION__);
}
else
{
ALOGD_IF(log_level(DBG_VERBOSE),"%s: hdr_metadata eotf=0x%x, hd->last_hdr_metadata=0x%x", __FUNCTION__,
HDR_METADATA_EOTF_P(hdr_metadata), HDR_METADATA_EOTF_T(hd->last_hdr_metadata));
ctx->drm.CreatePropertyBlob(hdr_metadata, sizeof(hdr_metadata_s), &blob_id);
ret = drmModeAtomicAddProperty(pset, connector->id(), connector->hdr_metadata_property().id(), blob_id);
if (ret < 0) {
ALOGE("%s:line=%d Failed to add prop[%d] to [%d]", __FUNCTION__, __LINE__, connector->hdr_metadata_property().id(), connector->id());
}
}
if(connector->hdmi_output_colorimetry_property().id())
{
if((android_colorspace & HAL_DATASPACE_STANDARD_BT2020) == HAL_DATASPACE_STANDARD_BT2020)
{
colorimetry = COLOR_METRY_ITU_2020;
}
if(hd->colorimetry != colorimetry)
{
ALOGD_IF(log_level(DBG_VERBOSE),"%s: change bt2020 %d", __FUNCTION__, colorimetry);
ret = drmModeAtomicAddProperty(pset, connector->id(), connector->hdmi_output_colorimetry_property().id(), colorimetry);
if (ret < 0) {
ALOGE("%s:line=%d Failed to add prop[%d] to [%d]", __FUNCTION__, __LINE__, connector->hdmi_output_colorimetry_property().id(), connector->id());
}
}
}
drmModeAtomicCommit(ctx->drm.fd(), pset, DRM_MODE_ATOMIC_ALLOW_MODESET, &ctx->drm);
if (ret < 0) {
ALOGE("%s:line=%d Failed to commit pset ret=%d\n", __FUNCTION__, __LINE__, ret);
drmModeAtomicFree(pset);
return false;
}
else
{
memcpy(&hd->last_hdr_metadata, hdr_metadata, sizeof(hdr_metadata_s));
hd->colorimetry = colorimetry;
}
if (blob_id)
ctx->drm.DestroyPropertyBlob(blob_id);
drmModeAtomicFree(pset);
return true;
}
else
{
ALOGD_IF(log_level(DBG_VERBOSE),"%s: hdmi don't support hdr metadata", __FUNCTION__);
return false;
}
}
#if RK_RGA_PREPARE_ASYNC
static int PrepareRgaBuffer(DrmRgaBuffer &rgaBuffer, DrmHwcLayer &layer) {
int rga_transform = 0;
int src_l=0,src_t=0,src_w=0,src_h=0;
int dst_l=0,dst_t=0,dst_r=0,dst_b=0;
int ret;
int dst_w,dst_h,dst_stride;
rga_info_t src, dst;
int alloc_format = 0;
memset(&src, 0, sizeof(rga_info_t));
memset(&dst, 0, sizeof(rga_info_t));
src.fd = -1;
dst.fd = -1;
#if 0
ret = rgaBuffer.WaitReleased(-1);
if (ret) {
ALOGE("Failed to wait for rga buffer release %d", ret);
return ret;
}
rgaBuffer.set_release_fence_fd(-1);
#endif
src_l = (int)layer.source_crop.left;
src_t = (int)layer.source_crop.top;
src_w = (int)(layer.source_crop.right - layer.source_crop.left);
src_h = (int)(layer.source_crop.bottom - layer.source_crop.top);
src_l = ALIGN_DOWN(src_l, 2);
src_t = ALIGN_DOWN(src_t, 2);
dst_l = 0;
dst_t = 0;
#if !RK_RGA_SCALE_AND_ROTATE
if(layer.transform & DrmHwcTransform::kRotate90 || layer.transform & DrmHwcTransform::kRotate270)
{
dst_r = (int)(layer.source_crop.bottom - layer.source_crop.top);
dst_b = (int)(layer.source_crop.right - layer.source_crop.left);
src_h = ALIGN_DOWN(src_h, 8);
src_w = ALIGN_DOWN(src_w, 2);
}
else
{
dst_r = (int)(layer.source_crop.right - layer.source_crop.left);
dst_b = (int)(layer.source_crop.bottom - layer.source_crop.top);
src_w = ALIGN_DOWN(src_w, 8);
src_h = ALIGN_DOWN(src_h, 2);
}
dst_w = dst_r - dst_l;
dst_h = dst_b - dst_t;
int dst_raw_w = dst_w;
int dst_raw_h = dst_h;
dst_w = ALIGN_DOWN(dst_w, 8);
dst_h = ALIGN_DOWN(dst_h, 2);
#else
UN_USED(dst_r);
UN_USED(dst_b);
src_w = ALIGN_DOWN(src_w, 2);
src_h = ALIGN_DOWN(src_h, 2);
dst_w = layer.rect_merge.right - layer.rect_merge.left;
dst_h = layer.rect_merge.bottom - layer.rect_merge.top;
dst_w = ALIGN(dst_w, 8);
dst_h = ALIGN(dst_h, 2);
#endif
if(dst_w < 0 || dst_h <0 )
ALOGE("RGA invalid dst_w=%d,dst_h=%d",dst_w,dst_h);
//If the layer's format is NV12_10,then use RGA to switch it to NV12.
if(layer.format == HAL_PIXEL_FORMAT_YCrCb_NV12_10)
alloc_format = HAL_PIXEL_FORMAT_YCrCb_NV12;
else
alloc_format = layer.format;
if (!rgaBuffer.Allocate(dst_w, dst_h, alloc_format)) {
ALOGE("Failed to allocate rga buffer with size %dx%d", dst_w, dst_h);
return -ENOMEM;
}
dst_stride = rgaBuffer.buffer()->getStride();
//DumpLayer("rga", layer.sf_handle);
if(layer.transform & DrmHwcTransform::kRotate90) {
rga_transform = DRM_RGA_TRANSFORM_ROT_90;
}
else if(layer.transform & DrmHwcTransform::kRotate270) {
rga_transform = DRM_RGA_TRANSFORM_ROT_270;
}
else if(layer.transform & DrmHwcTransform::kRotate180) {
rga_transform = DRM_RGA_TRANSFORM_ROT_180;
}
else if(layer.transform & DrmHwcTransform::kRotate0) {
rga_transform = DRM_RGA_TRANSFORM_ROT_0;
}
else if(layer.transform & DrmHwcTransform::kFlipH) {
rga_transform = DRM_RGA_TRANSFORM_FLIP_H;
}
else if(layer.transform & DrmHwcTransform::kFlipV) {
rga_transform = DRM_RGA_TRANSFORM_FLIP_V;
}
else {
ALOGE("%s: line=%d, wrong transform=0x%x", __FUNCTION__, __LINE__, layer.transform);
ret = -1;
return ret;
}
if(rga_transform != DRM_RGA_TRANSFORM_FLIP_H && layer.transform & DrmHwcTransform::kFlipH)
rga_transform |= DRM_RGA_TRANSFORM_FLIP_H;
if (rga_transform != DRM_RGA_TRANSFORM_FLIP_V && layer.transform & DrmHwcTransform::kFlipV)
rga_transform |= DRM_RGA_TRANSFORM_FLIP_V;
//rga async mode,flush in Composite thread.
src.sync_mode = RGA_BLIT_ASYNC;
rga_set_rect(&src.rect,
src_l, src_t, src_w, src_h,
layer.stride, layer.height, layer.format);
rga_set_rect(&dst.rect, dst_l, dst_t, dst_w, dst_h, dst_stride, dst_h, alloc_format);
ALOGD_IF(log_level(DBG_DEBUG),"RK_RGA_PREPARE_ASYNC rgaRotateScale : src[x=%d,y=%d,w=%d,h=%d,ws=%d,hs=%d,format=0x%x],dst[x=%d,y=%d,w=%d,h=%d,ws=%d,hs=%d,format=0x%x]",
src.rect.xoffset, src.rect.yoffset, src.rect.width, src.rect.height, src.rect.wstride, src.rect.hstride, src.rect.format,
dst.rect.xoffset, dst.rect.yoffset, dst.rect.width, dst.rect.height, dst.rect.wstride, dst.rect.hstride, dst.rect.format);
ALOGD_IF(log_level(DBG_DEBUG),"RK_RGA_PREPARE_ASYNC rgaRotateScale : src hnd=%p,dst hnd=%p, format=0x%x, transform=0x%x\n",
(void*)layer.sf_handle, (void*)(rgaBuffer.buffer()->handle), layer.format, rga_transform);
src.hnd = layer.sf_handle;
dst.hnd = rgaBuffer.buffer()->handle;
src.rotation = rga_transform;
RockchipRga& rkRga(RockchipRga::get());
ret = rkRga.RkRgaBlit(&src, &dst, NULL);
if(ret) {
ALOGE("rgaRotateScale error : src[x=%d,y=%d,w=%d,h=%d,ws=%d,hs=%d,format=0x%x],dst[x=%d,y=%d,w=%d,h=%d,ws=%d,hs=%d,format=0x%x]",
src.rect.xoffset, src.rect.yoffset, src.rect.width, src.rect.height, src.rect.wstride, src.rect.hstride, src.rect.format,
dst.rect.xoffset, dst.rect.yoffset, dst.rect.width, dst.rect.height, dst.rect.wstride, dst.rect.hstride, dst.rect.format);
ALOGE("rgaRotateScale error : %s,src hnd=%p,dst hnd=%p",
strerror(errno), (void*)layer.sf_handle, (void*)(rgaBuffer.buffer()->handle));
}
DumpLayer("rga", dst.hnd);
//instead of the original DrmHwcLayer
layer.is_rotate_by_rga = true;
layer.buffer.Clear();
layer.source_crop = DrmHwcRect<float>(dst_l,dst_t,dst_w,dst_h);
//The dst layer's format is NV12.
if(layer.format == HAL_PIXEL_FORMAT_YCrCb_NV12_10)
layer.format = HAL_PIXEL_FORMAT_YCrCb_NV12;
layer.sf_handle = rgaBuffer.buffer()->handle;
#if RK_VIDEO_SKIP_LINE
layer.SkipLine = 0;
#endif
layer.rga_handle = rgaBuffer.buffer()->handle;
return ret;
}
static int ApplyPreRotate(hwc_drm_display_t *hd, DrmHwcLayer &layer) {
int ret = 0;
ALOGD_IF(log_level(DBG_DEBUG), "%s:rgaBuffer_index=%d", __FUNCTION__, hd->rgaBuffer_index);
DrmRgaBuffer &rga_buffer = hd->rgaBuffers[hd->rgaBuffer_index];
ret = PrepareRgaBuffer(rga_buffer, layer);
if (ret) {
ALOGE("Failed to prepare rga buffer for RGA rotate %d", ret);
return ret;
}
#if 0
ret = display_comp->CreateNextTimelineFence("ApplyPreRotate");
if (ret <= 0) {
ALOGE("Failed to create RGA rotate release fence %d", ret);
return ret;
}
rga_buffer.set_release_fence_fd(ret);
#endif
return 0;
}
static void freeRgaBuffers(hwc_drm_display_t *hd) {
for(int i = 0; i < MaxRgaBuffers; i++) {
hd->rgaBuffers[i].Clear();
}
}
#endif
static int hwc_prepare(hwc_composer_device_1_t *dev, size_t num_displays,
hwc_display_contents_1_t **display_contents) {
struct hwc_context_t *ctx = (struct hwc_context_t *)&dev->common;
int ret = -1;
#ifdef USE_PLANE_RESERVED
int win1_reserved = hwc_get_int_property( PROPERTY_TYPE ".hwc.win1.reserved", "0");
#endif
#ifdef USE_HWC2
DrmConnector *extend = ctx->drm.GetConnectorFromType(HWC_DISPLAY_EXTERNAL);
//Fake handle event if the hotplug happen earlyer than hwc thread.
if(get_frame() == 1 && !g_hasHotplug && extend && (extend->raw_state() == DRM_MODE_CONNECTED))
{
pthread_t hotplug_event;
if (pthread_create(&hotplug_event, NULL, hotplug_event_thread, ctx))
{
ALOGE("Create hotplug_event thread error .");
}
}
#endif
//Update LUT from baseparameter at boot time
if(get_frame() == 1){
hwc_SetGamma(&ctx->drm);
}
init_log_level();
hwc_dump_fps();
ALOGD_IF(log_level(DBG_VERBOSE),"----------------------------frame=%d start ----------------------------",get_frame());
ctx->layer_contents.clear();
ctx->layer_contents.reserve(num_displays);
ctx->comp_plane_group.clear();
ctx->drm.UpdateDisplayRoute();
DetectAuxStatus(ctx);
for (int i = 0; i < (int)num_displays; ++i) {
bool use_framebuffer_target = false;
if (!display_contents[i])
continue;
ALOGD_IF(log_level(DBG_VERBOSE), "************** display=%d **************", i);
int num_layers = display_contents[i]->numHwLayers;
for (int j = 0; j < num_layers; j++) {
hwc_layer_1_t *layer = &display_contents[i]->hwLayers[j];
dump_layer(ctx->gralloc, false, layer, j);
}
if(i == HWC_DISPLAY_VIRTUAL)
{
for (int j = 0; j < num_layers; ++j) {
hwc_layer_1_t *layer = &display_contents[i]->hwLayers[j];
layer->compositionType = HWC_FRAMEBUFFER;
}
continue;
}
ctx->layer_contents.emplace_back();
DrmHwcDisplayContents &layer_content = ctx->layer_contents.back();
ctx->comp_plane_group.emplace_back();
DrmCompositionDisplayPlane &comp_plane = ctx->comp_plane_group.back();
comp_plane.display = i;
if(ctx->fb_blanked == FB_BLANK_POWERDOWN){
ALOGD_IF(log_level(DBG_DEBUG),"%s: display=%d fb_blanked = %s,line = %d",__FUNCTION__,i,
ctx->fb_blanked == FB_BLANK_POWERDOWN ? "POWERDOWN" : "ACTIVE",__LINE__);
hwc_list_nodraw(display_contents[i]);
continue;
}
DrmConnector *connector = ctx->drm.GetConnectorFromType(i);
if (!connector) {
ALOGE("%s:Failed to get connector for display %d line=%d",__FUNCTION__, i,__LINE__);
hwc_list_nodraw(display_contents[i]);
continue;
}
hwc_drm_display_t *hd = &ctx->displays[connector->display()];
DrmCrtc *crtc = ctx->drm.GetCrtcFromConnector(connector);
if (connector->state() != DRM_MODE_CONNECTED || !crtc) {
ALOGE("%s: display=%d, connector[%d] is disconnect type=%s",__FUNCTION__,i,
connector->display(),ctx->drm.connector_type_str(connector->get_type()));
hwc_list_nodraw(display_contents[i]);
continue;
}
#if RK_3D_VIDEO
hd->stereo_mode = NON_3D;
int bk_is_3d = hd->is_3d;
hd->is_3d = detect_3d_mode(hd, display_contents[i], i);
if(bk_is_3d != hd->is_3d)
{
int timeline = 0;
char acTimelie[10];
timeline = property_get_int32( PROPERTY_TYPE ".display.timeline", -1);
timeline++;
snprintf(acTimelie,10,"%d",timeline);
property_set( PROPERTY_TYPE ".display.timeline", acTimelie);
}
#endif
update_hdmi_output_format(ctx, connector, i, hd);
update_display_bestmode(hd, i, connector);
DrmMode mode = connector->best_mode();
connector->set_current_mode(mode);
hd->rel_xres = mode.h_display();
hd->rel_yres = mode.v_display();
hd->v_total = mode.v_total();
hd->w_scale = (float)mode.h_display() / hd->framebuffer_width;
hd->h_scale = (float)mode.v_display() / hd->framebuffer_height;
int fbSize = hd->framebuffer_width * hd->framebuffer_height;
//get plane size for display
std::vector<PlaneGroup *>& plane_groups = ctx->drm.GetPlaneGroups();
hd->iPlaneSize = 0;
hd->hasEotfPlane = false;
hd->is_interlaced = (mode.interlaced()>0) ? true:false;
hd->bPreferMixDown = false;
for (std::vector<PlaneGroup *> ::const_iterator iter = plane_groups.begin();
iter != plane_groups.end(); ++iter)
{
#ifdef USE_PLANE_RESERVED
if (win1_reserved > 0 && GetCrtcSupported(*crtc, (*iter)->possible_crtcs) &&
((*iter)->planes.at(0)->type() == DRM_PLANE_TYPE_OVERLAY) &&
(*iter)->planes.at(0)->get_yuv())
{
(*iter)->b_reserved = true;
for(std::vector<DrmPlane*> ::const_iterator iter_plane = (*iter)->planes.begin();
iter_plane != (*iter)->planes.end(); ++iter_plane)
{
(*iter_plane)->set_reserved(true);
}
ALOGD_IF(log_level(DBG_DEBUG),"Enable USE_PLANE_RESERVED, plane share_id = %" PRIu64 "", (*iter)->share_id);
continue;
}
#endif
if(hd->is_interlaced && (*iter)->planes.size() > 2)
{
(*iter)->b_reserved = true;
// continue;
}
else if(GetCrtcSupported(*crtc, (*iter)->possible_crtcs))
{
(*iter)->b_reserved = false;
hd->iPlaneSize++;
if(!hd->hasEotfPlane)
{
for(std::vector<DrmPlane*> ::const_iterator iter_plane = (*iter)->planes.begin();
iter_plane != (*iter)->planes.end(); ++iter_plane)
{
if((*iter_plane)->get_hdr2sdr())
{
hd->hasEotfPlane = true;
break;
}
}
}
}
}
#if SKIP_BOOT
if(g_boot_cnt < BOOT_COUNT)
{
hwc_list_nodraw(display_contents[i]);
ALOGD_IF(log_level(DBG_DEBUG),"prepare skip %d",g_boot_cnt);
return 0;
}
#endif
for (int j = 0; j < num_layers-1; j++) {
hwc_layer_1_t *layer = &display_contents[i]->hwLayers[j];
if(layer->handle)
{
if(layer->compositionType == HWC_NODRAW)
layer->compositionType = HWC_FRAMEBUFFER;
}
}
int format = 0;
int usage = 0;
bool isHdr = false;
hd->is10bitVideo = false;
hd->isVideo = false;
for (int j = 0; j < num_layers-1; j++) {
hwc_layer_1_t *layer = &display_contents[i]->hwLayers[j];
if(layer->handle)
{
#if (!RK_PER_MODE && RK_DRM_GRALLOC)
format = hwc_get_handle_attibute(ctx->gralloc,layer->handle, ATT_FORMAT);
#else
format = hwc_get_handle_format(ctx->gralloc,layer->handle);
#endif
if(format == HAL_PIXEL_FORMAT_YCrCb_NV12)
{
hd->isVideo = true;
}
if(format == HAL_PIXEL_FORMAT_YCrCb_NV12_10)
{
hd->is10bitVideo = true;
hd->isVideo = true;
usage = hwc_get_handle_usage(ctx->gralloc,layer->handle);
ALOGD_IF(log_level(DBG_VERBOSE),"%s:line=%d usage = %x",__FUNCTION__,__LINE__,
usage);
ALOGD_IF(log_level(DBG_VERBOSE),"%s:line=%d isSupportSt2084 = %d, isSupportHLG = %d",__FUNCTION__,__LINE__,
connector->isSupportSt2084(),connector->isSupportHLG() );
if((usage & 0x0F000000) == HDR_ST2084_USAGE || (usage & 0x0F000000) == HDR_HLG_USAGE)
{
isHdr = true;
//vop limit: hdr video must in the bottom.
if(j != 0)
{
ALOGD_IF(log_level(DBG_DEBUG),"hdr video must in the bottom of layer list,go to GPU GLES at line=%d", __LINE__);
use_framebuffer_target = true;
}
if(hd->isHdr != isHdr && connector->is_hdmi_support_hdr())
{
ALOGD_IF(log_level(DBG_VERBOSE),"%s:line=%d isSupportSt2084 = %d, isSupportHLG = %d",__FUNCTION__,__LINE__,
connector->isSupportSt2084(),connector->isSupportHLG() );
uint32_t android_colorspace = hwc_get_layer_colorspace(layer);
hdr_metadata_s hdr_metadata;
memset(&hdr_metadata, 0, sizeof(hdr_metadata_s));
if((android_colorspace & HAL_DATASPACE_TRANSFER_MASK) == HAL_DATASPACE_TRANSFER_ST2084
&& connector->isSupportSt2084())
{
ALOGD_IF(log_level(DBG_VERBOSE),"%s:line=%d has st2084",__FUNCTION__,__LINE__);
HDR_METADATA_EOTF_T(hdr_metadata) = SMPTE_ST2084;
}
else if((android_colorspace & HAL_DATASPACE_TRANSFER_MASK) == HAL_DATASPACE_TRANSFER_HLG
&& connector->isSupportHLG())
{
ALOGD_IF(log_level(DBG_VERBOSE),"%s:line=%d has HLG",__FUNCTION__,__LINE__);
HDR_METADATA_EOTF_T(hdr_metadata) = HLG;
}
else
{
//ALOGE("Unknow etof %d",eotf);
HDR_METADATA_EOTF_T(hdr_metadata) = TRADITIONAL_GAMMA_SDR;
}
set_hdmi_hdr_meta(ctx, connector, &hdr_metadata, hd, android_colorspace);
}
break;
}
}
}
}
bool force_not_invalid_refresh = false;
for (int j = 0; j < num_layers-1; j++) {
hwc_layer_1_t *layer = &display_contents[i]->hwLayers[j];
if(layer->handle)
{
#if RK_DRM_GRALLOC
format = hwc_get_handle_attibute(ctx->gralloc,layer->handle, ATT_FORMAT);
#else
format = hwc_get_handle_format(ctx->gralloc,layer->handle);
#endif
#if RK_PRINT_LAYER_NAME
char layername[100];
#ifdef USE_HWC2
HWC_GET_HANDLE_LAYERNAME(ctx->gralloc,layer,layer->handle, layername, 100);
#else
strcpy(layername, layer->LayerName);
#endif
#endif
int src_l,src_t,src_w,src_h;
src_l = (int)layer->sourceCropf.left;
src_t = (int)layer->sourceCropf.top;
src_w = (int)(layer->sourceCropf.right - layer->sourceCropf.left);
src_h = (int)(layer->sourceCropf.bottom - layer->sourceCropf.top);
if(!force_not_invalid_refresh && src_w > src_h && src_w >= 3840
&& format != HAL_PIXEL_FORMAT_YCrCb_NV12 && format != HAL_PIXEL_FORMAT_YCrCb_NV12_10)
{
force_not_invalid_refresh = true;
}
/*
* VOP can't display layer size < 16 pixel , so set layer HWC_NODRAW in 1080P
*/
if( hd->rel_xres * hd->rel_yres > 2073600 && (src_w * src_h < 16 ))
{
layer->compositionType = HWC_NODRAW;
//layer->flags |= HWC_SKIP_LAYER;
ALOGD_IF(log_level(DBG_DEBUG),
"%s:line=%d layer size[%d,%d] too small ,set HWC_NODRAW",
__FUNCTION__,__LINE__,src_w,src_h);
}
/*
* VOP can't scale layer width or height < 4 pixel , so set layer HWC_SKIP_LAYER to
* compose by GPU.
*/
if( src_w < 4 || src_h < 4 )
{
layer->compositionType = HWC_FRAMEBUFFER;
layer->flags |= HWC_SKIP_LAYER;
ALOGD_IF(log_level(DBG_DEBUG),
"%s:line=%d layer size[%d,%d] too small ,set HWC_SKIP_LAYER",
__FUNCTION__,__LINE__,src_w,src_h);
}
#if RK_PRINT_LAYER_NAME
if(strstr(layername,"drawpath"))
{
hd->bPreferMixDown = true;
ALOGD_IF(log_level(DBG_DEBUG),"%s:line=%d in drawpath mode prefer use mix down policy",
__FUNCTION__,__LINE__);
}
#endif
}
}
#if RK_INVALID_REFRESH
if(ctx->mOneWinOpt && force_not_invalid_refresh && hd->rel_xres >= 3840 && hd->rel_xres != hd->framebuffer_width)
{
ALOGD_IF(log_level(DBG_DEBUG),"disable static timer");
ctx->mOneWinOpt = false;
}
if(hd->isHdr){
ALOGD_IF(log_level(DBG_DEBUG),"HDR video mode,disable static timer");
ctx->mOneWinOpt = false;
}
#endif
//Switch hdr mode
if(hd->isHdr != isHdr)
{
hd->isHdr = isHdr;
#if RK_HDR_PERF_MODE
if(hd->isHdr)
{
ALOGD_IF(log_level(DBG_DEBUG),"Enter hdr performance mode");
ctl_little_cpu(0);
ctl_cpu_performance(1, 1);
}
else
{
ALOGD_IF(log_level(DBG_DEBUG),"Exit hdr performance mode");
ctl_cpu_performance(0, 1);
ctl_little_cpu(1);
}
#endif
if(!hd->isHdr && connector->is_hdmi_support_hdr())
{
uint32_t android_colorspace = 0;
hdr_metadata_s hdr_metadata;
ALOGD_IF(log_level(DBG_VERBOSE),"disable hdmi hdr meta");
memset(&hdr_metadata, 0, sizeof(hdr_metadata_s));
set_hdmi_hdr_meta(ctx, connector, &hdr_metadata, hd, android_colorspace);
}
}
#if RK_3D_VIDEO
int iLastFps = num_layers-1;
if(hd->stereo_mode == FPS_3D)
{
for(int j=num_layers-1; j>=0; j--) {
hwc_layer_1_t *layer = &display_contents[i]->hwLayers[j];
int32_t alreadyStereo = 0;
#ifdef USE_HWC2
if(layer->handle)
{
alreadyStereo = hwc_get_handle_alreadyStereo(ctx->gralloc, layer->handle);
if(alreadyStereo < 0)
{
ALOGE("hwc_get_handle_alreadyStereo fail");
alreadyStereo = 0;
}
}
#else
alreadyStereo = layer->alreadyStereo;
#endif
if(alreadyStereo == FPS_3D) {
iLastFps = j;
break;
}
}
for (int j = 0; j < iLastFps; j++)
{
display_contents[i]->hwLayers[j].compositionType = HWC_NODRAW;
}
}
#endif
#if RK_VIDEO_UI_OPT
video_ui_optimize(ctx->gralloc, display_contents[i], &ctx->displays[connector->display()]);
#endif
if(!use_framebuffer_target)
use_framebuffer_target = is_use_gles_comp(ctx, connector, display_contents[i], connector->display());
bool bHasFPS_3D_UI = false;
int index = 0;
for (int j = 0; j < num_layers; j++) {
hwc_layer_1_t *sf_layer = &display_contents[i]->hwLayers[j];
if(!(sf_layer->flags & HWC_SKIP_LAYER) && sf_layer->compositionType != HWC_FRAMEBUFFER_TARGET && sf_layer->handle == NULL)
continue;
if(sf_layer->compositionType == HWC_NODRAW)
continue;
#if RK_3D_VIDEO
if(hd->stereo_mode == FPS_3D && iLastFps < num_layers-1)
{
int32_t alreadyStereo = 0, displayStereo = 0;
#ifdef USE_HWC2
alreadyStereo = hwc_get_handle_alreadyStereo(ctx->gralloc, sf_layer->handle);
if(alreadyStereo < 0)
{
ALOGE("hwc_get_handle_alreadyStereo fail");
alreadyStereo = 0;
}
displayStereo = hwc_get_handle_displayStereo(ctx->gralloc, sf_layer->handle);
if(displayStereo < 0)
{
ALOGE("hwc_get_handle_alreadyStereo fail");
displayStereo = 0;
}
#else
alreadyStereo = sf_layer->alreadyStereo;
displayStereo = sf_layer->displayStereo;
#endif
if(j>iLastFps && alreadyStereo!= FPS_3D && displayStereo)
{
bHasFPS_3D_UI = true;
}
}
#endif
layer_content.layers.emplace_back();
DrmHwcLayer &layer = layer_content.layers.back();
ret = layer.InitFromHwcLayer(ctx, i, sf_layer, ctx->importer.get(), ctx->gralloc, false);
if (ret) {
ALOGE("Failed to init composition from layer %d", ret);
return ret;
}
layer.index = j;
index = j;
std::ostringstream out;
layer.dump_drm_layer(j,&out);
ALOGD_IF(log_level(DBG_DEBUG),"%s",out.str().c_str());
}
#if RK_3D_VIDEO
if(bHasFPS_3D_UI)
{
hwc_layer_1_t *sf_layer = &display_contents[i]->hwLayers[num_layers-1];
if(sf_layer->handle == NULL)
continue;
layer_content.layers.emplace_back();
DrmHwcLayer &layer = layer_content.layers.back();
ret = layer.InitFromHwcLayer(ctx, i, sf_layer, ctx->importer.get(), ctx->gralloc, true);
if (ret) {
ALOGE("Failed to init composition from layer %d", ret);
return ret;
}
index++;
layer.index = index;
std::ostringstream out;
layer.dump_drm_layer(index,&out);
ALOGD_IF(log_level(DBG_DEBUG),"clone layer: %s",out.str().c_str());
}
#endif
//vop limit: If vop cann't support alpha scale,it should go into gles.
if(!crtc->get_alpha_scale())
{
for (size_t j = 0; j < layer_content.layers.size(); j++) {
DrmHwcLayer& layer = layer_content.layers[j];
if(layer.format == HAL_PIXEL_FORMAT_RGBA_8888 || layer.format == HAL_PIXEL_FORMAT_BGRA_8888)
{
if(layer.h_scale_mul != 1.0 || layer.v_scale_mul != 1.0)
{
use_framebuffer_target = true;
ALOGD_IF(log_level(DBG_DEBUG),"alpha scale is not support,format=0x%x,h_scale=%f,v_scale=%f,go to GPU GLES at line=%d",
layer.format, layer.h_scale_mul, layer.v_scale_mul, __LINE__);
break;
}
if(layer.alpha != 0xff)
{
use_framebuffer_target = true;
ALOGD_IF(log_level(DBG_DEBUG),"per-pixel alpha with global alpha is not support,global alpha=0x%x,go to GPU GLES at line=%d",
layer.alpha, __LINE__);
break;
}
}
}
}
if(!use_framebuffer_target)
{
int iRgaCnt = 0;
for (size_t j = 0; j < layer_content.layers.size(); j++) {
DrmHwcLayer& layer = layer_content.layers[j];
if(layer.mlayer->compositionType == HWC_FRAMEBUFFER_TARGET)
continue;
#if !RK_RGA_SCALE_AND_ROTATE
if(layer.h_scale_mul > 1.0 && (int)(layer.display_frame.right - layer.display_frame.left) > 2560)
{
ALOGD_IF(log_level(DBG_DEBUG),"On rk3368 don't use rga for scale, go to GPU GLES at line=%d", __LINE__);
use_framebuffer_target = true;
break;
}
#endif
if(layer.transform!=DrmHwcTransform::kRotate0
#if RK_RGA_SCALE_AND_ROTATE
|| (layer.h_scale_mul > 1.0 && (int)(layer.display_frame.right - layer.display_frame.left) > 2560)
#endif
)
{
iRgaCnt++;
}
}
if(iRgaCnt > 1)
{
ALOGD_IF(log_level(DBG_DEBUG),"rga cnt = %d, go to GPU GLES at line=%d", iRgaCnt, __LINE__);
use_framebuffer_target = true;
}
}
if(!use_framebuffer_target)
{
bool bAllMatch = false;
hd->mixMode = HWC_DEFAULT;
if(crtc && layer_content.layers.size()>0)
{
bAllMatch = mix_policy(&ctx->drm, crtc, &ctx->displays[connector->display()],layer_content.layers,
hd->iPlaneSize, fbSize, comp_plane.composition_planes);
}
if(!bAllMatch)
{
ALOGD_IF(log_level(DBG_DEBUG),"mix_policy failed,go to GPU GLES at line=%d", __LINE__);
use_framebuffer_target = true;
}
}
for (int j = 0; j < num_layers; ++j) {
hwc_layer_1_t *layer = &display_contents[i]->hwLayers[j];
if (!use_framebuffer_target && layer->compositionType != HWC_MIX) {
// If the layer is off the screen, don't earmark it for an overlay.
// We'll leave it as-is, which effectively just drops it from the frame
const hwc_rect_t *frame = &layer->displayFrame;
if ((frame->right - frame->left) <= 0 ||
(frame->bottom - frame->top) <= 0 ||
frame->right <= 0 || frame->bottom <= 0 ||
frame->left >= (int)hd->framebuffer_width ||
frame->top >= (int)hd->framebuffer_height)
{
continue;
}
if (layer->compositionType == HWC_FRAMEBUFFER)
layer->compositionType = HWC_OVERLAY;
} else {
switch (layer->compositionType) {
case HWC_MIX:
case HWC_OVERLAY:
case HWC_BACKGROUND:
case HWC_SIDEBAND:
case HWC_CURSOR_OVERLAY:
layer->compositionType = HWC_FRAMEBUFFER;
break;
}
}
#if DUAL_VIEW_MODE
if(hd->bDualViewMode && i == HWC_DISPLAY_EXTERNAL && layer->compositionType != HWC_FRAMEBUFFER_TARGET)
{
layer->compositionType = HWC_NODRAW;
}
#endif
}
#if RK_RGA_PREPARE_ASYNC
if(!use_framebuffer_target && ctx->drm.isSupportRkRga())
{
bool bUseRga = false;
for (size_t j = 0; j < layer_content.layers.size(); j++) {
DrmHwcLayer& layer = layer_content.layers[j];
if((layer.is_yuv && layer.transform!=DrmHwcTransform::kRotate0))
{
ret = ApplyPreRotate(hd,layer);
if (ret)
{
freeRgaBuffers(hd);
hd->mUseRga = hd->mUseRga ? false : hd->mUseRga;
return ret;
}
hd->rgaBuffer_index = (hd->rgaBuffer_index + 1) % MaxRgaBuffers;
bUseRga = true;
hd->mUseRga = hd->mUseRga ? hd->mUseRga : true;
}
}
if(hd->mUseRga && !bUseRga)
{
freeRgaBuffers(hd);
hd->mUseRga = false;
}
}
#endif
if(use_framebuffer_target)
ctx->isGLESComp = true;
else
ctx->isGLESComp = false;
if(ctx->isGLESComp)
{
#if RK_ROTATE_VIDEO_MODE
if(hd->bRotateVideoMode)
{
ALOGD_IF(log_level(DBG_DEBUG), "Exit Rotate video Mode mode");
set_cpu_min_freq(hd->original_min_freq);
hd->bRotateVideoMode = false;
}
#endif
//remove all layers except fb layer
for (auto k = layer_content.layers.begin(); k != layer_content.layers.end();)
{
//remove gles layers
if((*k).mlayer->compositionType != HWC_FRAMEBUFFER_TARGET)
k = layer_content.layers.erase(k);
else
k++;
}
//match plane for gles composer.
bool bAllMatch = match_process(&ctx->drm, crtc, hd->is_interlaced ,layer_content.layers,
hd->iPlaneSize, fbSize, comp_plane.composition_planes);
if(!bAllMatch)
ALOGE("Fetal error when match plane for fb layer");
}
else
{
#if RK_ROTATE_VIDEO_MODE
if(hd->transform_nv12==1 && !hd->bRotateVideoMode)
{
ALOGD_IF(log_level(DBG_DEBUG), "Enter Rotate video Mode mode");
hd->original_min_freq = set_cpu_min_freq(408);
hd->bRotateVideoMode = true;
}
else if(hd->transform_nv12!=1 && hd->bRotateVideoMode)
{
ALOGD_IF(log_level(DBG_DEBUG), "Exit Rotate video Mode mode");
set_cpu_min_freq(hd->original_min_freq);
hd->bRotateVideoMode = false;
}
#endif
}
for (int j = 0; j < num_layers; ++j) {
hwc_layer_1_t *layer = &display_contents[i]->hwLayers[j];
char layername[100];
#if RK_PRINT_LAYER_NAME
#ifdef USE_HWC2
if(layer->handle == NULL)
{
strcpy(layername,"");
}
else
{
HWC_GET_HANDLE_LAYERNAME(ctx->gralloc,layer,layer->handle, layername, 100);
}
#else
strcpy(layername, layer->LayerName);
#endif
#endif
if(layer->compositionType==HWC_FRAMEBUFFER)
ALOGD_IF(log_level(DBG_DEBUG),"%s: HWC_FRAMEBUFFER",layername);
else if(layer->compositionType==HWC_OVERLAY)
ALOGD_IF(log_level(DBG_DEBUG),"%s: HWC_OVERLAY",layername);
else
ALOGD_IF(log_level(DBG_DEBUG),"%s: HWC_OTHER",layername);
}
}
#if RK_INVALID_REFRESH
if(ctx->mOneWinOpt)
ctx->mOneWinOpt = false;
#endif
return 0;
}
static void hwc_add_layer_to_retire_fence(
hwc_layer_1_t *layer, hwc_display_contents_1_t *display_contents) {
if (layer->releaseFenceFd < 0)
return;
if (display_contents->retireFenceFd >= 0) {
int old_retire_fence = display_contents->retireFenceFd;
display_contents->retireFenceFd =
sync_merge("dc_retire", old_retire_fence, layer->releaseFenceFd);
close(old_retire_fence);
} else {
display_contents->retireFenceFd = dup(layer->releaseFenceFd);
}
}
/* rk:
* acquireFenceFd may transfer from hwc_layer_1_t to DrmHwcLayer.
* So we signal acquire_fence of DrmHwcLayer at first.
* Then we try to signal acquireFenceFd of hwc_layer_1_t.
*/
void signal_all_fence(DrmHwcDisplayContents &display_contents,hwc_display_contents_1_t *dc)
{
for (size_t j=0; j< display_contents.layers.size(); j++) {
DrmHwcLayer &layer = display_contents.layers[j];
int acquire_fence = layer.acquire_fence.get();
if(acquire_fence >= 0)
{
int ret = sync_wait(acquire_fence, 1000);
if (ret) {
ALOGE("signal_all_fence Failed to wait for acquire %d/%d 1000ms", acquire_fence, ret);
continue;
}
layer.acquire_fence.Close();
}
}
hwc_sync_release(dc);
}
static int hwc_set(hwc_composer_device_1_t *dev, size_t num_displays,
hwc_display_contents_1_t **sf_display_contents) {
ATRACE_CALL();
#ifdef USE_HWC2
g_waitHwcSetHotplug = true;
#endif
struct hwc_context_t *ctx = (struct hwc_context_t *)&dev->common;
int ret = 0;
inc_frame();
std::vector<CheckedOutputFd> checked_output_fences;
std::vector<DrmHwcDisplayContents> displays_contents;
std::vector<DrmCompositionDisplayLayersMap> layers_map;
std::vector<std::vector<size_t>> layers_indices;
std::vector<uint32_t> fail_displays;
DrmComposition* composition = NULL;
// layers_map.reserve(num_displays);
layers_indices.reserve(num_displays);
// Phase one does nothing that would cause errors. Only take ownership of FDs.
for (size_t i = 0; i < num_displays; ++i) {
hwc_display_contents_1_t *dc = sf_display_contents[i];
DrmHwcDisplayContents &display_contents = ctx->layer_contents[i];
displays_contents.emplace_back();
DrmHwcDisplayContents &display_contents_tmp = displays_contents.back();
layers_indices.emplace_back();
if (!sf_display_contents[i])
continue;
#if SKIP_BOOT
if(g_boot_cnt < BOOT_COUNT) {
hwc_sync_release(sf_display_contents[i]);
if(0 == i)
g_boot_cnt++;
ALOGD_IF(log_level(DBG_DEBUG),"set skip %d",g_boot_cnt);
return 0;
}
#endif
if (i == HWC_DISPLAY_VIRTUAL) {
ctx->virtual_compositor_worker.QueueComposite(dc);
continue;
}
if(ctx->fb_blanked == FB_BLANK_POWERDOWN){
ALOGD_IF(log_level(DBG_DEBUG),"%s: display=%zu fb_blanked = %s,line = %d",__FUNCTION__,i,
ctx->fb_blanked == FB_BLANK_POWERDOWN ? "POWERDOWN" : "ACTIVE",__LINE__);
hwc_sync_release(sf_display_contents[i]);
ctx->drm.ClearDisplay(i);
continue;
}
DrmConnector *c = ctx->drm.GetConnectorFromType(i);
size_t num_dc_layers = dc->numHwLayers;
if (!c || c->state() != DRM_MODE_CONNECTED || num_dc_layers==1) {
if(c)
ALOGD_IF(log_level(DBG_DEBUG),"hwc_set connector is disconnect,type=%s",ctx->drm.connector_type_str(c->get_type()));
if(num_dc_layers==1)
ALOGD_IF(log_level(DBG_DEBUG), "%s display=%zu layer is null", __FUNCTION__, i);
hwc_sync_release(sf_display_contents[i]);
ctx->drm.ClearDisplay(i);
continue;
}
DumpLayerList(dc,ctx->gralloc);
std::ostringstream display_index_formatter;
display_index_formatter << "retire fence for display " << i;
std::string display_fence_description(display_index_formatter.str());
checked_output_fences.emplace_back(&dc->retireFenceFd,
display_fence_description.c_str(),
ctx->dummy_timeline);
display_contents.retire_fence = OutputFd(&dc->retireFenceFd);
int framebuffer_target_index = -1;
for (size_t j = 0; j < num_dc_layers; ++j) {
hwc_layer_1_t *sf_layer = &dc->hwLayers[j];
if (sf_layer->compositionType == HWC_FRAMEBUFFER_TARGET) {
framebuffer_target_index = j;
break;
}
}
for (size_t j = 0; j < num_dc_layers; ++j) {
size_t k = 0;
hwc_layer_1_t *sf_layer = &dc->hwLayers[j];
// In prepare() we marked all layers FRAMEBUFFER between SKIP_LAYER's.
// This means we should insert the FB_TARGET layer in the composition
// stack at the location of the first skip layer, and ignore the rest.
if (sf_layer->flags & HWC_SKIP_LAYER) {
//rk: SurfaceFlinger will create acquireFenceFd for nodraw skip layer.
// Close it here to avoid anon_inode:sync_fence fd leak.
if(sf_layer->compositionType == HWC_NODRAW)
{
if(sf_layer->acquireFenceFd >= 0)
{
close(sf_layer->acquireFenceFd);
sf_layer->acquireFenceFd = -1;
}
}
if (framebuffer_target_index < 0)
continue;
int idx = framebuffer_target_index;
framebuffer_target_index = -1;
hwc_layer_1_t *fbt_layer = &dc->hwLayers[idx];
if (!fbt_layer->handle || (fbt_layer->flags & HWC_SKIP_LAYER)) {
ALOGE("Invalid HWC_FRAMEBUFFER_TARGET with HWC_SKIP_LAYER present");
continue;
}
continue;
}
char value[PROPERTY_VALUE_MAX];
property_get( PROPERTY_TYPE ".hwc.force_wait_acquireFence", value, "0");
if(atoi(value) != 0){
// rk: wait acquireFenceFd at hwc_set.
if(sf_layer->acquireFenceFd > 0)
{
sync_wait(sf_layer->acquireFenceFd, -1);
close(sf_layer->acquireFenceFd);
sf_layer->acquireFenceFd = -1;
}
}
for (k = 0; k < display_contents.layers.size(); ++k)
{
DrmHwcLayer &layer = display_contents.layers[k];
if(j == layer.index)
{
// sf_layer = layer.raw_sf_layer;
layer.acquire_fence.Set(sf_layer->acquireFenceFd);
sf_layer->acquireFenceFd = -1;
std::ostringstream layer_fence_formatter;
layer_fence_formatter << "release fence for layer " << j << " of display "
<< i;
std::string layer_fence_description(layer_fence_formatter.str());
checked_output_fences.emplace_back(&sf_layer->releaseFenceFd,
layer_fence_description.c_str(),
ctx->dummy_timeline);
layer.release_fence = OutputFd(&sf_layer->releaseFenceFd);
break;
}
}
if(k == display_contents.layers.size())
{
display_contents_tmp.layers.emplace_back();
DrmHwcLayer &layer = display_contents_tmp.layers.back();
layer.acquire_fence.Set(sf_layer->acquireFenceFd);
sf_layer->acquireFenceFd = -1;
std::ostringstream layer_fence_formatter;
layer_fence_formatter << "release fence for layer " << j << " of display "
<< i;
std::string layer_fence_description(layer_fence_formatter.str());
checked_output_fences.emplace_back(&sf_layer->releaseFenceFd,
layer_fence_description.c_str(),
ctx->dummy_timeline);
layer.release_fence = OutputFd(&sf_layer->releaseFenceFd);
}
}
if(display_contents.layers.size() == 0 && framebuffer_target_index >= 0)
{
hwc_layer_1_t *sf_layer = &dc->hwLayers[framebuffer_target_index];
if (!sf_layer->handle || (sf_layer->flags & HWC_SKIP_LAYER)) {
ALOGE(
"Expected valid layer with HWC_FRAMEBUFFER_TARGET when all "
"HWC_OVERLAY layers are skipped.");
fail_displays.emplace_back(i);
ret = -EINVAL;
}
}
}
#if 0
if (ret)
return ret;
#endif
int fail_displays_count = 0;
for (size_t i = 0; i < num_displays; ++i) {
hwc_display_contents_1_t *dc = sf_display_contents[i];
DrmHwcDisplayContents &display_contents = ctx->layer_contents[i];
bool bFindDisplay = false;
if (!sf_display_contents[i] || i == HWC_DISPLAY_VIRTUAL)
continue;
for (auto &fail_display : fail_displays) {
if( i == fail_display )
{
bFindDisplay = true;
fail_displays_count ++;
ALOGD_IF(log_level(DBG_VERBOSE),"%s:line=%d,Find fail display %zu",__FUNCTION__,__LINE__,i);
break;
}
}
if(bFindDisplay)
continue;
size_t num_dc_layers = dc->numHwLayers;
DrmConnector *c = ctx->drm.GetConnectorFromType(i);
if (!c || c->state() != DRM_MODE_CONNECTED || num_dc_layers==1) {
ALOGD_IF(log_level(DBG_VERBOSE),
"%s,display %zu Connector is NULL or disconnect ,layer_list is NULL",__FUNCTION__,i);
continue;
}
/*
* DUAL_VIEW_MODE
* Primary layers -> Primary Device
* |
* -> Extend Device
*/
#if DUAL_VIEW_MODE
static int primaryAcquirFenceDup = -1;
hwc_drm_display_t *hd = &ctx->displays[c->display()];
if(hd->bDualViewMode){
DrmHwcDisplayContents &display_contents_pri = ctx->layer_contents[0];
layers_map.emplace_back();
DrmCompositionDisplayLayersMap &map = layers_map.back();
map.display = i;
map.geometry_changed =
(dc->flags & HWC_GEOMETRY_CHANGED) == HWC_GEOMETRY_CHANGED;
for (size_t j=0; j< display_contents.layers.size(); j++) {
DrmHwcLayer &layer = display_contents.layers[j];
DrmHwcLayer &layer_pri = display_contents_pri.layers[j];
//Dup primary acquireFence to extend, should wait acquireFence before commmit.
if( i == HWC_DISPLAY_PRIMARY ){
if( primaryAcquirFenceDup > 0){
close(primaryAcquirFenceDup);
primaryAcquirFenceDup = -1;
}
if(layer_pri.acquire_fence.get() > 0){
primaryAcquirFenceDup = dup(layer_pri.acquire_fence.get());
}
}else if( i == HWC_DISPLAY_EXTERNAL ){
if(primaryAcquirFenceDup > 0){
layer.acquire_fence.Set(primaryAcquirFenceDup);
primaryAcquirFenceDup = -1;
}
}
if(!layer_pri.sf_handle && layer_pri.raw_sf_layer->handle)
{
layer_pri.sf_handle = layer_pri.raw_sf_layer->handle;
#if (!RK_PER_MODE && RK_DRM_GRALLOC)
layer.width = hwc_get_handle_attibute(ctx->gralloc,layer_pri.sf_handle,ATT_WIDTH);
layer.height = hwc_get_handle_attibute(ctx->gralloc,layer_pri.sf_handle,ATT_HEIGHT);
layer.stride = hwc_get_handle_attibute(ctx->gralloc,layer_pri.sf_handle,ATT_STRIDE);
layer.format = hwc_get_handle_attibute(ctx->gralloc,layer_pri.sf_handle,ATT_FORMAT);
#else
layer.width = hwc_get_handle_width(ctx->gralloc,layer_pri.sf_handle);
layer.height = hwc_get_handle_height(ctx->gralloc,layer_pri.sf_handle);
layer.stride = hwc_get_handle_stride(ctx->gralloc,layer_pri.sf_handle);
layer.format = hwc_get_handle_format(ctx->gralloc,layer_pri.sf_handle);
#endif
}
if(!layer_pri.sf_handle)
{
ALOGE("%s: disply=%zu sf_handle is null,maybe fb target is null",__FUNCTION__,i);
signal_all_fence(display_contents, dc);
ctx->drm.ClearDisplay(i);
std::vector<DrmCompositionDisplayLayersMap>::iterator iter = layers_map.begin()+i - fail_displays_count;
layers_map.erase(iter);
break;
}
if(!layer_pri.bClone_)
{
#if RK_RGA_PREPARE_ASYNC
if(!layer_pri.is_rotate_by_rga)
#endif
layer.ImportBuffer(ctx, layer_pri.raw_sf_layer, ctx->importer.get());
#if RK_RGA_PREPARE_ASYNC
else
{
ret = layer.buffer.ImportBuffer(layer_pri.rga_handle,
ctx->importer.get()
#if RK_VIDEO_SKIP_LINE
, layer_pri.SkipLine
#endif
);
if (ret) {
ALOGE("Failed to import rga buffer ret=%d", ret);
goto err;
}
ret = layer_pri.handle.CopyBufferHandle(layer_pri.rga_handle, ctx->gralloc);
if (ret) {
ALOGE("Failed to copy rga handle ret=%d", ret);
goto err;
}
}
#endif
}
map.layers.emplace_back(std::move(layer));
}
}else
#endif //DUAL_VIEW_MODE
{
layers_map.emplace_back();
DrmCompositionDisplayLayersMap &map = layers_map.back();
map.display = i;
map.geometry_changed =
(dc->flags & HWC_GEOMETRY_CHANGED) == HWC_GEOMETRY_CHANGED;
for (size_t j=0; j< display_contents.layers.size(); j++) {
DrmHwcLayer &layer = display_contents.layers[j];
if(!layer.sf_handle && layer.raw_sf_layer && layer.raw_sf_layer->handle)
{
layer.sf_handle = layer.raw_sf_layer->handle;
#if (!RK_PER_MODE && RK_DRM_GRALLOC)
layer.width = hwc_get_handle_attibute(ctx->gralloc,layer.sf_handle,ATT_WIDTH);
layer.height = hwc_get_handle_attibute(ctx->gralloc,layer.sf_handle,ATT_HEIGHT);
layer.stride = hwc_get_handle_attibute(ctx->gralloc,layer.sf_handle,ATT_STRIDE);
layer.format = hwc_get_handle_attibute(ctx->gralloc,layer.sf_handle,ATT_FORMAT);
#else
layer.width = hwc_get_handle_width(ctx->gralloc,layer.sf_handle);
layer.height = hwc_get_handle_height(ctx->gralloc,layer.sf_handle);
layer.stride = hwc_get_handle_stride(ctx->gralloc,layer.sf_handle);
layer.format = hwc_get_handle_format(ctx->gralloc,layer.sf_handle);
#endif
}
if(!layer.sf_handle)
{
ALOGE("%s: disply=%zu sf_handle is null,maybe fb target is null",__FUNCTION__,i);
signal_all_fence(display_contents, dc);
ctx->drm.ClearDisplay(i);
std::vector<DrmCompositionDisplayLayersMap>::iterator iter = layers_map.begin()+i - fail_displays_count;
layers_map.erase(iter);
break;
}
if(!layer.raw_sf_layer)
{
ALOGE("%s: disply=%zu raw_sf_handle is null, hw_layer init error",__FUNCTION__,i);
signal_all_fence(display_contents, dc);
ctx->drm.ClearDisplay(i);
std::vector<DrmCompositionDisplayLayersMap>::iterator iter = layers_map.begin()+i - fail_displays_count;
layers_map.erase(iter);
break;
}
if(!layer.bClone_)
{
#if RK_RGA_PREPARE_ASYNC
if(!layer.is_rotate_by_rga)
#endif
layer.ImportBuffer(ctx, layer.raw_sf_layer, ctx->importer.get());
#if RK_RGA_PREPARE_ASYNC
else
{
ret = layer.buffer.ImportBuffer(layer.rga_handle,
ctx->importer.get()
#if RK_VIDEO_SKIP_LINE
, layer.SkipLine
#endif
);
if (ret) {
ALOGE("Failed to import rga buffer ret=%d", ret);
goto err;
}
ret = layer.handle.CopyBufferHandle(layer.rga_handle, ctx->gralloc);
if (ret) {
ALOGE("Failed to copy rga handle ret=%d", ret);
goto err;
}
}
#endif
}
map.layers.emplace_back(std::move(layer));
}
}
}
if(layers_map.size() == 0)
{
ALOGD("%s: layers_map size is 0",__FUNCTION__);
goto err;
}
ctx->drm.UpdateDisplayRoute();
ctx->drm.UpdatePropertys();
ctx->drm.ClearDisplay();
composition = ctx->drm.compositor()->CreateComposition(ctx->importer.get(), get_frame());
if (!composition) {
ALOGE("%s: Drm composition init failed",__FUNCTION__);
goto err;
}
ret = composition->SetLayers(layers_map.size(), layers_map.data());
if (ret) {
ALOGD("%s: SetLayers fail",__FUNCTION__);
goto err;
}
for (size_t i = 0; i < num_displays; ++i) {
if (!sf_display_contents[i] || i == HWC_DISPLAY_VIRTUAL)
continue;
DrmConnector *c = ctx->drm.GetConnectorFromType(i);
if (!c || c->state() != DRM_MODE_CONNECTED) {
continue;
}
hwc_drm_display_t *hd = &ctx->displays[c->display()];
composition->SetMode3D(i, hd->stereo_mode);
}
for (size_t i = 0; i < ctx->comp_plane_group.size(); ++i) {
if(ctx->comp_plane_group[i].composition_planes.size() > 0)
{
ret = composition->SetCompPlanes(ctx->comp_plane_group[i].display, ctx->comp_plane_group[i].composition_planes);
if (ret) {
ALOGE("%s: SetCompPlanes fail",__FUNCTION__);
goto err;
}
}
else
{
DrmHwcDisplayContents &display_contents = ctx->layer_contents[i];
if (sf_display_contents[i])
{
signal_all_fence(display_contents, sf_display_contents[i]);
ctx->drm.ClearDisplay(i);
}
}
}
/* rk:
* we use loop to call QueueComposition to avoid the release fence leak.
* Before:
* QueueComposition
* DrmComposition::Plan
* DrmDisplayComposition::Plan[0]---> return ok,it will create release fences for display 0
* DrmDisplayComposition::Plan[1]---> return err
* return err to DrmComposition::Plan,then return err to QueueComposition,
* it has no change to call DrmDisplayCompositor::QueueComposition(push composition in composite Queue.)
* So even you call ClearDisplay,the release fences of display 0 still cann't be signal.
* There are two workrounds:
* 1. You can call SignalCompositionDone or DrmDisplayComposition.reset(NULL) for display 0 before return to QueueComposition.
* Tip: DrmDisplayComposition.reset(NULL) will call SignalCompositionDone in ~DrmDisplayComposition.
* 2. Use loop to separate the success and the error processing.(<----current workround.)
*
*/
for (size_t i = 0; i < HWC_NUM_PHYSICAL_DISPLAY_TYPES; ++i) {
if (!sf_display_contents[i])
continue;
ret = ctx->drm.compositor()->QueueComposition(composition, i);
if (ret) {
ALOGE("%s: QueueComposition fail for display=%zu",__FUNCTION__,i);
DrmHwcDisplayContents &display_contents = ctx->layer_contents[i];
signal_all_fence(display_contents, sf_display_contents[i]);
ctx->drm.ClearDisplay(i);
}
}
for (size_t i = 0; i < num_displays; ++i) {
hwc_display_contents_1_t *dc = sf_display_contents[i];
bool bFindDisplay = false;
if (!dc || i == HWC_DISPLAY_VIRTUAL)
continue;
DrmConnector *c = ctx->drm.GetConnectorFromType(i);
if (!c || c->state() != DRM_MODE_CONNECTED) {
DrmHwcDisplayContents &display_contents = ctx->layer_contents[i];
signal_all_fence(display_contents, sf_display_contents[i]);
ctx->drm.ClearDisplay(i);
continue;
}
hwc_drm_display_t *hd = &ctx->displays[c->display()];
for (auto &fail_display : fail_displays) {
if( i == fail_display )
{
bFindDisplay = true;
ALOGD_IF(log_level(DBG_DEBUG),"%s:line=%d,Find fail display %zu",__FUNCTION__,__LINE__,i);
break;
}
}
if(bFindDisplay)
continue;
size_t num_dc_layers = dc->numHwLayers;
for (size_t j = 0; j < num_dc_layers; ++j) {
hwc_layer_1_t *layer = &dc->hwLayers[j];
if (layer->flags & HWC_SKIP_LAYER)
continue;
hwc_add_layer_to_retire_fence(layer, dc);
}
}
delete composition;
composition = NULL;
#if RK_INVALID_REFRESH
hwc_static_screen_opt_set(ctx->isGLESComp);
#endif
ALOGD_IF(log_level(DBG_VERBOSE),"----------------------------frame=%d end----------------------------",get_frame());
return ret;
err:
ALOGE("%s: not normal frame happen",__FUNCTION__);
for (size_t i = 0; i < num_displays; ++i) {
hwc_display_contents_1_t *dc = sf_display_contents[i];
if (!dc || i == HWC_DISPLAY_VIRTUAL)
continue;
int num_layers = dc->numHwLayers;
for (int j = 0; j < num_layers; j++) {
hwc_layer_1_t *layer = &dc->hwLayers[j];
dump_layer(ctx->gralloc, true, layer, j);
}
DrmHwcDisplayContents &display_contents = ctx->layer_contents[i];
signal_all_fence(display_contents, sf_display_contents[i]);
}
if(NULL != composition)
{
delete composition;
composition = NULL;
}
ctx->drm.ClearAllDisplay();
return -EINVAL;
}
static int hwc_event_control(struct hwc_composer_device_1 *dev, int display,
int event, int enabled) {
if (event != HWC_EVENT_VSYNC || (enabled != 0 && enabled != 1))
return -EINVAL;
struct hwc_context_t *ctx = (struct hwc_context_t *)&dev->common;
if (display == HWC_DISPLAY_PRIMARY)
return ctx->primary_vsync_worker.VSyncControl(enabled);
else if (display == HWC_DISPLAY_EXTERNAL)
return ctx->extend_vsync_worker.VSyncControl(enabled);
ALOGE("Can't support vsync control for display %d\n", display);
return -EINVAL;
}
static int hwc_set_power_mode(struct hwc_composer_device_1 *dev, int display,
int mode) {
struct hwc_context_t *ctx = (struct hwc_context_t *)&dev->common;
uint64_t dpmsValue = 0;
switch (mode) {
case HWC_POWER_MODE_OFF:
dpmsValue = DRM_MODE_DPMS_OFF;
break;
/* We can't support dozing right now, so go full on */
case HWC_POWER_MODE_DOZE:
case HWC_POWER_MODE_DOZE_SUSPEND:
case HWC_POWER_MODE_NORMAL:
dpmsValue = DRM_MODE_DPMS_ON;
break;
};
int fb_blank = 0;
if(dpmsValue == DRM_MODE_DPMS_OFF)
fb_blank = FB_BLANK_POWERDOWN;
else if(dpmsValue == DRM_MODE_DPMS_ON)
fb_blank = FB_BLANK_UNBLANK;
else
ALOGE("dpmsValue is invalid value= %" PRIu64 "",dpmsValue);
if(fb_blank != ctx->fb_blanked && ctx->fb_fd > 0){
int err = ioctl(ctx->fb_fd, FBIOBLANK, fb_blank);
ALOGD_IF(log_level(DBG_DEBUG),"%s Notice fb_blank to fb=%d", __FUNCTION__, fb_blank);
if (err < 0) {
if (errno == EBUSY)
ALOGD("fb_blank ioctl failed display=%d,fb_blank=%d,dpmsValue=%" PRIu64 "",
display,fb_blank,dpmsValue);
else
ALOGE("fb_blank ioctl failed(%s) display=%d,fb_blank=%d,dpmsValue=%" PRIu64 "",
strerror(errno),display,fb_blank,dpmsValue);
return -errno;
}
}
ctx->fb_blanked = fb_blank;
DrmConnector *connector = ctx->drm.GetConnectorFromType(display);
if (!connector) {
ALOGE("%s:Failed to get connector for display %d line=%d", __FUNCTION__,display,__LINE__);
return -ENODEV;
}
//In tv mode, we still need update the hdmi force_disconnect.
//Pg: sleep(force_disconnect will be true) ==> plug out HDMI(switch to tv mode) ==> wake up ==> plug in HDMI(force_disconnect still be true)
//Workround: ==> update HDMI's force_disconnect
if(connector->get_type() == DRM_MODE_CONNECTOR_TV)
{
for (auto &conn : ctx->drm.connectors())
{
if(conn->get_type() == DRM_MODE_CONNECTOR_HDMIA)
{
conn->force_disconnect(dpmsValue == DRM_MODE_DPMS_OFF);
break;
}
}
}
connector->force_disconnect(dpmsValue == DRM_MODE_DPMS_OFF);
//If process of device boot have two connector's status is connected,
//the first setPowerMode will to set drmMode-id for every connector
//in order to avoid some initialization problems.
for (int i = 0; i < HWC_NUM_PHYSICAL_DISPLAY_TYPES; i++) {
DrmConnector *conn = ctx->drm.GetConnectorFromType(i);
if (!conn || conn->state() != DRM_MODE_CONNECTED)
continue;
hwc_drm_display_t *hd = &ctx->displays[conn->display()];
update_display_bestmode(hd, i, conn);
DrmMode drmmode = conn->best_mode();
conn->set_current_mode(drmmode);
}
ctx->drm.DisplayChanged();
ctx->drm.UpdateDisplayRoute();
ctx->drm.ClearDisplay();
return 0;
}
static int hwc_query(struct hwc_composer_device_1 * /* dev */, int what,
int *value) {
switch (what) {
case HWC_BACKGROUND_LAYER_SUPPORTED:
*value = 0; /* TODO: We should do this */
break;
case HWC_VSYNC_PERIOD:
ALOGW("Query for deprecated vsync value, returning 60Hz");
*value = 1000 * 1000 * 1000 / 60;
break;
case HWC_DISPLAY_TYPES_SUPPORTED:
*value = HWC_DISPLAY_PRIMARY_BIT | HWC_DISPLAY_EXTERNAL_BIT |
HWC_DISPLAY_VIRTUAL_BIT;
break;
}
return 0;
}
static void hwc_register_procs(struct hwc_composer_device_1 *dev,
hwc_procs_t const *procs) {
struct hwc_context_t *ctx = (struct hwc_context_t *)&dev->common;
ctx->procs = procs;
ctx->primary_vsync_worker.SetProcs(procs);
ctx->extend_vsync_worker.SetProcs(procs);
ctx->hotplug_handler.Init(&ctx->displays, &ctx->drm, procs);
ctx->drm.event_listener()->RegisterHotplugHandler(&ctx->hotplug_handler);
}
static int hwc_get_display_configs(struct hwc_composer_device_1 *dev,
int display, uint32_t *configs,
size_t *num_configs) {
if (!num_configs)
return 0;
struct hwc_context_t *ctx = (struct hwc_context_t *)&dev->common;
DrmConnector *connector = ctx->drm.GetConnectorFromType(display);
if (!connector) {
ALOGE("%s:Failed to get connector for display %d line=%d", __FUNCTION__,display,__LINE__);
return -ENODEV;
}
hwc_drm_display_t *hd = &ctx->displays[connector->display()];
if (!hd->active)
return -ENODEV;
int ret = connector->UpdateModes();
if (ret) {
ALOGE("Failed to update display modes %d", ret);
return ret;
}
if (connector->state() != DRM_MODE_CONNECTED && display == HWC_DISPLAY_EXTERNAL) {
ALOGE("connector is not connected with display %d", display);
return -ENODEV;
}
update_display_bestmode(hd, display, connector);
DrmMode mode = connector->best_mode();
connector->set_current_mode(mode);
char framebuffer_size[PROPERTY_VALUE_MAX];
uint32_t width = 0, height = 0 , vrefresh = 0 ;
if (display == HWC_DISPLAY_PRIMARY)
property_get("persist." PROPERTY_TYPE ".framebuffer.main", framebuffer_size, "use_baseparameter");
else if(display == HWC_DISPLAY_EXTERNAL)
property_get("persist." PROPERTY_TYPE ".framebuffer.aux", framebuffer_size, "use_baseparameter");
/*
* if unset framebuffer_size, get it from baseparameter , by libin
*/
if(hwc_have_baseparameter() && !strcmp(framebuffer_size,"use_baseparameter")){
int res = 0;
res = hwc_get_baseparameter_config(framebuffer_size,display,BP_FB_SIZE,0);
if(res)
ALOGW("BP: hwc get baseparameter config err ,res = %d",res);
}
sscanf(framebuffer_size, "%dx%d@%d", &width, &height, &vrefresh);
if (width && height) {
hd->framebuffer_width = width;
hd->framebuffer_height = height;
hd->vrefresh = vrefresh ? vrefresh : 60;
} else if (mode.h_display() && mode.v_display() && mode.v_refresh()) {
hd->framebuffer_width = mode.h_display();
hd->framebuffer_height = mode.v_display();
hd->vrefresh = mode.v_refresh();
/*
* Limit to 1080p if large than 2160p
*/
if (hd->framebuffer_height >= 2160 && hd->framebuffer_width >= hd->framebuffer_height) {
hd->framebuffer_width = hd->framebuffer_width * (1080.0 / hd->framebuffer_height);
hd->framebuffer_height = 1080;
}
} else {
hd->framebuffer_width = 1920;
hd->framebuffer_height = 1080;
hd->vrefresh = 60;
ALOGE("Failed to find available display mode for display %d\n", display);
}
hd->rel_xres = mode.h_display();
hd->rel_yres = mode.v_display();
hd->v_total = mode.v_total();
// AFBDC limit
bool disable_afbdc = false;
if(display == HWC_DISPLAY_PRIMARY){
#ifdef TARGET_BOARD_PLATFORM_RK3399
if(hd->framebuffer_width > 2560 || hd->framebuffer_width % 16 != 0 || hd->framebuffer_height % 8 != 0)
disable_afbdc = true;
#elif TARGET_BOARD_PLATFORM_RK3368
if(hd->framebuffer_width > 2048 || hd->framebuffer_width % 16 != 0 || hd->framebuffer_height % 4 != 0)
disable_afbdc = true;
#elif TARGET_BOARD_PLATFORM_RK3326
if(hd->framebuffer_width > 1920 || hd->framebuffer_width % 16 != 0 || hd->framebuffer_height % 8 != 0)
disable_afbdc = true;
#endif
if(disable_afbdc){
#ifdef USE_GRALLOC_4 // Android 11 use Gralloc 4.0
property_set("vendor.gralloc.no_afbc_for_fb_target_layer", "1");
#else
property_set( PROPERTY_TYPE ".gralloc.disable_afbc", "1");
#endif
ALOGI("%s:line=%d primary framebuffer size %dx%d not support AFBDC, to disable AFBDC\n",
__FUNCTION__, __LINE__, hd->framebuffer_width,hd->framebuffer_height);
}
}
*num_configs = 1;
configs[0] = connector->display();
return 0;
}
static float getDefaultDensity(uint32_t width, uint32_t height) {
// Default density is based on TVs: 1080p displays get XHIGH density,
// lower-resolution displays get TV density. Maybe eventually we'll need
// to update it for 4K displays, though hopefully those just report
// accurate DPI information to begin with. This is also used for virtual
// displays and even primary displays with older hwcomposers, so be
// careful about orientation.
uint32_t h = width < height ? width : height;
if (h >= 1080) return ACONFIGURATION_DENSITY_XHIGH;
else return ACONFIGURATION_DENSITY_TV;
}
static int hwc_get_display_attributes(struct hwc_composer_device_1 *dev,
int display, uint32_t config,
const uint32_t *attributes,
int32_t *values) {
UN_USED(config);
struct hwc_context_t *ctx = (struct hwc_context_t *)&dev->common;
DrmConnector *c = ctx->drm.GetConnectorFromType(display);
if (!c) {
ALOGE("Failed to get DrmConnector for display %d", display);
return -ENODEV;
}
hwc_drm_display_t *hd = &ctx->displays[c->display()];
if (!hd->active)
return -ENODEV;
uint32_t mm_width = c->mm_width();
uint32_t mm_height = c->mm_height();
int w = hd->framebuffer_width;
int h = hd->framebuffer_height;
int vrefresh = hd->vrefresh;
for (int i = 0; attributes[i] != HWC_DISPLAY_NO_ATTRIBUTE; ++i) {
switch (attributes[i]) {
case HWC_DISPLAY_VSYNC_PERIOD:
values[i] = 1000 * 1000 * 1000 / vrefresh;
break;
case HWC_DISPLAY_WIDTH:
values[i] = w;
break;
case HWC_DISPLAY_HEIGHT:
values[i] = h;
break;
case HWC_DISPLAY_DPI_X:
/* Dots per 1000 inches */
values[i] = mm_width ? (w * UM_PER_INCH) / mm_width : getDefaultDensity(w,h)*1000;
break;
case HWC_DISPLAY_DPI_Y:
/* Dots per 1000 inches */
values[i] =
mm_height ? (h * UM_PER_INCH) / mm_height : getDefaultDensity(w,h)*1000;
break;
}
}
return 0;
}
static int hwc_get_active_config(struct hwc_composer_device_1 *dev,
int display) {
UN_USED(dev);
UN_USED(display);
return 0;
}
static int hwc_set_active_config(struct hwc_composer_device_1 *dev, int display,
int index) {
struct hwc_context_t *ctx = (struct hwc_context_t *)&dev->common;
UN_USED(index);
DrmConnector *c = ctx->drm.GetConnectorFromType(display);
if (!c) {
ALOGE("%s:Failed to get connector for display %d line=%d", __FUNCTION__,display,__LINE__);
return -ENODEV;
}
if (c->state() != DRM_MODE_CONNECTED) {
/*
* fake primary display if primary is not connected.
*/
if (display == HWC_DISPLAY_PRIMARY)
return 0;
return -ENODEV;
}
hwc_drm_display_t *hd = &ctx->displays[c->display()];
DrmMode mode = c->best_mode();
if (!mode.id()) {
ALOGE("Could not find active mode for display=%d", display);
return -ENOENT;
}
hd->w_scale = (float)mode.h_display() / hd->framebuffer_width;
hd->h_scale = (float)mode.v_display() / hd->framebuffer_height;
c->set_current_mode(mode);
ctx->drm.UpdateDisplayRoute();
return 0;
}
static int hwc_device_close(struct hw_device_t *dev) {
struct hwc_context_t *ctx = (struct hwc_context_t *)dev;
#if RK_CTS_WORKROUND
if(ctx->regFile)
{
fclose(ctx->regFile);
ctx->regFile = NULL;
}
#endif
#if RK_INVALID_REFRESH
free_thread_pamaters(&ctx->mRefresh);
#endif
#if 0
if(ctx->fd_3d >= 0)
{
close(ctx->fd_3d);
ctx->fd_3d = -1;
}
free_thread_pamaters(&ctx->mControlStereo);
#endif
delete ctx;
return 0;
}
/*
* TODO: This function sets the active config to the first one in the list. This
* should be fixed such that it selects the preferred mode for the display, or
* some other, saner, method of choosing the config.
*/
static int hwc_set_initial_config(struct hwc_context_t *ctx, int display) {
uint32_t config;
size_t num_configs = 1;
int ret = hwc_get_display_configs(&ctx->device, display, &config,
&num_configs);
if (ret || !num_configs)
return 0;
ret = hwc_set_active_config(&ctx->device, display, 0);
if (ret) {
ALOGE("Failed to set active config d=%d ret=%d", display, ret);
return ret;
}
return ret;
}
static int hwc_initialize_display(struct hwc_context_t *ctx, int display) {
hwc_drm_display_t *hd = &ctx->displays[display];
hd->ctx = ctx;
hd->gralloc = ctx->gralloc;
#if RK_VIDEO_UI_OPT
hd->iUiFd = -1;
hd->bHideUi = false;
#endif
hd->framebuffer_width = 0;
hd->framebuffer_height = 0;
hd->rel_xres = 0;
hd->rel_yres = 0;
hd->v_total = 0;
hd->w_scale = 1.0;
hd->h_scale = 1.0;
hd->active = true;
hd->last_hdmi_status = HDMI_ON;
hd->isHdr = false;
memset(&hd->last_hdr_metadata, 0, sizeof(hd->last_hdr_metadata));
hd->colorimetry = 0;
hd->hotplug_timeline = 0;
hd->display_timeline = 0;
hd->is_3d = false;
hd->hasEotfPlane = false;
hd->bPreferMixDown = false;
#if RK_RGA_PREPARE_ASYNC
hd->rgaBuffer_index = 0;
hd->mUseRga = false;
#endif
#if RK_ROTATE_VIDEO_MODE
hd->bRotateVideoMode = false;
#endif
return 0;
}
static int hwc_enumerate_displays(struct hwc_context_t *ctx) {
int ret, num_connectors = 0;
for (auto &conn : ctx->drm.connectors()) {
ret = hwc_initialize_display(ctx, conn->display());
if (ret) {
ALOGE("Failed to initialize display %d", conn->display());
return ret;
}
num_connectors++;
}
#if 0
ret = hwc_set_initial_config(ctx, HWC_DISPLAY_PRIMARY);
if (ret) {
ALOGE("Failed to set initial config for primary display ret=%d", ret);
return ret;
}
ret = hwc_set_initial_config(ctx, HWC_DISPLAY_EXTERNAL);
if (ret) {
ALOGE("Failed to set initial config for extend display ret=%d", ret);
// return ret;
}
#endif
ret = ctx->primary_vsync_worker.Init(&ctx->drm, HWC_DISPLAY_PRIMARY);
if (ret) {
ALOGE("Failed to create event worker for primary display %d\n", ret);
return ret;
}
if (num_connectors > 1) {
ret = ctx->extend_vsync_worker.Init(&ctx->drm, HWC_DISPLAY_EXTERNAL);
if (ret) {
ALOGE("Failed to create event worker for extend display %d\n", ret);
return ret;
}
}
ret = ctx->virtual_compositor_worker.Init();
if (ret) {
ALOGE("Failed to initialize virtual compositor worker");
return ret;
}
return 0;
}
#if RK_INVALID_REFRESH
static void hwc_static_screen_opt_handler(int sig)
{
hwc_context_t* ctx = g_ctx;
if (sig == SIGALRM) {
ctx->mOneWinOpt = true;
pthread_mutex_lock(&ctx->mRefresh.mlk);
ctx->mRefresh.count = 100;
ALOGD_IF(log_level(DBG_VERBOSE),"hwc_static_screen_opt_handler:mRefresh.count=%d",ctx->mRefresh.count);
pthread_mutex_unlock(&ctx->mRefresh.mlk);
pthread_cond_signal(&ctx->mRefresh.cond);
}
return;
}
void *invalidate_refresh(void *arg)
{
hwc_context_t* ctx = (hwc_context_t*)arg;
int count = 0;
int nMaxCnt = 25;
unsigned int nSleepTime = 200;
pthread_cond_wait(&ctx->mRefresh.cond,&ctx->mRefresh.mtx);
while(true) {
for(count = 0; count < nMaxCnt; count++) {
usleep(nSleepTime*1000);
pthread_mutex_lock(&ctx->mRefresh.mlk);
count = ctx->mRefresh.count;
ctx->mRefresh.count ++;
ALOGD_IF(log_level(DBG_VERBOSE),"invalidate_refresh mRefresh.count=%d",ctx->mRefresh.count);
pthread_mutex_unlock(&ctx->mRefresh.mlk);
ctx->procs->invalidate(ctx->procs);
}
pthread_cond_wait(&ctx->mRefresh.cond,&ctx->mRefresh.mtx);
count = 0;
}
pthread_exit(NULL);
return NULL;
}
#endif
#if 0
void* hwc_control_3dmode_thread(void *arg)
{
hwc_context_t* ctx = (hwc_context_t*)arg;
int ret = -1;
int needStereo = 0;
ALOGD("hwc_control_3dmode_thread creat");
pthread_cond_wait(&ctx->mControlStereo.cond,&ctx->mControlStereo.mtx);
while(true) {
pthread_mutex_lock(&ctx->mControlStereo.mlk);
needStereo = ctx->mControlStereo.count;
pthread_mutex_unlock(&ctx->mControlStereo.mlk);
ret = hwc_control_3dmode(ctx->fb_3d, 2, READ_3D_MODE);
if(needStereo != ret) {
hwc_control_3dmode(ctx, needStereo,WRITE_3D_MODE);
ALOGI_IF(log_level(DBG_VERBOSE),"change stereo mode %d to %d",ret,needStereo);
}
ALOGD_IF(log_level(DBG_VERBOSE),"mControlStereo.count=%d",needStereo);
pthread_cond_wait(&ctx->mControlStereo.cond,&ctx->mControlStereo.mtx);
}
ALOGD("hwc_control_3dmode_thread exit");
pthread_exit(NULL);
return NULL;
}
#endif
static int hwc_device_open(const struct hw_module_t *module, const char *name,
struct hw_device_t **dev) {
if (strcmp(name, HWC_HARDWARE_COMPOSER)) {
ALOGE("Invalid module name- %s", name);
return -EINVAL;
}
init_rk_debug();
hwc_get_baseparameter_config(NULL,0,BP_UPDATE,0);
std::unique_ptr<hwc_context_t> ctx(new hwc_context_t());
if (!ctx) {
ALOGE("Failed to allocate hwc context");
return -ENOMEM;
}
int ret = ctx->drm.Init();
if (ret) {
ALOGE("Can't initialize Drm object %d", ret);
return ret;
}
#if USE_GRALLOC_4
ctx->gralloc = NULL;
#else // USE_GRALLOC_4
ret = hw_get_module(GRALLOC_HARDWARE_MODULE_ID,
(const hw_module_t **)&ctx->gralloc);
if (ret) {
ALOGE("Failed to open gralloc module %d", ret);
return ret;
}
#endif // USE_GRALLOC_4
ctx->drm.setGralloc(ctx->gralloc);
ret = ctx->dummy_timeline.Init();
if (ret) {
ALOGE("Failed to create dummy sw sync timeline %d", ret);
return ret;
}
ctx->importer.reset(Importer::CreateInstance(&ctx->drm));
if (!ctx->importer) {
ALOGE("Failed to create importer instance");
return ret;
}
ret = hwc_enumerate_displays(ctx.get());
if (ret) {
ALOGE("Failed to enumerate displays: %s", strerror(ret));
return ret;
}
ctx->device.common.tag = HARDWARE_DEVICE_TAG;
ctx->device.common.version = HWC_DEVICE_API_VERSION_1_4;
ctx->device.common.module = const_cast<hw_module_t *>(module);
ctx->device.common.close = hwc_device_close;
ctx->device.dump = hwc_dump;
ctx->device.prepare = hwc_prepare;
ctx->device.set = hwc_set;
ctx->device.eventControl = hwc_event_control;
ctx->device.setPowerMode = hwc_set_power_mode;
ctx->device.query = hwc_query;
ctx->device.registerProcs = hwc_register_procs;
ctx->device.getDisplayConfigs = hwc_get_display_configs;
ctx->device.getDisplayAttributes = hwc_get_display_attributes;
ctx->device.getActiveConfig = hwc_get_active_config;
ctx->device.setActiveConfig = hwc_set_active_config;
ctx->device.setCursorPositionAsync = NULL; /* TODO: Add cursor */
g_ctx = ctx.get();
ctx->fb_fd = open("/dev/graphics/fb0", O_RDWR, 0);
if(ctx->fb_fd < 0)
{
ALOGE("Open fb0 fail in %s",__FUNCTION__);
}
ctx->hdmi_status_fd = open(HDMI_STATUS_PATH, O_RDWR, 0);
if(ctx->hdmi_status_fd < 0)
{
ALOGE("Open hdmi_status_fd fail in %s",__FUNCTION__);
//return -1;
}
ctx->dp_status_fd = open(DP_STATUS_PATH, O_RDWR, 0);
if(ctx->hdmi_status_fd < 0)
{
ALOGE("Open hdmi_status_fd fail in %s",__FUNCTION__);
//return -1;
}
#if RK_CTS_WORKROUND
ctx->regFile = fopen(VIEW_CTS_FILE, "r");
if(ctx->regFile == NULL)
{
ALOGE("%s open fail errno=0x%x (%s)",__FUNCTION__, errno,strerror(errno));
}
#endif
hwc_init_version();
ctx->hdr_video_compose_by_gles = hwc_get_bool_property( PROPERTY_TYPE ".hwc.hdr_video_by_gles","false");
ALOGI("HWC property : hdr_video_by_gles = %s",ctx->hdr_video_compose_by_gles ? "True" : "False");
#if RK_INVALID_REFRESH
ctx->mOneWinOpt = false;
ctx->isGLESComp = false;
init_thread_pamaters(&ctx->mRefresh);
pthread_t invalidate_refresh_th;
if (pthread_create(&invalidate_refresh_th, NULL, invalidate_refresh, ctx.get()))
{
ALOGE("Create invalidate_refresh_th thread error .");
}
signal(SIGALRM, hwc_static_screen_opt_handler);
#endif
#if 0
init_thread_pamaters(&ctx->mControlStereo);
ctx->fd_3d = open("/sys/class/display/HDMI/3dmode", O_RDWR, 0);
if(ctx->fd_3d < 0){
ALOGE("open /sys/class/display/HDMI/3dmode fail");
}
pthread_t thread_3d;
if (pthread_create(&thread_3d, NULL, hwc_control_3dmode_thread, ctx.get()))
{
ALOGE("Create hwc_control_3dmode_thread thread error .");
}
#endif
*dev = &ctx->device.common;
ctx.release();
return 0;
}
}
static struct hw_module_methods_t hwc_module_methods = {
.open = android::hwc_device_open
};
hwc_module_t HAL_MODULE_INFO_SYM = {
.common = {
.tag = HARDWARE_MODULE_TAG,
.version_major = 1,
.version_minor = 0,
.id = HWC_HARDWARE_MODULE_ID,
.name = "DRM hwcomposer module",
.author = "The Android Open Source Project",
.methods = &hwc_module_methods,
.dso = NULL,
.reserved = {0},
}
};
Reference in New Issue View Git Blame Copy Permalink