garnet/lib/ui/gfx/displays/display_manager.cc - fuchsia/ - Git at Google

 // Copyright 2017 The Fuchsia Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include "garnet/lib/ui/gfx/displays/display_manager.h"

 #include <lib/async/default.h>
 #include <lib/fdio/directory.h>
 #include <trace/event.h>
 #include <zircon/syscalls.h>

 #include "fuchsia/ui/scenic/cpp/fidl.h"

 namespace scenic_impl {
 namespace gfx {

 DisplayManager::DisplayManager() {
   zx_status_t status = fdio_service_connect(
       "/svc/fuchsia.sysmem.Allocator",
       sysmem_allocator_.NewRequest().TakeChannel().release());
   if (status != ZX_OK) {
     sysmem_allocator_.Unbind();
     FXL_LOG(ERROR) << "Unable to connect to sysmem: " << status;
   }
 }

 DisplayManager::~DisplayManager() {
   if (wait_.object() != ZX_HANDLE_INVALID) {
     wait_.Cancel();
   }
 }

 void DisplayManager::WaitForDefaultDisplay(fit::closure callback) {
   FXL_DCHECK(!default_display_);

   display_available_cb_ = std::move(callback);
   display_watcher_.WaitForDisplay(
       [this](zx::channel device, zx::channel dc_handle) {
         dc_device_ = std::move(device);
         dc_channel_ = dc_handle.get();
         display_controller_.Bind(std::move(dc_handle));

         // TODO(FIDL-183): Resolve this hack when synchronous interfaces
         // support events.
         auto dispatcher =
             static_cast<fuchsia::hardware::display::Controller::Proxy_*>(
                 event_dispatcher_.get());
         dispatcher->DisplaysChanged = [this](auto added, auto removed) {
           DisplaysChanged(std::move(added), std::move(removed));
         };
         dispatcher->ClientOwnershipChange = [this](auto change) {
           ClientOwnershipChange(change);
         };
         dispatcher->Vsync = [this](uint64_t display_id, uint64_t timestamp,
                                    ::std::vector<uint64_t> images) {
           if (display_id == default_display_->display_id() && vsync_cb_) {
             vsync_cb_(timestamp, images);
           }
         };

         wait_.set_object(dc_channel_);
         wait_.set_trigger(ZX_CHANNEL_READABLE | ZX_CHANNEL_PEER_CLOSED);
         wait_.Begin(async_get_default_dispatcher());
       });
 }

 void DisplayManager::OnAsync(async_dispatcher_t* dispatcher,
                              async::WaitBase* self, zx_status_t status,
                              const zx_packet_signal_t* signal) {
   if (status & ZX_CHANNEL_PEER_CLOSED) {
     // TODO(SCN-244): handle this more robustly.
     FXL_DCHECK(false) << "Display channel lost";
     return;
   }

   // Read FIDL message.
   uint8_t byte_buffer[ZX_CHANNEL_MAX_MSG_BYTES];
   fidl::Message msg(fidl::BytePart(byte_buffer, ZX_CHANNEL_MAX_MSG_BYTES),
                     fidl::HandlePart());
   if (msg.Read(dc_channel_, 0) != ZX_OK || !msg.has_header()) {
     FXL_LOG(WARNING) << "Display callback read failed";
     return;
   }
   // Re-arm the wait.
   wait_.Begin(async_get_default_dispatcher());

   // TODO(FIDL-183): Resolve this hack when synchronous interfaces
   // support events.
   static_cast<fuchsia::hardware::display::Controller::Proxy_*>(
       event_dispatcher_.get())
       ->Dispatch_(std::move(msg));
 }

 void DisplayManager::DisplaysChanged(
     ::std::vector<fuchsia::hardware::display::Info> added,
     ::std::vector<uint64_t> removed) {
   if (!default_display_) {
     FXL_DCHECK(added.size());

     auto& display = added[0];
     auto& mode = display.modes[0];

     zx_status_t status;
     zx_status_t transport_status =
         display_controller_->CreateLayer(&status, &layer_id_);
     if (transport_status != ZX_OK || status != ZX_OK) {
       FXL_LOG(ERROR) << "Failed to create layer";
       return;
     }

     std::vector<uint64_t> layers;
     layers.push_back(layer_id_);
     ::fidl::VectorPtr<uint64_t> fidl_layers(std::move(layers));
     status = display_controller_->SetDisplayLayers(display.id,
                                                    std::move(fidl_layers));
     if (status != ZX_OK) {
       FXL_LOG(ERROR) << "Failed to configure display layers";
       return;
     }

     default_display_ = std::make_unique<Display>(
         display.id, mode.horizontal_resolution, mode.vertical_resolution,
         std::move(display.pixel_format));
     ClientOwnershipChange(owns_display_controller_);

     display_available_cb_();
     display_available_cb_ = nullptr;
   } else {
     for (uint64_t id : removed) {
       if (default_display_->display_id() == id) {
         // TODO(SCN-244): handle this more robustly.
         FXL_DCHECK(false) << "Display disconnected";
         wait_.Cancel();
         return;
       }
     }
   }
 }

 void DisplayManager::ClientOwnershipChange(bool has_ownership) {
   owns_display_controller_ = has_ownership;
   if (default_display_) {
     if (has_ownership) {
       default_display_->ownership_event().signal(
           fuchsia::ui::scenic::displayNotOwnedSignal,
           fuchsia::ui::scenic::displayOwnedSignal);
     } else {
       default_display_->ownership_event().signal(
           fuchsia::ui::scenic::displayOwnedSignal,
           fuchsia::ui::scenic::displayNotOwnedSignal);
     }
   }
 }

 uint64_t DisplayManager::ImportEvent(const zx::event& event) {
   zx::event dup;
   uint64_t event_id = next_event_id_++;
   if (event.duplicate(ZX_RIGHT_SAME_RIGHTS, &dup) == ZX_OK &&
       display_controller_->ImportEvent(std::move(dup), event_id) == ZX_OK) {
     return event_id;
   }
   return fuchsia::hardware::display::invalidId;
 }

 void DisplayManager::ReleaseEvent(uint64_t id) {
   display_controller_->ReleaseEvent(id);
 }

 void DisplayManager::SetImageConfig(int32_t width, int32_t height,
                                     zx_pixel_format_t format) {
   image_config_.height = height;
   image_config_.width = width;
   image_config_.pixel_format = format;

 #if defined(__x86_64__)
   // IMAGE_TYPE_X_TILED from ddk/protocol/intelgpucore.h
   image_config_.type = 1;
 #elif defined(__aarch64__)
   image_config_.type = 0;
 #else
   FXL_DCHECK(false) << "Display swapchain only supported on intel and ARM";
 #endif

   display_controller_->SetLayerPrimaryConfig(layer_id_, image_config_);
 }

 uint64_t DisplayManager::ImportImage(uint64_t collection_id, uint32_t index) {
   zx_status_t status, result_status = ZX_OK;
   uint64_t id;
   status = display_controller_->ImportImage(image_config_, collection_id, index,
                                             &result_status, &id);
   if (status != ZX_OK || result_status != ZX_OK) {
     return fuchsia::hardware::display::invalidId;
   }
   return id;
 }

 void DisplayManager::ReleaseImage(uint64_t id) {
   display_controller_->ReleaseImage(id);
 }

 fuchsia::sysmem::BufferCollectionTokenSyncPtr
 DisplayManager::CreateBufferCollection() {
   fuchsia::sysmem::BufferCollectionTokenSyncPtr local_token;
   zx_status_t status =
       sysmem_allocator_->AllocateSharedCollection(local_token.NewRequest());
   if (status != ZX_OK) {
     FXL_DLOG(ERROR) << "CreateBufferCollection failed " << status;
     return nullptr;
   }
   return local_token;
 }

 fuchsia::sysmem::BufferCollectionSyncPtr DisplayManager::GetCollectionFromToken(
     fuchsia::sysmem::BufferCollectionTokenSyncPtr token) {
   fuchsia::sysmem::BufferCollectionSyncPtr collection;
   zx_status_t status = sysmem_allocator_->BindSharedCollection(
       std::move(token), collection.NewRequest());
   if (status != ZX_OK) {
     FXL_DLOG(ERROR) << "BindSharedCollection failed " << status;
     return nullptr;
   }
   return collection;
 }

 uint64_t DisplayManager::ImportBufferCollection(
     fuchsia::sysmem::BufferCollectionTokenSyncPtr token) {
   uint64_t buffer_collection_id = next_buffer_collection_id_++;
   zx_status_t status;
   if (display_controller_->ImportBufferCollection(
           buffer_collection_id, std::move(token), &status) != ZX_OK ||
       status != ZX_OK) {
     FXL_DLOG(ERROR) << "ImportBufferCollection failed - status: " << status;
     return 0;
   }

   if (display_controller_->SetBufferCollectionConstraints(
           buffer_collection_id, image_config_, &status) != ZX_OK ||
       status != ZX_OK) {
     FXL_DLOG(ERROR) << "SetBufferCollectionConstraints failed.";
     display_controller_->ReleaseBufferCollection(buffer_collection_id);
     return 0;
   }

   return buffer_collection_id;
 }

 void DisplayManager::ReleaseBufferCollection(uint64_t id) {
   display_controller_->ReleaseBufferCollection(id);
 }

 void DisplayManager::Flip(Display* display, uint64_t buffer,
                           uint64_t render_finished_event_id,
                           uint64_t signal_event_id) {
   zx_status_t status = display_controller_->SetLayerImage(
       layer_id_, buffer, render_finished_event_id, signal_event_id);
   // TODO(SCN-244): handle this more robustly.
   FXL_DCHECK(status == ZX_OK) << "DisplayManager::Flip failed";

   status = display_controller_->ApplyConfig();
   // TODO(SCN-244): handle this more robustly.
   FXL_DCHECK(status == ZX_OK) << "DisplayManager::Flip failed";
 }

 bool DisplayManager::EnableVsync(VsyncCallback vsync_cb) {
   vsync_cb_ = std::move(vsync_cb);
   return display_controller_->EnableVsync(true) == ZX_OK;
 }

 }  // namespace gfx
 }  // namespace scenic_impl
	// Copyright 2017 The Fuchsia Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include "garnet/lib/ui/gfx/displays/display_manager.h"

	#include <lib/async/default.h>
	#include <lib/fdio/directory.h>
	#include <trace/event.h>
	#include <zircon/syscalls.h>

	#include "fuchsia/ui/scenic/cpp/fidl.h"

	namespace scenic_impl {
	namespace gfx {

	DisplayManager::DisplayManager() {
	zx_status_t status = fdio_service_connect(
	"/svc/fuchsia.sysmem.Allocator",
	sysmem_allocator_.NewRequest().TakeChannel().release());
	if (status != ZX_OK) {
	sysmem_allocator_.Unbind();
	FXL_LOG(ERROR) << "Unable to connect to sysmem: " << status;
	}
	}

	DisplayManager::~DisplayManager() {
	if (wait_.object() != ZX_HANDLE_INVALID) {
	wait_.Cancel();
	}
	}

	void DisplayManager::WaitForDefaultDisplay(fit::closure callback) {
	FXL_DCHECK(!default_display_);

	display_available_cb_ = std::move(callback);
	display_watcher_.WaitForDisplay(
	[this](zx::channel device, zx::channel dc_handle) {
	dc_device_ = std::move(device);
	dc_channel_ = dc_handle.get();
	display_controller_.Bind(std::move(dc_handle));

	// TODO(FIDL-183): Resolve this hack when synchronous interfaces
	// support events.
	auto dispatcher =
	static_cast<fuchsia::hardware::display::Controller::Proxy_*>(
	event_dispatcher_.get());
	dispatcher->DisplaysChanged = [this](auto added, auto removed) {
	DisplaysChanged(std::move(added), std::move(removed));
	};
	dispatcher->ClientOwnershipChange = [this](auto change) {
	ClientOwnershipChange(change);
	};
	dispatcher->Vsync = [this](uint64_t display_id, uint64_t timestamp,
	::std::vector<uint64_t> images) {
	if (display_id == default_display_->display_id() && vsync_cb_) {
	vsync_cb_(timestamp, images);
	}
	};

	wait_.set_object(dc_channel_);
	wait_.set_trigger(ZX_CHANNEL_READABLE \| ZX_CHANNEL_PEER_CLOSED);
	wait_.Begin(async_get_default_dispatcher());
	});
	}

	void DisplayManager::OnAsync(async_dispatcher_t* dispatcher,
	async::WaitBase* self, zx_status_t status,
	const zx_packet_signal_t* signal) {
	if (status & ZX_CHANNEL_PEER_CLOSED) {
	// TODO(SCN-244): handle this more robustly.
	FXL_DCHECK(false) << "Display channel lost";
	return;
	}

	// Read FIDL message.
	uint8_t byte_buffer[ZX_CHANNEL_MAX_MSG_BYTES];
	fidl::Message msg(fidl::BytePart(byte_buffer, ZX_CHANNEL_MAX_MSG_BYTES),
	fidl::HandlePart());
	if (msg.Read(dc_channel_, 0) != ZX_OK \|\| !msg.has_header()) {
	FXL_LOG(WARNING) << "Display callback read failed";
	return;
	}
	// Re-arm the wait.
	wait_.Begin(async_get_default_dispatcher());

	// TODO(FIDL-183): Resolve this hack when synchronous interfaces
	// support events.
	static_cast<fuchsia::hardware::display::Controller::Proxy_*>(
	event_dispatcher_.get())
	->Dispatch_(std::move(msg));
	}

	void DisplayManager::DisplaysChanged(
	::std::vector<fuchsia::hardware::display::Info> added,
	::std::vector<uint64_t> removed) {
	if (!default_display_) {
	FXL_DCHECK(added.size());

	auto& display = added[0];
	auto& mode = display.modes[0];

	zx_status_t status;
	zx_status_t transport_status =
	display_controller_->CreateLayer(&status, &layer_id_);
	if (transport_status != ZX_OK \|\| status != ZX_OK) {
	FXL_LOG(ERROR) << "Failed to create layer";
	return;
	}

	std::vector<uint64_t> layers;
	layers.push_back(layer_id_);
	::fidl::VectorPtr<uint64_t> fidl_layers(std::move(layers));
	status = display_controller_->SetDisplayLayers(display.id,
	std::move(fidl_layers));
	if (status != ZX_OK) {
	FXL_LOG(ERROR) << "Failed to configure display layers";
	return;
	}

	default_display_ = std::make_unique<Display>(
	display.id, mode.horizontal_resolution, mode.vertical_resolution,
	std::move(display.pixel_format));
	ClientOwnershipChange(owns_display_controller_);

	display_available_cb_();
	display_available_cb_ = nullptr;
	} else {
	for (uint64_t id : removed) {
	if (default_display_->display_id() == id) {
	// TODO(SCN-244): handle this more robustly.
	FXL_DCHECK(false) << "Display disconnected";
	wait_.Cancel();
	return;
	}
	}
	}
	}

	void DisplayManager::ClientOwnershipChange(bool has_ownership) {
	owns_display_controller_ = has_ownership;
	if (default_display_) {
	if (has_ownership) {
	default_display_->ownership_event().signal(
	fuchsia::ui::scenic::displayNotOwnedSignal,
	fuchsia::ui::scenic::displayOwnedSignal);
	} else {
	default_display_->ownership_event().signal(
	fuchsia::ui::scenic::displayOwnedSignal,
	fuchsia::ui::scenic::displayNotOwnedSignal);
	}
	}
	}

	uint64_t DisplayManager::ImportEvent(const zx::event& event) {
	zx::event dup;
	uint64_t event_id = next_event_id_++;
	if (event.duplicate(ZX_RIGHT_SAME_RIGHTS, &dup) == ZX_OK &&
	display_controller_->ImportEvent(std::move(dup), event_id) == ZX_OK) {
	return event_id;
	}
	return fuchsia::hardware::display::invalidId;
	}

	void DisplayManager::ReleaseEvent(uint64_t id) {
	display_controller_->ReleaseEvent(id);
	}

	void DisplayManager::SetImageConfig(int32_t width, int32_t height,
	zx_pixel_format_t format) {
	image_config_.height = height;
	image_config_.width = width;
	image_config_.pixel_format = format;

	#if defined(__x86_64__)
	// IMAGE_TYPE_X_TILED from ddk/protocol/intelgpucore.h
	image_config_.type = 1;
	#elif defined(__aarch64__)
	image_config_.type = 0;
	#else
	FXL_DCHECK(false) << "Display swapchain only supported on intel and ARM";
	#endif

	display_controller_->SetLayerPrimaryConfig(layer_id_, image_config_);
	}

	uint64_t DisplayManager::ImportImage(uint64_t collection_id, uint32_t index) {
	zx_status_t status, result_status = ZX_OK;
	uint64_t id;
	status = display_controller_->ImportImage(image_config_, collection_id, index,
	&result_status, &id);
	if (status != ZX_OK \|\| result_status != ZX_OK) {
	return fuchsia::hardware::display::invalidId;
	}
	return id;
	}

	void DisplayManager::ReleaseImage(uint64_t id) {
	display_controller_->ReleaseImage(id);
	}

	fuchsia::sysmem::BufferCollectionTokenSyncPtr
	DisplayManager::CreateBufferCollection() {
	fuchsia::sysmem::BufferCollectionTokenSyncPtr local_token;
	zx_status_t status =
	sysmem_allocator_->AllocateSharedCollection(local_token.NewRequest());
	if (status != ZX_OK) {
	FXL_DLOG(ERROR) << "CreateBufferCollection failed " << status;
	return nullptr;
	}
	return local_token;
	}

	fuchsia::sysmem::BufferCollectionSyncPtr DisplayManager::GetCollectionFromToken(
	fuchsia::sysmem::BufferCollectionTokenSyncPtr token) {
	fuchsia::sysmem::BufferCollectionSyncPtr collection;
	zx_status_t status = sysmem_allocator_->BindSharedCollection(
	std::move(token), collection.NewRequest());
	if (status != ZX_OK) {
	FXL_DLOG(ERROR) << "BindSharedCollection failed " << status;
	return nullptr;
	}
	return collection;
	}

	uint64_t DisplayManager::ImportBufferCollection(
	fuchsia::sysmem::BufferCollectionTokenSyncPtr token) {
	uint64_t buffer_collection_id = next_buffer_collection_id_++;
	zx_status_t status;
	if (display_controller_->ImportBufferCollection(
	buffer_collection_id, std::move(token), &status) != ZX_OK \|\|
	status != ZX_OK) {
	FXL_DLOG(ERROR) << "ImportBufferCollection failed - status: " << status;
	return 0;
	}

	if (display_controller_->SetBufferCollectionConstraints(
	buffer_collection_id, image_config_, &status) != ZX_OK \|\|
	status != ZX_OK) {
	FXL_DLOG(ERROR) << "SetBufferCollectionConstraints failed.";
	display_controller_->ReleaseBufferCollection(buffer_collection_id);
	return 0;
	}

	return buffer_collection_id;
	}

	void DisplayManager::ReleaseBufferCollection(uint64_t id) {
	display_controller_->ReleaseBufferCollection(id);
	}

	void DisplayManager::Flip(Display* display, uint64_t buffer,
	uint64_t render_finished_event_id,
	uint64_t signal_event_id) {
	zx_status_t status = display_controller_->SetLayerImage(
	layer_id_, buffer, render_finished_event_id, signal_event_id);
	// TODO(SCN-244): handle this more robustly.
	FXL_DCHECK(status == ZX_OK) << "DisplayManager::Flip failed";

	status = display_controller_->ApplyConfig();
	// TODO(SCN-244): handle this more robustly.
	FXL_DCHECK(status == ZX_OK) << "DisplayManager::Flip failed";
	}

	bool DisplayManager::EnableVsync(VsyncCallback vsync_cb) {
	vsync_cb_ = std::move(vsync_cb);
	return display_controller_->EnableVsync(true) == ZX_OK;
	}

	} // namespace gfx
	} // namespace scenic_impl