xvinfo/xvinfo.c

   1 #include <X11/X.h>
   2 #include <X11/Xlib.h>
   3 #include <X11/extensions/Xvlib.h>
   4 #include <stdio.h>
   5 #include <stdlib.h>
   6 #include <string.h>
   7 #include <ctype.h>
   8
   9 static void
  10 PrintUsage(void)
  11 {
  12    fprintf(stderr, "Usage:  xvinfo [-display host:dpy] [-short]\n");
  13    exit(0);
  14 }
  15
  16 int main(int argc, char *argv[])
  17 {
  18     Display *dpy;
  19     unsigned int ver, rev, eventB, reqB, errorB;
  20     int i, j, k, n;
  21     unsigned int nencode, nadaptors;
  22     int nscreens, nattr, numImages;
  23     XvAdaptorInfo *ainfo;
  24     XvAttribute *attributes;
  25     XvEncodingInfo *encodings;
  26     XvFormat *format;
  27     XvImageFormatValues *formats;
  28     char * disname = NULL;
  29     char shortmode = 0;
  30
  31     if((argc > 4))
  32        PrintUsage();
  33
  34     if(argc != 1) {
  35        for ( i = 1; i < argc; i ++ ) {
  36            if(! strcmp(argv[i], "-display")) {
  37                disname = argv[i + 1];
  38                i ++;
  39            } else if(! strcmp(argv[i], "-short") )
  40                shortmode = 1;
  41              else {
  42                PrintUsage();
  43              }
  44        }
  45     }
  46
  47
  48     if(!(dpy = XOpenDisplay(disname)))
  49     {
  50         fprintf(stderr, "xvinfo:  Unable to open display %s\n",
  51                        (disname != NULL) ? disname : XDisplayName(NULL));
  52         exit(-1);
  53     }
  54
  55     if((Success != XvQueryExtension(dpy, &ver, &rev, &reqB, &eventB, &errorB)))
  56     {
  57         fprintf(stderr, "xvinfo: No X-Video Extension on %s\n",
  58                         (disname != NULL) ? disname : XDisplayName(NULL));
  59         exit(0);
  60     }
  61     else
  62     {
  63         fprintf(stdout, "X-Video Extension version %i.%i\n", ver, rev);
  64     }
  65
  66     nscreens = ScreenCount(dpy);
  67
  68     for(i = 0; i < nscreens; i++) {
  69         fprintf(stdout, "screen #%i\n", i);
  70         XvQueryAdaptors(dpy, RootWindow(dpy, i), &nadaptors, &ainfo);
  71
  72         if(!nadaptors) {
  73             fprintf(stdout, " no adaptors present\n");
  74             continue;
  75         }
  76
  77         for(j = 0; j < nadaptors; j++) {
  78             fprintf(stdout, "  Adaptor #%i: \"%s\"\n", j, ainfo[j].name);
  79             fprintf(stdout, "    number of ports: %li\n", ainfo[j].num_ports);
  80             fprintf(stdout, "    port base: %li\n", ainfo[j].base_id);
  81             fprintf(stdout, "    operations supported: ");
  82             switch(ainfo[j].type & (XvInputMask | XvOutputMask)) {
  83             case XvInputMask:
  84              if(ainfo[j].type & XvVideoMask)
  85                 fprintf(stdout, "PutVideo ");
  86              if(ainfo[j].type & XvStillMask)
  87                 fprintf(stdout, "PutStill ");
  88              if(ainfo[j].type & XvImageMask)
  89                 fprintf(stdout, "PutImage ");
  90              break;
  91             case XvOutputMask:
  92              if(ainfo[j].type & XvVideoMask)
  93                 fprintf(stdout, "GetVideo ");
  94              if(ainfo[j].type & XvStillMask)
  95                 fprintf(stdout, "GetStill ");
  96              break;
  97             default:
  98                 fprintf(stdout, "none ");
  99                 break;
 100             }
 101             fprintf(stdout, "\n");
 102
 103             format = ainfo[j].formats;
 104
 105             if ( ! shortmode ) {
 106                     fprintf(stdout, "    supported visuals:\n");
 107                     for(k = 0; k < ainfo[j].num_formats; k++, format++) {
 108                          fprintf(stdout, "      depth %i, visualID 0x%2lx\n",
 109                                  format->depth, format->visual_id);
 110                     }
 111             }
 112
 113             attributes = XvQueryPortAttributes(dpy, ainfo[j].base_id, &nattr);
 114
 115             if(attributes && nattr) {
 116                 fprintf(stdout, "    number of attributes: %i\n", nattr);
 117
 118                 for(k = 0; k < nattr; k++) {
 119                     fprintf(stdout, "      \"%s\" (range %i to %i)\n",
 120                                         attributes[k].name,
 121                                         attributes[k].min_value,
 122                                         attributes[k].max_value);
 123
 124                     if(attributes[k].flags & XvSettable)
 125                         if ( ! shortmode )
 126                           fprintf(stdout, "              client settable attribute\n");
 127                         else fprintf(stdout, "              settable");
 128
 129                     if(attributes[k].flags & XvGettable) {
 130                         Atom the_atom;
 131                         int value;
 132
 133                         if ( ! shortmode )
 134                           fprintf(stdout, "              client gettable attribute");
 135                         else fprintf(stdout, ", gettable");
 136
 137                         the_atom = XInternAtom(dpy, attributes[k].name, True);
 138
 139                         if(the_atom != None){
 140                            if((Success == XvGetPortAttribute(dpy,
 141                                         ainfo[j].base_id, the_atom, &value)))
 142                                fprintf(stdout, " (current value is %i)", value);
 143                         }
 144                         fprintf(stdout, "\n");
 145                     }
 146                     else if (shortmode)
 147                         fprintf(stdout, "\n");
 148
 149                 }
 150                 XFree(attributes);
 151             } else {
 152                 fprintf(stdout, "    no port attributes defined\n");
 153             }
 154
 155             XvQueryEncodings(dpy, ainfo[j].base_id,
 156                                                 &nencode, &encodings);
 157
 158             if(encodings && nencode) {
 159                 int ImageEncodings = 0;
 160
 161                 for(n = 0; n < nencode; n++) {
 162                     if(!strcmp(encodings[n].name, "XV_IMAGE"))
 163                         ImageEncodings++;
 164                 }
 165
 166                 if(nencode - ImageEncodings) {
 167                     fprintf(stdout, "    number of encodings: %i\n",
 168                                                 nencode - ImageEncodings);
 169
 170                     for(n = 0; n < nencode; n++) {
 171                         if(strcmp(encodings[n].name, "XV_IMAGE")) {
 172                             fprintf(stdout, "      encoding ID #%li: \"%s\"\n",
 173                                         encodings[n].encoding_id,
 174                                         encodings[n].name);
 175                             fprintf(stdout, "        size: %li x %li\n",
 176                                         encodings[n].width,
 177                                         encodings[n].height);
 178                             fprintf(stdout, "        rate: %f\n",
 179                                         (float)encodings[n].rate.numerator/
 180                                         (float)encodings[n].rate.denominator);
 181                         }
 182                     }
 183                 }
 184
 185                 if(ImageEncodings && (ainfo[j].type & XvImageMask)) {
 186                    char imageName[5];
 187
 188                    for(n = 0; n < nencode; n++) {
 189                       if(!strcmp(encodings[n].name, "XV_IMAGE")) {
 190                         fprintf(stdout,
 191                                 "    maximum XvImage size: %li x %li\n",
 192                                 encodings[n].width, encodings[n].height);
 193                         break;
 194                       }
 195                    }
 196
 197                    formats = XvListImageFormats(
 198                                 dpy, ainfo[j].base_id, &numImages);
 199
 200                    fprintf(stdout, "    Number of image formats: %i\n",
 201                                                 numImages);
 202
 203                    for(n = 0; n < numImages; n++) {
 204                         sprintf(imageName, "%c%c%c%c", formats[n].id & 0xff,
 205                                 (formats[n].id >> 8) & 0xff,
 206                                 (formats[n].id >> 16) & 0xff,
 207                                 (formats[n].id >> 24) & 0xff);
 208                         fprintf(stdout, "      id: 0x%x", formats[n].id);
 209                         if(isprint(imageName[0]) && isprint(imageName[1]) &&
 210                           isprint(imageName[2]) && isprint(imageName[3]))
 211                         {
 212                           fprintf(stdout, " (%s)\n", imageName);
 213                         } else {
 214                           fprintf(stdout, "\n");
 215                         }
 216                         if ( ! shortmode ) {
 217                             fprintf(stdout, "        guid: ");
 218                             fprintf(stdout, "%02x", (unsigned char)
 219                                                 formats[n].guid[0]);
 220                             fprintf(stdout, "%02x", (unsigned char)
 221                                                 formats[n].guid[1]);
 222                             fprintf(stdout, "%02x", (unsigned char)
 223                                                 formats[n].guid[2]);
 224                             fprintf(stdout, "%02x-", (unsigned char)
 225                                                 formats[n].guid[3]);
 226                             fprintf(stdout, "%02x", (unsigned char)
 227                                                 formats[n].guid[4]);
 228                             fprintf(stdout, "%02x-", (unsigned char)
 229                                                 formats[n].guid[5]);
 230                             fprintf(stdout, "%02x", (unsigned char)
 231                                                 formats[n].guid[6]);
 232                             fprintf(stdout, "%02x-", (unsigned char)
 233                                                 formats[n].guid[7]);
 234                             fprintf(stdout, "%02x", (unsigned char)
 235                                                 formats[n].guid[8]);
 236                             fprintf(stdout, "%02x-", (unsigned char)
 237                                                 formats[n].guid[9]);
 238                             fprintf(stdout, "%02x", (unsigned char)
 239                                                 formats[n].guid[10]);
 240                             fprintf(stdout, "%02x", (unsigned char)
 241                                                 formats[n].guid[11]);
 242                             fprintf(stdout, "%02x", (unsigned char)
 243                                                 formats[n].guid[12]);
 244                             fprintf(stdout, "%02x", (unsigned char)
 245                                                 formats[n].guid[13]);
 246                             fprintf(stdout, "%02x", (unsigned char)
 247                                                 formats[n].guid[14]);
 248                             fprintf(stdout, "%02x\n", (unsigned char)
 249                                                 formats[n].guid[15]);
 250
 251                             fprintf(stdout, "        bits per pixel: %i\n",
 252                                         formats[n].bits_per_pixel);
 253                             fprintf(stdout, "        number of planes: %i\n",
 254                                         formats[n].num_planes);
 255                             fprintf(stdout, "        type: %s (%s)\n",
 256                               (formats[n].type == XvRGB) ? "RGB" : "YUV",
 257                               (formats[n].format == XvPacked) ? "packed" : "planar");
 258
 259                             if(formats[n].type == XvRGB) {
 260                                 fprintf(stdout, "        depth: %i\n",
 261                                         formats[n].depth);
 262
 263                                 fprintf(stdout, "        red, green, blue masks: "
 264                                         "0x%x, 0x%x, 0x%x\n",
 265                                         formats[n].red_mask,
 266                                         formats[n].green_mask,
 267                                         formats[n].blue_mask);
 268                             } else {
 269
 270                             }
 271                         }
 272
 273
 274                    }
 275                    if(formats) XFree(formats);
 276                 }
 277
 278                 XvFreeEncodingInfo(encodings);
 279             }
 280
 281         }
 282
 283         XvFreeAdaptorInfo(ainfo);
 284     }
 285     return 1;
 286 }