| /* |
| * Copyright (c) 2007-2008 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. |
| */ |
| |
| /* |
| * it is a real program to show how VAAPI decode work, |
| * It does VLD decode for a simple MPEG2 clip "mpeg2-I.m2v" |
| * "mpeg2-I.m2v" and VA parameters are hardcoded into mpeg2vldemo.c, |
| * See mpeg2-I.jif to know how those VA parameters come from |
| * |
| * gcc -o mpeg2vldemo mpeg2vldemo.c -lva -lva-x11 -I/usr/include/va |
| * ./mpeg2vldemo : only do decode |
| * ./mpeg2vldemo <any parameter >: decode+display |
| * |
| */ |
| #include <stdio.h> |
| #include <string.h> |
| #include <stdlib.h> |
| #include <getopt.h> |
| #include <unistd.h> |
| #include <sys/types.h> |
| #include <sys/stat.h> |
| #include <fcntl.h> |
| #include <assert.h> |
| #include <va/va.h> |
| #include "va_display.h" |
| |
| #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); \ |
| } |
| |
| /* Data dump of a 16x16 MPEG2 video clip,it has one I frame |
| */ |
| 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 |
| }; |
| |
| /* hardcoded here without a bitstream parser helper |
| * please see picture mpeg2-I.jpg for bitstream details |
| */ |
| 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 |
| }, |
| } |
| }; |
| |
| /* see MPEG2 spec65 for the defines of matrix */ |
| 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) |
| |
| int main(int argc,char **argv) |
| { |
| 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; |
| int major_ver, minor_ver; |
| VADisplay va_dpy; |
| VAStatus va_status; |
| int putsurface=0; |
| |
| va_init_display_args(&argc, argv); |
| |
| if (argc > 1) |
| putsurface=1; |
| |
| va_dpy = va_open_display(); |
| va_status = vaInitialize(va_dpy, &major_ver, &minor_ver); |
| assert(va_status == VA_STATUS_SUCCESS); |
| |
| va_status = vaQueryConfigEntrypoints(va_dpy, VAProfileMPEG2Main, entrypoints, |
| &num_entrypoints); |
| CHECK_VASTATUS(va_status, "vaQueryConfigEntrypoints"); |
| |
| 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 */ |
| assert(0); |
| } |
| |
| /* Assuming finding VLD, find out the format for the render target */ |
| attrib.type = VAConfigAttribRTFormat; |
| vaGetConfigAttributes(va_dpy, VAProfileMPEG2Main, VAEntrypointVLD, |
| &attrib, 1); |
| if ((attrib.value & VA_RT_FORMAT_YUV420) == 0) { |
| /* not find desired YUV420 RT format */ |
| assert(0); |
| } |
| |
| va_status = vaCreateConfig(va_dpy, VAProfileMPEG2Main, VAEntrypointVLD, |
| &attrib, 1,&config_id); |
| CHECK_VASTATUS(va_status, "vaQueryConfigEntrypoints"); |
| |
| va_status = vaCreateSurfaces( |
| va_dpy, |
| VA_RT_FORMAT_YUV420, CLIP_WIDTH, CLIP_HEIGHT, |
| &surface_id, 1, |
| NULL, 0 |
| ); |
| CHECK_VASTATUS(va_status, "vaCreateSurfaces"); |
| |
| /* Create a context for this decode pipe */ |
| va_status = vaCreateContext(va_dpy, config_id, |
| CLIP_WIDTH, |
| ((CLIP_HEIGHT+15)/16)*16, |
| VA_PROGRESSIVE, |
| &surface_id, |
| 1, |
| &context_id); |
| CHECK_VASTATUS(va_status, "vaCreateContext"); |
| |
| va_status = vaCreateBuffer(va_dpy, context_id, |
| VAPictureParameterBufferType, |
| sizeof(VAPictureParameterBufferMPEG2), |
| 1, &pic_param, |
| &pic_param_buf); |
| CHECK_VASTATUS(va_status, "vaCreateBuffer"); |
| |
| va_status = vaCreateBuffer(va_dpy, context_id, |
| VAIQMatrixBufferType, |
| sizeof(VAIQMatrixBufferMPEG2), |
| 1, &iq_matrix, |
| &iqmatrix_buf ); |
| CHECK_VASTATUS(va_status, "vaCreateBuffer"); |
| |
| va_status = vaCreateBuffer(va_dpy, context_id, |
| VASliceParameterBufferType, |
| sizeof(VASliceParameterBufferMPEG2), |
| 1, |
| &slice_param, &slice_param_buf); |
| CHECK_VASTATUS(va_status, "vaCreateBuffer"); |
| |
| va_status = vaCreateBuffer(va_dpy, context_id, |
| VASliceDataBufferType, |
| 0xc4-0x2f+1, |
| 1, |
| mpeg2_clip+0x2f, |
| &slice_data_buf); |
| CHECK_VASTATUS(va_status, "vaCreateBuffer"); |
| |
| va_status = vaBeginPicture(va_dpy, context_id, surface_id); |
| CHECK_VASTATUS(va_status, "vaBeginPicture"); |
| |
| va_status = vaRenderPicture(va_dpy,context_id, &pic_param_buf, 1); |
| CHECK_VASTATUS(va_status, "vaRenderPicture"); |
| |
| va_status = vaRenderPicture(va_dpy,context_id, &iqmatrix_buf, 1); |
| CHECK_VASTATUS(va_status, "vaRenderPicture"); |
| |
| va_status = vaRenderPicture(va_dpy,context_id, &slice_param_buf, 1); |
| CHECK_VASTATUS(va_status, "vaRenderPicture"); |
| |
| va_status = vaRenderPicture(va_dpy,context_id, &slice_data_buf, 1); |
| CHECK_VASTATUS(va_status, "vaRenderPicture"); |
| |
| va_status = vaEndPicture(va_dpy,context_id); |
| CHECK_VASTATUS(va_status, "vaEndPicture"); |
| |
| va_status = vaSyncSurface(va_dpy, surface_id); |
| CHECK_VASTATUS(va_status, "vaSyncSurface"); |
| |
| if (putsurface) { |
| VARectangle src_rect, dst_rect; |
| |
| src_rect.x = 0; |
| src_rect.y = 0; |
| src_rect.width = CLIP_WIDTH; |
| src_rect.height = CLIP_HEIGHT; |
| |
| dst_rect.x = 0; |
| dst_rect.y = 0; |
| dst_rect.width = WIN_WIDTH; |
| dst_rect.height = WIN_HEIGHT; |
| |
| va_status = va_put_surface(va_dpy, surface_id, &src_rect, &dst_rect); |
| CHECK_VASTATUS(va_status, "vaPutSurface"); |
| } |
| printf("press any key to exit\n"); |
| getchar(); |
| |
| vaDestroySurfaces(va_dpy,&surface_id,1); |
| vaDestroyConfig(va_dpy,config_id); |
| vaDestroyContext(va_dpy,context_id); |
| |
| vaTerminate(va_dpy); |
| va_close_display(va_dpy); |
| return 0; |
| } |
