| 0,0 → 1,688 |
|---|
| /* |
| * Copyright (c) 2008-2009 Intel Corporation. All Rights Reserved. |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a |
| * copy of this software and associated documentation files (the |
| * "Software"), to deal in the Software without restriction, including |
| * without limitation the rights to use, copy, modify, merge, publish, |
| * distribute, sub license, and/or sell copies of the Software, and to |
| * permit persons to whom the Software is furnished to do so, subject to |
| * the following conditions: |
| * |
| * The above copyright notice and this permission notice (including the |
| * next paragraph) shall be included in all copies or substantial portions |
| * of the Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS |
| * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
| * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. |
| * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR |
| * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, |
| * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE |
| * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
| */ |
| |
| #include <stdio.h> |
| #include <string.h> |
| #include <stdlib.h> |
| #include <stdint.h> |
| #include <getopt.h> |
| |
| #include <sys/time.h> |
| |
| #include <unistd.h> |
| |
| #include <sys/types.h> |
| #include <sys/stat.h> |
| #include <fcntl.h> |
| #include <assert.h> |
| #include <pthread.h> |
| |
| /*currently, if XCheckWindowEvent was called in more than one thread, it would cause |
| * XIO: fatal IO error 11 (Resource temporarily unavailable) on X server ":0.0" |
| * after 87 requests (83 known processed) with 0 events remaining. |
| * |
| * X Error of failed request: BadGC (invalid GC parameter) |
| * Major opcode of failed request: 60 (X_FreeGC) |
| * Resource id in failed request: 0x600034 |
| * Serial number of failed request: 398 |
| * Current serial number in output stream: 399 |
| * The root cause is unknown. */ |
| |
| #define CHECK_VASTATUS(va_status,func) \ |
| if (va_status != VA_STATUS_SUCCESS) { \ |
| fprintf(stderr,"%s:%s (%d) failed,exit\n", __func__, func, __LINE__); \ |
| exit(1); \ |
| } |
| #include "../loadsurface.h" |
| |
| #define SURFACE_NUM 16 |
| |
| static void *win_display; |
| static VADisplay va_dpy; |
| static VAImageFormat *va_image_formats; |
| static int va_num_image_formats = -1; |
| static VAConfigID vpp_config_id = VA_INVALID_ID; |
| static VASurfaceAttrib *va_surface_attribs; |
| static int va_num_surface_attribs = -1; |
| static VASurfaceID surface_id[SURFACE_NUM]; |
| static pthread_mutex_t surface_mutex[SURFACE_NUM]; |
| |
| static void *drawable_thread0, *drawable_thread1; |
| static int surface_width = 352, surface_height = 288; |
| static int win_x = 0, win_y = 0; |
| static int win_width = 352, win_height = 288; |
| static int frame_rate = 0; |
| static unsigned long long frame_num_total = ~0; |
| static int check_event = 1; |
| static int put_pixmap = 0; |
| static int test_clip = 0; |
| static int display_field = VA_FRAME_PICTURE; |
| static pthread_mutex_t gmutex; |
| static int box_width = 32; |
| static int multi_thread = 0; |
| static int verbose = 0; |
| static int test_color_conversion = 0; |
| static int csc_src_fourcc = 0, csc_dst_fourcc = 0; |
| static VAImage csc_dst_fourcc_image; |
| static VASurfaceID csc_render_surface; |
| |
| |
| typedef struct { |
| char* fmt_str; |
| unsigned int fourcc; |
| } fourcc_map; |
| fourcc_map va_fourcc_map[] = { |
| {"YUYV", VA_FOURCC_YUY2}, |
| {"YUY2", VA_FOURCC_YUY2}, |
| {"NV12", VA_FOURCC_NV12}, |
| {"YV12", VA_FOURCC_YV12}, |
| {"BGRA", VA_FOURCC_BGRA}, |
| {"RGBA", VA_FOURCC_RGBA}, |
| {"BGRX", VA_FOURCC_BGRX}, |
| {"RGBX", VA_FOURCC_RGBX}, |
| }; |
| unsigned int map_str_to_vafourcc (char * str) |
| { |
| int i; |
| for (i=0; i< sizeof(va_fourcc_map)/sizeof(fourcc_map); i++) { |
| if (!strcmp(va_fourcc_map[i].fmt_str, str)) { |
| return va_fourcc_map[i].fourcc; |
| } |
| } |
| |
| return 0; |
| |
| } |
| char* map_vafourcc_to_str (unsigned int format) |
| { |
| static char unknown_format[] = "unknown-format"; |
| int i; |
| for (i=0; i< sizeof(va_fourcc_map)/sizeof(fourcc_map); i++) { |
| if (va_fourcc_map[i].fourcc == format) { |
| return va_fourcc_map[i].fmt_str; |
| } |
| } |
| |
| return unknown_format; |
| |
| } |
| |
| static int |
| va_value_equals(const VAGenericValue *v1, const VAGenericValue *v2) |
| { |
| if (v1->type != v2->type) |
| return 0; |
| |
| switch (v1->type) { |
| case VAGenericValueTypeInteger: |
| return v1->value.i == v2->value.i; |
| case VAGenericValueTypeFloat: |
| return v1->value.f == v2->value.f; |
| case VAGenericValueTypePointer: |
| return v1->value.p == v2->value.p; |
| case VAGenericValueTypeFunc: |
| return v1->value.fn == v2->value.fn; |
| } |
| return 0; |
| } |
| |
| static int |
| ensure_image_formats(void) |
| { |
| VAStatus va_status; |
| VAImageFormat *image_formats; |
| int num_image_formats; |
| |
| if (va_num_image_formats >= 0) |
| return va_num_image_formats; |
| |
| num_image_formats = vaMaxNumImageFormats(va_dpy); |
| if (num_image_formats == 0) |
| return 0; |
| |
| image_formats = malloc(num_image_formats * sizeof(*image_formats)); |
| if (!image_formats) |
| return 0; |
| |
| va_status = vaQueryImageFormats(va_dpy, image_formats, &num_image_formats); |
| CHECK_VASTATUS(va_status, "vaQuerySurfaceAttributes()"); |
| |
| va_image_formats = image_formats; |
| va_num_image_formats = num_image_formats; |
| return num_image_formats; |
| } |
| |
| static const VAImageFormat * |
| lookup_image_format(uint32_t fourcc) |
| { |
| int i; |
| |
| if (!ensure_image_formats()) |
| return NULL; |
| |
| for (i = 0; i < va_num_image_formats; i++) { |
| const VAImageFormat * const image_format = &va_image_formats[i]; |
| if (image_format->fourcc == fourcc) |
| return image_format; |
| } |
| return NULL; |
| } |
| |
| static int |
| ensure_surface_attribs(void) |
| { |
| VAStatus va_status; |
| VASurfaceAttrib *surface_attribs; |
| unsigned int num_image_formats, num_surface_attribs; |
| |
| if (va_num_surface_attribs >= 0) |
| return va_num_surface_attribs; |
| |
| num_image_formats = vaMaxNumImageFormats(va_dpy); |
| if (num_image_formats == 0) |
| return 0; |
| |
| va_status = vaCreateConfig(va_dpy, VAProfileNone, VAEntrypointVideoProc, |
| NULL, 0, &vpp_config_id); |
| CHECK_VASTATUS(va_status, "vaCreateConfig()"); |
| |
| /* Guess the number of surface attributes, thus including any |
| pixel-format supported by the VA driver */ |
| num_surface_attribs = VASurfaceAttribCount + num_image_formats; |
| surface_attribs = malloc(num_surface_attribs * sizeof(*surface_attribs)); |
| if (!surface_attribs) |
| return 0; |
| |
| va_status = vaQuerySurfaceAttributes(va_dpy, vpp_config_id, |
| surface_attribs, &num_surface_attribs); |
| if (va_status == VA_STATUS_SUCCESS) |
| va_surface_attribs = surface_attribs; |
| else if (va_status == VA_STATUS_ERROR_MAX_NUM_EXCEEDED) { |
| va_surface_attribs = realloc(surface_attribs, |
| num_surface_attribs * sizeof(*va_surface_attribs)); |
| if (!va_surface_attribs) { |
| free(surface_attribs); |
| return 0; |
| } |
| va_status = vaQuerySurfaceAttributes(va_dpy, vpp_config_id, |
| va_surface_attribs, &num_surface_attribs); |
| } |
| CHECK_VASTATUS(va_status, "vaQuerySurfaceAttributes()"); |
| va_num_surface_attribs = num_surface_attribs; |
| return num_surface_attribs; |
| } |
| |
| static const VASurfaceAttrib * |
| lookup_surface_attrib(VASurfaceAttribType type, const VAGenericValue *value) |
| { |
| int i; |
| |
| if (!ensure_surface_attribs()) |
| return NULL; |
| |
| for (i = 0; i < va_num_surface_attribs; i++) { |
| const VASurfaceAttrib * const surface_attrib = &va_surface_attribs[i]; |
| if (surface_attrib->type != type) |
| continue; |
| if (!(surface_attrib->flags & VA_SURFACE_ATTRIB_SETTABLE)) |
| continue; |
| if (va_value_equals(&surface_attrib->value, value)) |
| return surface_attrib; |
| } |
| return NULL; |
| } |
| |
| int csc_preparation () |
| { |
| VAStatus va_status; |
| |
| // 1. make sure dst fourcc is supported for vaImage |
| if (!lookup_image_format(csc_dst_fourcc)) { |
| test_color_conversion = 0; |
| printf("VA driver doesn't support %s image, skip additional color conversion\n", map_vafourcc_to_str(csc_dst_fourcc)); |
| goto cleanup; |
| } |
| |
| // 2. make sure src_fourcc is supported for vaSurface |
| VASurfaceAttrib surface_attribs[1], * const s_attrib = &surface_attribs[0]; |
| s_attrib->type = VASurfaceAttribPixelFormat; |
| s_attrib->flags = VA_SURFACE_ATTRIB_SETTABLE; |
| s_attrib->value.type = VAGenericValueTypeInteger; |
| s_attrib->value.value.i = csc_src_fourcc; |
| |
| if (!lookup_surface_attrib(VASurfaceAttribPixelFormat, &s_attrib->value)) { |
| printf("VA driver doesn't support %s surface, skip additional color conversion\n", map_vafourcc_to_str(csc_src_fourcc)); |
| test_color_conversion = 0; |
| goto cleanup; |
| } |
| |
| // 3 create all objs required by csc |
| // 3.1 vaSurface with src fourcc |
| va_status = vaCreateSurfaces( |
| va_dpy, |
| VA_RT_FORMAT_YUV420, surface_width, surface_height, |
| &surface_id[0], SURFACE_NUM, |
| surface_attribs, 1 |
| ); |
| CHECK_VASTATUS(va_status,"vaCreateSurfaces"); |
| |
| // 3.2 vaImage with dst fourcc |
| VAImageFormat image_format; |
| image_format.fourcc = csc_dst_fourcc; |
| image_format.byte_order = VA_LSB_FIRST; |
| image_format.bits_per_pixel = 16; |
| |
| va_status = vaCreateImage(va_dpy, &image_format, |
| surface_width, surface_height, |
| &csc_dst_fourcc_image); |
| CHECK_VASTATUS(va_status,"vaCreateImage"); |
| |
| |
| // 3.3 create a temp VASurface for final rendering(vaPutSurface) |
| s_attrib->value.value.i = VA_FOURCC_NV12; |
| va_status = vaCreateSurfaces(va_dpy, VA_RT_FORMAT_YUV420, |
| surface_width, surface_height, |
| &csc_render_surface, 1, |
| surface_attribs, 1); |
| CHECK_VASTATUS(va_status,"vaCreateSurfaces"); |
| |
| |
| cleanup: |
| return test_color_conversion; |
| } |
| |
| static VASurfaceID get_next_free_surface(int *index) |
| { |
| VASurfaceStatus surface_status; |
| int i; |
| |
| assert(index); |
| |
| if (multi_thread == 0) { |
| i = *index; |
| i++; |
| if (i == SURFACE_NUM) |
| i = 0; |
| *index = i; |
| |
| return surface_id[i]; |
| } |
| |
| for (i=0; i<SURFACE_NUM; i++) { |
| surface_status = (VASurfaceStatus)0; |
| vaQuerySurfaceStatus(va_dpy, surface_id[i], &surface_status); |
| if (surface_status == VASurfaceReady) |
| { |
| if (0 == pthread_mutex_trylock(&surface_mutex[i])) |
| { |
| *index = i; |
| break; |
| } |
| } |
| } |
| |
| if (i==SURFACE_NUM) |
| return VA_INVALID_SURFACE; |
| else |
| return surface_id[i]; |
| } |
| |
| static int upload_source_YUV_once_for_all() |
| { |
| VAImage surface_image; |
| void *surface_p=NULL, *U_start,*V_start; |
| VAStatus va_status; |
| int box_width_loc=8; |
| int row_shift_loc=0; |
| int i; |
| |
| for (i=0; i<SURFACE_NUM; i++) { |
| printf("\rLoading data into surface %d.....", i); |
| upload_surface(va_dpy, surface_id[i], box_width_loc, row_shift_loc, 0); |
| |
| row_shift_loc++; |
| if (row_shift_loc==(2*box_width_loc)) row_shift_loc= 0; |
| } |
| printf("\n"); |
| |
| return 0; |
| } |
| |
| /* |
| * Helper function for profiling purposes |
| */ |
| static unsigned long get_tick_count(void) |
| { |
| struct timeval tv; |
| if (gettimeofday(&tv, NULL)) |
| return 0; |
| return tv.tv_usec/1000+tv.tv_sec*1000; |
| } |
| |
| static void update_clipbox(VARectangle *cliprects, int width, int height) |
| { |
| if (test_clip == 0) |
| return; |
| |
| srand((unsigned)time(NULL)); |
| |
| cliprects[0].x = (rand() % width); |
| cliprects[0].y = (rand() % height); |
| cliprects[0].width = (rand() % (width - cliprects[0].x)); |
| cliprects[0].height = (rand() % (height - cliprects[0].y)); |
| |
| cliprects[1].x = (rand() % width); |
| cliprects[1].y = (rand() % height); |
| cliprects[1].width = (rand() % (width - cliprects[1].x)); |
| cliprects[1].height = (rand() % (height - cliprects[1].y)); |
| printf("\nTest clip (%d,%d, %d x %d) and (%d,%d, %d x %d) \n", |
| cliprects[0].x, cliprects[0].y, cliprects[0].width, cliprects[0].height, |
| cliprects[1].x, cliprects[1].y, cliprects[1].width, cliprects[1].height); |
| } |
| |
| static void* putsurface_thread(void *data) |
| { |
| int width=win_width, height=win_height; |
| void *drawable = data; |
| int quit = 0; |
| VAStatus vaStatus; |
| int row_shift = 0; |
| int index = 0; |
| unsigned int frame_num=0, start_time, putsurface_time; |
| VARectangle cliprects[2]; /* client supplied clip list */ |
| int continue_display = 0; |
| |
| if (drawable == drawable_thread0) |
| printf("Enter into thread0\n\n"); |
| if (drawable == drawable_thread1) |
| printf("Enter into thread1\n\n"); |
| |
| putsurface_time = 0; |
| while (!quit) { |
| VASurfaceID surface_id = VA_INVALID_SURFACE; |
| |
| while (surface_id == VA_INVALID_SURFACE) |
| surface_id = get_next_free_surface(&index); |
| |
| if (verbose) printf("Thread: %p Display surface 0x%x,\n", drawable, surface_id); |
| |
| if (multi_thread) |
| upload_surface(va_dpy, surface_id, box_width, row_shift, display_field); |
| |
| if (check_event) |
| pthread_mutex_lock(&gmutex); |
| |
| start_time = get_tick_count(); |
| if ((continue_display == 0) && getenv("FRAME_STOP")) { |
| char c; |
| printf("Press any key to display frame %d...(c/C to continue)\n", frame_num); |
| c = getchar(); |
| if (c == 'c' || c == 'C') |
| continue_display = 1; |
| } |
| if (test_color_conversion) { |
| static int _put_surface_count = 0; |
| if (_put_surface_count++ %50 == 0) { |
| printf("do additional colorcoversion from %s to %s\n", map_vafourcc_to_str(csc_src_fourcc), map_vafourcc_to_str(csc_dst_fourcc)); |
| } |
| // get image from surface, csc_src_fourcc to csc_dst_fourcc conversion happens |
| vaStatus = vaGetImage(va_dpy, surface_id, 0, 0, |
| surface_width, surface_height, csc_dst_fourcc_image.image_id); |
| CHECK_VASTATUS(vaStatus,"vaGetImage"); |
| |
| // render csc_dst_fourcc image to temp surface |
| vaStatus = vaPutImage(va_dpy, csc_render_surface, csc_dst_fourcc_image.image_id, |
| 0, 0, surface_width, surface_height, |
| 0, 0, surface_width, surface_height); |
| CHECK_VASTATUS(vaStatus,"vaPutImage"); |
| |
| // render the temp surface, it should be same with original surface without color conversion test |
| vaStatus = vaPutSurface(va_dpy, csc_render_surface, CAST_DRAWABLE(drawable), |
| 0,0,surface_width,surface_height, |
| 0,0,width,height, |
| (test_clip==0)?NULL:&cliprects[0], |
| (test_clip==0)?0:2, |
| display_field); |
| CHECK_VASTATUS(vaStatus,"vaPutSurface"); |
| |
| } |
| else { |
| vaStatus = vaPutSurface(va_dpy, surface_id, CAST_DRAWABLE(drawable), |
| 0,0,surface_width,surface_height, |
| 0,0,width,height, |
| (test_clip==0)?NULL:&cliprects[0], |
| (test_clip==0)?0:2, |
| display_field); |
| CHECK_VASTATUS(vaStatus,"vaPutSurface"); |
| } |
| |
| putsurface_time += (get_tick_count() - start_time); |
| |
| if (check_event) |
| pthread_mutex_unlock(&gmutex); |
| |
| pthread_mutex_unlock(&surface_mutex[index]); /* locked in get_next_free_surface */ |
| |
| if ((frame_num % 0xff) == 0) { |
| fprintf(stderr, "%.2f FPS \r", 256000.0 / (float)putsurface_time); |
| putsurface_time = 0; |
| update_clipbox(cliprects, width, height); |
| } |
| |
| if (check_event) |
| check_window_event(win_display, drawable, &width, &height, &quit); |
| |
| if (multi_thread) { /* reload surface content */ |
| row_shift++; |
| if (row_shift==(2*box_width)) row_shift= 0; |
| } |
| |
| if (frame_rate != 0) /* rough framerate control */ |
| usleep(1000/frame_rate*1000); |
| |
| frame_num++; |
| if (frame_num >= frame_num_total) |
| quit = 1; |
| } |
| |
| if (drawable == drawable_thread1) |
| pthread_exit(NULL); |
| |
| return 0; |
| } |
| 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; |
| } |