buffer: Harmonize coding style

Signed-off-by: Paul Kocialkowski <paul.kocialkowski@bootlin.com>

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);
+	id = object_heap_allocate(&driver_data->buffer_heap);
-	obj_buffer = BUFFER(bufferID);
+	buffer_object = BUFFER(buffer_id);
-	if (obj_buffer == NULL)
+	if (buffer_object == NULL)
 		return VA_STATUS_ERROR_ALLOCATION_FAILED;
 
-	obj_buffer->type = type;
+	if(buffer_object->type == VASliceDataBufferType) {
-	obj_buffer->initial_count = count;
+		context_object = CONTEXT(context_id);
-	obj_buffer->count = count;
+		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;
+		memset(plane, 0, sizeof(plane));
-	obj_buffer->map = NULL;
-	obj_buffer->size = size;
-	obj_buffer->map_size = 0;
 
-	if(obj_buffer->type == VASliceDataBufferType) {
+		memset(&buf, 0, sizeof(buf));
-		struct object_context *obj_context;
-
-		obj_context = CONTEXT(context_id);
-		assert(obj_context);
-
-		struct v4l2_buffer 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;
+		map_size = driver_data->slice_offset[buf.index] + size * count;
-		obj_buffer->map = mmap(NULL, obj_buffer->map_size,
+		map_data = mmap(NULL, map_size, PROT_READ | PROT_WRITE, MAP_SHARED,
-				PROT_READ | PROT_WRITE, MAP_SHARED,
+			driver_data->mem2mem_fd, buf.m.planes[0].m.mem_offset);
-				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;
+		buffer_data = malloc(size * count);
-		obj_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);
+	struct object_buffer *buffer_object;
-	assert(obj_buffer);
 
-	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 *buffer_object;
-	struct object_buffer *obj_buffer = BUFFER(buffer_id);
-	assert(obj_buffer);
 
-	if (NULL == obj_buffer)
+	buffer_object = BUFFER(buffer_id);
-	{
+	if (buffer_object == NULL || buffer_object->data == NULL)
-		vaStatus = VA_STATUS_ERROR_INVALID_BUFFER;
+		return VA_STATUS_ERROR_INVALID_BUFFER;
-		return vaStatus;
-	}
 
-	if (NULL != obj_buffer->data)
+	/* Our buffers are always mapped. */
-	{
+	*data_map = buffer_object->data;
-		*data_map = obj_buffer->data;
+
-		vaStatus = VA_STATUS_SUCCESS;
+	return VA_STATUS_SUCCESS;
-	}
-	return vaStatus;
 }
 
 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 *buffer_object;
-	struct object_buffer *obj_buffer = BUFFER(buffer_id);
-	assert(obj_buffer);
 
-	if ((count < 0) || (count > obj_buffer->initial_count))
+	buffer_object = BUFFER(buffer_id);
-		vaStatus = VA_STATUS_ERROR_UNKNOWN;
+	if (buffer_object == NULL)
-	if (VA_STATUS_SUCCESS == vaStatus)
+		return VA_STATUS_ERROR_INVALID_BUFFER;
-		obj_buffer->count = count;
 
-	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;
 }