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