drmdisplaycomposition.cpp - platform/external/drm_hwcomposer - Git at Google

 /*
  * 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 LOG_TAG "hwc-drm-display-composition"

 #include "drmdisplaycomposition.h"
 #include "drmcrtc.h"
 #include "drmdevice.h"
 #include "drmdisplaycompositor.h"
 #include "drmplane.h"
 #include "platform.h"

 #include <stdlib.h>

 #include <algorithm>
 #include <unordered_set>

 #include <log/log.h>
 #include <sync/sync.h>
 #include <xf86drmMode.h>

 namespace android {

 DrmDisplayComposition::~DrmDisplayComposition() {
 }

 int DrmDisplayComposition::Init(DrmDevice *drm, DrmCrtc *crtc,
                                 Importer *importer, Planner *planner,
                                 uint64_t frame_no) {
   drm_ = drm;
   crtc_ = crtc;  // Can be NULL if we haven't modeset yet
   importer_ = importer;
   planner_ = planner;
   frame_no_ = frame_no;

   return 0;
 }

 bool DrmDisplayComposition::validate_composition_type(DrmCompositionType des) {
   return type_ == DRM_COMPOSITION_TYPE_EMPTY || type_ == des;
 }

 int DrmDisplayComposition::SetLayers(DrmHwcLayer *layers, size_t num_layers,
                                      bool geometry_changed) {
   if (!validate_composition_type(DRM_COMPOSITION_TYPE_FRAME))
     return -EINVAL;

   geometry_changed_ = geometry_changed;

   for (size_t layer_index = 0; layer_index < num_layers; layer_index++) {
     layers_.emplace_back(std::move(layers[layer_index]));
   }

   type_ = DRM_COMPOSITION_TYPE_FRAME;
   return 0;
 }

 int DrmDisplayComposition::SetDpmsMode(uint32_t dpms_mode) {
   if (!validate_composition_type(DRM_COMPOSITION_TYPE_DPMS))
     return -EINVAL;
   dpms_mode_ = dpms_mode;
   type_ = DRM_COMPOSITION_TYPE_DPMS;
   return 0;
 }

 int DrmDisplayComposition::SetDisplayMode(const DrmMode &display_mode) {
   if (!validate_composition_type(DRM_COMPOSITION_TYPE_MODESET))
     return -EINVAL;
   display_mode_ = display_mode;
   dpms_mode_ = DRM_MODE_DPMS_ON;
   type_ = DRM_COMPOSITION_TYPE_MODESET;
   return 0;
 }

 int DrmDisplayComposition::AddPlaneDisable(DrmPlane *plane) {
   composition_planes_.emplace_back(DrmCompositionPlane::Type::kDisable, plane,
                                    crtc_);
   return 0;
 }

 int DrmDisplayComposition::AddPlaneComposition(DrmCompositionPlane plane) {
   composition_planes_.emplace_back(std::move(plane));
   return 0;
 }

 int DrmDisplayComposition::Plan(std::vector<DrmPlane *> *primary_planes,
                                 std::vector<DrmPlane *> *overlay_planes) {
   if (type_ != DRM_COMPOSITION_TYPE_FRAME)
     return 0;

   std::map<size_t, DrmHwcLayer *> to_composite;

   for (size_t i = 0; i < layers_.size(); ++i)
     to_composite.emplace(std::make_pair(i, &layers_[i]));

   int ret;
   std::tie(ret,
            composition_planes_) = planner_->ProvisionPlanes(to_composite, crtc_,
                                                             primary_planes,
                                                             overlay_planes);
   if (ret) {
     ALOGE("Planner failed provisioning planes ret=%d", ret);
     return ret;
   }

   // Remove the planes we used from the pool before returning. This ensures they
   // won't be reused by another display in the composition.
   for (auto &i : composition_planes_) {
     if (!i.plane())
       continue;

     // make sure that source layers are ordered based on zorder
     std::sort(i.source_layers().begin(), i.source_layers().end());

     std::vector<DrmPlane *> *container;
     if (i.plane()->type() == DRM_PLANE_TYPE_PRIMARY)
       container = primary_planes;
     else
       container = overlay_planes;
     for (auto j = container->begin(); j != container->end(); ++j) {
       if (*j == i.plane()) {
         container->erase(j);
         break;
       }
     }
   }

   return 0;
 }

 static const char *DrmCompositionTypeToString(DrmCompositionType type) {
   switch (type) {
     case DRM_COMPOSITION_TYPE_EMPTY:
       return "EMPTY";
     case DRM_COMPOSITION_TYPE_FRAME:
       return "FRAME";
     case DRM_COMPOSITION_TYPE_DPMS:
       return "DPMS";
     case DRM_COMPOSITION_TYPE_MODESET:
       return "MODESET";
     default:
       return "<invalid>";
   }
 }

 static const char *DPMSModeToString(int dpms_mode) {
   switch (dpms_mode) {
     case DRM_MODE_DPMS_ON:
       return "ON";
     case DRM_MODE_DPMS_OFF:
       return "OFF";
     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 << "/" << buffer->format;
 }

 static void DumpTransform(uint32_t transform, std::ostringstream *out) {
   *out << "[";

   if (transform == 0)
     *out << "IDENTITY";

   bool separator = false;
   if (transform & DrmHwcTransform::kFlipH) {
     *out << "FLIPH";
     separator = true;
   }
   if (transform & DrmHwcTransform::kFlipV) {
     if (separator)
       *out << "|";
     *out << "FLIPV";
     separator = true;
   }
   if (transform & DrmHwcTransform::kRotate90) {
     if (separator)
       *out << "|";
     *out << "ROTATE90";
     separator = true;
   }
   if (transform & DrmHwcTransform::kRotate180) {
     if (separator)
       *out << "|";
     *out << "ROTATE180";
     separator = true;
   }
   if (transform & DrmHwcTransform::kRotate270) {
     if (separator)
       *out << "|";
     *out << "ROTATE270";
     separator = true;
   }

   uint32_t valid_bits = DrmHwcTransform::kFlipH | DrmHwcTransform::kFlipH |
                         DrmHwcTransform::kRotate90 |
                         DrmHwcTransform::kRotate180 |
                         DrmHwcTransform::kRotate270;
   if (transform & ~valid_bits) {
     if (separator)
       *out << "|";
     *out << "INVALID";
   }
   *out << "]";
 }

 static 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 DrmDisplayComposition::Dump(std::ostringstream *out) const {
   *out << "----DrmDisplayComposition"
        << " crtc=" << (crtc_ ? crtc_->id() : -1)
        << " type=" << DrmCompositionTypeToString(type_);

   switch (type_) {
     case DRM_COMPOSITION_TYPE_DPMS:
       *out << " dpms_mode=" << DPMSModeToString(dpms_mode_);
       break;
     case DRM_COMPOSITION_TYPE_MODESET:
       *out << " display_mode=" << display_mode_.h_display() << "x"
            << display_mode_.v_display();
       break;
     default:
       break;
   }

   *out << "    Layers: count=" << layers_.size() << "\n";
   for (size_t i = 0; i < layers_.size(); i++) {
     const DrmHwcLayer &layer = layers_[i];
     *out << "      [" << i << "] ";

     DumpBuffer(layer.buffer, out);

     if (layer.protected_usage())
       *out << " protected";

     *out << " transform=";
     DumpTransform(layer.transform, out);
     *out << " blending[a=" << (int)layer.alpha
          << "]=" << BlendingToString(layer.blending) << "\n";
   }

   *out << "    Planes: count=" << composition_planes_.size() << "\n";
   for (size_t i = 0; i < composition_planes_.size(); i++) {
     const DrmCompositionPlane &comp_plane = composition_planes_[i];
     *out << "      [" << i << "]"
          << " plane=" << (comp_plane.plane() ? comp_plane.plane()->id() : -1)
          << " type=";
     switch (comp_plane.type()) {
       case DrmCompositionPlane::Type::kDisable:
         *out << "DISABLE";
         break;
       case DrmCompositionPlane::Type::kLayer:
         *out << "LAYER";
         break;
       default:
         *out << "<invalid>";
         break;
     }

     *out << " source_layer=";
     for (auto i : comp_plane.source_layers()) {
       *out << i << " ";
     }
     *out << "\n";
   }
 }
 }  // namespace android
	/*
	* 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 LOG_TAG "hwc-drm-display-composition"

	#include "drmdisplaycomposition.h"
	#include "drmcrtc.h"
	#include "drmdevice.h"
	#include "drmdisplaycompositor.h"
	#include "drmplane.h"
	#include "platform.h"

	#include <stdlib.h>

	#include <algorithm>
	#include <unordered_set>

	#include <log/log.h>
	#include <sync/sync.h>
	#include <xf86drmMode.h>

	namespace android {

	DrmDisplayComposition::~DrmDisplayComposition() {
	}

	int DrmDisplayComposition::Init(DrmDevice drm, DrmCrtc crtc,
	Importer importer, Planner planner,
	uint64_t frame_no) {
	drm_ = drm;
	crtc_ = crtc; // Can be NULL if we haven't modeset yet
	importer_ = importer;
	planner_ = planner;
	frame_no_ = frame_no;

	return 0;
	}

	bool DrmDisplayComposition::validate_composition_type(DrmCompositionType des) {
	return type_ == DRM_COMPOSITION_TYPE_EMPTY \|\| type_ == des;
	}

	int DrmDisplayComposition::SetLayers(DrmHwcLayer *layers, size_t num_layers,
	bool geometry_changed) {
	if (!validate_composition_type(DRM_COMPOSITION_TYPE_FRAME))
	return -EINVAL;

	geometry_changed_ = geometry_changed;

	for (size_t layer_index = 0; layer_index < num_layers; layer_index++) {
	layers_.emplace_back(std::move(layers[layer_index]));
	}

	type_ = DRM_COMPOSITION_TYPE_FRAME;
	return 0;
	}

	int DrmDisplayComposition::SetDpmsMode(uint32_t dpms_mode) {
	if (!validate_composition_type(DRM_COMPOSITION_TYPE_DPMS))
	return -EINVAL;
	dpms_mode_ = dpms_mode;
	type_ = DRM_COMPOSITION_TYPE_DPMS;
	return 0;
	}

	int DrmDisplayComposition::SetDisplayMode(const DrmMode &display_mode) {
	if (!validate_composition_type(DRM_COMPOSITION_TYPE_MODESET))
	return -EINVAL;
	display_mode_ = display_mode;
	dpms_mode_ = DRM_MODE_DPMS_ON;
	type_ = DRM_COMPOSITION_TYPE_MODESET;
	return 0;
	}

	int DrmDisplayComposition::AddPlaneDisable(DrmPlane *plane) {
	composition_planes_.emplace_back(DrmCompositionPlane::Type::kDisable, plane,
	crtc_);
	return 0;
	}

	int DrmDisplayComposition::AddPlaneComposition(DrmCompositionPlane plane) {
	composition_planes_.emplace_back(std::move(plane));
	return 0;
	}

	int DrmDisplayComposition::Plan(std::vector<DrmPlane > primary_planes,
	std::vector<DrmPlane > overlay_planes) {
	if (type_ != DRM_COMPOSITION_TYPE_FRAME)
	return 0;

	std::map<size_t, DrmHwcLayer *> to_composite;

	for (size_t i = 0; i < layers_.size(); ++i)
	to_composite.emplace(std::make_pair(i, &layers_[i]));

	int ret;
	std::tie(ret,
	composition_planes_) = planner_->ProvisionPlanes(to_composite, crtc_,
	primary_planes,
	overlay_planes);
	if (ret) {
	ALOGE("Planner failed provisioning planes ret=%d", ret);
	return ret;
	}

	// Remove the planes we used from the pool before returning. This ensures they
	// won't be reused by another display in the composition.
	for (auto &i : composition_planes_) {
	if (!i.plane())
	continue;

	// make sure that source layers are ordered based on zorder
	std::sort(i.source_layers().begin(), i.source_layers().end());

	std::vector<DrmPlane > container;
	if (i.plane()->type() == DRM_PLANE_TYPE_PRIMARY)
	container = primary_planes;
	else
	container = overlay_planes;
	for (auto j = container->begin(); j != container->end(); ++j) {
	if (*j == i.plane()) {
	container->erase(j);
	break;
	}
	}
	}

	return 0;
	}

	static const char *DrmCompositionTypeToString(DrmCompositionType type) {
	switch (type) {
	case DRM_COMPOSITION_TYPE_EMPTY:
	return "EMPTY";
	case DRM_COMPOSITION_TYPE_FRAME:
	return "FRAME";
	case DRM_COMPOSITION_TYPE_DPMS:
	return "DPMS";
	case DRM_COMPOSITION_TYPE_MODESET:
	return "MODESET";
	default:
	return "<invalid>";
	}
	}

	static const char *DPMSModeToString(int dpms_mode) {
	switch (dpms_mode) {
	case DRM_MODE_DPMS_ON:
	return "ON";
	case DRM_MODE_DPMS_OFF:
	return "OFF";
	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 << "/" << buffer->format;
	}

	static void DumpTransform(uint32_t transform, std::ostringstream *out) {
	*out << "[";

	if (transform == 0)
	*out << "IDENTITY";

	bool separator = false;
	if (transform & DrmHwcTransform::kFlipH) {
	*out << "FLIPH";
	separator = true;
	}
	if (transform & DrmHwcTransform::kFlipV) {
	if (separator)
	*out << "\|";
	*out << "FLIPV";
	separator = true;
	}
	if (transform & DrmHwcTransform::kRotate90) {
	if (separator)
	*out << "\|";
	*out << "ROTATE90";
	separator = true;
	}
	if (transform & DrmHwcTransform::kRotate180) {
	if (separator)
	*out << "\|";
	*out << "ROTATE180";
	separator = true;
	}
	if (transform & DrmHwcTransform::kRotate270) {
	if (separator)
	*out << "\|";
	*out << "ROTATE270";
	separator = true;
	}

	uint32_t valid_bits = DrmHwcTransform::kFlipH \| DrmHwcTransform::kFlipH \|
	DrmHwcTransform::kRotate90 \|
	DrmHwcTransform::kRotate180 \|
	DrmHwcTransform::kRotate270;
	if (transform & ~valid_bits) {
	if (separator)
	*out << "\|";
	*out << "INVALID";
	}
	*out << "]";
	}

	static 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 DrmDisplayComposition::Dump(std::ostringstream *out) const {
	*out << "----DrmDisplayComposition"
	<< " crtc=" << (crtc_ ? crtc_->id() : -1)
	<< " type=" << DrmCompositionTypeToString(type_);

	switch (type_) {
	case DRM_COMPOSITION_TYPE_DPMS:
	*out << " dpms_mode=" << DPMSModeToString(dpms_mode_);
	break;
	case DRM_COMPOSITION_TYPE_MODESET:
	*out << " display_mode=" << display_mode_.h_display() << "x"
	<< display_mode_.v_display();
	break;
	default:
	break;
	}

	*out << " Layers: count=" << layers_.size() << "\n";
	for (size_t i = 0; i < layers_.size(); i++) {
	const DrmHwcLayer &layer = layers_[i];
	*out << " [" << i << "] ";

	DumpBuffer(layer.buffer, out);

	if (layer.protected_usage())
	*out << " protected";

	*out << " transform=";
	DumpTransform(layer.transform, out);
	*out << " blending[a=" << (int)layer.alpha
	<< "]=" << BlendingToString(layer.blending) << "\n";
	}

	*out << " Planes: count=" << composition_planes_.size() << "\n";
	for (size_t i = 0; i < composition_planes_.size(); i++) {
	const DrmCompositionPlane &comp_plane = composition_planes_[i];
	*out << " [" << i << "]"
	<< " plane=" << (comp_plane.plane() ? comp_plane.plane()->id() : -1)
	<< " type=";
	switch (comp_plane.type()) {
	case DrmCompositionPlane::Type::kDisable:
	*out << "DISABLE";
	break;
	case DrmCompositionPlane::Type::kLayer:
	*out << "LAYER";
	break;
	default:
	*out << "<invalid>";
	break;
	}

	*out << " source_layer=";
	for (auto i : comp_plane.source_layers()) {
	*out << i << " ";
	}
	*out << "\n";
	}
	}
	} // namespace android