grabV4l2.cpp

/****************************************************************************
 *
 * $Id: grabV4l2.cpp 4056 2013-01-05 13:04:42Z fspindle $
 *
 * This file is part of the ViSP software.
 * Copyright (C) 2005 - 2013 by INRIA. All rights reserved.
 * 
 * This software is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * ("GPL") version 2 as published by the Free Software Foundation.
 * See the file LICENSE.txt at the root directory of this source
 * distribution for additional information about the GNU GPL.
 *
 * For using ViSP with software that can not be combined with the GNU
 * GPL, please contact INRIA about acquiring a ViSP Professional 
 * Edition License.
 *
 * See http://www.irisa.fr/lagadic/visp/visp.html for more information.
 * 
 * This software was developed at:
 * INRIA Rennes - Bretagne Atlantique
 * Campus Universitaire de Beaulieu
 * 35042 Rennes Cedex
 * France
 * http://www.irisa.fr/lagadic
 *
 * If you have questions regarding the use of this file, please contact
 * INRIA at visp@inria.fr
 * 
 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 *
 *
 * Description:
 * Acquire images using 1394 device with cfox (MAC OSX) and display it
 * using GTK or GTK.
 *
 * Authors:
 * Fabien Spindler
 *
 *****************************************************************************/


#include <visp/vpConfig.h>
#include <visp/vpDebug.h>
#include <stdlib.h>
#ifdef VISP_HAVE_V4L2

#if (defined (VISP_HAVE_X11) || defined(VISP_HAVE_GTK))

#include <visp/vpDisplay.h>
#include <visp/vpDisplayX.h>
#include <visp/vpDisplayGTK.h>
#include <visp/vpImage.h>
#include <visp/vpImageIo.h>
#include <visp/vpTime.h>
#include <visp/vpParseArgv.h>
#include <visp/vpV4l2Grabber.h>

// List of allowed command line options
#define GETOPTARGS  "df:i:hn:o:p:s:t:v:x"

typedef enum {
  grey_image = 0, // for ViSP unsigned char grey images
  color_image     // for ViSP vpRGBa color images
} vpImage_type;

void usage(const char *name, const char *badparam, unsigned fps, 
       unsigned input, unsigned scale, long niter, char *device, 
       vpV4l2Grabber::vpV4l2PixelFormatType pixelformat, 
     const vpImage_type &image_type, const std::string &opath)
{
  fprintf(stdout, "\n\
Grab grey level images using the Video For Linux Two framegrabber. \n\
Display these images using X11 or GTK.\n\
\n\
SYNOPSIS\n\
  %s [-v <video device>] [-f <fps=25|50>] \n\
     [-i <input=0|1|2|3> [-s <scale=1|2|4>] [-p <pixel format>]\n\
     [-n <niter>] [-t <image type>] [-o <filename>] [-x] [-d] [-h]\n", name);

  fprintf(stdout, "\n\
OPTIONS:                                                  Default\n\
  -v <video device>                                         %s\n\
     Video device to access to the camera\n\
\n\
  -f <fps>                                                  %u\n\
     Framerate in term od number of images per second.\n\
     Possible values are 25 (for 25Hz) or 50 (for %%) Hz)\n\
\n\
  -i <input>                                                %u\n\
     Framegrabber active input. Values can be 0, 1, 2, 4\n\
\n\
  -p <pixel format>                                         %d\n\
     Camera pixel format. Values must be in [0-%d]:\n\
       0 for gray format\n\
       1 for RGB24 format\n\
       2 for RGB32 format\n\
       3 for BGR24 format\n\
       4 for YUYV format\n\
\n\
  -t <image type>                                           %d\n\
     Kind of images that are acquired/displayed by ViSP. \n\
     Values must be in [0-1]:\n\
       0 for grey images in unsigned char \n\
       1 for color images in vpRGBa\n\
\n\
  -s <scale>                                                %u\n\
     Framegrabber subsampling factor. \n\
     If 1, full resolution image acquisition.\n\
     If 2, half resolution image acquisition. The \n\
     subsampling is achieved by the hardware.\n\
\n\
  -n <niter>                                                %ld\n\
     Number of images to acquire.\n\
\n\
  -d \n\
     Turn off the display.\n\
\n\
  -x \n\
     Activates the extra verbose mode.\n\
\n\
  -o [%%s] : Filename for image saving.                     \n\
     Example: -o %s\n\
     The %%d is for the image numbering. The format is set \n\
     by the extension of the file (ex .png, .pgm, ...) \n\
                    \n\
  -h \n\
     Print the help.\n\n",
      device, fps, input, pixelformat, 
    vpV4l2Grabber::V4L2_MAX_FORMAT-1, image_type, scale, niter, opath.c_str());

  if (badparam)
    fprintf(stdout, "\nERROR: Bad parameter [%s]\n", badparam);
}

