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

context: Harmonize coding style

Browse Source 
Signed-off-by: Paul Kocialkowski <paul.kocialkowski@bootlin.com>
This commit is contained in:
Paul Kocialkowski
2018-04-24 10:03:58 +02:00
parent c2e98f6c7e
commit 2399515b84
1 changed files with 104 additions and 92 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/context.c
+106 -94
View File
@@ -42,104 +42,119 @@ VAStatus SunxiCedrusCreateContext(VADriverContextP context,
VASurfaceID *surfaces_ids, int surfaces_count, VASurfaceID *surfaces_ids, int surfaces_count,
VAContextID *context_id) VAContextID *context_id)
{ {
struct sunxi_cedrus_driver_data *driver_data = struct dump_driver_data *driver_data = (struct dump_driver_data *) context->pDriverData;
(struct sunxi_cedrus_driver_data *) context->pDriverData; struct object_config *config_object;
VAStatus vaStatus = VA_STATUS_SUCCESS; struct object_surface *surface_object;
struct object_config *obj_config; struct object_context *context_object = NULL;
int i; VASurfaceID *ids = NULL;
struct v4l2_create_buffers create_bufs; VAContextID id;
struct v4l2_format fmt; VAStatus status;
struct v4l2_create_buffers create_buffers;
struct v4l2_format format;
enum v4l2_buf_type type; enum v4l2_buf_type type;
unsigned int i;
obj_config = CONFIG(config_id); config_object = CONFIG(config_id);
if (NULL == obj_config) if (config_object == NULL) {
{ status = VA_STATUS_ERROR_INVALID_CONFIG;
vaStatus = VA_STATUS_ERROR_INVALID_CONFIG; goto error;
return vaStatus;
} }
int contextID = object_heap_allocate(&driver_data->context_heap); id = object_heap_allocate(&driver_data->context_heap);
struct object_context *obj_context = CONTEXT(contextID); context_object = CONTEXT(id);
if (NULL == obj_context) if (context_object == NULL) {
{ status = VA_STATUS_ERROR_ALLOCATION_FAILED;
vaStatus = VA_STATUS_ERROR_ALLOCATION_FAILED; goto error;
return vaStatus;
} }
obj_context->config_id = config_id; ids = malloc(surfaces_count * sizeof(VASurfaceID));
obj_context->render_surface_id = VA_INVALID; if (ids == NULL) {
obj_context->surfaces_ids = (VASurfaceID *) malloc(surfaces_count * sizeof(VASurfaceID)); status = VA_STATUS_ERROR_ALLOCATION_FAILED;
obj_context->surfaces_count = surfaces_count; goto error;
obj_context->picture_width = picture_width;
obj_context->picture_height = picture_height;
obj_context->num_rendered_surfaces = 0;
*context_id = contextID;
struct v4l2_ctrl_mpeg2_frame_hdr mpeg2_frame_hdr;
uint32_t num_rendered_surfaces;
if (obj_context->surfaces_ids == NULL)
{
vaStatus = VA_STATUS_ERROR_ALLOCATION_FAILED;
return vaStatus;
} }
for(i = 0; i < surfaces_count; i++) for (i = 0; i < surfaces_count; i++) {
{ surface_object = SURFACE(surfaces_ids[i]);
if (NULL == SURFACE(surfaces_ids[i])) if (surface_object == NULL) {
{ status = VA_STATUS_ERROR_INVALID_SURFACE;
vaStatus = VA_STATUS_ERROR_INVALID_SURFACE; goto error;
break;
}
obj_context->surfaces_ids[i] = surfaces_ids[i];
}
obj_context->flags = flag;
/* Error recovery */
if (VA_STATUS_SUCCESS != vaStatus)
{
obj_context->config_id = -1;
free(obj_context->surfaces_ids);
obj_context->surfaces_ids = NULL;
obj_context->surfaces_count = 0;
obj_context->flags = 0;
object_heap_free(&driver_data->context_heap, (object_base_p) obj_context);
} }
memset(&(fmt), 0, sizeof(fmt)); ids[i] = surfaces_ids[i];
fmt.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE; }
fmt.fmt.pix_mp.width = picture_width;
fmt.fmt.pix_mp.height = picture_height; memset(&format, 0, sizeof(format));
fmt.fmt.pix_mp.plane_fmt[0].sizeimage = INPUT_BUFFER_MAX_SIZE * INPUT_BUFFERS_NB; format.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
switch(obj_config->profile) { format.fmt.pix_mp.width = picture_width;
format.fmt.pix_mp.height = picture_height;
format.fmt.pix_mp.plane_fmt[0].sizeimage = INPUT_BUFFER_MAX_SIZE * INPUT_BUFFERS_NB;
format.fmt.pix_mp.field = V4L2_FIELD_ANY;
format.fmt.pix_mp.num_planes = 1;
switch (config_object->profile) {
case VAProfileMPEG2Simple: case VAProfileMPEG2Simple:
case VAProfileMPEG2Main: case VAProfileMPEG2Main:
fmt.fmt.pix_mp.pixelformat = V4L2_PIX_FMT_MPEG2_FRAME; format.fmt.pix_mp.pixelformat = V4L2_PIX_FMT_MPEG2_FRAME;
break; break;
default: default:
vaStatus = VA_STATUS_ERROR_UNSUPPORTED_PROFILE; status = VA_STATUS_ERROR_UNSUPPORTED_PROFILE;
return vaStatus; goto error;
break;
} }
fmt.fmt.pix_mp.field = V4L2_FIELD_ANY;
fmt.fmt.pix_mp.num_planes = 1;
assert(ioctl(driver_data->mem2mem_fd, VIDIOC_S_FMT, &fmt)==0);
memset (&create_bufs, 0, sizeof (struct v4l2_create_buffers)); rc = ioctl(driver_data->mem2mem_fd, VIDIOC_S_FMT, &format);
create_bufs.count = INPUT_BUFFERS_NB; if (rc < 0) {
create_bufs.memory = V4L2_MEMORY_MMAP; status = VA_STATUS_ERROR_ALLOCATION_FAILED;
create_bufs.format.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE; goto error;
assert(ioctl(driver_data->mem2mem_fd, VIDIOC_G_FMT, &create_bufs.format)==0); }
assert(ioctl(driver_data->mem2mem_fd, VIDIOC_CREATE_BUFS, &create_bufs)==0);
memset(&create_buffers, 0, sizeof(create_buffers));
create_buffers.count = INPUT_BUFFERS_NB;
create_buffers.memory = V4L2_MEMORY_MMAP;
create_buffers.format.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
rc = ioctl(driver_data->mem2mem_fd, VIDIOC_G_FMT, &create_buffers.format);
if (rc < 0) {
status = VA_STATUS_ERROR_ALLOCATION_FAILED;
goto error;
}
rc = ioctl(driver_data->mem2mem_fd, VIDIOC_CREATE_BUFS, &create_buffers);
if (rc < 0) {
status = VA_STATUS_ERROR_ALLOCATION_FAILED;
goto error;
}
type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE; type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
assert(ioctl(driver_data->mem2mem_fd, VIDIOC_STREAMON, &type)==0); rc = ioctl(driver_data->mem2mem_fd, VIDIOC_STREAMON, &type);
if (rc < 0) {
status = VA_STATUS_ERROR_ALLOCATION_FAILED;
goto error;
}
type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE; type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
assert(ioctl(driver_data->mem2mem_fd, VIDIOC_STREAMON, &type)==0); rc = ioctl(driver_data->mem2mem_fd, VIDIOC_STREAMON, &type);
if (rc < 0) {
status = VA_STATUS_ERROR_ALLOCATION_FAILED;
goto error;
}
return vaStatus; context_object->config_id = config_id;
context_object->surfaces_ids = ids;
*context_id = id;
status = VA_STATUS_SUCCESS;
goto complete;
error:
if (ids != NULL)
free(ids);
if (context_object != NULL)
object_heap_free(&driver_data->context_heap, (struct object_base *) context_object);
complete:
return status;
} }
VAStatus SunxiCedrusDestroyContext(VADriverContextP context, VAStatus SunxiCedrusDestroyContext(VADriverContextP context,
@@ -147,27 +162,24 @@ VAStatus SunxiCedrusDestroyContext(VADriverContextP context,
{ {
struct sunxi_cedrus_driver_data *driver_data = struct sunxi_cedrus_driver_data *driver_data =
(struct sunxi_cedrus_driver_data *) context->pDriverData; (struct sunxi_cedrus_driver_data *) context->pDriverData;
struct object_context *obj_context = CONTEXT(context_id); struct object_context *context_object;
assert(obj_context);
enum v4l2_buf_type type; enum v4l2_buf_type type;
context_object = (struct object_context *) object_heap_lookup(&driver_data->context_heap, context_id);
if (context_object == NULL)
return VA_STATUS_ERROR_INVALID_CONTEXT;
object_heap_free(&driver_data->context_heap, (struct object_base *) context_object);
type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE; type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
ioctl(driver_data->mem2mem_fd, VIDIOC_STREAMOFF, &type); rc = ioctl(driver_data->mem2mem_fd, VIDIOC_STREAMOFF, &type);
if (rc < 0)
return VA_STATUS_ERROR_UNKNOWN;
type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE; type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
ioctl(driver_data->mem2mem_fd, VIDIOC_STREAMOFF, &type); rc = ioctl(driver_data->mem2mem_fd, VIDIOC_STREAMOFF, &type);
if (rc < 0)
obj_context->config_id = -1; return VA_STATUS_ERROR_UNKNOWN;
obj_context->picture_width = 0;
obj_context->picture_height = 0;
if (obj_context->surfaces_ids)
free(obj_context->surfaces_ids);
obj_context->surfaces_ids = NULL;
obj_context->surfaces_count = 0;
obj_context->flags = 0;
obj_context->render_surface_id = -1;
object_heap_free(&driver_data->context_heap, (object_base_p) obj_context);
return VA_STATUS_SUCCESS; return VA_STATUS_SUCCESS;
} }