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