ALT Linux Sisyphus

pax_global_header00006660000000000000000000000064114652755430014526gustar00rootroot0000000000000052 comment=2abf1e4cbff8b67f836dd4102dcc0a179d98a142
xvinfo-1.1.1/000075500000000000000000000000001146527554300130355ustar00rootroot00000000000000xvinfo-1.1.1/.gitignore000064400000000000000000000017561146527554300150360ustar00rootroot00000000000000#
#		X.Org module default exclusion patterns
#		The next section if for module specific patterns
#
#	Do not edit the following section
# 	GNU Build System (Autotools)
aclocal.m4
autom4te.cache/
autoscan.log
ChangeLog
compile
config.guess
config.h
config.h.in
config.log
config-ml.in
config.py
config.status
config.status.lineno
config.sub
configure
configure.scan
depcomp
.deps/
INSTALL
install-sh
.libs/
libtool
libtool.m4
ltmain.sh
lt~obsolete.m4
ltoptions.m4
ltsugar.m4
ltversion.m4
Makefile
Makefile.in
mdate-sh
missing
mkinstalldirs
*.pc
py-compile
stamp-h?
symlink-tree
texinfo.tex
ylwrap

#	Do not edit the following section
# 	Edit Compile Debug Document Distribute
*~
*.[0-9]
*.[0-9]x
*.bak
*.bin
core
*.dll
*.exe
*-ISO*.bdf
*-JIS*.bdf
*-KOI8*.bdf
*.kld
*.ko
*.ko.cmd
*.lai
*.l[oa]
*.[oa]
*.obj
*.patch
*.so
*.pcf.gz
*.pdb
*.tar.bz2
*.tar.gz
#
#		Add & Override patterns for xvinfo 
#
#		Edit the following section as needed
# For example, !report.pc overrides *.pc. See 'man gitignore'
# 
xvinfo
xvinfo-1.1.1/COPYING000064400000000000000000000026161146527554300140750ustar00rootroot00000000000000XFree86 code without an explicit copyright is covered by the following copy-
right/license:

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is fur-
nished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FIT-
NESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
XFREE86 PROJECT BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CON-
NECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

Except as contained in this notice, the name of the XFree86 Project shall not
be used in advertising or otherwise to promote the sale, use or other deal-
ings in this Software without prior written authorization from the XFree86
Project.
xvinfo-1.1.1/Makefile.am000064400000000000000000000033541146527554300150760ustar00rootroot00000000000000# 
#  Copyright 2005  Red Hat, Inc.
# 
#  Permission to use, copy, modify, distribute, and sell this software and its
#  documentation for any purpose is hereby granted without fee, provided that
#  the above copyright notice appear in all copies and that both that
#  copyright notice and this permission notice appear in supporting
#  documentation, and that the name of Red Hat not be used in
#  advertising or publicity pertaining to distribution of the software without
#  specific, written prior permission.  Red Hat makes no
#  representations about the suitability of this software for any purpose.  It
#  is provided "as is" without express or implied warranty.
# 
#  RED HAT DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
#  INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
#  EVENT SHALL RED HAT BE LIABLE FOR ANY SPECIAL, INDIRECT OR
#  CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
#  DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
#  TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
#  PERFORMANCE OF THIS SOFTWARE.

bin_PROGRAMS = xvinfo

AM_CFLAGS = $(CWARNFLAGS) $(XVINFO_CFLAGS)
xvinfo_LDADD = $(XVINFO_LIBS)

xvinfo_SOURCES =	\
        xvinfo.c

appman_PRE = \
        xvinfo.man

appmandir = $(APP_MAN_DIR)

appman_DATA = $(appman_PRE:man=@APP_MAN_SUFFIX@)

EXTRA_DIST = $(appman_PRE) 
MAINTAINERCLEANFILES = ChangeLog INSTALL
CLEANFILES = $(appman_DATA)

.PHONY: ChangeLog INSTALL

INSTALL:
	$(INSTALL_CMD)

ChangeLog:
	$(CHANGELOG_CMD)

dist-hook: ChangeLog INSTALL

SUFFIXES = .$(APP_MAN_SUFFIX) .man

# String replacements in MAN_SUBSTS now come from xorg-macros.m4 via configure
.man.$(APP_MAN_SUFFIX):
	$(AM_V_GEN)$(SED) $(MAN_SUBSTS) < $< > $@
xvinfo-1.1.1/README000064400000000000000000000013751146527554300137230ustar00rootroot00000000000000xvinfo prints out the capabilities of any video adaptors associated
with the display that are accessible through the X-Video extension.

All questions regarding this software should be directed at the
Xorg mailing list:

        http://lists.freedesktop.org/mailman/listinfo/xorg

