int slot_map_remove(struct slot_map* sm, sm_key k)
{
struct sm_slot* s = &sm->slots[k.index];
if (k.generation == s->generation) {
++(s->generation);
free_list_push(sm, k.index);
if (s->data_idx != sm->size - 1)
swap_with_last(sm, s->data_idx);
s->data_idx = INVALID_IDX;
--sm->size;
--sm->num_slots;
return 1;
}
return 0;
}
static inline void slots_resize(struct slot_map* sm, size_t ncap)
{
assert(ncap > sm->cap_slots);
size_t prev_cap = sm->cap_slots;
sm->cap_slots = ncap;
sm->slots = realloc(sm->slots, sm->cap_slots * sizeof(struct sm_slot));
for (size_t i = prev_cap; i < sm->cap_slots; ++i) {
struct sm_slot* s = &sm->slots[i];
s->generation = 0;
s->data_idx = INVALID_IDX;
s->free_list_next = INVALID_IDX;
s->free_list_prev = INVALID_IDX;
free_list_push(sm, i);
}
}
VdpStatus
vdpVideoSurfaceDestroy(VdpVideoSurface surface)
{
VdpVideoSurfaceData *videoSurfData = handle_acquire(surface, HANDLETYPE_VIDEO_SURFACE);
if (NULL == videoSurfData)
return VDP_STATUS_INVALID_HANDLE;
VdpDeviceData *deviceData = videoSurfData->deviceData;
glx_ctx_push_thread_local(deviceData);
glDeleteTextures(1, &videoSurfData->tex_id);
GLenum gl_error = glGetError();
glx_ctx_pop();
if (GL_NO_ERROR != gl_error) {
traceError("error (%s): gl error %d\n", __func__, gl_error);
handle_release(surface);
return VDP_STATUS_ERROR;
}
if (deviceData->va_available) {
// return VA surface to the free list
if (videoSurfData->decoder != VDP_INVALID_HANDLE) {
VdpDecoderData *dd = handle_acquire(videoSurfData->decoder, HANDLETYPE_DECODER);
if (NULL != dd) {
free_list_push(dd->free_list, &dd->free_list_head, videoSurfData->rt_idx);
handle_release(videoSurfData->decoder);
}
}
// .va_surf will be freed in VdpDecoderDestroy
}
if (videoSurfData->y_plane)
free(videoSurfData->y_plane);
if (videoSurfData->u_plane)
free(videoSurfData->u_plane);
// do not free videoSurfData->v_plane, it's just pointer into the middle of u_plane
unref_device(deviceData);
handle_expunge(surface);
free(videoSurfData);
return VDP_STATUS_OK;
}
VdpStatus
softVdpDecoderCreate(VdpDevice device, VdpDecoderProfile profile, uint32_t width, uint32_t height,
uint32_t max_references, VdpDecoder *decoder)
{
VdpStatus err_code;
if (!decoder)
return VDP_STATUS_INVALID_POINTER;
VdpDeviceData *deviceData = handle_acquire(device, HANDLETYPE_DEVICE);
if (NULL == deviceData)
return VDP_STATUS_INVALID_HANDLE;
if (!deviceData->va_available) {
err_code = VDP_STATUS_INVALID_DECODER_PROFILE;
goto quit;
}
VADisplay va_dpy = deviceData->va_dpy;
VdpDecoderData *data = calloc(1, sizeof(VdpDecoderData));
if (NULL == data) {
err_code = VDP_STATUS_RESOURCES;
goto quit;
}
data->type = HANDLETYPE_DECODER;
data->device = deviceData;
data->profile = profile;
data->width = width;
data->height = height;
data->max_references = max_references;
// initialize free_list. Initially they all free
data->free_list_head = -1;
for (int k = 0; k < MAX_RENDER_TARGETS; k ++) {
free_list_push(data->free_list, &data->free_list_head, k);
}
VAProfile va_profile;
VAStatus status;
int final_try = 0;
VdpDecoderProfile next_profile = profile;
// Try to create decoder for asked profile. On failure try to create more advanced one
while (! final_try) {
profile = next_profile;
switch (profile) {
case VDP_DECODER_PROFILE_H264_BASELINE:
va_profile = VAProfileH264Baseline;
data->num_render_targets = NUM_RENDER_TARGETS_H264;
next_profile = VDP_DECODER_PROFILE_H264_MAIN;
break;
case VDP_DECODER_PROFILE_H264_MAIN:
va_profile = VAProfileH264Main;
data->num_render_targets = NUM_RENDER_TARGETS_H264;
next_profile = VDP_DECODER_PROFILE_H264_HIGH;
break;
case VDP_DECODER_PROFILE_H264_HIGH:
va_profile = VAProfileH264High;
data->num_render_targets = NUM_RENDER_TARGETS_H264;
// there is no more advanced profile, so it's final try
final_try = 1;
break;
default:
traceError("error (softVdpDecoderCreate): decoder %s not implemented\n",
reverse_decoder_profile(profile));
err_code = VDP_STATUS_INVALID_DECODER_PROFILE;
goto quit_free_data;
}
status = vaCreateConfig(va_dpy, va_profile, VAEntrypointVLD, NULL, 0, &data->config_id);
if (VA_STATUS_SUCCESS == status) // break loop if decoder created
break;
}
if (VA_STATUS_SUCCESS != status) {
err_code = VDP_STATUS_ERROR;
goto quit_free_data;
}
// Create surfaces. All video surfaces created here, rather than in VdpVideoSurfaceCreate.
// VAAPI requires surfaces to be bound with context on its creation time, while VDPAU allows
// to do it later. So here is a trick: VDP video surfaces get their va_surf dynamically in
// DecoderRender.
// TODO: check format of surfaces created
#if VA_CHECK_VERSION(0, 34, 0)
status = vaCreateSurfaces(va_dpy, VA_RT_FORMAT_YUV420, width, height,
data->render_targets, data->num_render_targets, NULL, 0);
#else
status = vaCreateSurfaces(va_dpy, width, height, VA_RT_FORMAT_YUV420,
data->num_render_targets, data->render_targets);
#endif
if (VA_STATUS_SUCCESS != status) {
err_code = VDP_STATUS_ERROR;
goto quit_free_data;
}
status = vaCreateContext(va_dpy, data->config_id, width, height, VA_PROGRESSIVE,
data->render_targets, data->num_render_targets, &data->context_id);
if (VA_STATUS_SUCCESS != status) {
err_code = VDP_STATUS_ERROR;
goto quit_free_data;
}
deviceData->refcount ++;
*decoder = handle_insert(data);
err_code = VDP_STATUS_OK;
goto quit;
quit_free_data:
free(data);
quit:
handle_release(device);
return err_code;
}