bool getOptions(int argc, const char **argv, unsigned &fps, unsigned &input,
                unsigned &scale, bool &display, bool &verbose,
                long &niter, char *device,
                vpV4l2Grabber::vpV4l2PixelFormatType &pixelformat,
                vpImage_type &image_type, bool &save, std::string &opath)
{
  const char *optarg;
  int   c;
  while ((c = vpParseArgv::parse(argc, argv, GETOPTARGS, &optarg)) > 1) {

    switch (c) {
    case 'd': display = false; break;
    case 'f': fps = (unsigned) atoi(optarg); break;
    case 'i': input = (unsigned) atoi(optarg); break;
    case 'n': niter = atol(optarg); break;
    case 'o':
      save = true;
      opath = optarg; break;
    case 'p': pixelformat = (vpV4l2Grabber::vpV4l2PixelFormatType) atoi(optarg); break;
    case 's': scale = (unsigned) atoi(optarg); break;
    case 't': image_type = (vpImage_type) atoi(optarg); break;
    case 'v': sprintf(device, "%s", optarg); break;
    case 'x': verbose = true; break;
    case 'h': usage(argv[0], NULL, fps, input, scale, niter, 
                    device, pixelformat, image_type, opath);
      return false; break;

    default:
      usage(argv[0], optarg, fps, input, scale, niter, 
            device, pixelformat, image_type, opath); return false; break;
    }
  }

  if ((c == 1) || (c == -1)) {
    // standalone param or error
    usage(argv[0], NULL, fps, input, scale, niter, 
          device, pixelformat, image_type, opath);
    std::cerr << "ERROR: " << std::endl;
    std::cerr << "  Bad argument " << optarg << std::endl << std::endl;
    return false;
  }

  return true;
}

