diff options
Diffstat (limited to 'trace/vdpau_trace.cpp')
| -rw-r--r-- | trace/vdpau_trace.cpp | 4293 |
1 files changed, 4293 insertions, 0 deletions
diff --git a/trace/vdpau_trace.cpp b/trace/vdpau_trace.cpp new file mode 100644 index 0000000..ae43973 --- /dev/null +++ b/trace/vdpau_trace.cpp @@ -0,0 +1,4293 @@ +/* + * Copyright (c) 2008-2009 NVIDIA, Corporation + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +#define __STDC_FORMAT_MACROS +#define __STDC_LIMIT_MACROS +#include <inttypes.h> + +#include <dlfcn.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <vdpau/vdpau_x11.h> + +#define _VDP_TRACE_ARSIZE(_x_) ((sizeof (_x_)) / (sizeof ((_x_)[0]))) + +#if DEBUG + +static void _vdp_trace_error_breakpoint(char const * file, int line, char const * function) +{ + fprintf(stderr, "VDPAU trace:: Error detected at %s:%d %s()\n", file, line, function); +} + +#define _VDP_TRACE_ERROR_BREAKPOINT() _vdp_trace_error_breakpoint(__FILE__, __LINE__, __FUNCTION__) + +#else + +#define _VDP_TRACE_ERROR_BREAKPOINT() + +#endif + +#define LEVEL_PARAMS 1 +#define LEVEL_DATA 2 + +struct _VdpCapData { + void * dll; + + int level; + FILE * fp; + + VdpDevice vdp_device; + VdpGetProcAddress * vdp_get_proc_address; + + VdpGetErrorString * vdp_get_error_string; + VdpGetApiVersion * vdp_get_api_version; + VdpGetInformationString * vdp_get_information_string; + VdpDeviceDestroy * vdp_device_destroy; + VdpGenerateCSCMatrix * vdp_generate_csc_matrix; + VdpVideoSurfaceQueryCapabilities * vdp_video_surface_query_capabilities; + VdpVideoSurfaceQueryGetPutBitsYCbCrCapabilities * vdp_video_surface_query_get_put_bits_y_cb_cr_capabilities; + VdpVideoSurfaceCreate * vdp_video_surface_create; + VdpVideoSurfaceDestroy * vdp_video_surface_destroy; + VdpVideoSurfaceGetParameters * vdp_video_surface_get_parameters; + VdpVideoSurfaceGetBitsYCbCr * vdp_video_surface_get_bits_y_cb_cr; + VdpVideoSurfacePutBitsYCbCr * vdp_video_surface_put_bits_y_cb_cr; + VdpOutputSurfaceQueryCapabilities * vdp_output_surface_query_capabilities; + VdpOutputSurfaceQueryGetPutBitsNativeCapabilities * vdp_output_surface_query_get_put_bits_native_capabilities; + VdpOutputSurfaceQueryPutBitsIndexedCapabilities * vdp_output_surface_query_put_bits_indexed_capabilities; + VdpOutputSurfaceQueryPutBitsYCbCrCapabilities * vdp_output_surface_query_put_bits_y_cb_cr_capabilities; + VdpOutputSurfaceCreate * vdp_output_surface_create; + VdpOutputSurfaceDestroy * vdp_output_surface_destroy; + VdpOutputSurfaceGetParameters * vdp_output_surface_get_parameters; + VdpOutputSurfaceGetBitsNative * vdp_output_surface_get_bits_native; + VdpOutputSurfacePutBitsNative * vdp_output_surface_put_bits_native; + VdpOutputSurfacePutBitsIndexed * vdp_output_surface_put_bits_indexed; + VdpOutputSurfacePutBitsYCbCr * vdp_output_surface_put_bits_y_cb_cr; + VdpBitmapSurfaceQueryCapabilities * vdp_bitmap_surface_query_capabilities; + VdpBitmapSurfaceCreate * vdp_bitmap_surface_create; + VdpBitmapSurfaceDestroy * vdp_bitmap_surface_destroy; + VdpBitmapSurfaceGetParameters * vdp_bitmap_surface_get_parameters; + VdpBitmapSurfacePutBitsNative * vdp_bitmap_surface_put_bits_native; + VdpOutputSurfaceRenderOutputSurface * vdp_output_surface_render_output_surface; + VdpOutputSurfaceRenderBitmapSurface * vdp_output_surface_render_bitmap_surface; + VdpDecoderQueryCapabilities * vdp_decoder_query_capabilities; + VdpDecoderCreate * vdp_decoder_create; + VdpDecoderDestroy * vdp_decoder_destroy; + VdpDecoderGetParameters * vdp_decoder_get_parameters; + VdpDecoderRender * vdp_decoder_render; + VdpVideoMixerQueryFeatureSupport * vdp_video_mixer_query_feature_support; + VdpVideoMixerQueryParameterSupport * vdp_video_mixer_query_parameter_support; + VdpVideoMixerQueryAttributeSupport * vdp_video_mixer_query_attribute_support; + VdpVideoMixerQueryParameterValueRange * vdp_video_mixer_query_parameter_value_range; + VdpVideoMixerQueryAttributeValueRange * vdp_video_mixer_query_attribute_value_range; + VdpVideoMixerCreate * vdp_video_mixer_create; + VdpVideoMixerSetFeatureEnables * vdp_video_mixer_set_feature_enables; + VdpVideoMixerSetAttributeValues * vdp_video_mixer_set_attribute_values; + VdpVideoMixerGetFeatureSupport * vdp_video_mixer_get_feature_support; + VdpVideoMixerGetFeatureEnables * vdp_video_mixer_get_feature_enables; + VdpVideoMixerGetParameterValues * vdp_video_mixer_get_parameter_values; + VdpVideoMixerGetAttributeValues * vdp_video_mixer_get_attribute_values; + VdpVideoMixerDestroy * vdp_video_mixer_destroy; + VdpVideoMixerRender * vdp_video_mixer_render; + VdpPresentationQueueTargetDestroy * vdp_presentation_queue_target_destroy; + VdpPresentationQueueCreate * vdp_presentation_queue_create; + VdpPresentationQueueDestroy * vdp_presentation_queue_destroy; + VdpPresentationQueueSetBackgroundColor * vdp_presentation_queue_set_background_color; + VdpPresentationQueueGetBackgroundColor * vdp_presentation_queue_get_background_color; + VdpPresentationQueueGetTime * vdp_presentation_queue_get_time; + VdpPresentationQueueDisplay * vdp_presentation_queue_display; + VdpPresentationQueueBlockUntilSurfaceIdle * vdp_presentation_queue_block_until_surface_idle; + VdpPresentationQueueQuerySurfaceStatus * vdp_presentation_queue_query_surface_status; + VdpPreemptionCallbackRegister * vdp_preemption_callback_register; + VdpPresentationQueueTargetCreateX11 * vdp_presentation_queue_target_create_x11; +}; + +static _VdpCapData _vdp_cap_data; + +template<class T> static inline T const delta(T const & a, T const & b) +{ + if (a < b) { + return b - a; + } + else { + return a - b; + } +} + +static void _vdp_cap_dump_procamp(VdpProcamp * procamp) +{ + if (!procamp) { + fprintf(_vdp_cap_data.fp, "NULL"); + return; + } + + fprintf( + _vdp_cap_data.fp, + "{(ver=%d)%s %f, %f, %f, %f}", + procamp->struct_version, + (procamp->struct_version > 0) + ? "(unsupported; cannot dump all fields)" + : "", + procamp->brightness, + procamp->contrast, + procamp->saturation, + procamp->hue + ); +} + +static void _vdp_cap_dump_color( + VdpColor const * color +) +{ + if (!color) { + fputs("NULL", _vdp_cap_data.fp); + return; + } + + fprintf( + _vdp_cap_data.fp, + "{%f, %f, %f, %f}", + color->red, + color->green, + color->blue, + color->alpha + ); +} + +static void _vdp_cap_dump_point( + VdpPoint const * point +) +{ + if (!point) { + fprintf(_vdp_cap_data.fp, "NULL"); + return; + } + + fprintf( + _vdp_cap_data.fp, + "{%u, %u}", + point->x, + point->y + ); +} + +static void _vdp_cap_dump_rect( + VdpRect const * rect +) +{ + if (!rect) { + fprintf(_vdp_cap_data.fp, "NULL"); + return; + } + + fprintf( + _vdp_cap_data.fp, + "{%u, %u, %u, %u}", + rect->x0, + rect->y0, + rect->x1, + rect->y1 + ); +} + +static void _vdp_cap_dump_csc_matrix( + VdpCSCMatrix const * matrix +) +{ + if (!matrix) { + fprintf(_vdp_cap_data.fp, "NULL"); + return; + } + + fprintf( + _vdp_cap_data.fp, + "{{%f, %f, %f, %f}, {%f, %f, %f, %f}, {%f, %f, %f, %f}}", + (*matrix)[0][0], + (*matrix)[0][1], + (*matrix)[0][2], + (*matrix)[0][3], + (*matrix)[1][0], + (*matrix)[1][1], + (*matrix)[1][2], + (*matrix)[1][3], + (*matrix)[2][0], + (*matrix)[2][1], + (*matrix)[2][2], + (*matrix)[2][3] + ); +} + +static void _vdp_cap_dump_blend_state( + VdpOutputSurfaceRenderBlendState const * blend_state +) +{ + if (!blend_state) { + fprintf(_vdp_cap_data.fp, "NULL"); + return; + } + + fprintf( + _vdp_cap_data.fp, + "{(ver=%d)%s %u, %u, %u, %u, %u, %u, ", + blend_state->struct_version, + (blend_state->struct_version > 0) + ? "(unsupported; cannot dump all fields)" + : "", + blend_state->blend_factor_source_color, + blend_state->blend_factor_destination_color, + blend_state->blend_factor_source_alpha, + blend_state->blend_factor_destination_alpha, + blend_state->blend_equation_color, + blend_state->blend_equation_alpha + ); + _vdp_cap_dump_color(&(blend_state->blend_constant)); + fputs("}", _vdp_cap_data.fp); +} + +static void _vdp_cap_dump_picture_info( + VdpDecoderProfile profile, + VdpPictureInfo const * picture_info +) +{ + VdpPictureInfoMPEG1Or2 const * picture_info_mpeg1or2; + + switch (profile) { + case VDP_DECODER_PROFILE_MPEG1: + case VDP_DECODER_PROFILE_MPEG2_SIMPLE: + case VDP_DECODER_PROFILE_MPEG2_MAIN: + picture_info_mpeg1or2 = (VdpPictureInfoMPEG1Or2 const *)picture_info; + + fprintf( + _vdp_cap_data.fp, + "{%u, %u, %u, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, {{%d, %d}, {%d, %d}}, {", + picture_info_mpeg1or2->forward_reference, + picture_info_mpeg1or2->backward_reference, + picture_info_mpeg1or2->slice_count, + picture_info_mpeg1or2->picture_structure, + picture_info_mpeg1or2->picture_coding_type, + picture_info_mpeg1or2->intra_dc_precision, + picture_info_mpeg1or2->frame_pred_frame_dct, + picture_info_mpeg1or2->concealment_motion_vectors, + picture_info_mpeg1or2->intra_vlc_format, + picture_info_mpeg1or2->alternate_scan, + picture_info_mpeg1or2->q_scale_type, + picture_info_mpeg1or2->top_field_first, + picture_info_mpeg1or2->full_pel_forward_vector, + picture_info_mpeg1or2->full_pel_backward_vector, + picture_info_mpeg1or2->f_code[0][0], + picture_info_mpeg1or2->f_code[0][1], + picture_info_mpeg1or2->f_code[1][0], + picture_info_mpeg1or2->f_code[1][1] + ); + for (uint32_t i = 0; i < _VDP_TRACE_ARSIZE(picture_info_mpeg1or2->intra_quantizer_matrix); ++i) { + fprintf( + _vdp_cap_data.fp, + "%s%d", + (i == 0) ? "" : ", ", + picture_info_mpeg1or2->intra_quantizer_matrix[i] + ); + } + fputs("}, {", _vdp_cap_data.fp); + for (uint32_t i = 0; i < _VDP_TRACE_ARSIZE(picture_info_mpeg1or2->non_intra_quantizer_matrix); ++i) { + fprintf( + _vdp_cap_data.fp, + "%s%d", + (i == 0) ? "" : ", ", + picture_info_mpeg1or2->non_intra_quantizer_matrix[i] + ); + } + fputs("}}", _vdp_cap_data.fp); + break; + 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: + // FIXME: Dump all the other types too. + // For now, just deliberately fall through + default: + fputs("{...}", _vdp_cap_data.fp); + break; + } +} + +static void _vdp_cap_dump_video_mixer_parameter_value( + VdpVideoMixerParameter parameter, + void const * value +) +{ + switch (parameter) { + 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: + if (!value) { + fputs("???", _vdp_cap_data.fp); + } + else { + fprintf(_vdp_cap_data.fp, "%u", *(uint32_t const *)value); + } + break; + default: + fputs("???", _vdp_cap_data.fp); + break; + } +} + +static void _vdp_cap_dump_video_mixer_attribute_value( + VdpVideoMixerAttribute attribute, + void const * value, + bool get_operation +) +{ + if (!value) { + fputs("NULL", _vdp_cap_data.fp); + return; + } + + switch (attribute) { + case VDP_VIDEO_MIXER_ATTRIBUTE_BACKGROUND_COLOR: + _vdp_cap_dump_color((VdpColor const *)value); + break; + case VDP_VIDEO_MIXER_ATTRIBUTE_CSC_MATRIX: + { + // We don't really need/want to cast away the const here, + // but the buggy compiler thinks we are, even when we don't. + // The const_cast tells it to quit complaining. + VdpCSCMatrix * ptr; + + // For some objects, the "default" value is a NULL pointer. + // So, VdpVideoMixerGetAttributeValues expects a double pointer to + // the value, so it can either fill in the value, or NULL out the + // pointer. + if (get_operation) { + VdpCSCMatrix * * dptr = (VdpCSCMatrix * *)const_cast<void *>(value); + if (!dptr) { + return; + } + ptr = *dptr; + } + else { + ptr = (VdpCSCMatrix *)const_cast<void *>(value); + } + _vdp_cap_dump_csc_matrix(ptr); + } + break; + 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: + fprintf(_vdp_cap_data.fp, "%f", *(float const *)value); + break; + default: + fputs("???", _vdp_cap_data.fp); + break; + } +} + +static void _vdp_cap_dump_uint8_t_stream( + uint32_t count, + uint8_t const * values +) +{ + if (!values) { + fputs("NULL", _vdp_cap_data.fp); + return; + } + + fputs("{", _vdp_cap_data.fp); + while (count) { + fprintf( + _vdp_cap_data.fp, + "%02x", + values[0] + ); + + --count; + ++values; + } + fputs("}", _vdp_cap_data.fp); +} + +static void _vdp_cap_dump_uint32_t_stream( + uint32_t count, + uint32_t const * values +) +{ + if (!values) { + fputs("NULL", _vdp_cap_data.fp); + return; + } + + fputs("{", _vdp_cap_data.fp); + while (count) { + fprintf( + _vdp_cap_data.fp, + "%08x%s", + values[0], + (count > 1) ? " " : "" + ); + + --count; + ++values; + } + fputs("}", _vdp_cap_data.fp); +} + +struct _VdpcapPlane { + void const * data; + uint32_t pitch; + uint32_t item_count; + uint32_t item_size; + uint32_t lines; +}; + +typedef void _VdpcapPlaneDumper(uint32_t count, void const * values); + +static void _vdp_cap_dump_plane_list( + uint32_t plane_count, + _VdpcapPlane const * planes +) +{ + if (!planes) { + fputs("NULL", _vdp_cap_data.fp); + return; + } + + fputs("{", _vdp_cap_data.fp); + while (plane_count) { + uint32_t lines = planes[0].lines; + + _VdpcapPlaneDumper * dumper; + if (planes[0].item_size == 4) { + dumper = (_VdpcapPlaneDumper*)_vdp_cap_dump_uint32_t_stream; + } + else { + dumper = (_VdpcapPlaneDumper*)_vdp_cap_dump_uint8_t_stream; + } + + fputs("{", _vdp_cap_data.fp); + uint8_t const * ptr = (uint8_t const *)planes[0].data; + while (lines) { + dumper(planes[0].item_count, ptr); + if (lines > 1) { + fputs(", ", _vdp_cap_data.fp); + } + + ptr += planes[0].pitch; + --lines; + } + fputs("}", _vdp_cap_data.fp); + + if (plane_count > 1) { + fputs(", ", _vdp_cap_data.fp); + } + + --plane_count; + ++planes; + } + fputs("}", _vdp_cap_data.fp); +} + +static bool _vdp_cap_init_planes_for_ycbcr_format( + uint32_t * plane_count, + _VdpcapPlane * planes, + VdpYCbCrFormat format, + uint32_t region_width, + uint32_t region_height +) +{ + switch (format) { + case VDP_YCBCR_FORMAT_NV12: + if (*plane_count < 2) { + return false; + } + *plane_count = 2; + planes[0].item_size = 1; + planes[0].item_count = region_width; + planes[0].lines = region_height; + planes[1].item_size = 1; + planes[1].item_count = region_width; + planes[1].lines = region_height / 2; + break; + case VDP_YCBCR_FORMAT_YV12: + if (*plane_count < 3) { + return false; + } + *plane_count = 3; + planes[0].item_size = 1; + planes[0].item_count = region_width; + planes[0].lines = region_height; + planes[1].item_size = 1; + planes[1].item_count = region_width / 2; + planes[1].lines = region_height / 2; + planes[2].item_size = 1; + planes[2].item_count = region_width / 2; + planes[2].lines = region_height / 2; + break; + case VDP_YCBCR_FORMAT_UYVY: + case VDP_YCBCR_FORMAT_YUYV: + if (*plane_count < 1) { + return false; + } + *plane_count = 1; + planes[0].item_size = 1; + planes[0].item_count = region_width * 2; + planes[0].lines = region_height; + break; + case VDP_YCBCR_FORMAT_Y8U8V8A8: + case VDP_YCBCR_FORMAT_V8U8Y8A8: + if (*plane_count < 1) { + return false; + } + *plane_count = 1; + planes[0].item_size = 4; + planes[0].item_count = region_width; + planes[0].lines = region_height; + break; + default: + return false; + } + + return true; +} + +static bool _vdp_cap_init_planes_for_rgba_format( + uint32_t * plane_count, + _VdpcapPlane * planes, + VdpRGBAFormat format, + uint32_t region_width, + uint32_t region_height +) +{ + switch (format) { + case VDP_RGBA_FORMAT_B8G8R8A8: + case VDP_RGBA_FORMAT_R8G8B8A8: + case VDP_RGBA_FORMAT_R10G10B10A2: + case VDP_RGBA_FORMAT_B10G10R10A2: + if (*plane_count < 1) { + return false; + } + *plane_count = 1; + planes[0].item_size = 4; + break; + case VDP_RGBA_FORMAT_A8: + if (*plane_count < 1) { + return false; + } + *plane_count = 1; + planes[0].item_size = 1; + break; + default: + return false; + } + planes[0].item_count = region_width; + planes[0].lines = region_height; + + return true; +} + +static bool _vdp_cap_init_planes_for_indexed_format( + uint32_t * plane_count, + _VdpcapPlane * planes, + VdpIndexedFormat format, + uint32_t region_width, + uint32_t region_height +) +{ + uint32_t width_multiplier; + + switch (format) { + case VDP_INDEXED_FORMAT_A4I4: + case VDP_INDEXED_FORMAT_I4A4: + width_multiplier = 1; + break; + case VDP_INDEXED_FORMAT_A8I8: + case VDP_INDEXED_FORMAT_I8A8: + width_multiplier = 2; + break; + default: + return false; + } + + if (*plane_count < 1) { + return false; + } + *plane_count = 1; + planes[0].item_size = 1; + planes[0].item_count = region_width * width_multiplier; + planes[0].lines = region_height; + + return true; +} + +static bool _vdp_cap_init_planes_adapt_format_bits_ycbcr( + uint32_t * plane_count, + _VdpcapPlane * planes, + uint32_t surface_format, + uint32_t bits_format, + uint32_t region_width, + uint32_t region_height +) +{ + return _vdp_cap_init_planes_for_ycbcr_format( + plane_count, + planes, + bits_format, + region_width, + region_height + ); +} + +static bool _vdp_cap_init_planes_adapt_format_surface_rgba( + uint32_t * plane_count, + _VdpcapPlane * planes, + uint32_t surface_format, + uint32_t bits_format, + uint32_t region_width, + uint32_t region_height +) +{ + return _vdp_cap_init_planes_for_rgba_format( + plane_count, + planes, + surface_format, + region_width, + region_height + ); +} + +static bool _vdp_cap_init_planes_adapt_format_bits_indexed( + uint32_t * plane_count, + _VdpcapPlane * planes, + uint32_t surface_format, + uint32_t bits_format, + uint32_t region_width, + uint32_t region_height +) +{ + return _vdp_cap_init_planes_for_indexed_format( + plane_count, + planes, + bits_format, + region_width, + region_height + ); +} + +bool _vdp_cap_init_planes_adapt_surface_video( + uint32_t surface, + uint32_t * surface_format, + uint32_t * width, + uint32_t * height +) +{ + VdpStatus ret; + + VdpChromaType chroma_type; + ret = _vdp_cap_data.vdp_video_surface_get_parameters( + surface, + &chroma_type, + width, + height + ); + if (ret != VDP_STATUS_OK) { + return false; + } + + *surface_format = chroma_type; + + return true; +} + +bool _vdp_cap_init_planes_adapt_surface_output( + uint32_t surface, + uint32_t * surface_format, + uint32_t * width, + uint32_t * height +) +{ + VdpStatus ret; + + VdpRGBAFormat rgba_format; + ret = _vdp_cap_data.vdp_output_surface_get_parameters( + surface, + &rgba_format, + width, + height + ); + if (ret != VDP_STATUS_OK) { + return false; + } + + *surface_format = rgba_format; + + return true; +} + +bool _vdp_cap_init_planes_adapt_surface_bitmap( + uint32_t surface, + uint32_t * surface_format, + uint32_t * width, + uint32_t * height +) +{ + VdpStatus ret; + + VdpRGBAFormat rgba_format; + VdpBool frequently_accessed; + ret = _vdp_cap_data.vdp_bitmap_surface_get_parameters( + surface, + &rgba_format, + width, + height, + &frequently_accessed + ); + if (ret != VDP_STATUS_OK) { + return false; + } + + *surface_format = rgba_format; + + return true; +} + +typedef bool _Vdpcap_Init_Planes_Adapt_Format( + uint32_t * plane_count, + _VdpcapPlane * planes, + uint32_t surface_format, + uint32_t bits_format, + uint32_t region_width, + uint32_t region_height +); + +typedef bool _Vdpcap_Init_Planes_Adapt_Surface( + uint32_t surface, + uint32_t * surface_format, + uint32_t * width, + uint32_t * height +); + +static bool _vdp_cap_init_planes( + uint32_t surface, + void const * const * source_data, + uint32_t const * source_pitches, + VdpRect const * destination_rect, + uint32_t * plane_count, + _VdpcapPlane * planes, + _Vdpcap_Init_Planes_Adapt_Surface * adapt_surface, + _Vdpcap_Init_Planes_Adapt_Format * adapt_format, + uint32_t adapt_format_bits_format +) +{ + bool ok; + + if (!source_data || !source_pitches) { + return false; + } + + if (_vdp_cap_data.level < LEVEL_PARAMS) { + return false; + } + + uint32_t surface_format; + uint32_t width; + uint32_t height; + ok = adapt_surface( + surface, + &surface_format, + &width, + &height + ); + if (!ok) { + return false; + } + + if (destination_rect) { + width = delta<uint32_t>(destination_rect->x0, destination_rect->x1); + height = delta<uint32_t>(destination_rect->y0, destination_rect->y1); + } + + ok = adapt_format( + plane_count, + planes, + surface_format, + adapt_format_bits_format, + width, + height + ); + if (!ok) { + return false; + } + + for (uint32_t i = 0; i < *plane_count; ++i) { + planes[i].data = source_data[i]; + planes[i].pitch = source_pitches[i]; + } + + return true; +} + +static void _vdp_cap_dump_bool_list( + uint32_t count, + VdpBool const * values +) +{ + if (!values) { + fputs("NULL", _vdp_cap_data.fp); + return; + } + + fputs("{", _vdp_cap_data.fp); + while (count) { + fprintf( + _vdp_cap_data.fp, + "%d%s", + (int)values[0], + (count > 1) ? ", " : "" + ); + + --count; + ++values; + } + fputs("}", _vdp_cap_data.fp); +} + +static void _vdp_cap_dump_void_pointer_list( + uint32_t count, + void const * const * values, + bool zero_count_question_marks +) +{ + if (!values) { + fputs("NULL", _vdp_cap_data.fp); + return; + } + + fputs("{", _vdp_cap_data.fp); + if (!count && zero_count_question_marks) { + fputs("???", _vdp_cap_data.fp); + } + while (count) { + fprintf( + _vdp_cap_data.fp, + "%p%s", + values[0], + (count > 1) ? ", " : "" + ); + + --count; + ++values; + } + fputs("}", _vdp_cap_data.fp); +} + +static void _vdp_cap_dump_uint32_t_list( + uint32_t count, + uint32_t const * values, + bool zero_count_question_marks +) +{ + if (!values) { + fputs("NULL", _vdp_cap_data.fp); + return; + } + + fputs("{", _vdp_cap_data.fp); + if (!count && zero_count_question_marks) { + fputs("???", _vdp_cap_data.fp); + } + while (count) { + fprintf( + _vdp_cap_data.fp, + "%u%s", + values[0], + (count > 1) ? ", " : "" + ); + + --count; + ++values; + } + fputs("}", _vdp_cap_data.fp); +} + +static void _vdp_cap_dump_color_list( + uint32_t count, + VdpColor const * colors +) +{ + if (!colors) { + fputs("NULL", _vdp_cap_data.fp); + return; + } + + fputs("{", _vdp_cap_data.fp); + while (count) { + _vdp_cap_dump_color(&colors[0]); + fputs( + (count > 1) ? ", " : "", + _vdp_cap_data.fp + ); + + --count; + ++colors; + } + fputs("}", _vdp_cap_data.fp); +} + +static void _vdp_cap_dump_color_table( + VdpIndexedFormat indexed_format, + VdpColorTableFormat format, + void const * table +) +{ + if (!table) { + fprintf(_vdp_cap_data.fp, "NULL"); + return; + } + + uint32_t count; + switch (indexed_format) { + case VDP_INDEXED_FORMAT_A4I4: + case VDP_INDEXED_FORMAT_I4A4: + count = 1 << 4; + break; + case VDP_INDEXED_FORMAT_A8I8: + case VDP_INDEXED_FORMAT_I8A8: + count = 1 << 8; + break; + default: + fprintf(_vdp_cap_data.fp, "???"); + return; + } + + switch (format) { + case VDP_COLOR_TABLE_FORMAT_B8G8R8X8: + break; + default: + fprintf(_vdp_cap_data.fp, "???"); + return; + } + + _vdp_cap_dump_uint32_t_list( + count, + (uint32_t const *)table, + true + ); +} + +static void _vdp_cap_dump_bitstream_buffer_list( + uint32_t count, + VdpBitstreamBuffer const * buffers +) +{ + if (!buffers) { + fputs("NULL", _vdp_cap_data.fp); + return; + } + + fputs("{", _vdp_cap_data.fp); + while (count) { + fprintf( + _vdp_cap_data.fp, + "{(ver %d)%s %u, ", + buffers[0].struct_version, + (buffers[0].struct_version > 0) + ? "(unsupported; cannot dump all fields)" + : "", + buffers[0].bitstream_bytes + ); + if (_vdp_cap_data.level >= LEVEL_DATA) { + uint8_t * ptr = (uint8_t * )buffers[0].bitstream; + for (uint32_t i = 0; i < buffers[0].bitstream_bytes; ++i) { + fprintf(_vdp_cap_data.fp, "%02x ", ptr[i]); + } + } + else { + fputs("...", _vdp_cap_data.fp); + } + fputs( + (count > 1) ? "}, " : "}", + _vdp_cap_data.fp + ); + + --count; + ++buffers; + } + fputs("}", _vdp_cap_data.fp); +} + +static void _vdp_cap_dump_video_mixer_feature_list( + uint32_t feature_count, + VdpVideoMixerFeature const * features +) +{ + _vdp_cap_dump_uint32_t_list( + feature_count, + features, + false + ); +} + +static void _vdp_cap_dump_video_mixer_parameter_list( + uint32_t parameter_count, + VdpVideoMixerParameter const * parameters +) +{ + _vdp_cap_dump_uint32_t_list( + parameter_count, + parameters, + false + ); +} + +static void _vdp_cap_dump_video_mixer_attribute_list( + uint32_t attribute_count, + VdpVideoMixerAttribute const * attributes +) +{ + _vdp_cap_dump_uint32_t_list( + attribute_count, + attributes, + false + ); +} + +static void _vdp_cap_dump_video_mixer_parameter_value_list( + uint32_t parameter_count, + VdpVideoMixerParameter const * parameters, + void const * const * parameter_values +) +{ + if (!parameters || !parameter_values) { + fputs("NULL", _vdp_cap_data.fp); + return; + } + + fputs("{", _vdp_cap_data.fp); + while (parameter_count) { + _vdp_cap_dump_video_mixer_parameter_value(parameters[0], parameter_values[0]); + fputs((parameter_count > 1) ? ", " : "", _vdp_cap_data.fp); + + --parameter_count; + ++parameters; + ++parameter_values; + } + fputs("}", _vdp_cap_data.fp); +} + +static void _vdp_cap_dump_video_mixer_attribute_value_list( + uint32_t attribute_count, + VdpVideoMixerAttribute const * attributes, + void const * const * attribute_values, + bool get_operation +) +{ + if (!attributes || !attribute_values) { + fputs("NULL", _vdp_cap_data.fp); + return; + } + + fputs("{", _vdp_cap_data.fp); + while (attribute_count) { + _vdp_cap_dump_video_mixer_attribute_value( + attributes[0], + attribute_values[0], + get_operation + ); + fputs((attribute_count > 1) ? ", " : "", _vdp_cap_data.fp); + + --attribute_count; + ++attributes; + ++attribute_values; + } + fputs("}", _vdp_cap_data.fp); +} + +static void _vdp_cap_dump_layers_list( + uint32_t layer_count, + VdpLayer const * layers +) +{ + if (!layers) { + fputs("NULL", _vdp_cap_data.fp); + return; + } + + fputs("{", _vdp_cap_data.fp); + while (layer_count) { + fprintf( + _vdp_cap_data.fp, + "{(ver %d)%s %u,", + layers[0].struct_version, + (layers[0].struct_version > 0) + ? "(unsupported; cannot dump all fields)" + : "", + layers[0].source_surface + ); + + _vdp_cap_dump_rect(layers[0].source_rect); + fputs(", ", _vdp_cap_data.fp); + _vdp_cap_dump_rect(layers[0].destination_rect); + + fputs((layer_count > 1) ? "}, " : "}", _vdp_cap_data.fp); + + --layer_count; + ++layers; + } + fputs("}", _vdp_cap_data.fp); +} + +static char const * _vdp_cap_get_error_string( + VdpStatus status +) +{ + char const * ret; + + fputs("vdp_get_error_string(", _vdp_cap_data.fp); + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf( + _vdp_cap_data.fp, + "%d", + status + ); + } + fputs(")\n", _vdp_cap_data.fp); + + ret = _vdp_cap_data.vdp_get_error_string( + status + ); + + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + if (ret) { + fprintf(_vdp_cap_data.fp, " -> '%s'\n", ret); + } + else { + fprintf(_vdp_cap_data.fp, " -> NULL\n"); + } + } + + return ret; +} + +static VdpStatus _vdp_cap_get_api_version( + /* output parameters follow */ + uint32_t * api_version +) +{ + VdpStatus ret; + + fputs("vdp_get_api_version(", _vdp_cap_data.fp); + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf( + _vdp_cap_data.fp, + "%s", + api_version ? "-" : "NULL" + ); + } + fputs(")\n", _vdp_cap_data.fp); + + ret = _vdp_cap_data.vdp_get_api_version( + api_version + ); + + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf(_vdp_cap_data.fp, " -> %d", ret); + if (ret == VDP_STATUS_OK) { + fprintf( + _vdp_cap_data.fp, + ", %u", + *api_version + ); + } + fputs("\n", _vdp_cap_data.fp); + } + + return ret; +} + +static VdpStatus _vdp_cap_get_information_string( + /* output parameters follow */ + char const * * information_string +) +{ + VdpStatus ret; + + fputs("vdp_get_information_string(", _vdp_cap_data.fp); + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf( + _vdp_cap_data.fp, + "%s", + information_string ? "-" : "NULL" + ); + } + fputs(")\n", _vdp_cap_data.fp); + + ret = _vdp_cap_data.vdp_get_information_string( + information_string + ); + + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf(_vdp_cap_data.fp, " -> %d", ret); + if (ret == VDP_STATUS_OK) { + fprintf(_vdp_cap_data.fp, ", \"%s\"", *information_string); + } + fputs("\n", _vdp_cap_data.fp); + } + + return ret; +} + +static VdpStatus _vdp_cap_device_destroy( + VdpDevice device +) +{ + VdpStatus ret; + + fputs("vdp_device_destroy(", _vdp_cap_data.fp); + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf( + _vdp_cap_data.fp, + "%u", + device + ); + } + fputs(")\n", _vdp_cap_data.fp); + + ret = _vdp_cap_data.vdp_device_destroy( + device + ); + + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf(_vdp_cap_data.fp, " -> %d\n", ret); + } + + return ret; +} + +static VdpStatus _vdp_cap_generate_csc_matrix( + VdpProcamp * procamp, + VdpColorStandard standard, + /* output parameters follow */ + VdpCSCMatrix * csc_matrix +) +{ + VdpStatus ret; + + fputs("vdp_generate_csc_matrix(", _vdp_cap_data.fp); + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + _vdp_cap_dump_procamp(procamp); + fprintf( + _vdp_cap_data.fp, + ", %u, %s", + standard, + csc_matrix ? "-" : "NULL" + ); + } + fputs(")\n", _vdp_cap_data.fp); + + ret = _vdp_cap_data.vdp_generate_csc_matrix( + procamp, + standard, + csc_matrix + ); + + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf(_vdp_cap_data.fp, " -> %d", ret); + if (ret == VDP_STATUS_OK) { + fputs(", ", _vdp_cap_data.fp); + _vdp_cap_dump_csc_matrix(csc_matrix); + } + fputs("\n", _vdp_cap_data.fp); + } + + return ret; +} + +static VdpStatus _vdp_cap_video_surface_query_capabilities( + VdpDevice device, + VdpChromaType surface_chroma_type, + /* output parameters follow */ + VdpBool * is_supported, + uint32_t * max_width, + uint32_t * max_height +) +{ + VdpStatus ret; + + fputs("vdp_video_surface_query_capabilities(", _vdp_cap_data.fp); + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf( + _vdp_cap_data.fp, + "%u, %u, %s, %s, %s", + device, + surface_chroma_type, + is_supported ? "-" : "NULL", + max_width ? "-" : "NULL", + max_height ? "-" : "NULL" + ); + } + fputs(")\n", _vdp_cap_data.fp); + + ret = _vdp_cap_data.vdp_video_surface_query_capabilities( + device, + surface_chroma_type, + is_supported, + max_width, + max_height + ); + + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf(_vdp_cap_data.fp, " -> %d", ret); + if (ret == VDP_STATUS_OK) { + fprintf( + _vdp_cap_data.fp, + ", %d, %u, %u", + *is_supported, + *max_width, + *max_height + ); + } + fputs("\n", _vdp_cap_data.fp); + } + + return ret; +} + +static VdpStatus _vdp_cap_video_surface_query_get_put_bits_y_cb_cr_capabilities( + VdpDevice device, + VdpChromaType surface_chroma_type, + VdpYCbCrFormat bits_ycbcr_format, + /* output parameters follow */ + VdpBool * is_supported +) +{ + VdpStatus ret; + + fputs("vdp_video_surface_query_get_put_bits_y_cb_cr_capabilities(", _vdp_cap_data.fp); + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf( + _vdp_cap_data.fp, + "%u, %u, %u, %s", + device, + surface_chroma_type, + bits_ycbcr_format, + is_supported ? "-" : "NULL" + ); + } + fputs(")\n", _vdp_cap_data.fp); + + ret = _vdp_cap_data.vdp_video_surface_query_get_put_bits_y_cb_cr_capabilities( + device, + surface_chroma_type, + bits_ycbcr_format, + is_supported + ); + + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf(_vdp_cap_data.fp, " -> %d", ret); + if (ret == VDP_STATUS_OK) { + fprintf( + _vdp_cap_data.fp, + ", %d", + *is_supported + ); + } + fputs("\n", _vdp_cap_data.fp); + } + + return ret; +} + +static VdpStatus _vdp_cap_video_surface_create( + VdpDevice device, + VdpChromaType chroma_type, + uint32_t width, + uint32_t height, + /* output parameters follow */ + VdpVideoSurface * surface +) +{ + VdpStatus ret; + + fputs("vdp_video_surface_create(", _vdp_cap_data.fp); + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf( + _vdp_cap_data.fp, + "%u, %u, %u, %u, %s", + device, + chroma_type, + width, + height, + surface ? "-" : "NULL" + ); + } + fputs(")\n", _vdp_cap_data.fp); + + ret = _vdp_cap_data.vdp_video_surface_create( + device, + chroma_type, + width, + height, + surface + ); + + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf(_vdp_cap_data.fp, " -> %d", ret); + if (ret == VDP_STATUS_OK) { + fprintf( + _vdp_cap_data.fp, + ", %u", + *surface + ); + } + fputs("\n", _vdp_cap_data.fp); + } + + return ret; +} + +static VdpStatus _vdp_cap_video_surface_destroy( + VdpVideoSurface surface +) +{ + VdpStatus ret; + + fputs("vdp_video_surface_destroy(", _vdp_cap_data.fp); + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf( + _vdp_cap_data.fp, + "%u", + surface + ); + } + fputs(")\n", _vdp_cap_data.fp); + + ret = _vdp_cap_data.vdp_video_surface_destroy( + surface + ); + + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf(_vdp_cap_data.fp, " -> %d\n", ret); + } + + return ret; +} + +static VdpStatus _vdp_cap_video_surface_get_parameters( + VdpVideoSurface surface, + /* output parameters follow */ + VdpChromaType * chroma_type, + uint32_t * width, + uint32_t * height +) +{ + VdpStatus ret; + + fputs("vdp_video_surface_get_parameters(", _vdp_cap_data.fp); + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf( + _vdp_cap_data.fp, + "%u, %s, %s, %s", + surface, + chroma_type ? "-" : "NULL", + width ? "-" : "NULL", + height ? "-" : "NULL" + ); + } + fputs(")\n", _vdp_cap_data.fp); + + ret = _vdp_cap_data.vdp_video_surface_get_parameters( + surface, + chroma_type, + width, + height + ); + + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf(_vdp_cap_data.fp, " -> %d", ret); + if (ret == VDP_STATUS_OK) { + fprintf( + _vdp_cap_data.fp, + ", %u, %u, %u", + *chroma_type, + *width, + *height + ); + } + fputs("\n", _vdp_cap_data.fp); + } + + return ret; +} + +static VdpStatus _vdp_cap_video_surface_get_bits_y_cb_cr( + VdpVideoSurface surface, + VdpYCbCrFormat destination_ycbcr_format, + void * const * destination_data, + uint32_t const * destination_pitches +) +{ + VdpStatus ret; + + _VdpcapPlane planes[3]; + uint32_t plane_count = _VDP_TRACE_ARSIZE(planes); + bool dump_data = _vdp_cap_init_planes( + surface, + destination_data, + destination_pitches, + 0, + &plane_count, + planes, + _vdp_cap_init_planes_adapt_surface_video, + _vdp_cap_init_planes_adapt_format_bits_ycbcr, + destination_ycbcr_format + ); + if (!dump_data) { + plane_count = 0; + } + + fputs("vdp_video_surface_get_bits_y_cb_cr(", _vdp_cap_data.fp); + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf( + _vdp_cap_data.fp, + "%u, %u, ", + surface, + destination_ycbcr_format + ); + _vdp_cap_dump_void_pointer_list(plane_count, destination_data, true); + fputs(", ", _vdp_cap_data.fp); + _vdp_cap_dump_uint32_t_list(plane_count, destination_pitches, true); + } + fputs(")\n", _vdp_cap_data.fp); + + ret = _vdp_cap_data.vdp_video_surface_get_bits_y_cb_cr( + surface, + destination_ycbcr_format, + destination_data, + destination_pitches + ); + + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf(_vdp_cap_data.fp, " -> %d\n", ret); + } + if (_vdp_cap_data.level >= LEVEL_DATA) { + fputs(" ... Data: ", _vdp_cap_data.fp); + if (dump_data) { + _vdp_cap_dump_plane_list(plane_count, planes); + } + else { + fputs("???", _vdp_cap_data.fp); + } + fputs("\n", _vdp_cap_data.fp); + } + + return ret; +} + +static VdpStatus _vdp_cap_video_surface_put_bits_y_cb_cr( + VdpVideoSurface surface, + VdpYCbCrFormat source_ycbcr_format, + void const * const * source_data, + uint32_t const * source_pitches +) +{ + VdpStatus ret; + + _VdpcapPlane planes[3]; + uint32_t plane_count = _VDP_TRACE_ARSIZE(planes); + bool dump_data = _vdp_cap_init_planes( + surface, + source_data, + source_pitches, + 0, + &plane_count, + planes, + _vdp_cap_init_planes_adapt_surface_video, + _vdp_cap_init_planes_adapt_format_bits_ycbcr, + source_ycbcr_format + ); + if (!dump_data) { + plane_count = 0; + } + + fputs("vdp_video_surface_put_bits_y_cb_cr(", _vdp_cap_data.fp); + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf( + _vdp_cap_data.fp, + "%u, %u, ", + surface, + source_ycbcr_format + ); + _vdp_cap_dump_void_pointer_list(plane_count, source_data, true); + fputs(", ", _vdp_cap_data.fp); + _vdp_cap_dump_uint32_t_list(plane_count, source_pitches, true); + fputs(", ", _vdp_cap_data.fp); + } + fputs(")\n", _vdp_cap_data.fp); + if (_vdp_cap_data.level >= LEVEL_DATA) { + fputs(" ... Data: ", _vdp_cap_data.fp); + if (dump_data) { + _vdp_cap_dump_plane_list(plane_count, planes); + } + else { + fputs("???", _vdp_cap_data.fp); + } + fputs("\n", _vdp_cap_data.fp); + } + + ret = _vdp_cap_data.vdp_video_surface_put_bits_y_cb_cr( + surface, + source_ycbcr_format, + source_data, + source_pitches + ); + + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf(_vdp_cap_data.fp, " -> %d\n", ret); + } + + return ret; +} + +static VdpStatus _vdp_cap_output_surface_query_capabilities( + VdpDevice device, + VdpRGBAFormat surface_rgba_format, + /* output parameters follow */ + VdpBool * is_supported, + uint32_t * max_width, + uint32_t * max_height +) +{ + VdpStatus ret; + + fputs("vdp_output_surface_query_capabilities(", _vdp_cap_data.fp); + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf( + _vdp_cap_data.fp, + "%u, %u, %s, %s, %s", + device, + surface_rgba_format, + is_supported ? "-" : "NULL", + max_width ? "-" : "NULL", + max_height ? "-" : "NULL" + ); + } + fputs(")\n", _vdp_cap_data.fp); + + ret = _vdp_cap_data.vdp_output_surface_query_capabilities( + device, + surface_rgba_format, + is_supported, + max_width, + max_height + ); + + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf(_vdp_cap_data.fp, " -> %d", ret); + if (ret == VDP_STATUS_OK) { + fprintf( + _vdp_cap_data.fp, + ", %d, %u, %u", + *is_supported, + *max_width, + *max_height + ); + } + fputs("\n", _vdp_cap_data.fp); + } + + return ret; +} + +static VdpStatus _vdp_cap_output_surface_query_get_put_bits_native_capabilities( + VdpDevice device, + VdpRGBAFormat surface_rgba_format, + /* output parameters follow */ + VdpBool * is_supported +) +{ + VdpStatus ret; + + fputs("vdp_output_surface_query_get_put_bits_native_capabilities(", _vdp_cap_data.fp); + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf( + _vdp_cap_data.fp, + "%u, %u, %s", + device, + surface_rgba_format, + is_supported ? "-" : "NULL" + ); + } + fputs(")\n", _vdp_cap_data.fp); + + ret = _vdp_cap_data.vdp_output_surface_query_get_put_bits_native_capabilities( + device, + surface_rgba_format, + is_supported + ); + + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf(_vdp_cap_data.fp, " -> %d", ret); + if (ret == VDP_STATUS_OK) { + fprintf( + _vdp_cap_data.fp, + ", %d", + *is_supported + ); + } + fputs("\n", _vdp_cap_data.fp); + } + + return ret; +} + +static VdpStatus _vdp_cap_output_surface_query_put_bits_indexed_capabilities( + VdpDevice device, + VdpRGBAFormat surface_rgba_format, + VdpIndexedFormat bits_indexed_format, + VdpColorTableFormat color_table_format, + /* output parameters follow */ + VdpBool * is_supported +) +{ + VdpStatus ret; + + fputs("vdp_output_surface_query_put_bits_indexed_capabilities(", _vdp_cap_data.fp); + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf( + _vdp_cap_data.fp, + "%u, %u, %u, %u, %s", + device, + surface_rgba_format, + bits_indexed_format, + color_table_format, + is_supported ? "-" : "NULL" + ); + } + fputs(")\n", _vdp_cap_data.fp); + + ret = _vdp_cap_data.vdp_output_surface_query_put_bits_indexed_capabilities( + device, + surface_rgba_format, + bits_indexed_format, + color_table_format, + is_supported + ); + + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf(_vdp_cap_data.fp, " -> %d", ret); + if (ret == VDP_STATUS_OK) { + fprintf( + _vdp_cap_data.fp, + ", %d", + *is_supported + ); + } + fputs("\n", _vdp_cap_data.fp); + } + + return ret; +} + +static VdpStatus _vdp_cap_output_surface_query_put_bits_y_cb_cr_capabilities( + VdpDevice device, + VdpRGBAFormat surface_rgba_format, + VdpYCbCrFormat bits_ycbcr_format, + /* output parameters follow */ + VdpBool * is_supported +) +{ + VdpStatus ret; + + fputs("vdp_output_surface_query_put_bits_y_cb_cr_capabilities(", _vdp_cap_data.fp); + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf( + _vdp_cap_data.fp, + "%u, %u, %u, %s", + device, + surface_rgba_format, + bits_ycbcr_format, + is_supported ? "-" : "NULL" + ); + } + fputs(")\n", _vdp_cap_data.fp); + + ret = _vdp_cap_data.vdp_output_surface_query_put_bits_y_cb_cr_capabilities( + device, + surface_rgba_format, + bits_ycbcr_format, + is_supported + ); + + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf(_vdp_cap_data.fp, " -> %d", ret); + if (ret == VDP_STATUS_OK) { + fprintf( + _vdp_cap_data.fp, + ", %d", + *is_supported + ); + } + fputs("\n", _vdp_cap_data.fp); + } + + return ret; +} + +static VdpStatus _vdp_cap_output_surface_create( + VdpDevice device, + VdpRGBAFormat rgba_format, + uint32_t width, + uint32_t height, + /* output parameters follow */ + VdpOutputSurface * surface +) +{ + VdpStatus ret; + + fputs("vdp_output_surface_create(", _vdp_cap_data.fp); + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf( + _vdp_cap_data.fp, + "%u, %u, %u, %u, %s", + device, + rgba_format, + width, + height, + surface ? "-" : "NULL" + ); + } + fputs(")\n", _vdp_cap_data.fp); + + ret = _vdp_cap_data.vdp_output_surface_create( + device, + rgba_format, + width, + height, + surface + ); + + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf(_vdp_cap_data.fp, " -> %d", ret); + if (ret == VDP_STATUS_OK) { + fprintf( + _vdp_cap_data.fp, + ", %u", + *surface + ); + } + fputs("\n", _vdp_cap_data.fp); + } + + return ret; +} + +static VdpStatus _vdp_cap_output_surface_destroy( + VdpOutputSurface surface +) +{ + VdpStatus ret; + + fputs("vdp_output_surface_destroy(", _vdp_cap_data.fp); + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf( + _vdp_cap_data.fp, + "%u", + surface + ); + } + fputs(")\n", _vdp_cap_data.fp); + + ret = _vdp_cap_data.vdp_output_surface_destroy( + surface + ); + + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf(_vdp_cap_data.fp, " -> %d\n", ret); + } + + return ret; +} + +static VdpStatus _vdp_cap_output_surface_get_parameters( + VdpOutputSurface surface, + /* output parameters follow */ + VdpRGBAFormat * rgba_format, + uint32_t * width, + uint32_t * height +) +{ + VdpStatus ret; + + fputs("vdp_output_surface_get_parameters(", _vdp_cap_data.fp); + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf( + _vdp_cap_data.fp, + "%u, %s, %s, %s", + surface, + rgba_format ? "-" : "NULL", + width ? "-" : "NULL", + height ? "-" : "NULL" + ); + } + fputs(")\n", _vdp_cap_data.fp); + + ret = _vdp_cap_data.vdp_output_surface_get_parameters( + surface, + rgba_format, + width, + height + ); + + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf(_vdp_cap_data.fp, " -> %d", ret); + if (ret == VDP_STATUS_OK) { + fprintf( + _vdp_cap_data.fp, + ", %u, %u, %u", + *rgba_format, + *width, + *height + ); + } + fputs("\n", _vdp_cap_data.fp); + } + + return ret; +} + +static VdpStatus _vdp_cap_output_surface_get_bits_native( + VdpOutputSurface surface, + VdpRect const * source_rect, + void * const * destination_data, + uint32_t const * destination_pitches +) +{ + VdpStatus ret; + + _VdpcapPlane planes[1]; + uint32_t plane_count = _VDP_TRACE_ARSIZE(planes); + bool dump_data = _vdp_cap_init_planes( + surface, + destination_data, + destination_pitches, + source_rect, + &plane_count, + planes, + _vdp_cap_init_planes_adapt_surface_output, + _vdp_cap_init_planes_adapt_format_surface_rgba, + 0 + ); + if (!dump_data) { + plane_count = 0; + } + + fputs("vdp_output_surface_get_bits_native(", _vdp_cap_data.fp); + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf( + _vdp_cap_data.fp, + "%u, ", + surface + ); + _vdp_cap_dump_rect(source_rect); + fputs(", ", _vdp_cap_data.fp); + _vdp_cap_dump_void_pointer_list(plane_count, destination_data, true); + fputs(", ", _vdp_cap_data.fp); + _vdp_cap_dump_uint32_t_list(plane_count, destination_pitches, true); + } + fputs(")\n", _vdp_cap_data.fp); + + ret = _vdp_cap_data.vdp_output_surface_get_bits_native( + surface, + source_rect, + destination_data, + destination_pitches + ); + + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf(_vdp_cap_data.fp, " -> %d\n", ret); + } + if (_vdp_cap_data.level >= LEVEL_DATA) { + fputs(" ... Data: ", _vdp_cap_data.fp); + if (dump_data) { + _vdp_cap_dump_plane_list(plane_count, planes); + } + else { + fputs("???", _vdp_cap_data.fp); + } + fputs("\n", _vdp_cap_data.fp); + } + + return ret; +} + +static VdpStatus _vdp_cap_output_surface_put_bits_native( + VdpOutputSurface surface, + void const * const * source_data, + uint32_t const * source_pitches, + VdpRect const * destination_rect +) +{ + VdpStatus ret; + + _VdpcapPlane planes[1]; + uint32_t plane_count = _VDP_TRACE_ARSIZE(planes); + bool dump_data = _vdp_cap_init_planes( + surface, + source_data, + source_pitches, + destination_rect, + &plane_count, + planes, + _vdp_cap_init_planes_adapt_surface_output, + _vdp_cap_init_planes_adapt_format_surface_rgba, + 0 + ); + if (!dump_data) { + plane_count = 0; + } + + fputs("vdp_output_surface_put_bits_native(", _vdp_cap_data.fp); + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf( + _vdp_cap_data.fp, + "%u, ", + surface + ); + _vdp_cap_dump_void_pointer_list(plane_count, source_data, true); + fputs(", ", _vdp_cap_data.fp); + _vdp_cap_dump_uint32_t_list(plane_count, source_pitches, true); + fputs(", ", _vdp_cap_data.fp); + _vdp_cap_dump_rect(destination_rect); + } + fputs(")\n", _vdp_cap_data.fp); + if (_vdp_cap_data.level >= LEVEL_DATA) { + fputs(" ... Data: ", _vdp_cap_data.fp); + if (dump_data) { + _vdp_cap_dump_plane_list(plane_count, planes); + } + else { + fputs("???", _vdp_cap_data.fp); + } + fputs("\n", _vdp_cap_data.fp); + } + + ret = _vdp_cap_data.vdp_output_surface_put_bits_native( + surface, + source_data, + source_pitches, + destination_rect + ); + + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf(_vdp_cap_data.fp, " -> %d\n", ret); + } + + return ret; +} + +static VdpStatus _vdp_cap_output_surface_put_bits_indexed( + VdpOutputSurface surface, + VdpIndexedFormat source_indexed_format, + void const * const * source_data, + uint32_t const * source_pitches, + VdpRect const * destination_rect, + VdpColorTableFormat color_table_format, + void const * color_table +) +{ + VdpStatus ret; + + _VdpcapPlane planes[1]; + uint32_t plane_count = _VDP_TRACE_ARSIZE(planes); + bool dump_data = _vdp_cap_init_planes( + surface, + source_data, + source_pitches, + destination_rect, + &plane_count, + planes, + _vdp_cap_init_planes_adapt_surface_output, + _vdp_cap_init_planes_adapt_format_bits_indexed, + source_indexed_format + ); + if (!dump_data) { + plane_count = 0; + } + + fputs("vdp_output_surface_put_bits_indexed(", _vdp_cap_data.fp); + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf( + _vdp_cap_data.fp, + "%u, %u, ", + surface, + source_indexed_format + ); + _vdp_cap_dump_void_pointer_list(plane_count, source_data, true); + fputs(", ", _vdp_cap_data.fp); + _vdp_cap_dump_uint32_t_list(plane_count, source_pitches, true); + fputs(", ", _vdp_cap_data.fp); + _vdp_cap_dump_rect(destination_rect); + fprintf( + _vdp_cap_data.fp, + ", %u, ", + color_table_format + ); + _vdp_cap_dump_color_table( + source_indexed_format, + color_table_format, + color_table + ); + } + fputs(")\n", _vdp_cap_data.fp); + if (_vdp_cap_data.level >= LEVEL_DATA) { + fputs(" ... Data: ", _vdp_cap_data.fp); + if (dump_data) { + _vdp_cap_dump_plane_list(plane_count, planes); + } + else { + fputs("???", _vdp_cap_data.fp); + } + fputs("\n", _vdp_cap_data.fp); + } + + ret = _vdp_cap_data.vdp_output_surface_put_bits_indexed( + surface, + source_indexed_format, + source_data, + source_pitches, + destination_rect, + color_table_format, + color_table + ); + + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf(_vdp_cap_data.fp, " -> %d\n", ret); + } + + return ret; +} + +static VdpStatus _vdp_cap_output_surface_put_bits_y_cb_cr( + VdpOutputSurface surface, + VdpYCbCrFormat source_ycbcr_format, + void const * const * source_data, + uint32_t const * source_pitches, + VdpRect const * destination_rect, + VdpCSCMatrix const * csc_matrix +) +{ + VdpStatus ret; + + _VdpcapPlane planes[1]; + uint32_t plane_count = _VDP_TRACE_ARSIZE(planes); + bool dump_data = _vdp_cap_init_planes( + surface, + source_data, + source_pitches, + destination_rect, + &plane_count, + planes, + _vdp_cap_init_planes_adapt_surface_output, + _vdp_cap_init_planes_adapt_format_bits_ycbcr, + source_ycbcr_format + ); + if (!dump_data) { + plane_count = 0; + } + + fputs("vdp_output_surface_put_bits_y_cb_cr(", _vdp_cap_data.fp); + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf( + _vdp_cap_data.fp, + "%u, %u, ", + surface, + source_ycbcr_format + ); + _vdp_cap_dump_void_pointer_list(plane_count, source_data, true); + fputs(", ", _vdp_cap_data.fp); + _vdp_cap_dump_uint32_t_list(plane_count, source_pitches, true); + fputs(", ", _vdp_cap_data.fp); + _vdp_cap_dump_rect(destination_rect); + fputs(", ", _vdp_cap_data.fp); + _vdp_cap_dump_csc_matrix(csc_matrix); + } + fputs(")\n", _vdp_cap_data.fp); + if (_vdp_cap_data.level >= LEVEL_DATA) { + fputs(" ... Data: ", _vdp_cap_data.fp); + if (dump_data) { + _vdp_cap_dump_plane_list(plane_count, planes); + } + else { + fputs("???", _vdp_cap_data.fp); + } + fputs("\n", _vdp_cap_data.fp); + } + + ret = _vdp_cap_data.vdp_output_surface_put_bits_y_cb_cr( + surface, + source_ycbcr_format, + source_data, + source_pitches, + destination_rect, + csc_matrix + ); + + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf(_vdp_cap_data.fp, " -> %d\n", ret); + } + + return ret; +} + +static VdpStatus _vdp_cap_bitmap_surface_query_capabilities( + VdpDevice device, + VdpRGBAFormat surface_rgba_format, + /* output parameters follow */ + VdpBool * is_supported, + uint32_t * max_width, + uint32_t * max_height +) +{ + VdpStatus ret; + + fputs("vdp_bitmap_surface_query_capabilities(", _vdp_cap_data.fp); + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf( + _vdp_cap_data.fp, + "%u, %u, %s, %s, %s", + device, + surface_rgba_format, + is_supported ? "-" : "NULL", + max_width ? "-" : "NULL", + max_height ? "-" : "NULL" + ); + } + fputs(")\n", _vdp_cap_data.fp); + + ret = _vdp_cap_data.vdp_bitmap_surface_query_capabilities( + device, + surface_rgba_format, + is_supported, + max_width, + max_height + ); + + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf(_vdp_cap_data.fp, " -> %d", ret); + if (ret == VDP_STATUS_OK) { + fprintf( + _vdp_cap_data.fp, + ", %d, %u, %u", + *is_supported, + *max_width, + *max_height + ); + } + fputs("\n", _vdp_cap_data.fp); + } + + return ret; +} + +static VdpStatus _vdp_cap_bitmap_surface_create( + VdpDevice device, + VdpRGBAFormat rgba_format, + uint32_t width, + uint32_t height, + VdpBool frequently_accessed, + /* output parameters follow */ + VdpBitmapSurface * surface +) +{ + VdpStatus ret; + + fputs("vdp_bitmap_surface_create(", _vdp_cap_data.fp); + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf( + _vdp_cap_data.fp, + "%u, %u, %u, %u, %d, %s", + device, + rgba_format, + width, + height, + frequently_accessed, + surface ? "-" : "NULL" + ); + } + fputs(")\n", _vdp_cap_data.fp); + + ret = _vdp_cap_data.vdp_bitmap_surface_create( + device, + rgba_format, + width, + height, + frequently_accessed, + surface + ); + + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf(_vdp_cap_data.fp, " -> %d", ret); + if (ret == VDP_STATUS_OK) { + fprintf( + _vdp_cap_data.fp, + ", %u", + *surface + ); + } + fputs("\n", _vdp_cap_data.fp); + } + + return ret; +} + +static VdpStatus _vdp_cap_bitmap_surface_destroy( + VdpBitmapSurface surface +) +{ + VdpStatus ret; + + fputs("vdp_bitmap_surface_destroy(", _vdp_cap_data.fp); + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf( + _vdp_cap_data.fp, + "%u", + surface + ); + } + fputs(")\n", _vdp_cap_data.fp); + + ret = _vdp_cap_data.vdp_bitmap_surface_destroy( + surface + ); + + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf(_vdp_cap_data.fp, " -> %d\n", ret); + } + + return ret; +} + +static VdpStatus _vdp_cap_bitmap_surface_get_parameters( + VdpBitmapSurface surface, + /* output parameters follow */ + VdpRGBAFormat * rgba_format, + uint32_t * width, + uint32_t * height, + VdpBool * frequently_accessed +) +{ + VdpStatus ret; + + fputs("vdp_bitmap_surface_get_parameters(", _vdp_cap_data.fp); + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf( + _vdp_cap_data.fp, + "%u, %s, %s, %s, %s", + surface, + rgba_format ? "-" : "NULL", + width ? "-" : "NULL", + height ? "-" : "NULL", + frequently_accessed ? "-" : "NULL" + ); + } + fputs(")\n", _vdp_cap_data.fp); + + ret = _vdp_cap_data.vdp_bitmap_surface_get_parameters( + surface, + rgba_format, + width, + height, + frequently_accessed + ); + + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf(_vdp_cap_data.fp, " -> %d", ret); + if (ret == VDP_STATUS_OK) { + fprintf( + _vdp_cap_data.fp, + ", %u, %u, %u, %d", + *rgba_format, + *width, + *height, + *frequently_accessed + ); + } + fputs("\n", _vdp_cap_data.fp); + } + + return ret; +} + +static VdpStatus _vdp_cap_bitmap_surface_put_bits_native( + VdpBitmapSurface surface, + void const * const * source_data, + uint32_t const * source_pitches, + VdpRect const * destination_rect +) +{ + VdpStatus ret; + + _VdpcapPlane planes[1]; + uint32_t plane_count = _VDP_TRACE_ARSIZE(planes); + bool dump_data = _vdp_cap_init_planes( + surface, + source_data, + source_pitches, + destination_rect, + &plane_count, + planes, + _vdp_cap_init_planes_adapt_surface_bitmap, + _vdp_cap_init_planes_adapt_format_surface_rgba, + 0 + ); + if (!dump_data) { + plane_count = 0; + } + + fputs("vdp_bitmap_surface_put_bits_native(", _vdp_cap_data.fp); + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf( + _vdp_cap_data.fp, + "%u, ", + surface + ); + _vdp_cap_dump_void_pointer_list(plane_count, source_data, true); + fputs(", ", _vdp_cap_data.fp); + _vdp_cap_dump_uint32_t_list(plane_count, source_pitches, true); + fputs(", ", _vdp_cap_data.fp); + _vdp_cap_dump_rect(destination_rect); + } + fputs(")\n", _vdp_cap_data.fp); + if (_vdp_cap_data.level >= LEVEL_DATA) { + fputs(" ... Data: ", _vdp_cap_data.fp); + if (dump_data) { + _vdp_cap_dump_plane_list(plane_count, planes); + } + else { + fputs("???", _vdp_cap_data.fp); + } + fputs("\n", _vdp_cap_data.fp); + } + + ret = _vdp_cap_data.vdp_bitmap_surface_put_bits_native( + surface, + source_data, + source_pitches, + destination_rect + ); + + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf(_vdp_cap_data.fp, " -> %d\n", ret); + } + + return ret; +} + +static VdpStatus _vdp_cap_output_surface_render_output_surface( + VdpOutputSurface destination_surface, + VdpRect const * destination_rect, + VdpOutputSurface source_surface, + VdpRect const * source_rect, + VdpColor const * colors, + VdpOutputSurfaceRenderBlendState const * blend_state, + uint32_t flags +) +{ + VdpStatus ret; + + fputs("vdp_output_surface_render_output_surface(", _vdp_cap_data.fp); + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf( + _vdp_cap_data.fp, + "%u, ", + destination_surface + ); + _vdp_cap_dump_rect(destination_rect); + fprintf( + _vdp_cap_data.fp, + ", %u, ", + source_surface + ); + _vdp_cap_dump_rect(source_rect); + fputs(", ", _vdp_cap_data.fp); + _vdp_cap_dump_color_list((flags & VDP_OUTPUT_SURFACE_RENDER_COLOR_PER_VERTEX) ? 4 : 1, colors); + fputs(", ", _vdp_cap_data.fp); + _vdp_cap_dump_blend_state(blend_state); + fprintf( + _vdp_cap_data.fp, + ", %u", + flags + ); + } + fputs(")\n", _vdp_cap_data.fp); + + ret = _vdp_cap_data.vdp_output_surface_render_output_surface( + destination_surface, + destination_rect, + source_surface, + source_rect, + colors, + blend_state, + flags + ); + + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf(_vdp_cap_data.fp, " -> %d\n", ret); + } + + return ret; +} + +static VdpStatus _vdp_cap_output_surface_render_bitmap_surface( + VdpOutputSurface destination_surface, + VdpRect const * destination_rect, + VdpBitmapSurface source_surface, + VdpRect const * source_rect, + VdpColor const * colors, + VdpOutputSurfaceRenderBlendState const * blend_state, + uint32_t flags +) +{ + VdpStatus ret; + + fputs("vdp_output_surface_render_bitmap_surface(", _vdp_cap_data.fp); + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf( + _vdp_cap_data.fp, + "%u, ", + destination_surface + ); + _vdp_cap_dump_rect(destination_rect); + fprintf( + _vdp_cap_data.fp, + ", %u, ", + source_surface + ); + _vdp_cap_dump_rect(source_rect); + fputs(", ", _vdp_cap_data.fp); + _vdp_cap_dump_color_list((flags & VDP_OUTPUT_SURFACE_RENDER_COLOR_PER_VERTEX) ? 4 : 1, colors); + fputs(", ", _vdp_cap_data.fp); + _vdp_cap_dump_blend_state(blend_state); + fprintf( + _vdp_cap_data.fp, + ", %u", + flags + ); + } + fputs(")\n", _vdp_cap_data.fp); + + ret = _vdp_cap_data.vdp_output_surface_render_bitmap_surface( + destination_surface, + destination_rect, + source_surface, + source_rect, + colors, + blend_state, + flags + ); + + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf(_vdp_cap_data.fp, " -> %d\n", ret); + } + + return ret; +} + +static VdpStatus _vdp_cap_decoder_query_capabilities( + VdpDevice device, + VdpDecoderProfile profile, + /* output parameters follow */ + VdpBool * is_supported, + uint32_t * max_level, + uint32_t * max_macroblocks, + uint32_t * max_width, + uint32_t * max_height +) +{ + VdpStatus ret; + + fputs("vdp_decoder_query_capabilities(", _vdp_cap_data.fp); + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf( + _vdp_cap_data.fp, + "%u, %u, %s, %s, %s, %s, %s", + device, + profile, + is_supported ? "-" : "NULL", + max_level ? "-" : "NULL", + max_macroblocks ? "-" : "NULL", + max_width ? "-" : "NULL", + max_height ? "-" : "NULL" + ); + } + fputs(")\n", _vdp_cap_data.fp); + + ret = _vdp_cap_data.vdp_decoder_query_capabilities( + device, + profile, + is_supported, + max_level, + max_macroblocks, + max_width, + max_height + ); + + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf(_vdp_cap_data.fp, " -> %d", ret); + if (ret == VDP_STATUS_OK) { + fprintf( + _vdp_cap_data.fp, + ", %d, %u, %u, %u, %u", + *is_supported, + *max_level, + *max_macroblocks, + *max_width, + *max_height + ); + } + fputs("\n", _vdp_cap_data.fp); + } + + return ret; +} + +static VdpStatus _vdp_cap_decoder_create( + VdpDevice device, + VdpDecoderProfile profile, + uint32_t width, + uint32_t height, + uint32_t max_references, + /* output parameters follow */ + VdpDecoder * decoder +) +{ + VdpStatus ret; + + fputs("vdp_decoder_create(", _vdp_cap_data.fp); + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf( + _vdp_cap_data.fp, + "%u, %u, %u, %u, %u, %s", + device, + profile, + width, + height, + max_references, + decoder ? "-" : "NULL" + ); + } + fputs(")\n", _vdp_cap_data.fp); + + ret = _vdp_cap_data.vdp_decoder_create( + device, + profile, + width, + height, + max_references, + decoder + ); + + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf(_vdp_cap_data.fp, " -> %d", ret); + if (ret == VDP_STATUS_OK) { + fprintf( + _vdp_cap_data.fp, + ", %u", + *decoder + ); + } + fputs("\n", _vdp_cap_data.fp); + } + + return ret; +} + +static VdpStatus _vdp_cap_decoder_destroy( + VdpDecoder decoder +) +{ + VdpStatus ret; + + fputs("vdp_decoder_destroy(", _vdp_cap_data.fp); + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf( + _vdp_cap_data.fp, + "%u", + decoder + ); + } + fputs(")\n", _vdp_cap_data.fp); + + ret = _vdp_cap_data.vdp_decoder_destroy( + decoder + ); + + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf(_vdp_cap_data.fp, " -> %d\n", ret); + } + + return ret; +} + +static VdpStatus _vdp_cap_decoder_get_parameters( + VdpDecoder decoder, + /* output parameters follow */ + VdpDecoderProfile * profile, + uint32_t * width, + uint32_t * height +) +{ + VdpStatus ret; + + fputs("vdp_decoder_get_parameters(", _vdp_cap_data.fp); + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf( + _vdp_cap_data.fp, + "%u, %s, %s, %s", + decoder, + profile ? "-" : "NULL", + width ? "-" : "NULL", + height ? "-" : "NULL" + ); + } + fputs(")\n", _vdp_cap_data.fp); + + ret = _vdp_cap_data.vdp_decoder_get_parameters( + decoder, + profile, + width, + height + ); + + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf(_vdp_cap_data.fp, " -> %d", ret); + if (ret == VDP_STATUS_OK) { + fprintf( + _vdp_cap_data.fp, + ", %u, %u, %u", + *profile, + *width, + *height + ); + } + fputs("\n", _vdp_cap_data.fp); + } + + return ret; +} + +static VdpStatus _vdp_cap_decoder_render( + VdpDecoder decoder, + VdpVideoSurface target, + VdpPictureInfo const * picture_info, + uint32_t bitstream_buffer_count, + VdpBitstreamBuffer const * bitstream_buffers +) +{ + VdpStatus ret; + + fputs("vdp_decoder_render(", _vdp_cap_data.fp); + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + VdpDecoderProfile profile; + uint32_t width; + uint32_t height; + + ret = _vdp_cap_data.vdp_decoder_get_parameters( + decoder, + &profile, + &width, + &height + ); + + fprintf( + _vdp_cap_data.fp, + "%u, %u, ", + decoder, + target + ); + _vdp_cap_dump_picture_info(profile, picture_info); + fprintf( + _vdp_cap_data.fp, + ", %u, ", + bitstream_buffer_count + ); + _vdp_cap_dump_bitstream_buffer_list(bitstream_buffer_count, bitstream_buffers); + } + fputs(")\n", _vdp_cap_data.fp); + + ret = _vdp_cap_data.vdp_decoder_render( + decoder, + target, + picture_info, + bitstream_buffer_count, + bitstream_buffers + ); + + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf(_vdp_cap_data.fp, " -> %d\n", ret); + } + + return ret; +} + + +static VdpStatus _vdp_cap_video_mixer_query_feature_support( + VdpDevice device, + VdpVideoMixerFeature feature, + /* output parameters follow */ + VdpBool * is_supported +) +{ + VdpStatus ret; + + fputs("vdp_video_mixer_query_feature_support(", _vdp_cap_data.fp); + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf( + _vdp_cap_data.fp, + "%u, %u, %s", + device, + feature, + is_supported ? "-" : "NULL" + ); + } + fputs(")\n", _vdp_cap_data.fp); + + ret = _vdp_cap_data.vdp_video_mixer_query_feature_support( + device, + feature, + is_supported + ); + + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf(_vdp_cap_data.fp, " -> %d", ret); + if (ret == VDP_STATUS_OK) { + fprintf(_vdp_cap_data.fp, ", %d", *is_supported); + } + fputs("\n", _vdp_cap_data.fp); + } + + return ret; +} + +static VdpStatus _vdp_cap_video_mixer_query_parameter_support( + VdpDevice device, + VdpVideoMixerParameter parameter, + /* output parameters follow */ + VdpBool * is_supported +) +{ + VdpStatus ret; + + fputs("vdp_video_mixer_query_parameter_support(", _vdp_cap_data.fp); + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf( + _vdp_cap_data.fp, + "%u, %u, %s", + device, + parameter, + is_supported ? "-" : "NULL" + ); + } + fputs(")\n", _vdp_cap_data.fp); + + ret = _vdp_cap_data.vdp_video_mixer_query_parameter_support( + device, + parameter, + is_supported + ); + + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf(_vdp_cap_data.fp, " -> %d", ret); + if (ret == VDP_STATUS_OK) { + fprintf(_vdp_cap_data.fp, ", %d", *is_supported); + } + fputs("\n", _vdp_cap_data.fp); + } + + return ret; +} + +static VdpStatus _vdp_cap_video_mixer_query_attribute_support( + VdpDevice device, + VdpVideoMixerAttribute attribute, + /* output parameters follow */ + VdpBool * is_supported +) +{ + VdpStatus ret; + + fputs("vdp_video_mixer_query_attribute_support(", _vdp_cap_data.fp); + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf( + _vdp_cap_data.fp, + "%u, %u, %s", + device, + attribute, + is_supported ? "-" : "NULL" + ); + } + fputs(")\n", _vdp_cap_data.fp); + + ret = _vdp_cap_data.vdp_video_mixer_query_attribute_support( + device, + attribute, + is_supported + ); + + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf(_vdp_cap_data.fp, " -> %d", ret); + if (ret == VDP_STATUS_OK) { + fprintf(_vdp_cap_data.fp, ", %d", *is_supported); + } + fputs("\n", _vdp_cap_data.fp); + } + + return ret; +} + +static VdpStatus _vdp_cap_video_mixer_query_parameter_value_range( + VdpDevice device, + VdpVideoMixerParameter parameter, + /* output parameters follow */ + void * min_value, + void * max_value +) +{ + VdpStatus ret; + + fputs("vdp_video_mixer_query_parameter_value_range(", _vdp_cap_data.fp); + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf( + _vdp_cap_data.fp, + "%u, %u, %s, %s", + device, + parameter, + min_value ? "-" : "NULL", + max_value ? "-" : "NULL" + ); + } + fputs(")\n", _vdp_cap_data.fp); + + ret = _vdp_cap_data.vdp_video_mixer_query_parameter_value_range( + device, + parameter, + min_value, + max_value + ); + + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf(_vdp_cap_data.fp, " -> %d", ret); + if (ret == VDP_STATUS_OK) { + fputs(", ", _vdp_cap_data.fp); + _vdp_cap_dump_video_mixer_parameter_value(parameter, min_value); + fputs(", ", _vdp_cap_data.fp); + _vdp_cap_dump_video_mixer_parameter_value(parameter, max_value); + } + fputs("\n", _vdp_cap_data.fp); + } + + return ret; +} + +static VdpStatus _vdp_cap_video_mixer_query_attribute_value_range( + VdpDevice device, + VdpVideoMixerAttribute attribute, + /* output parameters follow */ + void * min_value, + void * max_value +) +{ + VdpStatus ret; + + fputs("vdp_video_mixer_query_attribute_value_range(", _vdp_cap_data.fp); + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf( + _vdp_cap_data.fp, + "%u, %u, %s, %s", + device, + attribute, + min_value ? "-" : "NULL", + max_value ? "-" : "NULL" + ); + } + fputs(")\n", _vdp_cap_data.fp); + + ret = _vdp_cap_data.vdp_video_mixer_query_attribute_value_range( + device, + attribute, + min_value, + max_value + ); + + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf(_vdp_cap_data.fp, " -> %d", ret); + if (ret == VDP_STATUS_OK) { + fputs(", ", _vdp_cap_data.fp); + _vdp_cap_dump_video_mixer_attribute_value(attribute, min_value, false); + fputs(", ", _vdp_cap_data.fp); + _vdp_cap_dump_video_mixer_attribute_value(attribute, max_value, false); + } + fputs("\n", _vdp_cap_data.fp); + } + + return ret; +} + +static VdpStatus _vdp_cap_video_mixer_create( + VdpDevice device, + uint32_t feature_count, + VdpVideoMixerFeature const * features, + uint32_t parameter_count, + VdpVideoMixerParameter const * parameters, + void const * const * parameter_values, + /* output parameters follow */ + VdpVideoMixer * mixer +) +{ + VdpStatus ret; + + fputs("vdp_video_mixer_create(", _vdp_cap_data.fp); + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf(_vdp_cap_data.fp, "%u, %u, ", device, feature_count); + _vdp_cap_dump_video_mixer_feature_list(feature_count, features); + fprintf(_vdp_cap_data.fp, ", %u, ", parameter_count); + _vdp_cap_dump_video_mixer_parameter_list(parameter_count, parameters); + fputs(", ", _vdp_cap_data.fp); + _vdp_cap_dump_video_mixer_parameter_value_list( + parameter_count, + parameters, + parameter_values + ); + fprintf(_vdp_cap_data.fp, ", %s", mixer ? "-" : "NULL"); + } + fputs(")\n", _vdp_cap_data.fp); + + ret = _vdp_cap_data.vdp_video_mixer_create( + device, + feature_count, + features, + parameter_count, + parameters, + parameter_values, + mixer + ); + + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf(_vdp_cap_data.fp, " -> %d", ret); + if (ret == VDP_STATUS_OK) { + fprintf( + _vdp_cap_data.fp, + ", %u", + *mixer + ); + } + fputs("\n", _vdp_cap_data.fp); + } + + return ret; +} + +static VdpStatus _vdp_cap_video_mixer_set_feature_enables( + VdpVideoMixer mixer, + uint32_t feature_count, + VdpVideoMixerFeature const * features, + VdpBool const * feature_enables +) +{ + VdpStatus ret; + + fputs("vdp_video_mixer_set_feature_enables(", _vdp_cap_data.fp); + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf(_vdp_cap_data.fp, "%u, %u, ", mixer, feature_count); + _vdp_cap_dump_video_mixer_feature_list(feature_count, features); + fputs(", ", _vdp_cap_data.fp); + _vdp_cap_dump_bool_list(feature_count, feature_enables); + } + fputs(")\n", _vdp_cap_data.fp); + + ret = _vdp_cap_data.vdp_video_mixer_set_feature_enables( + mixer, + feature_count, + features, + feature_enables + ); + + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf(_vdp_cap_data.fp, " -> %d\n", ret); + } + + return ret; +} + +static VdpStatus _vdp_cap_video_mixer_set_attribute_values( + VdpVideoMixer mixer, + uint32_t attribute_count, + VdpVideoMixerAttribute const * attributes, + void const * const * attribute_values +) +{ + VdpStatus ret; + + fputs("vdp_video_mixer_set_attribute_values(", _vdp_cap_data.fp); + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf(_vdp_cap_data.fp, "%u, %u, ", mixer, attribute_count); + _vdp_cap_dump_video_mixer_attribute_list(attribute_count, attributes); + fputs(", ", _vdp_cap_data.fp); + _vdp_cap_dump_video_mixer_attribute_value_list( + attribute_count, + attributes, + attribute_values, + false + ); + } + fputs(")\n", _vdp_cap_data.fp); + + ret = _vdp_cap_data.vdp_video_mixer_set_attribute_values( + mixer, + attribute_count, + attributes, + attribute_values + ); + + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf(_vdp_cap_data.fp, " -> %d\n", ret); + } + + return ret; +} + +static VdpStatus _vdp_cap_video_mixer_get_feature_support( + VdpVideoMixer mixer, + uint32_t feature_count, + VdpVideoMixerFeature const * features, + /* output parameters follow */ + VdpBool * feature_supports +) +{ + VdpStatus ret; + + fputs("vdp_video_mixer_get_feature_support(", _vdp_cap_data.fp); + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf(_vdp_cap_data.fp, "%u, %u, ", mixer, feature_count); + _vdp_cap_dump_video_mixer_feature_list(feature_count, features); + fputs(feature_supports ? "-" : "NULL", _vdp_cap_data.fp); + } + fputs(")\n", _vdp_cap_data.fp); + + ret = _vdp_cap_data.vdp_video_mixer_get_feature_support( + mixer, + feature_count, + features, + feature_supports + ); + + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf(_vdp_cap_data.fp, " -> %d", ret); + if (ret == VDP_STATUS_OK) { + fputs(", ", _vdp_cap_data.fp); + _vdp_cap_dump_bool_list(feature_count, feature_supports); + } + fputs("\n", _vdp_cap_data.fp); + } + + return ret; +} + +static VdpStatus _vdp_cap_video_mixer_get_feature_enables( + VdpVideoMixer mixer, + uint32_t feature_count, + VdpVideoMixerFeature const * features, + /* output parameters follow */ + VdpBool * feature_enables +) +{ + VdpStatus ret; + + fputs("vdp_video_mixer_get_feature_enables(", _vdp_cap_data.fp); + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf(_vdp_cap_data.fp, "%u, %u, ", mixer, feature_count); + _vdp_cap_dump_video_mixer_feature_list(feature_count, features); + fprintf(_vdp_cap_data.fp, ", %s", feature_enables ? "-" : "NULL"); + } + fputs(")\n", _vdp_cap_data.fp); + + ret = _vdp_cap_data.vdp_video_mixer_get_feature_enables( + mixer, + feature_count, + features, + feature_enables + ); + + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf(_vdp_cap_data.fp, " -> %d", ret); + if (ret == VDP_STATUS_OK) { + fputs(", ", _vdp_cap_data.fp); + _vdp_cap_dump_bool_list(feature_count, feature_enables); + } + fputs("\n", _vdp_cap_data.fp); + } + + return ret; +} + +static VdpStatus _vdp_cap_video_mixer_get_parameter_values( + VdpVideoMixer mixer, + uint32_t parameter_count, + VdpVideoMixerParameter const * parameters, + /* output parameters follow */ + void * const * parameter_values +) +{ + VdpStatus ret; + + fputs("vdp_video_mixer_get_parameter_values(", _vdp_cap_data.fp); + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf(_vdp_cap_data.fp, "%u, %u, ", mixer, parameter_count); + _vdp_cap_dump_video_mixer_parameter_list(parameter_count, parameters); + fprintf(_vdp_cap_data.fp, ", %s", parameter_values ? "-" : "NULL"); + } + fputs(")\n", _vdp_cap_data.fp); + + ret = _vdp_cap_data.vdp_video_mixer_get_parameter_values( + mixer, + parameter_count, + parameters, + parameter_values + ); + + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf(_vdp_cap_data.fp, " -> %d", ret); + if (ret == VDP_STATUS_OK) { + fputs(", ", _vdp_cap_data.fp); + _vdp_cap_dump_video_mixer_parameter_value_list( + parameter_count, + parameters, + parameter_values + ); + } + fputs("\n", _vdp_cap_data.fp); + } + + return ret; +} + +static VdpStatus _vdp_cap_video_mixer_get_attribute_values( + VdpVideoMixer mixer, + uint32_t attribute_count, + VdpVideoMixerAttribute const * attributes, + /* output parameters follow */ + void * const * attribute_values +) +{ + VdpStatus ret; + + fputs("vdp_video_mixer_get_attribute_values(", _vdp_cap_data.fp); + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf(_vdp_cap_data.fp, "%u, %u, ", mixer, attribute_count); + _vdp_cap_dump_video_mixer_attribute_list(attribute_count, attributes); + fprintf(_vdp_cap_data.fp, ", %s", attribute_values ? "-" : "NULL"); + } + fputs(")\n", _vdp_cap_data.fp); + + ret = _vdp_cap_data.vdp_video_mixer_get_attribute_values( + mixer, + attribute_count, + attributes, + attribute_values + ); + + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf(_vdp_cap_data.fp, " -> %d", ret); + if (ret == VDP_STATUS_OK) { + fputs(", ", _vdp_cap_data.fp); + _vdp_cap_dump_video_mixer_attribute_value_list( + attribute_count, + attributes, + attribute_values, + true + ); + } + fputs("\n", _vdp_cap_data.fp); + } + + return ret; +} + +static VdpStatus _vdp_cap_video_mixer_destroy( + VdpVideoMixer mixer +) +{ + VdpStatus ret; + + fputs("vdp_video_mixer_destroy(", _vdp_cap_data.fp); + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf( + _vdp_cap_data.fp, + "%u", + mixer + ); + } + fputs(")\n", _vdp_cap_data.fp); + + ret = _vdp_cap_data.vdp_video_mixer_destroy( + mixer + ); + + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf(_vdp_cap_data.fp, " -> %d\n", ret); + } + + return ret; +} + +static VdpStatus _vdp_cap_video_mixer_render( + VdpVideoMixer mixer, + VdpOutputSurface background_surface, + VdpRect const * background_source_rect, + VdpVideoMixerPictureStructure current_picture_structure, + uint32_t video_surface_past_count, + VdpVideoSurface const * video_surface_past, + VdpVideoSurface video_surface_current, + uint32_t video_surface_future_count, + VdpVideoSurface const * video_surface_future, + VdpRect const * video_source_rect, + VdpOutputSurface destination_surface, + VdpRect const * destination_rect, + VdpRect const * destination_video_rect, + uint32_t layer_count, + VdpLayer const * layers +) +{ + VdpStatus ret; + + fputs("vdp_video_mixer_render(", _vdp_cap_data.fp); + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf( + _vdp_cap_data.fp, + "%u, %u, ", + mixer, + background_surface + ); + _vdp_cap_dump_rect(background_source_rect); + fprintf( + _vdp_cap_data.fp, + ", %d, %u, ", + current_picture_structure, + video_surface_past_count + ); + _vdp_cap_dump_uint32_t_list(video_surface_past_count, video_surface_past, false); + fprintf( + _vdp_cap_data.fp, + ", %u, %u, ", + video_surface_current, + video_surface_future_count + ); + _vdp_cap_dump_uint32_t_list(video_surface_future_count, video_surface_future, false); + fputs(", ", _vdp_cap_data.fp); + _vdp_cap_dump_rect(video_source_rect); + fprintf( + _vdp_cap_data.fp, + ", %u, ", + destination_surface + ); + _vdp_cap_dump_rect(destination_rect); + fputs(", ", _vdp_cap_data.fp); + _vdp_cap_dump_rect(destination_video_rect); + fprintf( + _vdp_cap_data.fp, + ", %u, ", + layer_count + ); + _vdp_cap_dump_layers_list(layer_count, layers); + } + fputs(")\n", _vdp_cap_data.fp); + + ret = _vdp_cap_data.vdp_video_mixer_render( + mixer, + background_surface, + background_source_rect, + current_picture_structure, + video_surface_past_count, + video_surface_past, + video_surface_current, + video_surface_future_count, + video_surface_future, + video_source_rect, + destination_surface, + destination_rect, + destination_video_rect, + layer_count, + layers + ); + + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf(_vdp_cap_data.fp, " -> %d\n", ret); + } + + return ret; +} + +static VdpStatus _vdp_cap_presentation_queue_target_destroy( + VdpPresentationQueueTarget presentation_queue_target +) +{ + VdpStatus ret; + + fputs("vdp_presentation_queue_target_destroy(", _vdp_cap_data.fp); + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf( + _vdp_cap_data.fp, + "%u", + presentation_queue_target + ); + } + fputs(")\n", _vdp_cap_data.fp); + + ret = _vdp_cap_data.vdp_presentation_queue_target_destroy( + presentation_queue_target + ); + + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf(_vdp_cap_data.fp, " -> %d\n", ret); + } + + return ret; +} + +static VdpStatus _vdp_cap_presentation_queue_create( + VdpDevice device, + VdpPresentationQueueTarget presentation_queue_target, + /* output parameters follow */ + VdpPresentationQueue * presentation_queue +) +{ + VdpStatus ret; + + fputs("vdp_presentation_queue_create(", _vdp_cap_data.fp); + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf( + _vdp_cap_data.fp, + "%u, %u, %s", + device, + presentation_queue_target, + presentation_queue ? "-" : "NULL" + ); + } + fputs(")\n", _vdp_cap_data.fp); + + ret = _vdp_cap_data.vdp_presentation_queue_create( + device, + presentation_queue_target, + presentation_queue + ); + + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf(_vdp_cap_data.fp, " -> %d", ret); + if (ret == VDP_STATUS_OK) { + fprintf( + _vdp_cap_data.fp, + ", %u", + *presentation_queue + ); + } + fputs("\n", _vdp_cap_data.fp); + } + + return ret; +} + +static VdpStatus _vdp_cap_presentation_queue_destroy( + VdpPresentationQueue presentation_queue +) +{ + VdpStatus ret; + + fputs("vdp_presentation_queue_destroy(", _vdp_cap_data.fp); + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf( + _vdp_cap_data.fp, + "%u", + presentation_queue + ); + } + fputs(")\n", _vdp_cap_data.fp); + + ret = _vdp_cap_data.vdp_presentation_queue_destroy( + presentation_queue + ); + + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf(_vdp_cap_data.fp, " -> %d\n", ret); + } + + return ret; +} + +static VdpStatus _vdp_cap_presentation_queue_set_background_color( + VdpPresentationQueue presentation_queue, + VdpColor * const background_color +) +{ + VdpStatus ret; + + fputs("vdp_presentation_queue_set_background_color(", _vdp_cap_data.fp); + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf( + _vdp_cap_data.fp, + "%u, ", + presentation_queue + ); + _vdp_cap_dump_color(background_color); + } + fputs(")\n", _vdp_cap_data.fp); + + ret = _vdp_cap_data.vdp_presentation_queue_set_background_color( + presentation_queue, + background_color + ); + + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf(_vdp_cap_data.fp, " -> %d\n", ret); + } + + return ret; +} + +static VdpStatus _vdp_cap_presentation_queue_get_background_color( + VdpPresentationQueue presentation_queue, + VdpColor * background_color +) +{ + VdpStatus ret; + + fputs("vdp_presentation_queue_get_background_color(", _vdp_cap_data.fp); + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf( + _vdp_cap_data.fp, + "%u, %s", + presentation_queue, + background_color ? "-" : "NULL" + ); + } + fputs(")\n", _vdp_cap_data.fp); + + ret = _vdp_cap_data.vdp_presentation_queue_get_background_color( + presentation_queue, + background_color + ); + + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf(_vdp_cap_data.fp, " -> %d", ret); + if (ret == VDP_STATUS_OK) { + fputs(", ", _vdp_cap_data.fp); + _vdp_cap_dump_color(background_color); + } + fputs("\n", _vdp_cap_data.fp); + } + + return ret; +} + +static VdpStatus _vdp_cap_presentation_queue_get_time( + VdpPresentationQueue presentation_queue, + /* output parameters follow */ + VdpTime * current_time +) +{ + VdpStatus ret; + + fputs("vdp_presentation_queue_get_time(", _vdp_cap_data.fp); + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf( + _vdp_cap_data.fp, + "%u, %s", + presentation_queue, + current_time ? "-" : "NULL" + ); + } + fputs(")\n", _vdp_cap_data.fp); + + ret = _vdp_cap_data.vdp_presentation_queue_get_time( + presentation_queue, + current_time + ); + + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf(_vdp_cap_data.fp, " -> %d", ret); + if (ret == VDP_STATUS_OK) { + fprintf( + _vdp_cap_data.fp, + ", %" PRIu64, + *current_time + ); + } + fputs("\n", _vdp_cap_data.fp); + } + + return ret; +} + +static VdpStatus _vdp_cap_presentation_queue_display( + VdpPresentationQueue presentation_queue, + VdpOutputSurface surface, + uint32_t clip_width, + uint32_t clip_height, + VdpTime earliest_presentation_time +) +{ + VdpStatus ret; + + fputs("vdp_presentation_queue_display(", _vdp_cap_data.fp); + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf( + _vdp_cap_data.fp, + "%u, %u, %u, %u, %" PRIu64, + presentation_queue, + surface, + clip_width, + clip_height, + earliest_presentation_time + ); + } + fputs(")\n", _vdp_cap_data.fp); + + ret = _vdp_cap_data.vdp_presentation_queue_display( + presentation_queue, + surface, + clip_width, + clip_height, + earliest_presentation_time + ); + + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf(_vdp_cap_data.fp, " -> %d\n", ret); + } + + return ret; +} + +static VdpStatus _vdp_cap_presentation_queue_block_until_surface_idle( + VdpPresentationQueue presentation_queue, + VdpOutputSurface surface, + /* output parameters follow */ + VdpTime * first_presentation_time +) +{ + VdpStatus ret; + + fputs("vdp_presentation_queue_block_until_surface_idle(", _vdp_cap_data.fp); + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf( + _vdp_cap_data.fp, + "%u, %u, %s", + presentation_queue, + surface, + first_presentation_time ? "-" : "NULL" + ); + } + fputs(")\n", _vdp_cap_data.fp); + + ret = _vdp_cap_data.vdp_presentation_queue_block_until_surface_idle( + presentation_queue, + surface, + first_presentation_time + ); + + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf(_vdp_cap_data.fp, " -> %d", ret); + if (ret == VDP_STATUS_OK) { + fprintf( + _vdp_cap_data.fp, + ", %" PRIu64, + *first_presentation_time + ); + } + fputs("\n", _vdp_cap_data.fp); + } + + return ret; +} + +static VdpStatus _vdp_cap_presentation_queue_query_surface_status( + VdpPresentationQueue presentation_queue, + VdpOutputSurface surface, + /* output parameters follow */ + VdpPresentationQueueStatus * status, + VdpTime * first_presentation_time +) +{ + VdpStatus ret; + + fputs("vdp_presentation_queue_query_surface_status(", _vdp_cap_data.fp); + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf( + _vdp_cap_data.fp, + "%u, %u, %s, %s", + presentation_queue, + surface, + status ? "-" : "NULL", + first_presentation_time ? "-" : "NULL" + ); + } + fputs(")\n", _vdp_cap_data.fp); + + ret = _vdp_cap_data.vdp_presentation_queue_query_surface_status( + presentation_queue, + surface, + status, + first_presentation_time + ); + + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf(_vdp_cap_data.fp, " -> %d", ret); + if (ret == VDP_STATUS_OK) { + fprintf( + _vdp_cap_data.fp, + ", %d, %" PRIu64, + *status, + *first_presentation_time + ); + } + fputs("\n", _vdp_cap_data.fp); + } + + return ret; +} + +static VdpStatus _vdp_cap_preemption_callback_register( + VdpDevice device, + VdpPreemptionCallback callback, + void * context +) +{ + VdpStatus ret; + + fputs("vdp_preemption_callback_register(", _vdp_cap_data.fp); + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf( + _vdp_cap_data.fp, + "%u, %p, %p", + device, + callback, + context + ); + } + fputs(")\n", _vdp_cap_data.fp); + + ret = _vdp_cap_data.vdp_preemption_callback_register( + device, + callback, + context + ); + + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf(_vdp_cap_data.fp, " -> %d\n", ret); + } + + return ret; +} + +static VdpStatus _vdp_cap_presentation_queue_target_create_x11( + VdpDevice device, + Drawable drawable, + /* output parameters follow */ + VdpPresentationQueueTarget * target +) +{ + VdpStatus ret; + + fprintf(_vdp_cap_data.fp, "vdp_presentation_queue_target_create_x11("); + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf( + _vdp_cap_data.fp, + "%u, %lu, %s", + device, + drawable, + target ? "-" : "NULL" + ); + } + fputs(")\n", _vdp_cap_data.fp); + + ret = _vdp_cap_data.vdp_presentation_queue_target_create_x11( + device, + drawable, + target + ); + + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf(_vdp_cap_data.fp, " -> %d", ret); + if (ret == VDP_STATUS_OK) { + fprintf( + _vdp_cap_data.fp, + ", %u", + *target + ); + } + fputs("\n", _vdp_cap_data.fp); + } + + return ret; +} + +static VdpStatus _vdp_cap_get_proc_address( + VdpDevice device, + VdpFuncId function_id, + /* output parameters follow */ + void * * function_pointer +) +{ + VdpStatus ret; + + fputs("vdp_get_proc_address(", _vdp_cap_data.fp); + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf( + _vdp_cap_data.fp, + "%u, %u, %s", + device, + function_id, + function_pointer ? "-" : "NULL" + ); + } + fputs(")\n", _vdp_cap_data.fp); + + if (device != _vdp_cap_data.vdp_device) { + _VDP_TRACE_ERROR_BREAKPOINT(); + ret = VDP_STATUS_ERROR; + } + else if (!function_pointer) { + _VDP_TRACE_ERROR_BREAKPOINT(); + ret = VDP_STATUS_ERROR; + } + else { + ret = VDP_STATUS_OK; + + switch (function_id) { + case VDP_FUNC_ID_GET_ERROR_STRING: + *function_pointer = (void *)&_vdp_cap_get_error_string; + break; + case VDP_FUNC_ID_GET_PROC_ADDRESS: + *function_pointer = (void *)&_vdp_cap_get_proc_address; + break; + case VDP_FUNC_ID_GET_API_VERSION: + *function_pointer = (void *)&_vdp_cap_get_api_version; + break; + case VDP_FUNC_ID_GET_INFORMATION_STRING: + *function_pointer = (void *)&_vdp_cap_get_information_string; + break; + case VDP_FUNC_ID_DEVICE_DESTROY: + *function_pointer = (void *)&_vdp_cap_device_destroy; + break; + case VDP_FUNC_ID_GENERATE_CSC_MATRIX: + *function_pointer = (void *)&_vdp_cap_generate_csc_matrix; + break; + case VDP_FUNC_ID_VIDEO_SURFACE_QUERY_CAPABILITIES: + *function_pointer = (void *)&_vdp_cap_video_surface_query_capabilities; + break; + case VDP_FUNC_ID_VIDEO_SURFACE_QUERY_GET_PUT_BITS_Y_CB_CR_CAPABILITIES: + *function_pointer = (void *)&_vdp_cap_video_surface_query_get_put_bits_y_cb_cr_capabilities; + break; + case VDP_FUNC_ID_VIDEO_SURFACE_CREATE: + *function_pointer = (void *)&_vdp_cap_video_surface_create; + break; + case VDP_FUNC_ID_VIDEO_SURFACE_DESTROY: + *function_pointer = (void *)&_vdp_cap_video_surface_destroy; + break; + case VDP_FUNC_ID_VIDEO_SURFACE_GET_PARAMETERS: + *function_pointer = (void *)&_vdp_cap_video_surface_get_parameters; + break; + case VDP_FUNC_ID_VIDEO_SURFACE_GET_BITS_Y_CB_CR: + *function_pointer = (void *)&_vdp_cap_video_surface_get_bits_y_cb_cr; + break; + case VDP_FUNC_ID_VIDEO_SURFACE_PUT_BITS_Y_CB_CR: + *function_pointer = (void *)&_vdp_cap_video_surface_put_bits_y_cb_cr; + break; + case VDP_FUNC_ID_OUTPUT_SURFACE_QUERY_CAPABILITIES: + *function_pointer = (void *)&_vdp_cap_output_surface_query_capabilities; + break; + case VDP_FUNC_ID_OUTPUT_SURFACE_QUERY_GET_PUT_BITS_NATIVE_CAPABILITIES: + *function_pointer = (void *)&_vdp_cap_output_surface_query_get_put_bits_native_capabilities; + break; + case VDP_FUNC_ID_OUTPUT_SURFACE_QUERY_PUT_BITS_INDEXED_CAPABILITIES: + *function_pointer = (void *)&_vdp_cap_output_surface_query_put_bits_indexed_capabilities; + break; + case VDP_FUNC_ID_OUTPUT_SURFACE_QUERY_PUT_BITS_Y_CB_CR_CAPABILITIES: + *function_pointer = (void *)&_vdp_cap_output_surface_query_put_bits_y_cb_cr_capabilities; + break; + case VDP_FUNC_ID_OUTPUT_SURFACE_CREATE: + *function_pointer = (void *)&_vdp_cap_output_surface_create; + break; + case VDP_FUNC_ID_OUTPUT_SURFACE_DESTROY: + *function_pointer = (void *)&_vdp_cap_output_surface_destroy; + break; + case VDP_FUNC_ID_OUTPUT_SURFACE_GET_PARAMETERS: + *function_pointer = (void *)&_vdp_cap_output_surface_get_parameters; + break; + case VDP_FUNC_ID_OUTPUT_SURFACE_GET_BITS_NATIVE: + *function_pointer = (void *)&_vdp_cap_output_surface_get_bits_native; + break; + case VDP_FUNC_ID_OUTPUT_SURFACE_PUT_BITS_NATIVE: + *function_pointer = (void *)&_vdp_cap_output_surface_put_bits_native; + break; + case VDP_FUNC_ID_OUTPUT_SURFACE_PUT_BITS_INDEXED: + *function_pointer = (void *)&_vdp_cap_output_surface_put_bits_indexed; + break; + case VDP_FUNC_ID_OUTPUT_SURFACE_PUT_BITS_Y_CB_CR: + *function_pointer = (void *)&_vdp_cap_output_surface_put_bits_y_cb_cr; + break; + case VDP_FUNC_ID_BITMAP_SURFACE_QUERY_CAPABILITIES: + *function_pointer = (void *)&_vdp_cap_bitmap_surface_query_capabilities; + break; + case VDP_FUNC_ID_BITMAP_SURFACE_CREATE: + *function_pointer = (void *)&_vdp_cap_bitmap_surface_create; + break; + case VDP_FUNC_ID_BITMAP_SURFACE_DESTROY: + *function_pointer = (void *)&_vdp_cap_bitmap_surface_destroy; + break; + case VDP_FUNC_ID_BITMAP_SURFACE_GET_PARAMETERS: + *function_pointer = (void *)&_vdp_cap_bitmap_surface_get_parameters; + break; + case VDP_FUNC_ID_BITMAP_SURFACE_PUT_BITS_NATIVE: + *function_pointer = (void *)&_vdp_cap_bitmap_surface_put_bits_native; + break; + case VDP_FUNC_ID_OUTPUT_SURFACE_RENDER_OUTPUT_SURFACE: + *function_pointer = (void *)&_vdp_cap_output_surface_render_output_surface; + break; + case VDP_FUNC_ID_OUTPUT_SURFACE_RENDER_BITMAP_SURFACE: + *function_pointer = (void *)&_vdp_cap_output_surface_render_bitmap_surface; + break; + case VDP_FUNC_ID_DECODER_QUERY_CAPABILITIES: + *function_pointer = (void *)&_vdp_cap_decoder_query_capabilities; + break; + case VDP_FUNC_ID_DECODER_CREATE: + *function_pointer = (void *)&_vdp_cap_decoder_create; + break; + case VDP_FUNC_ID_DECODER_DESTROY: + *function_pointer = (void *)&_vdp_cap_decoder_destroy; + break; + case VDP_FUNC_ID_DECODER_GET_PARAMETERS: + *function_pointer = (void *)&_vdp_cap_decoder_get_parameters; + break; + case VDP_FUNC_ID_DECODER_RENDER: + *function_pointer = (void *)&_vdp_cap_decoder_render; + break; + case VDP_FUNC_ID_VIDEO_MIXER_QUERY_FEATURE_SUPPORT: + *function_pointer = (void *)&_vdp_cap_video_mixer_query_feature_support; + break; + case VDP_FUNC_ID_VIDEO_MIXER_QUERY_PARAMETER_SUPPORT: + *function_pointer = (void *)&_vdp_cap_video_mixer_query_parameter_support; + break; + case VDP_FUNC_ID_VIDEO_MIXER_QUERY_ATTRIBUTE_SUPPORT: + *function_pointer = (void *)&_vdp_cap_video_mixer_query_attribute_support; + break; + case VDP_FUNC_ID_VIDEO_MIXER_QUERY_PARAMETER_VALUE_RANGE: + *function_pointer = (void *)&_vdp_cap_video_mixer_query_parameter_value_range; + break; + case VDP_FUNC_ID_VIDEO_MIXER_QUERY_ATTRIBUTE_VALUE_RANGE: + *function_pointer = (void *)&_vdp_cap_video_mixer_query_attribute_value_range; + break; + case VDP_FUNC_ID_VIDEO_MIXER_CREATE: + *function_pointer = (void *)&_vdp_cap_video_mixer_create; + break; + case VDP_FUNC_ID_VIDEO_MIXER_SET_FEATURE_ENABLES: + *function_pointer = (void *)&_vdp_cap_video_mixer_set_feature_enables; + break; + case VDP_FUNC_ID_VIDEO_MIXER_SET_ATTRIBUTE_VALUES: + *function_pointer = (void *)&_vdp_cap_video_mixer_set_attribute_values; + break; + case VDP_FUNC_ID_VIDEO_MIXER_GET_FEATURE_SUPPORT: + *function_pointer = (void *)&_vdp_cap_video_mixer_get_feature_support; + break; + case VDP_FUNC_ID_VIDEO_MIXER_GET_FEATURE_ENABLES: + *function_pointer = (void *)&_vdp_cap_video_mixer_get_feature_enables; + break; + case VDP_FUNC_ID_VIDEO_MIXER_GET_PARAMETER_VALUES: + *function_pointer = (void *)&_vdp_cap_video_mixer_get_parameter_values; + break; + case VDP_FUNC_ID_VIDEO_MIXER_GET_ATTRIBUTE_VALUES: + *function_pointer = (void *)&_vdp_cap_video_mixer_get_attribute_values; + break; + case VDP_FUNC_ID_VIDEO_MIXER_DESTROY: + *function_pointer = (void *)&_vdp_cap_video_mixer_destroy; + break; + case VDP_FUNC_ID_VIDEO_MIXER_RENDER: + *function_pointer = (void *)&_vdp_cap_video_mixer_render; + break; + case VDP_FUNC_ID_PRESENTATION_QUEUE_TARGET_DESTROY: + *function_pointer = (void *)&_vdp_cap_presentation_queue_target_destroy; + break; + case VDP_FUNC_ID_PRESENTATION_QUEUE_CREATE: + *function_pointer = (void *)&_vdp_cap_presentation_queue_create; + break; + case VDP_FUNC_ID_PRESENTATION_QUEUE_DESTROY: + *function_pointer = (void *)&_vdp_cap_presentation_queue_destroy; + break; + case VDP_FUNC_ID_PRESENTATION_QUEUE_SET_BACKGROUND_COLOR: + *function_pointer = (void *)&_vdp_cap_presentation_queue_set_background_color; + break; + case VDP_FUNC_ID_PRESENTATION_QUEUE_GET_BACKGROUND_COLOR: + *function_pointer = (void *)&_vdp_cap_presentation_queue_get_background_color; + break; + case VDP_FUNC_ID_PRESENTATION_QUEUE_GET_TIME: + *function_pointer = (void *)&_vdp_cap_presentation_queue_get_time; + break; + case VDP_FUNC_ID_PRESENTATION_QUEUE_DISPLAY: + *function_pointer = (void *)&_vdp_cap_presentation_queue_display; + break; + case VDP_FUNC_ID_PRESENTATION_QUEUE_BLOCK_UNTIL_SURFACE_IDLE: + *function_pointer = (void *)&_vdp_cap_presentation_queue_block_until_surface_idle; + break; + case VDP_FUNC_ID_PRESENTATION_QUEUE_QUERY_SURFACE_STATUS: + *function_pointer = (void *)&_vdp_cap_presentation_queue_query_surface_status; + break; + case VDP_FUNC_ID_PREEMPTION_CALLBACK_REGISTER: + *function_pointer = (void *)&_vdp_cap_preemption_callback_register; + break; + case VDP_FUNC_ID_PRESENTATION_QUEUE_TARGET_CREATE_X11: + *function_pointer = (void *)&_vdp_cap_presentation_queue_target_create_x11; + break; + default: + fprintf( + _vdp_cap_data.fp, + "VDPAU capture: Not able to proxy function %d", + function_id + ); + ret = _vdp_cap_data.vdp_get_proc_address(device, function_id, function_pointer); + break; + } + + if ((ret == VDP_STATUS_OK) && !*function_pointer) { + ret = VDP_STATUS_INVALID_FUNC_ID; + } + } + + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf(_vdp_cap_data.fp, " -> %d", ret); + if (ret == VDP_STATUS_OK) { + fprintf( + _vdp_cap_data.fp, + ", %p", + *function_pointer + ); + } + fputs("\n", _vdp_cap_data.fp); + } + + return ret; +} + +extern "C" void vdp_trace_set_backend_handle( + void * driver_dll_handle +) +{ + _vdp_cap_data.dll = driver_dll_handle; +} + +extern "C" VdpDeviceCreateX11 vdp_trace_device_create_x11; + +VdpStatus vdp_trace_device_create_x11( + Display * display, + int screen, + /* output parameters follow */ + VdpDevice * device, + VdpGetProcAddress * * get_proc_address +) +{ + if (!device || !get_proc_address) { + _VDP_TRACE_ERROR_BREAKPOINT(); + return VDP_STATUS_INVALID_POINTER; + } + + // For now, the capture library only allows a single VdpDevice + // This could probably be fixed by dynamically associating most of + // _vdp_cap_data with a VdpDevice handle. + if (_vdp_cap_data.fp) { + fprintf(_vdp_cap_data.fp, + "VDPAU trace: Multiple devices created; " + "will return get_proc_address results from the latest only\n" + ); + } + else { + _vdp_cap_data.level = 0; + char const * vdpau_trace = getenv("VDPAU_TRACE"); + if (vdpau_trace) { + _vdp_cap_data.level = atoi(vdpau_trace); + } + + _vdp_cap_data.fp = 0; + char const * vdpau_trace_file = getenv("VDPAU_TRACE_FILE"); + if (vdpau_trace_file && strlen(vdpau_trace_file)) { + if (vdpau_trace_file[0] == '&') { + int fd = atoi(&vdpau_trace_file[1]); + _vdp_cap_data.fp = fdopen(fd, "wt"); + } + else { + _vdp_cap_data.fp = fopen(vdpau_trace_file, "wt"); + } + if (!_vdp_cap_data.fp) { + fprintf( + stderr, + "VDPAU capture: ERROR: Can't open '%s' for writing, defaulting to stderr\n", + vdpau_trace_file + ); + } + } + if (!_vdp_cap_data.fp) { + _vdp_cap_data.fp = stderr; + } + fprintf(_vdp_cap_data.fp, "VDPAU capture: Enabled\n"); + } + + fprintf(_vdp_cap_data.fp, "vdp_imp_device_create_x11("); + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf( + _vdp_cap_data.fp, + "%p, %d, %s, %s", + display, + screen, + device ? "-" : "NULL", + get_proc_address ? "-" : "NULL" + ); + } + fputs(")\n", _vdp_cap_data.fp); + + VdpStatus vdp_st = VDP_STATUS_ERROR; + + VdpDeviceCreateX11 * vdp_imp_device_create_x11; + vdp_imp_device_create_x11 = (VdpDeviceCreateX11*)dlsym( + _vdp_cap_data.dll, + "vdp_imp_device_create_x11" + ); + if (!vdp_imp_device_create_x11) { + _VDP_TRACE_ERROR_BREAKPOINT(); + vdp_st = VDP_STATUS_NO_IMPLEMENTATION; + goto done; + } + + vdp_st = vdp_imp_device_create_x11( + display, + screen, + &_vdp_cap_data.vdp_device, + &_vdp_cap_data.vdp_get_proc_address + ); + if (vdp_st != VDP_STATUS_OK) { + _VDP_TRACE_ERROR_BREAKPOINT(); + goto done; + } + + *device = _vdp_cap_data.vdp_device; + *get_proc_address = _vdp_cap_get_proc_address; + +#define GET_POINTER(_id_, _var_) \ + vdp_st = _vdp_cap_data.vdp_get_proc_address( \ + _vdp_cap_data.vdp_device, \ + (_id_), \ + (void * *)&_vdp_cap_data._var_ \ + ); \ + if (vdp_st != VDP_STATUS_OK) { \ + _vdp_cap_data._var_ = 0; \ + } + + GET_POINTER(VDP_FUNC_ID_PREEMPTION_CALLBACK_REGISTER, vdp_preemption_callback_register); + GET_POINTER(VDP_FUNC_ID_GET_ERROR_STRING, vdp_get_error_string); + GET_POINTER(VDP_FUNC_ID_GET_API_VERSION, vdp_get_api_version); + GET_POINTER(VDP_FUNC_ID_GET_INFORMATION_STRING, vdp_get_information_string); + GET_POINTER(VDP_FUNC_ID_DEVICE_DESTROY, vdp_device_destroy); + GET_POINTER(VDP_FUNC_ID_GENERATE_CSC_MATRIX, vdp_generate_csc_matrix); + GET_POINTER(VDP_FUNC_ID_VIDEO_SURFACE_QUERY_CAPABILITIES, vdp_video_surface_query_capabilities); + GET_POINTER(VDP_FUNC_ID_VIDEO_SURFACE_QUERY_GET_PUT_BITS_Y_CB_CR_CAPABILITIES, vdp_video_surface_query_get_put_bits_y_cb_cr_capabilities); + GET_POINTER(VDP_FUNC_ID_VIDEO_SURFACE_CREATE, vdp_video_surface_create); + GET_POINTER(VDP_FUNC_ID_VIDEO_SURFACE_DESTROY, vdp_video_surface_destroy); + GET_POINTER(VDP_FUNC_ID_VIDEO_SURFACE_GET_PARAMETERS, vdp_video_surface_get_parameters); + GET_POINTER(VDP_FUNC_ID_VIDEO_SURFACE_GET_BITS_Y_CB_CR, vdp_video_surface_get_bits_y_cb_cr); + GET_POINTER(VDP_FUNC_ID_VIDEO_SURFACE_PUT_BITS_Y_CB_CR, vdp_video_surface_put_bits_y_cb_cr); + GET_POINTER(VDP_FUNC_ID_OUTPUT_SURFACE_QUERY_CAPABILITIES, vdp_output_surface_query_capabilities); + GET_POINTER(VDP_FUNC_ID_OUTPUT_SURFACE_QUERY_GET_PUT_BITS_NATIVE_CAPABILITIES, vdp_output_surface_query_get_put_bits_native_capabilities); + GET_POINTER(VDP_FUNC_ID_OUTPUT_SURFACE_QUERY_PUT_BITS_INDEXED_CAPABILITIES, vdp_output_surface_query_put_bits_indexed_capabilities); + GET_POINTER(VDP_FUNC_ID_OUTPUT_SURFACE_QUERY_PUT_BITS_Y_CB_CR_CAPABILITIES, vdp_output_surface_query_put_bits_y_cb_cr_capabilities); + GET_POINTER(VDP_FUNC_ID_OUTPUT_SURFACE_CREATE, vdp_output_surface_create); + GET_POINTER(VDP_FUNC_ID_OUTPUT_SURFACE_DESTROY, vdp_output_surface_destroy); + GET_POINTER(VDP_FUNC_ID_OUTPUT_SURFACE_GET_PARAMETERS, vdp_output_surface_get_parameters); + GET_POINTER(VDP_FUNC_ID_OUTPUT_SURFACE_GET_BITS_NATIVE, vdp_output_surface_get_bits_native); + GET_POINTER(VDP_FUNC_ID_OUTPUT_SURFACE_PUT_BITS_NATIVE, vdp_output_surface_put_bits_native); + GET_POINTER(VDP_FUNC_ID_OUTPUT_SURFACE_PUT_BITS_INDEXED, vdp_output_surface_put_bits_indexed); + GET_POINTER(VDP_FUNC_ID_OUTPUT_SURFACE_PUT_BITS_Y_CB_CR, vdp_output_surface_put_bits_y_cb_cr); + GET_POINTER(VDP_FUNC_ID_BITMAP_SURFACE_QUERY_CAPABILITIES, vdp_bitmap_surface_query_capabilities); + GET_POINTER(VDP_FUNC_ID_BITMAP_SURFACE_CREATE, vdp_bitmap_surface_create); + GET_POINTER(VDP_FUNC_ID_BITMAP_SURFACE_DESTROY, vdp_bitmap_surface_destroy); + GET_POINTER(VDP_FUNC_ID_BITMAP_SURFACE_GET_PARAMETERS, vdp_bitmap_surface_get_parameters); + GET_POINTER(VDP_FUNC_ID_BITMAP_SURFACE_PUT_BITS_NATIVE, vdp_bitmap_surface_put_bits_native); + GET_POINTER(VDP_FUNC_ID_OUTPUT_SURFACE_RENDER_OUTPUT_SURFACE, vdp_output_surface_render_output_surface); + GET_POINTER(VDP_FUNC_ID_OUTPUT_SURFACE_RENDER_BITMAP_SURFACE, vdp_output_surface_render_bitmap_surface); + GET_POINTER(VDP_FUNC_ID_DECODER_QUERY_CAPABILITIES, vdp_decoder_query_capabilities); + GET_POINTER(VDP_FUNC_ID_DECODER_CREATE, vdp_decoder_create); + GET_POINTER(VDP_FUNC_ID_DECODER_DESTROY, vdp_decoder_destroy); + GET_POINTER(VDP_FUNC_ID_DECODER_GET_PARAMETERS, vdp_decoder_get_parameters); + GET_POINTER(VDP_FUNC_ID_DECODER_RENDER, vdp_decoder_render); + GET_POINTER(VDP_FUNC_ID_VIDEO_MIXER_QUERY_FEATURE_SUPPORT, vdp_video_mixer_query_feature_support); + GET_POINTER(VDP_FUNC_ID_VIDEO_MIXER_QUERY_PARAMETER_SUPPORT, vdp_video_mixer_query_parameter_support); + GET_POINTER(VDP_FUNC_ID_VIDEO_MIXER_QUERY_ATTRIBUTE_SUPPORT, vdp_video_mixer_query_attribute_support); + GET_POINTER(VDP_FUNC_ID_VIDEO_MIXER_QUERY_PARAMETER_VALUE_RANGE, vdp_video_mixer_query_parameter_value_range); + GET_POINTER(VDP_FUNC_ID_VIDEO_MIXER_QUERY_ATTRIBUTE_VALUE_RANGE, vdp_video_mixer_query_attribute_value_range); + GET_POINTER(VDP_FUNC_ID_VIDEO_MIXER_CREATE, vdp_video_mixer_create); + GET_POINTER(VDP_FUNC_ID_VIDEO_MIXER_SET_FEATURE_ENABLES, vdp_video_mixer_set_feature_enables); + GET_POINTER(VDP_FUNC_ID_VIDEO_MIXER_SET_ATTRIBUTE_VALUES, vdp_video_mixer_set_attribute_values); + GET_POINTER(VDP_FUNC_ID_VIDEO_MIXER_GET_FEATURE_SUPPORT, vdp_video_mixer_get_feature_support); + GET_POINTER(VDP_FUNC_ID_VIDEO_MIXER_GET_FEATURE_ENABLES, vdp_video_mixer_get_feature_enables); + GET_POINTER(VDP_FUNC_ID_VIDEO_MIXER_GET_PARAMETER_VALUES, vdp_video_mixer_get_parameter_values); + GET_POINTER(VDP_FUNC_ID_VIDEO_MIXER_GET_ATTRIBUTE_VALUES, vdp_video_mixer_get_attribute_values); + GET_POINTER(VDP_FUNC_ID_VIDEO_MIXER_DESTROY, vdp_video_mixer_destroy); + GET_POINTER(VDP_FUNC_ID_VIDEO_MIXER_RENDER, vdp_video_mixer_render); + GET_POINTER(VDP_FUNC_ID_PRESENTATION_QUEUE_TARGET_DESTROY, vdp_presentation_queue_target_destroy); + GET_POINTER(VDP_FUNC_ID_PRESENTATION_QUEUE_CREATE, vdp_presentation_queue_create); + GET_POINTER(VDP_FUNC_ID_PRESENTATION_QUEUE_DESTROY, vdp_presentation_queue_destroy); + GET_POINTER(VDP_FUNC_ID_PRESENTATION_QUEUE_SET_BACKGROUND_COLOR, vdp_presentation_queue_set_background_color); + GET_POINTER(VDP_FUNC_ID_PRESENTATION_QUEUE_GET_BACKGROUND_COLOR, vdp_presentation_queue_get_background_color); + GET_POINTER(VDP_FUNC_ID_PRESENTATION_QUEUE_GET_TIME, vdp_presentation_queue_get_time); + GET_POINTER(VDP_FUNC_ID_PRESENTATION_QUEUE_DISPLAY, vdp_presentation_queue_display); + GET_POINTER(VDP_FUNC_ID_PRESENTATION_QUEUE_BLOCK_UNTIL_SURFACE_IDLE, vdp_presentation_queue_block_until_surface_idle); + GET_POINTER(VDP_FUNC_ID_PRESENTATION_QUEUE_QUERY_SURFACE_STATUS, vdp_presentation_queue_query_surface_status); + GET_POINTER(VDP_FUNC_ID_PREEMPTION_CALLBACK_REGISTER, vdp_preemption_callback_register); + GET_POINTER(VDP_FUNC_ID_PRESENTATION_QUEUE_TARGET_CREATE_X11, vdp_presentation_queue_target_create_x11); + + vdp_st = VDP_STATUS_OK; + +done: + if (_vdp_cap_data.level >= LEVEL_PARAMS) { + fprintf(_vdp_cap_data.fp, " -> %d", vdp_st); + if (vdp_st == VDP_STATUS_OK) { + fprintf( + _vdp_cap_data.fp, + ", %x, %p", + _vdp_cap_data.vdp_device, + _vdp_cap_data.vdp_get_proc_address + ); + } + fputs("\n", _vdp_cap_data.fp); + } + + return vdp_st; +} + |