xorg_xv.c revision d509f84543d0979e9bb53c20c195f378dd61e728
1#include "xorg_tracker.h" 2 3#include <xf86xv.h> 4#include <X11/extensions/Xv.h> 5#include <fourcc.h> 6 7#include "xorg_exa.h" 8#include "xorg_renderer.h" 9#include "xorg_exa_tgsi.h" 10 11#include "cso_cache/cso_context.h" 12 13#include "pipe/p_screen.h" 14#include "pipe/p_inlines.h" 15 16/*XXX get these from pipe's texture limits */ 17#define IMAGE_MAX_WIDTH 2048 18#define IMAGE_MAX_HEIGHT 2048 19 20#define RES_720P_X 1280 21#define RES_720P_Y 720 22 23 24/* The ITU-R BT.601 conversion matrix for SDTV. */ 25/* original, matrix, but we transpose it to 26 * make the shader easier 27static const float bt_601[] = { 28 1.0, 0.0, 1.4075, , 29 1.0, -0.3455, -0.7169, 0, 30 1.0, 1.7790, 0., 0, 31};*/ 32static const float bt_601[] = { 33 1.0, 1.0, 1.0, 0.5, 34 0.0, -0.3455, 1.7790, 0, 35 1.4075, -0.7169, 0., 0, 36}; 37 38/* The ITU-R BT.709 conversion matrix for HDTV. */ 39/* original, but we transpose to make the conversion 40 * in the shader easier 41static const float bt_709[] = { 42 1.0, 0.0, 1.581, 0, 43 1.0, -0.1881, -0.47, 0, 44 1.0, 1.8629, 0., 0, 45};*/ 46static const float bt_709[] = { 47 1.0, 1.0, 1.0, 0.5, 48 0.0, -0.1881, 1.8629, 0, 49 1.581,-0.47 , 0.0, 0, 50}; 51 52#define MAKE_ATOM(a) MakeAtom(a, sizeof(a) - 1, TRUE) 53 54static Atom xvBrightness, xvContrast; 55 56#define NUM_TEXTURED_ATTRIBUTES 2 57static XF86AttributeRec TexturedAttributes[NUM_TEXTURED_ATTRIBUTES] = { 58 {XvSettable | XvGettable, -128, 127, "XV_BRIGHTNESS"}, 59 {XvSettable | XvGettable, 0, 255, "XV_CONTRAST"} 60}; 61 62#define NUM_FORMATS 3 63static XF86VideoFormatRec Formats[NUM_FORMATS] = { 64 {15, TrueColor}, {16, TrueColor}, {24, TrueColor} 65}; 66 67static XF86VideoEncodingRec DummyEncoding[1] = { 68 { 69 0, 70 "XV_IMAGE", 71 IMAGE_MAX_WIDTH, IMAGE_MAX_HEIGHT, 72 {1, 1} 73 } 74}; 75 76#define NUM_IMAGES 2 77static XF86ImageRec Images[NUM_IMAGES] = { 78 XVIMAGE_UYVY, 79 XVIMAGE_YUY2, 80}; 81 82struct xorg_xv_port_priv { 83 struct xorg_renderer *r; 84 85 RegionRec clip; 86 87 int brightness; 88 int contrast; 89 90 int current_set; 91 /* juggle two sets of seperate Y, U and V 92 * textures */ 93 struct pipe_texture *yuv[2][3]; 94}; 95 96 97static void 98stop_video(ScrnInfoPtr pScrn, pointer data, Bool shutdown) 99{ 100 struct xorg_xv_port_priv *priv = (struct xorg_xv_port_priv *)data; 101 102 REGION_EMPTY(pScrn->pScreen, &priv->clip); 103} 104 105static int 106set_port_attribute(ScrnInfoPtr pScrn, 107 Atom attribute, INT32 value, pointer data) 108{ 109 struct xorg_xv_port_priv *priv = (struct xorg_xv_port_priv *)data; 110 111 if (attribute == xvBrightness) { 112 if ((value < -128) || (value > 127)) 113 return BadValue; 114 priv->brightness = value; 115 } else if (attribute == xvContrast) { 116 if ((value < 0) || (value > 255)) 117 return BadValue; 118 priv->contrast = value; 119 } else 120 return BadMatch; 121 122 return Success; 123} 124 125static int 126get_port_attribute(ScrnInfoPtr pScrn, 127 Atom attribute, INT32 * value, pointer data) 128{ 129 struct xorg_xv_port_priv *priv = (struct xorg_xv_port_priv *)data; 130 131 if (attribute == xvBrightness) 132 *value = priv->brightness; 133 else if (attribute == xvContrast) 134 *value = priv->contrast; 135 else 136 return BadMatch; 137 138 return Success; 139} 140 141static void 142query_best_size(ScrnInfoPtr pScrn, 143 Bool motion, 144 short vid_w, short vid_h, 145 short drw_w, short drw_h, 146 unsigned int *p_w, unsigned int *p_h, pointer data) 147{ 148 if (vid_w > (drw_w << 1)) 149 drw_w = vid_w >> 1; 150 if (vid_h > (drw_h << 1)) 151 drw_h = vid_h >> 1; 152 153 *p_w = drw_w; 154 *p_h = drw_h; 155} 156 157static INLINE struct pipe_texture * 158create_component_texture(struct pipe_context *pipe, 159 int width, int height) 160{ 161 struct pipe_screen *screen = pipe->screen; 162 struct pipe_texture *tex = 0; 163 struct pipe_texture templ; 164 165 memset(&templ, 0, sizeof(templ)); 166 templ.target = PIPE_TEXTURE_2D; 167 templ.format = PIPE_FORMAT_L8_UNORM; 168 templ.last_level = 0; 169 templ.width0 = width; 170 templ.height0 = height; 171 templ.depth0 = 1; 172 pf_get_block(PIPE_FORMAT_L8_UNORM, &templ.block); 173 templ.tex_usage = PIPE_TEXTURE_USAGE_SAMPLER; 174 175 tex = screen->texture_create(screen, &templ); 176 177 return tex; 178} 179 180static int 181check_yuv_textures(struct xorg_xv_port_priv *priv, int width, int height) 182{ 183 struct pipe_texture **dst = priv->yuv[priv->current_set]; 184 if (!dst[0] || 185 dst[0]->width0 != width || 186 dst[0]->height0 != height) { 187 pipe_texture_reference(&dst[0], NULL); 188 } 189 if (!dst[1] || 190 dst[1]->width0 != width || 191 dst[1]->height0 != height) { 192 pipe_texture_reference(&dst[1], NULL); 193 } 194 if (!dst[2] || 195 dst[2]->width0 != width || 196 dst[2]->height0 != height) { 197 pipe_texture_reference(&dst[2], NULL); 198 } 199 200 if (!dst[0]) 201 dst[0] = create_component_texture(priv->r->pipe, width, height); 202 203 if (!dst[1]) 204 dst[1] = create_component_texture(priv->r->pipe, width, height); 205 206 if (!dst[2]) 207 dst[2] = create_component_texture(priv->r->pipe, width, height); 208 209 if (!dst[0] || !dst[1] || !dst[2]) 210 return BadAlloc; 211 212 return Success; 213} 214 215static void 216copy_packed_data(ScrnInfoPtr pScrn, 217 struct xorg_xv_port_priv *port, 218 int id, 219 unsigned char *buf, 220 int srcPitch, 221 int left, 222 int top, 223 int w, int h) 224{ 225 unsigned char *src; 226 int i, j; 227 struct pipe_texture **dst = port->yuv[port->current_set]; 228 struct pipe_transfer *ytrans, *utrans, *vtrans; 229 struct pipe_screen *screen = port->r->pipe->screen; 230 char *ymap, *vmap, *umap; 231 unsigned char y1, y2, u, v; 232 int yidx, uidx, vidx; 233 int y_array_size = w * h; 234 235 src = buf + (top * srcPitch) + (left << 1); 236 237 ytrans = screen->get_tex_transfer(screen, dst[0], 238 0, 0, 0, 239 PIPE_TRANSFER_WRITE, 240 left, top, w, h); 241 utrans = screen->get_tex_transfer(screen, dst[1], 242 0, 0, 0, 243 PIPE_TRANSFER_WRITE, 244 left, top, w, h); 245 vtrans = screen->get_tex_transfer(screen, dst[2], 246 0, 0, 0, 247 PIPE_TRANSFER_WRITE, 248 left, top, w, h); 249 250 ymap = (char*)screen->transfer_map(screen, ytrans); 251 umap = (char*)screen->transfer_map(screen, utrans); 252 vmap = (char*)screen->transfer_map(screen, vtrans); 253 254 yidx = uidx = vidx = 0; 255 256 switch (id) { 257 case FOURCC_YV12: { 258 for (i = 0; i < w; ++i) { 259 for (j = 0; i < h; ++j) { 260 /*XXX use src? */ 261 y1 = buf[j*w + i]; 262 u = buf[(j/2) * (w/2) + i/2 + y_array_size]; 263 v = buf[(j/2) * (w/2) + i/2 + y_array_size + y_array_size/4]; 264 ymap[yidx++] = y1; 265 umap[uidx++] = u; 266 vmap[vidx++] = v; 267 } 268 } 269 } 270 break; 271 case FOURCC_UYVY: 272 for (i = 0; i < y_array_size; i +=2 ) { 273 /* extracting two pixels */ 274 u = buf[0]; 275 y1 = buf[1]; 276 v = buf[2]; 277 y2 = buf[3]; 278 buf += 4; 279 280 ymap[yidx++] = y1; 281 ymap[yidx++] = y2; 282 umap[uidx++] = u; 283 umap[uidx++] = u; 284 vmap[vidx++] = v; 285 vmap[vidx++] = v; 286 } 287 break; 288 case FOURCC_YUY2: 289 for (i = 0; i < y_array_size; i +=2 ) { 290 /* extracting two pixels */ 291 y1 = buf[0]; 292 u = buf[1]; 293 y2 = buf[2]; 294 v = buf[3]; 295 296 buf += 4; 297 298 ymap[yidx++] = y1; 299 ymap[yidx++] = y2; 300 umap[uidx++] = u; 301 umap[uidx++] = u; 302 vmap[vidx++] = v; 303 vmap[vidx++] = v; 304 } 305 break; 306 default: 307 debug_assert(!"Unsupported yuv format!"); 308 break; 309 } 310 311 screen->transfer_unmap(screen, ytrans); 312 screen->transfer_unmap(screen, utrans); 313 screen->transfer_unmap(screen, vtrans); 314 screen->tex_transfer_destroy(ytrans); 315 screen->tex_transfer_destroy(utrans); 316 screen->tex_transfer_destroy(vtrans); 317} 318 319 320static void 321setup_vs_video_constants(struct xorg_renderer *r, struct exa_pixmap_priv *dst) 322{ 323 int width = dst->tex->width0; 324 int height = dst->tex->height0; 325 const int param_bytes = 8 * sizeof(float); 326 float vs_consts[8] = { 327 2.f/width, 2.f/height, 1, 1, 328 -1, -1, 0, 0 329 }; 330 331 renderer_set_constants(r, PIPE_SHADER_VERTEX, 332 vs_consts, param_bytes); 333} 334 335static void 336setup_fs_video_constants(struct xorg_renderer *r, boolean hdtv) 337{ 338 const int param_bytes = 12 * sizeof(float); 339 const float *video_constants = (hdtv) ? bt_709 : bt_601; 340 341 renderer_set_constants(r, PIPE_SHADER_FRAGMENT, 342 video_constants, param_bytes); 343} 344 345static void 346draw_yuv(struct xorg_xv_port_priv *port, 347 int src_x, int src_y, int src_w, int src_h, 348 int dst_x, int dst_y, int dst_w, int dst_h) 349{ 350 struct pipe_texture **textures = port->yuv[port->current_set]; 351 352 renderer_draw_yuv(port->r, 353 src_x, src_y, src_w, src_h, 354 dst_x, dst_y, dst_w, dst_h, 355 textures); 356} 357 358static void 359bind_blend_state(struct xorg_xv_port_priv *port) 360{ 361 struct pipe_blend_state blend; 362 363 memset(&blend, 0, sizeof(struct pipe_blend_state)); 364 blend.blend_enable = 1; 365 blend.colormask |= PIPE_MASK_RGBA; 366 367 /* porter&duff src */ 368 blend.rgb_src_factor = PIPE_BLENDFACTOR_ONE; 369 blend.alpha_src_factor = PIPE_BLENDFACTOR_ONE; 370 blend.rgb_dst_factor = PIPE_BLENDFACTOR_ZERO; 371 blend.alpha_dst_factor = PIPE_BLENDFACTOR_ZERO; 372 373 cso_set_blend(port->r->cso, &blend); 374} 375 376 377static void 378bind_shaders(struct xorg_xv_port_priv *port) 379{ 380 unsigned vs_traits = 0, fs_traits = 0; 381 struct xorg_shader shader; 382 383 vs_traits |= VS_YUV; 384 fs_traits |= FS_YUV; 385 386 shader = xorg_shaders_get(port->r->shaders, vs_traits, fs_traits); 387 cso_set_vertex_shader_handle(port->r->cso, shader.vs); 388 cso_set_fragment_shader_handle(port->r->cso, shader.fs); 389} 390 391static INLINE void 392conditional_flush(struct pipe_context *pipe, struct pipe_texture **tex, 393 int num) 394{ 395 int i; 396 for (i = 0; i < num; ++i) { 397 if (tex[i] && pipe->is_texture_referenced(pipe, tex[i], 0, 0) & 398 PIPE_REFERENCED_FOR_WRITE) { 399 pipe->flush(pipe, PIPE_FLUSH_RENDER_CACHE, NULL); 400 return; 401 } 402 } 403} 404 405static void 406bind_samplers(struct xorg_xv_port_priv *port) 407{ 408 struct pipe_sampler_state *samplers[PIPE_MAX_SAMPLERS]; 409 struct pipe_sampler_state sampler; 410 struct pipe_texture **dst = port->yuv[port->current_set]; 411 412 memset(&sampler, 0, sizeof(struct pipe_sampler_state)); 413 414 conditional_flush(port->r->pipe, dst, 3); 415 416 sampler.wrap_s = PIPE_TEX_WRAP_CLAMP; 417 sampler.wrap_t = PIPE_TEX_WRAP_CLAMP; 418 sampler.min_img_filter = PIPE_TEX_FILTER_LINEAR; 419 sampler.mag_img_filter = PIPE_TEX_FILTER_LINEAR; 420 sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NEAREST; 421 sampler.normalized_coords = 1; 422 423 samplers[0] = &sampler; 424 samplers[1] = &sampler; 425 samplers[2] = &sampler; 426 427 428 cso_set_samplers(port->r->cso, 3, 429 (const struct pipe_sampler_state **)samplers); 430 cso_set_sampler_textures(port->r->cso, 3, 431 dst); 432} 433 434static int 435display_video(ScrnInfoPtr pScrn, struct xorg_xv_port_priv *pPriv, int id, 436 RegionPtr dstRegion, 437 int src_x, int src_y, int src_w, int src_h, 438 int dstX, int dstY, int dst_w, int dst_h, 439 PixmapPtr pPixmap) 440{ 441 modesettingPtr ms = modesettingPTR(pScrn); 442 BoxPtr pbox; 443 int nbox; 444 int dxo, dyo; 445 Bool hdtv; 446 int x, y, w, h; 447 struct exa_pixmap_priv *dst = exaGetPixmapDriverPrivate(pPixmap); 448 449 if (!dst || !dst->tex) 450 XORG_FALLBACK("Xv destination %s", !dst ? "!dst" : "!dst->tex"); 451 452 hdtv = ((src_w >= RES_720P_X) && (src_h >= RES_720P_Y)); 453 454 REGION_TRANSLATE(pScrn->pScreen, dstRegion, -pPixmap->screen_x, 455 -pPixmap->screen_y); 456 457 dxo = dstRegion->extents.x1; 458 dyo = dstRegion->extents.y1; 459 460 pbox = REGION_RECTS(dstRegion); 461 nbox = REGION_NUM_RECTS(dstRegion); 462 463 renderer_bind_framebuffer(pPriv->r, dst); 464 renderer_bind_viewport(pPriv->r, dst); 465 bind_blend_state(pPriv); 466 renderer_bind_rasterizer(pPriv->r); 467 bind_shaders(pPriv); 468 bind_samplers(pPriv); 469 setup_vs_video_constants(pPriv->r, dst); 470 setup_fs_video_constants(pPriv->r, hdtv); 471 472 while (nbox--) { 473 int box_x1 = pbox->x1; 474 int box_y1 = pbox->y1; 475 int box_x2 = pbox->x2; 476 int box_y2 = pbox->y2; 477 float diff_x = (float)src_w / (float)dst_w; 478 float diff_y = (float)src_h / (float)dst_h; 479 int offset_x = box_x1 - dstX; 480 int offset_y = box_y1 - dstY; 481 int offset_w; 482 int offset_h; 483 484 x = box_x1; 485 y = box_y1; 486 w = box_x2 - box_x1; 487 h = box_y2 - box_y1; 488 489 offset_w = dst_w - w; 490 offset_h = dst_h - h; 491 492 draw_yuv(pPriv, src_x + offset_x*diff_x, src_y + offset_y*diff_y, 493 src_w - offset_w*diff_x, src_h - offset_h*diff_x, 494 x, y, w, h); 495 496 pbox++; 497 } 498 DamageDamageRegion(&pPixmap->drawable, dstRegion); 499 500 return TRUE; 501} 502 503static int 504put_image(ScrnInfoPtr pScrn, 505 short src_x, short src_y, 506 short drw_x, short drw_y, 507 short src_w, short src_h, 508 short drw_w, short drw_h, 509 int id, unsigned char *buf, 510 short width, short height, 511 Bool sync, RegionPtr clipBoxes, pointer data, 512 DrawablePtr pDraw) 513{ 514 struct xorg_xv_port_priv *pPriv = (struct xorg_xv_port_priv *) data; 515 ScreenPtr pScreen = screenInfo.screens[pScrn->scrnIndex]; 516 PixmapPtr pPixmap; 517 INT32 x1, x2, y1, y2; 518 int srcPitch; 519 BoxRec dstBox; 520 int ret; 521 522 /* Clip */ 523 x1 = src_x; 524 x2 = src_x + src_w; 525 y1 = src_y; 526 y2 = src_y + src_h; 527 528 dstBox.x1 = drw_x; 529 dstBox.x2 = drw_x + drw_w; 530 dstBox.y1 = drw_y; 531 dstBox.y2 = drw_y + drw_h; 532 533 if (!xf86XVClipVideoHelper(&dstBox, &x1, &x2, &y1, &y2, clipBoxes, 534 width, height)) 535 return Success; 536 537 switch (id) { 538 case FOURCC_UYVY: 539 case FOURCC_YUY2: 540 default: 541 srcPitch = width << 1; 542 break; 543 } 544 545 ret = check_yuv_textures(pPriv, width, height); 546 547 if (ret) 548 return ret; 549 550 copy_packed_data(pScrn, pPriv, id, buf, srcPitch, 551 src_x, src_y, width, height); 552 553 if (pDraw->type == DRAWABLE_WINDOW) { 554 pPixmap = (*pScreen->GetWindowPixmap)((WindowPtr)pDraw); 555 } else { 556 pPixmap = (PixmapPtr)pDraw; 557 } 558 559 display_video(pScrn, pPriv, id, clipBoxes, 560 src_x, src_y, src_w, src_h, 561 drw_x, drw_y, 562 drw_w, drw_h, pPixmap); 563 564 pPriv->current_set = (pPriv->current_set + 1) & 1; 565 return Success; 566} 567 568static int 569query_image_attributes(ScrnInfoPtr pScrn, 570 int id, 571 unsigned short *w, unsigned short *h, 572 int *pitches, int *offsets) 573{ 574 int size; 575 576 if (*w > IMAGE_MAX_WIDTH) 577 *w = IMAGE_MAX_WIDTH; 578 if (*h > IMAGE_MAX_HEIGHT) 579 *h = IMAGE_MAX_HEIGHT; 580 581 *w = (*w + 1) & ~1; 582 if (offsets) 583 offsets[0] = 0; 584 585 switch (id) { 586 case FOURCC_UYVY: 587 case FOURCC_YUY2: 588 default: 589 size = *w << 1; 590 if (pitches) 591 pitches[0] = size; 592 size *= *h; 593 break; 594 } 595 596 return size; 597} 598 599static struct xorg_xv_port_priv * 600port_priv_create(struct xorg_renderer *r) 601{ 602 struct xorg_xv_port_priv *priv = NULL; 603 604 priv = calloc(1, sizeof(struct xorg_xv_port_priv)); 605 606 if (!priv) 607 return NULL; 608 609 priv->r = r; 610 611 REGION_NULL(pScreen, &priv->clip); 612 613 debug_assert(priv && priv->r); 614 615 return priv; 616} 617 618static XF86VideoAdaptorPtr 619xorg_setup_textured_adapter(ScreenPtr pScreen) 620{ 621 ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum]; 622 modesettingPtr ms = modesettingPTR(pScrn); 623 XF86VideoAdaptorPtr adapt; 624 XF86AttributePtr attrs; 625 DevUnion *dev_unions; 626 int nports = 16, i; 627 int nattributes; 628 629 nattributes = NUM_TEXTURED_ATTRIBUTES; 630 631 debug_assert(ms->exa); 632 debug_assert(ms->exa->renderer); 633 634 adapt = calloc(1, sizeof(XF86VideoAdaptorRec)); 635 dev_unions = calloc(nports, sizeof(DevUnion)); 636 attrs = calloc(nattributes, sizeof(XF86AttributeRec)); 637 if (adapt == NULL || dev_unions == NULL || attrs == NULL) { 638 free(adapt); 639 free(dev_unions); 640 free(attrs); 641 return NULL; 642 } 643 644 adapt->type = XvWindowMask | XvInputMask | XvImageMask; 645 adapt->flags = 0; 646 adapt->name = "Gallium3D Textured Video"; 647 adapt->nEncodings = 1; 648 adapt->pEncodings = DummyEncoding; 649 adapt->nFormats = NUM_FORMATS; 650 adapt->pFormats = Formats; 651 adapt->nPorts = 0; 652 adapt->pPortPrivates = dev_unions; 653 adapt->nAttributes = nattributes; 654 adapt->pAttributes = attrs; 655 memcpy(attrs, TexturedAttributes, nattributes * sizeof(XF86AttributeRec)); 656 adapt->nImages = NUM_IMAGES; 657 adapt->pImages = Images; 658 adapt->PutVideo = NULL; 659 adapt->PutStill = NULL; 660 adapt->GetVideo = NULL; 661 adapt->GetStill = NULL; 662 adapt->StopVideo = stop_video; 663 adapt->SetPortAttribute = set_port_attribute; 664 adapt->GetPortAttribute = get_port_attribute; 665 adapt->QueryBestSize = query_best_size; 666 adapt->PutImage = put_image; 667 adapt->QueryImageAttributes = query_image_attributes; 668 669 for (i = 0; i < nports; i++) { 670 struct xorg_xv_port_priv *priv = 671 port_priv_create(ms->exa->renderer); 672 673 adapt->pPortPrivates[i].ptr = (pointer) (priv); 674 adapt->nPorts++; 675 } 676 677 return adapt; 678} 679 680void 681xorg_init_video(ScreenPtr pScreen) 682{ 683 ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum]; 684 /*modesettingPtr ms = modesettingPTR(pScrn);*/ 685 XF86VideoAdaptorPtr *adaptors, *new_adaptors = NULL; 686 XF86VideoAdaptorPtr textured_adapter; 687 int num_adaptors; 688 689 num_adaptors = xf86XVListGenericAdaptors(pScrn, &adaptors); 690 new_adaptors = malloc((num_adaptors + 1) * sizeof(XF86VideoAdaptorPtr *)); 691 if (new_adaptors == NULL) 692 return; 693 694 memcpy(new_adaptors, adaptors, num_adaptors * sizeof(XF86VideoAdaptorPtr)); 695 adaptors = new_adaptors; 696 697 /* Add the adaptors supported by our hardware. First, set up the atoms 698 * that will be used by both output adaptors. 699 */ 700 xvBrightness = MAKE_ATOM("XV_BRIGHTNESS"); 701 xvContrast = MAKE_ATOM("XV_CONTRAST"); 702 703 textured_adapter = xorg_setup_textured_adapter(pScreen); 704 705 debug_assert(textured_adapter); 706 707 if (textured_adapter) { 708 adaptors[num_adaptors++] = textured_adapter; 709 } 710 711 if (num_adaptors) { 712 xf86XVScreenInit(pScreen, adaptors, num_adaptors); 713 } else { 714 xf86DrvMsg(pScrn->scrnIndex, X_WARNING, 715 "Disabling Xv because no adaptors could be initialized.\n"); 716 } 717 718 free(adaptors); 719} 720