Attachment 76368 Details for Bug 62207 – This is the example application

This is the example application

main.c (text/plain), 24.68 KB, created by Clear on 2013-03-12 08:11:24 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Clear

Created: 2013-03-12 08:11:24 UTC

Size: 24.68 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 _dec_context {
>        Display *x11_dpy;
>        VADisplay va_dpy;
>        VAContextID va_context_id;
>        VAConfigID va_config_id;
>        int width;
>        int height;
>} DEC_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];
>
>
>//////////////////////////////////add for decoder
>static unsigned char mpeg2_clip[]={
>    0x00,0x00,0x01,0xb3,0x01,0x00,0x10,0x13,0xff,0xff,0xe0,0x18,0x00,0x00,0x01,0xb5,
>    0x14,0x8a,0x00,0x01,0x00,0x00,0x00,0x00,0x01,0xb8,0x00,0x08,0x00,0x00,0x00,0x00,
>    0x01,0x00,0x00,0x0f,0xff,0xf8,0x00,0x00,0x01,0xb5,0x8f,0xff,0xf3,0x41,0x80,0x00,
>    0x00,0x01,0x01,0x13,0xe1,0x00,0x15,0x81,0x54,0xe0,0x2a,0x05,0x43,0x00,0x2d,0x60,
>    0x18,0x01,0x4e,0x82,0xb9,0x58,0xb1,0x83,0x49,0xa4,0xa0,0x2e,0x05,0x80,0x4b,0x7a,
>    0x00,0x01,0x38,0x20,0x80,0xe8,0x05,0xff,0x60,0x18,0xe0,0x1d,0x80,0x98,0x01,0xf8,
>    0x06,0x00,0x54,0x02,0xc0,0x18,0x14,0x03,0xb2,0x92,0x80,0xc0,0x18,0x94,0x42,0x2c,
>    0xb2,0x11,0x64,0xa0,0x12,0x5e,0x78,0x03,0x3c,0x01,0x80,0x0e,0x80,0x18,0x80,0x6b,
>    0xca,0x4e,0x01,0x0f,0xe4,0x32,0xc9,0xbf,0x01,0x42,0x69,0x43,0x50,0x4b,0x01,0xc9,
>    0x45,0x80,0x50,0x01,0x38,0x65,0xe8,0x01,0x03,0xf3,0xc0,0x76,0x00,0xe0,0x03,0x20,
>    0x28,0x18,0x01,0xa9,0x34,0x04,0xc5,0xe0,0x0b,0x0b,0x04,0x20,0x06,0xc0,0x89,0xff,
>    0x60,0x12,0x12,0x8a,0x2c,0x34,0x11,0xff,0xf6,0xe2,0x40,0xc0,0x30,0x1b,0x7a,0x01,
>    0xa9,0x0d,0x00,0xac,0x64
>};
>
>static VAPictureParameterBufferMPEG2 pic_param={
>  horizontal_size:16,
>  vertical_size:16,
>  forward_reference_picture:0xffffffff,
>  backward_reference_picture:0xffffffff,
>  picture_coding_type:1,
>  f_code:0xffff,
>  {
>      {
>        intra_dc_precision:0,
>        picture_structure:3,
>        top_field_first:0,
>        frame_pred_frame_dct:1,
>        concealment_motion_vectors:0,
>        q_scale_type:0,
>        intra_vlc_format:0,
>        alternate_scan:0,
>        repeat_first_field:0,
>        progressive_frame:1 ,
>        is_first_field:1
>      },
>  }
>};
>
>static VAIQMatrixBufferMPEG2 iq_matrix = {
>  load_intra_quantiser_matrix:1,
>  load_non_intra_quantiser_matrix:1,
>  load_chroma_intra_quantiser_matrix:0,
>  load_chroma_non_intra_quantiser_matrix:0,
>  intra_quantiser_matrix:{
>         8, 16, 16, 19, 16, 19, 22, 22,
>        22, 22, 22, 22, 26, 24, 26, 27,
>        27, 27, 26, 26, 26, 26, 27, 27,
>        27, 29, 29, 29, 34, 34, 34, 29,
>        29, 29, 27, 27, 29, 29, 32, 32,
>        34, 34, 37, 38, 37, 35, 35, 34,
>        35, 38, 38, 40, 40, 40, 48, 48,
>        46, 46, 56, 56, 58, 69, 69, 83
>    },
>  non_intra_quantiser_matrix:{16},
>  chroma_intra_quantiser_matrix:{0},
>  chroma_non_intra_quantiser_matrix:{0}
>};
>
>#if 1
>static VASliceParameterBufferMPEG2 slice_param={
>  slice_data_size:150,
>  slice_data_offset:0,
>  slice_data_flag:0,
>  macroblock_offset:38, /* 4byte + 6bits=38bits */
>  slice_horizontal_position:0,
>  slice_vertical_position:0,
>  quantiser_scale_code:2,
>  intra_slice_flag:0
>};
>#endif
>
>#define CLIP_WIDTH  16
>#define CLIP_HEIGHT 16
>
>#define WIN_WIDTH  (CLIP_WIDTH<<1)
>#define WIN_HEIGHT (CLIP_HEIGHT<<1)
>
>
>
>
>/////////////////////////////////////////////////
>
>#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;
>}
>
>VABufferID pic_param_buf,iqmatrix_buf,slice_param_buf,slice_data_buf;
>int dec_context_init(DEC_Context* dec_context, VASurfaceID surface_id)
>{
>	VAEntrypoint entrypoints[5];
>    	int num_entrypoints,vld_entrypoint;
>    	VAConfigAttrib attrib;
>    	VAConfigID config_id;
>    	//VASurfaceID surface_id;
>    	VAContextID context_id;
>//    	VABufferID pic_param_buf,iqmatrix_buf,slice_param_buf,slice_data_buf;
>	VAStatus va_status;
>	
>	perror("==>dec_context_init");
>	va_status = vaQueryConfigEntrypoints(dec_context->va_dpy, VAProfileMPEG2Main, entrypoints,
>                             &num_entrypoints);
>        if(check_vaStatus(va_status, "vaQueryConfigEntrypoints"))
>        {
>                return -1;
>        }
>	printf("pass query entrypoints\n");
>
>        for (vld_entrypoint = 0; vld_entrypoint < num_entrypoints; vld_entrypoint++) {
>                if (entrypoints[vld_entrypoint] == VAEntrypointVLD)
>                        break;
>        }
>        if (vld_entrypoint == num_entrypoints) {
>                /* not find VLD entry point */
>                perror("Could not find mpeg2 decoder entry point");
>		return -1;
>	}
>
>	attrib.type = VAConfigAttribRTFormat;
>    	vaGetConfigAttributes(dec_context->va_dpy, VAProfileMPEG2Main, VAEntrypointVLD,
>                          &attrib, 1);
>    	if ((attrib.value & VA_RT_FORMAT_YUV420) == 0) {
>		perror("dec: YUV 420 is not supported in this format");
>                return -1;
>	}
>	
>	printf("pass get config attributes\n");
>	va_status = vaCreateConfig(dec_context->va_dpy, VAProfileMPEG2Main, VAEntrypointVLD,
>                              &attrib, 1,&dec_context->va_config_id);
>
>        if (check_vaStatus(va_status, "vaCreateConfig")) {
>                return -1;
>        }
>
>	printf("pass create config\n");
>
>
>    va_status = vaCreateContext(dec_context->va_dpy, dec_context->va_config_id,
>                               CLIP_WIDTH,
>                               ((CLIP_HEIGHT+15)/16)*16,
>                               VA_PROGRESSIVE,
>                               &surface_id,
>                               1,
>                               &dec_context->va_context_id);
>
>    if (check_vaStatus(va_status, "vaCreateContext")) {
>                return -1;
>    }
>
>	printf("pass create context\n");
>    va_status = vaCreateBuffer(dec_context->va_dpy, dec_context->va_context_id,
>                              VAPictureParameterBufferType,
>                              sizeof(VAPictureParameterBufferMPEG2),
>                              1, &pic_param,
>                              &pic_param_buf);
>
>    if (check_vaStatus(va_status, "vaCreateBuffer")) {
>                return -1;
>    }
>
>
>    va_status = vaCreateBuffer(dec_context->va_dpy, dec_context->va_context_id,
>                              VAIQMatrixBufferType,
>                              sizeof(VAIQMatrixBufferMPEG2),
>                              1, &iq_matrix,
>                              &iqmatrix_buf );
>    if (check_vaStatus(va_status, "vaCreateBuffer")) {
>                return -1;
>    }
>
>
>    va_status = vaCreateBuffer(dec_context->va_dpy, dec_context->va_context_id,
>                              VASliceParameterBufferType,
>                              sizeof(VASliceParameterBufferMPEG2),
>                              1,
>                              &slice_param, &slice_param_buf);
>    if (check_vaStatus(va_status, "vaCreateBuffer")) {
>                return -1;
>    }
>
>
>    va_status = vaCreateBuffer(dec_context->va_dpy, dec_context->va_context_id,
>                              VASliceDataBufferType,
>                              0xc4-0x2f+1,
>                              1,
>                              mpeg2_clip+0x2f,
>                              &slice_data_buf);
>    if (check_vaStatus(va_status, "vaCreateBuffer")) {
>                return -1;
>    }
>
>	printf("dec init done\n");
>
>	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, vld_entrypoint;
>	VAConfigAttrib attrib;
>
>	vpp_context->x11_dpy = NULL;
>	vpp_context->va_context_id = VA_INVALID_ID;
>	vpp_context->va_config_id = VA_INVALID_ID;
>
>	perror("==>vpp_context_init");
>	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],
>			1920,//surface->width,
>			1080,//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;
>
>	printf("input_surface width: %d, height: %d, id: 0x%x\n", input_surface->width, input_surface->height, input_surface->surface_id);
>
>	/* 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]);
>	printf("filled para\n");
>		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;
>	}
>	printf("pass render pic\n");
>
>	va_status = vaEndPicture(vpp_context->va_dpy, vpp_context->va_context_id);
>	if (check_vaStatus(va_status, "vaEndPicture")) {
>		return -1;
>	}
>	printf("pass endpic\n");
>	
>}
>  
>
>	
>//	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 = "1080.yuv";
>
>	short beginning = 0x10;
>	unsigned short length = 0x10; 
>	Window  win;
>
>	VPP_Context vpp_context;
>	DEC_Context dec_context;
>	VA_Surface surface[NUM_VA_SURFACES];   // Input and output surfaces
>	//VARectangle output_region;
>	VAStatus va_status;
>	short i;
>
>	surface[INPUT_SURFACE_0].height = 1080;
>	surface[INPUT_SURFACE_0].width = 1920;
>	surface[INPUT_SURFACE_1].height = 1080;
>	surface[INPUT_SURFACE_1].width = 1920;	
>	surface[INPUT_SURFACE_2].height = 1080;
>	surface[INPUT_SURFACE_2].width = 1920;
>	surface[INPUT_SURFACE_3].height = 1080;
>	surface[INPUT_SURFACE_3].width = 1920;
>	
>	/*
>	 * Read input image from file
>	 */
>/*****************remove for add decoder
>	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;
>
>//////////////////////add for decoder
>	dec_context.x11_dpy = vpp_context.x11_dpy;
>	dec_context.va_dpy = vpp_context.va_dpy;
>	dec_context.va_context_id = VA_INVALID_ID;
>	dec_context.va_config_id = VA_INVALID_ID;
>
>	surface[INPUT_SURFACE_0].height = CLIP_HEIGHT;
>        surface[INPUT_SURFACE_0].width = CLIP_WIDTH;
>
>
>//
>	/* Create input and output surfaces */
>	for (i = 0; i < NUM_VA_SURFACES; i++) {
>	//for(i=0;i<1;i++)
>	//{
>		va_status = vaCreateSurfaces(vpp_context.va_dpy,
>									 VA_RT_FORMAT_YUV420,
>									 surface[i].width,
>									 surface[i].height,
>									 &surface[i].surface_id,
>									 1, NULL, 0);
>		if (check_vaStatus(va_status, "vaCreateSurfaces")) {
>			return 1;
>		}
>		printf("index:%d, surface_id:0x%x", i, surface[i].surface_id);
>	}
>	if(dec_context_init(&dec_context, surface[INPUT_SURFACE_0].surface_id))
>        {
>                exit(1);
>        }
>
>
>///////////////////////add for decoder
>
>	va_status = vaBeginPicture(dec_context.va_dpy, dec_context.va_context_id, surface[INPUT_SURFACE_0].surface_id);
>	if (check_vaStatus(va_status, "vaBeginPicture")) {
>        	return 1;
>	}
>
>    	va_status = vaRenderPicture(dec_context.va_dpy,dec_context.va_context_id, &pic_param_buf, 1);
>	if (check_vaStatus(va_status, "vaRenderPicture")) {
>                return 1;
>        }
>
>
>	va_status = vaRenderPicture(dec_context.va_dpy,dec_context.va_context_id, &iqmatrix_buf, 1);
>	if (check_vaStatus(va_status, "vaRenderPicture")) {
>                return 1;
>        }
>
>
>        va_status = vaRenderPicture(dec_context.va_dpy,dec_context.va_context_id, &slice_param_buf, 1);
>	if (check_vaStatus(va_status, "vaRenderPicture")) {
>                return 1;
>        }
>
>
>        va_status = vaRenderPicture(dec_context.va_dpy,dec_context.va_context_id, &slice_data_buf, 1);
>	if (check_vaStatus(va_status, "vaRenderPicture")) {
>                return 1;
>        }
>
>
>        va_status = vaEndPicture(dec_context.va_dpy,dec_context.va_context_id);
>	if (check_vaStatus(va_status, "vaEndPicture")) {
>                return 1;
>        }
>
>
> 	va_status = vaSyncSurface(dec_context.va_dpy, surface[INPUT_SURFACE_0].surface_id);
>	if (check_vaStatus(va_status, "vaSyncSurface")) {
>                return 1;
>        }
>
>	printf("finish decoding\n");
>
>///////////////////////////
>
>	/* 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));
>	/*win = XCreateSimpleWindow (vpp_context.x11_dpy,
>                                                                                   RootWindow(vpp_context.x11_dpy, 0),
>                                                                                   0, 0, 16, 16,
>                                                                                   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);
>*///remove for add decoder
>
>	output_region[0].x = 0+beginning;//50;
>	output_region[0].y = 0+beginning;//50;
>	output_region[0].width =  1920/2-length;//surface[OUTPUT_SURFACE].width /2;//16* 40; //surface[INPUT_SURFACE].width / 2;
>	output_region[0].height = 1080/2-length;//surface[OUTPUT_SURFACE].height /2;//8 * 50; //surface[INPUT_SURFACE].height / 2;
>	output_region[1].x = 1920/2 +beginning;//surface[OUTPUT_SURFACE].width /2;//50;
>	output_region[1].y = 0+beginning ;//50;
>	output_region[1].width = 1920/2-length;//surface[OUTPUT_SURFACE].width / 2;//16* 40; //surface[INPUT_SURFACE].width / 2;
>	output_region[1].height = 1080/2-length;//surface[OUTPUT_SURFACE].height /2;//8 * 50; //surface[INPUT_SURFACE].height / 2;
>	output_region[2].x = 1920/2 +beginning;//50;
>	output_region[2].y = 1080/2 +beginning;//surface[OUTPUT_SURFACE].height /2;//50;
>	output_region[2].width = 1920/2-length;//surface[OUTPUT_SURFACE].width/2;//16* 40; //surface[INPUT_SURFACE].width / 2;
>	output_region[2].height = 1080/2-length;//surface[OUTPUT_SURFACE].height/2;//8 * 50; //surface[INPUT_SURFACE].height / 2;
>	output_region[3].x = 0 +beginning;//surface[OUTPUT_SURFACE].width/2;//50;
>	output_region[3].y = 1080/2 +beginning;//surface[OUTPUT_SURFACE].height/2;//50;
>	output_region[3].width = 1920/2-length;//surface[OUTPUT_SURFACE].width/2;//16* 40; //surface[INPUT_SURFACE].width / 2;
>	output_region[3].height = 1080/2-length;//surface[OUTPUT_SURFACE].height/2;//8 * 50; //surface[INPUT_SURFACE].height / 2;
>
>	//XSync (vpp_context.x11_dpy, False);
>
>	//output_region[0].width =  16;//surface[OUTPUT_SURFACE].width /2;//16* 40; //surface[INPUT_SURFACE].width / 2;
>        //output_region[0].height = 16;//surface[OUTPUT_SURFACE].height /2;//8 * 50; //surface[INPUT_SURFACE].height / 2;
>
>	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, 1)) {
>			printf ("\nvaapi_vpp_run failed!\n");
>			break;
>		}
>
>		/*vaPutSurface (vpp_context.va_dpy, surface[1].surface_id, win,
>                                  0, 0, surface[1].width, surface[1].height,
>                                  0, 0, surface[1].width, surface[1].height,
>                                  NULL, 0, 0);*/
>
>		/* 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");
>
>//	vaDestroySurfaces(dec_context.va_dpy, );
>	vaDestroyContext(dec_context.va_dpy, dec_context.va_context_id);
>	vaDestroyConfig(dec_context.va_dpy, dec_context.va_config_id);
>	vpp_context_uninit (&vpp_context);
>	return 0;
>}
>

Actions: View

Attachments on bug 62207: 76368

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.