/*
// Copyright (c) 2014 Intel Corporation
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
*/
#include <HwcTrace.h>
#include <tangier/TngPlaneManager.h>
#include <tangier/TngPrimaryPlane.h>
#include <tangier/TngSpritePlane.h>
#include <tangier/TngOverlayPlane.h>
#include <tangier/TngCursorPlane.h>
namespace android {
namespace intel {
TngPlaneManager::TngPlaneManager()
: DisplayPlaneManager()
{
memset(&mZorder, 0, sizeof(mZorder));
}
TngPlaneManager::~TngPlaneManager()
{
}
bool TngPlaneManager::initialize()
{
mSpritePlaneCount = 1; // Sprite D
mOverlayPlaneCount = 2; // Overlay A & C
mPrimaryPlaneCount = 3; // Primary A, B, C
mCursorPlaneCount = 3;
return DisplayPlaneManager::initialize();
}
void TngPlaneManager::deinitialize()
{
DisplayPlaneManager::deinitialize();
}
DisplayPlane* TngPlaneManager::allocPlane(int index, int type)
{
DisplayPlane *plane = 0;
switch (type) {
case DisplayPlane::PLANE_PRIMARY:
plane = new TngPrimaryPlane(index, index);
break;
case DisplayPlane::PLANE_SPRITE:
plane = new TngSpritePlane(index, 0);
break;
case DisplayPlane::PLANE_OVERLAY:
plane = new TngOverlayPlane(index, 0);
break;
case DisplayPlane::PLANE_CURSOR:
plane = new TngCursorPlane(index, index /*disp */);
break;
default:
ETRACE("unsupported type %d", type);
break;
}
if (plane && !plane->initialize(DisplayPlane::MIN_DATA_BUFFER_COUNT)) {
ETRACE("failed to initialize plane.");
DEINIT_AND_DELETE_OBJ(plane);
}
return plane;
}
bool TngPlaneManager::isValidZOrder(int dsp, ZOrderConfig& config)
{
// check whether it's a supported z order config
int firstRGB = -1;
int lastRGB = -1;
int firstOverlay = -1;
int lastOverlay = -1;
for (int i = 0; i < (int)config.size(); i++) {
const ZOrderLayer *layer = config[i];
switch (layer->planeType) {
case DisplayPlane::PLANE_PRIMARY:
case DisplayPlane::PLANE_SPRITE:
if (firstRGB == -1) {
firstRGB = i;
lastRGB = i;
} else {
lastRGB = i;
}
break;
case DisplayPlane::PLANE_OVERLAY:
case DisplayPlane::PLANE_CURSOR:
if (firstOverlay == -1) {
firstOverlay = i;
lastOverlay = i;
} else {
lastOverlay = i;
}
break;
}
}
if ((lastRGB < firstOverlay) || (firstRGB > lastOverlay)) {
return true;
} else {
VTRACE("invalid z order config. rgb (%d, %d) yuv (%d, %d)",
firstRGB, lastRGB, firstOverlay, lastOverlay);
return false;
}
}
bool TngPlaneManager::assignPlanes(int dsp, ZOrderConfig& config)
{
// probe if plane is available
int size = (int)config.size();
for (int i = 0; i < size; i++) {
const ZOrderLayer *layer = config.itemAt(i);
if (!getFreePlanes(dsp, layer->planeType)) {
DTRACE("no plane available for dsp %d, type %d", dsp, layer->planeType);
return false;
}
}
if (config.size() == 1 && config[0]->planeType == DisplayPlane::PLANE_SPRITE) {
config[0]->planeType == DisplayPlane::PLANE_PRIMARY;
}
// allocate planes
for (int i = 0; i < size; i++) {
ZOrderLayer *layer = config.itemAt(i);
layer->plane = getPlaneHelper(dsp, layer->planeType);
if (layer->plane == NULL) {
// should never happen!!
ETRACE("failed to assign plane for type %d", layer->planeType);
return false;
}
// sequence !!!!! enabling plane before setting zorder
// see TngSpritePlane::enablePlane implementation!!!!
layer->plane->enable();
}
// setup Z order
for (int i = 0; i < size; i++) {
ZOrderLayer *layer = config.itemAt(i);
layer->plane->setZOrderConfig(config, &mZorder);
}
return true;
}
void* TngPlaneManager::getZOrderConfig() const
{
return (void*)&mZorder;
}
DisplayPlane* TngPlaneManager::getPlaneHelper(int dsp, int type)
{
RETURN_NULL_IF_NOT_INIT();
if (dsp < 0 || dsp > IDisplayDevice::DEVICE_EXTERNAL) {
ETRACE("Invalid display device %d", dsp);
return 0;
}
int index = dsp == IDisplayDevice::DEVICE_PRIMARY ? 0 : 1;
if (type == DisplayPlane::PLANE_PRIMARY ||
type == DisplayPlane::PLANE_CURSOR) {
return getPlane(type, index);
} else if (type == DisplayPlane::PLANE_SPRITE) {
return getAnyPlane(type);
} else if (type == DisplayPlane::PLANE_OVERLAY) {
// use overlay A for pipe A and overlay C for pipe B if possible
DisplayPlane *plane = getPlane(type, index);
if (plane == NULL) {
plane = getPlane(type, !index);
}
return plane;
} else {
ETRACE("invalid plane type %d", type);
return 0;
}
}
} // namespace intel
} // namespace android