777 lines
21 KiB
Groff
777 lines
21 KiB
Groff
.\"
|
|
.\" $Id: meteor.4,v 1.6 1997/03/21 20:13:50 mpp Exp $
|
|
.\"
|
|
.Dd August 15, 1995
|
|
.br
|
|
.in +0.5i
|
|
.Dt METEOR 4 i386
|
|
.Os FreeBSD
|
|
.Sh NAME
|
|
.Nm meteor
|
|
.Nd video capture driver
|
|
.Sh SYNOPSIS
|
|
.Nm video meteor
|
|
.Sh DESCRIPTION
|
|
The
|
|
.Nm meteor
|
|
driver provides support for a PCI
|
|
.Em video
|
|
capture. It allows the capture of 24 bit RGB, 16 bit RGB and 16 bit YUV
|
|
output formats.
|
|
.Pp
|
|
.Sh Meteor Driver Installation
|
|
To use the Matrox Meteor card in your system, you need a computer
|
|
that support the PCI (preferably the Type 2 or better) interface bus.
|
|
It is recommended that the system has as more than 16 MB of RAM since this
|
|
capture card directly deposits the image to system RAM.
|
|
.Pp
|
|
The files required for Matrox Meteor card are:
|
|
.br
|
|
.in +0.5i
|
|
/sys/pci/meteor.c
|
|
.br
|
|
/sys/i386/include/ioctl_meteor.h (also known as:
|
|
.br
|
|
/usr/include/machine/ioctl_meteor.h)
|
|
.br
|
|
.in -0.5i
|
|
For
|
|
.Tn FreeBSD
|
|
release versions 2.1 and earlier, the following patch files are also required:
|
|
.br
|
|
.in +0.5i
|
|
meteor/usr/sys/i386/i386/conf.patch
|
|
.br
|
|
meteor/usr/sys/conf/files.patch
|
|
.br
|
|
meteor/sys/i386/conf/LINT.patch
|
|
.br
|
|
These files are available for anonymous ftp at:
|
|
.br
|
|
.in +0.5i
|
|
ftp://joy.cs.ndsu.nodak.edu/pub/meteor.tgz
|
|
.br
|
|
.in -1.0i
|
|
.Pp
|
|
1) In the configuration file, add the line (as shown in
|
|
meteor/usr/sys/i386/conf/LINT.patch):
|
|
.Pp
|
|
.Em device meteor0
|
|
.Pp
|
|
2) There is also a couple of optional parameters you may use
|
|
.Pp
|
|
.Em options "METEOR_ALLOC_PAGES=xxx"
|
|
specifies the number of contiguous pages to allocate when successfully
|
|
probed. The default number of pages allocated by the kernel is 151.
|
|
This means that there are (151*4096) bytes available for use.
|
|
.Pp
|
|
.Em options METEOR_DEALLOC_PAGES
|
|
deallocate all pages when closing the device. Note, the chance of
|
|
contiguously re-allocating new pages are very small. The default
|
|
behavior is to not deallocate pages.
|
|
.Pp
|
|
.Em options "METEOR_DEALLOC_ABOVE=xxx"
|
|
deallocate all pages above the specified number. The default action is
|
|
to not deallocate above any pages.
|
|
.Pp
|
|
3) Make and install the kernel.
|
|
.Pp
|
|
4) Make the special file name:
|
|
.Pp
|
|
.Em mknod /dev/meteor0 c <major> 0
|
|
The major number is determined by the placement of the device in conf.c.
|
|
The patch supplied with the driver will make the major number 67.
|
|
.Pp
|
|
.Sh Meteor Capture Modes
|
|
The Meteor capture driver has three modes of capture operation.
|
|
.Pp
|
|
1) Conventional read(2) interface.
|
|
.in +0.5i
|
|
.Pp
|
|
This mode is the easiest and slowest to use. This mode is great for
|
|
capturing a single field at little programming cost.
|
|
.Pp
|
|
In this mode, the user opens the device, set the capture mode
|
|
and size (See: METEORSETGEO ioctl call), and uses the read system
|
|
call to load the data into a buffer.
|
|
.Pp
|
|
meteor_read.c; read 400x300 RGB24 into a viewable PPM file
|
|
.Pp
|
|
.in -0.5i
|
|
.nf
|
|
#include <sys/fcntl.h>
|
|
#include <machine/ioctl_meteor.h>
|
|
|
|
extern int errno;
|
|
#define ROWS 300
|
|
#define COLS 400
|
|
#define SIZE (ROWS * COLS * 4)
|
|
main()
|
|
{
|
|
struct meteor_geomet geo;
|
|
char buf[SIZE],b[4],header[16],*p;
|
|
int i,o,c;
|
|
|
|
if ((i = open("/dev/meteor0", O_RDONLY)) < 0) {
|
|
printf("open failed: %d\n", errno);
|
|
exit(1);
|
|
}
|
|
/* set up the capture type and size */
|
|
geo.rows = ROWS;
|
|
geo.columns = COLS;
|
|
geo.frames = 1;
|
|
geo.oformat = METEOR_GEO_RGB24 ;
|
|
|
|
if (ioctl(i, METEORSETGEO, &geo) < 0) {
|
|
printf("ioctl failed: %d\n", errno);
|
|
exit(1);
|
|
}
|
|
|
|
c = METEOR_FMT_NTSC;
|
|
|
|
if (ioctl(i, METEORSFMT, &c) < 0) {
|
|
printf("ioctl failed: %d\n", errno);
|
|
exit(1);
|
|
}
|
|
|
|
c = METEOR_INPUT_DEV0;
|
|
|
|
if (ioctl(i, METEORSINPUT, &c) < 0) {
|
|
printf("ioctl failed: %d\n", errno);
|
|
exit(1);
|
|
}
|
|
|
|
if ((c=read(i, &buf[0], SIZE)) < SIZE) {
|
|
printf("read failed %d %d %d\n", c, i, errno);
|
|
close(i);
|
|
exit(1);
|
|
}
|
|
close(i);
|
|
|
|
if ((o = open("rgb24.ppm", O_WRONLY | O_CREAT, 0644)) < 0) {
|
|
printf("ppm open failed: %d\n", errno);
|
|
exit(1);
|
|
}
|
|
|
|
/* make PPM header and save to file */
|
|
strcpy(&header[0], "P6 400 300 255 ");
|
|
header[2] = header[6] = header[10] = header[14] = '\n';
|
|
write (o, &header[0], 15);
|
|
/* save the RGB data to PPM file */
|
|
for (p = &buf[0]; p < &buf[SIZE]; ) {
|
|
b[2] = *p++; /* blue */
|
|
b[1] = *p++; /* green */
|
|
b[0] = *p++; /* red */
|
|
*p++; /* NULL byte */
|
|
write(o,&b[0], 3); /* not very efficient */
|
|
}
|
|
close(o);
|
|
exit(0);
|
|
}
|
|
.if
|
|
.Pp
|
|
2) Memory mapped single capture or unsynchronized continuous capture.
|
|
.in +0.5i
|
|
.Pp
|
|
The single capture mode is designed for conferencing tools such as nv.
|
|
These tools need to control the starting of the image capture and also
|
|
need several frames a second. The continuous capture mode is designed
|
|
for applications that want free-running data.
|
|
.Pp
|
|
In this mode, the user opens the device, set the capture mode
|
|
and size (See: METEORSETGEO ioctl call), memory maps the frame buffer
|
|
memory into the user process space, and issues either the
|
|
single-capture or the continuous capture call (See: METEORCAPTUR ioctl
|
|
call) to load the data into the memory mapped buffer.
|
|
.Pp
|
|
As explained in the METEORCAPTUR ioctl call, the single frame capture
|
|
ioctl will block until the capture is complete, the continuous capture
|
|
will return immediately.
|
|
.in -0.5i
|
|
.Pp
|
|
meteor_mmap_single_continuous.c
|
|
.Pp
|
|
.nf
|
|
#include <sys/types.h>
|
|
#include <sys/mman.h>
|
|
#include <sys/fcntl.h>
|
|
#include <machine/ioctl_meteor.h>
|
|
|
|
extern int errno;
|
|
#define ROWS 480
|
|
#define COLS 640
|
|
#define SIZE (ROW * COLS * 2)
|
|
main()
|
|
{
|
|
struct meteor_geomet geo;
|
|
char buf[SIZE];
|
|
char *mmbuf;
|
|
int i,c;
|
|
|
|
if ((i = open("/dev/meteor0", O_RDONLY)) < 0) {
|
|
printf("open failed\n");
|
|
exit(1);
|
|
}
|
|
|
|
geo.rows = ROWS;
|
|
geo.columns = COLS;
|
|
geo.frames = 1;
|
|
geo.oformat = METEOR_GEO_RGB16 ;
|
|
|
|
if (ioctl(i, METEORSETGEO, &geo) < 0) {
|
|
printf("ioctl failed: %d\n", errno);
|
|
exit(1);
|
|
}
|
|
|
|
c = METEOR_FMT_NTSC;
|
|
|
|
if (ioctl(i, METEORSFMT, &c) < 0) {
|
|
printf("ioctl failed: %d\n", errno);
|
|
exit(1);
|
|
}
|
|
|
|
c = METEOR_INPUT_DEV0;
|
|
|
|
if (ioctl(i, METEORSINPUT, &c) < 0) {
|
|
printf("ioctl failed: %d\n", errno);
|
|
exit(1);
|
|
}
|
|
|
|
mmbuf=(char *)mmap((caddr_t)0, SIZE, PROT_READ,
|
|
MAP_SHARED, i, (off_t)0);
|
|
|
|
#ifdef SINGLE_MODE
|
|
/* single frame capture */
|
|
c = METEOR_CAP_SINGLE ;
|
|
ioctl(i, METEORCAPTUR, &c); /* wait for the frame */
|
|
|
|
/* directly access the frame buffer array data in mmbuf */
|
|
#else
|
|
/* continuous frame capture */
|
|
c = METEOR_CAP_CONTINOUS ;
|
|
ioctl(i, METEORCAPTUR, &c); /* returns immediately */
|
|
|
|
/* directly access the frame buffer array data in mmbuf */
|
|
|
|
c = METEOR_CAP_STOP_CONT ;
|
|
ioctl(i, METEORCAPTUR, &c); /* close will also stop capture */
|
|
#endif
|
|
|
|
close(i);
|
|
exit(0);
|
|
}
|
|
.if
|
|
.Pp
|
|
3) Memory mapped, multi-frame ring buffer synchronize capture.
|
|
.Pp
|
|
.in +0.5i
|
|
This continuous capture mode is synchronized with the application that
|
|
processes up to 32 frames. This gives the advantages of both single and
|
|
continuous capture modes.
|
|
.Pp
|
|
The kernel notifies the application of a new data by raising an
|
|
application defined signal. The driver also shares a structure with
|
|
the application that allows them to communicate which frame has been
|
|
written by the kernel and which frame has been read by the application.
|
|
.Pp
|
|
The shared structure starts on the first page after your data. The
|
|
structure address can be found by calculation:
|
|
.in +0.5i
|
|
.Pp
|
|
(number_rows * number_columns * pixel_depth + 4095) & 0xfffff000
|
|
.in -0.5i
|
|
.Pp
|
|
or
|
|
.in +0.5i
|
|
.Pp
|
|
((number_rows * number_columns * pixel_depth + 4095)/4096) * 4096
|
|
.in -0.5i
|
|
.Pp
|
|
The shared structure is of type struct meteor_mem. The two most
|
|
important fields are called active and num_active_buf. active
|
|
is a bitmap of frames written by the kernel. num_active_bufs is
|
|
a count of frames marked in the active field. When a frame is read
|
|
in by the driver, the num_active_bufs count is tested, if this
|
|
count is below the threshold of number of active frames (value
|
|
in meteor_mem's hiwat variable), the bit representing frame
|
|
number in the buffer is stored in the active variable, the
|
|
num_active_bufs is incremented, the kernel then raises the specified
|
|
signal to activate the user application. The user application's
|
|
responsibility when getting the signal is to check the active bitmap
|
|
to determine the lowest active frame, use the data as the application
|
|
desires, clear the bitmap entry for that frame, and decrement the
|
|
num_active_bufs. If the threshold of number of active frames (hiwat)
|
|
has been exceeded, no new frames or signal from the kernel will occur
|
|
until the num_active_bufs is less than or equal to lowat.
|
|
.Pp
|
|
The driver loads the frames in a round-robin fashion. it is expected
|
|
that the user removes them in the same order. The driver does not
|
|
check to see if the frame is already active.
|
|
.Pp
|
|
The frame_size and number of frames in the buffer are also provided
|
|
to the meteor_mem structure, but changing these fields in the
|
|
application will not change the operation of the driver.
|
|
.Pp
|
|
In programming for this mode, the user opens the device, sets the
|
|
geometry, mmaps the data/common control structure, then starts the
|
|
continuous capture mode. A special signal catcher is required to
|
|
process the frames as they are read by the kernel.
|
|
.Pp
|
|
When specifying the geometry (See: ioctl METEORSETGEO), it
|
|
is important that the number of frames is set greater than 1.
|
|
.in -0.5i
|
|
.Pp
|
|
skeleton_capture_n.c
|
|
.Pp
|
|
.nf
|
|
#include <sys/types.h>
|
|
#include <sys/mman.h>
|
|
#include <sys/fcntl.h>
|
|
#include <sys/signal.h>
|
|
#include <machine/ioctl_meteor.h>
|
|
|
|
int video; /* made global if you wish to stop capture in signal handler */
|
|
caddr_t data_frames;
|
|
struct meteor_mem *common_mem;
|
|
extern int errno;
|
|
|
|
#define FRAME_MAX
|
|
|
|
void
|
|
usr2_catcher()
|
|
{
|
|
#ifdef SIGNAL_STOP
|
|
struct meteor_capframe capframe; /* for ioctl */
|
|
#endif
|
|
char *frame;
|
|
|
|
/* find frame */
|
|
frame = (char *) (data_frames + sig_cnt * common_mem->frame_size) ;
|
|
|
|
/* add frame processing here */
|
|
/* deactivate frame */
|
|
common_mem->active &= ~(1 << (sig_cnt % 16));
|
|
common_mem->num_active_bufs--;
|
|
|
|
/* process next frame on next interrupt */
|
|
sig_cnt = ((sig_cnt+1) % FRAME_MAX);
|
|
|
|
#ifdef SIGNAL_STOP
|
|
if (some_condition_requiring_stopping) {
|
|
capframe.command=METEOR_CAP_STOP_FRAMES;
|
|
|
|
if (ioctl(i, METEORCAPFRM, &capframe) < 0) {
|
|
printf("METEORCAPFRM failed %d\n", errno);
|
|
exit(1);
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
main()
|
|
{
|
|
struct meteor_geomet geo;
|
|
int height, width, depth, frames, size;
|
|
struct meteor_capframe capframe;
|
|
|
|
if ((i = open("/dev/meteor0", O_RDONLY)) < 0) {
|
|
printf("open failed\n");
|
|
exit(1);
|
|
}
|
|
printf("test %d %d\n", errno, i);
|
|
|
|
height = geo.rows = 120;
|
|
width= geo.columns = 320;
|
|
frames = geo.frames = FRAME_MAX;
|
|
depth = 2; /* 2 bytes per pixel for RGB*/
|
|
|
|
|
|
geo.oformat = METEOR_GEO_RGB16;
|
|
|
|
if (ioctl(i, METEORSETGEO, &geo) < 0) {
|
|
printf("METEORSETGEO failed %d\n", errno);
|
|
exit(1);
|
|
}
|
|
|
|
c = METEOR_FMT_NTSC;
|
|
|
|
if (ioctl(i, METEORSFMT, &c) < 0) {
|
|
printf("ioctl failed: %d\n", errno);
|
|
exit(1);
|
|
}
|
|
|
|
c = METEOR_INPUT_DEV0;
|
|
|
|
if (ioctl(i, METEORSINPUT, &c) < 0) {
|
|
printf("ioctl failed: %d\n", errno);
|
|
exit(1);
|
|
}
|
|
|
|
size = ((width*height*depth*frames+4095)/4096)*4096;
|
|
/* add one page after data for meteor_mem */
|
|
data_frames = mmap((caddr_t)0, size + 4096, PROT_READ | PROT_WRITE,
|
|
MAP_SHARED, i, (off_t)0);
|
|
|
|
if (data_frames == (caddr_t) MAP_FAILED) return (0);
|
|
|
|
/* common_mem is located at page following data */
|
|
common_mem = (struct meteor_mem *) (y + size);
|
|
|
|
signal(SIGUSR2, usr2_catcher); /* catch new frame message */
|
|
|
|
capframe.command=METEOR_CAP_N_FRAMES;
|
|
capframe.signal=SIGUSR2;
|
|
capframe.lowat=12; /* must be < hiwat */
|
|
capframe.hiwat=14; /* must be < FRAME_MAX */
|
|
|
|
/* start the sync capture */
|
|
if (ioctl(i, METEORCAPFRM, &capframe) < 0) {
|
|
printf("METEORCAPFRM failed %d\n", errno);
|
|
exit(1);
|
|
}
|
|
|
|
/* this is the background working area, or you can sleep */
|
|
|
|
|
|
/* to stop capture */
|
|
capframe.command=METEOR_CAP_STOP_FRAMES;
|
|
|
|
if (ioctl(i, METEORCAPFRM, &capframe) < 0) {
|
|
printf("METEORCAPFRM failed %d\n", errno);
|
|
exit(1);
|
|
}
|
|
}
|
|
.if
|
|
.Pp
|
|
.Sh Meteor IOCTL Call and Parameters
|
|
.Pp
|
|
The Meteor capture driver has ioctl requests for capturing, reading card
|
|
status, for setting and reading the geometry, and for setting and reading the
|
|
attributes.
|
|
.Pp
|
|
IT IS VERY IMPORTANT TO CHECK FOR ERRORS ON THESE RETURNING IOCTLs.
|
|
Errors indicate that something is very wrong with the ioctl and the
|
|
application should not attempt to proceed further with capturing. The
|
|
meteor capture driver still makes attempts to stop the next capture step if
|
|
an error occurred in a previous step but was ignored by the application
|
|
programmer.
|
|
.Pp
|
|
1) ioctl requests METEORSETGEO and METEORGETGEO
|
|
.in +0.5i
|
|
METEORSETGEO and METEORGETGEO are used to set and read the input
|
|
size, input device, and output format for frame capture.
|
|
.Pp
|
|
These ioctl routines use the meteor_geomet structure that has the
|
|
following entries:
|
|
.Pp
|
|
.Bl -tag -width columns
|
|
.It Dv rows
|
|
number of rows (lines high) in output image
|
|
.It Dv columns
|
|
number of pixels in a row (width) in output image
|
|
.It Dv frames
|
|
number of frames in buffer. Should be 1, unless using
|
|
the multi-framed synchronous capture mode (METEORCAPFRM)
|
|
which REQUIRES frames to be larger than 1.
|
|
.Pp
|
|
Note: if rows, columns or frames is not changed, then
|
|
the existing values are used. The system defaults
|
|
is 640x480x1.
|
|
.It Dv oformat
|
|
you may choose one of the following output format:
|
|
.Bl -tag -width METEOR_GEO_YUV_PACKED
|
|
.It Dv METEOR_GEO_RGB16
|
|
RGB 16 bits xrrrrrgg gggbbbbb default)
|
|
.It Dv METEOR_GEO_RGB24
|
|
(RBG 24 bits packed in 32 bits:
|
|
00000000 rrrrrrrr gggggggg bbbbbbbb)
|
|
.It Dv METEOR_GEO_YUV_PACKED
|
|
(4-2-2 YUV 16 bits packed. byte format:
|
|
u0 y0 v0 y1 u1 y2 v1 y3 ...)
|
|
.It Dv METEOR_GEO_YUV_PLANER
|
|
(4-2-2 YUV 16 bits planer format:
|
|
rows * columns bytes of y
|
|
rows * column / 4 bytes of even u
|
|
rows * column / 4 bytes of even v
|
|
rows * column / 4 bytes of odd u
|
|
rows * column / 4 bytes of odd v)
|
|
.El
|
|
.El
|
|
.Pp
|
|
The METEORSETGEO ioctl will fail if more than one entry from a category
|
|
is selected. It is highly recommended that a METEORSETGEO is done
|
|
before capturing data because you cannot guarantee the initial mode
|
|
the card.
|
|
.Pp
|
|
The METEORSETGEO will also attempt to reallocate a new contiguous
|
|
kernel buffer if the new geometry exceeds the old geometry. On
|
|
other hand, if the new geometry will fit in the existing buffer,
|
|
the existing buffer is used.
|
|
.Pp
|
|
If METEORSETGEO fails the ioctl() will return a value of -1 and the
|
|
external variable errno will be set to:
|
|
.Pp
|
|
.Bl -tag -width EINVAL
|
|
.It Dv EINVAL
|
|
invalid meteor_geomet structure pointer, rows, columns,
|
|
frames were invalid.
|
|
.It Dv ENOMEM
|
|
could not allocate the contiguous block.
|
|
.El
|
|
.in -0.5i
|
|
.Pp
|
|
2) ioctl requests METEORSFMT and METEORGFMT
|
|
.in +0.5i
|
|
.Pp
|
|
METEORSFMT and METEORGFMT are used to set and read the camera input
|
|
standard format.
|
|
.Pp
|
|
Possible formats are:
|
|
.Bl -tag -width METEOR_FMT_AUTOMODE
|
|
.It Dv METEOR_FMT_NTSC
|
|
NTSC (default mode)
|
|
.It Dv METEOR_FMT_PAL
|
|
PAL
|
|
.It Dv METEOR_FMT_SECAM
|
|
SECAM
|
|
.It Dv METEOR_FMT_AUTOMODE
|
|
Autodetect.
|
|
.El
|
|
.in -0.5i
|
|
.Pp
|
|
3) ioctl requests METEORSINPUT and METEORGINPUT
|
|
.in +0.5i
|
|
.Pp
|
|
METEORSINPUT and METEORGINPUT are used to set and read the camera
|
|
input device. Using the DB9 connector on the Meteor card, 4 input
|
|
devices can be connected and an input camera can be selected with this
|
|
ioctl.
|
|
.Pp
|
|
Possible formats are:
|
|
.Bl -tag -width METEOR_INPUT_DEV_SVIDEO
|
|
.It Dv METEOR_INPUT_DEV0
|
|
(default if none specified)
|
|
.It Dv METEOR_INPUT_DEV_RCA
|
|
(same as METEOR_INPUT_DEV0)
|
|
.It Dv METEOR_INPUT_DEV1
|
|
.It Dv METEOR_INPUT_DEV2
|
|
.It Dv METEOR_INPUT_DEV_SVIDEO
|
|
(same as METEOR_INPUT_DEV2)
|
|
.El
|
|
.in -0.5i
|
|
.Pp
|
|
4) ioctl request METEORSTATUS
|
|
.in +0.5i
|
|
.Pp
|
|
METEORSTATUS is used to read the status of the Meteor capture card
|
|
and returns the following information:
|
|
.Pp
|
|
.Bl -tag -width METEOR_STATUS_ID_MASK
|
|
.It Dv METEOR_STATUS_ID_MASK
|
|
4 bit ID of the SAA7196 scaler chip.
|
|
.It Dv METEOR_STATUS_DIR
|
|
0 = scaler uses internal source.
|
|
.br
|
|
1 = scaler uses external data of expansion bus.
|
|
.It Dv METEOR_STATUS_OEF
|
|
0 = even field detected.
|
|
.br
|
|
1 = odd field detected.
|
|
.It Dv METEOR_STATUS_SVP
|
|
VRAM Port state:
|
|
.br
|
|
0 = inputs HFL and INCADDR inactive.
|
|
.br
|
|
1 = inputs HFL and INCADDR active.
|
|
.It Dv METEOR_STATUS_STTC
|
|
0 = TV horizontal time constant (slow).
|
|
.br
|
|
1 = VCR horizontal time constant (fast).
|
|
.It Dv METEOR_STATUS_HCLK
|
|
0 = Horizontal Phase Lock Loop locked.
|
|
.br
|
|
1 = Horizontal Phase Lock Loop unlocked.
|
|
.It Dv METEOR_STATUS_FIDT
|
|
0 = 50 Hz Field detected.
|
|
.br
|
|
1 = 60 Hz Field detected.
|
|
.It Dv METEOR_STATUS_ALTD
|
|
0 = no line alternating color burst detected.
|
|
.br
|
|
1 = line alternating color burst detected
|
|
(PAL/SECAM).
|
|
.It Dv METEOR_STATUS_CODE
|
|
0 = no color information detected.
|
|
.br
|
|
1 = color information detected.
|
|
.El
|
|
.in -0.5i
|
|
.Pp
|
|
5) ioctl request METEORCAPTUR
|
|
.in +0.5i
|
|
.Pp
|
|
METEORCAPTUR is used to single frame capture or unsynchronized
|
|
continuous capture.
|
|
.Pp
|
|
The single frame capture ioctl request will return only after a
|
|
frame has been captured and transfered to the frame buffer.
|
|
.Pp
|
|
The unsynchronized continuous capture will return immediately and
|
|
data is directly deposited into the buffer when it is available.
|
|
Since this is unsynchronized, it is possible the data is being
|
|
written by the kernel while being read by the application.
|
|
.Pp
|
|
These ioctl routines use the following settings:
|
|
following entries:
|
|
.Pp
|
|
.Bl -tag -width METEOR_CAP_CONTINOUS
|
|
.It Dv METEOR_CAP_SINGLE
|
|
capture one frame
|
|
.It Dv METEOR_CAP_CONTINOUS
|
|
unsynchronized continuous capture
|
|
.It Dv METEOR_CAP_STOP_CONT
|
|
stop the unsynchronized continuous
|
|
capture
|
|
.El
|
|
.Pp
|
|
If METEORCAPTUR fails the ioctl() will return a value of -1 and the
|
|
external variable errno will be set to:
|
|
.Pp
|
|
.Bl -tag -width EINVAL
|
|
.It Dv EINVAL
|
|
invalid capture command value
|
|
.It Dv ENXIO
|
|
there is not internal buffer to hold the frame.
|
|
this indicates the previous set geometry ioctl failed.
|
|
.It Dv EIO
|
|
card is already capturing.
|
|
.El
|
|
.in -0.5i
|
|
.Pp
|
|
6) ioctl request METEORCAPFRM
|
|
.in +0.5i
|
|
.Pp
|
|
METEORCAPFRM is used for synchronous capture of multiple frames.
|
|
.Pp
|
|
This ioctl routines use the meteor_capture structure that has the
|
|
following entries:
|
|
.Pp
|
|
.Bl -tag -width command
|
|
.It Dv command
|
|
possible values for command are:
|
|
.Bl -tag -width METEOR_CAP_STOP_FRAMES
|
|
.It Dv METEOR_CAP_STOP_FRAMES stop the capture does not use the
|
|
other variable in structure.
|
|
.It Dv METEOR_CAP_N_FRAMES start the capture using the other
|
|
variables in the structure as inputs
|
|
.El
|
|
.It Dv signal
|
|
signal to send to application when a new
|
|
frame has been captured. This signal will
|
|
only be raised if the captured frame is saved.
|
|
.It Dv lowat
|
|
see below
|
|
.It Dv hiwat
|
|
see below
|
|
.El
|
|
.Pp
|
|
When a new frame is completed, the driver checks the current unread
|
|
frame count stored in shared variable (the shared variable are stored
|
|
in the meteor_mem structure) num_active_buf, if the count is larger
|
|
than hiwat, the driver will not store any new frames and will not
|
|
send capture signal to the user application until the num_active_buf
|
|
is lower than lowat.
|
|
.Pp
|
|
If METEORCAPFRM fails the ioctl() will return a value of -1 and the
|
|
external variable errno will be set to:
|
|
.Pp
|
|
.Bl -tag -width EINVAL
|
|
.It Dv EINVAL
|
|
invalid meteor_geomet structure pointer or bad command.
|
|
.It Dv ENXIO
|
|
there is not internal buffer to hold the frame.
|
|
this indicates the previous set geometry ioctl failed.
|
|
.It Dv EIO
|
|
card is already capturing.
|
|
.El
|
|
.in -0.5i
|
|
.Pp
|
|
7) ioctl requests METEORSCHCV and METEORGCHCV
|
|
.in +0.5i
|
|
.Pp
|
|
METEORSCHCV and METEORGCHCV are used to set and get the chrominance
|
|
gain control and effects the UV output amplitude.
|
|
.Pp
|
|
If METEORSCHCV or METEORGCHCV fails the ioctl() will return a value
|
|
of -1 and the external variable errno will be set to:
|
|
.Pp
|
|
.Bl -tag -width EINVAL
|
|
.It Dv EINVAL
|
|
EINVAL
|
|
invalid unsigned char pointer.
|
|
.El
|
|
.in -0.5i
|
|
.Pp
|
|
8) ioctl requests METEORGHUE and METEORSHUE
|
|
.in +0.5i
|
|
.Pp
|
|
METEORGHUE and METEORSHUE are used to get and set the hue. The
|
|
signed character has legal values are from +127 which represent
|
|
+178.6 degrees to -128 which represents -180 degrees.
|
|
.Pp
|
|
If METEORGHUE or METEORSHUE fails the ioctl() will return a value of
|
|
-1 and the external variable errno will be set to:
|
|
.Pp
|
|
.Bl -tag -width EINVAL
|
|
.It Dv EINVAL
|
|
invalid signed char pointer.
|
|
.El
|
|
.in -0.5i
|
|
.Pp
|
|
9) ioctl requests METEORSCOUNT and METEORGCOUNT
|
|
.in +0.5i
|
|
.Pp
|
|
METEORGCOUNT is used to get the count of frame errors, DMA errors and
|
|
count of the number of frames captured that have occurred since
|
|
the device was opened. METEORSCOUNT can be used to reinitialize the
|
|
counters.
|
|
.Pp
|
|
This ioctl routines use the meteor_counts structure that has the
|
|
following entries:
|
|
.Pp
|
|
.Bl -tag -width frame_count
|
|
.It Dv fifo_errors
|
|
number of FIFO errors since device was opened.
|
|
.It Dv dma_errors number of DMA errors since device was opened.
|
|
|
|
.It Dv frame_count number of frames captured since device was opened.
|
|
.El
|
|
.Pp
|
|
If METEORSCOUNT or METEORGCOUNT fails the ioctl() will return a value
|
|
of -1 and the external variable errno will be set to:
|
|
.Bl -tag -width EINVAL
|
|
.It Dv EINVAL
|
|
invalid meteor_counts structure pointer.
|
|
.El
|
|
.in -0.5i
|
|
.Pp
|
|
.Sh Known Bugs:
|
|
.in +0.5i
|
|
.Pp
|
|
1) IIC register is difficult to set. We got around that by adding a long
|
|
wait at each IIC register write.
|
|
.Pp
|
|
2) We had difficulties getting the Meteor capture card to work on systems
|
|
that used NCR chipset SCSI cards. It is possible that the Meteor and NCR SCSI
|
|
could work together using the newer TRITON motherboards.
|
|
.in -0.5i
|
|
.Pp
|
|
.Sh Authors:
|
|
.Pp
|
|
.Bl -tag -width Mark_Tinguely
|
|
.It Dv Jim Lowe
|
|
(james@miller.cs.uwm.edu)
|
|
.It Dv Mark Tinguely
|
|
(tinguely@plains.nodak.edu)
|
|
.El
|