#include #include #include #include #include #include #include #include #include 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; }