claude-noether/libva-v4l2-request-fourier
1
0
Fork 0
forked from marfrit/libva-v4l2-request-fourier
Code Pull Requests Activity

surface: Harmonize coding style

Browse Source 
Signed-off-by: Paul Kocialkowski <paul.kocialkowski@bootlin.com>
This commit is contained in:
Paul Kocialkowski
2018-04-24 14:20:04 +02:00
parent 56614c25a6
commit 9716acc322
2 changed files with 96 additions and 92 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/picture.c
+6 -3
View File
@@ -148,8 +148,11 @@ VAStatus SunxiCedrusEndPicture(VADriverContextP context,
return VA_STATUS_ERROR_INVALID_SURFACE; return VA_STATUS_ERROR_INVALID_SURFACE;
request_fd = driver_data->request_fds[surface_object->input_buf_index]; request_fd = driver_data->request_fds[surface_object->input_buf_index];
if(request_fd < 0) { if (request_fd < 0) {
assert(ioctl(driver_data->mem2mem_fd, VIDIOC_NEW_REQUEST, &media_request)==0); rc = ioctl(driver_data->mem2mem_fd, VIDIOC_NEW_REQUEST, &media_request);
if (rc < 0)
return VA_STATUS_ERROR_OPERATION_FAILED;
driver_data->request_fds[surface_object->input_buf_index] = media_request.fd; driver_data->request_fds[surface_object->input_buf_index] = media_request.fd;
request_fd = media_request.fd; request_fd = media_request.fd;
} }
@@ -159,7 +162,7 @@ VAStatus SunxiCedrusEndPicture(VADriverContextP context,
memset(&ctrl, 0, sizeof(struct v4l2_ext_control)); memset(&ctrl, 0, sizeof(struct v4l2_ext_control));
memset(&ctrls, 0, sizeof(struct v4l2_ext_controls)); memset(&ctrls, 0, sizeof(struct v4l2_ext_controls));
memset(&(out_buf), 0, sizeof(out_buf)); memset(&out_buf, 0, sizeof(out_buf));
out_buf.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE; out_buf.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
out_buf.memory = V4L2_MEMORY_MMAP; out_buf.memory = V4L2_MEMORY_MMAP;
out_buf.index = surface_object->input_buf_index; out_buf.index = surface_object->input_buf_index;
src/surface.c
+90 -89
View File
@@ -43,89 +43,86 @@ VAStatus SunxiCedrusCreateSurfaces(VADriverContextP context, int width,
{ {
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;
VAStatus vaStatus = VA_STATUS_SUCCESS; struct object_surface *surface_object;
int i; VASurfaceID id;
struct v4l2_buffer buf; struct v4l2_buffer buf;
struct v4l2_plane planes[2]; struct v4l2_plane planes[2];
struct v4l2_create_buffers create_bufs; struct v4l2_create_buffers create_bufs;
struct v4l2_format fmt; struct v4l2_format fmt;
int i;
memset(planes, 0, 2 * sizeof(struct v4l2_plane)); memset(planes, 0, 2 * sizeof(struct v4l2_plane));
/* We only support one format */ if (format != VA_RT_FORMAT_YUV420)
if (VA_RT_FORMAT_YUV420 != format)
return VA_STATUS_ERROR_UNSUPPORTED_RT_FORMAT; return VA_STATUS_ERROR_UNSUPPORTED_RT_FORMAT;
/* Set format for capture */ memset(&fmt, 0, sizeof(fmt));
memset(&(fmt), 0, sizeof(fmt));
fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE; fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
fmt.fmt.pix_mp.width = width; fmt.fmt.pix_mp.width = width;
fmt.fmt.pix_mp.height = height; fmt.fmt.pix_mp.height = height;
fmt.fmt.pix_mp.pixelformat = V4L2_PIX_FMT_SUNXI; fmt.fmt.pix_mp.pixelformat = V4L2_PIX_FMT_SUNXI;
fmt.fmt.pix_mp.field = V4L2_FIELD_ANY; fmt.fmt.pix_mp.field = V4L2_FIELD_ANY;
fmt.fmt.pix_mp.num_planes = 2; fmt.fmt.pix_mp.num_planes = 2;
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, &fmt);
if (rc < 0)
return VA_STATUS_ERROR_OPERATION_FAILED;
memset(&create_bufs, 0, sizeof(create_bufs));
create_bufs.count = surfaces_count; create_bufs.count = surfaces_count;
create_bufs.memory = V4L2_MEMORY_MMAP; create_bufs.memory = V4L2_MEMORY_MMAP;
create_bufs.format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE; create_bufs.format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
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);
driver_data->num_dst_bufs = create_bufs.count;
for (i = 0; i < create_bufs.count; i++)
{ rc = ioctl(driver_data->mem2mem_fd, VIDIOC_G_FMT, &create_bufs.format);
VASurfaceID surfaceID = object_heap_allocate(&driver_data->surface_heap); if (rc < 0)
struct object_surface *obj_surface = SURFACE(surfaceID); return VA_STATUS_ERROR_OPERATION_FAILED;
if (NULL == obj_surface)
{ rc = ioctl(driver_data->mem2mem_fd, VIDIOC_CREATE_BUFS, &create_bufs);
vaStatus = VA_STATUS_ERROR_ALLOCATION_FAILED; if (rc < 0)
break; return VA_STATUS_ERROR_ALLOCATION_FAILED;
}
obj_surface->surface_id = surfaceID; for (i = 0; i < surfaces_count; i++) {
id = object_heap_allocate(&driver_data->surface_heap);
surface_object = (struct object_surface *) object_heap_lookup(&driver_data->surface_heap, id);
if (surface_object == NULL)
return VA_STATUS_ERROR_ALLOCATION_FAILED;
surfaces[i] = surfaceID; surfaces[i] = surfaceID;
memset(&(buf), 0, sizeof(buf)); memset(&buf, 0, sizeof(buf));
buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE; buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
buf.memory = V4L2_MEMORY_MMAP; buf.memory = V4L2_MEMORY_MMAP;
buf.index = create_bufs.index + i; // FIXME that's just i isn't it? buf.index = create_bufs.index + i;
buf.length = 2; buf.length = 2;
buf.m.planes = planes; buf.m.planes = planes;
assert(ioctl(driver_data->mem2mem_fd, VIDIOC_QUERYBUF, &buf)==0); rc = ioctl(driver_data->mem2mem_fd, VIDIOC_QUERYBUF, &buf);
if (rc < 0)
return VA_STATUS_ERROR_ALLOCATION_FAILED;
driver_data->luma_bufs[buf.index] = mmap(NULL, buf.m.planes[0].length, driver_data->luma_bufs[buf.index] = mmap(NULL, buf.m.planes[0].length, 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); if (driver_data->luma_bufs[buf.index] == MAP_FAILED)
assert(driver_data->luma_bufs[buf.index] != MAP_FAILED); return VA_STATUS_ERROR_ALLOCATION_FAILED;
driver_data->chroma_bufs[buf.index] = mmap(NULL, buf.m.planes[1].length, driver_data->chroma_bufs[buf.index] = mmap(NULL, buf.m.planes[1].length, PROT_READ | PROT_WRITE, MAP_SHARED,
PROT_READ | PROT_WRITE, MAP_SHARED, driver_data->mem2mem_fd, buf.m.planes[1].m.mem_offset);
driver_data->mem2mem_fd, buf.m.planes[1].m.mem_offset); if (driver_data->chroma_bufs[buf.index] == MAP_FAILED)
assert(driver_data->chroma_bufs[buf.index] != MAP_FAILED); return VA_STATUS_ERROR_ALLOCATION_FAILED;
obj_surface->input_buf_index = 0; surface_object->status = VASurfaceReady;
obj_surface->output_buf_index = create_bufs.index + i; // FIXME that's just i isn't it? surface_object->width = width;
surface_object->height = height;
surface_object->input_buf_index = 0;
surface_object->output_buf_index = create_bufs.index + i;
obj_surface->width = width; surfaces_ids[i] = id;
obj_surface->height = height;
obj_surface->status = VASurfaceReady;
} }
/* Error recovery */ driver_data->num_dst_bufs = create_bufs.count;
if (VA_STATUS_SUCCESS != vaStatus)
{ return VA_STATUS_SUCCESS;
/* surfaces[i-1] was the last successful allocation */
for(; i--;)
{
struct object_surface *obj_surface = SURFACE(surfaces[i]);
surfaces[i] = VA_INVALID_SURFACE;
assert(obj_surface);
object_heap_free(&driver_data->surface_heap, (object_base_p) obj_surface);
}
}
return vaStatus;
} }
VAStatus SunxiCedrusDestroySurfaces(VADriverContextP context, VAStatus SunxiCedrusDestroySurfaces(VADriverContextP context,
@@ -133,13 +130,17 @@ VAStatus SunxiCedrusDestroySurfaces(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_surface *surface_object;
int i; int i;
for(i = surfaces_count; i--;)
{ for (i = 0; i < surfaces_count; i++) {
struct object_surface *obj_surface = SURFACE(surfaces_ids[i]); surface_object = (struct object_surface *) object_heap_lookup(&driver_data->surface_heap, surfaces_ids[i]);
assert(obj_surface); if (surface_object == NULL)
object_heap_free(&driver_data->surface_heap, (object_base_p) obj_surface); return VA_STATUS_ERROR_INVALID_SURFACE;
object_heap_free(&driver_data->surface_heap, (struct object_base *) surface_object);
} }
return VA_STATUS_SUCCESS; return VA_STATUS_SUCCESS;
} }
@@ -148,7 +149,7 @@ VAStatus SunxiCedrusSyncSurface(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_surface *obj_surface; struct object_surface *surface_object;
struct v4l2_buffer buf; struct v4l2_buffer buf;
struct v4l2_plane plane[1]; struct v4l2_plane plane[1];
struct v4l2_plane planes[2]; struct v4l2_plane planes[2];
@@ -159,54 +160,55 @@ VAStatus SunxiCedrusSyncSurface(VADriverContextP context,
memset(plane, 0, sizeof(struct v4l2_plane)); memset(plane, 0, sizeof(struct v4l2_plane));
memset(planes, 0, 2 * sizeof(struct v4l2_plane)); memset(planes, 0, 2 * sizeof(struct v4l2_plane));
obj_surface = SURFACE(surface_id); surface_object = SURFACE(surface_id);
assert(obj_surface); if (surface_object == NULL)
return VA_STATUS_ERROR_INVALID_SURFACE;
if(obj_surface->status == VASurfaceSkipped) if (surface_object->status == VASurfaceSkipped)
return VA_STATUS_ERROR_UNKNOWN; return VA_STATUS_ERROR_UNKNOWN;
request_fd = driver_data->request_fds[obj_surface->input_buf_index]; request_fd = driver_data->request_fds[surface_object->input_buf_index];
if(request_fd < 0) if (request_fd < 0)
return VA_STATUS_ERROR_UNKNOWN; return VA_STATUS_ERROR_UNKNOWN;
assert(ioctl(request_fd, MEDIA_REQUEST_IOC_SUBMIT, NULL)==0); rc = ioctl(request_fd, MEDIA_REQUEST_IOC_SUBMIT, NULL);
if (rc < 0)
return VA_STATUS_ERROR_OPERATION_FAILED;
FD_ZERO(&read_fds); FD_ZERO(&read_fds);
FD_SET(request_fd, &read_fds); FD_SET(request_fd, &read_fds);
rc = select(request_fd + 1, &read_fds, NULL, NULL, NULL); rc = select(request_fd + 1, &read_fds, NULL, NULL, NULL);
if(rc <= 0) if(rc <= 0)
// FIXME: Properly dispose of the buffers here, also reinit request when it fails, also set surface status
return VA_STATUS_ERROR_UNKNOWN; return VA_STATUS_ERROR_UNKNOWN;
assert(ioctl(request_fd, MEDIA_REQUEST_IOC_REINIT, NULL)==0); rc = ioctl(request_fd, MEDIA_REQUEST_IOC_REINIT, NULL);
if (rc < 0)
return VA_STATUS_ERROR_OPERATION_FAILED;
memset(&(buf), 0, sizeof(buf)); memset(&buf, 0, sizeof(buf));
buf.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE; buf.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
buf.memory = V4L2_MEMORY_MMAP; buf.memory = V4L2_MEMORY_MMAP;
buf.index = obj_surface->input_buf_index; buf.index = surface_object->input_buf_index;
buf.length = 1; buf.length = 1;
buf.m.planes = plane; buf.m.planes = plane;
if(ioctl(driver_data->mem2mem_fd, VIDIOC_DQBUF, &buf)) { rc = ioctl(driver_data->mem2mem_fd, VIDIOC_DQBUF, &buf);
sunxi_cedrus_msg("Error when dequeuing input: %s\n", strerror(errno)); if (rc < 0)
return VA_STATUS_ERROR_UNKNOWN; return VA_STATUS_ERROR_OPERATION_FAILED;
}
memset(&(buf), 0, sizeof(buf)); memset(&buf, 0, sizeof(buf));
buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE; buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
buf.memory = V4L2_MEMORY_MMAP; buf.memory = V4L2_MEMORY_MMAP;
buf.index = obj_surface->output_buf_index; buf.index = surface_object->output_buf_index;
buf.length = 2; buf.length = 2;
buf.m.planes = planes; buf.m.planes = planes;
rc = ioctl(driver_data->mem2mem_fd, VIDIOC_DQBUF, &buf);
if (rc < 0)
return VA_STATUS_ERROR_OPERATION_FAILED;
if(ioctl(driver_data->mem2mem_fd, VIDIOC_DQBUF, &buf)) { surface_object->status = VASurfaceReady;
sunxi_cedrus_msg("Error when dequeuing output: %s\n", strerror(errno));
return VA_STATUS_ERROR_UNKNOWN;
}
obj_surface->status = VASurfaceReady;
return VA_STATUS_SUCCESS; return VA_STATUS_SUCCESS;
} }
@@ -216,15 +218,15 @@ VAStatus SunxiCedrusQuerySurfaceStatus(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;
VAStatus vaStatus = VA_STATUS_SUCCESS; struct object_surface *surface_object;
struct object_surface *obj_surface;
obj_surface = SURFACE(surface_id); surface_object = (struct object_surface *) object_heap_lookup(&driver_data->surface_heap, surface_id);
assert(obj_surface); if (surface_object == NULL)
return VA_STATUS_ERROR_INVALID_SURFACE;
*status = obj_surface->status; *status = surface_object->status;
return vaStatus; return VA_STATUS_SUCCESS;
} }
VAStatus SunxiCedrusPutSurface(VADriverContextP context, VASurfaceID surface_id, VAStatus SunxiCedrusPutSurface(VADriverContextP context, VASurfaceID surface_id,
@@ -244,12 +246,11 @@ VAStatus SunxiCedrusPutSurface(VADriverContextP context, VASurfaceID surface_id,
Colormap cm; Colormap cm;
int colorratio = 65535 / 255; int colorratio = 65535 / 255;
int x, y; int x, y;
struct object_surface *obj_surface; struct object_surface *surface_object;
/* WARNING: This is for development purpose only!!! */ /* WARNING: This is for development purpose only!!! */
obj_surface = SURFACE(surface); surface_object = SURFACE(surface);
assert(obj_surface);
display = XOpenDisplay(getenv("DISPLAY")); display = XOpenDisplay(getenv("DISPLAY"));
if (display == NULL) { if (display == NULL) {
@@ -267,7 +268,7 @@ VAStatus SunxiCedrusPutSurface(VADriverContextP context, VASurfaceID surface_id,
for(x=dst_x; x < dst_x+dst_w; x++) { for(x=dst_x; x < dst_x+dst_w; x++) {
for(y=dst_y; y < dst_y+dst_h; y++) { for(y=dst_y; y < dst_y+dst_h; y++) {
char lum = driver_data->luma_bufs[obj_surface->output_buf_index][x+srcw*y]; char lum = driver_data->luma_bufs[surface_object->output_buf_index][x+srcw*y];
xcolor.red = xcolor.green = xcolor.blue = lum*colorratio; xcolor.red = xcolor.green = xcolor.blue = lum*colorratio;
XAllocColor(display, cm, &xcolor); XAllocColor(display, cm, &xcolor);
XSetForeground(display, gc, xcolor.pixel); XSetForeground(display, gc, xcolor.pixel);