commit libvdpau-va-gl for openSUSE:Factory

Hello community, here is the log from the commit of package libvdpau-va-gl for openSUSE:Factory checked in at 2016-03-04 19:30:29 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/libvdpau-va-gl (Old) and /work/SRC/openSUSE:Factory/.libvdpau-va-gl.new (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Package is "libvdpau-va-gl" Changes: -------- --- /work/SRC/openSUSE:Factory/libvdpau-va-gl/libvdpau-va-gl.changes 2016-02-26 00:35:46.000000000 +0100 +++ /work/SRC/openSUSE:Factory/.libvdpau-va-gl.new/libvdpau-va-gl.changes 2016-03-04 19:30:37.000000000 +0100 @@ -1,0 +2,7 @@ +Fri Mar 4 07:46:25 UTC 2016 - sor.alexei@meowr.ru + +- Update to 0.3.6: + * core: Handle Constrained Baseline profile for H.264. + * misc: Bugfixes. + +------------------------------------------------------------------- Old: ---- libvdpau-va-gl-0.3.5.tar.gz New: ---- libvdpau-va-gl-0.3.6.tar.gz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ libvdpau-va-gl.spec ++++++ --- /var/tmp/diff_new_pack.y5mEQ5/_old 2016-03-04 19:30:37.000000000 +0100 +++ /var/tmp/diff_new_pack.y5mEQ5/_new 2016-03-04 19:30:37.000000000 +0100 @@ -19,7 +19,7 @@ %define soname libvdpau_va_gl %define sover 1 Name: libvdpau-va-gl -Version: 0.3.5 +Version: 0.3.6 Release: 0 Summary: VDPAU driver with OpenGL/VAAPI backend License: LGPL-3.0+ ++++++ libvdpau-va-gl-0.3.5.tar.gz -> libvdpau-va-gl-0.3.6.tar.gz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libvdpau-va-gl-0.3.5/ChangeLog new/libvdpau-va-gl-0.3.6/ChangeLog --- old/libvdpau-va-gl-0.3.5/ChangeLog 2016-02-21 21:57:50.000000000 +0100 +++ new/libvdpau-va-gl-0.3.6/ChangeLog 2016-03-02 17:59:50.000000000 +0100 @@ -1,3 +1,9 @@ +2016-03-02 Rinat Ibragimov + + * tag v0.3.6 + * core: handle Constrained Baseline profile for H.264 + * misc: bugfixes + 2016-02-21 Rinat Ibragimov * tag: v0.3.5 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libvdpau-va-gl-0.3.5/src/CMakeLists.txt new/libvdpau-va-gl-0.3.6/src/CMakeLists.txt --- old/libvdpau-va-gl-0.3.5/src/CMakeLists.txt 2016-02-21 21:57:50.000000000 +0100 +++ new/libvdpau-va-gl-0.3.6/src/CMakeLists.txt 2016-03-02 17:59:50.000000000 +0100 @@ -49,9 +49,6 @@ target_link_libraries(${DRIVER_NAME} ${LINK_LIBRARIES}) target_link_libraries(${DRIVER_NAME}_static ${LINK_LIBRARIES}) -# add_library (xinitthreads SHARED xinitthreads.c) -# target_link_libraries (xinitthreads -lpthread -lX11) - set_target_properties(${DRIVER_NAME} PROPERTIES VERSION 1 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libvdpau-va-gl-0.3.5/src/api-video-decoder.c new/libvdpau-va-gl-0.3.6/src/api-video-decoder.c --- old/libvdpau-va-gl-0.3.5/src/api-video-decoder.c 2016-02-21 21:57:50.000000000 +0100 +++ new/libvdpau-va-gl-0.3.6/src/api-video-decoder.c 2016-03-02 17:59:50.000000000 +0100 @@ -59,22 +59,31 @@ while (! final_try) { profile = next_profile; switch (profile) { + case VDP_DECODER_PROFILE_H264_CONSTRAINED_BASELINE: + va_profile = VAProfileH264ConstrainedBaseline; + data->num_render_targets = NUM_RENDER_TARGETS_H264; + next_profile = VDP_DECODER_PROFILE_H264_BASELINE; + break; + case VDP_DECODER_PROFILE_H264_BASELINE: va_profile = VAProfileH264Baseline; data->num_render_targets = NUM_RENDER_TARGETS_H264; next_profile = VDP_DECODER_PROFILE_H264_MAIN; break; + case VDP_DECODER_PROFILE_H264_MAIN: va_profile = VAProfileH264Main; data->num_render_targets = NUM_RENDER_TARGETS_H264; next_profile = VDP_DECODER_PROFILE_H264_HIGH; break; + case VDP_DECODER_PROFILE_H264_HIGH: va_profile = VAProfileH264High; data->num_render_targets = NUM_RENDER_TARGETS_H264; // there is no more advanced profile, so it's final try final_try = 1; break; + default: traceError("error (%s): decoder %s not implemented\n", __func__, reverse_decoder_profile(profile)); @@ -349,20 +358,28 @@ *is_supported = available_profiles.mpeg2_simple; *max_level = VDP_DECODER_LEVEL_MPEG2_HL; break; + case VDP_DECODER_PROFILE_MPEG2_MAIN: *is_supported = available_profiles.mpeg2_main; *max_level = VDP_DECODER_LEVEL_MPEG2_HL; break; + case VDP_DECODER_PROFILE_H264_CONSTRAINED_BASELINE: + *is_supported = available_profiles.h264_baseline || available_profiles.h264_main; + *max_level = VDP_DECODER_LEVEL_H264_5_1; + break; + case VDP_DECODER_PROFILE_H264_BASELINE: *is_supported = available_profiles.h264_baseline; // TODO: Do underlying libva really support 5.1? *max_level = VDP_DECODER_LEVEL_H264_5_1; break; + case VDP_DECODER_PROFILE_H264_MAIN: *is_supported = available_profiles.h264_main; *max_level = VDP_DECODER_LEVEL_H264_5_1; break; + case VDP_DECODER_PROFILE_H264_HIGH: *is_supported = available_profiles.h264_high; *max_level = VDP_DECODER_LEVEL_H264_5_1; @@ -372,10 +389,12 @@ *is_supported = available_profiles.vc1_simple; *max_level = VDP_DECODER_LEVEL_VC1_SIMPLE_MEDIUM; break; + case VDP_DECODER_PROFILE_VC1_MAIN: *is_supported = available_profiles.vc1_main; *max_level = VDP_DECODER_LEVEL_VC1_MAIN_HIGH; break; + case VDP_DECODER_PROFILE_VC1_ADVANCED: *is_supported = available_profiles.vc1_advanced; *max_level = VDP_DECODER_LEVEL_VC1_ADVANCED_L4; @@ -673,9 +692,10 @@ goto quit; } - if (VDP_DECODER_PROFILE_H264_BASELINE == decoderData->profile || - VDP_DECODER_PROFILE_H264_MAIN == decoderData->profile || - VDP_DECODER_PROFILE_H264_HIGH == decoderData->profile) + if (decoderData->profile == VDP_DECODER_PROFILE_H264_CONSTRAINED_BASELINE || + decoderData->profile == VDP_DECODER_PROFILE_H264_BASELINE || + decoderData->profile == VDP_DECODER_PROFILE_H264_MAIN || + decoderData->profile == VDP_DECODER_PROFILE_H264_HIGH) { // TODO: check exit code vdpDecoderRender_h264(decoder, decoderData, dstSurfData, picture_info, diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libvdpau-va-gl-0.3.5/src/api-video-mixer.c new/libvdpau-va-gl-0.3.6/src/api-video-mixer.c --- old/libvdpau-va-gl-0.3.5/src/api-video-mixer.c 2016-02-21 21:57:50.000000000 +0100 +++ new/libvdpau-va-gl-0.3.6/src/api-video-mixer.c 2016-03-02 17:59:50.000000000 +0100 @@ -13,6 +13,7 @@ #include #include #include +#include #include "api.h" #include "trace.h" @@ -269,8 +270,28 @@ vdpVideoMixerQueryParameterValueRange(VdpDevice device, VdpVideoMixerParameter parameter, void *min_value, void *max_value) { - (void)device; (void)parameter; (void)min_value; (void)max_value; - return VDP_STATUS_NO_IMPLEMENTATION; + uint32_t uint32_value; + + switch (parameter) { + case VDP_VIDEO_MIXER_PARAMETER_VIDEO_SURFACE_WIDTH: // TODO: get actual limits + uint32_value = 16; + memcpy(min_value, &uint32_value, sizeof(uint32_value)); + uint32_value = 4096; + memcpy(max_value, &uint32_value, sizeof(uint32_value)); + return VDP_STATUS_OK; + + case VDP_VIDEO_MIXER_PARAMETER_VIDEO_SURFACE_HEIGHT: // TODO: get actual limits + uint32_value = 16; + memcpy(min_value, &uint32_value, sizeof(uint32_value)); + uint32_value = 4096; + memcpy(max_value, &uint32_value, sizeof(uint32_value)); + return VDP_STATUS_OK; + + case VDP_VIDEO_MIXER_PARAMETER_CHROMA_TYPE: // TODO + case VDP_VIDEO_MIXER_PARAMETER_LAYERS: // TODO + default: + return VDP_STATUS_NO_IMPLEMENTATION; + } } VdpStatus diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libvdpau-va-gl-0.3.5/src/api-video-surface.c new/libvdpau-va-gl-0.3.6/src/api-video-surface.c --- old/libvdpau-va-gl-0.3.5/src/api-video-surface.c 2016-02-21 21:57:50.000000000 +0100 +++ new/libvdpau-va-gl-0.3.6/src/api-video-surface.c 2016-03-02 17:59:50.000000000 +0100 @@ -134,12 +134,11 @@ glx_ctx_push_thread_local(deviceData); glDeleteTextures(1, &videoSurfData->tex_id); - GLenum gl_error = glGetError(); + glx_ctx_pop(); if (GL_NO_ERROR != gl_error) { traceError("error (%s): gl error %d\n", __func__, gl_error); - glx_ctx_pop(); handle_release(surface); return VDP_STATUS_ERROR; } @@ -162,7 +161,6 @@ free(videoSurfData->u_plane); // do not free videoSurfData->v_plane, it's just pointer into the middle of u_plane - glx_ctx_pop(); unref_device(deviceData); handle_expunge(surface); free(videoSurfData); diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libvdpau-va-gl-0.3.5/src/h264-parse.c new/libvdpau-va-gl-0.3.6/src/h264-parse.c --- old/libvdpau-va-gl-0.3.5/src/h264-parse.c 2016-02-21 21:57:50.000000000 +0100 +++ new/libvdpau-va-gl-0.3.6/src/h264-parse.c 2016-03-02 17:59:50.000000000 +0100 @@ -13,6 +13,23 @@ #include #include "h264-parse.h" +enum { + SLICE_TYPE_P = 0, + SLICE_TYPE_B = 1, + SLICE_TYPE_I = 2, + SLICE_TYPE_SP = 3, + SLICE_TYPE_SI = 4, +}; + +enum { + NAL_UNSPECIFIED = 0, + NAL_SLICE = 1, + NAL_SLICE_DATA_A = 2, + NAL_SLICE_DATA_B = 3, + NAL_SLICE_DATA_C = 4, + NAL_IDR_SLICE = 5, +}; + #define NOT_IMPLEMENTED(str) assert(0 && "not implemented" && str) #define DESCRIBE(xparam, format) fprintf(stderr, #xparam " = %" #format "\n", xparam) @@ -102,22 +119,44 @@ vasp->chroma_log2_weight_denom = sp->chroma_log2_weight_denom; vasp->luma_weight_l0_flag = sp->luma_weight_l0_flag; - for (int k = 0; k < 32; k ++) vasp->luma_weight_l0[k] = sp->luma_weight_l0[k]; - for (int k = 0; k < 32; k ++) vasp->luma_offset_l0[k] = sp->luma_offset_l0[k]; + for (int k = 0; k < 32; k ++) + vasp->luma_weight_l0[k] = sp->luma_weight_l0[k]; + + for (int k = 0; k < 32; k ++) + vasp->luma_offset_l0[k] = sp->luma_offset_l0[k]; + vasp->chroma_weight_l0_flag = sp->chroma_weight_l0_flag; - for (int k = 0; k < 32; k ++) vasp->chroma_weight_l0[k][0] = sp->chroma_weight_l0[k][0]; - for (int k = 0; k < 32; k ++) vasp->chroma_weight_l0[k][1] = sp->chroma_weight_l0[k][1]; - for (int k = 0; k < 32; k ++) vasp->chroma_offset_l0[k][0] = sp->chroma_offset_l0[k][0]; - for (int k = 0; k < 32; k ++) vasp->chroma_offset_l0[k][1] = sp->chroma_offset_l0[k][1]; + for (int k = 0; k < 32; k ++) + vasp->chroma_weight_l0[k][0] = sp->chroma_weight_l0[k][0]; + + for (int k = 0; k < 32; k ++) + vasp->chroma_weight_l0[k][1] = sp->chroma_weight_l0[k][1]; + + for (int k = 0; k < 32; k ++) + vasp->chroma_offset_l0[k][0] = sp->chroma_offset_l0[k][0]; + + for (int k = 0; k < 32; k ++) + vasp->chroma_offset_l0[k][1] = sp->chroma_offset_l0[k][1]; vasp->luma_weight_l1_flag = sp->luma_weight_l1_flag; - for (int k = 0; k < 32; k ++) vasp->luma_weight_l1[k] = sp->luma_weight_l1[k]; - for (int k = 0; k < 32; k ++) vasp->luma_offset_l1[k] = sp->luma_offset_l1[k]; + for (int k = 0; k < 32; k ++) + vasp->luma_weight_l1[k] = sp->luma_weight_l1[k]; + + for (int k = 0; k < 32; k ++) + vasp->luma_offset_l1[k] = sp->luma_offset_l1[k]; + vasp->chroma_weight_l1_flag = sp->chroma_weight_l1_flag; - for (int k = 0; k < 32; k ++) vasp->chroma_weight_l1[k][0] = sp->chroma_weight_l1[k][0]; - for (int k = 0; k < 32; k ++) vasp->chroma_weight_l1[k][1] = sp->chroma_weight_l1[k][1]; - for (int k = 0; k < 32; k ++) vasp->chroma_offset_l1[k][0] = sp->chroma_offset_l1[k][0]; - for (int k = 0; k < 32; k ++) vasp->chroma_offset_l1[k][1] = sp->chroma_offset_l1[k][1]; + for (int k = 0; k < 32; k ++) + vasp->chroma_weight_l1[k][0] = sp->chroma_weight_l1[k][0]; + + for (int k = 0; k < 32; k ++) + vasp->chroma_weight_l1[k][1] = sp->chroma_weight_l1[k][1]; + + for (int k = 0; k < 32; k ++) + vasp->chroma_offset_l1[k][0] = sp->chroma_offset_l1[k][0]; + + for (int k = 0; k < 32; k ++) + vasp->chroma_offset_l1[k][1] = sp->chroma_offset_l1[k][1]; } void @@ -130,6 +169,12 @@ p->BottomFieldOrderCnt = 0; } +struct comparison_fcn1_context { + int descending; + int what; + const VAPictureH264 *ReferenceFrames; +}; + static gint comparison_fcn_1(gconstpointer p1, gconstpointer p2, gpointer context) @@ -137,11 +182,7 @@ const int idx_1 = *(const int *)p1; const int idx_2 = *(const int *)p2; - struct { - int descending; - int what; - const VAPictureH264 *ReferenceFrames; - } *ctx = context; + struct comparison_fcn1_context *ctx = context; int value1 = 0, value2 = 0; switch (ctx->what) { @@ -178,13 +219,9 @@ fill_ref_pic_list(struct slice_parameters *sp, const VAPictureParameterBufferH264 *vapp) { int idcs_asc[32], idcs_desc[32]; - struct { - int descending; - int what; - const VAPictureH264 *ReferenceFrames; - } ctx; + struct comparison_fcn1_context ctx; - if (SLICE_TYPE_I == sp->slice_type || SLICE_TYPE_SI == sp->slice_type) + if (sp->slice_type == SLICE_TYPE_I || sp->slice_type == SLICE_TYPE_SI) return; ctx.ReferenceFrames = vapp->ReferenceFrames; @@ -198,7 +235,7 @@ frame_count ++; } - if (SLICE_TYPE_P == sp->slice_type || SLICE_TYPE_SP == sp->slice_type) { + if (sp->slice_type == SLICE_TYPE_P || sp->slice_type == SLICE_TYPE_SP) { // TODO: implement interlaced P slices ctx.what = 1; ctx.descending = 0; @@ -215,7 +252,7 @@ if (vapp->ReferenceFrames[idcs_asc[k]].flags & VA_PICTURE_H264_LONG_TERM_REFERENCE) sp->RefPicList0[ptr++] = vapp->ReferenceFrames[idcs_asc[k]]; - } else if (SLICE_TYPE_B == sp->slice_type && !vapp->pic_fields.bits.field_pic_flag) { + } else if (sp->slice_type == SLICE_TYPE_B && !vapp->pic_fields.bits.field_pic_flag) { ctx.what = 1; ctx.descending = 0; g_qsort_with_data(idcs_asc, frame_count, sizeof(idcs_asc[0]), &comparison_fcn_1, &ctx); @@ -275,13 +312,15 @@ sp.nal_ref_idc = rbsp_get_u(st, 2); sp.nal_unit_type = rbsp_get_u(st, 5); - if (14 == sp.nal_unit_type || 20 == sp.nal_unit_type) { + if (sp.nal_unit_type == 14 || sp.nal_unit_type == 20) { NOT_IMPLEMENTED("nal unit types 14 and 20"); } sp.first_mb_in_slice = rbsp_get_uev(st); sp.slice_type = rbsp_get_uev(st); - if (sp.slice_type > 4) sp.slice_type -= 5; // wrap 5-9 to 0-4 + + if (sp.slice_type > 4) + sp.slice_type -= 5; // wrap 5-9 to 0-4 // as now we know slice_type, time to fill RefPicListX fill_ref_pic_list(&sp, vapp); @@ -301,12 +340,12 @@ } } sp.idr_pic_id = 0; - if (NAL_IDR_SLICE == sp.nal_unit_type) // IDR picture + if (sp.nal_unit_type == NAL_IDR_SLICE) // IDR picture sp.idr_pic_id = rbsp_get_uev(st); sp.pic_order_cnt_lsb = 0; sp.delta_pic_order_cnt_bottom = 0; - if (0 == vapp->seq_fields.bits.pic_order_cnt_type) { + if (vapp->seq_fields.bits.pic_order_cnt_type == 0) { sp.pic_order_cnt_lsb = rbsp_get_u(st, vapp->seq_fields.bits.log2_max_pic_order_cnt_lsb_minus4 + 4); if (vapp->pic_fields.bits.pic_order_present_flag && @@ -316,8 +355,9 @@ } } - sp.delta_pic_order_cnt[0] = sp.delta_pic_order_cnt[1] = 0; - if (1 == vapp->seq_fields.bits.pic_order_cnt_type && + sp.delta_pic_order_cnt[0] = 0; + sp.delta_pic_order_cnt[1] = 0; + if (vapp->seq_fields.bits.pic_order_cnt_type == 1 && !vapp->seq_fields.bits.delta_pic_order_always_zero_flag) { sp.delta_pic_order_cnt[0] = rbsp_get_sev(st); @@ -330,28 +370,28 @@ sp.redundant_pic_cnt = rbsp_get_uev(st); sp.direct_spatial_mv_pred_flag = 0; - if (SLICE_TYPE_B == sp.slice_type) + if (sp.slice_type == SLICE_TYPE_B) sp.direct_spatial_mv_pred_flag = rbsp_get_u(st, 1); sp.num_ref_idx_active_override_flag = 0; sp.num_ref_idx_l0_active_minus1 = 0; sp.num_ref_idx_l1_active_minus1 = 0; - if (SLICE_TYPE_P == sp.slice_type || SLICE_TYPE_SP == sp.slice_type || - SLICE_TYPE_B == sp.slice_type) + if (sp.slice_type == SLICE_TYPE_P || sp.slice_type == SLICE_TYPE_SP || + sp.slice_type == SLICE_TYPE_B) { sp.num_ref_idx_l0_active_minus1 = p_num_ref_idx_l0_active_minus1; - if (SLICE_TYPE_P != sp.slice_type) - sp.num_ref_idx_l1_active_minus1 = p_num_ref_idx_l1_active_minus1; + if (sp.slice_type != SLICE_TYPE_P) + sp.num_ref_idx_l1_active_minus1 = p_num_ref_idx_l1_active_minus1; sp.num_ref_idx_active_override_flag = rbsp_get_u(st, 1); if (sp.num_ref_idx_active_override_flag) { sp.num_ref_idx_l0_active_minus1 = rbsp_get_uev(st); - if (SLICE_TYPE_B == sp.slice_type) + if (sp.slice_type == SLICE_TYPE_B) sp.num_ref_idx_l1_active_minus1 = rbsp_get_uev(st); } } - if (20 == sp.nal_unit_type) { + if (sp.nal_unit_type == 20) { NOT_IMPLEMENTED("nal unit type 20"); } else { parse_ref_pic_list_modification(st, vapp, &sp); @@ -365,8 +405,8 @@ sp.chroma_weight_l0_flag = 0; sp.chroma_weight_l1_flag = 0; if ((vapp->pic_fields.bits.weighted_pred_flag && - (SLICE_TYPE_P == sp.slice_type || SLICE_TYPE_SP == sp.slice_type)) || - (1 == vapp->pic_fields.bits.weighted_bipred_idc && SLICE_TYPE_B == sp.slice_type)) + (sp.slice_type == SLICE_TYPE_P || sp.slice_type == SLICE_TYPE_SP)) || + (vapp->pic_fields.bits.weighted_bipred_idc == 1 && sp.slice_type == SLICE_TYPE_B)) { parse_pred_weight_table(st, ChromaArrayType, &sp); } @@ -377,15 +417,17 @@ sp.cabac_init_idc = 0; if (vapp->pic_fields.bits.entropy_coding_mode_flag && - SLICE_TYPE_I != sp.slice_type && SLICE_TYPE_SI != sp.slice_type) - sp.cabac_init_idc = rbsp_get_uev(st); + sp.slice_type != SLICE_TYPE_I && sp.slice_type != SLICE_TYPE_SI) + { + sp.cabac_init_idc = rbsp_get_uev(st); + } sp.slice_qp_delta = rbsp_get_sev(st); sp.sp_for_switch_flag = 0; sp.slice_qs_delta = 0; - if (SLICE_TYPE_SP == sp.slice_type || SLICE_TYPE_SI == sp.slice_type) { - if (SLICE_TYPE_SP == sp.slice_type) + if (sp.slice_type == SLICE_TYPE_SP || sp.slice_type == SLICE_TYPE_SI) { + if (sp.slice_type == SLICE_TYPE_SP) sp.sp_for_switch_flag = rbsp_get_u(st, 1); sp.slice_qs_delta = rbsp_get_sev(st); } @@ -395,7 +437,7 @@ sp.slice_beta_offset_div2 = 0; if (vapp->pic_fields.bits.deblocking_filter_control_present_flag) { sp.disable_deblocking_filter_idc = rbsp_get_uev(st); - if (1 != sp.disable_deblocking_filter_idc) { + if (sp.disable_deblocking_filter_idc != 1) { sp.slice_alpha_c0_offset_div2 = rbsp_get_sev(st); sp.slice_beta_offset_div2 = rbsp_get_sev(st); } @@ -410,7 +452,6 @@ do_fill_va_slice_parameter_buffer(&sp, vasp, st->bits_eaten); } - static void parse_ref_pic_list_modification(rbsp_state_t *st, const VAPictureParameterBufferH264 *vapp, @@ -419,7 +460,7 @@ const int MaxFrameNum = 1 << (vapp->seq_fields.bits.log2_max_frame_num_minus4 + 4); const int MaxPicNum = (vapp->pic_fields.bits.field_pic_flag) ? 2*MaxFrameNum : MaxFrameNum; - if (2 != sp->slice_type && 4 != sp->slice_type) { + if (sp->slice_type != SLICE_TYPE_I && sp->slice_type != SLICE_TYPE_SI) { int ref_pic_list_modification_flag_l0 = rbsp_get_u(st, 1); if (ref_pic_list_modification_flag_l0) { int modification_of_pic_nums_idc; @@ -429,9 +470,9 @@ modification_of_pic_nums_idc = rbsp_get_uev(st); if (modification_of_pic_nums_idc < 2) { int abs_diff_pic_num_minus1 = rbsp_get_uev(st); - if (0 == modification_of_pic_nums_idc) { + if (modification_of_pic_nums_idc == 0) { picNumL0 -= (abs_diff_pic_num_minus1 + 1); - } else { // 1 == modification_of_pic_nums_idc + } else { // modification_of_pic_nums_idc == 1 picNumL0 += (abs_diff_pic_num_minus1 + 1); } @@ -458,10 +499,12 @@ for (int k = refIdxL0; k <= sp->num_ref_idx_l0_active_minus1 + 1; k ++) { if (sp->RefPicList0[k].frame_idx != picNumL0 && (sp->RefPicList0[k].flags & VA_PICTURE_H264_SHORT_TERM_REFERENCE)) - sp->RefPicList0[j++] = sp->RefPicList0[k]; + { + sp->RefPicList0[j++] = sp->RefPicList0[k]; + } } - } else if (2 == modification_of_pic_nums_idc) { + } else if (modification_of_pic_nums_idc == 2) { NOT_IMPLEMENTED("long"); fprintf(stderr, "long_term_pic_num = %d\n", rbsp_get_uev(st)); } @@ -471,18 +514,18 @@ } } - if (1 == sp->slice_type) { + if (sp->slice_type == SLICE_TYPE_B) { int ref_pic_list_modification_flag_l1 = rbsp_get_u(st, 1); if (ref_pic_list_modification_flag_l1) { NOT_IMPLEMENTED("ref pic list modification 1"); // TODO: implement this int modification_of_pic_nums_idc; do { modification_of_pic_nums_idc = rbsp_get_uev(st); - if (0 == modification_of_pic_nums_idc || - 1 == modification_of_pic_nums_idc) + if (modification_of_pic_nums_idc == 0 || + modification_of_pic_nums_idc == 1) { fprintf(stderr, "abs_diff_pic_num_minus1 = %d\n", rbsp_get_uev(st)); - } else if (2 == modification_of_pic_nums_idc) { + } else if (modification_of_pic_nums_idc == 2) { fprintf(stderr, "long_term_pic_num = %d\n", rbsp_get_uev(st)); } } while (modification_of_pic_nums_idc != 3); @@ -516,7 +559,7 @@ { sp->luma_log2_weight_denom = rbsp_get_uev(st); sp->chroma_log2_weight_denom = 0; - if (0 != ChromaArrayType) + if (ChromaArrayType != 0) sp->chroma_log2_weight_denom = rbsp_get_uev(st); fill_default_pred_weight_table(sp); @@ -532,7 +575,7 @@ if (default_luma_weight != sp->luma_weight_l0[k]) sp->luma_weight_l0_flag = 1; } - if (0 != ChromaArrayType) { + if (ChromaArrayType != 0) { int chroma_weight_l0_flag = rbsp_get_u(st, 1); if (chroma_weight_l0_flag) { for (int j = 0; j < 2; j ++) { @@ -545,7 +588,7 @@ } } - if (1 == sp->slice_type) { + if (sp->slice_type == SLICE_TYPE_B) { for (int k = 0; k <= sp->num_ref_idx_l1_active_minus1; k ++) { int luma_weight_l1_flag = rbsp_get_u(st, 1); if (luma_weight_l1_flag) { @@ -554,7 +597,7 @@ if (default_luma_weight != sp->luma_weight_l1[k]) sp->luma_weight_l1_flag = 1; } - if (0 != ChromaArrayType) { + if (ChromaArrayType != 0) { int chroma_weight_l1_flag = rbsp_get_u(st, 1); if (chroma_weight_l1_flag) { for (int j = 0; j < 2; j ++) { @@ -573,7 +616,7 @@ void parse_dec_ref_pic_marking(rbsp_state_t *st, struct slice_parameters *sp) { - if (NAL_IDR_SLICE == sp->nal_unit_type) { + if (sp->nal_unit_type == NAL_IDR_SLICE) { sp->no_output_of_prior_pics_flag = rbsp_get_u(st, 1); sp->long_term_reference_flag = rbsp_get_u(st, 1); } else { @@ -584,20 +627,20 @@ int memory_management_control_operation; do { memory_management_control_operation = rbsp_get_uev(st); - if (1 == memory_management_control_operation || - 3 == memory_management_control_operation) + if (memory_management_control_operation == 1 || + memory_management_control_operation == 3) { rbsp_get_uev(st); // difference_of_pic_nums_minus1 } - if (2 == memory_management_control_operation) { + if (memory_management_control_operation == 2) { rbsp_get_uev(st); // long_term_pic_num } - if (3 == memory_management_control_operation || - 6 == memory_management_control_operation) + if (memory_management_control_operation == 3 || + memory_management_control_operation == 6) { rbsp_get_uev(st); // long_term_frame_idx } - if (4 == memory_management_control_operation) { + if (memory_management_control_operation == 4) { rbsp_get_uev(st); // max_long_term_frame_idx_plus1 } } while (memory_management_control_operation != 0); diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libvdpau-va-gl-0.3.5/src/h264-parse.h new/libvdpau-va-gl-0.3.6/src/h264-parse.h --- old/libvdpau-va-gl-0.3.5/src/h264-parse.h 2016-02-21 21:57:50.000000000 +0100 +++ new/libvdpau-va-gl-0.3.6/src/h264-parse.h 2016-03-02 17:59:50.000000000 +0100 @@ -12,18 +12,6 @@ #include #include "bitstream.h" -#define SLICE_TYPE_P 0 -#define SLICE_TYPE_B 1 -#define SLICE_TYPE_I 2 -#define SLICE_TYPE_SP 3 -#define SLICE_TYPE_SI 4 - -#define NAL_UNSPECIFIED 0 -#define NAL_SLICE 1 -#define NAL_SLICE_DATA_A 2 -#define NAL_SLICE_DATA_B 3 -#define NAL_SLICE_DATA_C 4 -#define NAL_IDR_SLICE 5 void parse_slice_header(rbsp_state_t *st, const VAPictureParameterBufferH264 *vapp, diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libvdpau-va-gl-0.3.5/src/reverse-constant.c new/libvdpau-va-gl-0.3.6/src/reverse-constant.c --- old/libvdpau-va-gl-0.3.5/src/reverse-constant.c 2016-02-21 21:57:50.000000000 +0100 +++ new/libvdpau-va-gl-0.3.6/src/reverse-constant.c 2016-03-02 17:59:50.000000000 +0100 @@ -10,134 +10,74 @@ #include #include +#define CASE(q) case q: return #q + const char * reverse_func_id(VdpFuncId func_id) { switch (func_id) { - case VDP_FUNC_ID_GET_ERROR_STRING: - return "VDP_FUNC_ID_GET_ERROR_STRING"; - case VDP_FUNC_ID_GET_PROC_ADDRESS: - return "VDP_FUNC_ID_GET_PROC_ADDRESS"; - case VDP_FUNC_ID_GET_API_VERSION: - return "VDP_FUNC_ID_GET_API_VERSION"; - case VDP_FUNC_ID_GET_INFORMATION_STRING: - return "VDP_FUNC_ID_GET_INFORMATION_STRING"; - case VDP_FUNC_ID_DEVICE_DESTROY: - return "VDP_FUNC_ID_DEVICE_DESTROY"; - case VDP_FUNC_ID_GENERATE_CSC_MATRIX: - return "VDP_FUNC_ID_GENERATE_CSC_MATRIX"; - case VDP_FUNC_ID_VIDEO_SURFACE_QUERY_CAPABILITIES: - return "VDP_FUNC_ID_VIDEO_SURFACE_QUERY_CAPABILITIES"; - case VDP_FUNC_ID_VIDEO_SURFACE_QUERY_GET_PUT_BITS_Y_CB_CR_CAPABILITIES: - return "VDP_FUNC_ID_VIDEO_SURFACE_QUERY_GET_PUT_BITS_Y_CB_CR_CAPABILITIES"; - case VDP_FUNC_ID_VIDEO_SURFACE_CREATE: - return "VDP_FUNC_ID_VIDEO_SURFACE_CREATE"; - case VDP_FUNC_ID_VIDEO_SURFACE_DESTROY: - return "VDP_FUNC_ID_VIDEO_SURFACE_DESTROY"; - case VDP_FUNC_ID_VIDEO_SURFACE_GET_PARAMETERS: - return "VDP_FUNC_ID_VIDEO_SURFACE_GET_PARAMETERS"; - case VDP_FUNC_ID_VIDEO_SURFACE_GET_BITS_Y_CB_CR: - return "VDP_FUNC_ID_VIDEO_SURFACE_GET_BITS_Y_CB_CR"; - case VDP_FUNC_ID_VIDEO_SURFACE_PUT_BITS_Y_CB_CR: - return "VDP_FUNC_ID_VIDEO_SURFACE_PUT_BITS_Y_CB_CR"; - case VDP_FUNC_ID_OUTPUT_SURFACE_QUERY_CAPABILITIES: - return "VDP_FUNC_ID_OUTPUT_SURFACE_QUERY_CAPABILITIES"; - case VDP_FUNC_ID_OUTPUT_SURFACE_QUERY_GET_PUT_BITS_NATIVE_CAPABILITIES: - return "VDP_FUNC_ID_OUTPUT_SURFACE_QUERY_GET_PUT_BITS_NATIVE_CAPABILITIES"; - case VDP_FUNC_ID_OUTPUT_SURFACE_QUERY_PUT_BITS_INDEXED_CAPABILITIES: - return "VDP_FUNC_ID_OUTPUT_SURFACE_QUERY_PUT_BITS_INDEXED_CAPABILITIES"; - case VDP_FUNC_ID_OUTPUT_SURFACE_QUERY_PUT_BITS_Y_CB_CR_CAPABILITIES: - return "VDP_FUNC_ID_OUTPUT_SURFACE_QUERY_PUT_BITS_Y_CB_CR_CAPABILITIES"; - case VDP_FUNC_ID_OUTPUT_SURFACE_CREATE: - return "VDP_FUNC_ID_OUTPUT_SURFACE_CREATE"; - case VDP_FUNC_ID_OUTPUT_SURFACE_DESTROY: - return "VDP_FUNC_ID_OUTPUT_SURFACE_DESTROY"; - case VDP_FUNC_ID_OUTPUT_SURFACE_GET_PARAMETERS: - return "VDP_FUNC_ID_OUTPUT_SURFACE_GET_PARAMETERS"; - case VDP_FUNC_ID_OUTPUT_SURFACE_GET_BITS_NATIVE: - return "VDP_FUNC_ID_OUTPUT_SURFACE_GET_BITS_NATIVE"; - case VDP_FUNC_ID_OUTPUT_SURFACE_PUT_BITS_NATIVE: - return "VDP_FUNC_ID_OUTPUT_SURFACE_PUT_BITS_NATIVE"; - case VDP_FUNC_ID_OUTPUT_SURFACE_PUT_BITS_INDEXED: - return "VDP_FUNC_ID_OUTPUT_SURFACE_PUT_BITS_INDEXED"; - case VDP_FUNC_ID_OUTPUT_SURFACE_PUT_BITS_Y_CB_CR: - return "VDP_FUNC_ID_OUTPUT_SURFACE_PUT_BITS_Y_CB_CR"; - case VDP_FUNC_ID_BITMAP_SURFACE_QUERY_CAPABILITIES: - return "VDP_FUNC_ID_BITMAP_SURFACE_QUERY_CAPABILITIES"; - case VDP_FUNC_ID_BITMAP_SURFACE_CREATE: - return "VDP_FUNC_ID_BITMAP_SURFACE_CREATE"; - case VDP_FUNC_ID_BITMAP_SURFACE_DESTROY: - return "VDP_FUNC_ID_BITMAP_SURFACE_DESTROY"; - case VDP_FUNC_ID_BITMAP_SURFACE_GET_PARAMETERS: - return "VDP_FUNC_ID_BITMAP_SURFACE_GET_PARAMETERS"; - case VDP_FUNC_ID_BITMAP_SURFACE_PUT_BITS_NATIVE: - return "VDP_FUNC_ID_BITMAP_SURFACE_PUT_BITS_NATIVE"; - case VDP_FUNC_ID_OUTPUT_SURFACE_RENDER_OUTPUT_SURFACE: - return "VDP_FUNC_ID_OUTPUT_SURFACE_RENDER_OUTPUT_SURFACE"; - case VDP_FUNC_ID_OUTPUT_SURFACE_RENDER_BITMAP_SURFACE: - return "VDP_FUNC_ID_OUTPUT_SURFACE_RENDER_BITMAP_SURFACE"; - case VDP_FUNC_ID_OUTPUT_SURFACE_RENDER_VIDEO_SURFACE_LUMA: - return "VDP_FUNC_ID_OUTPUT_SURFACE_RENDER_VIDEO_SURFACE_LUMA"; - case VDP_FUNC_ID_DECODER_QUERY_CAPABILITIES: - return "VDP_FUNC_ID_DECODER_QUERY_CAPABILITIES"; - case VDP_FUNC_ID_DECODER_CREATE: - return "VDP_FUNC_ID_DECODER_CREATE"; - case VDP_FUNC_ID_DECODER_DESTROY: - return "VDP_FUNC_ID_DECODER_DESTROY"; - case VDP_FUNC_ID_DECODER_GET_PARAMETERS: - return "VDP_FUNC_ID_DECODER_GET_PARAMETERS"; - case VDP_FUNC_ID_DECODER_RENDER: - return "VDP_FUNC_ID_DECODER_RENDER"; - case VDP_FUNC_ID_VIDEO_MIXER_QUERY_FEATURE_SUPPORT: - return "VDP_FUNC_ID_VIDEO_MIXER_QUERY_FEATURE_SUPPORT"; - case VDP_FUNC_ID_VIDEO_MIXER_QUERY_PARAMETER_SUPPORT: - return "VDP_FUNC_ID_VIDEO_MIXER_QUERY_PARAMETER_SUPPORT"; - case VDP_FUNC_ID_VIDEO_MIXER_QUERY_ATTRIBUTE_SUPPORT: - return "VDP_FUNC_ID_VIDEO_MIXER_QUERY_ATTRIBUTE_SUPPORT"; - case VDP_FUNC_ID_VIDEO_MIXER_QUERY_PARAMETER_VALUE_RANGE: - return "VDP_FUNC_ID_VIDEO_MIXER_QUERY_PARAMETER_VALUE_RANGE"; - case VDP_FUNC_ID_VIDEO_MIXER_QUERY_ATTRIBUTE_VALUE_RANGE: - return "VDP_FUNC_ID_VIDEO_MIXER_QUERY_ATTRIBUTE_VALUE_RANGE"; - case VDP_FUNC_ID_VIDEO_MIXER_CREATE: - return "VDP_FUNC_ID_VIDEO_MIXER_CREATE"; - case VDP_FUNC_ID_VIDEO_MIXER_SET_FEATURE_ENABLES: - return "VDP_FUNC_ID_VIDEO_MIXER_SET_FEATURE_ENABLES"; - case VDP_FUNC_ID_VIDEO_MIXER_SET_ATTRIBUTE_VALUES: - return "VDP_FUNC_ID_VIDEO_MIXER_SET_ATTRIBUTE_VALUES"; - case VDP_FUNC_ID_VIDEO_MIXER_GET_FEATURE_SUPPORT: - return "VDP_FUNC_ID_VIDEO_MIXER_GET_FEATURE_SUPPORT"; - case VDP_FUNC_ID_VIDEO_MIXER_GET_FEATURE_ENABLES: - return "VDP_FUNC_ID_VIDEO_MIXER_GET_FEATURE_ENABLES"; - case VDP_FUNC_ID_VIDEO_MIXER_GET_PARAMETER_VALUES: - return "VDP_FUNC_ID_VIDEO_MIXER_GET_PARAMETER_VALUES"; - case VDP_FUNC_ID_VIDEO_MIXER_GET_ATTRIBUTE_VALUES: - return "VDP_FUNC_ID_VIDEO_MIXER_GET_ATTRIBUTE_VALUES"; - case VDP_FUNC_ID_VIDEO_MIXER_DESTROY: - return "VDP_FUNC_ID_VIDEO_MIXER_DESTROY"; - case VDP_FUNC_ID_VIDEO_MIXER_RENDER: - return "VDP_FUNC_ID_VIDEO_MIXER_RENDER"; - case VDP_FUNC_ID_PRESENTATION_QUEUE_TARGET_DESTROY: - return "VDP_FUNC_ID_PRESENTATION_QUEUE_TARGET_DESTROY"; - case VDP_FUNC_ID_PRESENTATION_QUEUE_CREATE: - return "VDP_FUNC_ID_PRESENTATION_QUEUE_CREATE"; - case VDP_FUNC_ID_PRESENTATION_QUEUE_DESTROY: - return "VDP_FUNC_ID_PRESENTATION_QUEUE_DESTROY"; - case VDP_FUNC_ID_PRESENTATION_QUEUE_SET_BACKGROUND_COLOR: - return "VDP_FUNC_ID_PRESENTATION_QUEUE_SET_BACKGROUND_COLOR"; - case VDP_FUNC_ID_PRESENTATION_QUEUE_GET_BACKGROUND_COLOR: - return "VDP_FUNC_ID_PRESENTATION_QUEUE_GET_BACKGROUND_COLOR"; - case VDP_FUNC_ID_PRESENTATION_QUEUE_GET_TIME: - return "VDP_FUNC_ID_PRESENTATION_QUEUE_GET_TIME"; - case VDP_FUNC_ID_PRESENTATION_QUEUE_DISPLAY: - return "VDP_FUNC_ID_PRESENTATION_QUEUE_DISPLAY"; - case VDP_FUNC_ID_PRESENTATION_QUEUE_BLOCK_UNTIL_SURFACE_IDLE: - return "VDP_FUNC_ID_PRESENTATION_QUEUE_BLOCK_UNTIL_SURFACE_IDLE"; - case VDP_FUNC_ID_PRESENTATION_QUEUE_QUERY_SURFACE_STATUS: - return "VDP_FUNC_ID_PRESENTATION_QUEUE_QUERY_SURFACE_STATUS"; - case VDP_FUNC_ID_PREEMPTION_CALLBACK_REGISTER: - return "VDP_FUNC_ID_PREEMPTION_CALLBACK_REGISTER"; - case VDP_FUNC_ID_PRESENTATION_QUEUE_TARGET_CREATE_X11: - return "VDP_FUNC_ID_PRESENTATION_QUEUE_TARGET_CREATE_X11"; + CASE(VDP_FUNC_ID_GET_ERROR_STRING); + CASE(VDP_FUNC_ID_GET_PROC_ADDRESS); + CASE(VDP_FUNC_ID_GET_API_VERSION); + CASE(VDP_FUNC_ID_GET_INFORMATION_STRING); + CASE(VDP_FUNC_ID_DEVICE_DESTROY); + CASE(VDP_FUNC_ID_GENERATE_CSC_MATRIX); + CASE(VDP_FUNC_ID_VIDEO_SURFACE_QUERY_CAPABILITIES); + CASE(VDP_FUNC_ID_VIDEO_SURFACE_QUERY_GET_PUT_BITS_Y_CB_CR_CAPABILITIES); + CASE(VDP_FUNC_ID_VIDEO_SURFACE_CREATE); + CASE(VDP_FUNC_ID_VIDEO_SURFACE_DESTROY); + CASE(VDP_FUNC_ID_VIDEO_SURFACE_GET_PARAMETERS); + CASE(VDP_FUNC_ID_VIDEO_SURFACE_GET_BITS_Y_CB_CR); + CASE(VDP_FUNC_ID_VIDEO_SURFACE_PUT_BITS_Y_CB_CR); + CASE(VDP_FUNC_ID_OUTPUT_SURFACE_QUERY_CAPABILITIES); + CASE(VDP_FUNC_ID_OUTPUT_SURFACE_QUERY_GET_PUT_BITS_NATIVE_CAPABILITIES); + CASE(VDP_FUNC_ID_OUTPUT_SURFACE_QUERY_PUT_BITS_INDEXED_CAPABILITIES); + CASE(VDP_FUNC_ID_OUTPUT_SURFACE_QUERY_PUT_BITS_Y_CB_CR_CAPABILITIES); + CASE(VDP_FUNC_ID_OUTPUT_SURFACE_CREATE); + CASE(VDP_FUNC_ID_OUTPUT_SURFACE_DESTROY); + CASE(VDP_FUNC_ID_OUTPUT_SURFACE_GET_PARAMETERS); + CASE(VDP_FUNC_ID_OUTPUT_SURFACE_GET_BITS_NATIVE); + CASE(VDP_FUNC_ID_OUTPUT_SURFACE_PUT_BITS_NATIVE); + CASE(VDP_FUNC_ID_OUTPUT_SURFACE_PUT_BITS_INDEXED); + CASE(VDP_FUNC_ID_OUTPUT_SURFACE_PUT_BITS_Y_CB_CR); + CASE(VDP_FUNC_ID_BITMAP_SURFACE_QUERY_CAPABILITIES); + CASE(VDP_FUNC_ID_BITMAP_SURFACE_CREATE); + CASE(VDP_FUNC_ID_BITMAP_SURFACE_DESTROY); + CASE(VDP_FUNC_ID_BITMAP_SURFACE_GET_PARAMETERS); + CASE(VDP_FUNC_ID_BITMAP_SURFACE_PUT_BITS_NATIVE); + CASE(VDP_FUNC_ID_OUTPUT_SURFACE_RENDER_OUTPUT_SURFACE); + CASE(VDP_FUNC_ID_OUTPUT_SURFACE_RENDER_BITMAP_SURFACE); + CASE(VDP_FUNC_ID_OUTPUT_SURFACE_RENDER_VIDEO_SURFACE_LUMA); + CASE(VDP_FUNC_ID_DECODER_QUERY_CAPABILITIES); + CASE(VDP_FUNC_ID_DECODER_CREATE); + CASE(VDP_FUNC_ID_DECODER_DESTROY); + CASE(VDP_FUNC_ID_DECODER_GET_PARAMETERS); + CASE(VDP_FUNC_ID_DECODER_RENDER); + CASE(VDP_FUNC_ID_VIDEO_MIXER_QUERY_FEATURE_SUPPORT); + CASE(VDP_FUNC_ID_VIDEO_MIXER_QUERY_PARAMETER_SUPPORT); + CASE(VDP_FUNC_ID_VIDEO_MIXER_QUERY_ATTRIBUTE_SUPPORT); + CASE(VDP_FUNC_ID_VIDEO_MIXER_QUERY_PARAMETER_VALUE_RANGE); + CASE(VDP_FUNC_ID_VIDEO_MIXER_QUERY_ATTRIBUTE_VALUE_RANGE); + CASE(VDP_FUNC_ID_VIDEO_MIXER_CREATE); + CASE(VDP_FUNC_ID_VIDEO_MIXER_SET_FEATURE_ENABLES); + CASE(VDP_FUNC_ID_VIDEO_MIXER_SET_ATTRIBUTE_VALUES); + CASE(VDP_FUNC_ID_VIDEO_MIXER_GET_FEATURE_SUPPORT); + CASE(VDP_FUNC_ID_VIDEO_MIXER_GET_FEATURE_ENABLES); + CASE(VDP_FUNC_ID_VIDEO_MIXER_GET_PARAMETER_VALUES); + CASE(VDP_FUNC_ID_VIDEO_MIXER_GET_ATTRIBUTE_VALUES); + CASE(VDP_FUNC_ID_VIDEO_MIXER_DESTROY); + CASE(VDP_FUNC_ID_VIDEO_MIXER_RENDER); + CASE(VDP_FUNC_ID_PRESENTATION_QUEUE_TARGET_DESTROY); + CASE(VDP_FUNC_ID_PRESENTATION_QUEUE_CREATE); + CASE(VDP_FUNC_ID_PRESENTATION_QUEUE_DESTROY); + CASE(VDP_FUNC_ID_PRESENTATION_QUEUE_SET_BACKGROUND_COLOR); + CASE(VDP_FUNC_ID_PRESENTATION_QUEUE_GET_BACKGROUND_COLOR); + CASE(VDP_FUNC_ID_PRESENTATION_QUEUE_GET_TIME); + CASE(VDP_FUNC_ID_PRESENTATION_QUEUE_DISPLAY); + CASE(VDP_FUNC_ID_PRESENTATION_QUEUE_BLOCK_UNTIL_SURFACE_IDLE); + CASE(VDP_FUNC_ID_PRESENTATION_QUEUE_QUERY_SURFACE_STATUS); + CASE(VDP_FUNC_ID_PREEMPTION_CALLBACK_REGISTER); + CASE(VDP_FUNC_ID_PRESENTATION_QUEUE_TARGET_CREATE_X11); default: return "Unknown"; } @@ -147,36 +87,21 @@ reverse_video_mixer_feature(VdpVideoMixerFeature mixer_feature) { switch (mixer_feature) { - case VDP_VIDEO_MIXER_FEATURE_DEINTERLACE_TEMPORAL: - return "VDP_VIDEO_MIXER_FEATURE_DEINTERLACE_TEMPORAL"; - case VDP_VIDEO_MIXER_FEATURE_DEINTERLACE_TEMPORAL_SPATIAL: - return "VDP_VIDEO_MIXER_FEATURE_DEINTERLACE_TEMPORAL_SPATIAL"; - case VDP_VIDEO_MIXER_FEATURE_INVERSE_TELECINE: - return "VDP_VIDEO_MIXER_FEATURE_INVERSE_TELECINE"; - case VDP_VIDEO_MIXER_FEATURE_NOISE_REDUCTION: - return "VDP_VIDEO_MIXER_FEATURE_NOISE_REDUCTION"; - case VDP_VIDEO_MIXER_FEATURE_SHARPNESS: - return "VDP_VIDEO_MIXER_FEATURE_SHARPNESS"; - case VDP_VIDEO_MIXER_FEATURE_LUMA_KEY: - return "VDP_VIDEO_MIXER_FEATURE_LUMA_KEY"; - case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L1: - return "VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L1"; - case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L2: - return "VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L2"; - case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L3: - return "VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L3"; - case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L4: - return "VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L4"; - case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L5: - return "VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L5"; - case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L6: - return "VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L6"; - case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L7: - return "VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L7"; - case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L8: - return "VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L8"; - case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L9: - return "VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L9"; + CASE(VDP_VIDEO_MIXER_FEATURE_DEINTERLACE_TEMPORAL); + CASE(VDP_VIDEO_MIXER_FEATURE_DEINTERLACE_TEMPORAL_SPATIAL); + CASE(VDP_VIDEO_MIXER_FEATURE_INVERSE_TELECINE); + CASE(VDP_VIDEO_MIXER_FEATURE_NOISE_REDUCTION); + CASE(VDP_VIDEO_MIXER_FEATURE_SHARPNESS); + CASE(VDP_VIDEO_MIXER_FEATURE_LUMA_KEY); + CASE(VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L1); + CASE(VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L2); + CASE(VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L3); + CASE(VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L4); + CASE(VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L5); + CASE(VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L6); + CASE(VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L7); + CASE(VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L8); + CASE(VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L9); default: return "Unknown video mixer feature"; } @@ -186,20 +111,13 @@ reverse_video_mixer_attribute(VdpVideoMixerAttribute attr) { switch (attr) { - case VDP_VIDEO_MIXER_ATTRIBUTE_BACKGROUND_COLOR: - return "VDP_VIDEO_MIXER_ATTRIBUTE_BACKGROUND_COLOR"; - case VDP_VIDEO_MIXER_ATTRIBUTE_CSC_MATRIX: - return "VDP_VIDEO_MIXER_ATTRIBUTE_CSC_MATRIX"; - case VDP_VIDEO_MIXER_ATTRIBUTE_NOISE_REDUCTION_LEVEL: - return "VDP_VIDEO_MIXER_ATTRIBUTE_NOISE_REDUCTION_LEVEL"; - case VDP_VIDEO_MIXER_ATTRIBUTE_SHARPNESS_LEVEL: - return "VDP_VIDEO_MIXER_ATTRIBUTE_SHARPNESS_LEVEL"; - case VDP_VIDEO_MIXER_ATTRIBUTE_LUMA_KEY_MIN_LUMA: - return "VDP_VIDEO_MIXER_ATTRIBUTE_LUMA_KEY_MIN_LUMA"; - case VDP_VIDEO_MIXER_ATTRIBUTE_LUMA_KEY_MAX_LUMA: - return "VDP_VIDEO_MIXER_ATTRIBUTE_LUMA_KEY_MAX_LUMA"; - case VDP_VIDEO_MIXER_ATTRIBUTE_SKIP_CHROMA_DEINTERLACE: - return "VDP_VIDEO_MIXER_ATTRIBUTE_SKIP_CHROMA_DEINTERLACE"; + CASE(VDP_VIDEO_MIXER_ATTRIBUTE_BACKGROUND_COLOR); + CASE(VDP_VIDEO_MIXER_ATTRIBUTE_CSC_MATRIX); + CASE(VDP_VIDEO_MIXER_ATTRIBUTE_NOISE_REDUCTION_LEVEL); + CASE(VDP_VIDEO_MIXER_ATTRIBUTE_SHARPNESS_LEVEL); + CASE(VDP_VIDEO_MIXER_ATTRIBUTE_LUMA_KEY_MIN_LUMA); + CASE(VDP_VIDEO_MIXER_ATTRIBUTE_LUMA_KEY_MAX_LUMA); + CASE(VDP_VIDEO_MIXER_ATTRIBUTE_SKIP_CHROMA_DEINTERLACE); default: return "Unknown video mixer attribute"; } @@ -209,16 +127,11 @@ reverse_rgba_format(VdpRGBAFormat rgba_format) { switch (rgba_format) { - case VDP_RGBA_FORMAT_B8G8R8A8: - return "VDP_RGBA_FORMAT_B8G8R8A8"; - case VDP_RGBA_FORMAT_R8G8B8A8: - return "VDP_RGBA_FORMAT_R8G8B8A8"; - case VDP_RGBA_FORMAT_R10G10B10A2: - return "VDP_RGBA_FORMAT_R10G10B10A2"; - case VDP_RGBA_FORMAT_B10G10R10A2: - return "VDP_RGBA_FORMAT_B10G10R10A2"; - case VDP_RGBA_FORMAT_A8: - return "VDP_RGBA_FORMAT_A8"; + CASE(VDP_RGBA_FORMAT_B8G8R8A8); + CASE(VDP_RGBA_FORMAT_R8G8B8A8); + CASE(VDP_RGBA_FORMAT_R10G10B10A2); + CASE(VDP_RGBA_FORMAT_B10G10R10A2); + CASE(VDP_RGBA_FORMAT_A8); default: return "Unknown RGBA format"; } @@ -228,12 +141,9 @@ reverse_chroma_type(VdpChromaType chroma_type) { switch (chroma_type) { - case VDP_CHROMA_TYPE_420: - return "VDP_CHROMA_TYPE_420"; - case VDP_CHROMA_TYPE_422: - return "VDP_CHROMA_TYPE_422"; - case VDP_CHROMA_TYPE_444: - return "VDP_CHROMA_TYPE_444"; + CASE(VDP_CHROMA_TYPE_420); + CASE(VDP_CHROMA_TYPE_422); + CASE(VDP_CHROMA_TYPE_444); default: return "Unknown chroma type"; } @@ -243,18 +153,12 @@ reverse_ycbcr_format(VdpYCbCrFormat ycbcr_format) { switch (ycbcr_format) { - case VDP_YCBCR_FORMAT_NV12: - return "VDP_YCBCR_FORMAT_NV12"; - case VDP_YCBCR_FORMAT_YV12: - return "VDP_YCBCR_FORMAT_YV12"; - case VDP_YCBCR_FORMAT_UYVY: - return "VDP_YCBCR_FORMAT_UYVY"; - case VDP_YCBCR_FORMAT_YUYV: - return "VDP_YCBCR_FORMAT_YUYV"; - case VDP_YCBCR_FORMAT_Y8U8V8A8: - return "VDP_YCBCR_FORMAT_Y8U8V8A8"; - case VDP_YCBCR_FORMAT_V8U8Y8A8: - return "VDP_YCBCR_FORMAT_V8U8Y8A8"; + CASE(VDP_YCBCR_FORMAT_NV12); + CASE(VDP_YCBCR_FORMAT_YV12); + CASE(VDP_YCBCR_FORMAT_UYVY); + CASE(VDP_YCBCR_FORMAT_YUYV); + CASE(VDP_YCBCR_FORMAT_Y8U8V8A8); + CASE(VDP_YCBCR_FORMAT_V8U8Y8A8); default: return "Unknown YCbCr format"; } @@ -264,12 +168,9 @@ reverser_video_mixer_picture_structure(VdpVideoMixerPictureStructure s) { switch (s) { - case VDP_VIDEO_MIXER_PICTURE_STRUCTURE_TOP_FIELD: - return "VDP_VIDEO_MIXER_PICTURE_STRUCTURE_TOP_FIELD"; - case VDP_VIDEO_MIXER_PICTURE_STRUCTURE_BOTTOM_FIELD: - return "VDP_VIDEO_MIXER_PICTURE_STRUCTURE_BOTTOM_FIELD"; - case VDP_VIDEO_MIXER_PICTURE_STRUCTURE_FRAME: - return "VDP_VIDEO_MIXER_PICTURE_STRUCTURE_FRAME"; + CASE(VDP_VIDEO_MIXER_PICTURE_STRUCTURE_TOP_FIELD); + CASE(VDP_VIDEO_MIXER_PICTURE_STRUCTURE_BOTTOM_FIELD); + CASE(VDP_VIDEO_MIXER_PICTURE_STRUCTURE_FRAME); default: return "Unknown video mixer picture structure"; } @@ -279,36 +180,21 @@ reverse_blend_factor(VdpOutputSurfaceRenderBlendFactor blend_factor) { switch (blend_factor) { - case VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_ZERO: - return "VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_ZERO"; - case VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_ONE: - return "VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_ONE"; - case VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_SRC_COLOR: - return "VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_SRC_COLOR"; - case VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_ONE_MINUS_SRC_COLOR: - return "VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_ONE_MINUS_SRC_COLOR"; - case VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_SRC_ALPHA: - return "VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_SRC_ALPHA"; - case VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA: - return "VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA"; - case VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_DST_ALPHA: - return "VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_DST_ALPHA"; - case VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_ONE_MINUS_DST_ALPHA: - return "VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_ONE_MINUS_DST_ALPHA"; - case VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_DST_COLOR: - return "VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_DST_COLOR"; - case VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_ONE_MINUS_DST_COLOR: - return "VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_ONE_MINUS_DST_COLOR"; - case VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_SRC_ALPHA_SATURATE: - return "VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_SRC_ALPHA_SATURATE"; - case VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_CONSTANT_COLOR: - return "VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_CONSTANT_COLOR"; - case VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR: - return "VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR"; - case VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_CONSTANT_ALPHA: - return "VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_CONSTANT_ALPHA"; - case VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA: - return "VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA"; + CASE(VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_ZERO); + CASE(VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_ONE); + CASE(VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_SRC_COLOR); + CASE(VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_ONE_MINUS_SRC_COLOR); + CASE(VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_SRC_ALPHA); + CASE(VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA); + CASE(VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_DST_ALPHA); + CASE(VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_ONE_MINUS_DST_ALPHA); + CASE(VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_DST_COLOR); + CASE(VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_ONE_MINUS_DST_COLOR); + CASE(VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_SRC_ALPHA_SATURATE); + CASE(VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_CONSTANT_COLOR); + CASE(VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR); + CASE(VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_CONSTANT_ALPHA); + CASE(VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA); default: return "Unknown blend factor"; } @@ -318,16 +204,11 @@ reverse_blend_equation(VdpOutputSurfaceRenderBlendEquation blend_equation) { switch (blend_equation) { - case VDP_OUTPUT_SURFACE_RENDER_BLEND_EQUATION_SUBTRACT: - return "VDP_OUTPUT_SURFACE_RENDER_BLEND_EQUATION_SUBTRACT"; - case VDP_OUTPUT_SURFACE_RENDER_BLEND_EQUATION_REVERSE_SUBTRACT: - return "VDP_OUTPUT_SURFACE_RENDER_BLEND_EQUATION_REVERSE_SUBTRACT"; - case VDP_OUTPUT_SURFACE_RENDER_BLEND_EQUATION_ADD: - return "VDP_OUTPUT_SURFACE_RENDER_BLEND_EQUATION_ADD"; - case VDP_OUTPUT_SURFACE_RENDER_BLEND_EQUATION_MIN: - return "VDP_OUTPUT_SURFACE_RENDER_BLEND_EQUATION_MIN"; - case VDP_OUTPUT_SURFACE_RENDER_BLEND_EQUATION_MAX: - return "VDP_OUTPUT_SURFACE_RENDER_BLEND_EQUATION_MAX"; + CASE(VDP_OUTPUT_SURFACE_RENDER_BLEND_EQUATION_SUBTRACT); + CASE(VDP_OUTPUT_SURFACE_RENDER_BLEND_EQUATION_REVERSE_SUBTRACT); + CASE(VDP_OUTPUT_SURFACE_RENDER_BLEND_EQUATION_ADD); + CASE(VDP_OUTPUT_SURFACE_RENDER_BLEND_EQUATION_MIN); + CASE(VDP_OUTPUT_SURFACE_RENDER_BLEND_EQUATION_MAX); default: return "Unknown blend equation"; } @@ -337,44 +218,26 @@ reverse_decoder_profile(VdpDecoderProfile profile) { switch (profile) { - case VDP_DECODER_PROFILE_MPEG1: - return "VDP_DECODER_PROFILE_MPEG1"; - case VDP_DECODER_PROFILE_MPEG2_SIMPLE: - return "VDP_DECODER_PROFILE_MPEG2_SIMPLE"; - case VDP_DECODER_PROFILE_MPEG2_MAIN: - return "VDP_DECODER_PROFILE_MPEG2_MAIN"; - case VDP_DECODER_PROFILE_H264_BASELINE: - return "VDP_DECODER_PROFILE_H264_BASELINE"; - case VDP_DECODER_PROFILE_H264_MAIN: - return "VDP_DECODER_PROFILE_H264_MAIN"; - case VDP_DECODER_PROFILE_H264_HIGH: - return "VDP_DECODER_PROFILE_H264_HIGH"; - case VDP_DECODER_PROFILE_VC1_SIMPLE: - return "VDP_DECODER_PROFILE_VC1_SIMPLE"; - case VDP_DECODER_PROFILE_VC1_MAIN: - return "VDP_DECODER_PROFILE_VC1_MAIN"; - case VDP_DECODER_PROFILE_VC1_ADVANCED: - return "VDP_DECODER_PROFILE_VC1_ADVANCED"; - case VDP_DECODER_PROFILE_MPEG4_PART2_SP: - return "VDP_DECODER_PROFILE_MPEG4_PART2_SP"; - case VDP_DECODER_PROFILE_MPEG4_PART2_ASP: - return "VDP_DECODER_PROFILE_MPEG4_PART2_ASP"; - case VDP_DECODER_PROFILE_DIVX4_QMOBILE: - return "VDP_DECODER_PROFILE_DIVX4_QMOBILE"; - case VDP_DECODER_PROFILE_DIVX4_MOBILE: - return "VDP_DECODER_PROFILE_DIVX4_MOBILE"; - case VDP_DECODER_PROFILE_DIVX4_HOME_THEATER: - return "VDP_DECODER_PROFILE_DIVX4_HOME_THEATER"; - case VDP_DECODER_PROFILE_DIVX4_HD_1080P: - return "VDP_DECODER_PROFILE_DIVX4_HD_1080P"; - case VDP_DECODER_PROFILE_DIVX5_QMOBILE: - return "VDP_DECODER_PROFILE_DIVX5_QMOBILE"; - case VDP_DECODER_PROFILE_DIVX5_MOBILE: - return "VDP_DECODER_PROFILE_DIVX5_MOBILE"; - case VDP_DECODER_PROFILE_DIVX5_HOME_THEATER: - return "VDP_DECODER_PROFILE_DIVX5_HOME_THEATER"; - case VDP_DECODER_PROFILE_DIVX5_HD_1080P: - return "VDP_DECODER_PROFILE_DIVX5_HD_1080P"; + CASE(VDP_DECODER_PROFILE_MPEG1); + CASE(VDP_DECODER_PROFILE_MPEG2_SIMPLE); + CASE(VDP_DECODER_PROFILE_MPEG2_MAIN); + CASE(VDP_DECODER_PROFILE_H264_CONSTRAINED_BASELINE); + CASE(VDP_DECODER_PROFILE_H264_BASELINE); + CASE(VDP_DECODER_PROFILE_H264_MAIN); + CASE(VDP_DECODER_PROFILE_H264_HIGH); + CASE(VDP_DECODER_PROFILE_VC1_SIMPLE); + CASE(VDP_DECODER_PROFILE_VC1_MAIN); + CASE(VDP_DECODER_PROFILE_VC1_ADVANCED); + CASE(VDP_DECODER_PROFILE_MPEG4_PART2_SP); + CASE(VDP_DECODER_PROFILE_MPEG4_PART2_ASP); + CASE(VDP_DECODER_PROFILE_DIVX4_QMOBILE); + CASE(VDP_DECODER_PROFILE_DIVX4_MOBILE); + CASE(VDP_DECODER_PROFILE_DIVX4_HOME_THEATER); + CASE(VDP_DECODER_PROFILE_DIVX4_HD_1080P); + CASE(VDP_DECODER_PROFILE_DIVX5_QMOBILE); + CASE(VDP_DECODER_PROFILE_DIVX5_MOBILE); + CASE(VDP_DECODER_PROFILE_DIVX5_HOME_THEATER); + CASE(VDP_DECODER_PROFILE_DIVX5_HD_1080P); default: return "Unknown decoder profile"; } @@ -384,58 +247,32 @@ reverse_status(VdpStatus status) { switch (status) { - case VDP_STATUS_OK: - return "VDP_STATUS_OK"; - case VDP_STATUS_NO_IMPLEMENTATION: - return "VDP_STATUS_NO_IMPLEMENTATION"; - case VDP_STATUS_DISPLAY_PREEMPTED: - return "VDP_STATUS_DISPLAY_PREEMPTED"; - case VDP_STATUS_INVALID_HANDLE: - return "VDP_STATUS_INVALID_HANDLE"; - case VDP_STATUS_INVALID_POINTER: - return "VDP_STATUS_INVALID_POINTER"; - case VDP_STATUS_INVALID_CHROMA_TYPE: - return "VDP_STATUS_INVALID_CHROMA_TYPE"; - case VDP_STATUS_INVALID_Y_CB_CR_FORMAT: - return "VDP_STATUS_INVALID_Y_CB_CR_FORMAT"; - case VDP_STATUS_INVALID_RGBA_FORMAT: - return "VDP_STATUS_INVALID_RGBA_FORMAT"; - case VDP_STATUS_INVALID_INDEXED_FORMAT: - return "VDP_STATUS_INVALID_INDEXED_FORMAT"; - case VDP_STATUS_INVALID_COLOR_STANDARD: - return "VDP_STATUS_INVALID_COLOR_STANDARD"; - case VDP_STATUS_INVALID_COLOR_TABLE_FORMAT: - return "VDP_STATUS_INVALID_COLOR_TABLE_FORMAT"; - case VDP_STATUS_INVALID_BLEND_FACTOR: - return "VDP_STATUS_INVALID_BLEND_FACTOR"; - case VDP_STATUS_INVALID_BLEND_EQUATION: - return "VDP_STATUS_INVALID_BLEND_EQUATION"; - case VDP_STATUS_INVALID_FLAG: - return "VDP_STATUS_INVALID_FLAG"; - case VDP_STATUS_INVALID_DECODER_PROFILE: - return "VDP_STATUS_INVALID_DECODER_PROFILE"; - case VDP_STATUS_INVALID_VIDEO_MIXER_FEATURE: - return "VDP_STATUS_INVALID_VIDEO_MIXER_FEATURE"; - case VDP_STATUS_INVALID_VIDEO_MIXER_PARAMETER: - return "VDP_STATUS_INVALID_VIDEO_MIXER_PARAMETER"; - case VDP_STATUS_INVALID_VIDEO_MIXER_ATTRIBUTE: - return "VDP_STATUS_INVALID_VIDEO_MIXER_ATTRIBUTE"; - case VDP_STATUS_INVALID_VIDEO_MIXER_PICTURE_STRUCTURE: - return "VDP_STATUS_INVALID_VIDEO_MIXER_PICTURE_STRUCTURE"; - case VDP_STATUS_INVALID_FUNC_ID: - return "VDP_STATUS_INVALID_FUNC_ID"; - case VDP_STATUS_INVALID_SIZE: - return "VDP_STATUS_INVALID_SIZE"; - case VDP_STATUS_INVALID_VALUE: - return "VDP_STATUS_INVALID_VALUE"; - case VDP_STATUS_INVALID_STRUCT_VERSION: - return "VDP_STATUS_INVALID_STRUCT_VERSION"; - case VDP_STATUS_RESOURCES: - return "VDP_STATUS_RESOURCES"; - case VDP_STATUS_HANDLE_DEVICE_MISMATCH: - return "VDP_STATUS_HANDLE_DEVICE_MISMATCH"; - case VDP_STATUS_ERROR: - return "VDP_STATUS_ERROR"; + CASE(VDP_STATUS_OK); + CASE(VDP_STATUS_NO_IMPLEMENTATION); + CASE(VDP_STATUS_DISPLAY_PREEMPTED); + CASE(VDP_STATUS_INVALID_HANDLE); + CASE(VDP_STATUS_INVALID_POINTER); + CASE(VDP_STATUS_INVALID_CHROMA_TYPE); + CASE(VDP_STATUS_INVALID_Y_CB_CR_FORMAT); + CASE(VDP_STATUS_INVALID_RGBA_FORMAT); + CASE(VDP_STATUS_INVALID_INDEXED_FORMAT); + CASE(VDP_STATUS_INVALID_COLOR_STANDARD); + CASE(VDP_STATUS_INVALID_COLOR_TABLE_FORMAT); + CASE(VDP_STATUS_INVALID_BLEND_FACTOR); + CASE(VDP_STATUS_INVALID_BLEND_EQUATION); + CASE(VDP_STATUS_INVALID_FLAG); + CASE(VDP_STATUS_INVALID_DECODER_PROFILE); + CASE(VDP_STATUS_INVALID_VIDEO_MIXER_FEATURE); + CASE(VDP_STATUS_INVALID_VIDEO_MIXER_PARAMETER); + CASE(VDP_STATUS_INVALID_VIDEO_MIXER_ATTRIBUTE); + CASE(VDP_STATUS_INVALID_VIDEO_MIXER_PICTURE_STRUCTURE); + CASE(VDP_STATUS_INVALID_FUNC_ID); + CASE(VDP_STATUS_INVALID_SIZE); + CASE(VDP_STATUS_INVALID_VALUE); + CASE(VDP_STATUS_INVALID_STRUCT_VERSION); + CASE(VDP_STATUS_RESOURCES); + CASE(VDP_STATUS_HANDLE_DEVICE_MISMATCH); + CASE(VDP_STATUS_ERROR); default: return "Unknown VDP error"; } @@ -445,14 +282,10 @@ reverse_indexed_format(VdpIndexedFormat indexed_format) { switch (indexed_format) { - case VDP_INDEXED_FORMAT_A4I4: - return "VDP_INDEXED_FORMAT_A4I4"; - case VDP_INDEXED_FORMAT_I4A4: - return "VDP_INDEXED_FORMAT_I4A4"; - case VDP_INDEXED_FORMAT_A8I8: - return "VDP_INDEXED_FORMAT_A8I8"; - case VDP_INDEXED_FORMAT_I8A8: - return "VDP_INDEXED_FORMAT_I8A8"; + CASE(VDP_INDEXED_FORMAT_A4I4); + CASE(VDP_INDEXED_FORMAT_I4A4); + CASE(VDP_INDEXED_FORMAT_A8I8); + CASE(VDP_INDEXED_FORMAT_I8A8); default: return "Unknown indexed format"; } @@ -462,8 +295,7 @@ reverse_color_table_format(VdpColorTableFormat color_table_format) { switch (color_table_format) { - case VDP_COLOR_TABLE_FORMAT_B8G8R8X8: - return "VDP_COLOR_TABLE_FORMAT_B8G8R8X8"; + CASE(VDP_COLOR_TABLE_FORMAT_B8G8R8X8); default: return "Unknown color table format"; } @@ -473,14 +305,10 @@ reverse_video_mixer_parameter(VdpVideoMixerParameter parameter) { switch (parameter) { - case VDP_VIDEO_MIXER_PARAMETER_VIDEO_SURFACE_WIDTH: - return "VDP_VIDEO_MIXER_PARAMETER_VIDEO_SURFACE_WIDTH"; - case VDP_VIDEO_MIXER_PARAMETER_VIDEO_SURFACE_HEIGHT: - return "VDP_VIDEO_MIXER_PARAMETER_VIDEO_SURFACE_HEIGHT"; - case VDP_VIDEO_MIXER_PARAMETER_CHROMA_TYPE: - return "VDP_VIDEO_MIXER_PARAMETER_CHROMA_TYPE"; - case VDP_VIDEO_MIXER_PARAMETER_LAYERS: - return "VDP_VIDEO_MIXER_PARAMETER_LAYERS"; + CASE(VDP_VIDEO_MIXER_PARAMETER_VIDEO_SURFACE_WIDTH); + CASE(VDP_VIDEO_MIXER_PARAMETER_VIDEO_SURFACE_HEIGHT); + CASE(VDP_VIDEO_MIXER_PARAMETER_CHROMA_TYPE); + CASE(VDP_VIDEO_MIXER_PARAMETER_LAYERS); default: return "Unknown video mixer parameter"; } @@ -490,12 +318,9 @@ reverse_color_standard(VdpColorStandard color_standard) { switch (color_standard) { - case VDP_COLOR_STANDARD_ITUR_BT_601: - return "VDP_COLOR_STANDARD_ITUR_BT_601"; - case VDP_COLOR_STANDARD_ITUR_BT_709: - return "VDP_COLOR_STANDARD_ITUR_BT_709"; - case VDP_COLOR_STANDARD_SMPTE_240M: - return "VDP_COLOR_STANDARD_SMPTE_240M"; + CASE(VDP_COLOR_STANDARD_ITUR_BT_601); + CASE(VDP_COLOR_STANDARD_ITUR_BT_709); + CASE(VDP_COLOR_STANDARD_SMPTE_240M); default: return "Unknown color standard"; } @@ -505,11 +330,11 @@ reverse_output_surface_render_rotate(int flags) { switch (flags & 3) { - case VDP_OUTPUT_SURFACE_RENDER_ROTATE_0: return "VDP_OUTPUT_SURFACE_RENDER_ROTATE_0"; - case VDP_OUTPUT_SURFACE_RENDER_ROTATE_90: return "VDP_OUTPUT_SURFACE_RENDER_ROTATE_90"; - case VDP_OUTPUT_SURFACE_RENDER_ROTATE_180: return "VDP_OUTPUT_SURFACE_RENDER_ROTATE_180"; + CASE(VDP_OUTPUT_SURFACE_RENDER_ROTATE_0); + CASE(VDP_OUTPUT_SURFACE_RENDER_ROTATE_90); + CASE(VDP_OUTPUT_SURFACE_RENDER_ROTATE_180); + CASE(VDP_OUTPUT_SURFACE_RENDER_ROTATE_270); default: - // The only possible case execution get here is VDP_OUTPUT_SURFACE_RENDER_ROTATE_270 case. - return "VDP_OUTPUT_SURFACE_RENDER_ROTATE_270"; + return "Unknown rotate"; } } diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libvdpau-va-gl-0.3.5/src/trace.c new/libvdpau-va-gl-0.3.6/src/trace.c --- old/libvdpau-va-gl-0.3.5/src/trace.c 2016-02-21 21:57:50.000000000 +0100 +++ new/libvdpau-va-gl-0.3.6/src/trace.c 2016-03-02 17:59:50.000000000 +0100 @@ -125,8 +125,8 @@ if (!trace_enabled) goto skip; traceCallHook(VDP_FUNC_ID_DECODER_QUERY_CAPABILITIES, 0, NULL); - fprintf(tlog, "%s%s VdpDecoderQueryCapabilities device=%d, profile=%s\n", - trace_header, impl_state, device, reverse_decoder_profile(profile)); + fprintf(tlog, "%s%s VdpDecoderQueryCapabilities device=%d, profile=%s(%d)\n", + trace_header, impl_state, device, reverse_decoder_profile(profile), profile); skip:; VdpStatus ret = vdpDecoderQueryCapabilities(device, profile, is_supported, max_level, max_macroblocks, max_width, max_height); @@ -458,7 +458,7 @@ VdpVideoMixerParameter parameter, void *min_value, void *max_value) { - const char *impl_state = "{zilch}"; + const char *impl_state = "{part}"; if (!trace_enabled) goto skip; traceCallHook(VDP_FUNC_ID_VIDEO_MIXER_QUERY_PARAMETER_VALUE_RANGE, 0, NULL); diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libvdpau-va-gl-0.3.5/src/xinitthreads.c new/libvdpau-va-gl-0.3.6/src/xinitthreads.c --- old/libvdpau-va-gl-0.3.5/src/xinitthreads.c 2016-02-21 21:57:50.000000000 +0100 +++ new/libvdpau-va-gl-0.3.6/src/xinitthreads.c 1970-01-01 01:00:00.000000000 +0100 @@ -1,19 +0,0 @@ -/* - * Copyright 2013-2014 Rinat Ibragimov - * - * This file is part of libvdpau-va-gl - * - * libvdpau-va-gl is distributed under the terms of the LGPLv3. See COPYING for details. - */ - -#include -#include - -__attribute__((constructor)) -static -void -library_constructor(void) -{ - XInitThreads(); - printf("XInitThreads()\n"); -}