device.c revision 20446d0e535c0735489c8944e8d767e0fc74fc6e
1/************************************************************************** 2 * 3 * Copyright 2010 Younes Manton og Thomas Balling Sørensen. 4 * All Rights Reserved. 5 * 6 * Permission is hereby granted, free of charge, to any person obtaining a 7 * copy of this software and associated documentation files (the 8 * "Software"), to deal in the Software without restriction, including 9 * without limitation the rights to use, copy, modify, merge, publish, 10 * distribute, sub license, and/or sell copies of the Software, and to 11 * permit persons to whom the Software is furnished to do so, subject to 12 * the following conditions: 13 * 14 * The above copyright notice and this permission notice (including the 15 * next paragraph) shall be included in all copies or substantial portions 16 * of the Software. 17 * 18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 20 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. 21 * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR 22 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 23 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE 24 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 25 * 26 **************************************************************************/ 27 28#include "pipe/p_compiler.h" 29 30#include "util/u_memory.h" 31#include "util/u_debug.h" 32#include "util/u_format.h" 33#include "util/u_sampler.h" 34 35#include "vdpau_private.h" 36 37/** 38 * Create a VdpDevice object for use with X11. 39 */ 40PUBLIC VdpStatus 41vdp_imp_device_create_x11(Display *display, int screen, VdpDevice *device, 42 VdpGetProcAddress **get_proc_address) 43{ 44 struct pipe_screen *pscreen; 45 vlVdpDevice *dev = NULL; 46 VdpStatus ret; 47 48 if (!(display && device && get_proc_address)) 49 return VDP_STATUS_INVALID_POINTER; 50 51 if (!vlCreateHTAB()) { 52 ret = VDP_STATUS_RESOURCES; 53 goto no_htab; 54 } 55 56 dev = CALLOC(1, sizeof(vlVdpDevice)); 57 if (!dev) { 58 ret = VDP_STATUS_RESOURCES; 59 goto no_dev; 60 } 61 62 dev->vscreen = vl_screen_create(display, screen); 63 if (!dev->vscreen) { 64 ret = VDP_STATUS_RESOURCES; 65 goto no_vscreen; 66 } 67 68 pscreen = dev->vscreen->pscreen; 69 dev->context = pscreen->context_create(pscreen, dev->vscreen); 70 if (!dev->context) { 71 ret = VDP_STATUS_RESOURCES; 72 goto no_context; 73 } 74 75 *device = vlAddDataHTAB(dev); 76 if (*device == 0) { 77 ret = VDP_STATUS_ERROR; 78 goto no_handle; 79 } 80 81 vl_compositor_init(&dev->compositor, dev->context); 82 pipe_mutex_init(dev->mutex); 83 84 *get_proc_address = &vlVdpGetProcAddress; 85 86 return VDP_STATUS_OK; 87 88no_handle: 89 dev->context->destroy(dev->context); 90 /* Destroy vscreen */ 91no_context: 92 vl_screen_destroy(dev->vscreen); 93no_vscreen: 94 FREE(dev); 95no_dev: 96 vlDestroyHTAB(); 97no_htab: 98 return ret; 99} 100 101/** 102 * Create a VdpPresentationQueueTarget for use with X11. 103 */ 104PUBLIC VdpStatus 105vlVdpPresentationQueueTargetCreateX11(VdpDevice device, Drawable drawable, 106 VdpPresentationQueueTarget *target) 107{ 108 vlVdpPresentationQueueTarget *pqt; 109 VdpStatus ret; 110 111 if (!drawable) 112 return VDP_STATUS_INVALID_HANDLE; 113 114 vlVdpDevice *dev = vlGetDataHTAB(device); 115 if (!dev) 116 return VDP_STATUS_INVALID_HANDLE; 117 118 pqt = CALLOC(1, sizeof(vlVdpPresentationQueue)); 119 if (!pqt) 120 return VDP_STATUS_RESOURCES; 121 122 pqt->device = dev; 123 pqt->drawable = drawable; 124 125 *target = vlAddDataHTAB(pqt); 126 if (*target == 0) { 127 ret = VDP_STATUS_ERROR; 128 goto no_handle; 129 } 130 131 return VDP_STATUS_OK; 132 133no_handle: 134 FREE(pqt); 135 return ret; 136} 137 138/** 139 * Destroy a VdpPresentationQueueTarget. 140 */ 141VdpStatus 142vlVdpPresentationQueueTargetDestroy(VdpPresentationQueueTarget presentation_queue_target) 143{ 144 vlVdpPresentationQueueTarget *pqt; 145 146 pqt = vlGetDataHTAB(presentation_queue_target); 147 if (!pqt) 148 return VDP_STATUS_INVALID_HANDLE; 149 150 vlRemoveDataHTAB(presentation_queue_target); 151 FREE(pqt); 152 153 return VDP_STATUS_OK; 154} 155 156/** 157 * Destroy a VdpDevice. 158 */ 159VdpStatus 160vlVdpDeviceDestroy(VdpDevice device) 161{ 162 vlVdpDevice *dev = vlGetDataHTAB(device); 163 if (!dev) 164 return VDP_STATUS_INVALID_HANDLE; 165 166 pipe_mutex_destroy(dev->mutex); 167 vl_compositor_cleanup(&dev->compositor); 168 dev->context->destroy(dev->context); 169 vl_screen_destroy(dev->vscreen); 170 171 vlRemoveDataHTAB(device); 172 FREE(dev); 173 vlDestroyHTAB(); 174 175 return VDP_STATUS_OK; 176} 177 178/** 179 * Retrieve a VDPAU function pointer. 180 */ 181VdpStatus 182vlVdpGetProcAddress(VdpDevice device, VdpFuncId function_id, void **function_pointer) 183{ 184 vlVdpDevice *dev = vlGetDataHTAB(device); 185 if (!dev) 186 return VDP_STATUS_INVALID_HANDLE; 187 188 if (!function_pointer) 189 return VDP_STATUS_INVALID_POINTER; 190 191 if (!vlGetFuncFTAB(function_id, function_pointer)) 192 return VDP_STATUS_INVALID_FUNC_ID; 193 194 VDPAU_MSG(VDPAU_TRACE, "[VDPAU] Got proc adress %p for id %d\n", *function_pointer, function_id); 195 196 return VDP_STATUS_OK; 197} 198 199#define _ERROR_TYPE(TYPE,STRING) case TYPE: return STRING; 200 201/** 202 * Retrieve a string describing an error code. 203 */ 204char const * 205vlVdpGetErrorString (VdpStatus status) 206{ 207 switch (status) { 208 _ERROR_TYPE(VDP_STATUS_OK,"The operation completed successfully; no error."); 209 _ERROR_TYPE(VDP_STATUS_NO_IMPLEMENTATION,"No backend implementation could be loaded."); 210 _ERROR_TYPE(VDP_STATUS_DISPLAY_PREEMPTED,"The display was preempted, or a fatal error occurred. The application must re-initialize VDPAU."); 211 _ERROR_TYPE(VDP_STATUS_INVALID_HANDLE,"An invalid handle value was provided. Either the handle does not exist at all, or refers to an object of an incorrect type."); 212 _ERROR_TYPE(VDP_STATUS_INVALID_POINTER,"An invalid pointer was provided. Typically, this means that a NULL pointer was provided for an 'output' parameter."); 213 _ERROR_TYPE(VDP_STATUS_INVALID_CHROMA_TYPE,"An invalid/unsupported VdpChromaType value was supplied."); 214 _ERROR_TYPE(VDP_STATUS_INVALID_Y_CB_CR_FORMAT,"An invalid/unsupported VdpYCbCrFormat value was supplied."); 215 _ERROR_TYPE(VDP_STATUS_INVALID_RGBA_FORMAT,"An invalid/unsupported VdpRGBAFormat value was supplied."); 216 _ERROR_TYPE(VDP_STATUS_INVALID_INDEXED_FORMAT,"An invalid/unsupported VdpIndexedFormat value was supplied."); 217 _ERROR_TYPE(VDP_STATUS_INVALID_COLOR_STANDARD,"An invalid/unsupported VdpColorStandard value was supplied."); 218 _ERROR_TYPE(VDP_STATUS_INVALID_COLOR_TABLE_FORMAT,"An invalid/unsupported VdpColorTableFormat value was supplied."); 219 _ERROR_TYPE(VDP_STATUS_INVALID_BLEND_FACTOR,"An invalid/unsupported VdpOutputSurfaceRenderBlendFactor value was supplied."); 220 _ERROR_TYPE(VDP_STATUS_INVALID_BLEND_EQUATION,"An invalid/unsupported VdpOutputSurfaceRenderBlendEquation value was supplied."); 221 _ERROR_TYPE(VDP_STATUS_INVALID_FLAG,"An invalid/unsupported flag value/combination was supplied."); 222 _ERROR_TYPE(VDP_STATUS_INVALID_DECODER_PROFILE,"An invalid/unsupported VdpDecoderProfile value was supplied."); 223 _ERROR_TYPE(VDP_STATUS_INVALID_VIDEO_MIXER_FEATURE,"An invalid/unsupported VdpVideoMixerFeature value was supplied."); 224 _ERROR_TYPE(VDP_STATUS_INVALID_VIDEO_MIXER_PARAMETER,"An invalid/unsupported VdpVideoMixerParameter value was supplied."); 225 _ERROR_TYPE(VDP_STATUS_INVALID_VIDEO_MIXER_ATTRIBUTE,"An invalid/unsupported VdpVideoMixerAttribute value was supplied."); 226 _ERROR_TYPE(VDP_STATUS_INVALID_VIDEO_MIXER_PICTURE_STRUCTURE,"An invalid/unsupported VdpVideoMixerPictureStructure value was supplied."); 227 _ERROR_TYPE(VDP_STATUS_INVALID_FUNC_ID,"An invalid/unsupported VdpFuncId value was supplied."); 228 _ERROR_TYPE(VDP_STATUS_INVALID_SIZE,"The size of a supplied object does not match the object it is being used with.\ 229 For example, a VdpVideoMixer is configured to process VdpVideoSurface objects of a specific size.\ 230 If presented with a VdpVideoSurface of a different size, this error will be raised."); 231 _ERROR_TYPE(VDP_STATUS_INVALID_VALUE,"An invalid/unsupported value was supplied.\ 232 This is a catch-all error code for values of type other than those with a specific error code."); 233 _ERROR_TYPE(VDP_STATUS_INVALID_STRUCT_VERSION,"An invalid/unsupported structure version was specified in a versioned structure. \ 234 This implies that the implementation is older than the header file the application was built against."); 235 _ERROR_TYPE(VDP_STATUS_RESOURCES,"The system does not have enough resources to complete the requested operation at this time."); 236 _ERROR_TYPE(VDP_STATUS_HANDLE_DEVICE_MISMATCH,"The set of handles supplied are not all related to the same VdpDevice.When performing operations \ 237 that operate on multiple surfaces, such as VdpOutputSurfaceRenderOutputSurface or VdpVideoMixerRender, \ 238 all supplied surfaces must have been created within the context of the same VdpDevice object. \ 239 This error is raised if they were not."); 240 _ERROR_TYPE(VDP_STATUS_ERROR,"A catch-all error, used when no other error code applies."); 241 default: return "Unknown Error"; 242 } 243} 244 245void 246vlVdpDefaultSamplerViewTemplate(struct pipe_sampler_view *templ, struct pipe_resource *res) 247{ 248 const struct util_format_description *desc; 249 250 memset(templ, 0, sizeof(*templ)); 251 u_sampler_view_default_template(templ, res, res->format); 252 253 desc = util_format_description(res->format); 254 if (desc->swizzle[0] == UTIL_FORMAT_SWIZZLE_0) 255 templ->swizzle_r = PIPE_SWIZZLE_ONE; 256 if (desc->swizzle[1] == UTIL_FORMAT_SWIZZLE_0) 257 templ->swizzle_g = PIPE_SWIZZLE_ONE; 258 if (desc->swizzle[2] == UTIL_FORMAT_SWIZZLE_0) 259 templ->swizzle_b = PIPE_SWIZZLE_ONE; 260 if (desc->swizzle[3] == UTIL_FORMAT_SWIZZLE_0) 261 templ->swizzle_a = PIPE_SWIZZLE_ONE; 262} 263 264void 265vlVdpResolveDelayedRendering(vlVdpDevice *dev, struct pipe_surface *surface, struct u_rect *dirty_area) 266{ 267 struct vl_compositor_state *cstate; 268 vlVdpOutputSurface *vlsurface; 269 270 assert(dev); 271 272 cstate = dev->delayed_rendering.cstate; 273 if (!cstate) 274 return; 275 276 vlsurface = vlGetDataHTAB(dev->delayed_rendering.surface); 277 if (!vlsurface) 278 return; 279 280 if (!surface) { 281 surface = vlsurface->surface; 282 dirty_area = &vlsurface->dirty_area; 283 } 284 285 vl_compositor_render(cstate, &dev->compositor, surface, dirty_area, true); 286 287 dev->delayed_rendering.surface = VDP_INVALID_HANDLE; 288 dev->delayed_rendering.cstate = NULL; 289 290 /* test if we need to create a new sampler for the just filled texture */ 291 if (surface->texture != vlsurface->sampler_view->texture) { 292 struct pipe_resource *res = surface->texture; 293 struct pipe_sampler_view sv_templ; 294 295 vlVdpDefaultSamplerViewTemplate(&sv_templ, res); 296 pipe_sampler_view_reference(&vlsurface->sampler_view, NULL); 297 vlsurface->sampler_view = dev->context->create_sampler_view(dev->context, res, &sv_templ); 298 } 299 300 return; 301} 302 303void 304vlVdpSave4DelayedRendering(vlVdpDevice *dev, VdpOutputSurface surface, struct vl_compositor_state *cstate) 305{ 306 assert(dev); 307 308 vlVdpResolveDelayedRendering(dev, NULL, NULL); 309 310 dev->delayed_rendering.surface = surface; 311 dev->delayed_rendering.cstate = cstate; 312} 313