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