[V4L] v4l programming

["Jian Peng" <jian_peng@xxxxxxxxxxx>]

Hi, everyone,

 

I just started to write programs using v4l. I read the API, and refered to CamCal, however, my program doesn't get the image data. I included my program here, hope somebody can help me! My bttv card only supports mmap(), no read(). I am using Redhat Linux 6.2.

 

Thanks,

 

Jian

 

 

#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <sys/ioctl.h>
#include <stdlib.h>

 

#include <linux/types.h>
#include <linux/videodev.h>

 

#include <sys/mman.h>

 

/* Stole from calib.h */
#define VIDEO_DEVICE            "/dev/video"

 

#define VIDEO_WIDTH       320
#define VIDEO_HEIGHT      240

 

/* Stole from v4l.c */
char video_device[50] = VIDEO_DEVICE;

 

int video_width = VIDEO_WIDTH;
int video_height = VIDEO_HEIGHT;

 

int video_input = 1;
int video_norm = 1;

 

int video_contrast = 32768;
int video_brightness = 32768;
int video_color = 32768;
int video_hue = 32768;

 

char *image_new = 0;
char *image_base = 0;

 

int vid_dev = -1;
char *vid_mmap = (char *)-1;
char *vid_alloc_map = 0;
int vid_alloc_size = 0;
int vid_mmap_size = 0;

 

struct video_mbuf vid_buf;

 

/* prototype */
void v4l_CloseDev(
   void
);

 

int v4l_OpenDev(
   char *device
);

 

char *v4l_SetDevice (
   int dev,
   int width,
   int height,
   int input,
   int norm
);

 

char *v4l_DoCapture (
   int dev,
   int width,
   int height
);

 

int v4l_Settings (
   void
);

 

/* Functions */
char *v4l_SetDevice (
   int dev,
   int width,
   int height,
   int input,
   int norm
)
{
   struct video_capability vid_caps;
   struct video_channel vid_chnl;
   struct video_window vid_win;

 

   if (ioctl (dev, VIDIOCGCAP, &vid_caps) == -1) {
      fprintf(stderr, "ioctl (VIDIOCGCAP) failed");
      return NULL;
   }

 

   if (input || norm) {
      vid_chnl.channel = -1;
      if (ioctl (dev, VIDIOCGCHAN, &vid_chnl) == -1) {
         fprintf(stderr, "ioctl (VIDIOCGCHAN) failed");
      } else {
         vid_chnl.channel = input;
         vid_chnl.norm    = norm;
         if (ioctl (dev, VIDIOCSCHAN, &vid_chnl) == -1) {
            fprintf (stderr, "ioctl (VIDIOCSCHAN) failed");
            return NULL;
         }
      }
   }

 

   v4l_Settings();

 

   if (ioctl (dev, VIDIOCGMBUF, &vid_buf) == -1) {
      fprintf(stderr, "No memory-mapping available.\n");

 

      if (ioctl (dev, VIDIOCGWIN, &vid_win)== -1) {
         fprintf(stderr, "ioctl (VIDIOCGWIN) failed");
         return NULL;
      }
      vid_win.width=width;
      vid_win.height=height;
      if (ioctl (dev, VIDIOCSWIN, &vid_win)== -1) {
         fprintf(stderr, "ioctl (VIDIOCSWIN) failed");
         return NULL;
      }
      vid_alloc_map = malloc(width*height*3);
      vid_alloc_size = width*height*3;

 

      return vid_alloc_map;
   } else {
      vid_mmap=mmap(0, vid_buf.size, PROT_READ|PROT_WRITE, MAP_SHARED, dev, 0);
 
      if ((unsigned char *)-1 == (unsigned char *) vid_mmap)
         return NULL;

 

      vid_mmap_size = vid_buf.size;

 

      return vid_mmap;
   }
}

 

char *v4l_DoCapture (
   int dev,
   int width,
   int height
)
{
   struct video_mmap t_mmap;
   int frame = 0;

 

   if (vid_alloc_map) {
      if (read(dev, vid_alloc_map, vid_alloc_size) != vid_alloc_size)
         return NULL;

 

      return vid_alloc_map;
   } else {
      t_mmap.format=VIDEO_PALETTE_RGB24;
      t_mmap.frame=frame;

 

      t_mmap.width=width;
      t_mmap.height=height;
   
      if (ioctl(dev, VIDIOCMCAPTURE, &t_mmap) == -1) {
         return NULL;
      }

 

      if (ioctl(dev, VIDIOCSYNC, &t_mmap) == -1) {
         fprintf(stderr, "Error with sync!\n");
         return NULL;
      }

 

      return vid_mmap + vid_buf.offsets[frame];
   }
}

 

int v4l_Settings (
   void
)
{
   struct video_picture vp;

 

   if (vid_dev == -1)
      return -1;

 

   if (ioctl (vid_dev, VIDIOCGPICT, &vp) == -1) {
      fprintf(stderr, "Error getting vp\n");
      return 1;
   }

 

   vp.contrast = video_contrast;
   vp.brightness = video_brightness;
   vp.colour = video_color;
   vp.hue = video_hue;
//  vp.whiteness = video_whiteness;

 

   if (ioctl(vid_dev, VIDIOCSPICT, &vp) == -1) {
      fprintf(stderr, "Error getting vp\n");
      return 2;
   }

 

   return 0;
}

 

void v4l_CloseDev(
   void
)
{
  if (vid_mmap > 0)
     munmap(vid_mmap, vid_mmap_size);
  vid_mmap = 0;

 

  if (vid_alloc_map)
     free(vid_alloc_map);
  vid_alloc_map = 0;

 

  close(vid_dev);
  vid_dev = -1;
}

 

int v4l_OpenDev(
  char *device
)
{
  if (vid_dev) { v4l_CloseDev(); sleep(1); }

 

  vid_dev=open(device, O_RDWR);

 

  if (vid_dev < 0) {
     fprintf(stderr, "Open device error\n");
     return -1;
  }

 

  /* Allow videodevice to settle in */
  sleep(1);

 

  image_base=v4l_SetDevice (vid_dev, video_width, video_height,
       video_input, video_norm);

 

  if (!image_base)
    return -2;

 

  return vid_dev;
}

 

/* End */

 

int main(int argc, char ** argv)
{
 /* new version */
 long i;
 FILE* im_file;

 

 im_file=fopen("imdata.txt","w");
 if (im_file==NULL) {
  fprintf(stderr, "cannot open imdata.txt\n");
  exit(1);
 }

 

 vid_dev = v4l_OpenDev(VIDEO_DEVICE);
 image_new = v4l_DoCapture(vid_dev, video_width, video_height);

 

  for (i = 0; i < VIDEO_WIDTH * VIDEO_HEIGHT*3; i++) {
  fprintf(im_file, "%x", image_new[i]);
  }
   
  fclose(im_file);
 v4l_CloseDev();

 

  return 0;
}