marfrit/libva-v4l2-request-fourier
1
0
Fork 1
Code Issues 2 Pull Requests Actions Packages Projects Releases Wiki Activity

buffer: Harmonize coding style

Browse Source 
Signed-off-by: Paul Kocialkowski <paul.kocialkowski@bootlin.com>
This commit is contained in:
Paul Kocialkowski
2018-04-24 09:56:39 +02:00
parent 8b4ffd2609
commit c2e98f6c7e
1 changed files with 94 additions and 88 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/buffer.c
+94 -88
View File
@@ -42,109 +42,105 @@ VAStatus SunxiCedrusCreateBuffer(VADriverContextP context,
{
struct sunxi_cedrus_driver_data *driver_data =
(struct sunxi_cedrus_driver_data *) context->pDriverData;
int bufferID;
struct object_context *context_object;
struct object_buffer *buffer_object;
struct v4l2_plane plane[1];
struct object_buffer *obj_buffer;
struct v4l2_buffer buf;
void *buffer_data;
void *map_data;
unsigned int map_size;
VABufferID id;
int rc;
memset(plane, 0, sizeof(struct v4l2_plane));
/*
* A Buffer is a memory zone used to handle all kind of data, for example an IQ
* matrix or image buffer (which are allocated using realloc) or slice data
* (which are mmapped from v4l's kernel space)
*/
/* Validate type */
switch (type) {
case VAPictureParameterBufferType:
case VAIQMatrixBufferType: /* Ignored */
case VAIQMatrixBufferType:
case VASliceParameterBufferType:
case VASliceDataBufferType:
case VAImageBufferType:
/* Ok */
break;
default:
return VA_STATUS_ERROR_UNSUPPORTED_BUFFERTYPE;
}
bufferID = object_heap_allocate(&driver_data->buffer_heap);
obj_buffer = BUFFER(bufferID);
if (obj_buffer == NULL)
id = object_heap_allocate(&driver_data->buffer_heap);
buffer_object = BUFFER(buffer_id);
if (buffer_object == NULL)
return VA_STATUS_ERROR_ALLOCATION_FAILED;
obj_buffer->type = type;
obj_buffer->initial_count = count;
obj_buffer->count = count;
if(buffer_object->type == VASliceDataBufferType) {
context_object = CONTEXT(context_id);
if (context_object == NULL) {
object_heap_free(&driver_data->buffer_heap, (struct object_base *) buffer_object);
return VA_STATUS_ERROR_INVALID_CONTEXT;
}
obj_buffer->data = NULL;
obj_buffer->map = NULL;
obj_buffer->size = size;
obj_buffer->map_size = 0;
memset(plane, 0, sizeof(plane));
if(obj_buffer->type == VASliceDataBufferType) {
struct object_context *obj_context;
obj_context = CONTEXT(context_id);
assert(obj_context);
struct v4l2_buffer buf;
memset(&(buf), 0, sizeof(buf));
memset(&buf, 0, sizeof(buf));
buf.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
buf.memory = V4L2_MEMORY_MMAP;
buf.index = obj_context->num_rendered_surfaces%INPUT_BUFFERS_NB;
buf.index = context_object->num_rendered_surfaces % INPUT_BUFFERS_NB;
buf.length = 1;
buf.m.planes = plane;
assert(ioctl(driver_data->mem2mem_fd, VIDIOC_QUERYBUF, &buf)==0);
rc = ioctl(driver_data->mem2mem_fd, VIDIOC_QUERYBUF, &buf);
if (rc < 0) {
object_heap_free(&driver_data->buffer_heap, (struct object_base *) buffer_object);
return VA_STATUS_ERROR_ALLOCATION_FAILED;
}
obj_buffer->map_size = driver_data->slice_offset[buf.index] + size * count;
obj_buffer->map = mmap(NULL, obj_buffer->map_size,
PROT_READ | PROT_WRITE, MAP_SHARED,
driver_data->mem2mem_fd, buf.m.planes[0].m.mem_offset);
map_size = driver_data->slice_offset[buf.index] + size * count;
map_data = mmap(NULL, map_size, PROT_READ | PROT_WRITE, MAP_SHARED,
driver_data->mem2mem_fd, buf.m.planes[0].m.mem_offset);
obj_buffer->data = obj_buffer->map + driver_data->slice_offset[buf.index];
buffer_data = map_data + driver_data->slice_offset[buf.index];
driver_data->slice_offset[buf.index] += size * count;
} else {
obj_buffer->map = NULL;
obj_buffer->data = malloc(size * count);
buffer_data = malloc(size * count);
map_size = 0;
map_data = NULL;
}
if (obj_buffer->data == NULL || obj_buffer->map == MAP_FAILED)
if (buffer_object->data == NULL || buffer_object->map == MAP_FAILED)
return VA_STATUS_ERROR_ALLOCATION_FAILED;
if (data)
memcpy(obj_buffer->data, data, size * count);
memcpy(map_data, data, size * count);
*buffer_id = bufferID;
buffer_object->type = type;
buffer_object->initial_count = count;
buffer_object->count = count;
buffer_object->data = buffer_data;
buffer_object->map = map_data;
buffer_object->size = size;
buffer_object->map_size = map_size;
*buffer_id = id;
return VA_STATUS_SUCCESS;
}
void sunxi_cedrus_destroy_buffer(struct sunxi_cedrus_driver_data *driver_data,
struct object_buffer *obj_buffer)
{
if (obj_buffer->data != NULL) {
if (obj_buffer->type != VASliceDataBufferType)
free(obj_buffer->data);
else if (obj_buffer->map != NULL && obj_buffer->map_size > 0)
munmap(obj_buffer->map, obj_buffer->map_size);
obj_buffer->map = NULL;
obj_buffer->data = NULL;
}
object_heap_free(&driver_data->buffer_heap, obj_buffer);
}
VAStatus SunxiCedrusDestroyBuffer(VADriverContextP context,
VABufferID buffer_id)
{
struct sunxi_cedrus_driver_data *driver_data =
(struct sunxi_cedrus_driver_data *) context->pDriverData;
struct object_buffer *obj_buffer = BUFFER(buffer_id);
assert(obj_buffer);
struct object_buffer *buffer_object;
sunxi_cedrus_destroy_buffer(driver_data, obj_buffer);
buffer_object = BUFFER(buffer_id);
if (buffer_object == NULL)
return VA_STATUS_ERROR_INVALID_BUFFER;
if (buffer_object->data != NULL) {
if (buffer_object->type != VASliceDataBufferType)
free(buffer_object->data);
else if (buffer_object->map != NULL && buffer_object->map_size > 0)
munmap(buffer_object->map, buffer_object->map_size);
}
object_heap_free(&driver_data->buffer_heap, (struct object_base *) buffer_object);
return VA_STATUS_SUCCESS;
}
@@ -154,34 +150,30 @@ VAStatus SunxiCedrusMapBuffer(VADriverContextP context, VABufferID buffer_id,
{
struct sunxi_cedrus_driver_data *driver_data =
(struct sunxi_cedrus_driver_data *) context->pDriverData;
VAStatus vaStatus = VA_STATUS_ERROR_UNKNOWN;
struct object_buffer *obj_buffer = BUFFER(buffer_id);
assert(obj_buffer);
struct object_buffer *buffer_object;
if (NULL == obj_buffer)
{
vaStatus = VA_STATUS_ERROR_INVALID_BUFFER;
return vaStatus;
}
buffer_object = BUFFER(buffer_id);
if (buffer_object == NULL || buffer_object->data == NULL)
return VA_STATUS_ERROR_INVALID_BUFFER;
if (NULL != obj_buffer->data)
{
*data_map = obj_buffer->data;
vaStatus = VA_STATUS_SUCCESS;
}
return vaStatus;
/* Our buffers are always mapped. */
*data_map = buffer_object->data;
return VA_STATUS_SUCCESS;
}
VAStatus SunxiCedrusUnmapBuffer(VADriverContextP context, VABufferID buffer_id)
{
struct sunxi_cedrus_driver_data *driver_data =
(struct sunxi_cedrus_driver_data *) context->pDriverData;
struct object_buffer *obj_buffer = BUFFER(buffer_id);
struct object_buffer *buffer_object;
if (obj_buffer == NULL)
buffer_object = BUFFER(buffer_id);
if (buffer_object == NULL || buffer_object->data == NULL)
return VA_STATUS_ERROR_INVALID_BUFFER;
/* Do nothing */
/* Our buffers are always mapped. */
return VA_STATUS_SUCCESS;
}
@@ -190,20 +182,34 @@ VAStatus SunxiCedrusBufferSetNumElements(VADriverContextP context,
{
struct sunxi_cedrus_driver_data *driver_data =
(struct sunxi_cedrus_driver_data *) context->pDriverData;
VAStatus vaStatus = VA_STATUS_SUCCESS;
struct object_buffer *obj_buffer = BUFFER(buffer_id);
assert(obj_buffer);
struct object_buffer *buffer_object;
if ((count < 0) || (count > obj_buffer->initial_count))
vaStatus = VA_STATUS_ERROR_UNKNOWN;
if (VA_STATUS_SUCCESS == vaStatus)
obj_buffer->count = count;
buffer_object = BUFFER(buffer_id);
if (buffer_object == NULL)
return VA_STATUS_ERROR_INVALID_BUFFER;
return vaStatus;
if (count > buffer_object->initial_count)
return VA_STATUS_ERROR_INVALID_PARAMETER;
buffer_object->count = count;
return VA_STATUS_SUCCESS;
}
VAStatus SunxiCedrusBufferInfo(VADriverContextP context, VABufferID buffer_id,
VABufferType *type, unsigned int *size, unsigned int *count)
{
return VA_STATUS_ERROR_UNIMPLEMENTED;
struct sunxi_cedrus_driver_data *driver_data =
(struct sunxi_cedrus_driver_data *) context->pDriverData;
struct object_buffer *buffer_object;
buffer_object = BUFFER(buffer_id);
if (buffer_object == NULL)
return VA_STATUS_ERROR_INVALID_BUFFER;
*type = buffer_object->type;
*size = buffer_object->size;
*count = buffer_object->count;
return VA_STATUS_SUCCESS;
}