mvc.c

mvc源码

/*
 * vidcat.c
 *
 * Copyright (C) 1998 Rasca, Berlin
 * EMail: [e-mail]
 * Modified: [e-mail] Jun.16, Jul.7, 2000
 *
 * 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.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <getopt.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <unistd.h>
#include <linux/types.h>
#include <linux/videodev.h>
#include <time.h>
#include <jpeglib.h>

#include "mvc.h"

/*
 * read rgb image from v4l device
 * return: mmap'ed buffer and size
 */
char *
get_image (int dev, int width, int height, int input, int norm, int fmt,
	   int *size)
{
  struct video_capability vid_caps;
  struct video_mbuf vid_buf;
  struct video_mmap vid_mmap;
  struct video_channel vid_chnl;
  char *map;
  int len;

  if (ioctl (dev, VIDIOCGCAP, &vid_caps) == -1) 
  {
    perror ("ioctl (VIDIOCGCAP)");
    return (NULL);
  }
  vid_chnl.channel = -1;
  if (ioctl (dev, VIDIOCGCHAN, &vid_chnl) == -1) 
  {
    perror ("ioctl (VIDIOCGCHAN)");
  }
  else 
  {
	printf("get channel failed\n");
    vid_chnl.channel = input;
    vid_chnl.norm = norm;
    if (ioctl (dev, VIDIOCSCHAN, &vid_chnl) == -1) 
	{
      perror ("ioctl (VIDIOCSCHAN)");
      return (NULL);
    }
	else
	  printf("get channel failed. but set channel success\n\n");
  }
  if (ioctl (dev, VIDIOCGMBUF, &vid_buf) == -1) 
  {
    map = malloc (width * height * 3);
    len = read (dev, map, width * height * 3);
    if (len <= 0) 
	{
      free (map);
      return (NULL);
    }
    *size = 0;
    return (map);
  }

  //void  *  mmap(void *start, size_t length, int prot , int flags, int fd, off_t offset);
  //int munmap(void *start, size_t length);
  //mmap returns a pointer  to  the  mapped  area ,or MAP_FAILED  (-1)  is returned
  map = mmap (0, vid_buf.size, PROT_READ | PROT_WRITE, MAP_SHARED, dev, 0);
  if ((unsigned char *) -1 == (unsigned char *) map)  //???? what's the meaning?
  {
    perror ("mmap()");
    return (NULL);
  }

  vid_mmap.format = fmt;
  vid_mmap.frame = 0;
  vid_mmap.width = width;
  vid_mmap.height = height;
  if (ioctl (dev, VIDIOCMCAPTURE, &vid_mmap) == -1) 
  {
    perror ("VIDIOCMCAPTURE");
    munmap (map, vid_buf.size);
    return (NULL);
  }
  if (ioctl (dev, VIDIOCSYNC, &vid_mmap) == -1) 
  {
    perror ("VIDIOCSYNC");
    munmap (map, vid_buf.size);
    return (NULL);
  }
  *size = vid_buf.size;
  return (map);
}

/*
 * Write image buffer to timestamp named jpeg file.
 */
void
put_image_jpeg (char *filename, char *image, int width, int height,
		int quality)
{
  int y, x, line_width;
  JSAMPROW row_ptr[1];
  struct jpeg_compress_struct cjpeg;
  struct jpeg_error_mgr jerr;
  char *line;
  FILE *fd;

  if ((fd = fopen (filename, "w+")) == NULL) {
    fprintf (stderr, "Error: Can't Create File %s\n", filename);
    exit (-2);
  }
  line = malloc (width * 3);
  if (!line)
    return;
  cjpeg.err = jpeg_std_error (&jerr);
  jpeg_create_compress (&cjpeg);
  cjpeg.image_width = width;
  cjpeg.image_height = height;
  cjpeg.input_components = 3;
  cjpeg.in_color_space = JCS_RGB;
  jpeg_set_defaults (&cjpeg);

  jpeg_set_quality (&cjpeg, quality, TRUE);
  cjpeg.dct_method = JDCT_FASTEST;
  jpeg_stdio_dest (&cjpeg, fd);

  jpeg_start_compress (&cjpeg, TRUE);

  row_ptr[0] = line;
  line_width = width * 3;
  for (y = 0; y < height; y++) {
    for (x = 0; x < line_width; x += 3) {
      line[x] = image[x + 2];
      line[x + 1] = image[x + 1];
      line[x + 2] = image[x];
    }
    jpeg_write_scanlines (&cjpeg, row_ptr, 1);
    image += line_width;
  }
  jpeg_finish_compress (&cjpeg);
  jpeg_destroy_compress (&cjpeg);
  free (line);
  fclose (fd);
}