Please submit bug reports to the Xorg bugzilla:

        https://bugs.freedesktop.org/enter_bug.cgi?product=xorg

The master development code repository can be found at:

        git://anongit.freedesktop.org/git/xorg/app/xvinfo

        http://cgit.freedesktop.org/xorg/app/xvinfo

For patch submission instructions, see:

	http://www.x.org/wiki/Development/Documentation/SubmittingPatches

For more information on the git code manager, see:

        http://wiki.x.org/wiki/GitPage

xvinfo-1.1.1/autogen.sh000075500000000000000000000003041146527554300150330ustar00rootroot00000000000000#! /bin/sh

srcdir=`dirname $0`
test -z "$srcdir" && srcdir=.

ORIGDIR=`pwd`
cd $srcdir

autoreconf -v --install || exit 1
cd $ORIGDIR || exit $?

$srcdir/configure --enable-maintainer-mode "$@"

xvinfo-1.1.1/configure.ac000064400000000000000000000033571146527554300153330ustar00rootroot00000000000000
dnl  Copyright 2005 Red Hat, Inc.
dnl 
dnl  Permission to use, copy, modify, distribute, and sell this software and its
dnl  documentation for any purpose is hereby granted without fee, provided that
dnl  the above copyright notice appear in all copies and that both that
dnl  copyright notice and this permission notice appear in supporting
dnl  documentation, and that the name of Red Hat not be used in
dnl  advertising or publicity pertaining to distribution of the software without
dnl  specific, written prior permission.  Red Hat makes no
dnl  representations about the suitability of this software for any purpose.  It
dnl  is provided "as is" without express or implied warranty.
dnl 
dnl  RED HAT DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
dnl  INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
dnl  EVENT SHALL RED HAT BE LIABLE FOR ANY SPECIAL, INDIRECT OR
dnl  CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
dnl  DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
dnl  TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
dnl  PERFORMANCE OF THIS SOFTWARE.
dnl
dnl Process this file with autoconf to create configure.

