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