libs/vr/libbufferhub/ion_buffer.cpp - android_frameworks_native - Gitiles

 #include <private/dvr/ion_buffer.h>

 #include <cutils/log.h>
 #define ATRACE_TAG ATRACE_TAG_GRAPHICS
 #include <utils/Trace.h>

 #include <mutex>

 namespace android {
 namespace dvr {

 gralloc_module_t const* IonBuffer::gralloc_module_ = nullptr;
 alloc_device_t* IonBuffer::gralloc_device_ = nullptr;

 IonBuffer::IonBuffer() : IonBuffer(nullptr, 0, 0, 0, 0, 0, 0, 0) {}

 IonBuffer::IonBuffer(int width, int height, int format, int usage)
     : IonBuffer() {
   Alloc(width, height, format, usage);
 }

 IonBuffer::IonBuffer(buffer_handle_t handle, int width, int height, int stride,
                      int format, int usage)
     : IonBuffer(handle, width, height, 1, stride, 0, format, usage) {}

 IonBuffer::IonBuffer(buffer_handle_t handle, int width, int height,
                      int layer_count, int stride, int layer_stride, int format,
                      int usage)
     : handle_(handle),
       width_(width),
       height_(height),
       layer_count_(layer_count),
       stride_(stride),
       layer_stride_(layer_stride),
       format_(format),
       usage_(usage),
       locked_(false),
       needs_unregister_(false) {
   ALOGD_IF(TRACE,
            "IonBuffer::IonBuffer: handle=%p width=%d height=%d layer_count=%d "
            "stride=%d layer stride=%d format=%d usage=%d",
            handle_, width_, height_, layer_count_, stride_, layer_stride_,
            format_, usage_);
   GrallocInit();
 }

 IonBuffer::~IonBuffer() {
   ALOGD_IF(TRACE,
            "IonBuffer::~IonBuffer: handle=%p width=%d height=%d stride=%d "
            "format=%d usage=%d",
            handle_, width_, height_, stride_, format_, usage_);

   FreeHandle();
 }

 IonBuffer::IonBuffer(IonBuffer&& other) : IonBuffer() {
   *this = std::move(other);
 }

 IonBuffer& IonBuffer::operator=(IonBuffer&& other) {
   ALOGD_IF(TRACE, "IonBuffer::operator=: handle_=%p other.handle_=%p", handle_,
            other.handle_);

   if (this != &other) {
     Replace(other.handle_, other.width_, other.height_, other.layer_count_,
             other.stride_, other.layer_stride_, other.format_, other.usage_,
             other.needs_unregister_);
     locked_ = other.locked_;
     other.handle_ = nullptr;
     other.FreeHandle();
   }

   return *this;
 }

 void IonBuffer::FreeHandle() {
   if (handle_) {
     // Lock/Unlock don't need to be balanced, but one Unlock is needed to
     // clean/unmap the buffer. Warn if this didn't happen before freeing the
     // native handle.
     ALOGW_IF(locked_,
              "IonBuffer::FreeHandle: freeing a locked handle!!! handle=%p",
              handle_);

     if (needs_unregister_) {
       int ret = gralloc_module_->unregisterBuffer(gralloc_module_, handle_);
       ALOGE_IF(ret < 0,
                "IonBuffer::FreeHandle: Failed to unregister handle: %s",
                strerror(-ret));

       native_handle_close(const_cast<native_handle_t*>(handle_));
       native_handle_delete(const_cast<native_handle_t*>(handle_));
     } else {
       int ret = gralloc_device_->free(gralloc_device_, handle_);
       if (ret < 0) {
         ALOGE("IonBuffer::FreeHandle: failed to free buffer: %s",
               strerror(-ret));

         // Not sure if this is the right thing to do. Attempting to prevent a
         // memory leak of the native handle.
         native_handle_close(const_cast<native_handle_t*>(handle_));
         native_handle_delete(const_cast<native_handle_t*>(handle_));
       }
     }
   }

   // Always re-initialize these members, even if handle_ was nullptr, in case
   // someone was dumb enough to pass a nullptr handle to the constructor or
   // Reset.
   handle_ = nullptr;
   width_ = 0;
   height_ = 0;
   layer_count_ = 0;
   stride_ = 0;
   layer_stride_ = 0;
   format_ = 0;
   usage_ = 0;
   locked_ = false;
   needs_unregister_ = false;
 }

 int IonBuffer::Alloc(int width, int height, int format, int usage) {
   ATRACE_NAME("IonBuffer::Alloc");
   ALOGD_IF(TRACE, "IonBuffer::Alloc: width=%d height=%d format=%d usage=%d",
            width, height, format, usage);

   int stride;
   buffer_handle_t handle;

   int ret = gralloc_device_->alloc(gralloc_device_, width, height, format,
                                    usage, &handle, &stride);
   if (ret < 0) {
     ALOGE("IonBuffer::Alloc: failed to allocate gralloc buffer: %s",
           strerror(-ret));
     return ret;
   }

   Replace(handle, width, height, 1, stride, 0, format, usage, false);
   return 0;
 }

 void IonBuffer::Replace(buffer_handle_t handle, int width, int height,
                         int layer_count, int stride, int layer_stride,
                         int format, int usage, bool needs_unregister) {
   FreeHandle();

   handle_ = handle;
   width_ = width;
   height_ = height;
   layer_count_ = layer_count;
   stride_ = stride;
   layer_stride_ = layer_stride;
   format_ = format;
   usage_ = usage;
   needs_unregister_ = needs_unregister;
 }

 void IonBuffer::Reset(buffer_handle_t handle, int width, int height, int stride,
                       int format, int usage) {
   ALOGD_IF(TRACE,
            "IonBuffer::Reset: handle=%p width=%d height=%d stride=%d format=%d "
            "usage=%d",
            handle, width, height, stride, format, usage);

   Replace(handle, width, height, 1, stride, 0, format, usage, false);
 }

 int IonBuffer::Import(buffer_handle_t handle, int width, int height, int stride,
                       int format, int usage) {
   ATRACE_NAME("IonBuffer::Import1");
   ALOGD_IF(
       TRACE,
       "IonBuffer::Import: handle=%p width=%d height=%d stride=%d format=%d "
       "usage=%d",
       handle, width, height, stride, format, usage);

   int ret = gralloc_module_->registerBuffer(gralloc_module_, handle);
   if (ret < 0) {
     ALOGE("IonBuffer::Import: failed to import handle: %s", strerror(-ret));
     return ret;
   }

   Replace(handle, width, height, 1, stride, 0, format, usage, true);
   return 0;
 }

 int IonBuffer::Import(const int* fd_array, int fd_count, const int* int_array,
                       int int_count, int width, int height, int stride,
                       int format, int usage) {
   ATRACE_NAME("IonBuffer::Import2");
   ALOGD_IF(TRACE,
            "IonBuffer::Import: fd_count=%d int_count=%d width=%d height=%d "
            "stride=%d format=%d usage=%d",
            fd_count, int_count, width, height, stride, format, usage);

   if (fd_count < 0 || int_count < 0) {
     ALOGE("IonBuffer::Import: invalid arguments.");
     return -EINVAL;
   }

   native_handle_t* handle = native_handle_create(fd_count, int_count);
   if (!handle) {
     ALOGE("IonBuffer::Import: failed to create new native handle.");
     return -ENOMEM;
   }

   // Copy fd_array into the first part of handle->data and int_array right
   // after it.
   memcpy(handle->data, fd_array, sizeof(int) * fd_count);
   memcpy(handle->data + fd_count, int_array, sizeof(int) * int_count);

   int ret = Import(handle, width, height, stride, format, usage);
   if (ret < 0) {
     ALOGE("IonBuffer::Import: failed to import raw native handle: %s",
           strerror(-ret));
     native_handle_close(handle);
     native_handle_delete(handle);
   }

   return ret;
 }

 int IonBuffer::Duplicate(const IonBuffer* other) {
   if (!other->handle())
     return -EINVAL;

   const int fd_count = other->handle()->numFds;
   const int int_count = other->handle()->numInts;

   if (fd_count < 0 || int_count < 0)
     return -EINVAL;

   native_handle_t* handle = native_handle_create(fd_count, int_count);
   if (!handle) {
     ALOGE("IonBuffer::Duplicate: Failed to create new native handle.");
     return -ENOMEM;
   }

   // Duplicate the file descriptors from the other native handle.
   for (int i = 0; i < fd_count; i++)
     handle->data[i] = dup(other->handle()->data[i]);

   // Copy the ints after the file descriptors.
   memcpy(handle->data + fd_count, other->handle()->data + fd_count,
          sizeof(int) * int_count);

   const int ret = Import(handle, other->width(), other->height(),
                          other->stride(), other->format(), other->usage());
   if (ret < 0) {
     ALOGE("IonBuffer::Duplicate: Failed to import duplicate native handle: %s",
           strerror(-ret));
     native_handle_close(handle);
     native_handle_delete(handle);
   }

   return ret;
 }

 int IonBuffer::Lock(int usage, int x, int y, int width, int height,
                     void** address) {
   ATRACE_NAME("IonBuffer::Lock");
   ALOGD_IF(TRACE,
            "IonBuffer::Lock: handle=%p usage=%d x=%d y=%d width=%d height=%d "
            "address=%p",
            handle_, usage, x, y, width, height, address);

   // Lock may be called multiple times; but only one Unlock is required.
   const int err = gralloc_module_->lock(gralloc_module_, handle_, usage, x, y,
                                         width, height, address);
   if (!err)
     locked_ = true;

   return err;
 }

 int IonBuffer::LockYUV(int usage, int x, int y, int width, int height,
                        struct android_ycbcr* yuv) {
   ATRACE_NAME("IonBuffer::LockYUV");
   ALOGD_IF(TRACE,
            "IonBuffer::Lock: handle=%p usage=%d x=%d y=%d width=%d height=%d",
            handle_, usage, x, y, width, height);
   const int err = gralloc_module_->lock_ycbcr(gralloc_module_, handle_, usage,
                                               x, y, width, height, yuv);
   if (!err)
     locked_ = true;

   return err;
 }

 int IonBuffer::Unlock() {
   ATRACE_NAME("IonBuffer::Unlock");
   ALOGD_IF(TRACE, "IonBuffer::Unlock: handle=%p", handle_);

   // Lock may be called multiple times; but only one Unlock is required.
   const int err = gralloc_module_->unlock(gralloc_module_, handle_);
   if (!err)
     locked_ = false;

   return err;
 }

 void IonBuffer::GrallocInit() {
   static std::once_flag gralloc_flag;
   std::call_once(gralloc_flag, []() {
     hw_module_t const* module = nullptr;
     alloc_device_t* device = nullptr;

     int err = hw_get_module(GRALLOC_HARDWARE_MODULE_ID, &module);
     ALOGE_IF(err, "IonBuffer::GrallocInit: failed to find the %s module: %s",
              GRALLOC_HARDWARE_MODULE_ID, strerror(-err));

     err = gralloc_open(module, &device);
     ALOGE_IF(err, "IonBuffer::GrallocInit: failed to open gralloc device: %s",
              strerror(-err));

     gralloc_module_ = reinterpret_cast<gralloc_module_t const*>(module);
     gralloc_device_ = device;
   });
 }

 }  // namespace dvr
 }  // namespace android
	#include <private/dvr/ion_buffer.h>

	#include <cutils/log.h>
	#define ATRACE_TAG ATRACE_TAG_GRAPHICS
	#include <utils/Trace.h>

	#include <mutex>

	namespace android {
	namespace dvr {

	gralloc_module_t const* IonBuffer::gralloc_module_ = nullptr;
	alloc_device_t* IonBuffer::gralloc_device_ = nullptr;

	IonBuffer::IonBuffer() : IonBuffer(nullptr, 0, 0, 0, 0, 0, 0, 0) {}

	IonBuffer::IonBuffer(int width, int height, int format, int usage)
	: IonBuffer() {
	Alloc(width, height, format, usage);
	}

	IonBuffer::IonBuffer(buffer_handle_t handle, int width, int height, int stride,
	int format, int usage)
	: IonBuffer(handle, width, height, 1, stride, 0, format, usage) {}

	IonBuffer::IonBuffer(buffer_handle_t handle, int width, int height,
	int layer_count, int stride, int layer_stride, int format,
	int usage)
	: handle_(handle),
	width_(width),
	height_(height),
	layer_count_(layer_count),
	stride_(stride),
	layer_stride_(layer_stride),
	format_(format),
	usage_(usage),
	locked_(false),
	needs_unregister_(false) {
	ALOGD_IF(TRACE,
	"IonBuffer::IonBuffer: handle=%p width=%d height=%d layer_count=%d "
	"stride=%d layer stride=%d format=%d usage=%d",
	handle_, width_, height_, layer_count_, stride_, layer_stride_,
	format_, usage_);
	GrallocInit();
	}

	IonBuffer::~IonBuffer() {
	ALOGD_IF(TRACE,
	"IonBuffer::~IonBuffer: handle=%p width=%d height=%d stride=%d "
	"format=%d usage=%d",
	handle_, width_, height_, stride_, format_, usage_);

	FreeHandle();
	}

	IonBuffer::IonBuffer(IonBuffer&& other) : IonBuffer() {
	*this = std::move(other);
	}

	IonBuffer& IonBuffer::operator=(IonBuffer&& other) {
	ALOGD_IF(TRACE, "IonBuffer::operator=: handle_=%p other.handle_=%p", handle_,
	other.handle_);

	if (this != &other) {
	Replace(other.handle_, other.width_, other.height_, other.layer_count_,
	other.stride_, other.layer_stride_, other.format_, other.usage_,
	other.needs_unregister_);
	locked_ = other.locked_;
	other.handle_ = nullptr;
	other.FreeHandle();
	}

	return *this;
	}

	void IonBuffer::FreeHandle() {
	if (handle_) {
	// Lock/Unlock don't need to be balanced, but one Unlock is needed to
	// clean/unmap the buffer. Warn if this didn't happen before freeing the
	// native handle.
	ALOGW_IF(locked_,
	"IonBuffer::FreeHandle: freeing a locked handle!!! handle=%p",
	handle_);

	if (needs_unregister_) {
	int ret = gralloc_module_->unregisterBuffer(gralloc_module_, handle_);
	ALOGE_IF(ret < 0,
	"IonBuffer::FreeHandle: Failed to unregister handle: %s",
	strerror(-ret));

	native_handle_close(const_cast<native_handle_t*>(handle_));
	native_handle_delete(const_cast<native_handle_t*>(handle_));
	} else {
	int ret = gralloc_device_->free(gralloc_device_, handle_);
	if (ret < 0) {
	ALOGE("IonBuffer::FreeHandle: failed to free buffer: %s",
	strerror(-ret));

	// Not sure if this is the right thing to do. Attempting to prevent a
	// memory leak of the native handle.
	native_handle_close(const_cast<native_handle_t*>(handle_));
	native_handle_delete(const_cast<native_handle_t*>(handle_));
	}
	}
	}

	// Always re-initialize these members, even if handle_ was nullptr, in case
	// someone was dumb enough to pass a nullptr handle to the constructor or
	// Reset.
	handle_ = nullptr;
	width_ = 0;
	height_ = 0;
	layer_count_ = 0;
	stride_ = 0;
	layer_stride_ = 0;
	format_ = 0;
	usage_ = 0;
	locked_ = false;
	needs_unregister_ = false;
	}

	int IonBuffer::Alloc(int width, int height, int format, int usage) {
	ATRACE_NAME("IonBuffer::Alloc");
	ALOGD_IF(TRACE, "IonBuffer::Alloc: width=%d height=%d format=%d usage=%d",
	width, height, format, usage);

	int stride;
	buffer_handle_t handle;

	int ret = gralloc_device_->alloc(gralloc_device_, width, height, format,
	usage, &handle, &stride);
	if (ret < 0) {
	ALOGE("IonBuffer::Alloc: failed to allocate gralloc buffer: %s",
	strerror(-ret));
	return ret;
	}

	Replace(handle, width, height, 1, stride, 0, format, usage, false);
	return 0;
	}

	void IonBuffer::Replace(buffer_handle_t handle, int width, int height,
	int layer_count, int stride, int layer_stride,
	int format, int usage, bool needs_unregister) {
	FreeHandle();

	handle_ = handle;
	width_ = width;
	height_ = height;
	layer_count_ = layer_count;
	stride_ = stride;
	layer_stride_ = layer_stride;
	format_ = format;
	usage_ = usage;
	needs_unregister_ = needs_unregister;
	}

	void IonBuffer::Reset(buffer_handle_t handle, int width, int height, int stride,
	int format, int usage) {
	ALOGD_IF(TRACE,
	"IonBuffer::Reset: handle=%p width=%d height=%d stride=%d format=%d "
	"usage=%d",
	handle, width, height, stride, format, usage);

	Replace(handle, width, height, 1, stride, 0, format, usage, false);
	}

	int IonBuffer::Import(buffer_handle_t handle, int width, int height, int stride,
	int format, int usage) {
	ATRACE_NAME("IonBuffer::Import1");
	ALOGD_IF(
	TRACE,
	"IonBuffer::Import: handle=%p width=%d height=%d stride=%d format=%d "
	"usage=%d",
	handle, width, height, stride, format, usage);

	int ret = gralloc_module_->registerBuffer(gralloc_module_, handle);
	if (ret < 0) {
	ALOGE("IonBuffer::Import: failed to import handle: %s", strerror(-ret));
	return ret;
	}

	Replace(handle, width, height, 1, stride, 0, format, usage, true);
	return 0;
	}

	int IonBuffer::Import(const int* fd_array, int fd_count, const int* int_array,
	int int_count, int width, int height, int stride,
	int format, int usage) {
	ATRACE_NAME("IonBuffer::Import2");
	ALOGD_IF(TRACE,
	"IonBuffer::Import: fd_count=%d int_count=%d width=%d height=%d "
	"stride=%d format=%d usage=%d",
	fd_count, int_count, width, height, stride, format, usage);

	if (fd_count < 0 \|\| int_count < 0) {
	ALOGE("IonBuffer::Import: invalid arguments.");
	return -EINVAL;
	}

	native_handle_t* handle = native_handle_create(fd_count, int_count);
	if (!handle) {
	ALOGE("IonBuffer::Import: failed to create new native handle.");
	return -ENOMEM;
	}

	// Copy fd_array into the first part of handle->data and int_array right
	// after it.
	memcpy(handle->data, fd_array, sizeof(int) * fd_count);
	memcpy(handle->data + fd_count, int_array, sizeof(int) * int_count);

	int ret = Import(handle, width, height, stride, format, usage);
	if (ret < 0) {
	ALOGE("IonBuffer::Import: failed to import raw native handle: %s",
	strerror(-ret));
	native_handle_close(handle);
	native_handle_delete(handle);
	}

	return ret;
	}

	int IonBuffer::Duplicate(const IonBuffer* other) {
	if (!other->handle())
	return -EINVAL;

	const int fd_count = other->handle()->numFds;
	const int int_count = other->handle()->numInts;

	if (fd_count < 0 \|\| int_count < 0)
	return -EINVAL;

	native_handle_t* handle = native_handle_create(fd_count, int_count);
	if (!handle) {
	ALOGE("IonBuffer::Duplicate: Failed to create new native handle.");
	return -ENOMEM;
	}

	// Duplicate the file descriptors from the other native handle.
	for (int i = 0; i < fd_count; i++)
	handle->data[i] = dup(other->handle()->data[i]);

	// Copy the ints after the file descriptors.
	memcpy(handle->data + fd_count, other->handle()->data + fd_count,
	sizeof(int) * int_count);

	const int ret = Import(handle, other->width(), other->height(),
	other->stride(), other->format(), other->usage());
	if (ret < 0) {
	ALOGE("IonBuffer::Duplicate: Failed to import duplicate native handle: %s",
	strerror(-ret));
	native_handle_close(handle);
	native_handle_delete(handle);
	}

	return ret;
	}

	int IonBuffer::Lock(int usage, int x, int y, int width, int height,
	void** address) {
	ATRACE_NAME("IonBuffer::Lock");
	ALOGD_IF(TRACE,
	"IonBuffer::Lock: handle=%p usage=%d x=%d y=%d width=%d height=%d "
	"address=%p",
	handle_, usage, x, y, width, height, address);

	// Lock may be called multiple times; but only one Unlock is required.
	const int err = gralloc_module_->lock(gralloc_module_, handle_, usage, x, y,
	width, height, address);
	if (!err)
	locked_ = true;

	return err;
	}

	int IonBuffer::LockYUV(int usage, int x, int y, int width, int height,
	struct android_ycbcr* yuv) {
	ATRACE_NAME("IonBuffer::LockYUV");
	ALOGD_IF(TRACE,
	"IonBuffer::Lock: handle=%p usage=%d x=%d y=%d width=%d height=%d",
	handle_, usage, x, y, width, height);
	const int err = gralloc_module_->lock_ycbcr(gralloc_module_, handle_, usage,
	x, y, width, height, yuv);
	if (!err)
	locked_ = true;

	return err;
	}

	int IonBuffer::Unlock() {
	ATRACE_NAME("IonBuffer::Unlock");
	ALOGD_IF(TRACE, "IonBuffer::Unlock: handle=%p", handle_);

	// Lock may be called multiple times; but only one Unlock is required.
	const int err = gralloc_module_->unlock(gralloc_module_, handle_);
	if (!err)
	locked_ = false;

	return err;
	}

	void IonBuffer::GrallocInit() {
	static std::once_flag gralloc_flag;
	std::call_once(gralloc_flag, []() {
	hw_module_t const* module = nullptr;
	alloc_device_t* device = nullptr;

	int err = hw_get_module(GRALLOC_HARDWARE_MODULE_ID, &module);
	ALOGE_IF(err, "IonBuffer::GrallocInit: failed to find the %s module: %s",
	GRALLOC_HARDWARE_MODULE_ID, strerror(-err));

	err = gralloc_open(module, &device);
	ALOGE_IF(err, "IonBuffer::GrallocInit: failed to open gralloc device: %s",
	strerror(-err));

	gralloc_module_ = reinterpret_cast<gralloc_module_t const*>(module);
	gralloc_device_ = device;
	});
	}

	} // namespace dvr
	} // namespace android