X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fgallium%2Fstate_trackers%2Fvdpau%2Fvdpau_private.h;h=420573b57ad49d78da18dac527eea52dc3b2a8e0;hb=7004afcd247f82664ff9a0a73d1991bf9e38ce26;hp=912f73d22c9fc6e7a709960c6db59b059fffcc37;hpb=4a4811ea178fb158339c1fbfacc58a9ab97058f8;p=mesa.git diff --git a/src/gallium/state_trackers/vdpau/vdpau_private.h b/src/gallium/state_trackers/vdpau/vdpau_private.h index 912f73d22c9..420573b57ad 100644 --- a/src/gallium/state_trackers/vdpau/vdpau_private.h +++ b/src/gallium/state_trackers/vdpau/vdpau_private.h @@ -18,7 +18,7 @@ * 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 NON-INFRINGEMENT. - * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR + * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS 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. @@ -34,13 +34,24 @@ #include #include "pipe/p_compiler.h" -#include "pipe/p_video_decoder.h" +#include "pipe/p_video_codec.h" + +#include "state_tracker/vdpau_interop.h" +#include "state_tracker/vdpau_dmabuf.h" +#include "state_tracker/vdpau_funcs.h" #include "util/u_debug.h" #include "util/u_rect.h" -#include "vl/vl_compositor.h" +#include "os/os_thread.h" -#include "vl_winsys.h" +#include "vl/vl_video_buffer.h" +#include "vl/vl_bicubic_filter.h" +#include "vl/vl_compositor.h" +#include "vl/vl_csc.h" +#include "vl/vl_deint_filter.h" +#include "vl/vl_matrix_filter.h" +#include "vl/vl_median_filter.h" +#include "vl/vl_winsys.h" /* Full VDPAU API documentation available at : * ftp://download.nvidia.com/XFree86/vdpau/doxygen/html/index.html */ @@ -49,7 +60,6 @@ #define QUOTEME(x) #x #define TOSTRING(x) QUOTEME(x) #define INFORMATION_STRING TOSTRING(INFORMATION) -#define VL_HANDLES static inline enum pipe_video_chroma_format ChromaToPipe(VdpChromaType vdpau_type) @@ -85,6 +95,29 @@ PipeToChroma(enum pipe_video_chroma_format pipe_type) return -1; } +static inline enum pipe_video_chroma_format +FormatYCBCRToPipeChroma(VdpYCbCrFormat vdpau_format) +{ + switch (vdpau_format) { + case VDP_YCBCR_FORMAT_NV12: + return PIPE_VIDEO_CHROMA_FORMAT_420; + case VDP_YCBCR_FORMAT_YV12: + return PIPE_VIDEO_CHROMA_FORMAT_420; + case VDP_YCBCR_FORMAT_UYVY: + return PIPE_VIDEO_CHROMA_FORMAT_422; + case VDP_YCBCR_FORMAT_YUYV: + return PIPE_VIDEO_CHROMA_FORMAT_422; + case VDP_YCBCR_FORMAT_Y8U8V8A8: + return PIPE_VIDEO_CHROMA_FORMAT_444; + case VDP_YCBCR_FORMAT_V8U8Y8A8: + return PIPE_VIDEO_CHROMA_FORMAT_444; + default: + assert(0); + } + + return PIPE_FORMAT_NONE; +} + static inline enum pipe_format FormatYCBCRToPipe(VdpYCbCrFormat vdpau_format) { @@ -97,10 +130,10 @@ FormatYCBCRToPipe(VdpYCbCrFormat vdpau_format) return PIPE_FORMAT_UYVY; case VDP_YCBCR_FORMAT_YUYV: return PIPE_FORMAT_YUYV; - case VDP_YCBCR_FORMAT_Y8U8V8A8: /* Not defined in p_format.h */ - return PIPE_FORMAT_NONE; + case VDP_YCBCR_FORMAT_Y8U8V8A8: + return PIPE_FORMAT_R8G8B8A8_UNORM; case VDP_YCBCR_FORMAT_V8U8Y8A8: - return PIPE_FORMAT_VUYA; + return PIPE_FORMAT_B8G8R8A8_UNORM; default: assert(0); } @@ -120,9 +153,9 @@ PipeToFormatYCBCR(enum pipe_format p_format) return VDP_YCBCR_FORMAT_UYVY; case PIPE_FORMAT_YUYV: return VDP_YCBCR_FORMAT_YUYV; - //case PIPE_FORMAT_YUVA: - // return VDP_YCBCR_FORMAT_Y8U8V8A8; - case PIPE_FORMAT_VUYA: + case PIPE_FORMAT_R8G8B8A8_UNORM: + return VDP_YCBCR_FORMAT_Y8U8V8A8; + case PIPE_FORMAT_B8G8R8A8_UNORM: return VDP_YCBCR_FORMAT_V8U8Y8A8; default: assert(0); @@ -131,27 +164,6 @@ PipeToFormatYCBCR(enum pipe_format p_format) return -1; } -static inline enum pipe_format -FormatRGBAToPipe(VdpRGBAFormat vdpau_format) -{ - switch (vdpau_format) { - case VDP_RGBA_FORMAT_A8: - return PIPE_FORMAT_A8_UNORM; - case VDP_RGBA_FORMAT_B10G10R10A2: - return PIPE_FORMAT_B10G10R10A2_UNORM; - case VDP_RGBA_FORMAT_B8G8R8A8: - return PIPE_FORMAT_B8G8R8A8_UNORM; - case VDP_RGBA_FORMAT_R10G10B10A2: - return PIPE_FORMAT_R10G10B10A2_UNORM; - case VDP_RGBA_FORMAT_R8G8B8A8: - return PIPE_FORMAT_R8G8B8A8_UNORM; - default: - assert(0); - } - - return PIPE_FORMAT_NONE; -} - static inline VdpRGBAFormat PipeToFormatRGBA(enum pipe_format p_format) { @@ -178,9 +190,9 @@ FormatIndexedToPipe(VdpRGBAFormat vdpau_format) { switch (vdpau_format) { case VDP_INDEXED_FORMAT_A4I4: - return PIPE_FORMAT_A4R4_UNORM; - case VDP_INDEXED_FORMAT_I4A4: return PIPE_FORMAT_R4A4_UNORM; + case VDP_INDEXED_FORMAT_I4A4: + return PIPE_FORMAT_A4R4_UNORM; case VDP_INDEXED_FORMAT_A8I8: return PIPE_FORMAT_A8R8_UNORM; case VDP_INDEXED_FORMAT_I8A8: @@ -217,6 +229,8 @@ ProfileToPipe(VdpDecoderProfile vdpau_profile) return PIPE_VIDEO_PROFILE_MPEG2_MAIN; case VDP_DECODER_PROFILE_H264_BASELINE: return PIPE_VIDEO_PROFILE_MPEG4_AVC_BASELINE; + case VDP_DECODER_PROFILE_H264_CONSTRAINED_BASELINE: + return PIPE_VIDEO_PROFILE_MPEG4_AVC_CONSTRAINED_BASELINE; case VDP_DECODER_PROFILE_H264_MAIN: return PIPE_VIDEO_PROFILE_MPEG4_AVC_MAIN; case VDP_DECODER_PROFILE_H264_HIGH: @@ -231,6 +245,16 @@ ProfileToPipe(VdpDecoderProfile vdpau_profile) return PIPE_VIDEO_PROFILE_VC1_MAIN; case VDP_DECODER_PROFILE_VC1_ADVANCED: return PIPE_VIDEO_PROFILE_VC1_ADVANCED; + case VDP_DECODER_PROFILE_HEVC_MAIN: + return PIPE_VIDEO_PROFILE_HEVC_MAIN; + case VDP_DECODER_PROFILE_HEVC_MAIN_10: + return PIPE_VIDEO_PROFILE_HEVC_MAIN_10; + case VDP_DECODER_PROFILE_HEVC_MAIN_STILL: + return PIPE_VIDEO_PROFILE_HEVC_MAIN_STILL; + case VDP_DECODER_PROFILE_HEVC_MAIN_12: + return PIPE_VIDEO_PROFILE_HEVC_MAIN_12; + case VDP_DECODER_PROFILE_HEVC_MAIN_444: + return PIPE_VIDEO_PROFILE_HEVC_MAIN_444; default: return PIPE_VIDEO_PROFILE_UNKNOWN; } @@ -248,6 +272,8 @@ PipeToProfile(enum pipe_video_profile p_profile) return VDP_DECODER_PROFILE_MPEG2_MAIN; case PIPE_VIDEO_PROFILE_MPEG4_AVC_BASELINE: return VDP_DECODER_PROFILE_H264_BASELINE; + case PIPE_VIDEO_PROFILE_MPEG4_AVC_CONSTRAINED_BASELINE: + return VDP_DECODER_PROFILE_H264_CONSTRAINED_BASELINE; case PIPE_VIDEO_PROFILE_MPEG4_AVC_MAIN: return VDP_DECODER_PROFILE_H264_MAIN; case PIPE_VIDEO_PROFILE_MPEG4_AVC_HIGH: @@ -262,55 +288,114 @@ PipeToProfile(enum pipe_video_profile p_profile) return VDP_DECODER_PROFILE_VC1_MAIN; case PIPE_VIDEO_PROFILE_VC1_ADVANCED: return VDP_DECODER_PROFILE_VC1_ADVANCED; + case PIPE_VIDEO_PROFILE_HEVC_MAIN: + return VDP_DECODER_PROFILE_HEVC_MAIN; + case PIPE_VIDEO_PROFILE_HEVC_MAIN_10: + return VDP_DECODER_PROFILE_HEVC_MAIN_10; + case PIPE_VIDEO_PROFILE_HEVC_MAIN_STILL: + return VDP_DECODER_PROFILE_HEVC_MAIN_STILL; + case PIPE_VIDEO_PROFILE_HEVC_MAIN_12: + return VDP_DECODER_PROFILE_HEVC_MAIN_12; + case PIPE_VIDEO_PROFILE_HEVC_MAIN_444: + return VDP_DECODER_PROFILE_HEVC_MAIN_444; default: assert(0); return -1; } } -static inline struct pipe_video_rect * -RectToPipe(const VdpRect *src, struct pipe_video_rect *dst) +static inline struct u_rect * +RectToPipe(const VdpRect *src, struct u_rect *dst) { if (src) { - dst->x = MIN2(src->x1, src->x0); - dst->y = MIN2(src->y1, src->y0); - dst->w = abs(src->x1 - src->x0); - dst->h = abs(src->y1 - src->y0); + dst->x0 = src->x0; + dst->y0 = src->y0; + dst->x1 = src->x1; + dst->y1 = src->y1; return dst; } return NULL; } -typedef struct +static inline struct pipe_box +RectToPipeBox(const VdpRect *rect, struct pipe_resource *res) { - struct vl_screen *vscreen; - struct vl_context *context; - struct vl_compositor compositor; -} vlVdpDevice; + struct pipe_box box; + + box.x = 0; + box.y = 0; + box.z = 0; + box.width = res->width0; + box.height = res->height0; + box.depth = 1; + + if (rect) { + box.x = MIN2(rect->x0, rect->x1); + box.y = MIN2(rect->y0, rect->y1); + box.width = abs(rect->x1 - rect->x0); + box.height = abs(rect->y1 - rect->y0); + } -typedef struct + return box; +} + +static inline bool +CheckSurfaceParams(struct pipe_screen *screen, + const struct pipe_resource *templ) { - vlVdpDevice *device; - Drawable drawable; -} vlVdpPresentationQueueTarget; + return screen->is_format_supported(screen, templ->format, templ->target, + templ->nr_samples, + templ->nr_storage_samples, templ->bind); +} typedef struct { - vlVdpDevice *device; - Drawable drawable; + struct pipe_reference reference; + struct vl_screen *vscreen; + struct pipe_context *context; struct vl_compositor compositor; - struct u_rect dirty_area; -} vlVdpPresentationQueue; + struct pipe_sampler_view *dummy_sv; + mtx_t mutex; +} vlVdpDevice; typedef struct { vlVdpDevice *device; - struct vl_compositor compositor; + struct vl_compositor_state cstate; + + struct { + bool supported, enabled; + float luma_min, luma_max; + } luma_key; + + struct { + bool supported, enabled, spatial; + struct vl_deint_filter *filter; + } deint; + + struct { + bool supported, enabled; + struct vl_bicubic_filter *filter; + } bicubic; + + struct { + bool supported, enabled; + unsigned level; + struct vl_median_filter *filter; + } noise_reduction; + + struct { + bool supported, enabled; + float value; + struct vl_matrix_filter *filter; + } sharpness; + unsigned video_width, video_height; enum pipe_video_chroma_format chroma_format; - unsigned max_layers, skip_chroma_deint, custom_csc; - float luma_key_min, luma_key_max, sharpness, noise_reduction_level; - float csc[16]; + unsigned max_layers, skip_chroma_deint; + + bool custom_csc; + vl_csc_matrix csc; } vlVdpVideoMixer; typedef struct @@ -319,22 +404,44 @@ typedef struct struct pipe_video_buffer templat, *video_buffer; } vlVdpSurface; +typedef struct +{ + vlVdpDevice *device; + struct pipe_sampler_view *sampler_view; +} vlVdpBitmapSurface; + typedef uint64_t vlVdpTime; typedef struct { - vlVdpTime timestamp; vlVdpDevice *device; struct pipe_surface *surface; struct pipe_sampler_view *sampler_view; struct pipe_fence_handle *fence; + struct vl_compositor_state cstate; struct u_rect dirty_area; + bool send_to_X; } vlVdpOutputSurface; typedef struct { vlVdpDevice *device; - struct pipe_video_decoder *decoder; + Drawable drawable; +} vlVdpPresentationQueueTarget; + +typedef struct +{ + vlVdpDevice *device; + Drawable drawable; + struct vl_compositor_state cstate; + vlVdpOutputSurface *last_surf; +} vlVdpPresentationQueue; + +typedef struct +{ + vlVdpDevice *device; + mtx_t mutex; + struct pipe_video_codec *decoder; } vlVdpDecoder; typedef uint32_t vlHandle; @@ -349,11 +456,13 @@ boolean vlGetFuncFTAB(VdpFuncId function_id, void **func); /* Public functions */ VdpDeviceCreateX11 vdp_imp_device_create_x11; -VdpPresentationQueueTargetCreateX11 vlVdpPresentationQueueTargetCreateX11; + +void vlVdpDefaultSamplerViewTemplate(struct pipe_sampler_view *templ, struct pipe_resource *res); /* Internal function pointers */ VdpGetErrorString vlVdpGetErrorString; VdpDeviceDestroy vlVdpDeviceDestroy; +void vlVdpDeviceFree(vlVdpDevice *dev); VdpGetProcAddress vlVdpGetProcAddress; VdpGetApiVersion vlVdpGetApiVersion; VdpGetInformationString vlVdpGetInformationString; @@ -375,6 +484,7 @@ VdpVideoSurfaceDestroy vlVdpVideoSurfaceDestroy; VdpVideoSurfaceGetParameters vlVdpVideoSurfaceGetParameters; VdpVideoSurfaceGetBitsYCbCr vlVdpVideoSurfaceGetBitsYCbCr; VdpVideoSurfacePutBitsYCbCr vlVdpVideoSurfacePutBitsYCbCr; +void vlVdpVideoSurfaceClear(vlVdpSurface *vlsurf); VdpDecoderCreate vlVdpDecoderCreate; VdpDecoderDestroy vlVdpDecoderDestroy; VdpDecoderGetParameters vlVdpDecoderGetParameters; @@ -413,6 +523,15 @@ VdpVideoMixerGetParameterValues vlVdpVideoMixerGetParameterValues; VdpVideoMixerGetAttributeValues vlVdpVideoMixerGetAttributeValues; VdpVideoMixerDestroy vlVdpVideoMixerDestroy; VdpGenerateCSCMatrix vlVdpGenerateCSCMatrix; +/* Winsys specific internal function pointers */ +VdpPresentationQueueTargetCreateX11 vlVdpPresentationQueueTargetCreateX11; + + +/* interop to mesa state tracker */ +VdpVideoSurfaceGallium vlVdpVideoSurfaceGallium; +VdpOutputSurfaceGallium vlVdpOutputSurfaceGallium; +VdpVideoSurfaceDMABuf vlVdpVideoSurfaceDMABuf; +VdpOutputSurfaceDMABuf vlVdpOutputSurfaceDMABuf; #define VDPAU_OUT 0 #define VDPAU_ERR 1 @@ -435,4 +554,14 @@ static inline void VDPAU_MSG(unsigned int level, const char *fmt, ...) } } +static inline void +DeviceReference(vlVdpDevice **ptr, vlVdpDevice *dev) +{ + vlVdpDevice *old_dev = *ptr; + + if (pipe_reference(&(*ptr)->reference, &dev->reference)) + vlVdpDeviceFree(old_dev); + *ptr = dev; +} + #endif /* VDPAU_PRIVATE_H */