/*
 * main()
 */
int
main (int argc, char *argv[])
{
  int width = DEF_WIDTH, height = DEF_HEIGHT, size, dev = -1, c, n = 0;
  char *image, *oldimg, *device = VIDEO_DEV;
  char lasttime[32], timename[32], filename[64];
  time_t now;
  struct tm *tm;
  int max_try = 5;		/* we try 5 seconds/times to open the device */
  int quality = QUAL_DEFAULT;	/* default jpeg quality setting */
  int input = IN_DEFAULT;
  int norm = NORM_DEFAULT;
  int palette = VIDEO_PALETTE_RGB24;
  int blk_x = 16;
  int blk_y = 8;
  int color_lim = 50;
  int blk_lim = blk_x * blk_y / 64 + 1;

  oldimg = malloc (width * height * 3);
  while ((c = getopt (argc, argv, "s:q:a:b:c:n:i:d")) != EOF) {
    switch (c) {
    case 'd':
      device = optarg;
      break;
    case 's':
      sscanf (optarg, "%dx%d", &width, &height);
      break;
    case 'a':
      sscanf (optarg, "%dx%d", &blk_x, &blk_y);
      blk_lim = blk_x * blk_y / 64 + 1;
      break;
    case 'b':
      sscanf (optarg, "%d", &blk_lim);
      break;
    case 'c':
      sscanf (optarg, "%d", &color_lim);
      break;
    case 'n':
      if (strcasecmp ("ntsc", optarg) == 0) {
	norm = NORM_NTSC;
      }
      else if (strcasecmp ("pal", optarg) == 0) {
	norm = NORM_PAL;
      }
      else if (strcasecmp ("secam", optarg) == 0) {
	norm = NORM_SECAM;
      }
      break;
    case 'q':
      sscanf (optarg, "%d", &quality);
      break;
    case 'i':
      if (strcasecmp ("tv", optarg) == 0) {
	input = IN_TV;
      }
      else if (strcasecmp ("comp1", optarg) == 0) {
	input = IN_COMPOSITE;
      }
      else if (strcasecmp ("comp2", optarg) == 0) {
	input = IN_COMPOSITE2;
      }
      else if (strcasecmp ("s-video", optarg) == 0) {
	input = IN_SVIDEO;
      }
      break;
    default:
      fprintf (stderr,
	       "%s, Version %s\n"
	       "Usage: %s <options>\n"
	       " -s XxY define size of the output image (default: %dx%d)\n"
	       " -a HxV define sense areas in Horizantal and Vertical (default: %dx%d)\n"
	       " -i {tv|comp1|comp2|s-video} which input channel to use\n"
	       " -n {pal|ntsc|secam}         which norm to use, default: PAL\n"
	       " -q <quality>                only for jpeg: quality setting (1-100, default: %d)\n"
	       " -d <device>                 video device (default: " VIDEO_DEV ")\n"
	       " -b <diff_block_limit>       blocks different limit, default: %d\n"
	       " -c <diff_color_limit>       color  different limit, default: %d\n",
	       argv[0], VERSION, argv[0], DEF_WIDTH, DEF_HEIGHT, blk_x, blk_y,
	       QUAL_DEFAULT, blk_lim, color_lim);
      exit (1);
      break;
    }
  }

#ifdef DEBUG
  fprintf (stderr, "-------------------- Debug Info ---------------------\n");
  fprintf (stderr, " ImageSize:    %dx%d\n", width, height);
  fprintf (stderr, " ImageQuality: %d\n", quality);
  fprintf (stderr, " VideoDEV:     %s\n", device);
  fprintf (stderr, " VideoInput(TV=0, COMP1=1, COMP2=2, SVIDEO=3): %d\n",
	   input);
  fprintf (stderr, " VideoNORM(PAL=0, NTSC=1, SECAM=2, AUTO=3): %d\n", norm);
  fprintf (stderr, " SenseBlockSize: %dx%d\n", blk_x, blk_y);
  fprintf (stderr, " ColorLimit:   %d\n", color_lim);
  fprintf (stderr, " BlockLimit:   %d\n", blk_lim);
  fprintf (stderr, "-----------------------------------------------------\n");
#endif

loop:
  /* open the video4linux device */
  max_try = 5;
  while ((dev = open (device, O_RDWR)) == -1 && --max_try)
    sleep (1);
  if (dev == -1) {
    fprintf (stderr, "Can't open device %s\n", VIDEO_DEV);
    exit (-1);
  }
  else
  {
	  printf("device opening success!");
  }

  image = get_image (dev, width, height, input, norm, palette, &size);
  if (image) {
    if (cmp_img(image, oldimg, width, height, blk_x, blk_y, color_lim,
	blk_lim) == 1) {
      time (&now);
      tm = localtime (&now);
      strftime (timename, 31, "%Y%m%d-%H%M%S", tm);
      if (strcmp (timename, lasttime) == 0)
	n++;
      else
	n = 0;
      strcpy (lasttime, timename);
      sprintf (filename, "mvc%s-%d.jpg", timename, n);
#ifdef DEBUG
      printf ("Writing: %s \a\n", filename);
#endif
      put_image_jpeg (filename, image, width, height, quality);
    }
    memcpy (oldimg, image, width * height * 3);
    if (size)
      munmap (image, size);
    else if (image)
      free (image);
  }
  else {
    fprintf (stderr, "Error: Can't get image\n");
  }
  close (dev);
  usleep (500000);
  goto loop;
}

