Script 'mail_helper' called by obssrc Hello community, here is the log from the commit of package libva-utils for openSUSE:Factory checked in at 2023-07-24 18:26:12 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/libva-utils (Old) and /work/SRC/openSUSE:Factory/.libva-utils.new.1467 (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "libva-utils" Mon Jul 24 18:26:12 2023 rev:24 rq:1099955 version:2.19.0 Changes: -------- --- /work/SRC/openSUSE:Factory/libva-utils/libva-utils.changes 2023-05-30 22:02:59.955207204 +0200 +++ /work/SRC/openSUSE:Factory/.libva-utils.new.1467/libva-utils.changes 2023-07-24 18:26:39.594394534 +0200 @@ -1,0 +2,12 @@ +Fri Jul 21 15:35:19 UTC 2023 - Dirk Müller <[email protected]> + +- update to 2.19.0: + * add: Add support for VAConfigAttribEncHEVCBlockSizes & + VAConfigAttribEncHEVCFeatures for hevcencode. + * meson: guard code introduced after libva 1.xx release + * meson: libva-xyz should be same version as detected libva + * configure: libva-xyz should be same version as detected libva + * fix: scan num limitation. + * fix: pic_order_cnt_lsb to accept larger GOP + +------------------------------------------------------------------- Old: ---- libva-utils-2.18.2.tar.gz New: ---- libva-utils-2.19.0.tar.gz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ libva-utils.spec ++++++ --- /var/tmp/diff_new_pack.KMTyt0/_old 2023-07-24 18:26:40.298398669 +0200 +++ /var/tmp/diff_new_pack.KMTyt0/_new 2023-07-24 18:26:40.302398693 +0200 @@ -17,7 +17,7 @@ Name: libva-utils -Version: 2.18.2 +Version: 2.19.0 Release: 0 Summary: A collection of utilities and examples to exercise VA-API License: EPL-1.0 AND MIT ++++++ libva-utils-2.18.2.tar.gz -> libva-utils-2.19.0.tar.gz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libva-utils-2.18.2/.github/workflows/ubuntu.yml new/libva-utils-2.19.0/.github/workflows/ubuntu.yml --- old/libva-utils-2.18.2/.github/workflows/ubuntu.yml 2023-04-17 07:37:14.000000000 +0200 +++ new/libva-utils-2.19.0/.github/workflows/ubuntu.yml 2023-07-04 10:25:59.000000000 +0200 @@ -47,40 +47,3 @@ make -j$(nproc) make check sudo make install - - ubuntu-18-04: - runs-on: ubuntu-18.04 - steps: - - name: checkout libva - uses: actions/checkout@v3 - with: - repository: intel/libva - path: libva - - name: checkout libva-utils - uses: actions/checkout@v3 - with: - path: libva-utils - - name: install prerequisites - run: | - sudo apt-get update - sudo apt-get install -y --no-install-recommends \ - libdrm-dev \ - libegl1-mesa-dev \ - libgl1-mesa-dev \ - libx11-dev \ - libxext-dev \ - libxfixes-dev \ - libwayland-dev - - name: build libva - run: | - cd libva - ./autogen.sh --prefix=/usr --libdir=/usr/lib/x86_64-linux-gnu - make -j$(nproc) - sudo make install - - name: build libva-utils - run: | - cd libva-utils - ./autogen.sh --prefix=/usr --libdir=/usr/lib/x86_64-linux-gnu - make -j$(nproc) - make check - sudo make install diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libva-utils-2.18.2/NEWS new/libva-utils-2.19.0/NEWS --- old/libva-utils-2.18.2/NEWS 2023-04-17 07:37:14.000000000 +0200 +++ new/libva-utils-2.19.0/NEWS 2023-07-04 10:25:59.000000000 +0200 @@ -1,6 +1,15 @@ -libva-utils NEWS -- summary of changes. 2023-03-17 +libva-utils NEWS -- summary of changes. 2023-07-04 Copyright (C) 2009-2023 Intel Corporation +Version 2.19.0 - 04.Jul.2023 +* add: Add support for VAConfigAttribEncHEVCBlockSizes & VAConfigAttribEncHEVCFeatures for hevcencode. +* ci:Update ubuntu.yml to remove ubuntu 18.04 +* meson: guard code introduced after libva 1.xx release +* meson: libva-xyz should be same version as detected libva +* configure: libva-xyz should be same version as detected libva +* fix: scan num limitation. +* fix: pic_order_cnt_lsb to accept larger GOP + Version 2.18.0 - 17.Mar.2023 * doc:Add build and install libva-utils steps * test: Add VAProfileH264High10 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libva-utils-2.18.2/configure.ac new/libva-utils-2.19.0/configure.ac --- old/libva-utils-2.18.2/configure.ac 2023-04-17 07:37:14.000000000 +0200 +++ new/libva-utils-2.19.0/configure.ac 2023-07-04 10:25:59.000000000 +0200 @@ -29,8 +29,8 @@ # - micro version is libva_micro_version # - pre version is libva_pre_version, usually development version m4_define([libva_utils_major_version], [2]) -m4_define([libva_utils_minor_version], [18]) -m4_define([libva_utils_micro_version], [2]) +m4_define([libva_utils_minor_version], [19]) +m4_define([libva_utils_micro_version], [0]) m4_define([libva_utils_pre_version], [0]) m4_define([libva_utils_version], @@ -142,9 +142,6 @@ fi AM_CONDITIONAL(USE_SSP, test "$ssp_cc" = "yes") -# Check for DRM (mandatory) -PKG_CHECK_MODULES([LIBVA_DRM], [libva-drm libdrm]) - # Check for libva (for dynamic linking) LIBVA_API_MIN_VERSION=libva_api_min_version PKG_CHECK_MODULES([LIBVA], [libva >= $LIBVA_API_MIN_VERSION]) @@ -155,7 +152,8 @@ VA_MINOR_VERSION=`echo "$LIBVA_API_VERSION" | cut -d'.' -f2` VA_MICRO_VERSION=`echo "$LIBVA_API_VERSION" | cut -d'.' -f3` - +# Check for DRM (mandatory) +PKG_CHECK_MODULES([LIBVA_DRM], [libdrm libva-drm = $LIBVA_API_VERSION]) USE_DRM="no" if test "$enable_drm" = "yes"; then @@ -167,7 +165,7 @@ # Check for X11 USE_X11="no" if test "x$enable_x11" != "xno"; then - PKG_CHECK_MODULES([X11], [x11 libva-x11], + PKG_CHECK_MODULES([X11], [x11 libva-x11 = $LIBVA_API_VERSION], [USE_X11="yes"], [:]) if test "x$USE_X11" = "xno" -a "x$enable_x11" = "xyes"; then @@ -186,7 +184,7 @@ USE_WAYLAND="no" if test "x$enable_wayland" != "xno"; then - PKG_CHECK_MODULES([WAYLAND], [wayland-client >= wayland_api_version libva-wayland], + PKG_CHECK_MODULES([WAYLAND], [wayland-client >= wayland_api_version libva-wayland = $LIBVA_API_VERSION], [USE_WAYLAND="yes"], [:]) if test "x$USE_WAYLAND" = "xno" -a "x$enable_wayland" = "xyes"; then diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libva-utils-2.18.2/encode/h264encode.c new/libva-utils-2.19.0/encode/h264encode.c --- old/libva-utils-2.18.2/encode/h264encode.c 2023-04-17 07:37:14.000000000 +0200 +++ new/libva-utils-2.19.0/encode/h264encode.c 2023-07-04 10:25:59.000000000 +0200 @@ -1483,7 +1483,12 @@ seq_param.seq_fields.bits.frame_mbs_only_flag = 1; seq_param.time_scale = 900; seq_param.num_units_in_tick = 15; /* Tc = num_units_in_tick / time_sacle */ + Log2MaxPicOrderCntLsb = ceil(log2(intra_idr_period*2)); seq_param.seq_fields.bits.log2_max_pic_order_cnt_lsb_minus4 = Log2MaxPicOrderCntLsb - 4; + if(seq_param.seq_fields.bits.log2_max_pic_order_cnt_lsb_minus4 > 12) + { + seq_param.seq_fields.bits.log2_max_pic_order_cnt_lsb_minus4 = 12; + } seq_param.seq_fields.bits.log2_max_frame_num_minus4 = Log2MaxFrameNum - 4;; seq_param.seq_fields.bits.frame_mbs_only_flag = 1; seq_param.seq_fields.bits.chroma_format_idc = 1; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libva-utils-2.18.2/encode/hevcencode.c new/libva-utils-2.19.0/encode/hevcencode.c --- old/libva-utils-2.18.2/encode/hevcencode.c 2023-04-17 07:37:14.000000000 +0200 +++ new/libva-utils-2.19.0/encode/hevcencode.c 2023-07-04 10:25:59.000000000 +0200 @@ -367,10 +367,46 @@ uint8_t *slice_segment_header_extension_data_byte; //u(8) }; +struct BlockSizes { + uint32_t log2_max_coding_tree_block_size_minus3; + uint32_t log2_min_coding_tree_block_size_minus3; + uint32_t log2_min_luma_coding_block_size_minus3; + uint32_t log2_max_luma_transform_block_size_minus2; + uint32_t log2_min_luma_transform_block_size_minus2; + uint32_t log2_max_pcm_coding_block_size_minus3; + uint32_t log2_min_pcm_coding_block_size_minus3; + uint32_t max_max_transform_hierarchy_depth_inter; + uint32_t min_max_transform_hierarchy_depth_inter; + uint32_t max_max_transform_hierarchy_depth_intra; + uint32_t min_max_transform_hierarchy_depth_intra; +}; + +struct Features { + uint32_t amp; //sps->amp_enable_flag + uint32_t constrained_intra_pred; + uint32_t cu_qp_delta; // pps->cu_qp_delta_enabled_flag + uint32_t deblocking_filter_disable; + uint32_t dependent_slices; + uint32_t pcm; // sps->pcm_enable_flag + uint32_t sao; //sps->sample_adaptive_offset_enabled_flag + uint32_t scaling_lists; + uint32_t separate_colour_planes; + uint32_t sign_data_hiding; + uint32_t strong_intra_smoothing; + uint32_t temporal_mvp; //sps->sps_temporal_mvp_enabled_flag + uint32_t transform_skip; // pps->transform_skip_enabled_flag + uint32_t transquant_bypass; + uint32_t weighted_prediction; +}; + static struct VideoParamSet vps; static struct SeqParamSet sps; static struct PicParamSet pps; static struct SliceHeader ssh; +static struct BlockSizes block_sizes; +static int use_block_sizes = 0; +static struct Features features; +static int use_features = 0; static VADisplay va_dpy; static VAProfile hevc_profile = ~0; static int real_hevc_profile = 0; @@ -746,7 +782,7 @@ sps->sps_seq_parameter_set_id = id; sps->chroma_format_idc = 1; if (sps->chroma_format_idc == 3) { - sps->separate_colour_plane_flag = 0; + sps->separate_colour_plane_flag = use_features ? features.separate_colour_planes : 0; } frame_width_aligned = ALIGN16(frame_width); frame_height_aligned = ALIGN16(frame_height); @@ -788,20 +824,21 @@ sps->sps_max_num_reorder_pics[i] = ip_period != 0 ? ip_period - 1 : 0; sps->sps_max_latency_increase_plus1[i] = 0; } - sps->log2_min_luma_coding_block_size_minus3 = 0; - int log2_max_luma_coding_block_size = log2(LCU_SIZE); + sps->log2_min_luma_coding_block_size_minus3 = use_block_sizes ? block_sizes.log2_min_luma_coding_block_size_minus3 : 0; + int log2_max_luma_coding_block_size = use_block_sizes ? block_sizes.log2_max_coding_tree_block_size_minus3 + 3 : log2(LCU_SIZE); int log2_min_luma_coding_block_size = sps->log2_min_luma_coding_block_size_minus3 + 3; sps->log2_diff_max_min_luma_coding_block_size = log2_max_luma_coding_block_size - log2_min_luma_coding_block_size; - sps->log2_min_luma_transform_block_size_minus2 = 0; - sps->log2_diff_max_min_luma_transform_block_size = 3; - sps->max_transform_hierarchy_depth_inter = 2; - sps->max_transform_hierarchy_depth_intra = 2; - sps->scaling_list_enabled_flag = 0; - //sps->sps_scaling_list_data_present_flag; // ignore since scaling_list_enabled_flag equal to 0 - sps->amp_enabled_flag = 1; - sps->sample_adaptive_offset_enabled_flag = 1; - sps->pcm_enabled_flag = 0; + sps->log2_min_luma_transform_block_size_minus2 = use_block_sizes ? block_sizes.log2_min_luma_transform_block_size_minus2 : 0; + sps->log2_diff_max_min_luma_transform_block_size = use_block_sizes ? (block_sizes.log2_max_luma_transform_block_size_minus2 - + sps->log2_min_luma_transform_block_size_minus2) : 3; + sps->max_transform_hierarchy_depth_inter = use_block_sizes ? block_sizes.max_max_transform_hierarchy_depth_inter : 2; + sps->max_transform_hierarchy_depth_intra = use_block_sizes ? block_sizes.max_max_transform_hierarchy_depth_intra : 2; + sps->scaling_list_enabled_flag = use_features ? features.scaling_lists : 0; + sps->sps_scaling_list_data_present_flag = 0; + sps->amp_enabled_flag = use_features ? features.amp : 1; + sps->sample_adaptive_offset_enabled_flag = use_features ? features.sao : 1; + sps->pcm_enabled_flag = use_features ? features.pcm : 0; /* ignore below parameters seting since pcm_enabled_flag equal to 0 pcm_sample_bit_depth_luma_minus1; pcm_sample_bit_depth_chroma_minus1; @@ -820,9 +857,9 @@ lt_ref_pic_poc_lsb_sps[kMaxLongTermRefPic]; used_by_curr_pic_lt_sps_flag[kMaxLongTermRefPic]; */ - sps->sps_temporal_mvp_enabled_flag = 1; - sps->strong_intra_smoothing_enabled_flag = 0; - + sps->sps_temporal_mvp_enabled_flag = use_features ? features.temporal_mvp : 1; + sps->strong_intra_smoothing_enabled_flag = use_features ? features.strong_intra_smoothing : 0; + sps->vui_parameters_present_flag = 0; sps->sps_extension_present_flag = 0; /* ignore below parameters seting since sps_extension_present_flag equal to 0 @@ -843,34 +880,34 @@ pps->pps_pic_parameter_set_id = pps_id; pps->pps_seq_parameter_set_id = sps_id; - pps->dependent_slice_segments_enabled_flag = 0; + pps->dependent_slice_segments_enabled_flag = use_features ? features.dependent_slices : 0; pps->output_flag_present_flag = 0; pps->num_extra_slice_header_bits = 0; - pps->sign_data_hiding_enabled_flag = 0; + pps->sign_data_hiding_enabled_flag = use_features ? features.sign_data_hiding : 0; pps->cabac_init_present_flag = 1; pps->num_ref_idx_l0_default_active_minus1 = 0; pps->num_ref_idx_l1_default_active_minus1 = 0; pps->init_qp_minus26 = initial_qp - 26; - pps->constrained_intra_pred_flag = 0; - pps->transform_skip_enabled_flag = 0; - pps->cu_qp_delta_enabled_flag = 1; + pps->constrained_intra_pred_flag = use_features ? features.constrained_intra_pred : 0; + pps->transform_skip_enabled_flag = use_features ? features.transform_skip : 0; + pps->cu_qp_delta_enabled_flag = use_features ? features.cu_qp_delta : 1; if (pps->cu_qp_delta_enabled_flag) pps->diff_cu_qp_delta_depth = 2; pps->pps_cb_qp_offset = 0; pps->pps_cr_qp_offset = 0; pps->pps_slice_chroma_qp_offsets_present_flag = 0; - pps->weighted_pred_flag = 0; + pps->weighted_pred_flag = use_features ? features.weighted_prediction : 0; pps->weighted_bipred_flag = 0; - pps->transquant_bypass_enabled_flag = 0; + pps->transquant_bypass_enabled_flag = use_features ? features.transquant_bypass : 0; pps->entropy_coding_sync_enabled_flag = 0; pps->tiles_enabled_flag = 0; pps->pps_loop_filter_across_slices_enabled_flag = 0; pps->deblocking_filter_control_present_flag = 1; pps->deblocking_filter_override_enabled_flag = 0, - pps->pps_deblocking_filter_disabled_flag = 0, + pps->pps_deblocking_filter_disabled_flag = use_features ? features.deblocking_filter_disable : 0, pps->pps_beta_offset_div2 = 2, pps->pps_tc_offset_div2 = 0, pps->pps_scaling_list_data_present_flag = 0; @@ -893,8 +930,9 @@ slice->pic_order_cnt_lsb = calc_poc((current_frame_display - current_IDR_display) % MaxPicOrderCntLsb); //slice_segment_address (u(v)) - slice->picture_height_in_ctus = (frame_height + LCU_SIZE - 1) / LCU_SIZE; - slice->picture_width_in_ctus = (frame_width + LCU_SIZE - 1) / LCU_SIZE; + int lcu_size = use_block_sizes ? (1 << (block_sizes.log2_max_coding_tree_block_size_minus3 + 3)) : LCU_SIZE; + slice->picture_height_in_ctus = (frame_height + lcu_size - 1) / lcu_size; + slice->picture_width_in_ctus = (frame_width + lcu_size - 1) / lcu_size; slice->slice_segment_address = 0; slice->first_slice_segment_in_pic_flag = ((slice->slice_segment_address == 0) ? 1 : 0); slice->slice_type = current_frame_type == FRAME_P ? (p2b ? SLICE_B : SLICE_P) : @@ -908,7 +946,7 @@ slice->strp.num_positive_pics = 0; slice->slice_sao_luma_flag = 0; slice->slice_sao_chroma_flag = 0; - slice->slice_temporal_mvp_enabled_flag = 1; + slice->slice_temporal_mvp_enabled_flag = use_features ? features.temporal_mvp : 1; slice->num_ref_idx_l0_active_minus1 = pps->num_ref_idx_l0_default_active_minus1; slice->num_ref_idx_l1_active_minus1 = pps->num_ref_idx_l1_default_active_minus1; @@ -1386,7 +1424,7 @@ put_ue(bs, slice_header->num_long_term_pics); } - if (slice_header->slice_temporal_mvp_enabled_flag) + if (sps->sps_temporal_mvp_enabled_flag) put_ui(bs, slice_header->slice_temporal_mvp_enabled_flag, 1); } @@ -2168,6 +2206,52 @@ if (attrib[VAConfigAttribEncMacroblockInfo].value != VA_ATTRIB_NOT_SUPPORTED) { printf("Support VAConfigAttribEncMacroblockInfo\n"); } + if (attrib[VAConfigAttribEncHEVCBlockSizes].value != VA_ATTRIB_NOT_SUPPORTED) { + printf("Support VAConfigAttribEncHEVCBlockSizes\n"); + uint32_t tmp = attrib[VAConfigAttribEncHEVCBlockSizes].value; + VAConfigAttribValEncHEVCBlockSizes bs = { .value = tmp }; + block_sizes.log2_max_coding_tree_block_size_minus3 = bs.bits.log2_max_coding_tree_block_size_minus3; + block_sizes.log2_min_coding_tree_block_size_minus3 = bs.bits.log2_min_coding_tree_block_size_minus3; + block_sizes.log2_min_luma_coding_block_size_minus3 = bs.bits.log2_min_luma_coding_block_size_minus3; + block_sizes.log2_max_luma_transform_block_size_minus2 = bs.bits.log2_max_luma_transform_block_size_minus2; + block_sizes.log2_min_luma_transform_block_size_minus2 = bs.bits.log2_min_luma_transform_block_size_minus2; + block_sizes.log2_max_pcm_coding_block_size_minus3 = bs.bits.log2_max_pcm_coding_block_size_minus3; + block_sizes.log2_min_pcm_coding_block_size_minus3 = bs.bits.log2_min_pcm_coding_block_size_minus3; + block_sizes.max_max_transform_hierarchy_depth_inter = bs.bits.max_max_transform_hierarchy_depth_inter; + block_sizes.min_max_transform_hierarchy_depth_inter = bs.bits.min_max_transform_hierarchy_depth_inter; + block_sizes.max_max_transform_hierarchy_depth_intra = bs.bits.max_max_transform_hierarchy_depth_intra; + block_sizes.min_max_transform_hierarchy_depth_intra = bs.bits.min_max_transform_hierarchy_depth_intra; + + use_block_sizes = 1; + config_attrib[config_attrib_num].type = VAConfigAttribEncHEVCBlockSizes; + config_attrib[config_attrib_num].value = tmp; + config_attrib_num++; + } + if (attrib[VAConfigAttribEncHEVCFeatures].value != VA_ATTRIB_NOT_SUPPORTED) { + printf("Support VAConfigAttribEncHEVCFeatures\n"); + uint32_t tmp = attrib[VAConfigAttribEncHEVCFeatures].value; + VAConfigAttribValEncHEVCFeatures f = { .value = tmp }; + features.amp = f.bits.amp; + features.constrained_intra_pred = f.bits.constrained_intra_pred; + features.cu_qp_delta = f.bits.cu_qp_delta; + features.deblocking_filter_disable = f.bits.deblocking_filter_disable; + features.dependent_slices = f.bits.dependent_slices; + features.pcm = f.bits.pcm; + features.sao = f.bits.sao; + features.scaling_lists = f.bits.scaling_lists; + features.separate_colour_planes = f.bits.separate_colour_planes; + features.sign_data_hiding = f.bits.sign_data_hiding; + features.strong_intra_smoothing = f.bits.strong_intra_smoothing; + features.temporal_mvp = f.bits.temporal_mvp; + features.transform_skip = f.bits.transform_skip; + features.transquant_bypass = f.bits.transquant_bypass; + features.weighted_prediction = f.bits.weighted_prediction; + + use_features = 1; + config_attrib[config_attrib_num].type = VAConfigAttribEncHEVCFeatures; + config_attrib[config_attrib_num].value = attrib[VAConfigAttribEncHEVCFeatures].value; + config_attrib_num++; + } free(entrypoints); return 0; @@ -3296,6 +3380,7 @@ { unsigned int start; + va_init_display_args(&argc, argv); process_cmdline(argc, argv); print_input(); diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libva-utils-2.18.2/encode/meson.build new/libva-utils-2.19.0/encode/meson.build --- old/libva-utils-2.18.2/encode/meson.build 2023-04-17 07:37:14.000000000 +0200 +++ new/libva-utils-2.19.0/encode/meson.build 2023-07-04 10:25:59.000000000 +0200 @@ -24,6 +24,8 @@ executable('vp8enc', [ 'vp8enc.c' ], dependencies: [libva_display_dep, threads, m ], install: true) -executable('av1encode', [ 'av1encode.c' ], - dependencies: [ libva_display_dep, threads, m ], - install: true) +if libva_dep.version().version_compare('>= 1.14.0') + executable('av1encode', [ 'av1encode.c' ], + dependencies: [ libva_display_dep, threads, m ], + install: true) +endif \ No newline at end of file diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libva-utils-2.18.2/meson.build new/libva-utils-2.19.0/meson.build --- old/libva-utils-2.18.2/meson.build 2023-04-17 07:37:14.000000000 +0200 +++ new/libva-utils-2.19.0/meson.build 2023-07-04 10:25:59.000000000 +0200 @@ -1,5 +1,5 @@ project('libva-utils', 'c', 'cpp', - version : '2.18.2', + version : '2.19.0', default_options : [ 'warning_level=2', 'c_std=gnu99', @@ -25,7 +25,7 @@ if get_option('drm') != 'false' require_drm = get_option('drm') == 'true' drm_deps = [ - dependency('libva-drm', required: require_drm), + dependency('libva-drm', version: libva_dep.version(), required: require_drm), dependency('libdrm', required: require_drm), ] use_drm = true @@ -46,7 +46,7 @@ require_x11 = get_option('x11') == 'true' x11_deps = [ dependency('x11', required: require_x11), - dependency('libva-x11', required: require_x11), + dependency('libva-x11', version: libva_dep.version(), required: require_x11), ] use_x11 = true foreach d : x11_deps @@ -66,7 +66,7 @@ require_wayland = get_option('wayland') == 'true' wayland_deps = [ dependency('wayland-client', version: '>= 1.0.0', required: require_wayland), - dependency('libva-wayland', required: require_wayland), + dependency('libva-wayland', version: libva_dep.version(), required: require_wayland), ] use_wayland = true foreach d : wayland_deps @@ -84,7 +84,7 @@ use_win32 = false if get_option('win32') != 'false' require_win32 = get_option('win32') == 'true' - use_win32 = dependency('libva-win32', required: require_win32).found() + use_win32 = dependency('libva-win32', version: libva_dep.version(), required: require_win32).found() if use_win32 libva_utils_flags = [ '-DHAVE_VA_WIN32=1', '-DNOMINMAX'] dep_dxheaders = dependency('directx-headers', required : false) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libva-utils-2.18.2/videoprocess/meson.build new/libva-utils-2.19.0/videoprocess/meson.build --- old/libva-utils-2.18.2/videoprocess/meson.build 2023-04-17 07:37:14.000000000 +0200 +++ new/libva-utils-2.19.0/videoprocess/meson.build 2023-07-04 10:25:59.000000000 +0200 @@ -4,9 +4,11 @@ executable('vavpp', [ 'vavpp.cpp' ], dependencies: libva_display_dep, install: true) -executable('vpp3dlut', [ 'vpp3dlut.cpp' ], - dependencies: libva_display_dep, - install: true) +if libva_dep.version().version_compare('>= 1.12.0') + executable('vpp3dlut', [ 'vpp3dlut.cpp' ], + dependencies: libva_display_dep, + install: true) +endif executable('vppblending', [ 'vppblending.cpp' ], dependencies: libva_display_dep, install: true)
