ola,
in the SVN ( in th etrunk, not any branches ),
anyway this particular source is here also,
if you want to compile it as standalone.
ciao,
sevy
olsen wrote:
thanks senor!
just one stupid question - where do i find the actual pidip sources?
no linkage on http://ydegoyon.free.fr/pidip.html
thanks&salutis
olsen
ydegoyon wrote:
it's not the right version of pdp_v4l2,
and i think this one should be removed,
pdp_v4l2 has been improved and integrated in P.i.D.i.P.
with the right authorship ( e.g. Lluis Gomez and I )
so you'd better install this one.
saludos,
sevy
olsen wrote:
buenas
on the macbook penryn(4th generation?) i can't report a success so
far - running ubuntu hardy with luvcview the camera works. with
pdp_v4l2 there's only a marsy green window flickering with the
initialization of the camera...
i compiled the pdp_v4l2 as mentioned on:
http://hangar.org/wikis/lab/doku.php?id=start:puredata_pdvjtools
output errors this:
VIDIOC_S_FMT error 22, Invalid argument
the format 1 message didn't change anything on the image
thanks for hints & greets
olsen
Hans-Christoph Steiner wrote:
Hey,
Sergi and I just figured out how to use the macbook pro iSight
camera with pdp_v4l2, so I thought I just post here how for the
record: By default the iSight with pdp_v4l2 seems to use MJPEG
colorspace, so I was getting a "pdp_v4l2: unsupported color model"
error.
We sent the [format 1( to get the YUYV space, as reported in the
Pd window, and it works!
.hc
------------------------------------------------------------------------
----
I spent 33 years and four months in active military service and
during that period I spent most of my time as a high class muscle
man for Big Business, for Wall Street and the bankers. -
General Smedley Butler
_______________________________________________
[email protected] mailing list
UNSUBSCRIBE and account-management ->
http://lists.puredata.info/listinfo/pd-list
/*
* PiDiP module
* Authors : Yves Degoyon ( [EMAIL PROTECTED] ) and Lluis Gomez i Bigorda
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*
*/
/* This object is a video 4 linux 2 driver wrapper,
* inspired by pdp_v4l by Tom Schouten
* and some driver code from xawtv ( thanks to Gerd Knorr <[EMAIL PROTECTED]> )
*/
#include "pdp_config.h"
#include "pdp.h"
#include "pdp_llconv.h"
#include "pdp_imageproc.h"
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <unistd.h>
#include <string.h>
#include <ctype.h>
#include <fcntl.h>
#include <errno.h>
#include <sys/ioctl.h>
#include <sys/types.h>
#include <sys/time.h>
#include <linux/types.h>
#include <linux/videodev.h>
#include <linux/videodev2.h>
#include <sys/mman.h>
#include <sched.h>
#include <pthread.h>
// dont open any more after a set number
// of failed attempts
// this is to prevent locks on auto-open
// is reset when manually opened or closed
#define PDP_XV_RETRIES 10
#define DEVICENO 0
#define NBUF 2
#define COMPOSITEIN 1
#define WANTED_BUFFERS 2
#define MAX_INPUT 16
#define MAX_NORM 16
#define MAX_FORMAT 32
#define MAX_CTRL 32
typedef struct pdp_v4l2_struct
{
t_object x_obj;
t_float x_f;
t_outlet *x_outlet0;
bool x_initialized;
bool x_auto_open;
unsigned int x_width;
unsigned int x_height;
int x_curinput;
int x_curstandard;
int x_curformat;
int x_freq;
// video 4 linux 2 structures
int x_ninputs;
int x_nstandards;
int x_nformats;
struct v4l2_capability x_vcap;
struct v4l2_input x_inputs[MAX_INPUT];
struct v4l2_standard x_standards[MAX_NORM];
struct v4l2_fmtdesc x_formats[MAX_FORMAT];
struct v4l2_streamparm x_streamparam;
struct v4l2_queryctrl x_controls[MAX_CTRL*2];
struct v4l2_buffer x_v4l2_buf[WANTED_BUFFERS];
struct v4l2_format x_v4l2_format;
struct v4l2_requestbuffers x_reqbufs;
unsigned char *x_pdp_buf[WANTED_BUFFERS];
int x_tvfd;
int x_frame;
int x_skipnext;
int x_mytopmargin, x_mybottommargin;
int x_myleftmargin, x_myrightmargin;
t_symbol *x_device;
pthread_t x_thread_id;
int x_continue_thread;
int x_frame_ready;
int x_only_new_frames;
int x_last_frame;
int x_open_retry;
u32 x_minwidth;
u32 x_maxwidth;
u32 x_minheight;
u32 x_maxheight;
int x_debug;
} t_pdp_v4l2;
static void pdp_v4l2_close(t_pdp_v4l2 *x)
{
/* close the v4l device and dealloc buffer */
void *dummy;
int i;
/* terminate thread if there is one */
if(x->x_continue_thread){
x->x_continue_thread = 0;
pthread_join (x->x_thread_id, &dummy);
}
if (x->x_tvfd >= 0)
{
close(x->x_tvfd);
x->x_tvfd = -1;
}
if (x->x_initialized){
for( i=0; i<WANTED_BUFFERS; i++ )
{
munmap(x->x_pdp_buf[i], x->x_v4l2_buf[i].length);
}
x->x_initialized = false;
}
}
static void pdp_v4l2_close_manual(t_pdp_v4l2 *x)
{
x->x_open_retry = PDP_XV_RETRIES;
pdp_v4l2_close(x);
}
static void pdp_v4l2_close_error(t_pdp_v4l2 *x)
{
pdp_v4l2_close(x);
if(x->x_open_retry) x->x_open_retry--;
}
static int pdp_v4l2_capture_frame(t_pdp_v4l2* x)
{
x->x_v4l2_buf[x->x_frame].index = x->x_frame;
x->x_v4l2_buf[x->x_frame].type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
x->x_v4l2_buf[x->x_frame].memory = V4L2_MEMORY_MMAP;
if (-1 == ioctl (x->x_tvfd, VIDIOC_DQBUF, &x->x_v4l2_buf[x->x_frame]))
{
switch (errno)
{
case EAGAIN:
return 0;
case EIO:
// could ignore EIO, see spec
default:
post( "pdp_v4l2 : error reading buffer : thread exiting");
exit(-1);
}
}
// reenqueing buffer
if (-1 == ioctl (x->x_tvfd, VIDIOC_QBUF, &x->x_v4l2_buf[x->x_frame]))
{
perror("pdp_v4l2 : error queing buffers : thread exiting");
exit(-1);
}
return 0;
}
static void pdp_v4l2_wait_frame(t_pdp_v4l2* x)
{
// wait an event on file descriptor
fd_set fds;
struct timeval tv;
int ret;
FD_ZERO (&fds);
FD_SET (x->x_tvfd, &fds);
// Timeout.
tv.tv_sec = 2;
tv.tv_usec = 0;
ret = select (x->x_tvfd + 1, &fds, NULL, NULL, &tv);
if (-1 == ret) {
if (EINTR == errno) return;
post ( "pdp_v4l2 : select timeout : thread exiting");
exit (-1);
}
if (0 == ret)
{
post ( "pdp_v4l2 : select timeout : thread exiting");
exit (-1);
}
}
static int pdp_v4l2_start_capturing(t_pdp_v4l2 *x)
{
enum v4l2_buf_type type;
type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
if (-1 == ioctl (x->x_tvfd, VIDIOC_STREAMON, &type))
{
perror("pdp_v4l2 : error starting streaming");
return -1;
}
post("pdp_v4l2 : capture started");
return 0;
}
static int pdp_v4l2_stop_capturing(t_pdp_v4l2 *x)
{
enum v4l2_buf_type type;
type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
if (-1 == ioctl (x->x_tvfd, VIDIOC_STREAMOFF, &type))
{
perror("pdp_v4l2 : error stopping streaming");
return -1;
}
return 0;
}
static void *pdp_v4l2_thread(void *voidx)
{
t_pdp_v4l2 *x = ((t_pdp_v4l2 *)voidx);
x->x_frame ^= 0x1;
if ( -1 == pdp_v4l2_start_capturing( x ) )
{
post( "pdp_v4l2 : problem starting capture.. exiting " );
exit( -1 );
}
/* capture with a double buffering scheme */
while (x->x_continue_thread)
{
/* schedule capture command for next frame */
pdp_v4l2_wait_frame(x);
/* wait until previous capture is ready */
x->x_frame ^= 0x1;
pdp_v4l2_capture_frame(x);
/* setup pointers for main thread */
x->x_frame_ready = 1;
x->x_last_frame = x->x_frame;
}
if ( -1 == pdp_v4l2_stop_capturing( x ) )
{
post( "pdp_v4l2 : problem stopping capture.. " );
}
post( "pdp_v4l2 : capture thread quitting" );
return 0;
}
static void pdp_v4l2_setlegaldim(t_pdp_v4l2 *x, int xx, int yy);
static int pdp_v4l2_set_format(t_pdp_v4l2 *x, t_int index)
{
x->x_v4l2_format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
x->x_v4l2_format.fmt.pix.pixelformat = x->x_formats[index].pixelformat;
x->x_v4l2_format.fmt.pix.width = x->x_width;
x->x_v4l2_format.fmt.pix.height = x->x_height;
x->x_v4l2_format.fmt.pix.field = V4L2_FIELD_ANY;
x->x_v4l2_format.fmt.pix.bytesperline = 0;
post( "pdp_v4l2 : setting format : pixel format : %c%c%c%c",
x->x_v4l2_format.fmt.pix.pixelformat & 0xff,
(x->x_v4l2_format.fmt.pix.pixelformat >> 8) & 0xff,
(x->x_v4l2_format.fmt.pix.pixelformat >> 16) & 0xff,
(x->x_v4l2_format.fmt.pix.pixelformat >> 24) & 0xff );
if (-1 == ioctl(x->x_tvfd, VIDIOC_S_FMT, &x->x_v4l2_format, EINVAL))
{
perror( "pdp_v4l2 : setting format" );
return -1;
}
if ( x->x_v4l2_format.fmt.pix.pixelformat != x->x_formats[index].pixelformat )
{
post( "pdp_v4l2 : couldn't set format : wrong pixel format " );
return -1;
}
post( "pdp_v4l2 : capture format : width : %d : height :%d : bytesperline : %d : image size : %d",
x->x_v4l2_format.fmt.pix.width , x->x_v4l2_format.fmt.pix.height,
x->x_v4l2_format.fmt.pix.bytesperline, x->x_v4l2_format.fmt.pix.sizeimage );
return 0;
}
static int pdp_v4l2_init_mmap(t_pdp_v4l2 *x)
{
unsigned int i;
// get mmap numbers
x->x_reqbufs.count = WANTED_BUFFERS;
x->x_reqbufs.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
x->x_reqbufs.memory = V4L2_MEMORY_MMAP;
if (-1 == ioctl(x->x_tvfd, VIDIOC_REQBUFS, &x->x_reqbufs, 0))
{
post( "pdp_v4l2 : error : couldn't init driver buffers" );
return -1;
}
post("pdp_v4l2: got %d buffers type %d memory %d",
x->x_reqbufs.count, x->x_reqbufs.type, x->x_reqbufs.memory );
for (i = 0; i < x->x_reqbufs.count; i++)
{
x->x_v4l2_buf[i].index = i;
x->x_v4l2_buf[i].type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
x->x_v4l2_buf[i].memory = V4L2_MEMORY_MMAP;
if (-1 == ioctl(x->x_tvfd, VIDIOC_QUERYBUF, &x->x_v4l2_buf[i], 0))
{
post( "pdp_v4l2 : error : couldn't query buffer %d", i );
return -1;
}
x->x_pdp_buf[i] = (unsigned char *) mmap(NULL, x->x_v4l2_buf[i].length,
PROT_READ | PROT_WRITE, MAP_SHARED,
x->x_tvfd, x->x_v4l2_buf[i].m.offset);
if (MAP_FAILED == x->x_pdp_buf[i])
{
perror("pdp_v4l2 : mmap");
return -1;
}
}
post( "pdp_v4l2 : mapped %d buffers", x->x_reqbufs.count );
for (i = 0; i < WANTED_BUFFERS; i++)
{
x->x_v4l2_buf[i].type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
x->x_v4l2_buf[i].memory = V4L2_MEMORY_MMAP;
x->x_v4l2_buf[i].index = i;
if (-1 == ioctl (x->x_tvfd, VIDIOC_QBUF, &x->x_v4l2_buf[i]))
{
perror("pdp_v4l2 : error queing buffers");
return -1;
}
}
post( "pdp_v4l2 : queued %d buffers", x->x_reqbufs.count );
return 0;
}
static void pdp_v4l2_open(t_pdp_v4l2 *x, t_symbol *name)
{
// open a v4l device and allocate a buffer
unsigned int size;
int i;
unsigned int width, height;
/* if already opened -> close */
if (x->x_initialized) pdp_v4l2_close(x);
/* exit if retried too much */
if (!x->x_open_retry){
post("pdp_v4l2: retry count reached zero for %s", name->s_name);
post("pdp_v4l2: try to open manually");
return;
}
post("pdp_v4l2: opening %s", name->s_name);
x->x_device = name;
if ((x->x_tvfd = open(name->s_name, O_RDWR)) < 0)
{
post("pdp_v4l2: error: open %s: %s",name->s_name,strerror(errno));
perror(name->s_name);
pdp_v4l2_close_error(x);
x->x_initialized = false;
return;
}
if (ioctl(x->x_tvfd, VIDIOC_QUERYCAP, &x->x_vcap) < 0)
{
perror("get capabilities");
return;
}
post("pdp_v4l2: driver info: %s %d.%d.%d / %s @ %s",
x->x_vcap.driver, (x->x_vcap.version >> 16) & 0xff, (x->x_vcap.version >> 8) & 0xff, x->x_vcap.version & 0xff, x->x_vcap.card, x->x_vcap.bus_info);
for (x->x_ninputs = 0; x->x_ninputs < MAX_INPUT; x->x_ninputs++) {
x->x_inputs[x->x_ninputs].index = x->x_ninputs;
if (-1 == ioctl(x->x_tvfd, VIDIOC_ENUMINPUT, &x->x_inputs[x->x_ninputs], EINVAL))
{
// perror("get inputs");
break;
}
else
{
post ("pdp_v4l2 : input %d : %s", x->x_ninputs, x->x_inputs[x->x_ninputs].name );
}
}
if (x->x_debug) post("pdp_v4l2: device has %d inputs", x->x_ninputs );
if ( x->x_ninputs > 0 )
{
if (x->x_curinput < 0) x->x_curinput = 0;
if (x->x_curinput >= x->x_ninputs) x->x_curinput = x->x_ninputs-1;
if (ioctl(x->x_tvfd, VIDIOC_S_INPUT, &x->x_curinput) < 0)
{
perror("pdp_v4l2: error: VIDIOC_S_INPUT");
post("pdp_v4l2: cant switch to input %d",x->x_curinput);
}
else
{
post("pdp_v4l2: switched to input %d", x->x_curinput);
}
if (ioctl(x->x_tvfd, VIDIOC_G_INPUT, &x->x_curinput) < 0)
{
post("pdp_v4l2: cant get current input %d",x->x_curinput);
}
else
{
post("pdp_v4l2: current input is %d",x->x_curinput);
}
}
for (x->x_nstandards = 0; x->x_nstandards < MAX_NORM; x->x_nstandards++) {
x->x_standards[x->x_nstandards].index = x->x_nstandards;
if (-1 == ioctl(x->x_tvfd, VIDIOC_ENUMSTD, &x->x_standards[x->x_nstandards], EINVAL))
{
// perror("get standards");
break;
}
else
{
post ("pdp_v4l2 : standard %d : %s", x->x_nstandards, x->x_standards[x->x_nstandards].name );
}
}
if (x->x_debug) post("pdp_v4l2: device supports %d standards", x->x_nstandards );
// switch to desired norm ( if available )
if ( x->x_nstandards > 0 )
{
if (x->x_curstandard < 0) x->x_curstandard = 0;
if (x->x_curstandard >= x->x_nstandards) x->x_curstandard = x->x_nstandards-1;
if (ioctl(x->x_tvfd, VIDIOC_S_STD, &x->x_curstandard) < 0)
{
perror("pdp_v4l2: error: VIDIOC_S_STD");
post("pdp_v4l2: cant switch to standard %d",x->x_curstandard);
}
else
{
post("pdp_v4l2: switched to standard %d", x->x_curstandard);
}
if (ioctl(x->x_tvfd, VIDIOC_G_STD, &x->x_curstandard) < 0)
{
post("pdp_v4l2: cant get current standard %d",x->x_curstandard);
}
else
{
post("pdp_v4l2: current standard is %d",x->x_curstandard);
}
}
if (x->x_freq > 0){
if (ioctl(x->x_tvfd, VIDIOC_S_FREQUENCY, &x->x_freq) < 0)
perror ("couldn't set frequency :");
}
for (x->x_nformats = 0; x->x_nformats < MAX_FORMAT; x->x_nformats++) {
x->x_formats[x->x_nformats].index = x->x_nformats;
x->x_formats[x->x_nformats].type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
if (-1 == ioctl(x->x_tvfd, VIDIOC_ENUM_FMT, &x->x_formats[x->x_nformats], EINVAL))
{
// perror("get formats");
break;
}
else
{
post ("pdp_v4l2 : format %d : %s", x->x_nformats, x->x_formats[x->x_nformats].description );
}
}
if (x->x_debug) post("pdp_v4l2: device supports %d formats", x->x_nformats );
x->x_streamparam.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
ioctl(x->x_tvfd,VIDIOC_G_PARM,&x->x_streamparam);
/* controls */
for (i = 0; i < MAX_CTRL; i++) {
x->x_controls[i].id = V4L2_CID_BASE+i;
if (-1 == ioctl(x->x_tvfd, VIDIOC_QUERYCTRL, &x->x_controls[i], EINVAL) ||
(x->x_controls[i].flags & V4L2_CTRL_FLAG_DISABLED))
x->x_controls[i].id = -1;
else if (x->x_debug) post( "control %d active (i:%d)", x->x_controls[i].id, i );
}
for (i = 0; i < MAX_CTRL; i++) {
x->x_controls[i+MAX_CTRL].id = V4L2_CID_PRIVATE_BASE+i;
if (-1 == ioctl(x->x_tvfd, VIDIOC_QUERYCTRL, &x->x_controls[i+MAX_CTRL], EINVAL) ||
(x->x_controls[i+MAX_CTRL].flags & V4L2_CTRL_FLAG_DISABLED))
x->x_controls[i+MAX_CTRL].id = -1;
else if (x->x_debug) post( "control %d active (i:%d)", x->x_controls[i+MAX_CTRL].id, i );
}
if ( x->x_nformats > 0 )
{
if (x->x_curformat < 0) x->x_curformat = 0;
if (x->x_curformat >= x->x_nformats) x->x_curformat = x->x_nformats-1;
// set the first available format
if ( pdp_v4l2_set_format(x, x->x_curformat) < 0 )
{
post( "pdp_v4l2 : couldn't set format : closing..." );
pdp_v4l2_close_error(x);
x->x_initialized = false;
return;
}
}
else
{
post( "pdp_v4l2 : error : no available formats : closing..." );
pdp_v4l2_close_error(x);
x->x_initialized = false;
return;
}
if ( pdp_v4l2_init_mmap(x) < 0 )
{
post( "pdp_v4l2 : error : couldn't initialize memory mapping : closing..." );
pdp_v4l2_close_error(x);
x->x_initialized = false;
return;
}
x->x_initialized=true;
post( "pdp_v4l2 : device initialized" );
// create thread
x->x_continue_thread = 1;
x->x_frame_ready = 0;
pthread_create(&x->x_thread_id, 0, pdp_v4l2_thread, x);
post( "pdp_v4l2 : created thread : %u", x->x_thread_id );
}
static void pdp_v4l2_open_manual(t_pdp_v4l2 *x, t_symbol *name)
{
x->x_open_retry = PDP_XV_RETRIES;
pdp_v4l2_open(x, name);
}
static void pdp_v4l2_input(t_pdp_v4l2 *x, t_float f)
{
if (!x->x_initialized){
post( "pdp_v4l2 : cannot set input : no device opened ");
return;
}
if ( ( (int)f < 0 ) || ( (int)f >= x->x_ninputs ) )
{
post( "pdp_v4l2 : input number %d out of range", (int)f );
return;
}
if (x->x_initialized){
pdp_v4l2_close(x);
x->x_curinput = (int)f;
pdp_v4l2_open(x, x->x_device);
}
}
static void pdp_v4l2_standard(t_pdp_v4l2 *x, t_float f)
{
if (!x->x_initialized){
post( "pdp_v4l2 : cannot set standard : no device opened ");
return;
}
if ( ( (int)f < 0 ) || ( (int)f >= x->x_nstandards ) )
{
post( "pdp_v4l2 : standard number %d out of range", (int)f );
return;
}
if (x->x_initialized){
pdp_v4l2_close(x);
x->x_curstandard = (int)f;
pdp_v4l2_open(x, x->x_device);
}
}
static void pdp_v4l2_format(t_pdp_v4l2 *x, t_float f)
{
if (!x->x_initialized){
post( "pdp_v4l2 : cannot set format : no device opened ");
return;
}
if ( ( (int)f < 0 ) || ( (int)f >= x->x_nformats ) )
{
post( "pdp_v4l2 : format number %d out of range", (int)f );
return;
}
if (x->x_initialized){
pdp_v4l2_close(x);
x->x_curformat = (int)f;
pdp_v4l2_open(x, x->x_device);
}
}
static void pdp_v4l2_freq(t_pdp_v4l2 *x, t_float f)
{
if (!x->x_initialized){
post( "pdp_v4l2 : cannot set format : no device opened ");
return;
}
x->x_freq = (int)f;
if (x->x_freq > 0)
{
if (ioctl(x->x_tvfd, VIDIOC_S_FREQUENCY, &x->x_freq) < 0)
{
perror ("couldn't set frequency :");
}
else
{
post("pdp_v4l2: tuner frequency set to : %f MHz", f / 16.0f);
}
}
}
static void pdp_v4l2_freqMHz(t_pdp_v4l2 *x, t_float f)
{
pdp_v4l2_freq(x, f*16.0f);
}
static void pdp_v4l2_bang(t_pdp_v4l2 *x)
{
/* if initialized, grab a frame and output it */
unsigned int w,h,nbpixels,packet_size,plane1,plane2;
unsigned char *newimage=NULL;
int pdp_packt,length,pos,i,encoding;
t_pdp* header;
t_image* image;
short int * data;
static short int gain[4] = {0x7fff, 0x7fff, 0x7fff, 0x7fff};
if (!(x->x_initialized)){
post("pdp_v4l2: no device opened");
if (x->x_auto_open){
post("pdp_v4l2: attempting auto open");
pdp_v4l2_open(x, x->x_device);
if (!(x->x_initialized)){
post("pdp_v4l2: auto open failed");
return;
}
}
else return;
}
/* do nothing if there is no frame ready */
if((!x->x_frame_ready) && (x->x_only_new_frames)) return;
x->x_frame_ready = 0;
newimage = x->x_pdp_buf[x->x_last_frame];
/* create new packet */
pdp_packt = pdp_packet_new_image(PDP_IMAGE_YV12, x->x_width, x->x_height);
header = pdp_packet_header(pdp_packt);
image = pdp_packet_image_info(pdp_packt);
if (!header){
post("pdp_v4l2: ERROR: can't allocate packet");
return;
}
data = (short int *) pdp_packet_data(pdp_packt);
/* convert data to pdp packet */
switch(x->x_v4l2_format.fmt.pix.pixelformat){
case V4L2_PIX_FMT_YUV420:
pdp_llconv(newimage, RIF_YUV__P411_U8, data, RIF_YVU__P411_S16, x->x_width, x->x_height);
break;
/* long live standards. v4l's rgb is in fact ogl's bgr */
case V4L2_PIX_FMT_RGB24:
pdp_llconv(newimage, RIF_BGR__P____U8, data, RIF_YVU__P411_S16, x->x_width, x->x_height);
break;
case V4L2_PIX_FMT_RGB32:
pdp_llconv(newimage, RIF_BGRA_P____U8, data, RIF_YVU__P411_S16, x->x_width, x->x_height);
break;
case V4L2_PIX_FMT_YUYV:
pdp_llconv(newimage, RIF_YUYV_P____U8, data, RIF_YVU__P411_S16, x->x_width, x->x_height);
break;
case V4L2_PIX_FMT_UYVY:
pdp_llconv(newimage, RIF_UYVY_P____U8, data, RIF_YVU__P411_S16, x->x_width, x->x_height);
break;
default:
post("pdp_v4l2: unsupported color model");
break;
}
pdp_packet_pass_if_valid(x->x_outlet0, &pdp_packt);
}
static void pdp_v4l2_setlegaldim(t_pdp_v4l2 *x, int xx, int yy)
{
unsigned int w,h;
w = pdp_imageproc_legalwidth((int)xx);
h = pdp_imageproc_legalheight((int)yy);
w = (w < x->x_maxwidth) ? w : x->x_maxwidth;
w = (w > x->x_minwidth) ? w : x->x_minwidth;
h = (h < x->x_maxheight) ? h : x->x_maxheight;
h = (h > x->x_minheight) ? h : x->x_minheight;
x->x_width = w;
x->x_height = h;
}
static void pdp_v4l2_dim(t_pdp_v4l2 *x, t_floatarg xx, t_floatarg yy)
{
if (!x->x_initialized){
post( "pdp_v4l2 : cannot set dim : no device opened ");
return;
}
if (x->x_initialized){
pdp_v4l2_close(x);
pdp_v4l2_setlegaldim(x, (int)xx, (int)yy);
pdp_v4l2_open(x, x->x_device);
}
}
static void pdp_v4l2_free(t_pdp_v4l2 *x)
{
pdp_v4l2_close(x);
}
t_class *pdp_v4l2_class;
void *pdp_v4l2_new(t_symbol *vdef)
{
t_pdp_v4l2 *x = (t_pdp_v4l2 *)pd_new(pdp_v4l2_class);
x->x_outlet0 = outlet_new(&x->x_obj, &s_anything);
x->x_initialized = false;
x->x_tvfd = -1;
x->x_ninputs = 0;
x->x_curinput = -1;
x->x_curstandard = -1;
x->x_curformat = -1;
x->x_freq = -1;
x->x_nstandards = 0;
x->x_nformats = 0;
x->x_frame = 0;
x->x_last_frame = 0;
x->x_auto_open = true;
if (vdef != gensym("")){
x->x_device = vdef;
}
else{
x->x_device = gensym("/dev/video0");
}
x->x_continue_thread = 0;
x->x_only_new_frames = 1;
x->x_width = 320;
x->x_height = 240;
x->x_open_retry = PDP_XV_RETRIES;
x->x_minwidth = pdp_imageproc_legalwidth(0);
x->x_maxwidth = pdp_imageproc_legalwidth_round_down(0x7fffffff);
x->x_minheight = pdp_imageproc_legalheight(0);
x->x_maxheight = pdp_imageproc_legalheight_round_down(0x7fffffff);
x->x_debug = 1;
return (void *)x;
}
#ifdef __cplusplus
extern "C"
{
#endif
void pdp_v4l2_setup(void)
{
pdp_v4l2_class = class_new(gensym("pdp_v4l2"), (t_newmethod)pdp_v4l2_new,
(t_method)pdp_v4l2_free, sizeof(t_pdp_v4l2), 0, A_DEFSYMBOL, A_DEFSYMBOL, A_NULL);
class_addmethod(pdp_v4l2_class, (t_method)pdp_v4l2_close_manual, gensym("close"), A_NULL);
class_addmethod(pdp_v4l2_class, (t_method)pdp_v4l2_open_manual, gensym("open"), A_SYMBOL, A_NULL);
class_addmethod(pdp_v4l2_class, (t_method)pdp_v4l2_input, gensym("input"), A_FLOAT, A_NULL);
class_addmethod(pdp_v4l2_class, (t_method)pdp_v4l2_format, gensym("format"), A_FLOAT, A_NULL);
class_addmethod(pdp_v4l2_class, (t_method)pdp_v4l2_standard, gensym("standard"), A_FLOAT, A_NULL);
class_addmethod(pdp_v4l2_class, (t_method)pdp_v4l2_dim, gensym("dim"), A_FLOAT, A_FLOAT, A_NULL);
class_addmethod(pdp_v4l2_class, (t_method)pdp_v4l2_freq, gensym("freq"), A_FLOAT, A_NULL);
class_addmethod(pdp_v4l2_class, (t_method)pdp_v4l2_freqMHz, gensym("freqMHz"), A_FLOAT, A_NULL);
class_addmethod(pdp_v4l2_class, (t_method)pdp_v4l2_bang, gensym("bang"), A_NULL);
}
#ifdef __cplusplus
}
#endif
#N canvas 508 213 927 686 10;
#X obj 35 20 metro 40;
#X msg 87 -19 stop;
#X msg 35 -19 bang;
#X msg 207 -159 open /dev/video0;
#X msg 207 -135 open /dev/video1;
#X text 339 -162 you can choose the input device using the 'open' message.
the default is /dev/video0;
#X msg 207 -110 close;
#X text 347 -110 closes the video port;
#X msg 208 -84 dim 320 240;
#X msg 208 -61 dim 640 480;
#X floatatom 209 -28 5 0 0 0 - - -;
#X floatatom 212 137 5 0 0 0 - - -;
#X msg 212 161 freq \$1;
#X floatatom 273 137 5 0 0 0 - - -;
#X msg 273 161 freqMHz \$1;
#X text 317 135 sets the v4l tuner frequency (in v4l units and MHz)
;
#X text 325 253 pdp_v4l2 is an interface for video 4 linux 2 devices
;
#X text 324 268 it's very similar to pdp_v4l but should support more
recent cameras \, if it doesn't with yours report bugs to [EMAIL PROTECTED]
;
#X obj 96 247 pdp_v4l2;
#X text 321 202 creation arguments: <input device>;
#X floatatom 210 20 5 0 0 0 - - -;
#X msg 210 40 format \$1;
#X text 294 18 sets the pixel format (like YUYV \, RGB32 \, ...);
#X msg 209 -8 input \$1;
#X text 293 -30 sets the v4l input (like camera \, tuner \, svideo
\, ...);
#X text 292 -19 see initialization phase for valid inputs;
#X text 297 69 sets the video standard ( for tuner cards );
#X text 294 29 see initialization phase for valid formats;
#X text 297 81 see initialization phase for valid standards;
#X floatatom 213 71 5 0 0 0 - - -;
#X msg 213 91 standard \$1;
#X obj 96 300 pdp_xv;
#X msg 179 299 cursor 1;
#X msg 167 271 posdim 0 0 1440 800;
#X text 324 303 authors : Yves Degoyon and Lluis Gomez i Bigorda;
#X text 325 317 code was inspired by pdp_v4l by Tom Schouten and xawtv
by Gerd Knorr;
#X connect 0 0 18 0;
#X connect 1 0 0 0;
#X connect 2 0 0 0;
#X connect 3 0 18 0;
#X connect 4 0 18 0;
#X connect 6 0 18 0;
#X connect 8 0 18 0;
#X connect 9 0 18 0;
#X connect 10 0 23 0;
#X connect 11 0 12 0;
#X connect 12 0 18 0;
#X connect 13 0 14 0;
#X connect 14 0 18 0;
#X connect 18 0 31 0;
#X connect 20 0 21 0;
#X connect 21 0 18 0;
#X connect 23 0 18 0;
#X connect 29 0 30 0;
#X connect 30 0 18 0;
#X connect 32 0 31 0;
#X connect 33 0 31 0;
_______________________________________________
[email protected] mailing list
UNSUBSCRIBE and account-management ->
http://lists.puredata.info/listinfo/pd-list
