system/ulib/sysmem/sysmem.cpp - zircon/ - Git at Google

 // Copyright 2018 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 <lib/sysmem/sysmem.h>

 #include <fbl/algorithm.h>
 #include <fuchsia/sysmem/c/fidl.h>
 #include <lib/fidl-async/bind.h>
 #include <lib/syslog/global.h>
 #include <lib/zx/vmo.h>
 #include <string.h>
 #include <zircon/assert.h>
 #include <zircon/syscalls.h>

 constexpr char kTag[] = "sysmem";

 namespace {

 // A helper function to set the plane info for the most common YUV planar formats.
 // The width and height fields of |format| must be valid before calling
 // this function.
 // |format|->layers and |format|->planes will be set.
 // The intensity (Y in YUV) is assumed to be present at full resolution, in the
 // first plane, with |y_bits_per_pixel| representing each pixel.
 // The U and V planes follow.  |uv_together| indicates that U and V are both located on
 // the second plane; otherwise U and V are located on planes 2 and 3.
 // This function assumes U and V are represented equally.
 // |uv_horizontal_bits_per_pixel| indicates how many bits each pixel is represented by
 // for a horizontal line only - the vertical subsampling is indicated by |uv_vertical_subsample|,
 // so a UV plane that is subsampled 2x2 and U and V are 8 bit interleaved (i.e. NV12)
 // (This means for every 2 Y pixels, there is one U byte and one V byte)
 // would give uv_horizontal_bits_per_pixel = 4 (8 bits for U and 8 for V for every 2 pixels), and
 // a uv_vertical_subsample = 2, to indicate that those 8 bits actually correspond to a set
 // of 4 pixels.
 // |buffer_size| is set to the total (maximum) image size, rounded up to the nearest page boundary.
 void SetImagePlaneInfoPlanarYuv(fuchsia_sysmem_ImageFormat* format,
                                 size_t* buffer_size, uint32_t y_bits_per_pixel,
                                 uint32_t uv_horizontal_bits_per_pixel,
                                 uint32_t uv_vertical_subsample,
                                 bool uv_together, bool page_align_layers = false) {
     uint32_t offset;
     format->planes[0].byte_offset = 0;
     format->planes[0].bytes_per_row = (format->width * y_bits_per_pixel) / 8;
     offset = format->planes[0].bytes_per_row * format->height;
     offset = page_align_layers ? fbl::round_up(offset, ZX_PAGE_SIZE) : offset;
     format->planes[1].bytes_per_row = (format->width * uv_horizontal_bits_per_pixel * (uv_together ? 2 : 1)) / 8;
     format->planes[1].byte_offset = offset;
     offset += format->planes[1].bytes_per_row * format->height / uv_vertical_subsample;
     offset = page_align_layers ? fbl::round_up(offset, ZX_PAGE_SIZE) : offset;
     format->layers = 2;
     if (!uv_together) {
         format->layers = 3;
         format->planes[2].bytes_per_row = format->planes[1].bytes_per_row;
         format->planes[2].byte_offset = offset;
         offset += format->planes[2].bytes_per_row * format->height / uv_vertical_subsample;
     }
     *buffer_size = fbl::round_up(offset, ZX_PAGE_SIZE);
 }

 // A helper function to set the plane info for the most common packed formats.
 // The width and height fields of |format| must be valid before calling
 // this function.
 // |format|->layers and |format|->planes will be set.
 // |buffer_size| is set to the total (maximum) image buffer size, rounded up to the nearest page boundary.
 void SetImagePlaneInfoPacked(fuchsia_sysmem_ImageFormat* format,
                              size_t* buffer_size, uint32_t bits_per_pixel) {
     format->planes[0].bytes_per_row = (format->width * bits_per_pixel) / 8;
     format->layers = 1;
     *buffer_size = fbl::round_up(format->height * format->planes[0].bytes_per_row, ZX_PAGE_SIZE);
 }

 zx_status_t PickImageFormat(const fuchsia_sysmem_BufferSpec& spec,
                             fuchsia_sysmem_ImageFormat* format,
                             size_t* buffer_size) {
     // If hardware compatibility needs to be checked, do so here!
     // For the simple case, just use whatever format was specified.
     format->width = spec.image.min_width;
     format->height = spec.image.min_height;
     format->pixel_format = spec.image.pixel_format;
     format->color_space = spec.image.color_space;
     // Need to fill out the plane info, which depends on pixel_format:
     // (More generally, it also depends on color space and BufferUsage,
     // but this is a simplified version.)
     switch (format->pixel_format.type) {
     case fuchsia_sysmem_PixelFormatType_R8G8B8A8:
     case fuchsia_sysmem_PixelFormatType_BGRA32:
         SetImagePlaneInfoPacked(format, buffer_size, 32);
         break;
     case fuchsia_sysmem_PixelFormatType_YUY2:
         SetImagePlaneInfoPacked(format, buffer_size, 16);
         break;
     // NV12 has an NxN Y plane and an interlaced (N/2)x(N/2) U and V plane.
     case fuchsia_sysmem_PixelFormatType_NV12:
         SetImagePlaneInfoPlanarYuv(format, buffer_size, 8, 4, 2, true, false);
         break;
     // I420 has an NxN Y plane and separate (N/2)x(N/2) U and V planes.
     case fuchsia_sysmem_PixelFormatType_I420:
         SetImagePlaneInfoPlanarYuv(format, buffer_size, 8, 4, 2, false, false);
         break;
     // M420 is interleaved version of I420, with 2 rows of Y and one row of equal size with
     // 2x2 subsampled U and V.  It results in 12 bits per pixel, but since it is organized
     // as height * 1.5 rows, SetImagePlaneInfoPacked will not work if line padding is != 0.
     case fuchsia_sysmem_PixelFormatType_M420:
         SetImagePlaneInfoPacked(format, buffer_size, 12);
         break;
     default:
         FX_LOGF(ERROR, kTag, "Unsupported pixel format %u\n", format->pixel_format.type);
         // static_cast<const uint32_t>(spec.image.pixel_format));
         return ZX_ERR_NOT_SUPPORTED;
     }
     return ZX_OK;
 }

 } // namespace

 static zx_status_t Allocator_AllocateCollection(void* ctx,
                                                 uint32_t buffer_count,
                                                 const fuchsia_sysmem_BufferSpec* spec,
                                                 const fuchsia_sysmem_BufferUsage* usage,
                                                 fidl_txn_t* txn) {
     fuchsia_sysmem_BufferCollectionInfo info;
     memset(&info, 0, sizeof(info));
     // Most basic usage of the allocator: create vmos with no special vendor format:
     // 1) Pick which format gets used.  For the simple case, just use whatever format was given.
     //    We also assume here that the format is an ImageFormat
     ZX_ASSERT(info.format.tag == fuchsia_sysmem_BufferSpecTag_image);
     zx_status_t status = PickImageFormat(*spec, &info.format.image, &info.vmo_size);
     if (status != ZX_OK) {
         FX_LOG(ERROR, kTag, "Failed to pick format for Buffer Collection\n");
         return fuchsia_sysmem_AllocatorAllocateCollection_reply(txn, status, &info);
     }

     // 3) Allocate the buffers.  This will be specialized for different formats.
     info.buffer_count = buffer_count;
     for (uint32_t i = 0; i < buffer_count; ++i) {
         status = zx_vmo_create(info.vmo_size, 0, &info.vmos[i]);
         if (status != ZX_OK) {
             // Close the handles we created already.  We do not support partial allocations.
             for (uint32_t j = 0; j < i; ++j) {
                 zx_handle_close(info.vmos[j]);
                 info.vmos[j] = ZX_HANDLE_INVALID;
             }
             info.buffer_count = 0;
             FX_LOG(ERROR, kTag, "Failed to allocate Buffer Collection\n");
             return fuchsia_sysmem_AllocatorAllocateCollection_reply(txn, ZX_ERR_NO_MEMORY, &info);
         }
     }
     // If everything is happy and allocated, can give ZX_OK:
     return fuchsia_sysmem_AllocatorAllocateCollection_reply(txn, ZX_OK, &info);
 }

 static zx_status_t Allocator_AllocateSharedCollection(void* ctx,
                                                       uint32_t buffer_count,
                                                       const fuchsia_sysmem_BufferSpec* spec,
                                                       zx_handle_t token_peer,
                                                       fidl_txn_t* txn) {
     return fuchsia_sysmem_AllocatorAllocateSharedCollection_reply(txn, ZX_ERR_NOT_SUPPORTED);
 }

 static zx_status_t Allocator_BindSharedCollection(void* ctx,
                                                   const fuchsia_sysmem_BufferUsage* usage,
                                                   zx_handle_t token,
                                                   fidl_txn_t* txn) {
     fuchsia_sysmem_BufferCollectionInfo info;
     memset(&info, 0, sizeof(info));
     return fuchsia_sysmem_AllocatorBindSharedCollection_reply(txn, ZX_ERR_NOT_SUPPORTED, &info);
 }

 static constexpr const fuchsia_sysmem_Allocator_ops_t allocator_ops = {
     .AllocateCollection = Allocator_AllocateCollection,
     .AllocateSharedCollection = Allocator_AllocateSharedCollection,
     .BindSharedCollection = Allocator_BindSharedCollection,
 };

 static zx_status_t connect(void* ctx, async_dispatcher_t* dispatcher,
                            const char* service_name, zx_handle_t request) {
     if (!strcmp(service_name, fuchsia_sysmem_Allocator_Name)) {
         return fidl_bind(dispatcher, request,
                          (fidl_dispatch_t*)fuchsia_sysmem_Allocator_dispatch,
                          ctx, &allocator_ops);
     }

     zx_handle_close(request);
     return ZX_ERR_NOT_SUPPORTED;
 }

 static constexpr const char* sysmem_services[] = {
     fuchsia_sysmem_Allocator_Name,
     nullptr,
 };

 static constexpr zx_service_ops_t sysmem_ops = {
     .init = nullptr,
     .connect = connect,
     .release = nullptr,
 };

 static constexpr zx_service_provider_t sysmem_service_provider = {
     .version = SERVICE_PROVIDER_VERSION,
     .services = sysmem_services,
     .ops = &sysmem_ops,
 };

 const zx_service_provider_t* sysmem_get_service_provider() {
     return &sysmem_service_provider;
 }
	// Copyright 2018 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 <lib/sysmem/sysmem.h>

	#include <fbl/algorithm.h>
	#include <fuchsia/sysmem/c/fidl.h>
	#include <lib/fidl-async/bind.h>
	#include <lib/syslog/global.h>
	#include <lib/zx/vmo.h>
	#include <string.h>
	#include <zircon/assert.h>
	#include <zircon/syscalls.h>

	constexpr char kTag[] = "sysmem";

	namespace {

	// A helper function to set the plane info for the most common YUV planar formats.
	// The width and height fields of \|format\| must be valid before calling
	// this function.
	// \|format\|->layers and \|format\|->planes will be set.
	// The intensity (Y in YUV) is assumed to be present at full resolution, in the
	// first plane, with \|y_bits_per_pixel\| representing each pixel.
	// The U and V planes follow. \|uv_together\| indicates that U and V are both located on
	// the second plane; otherwise U and V are located on planes 2 and 3.
	// This function assumes U and V are represented equally.
	// \|uv_horizontal_bits_per_pixel\| indicates how many bits each pixel is represented by
	// for a horizontal line only - the vertical subsampling is indicated by \|uv_vertical_subsample\|,
	// so a UV plane that is subsampled 2x2 and U and V are 8 bit interleaved (i.e. NV12)
	// (This means for every 2 Y pixels, there is one U byte and one V byte)
	// would give uv_horizontal_bits_per_pixel = 4 (8 bits for U and 8 for V for every 2 pixels), and
	// a uv_vertical_subsample = 2, to indicate that those 8 bits actually correspond to a set
	// of 4 pixels.
	// \|buffer_size\| is set to the total (maximum) image size, rounded up to the nearest page boundary.
	void SetImagePlaneInfoPlanarYuv(fuchsia_sysmem_ImageFormat* format,
	size_t* buffer_size, uint32_t y_bits_per_pixel,
	uint32_t uv_horizontal_bits_per_pixel,
	uint32_t uv_vertical_subsample,
	bool uv_together, bool page_align_layers = false) {
	uint32_t offset;
	format->planes[0].byte_offset = 0;
	format->planes[0].bytes_per_row = (format->width * y_bits_per_pixel) / 8;
	offset = format->planes[0].bytes_per_row * format->height;
	offset = page_align_layers ? fbl::round_up(offset, ZX_PAGE_SIZE) : offset;
	format->planes[1].bytes_per_row = (format->width * uv_horizontal_bits_per_pixel * (uv_together ? 2 : 1)) / 8;
	format->planes[1].byte_offset = offset;
	offset += format->planes[1].bytes_per_row * format->height / uv_vertical_subsample;
	offset = page_align_layers ? fbl::round_up(offset, ZX_PAGE_SIZE) : offset;
	format->layers = 2;
	if (!uv_together) {
	format->layers = 3;
	format->planes[2].bytes_per_row = format->planes[1].bytes_per_row;
	format->planes[2].byte_offset = offset;
	offset += format->planes[2].bytes_per_row * format->height / uv_vertical_subsample;
	}
	*buffer_size = fbl::round_up(offset, ZX_PAGE_SIZE);
	}

	// A helper function to set the plane info for the most common packed formats.
	// The width and height fields of \|format\| must be valid before calling
	// this function.
	// \|format\|->layers and \|format\|->planes will be set.
	// \|buffer_size\| is set to the total (maximum) image buffer size, rounded up to the nearest page boundary.
	void SetImagePlaneInfoPacked(fuchsia_sysmem_ImageFormat* format,
	size_t* buffer_size, uint32_t bits_per_pixel) {
	format->planes[0].bytes_per_row = (format->width * bits_per_pixel) / 8;
	format->layers = 1;
	buffer_size = fbl::round_up(format->height format->planes[0].bytes_per_row, ZX_PAGE_SIZE);
	}

	zx_status_t PickImageFormat(const fuchsia_sysmem_BufferSpec& spec,
	fuchsia_sysmem_ImageFormat* format,
	size_t* buffer_size) {
	// If hardware compatibility needs to be checked, do so here!
	// For the simple case, just use whatever format was specified.
	format->width = spec.image.min_width;
	format->height = spec.image.min_height;
	format->pixel_format = spec.image.pixel_format;
	format->color_space = spec.image.color_space;
	// Need to fill out the plane info, which depends on pixel_format:
	// (More generally, it also depends on color space and BufferUsage,
	// but this is a simplified version.)
	switch (format->pixel_format.type) {
	case fuchsia_sysmem_PixelFormatType_R8G8B8A8:
	case fuchsia_sysmem_PixelFormatType_BGRA32:
	SetImagePlaneInfoPacked(format, buffer_size, 32);
	break;
	case fuchsia_sysmem_PixelFormatType_YUY2:
	SetImagePlaneInfoPacked(format, buffer_size, 16);
	break;
	// NV12 has an NxN Y plane and an interlaced (N/2)x(N/2) U and V plane.
	case fuchsia_sysmem_PixelFormatType_NV12:
	SetImagePlaneInfoPlanarYuv(format, buffer_size, 8, 4, 2, true, false);
	break;
	// I420 has an NxN Y plane and separate (N/2)x(N/2) U and V planes.
	case fuchsia_sysmem_PixelFormatType_I420:
	SetImagePlaneInfoPlanarYuv(format, buffer_size, 8, 4, 2, false, false);
	break;
	// M420 is interleaved version of I420, with 2 rows of Y and one row of equal size with
	// 2x2 subsampled U and V. It results in 12 bits per pixel, but since it is organized
	// as height * 1.5 rows, SetImagePlaneInfoPacked will not work if line padding is != 0.
	case fuchsia_sysmem_PixelFormatType_M420:
	SetImagePlaneInfoPacked(format, buffer_size, 12);
	break;
	default:
	FX_LOGF(ERROR, kTag, "Unsupported pixel format %u\n", format->pixel_format.type);
	// static_cast<const uint32_t>(spec.image.pixel_format));
	return ZX_ERR_NOT_SUPPORTED;
	}
	return ZX_OK;
	}

	} // namespace

	static zx_status_t Allocator_AllocateCollection(void* ctx,
	uint32_t buffer_count,
	const fuchsia_sysmem_BufferSpec* spec,
	const fuchsia_sysmem_BufferUsage* usage,
	fidl_txn_t* txn) {
	fuchsia_sysmem_BufferCollectionInfo info;
	memset(&info, 0, sizeof(info));
	// Most basic usage of the allocator: create vmos with no special vendor format:
	// 1) Pick which format gets used. For the simple case, just use whatever format was given.
	// We also assume here that the format is an ImageFormat
	ZX_ASSERT(info.format.tag == fuchsia_sysmem_BufferSpecTag_image);
	zx_status_t status = PickImageFormat(*spec, &info.format.image, &info.vmo_size);
	if (status != ZX_OK) {
	FX_LOG(ERROR, kTag, "Failed to pick format for Buffer Collection\n");
	return fuchsia_sysmem_AllocatorAllocateCollection_reply(txn, status, &info);
	}

	// 3) Allocate the buffers. This will be specialized for different formats.
	info.buffer_count = buffer_count;
	for (uint32_t i = 0; i < buffer_count; ++i) {
	status = zx_vmo_create(info.vmo_size, 0, &info.vmos[i]);
	if (status != ZX_OK) {
	// Close the handles we created already. We do not support partial allocations.
	for (uint32_t j = 0; j < i; ++j) {
	zx_handle_close(info.vmos[j]);
	info.vmos[j] = ZX_HANDLE_INVALID;
	}
	info.buffer_count = 0;
	FX_LOG(ERROR, kTag, "Failed to allocate Buffer Collection\n");
	return fuchsia_sysmem_AllocatorAllocateCollection_reply(txn, ZX_ERR_NO_MEMORY, &info);
	}
	}
	// If everything is happy and allocated, can give ZX_OK:
	return fuchsia_sysmem_AllocatorAllocateCollection_reply(txn, ZX_OK, &info);
	}

	static zx_status_t Allocator_AllocateSharedCollection(void* ctx,
	uint32_t buffer_count,
	const fuchsia_sysmem_BufferSpec* spec,
	zx_handle_t token_peer,
	fidl_txn_t* txn) {
	return fuchsia_sysmem_AllocatorAllocateSharedCollection_reply(txn, ZX_ERR_NOT_SUPPORTED);
	}

	static zx_status_t Allocator_BindSharedCollection(void* ctx,
	const fuchsia_sysmem_BufferUsage* usage,
	zx_handle_t token,
	fidl_txn_t* txn) {
	fuchsia_sysmem_BufferCollectionInfo info;
	memset(&info, 0, sizeof(info));
	return fuchsia_sysmem_AllocatorBindSharedCollection_reply(txn, ZX_ERR_NOT_SUPPORTED, &info);
	}

	static constexpr const fuchsia_sysmem_Allocator_ops_t allocator_ops = {
	.AllocateCollection = Allocator_AllocateCollection,
	.AllocateSharedCollection = Allocator_AllocateSharedCollection,
	.BindSharedCollection = Allocator_BindSharedCollection,
	};

	static zx_status_t connect(void* ctx, async_dispatcher_t* dispatcher,
	const char* service_name, zx_handle_t request) {
	if (!strcmp(service_name, fuchsia_sysmem_Allocator_Name)) {
	return fidl_bind(dispatcher, request,
	(fidl_dispatch_t*)fuchsia_sysmem_Allocator_dispatch,
	ctx, &allocator_ops);
	}

	zx_handle_close(request);
	return ZX_ERR_NOT_SUPPORTED;
	}

	static constexpr const char* sysmem_services[] = {
	fuchsia_sysmem_Allocator_Name,
	nullptr,
	};

	static constexpr zx_service_ops_t sysmem_ops = {
	.init = nullptr,
	.connect = connect,
	.release = nullptr,
	};

	static constexpr zx_service_provider_t sysmem_service_provider = {
	.version = SERVICE_PROVIDER_VERSION,
	.services = sysmem_services,
	.ops = &sysmem_ops,
	};

	const zx_service_provider_t* sysmem_get_service_provider() {
	return &sysmem_service_provider;
	}