AC_PREREQ([2.60])
AC_INIT([xvinfo], [1.1.1],
        [https://bugs.freedesktop.org/enter_bug.cgi?product=xorg], [xvinfo])
AM_INIT_AUTOMAKE([foreign dist-bzip2])
AM_MAINTAINER_MODE

# Require X.Org macros 1.8 or later for MAN_SUBSTS set by XORG_MANPAGE_SECTIONS
m4_ifndef([XORG_MACROS_VERSION],
	  [m4_fatal([must install xorg-macros 1.8 or later before running autoconf/autogen])])
XORG_MACROS_VERSION(1.8)

AM_CONFIG_HEADER(config.h)

XORG_DEFAULT_OPTIONS

# Checks for pkg-config packages
PKG_CHECK_MODULES(XVINFO, xv x11)

AC_OUTPUT([Makefile])
xvinfo-1.1.1/xvinfo.c000064400000000000000000000174411146527554300145210ustar00rootroot00000000000000#include <X11/X.h>
#include <X11/Xlib.h>
#include <X11/extensions/Xvlib.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

static void
PrintUsage(void)
{
   fprintf(stderr, "Usage:  xvinfo [-display host:dpy] [-short]\n");
   exit(0);
}

int main(int argc, char *argv[])
{
    Display *dpy;
    unsigned int ver, rev, eventB, reqB, errorB; 
    int i, j, k, n; 
    unsigned int nencode, nadaptors;
    int nscreens, nattr, numImages;
    XvAdaptorInfo *ainfo;
    XvAttribute *attributes;
    XvEncodingInfo *encodings;
    XvFormat *format;
    XvImageFormatValues *formats;
    char * disname = NULL;
    char shortmode = 0;

    if((argc > 4))
       PrintUsage();

    if(argc != 1) {
       for ( i = 1; i < argc; i ++ ) {
           if(! strcmp(argv[i], "-display")) {
	       disname = argv[i + 1];
	       i ++;
	   } else if(! strcmp(argv[i], "-short") )
	       shortmode = 1;
	     else {
	       PrintUsage();
	     }
       }
    }

    if(!(dpy = XOpenDisplay(disname))) 
    {
	fprintf(stderr, "xvinfo:  Unable to open display %s\n",
                       (disname != NULL) ? disname : XDisplayName(NULL));
	exit(-1);
    }

    if((Success != XvQueryExtension(dpy, &ver, &rev, &reqB, &eventB, &errorB))) 
    {
	fprintf(stderr, "xvinfo: No X-Video Extension on %s\n",
                        (disname != NULL) ? disname : XDisplayName(NULL));
	exit(0);
    } 
    else
    {
	fprintf(stdout, "X-Video Extension version %i.%i\n", ver, rev);
    }

    nscreens = ScreenCount(dpy);

    for(i = 0; i < nscreens; i++) {
  	fprintf(stdout, "screen #%i\n", i);
	XvQueryAdaptors(dpy, RootWindow(dpy, i), &nadaptors, &ainfo);

	if(!nadaptors) {
	    fprintf(stdout, " no adaptors present\n");
	    continue;
	} 

	for(j = 0; j < nadaptors; j++) {
	    fprintf(stdout, "  Adaptor #%i: \"%s\"\n", j, ainfo[j].name);
	    fprintf(stdout, "    number of ports: %li\n", ainfo[j].num_ports);
	    fprintf(stdout, "    port base: %li\n", ainfo[j].base_id);
	    fprintf(stdout, "    operations supported: ");
	    switch(ainfo[j].type & (XvInputMask | XvOutputMask)) {
	    case XvInputMask:
	     if(ainfo[j].type & XvVideoMask) 
		fprintf(stdout, "PutVideo ");
	     if(ainfo[j].type & XvStillMask) 
		fprintf(stdout, "PutStill ");
	     if(ainfo[j].type & XvImageMask) 
		fprintf(stdout, "PutImage ");
	     break;
	    case XvOutputMask:
	     if(ainfo[j].type & XvVideoMask) 
		fprintf(stdout, "GetVideo ");
	     if(ainfo[j].type & XvStillMask) 
		fprintf(stdout, "GetStill ");
	     break;
	    default:
		fprintf(stdout, "none ");
		break;
	    }
	    fprintf(stdout, "\n");

	    format = ainfo[j].formats;

	    if ( ! shortmode ) {
		    fprintf(stdout, "    supported visuals:\n");
		    for(k = 0; k < ainfo[j].num_formats; k++, format++) {
		         fprintf(stdout, "      depth %i, visualID 0x%2lx\n",
				 format->depth, format->visual_id);
		    }
	    }

	    attributes = XvQueryPortAttributes(dpy, ainfo[j].base_id, &nattr);

	    if(attributes && nattr) {
		fprintf(stdout, "    number of attributes: %i\n", nattr);

		for(k = 0; k < nattr; k++) {
		    fprintf(stdout, "      \"%s\" (range %i to %i)\n",
					attributes[k].name, 
					attributes[k].min_value,
					attributes[k].max_value);

		    if(attributes[k].flags & XvSettable)
			if ( ! shortmode )
		    	  fprintf(stdout, "              client settable attribute\n");
		        else fprintf(stdout, "              settable");

		    if(attributes[k].flags & XvGettable) {
			Atom the_atom;
			int value;

			if ( ! shortmode )
		    	  fprintf(stdout, "              client gettable attribute");
			else fprintf(stdout, ", gettable");

			the_atom = XInternAtom(dpy, attributes[k].name, True);

			if(the_atom != None){
			   if((Success == XvGetPortAttribute(dpy, 
					ainfo[j].base_id, the_atom, &value)))
		    	       fprintf(stdout, " (current value is %i)", value);
			}
			fprintf(stdout, "\n");
		    }
		    else if (shortmode) 
			fprintf(stdout, "\n");

		}
		XFree(attributes);
	    } else {
		fprintf(stdout, "    no port attributes defined\n");
	    }

	    XvQueryEncodings(dpy, ainfo[j].base_id,
						&nencode, &encodings);

	    if(encodings && nencode) {
		int ImageEncodings = 0;

		for(n = 0; n < nencode; n++) {
		    if(!strcmp(encodings[n].name, "XV_IMAGE"))
			ImageEncodings++;
		}

		if(nencode - ImageEncodings) {
		    fprintf(stdout, "    number of encodings: %i\n", 
						nencode - ImageEncodings);

		    for(n = 0; n < nencode; n++) {
		    	if(strcmp(encodings[n].name, "XV_IMAGE")) {
			    fprintf(stdout, "      encoding ID #%li: \"%s\"\n",
					encodings[n].encoding_id,
					encodings[n].name);
			    fprintf(stdout, "        size: %li x %li\n",
					encodings[n].width,
					encodings[n].height);
			    fprintf(stdout, "        rate: %f\n",
					(float)encodings[n].rate.numerator/
					(float)encodings[n].rate.denominator);
			}
		    }
		}

		if(ImageEncodings && (ainfo[j].type & XvImageMask)) {
		   char imageName[5];

		   for(n = 0; n < nencode; n++) {
		      if(!strcmp(encodings[n].name, "XV_IMAGE")) {
			fprintf(stdout, 
				"    maximum XvImage size: %li x %li\n",	
				encodings[n].width, encodings[n].height);
			break;
		      }
		   }

                   formats = XvListImageFormats(
				dpy, ainfo[j].base_id, &numImages);

		   fprintf(stdout, "    Number of image formats: %i\n",
						numImages);

		   for(n = 0; n < numImages; n++) {
			sprintf(imageName, "%c%c%c%c", formats[n].id & 0xff,
				(formats[n].id >> 8) & 0xff,
				(formats[n].id >> 16) & 0xff,
				(formats[n].id >> 24) & 0xff);
			fprintf(stdout, "      id: 0x%x", formats[n].id);
			if(isprint(imageName[0]) && isprint(imageName[1]) &&
			  isprint(imageName[2]) && isprint(imageName[3])) 
			{
			  fprintf(stdout, " (%s)\n", imageName);
			} else {
			  fprintf(stdout, "\n");
			}
			if ( ! shortmode ) {
			    fprintf(stdout, "        guid: ");
			    fprintf(stdout, "%02x", (unsigned char) 
						formats[n].guid[0]);
			    fprintf(stdout, "%02x", (unsigned char) 
						formats[n].guid[1]);
			    fprintf(stdout, "%02x", (unsigned char) 
						formats[n].guid[2]);
			    fprintf(stdout, "%02x-", (unsigned char) 
						formats[n].guid[3]);
			    fprintf(stdout, "%02x", (unsigned char) 
						formats[n].guid[4]);
			    fprintf(stdout, "%02x-", (unsigned char) 
						formats[n].guid[5]);
			    fprintf(stdout, "%02x", (unsigned char) 
						formats[n].guid[6]);
			    fprintf(stdout, "%02x-", (unsigned char) 
						formats[n].guid[7]);
			    fprintf(stdout, "%02x", (unsigned char) 
						formats[n].guid[8]);
			    fprintf(stdout, "%02x-", (unsigned char) 
						formats[n].guid[9]);
			    fprintf(stdout, "%02x", (unsigned char) 
						formats[n].guid[10]);
			    fprintf(stdout, "%02x", (unsigned char) 
						formats[n].guid[11]);
			    fprintf(stdout, "%02x", (unsigned char) 
						formats[n].guid[12]);
			    fprintf(stdout, "%02x", (unsigned char) 
						formats[n].guid[13]);
			    fprintf(stdout, "%02x", (unsigned char) 
						formats[n].guid[14]);
			    fprintf(stdout, "%02x\n", (unsigned char) 
						formats[n].guid[15]);

			    fprintf(stdout, "        bits per pixel: %i\n",
					formats[n].bits_per_pixel);
			    fprintf(stdout, "        number of planes: %i\n",
					formats[n].num_planes);
			    fprintf(stdout, "        type: %s (%s)\n", 
			      (formats[n].type == XvRGB) ? "RGB" : "YUV",
			      (formats[n].format == XvPacked) ? "packed" : "planar");

			    if(formats[n].type == XvRGB) {
			        fprintf(stdout, "        depth: %i\n", 
                                        formats[n].depth);

			        fprintf(stdout, "        red, green, blue masks: " 
					"0x%x, 0x%x, 0x%x\n", 
					formats[n].red_mask,
					formats[n].green_mask,
					formats[n].blue_mask);
			    } else {

			    } 
			}

		   }
		   if(formats) XFree(formats);
		}

		XvFreeEncodingInfo(encodings);
	    }

	}

	XvFreeAdaptorInfo(ainfo);
    }
    return 1;
}
xvinfo-1.1.1/xvinfo.man000064400000000000000000000014741146527554300150510ustar00rootroot00000000000000.TH xvinfo __appmansuffix__ __vendorversion__
.SH NAME
xvinfo - Print out X-Video extension adaptor information
.SH SYNOPSIS
.B "xvinfo"
[-display \fIdisplayname\fP] 
.SH DESCRIPTION
.PP
.B xvinfo
prints out the capabilities of any video adaptors associated
with the display that are accessible through the X-Video extension. 
.SH OPTIONS
.PP
.TP 8
.B "-display \fIdisplay\fP"
This argument allows you to specify the server to query; see \fIX(__miscmansuffix__)\fP.
.TP 8
.B "-short"
Output less details, to reduce the amount of text.
.SH ENVIRONMENT
.PP
.TP 8
.B DISPLAY
This variable may be used to specify the server to query.

.SH SEE ALSO
X(__miscmansuffix__), xdpyinfo(__appmansuffix__), xwininfo(__appmansuffix__),
xdriinfo(__appmansuffix__), glxinfo(__appmansuffix__), xprop(__appmansuffix__)
.SH AUTHORS
Mark Vojkovich

S:	1.1.4-alt1
5.1:	1.0.2-alt1
4.1:	1.0.2-alt1
4.0:	1.0.1-alt1