struct pipe_video_buffer *
vl_video_buffer_create_ex(struct pipe_context *pipe,
const struct pipe_video_buffer *tmpl,
const enum pipe_format resource_formats[VL_NUM_COMPONENTS],
unsigned depth, unsigned array_size, unsigned usage)
{
struct pipe_resource res_tmpl;
struct pipe_resource *resources[VL_NUM_COMPONENTS];
unsigned i;
assert(pipe);
memset(resources, 0, sizeof resources);
vl_video_buffer_template(&res_tmpl, tmpl, resource_formats[0], depth, array_size, usage, 0);
resources[0] = pipe->screen->resource_create(pipe->screen, &res_tmpl);
if (!resources[0])
goto error;
if (resource_formats[1] == PIPE_FORMAT_NONE) {
assert(resource_formats[2] == PIPE_FORMAT_NONE);
return vl_video_buffer_create_ex2(pipe, tmpl, resources);
}
vl_video_buffer_template(&res_tmpl, tmpl, resource_formats[1], depth, array_size, usage, 1);
resources[1] = pipe->screen->resource_create(pipe->screen, &res_tmpl);
if (!resources[1])
goto error;
if (resource_formats[2] == PIPE_FORMAT_NONE)
return vl_video_buffer_create_ex2(pipe, tmpl, resources);
vl_video_buffer_template(&res_tmpl, tmpl, resource_formats[2], depth, array_size, usage, 2);
resources[2] = pipe->screen->resource_create(pipe->screen, &res_tmpl);
if (!resources[2])
goto error;
return vl_video_buffer_create_ex2(pipe, tmpl, resources);
error:
for (i = 0; i < VL_NUM_COMPONENTS; ++i)
pipe_resource_reference(&resources[i], NULL);
return NULL;
}
static void get_eglimage(vid_dec_PrivateType* priv) {
OMX_PTR p_eglimage = NULL;
OMX_NATIVE_WINDOWTYPE * p_egldisplay = NULL;
const tiz_port_t * p_port = NULL;
struct pipe_video_buffer templat = {};
struct pipe_video_buffer *video_buffer = NULL;
struct pipe_resource * p_res = NULL;
struct pipe_resource *resources[VL_NUM_COMPONENTS];
if (OMX_ErrorNone ==
tiz_krn_claim_eglimage(tiz_get_krn (handleOf (priv)),
OMX_VID_DEC_AVC_OUTPUT_PORT_INDEX,
priv->p_outhdr_, &p_eglimage)) {
priv->use_eglimage = true;
p_port = tiz_krn_get_port(tiz_get_krn (handleOf (priv)),
OMX_VID_DEC_AVC_OUTPUT_PORT_INDEX);
p_egldisplay = p_port->portdef_.format.video.pNativeWindow;
if (!util_hash_table_get(priv->video_buffer_map, priv->p_outhdr_)) {
p_res = st_omx_pipe_texture_from_eglimage(p_egldisplay, p_eglimage);
assert(p_res);
memset(&templat, 0, sizeof(templat));
templat.buffer_format = p_res->format;
templat.chroma_format = PIPE_VIDEO_CHROMA_FORMAT_NONE;
templat.width = p_res->width0;
templat.height = p_res->height0;
templat.interlaced = 0;
memset(resources, 0, sizeof(resources));
pipe_resource_reference(&resources[0], p_res);
video_buffer = vl_video_buffer_create_ex2(priv->pipe, &templat, resources);
assert(video_buffer);
assert(video_buffer->buffer_format == p_res->format);
util_hash_table_set(priv->video_buffer_map, priv->p_outhdr_, video_buffer);
}
} else {
(void) tiz_krn_release_buffer(tiz_get_krn (handleOf (priv)),
OMX_VID_DEC_AVC_OUTPUT_PORT_INDEX,
priv->p_outhdr_);
priv->p_outhdr_ = NULL;
}
}
static VAStatus
suface_from_external_memory(VADriverContextP ctx, vlVaSurface *surface,
VASurfaceAttribExternalBuffers *memory_attibute,
int index, VASurfaceID *surfaces,
struct pipe_video_buffer *templat)
{
vlVaDriver *drv;
struct pipe_screen *pscreen;
struct pipe_resource *resource;
struct pipe_resource res_templ;
struct winsys_handle whandle;
struct pipe_resource *resources[VL_NUM_COMPONENTS];
if (!ctx)
return VA_STATUS_ERROR_INVALID_PARAMETER;
pscreen = VL_VA_PSCREEN(ctx);
drv = VL_VA_DRIVER(ctx);
if (!memory_attibute || !memory_attibute->buffers ||
index > memory_attibute->num_buffers)
return VA_STATUS_ERROR_INVALID_PARAMETER;
if (surface->templat.width != memory_attibute->width ||
surface->templat.height != memory_attibute->height ||
memory_attibute->num_planes < 1)
return VA_STATUS_ERROR_INVALID_PARAMETER;
switch (memory_attibute->pixel_format) {
case VA_FOURCC_RGBA:
case VA_FOURCC_RGBX:
case VA_FOURCC_BGRA:
case VA_FOURCC_BGRX:
if (memory_attibute->num_planes != 1)
return VA_STATUS_ERROR_INVALID_PARAMETER;
break;
default:
return VA_STATUS_ERROR_INVALID_PARAMETER;
}
memset(&res_templ, 0, sizeof(res_templ));
res_templ.target = PIPE_TEXTURE_2D;
res_templ.last_level = 0;
res_templ.depth0 = 1;
res_templ.array_size = 1;
res_templ.width0 = memory_attibute->width;
res_templ.height0 = memory_attibute->height;
res_templ.format = surface->templat.buffer_format;
res_templ.bind = PIPE_BIND_SAMPLER_VIEW;
res_templ.usage = PIPE_USAGE_DEFAULT;
memset(&whandle, 0, sizeof(struct winsys_handle));
whandle.type = DRM_API_HANDLE_TYPE_FD;
whandle.handle = memory_attibute->buffers[index];
whandle.stride = memory_attibute->pitches[index];
resource = pscreen->resource_from_handle(pscreen, &res_templ, &whandle);
if (!resource)
return VA_STATUS_ERROR_ALLOCATION_FAILED;
memset(resources, 0, sizeof resources);
resources[0] = resource;
surface->buffer = vl_video_buffer_create_ex2(drv->pipe, templat, resources);
if (!surface->buffer)
return VA_STATUS_ERROR_ALLOCATION_FAILED;
util_dynarray_init(&surface->subpics);
surfaces[index] = handle_table_add(drv->htab, surface);
if (!surfaces[index])
return VA_STATUS_ERROR_ALLOCATION_FAILED;
return VA_STATUS_SUCCESS;
}
