From fe88f8b49646e61df75a45dd5e80b08191352cc29f46f59d9f2405bf72c77a7c Mon Sep 17 00:00:00 2001 From: Stefan Dirsch Date: Thu, 14 Jan 2021 19:31:19 +0000 Subject: [PATCH] Accepting request 863170 from home:dirkmueller:branches:X11:XOrg - add c5a8e7c6c8b4b36a0e4c9a4369404519262a3256.patch e82dc4bdbb0db3ffa8c78275902738eb63aa5ca8.patch: upstream patches to include tracing info for VP9 and HEVC OBS-URL: https://build.opensuse.org/request/show/863170 OBS-URL: https://build.opensuse.org/package/show/X11:XOrg/libvdpau?expand=0&rev=26 --- ...e7c6c8b4b36a0e4c9a4369404519262a3256.patch | 177 ++++++++++ ...c4bdbb0db3ffa8c78275902738eb63aa5ca8.patch | 319 ++++++++++++++++++ libvdpau.changes | 7 + libvdpau.spec | 17 +- 4 files changed, 511 insertions(+), 9 deletions(-) create mode 100644 c5a8e7c6c8b4b36a0e4c9a4369404519262a3256.patch create mode 100644 e82dc4bdbb0db3ffa8c78275902738eb63aa5ca8.patch diff --git a/c5a8e7c6c8b4b36a0e4c9a4369404519262a3256.patch b/c5a8e7c6c8b4b36a0e4c9a4369404519262a3256.patch new file mode 100644 index 0000000..d9ce43e --- /dev/null +++ b/c5a8e7c6c8b4b36a0e4c9a4369404519262a3256.patch @@ -0,0 +1,177 @@ +From c5a8e7c6c8b4b36a0e4c9a4369404519262a3256 Mon Sep 17 00:00:00 2001 +From: ManojGuptaBonda +Date: Wed, 22 Jul 2020 15:41:08 +0530 +Subject: [PATCH] Add tracing for VP9 picture info + +--- + trace/vdpau_trace.cpp | 154 ++++++++++++++++++++++++++++++++++++++++++ + 1 file changed, 154 insertions(+) + +diff --git a/trace/vdpau_trace.cpp b/trace/vdpau_trace.cpp +index 11e227c..3479e05 100644 +--- a/trace/vdpau_trace.cpp ++++ b/trace/vdpau_trace.cpp +@@ -722,6 +722,160 @@ static void _vdp_cap_dump_picture_info( + fputs("}}", _vdp_cap_data.fp); + } + break; ++ case VDP_DECODER_PROFILE_VP9_PROFILE_0: ++ case VDP_DECODER_PROFILE_VP9_PROFILE_1: ++ case VDP_DECODER_PROFILE_VP9_PROFILE_2: ++ case VDP_DECODER_PROFILE_VP9_PROFILE_3: ++ { ++ VdpPictureInfoVP9 const * picture_info_vp9 = ++ (VdpPictureInfoVP9 const *)picture_info; ++ ++ fprintf( ++ _vdp_cap_data.fp, ++ "{%u, %u, %u, %u, %u, %u, %u, %u, %u, %u, %u, %u, %u, %u, %u, %u, %u {", ++ (uint32_t)picture_info_vp9->width, ++ (uint32_t)picture_info_vp9->height, ++ picture_info_vp9->lastReference, ++ picture_info_vp9->goldenReference, ++ picture_info_vp9->altReference, ++ (uint32_t)picture_info_vp9->colorSpace, ++ (uint32_t)picture_info_vp9->profile, ++ (uint32_t)picture_info_vp9->frameContextIdx, ++ (uint32_t)picture_info_vp9->keyFrame, ++ (uint32_t)picture_info_vp9->showFrame, ++ (uint32_t)picture_info_vp9->errorResilient, ++ (uint32_t)picture_info_vp9->frameParallelDecoding, ++ (uint32_t)picture_info_vp9->subSamplingX, ++ (uint32_t)picture_info_vp9->subSamplingY, ++ (uint32_t)picture_info_vp9->intraOnly, ++ (uint32_t)picture_info_vp9->allowHighPrecisionMv, ++ (uint32_t)picture_info_vp9->refreshEntropyProbs ++ ); ++ for (uint32_t i = 0; i < _VDP_TRACE_ARSIZE(picture_info_vp9->refFrameSignBias); ++i) { ++ fprintf( ++ _vdp_cap_data.fp, ++ "%s%u", ++ (i == 0) ? "" : ", ", ++ (uint32_t)picture_info_vp9->refFrameSignBias[i] ++ ); ++ } ++ fputs("}, ", _vdp_cap_data.fp); ++ fprintf( ++ _vdp_cap_data.fp, ++ "%u, %u, %u, %u, %u, %u, %u, %u, %u, %u, %u, {", ++ (uint32_t)picture_info_vp9->bitDepthMinus8Luma, ++ (uint32_t)picture_info_vp9->bitDepthMinus8Chroma, ++ (uint32_t)picture_info_vp9->loopFilterLevel, ++ (uint32_t)picture_info_vp9->loopFilterSharpness, ++ (uint32_t)picture_info_vp9->modeRefLfEnabled, ++ (uint32_t)picture_info_vp9->log2TileColumns, ++ (uint32_t)picture_info_vp9->log2TileRows, ++ (uint32_t)picture_info_vp9->segmentEnabled, ++ (uint32_t)picture_info_vp9->segmentMapUpdate, ++ (uint32_t)picture_info_vp9->segmentMapTemporalUpdate, ++ (uint32_t)picture_info_vp9->segmentFeatureMode ++ ); ++ for (uint32_t i = 0; i < _VDP_TRACE_ARSIZE(picture_info_vp9->segmentFeatureEnable); ++i) { ++ fputs((i == 0) ? "{" : "}, {", _vdp_cap_data.fp); ++ for (uint32_t j = 0; j < _VDP_TRACE_ARSIZE(picture_info_vp9->segmentFeatureEnable[0]); ++j) { ++ fprintf( ++ _vdp_cap_data.fp, ++ "%s%u", ++ (j == 0) ? "" : ", ", ++ (uint32_t)picture_info_vp9->segmentFeatureEnable[i][j] ++ ); ++ } ++ } ++ fputs("}}, {", _vdp_cap_data.fp); ++ for (uint32_t i = 0; i < _VDP_TRACE_ARSIZE(picture_info_vp9->segmentFeatureData); ++i) { ++ fputs((i == 0) ? "{" : "}, {", _vdp_cap_data.fp); ++ for (uint32_t j = 0; j < _VDP_TRACE_ARSIZE(picture_info_vp9->segmentFeatureData[0]); ++j) { ++ fprintf( ++ _vdp_cap_data.fp, ++ "%s%d", ++ (j == 0) ? "" : ", ", ++ (int32_t)picture_info_vp9->segmentFeatureData[i][j] ++ ); ++ } ++ } ++ fputs("}}, {", _vdp_cap_data.fp); ++ for (uint32_t i = 0; i < _VDP_TRACE_ARSIZE(picture_info_vp9->mbSegmentTreeProbs); ++i) { ++ fprintf( ++ _vdp_cap_data.fp, ++ "%s%u", ++ (i == 0) ? "" : ", ", ++ (uint32_t)picture_info_vp9->mbSegmentTreeProbs[i] ++ ); ++ } ++ fputs("}, {", _vdp_cap_data.fp); ++ for (uint32_t i = 0; i < _VDP_TRACE_ARSIZE(picture_info_vp9->segmentPredProbs); ++i) { ++ fprintf( ++ _vdp_cap_data.fp, ++ "%s%u", ++ (i == 0) ? "" : ", ", ++ (uint32_t)picture_info_vp9->segmentPredProbs[i] ++ ); ++ } ++ fputs("}, {", _vdp_cap_data.fp); ++ for (uint32_t i = 0; i < _VDP_TRACE_ARSIZE(picture_info_vp9->reservedSegment16Bits); ++i) { ++ fprintf( ++ _vdp_cap_data.fp, ++ "%s%u", ++ (i == 0) ? "" : ", ", ++ (uint32_t)picture_info_vp9->reservedSegment16Bits[i] ++ ); ++ } ++ fputs("}, ", _vdp_cap_data.fp); ++ fprintf( ++ _vdp_cap_data.fp, ++ "%d, %d, %d, %d, {", ++ (int32_t)picture_info_vp9->qpYAc, ++ (int32_t)picture_info_vp9->qpYDc, ++ (int32_t)picture_info_vp9->qpChDc, ++ (int32_t)picture_info_vp9->qpChAc ++ ); ++ for (uint32_t i = 0; i < _VDP_TRACE_ARSIZE(picture_info_vp9->activeRefIdx); ++i) { ++ fprintf( ++ _vdp_cap_data.fp, ++ "%s%u", ++ (i == 0) ? "" : ", ", ++ (uint32_t)picture_info_vp9->activeRefIdx[i] ++ ); ++ } ++ fputs("}, ", _vdp_cap_data.fp); ++ fprintf( ++ _vdp_cap_data.fp, ++ "%u, %u, {", ++ (uint32_t)picture_info_vp9->resetFrameContext, ++ (uint32_t)picture_info_vp9->mcompFilterType ++ ); ++ for (uint32_t i = 0; i < _VDP_TRACE_ARSIZE(picture_info_vp9->mbRefLfDelta); ++i) { ++ fprintf( ++ _vdp_cap_data.fp, ++ "%s%u", ++ (i == 0) ? "" : ", ", ++ (uint32_t)picture_info_vp9->mbRefLfDelta[i] ++ ); ++ } ++ fputs("}, {", _vdp_cap_data.fp); ++ for (uint32_t i = 0; i < _VDP_TRACE_ARSIZE(picture_info_vp9->mbModeLfDelta); ++i) { ++ fprintf( ++ _vdp_cap_data.fp, ++ "%s%d", ++ (i == 0) ? "" : ", ", ++ (int32_t)picture_info_vp9->mbModeLfDelta[i] ++ ); ++ } ++ fputs("}, ", _vdp_cap_data.fp); ++ fprintf( ++ _vdp_cap_data.fp, ++ "%u, %u, {", ++ (uint32_t)picture_info_vp9->uncompressedHeaderSize, ++ (uint32_t)picture_info_vp9->compressedHeaderSize ++ ); ++ fputs("}", _vdp_cap_data.fp); ++ } ++ break; + default: + fputs("{...}", _vdp_cap_data.fp); + break; +-- +GitLab + diff --git a/e82dc4bdbb0db3ffa8c78275902738eb63aa5ca8.patch b/e82dc4bdbb0db3ffa8c78275902738eb63aa5ca8.patch new file mode 100644 index 0000000..880d75b --- /dev/null +++ b/e82dc4bdbb0db3ffa8c78275902738eb63aa5ca8.patch @@ -0,0 +1,319 @@ +From e82dc4bdbb0db3ffa8c78275902738eb63aa5ca8 Mon Sep 17 00:00:00 2001 +From: ManojGuptaBonda +Date: Mon, 27 Jul 2020 17:26:11 +0530 +Subject: [PATCH] Add tracing for HEVCRangeExt picture info + +--- + trace/vdpau_trace.cpp | 281 +++++++++++++++++++++++++++++++++++++++++- + 1 file changed, 280 insertions(+), 1 deletion(-) + +diff --git a/trace/vdpau_trace.cpp b/trace/vdpau_trace.cpp +index 3479e05..c399801 100644 +--- a/trace/vdpau_trace.cpp ++++ b/trace/vdpau_trace.cpp +@@ -488,15 +488,252 @@ static void _vdp_cap_dump_picture_info( + case VDP_DECODER_PROFILE_HEVC_MAIN: + case VDP_DECODER_PROFILE_HEVC_MAIN_10: + case VDP_DECODER_PROFILE_HEVC_MAIN_STILL: ++ { ++ VdpPictureInfoHEVC const * picture_info_hevc = ++ (VdpPictureInfoHEVC const *)picture_info; ++ ++ fprintf( ++ _vdp_cap_data.fp, ++ "{%u, %u, %u, %u, %u, %u, %u, %u, %u, %u, %u, %u, %u, %u, %u, {", ++ (uint32_t)picture_info_hevc->chroma_format_idc, ++ (uint32_t)picture_info_hevc->separate_colour_plane_flag, ++ (uint32_t)picture_info_hevc->pic_width_in_luma_samples, ++ (uint32_t)picture_info_hevc->pic_height_in_luma_samples, ++ (uint32_t)picture_info_hevc->bit_depth_luma_minus8, ++ (uint32_t)picture_info_hevc->bit_depth_chroma_minus8, ++ (uint32_t)picture_info_hevc->log2_max_pic_order_cnt_lsb_minus4, ++ (uint32_t)picture_info_hevc->sps_max_dec_pic_buffering_minus1, ++ (uint32_t)picture_info_hevc->log2_min_luma_coding_block_size_minus3, ++ (uint32_t)picture_info_hevc->log2_diff_max_min_luma_coding_block_size, ++ (uint32_t)picture_info_hevc->log2_min_transform_block_size_minus2, ++ (uint32_t)picture_info_hevc->log2_diff_max_min_transform_block_size, ++ (uint32_t)picture_info_hevc->max_transform_hierarchy_depth_inter, ++ (uint32_t)picture_info_hevc->max_transform_hierarchy_depth_intra, ++ (uint32_t)picture_info_hevc->scaling_list_enabled_flag ++ ); ++ for (uint32_t i = 0; i < _VDP_TRACE_ARSIZE(picture_info_hevc->ScalingList4x4); ++i) { ++ fputs((i == 0) ? "{" : "}, {", _vdp_cap_data.fp); ++ for (uint32_t j = 0; j < _VDP_TRACE_ARSIZE(picture_info_hevc->ScalingList4x4[0]); ++j) { ++ fprintf( ++ _vdp_cap_data.fp, ++ "%s%u", ++ (j == 0) ? "" : ", ", ++ (uint32_t)picture_info_hevc->ScalingList4x4[i][j] ++ ); ++ } ++ } ++ fputs("}}, {", _vdp_cap_data.fp); ++ for (uint32_t i = 0; i < _VDP_TRACE_ARSIZE(picture_info_hevc->ScalingList8x8); ++i) { ++ fputs((i == 0) ? "{" : "}, {", _vdp_cap_data.fp); ++ for (uint32_t j = 0; j < _VDP_TRACE_ARSIZE(picture_info_hevc->ScalingList8x8[0]); ++j) { ++ fprintf( ++ _vdp_cap_data.fp, ++ "%s%u", ++ (j == 0) ? "" : ", ", ++ (uint32_t)picture_info_hevc->ScalingList8x8[i][j] ++ ); ++ } ++ } ++ fputs("}}, {", _vdp_cap_data.fp); ++ for (uint32_t i = 0; i < _VDP_TRACE_ARSIZE(picture_info_hevc->ScalingList16x16); ++i) { ++ fputs((i == 0) ? "{" : "}, {", _vdp_cap_data.fp); ++ for (uint32_t j = 0; j < _VDP_TRACE_ARSIZE(picture_info_hevc->ScalingList16x16[0]); ++j) { ++ fprintf( ++ _vdp_cap_data.fp, ++ "%s%u", ++ (j == 0) ? "" : ", ", ++ (uint32_t)picture_info_hevc->ScalingList16x16[i][j] ++ ); ++ } ++ } ++ fputs("}}, {", _vdp_cap_data.fp); ++ for (uint32_t i = 0; i < _VDP_TRACE_ARSIZE(picture_info_hevc->ScalingList32x32); ++i) { ++ fputs((i == 0) ? "{" : "}, {", _vdp_cap_data.fp); ++ for (uint32_t j = 0; j < _VDP_TRACE_ARSIZE(picture_info_hevc->ScalingList32x32[0]); ++j) { ++ fprintf( ++ _vdp_cap_data.fp, ++ "%s%u", ++ (j == 0) ? "" : ", ", ++ (uint32_t)picture_info_hevc->ScalingList32x32[i][j] ++ ); ++ } ++ } ++ fputs("}}, {", _vdp_cap_data.fp); ++ for (uint32_t i = 0; i < _VDP_TRACE_ARSIZE(picture_info_hevc->ScalingListDCCoeff16x16); ++i) { ++ fprintf( ++ _vdp_cap_data.fp, ++ "%s%u", ++ (i == 0) ? "" : ", ", ++ (uint32_t)picture_info_hevc->ScalingListDCCoeff16x16[i] ++ ); ++ } ++ fputs("}, {", _vdp_cap_data.fp); ++ for (uint32_t i = 0; i < _VDP_TRACE_ARSIZE(picture_info_hevc->ScalingListDCCoeff32x32); ++i) { ++ fprintf( ++ _vdp_cap_data.fp, ++ "%s%u", ++ (i == 0) ? "" : ", ", ++ (uint32_t)picture_info_hevc->ScalingListDCCoeff32x32[i] ++ ); ++ } ++ fputs("}, ", _vdp_cap_data.fp); ++ fprintf( ++ _vdp_cap_data.fp, ++ "%u, %u, %u, %u, %u, %u, %u, %u, %u, %u, %u, %u, %u, %u, %u, %u, %u, %u, %u, %u, %d, %u, %u, %u, %u, %d, %d, %u, %u, %u, %u, %u, %u, %u, %u, %u, {", ++ (uint32_t)picture_info_hevc->amp_enabled_flag, ++ (uint32_t)picture_info_hevc->sample_adaptive_offset_enabled_flag, ++ (uint32_t)picture_info_hevc->pcm_enabled_flag, ++ (uint32_t)picture_info_hevc->pcm_sample_bit_depth_luma_minus1, ++ (uint32_t)picture_info_hevc->pcm_sample_bit_depth_chroma_minus1, ++ (uint32_t)picture_info_hevc->log2_min_pcm_luma_coding_block_size_minus3, ++ (uint32_t)picture_info_hevc->log2_diff_max_min_pcm_luma_coding_block_size, ++ (uint32_t)picture_info_hevc->pcm_loop_filter_disabled_flag, ++ (uint32_t)picture_info_hevc->num_short_term_ref_pic_sets, ++ (uint32_t)picture_info_hevc->long_term_ref_pics_present_flag, ++ (uint32_t)picture_info_hevc->num_long_term_ref_pics_sps, ++ (uint32_t)picture_info_hevc->sps_temporal_mvp_enabled_flag, ++ (uint32_t)picture_info_hevc->strong_intra_smoothing_enabled_flag, ++ (uint32_t)picture_info_hevc->dependent_slice_segments_enabled_flag, ++ (uint32_t)picture_info_hevc->output_flag_present_flag, ++ (uint32_t)picture_info_hevc->num_extra_slice_header_bits, ++ (uint32_t)picture_info_hevc->sign_data_hiding_enabled_flag, ++ (uint32_t)picture_info_hevc->cabac_init_present_flag, ++ (uint32_t)picture_info_hevc->num_ref_idx_l0_default_active_minus1, ++ (uint32_t)picture_info_hevc->num_ref_idx_l1_default_active_minus1, ++ (int32_t)picture_info_hevc->init_qp_minus26, ++ (uint32_t)picture_info_hevc->constrained_intra_pred_flag, ++ (uint32_t)picture_info_hevc->transform_skip_enabled_flag, ++ (uint32_t)picture_info_hevc->cu_qp_delta_enabled_flag, ++ (uint32_t)picture_info_hevc->diff_cu_qp_delta_depth, ++ (int32_t)picture_info_hevc->pps_cb_qp_offset, ++ (int32_t)picture_info_hevc->pps_cr_qp_offset, ++ (uint32_t)picture_info_hevc->pps_slice_chroma_qp_offsets_present_flag, ++ (uint32_t)picture_info_hevc->weighted_pred_flag, ++ (uint32_t)picture_info_hevc->weighted_bipred_flag, ++ (uint32_t)picture_info_hevc->transquant_bypass_enabled_flag, ++ (uint32_t)picture_info_hevc->tiles_enabled_flag, ++ (uint32_t)picture_info_hevc->entropy_coding_sync_enabled_flag, ++ (uint32_t)picture_info_hevc->num_tile_columns_minus1, ++ (uint32_t)picture_info_hevc->num_tile_rows_minus1, ++ (uint32_t)picture_info_hevc->uniform_spacing_flag ++ ); ++ for (uint32_t i = 0; i < _VDP_TRACE_ARSIZE(picture_info_hevc->column_width_minus1); ++i) { ++ fprintf( ++ _vdp_cap_data.fp, ++ "%s%u", ++ (i == 0) ? "" : ", ", ++ (uint32_t)picture_info_hevc->column_width_minus1[i] ++ ); ++ } ++ fputs("}, {", _vdp_cap_data.fp); ++ for (uint32_t i = 0; i < _VDP_TRACE_ARSIZE(picture_info_hevc->row_height_minus1); ++i) { ++ fprintf( ++ _vdp_cap_data.fp, ++ "%s%u", ++ (i == 0) ? "" : ", ", ++ (uint32_t)picture_info_hevc->row_height_minus1[i] ++ ); ++ } ++ fputs("}, ", _vdp_cap_data.fp); ++ fprintf( ++ _vdp_cap_data.fp, ++ "%u, %u, %u, %u, %u, %d, %d, %u, %u, %u, %u, %u, %u, %u, %u, %u, %u, %d, {", ++ (uint32_t)picture_info_hevc->loop_filter_across_tiles_enabled_flag, ++ (uint32_t)picture_info_hevc->pps_loop_filter_across_slices_enabled_flag, ++ (uint32_t)picture_info_hevc->deblocking_filter_control_present_flag, ++ (uint32_t)picture_info_hevc->deblocking_filter_override_enabled_flag, ++ (uint32_t)picture_info_hevc->pps_deblocking_filter_disabled_flag, ++ (int32_t)picture_info_hevc->pps_beta_offset_div2, ++ (int32_t)picture_info_hevc->pps_tc_offset_div2, ++ (uint32_t)picture_info_hevc->lists_modification_present_flag, ++ (uint32_t)picture_info_hevc->log2_parallel_merge_level_minus2, ++ (uint32_t)picture_info_hevc->slice_segment_header_extension_present_flag, ++ (uint32_t)picture_info_hevc->IDRPicFlag, ++ (uint32_t)picture_info_hevc->RAPPicFlag, ++ (uint32_t)picture_info_hevc->CurrRpsIdx, ++ (uint32_t)picture_info_hevc->NumPocTotalCurr, ++ (uint32_t)picture_info_hevc->NumDeltaPocsOfRefRpsIdx, ++ (uint32_t)picture_info_hevc->NumShortTermPictureSliceHeaderBits, ++ (uint32_t)picture_info_hevc->NumLongTermPictureSliceHeaderBits, ++ (int32_t)picture_info_hevc->CurrPicOrderCntVal ++ ); ++ for (uint32_t i = 0; i < _VDP_TRACE_ARSIZE(picture_info_hevc->RefPics); ++i) { ++ fprintf( ++ _vdp_cap_data.fp, ++ "%s%u", ++ (i == 0) ? "" : ", ", ++ (uint32_t)picture_info_hevc->RefPics[i] ++ ); ++ } ++ fputs("}, {", _vdp_cap_data.fp); ++ for (uint32_t i = 0; i < _VDP_TRACE_ARSIZE(picture_info_hevc->PicOrderCntVal); ++i) { ++ fprintf( ++ _vdp_cap_data.fp, ++ "%s%d", ++ (i == 0) ? "" : ", ", ++ (int32_t)picture_info_hevc->PicOrderCntVal[i] ++ ); ++ } ++ fputs("}, {", _vdp_cap_data.fp); ++ for (uint32_t i = 0; i < _VDP_TRACE_ARSIZE(picture_info_hevc->IsLongTerm); ++i) { ++ fprintf( ++ _vdp_cap_data.fp, ++ "%s%u", ++ (i == 0) ? "" : ", ", ++ (uint32_t)picture_info_hevc->IsLongTerm[i] ++ ); ++ } ++ fputs("}, ", _vdp_cap_data.fp); ++ fprintf( ++ _vdp_cap_data.fp, ++ "%u, %u, %u, {", ++ (uint32_t)picture_info_hevc->NumPocStCurrBefore, ++ (uint32_t)picture_info_hevc->NumPocStCurrAfter, ++ (uint32_t)picture_info_hevc->NumPocLtCurr ++ ); ++ for (uint32_t i = 0; i < _VDP_TRACE_ARSIZE(picture_info_hevc->RefPicSetStCurrBefore); ++i) { ++ fprintf( ++ _vdp_cap_data.fp, ++ "%s%u", ++ (i == 0) ? "" : ", ", ++ (uint32_t)picture_info_hevc->RefPicSetStCurrBefore[i] ++ ); ++ } ++ fputs("}, {", _vdp_cap_data.fp); ++ for (uint32_t i = 0; i < _VDP_TRACE_ARSIZE(picture_info_hevc->RefPicSetStCurrAfter); ++i) { ++ fprintf( ++ _vdp_cap_data.fp, ++ "%s%u", ++ (i == 0) ? "" : ", ", ++ (uint32_t)picture_info_hevc->RefPicSetStCurrAfter[i] ++ ); ++ } ++ fputs("}, {", _vdp_cap_data.fp); ++ for (uint32_t i = 0; i < _VDP_TRACE_ARSIZE(picture_info_hevc->RefPicSetLtCurr); ++i) { ++ fprintf( ++ _vdp_cap_data.fp, ++ "%s%u", ++ (i == 0) ? "" : ", ", ++ (uint32_t)picture_info_hevc->RefPicSetLtCurr[i] ++ ); ++ } ++ fputs("}}", _vdp_cap_data.fp); ++ } ++ break; + case VDP_DECODER_PROFILE_HEVC_MAIN_12: + case VDP_DECODER_PROFILE_HEVC_MAIN_444: ++ case VDP_DECODER_PROFILE_HEVC_MAIN_444_10: ++ case VDP_DECODER_PROFILE_HEVC_MAIN_444_12: + { + VdpPictureInfoHEVC const * picture_info_hevc = + (VdpPictureInfoHEVC const *)picture_info; + ++ VdpPictureInfoHEVCRangeExt const * picture_info_hevc_rxt = ++ (VdpPictureInfoHEVCRangeExt const *)picture_info; ++ + fprintf( + _vdp_cap_data.fp, +- "{%u, %u, %u, %u, %u, %u, %u, %u, %u, %u, %u, %u, %u, %u, %u, {", ++ "{{%u, %u, %u, %u, %u, %u, %u, %u, %u, %u, %u, %u, %u, %u, %u, {", + (uint32_t)picture_info_hevc->chroma_format_idc, + (uint32_t)picture_info_hevc->separate_colour_plane_flag, + (uint32_t)picture_info_hevc->pic_width_in_luma_samples, +@@ -720,6 +957,48 @@ static void _vdp_cap_dump_picture_info( + ); + } + fputs("}}", _vdp_cap_data.fp); ++ fprintf( ++ _vdp_cap_data.fp, ++ "%u, %u, %u, %u, %u, %u, %u, %u, %u, %u, %u, %u, %u, %u, %u, %u, %u, %u, %u, {", ++ (uint32_t)picture_info_hevc_rxt->sps_range_extension_flag, ++ (uint32_t)picture_info_hevc_rxt->transformSkipRotationEnableFlag, ++ (uint32_t)picture_info_hevc_rxt->transformSkipContextEnableFlag, ++ (uint32_t)picture_info_hevc_rxt->implicitRdpcmEnableFlag, ++ (uint32_t)picture_info_hevc_rxt->explicitRdpcmEnableFlag, ++ (uint32_t)picture_info_hevc_rxt->extendedPrecisionProcessingFlag, ++ (uint32_t)picture_info_hevc_rxt->intraSmoothingDisabledFlag, ++ (uint32_t)picture_info_hevc_rxt->highPrecisionOffsetsEnableFlag, ++ (uint32_t)picture_info_hevc_rxt->persistentRiceAdaptationEnableFlag, ++ (uint32_t)picture_info_hevc_rxt->cabacBypassAlignmentEnableFlag, ++ (uint32_t)picture_info_hevc_rxt->intraBlockCopyEnableFlag, ++ (uint32_t)picture_info_hevc_rxt->pps_range_extension_flag, ++ (uint32_t)picture_info_hevc_rxt->log2MaxTransformSkipSize, ++ (uint32_t)picture_info_hevc_rxt->crossComponentPredictionEnableFlag, ++ (uint32_t)picture_info_hevc_rxt->chromaQpAdjustmentEnableFlag, ++ (uint32_t)picture_info_hevc_rxt->diffCuChromaQpAdjustmentDepth, ++ (uint32_t)picture_info_hevc_rxt->chromaQpAdjustmentTableSize, ++ (uint32_t)picture_info_hevc_rxt->log2SaoOffsetScaleLuma, ++ (uint32_t)picture_info_hevc_rxt->log2SaoOffsetScaleChroma ++ ); ++ fputs("}, {", _vdp_cap_data.fp); ++ for (uint32_t i = 0; i < _VDP_TRACE_ARSIZE(picture_info_hevc_rxt->cb_qp_adjustment); ++i) { ++ fprintf( ++ _vdp_cap_data.fp, ++ "%s%u", ++ (i == 0) ? "" : ", ", ++ (uint32_t)picture_info_hevc_rxt->cb_qp_adjustment[i] ++ ); ++ } ++ fputs("}, {", _vdp_cap_data.fp); ++ for (uint32_t i = 0; i < _VDP_TRACE_ARSIZE(picture_info_hevc_rxt->cr_qp_adjustment); ++i) { ++ fprintf( ++ _vdp_cap_data.fp, ++ "%s%u", ++ (i == 0) ? "" : ", ", ++ (uint32_t)picture_info_hevc_rxt->cr_qp_adjustment[i] ++ ); ++ } ++ fputs("}}", _vdp_cap_data.fp); + } + break; + case VDP_DECODER_PROFILE_VP9_PROFILE_0: +-- +GitLab + diff --git a/libvdpau.changes b/libvdpau.changes index cc48869..8364039 100644 --- a/libvdpau.changes +++ b/libvdpau.changes @@ -1,3 +1,10 @@ +------------------------------------------------------------------- +Thu Jan 14 18:33:07 UTC 2021 - Dirk Müller + +- add c5a8e7c6c8b4b36a0e4c9a4369404519262a3256.patch + e82dc4bdbb0db3ffa8c78275902738eb63aa5ca8.patch: upstream + patches to include tracing info for VP9 and HEVC + ------------------------------------------------------------------- Fri Jul 31 11:52:51 UTC 2020 - Stefan Dirsch diff --git a/libvdpau.spec b/libvdpau.spec index 3185c1f..40c63cd 100644 --- a/libvdpau.spec +++ b/libvdpau.spec @@ -1,7 +1,7 @@ # # spec file for package libvdpau # -# Copyright (c) 2020 SUSE LLC +# Copyright (c) 2021 SUSE LLC # # All modifications and additions to the file contributed by third parties # remain the property of their copyright owners, unless otherwise agreed @@ -17,22 +17,25 @@ %if 0%{?suse_version} < 1550 - %define _distconfdir /usr/etc + %define _distconfdir %{_prefix}%{_sysconfdir} %endif - Name: libvdpau Version: 1.4 Release: 0 Summary: VDPAU wrapper and trace libraries License: MIT Group: Development/Libraries/C and C++ -URL: http://www.freedesktop.org/wiki/Software/VDPAU/ +URL: https://www.freedesktop.org/wiki/Software/VDPAU/ Source: https://gitlab.freedesktop.org/vdpau/libvdpau/-/archive/%{version}/%{name}-%{version}.tar.bz2 Source1: https://gitlab.freedesktop.org/vdpau/vdpauinfo/-/archive/vdpauinfo-1.3/vdpauinfo-1.3.tar.bz2 Source2: README Source99: baselibs.conf Source100: %{name}-rpmlintrc Patch0: n_UsrEtc.patch +# PATCH-FIX-UPSTREAM +Patch1: https://gitlab.freedesktop.org/vdpau/libvdpau/-/commit/c5a8e7c6c8b4b36a0e4c9a4369404519262a3256.patch +# PATCH-FIX-UPSTREAM +Patch2: https://gitlab.freedesktop.org/vdpau/libvdpau/-/commit/e82dc4bdbb0db3ffa8c78275902738eb63aa5ca8.patch BuildRequires: autoconf BuildRequires: automake BuildRequires: doxygen @@ -87,7 +90,7 @@ Its usage is documented in the README. %prep %setup -q -b1 -%patch0 -p1 +%autopatch -p1 %build %meson @@ -112,11 +115,9 @@ popd cp %{_sourcedir}/README . %post -n libvdpau1 -p /sbin/ldconfig - %postun -n libvdpau1 -p /sbin/ldconfig %files -n libvdpau1 -%defattr(-,root,root) %dir %{_libdir}/vdpau %dir %{_distconfdir} %{_bindir}/vdpauinfo @@ -124,14 +125,12 @@ cp %{_sourcedir}/README . %{_distconfdir}/vdpau_wrapper.cfg %files -n libvdpau-devel -%defattr(-,root,root) %dir %{_libdir}/vdpau %{_includedir}/vdpau %{_libdir}/libvdpau.so %{_libdir}/pkgconfig/vdpau.pc %files -n libvdpau_trace1 -%defattr(-,root,root) %doc README %{_libdir}/vdpau/libvdpau_trace.so.*