bool VDPAUContext::getFunc( int func, void** p )
{
VdpStatus st = vdp_get_proc_address( vdpDevice, func , p );
if ( st != VDP_STATUS_OK )
return false;
return true;
}
VdpStatus vdp_presentation_queue_target_create_x11(const vdp_t *vdp,
VdpDevice device, uint32_t drawable, VdpPresentationQueueTarget *target)
{
void *ptr;
VdpStatus err = vdp_get_proc_address(vdp, device,
VDP_FUNC_ID_PRESENTATION_QUEUE_TARGET_CREATE_X11, &ptr);
if (err != VDP_STATUS_OK)
return err;
VdpPresentationQueueTargetCreateX11 *f = ptr;
return f(device, drawable, target);
}
static int vdpau_init( producer_avformat self )
{
if ( !vdpau_supported )
return 0;
mlt_log_debug( MLT_PRODUCER_SERVICE(self->parent), "vdpau_init\n" );
int success = 0;
mlt_properties properties = MLT_PRODUCER_PROPERTIES( self->parent );
Display *display = XOpenDisplay( NULL );
if ( !display || mlt_properties_get_int( properties, "novdpau" )
|| ( getenv( "MLT_NO_VDPAU" ) && strcmp( getenv( "MLT_NO_VDPAU" ), "1" ) == 0 ) )
return success;
void *object = NULL;
if ( !vdpau_init_done )
{
int flags = RTLD_NOW;
object = dlopen( "/usr/lib/libvdpau.so", flags );
#ifdef ARCH_X86_64
if ( !object )
object = dlopen( "/usr/lib64/libvdpau.so", flags );
if ( !object )
object = dlopen( "/usr/lib/x86_64-linux-gnu/libvdpau.so.1", flags );
#elif ARCH_X86
if ( !object )
object = dlopen( "/usr/lib/i386-linux-gnu/libvdpau.so.1", flags );
#endif
if ( !object )
object = dlopen( "/usr/local/lib/libvdpau.so", flags );
if ( object )
vdpau_device_create_x11 = dlsym( object, "vdp_device_create_x11" );
else
{
mlt_log( MLT_PRODUCER_SERVICE(self->parent), MLT_LOG_WARNING, "%s: failed to dlopen libvdpau.so\n (%s)\n", __FUNCTION__, dlerror() );
// Don't try again.
vdpau_supported = 0;
return success;
}
}
if ( vdpau_device_create_x11 )
{
int screen = mlt_properties_get_int( properties, "x11_screen" );
self->vdpau = calloc( 1, sizeof( *self->vdpau ) );
self->vdpau->device = VDP_INVALID_HANDLE;
self->vdpau->decoder = VDP_INVALID_HANDLE;
mlt_log_debug( MLT_PRODUCER_SERVICE(self->parent), "X11 Display = %p\n", display );
if ( VDP_STATUS_OK == vdpau_device_create_x11( display, screen, &self->vdpau->device, &vdp_get_proc_address ) )
{
if ( !vdpau_init_done ) {
vdp_get_proc_address( self->vdpau->device, VDP_FUNC_ID_GET_ERROR_STRING, (void**) &vdp_get_error_string );
vdp_get_proc_address( self->vdpau->device, VDP_FUNC_ID_GET_API_VERSION, (void**) &vdp_get_api_version );
vdp_get_proc_address( self->vdpau->device, VDP_FUNC_ID_GET_INFORMATION_STRING, (void**) &vdp_get_information_string );
vdp_get_proc_address( self->vdpau->device, VDP_FUNC_ID_VIDEO_SURFACE_CREATE, (void**) &vdp_surface_create );
vdp_get_proc_address( self->vdpau->device, VDP_FUNC_ID_VIDEO_SURFACE_DESTROY, (void**) &vdp_surface_destroy );
vdp_get_proc_address( self->vdpau->device, VDP_FUNC_ID_VIDEO_SURFACE_GET_BITS_Y_CB_CR, (void**) &vdp_surface_get_bits );
vdp_get_proc_address( self->vdpau->device, VDP_FUNC_ID_DECODER_CREATE, (void**) &vdp_decoder_create );
vdp_get_proc_address( self->vdpau->device, VDP_FUNC_ID_DECODER_DESTROY, (void**) &vdp_decoder_destroy );
vdp_get_proc_address( self->vdpau->device, VDP_FUNC_ID_DECODER_RENDER, (void**) &vdp_decoder_render );
vdp_get_proc_address( self->vdpau->device, VDP_FUNC_ID_DEVICE_DESTROY, (void**) &vdp_device_destroy );
vdpau_init_done = 1;
}
success = 1;
}
}
if ( !success )
{
mlt_log_debug( MLT_PRODUCER_SERVICE(self->parent), "VDPAU failed to initialize device\n" );
if ( object )
dlclose( object );
free( self->vdpau );
self->vdpau = NULL;
}
return success;
}
static int Open(vlc_va_t *va, AVCodecContext *ctx, const es_format_t *fmt)
{
VdpStatus err;
VdpDecoderProfile profile;
int level = fmt->i_level;
if (av_vdpau_get_profile(ctx, &profile))
{
msg_Err(va, "unsupported codec %d or profile %d", ctx->codec_id,
fmt->i_profile);
return VLC_EGENERIC;
}
switch (ctx->codec_id)
{
case AV_CODEC_ID_MPEG1VIDEO:
level = VDP_DECODER_LEVEL_MPEG1_NA;
break;
case AV_CODEC_ID_MPEG2VIDEO:
level = VDP_DECODER_LEVEL_MPEG2_HL;
break;
case AV_CODEC_ID_H263:
level = VDP_DECODER_LEVEL_MPEG4_PART2_ASP_L5;
break;
case AV_CODEC_ID_H264:
if ((fmt->i_profile & FF_PROFILE_H264_INTRA)
&& (fmt->i_level == 11))
level = VDP_DECODER_LEVEL_H264_1b;
default:
break;
}
if (!vlc_xlib_init(VLC_OBJECT(va)))
{
msg_Err(va, "Xlib is required for VDPAU");
return VLC_EGENERIC;
}
vlc_va_sys_t *sys = malloc(sizeof (*sys));
if (unlikely(sys == NULL))
return VLC_ENOMEM;
sys->context = av_vdpau_alloc_context();
if (unlikely(sys->context == NULL))
{
free(sys);
return VLC_ENOMEM;
}
err = vdp_get_x11(NULL, -1, &sys->vdp, &sys->device);
if (err != VDP_STATUS_OK)
{
free(sys->context);
free(sys);
return VLC_EGENERIC;
}
void *func;
err = vdp_get_proc_address(sys->vdp, sys->device,
VDP_FUNC_ID_DECODER_RENDER, &func);
if (err != VDP_STATUS_OK)
goto error;
sys->context->decoder = VDP_INVALID_HANDLE;
sys->context->render = func;
sys->profile = profile;
/* Check capabilities */
VdpBool support;
uint32_t l, mb, w, h;
if (vdp_video_surface_query_capabilities(sys->vdp, sys->device,
VDP_CHROMA_TYPE_420, &support, &w, &h) != VDP_STATUS_OK)
support = VDP_FALSE;
if (!support)
{
msg_Err(va, "video surface format not supported: %s", "YUV 4:2:0");
goto error;
}
msg_Dbg(va, "video surface limits: %"PRIu32"x%"PRIu32, w, h);
if (w < fmt->video.i_width || h < fmt->video.i_height)
{
msg_Err(va, "video surface above limits: %ux%u",
fmt->video.i_width, fmt->video.i_height);
goto error;
}
if (vdp_decoder_query_capabilities(sys->vdp, sys->device, profile,
&support, &l, &mb, &w, &h) != VDP_STATUS_OK)
support = VDP_FALSE;
if (!support)
{
msg_Err(va, "decoder profile not supported: %u", profile);
goto error;
}
msg_Dbg(va, "decoder profile limits: level %"PRIu32" mb %"PRIu32" "
"%"PRIu32"x%"PRIu32, l, mb, w, h);
if ((int)l < level || w < fmt->video.i_width || h < fmt->video.i_height)
{
msg_Err(va, "decoder profile above limits: level %d %ux%u",
level, fmt->video.i_width, fmt->video.i_height);
goto error;
}
const char *infos;
if (vdp_get_information_string(sys->vdp, &infos) != VDP_STATUS_OK)
infos = "VDPAU";
va->sys = sys;
va->description = (char *)infos;
va->pix_fmt = AV_PIX_FMT_VDPAU;
va->setup = Setup;
va->get = Lock;
va->release = Unlock;
va->extract = Copy;
return VLC_SUCCESS;
error:
vdp_release_x11(sys->vdp);
av_free(sys->context);
free(sys);
return VLC_EGENERIC;
}
static int Open(vlc_va_t *va, AVCodecContext *avctx, enum PixelFormat pix_fmt,
const es_format_t *fmt, picture_sys_t *p_sys)
{
if (pix_fmt != AV_PIX_FMT_VDPAU)
return VLC_EGENERIC;
(void) fmt;
(void) p_sys;
void *func;
VdpStatus err;
VdpChromaType type;
uint32_t width, height;
if (av_vdpau_get_surface_parameters(avctx, &type, &width, &height))
return VLC_EGENERIC;
switch (type)
{
case VDP_CHROMA_TYPE_420:
case VDP_CHROMA_TYPE_422:
case VDP_CHROMA_TYPE_444:
break;
default:
msg_Err(va, "unsupported chroma type %"PRIu32, type);
return VLC_EGENERIC;
}
if (!vlc_xlib_init(VLC_OBJECT(va)))
{
msg_Err(va, "Xlib is required for VDPAU");
return VLC_EGENERIC;
}
unsigned refs = avctx->refs + 2 * avctx->thread_count + 5;
vlc_va_sys_t *sys = malloc(sizeof (*sys)
+ (refs + 1) * sizeof (sys->pool[0]));
if (unlikely(sys == NULL))
return VLC_ENOMEM;
sys->type = type;
sys->width = width;
sys->height = height;
err = vdp_get_x11(NULL, -1, &sys->vdp, &sys->device);
if (err != VDP_STATUS_OK)
{
free(sys);
return VLC_EGENERIC;
}
unsigned flags = AV_HWACCEL_FLAG_ALLOW_HIGH_DEPTH;
err = vdp_get_proc_address(sys->vdp, sys->device,
VDP_FUNC_ID_GET_PROC_ADDRESS, &func);
if (err != VDP_STATUS_OK)
goto error;
if (av_vdpau_bind_context(avctx, sys->device, func, flags))
goto error;
va->sys = sys;
unsigned i = 0;
while (i < refs)
{
sys->pool[i] = CreateSurface(va);
if (sys->pool[i] == NULL)
break;
i++;
}
sys->pool[i] = NULL;
if (i < avctx->refs + 3u)
{
msg_Err(va, "not enough video RAM");
while (i > 0)
DestroySurface(sys->pool[--i]);
goto error;
}
if (i < refs)
msg_Warn(va, "video RAM low (allocated %u of %u buffers)",
i, refs);
const char *infos;
if (vdp_get_information_string(sys->vdp, &infos) != VDP_STATUS_OK)
infos = "VDPAU";
va->description = infos;
va->get = Lock;
va->release = NULL;
va->extract = Copy;
return VLC_SUCCESS;
error:
vdp_release_x11(sys->vdp);
free(sys);
return VLC_EGENERIC;
}