int
main(int argc, const char ** argv)
{
  unsigned int opt_fps = 25;
  unsigned int opt_input = 0;
  unsigned int opt_scale = 1;
  vpV4l2Grabber::vpV4l2PixelFormatType opt_pixelformat = vpV4l2Grabber::V4L2_YUYV_FORMAT;
  long opt_iter = 100;
  bool opt_verbose = false;
  bool opt_display = true;
  char opt_device[20];
  bool opt_save = false;
  sprintf(opt_device, "/dev/video0");
  // Default output path for image saving
  std::string opt_opath = "/tmp/I%04d.ppm";

  vpImage_type opt_image_type = color_image;

  // Read the command line options
  if (getOptions(argc, argv, opt_fps, opt_input, opt_scale, opt_display, 
                 opt_verbose, opt_iter, opt_device,
                 opt_pixelformat, opt_image_type, opt_save, opt_opath) == false) {
    exit (-1);
  }

  // Declare an image, this is a gray level image (unsigned char) and
  // an other one that is a color image. There size is not defined
  // yet. It will be defined when the image will acquired the first
  // time.
  vpImage<unsigned char> Ig ; // grey level image
  vpImage<vpRGBa> Ic ; // color image

  // Creates the grabber
  vpV4l2Grabber g;

  try{
    // Initialize the grabber
    g.setVerboseMode(opt_verbose);
    g.setDevice(opt_device);
    g.setInput(opt_input);
    g.setScale(opt_scale);
    g.setPixelFormat(opt_pixelformat);
    if (opt_fps == 25)
      g.setFramerate(vpV4l2Grabber::framerate_25fps);
    else
      g.setFramerate(vpV4l2Grabber::framerate_50fps);
    if (opt_image_type == grey_image) {
      // Open the framegrabber with the specified settings on grey images
      g.open(Ig) ;
      // Acquire an image
      g.acquire(Ig) ;
      std::cout << "Grey image size: width : " << Ig.getWidth() <<  " height: "
                << Ig.getHeight() << std::endl;
    }
    else {
      // Open the framegrabber with the specified settings on color images
      g.open(Ic) ;
      // Acquire an image
      g.acquire(Ic) ;
      std::cout << "Color image size: width : " << Ic.getWidth() <<  " height: "
                << Ic.getHeight() << std::endl;
    }
  }
  catch (vpException e) {
    std::cout << "Catched exception: " << e.getMessage() << std::endl;
    return 0;
  }
  catch(...)
  {
    vpERROR_TRACE("Cannot acquire an image...") ;
    return 0;
  }


  // We open a window using either X11 or GTK.
  // Its size is automatically defined by the image (I) size
#if defined VISP_HAVE_X11
  vpDisplayX display;
#elif defined VISP_HAVE_GTK
  vpDisplayGTK display;
#endif

  if (opt_display) {
    try{
      // Display the image
      // The image class has a member that specify a pointer toward
      // the display that has been initialized in the display declaration
      // therefore is is no longuer necessary to make a reference to the
      // display variable.
      if (opt_image_type == grey_image) {
        display.init(Ig, 100, 100, "V4L2 grey images framegrabbing") ;
        vpDisplay::display(Ig) ;
        vpDisplay::flush(Ig) ;
      }
      else {
        display.init(Ic, 100, 100, "V4L2 color images framegrabbing") ;
        vpDisplay::display(Ic) ;
        vpDisplay::flush(Ic) ;
      }

    }
    catch (vpException e) {
      std::cout << "Exception: " << e.getMessage() << std::endl;
    }
    catch(...)
    {
      vpERROR_TRACE("Error while displaying the image") ;
      exit(-1);
    }
  }
  try {
    // Acquisition loop
    long cpt = 1;
    while(cpt ++ < opt_iter)
    {
      // Measure the initial time of an iteration
      double t = vpTime::measureTimeMs();
      // Acquire the image
      if (opt_image_type == grey_image) {
        g.acquire(Ig) ;
        if (opt_display) {
          // Display the image
          vpDisplay::display(Ig) ;
          // Flush the display
          vpDisplay::flush(Ig) ;
        }
      }
      else {
        g.acquire(Ic) ;
        if (opt_display) {
          // Display the image
          vpDisplay::display(Ic) ;
          // Flush the display
          vpDisplay::flush(Ic) ;
        }
      }

      if (opt_save) {
        char buf[FILENAME_MAX];
        sprintf(buf, opt_opath.c_str(), cpt);
        std::string filename(buf);
        std::cout << "Write: " << filename << std::endl;
        if (opt_image_type == grey_image) {
          vpImageIo::write(Ig, filename);
        }
        else {
          vpImageIo::write(Ic, filename);
        }
      }

      // Print the iteration duration
      std::cout << "time: " << vpTime::measureTimeMs() - t << " (ms)" << std::endl;
    }

    g.close();
  }
  catch (vpException e) {
    std::cout << "Exception: " << e.getMessage() << std::endl;
    g.close();
  }

}
#else
int
main()
{
  vpTRACE("X11 or GTK display are not available") ;
}
#endif
#else
int
main()
{
  vpTRACE("Video 4 Linux 2 frame grabber drivers are not available") ;
}
#endif