Attachment 71256 Details for Bug 57398 – test program for this bug

test program for this bug

main.c (text/plain), 14.53 KB, created by Clear on 2012-12-10 08:51:21 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Clear

Created: 2012-12-10 08:51:21 UTC

Size: 14.53 KB

patch

obsolete

>#include <stdio.h>
>#include <stdlib.h>
>#include <unistd.h>
>#include <fcntl.h>
>#include <inttypes.h>
>#include <string.h>
>
>#include <va/va_x11.h>
>#include <va/va.h>
>#include <va/va_vpp.h>
>
>typedef struct _vpp_context {
>	Display *x11_dpy;
>	VADisplay va_dpy;
>	VAContextID va_context_id;
>	VAConfigID va_config_id;
>	int width;
>	int height;
>} VPP_Context;
>
>typedef struct _va_surface {
>	int width;
>	int height;
>	VASurfaceID surface_id;
>} VA_Surface;
>
>enum Surface_Ids {
>	OUTPUT_SURFACE = 0,
>	INPUT_SURFACE_0,
>	INPUT_SURFACE_1,
>	INPUT_SURFACE_2,
>	INPUT_SURFACE_3,
>	NUM_VA_SURFACES
>};
>
>VARectangle output_region[4];
>
>
>
>#define NV12_FOURCC_FMT		VA_FOURCC('N','V','1','2')
>
>short check_vaStatus(VAStatus status, const char* func)
>{
>    if (status != VA_STATUS_SUCCESS) {
>    	printf("\n%s() failed. Error=%d\n", func, status);
>        return (1);
>    }
>    return 0;
>}
>
>int vpp_context_init(VPP_Context* vpp_context)
>{
>	VAStatus va_status;
>	VAEntrypoint entrypoints[5];
>	int major_ver = 0;
>	int minor_ver = 0;
>	XWindowAttributes x11_attr;
>	int num_entrypoints, proc_entrypoint;
>	VAConfigAttrib attrib;
>
>	vpp_context->x11_dpy = NULL;
>	vpp_context->va_context_id = VA_INVALID_ID;
>	vpp_context->va_config_id = VA_INVALID_ID;
>
>	if (NULL == (vpp_context->x11_dpy = XOpenDisplay(NULL))) {
>		perror("Failed to open X Display");
>		return -1;
>	}
>
>	/* Full screen */
>	Window wid = DefaultRootWindow(vpp_context->x11_dpy);
>	XGetWindowAttributes(vpp_context->x11_dpy, wid, &x11_attr);
>	vpp_context->width = x11_attr.width;
>	vpp_context->height = x11_attr.height;
>
>	vpp_context->va_dpy = vaGetDisplay(vpp_context->x11_dpy);
>	va_status = vaInitialize(vpp_context->va_dpy, &major_ver, &minor_ver);
>
>	/* Check if LibVA has post processing entry points */
>	va_status = vaQueryConfigEntrypoints(vpp_context->va_dpy,
>										 VAProfileNone,
>										 entrypoints,
>										 &num_entrypoints);
>	if (check_vaStatus(va_status, "vaQueryConfigEntrypoints")) {
>		return -1;
>	}
>
>	for (proc_entrypoint = 0; proc_entrypoint < num_entrypoints; proc_entrypoint++) {
>		if (entrypoints[proc_entrypoint] == VAEntrypointVideoProc)
>			break;
>	}
>
>	if (proc_entrypoint == num_entrypoints) {
>		perror("Could not find Video Post Processing entry point");
>		return -1;
>	}
>
>	/* Get the attributes of the VAEntrypointVideoProc entry point
>	 * and check if YUV format is supported */
>	attrib.type = VAConfigAttribRTFormat;
>	vaGetConfigAttributes (vpp_context->va_dpy,
>						   VAProfileNone,
>						   VAEntrypointVideoProc,
>						   &attrib, 1);
>
>	if (0 == (attrib.value & VA_RT_FORMAT_YUV420)) {
>		perror("YUV 420 is not supported in this format");
>		return -1;
>	}
>
>	va_status = vaCreateConfig(vpp_context->va_dpy,
>							   VAProfileNone, VAEntrypointVideoProc,
>							   &attrib, 1, &vpp_context->va_config_id);
>	if (check_vaStatus(va_status, "vaCreateConfig")) {
>		return -1;
>	}
>
>	/* Create a context for VPP pipeline */
>	va_status = vaCreateContext(vpp_context->va_dpy, vpp_context->va_config_id,
>								vpp_context->width,
>								vpp_context->height,
>							    VA_PROGRESSIVE, NULL, 0,
>							    &vpp_context->va_context_id);
>	if (check_vaStatus(va_status, "vaCreateContext")) {
>		return -1;
>	}
>
>	return 0;
>}
>
>int vpp_context_uninit(VPP_Context *vpp_ctx)
>{
>	int ret = 0;
>
>	VAStatus va_status = VA_STATUS_ERROR_UNKNOWN;
>
>	/* Destroy the VPP context */
>	if (VA_INVALID_ID != vpp_ctx->va_context_id) {
>		va_status = vaDestroyContext(vpp_ctx->va_dpy, vpp_ctx->va_context_id);
>		if (check_vaStatus(va_status, "vaDestroyContext")) {
>			ret = -1;
>		}
>		vpp_ctx->va_context_id = VA_INVALID_ID;
>	}
>
>	/* Destroy the VPP configuration */
>	if (VA_INVALID_ID != vpp_ctx->va_config_id) {
>		va_status = vaDestroyConfig(vpp_ctx->va_dpy, vpp_ctx->va_config_id);
>		if (check_vaStatus(va_status, "vaDestroyConfig")) {
>			ret = -1;
>		}
>		vpp_ctx->va_config_id = VA_INVALID_ID;
>	}
>
>	/* Close VAAPI */
>	va_status = vaTerminate(vpp_ctx->va_dpy);
>	if (check_vaStatus(va_status, "vaTerminate")) {
>		ret = -1;
>	}
>
>	/* Close X11 display */
>	if (NULL != vpp_ctx->x11_dpy) {
>		XCloseDisplay(vpp_ctx->x11_dpy);
>	}
>
>	return ret;
>}
>
>int vaapi_load_surface (VPP_Context *vpp_context, VA_Surface* surfaces, const unsigned char* data, const int input_num)
>{
>int size = 0;
>  for(; size < input_num; size++)
>  {	VAImage load_image;
>	VAImageFormat *imgFmt = NULL;
>	VAStatus va_status = VA_STATUS_ERROR_UNKNOWN;
>	int numVaImageFormats = 0;
>	unsigned int i, j;
>	void *pOutBuffer = NULL;
>	const unsigned char *ySrcPtr, *uSrcPtr, *vSrcPtr;
>	unsigned char *yDestPtr, *uvDestPtr;
>	unsigned char *uvDestImage_Index = NULL;
>
>	/* Check if the NV12 pixel format is available.  */
>	numVaImageFormats = vaMaxNumImageFormats(vpp_context->va_dpy);
>	imgFmt = (VAImageFormat*) malloc(numVaImageFormats * sizeof(*imgFmt));
>	if (NULL == imgFmt) {
>		perror("malloc failure (VAImageFormat)");
>		return -1;
>	}
>	va_status = vaQueryImageFormats(vpp_context->va_dpy, imgFmt, &numVaImageFormats);
>	if (check_vaStatus(va_status, "vaQueryImageFormats")) {
>		free(imgFmt);
>		return -1;
>	}
>	for (i = 0; i < numVaImageFormats; i++) {
>		if (NV12_FOURCC_FMT == imgFmt[i].fourcc) {
>			break;
>		}
>	}
>	if (i == numVaImageFormats) {
>		free(imgFmt);
>		perror("NV12 Image not available");
>		return -1;
>	}
>
>	va_status = vaCreateImage(vpp_context->va_dpy, &imgFmt[i],
>			1280,//surface->width,
>			720,//surface->height,
>			&load_image);
>	if (check_vaStatus(va_status, "vaCreateImage")) {
>		free(imgFmt);
>		return -1;
>	}
>
>	free(imgFmt);
>
>	/*
>	 * Copy YUV frame to VA Image
>	 * */
>	va_status = vaMapBuffer(vpp_context->va_dpy, load_image.buf, (void*) &pOutBuffer);
>	if (check_vaStatus(va_status, "vaMapBuffer")) {
>		return -1;
>	}
>
>	/* Setup source pointers to Y, U and V planes */
>	ySrcPtr = data;
>	uSrcPtr = data + load_image.width * load_image.height;
>	vSrcPtr = data + load_image.width * load_image.height + ((load_image.width
>			* load_image.height) >> 2);
>
>	/* Setup pointers in destination image based on offset values */
>	yDestPtr = (unsigned char*) (pOutBuffer + load_image.offsets[0]);
>	uvDestPtr = (unsigned char*) (pOutBuffer + load_image.offsets[1]);
>
>	/* YV12 or I420 format */
>	for (i = 0; i < load_image.height; i += 2) {
>		memcpy(yDestPtr, ySrcPtr, load_image.width);
>		memcpy(yDestPtr + load_image.pitches[0], ySrcPtr + load_image.width,
>				load_image.width);
>
>		/* Update buffer indexes */
>		ySrcPtr += load_image.width * 2;
>		yDestPtr += load_image.pitches[0] * 2;
>
>		/* Fill up U and V spaces */
>		uvDestImage_Index = uvDestPtr;
>		for (j = 0; j < load_image.width; j += 2) {
>			*(uvDestImage_Index++) = *(uSrcPtr++);
>			*(uvDestImage_Index++) = *(vSrcPtr++);
>		}
>		uvDestPtr += load_image.pitches[1];
>	}
>	va_status = vaUnmapBuffer(vpp_context->va_dpy, load_image.buf);
>	if (check_vaStatus(va_status, "vaUnmapBuffer")) {
>		return -1;
>	}
>
>
>//        printf("come on\n");
>  	VA_Surface* surface = &(surfaces[size]);
>	/* Copy input image to VPP input surface */
>	va_status = vaPutImage (vpp_context->va_dpy,
>				surface->surface_id,
>				load_image.image_id,
>	            0, 0, surface->width, surface->height,
>	            0, 0, surface->width, surface->height);
>	if (check_vaStatus(va_status, "vaPutImage")) {
>		return -1;
>	}
>
>	/* Destroy VA image used to input YUV frame onto surface. */
>	if (VA_INVALID_ID != load_image.image_id) {
>		vaDestroyImage(vpp_context->va_dpy, load_image.image_id);
>		if (check_vaStatus(va_status, "vaDestroyImage")) {
>			return -1;
>		}
>		load_image.image_id = VA_INVALID_ID;
>	}
>}
>
>	return 0;
>}
>
>int vaapi_vpp_run (VPP_Context *vpp_context, VA_Surface* input_surfaces, VA_Surface* output_surface, VARectangle* output_regions, unsigned int bg_color, const int input_num)
>{
>	VAStatus va_status;
>	VAProcPipelineParameterBuffer *pipeline_param[4];
>	VABufferID pipeline_param_buffer_id[4];
>	VARectangle input_region[4];
>	
>//	printf("vaapi_vpp_run1\n");
>
>
>
>  int size = 0;
>  for(;size < input_num;size++)
>  {
>  		va_status = vaBeginPicture (vpp_context->va_dpy,
>							    vpp_context->va_context_id,
>							    output_surface->surface_id);
>	if (check_vaStatus(va_status, "vaBeginPicture")) {
>		return -1;
>	}
>  	 //VABufferID filter_bufs[VAProcFilterCount];
>    //unsigned int num_filter_bufs;
>  	VA_Surface* input_surface = &(input_surfaces[size]);
>  	VARectangle* output_region = &(output_regions[size]);
>	/* Setup input region */
>	input_region[size].x = 0;
>	input_region[size].y = 0;
>	input_region[size].width = input_surface->width;
>	input_region[size].height = input_surface->height;
>
>	/* Create an empty pipeline parameter buffer that will be
>	 * destroyed automatically after rendering
>	 */
>	va_status = vaCreateBuffer (vpp_context->va_dpy,
>	     						vpp_context->va_context_id,
>	                            VAProcPipelineParameterBufferType,
>	                            sizeof(VAProcPipelineParameterBuffer),
>	                            1,
>	                            NULL,
>	                            &pipeline_param_buffer_id[size]);
>	if (check_vaStatus(va_status, "vaCreateBuffer")) {
>		return -1;
>	}
>
>	/* Initialise buffer */
>	vaMapBuffer(vpp_context->va_dpy, pipeline_param_buffer_id[size], (void*) &(pipeline_param[size]));
>	pipeline_param[size]->surface = input_surface->surface_id;
>	pipeline_param[size]->surface_region = &input_region[size];
>	pipeline_param[size]->output_region = output_region;
>
>	pipeline_param[size]->output_background_color = 0x00000000;//bg_color;  /* Use 0xff000000 for first pic, 0x00000000 for subsequent ones */
>	
>	if(size == 0) 
>	pipeline_param[size]->output_background_color = 0xff000000;
>	
>	
>	pipeline_param[size]->filter_flags = VA_FILTER_SCALING_HQ;//VA_FILTER_SCALING_HQ;   // VA_FILTER_SCALING_NL_ANAMORPHIC
>	pipeline_param[size]->filters = NULL;
>	pipeline_param[size]->num_filters = 0;
>	pipeline_param[size]->pipeline_flags = VA_PROC_PIPELINE_SUBPICTURES;//0; //VA_PROC_PIPELINE_SUBPICTURES; 
>	vaUnmapBuffer(vpp_context->va_dpy, pipeline_param_buffer_id[size]);
>	
>		va_status = vaRenderPicture (vpp_context->va_dpy,
>							     vpp_context->va_context_id,
>	                             &pipeline_param_buffer_id[size],
>	                             1);
>	if (check_vaStatus(va_status, "vaRenderPicture")) {
>		return -1;
>	}
>
>	va_status = vaEndPicture(vpp_context->va_dpy, vpp_context->va_context_id);
>	if (check_vaStatus(va_status, "vaEndPicture")) {
>		return -1;
>	}
>	
>}
>  
>
>	
>//	printf("vaapi_vpp_run2\n");
>
>	return 0;
>}
>
>int main (int argc, char *argv[])
>{
>	uint8_t* input_buffer = NULL;
>	uint32_t frame_size = 0;
>	uint32_t r_items = 0;
>	FILE* fp = NULL;
>	char* input_file_path = "test.yuv";
>
>	Window  win;
>
>	VPP_Context vpp_context;
>	VA_Surface surface[NUM_VA_SURFACES];   // Input and output surfaces
>	//VARectangle output_region;
>	VAStatus va_status;
>	short i;
>
>	surface[INPUT_SURFACE_0].height = 720;
>	surface[INPUT_SURFACE_0].width = 1280;
>	surface[INPUT_SURFACE_1].height = 720;
>	surface[INPUT_SURFACE_1].width = 1280;	
>	surface[INPUT_SURFACE_2].height = 720;
>	surface[INPUT_SURFACE_2].width = 1280;
>	surface[INPUT_SURFACE_3].height = 720;
>	surface[INPUT_SURFACE_3].width = 1280;
>	
>	/*
>	 * Read input image from file
>	 */
>	fp = fopen(input_file_path,"rb");
>	if (NULL == fp) {
>		perror("Failed to open input file");
>		exit(1);
>	}
>	frame_size = ((surface[INPUT_SURFACE_0].height * surface[INPUT_SURFACE_0].width) * 3) / 2;  // YUV - Y full; U,V each subsampled by 2 in each direction
>	input_buffer = (uint8_t*) malloc (frame_size * sizeof(uint8_t));
>	r_items = fread(input_buffer, frame_size, 1, fp);
>	fclose (fp);
>	if (r_items < 1) {
>		free (input_buffer);
>		perror("Invalid input file");
>		exit(1);
>	}
>
>	/*
>	 * Initialise VA API
>	 */
>	if (vpp_context_init(&vpp_context)) {
>		exit(1);
>	}
>
>	surface[OUTPUT_SURFACE].width = vpp_context.width;
>	surface[OUTPUT_SURFACE].height = vpp_context.height;
>
>	/* Create input and output surfaces */
>	for (i = 0; i < NUM_VA_SURFACES; i++) {
>		va_status = vaCreateSurfaces(vpp_context.va_dpy,
>									 VA_RT_FORMAT_YUV420,
>									 surface[i].width*1.5,
>									 surface[i].height*1.5,
>									 &surface[i].surface_id,
>									 1, NULL, 0);
>		if (check_vaStatus(va_status, "vaCreateSurfaces")) {
>			return 1;
>		}
>	}
>
>	/* Create display window */
>	win = XCreateSimpleWindow (vpp_context.x11_dpy,
>									  	   RootWindow(vpp_context.x11_dpy, 0),
>									  	   0, 0, vpp_context.width, vpp_context.height,
>									  	   0, 0, WhitePixel(vpp_context.x11_dpy, 0));
>	XMapWindow (vpp_context.x11_dpy, win);
>
>	/* Upload image to input surface */
>	if (vaapi_load_surface (&vpp_context, &surface[INPUT_SURFACE_0], input_buffer, 4)) {
>		printf ("\nVA API load surface failed\n");
>		free (input_buffer);
>		vpp_context_uninit (&vpp_context);
>		exit(1);
>	}
>	free (input_buffer);
>
>	output_region[0].x = 40;//50;
>	output_region[0].y = 50;//50;
>	output_region[0].width =  16 * 40;//surface[OUTPUT_SURFACE].width /2;//16* 40; //surface[INPUT_SURFACE].width / 2;
>	output_region[0].height = 16 * 25;//surface[OUTPUT_SURFACE].height /2;//8 * 50; //surface[INPUT_SURFACE].height / 2;
>	output_region[1].x = 40 + 16 * 40 + 40;//surface[OUTPUT_SURFACE].width /2;//50;
>	output_region[1].y = 50 ;//50;
>	output_region[1].width = 16 * 40;//surface[OUTPUT_SURFACE].width / 2;//16* 40; //surface[INPUT_SURFACE].width / 2;
>	output_region[1].height = 16 * 25;//surface[OUTPUT_SURFACE].height /2;//8 * 50; //surface[INPUT_SURFACE].height / 2;
>	output_region[2].x = 40;//50;
>	output_region[2].y = 50 + 16 *25 + 50;//surface[OUTPUT_SURFACE].height /2;//50;
>	output_region[2].width = 16 * 40;//surface[OUTPUT_SURFACE].width/2;//16* 40; //surface[INPUT_SURFACE].width / 2;
>	output_region[2].height = 16 * 25;//surface[OUTPUT_SURFACE].height/2;//8 * 50; //surface[INPUT_SURFACE].height / 2;
>	output_region[3].x = 40 + 16 * 40 + 40;//surface[OUTPUT_SURFACE].width/2;//50;
>	output_region[3].y = 50 + 16 * 25 + 50;//surface[OUTPUT_SURFACE].height/2;//50;
>	output_region[3].width = 16 * 40;//surface[OUTPUT_SURFACE].width/2;//16* 40; //surface[INPUT_SURFACE].width / 2;
>	output_region[3].height = 16 * 25;//surface[OUTPUT_SURFACE].height/2;//8 * 50; //surface[INPUT_SURFACE].height / 2;
>
>	//XSync (vpp_context.x11_dpy, False);
>
>	do {
>		//printf(" %d X %d\n", output_region.width, output_region.height);
>
>		/*
>		 * Run VPP pipeline
>		 */
>		if (vaapi_vpp_run (&vpp_context, &surface[INPUT_SURFACE_0], &surface[OUTPUT_SURFACE], &(output_region[0]), 0xff000000, 4)) {
>			printf ("\nvaapi_vpp_run failed!\n");
>			break;
>		}
>
>		/* Display result */
>		vaPutSurface (vpp_context.va_dpy, surface[OUTPUT_SURFACE].surface_id, win,
>				  0, 0, surface[OUTPUT_SURFACE].width, surface[OUTPUT_SURFACE].height,
>				  0, 0, surface[OUTPUT_SURFACE].width, surface[OUTPUT_SURFACE].height,
>				  NULL, 0, 0);
>/*
>#if 1
>		if (output_region.width < 1600)
>			output_region.width += 1; //16;
>		else
>			break;
>		if (output_region.height < 900)
>			output_region.height += 1; //8;
>		else
>			break;
>#endif
>*/
>
>		sleep(1);
>		//getchar();
>
>	} while(1);
>
>	printf("DONE!\n");
>
>	vpp_context_uninit (&vpp_context);
>	return 0;
>}
>

Actions: View

Attachments on bug 57398: 71256 | 71257

Use of freedesktop.org services, including Bugzilla, is subject to our Code of Conduct. How we collect and use information is described in our Privacy Policy.