Merge "minui: remove libadf since it is no longer supported" (0cd9a636) · Commits · e / os / android_bootable_recovery

minui/Android.bp

+0 −2

Original line number	Diff line number	Diff line
		@@ -27,14 +27,12 @@ cc_library {
		srcs: [
		"events.cpp",
		"graphics.cpp",
		"graphics_adf.cpp",
		"graphics_drm.cpp",
		"graphics_fbdev.cpp",
		"resources.cpp",
		],

		whole_static_libs: [
		"libadf",
		"libdrm",
		"libsync",
		],

minui/graphics.cpp

+1 −7

Original line number	Diff line number	Diff line
		@@ -25,7 +25,6 @@

		#include <android-base/properties.h>

		#include "graphics_adf.h"
		#include "graphics_drm.h"
		#include "graphics_fbdev.h"
		#include "minui/minui.h"
		@@ -362,14 +361,9 @@ int gr_init() {
		ret);
		}

		auto backend = std::unique_ptr<MinuiBackend>{ std::make_unique<MinuiBackendAdf>() };
		auto backend = std::unique_ptr<MinuiBackend>{ std::make_unique<MinuiBackendDrm>() };
		gr_draw = backend->Init();

		if (!gr_draw) {
		backend = std::make_unique<MinuiBackendDrm>();
		gr_draw = backend->Init();
		}

		if (!gr_draw) {
		backend = std::make_unique<MinuiBackendFbdev>();
		gr_draw = backend->Init();

minui/graphics_adf.cpp

deleted100644 → 0

+0 −200

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2014 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		#include "graphics_adf.h"

		#include <errno.h>
		#include <fcntl.h>
		#include <stdio.h>
		#include <stdlib.h>
		#include <string.h>
		#include <sys/mman.h>
		#include <unistd.h>

		#include <adf/adf.h>
		#include <sync/sync.h>

		#include "minui/minui.h"

		GRSurfaceAdf::~GRSurfaceAdf() {
		if (mmapped_buffer_) {
		munmap(mmapped_buffer_, pitch * height);
		}
		if (fence_fd != -1) {
		close(fence_fd);
		}
		if (fd != -1) {
		close(fd);
		}
		}

		std::unique_ptr<GRSurfaceAdf> GRSurfaceAdf::Create(int intf_fd, const drm_mode_modeinfo* mode,
		__u32 format, int* err) {
		__u32 offset;
		__u32 pitch;
		auto fd = adf_interface_simple_buffer_alloc(intf_fd, mode->hdisplay, mode->vdisplay, format,
		&offset, &pitch);

		if (fd < 0) {
		*err = fd;
		return nullptr;
		}

		std::unique_ptr<GRSurfaceAdf> surf = std::unique_ptr<GRSurfaceAdf>(
		new GRSurfaceAdf(mode->hdisplay, mode->vdisplay, pitch, (format == DRM_FORMAT_RGB565 ? 2 : 4),
		offset, pitch, fd));

		auto mmapped =
		mmap(nullptr, surf->pitch * surf->height, PROT_WRITE, MAP_SHARED, surf->fd, surf->offset);
		if (mmapped == MAP_FAILED) {
		*err = -errno;
		return nullptr;
		}
		surf->mmapped_buffer_ = static_cast<uint8_t*>(mmapped);
		return surf;
		}

		MinuiBackendAdf::MinuiBackendAdf() : intf_fd(-1), dev(), current_surface(0), n_surfaces(0) {}

		int MinuiBackendAdf::InterfaceInit() {
		adf_interface_data intf_data;
		if (int err = adf_get_interface_data(intf_fd, &intf_data); err < 0) return err;

		int result = 0;
		surfaces[0] = GRSurfaceAdf::Create(intf_fd, &intf_data.current_mode, format, &result);
		if (!surfaces[0]) {
		fprintf(stderr, "Failed to allocate surface 0: %s\n", strerror(-result));
		goto done;
		}

		surfaces[1] = GRSurfaceAdf::Create(intf_fd, &intf_data.current_mode, format, &result);
		if (!surfaces[1]) {
		fprintf(stderr, "Failed to allocate surface 1: %s\n", strerror(-result));
		n_surfaces = 1;
		} else {
		n_surfaces = 2;
		}

		done:
		adf_free_interface_data(&intf_data);
		return result;
		}

		int MinuiBackendAdf::DeviceInit(adf_device* dev) {
		adf_id_t intf_id;
		int err = adf_find_simple_post_configuration(dev, &format, 1, &intf_id, &eng_id);
		if (err < 0) return err;

		err = adf_device_attach(dev, eng_id, intf_id);
		if (err < 0 && err != -EALREADY) return err;

		intf_fd = adf_interface_open(dev, intf_id, O_RDWR \| O_CLOEXEC);
		if (intf_fd < 0) return intf_fd;

		err = InterfaceInit();
		if (err < 0) {
		close(intf_fd);
		intf_fd = -1;
		}

		return err;
		}

		GRSurface* MinuiBackendAdf::Init() {
		PixelFormat pixel_format = gr_pixel_format();
		if (pixel_format == PixelFormat::ABGR) {
		format = DRM_FORMAT_ABGR8888;
		} else if (pixel_format == PixelFormat::BGRA) {
		format = DRM_FORMAT_BGRA8888;
		} else if (pixel_format == PixelFormat::RGBX) {
		format = DRM_FORMAT_RGBX8888;
		} else {
		format = DRM_FORMAT_RGB565;
		}

		adf_id_t* dev_ids = nullptr;
		ssize_t n_dev_ids = adf_devices(&dev_ids);
		if (n_dev_ids == 0) {
		return nullptr;
		} else if (n_dev_ids < 0) {
		fprintf(stderr, "enumerating adf devices failed: %s\n", strerror(-n_dev_ids));
		return nullptr;
		}

		intf_fd = -1;

		for (ssize_t i = 0; i < n_dev_ids && intf_fd < 0; i++) {
		int err = adf_device_open(dev_ids[i], O_RDWR, &dev);
		if (err < 0) {
		fprintf(stderr, "opening adf device %u failed: %s\n", dev_ids[i], strerror(-err));
		continue;
		}

		err = DeviceInit(&dev);
		if (err < 0) {
		fprintf(stderr, "initializing adf device %u failed: %s\n", dev_ids[i], strerror(-err));
		adf_device_close(&dev);
		}
		}

		free(dev_ids);

		if (intf_fd < 0) return nullptr;

		GRSurface* ret = Flip();

		Blank(true);
		Blank(false);

		return ret;
		}

		void MinuiBackendAdf::Sync(GRSurfaceAdf* surf) {
		static constexpr unsigned int kWarningTimeout = 3000;

		if (surf == nullptr) return;

		if (surf->fence_fd >= 0) {
		int err = sync_wait(surf->fence_fd, kWarningTimeout);
		if (err < 0) {
		perror("adf sync fence wait error\n");
		}

		close(surf->fence_fd);
		surf->fence_fd = -1;
		}
		}

		GRSurface* MinuiBackendAdf::Flip() {
		const auto& surf = surfaces[current_surface];

		int fence_fd = adf_interface_simple_post(intf_fd, eng_id, surf->width, surf->height, format,
		surf->fd, surf->offset, surf->pitch, -1);
		if (fence_fd >= 0) surf->fence_fd = fence_fd;

		current_surface = (current_surface + 1) % n_surfaces;
		Sync(surfaces[current_surface].get());
		return surfaces[current_surface].get();
		}

		void MinuiBackendAdf::Blank(bool blank) {
		adf_interface_blank(intf_fd, blank ? DRM_MODE_DPMS_OFF : DRM_MODE_DPMS_ON);
		}

		MinuiBackendAdf::~MinuiBackendAdf() {
		adf_device_close(&dev);
		if (intf_fd >= 0) close(intf_fd);
		}

minui/graphics_adf.h

deleted100644 → 0

+0 −76

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2017 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.
		*/

		#pragma once

		#include <stddef.h>
		#include <stdint.h>
		#include <sys/types.h>

		#include <memory>

		#include <adf/adf.h>

		#include "graphics.h"
		#include "minui/minui.h"

		class GRSurfaceAdf : public GRSurface {
		public:
		~GRSurfaceAdf() override;

		static std::unique_ptr<GRSurfaceAdf> Create(int intf_fd, const drm_mode_modeinfo* mode,
		__u32 format, int* err);

		uint8_t* data() override {
		return mmapped_buffer_;
		}

		private:
		friend class MinuiBackendAdf;

		GRSurfaceAdf(size_t width, size_t height, size_t row_bytes, size_t pixel_bytes, __u32 offset,
		__u32 pitch, int fd)
		: GRSurface(width, height, row_bytes, pixel_bytes), offset(offset), pitch(pitch), fd(fd) {}

		const __u32 offset;
		const __u32 pitch;

		int fd;
		int fence_fd{ -1 };
		uint8_t* mmapped_buffer_{ nullptr };
		};

		class MinuiBackendAdf : public MinuiBackend {
		public:
		MinuiBackendAdf();
		~MinuiBackendAdf() override;
		GRSurface* Init() override;
		GRSurface* Flip() override;
		void Blank(bool) override;

		private:
		int InterfaceInit();
		int DeviceInit(adf_device* dev);
		void Sync(GRSurfaceAdf* surf);

		int intf_fd;
		adf_id_t eng_id;
		__u32 format;
		adf_device dev;
		size_t current_surface;
		size_t n_surfaces;
		std::unique_ptr<GRSurfaceAdf> surfaces[2];
		};