/*
 * Compare image img1 and img2 by split blocks, 
 * if changed, return 1.
 */
int
cmp_img (char *img1, char *img2, int width, int height, int split_x,
	 int split_y, int c_lim, int b_lim)
{
  int i, count;
  RGB a1[8192], a2[8192];
  int color_diff[8192];

  proc_img (a1, img1, width, height, split_x, split_y);
  proc_img (a2, img2, width, height, split_x, split_y);

  count = 0;
  for (i = 0; i < split_x * split_y; i++) {
    color_diff[i] = abs (a1[i].red - a2[i].red) + 
      abs (a1[i].green - a2[i].green) +
      abs (a1[i].blue - a2[i].blue);
    if (color_diff[i] > c_lim) {
      count++;
    }
    if (count >= b_lim) {
      return 1;
    }
  }
  return 0;
}

/*
 * Split image buffer *img (width=w, height=h) into sx * sy blocks. 
 * For every splited block, calculate its average RGB color, then 
 * store this RGB color into array r.
 */
int
proc_img (RGB * r, char *img, int w, int h, int sx, int sy)
{
  unsigned char *p;
  int x, y, m, n;
  int blk_wid = w / sx, blk_hgt = h / sy;
  int x0, y0, x1, y1;
  unsigned long s = blk_wid * blk_hgt;
  unsigned long R, G, B;

  for (n = 1; n <= sy; n++) {
    for (m = 1; m <= sx; m++) {
      x0 = (m - 1) * blk_wid;
      y0 = (n - 1) * blk_hgt;
      x1 = blk_wid * m - 1;
      y1 = blk_hgt * n - 1;
      R = G = B = 0;
      for (y = y0; y <= y1; y++) {
	for (x = x0; x <= x1; x++) {
	  p = img + (y * w + x) * 3;
	  R += *(p + 2);
	  G += *(p + 1);
	  B += *p;
	}
      }
      r->red = R / s;
      r->green = G / s;
      r->blue = B / s;
      r++;
    }
  }
  return s;
}