/*
|
* Copyright (c) 2021 by Allwinnertech Co., Ltd.
|
*
|
* 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 "CameraHALv3_V4L2Gralloc"
|
|
#include "v4l2_gralloc.h"
|
|
#include <hardware/camera3.h>
|
#include <hardware/gralloc.h>
|
#include <linux/videodev2.h>
|
#include <system/graphics.h>
|
#include <ui/GraphicBufferMapper.h>
|
#include <ui/Rect.h>
|
|
#include <cstdlib>
|
#include <memory>
|
|
#include "stream_format.h"
|
#include GPU_PUBLIC_INCLUDE
|
|
namespace v4l2_camera_hal {
|
|
// Copy |height| lines from |src| to |dest|,
|
// where |src| and |dest| may have different line lengths.
|
void copyWithPadding(uint8_t* dest,
|
const uint8_t* src,
|
size_t dest_stride,
|
size_t src_stride,
|
size_t height) {
|
size_t copy_stride = dest_stride;
|
if (copy_stride > src_stride) {
|
// Adding padding, not reducing. 0 out the extra memory.
|
memset(dest, 0, src_stride * height);
|
copy_stride = src_stride;
|
}
|
uint8_t* dest_line_start = dest;
|
const uint8_t* src_line_start = src;
|
for (size_t row = 0; row < height;
|
++row, dest_line_start += dest_stride, src_line_start += src_stride) {
|
memcpy(dest_line_start, src_line_start, copy_stride);
|
}
|
}
|
|
V4L2Gralloc* V4L2Gralloc::NewV4L2Gralloc() {
|
// Initialize and check the gralloc module.
|
const hw_module_t* module = nullptr;
|
int res = hw_get_module(GRALLOC_HARDWARE_MODULE_ID, &module);
|
if (res || !module) {
|
HAL_LOGE("Couldn't get gralloc module.");
|
return nullptr;
|
}
|
const gralloc_module_t* gralloc =
|
reinterpret_cast<const gralloc_module_t*>(module);
|
|
return new V4L2Gralloc(gralloc);
|
}
|
|
// Private. As checked by above factory, module will be non-null
|
// and a supported version.
|
V4L2Gralloc::V4L2Gralloc(const gralloc_module_t* module) : mModule(module) {
|
for (int i = 0; i< MAX_BUFFER_NUM; i++) {
|
aBufferData[i] = (BufferData *)malloc(sizeof(BufferData));
|
memset(aBufferData[i] , 0, sizeof(BufferData));
|
}
|
}
|
|
V4L2Gralloc::~V4L2Gralloc() {
|
// Unlock buffers that are still locked.
|
unlockAllBuffers();
|
for (int i = 0; i< MAX_BUFFER_NUM; i++) {
|
free(aBufferData[i]);
|
}
|
}
|
|
int V4L2Gralloc::get_share_fd(const buffer_handle_t* buffer,
|
int* sharefd,
|
unsigned long * mJpegBufferSizes) {
|
// Lock the camera buffer (varies depending on if the buffer is YUV or not).
|
private_handle_t* hnd = (private_handle_t *)(*buffer);
|
HAL_LOGD("buffer_handle_t buffer : %p, hnd->height:%d, hnd->width:%d, "
|
"hnd->usage:0x%x, hnd->share_fd:%d.",
|
*buffer, hnd->height, hnd->width,
|
hnd->usage, hnd->share_fd);
|
*mJpegBufferSizes = hnd->width*hnd->height;
|
*sharefd = hnd->share_fd;
|
return 0;
|
}
|
|
int V4L2Gralloc::lock_handle(const buffer_handle_t* buffer,
|
void ** dst_addr) {
|
int ret = -1;
|
void* virFromGralloc;
|
private_handle_t* hnd = (private_handle_t *)(*buffer);
|
HAL_LOGD("buffer_handle_t buffer : %p, hnd->height:%d, "
|
"hnd->width:%d, hnd->usage:0x%x.",
|
*buffer, hnd->height, hnd->width, hnd->usage);
|
|
/* let the graphics framework to lock the buffer,
|
* and get the virtual address. */
|
const android::Rect rect(hnd->width, hnd->height);
|
android::GraphicBufferMapper& grbuffer_mapper(
|
android::GraphicBufferMapper::get());
|
ret = grbuffer_mapper.lock(*buffer, hnd->usage, rect, &virFromGralloc);
|
HAL_LOGV("virFromGralloc = %p ", virFromGralloc);
|
if (ret != 1) {
|
HAL_LOGD("grbuffer_mapper.lock : %d -> %s",
|
ret, strerror(ret));
|
}
|
*dst_addr = virFromGralloc;
|
HAL_LOGD("lock get buffer vaddr is %p", *dst_addr);
|
return 0;
|
}
|
|
int V4L2Gralloc::lock_handle_ycbcr(const buffer_handle_t* buffer,
|
android_ycbcr* ycbcr_dst_addr) {
|
int ret = -1;
|
private_handle_t* hnd = (private_handle_t *)(*buffer);
|
HAL_LOGV("buffer_handle_t buffer : %p, hnd->height:%d,"
|
" hnd->width:%d, hnd->usage:0x%x.",
|
*buffer, hnd->height, hnd->width, hnd->usage);
|
// let the graphics framework to lock the buffer, and get the virtual address.
|
const android::Rect rect(hnd->width, hnd->height);
|
android::GraphicBufferMapper& grbuffer_mapper(
|
android::GraphicBufferMapper::get());
|
ret = grbuffer_mapper.lockYCbCr(*buffer, hnd->usage, rect, ycbcr_dst_addr);
|
if (ret != 1) {
|
HAL_LOGV("grbuffer_mapper.lock : %d -> %s",
|
ret, strerror(ret));
|
}
|
HAL_LOGV("lock get buffer vaddr is %p", (void*)ycbcr_dst_addr);
|
return 0;
|
}
|
|
int V4L2Gralloc::lock_handle(const buffer_handle_t* buffer,
|
void** dst_addr,
|
unsigned long * mJpegBufferSizes) {
|
// Lock the camera buffer (varies depending on if the buffer is YUV or not).
|
private_handle_t *hnd = (private_handle_t *)(*buffer);
|
HAL_LOGD("buffer_handle_t buffer : %p, hnd->height:%d, "
|
"hnd->width:%d, hnd->usage:0x%x, hnd->share_fd:%d.",
|
*buffer,
|
hnd->height,
|
hnd->width,
|
hnd->usage,
|
hnd->share_fd);
|
*mJpegBufferSizes = hnd->width * hnd->height;
|
int ret = -1;
|
void * virFromGralloc;
|
|
// let the graphics framework to lock the buffer,
|
// and get the virtual address.
|
const android::Rect rect(hnd->width, hnd->height);
|
android::GraphicBufferMapper& grbuffer_mapper(
|
android::GraphicBufferMapper::get());
|
ret = grbuffer_mapper.lock(*buffer, hnd->usage, rect, &virFromGralloc);
|
HAL_LOGV("virFromGralloc = %p ", virFromGralloc);
|
if (ret != 1) {
|
HAL_LOGD("%s: grbuffer_mapper.lock: %d -> %s",
|
__FUNCTION__, ret, strerror(ret));
|
}
|
*dst_addr = virFromGralloc;
|
HAL_LOGD("lock get buffer vaddr is %p", *dst_addr);
|
|
return 0;
|
}
|
|
int V4L2Gralloc::unlock_handle(const buffer_handle_t* buffer) {
|
int ret = -1;
|
private_handle_t* hnd = (private_handle_t *)(*buffer);
|
HAL_LOGV("buffer : %p,The id is %lld.", *buffer, hnd->aw_buf_id);
|
// let the graphics framework to lock the buffer,
|
// and get the virtual address.
|
const android::Rect rect(hnd->width, hnd->height);
|
android::GraphicBufferMapper& grbuffer_mapper(
|
android::GraphicBufferMapper::get());
|
ret = grbuffer_mapper.unlock(*buffer);
|
if (ret != 1) {
|
HAL_LOGV("grbuffer_mapper.unlock: %d -> %s", ret, strerror(ret));
|
}
|
return 0;
|
}
|
|
int V4L2Gralloc::lock_buffer(const camera3_stream_buffer_t* camera_buffer,
|
unsigned long* device_buffer) {
|
// Lock the camera buffer (varies depending on if the buffer is YUV or not).
|
buffer_handle_t buffer = *camera_buffer->buffer;
|
camera3_stream_t* stream = camera_buffer->stream;
|
int ret = 0;
|
private_handle_t *hnd = (private_handle_t *)buffer;
|
|
HAL_LOGV("buffer_handle_t buffer : %p, hnd->height:%d, hnd->width:%d.",
|
buffer, hnd->height, hnd->width);
|
|
void* data;
|
ret = mModule->lock(mModule,
|
buffer,
|
stream->usage,
|
0,
|
0,
|
stream->width,
|
stream->height,
|
&data);
|
|
if (ret) {
|
HAL_LOGE("Failed to lock buffer: %d", ret);
|
return ret;
|
}
|
HAL_LOGV("*camera_buffer->buffer:0x%p, stream->width:%d,"
|
" stream->height:%d, lock buffer:%p.",
|
(*camera_buffer->buffer),
|
stream->width,
|
stream->height, data);
|
// If so, great, point to the beginning.
|
if (!data) {
|
ALOGE("Gralloc lock returned null ptr");
|
return -ENODEV;
|
}
|
*device_buffer = reinterpret_cast<unsigned long>(data);
|
HAL_LOGD("lock get buffer vaddr is %p", (void*)device_buffer);
|
return 0;
|
}
|
|
int V4L2Gralloc::unlock_buffer(const camera3_stream_buffer_t* camera_buffer) {
|
buffer_handle_t buffer = *camera_buffer->buffer;
|
private_handle_t *hnd = (private_handle_t *)buffer;
|
HAL_LOGV("buffer : %p,The id is %lld.", buffer, hnd->aw_buf_id);
|
// Unlock.
|
int res = mModule->unlock(mModule, buffer);
|
if (res) {
|
HAL_LOGE("Failed to unlock buffer at %p", buffer);
|
return -ENODEV;
|
}
|
return 0;
|
}
|
|
int V4L2Gralloc::lock_pic(const camera3_stream_buffer_t* camera_buffer,
|
unsigned long* device_buffer) {
|
// Lock the camera buffer (varies depending on if the buffer is YUV or not).
|
buffer_handle_t buffer = *camera_buffer->buffer;
|
void* data;
|
camera3_stream_t* stream = camera_buffer->stream;
|
int ret = 0;
|
HAL_LOGV("buffer_handle_t buffer : %p", buffer);
|
|
void* nv21_data;
|
ret = mModule->lock(mModule,
|
buffer,
|
stream->usage,
|
0,
|
0,
|
stream->width,
|
stream->height,
|
&nv21_data);
|
if (ret) {
|
HAL_LOGE("Failed to lock buffer: %d", ret);
|
return ret;
|
}
|
HAL_LOGV("*camera_buffer->buffer:0x%p, stream->width:%d, stream->height:%d.",
|
(*camera_buffer->buffer), stream->width, stream->height);
|
// If so, great, point to the beginning.
|
data = nv21_data;
|
HAL_LOGD("yuv_data:0x%p.", nv21_data);
|
if (!data) {
|
ALOGE("Gralloc lock returned null ptr");
|
return -ENODEV;
|
}
|
|
// Set up the device buffer.
|
static_assert(sizeof(unsigned long) >= sizeof(void*),
|
"void* must be able to fit in the v4l2_buffer m.userptr "
|
"field (unsigned long) for this code to work");
|
|
*device_buffer = reinterpret_cast<unsigned long>(data);
|
HAL_LOGD("lock get buffer vaddr is %p", (void*)device_buffer);
|
return 0;
|
}
|
|
int V4L2Gralloc::lock_index(const camera3_stream_buffer_t* camera_buffer,
|
unsigned long* device_buffer,
|
uint32_t result_index) {
|
// Lock the camera buffer (varies depending on if the buffer is YUV or not).
|
buffer_handle_t buffer = *camera_buffer->buffer;
|
void* data;
|
camera3_stream_t* stream = camera_buffer->stream;
|
int ret = 0;
|
HAL_LOGV("buffer_handle_t buffer : %p", buffer);
|
aBufferDataVideo[result_index] = buffer;
|
|
void* nv21_data;
|
ret = mModule->lock(mModule,
|
buffer,
|
stream->usage,
|
0,
|
0,
|
stream->width,
|
stream->height,
|
&nv21_data);
|
if (ret) {
|
HAL_LOGE("Failed to lock buffer: %d", ret);
|
return ret;
|
}
|
HAL_LOGV("*camera_buffer->buffer:0x%p, stream->width:%d, stream->height:%d.",
|
(*camera_buffer->buffer), stream->width, stream->height);
|
// If so, great, point to the beginning.
|
data = nv21_data;
|
|
if (!data) {
|
ALOGE("Gralloc lock returned null ptr");
|
return -ENODEV;
|
}
|
|
*device_buffer = reinterpret_cast<unsigned long>(data);
|
HAL_LOGD("lock get buffer vaddr is %p",(void*)device_buffer);
|
return 0;
|
}
|
|
int V4L2Gralloc::unlock_index(uint32_t result_index) {
|
const buffer_handle_t buffer = aBufferDataVideo[result_index];
|
private_handle_t *hnd = (private_handle_t *)buffer;
|
HAL_LOGV("buffer_handle_t[%d] buffer : %p,The id is %lld.",
|
result_index, buffer, hnd->aw_buf_id);
|
// Unlock.
|
int res = mModule->unlock(mModule, buffer);
|
if (res) {
|
HAL_LOGE("Failed to unlock buffer at %p", buffer);
|
return -ENODEV;
|
}
|
|
return 0;
|
}
|
|
int V4L2Gralloc::lock(const camera3_stream_buffer_t* camera_buffer,
|
uint32_t bytes_per_line,
|
v4l2_buffer* device_buffer) {
|
// Lock the camera buffer (varies depending on if the buffer is YUV or not).
|
std::shared_ptr<BufferData> buffer_data(
|
new BufferData{camera_buffer, bytes_per_line});
|
memcpy(aBufferData[device_buffer->index],
|
buffer_data.get(),
|
sizeof(BufferData));
|
|
HAL_LOGD("aBufferData[%d]:%p, camera_buffer:%p.",
|
device_buffer->index,
|
aBufferData[device_buffer->index],
|
aBufferData[device_buffer->index]->camera_buffer);
|
|
buffer_handle_t buffer = *camera_buffer->buffer;
|
void* data;
|
camera3_stream_t* stream = camera_buffer->stream;
|
private_handle_t *hnd = (private_handle_t *)buffer;
|
int ret = 0;
|
HAL_LOGV("buffer_handle_t[%d] buffer : %p,"
|
" The camera_buffer is %p,id is %lld.",
|
device_buffer->index, buffer, camera_buffer, hnd->aw_buf_id);
|
|
switch (StreamFormat::HalToV4L2PixelFormat(stream->format)) {
|
case V4L2_PIX_FMT_NV21:
|
case V4L2_PIX_FMT_NV12:
|
case V4L2_PIX_FMT_YUV420:
|
void* nv21_data;
|
ret = mModule->lock(mModule,
|
buffer,
|
stream->usage,
|
0,
|
0,
|
stream->width,
|
stream->height,
|
&nv21_data);
|
if (ret) {
|
HAL_LOGE("Failed to lock buffer: %d", ret);
|
return ret;
|
}
|
HAL_LOGV("*camera_buffer->buffer:0x%p, stream->width:%d,"
|
" stream->height:%d, bytes_per_line:%d.",
|
(*camera_buffer->buffer),
|
stream->width,
|
stream->height, bytes_per_line);
|
// If so, great, point to the beginning.
|
data = nv21_data;
|
HAL_LOGD("yuv_data:0x%p, bytes_per_line:%d.",
|
nv21_data, bytes_per_line);
|
break;
|
// TODO(b/30119452): support more YCbCr formats.
|
case V4L2_PIX_FMT_YVU420:
|
android_ycbcr yuv_data;
|
ret = mModule->lock_ycbcr(mModule,
|
buffer,
|
stream->usage,
|
0,
|
0,
|
stream->width,
|
stream->height,
|
&yuv_data);
|
if (ret) {
|
HAL_LOGE("Failed to lock ycbcr buffer: %d", ret);
|
return ret;
|
}
|
HAL_LOGV("*camera_buffer->buffer:0x%p, stream->width:%d,"
|
" stream->height:%d, bytes_per_line:%d.",
|
(*camera_buffer->buffer),
|
stream->width,
|
stream->height,
|
bytes_per_line);
|
HAL_LOGV("yuv_data.ystride:%zu, yuv_data.cstride:%zu,"
|
" yuv_data.chroma_step:%zu, yuv_data.y:0x%p, yuv_data.cb:0x%p, "
|
"yuv_data.cr:0x%p.",
|
yuv_data.ystride,
|
yuv_data.cstride,
|
yuv_data.chroma_step,
|
yuv_data.y,
|
yuv_data.cb,
|
yuv_data.cr);
|
|
// Check if gralloc format matches v4l2 format
|
// (same padding, not interleaved, contiguous).
|
// In there yuv_data.chroma_step is difference.
|
// So what the yuv_data.chroma_step meant for buffer?
|
if (1) {
|
// If so, great, point to the beginning.
|
data = yuv_data.y;
|
HAL_LOGD("yuv_data.y:0x%p, bytes_per_line:%d.",
|
yuv_data.y, bytes_per_line);
|
} else {
|
// If not, allocate a contiguous buffer of appropriate size
|
// (to be transformed back upon unlock).
|
data = new uint8_t[device_buffer->length];
|
// Make a dynamically-allocated copy of yuv_data,
|
// since it will be needed at transform time.
|
// buffer_data->transform_dest.reset(new android_ycbcr(yuv_data));
|
}
|
break;
|
case V4L2_PIX_FMT_JPEG:
|
// Jpeg buffers are just contiguous blobs; lock length * 1.
|
ret = mModule->lock(mModule,
|
buffer,
|
stream->usage,
|
0,
|
0,
|
device_buffer->length,
|
1,
|
&data);
|
if (ret) {
|
HAL_LOGE("Failed to lock jpeg buffer: %d", ret);
|
return ret;
|
}
|
break;
|
case V4L2_PIX_FMT_BGR32: // Fall-through.
|
case V4L2_PIX_FMT_RGB32:
|
// RGB formats have nice agreed upon representation. Unless using android
|
// flex formats.
|
ret = mModule->lock(mModule,
|
buffer,
|
stream->usage,
|
0,
|
0,
|
stream->width,
|
stream->height,
|
&data);
|
if (ret) {
|
HAL_LOGE("Failed to lock RGB buffer: %d", ret);
|
return ret;
|
}
|
break;
|
default:
|
return -EINVAL;
|
}
|
|
if (!data) {
|
ALOGE("Gralloc lock returned null ptr");
|
return -ENODEV;
|
}
|
|
// Set up the device buffer.
|
static_assert(sizeof(unsigned long) >= sizeof(void*),
|
"void* must be able to fit in the v4l2_buffer m.userptr "
|
"field (unsigned long) for this code to work");
|
|
if (V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE == device_buffer->type) {
|
// Note the mapping of index:buffer info for when unlock is called.
|
device_buffer->m.planes[0].m.userptr =
|
reinterpret_cast<unsigned long>(data);
|
|
} else if (V4L2_BUF_TYPE_VIDEO_CAPTURE == device_buffer->type) {
|
// Note the mapping of index:buffer info for when unlock is called.
|
device_buffer->m.userptr = reinterpret_cast<unsigned long>(data);
|
}
|
device_buffer->m.planes[0].m.userptr = reinterpret_cast<unsigned long>(data);
|
HAL_LOGD("lock get index:%d buffer vaddr is %p", device_buffer->index, data);
|
|
return 0;
|
}
|
|
int V4L2Gralloc::unlock(const v4l2_buffer* device_buffer) {
|
// TODO(b/30000211): support multi-planar data (video_capture_mplane).
|
if (device_buffer->type != V4L2_CAPTURE_TYPE) {
|
return -EINVAL;
|
}
|
HAL_LOGV("unlock get index:%d buffer ", device_buffer->index);
|
// Find and pop the matching entry in the map.
|
HAL_LOGD("aBufferData[%d]:%p, camera_buffer:%p.",
|
device_buffer->index,
|
aBufferData[device_buffer->index],
|
aBufferData[device_buffer->index]->camera_buffer);
|
|
const camera3_stream_buffer_t* camera_buffer =
|
aBufferData[device_buffer->index]->camera_buffer;
|
const buffer_handle_t buffer = *camera_buffer->buffer;
|
|
private_handle_t *hnd = (private_handle_t *)buffer;
|
HAL_LOGV("buffer_handle_t[%d] buffer : %p,The camera_buffer is %p,"
|
" id is %lld, vaddr is 0x%p.",
|
device_buffer->index,
|
buffer, camera_buffer,
|
hnd->aw_buf_id,
|
static_cast<void*>(&hnd->base));
|
|
// Unlock.
|
int res = mModule->unlock(mModule, buffer);
|
if (res) {
|
HAL_LOGE("Failed to unlock buffer at %p", buffer);
|
return -ENODEV;
|
}
|
HAL_LOGD("The camera_buffer is %p,camera_buffer->buffer is %p",
|
camera_buffer, camera_buffer->buffer);
|
|
return 0;
|
}
|
|
int V4L2Gralloc::unlockAllBuffers() {
|
HAL_LOG_ENTER();
|
bool failed = false;
|
// If any unlock failed, return error.
|
if (failed) {
|
return -ENODEV;
|
}
|
return 0;
|
}
|
|
} // namespace default_camera_hal
|
