void *handle; /**< Shared library handle */
};
+#define CHECK_FUNC(id) \
+ if (unlikely(vdp->funcs[VDP_FUNC_ID_##id] == NULL)) \
+ return VDP_STATUS_NO_IMPLEMENTATION
+
const char *vdp_get_error_string(const vdp_t *vdp, VdpStatus status)
{
+ if (unlikely(vdp->funcs[VDP_FUNC_ID_GET_ERROR_STRING] == NULL))
+ return (status != VDP_STATUS_OK) ? "Unknown error" : "No error";
return vdp->vt.get_error_string(status);
}
-static const char *vdp_get_error_string_fallback(const vdp_t *vdp,
- VdpStatus status)
-{
- (void) vdp;
- return (status != VDP_STATUS_OK) ? "Unknown error" : "No error";
-}
-
VdpStatus vdp_get_proc_address(const vdp_t *vdp, VdpDevice device,
VdpFuncId func_id, void **func_ptr)
{
+ CHECK_FUNC(GET_PROC_ADDRESS);
return vdp->vt.get_proc_address(device, func_id, func_ptr);
}
VdpStatus vdp_get_api_version(const vdp_t *vdp, uint32_t *ver)
{
+ CHECK_FUNC(GET_API_VERSION);
return vdp->vt.get_api_version(ver);
}
VdpStatus vdp_get_information_string(const vdp_t *vdp, const char **str)
{
+ CHECK_FUNC(GET_INFORMATION_STRING);
return vdp->vt.get_information_string(str);
}
/*** Device ***/
VdpStatus vdp_device_destroy(const vdp_t *vdp, VdpDevice device)
{
+ CHECK_FUNC(DEVICE_DESTROY);
return vdp->vt.device_destroy(device);
}
buf = *procamp;
copy = &buf;
}
+ CHECK_FUNC(GENERATE_CSC_MATRIX);
return vdp->vt.generate_csc_matrix(copy, standard, csc_matrix);
}
VdpStatus vdp_video_surface_query_capabilities(const vdp_t *vdp, VdpDevice dev,
VdpChromaType type, VdpBool *ok, uint32_t *mw, uint32_t *mh)
{
+ CHECK_FUNC(VIDEO_SURFACE_QUERY_CAPABILITIES);
return vdp->vt.video_surface_query_capabilities(dev, type, ok, mw, mh);
}
const vdp_t *vdp, VdpDevice device, VdpChromaType type, VdpYCbCrFormat fmt,
VdpBool *ok)
{
+ CHECK_FUNC(VIDEO_SURFACE_QUERY_GET_PUT_BITS_Y_CB_CR_CAPABILITIES);
return vdp->vt.video_surface_query_get_put_bits_y_cb_cr_capabilities(
device, type, fmt, ok);
}
VdpStatus vdp_video_surface_create(const vdp_t *vdp, VdpDevice device,
VdpChromaType chroma, uint32_t w, uint32_t h, VdpVideoSurface *surface)
{
+ CHECK_FUNC(VIDEO_SURFACE_CREATE);
return vdp->vt.video_surface_create(device, chroma, w, h, surface);
}
VdpStatus vdp_video_surface_destroy(const vdp_t *vdp, VdpVideoSurface surface)
{
+ CHECK_FUNC(VIDEO_SURFACE_DESTROY);
return vdp->vt.video_surface_destroy(surface);
}
VdpStatus vdp_video_surface_get_parameters(const vdp_t *vdp,
VdpVideoSurface surface, VdpChromaType *type, uint32_t *w, uint32_t *h)
{
+ CHECK_FUNC(VIDEO_SURFACE_GET_PARAMETERS);
return vdp->vt.video_surface_get_parameters(surface, type, w, h);
}
VdpVideoSurface surface, VdpYCbCrFormat fmt,
void *const *data, uint32_t const *pitches)
{
+ CHECK_FUNC(VIDEO_SURFACE_GET_BITS_Y_CB_CR);
return vdp->vt.video_surface_get_bits_y_cb_cr(surface, fmt, data, pitches);
}
VdpVideoSurface surface, VdpYCbCrFormat fmt,
const void *const *data, uint32_t const *pitches)
{
+ CHECK_FUNC(VIDEO_SURFACE_PUT_BITS_Y_CB_CR);
return vdp->vt.video_surface_put_bits_y_cb_cr(surface, fmt, data, pitches);
}
VdpDevice device, VdpRGBAFormat fmt, VdpBool *ok,
uint32_t *max_width, uint32_t *max_height)
{
+ CHECK_FUNC(OUTPUT_SURFACE_QUERY_CAPABILITIES);
return vdp->vt.output_surface_query_capabilities(device, fmt, ok,
max_width, max_height);
}
VdpStatus vdp_output_surface_query_get_put_bits_native_capabilities(
const vdp_t *vdp, VdpDevice device, VdpRGBAFormat fmt, VdpBool *ok)
{
+ CHECK_FUNC(OUTPUT_SURFACE_QUERY_GET_PUT_BITS_NATIVE_CAPABILITIES);
return vdp->vt.output_surface_query_get_put_bits_native_capabilities(
device, fmt, ok);
}
const vdp_t *vdp, VdpDevice device, VdpRGBAFormat fmt,
VdpIndexedFormat idxfmt, VdpColorTableFormat colfmt, VdpBool *ok)
{
+ CHECK_FUNC(OUTPUT_SURFACE_QUERY_PUT_BITS_INDEXED_CAPABILITIES);
return vdp->vt.output_surface_query_put_bits_indexed_capabilities(device,
fmt, idxfmt, colfmt, ok);
}
const vdp_t *vdp, VdpDevice device,
VdpRGBAFormat fmt, VdpYCbCrFormat yccfmt, VdpBool *ok)
{
+ CHECK_FUNC(OUTPUT_SURFACE_QUERY_PUT_BITS_Y_CB_CR_CAPABILITIES);
return vdp->vt.output_surface_query_put_bits_y_cb_cr_capabilities(device,
fmt, yccfmt, ok);
}
VdpStatus vdp_output_surface_create(const vdp_t *vdp, VdpDevice device,
VdpRGBAFormat fmt, uint32_t w, uint32_t h, VdpOutputSurface *surface)
{
+ CHECK_FUNC(OUTPUT_SURFACE_CREATE);
return vdp->vt.output_surface_create(device, fmt, w, h, surface);
}
VdpStatus vdp_output_surface_destroy(const vdp_t *vdp,
VdpOutputSurface surface)
{
+ CHECK_FUNC(OUTPUT_SURFACE_DESTROY);
return vdp->vt.output_surface_destroy(surface);
}
VdpStatus vdp_output_surface_get_parameters(const vdp_t *vdp,
VdpOutputSurface surface, VdpRGBAFormat *fmt, uint32_t *w, uint32_t *h)
{
+ CHECK_FUNC(OUTPUT_SURFACE_GET_PARAMETERS);
return vdp->vt.output_surface_get_parameters(surface, fmt, w, h);
}
VdpOutputSurface surface, const VdpRect *src,
void *const *data, uint32_t const *pitches)
{
+ CHECK_FUNC(OUTPUT_SURFACE_GET_BITS_NATIVE);
return vdp->vt.output_surface_get_bits_native(surface, src, data, pitches);
}
VdpOutputSurface surface, const void *const *data, uint32_t const *pitches,
const VdpRect *dst)
{
+ CHECK_FUNC(OUTPUT_SURFACE_PUT_BITS_NATIVE);
return vdp->vt.output_surface_put_bits_native(surface, data, pitches, dst);
}
const uint32_t *pitch, const VdpRect *dst,
VdpColorTableFormat tabfmt, const void *tab)
{
+ CHECK_FUNC(OUTPUT_SURFACE_PUT_BITS_INDEXED);
return vdp->vt.output_surface_put_bits_indexed(surface, fmt, data, pitch,
dst, tabfmt, tab);
}
VdpOutputSurface surface, VdpYCbCrFormat fmt, const void *const *data,
const uint32_t *pitches, const VdpRect *dst, const VdpCSCMatrix *mtx)
{
+ CHECK_FUNC(OUTPUT_SURFACE_PUT_BITS_Y_CB_CR);
return vdp->vt.output_surface_put_bits_y_cb_cr(surface, fmt, data,
pitches, dst, mtx);
}
VdpStatus vdp_bitmap_surface_query_capabilities(const vdp_t *vdp,
VdpDevice device, VdpRGBAFormat fmt, VdpBool *ok, uint32_t *w, uint32_t *h)
{
+ CHECK_FUNC(BITMAP_SURFACE_QUERY_CAPABILITIES);
return vdp->vt.bitmap_surface_query_capabilities(device, fmt, ok, w, h);
}
VdpRGBAFormat fmt, uint32_t w, uint32_t h, VdpBool fq,
VdpBitmapSurface *surface)
{
+ CHECK_FUNC(BITMAP_SURFACE_CREATE);
return vdp->vt.bitmap_surface_create(device, fmt, w, h, fq, surface);
}
VdpStatus vdp_bitmap_surface_destroy(const vdp_t *vdp,
VdpBitmapSurface surface)
{
+ CHECK_FUNC(BITMAP_SURFACE_DESTROY);
return vdp->vt.bitmap_surface_destroy(surface);
}
VdpBitmapSurface surface, VdpRGBAFormat *fmt, uint32_t *w, uint32_t *h,
VdpBool *fq)
{
+ CHECK_FUNC(BITMAP_SURFACE_GET_PARAMETERS);
return vdp->vt.bitmap_surface_get_parameters(surface, fmt, w, h, fq);
}
VdpBitmapSurface surface, const void *const *data, const uint32_t *pitch,
const VdpRect *rect)
{
+ CHECK_FUNC(BITMAP_SURFACE_PUT_BITS_NATIVE);
return vdp->vt.bitmap_surface_put_bits_native(surface, data, pitch, rect);
}
const VdpColor *colors,
const VdpOutputSurfaceRenderBlendState *const state, uint32_t flags)
{
+ CHECK_FUNC(OUTPUT_SURFACE_RENDER_OUTPUT_SURFACE);
return vdp->vt.output_surface_render_output_surface(dst_surface, dst_rect,
src_surface, src_rect, colors, state, flags);
}
const VdpColor *colors,
const VdpOutputSurfaceRenderBlendState *state, uint32_t flags)
{
+ CHECK_FUNC(OUTPUT_SURFACE_RENDER_BITMAP_SURFACE);
return vdp->vt.output_surface_render_bitmap_surface(dst_surface, dst_rect,
src_surface, src_rect, colors, state, flags);
}
VdpDecoderProfile profile, VdpBool *ok, uint32_t *l, uint32_t *m,
uint32_t *w, uint32_t *h)
{
+ CHECK_FUNC(DECODER_QUERY_CAPABILITIES);
return vdp->vt.decoder_query_capabilities(device, profile, ok, l, m, w, h);
}
VdpDecoderProfile profile, uint32_t w, uint32_t h, uint32_t refs,
VdpDecoder *decoder)
{
+ CHECK_FUNC(DECODER_CREATE);
return vdp->vt.decoder_create(device, profile, w, h, refs, decoder);
}
VdpStatus vdp_decoder_destroy(const vdp_t *vdp, VdpDecoder decoder)
{
+ CHECK_FUNC(DECODER_DESTROY);
return vdp->vt.decoder_destroy(decoder);
}
VdpStatus vdp_decoder_get_parameters(const vdp_t *vdp, VdpDecoder decoder,
VdpDecoderProfile *profile, uint32_t *w, uint32_t *h)
{
+ CHECK_FUNC(DECODER_GET_PARAMETERS);
return vdp->vt.decoder_get_parameters(decoder, profile, w, h);
}
VdpStatus vdp_decoder_render(const vdp_t *vdp, VdpDecoder decoder,
VdpVideoSurface target, const VdpPictureInfo *info,
uint32_t bufv, const VdpBitstreamBuffer *bufc)
-
{
+ CHECK_FUNC(DECODER_RENDER);
return vdp->vt.decoder_render(decoder, target, info, bufv, bufc);
}
VdpStatus vdp_video_mixer_query_feature_support(const vdp_t *vdp,
VdpDevice device, VdpVideoMixerFeature feature, VdpBool *ok)
{
+ CHECK_FUNC(VIDEO_MIXER_QUERY_FEATURE_SUPPORT);
return vdp->vt.video_mixer_query_feature_support(device, feature, ok);
}
VdpStatus vdp_video_mixer_query_parameter_support(const vdp_t *vdp,
VdpDevice device, VdpVideoMixerParameter parameter, VdpBool *ok)
{
+ CHECK_FUNC(VIDEO_MIXER_QUERY_PARAMETER_SUPPORT);
return vdp->vt.video_mixer_query_parameter_support(device, parameter, ok);
}
VdpStatus vdp_video_mixer_query_attribute_support(const vdp_t *vdp,
VdpDevice device, VdpVideoMixerAttribute attribute, VdpBool *ok)
{
+ CHECK_FUNC(VIDEO_MIXER_QUERY_ATTRIBUTE_SUPPORT);
return vdp->vt.video_mixer_query_attribute_support(device, attribute, ok);
}
VdpStatus vdp_video_mixer_query_parameter_value_range(const vdp_t *vdp,
VdpDevice device, VdpVideoMixerParameter parameter, void *min, void *max)
{
+ CHECK_FUNC(VIDEO_MIXER_QUERY_PARAMETER_VALUE_RANGE);
return vdp->vt.video_mixer_query_parameter_value_range(device, parameter,
min, max);
}
VdpStatus vdp_video_mixer_query_attribute_value_range(const vdp_t *vdp,
VdpDevice device, VdpVideoMixerAttribute attribute, void *min, void *max)
{
+ CHECK_FUNC(VIDEO_MIXER_QUERY_ATTRIBUTE_VALUE_RANGE);
return vdp->vt.video_mixer_query_attribute_value_range(device, attribute,
min, max);
}
uint32_t parmc, const VdpVideoMixerParameter *parmv,
const void *const *parmvalv, VdpVideoMixer *mixer)
{
+ CHECK_FUNC(VIDEO_MIXER_CREATE);
return vdp->vt.video_mixer_create(device, featc, featv, parmc, parmv,
parmvalv, mixer);
}
VdpVideoMixer mixer, uint32_t count, const VdpVideoMixerFeature *ids,
const VdpBool *values)
{
+ CHECK_FUNC(VIDEO_MIXER_SET_FEATURE_ENABLES);
return vdp->vt.video_mixer_set_feature_enables(mixer, count, ids, values);
}
VdpVideoMixer mixer, uint32_t count,
const VdpVideoMixerAttribute *const ids, const void *const *values)
{
+ CHECK_FUNC(VIDEO_MIXER_SET_ATTRIBUTE_VALUES);
return vdp->vt.video_mixer_set_attribute_values(mixer, count, ids, values);
}
VdpVideoMixer mixer, uint32_t count, const VdpVideoMixerFeature *ids,
VdpBool *values)
{
+ CHECK_FUNC(VIDEO_MIXER_GET_FEATURE_SUPPORT);
return vdp->vt.video_mixer_get_feature_support(mixer, count, ids, values);
}
VdpVideoMixer mixer, uint32_t count, const VdpVideoMixerFeature *ids,
VdpBool *values)
{
+ CHECK_FUNC(VIDEO_MIXER_GET_FEATURE_ENABLES);
return vdp->vt.video_mixer_get_feature_enables(mixer, count, ids, values);
}
VdpVideoMixer mixer, uint32_t count, const VdpVideoMixerParameter *ids,
void *const *values)
{
+ CHECK_FUNC(VIDEO_MIXER_GET_PARAMETER_VALUES);
return vdp->vt.video_mixer_get_parameter_values(mixer, count, ids, values);
}
VdpVideoMixer mixer, uint32_t count, const VdpVideoMixerAttribute *ids,
void *const *values)
{
+ CHECK_FUNC(VIDEO_MIXER_GET_ATTRIBUTE_VALUES);
return vdp->vt.video_mixer_get_attribute_values(mixer, count, ids, values);
}
VdpStatus vdp_video_mixer_destroy(const vdp_t *vdp, VdpVideoMixer mixer)
{
+ CHECK_FUNC(VIDEO_MIXER_DESTROY);
return vdp->vt.video_mixer_destroy(mixer);
}
VdpOutputSurface dst, const VdpRect *dst_rect, const VdpRect *dst_v_rect,
uint32_t layerc, const VdpLayer *layerv)
{
+ CHECK_FUNC(VIDEO_MIXER_RENDER);
return vdp->vt.video_mixer_render(mixer, bgsurface, bgrect, pic_struct,
prev_count, prev, cur, next_count, next, src_rect, dst, dst_rect,
dst_v_rect, layerc, layerv);
VdpStatus vdp_presentation_queue_target_destroy(const vdp_t *vdp,
VdpPresentationQueueTarget target)
{
+ CHECK_FUNC(PRESENTATION_QUEUE_TARGET_DESTROY);
return vdp->vt.presentation_queue_target_destroy(target);
}
VdpStatus vdp_presentation_queue_create(const vdp_t *vdp, VdpDevice device,
VdpPresentationQueueTarget target, VdpPresentationQueue *queue)
{
+ CHECK_FUNC(PRESENTATION_QUEUE_CREATE);
return vdp->vt.presentation_queue_create(device, target, queue);
}
VdpStatus vdp_presentation_queue_destroy(const vdp_t *vdp,
VdpPresentationQueue queue)
{
+ CHECK_FUNC(PRESENTATION_QUEUE_DESTROY);
return vdp->vt.presentation_queue_destroy(queue);
}
VdpPresentationQueue queue, const VdpColor *color)
{
VdpColor bak = *color;
+ CHECK_FUNC(PRESENTATION_QUEUE_SET_BACKGROUND_COLOR);
return vdp->vt.presentation_queue_set_background_color(queue, &bak);
}
VdpStatus vdp_presentation_queue_get_background_color(const vdp_t *vdp,
VdpPresentationQueue queue, VdpColor *color)
{
+ CHECK_FUNC(PRESENTATION_QUEUE_GET_BACKGROUND_COLOR);
return vdp->vt.presentation_queue_get_background_color(queue, color);
}
VdpStatus vdp_presentation_queue_get_time(const vdp_t *vdp,
VdpPresentationQueue queue, VdpTime *current_time)
{
+ CHECK_FUNC(PRESENTATION_QUEUE_GET_TIME);
return vdp->vt.presentation_queue_get_time(queue, current_time);
}
VdpPresentationQueue queue, VdpOutputSurface surface, uint32_t clip_width,
uint32_t clip_height, VdpTime pts)
{
+ CHECK_FUNC(PRESENTATION_QUEUE_DISPLAY);
return vdp->vt.presentation_queue_display(queue, surface, clip_width,
clip_height, pts);
}
VdpStatus vdp_presentation_queue_block_until_surface_idle(const vdp_t *vdp,
VdpPresentationQueue queue, VdpOutputSurface surface, VdpTime *pts)
{
+ CHECK_FUNC(PRESENTATION_QUEUE_BLOCK_UNTIL_SURFACE_IDLE);
return vdp->vt.presentation_queue_block_until_surface_idle(queue, surface,
pts);
}
VdpPresentationQueue queue, VdpOutputSurface surface,
VdpPresentationQueueStatus *status, VdpTime *pts)
{
+ CHECK_FUNC(PRESENTATION_QUEUE_QUERY_SURFACE_STATUS);
return vdp->vt.presentation_queue_query_surface_status(queue, surface,
status, pts);
}
VdpStatus vdp_preemption_callback_register(const vdp_t *vdp, VdpDevice device,
VdpPreemptionCallback cb, void *ctx)
{
+ CHECK_FUNC(PREEMPTION_CALLBACK_REGISTER);
return vdp->vt.preemption_callback_register(device, cb, ctx);
}
-static VdpStatus vdp_fallback(/* UNDEFINED - LEAVE EMPTY */)
-{
- return VDP_STATUS_NO_IMPLEMENTATION;
-}
-
/*** X11 & VLC ***/
#include <dlfcn.h>
#include <vdpau/vdpau_x11.h>
for (VdpFuncId i = 0; i < sizeof (vdp->vt) / sizeof (void *); i++)
if (gpa(*devp, i, vdp->funcs + i) != VDP_STATUS_OK)
- {
- void *fallback = vdp_fallback;
- if (unlikely(i == VDP_FUNC_ID_GET_ERROR_STRING))
- fallback = vdp_get_error_string_fallback;
- vdp->funcs[i] = fallback;
- }
+ vdp->funcs[i] = NULL;
return VDP_STATUS_OK;
error:
projects / vlc / commitdiff