From c2e98f6c7eb38025e799dc6fab58c2fbe9a89bba Mon Sep 17 00:00:00 2001 From: Paul Kocialkowski Date: Tue, 24 Apr 2018 09:56:39 +0200 Subject: [PATCH] buffer: Harmonize coding style Signed-off-by: Paul Kocialkowski --- src/buffer.c | 182 ++++++++++++++++++++++++++------------------------- 1 file changed, 94 insertions(+), 88 deletions(-) diff --git a/src/buffer.c b/src/buffer.c index 241603e..b186a02 100644 --- a/src/buffer.c +++ b/src/buffer.c @@ -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; }