Hi,
see attached a patched capture example, for saving the driver output
buffer into raw files (200).
I haven't been able to test build it, but the changes are minimal so
it should work.
You just need to change the resolution, and maybe the pixel format to
whatever the driver expects.
see lines 495-497.
Regards,
Paulo
2011/9/9 Robert Krakora <rob.krak...@messagenetsystems.com>:
> All,
>
> I forgot to tell you that I came up with one more patch for the UVC source
> in v4l2 to get MPEG2 transport streams to behave correctly. I have attached
> it to this e-mail. My sincerest apologies.
>
> Best Regards,
>
> --
> Rob Krakora
> MessageNet Systems
> 101 East Carmel Dr. Suite 105
> Carmel, IN 46032
> (317)566-1677 Ext 212
> (317)663-0808 Fax
>
> On Fri, Sep 9, 2011 at 10:05 AM, Paulo Assis <pj.as...@gmail.com> wrote:
>>
>> Well one important thing to notice is the pixel format returned by the
>> driver, will it differentiate between avc and svc streams, or even
>> mpeg2 ?
>> If not maybe then it becomes harder for generic apps to decode it,
>> unless we use a bunch of switch cases for the different cameras
>> (something like this would be best implemented in the driver though)
>>
>> Regards,
>> Paulo
>>
>> 2011/9/9 Ajay Bhargav <ajay.bhar...@einfochips.com>:
>> > Hi Robert,
>> >
>> > As you know its a development camera... I think my camera need some
>> > fixing..
>> > my hardware decoder does not work with H.264 stream directly... I added
>> > h264parse element before h264 decoder in gstreamer pipeline to make it
>> > work.
>> >
>> > Regards,
>> > Ajay Bhargav
>> >
>> > ----- "Robert Krakora" <rob.krak...@messagenetsystems.com> wrote:
>> >
>> > Hi Ajay,
>> >
>> > The encoder in your camera may be different and produce H.264 AVC
>> > instead of
>> > SVC. The latest gstreamer-ffmpeg did not work for me for the FaceVsion
>> > Touchcam E1.
>> >
>> > Best Regards,
>> >
>> > Rob Krakora
>> >
>> > On Fri, Sep 9, 2011 at 9:18 AM, Ajay Bhargav
>> > <ajay.bhar...@einfochips.com>
>> > wrote:
>> >>
>> >> Hi Paulo,
>> >>
>> >> for me ffdec_h264 worked perfectly... I used current stable release of
>> >> gstreamer-ffmpeg. It has many more formats...
>> >>
>> >> --Ajay Bhargav
>> >>
>> >>
>> >> ----- "Paulo Assis" <pj.as...@gmail.com> wrote:
>> >>
>> >> > Hi,
>> >> > have you tried the open svc decoder (
>> >> > http://sourceforge.net/projects/opensvcdecoder/ ) ?
>> >> >
>> >> > It would probably be easier to add as dependency.
>> >> >
>> >> > Regards,
>> >> > Paulo
>> >> >
>> >> > 2011/9/9 Alexey Fisher <bug-tr...@fisher-privat.net>:
>> >> > > Hi Paulo,
>> >> > >
>> >> > > i have video dump from Robert, not v4l2... The problem with it is
>> >> > codec. It
>> >> > > seems to be some SVC variant of h264 and ffmpeg can't play it
>> >> > correctly.
>> >> > > Robert say, currently only fluh264dec (flyendo plugin for
>> >> > > gstreamer)
>> >> > can
>> >> > > play it.
>> >> > >
>> >> > > Am 09.09.2011 13:23, schrieb Paulo Assis:
>> >> > >>
>> >> > >> Hi,
>> >> > >> I was thinking on using ffmpeg (libavcodec) since this is already
>> >> > a
>> >> > >> guvcview dependency for enconding the streams, decoding them
>> >> > shouldn't
>> >> > >> be to hard, I just need to understand how they are handled by the
>> >> > driver.
>> >> > >> This is the reason I need the raw data, you should be able to use
>> >> > the
>> >> > >> v4l2 capture example to store the buffer data as delivered by the
>> >> > driver
>> >> > >> (something like buffer-1.raw,...,buffer-n.raw would be nice), or I
>> >> > can
>> >> > >> send you some code for doing this if you prefer.
>> >> > >>
>> >> > >> Regards,
>> >> > >> Paulo
>> >> > >>
>> >> > >> 2011/9/9 Ajay Bhargav <ajay.bhar...@einfochips.com
>> >> > >> <mailto:ajay.bhar...@einfochips.com>>
>> >> > >>
>> >> > >> Hi Paulo,
>> >> > >>
>> >> > >> I am not having H.264 camera, My camera is similar to
>> >> > Facevision's
>> >> > >> Touchcam E1. It sends out MPEG2-TS stream encoded with H.264. I
>> >> > have
>> >> > >> recorded some videos during my testing if that is fine for you
>> >> > >> I
>> >> > can
>> >> > >> send across... it would be great if guvcview can show
>> >> > compressed
>> >> > >> streams :) we can make use of gstreamer to achieve this..
>> >> > >>
>> >> > >> -- Ajay Bhargav
>> >> > >>
>> >> > >>
>> >> > >> ----- "Paulo Assis" <pj.as...@gmail.com
>> >> > <mailto:pj.as...@gmail.com>>
>> >> > >> wrote:
>> >> > >>
>> >> > >> Hi,
>> >> > >> I would like to add support for H.264 stream format in
>> >> > guvcview,
>> >> > >> Could you post some stream info, or even better an example
>> >> > of
>> >> > >> raw data output (does the capture buffer contains an exact
>> >> > frame
>> >> > >> like in MJPEG ?)
>> >> > >>
>> >> > >> Regards,
>> >> > >> Paulo
>> >> > >>
>> >> > >> 2011/9/9 Ajay Bhargav <ajay.bhar...@einfochips.com
>> >> > >> <mailto:ajay.bhar...@einfochips.com>>
>> >> > >>
>> >> > >> Hi Srinivas,
>> >> > >>
>> >> > >> UVC fixes wont be needed for you to get your cam
>> >> > output..
>> >> > >>
>> >> > >> You can build gstreamer0.10-ffmpeg to decode H.264
>> >> > stream,
>> >> > >> Robert has used fluendo package for decoding.
>> >> > >>
>> >> > >> --Ajay
>> >> > >>
>> >> > >>
>> >> > >> ----- "Max Lapshin" <max.laps...@gmail.com
>> >> > >> <mailto:max.laps...@gmail.com>> wrote:
>> >> > >>
>> >> > >>
>> >> > >>
>> >> > >> On Fri, Sep 9, 2011 at 11:01 AM, Srinivas
>> >> > Mandavilli
>> >> > >> <srinivas.mandavi...@lucivid.com
>> >> > >> <mailto:srinivas.mandavi...@lucivid.com>> wrote:
>> >> > >>
>> >> > >> Thanks Ajay! I just got a B990, and am trying
>> >> > to
>> >> > >> stream out H264.
>> >> > >>
>> >> > >> Hi, Srinivas. Be so kind: if you will have success
>> >> > with
>> >> > >> it, write an email: what kernel version are you
>> >> > using?
>> >> > >>
>> >> > >> I failed to do it with kernel 3.0.0
>> >> > >>
>> >> > >> --
>> >> > >> This message has been scanned for viruses and
>> >> > >> dangerous content by *Clean Mail Gateway*
>> >> > >> <http://www.CleanMailGateway.com/>, and is
>> >> > >> believed to be clean.
>> >> > >>
>> >> > >>
>> >> > >>
>> >> > >> _______________________________________________
>> >> > >> Linux-uvc-devel mailing list
>> >> > >> Linux-uvc-devel@lists.berlios.de
>> >> > >> <mailto:Linux-uvc-devel@lists.berlios.de>
>> >> > >>
>> >> > https://lists.berlios.de/mailman/listinfo/linux-uvc-devel
>> >> > >>
>> >> > >>
>> >> > >>
>> >> > >> --
>> >> > >> This message has been scanned for viruses and
>> >> > >> dangerous content by *Clean Mail Gateway*
>> >> > >> <http://www.CleanMailGateway.com/>, and is
>> >> > >> believed to be clean.
>> >> > >>
>> >> > >>
>> >> > >>
>> >> > >>
>> >> > >>
>> >> > >> _______________________________________________
>> >> > >> Linux-uvc-devel mailing list
>> >> > >> Linux-uvc-devel@lists.berlios.de
>> >> > >> https://lists.berlios.de/mailman/listinfo/linux-uvc-devel
>> >> > >
>> >> > >
>> >> >
>> >> > --
>> >> > This message has been scanned for viruses and
>> >> > dangerous content by Clean Mail Gateway, and is
>> >> > believed to be clean.
>> >> >
>> >> >
>> >> >
>> >> > *************************************************************************************************************************************************************
>> >> > einfochips Business Disclaimer : This e-mail message and all
>> >> > attachments transmitted with it are intended solely for the use of
>> >> > the
>> >> > addressee and may contain legally privileged and confidential
>> >> > information. If the reader of this message is not the intended
>> >> > recipient, or an employee or agent responsible for delivering this
>> >> > message to the intended recipient, you are hereby notified that any
>> >> > dissemination, distribution, copying, or other use of this message or
>> >> > its attachments is strictly prohibited. If you have received this
>> >> > message in error, please notify the sender immediately by replying to
>> >> > this message and please delete it from your computer. Any views
>> >> > expressed in this message are those of the individual sender unless
>> >> > otherwise stated. Company has taken enough precautions to prevent the
>> >> > spread of viruses. However the company accepts no liability for any
>> >> > damage caused by any virus transmitted by this email.
>> >> >
>> >> >
>> >> > *************************************************************************************************************************************************************
>> >
>> >
>> >
>> > --
>> > Rob Krakora
>> > MessageNet Systems
>> > 101 East Carmel Dr. Suite 105
>> > Carmel, IN 46032
>> > (317)566-1677 Ext 212
>> > (317)663-0808 Fax
>> >
>> > --
>> > This message has been scanned for viruses and
>> > dangerous content by Clean Mail Gateway, and is
>> > believed to be clean.
>> >
>> > _______________________________________________
>> > Linux-uvc-devel mailing list
>> > Linux-uvc-devel@lists.berlios.de
>> > https://lists.berlios.de/mailman/listinfo/linux-uvc-devel
>> >
>> >
>
>
/*
* V4L2 video capture example
*
* This program can be used and distributed without restrictions.
*
* This program is provided with the V4L2 API
* see http://linuxtv.org/docs.php for more information
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <getopt.h> /* getopt_long() */
#include <fcntl.h> /* low-level i/o */
#include <unistd.h>
#include <errno.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/time.h>
#include <sys/mman.h>
#include <sys/ioctl.h>
#include <linux/videodev2.h>
#define CLEAR(x) memset(&(x), 0, sizeof(x))
#ifndef V4L2_PIX_FMT_H264
#define V4L2_PIX_FMT_H264 v4l2_fourcc('H', '2', '6', '4') /* H264 with start codes */
#endif
enum io_method {
IO_METHOD_READ,
IO_METHOD_MMAP,
IO_METHOD_USERPTR,
};
struct buffer {
void *start;
size_t length;
};
static char *dev_name;
static enum io_method io = IO_METHOD_MMAP;
static int fd = -1;
struct buffer *buffers;
static unsigned int n_buffers;
static int out_buf;
static int force_format;
static int frame_count = 200;
static int frame_number = 0;
static void errno_exit(const char *s)
{
fprintf(stderr, "%s error %d, %s\n", s, errno, strerror(errno));
exit(EXIT_FAILURE);
}
static int xioctl(int fh, int request, void *arg)
{
int r;
do {
r = ioctl(fh, request, arg);
} while (-1 == r && EINTR == errno);
return r;
}
static void process_image(const void *p, int size)
{
frame_number++;
char filename[15];
sprintf(filename, "frame-%d.raw", frame_number);
FILE *fp=fopen(filename,"wb");
if (out_buf)
fwrite(p, size, 1, fp);
fflush(fp);
fclose(fp);
}
static int read_frame(void)
{
struct v4l2_buffer buf;
unsigned int i;
switch (io) {
case IO_METHOD_READ:
if (-1 == read(fd, buffers[0].start, buffers[0].length)) {
switch (errno) {
case EAGAIN:
return 0;
case EIO:
/* Could ignore EIO, see spec. */
/* fall through */
default:
errno_exit("read");
}
}
process_image(buffers[0].start, buffers[0].length);
break;
case IO_METHOD_MMAP:
CLEAR(buf);
buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
buf.memory = V4L2_MEMORY_MMAP;
if (-1 == xioctl(fd, VIDIOC_DQBUF, &buf)) {
switch (errno) {
case EAGAIN:
return 0;
case EIO:
/* Could ignore EIO, see spec. */
/* fall through */
default:
errno_exit("VIDIOC_DQBUF");
}
}
assert(buf.index < n_buffers);
process_image(buffers[buf.index].start, buf.bytesused);
if (-1 == xioctl(fd, VIDIOC_QBUF, &buf))
errno_exit("VIDIOC_QBUF");
break;
case IO_METHOD_USERPTR:
CLEAR(buf);
buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
buf.memory = V4L2_MEMORY_USERPTR;
if (-1 == xioctl(fd, VIDIOC_DQBUF, &buf)) {
switch (errno) {
case EAGAIN:
return 0;
case EIO:
/* Could ignore EIO, see spec. */
/* fall through */
default:
errno_exit("VIDIOC_DQBUF");
}
}
for (i = 0; i < n_buffers; ++i)
if (buf.m.userptr == (unsigned long)buffers[i].start
&& buf.length == buffers[i].length)
break;
assert(i < n_buffers);
process_image((void *)buf.m.userptr, buf.bytesused);
if (-1 == xioctl(fd, VIDIOC_QBUF, &buf))
errno_exit("VIDIOC_QBUF");
break;
}
return 1;
}
static void mainloop(void)
{
unsigned int count;
count = frame_count;
while (count-- > 0) {
for (;;) {
fd_set fds;
struct timeval tv;
int r;
FD_ZERO(&fds);
FD_SET(fd, &fds);
/* Timeout. */
tv.tv_sec = 2;
tv.tv_usec = 0;
r = select(fd + 1, &fds, NULL, NULL, &tv);
if (-1 == r) {
if (EINTR == errno)
continue;
errno_exit("select");
}
if (0 == r) {
fprintf(stderr, "select timeout\n");
exit(EXIT_FAILURE);
}
if (read_frame())
break;
/* EAGAIN - continue select loop. */
}
}
}
static void stop_capturing(void)
{
enum v4l2_buf_type type;
switch (io) {
case IO_METHOD_READ:
/* Nothing to do. */
break;
case IO_METHOD_MMAP:
case IO_METHOD_USERPTR:
type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
if (-1 == xioctl(fd, VIDIOC_STREAMOFF, &type))
errno_exit("VIDIOC_STREAMOFF");
break;
}
}
static void start_capturing(void)
{
unsigned int i;
enum v4l2_buf_type type;
switch (io) {
case IO_METHOD_READ:
/* Nothing to do. */
break;
case IO_METHOD_MMAP:
for (i = 0; i < n_buffers; ++i) {
struct v4l2_buffer buf;
CLEAR(buf);
buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
buf.memory = V4L2_MEMORY_MMAP;
buf.index = i;
if (-1 == xioctl(fd, VIDIOC_QBUF, &buf))
errno_exit("VIDIOC_QBUF");
}
type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
if (-1 == xioctl(fd, VIDIOC_STREAMON, &type))
errno_exit("VIDIOC_STREAMON");
break;
case IO_METHOD_USERPTR:
for (i = 0; i < n_buffers; ++i) {
struct v4l2_buffer buf;
CLEAR(buf);
buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
buf.memory = V4L2_MEMORY_USERPTR;
buf.index = i;
buf.m.userptr = (unsigned long)buffers[i].start;
buf.length = buffers[i].length;
if (-1 == xioctl(fd, VIDIOC_QBUF, &buf))
errno_exit("VIDIOC_QBUF");
}
type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
if (-1 == xioctl(fd, VIDIOC_STREAMON, &type))
errno_exit("VIDIOC_STREAMON");
break;
}
}
static void uninit_device(void)
{
unsigned int i;
switch (io) {
case IO_METHOD_READ:
free(buffers[0].start);
break;
case IO_METHOD_MMAP:
for (i = 0; i < n_buffers; ++i)
if (-1 == munmap(buffers[i].start, buffers[i].length))
errno_exit("munmap");
break;
case IO_METHOD_USERPTR:
for (i = 0; i < n_buffers; ++i)
free(buffers[i].start);
break;
}
free(buffers);
}
static void init_read(unsigned int buffer_size)
{
buffers = calloc(1, sizeof(*buffers));
if (!buffers) {
fprintf(stderr, "Out of memory\n");
exit(EXIT_FAILURE);
}
buffers[0].length = buffer_size;
buffers[0].start = malloc(buffer_size);
if (!buffers[0].start) {
fprintf(stderr, "Out of memory\n");
exit(EXIT_FAILURE);
}
}
static void init_mmap(void)
{
struct v4l2_requestbuffers req;
CLEAR(req);
req.count = 4;
req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
req.memory = V4L2_MEMORY_MMAP;
if (-1 == xioctl(fd, VIDIOC_REQBUFS, &req)) {
if (EINVAL == errno) {
fprintf(stderr, "%s does not support "
"memory mapping\n", dev_name);
exit(EXIT_FAILURE);
} else {
errno_exit("VIDIOC_REQBUFS");
}
}
if (req.count < 2) {
fprintf(stderr, "Insufficient buffer memory on %s\n",
dev_name);
exit(EXIT_FAILURE);
}
buffers = calloc(req.count, sizeof(*buffers));
if (!buffers) {
fprintf(stderr, "Out of memory\n");
exit(EXIT_FAILURE);
}
for (n_buffers = 0; n_buffers < req.count; ++n_buffers) {
struct v4l2_buffer buf;
CLEAR(buf);
buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
buf.memory = V4L2_MEMORY_MMAP;
buf.index = n_buffers;
if (-1 == xioctl(fd, VIDIOC_QUERYBUF, &buf))
errno_exit("VIDIOC_QUERYBUF");
buffers[n_buffers].length = buf.length;
buffers[n_buffers].start =
mmap(NULL /* start anywhere */,
buf.length,
PROT_READ | PROT_WRITE /* required */,
MAP_SHARED /* recommended */,
fd, buf.m.offset);
if (MAP_FAILED == buffers[n_buffers].start)
errno_exit("mmap");
}
}
static void init_userp(unsigned int buffer_size)
{
struct v4l2_requestbuffers req;
CLEAR(req);
req.count = 4;
req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
req.memory = V4L2_MEMORY_USERPTR;
if (-1 == xioctl(fd, VIDIOC_REQBUFS, &req)) {
if (EINVAL == errno) {
fprintf(stderr, "%s does not support "
"user pointer i/o\n", dev_name);
exit(EXIT_FAILURE);
} else {
errno_exit("VIDIOC_REQBUFS");
}
}
buffers = calloc(4, sizeof(*buffers));
if (!buffers) {
fprintf(stderr, "Out of memory\n");
exit(EXIT_FAILURE);
}
for (n_buffers = 0; n_buffers < 4; ++n_buffers) {
buffers[n_buffers].length = buffer_size;
buffers[n_buffers].start = malloc(buffer_size);
if (!buffers[n_buffers].start) {
fprintf(stderr, "Out of memory\n");
exit(EXIT_FAILURE);
}
}
}
static void init_device(void)
{
struct v4l2_capability cap;
struct v4l2_cropcap cropcap;
struct v4l2_crop crop;
struct v4l2_format fmt;
unsigned int min;
if (-1 == xioctl(fd, VIDIOC_QUERYCAP, &cap)) {
if (EINVAL == errno) {
fprintf(stderr, "%s is no V4L2 device\n",
dev_name);
exit(EXIT_FAILURE);
} else {
errno_exit("VIDIOC_QUERYCAP");
}
}
if (!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)) {
fprintf(stderr, "%s is no video capture device\n",
dev_name);
exit(EXIT_FAILURE);
}
switch (io) {
case IO_METHOD_READ:
if (!(cap.capabilities & V4L2_CAP_READWRITE)) {
fprintf(stderr, "%s does not support read i/o\n",
dev_name);
exit(EXIT_FAILURE);
}
break;
case IO_METHOD_MMAP:
case IO_METHOD_USERPTR:
if (!(cap.capabilities & V4L2_CAP_STREAMING)) {
fprintf(stderr, "%s does not support streaming i/o\n",
dev_name);
exit(EXIT_FAILURE);
}
break;
}
/* Select video input, video standard and tune here. */
CLEAR(cropcap);
cropcap.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
if (0 == xioctl(fd, VIDIOC_CROPCAP, &cropcap)) {
crop.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
crop.c = cropcap.defrect; /* reset to default */
if (-1 == xioctl(fd, VIDIOC_S_CROP, &crop)) {
switch (errno) {
case EINVAL:
/* Cropping not supported. */
break;
default:
/* Errors ignored. */
break;
}
}
} else {
/* Errors ignored. */
}
CLEAR(fmt);
fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
if (force_format) {
fmt.fmt.pix.width = 640; //replace
fmt.fmt.pix.height = 480; //replace
fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_H264; //replace
fmt.fmt.pix.field = V4L2_FIELD_ANY;
if (-1 == xioctl(fd, VIDIOC_S_FMT, &fmt))
errno_exit("VIDIOC_S_FMT");
/* Note VIDIOC_S_FMT may change width and height. */
} else {
/* Preserve original settings as set by v4l2-ctl for example */
if (-1 == xioctl(fd, VIDIOC_G_FMT, &fmt))
errno_exit("VIDIOC_G_FMT");
}
/* Buggy driver paranoia. */
min = fmt.fmt.pix.width * 2;
if (fmt.fmt.pix.bytesperline < min)
fmt.fmt.pix.bytesperline = min;
min = fmt.fmt.pix.bytesperline * fmt.fmt.pix.height;
if (fmt.fmt.pix.sizeimage < min)
fmt.fmt.pix.sizeimage = min;
switch (io) {
case IO_METHOD_READ:
init_read(fmt.fmt.pix.sizeimage);
break;
case IO_METHOD_MMAP:
init_mmap();
break;
case IO_METHOD_USERPTR:
init_userp(fmt.fmt.pix.sizeimage);
break;
}
}
static void close_device(void)
{
if (-1 == close(fd))
errno_exit("close");
fd = -1;
}
static void open_device(void)
{
struct stat st;
if (-1 == stat(dev_name, &st)) {
fprintf(stderr, "Cannot identify '%s': %d, %s\n",
dev_name, errno, strerror(errno));
exit(EXIT_FAILURE);
}
if (!S_ISCHR(st.st_mode)) {
fprintf(stderr, "%s is no device\n", dev_name);
exit(EXIT_FAILURE);
}
fd = open(dev_name, O_RDWR /* required */ | O_NONBLOCK, 0);
if (-1 == fd) {
fprintf(stderr, "Cannot open '%s': %d, %s\n",
dev_name, errno, strerror(errno));
exit(EXIT_FAILURE);
}
}
static void usage(FILE *fp, int argc, char **argv)
{
fprintf(fp,
"Usage: %s [options]\n\n"
"Version 1.3\n"
"Options:\n"
"-d | --device name Video device name [%s]\n"
"-h | --help Print this message\n"
"-m | --mmap Use memory mapped buffers [default]\n"
"-r | --read Use read() calls\n"
"-u | --userp Use application allocated buffers\n"
"-o | --output Outputs stream to stdout\n"
"-f | --format Force format to 640x480 YUYV\n"
"-c | --count Number of frames to grab [%i]\n"
"",
argv[0], dev_name, frame_count);
}
static const char short_options[] = "d:hmruofc:";
static const struct option
long_options[] = {
{ "device", required_argument, NULL, 'd' },
{ "help", no_argument, NULL, 'h' },
{ "mmap", no_argument, NULL, 'm' },
{ "read", no_argument, NULL, 'r' },
{ "userp", no_argument, NULL, 'u' },
{ "output", no_argument, NULL, 'o' },
{ "format", no_argument, NULL, 'f' },
{ "count", required_argument, NULL, 'c' },
{ 0, 0, 0, 0 }
};
int main(int argc, char **argv)
{
dev_name = "/dev/video0";
for (;;) {
int idx;
int c;
c = getopt_long(argc, argv,
short_options, long_options, &idx);
if (-1 == c)
break;
switch (c) {
case 0: /* getopt_long() flag */
break;
case 'd':
dev_name = optarg;
break;
case 'h':
usage(stdout, argc, argv);
exit(EXIT_SUCCESS);
case 'm':
io = IO_METHOD_MMAP;
break;
case 'r':
io = IO_METHOD_READ;
break;
case 'u':
io = IO_METHOD_USERPTR;
break;
case 'o':
out_buf++;
break;
case 'f':
force_format++;
break;
case 'c':
errno = 0;
frame_count = strtol(optarg, NULL, 0);
if (errno)
errno_exit(optarg);
break;
default:
usage(stderr, argc, argv);
exit(EXIT_FAILURE);
}
}
open_device();
init_device();
start_capturing();
mainloop();
stop_capturing();
uninit_device();
close_device();
fprintf(stderr, "\n");
return 0;
}_______________________________________________
Linux-uvc-devel mailing list
Linux-uvc-devel@lists.berlios.de
https://lists.berlios.de/mailman/listinfo/linux-uvc-devel
