void test()
{
VAEntrypoint entrypoints[5];
int num_entrypoints,slice_entrypoint;
VAConfigAttrib attrib[2];
VAConfigID config_id;
unsigned int fourcc, luma_stride, chroma_u_stride, chroma_v_stride, luma_offset, chroma_u_offset;
unsigned int chroma_v_offset, buffer_name;
unsigned int *p_buffer;
int i, ret;
char c;
int frame_width=640, frame_height=480;
VASurfaceID surface_id;
VAImage image_id;
unsigned char *usrbuf;
usrbuf = (unsigned char*)malloc(frame_width * frame_height * 2);
ASSERT ( usrbuf != NULL);
VASurfaceAttribExternalBuffers vaSurfaceExternBuf;
VASurfaceAttrib attrib_list[2];
va_status = vaQueryConfigEntrypoints(va_dpy, VAProfileH264Baseline, entrypoints, &num_entrypoints);
ASSERT( VA_STATUS_SUCCESS == va_status );
for (slice_entrypoint = 0; slice_entrypoint < num_entrypoints; slice_entrypoint++) {
if (entrypoints[slice_entrypoint] == VAEntrypointEncSlice)
break;
}
if (slice_entrypoint == num_entrypoints) {
/* not find Slice entry point */
status("VAEntrypointEncSlice doesn't support, exit.\n");
ASSERT(0);
}
/* find out the format for the render target, and rate control mode */
attrib[0].type = VAConfigAttribRTFormat;
attrib[1].type = VAConfigAttribRateControl;
va_status = vaGetConfigAttributes(va_dpy, VAProfileH264Baseline, VAEntrypointEncSlice, &attrib[0], 2);
ASSERT( VA_STATUS_SUCCESS == va_status );
if ((attrib[0].value & VA_RT_FORMAT_YUV420) == 0) {
/* not find desired YUV420 RT format */
status("VA_RT_FORMAT_YUV420 doesn't support, exit\n");
ASSERT(0);
}
if ((attrib[1].value & VA_RC_VBR) == 0) {
/* Can't find matched RC mode */
status("VBR mode doesn't found, exit\n");
ASSERT(0);
}
attrib[0].value = VA_RT_FORMAT_YUV420; /* set to desired RT format */
attrib[1].value = VA_RC_VBR; /* set to desired RC mode */
va_status = vaCreateConfig(va_dpy, VAProfileH264Baseline, VAEntrypointEncSlice, &attrib[0], 2, &config_id);
ASSERT( VA_STATUS_SUCCESS == va_status );
attrib_list[1].type = (VASurfaceAttribType)VASurfaceAttribExternalBufferDescriptor;
attrib_list[0].type = (VASurfaceAttribType)VASurfaceAttribMemoryType;
va_status = vaGetSurfaceAttributes(va_dpy, config_id, attrib_list, 2);
ASSERT( VA_STATUS_SUCCESS == va_status );
if (attrib_list[0].flags != VA_SURFACE_ATTRIB_NOT_SUPPORTED) {
status("supported memory type:\n");
if (attrib_list[0].value.value.i & VA_SURFACE_ATTRIB_MEM_TYPE_VA)
status("\tVA_SURFACE_ATTRIB_MEM_TYPE_VA\n");
if (attrib_list[0].value.value.i & VA_SURFACE_ATTRIB_MEM_TYPE_V4L2)
status("\tVA_SURFACE_ATTRIB_MEM_TYPE_V4L2\n");
if (attrib_list[0].value.value.i & VA_SURFACE_ATTRIB_MEM_TYPE_USER_PTR)
status("\tVA_SURFACE_ATTRIB_MEM_TYPE_USER_PTR\n");
if (attrib_list[0].value.value.i & VA_SURFACE_ATTRIB_MEM_TYPE_ANDROID_GRALLOC)
status("\tVA_SURFACE_ATTRIB_MEM_TYPE_ANDROID_GRALLOC\n");
if (attrib_list[0].value.value.i & VA_SURFACE_ATTRIB_MEM_TYPE_ANDROID_ION)
status("\tVA_SURFACE_ATTRIB_MEM_TYPE_ANDROID_ION\n");
if (attrib_list[0].value.value.i & VA_SURFACE_ATTRIB_MEM_TYPE_KERNEL_DRM)
status("\tVA_SURFACE_ATTRIB_MEM_TYPE_KERNEL_DRM\n");
}
if ((attrib_list[1].flags != VA_SURFACE_ATTRIB_NOT_SUPPORTED) &&
(attrib_list[0].value.value.i & VA_SURFACE_ATTRIB_MEM_TYPE_USER_PTR)) {
status("vaCreateSurfaces from external usr pointer\n");
vaSurfaceExternBuf.buffers = (unsigned long*)malloc(sizeof(unsigned int));
vaSurfaceExternBuf.buffers[0] = usrbuf;
vaSurfaceExternBuf.num_buffers = 1;
vaSurfaceExternBuf.width = frame_width;
vaSurfaceExternBuf.height = frame_height;
vaSurfaceExternBuf.pitches[0] = vaSurfaceExternBuf.pitches[1] = vaSurfaceExternBuf.pitches[2] = frame_width;
//vaSurfaceExternBuf.flags = VA_SURFACE_ATTRIB_MEM_TYPE_ANDROID_GRALLOC;
vaSurfaceExternBuf.pixel_format = VA_FOURCC_NV12;
//vaSurfaceExternBuf.pitches[0] = attribute_tpi->luma_stride;
attrib_list[1].flags = VA_SURFACE_ATTRIB_SETTABLE;
attrib_list[1].value.type = VAGenericValueTypePointer;
attrib_list[1].value.value.p = (void *)&vaSurfaceExternBuf;
attrib_list[0].flags = VA_SURFACE_ATTRIB_SETTABLE;
attrib_list[0].value.type = VAGenericValueTypeInteger;
attrib_list[0].value.value.i = VA_SURFACE_ATTRIB_MEM_TYPE_USER_PTR;
va_status = vaCreateSurfaces(va_dpy, VA_RT_FORMAT_YUV420, frame_width, frame_height, &surface_id, 1, attrib_list, 2);
ASSERT( VA_STATUS_SUCCESS == va_status );
va_status = vaDeriveImage(va_dpy, surface_id, &image_id);
ASSERT( VA_STATUS_SUCCESS == va_status );
va_status = vaMapBuffer(va_dpy, image_id.buf, (void**)&p_buffer);
ASSERT( VA_STATUS_SUCCESS == va_status );
memset(p_buffer, 0x80, image_id.width * image_id.height);
va_status = vaUnmapBuffer(va_dpy, image_id.buf);
ASSERT( VA_STATUS_SUCCESS == va_status );
va_status = vaDestroyImage(va_dpy, image_id.image_id);
ASSERT( VA_STATUS_SUCCESS == va_status );
va_status = vaDestroySurfaces(va_dpy, &surface_id, 1);
ASSERT( VA_STATUS_SUCCESS == va_status );
}
va_status = vaDestroyConfig(va_dpy, config_id);
ASSERT( VA_STATUS_SUCCESS == va_status );
free(usrbuf);
}
mfxStatus vaapiFrameAllocator::ReleaseResponse(mfxFrameAllocResponse *response)
{
vaapiMemId *vaapi_mids = NULL;
VASurfaceID* surfaces = NULL;
mfxU32 i = 0;
bool isBitstreamMemory=false;
if (!response) return MFX_ERR_NULL_PTR;
if (response->mids)
{
vaapi_mids = (vaapiMemId*)(response->mids[0]);
isBitstreamMemory = (MFX_FOURCC_P8 == vaapi_mids->m_fourcc)?true:false;
surfaces = vaapi_mids->m_surface;
for (i = 0; i < response->NumFrameActual; ++i)
{
if (MFX_FOURCC_P8 == vaapi_mids[i].m_fourcc) vaDestroyBuffer(m_dpy, surfaces[i]);
else if (vaapi_mids[i].m_sys_buffer) free(vaapi_mids[i].m_sys_buffer);
}
free(vaapi_mids);
free(response->mids);
response->mids = NULL;
if (!isBitstreamMemory) vaDestroySurfaces(m_dpy, surfaces, response->NumFrameActual);
free(surfaces);
}
response->NumFrameActual = 0;
return MFX_ERR_NONE;
}
static float run(const char* infile, const char* outfile1, const char* outfile2, bool doInterop)
{
VASurfaceID surface;
VAStatus status;
Timer t;
// initialize CL context for CL/VA interop
cv::va_intel::ocl::initializeContextFromVA(va::display, doInterop);
// load input image
cv::UMat u1 = readImage(infile);
cv::Size size2 = u1.size();
status = vaCreateSurfaces(va::display, VA_RT_FORMAT_YUV420, size2.width, size2.height, &surface, 1, NULL, 0);
CHECK_VASTATUS(status, "vaCreateSurfaces");
// transfer image into VA surface, make sure all CL initialization is done (kernels etc)
cv::va_intel::convertToVASurface(va::display, u1, surface, size2);
cv::va_intel::convertFromVASurface(va::display, surface, size2, u1);
cv::UMat u2;
cv::blur(u1, u2, cv::Size(7, 7), cv::Point(-3, -3));
// measure performance on some image processing
writeImage(u1, outfile1, doInterop);
t.start();
cv::va_intel::convertFromVASurface(va::display, surface, size2, u1);
cv::blur(u1, u2, cv::Size(7, 7), cv::Point(-3, -3));
cv::va_intel::convertToVASurface(va::display, u2, surface, size2);
t.stop();
writeImage(u2, outfile2, doInterop);
vaDestroySurfaces(va::display, &surface,1);
return t.time(Timer::MSEC);
}
static void DestroySurfaces( vlc_va_vaapi_t *p_va )
{
if( p_va->image.image_id != VA_INVALID_ID )
{
CopyCleanCache( &p_va->image_cache );
vaDestroyImage( p_va->p_display, p_va->image.image_id );
}
else if(p_va->b_supports_derive)
{
CopyCleanCache( &p_va->image_cache );
}
if( p_va->i_context_id != VA_INVALID_ID )
vaDestroyContext( p_va->p_display, p_va->i_context_id );
for( int i = 0; i < p_va->i_surface_count && p_va->p_surface; i++ )
{
vlc_va_surface_t *p_surface = &p_va->p_surface[i];
if( p_surface->i_id != VA_INVALID_SURFACE )
vaDestroySurfaces( p_va->p_display, &p_surface->i_id, 1 );
}
free( p_va->p_surface );
/* */
p_va->image.image_id = VA_INVALID_ID;
p_va->i_context_id = VA_INVALID_ID;
p_va->p_surface = NULL;
p_va->i_surface_width = 0;
p_va->i_surface_height = 0;
}
OMX_ERRORTYPE OMXVideoDecoderVP9HWR::ProcessorDeinit(void)
{
destroyDecoder();
unsigned int i = 0;
if (mWorkingMode == GRAPHICBUFFER_MODE) {
for (i = 0; i < mOMXBufferHeaderTypePtrNum; i++) {
if (extMIDs[i]->m_surface != NULL) {
vaDestroySurfaces(mVADisplay, extMIDs[i]->m_surface, 1);
}
}
} else if (mWorkingMode == RAWDATA_MODE) {
for (i = 0; i < OUTPORT_ACTUAL_BUFFER_COUNT; i++ ) {
if (extMIDs[i]->m_usrAddr != NULL) {
free(extMIDs[i]->m_usrAddr);
extMIDs[i]->m_usrAddr = NULL;
}
}
}
mOMXBufferHeaderTypePtrNum = 0;
memset(&mGraphicBufferParam, 0, sizeof(mGraphicBufferParam));
for (i = 0; i < MAX_NATIVE_BUFFER_COUNT; i++) {
delete extMIDs[i]->m_surface;
free(extMIDs[i]);
}
return OMXComponentCodecBase::ProcessorDeinit();
}
static void
gst_vaapi_surface_destroy (GstVaapiSurface * surface)
{
GstVaapiDisplay *const display = GST_VAAPI_OBJECT_DISPLAY (surface);
VASurfaceID surface_id;
VAStatus status;
surface_id = GST_VAAPI_OBJECT_ID (surface);
GST_DEBUG ("surface %" GST_VAAPI_ID_FORMAT, GST_VAAPI_ID_ARGS (surface_id));
gst_vaapi_surface_destroy_subpictures (surface);
gst_vaapi_surface_set_parent_context (surface, NULL);
if (surface_id != VA_INVALID_SURFACE) {
GST_VAAPI_DISPLAY_LOCK (display);
status = vaDestroySurfaces (GST_VAAPI_DISPLAY_VADISPLAY (display),
&surface_id, 1);
GST_VAAPI_DISPLAY_UNLOCK (display);
if (!vaapi_check_status (status, "vaDestroySurfaces()"))
g_warning ("failed to destroy surface %" GST_VAAPI_ID_FORMAT,
GST_VAAPI_ID_ARGS (surface_id));
GST_VAAPI_OBJECT_ID (surface) = VA_INVALID_SURFACE;
}
gst_vaapi_buffer_proxy_replace (&surface->extbuf_proxy, NULL);
}
void VideoDecoderVAAPIPrivate::destroySurfaces()
{
if (image.image_id != VA_INVALID_ID) {
//CopyCleanCache(&sys->image_cache);
vaDestroyImage(display, image.image_id);
} else if (supports_derive) {
//CopyCleanCache(&sys->image_cache);
}
if (context_id != VA_INVALID_ID)
vaDestroyContext(display, context_id);
for (int i = 0; i < nb_surfaces && surfaces; i++) {
va_surface_t *surface = &surfaces[i];
if (surface->i_id != VA_INVALID_SURFACE)
vaDestroySurfaces(display, &surface->i_id, 1);
}
//qDeleteAll(surfaces);
//surfaces.clear();
free(surfaces);
surfaces = 0;
/* */
image.image_id = VA_INVALID_ID;
context_id = VA_INVALID_ID;
surface_width = 0;
surface_height = 0;
//vlc_mutex_destroy(&sys->lock);
}
static
void
ppb_video_decoder_destroy_priv(void *p)
{
struct pp_video_decoder_s *vd = p;
if (vd->orig_graphics3d) {
pp_resource_unref(vd->orig_graphics3d);
vd->orig_graphics3d = 0;
}
if (vd->graphics3d) {
pp_resource_unref(vd->graphics3d);
vd->graphics3d = 0;
}
if (vd->avparser) {
av_parser_close(vd->avparser);
vd->avparser = NULL;
}
if (vd->avctx)
avcodec_free_context(&vd->avctx);
if (vd->avframe)
av_frame_free(&vd->avframe);
if (vd->va_context.context_id) {
vaDestroyContext(display.va, vd->va_context.context_id);
vd->va_context.context_id = 0;
}
if (vd->va_context.config_id) {
vaDestroyConfig(display.va, vd->va_context.config_id);
vd->va_context.config_id = 0;
}
vaDestroySurfaces(display.va, vd->surfaces, MAX_VIDEO_SURFACES);
for (uintptr_t k = 0; k < MAX_VIDEO_SURFACES; k ++) {
vd->surfaces[k] = VA_INVALID_SURFACE;
vd->surface_used[k] = 0;
}
for (uintptr_t k = 0; k < vd->buffer_count; k ++) {
vd->ppp_video_decoder_dev->DismissPictureBuffer(vd->instance->id, vd->self_id,
vd->buffers[k].id);
pthread_mutex_lock(&display.lock);
glXDestroyPixmap(display.x, vd->buffers[k].glx_pixmap);
XFreePixmap(display.x, vd->buffers[k].pixmap);
pthread_mutex_unlock(&display.lock);
}
vd->buffer_count = 0;
vd->buffers_were_requested = 0;
free_and_nullify(vd->buffers);
}
VaapiSurface::~VaapiSurface()
{
VAStatus status;
delete m_derivedImage;
status = vaDestroySurfaces(m_display->getID(), &m_ID, 1);
if (!checkVaapiStatus(status, "vaDestroySurfaces()"))
WARNING("failed to destroy surface");
}
VAAPIContext::~VAAPIContext()
{
delete [] m_pictureAttributes;
ClearGLXSurfaces();
if (m_display)
{
m_display->m_x_disp->Lock();
INIT_ST;
if (m_image.image_id != VA_INVALID_ID)
{
va_status = vaDestroyImage(m_ctx.display, m_image.image_id);
CHECK_ST;
}
if (m_ctx.context_id)
{
va_status = vaDestroyContext(m_ctx.display, m_ctx.context_id);
CHECK_ST;
}
if (m_ctx.config_id)
{
va_status = vaDestroyConfig(m_ctx.display, m_ctx.config_id);
CHECK_ST;
}
if (m_surfaces)
{
va_status = vaDestroySurfaces(m_ctx.display, m_surfaces, m_numSurfaces);
CHECK_ST;
}
}
if (m_surfaces)
delete [] m_surfaces;
if (m_surfaceData)
delete [] m_surfaceData;
if (m_display)
{
m_display->m_x_disp->Unlock();
m_display->DecrRef();
}
delete m_copy;
LOG(VB_PLAYBACK, LOG_INFO, LOC + "Deleted context");
}
static void vaapi_buffer_free(void *opaque, uint8_t *data)
{
AVHWFramesContext *hwfc = opaque;
AVVAAPIDeviceContext *hwctx = hwfc->device_ctx->hwctx;
VASurfaceID surface_id;
VAStatus vas;
surface_id = (VASurfaceID)(uintptr_t)data;
vas = vaDestroySurfaces(hwctx->display, &surface_id, 1);
if (vas != VA_STATUS_SUCCESS) {
av_log(hwfc, AV_LOG_ERROR, "Failed to destroy surface %#x: "
"%d (%s).\n", surface_id, vas, vaErrorStr(vas));
}
}
static void
pool_pic_destroy_cb(picture_t *pic)
{
picture_sys_t *p_sys = pic->p_sys;
struct pic_sys_vaapi_instance *instance = p_sys->instance;
if (atomic_fetch_sub(&instance->pic_refcount, 1) == 1)
{
vaDestroySurfaces(instance->va_dpy, instance->render_targets,
instance->num_render_targets);
vlc_vaapi_ReleaseInstance(instance->va_inst);
free(instance);
}
free(pic->p_sys);
}
VdpStatus
softVdpDecoderDestroy(VdpDecoder decoder)
{
VdpDecoderData *decoderData = handle_acquire(decoder, HANDLETYPE_DECODER);
if (NULL == decoderData)
return VDP_STATUS_INVALID_HANDLE;
VdpDeviceData *deviceData = decoderData->device;
if (deviceData->va_available) {
VADisplay va_dpy = deviceData->va_dpy;
vaDestroySurfaces(va_dpy, decoderData->render_targets, decoderData->num_render_targets);
vaDestroyContext(va_dpy, decoderData->context_id);
vaDestroyConfig(va_dpy, decoderData->config_id);
}
handle_expunge(decoder);
deviceData->refcount --;
free(decoderData);
return VDP_STATUS_OK;
}
static void Delete( vlc_va_t *va, AVCodecContext *avctx )
{
vlc_va_sys_t *sys = va->sys;
(void) avctx;
vlc_mutex_destroy(&sys->lock);
CopyCleanCache(&sys->image_cache);
vaDestroyContext(sys->hw_ctx.display, sys->hw_ctx.context_id);
vaDestroySurfaces(sys->hw_ctx.display, sys->surfaces, sys->count);
vaDestroyConfig(sys->hw_ctx.display, sys->hw_ctx.config_id);
vaTerminate(sys->hw_ctx.display);
#ifdef VLC_VA_BACKEND_XLIB
XCloseDisplay( sys->p_display_x11 );
#endif
#ifdef VLC_VA_BACKEND_DRM
close( sys->drm_fd );
#endif
free( sys );
}
static void h264_cleanup_decoder()
{
VAStatus va_status;
rfbClientLog("%s()\n", __FUNCTION__);
if (va_surface_id[0] != VA_INVALID_ID) {
va_status = vaDestroySurfaces(va_dpy, &va_surface_id[0], SURFACE_NUM);
CHECK_VASTATUS(va_status, "vaDestroySurfaces");
}
if (va_context_id) {
va_status = vaDestroyContext(va_dpy, va_context_id);
CHECK_VASTATUS(va_status, "vaDestroyContext");
va_context_id = 0;
}
num_frames = 0;
sid = 0;
frame_id = 0;
field_order_count = 0;
}
static AVBufferRef *vaapi_pool_alloc(void *opaque, int size)
{
AVHWFramesContext *hwfc = opaque;
VAAPIFramesContext *ctx = hwfc->internal->priv;
AVVAAPIDeviceContext *hwctx = hwfc->device_ctx->hwctx;
AVVAAPIFramesContext *avfc = hwfc->hwctx;
VASurfaceID surface_id;
VAStatus vas;
AVBufferRef *ref;
vas = vaCreateSurfaces(hwctx->display, ctx->rt_format,
hwfc->width, hwfc->height,
&surface_id, 1,
ctx->attributes, ctx->nb_attributes);
if (vas != VA_STATUS_SUCCESS) {
av_log(hwfc, AV_LOG_ERROR, "Failed to create surface: "
"%d (%s).\n", vas, vaErrorStr(vas));
return NULL;
}
av_log(hwfc, AV_LOG_DEBUG, "Created surface %#x.\n", surface_id);
ref = av_buffer_create((uint8_t*)(uintptr_t)surface_id,
sizeof(surface_id), &vaapi_buffer_free,
hwfc, AV_BUFFER_FLAG_READONLY);
if (!ref) {
vaDestroySurfaces(hwctx->display, &surface_id, 1);
return NULL;
}
if (hwfc->initial_pool_size > 0) {
// This is a fixed-size pool, so we must still be in the initial
// allocation sequence.
av_assert0(avfc->nb_surfaces < hwfc->initial_pool_size);
avfc->surface_ids[avfc->nb_surfaces] = surface_id;
++avfc->nb_surfaces;
}
return ref;
}
int main(int argc,char **argv)
{
int major_ver, minor_ver;
VAStatus va_status;
pthread_t thread1;
int ret;
char c;
int i;
char str_src_fmt[5], str_dst_fmt[5];
static struct option long_options[] =
{
{"fmt1", required_argument, NULL, '1'},
{"fmt2", required_argument, NULL, '2'},
{0, 0, 0, 0}
};
while ((c =getopt_long(argc,argv,"w:h:g:r:d:f:tcep?n:1:2:v", long_options, NULL)) != EOF) {
switch (c) {
case '?':
printf("putsurface <options>\n");
printf(" -g <widthxheight+x_location+y_location> window geometry\n");
printf(" -w/-h resolution of surface\n");
printf(" -r <framerate>\n");
printf(" -d the dimension of black/write square box, default is 32\n");
printf(" -t multi-threads\n");
printf(" -c test clipbox\n");
printf(" -f <1/2> top field, or bottom field\n");
printf(" -1 source format (fourcc) for color conversion test\n");
printf(" -2 dest format (fourcc) for color conversion test\n");
printf(" --fmt1 same to -1\n");
printf(" --fmt2 same to -2\n");
printf(" -v verbose output\n");
exit(0);
break;
case 'g':
ret = sscanf(optarg, "%dx%d+%d+%d", &win_width, &win_height, &win_x, &win_y);
if (ret != 4) {
printf("invalid window geometry, must be widthxheight+x_location+y_location\n");
exit(0);
} else
printf("Create window at (%d, %d), width = %d, height = %d\n",
win_x, win_y, win_width, win_height);
break;
case 'r':
frame_rate = atoi(optarg);
break;
case 'w':
surface_width = atoi(optarg);
break;
case 'h':
surface_height = atoi(optarg);
break;
case 'n':
frame_num_total = atoi(optarg);
break;
case 'd':
box_width = atoi(optarg);
break;
case 't':
multi_thread = 1;
printf("Two threads to do vaPutSurface\n");
break;
case 'e':
check_event = 0;
break;
case 'p':
put_pixmap = 1;
break;
case 'c':
test_clip = 1;
break;
case 'f':
if (atoi(optarg) == 1) {
printf("Display TOP field\n");
display_field = VA_TOP_FIELD;
} else if (atoi(optarg) == 2) {
printf("Display BOTTOM field\n");
display_field = VA_BOTTOM_FIELD;
} else
printf("The validate input for -f is: 1(top field)/2(bottom field)\n");
break;
case '1':
sscanf(optarg, "%s", str_src_fmt);
csc_src_fourcc = map_str_to_vafourcc (str_src_fmt);
if (!csc_src_fourcc) {
printf("invalid fmt1: %s\n", str_src_fmt );
exit(0);
}
break;
case '2':
sscanf(optarg, "%s", str_dst_fmt);
csc_dst_fourcc = map_str_to_vafourcc (str_dst_fmt);
if (!csc_dst_fourcc) {
printf("invalid fmt1: %s\n", str_dst_fmt );
exit(0);
}
break;
case 'v':
verbose = 1;
printf("Enable verbose output\n");
break;
}
}
if (csc_src_fourcc && csc_dst_fourcc) {
test_color_conversion = 1;
}
win_display = (void *)open_display();
if (win_display == NULL) {
fprintf(stderr, "Can't open the connection of display!\n");
exit(-1);
}
create_window(win_display, win_x, win_y, win_width, win_height);
va_dpy = vaGetDisplay(win_display);
va_status = vaInitialize(va_dpy, &major_ver, &minor_ver);
CHECK_VASTATUS(va_status, "vaInitialize");
if (test_color_conversion) {
ret = csc_preparation();
}
if (!test_color_conversion || !ret ) {
va_status = vaCreateSurfaces(
va_dpy,
VA_RT_FORMAT_YUV420, surface_width, surface_height,
&surface_id[0], SURFACE_NUM,
NULL, 0
);
}
CHECK_VASTATUS(va_status, "vaCreateSurfaces");
if (multi_thread == 0) /* upload the content for all surfaces */
upload_source_YUV_once_for_all();
if (check_event)
pthread_mutex_init(&gmutex, NULL);
for(i = 0; i< SURFACE_NUM; i++)
pthread_mutex_init(&surface_mutex[i], NULL);
if (multi_thread == 1)
ret = pthread_create(&thread1, NULL, putsurface_thread, (void*)drawable_thread1);
putsurface_thread((void *)drawable_thread0);
if (multi_thread == 1)
pthread_join(thread1, (void **)&ret);
printf("thread1 is free\n");
if (test_color_conversion) {
// destroy temp surface/image
va_status = vaDestroySurfaces(va_dpy, &csc_render_surface, 1);
CHECK_VASTATUS(va_status,"vaDestroySurfaces");
va_status = vaDestroyImage(va_dpy, csc_dst_fourcc_image.image_id);
CHECK_VASTATUS(va_status,"vaDestroyImage");
}
if (vpp_config_id != VA_INVALID_ID) {
vaDestroyConfig (va_dpy, vpp_config_id);
vpp_config_id = VA_INVALID_ID;
}
vaDestroySurfaces(va_dpy,&surface_id[0],SURFACE_NUM);
vaTerminate(va_dpy);
free(va_image_formats);
free(va_surface_attribs);
close_display(win_display);
return 0;
}
int vaapi_exit(void)
{
VAAPIContext * const vaapi = vaapi_get_context();
unsigned int i;
if (!vaapi)
return 0;
#if USE_GLX
if (display_type() == DISPLAY_GLX)
vaapi_glx_destroy_surface();
#endif
destroy_buffers(vaapi->display, &vaapi->pic_param_buf_id, 1);
destroy_buffers(vaapi->display, &vaapi->iq_matrix_buf_id, 1);
destroy_buffers(vaapi->display, &vaapi->bitplane_buf_id, 1);
destroy_buffers(vaapi->display, vaapi->slice_buf_ids, vaapi->n_slice_buf_ids);
if (vaapi->subpic_flags) {
free(vaapi->subpic_flags);
vaapi->subpic_flags = NULL;
}
if (vaapi->subpic_formats) {
free(vaapi->subpic_formats);
vaapi->subpic_formats = NULL;
vaapi->n_subpic_formats = 0;
}
if (vaapi->image_formats) {
free(vaapi->image_formats);
vaapi->image_formats = NULL;
vaapi->n_image_formats = 0;
}
if (vaapi->entrypoints) {
free(vaapi->entrypoints);
vaapi->entrypoints = NULL;
vaapi->n_entrypoints = 0;
}
if (vaapi->profiles) {
free(vaapi->profiles);
vaapi->profiles = NULL;
vaapi->n_profiles = 0;
}
if (vaapi->slice_params) {
free(vaapi->slice_params);
vaapi->slice_params = NULL;
vaapi->slice_params_alloc = 0;
vaapi->n_slice_params = 0;
}
if (vaapi->slice_buf_ids) {
free(vaapi->slice_buf_ids);
vaapi->slice_buf_ids = NULL;
vaapi->n_slice_buf_ids = 0;
}
if (vaapi->subpic_image.image_id != VA_INVALID_ID) {
vaDestroyImage(vaapi->display, vaapi->subpic_image.image_id);
vaapi->subpic_image.image_id = VA_INVALID_ID;
}
for (i = 0; i < ARRAY_ELEMS(vaapi->subpic_ids); i++) {
if (vaapi->subpic_ids[i] != VA_INVALID_ID) {
vaDestroySubpicture(vaapi->display, vaapi->subpic_ids[i]);
vaapi->subpic_ids[i] = VA_INVALID_ID;
}
}
if (vaapi->surface_id) {
vaDestroySurfaces(vaapi->display, &vaapi->surface_id, 1);
vaapi->surface_id = 0;
}
if (vaapi->context_id) {
vaDestroyContext(vaapi->display, vaapi->context_id);
vaapi->context_id = 0;
}
if (vaapi->config_id) {
vaDestroyConfig(vaapi->display, vaapi->config_id);
vaapi->config_id = 0;
}
if (vaapi->display) {
vaTerminate(vaapi->display);
vaapi->display = NULL;
}
free(vaapi_context);
return 0;
}
int vaapi_init_decoder(VAProfile profile,
VAEntrypoint entrypoint,
unsigned int picture_width,
unsigned int picture_height)
{
VAAPIContext * const vaapi = vaapi_get_context();
VAConfigAttrib attrib;
VAConfigID config_id = 0;
VAContextID context_id = 0;
VASurfaceID surface_id = 0;
VAStatus status;
if (!vaapi)
return -1;
#if 0
if (common_init_decoder(picture_width, picture_height) < 0)
return -1;
#endif
if (!has_profile(vaapi, profile))
return -1;
if (!has_entrypoint(vaapi, profile, entrypoint))
return -1;
if (vaapi->profile != profile || vaapi->entrypoint != entrypoint) {
if (vaapi->config_id)
vaDestroyConfig(vaapi->display, vaapi->config_id);
attrib.type = VAConfigAttribRTFormat;
status = vaGetConfigAttributes(vaapi->display, profile, entrypoint,
&attrib, 1);
if (!vaapi_check_status(status, "vaGetConfigAttributes()"))
return -1;
if ((attrib.value & VA_RT_FORMAT_YUV420) == 0)
return -1;
status = vaCreateConfig(vaapi->display, profile, entrypoint,
&attrib, 1, &config_id);
if (!vaapi_check_status(status, "vaCreateConfig()"))
return -1;
}
else
config_id = vaapi->config_id;
if (vaapi->picture_width != picture_width || vaapi->picture_height != picture_height) {
if (vaapi->surface_id)
vaDestroySurfaces(vaapi->display, &vaapi->surface_id, 1);
status = vaCreateSurfaces(vaapi->display, picture_width, picture_height,
VA_RT_FORMAT_YUV420, 1, &surface_id);
if (!vaapi_check_status(status, "vaCreateSurfaces()"))
return -1;
if (vaapi->context_id)
vaDestroyContext(vaapi->display, vaapi->context_id);
status = vaCreateContext(vaapi->display, config_id,
picture_width, picture_height,
VA_PROGRESSIVE,
&surface_id, 1,
&context_id);
if (!vaapi_check_status(status, "vaCreateContext()"))
return -1;
}
else {
context_id = vaapi->context_id;
surface_id = vaapi->surface_id;
}
vaapi->config_id = config_id;
vaapi->context_id = context_id;
vaapi->surface_id = surface_id;
vaapi->profile = profile;
vaapi->entrypoint = entrypoint;
vaapi->picture_width = picture_width;
vaapi->picture_height = picture_height;
return 0;
}
void HwAccX11Trait<IMGFMT_VAAPI>::destroySurface(SurfaceID id) {
vaDestroySurfaces(VaApi::glx(), &id, 1);
}
mfxStatus vaapiFrameAllocator::AllocImpl(mfxFrameAllocRequest *request, mfxFrameAllocResponse *response)
{
mfxStatus mfx_res = MFX_ERR_NONE;
VAStatus va_res = VA_STATUS_SUCCESS;
unsigned int va_fourcc = 0;
VASurfaceID* surfaces = NULL;
VASurfaceAttrib attrib;
vaapiMemId *vaapi_mids = NULL, *vaapi_mid = NULL;
mfxMemId* mids = NULL;
mfxU32 fourcc = request->Info.FourCC;
mfxU16 surfaces_num = request->NumFrameSuggested, numAllocated = 0, i = 0;
bool bCreateSrfSucceeded = false;
memset(response, 0, sizeof(mfxFrameAllocResponse));
va_fourcc = ConvertMfxFourccToVAFormat(fourcc);
if (!va_fourcc || ((VA_FOURCC_NV12 != va_fourcc) &&
(VA_FOURCC_YV12 != va_fourcc) &&
(VA_FOURCC_YUY2 != va_fourcc) &&
(VA_FOURCC_ARGB != va_fourcc) &&
(VA_FOURCC_P208 != va_fourcc)))
{
return MFX_ERR_MEMORY_ALLOC;
}
if (!surfaces_num)
{
return MFX_ERR_MEMORY_ALLOC;
}
if (MFX_ERR_NONE == mfx_res)
{
surfaces = (VASurfaceID*)calloc(surfaces_num, sizeof(VASurfaceID));
vaapi_mids = (vaapiMemId*)calloc(surfaces_num, sizeof(vaapiMemId));
mids = (mfxMemId*)calloc(surfaces_num, sizeof(mfxMemId));
if ((NULL == surfaces) || (NULL == vaapi_mids) || (NULL == mids)) mfx_res = MFX_ERR_MEMORY_ALLOC;
}
if (MFX_ERR_NONE == mfx_res)
{
if( VA_FOURCC_P208 != va_fourcc )
{
attrib.type = VASurfaceAttribPixelFormat;
attrib.value.type = VAGenericValueTypeInteger;
attrib.value.value.i = va_fourcc;
attrib.flags = VA_SURFACE_ATTRIB_SETTABLE;
va_res = vaCreateSurfaces(m_dpy,
VA_RT_FORMAT_YUV420,
request->Info.Width, request->Info.Height,
surfaces,
surfaces_num,
&attrib, 1);
mfx_res = va_to_mfx_status(va_res);
bCreateSrfSucceeded = (MFX_ERR_NONE == mfx_res);
}
else
{
VAContextID context_id = request->reserved[0];
int codedbuf_size = static_cast<int>((request->Info.Width * request->Info.Height) * 400LL / (16 * 16));
for (numAllocated = 0; numAllocated < surfaces_num; numAllocated++)
{
VABufferID coded_buf;
va_res = vaCreateBuffer(m_dpy,
context_id,
VAEncCodedBufferType,
codedbuf_size,
1,
NULL,
&coded_buf);
mfx_res = va_to_mfx_status(va_res);
if (MFX_ERR_NONE != mfx_res) break;
surfaces[numAllocated] = coded_buf;
}
}
}
if (MFX_ERR_NONE == mfx_res)
{
for (i = 0; i < surfaces_num; ++i)
{
vaapi_mid = &(vaapi_mids[i]);
vaapi_mid->m_fourcc = fourcc;
vaapi_mid->m_surface = &(surfaces[i]);
mids[i] = vaapi_mid;
}
}
if (MFX_ERR_NONE == mfx_res)
{
response->mids = mids;
response->NumFrameActual = surfaces_num;
}
else // i.e. MFX_ERR_NONE != mfx_res
{
response->mids = NULL;
response->NumFrameActual = 0;
if (VA_FOURCC_P208 != va_fourcc)
{
if (bCreateSrfSucceeded) vaDestroySurfaces(m_dpy, surfaces, surfaces_num);
}
else
{
for (i = 0; i < numAllocated; i++)
vaDestroyBuffer(m_dpy, surfaces[i]);
}
if (mids)
{
free(mids);
mids = NULL;
}
if (vaapi_mids) { free(vaapi_mids); vaapi_mids = NULL; }
if (surfaces) { free(surfaces); surfaces = NULL; }
}
return mfx_res;
}
int main(int argc,char **argv)
{
int major_ver, minor_ver;
VAStatus va_status;
pthread_t thread1;
int ret;
char c;
int i;
while ((c =getopt(argc,argv,"w:h:g:r:d:f:tcep?n:v") ) != EOF) {
switch (c) {
case '?':
printf("putsurface <options>\n");
printf(" -g <widthxheight+x_location+y_location> window geometry\n");
printf(" -w/-h resolution of surface\n");
printf(" -r <framerate>\n");
printf(" -d the dimension of black/write square box, default is 32\n");
printf(" -t multi-threads\n");
printf(" -c test clipbox\n");
printf(" -f <1/2> top field, or bottom field\n");
printf(" -v verbose output\n");
exit(0);
break;
case 'g':
ret = sscanf(optarg, "%dx%d+%d+%d", &win_width, &win_height, &win_x, &win_y);
if (ret != 4) {
printf("invalid window geometry, must be widthxheight+x_location+y_location\n");
exit(0);
} else
printf("Create window at (%d, %d), width = %d, height = %d\n",
win_x, win_y, win_width, win_height);
break;
case 'r':
frame_rate = atoi(optarg);
break;
case 'w':
surface_width = atoi(optarg);
break;
case 'h':
surface_height = atoi(optarg);
break;
case 'n':
frame_num_total = atoi(optarg);
break;
case 'd':
box_width = atoi(optarg);
break;
case 't':
multi_thread = 1;
printf("Two threads to do vaPutSurface\n");
break;
case 'e':
check_event = 0;
break;
case 'p':
put_pixmap = 1;
break;
case 'c':
test_clip = 1;
break;
case 'f':
if (atoi(optarg) == 1) {
printf("Display TOP field\n");
display_field = VA_TOP_FIELD;
} else if (atoi(optarg) == 2) {
printf("Display BOTTOM field\n");
display_field = VA_BOTTOM_FIELD;
} else
printf("The validate input for -f is: 1(top field)/2(bottom field)\n");
break;
case 'v':
verbose = 1;
printf("Enable verbose output\n");
break;
}
}
win_display = (void *)open_display();
if (win_display == NULL) {
fprintf(stderr, "Can't open the connection of display!\n");
exit(-1);
}
create_window(win_display, win_x, win_y, win_width, win_height);
va_dpy = vaGetDisplay(win_display);
va_status = vaInitialize(va_dpy, &major_ver, &minor_ver);
CHECK_VASTATUS(va_status, "vaInitialize");
va_status = vaCreateSurfaces(va_dpy,surface_width, surface_height,
VA_RT_FORMAT_YUV420, SURFACE_NUM, &surface_id[0]);
CHECK_VASTATUS(va_status, "vaCreateSurfaces");
if (multi_thread == 0) /* upload the content for all surfaces */
upload_source_YUV_once_for_all();
if (check_event)
pthread_mutex_init(&gmutex, NULL);
for(i = 0; i< SURFACE_NUM; i++)
pthread_mutex_init(&surface_mutex[i], NULL);
if (multi_thread == 1)
ret = pthread_create(&thread1, NULL, putsurface_thread, (void*)drawable_thread1);
putsurface_thread((void *)drawable_thread0);
if (multi_thread == 1)
pthread_join(thread1, (void **)&ret);
printf("thread1 is free\n");
vaDestroySurfaces(va_dpy,&surface_id[0],SURFACE_NUM);
vaTerminate(va_dpy);
close_display(win_display);
return 0;
}
static int Create( vlc_va_t *va, AVCodecContext *ctx, enum PixelFormat pix_fmt,
const es_format_t *fmt, picture_sys_t *p_sys )
{
if( pix_fmt != AV_PIX_FMT_VAAPI_VLD )
return VLC_EGENERIC;
(void) fmt;
(void) p_sys;
#ifdef VLC_VA_BACKEND_XLIB
if( !vlc_xlib_init( VLC_OBJECT(va) ) )
{
msg_Warn( va, "Ignoring VA-X11 API" );
return VLC_EGENERIC;
}
#endif
VAProfile i_profile, *p_profiles_list;
bool b_supported_profile = false;
int i_profiles_nb = 0;
unsigned count = 3;
/* */
switch( ctx->codec_id )
{
case AV_CODEC_ID_MPEG1VIDEO:
case AV_CODEC_ID_MPEG2VIDEO:
i_profile = VAProfileMPEG2Main;
count = 4;
break;
case AV_CODEC_ID_MPEG4:
i_profile = VAProfileMPEG4AdvancedSimple;
break;
case AV_CODEC_ID_WMV3:
i_profile = VAProfileVC1Main;
break;
case AV_CODEC_ID_VC1:
i_profile = VAProfileVC1Advanced;
break;
case AV_CODEC_ID_H264:
i_profile = VAProfileH264High;
count = 18;
break;;
default:
return VLC_EGENERIC;
}
count += ctx->thread_count;
vlc_va_sys_t *sys;
void *mem;
assert(popcount(sizeof (sys->surfaces)) == 1);
if (unlikely(posix_memalign(&mem, sizeof (sys->surfaces), sizeof (*sys))))
return VLC_ENOMEM;
sys = mem;
memset(sys, 0, sizeof (*sys));
/* */
sys->hw_ctx.display = NULL;
sys->hw_ctx.config_id = VA_INVALID_ID;
sys->hw_ctx.context_id = VA_INVALID_ID;
sys->width = ctx->coded_width;
sys->height = ctx->coded_height;
sys->count = count;
sys->available = (1 << sys->count) - 1;
assert(count < sizeof (sys->available) * CHAR_BIT);
assert(count * sizeof (sys->surfaces[0]) <= sizeof (sys->surfaces));
/* Create a VA display */
#ifdef VLC_VA_BACKEND_XLIB
sys->p_display_x11 = XOpenDisplay(NULL);
if( !sys->p_display_x11 )
{
msg_Err( va, "Could not connect to X server" );
goto error;
}
sys->hw_ctx.display = vaGetDisplay(sys->p_display_x11);
#endif
#ifdef VLC_VA_BACKEND_DRM
sys->drm_fd = vlc_open("/dev/dri/card0", O_RDWR);
if( sys->drm_fd == -1 )
{
msg_Err( va, "Could not access rendering device: %m" );
goto error;
}
sys->hw_ctx.display = vaGetDisplayDRM(sys->drm_fd);
#endif
if (sys->hw_ctx.display == NULL)
{
msg_Err( va, "Could not get a VAAPI device" );
goto error;
}
int major, minor;
if (vaInitialize(sys->hw_ctx.display, &major, &minor))
{
msg_Err( va, "Failed to initialize the VAAPI device" );
goto error;
}
/* Check if the selected profile is supported */
i_profiles_nb = vaMaxNumProfiles(sys->hw_ctx.display);
p_profiles_list = calloc( i_profiles_nb, sizeof( VAProfile ) );
if( !p_profiles_list )
goto error;
if (vaQueryConfigProfiles(sys->hw_ctx.display, p_profiles_list,
&i_profiles_nb) == VA_STATUS_SUCCESS)
{
for( int i = 0; i < i_profiles_nb; i++ )
{
if ( p_profiles_list[i] == i_profile )
{
b_supported_profile = true;
break;
}
}
}
free( p_profiles_list );
if ( !b_supported_profile )
{
msg_Dbg( va, "Codec and profile not supported by the hardware" );
goto error;
}
/* Create a VA configuration */
VAConfigAttrib attrib;
memset( &attrib, 0, sizeof(attrib) );
attrib.type = VAConfigAttribRTFormat;
if (vaGetConfigAttributes(sys->hw_ctx.display, i_profile, VAEntrypointVLD,
&attrib, 1))
goto error;
/* Not sure what to do if not, I don't have a way to test */
if( (attrib.value & VA_RT_FORMAT_YUV420) == 0 )
goto error;
if (vaCreateConfig(sys->hw_ctx.display, i_profile, VAEntrypointVLD,
&attrib, 1, &sys->hw_ctx.config_id))
{
sys->hw_ctx.config_id = VA_INVALID_ID;
goto error;
}
/* Create surfaces */
assert(ctx->coded_width > 0 && ctx->coded_height > 0);
if (vaCreateSurfaces(sys->hw_ctx.display, VA_RT_FORMAT_YUV420,
ctx->coded_width, ctx->coded_height,
sys->surfaces, sys->count, NULL, 0))
{
goto error;
}
/* Create a context */
if (vaCreateContext(sys->hw_ctx.display, sys->hw_ctx.config_id,
ctx->coded_width, ctx->coded_height, VA_PROGRESSIVE,
sys->surfaces, sys->count, &sys->hw_ctx.context_id))
{
sys->hw_ctx.context_id = VA_INVALID_ID;
vaDestroySurfaces(sys->hw_ctx.display, sys->surfaces, sys->count);
goto error;
}
if (FindFormat(sys))
goto error;
if (unlikely(CopyInitCache(&sys->image_cache, ctx->coded_width)))
goto error;
vlc_mutex_init(&sys->lock);
msg_Dbg(va, "using %s image format 0x%08x",
sys->do_derive ? "derive" : "get", sys->format.fourcc);
ctx->hwaccel_context = &sys->hw_ctx;
va->sys = sys;
va->description = vaQueryVendorString(sys->hw_ctx.display);
va->get = Get;
va->release = Release;
va->extract = Extract;
return VLC_SUCCESS;
error:
if (sys->hw_ctx.context_id != VA_INVALID_ID)
{
vaDestroyContext(sys->hw_ctx.display, sys->hw_ctx.context_id);
vaDestroySurfaces(sys->hw_ctx.display, sys->surfaces, sys->count);
}
if (sys->hw_ctx.config_id != VA_INVALID_ID)
vaDestroyConfig(sys->hw_ctx.display, sys->hw_ctx.config_id);
if (sys->hw_ctx.display != NULL)
vaTerminate(sys->hw_ctx.display);
#ifdef VLC_VA_BACKEND_XLIB
if( sys->p_display_x11 != NULL )
XCloseDisplay( sys->p_display_x11 );
#endif
#ifdef VLC_VA_BACKEND_DRM
if( sys->drm_fd != -1 )
close( sys->drm_fd );
#endif
free( sys );
return VLC_EGENERIC;
}
