---

/home/slang/XVision2/src/Devices/Video.h

#ifndef __xvvideo_h
#define __xvvideo_h

/*                                                      -*-c++-*-
    Copyright (C) 2000 Gregory D. Hager and Darius Burschka (JHU
    Lab for Computational Interaction with Physical Systems (CIPS))

Permission is granted to any individual or institution to use, copy,
modify, and distribute this software, provided that this complete
copyright and permission notice is maintained, intact, in all copies and
supporting documentation.  Authors of papers that describe software
systems using this software package are asked to acknowledge such use by
a brief statement in the paper.

We provide this software "as is" without express or implied warranty.
*/

#include <stdlib.h>
#include "XVImageRGB.h"

typedef enum {MODE_CAP_SINGLE = 0, MODE_CAP_CONTINUOUS = 1}       XVCapture_Mode;
typedef enum {NORM_NTSC=0,NORM_PAL,NORM_SECAM, INPUT_DETERMINED}  XV_Video_Norms;
typedef enum {FULL_SIZE, HALF_SIZE, QUARTER_SIZE}                 XV_Resolution;

// XVSize is defined in XVImageBase.h

extern XVSize XVSize_AVI_full,
  XVSize_NTSC_full,
  XVSize_NTSC_half,
  XVSize_NTSC_quarter;

//
typedef struct
{
   char   c;             // parameter specification e.g. B
   int  val;             // assigned value
}XVParser;

template <class PIXTYPE>
class Video
{
protected:

  const char     *name;
  XVSize          size;

  // By default, it is assumed that any video device might use multiple
  // buffers (e.g. a ring-buffer), so video provides basic support for
  // managing them.

  XVImageRGB<PIXTYPE>      *image_buffers;
  int               n_buffers;
  int             current_buffer;

  // This is the index of the most recently acquired frame. 

  int             frame_count;
  XVCapture_Mode  capture_mode;

  // Default creation of buffers to be used in open
  
  XVImageRGB<PIXTYPE> *init_map(XVSize s, int n_buffers);

  // Some local buffer management...by default this is just a ring queue

  virtual int next_buffer() {
    return (current_buffer = (++current_buffer%=n_buffers));};

  // parse through the param string, the resulting char * is
  // modified by each call
  //     return 1     - got parameters
  //     return 0     - end of file
  //     return -1    - error
  int   parse_param(char * &paramstring,XVParser &result);

  XVImageRGB<PIXTYPE> *frame_addr(int i) const 
  {
    assert(i<buffer_count());
    return image_buffers+i;
  }
  // describes if the buffers in XVImageRGB where created by Video
  int   own_buffers;

 public:

  /* This is the generic declaration of a video device and is what
     the user would normally see when opening it.  The second
     parameter is not used, but is here for reference since
     most devices will probably want to pass a parameter string in
     to get some default device configuration. */

  Video(const char *dev_name="/dev/video",const char *parm_string = NULL);

  virtual ~Video();

  int          buffer_count(void) const {return n_buffers;};

  XVImageRGB<PIXTYPE> &frame(int i) const {return *(frame_addr(i));}

  XVImageRGB<PIXTYPE> &current_frame() const {return frame(current_buffer);}

  virtual int  initiate_acquire(int buffernum)=0;
  virtual int  wait_for_completion(int buffernum)=0;
  int          release_buffer(int buffernum){};

  int &request_frame_continuous(int framenum) {
    while (frame_count < framenum)
      next_frame_continuous();

    return frame_count;
  }

  XVImageRGB<PIXTYPE> &next_frame_continuous() {
    if (capture_mode != MODE_CAP_CONTINUOUS) {// Start the cycle
      capture_mode = MODE_CAP_CONTINUOUS;
      initiate_acquire(current_buffer);
    }
    int temp = current_buffer;
    initiate_acquire(next_buffer());
    wait_for_completion(temp);
    frame_count++;
    return frame(temp);
  }

  int request_frame_poll(int framenum) {
    int next;

    if (capture_mode != MODE_CAP_SINGLE) {
      wait_for_completion(current_buffer);
      capture_mode = MODE_CAP_SINGLE;
      frame_count++;
    }
    while (framenum > frame_count) {
      initiate_acquire(next=next_buffer());
      wait_for_completion(next);
      frame_count++;
    }
    return (current_buffer);
  };

  const XVImageRGB<PIXTYPE> &next_frame_poll(void)
  {
    if (request_frame_poll(frame_count++))
      return current_frame();
  }

  //*** hardware device functions that need to be implemented for
  //*** any device

  // paramstring content
  // Bxx     - xx number of available buffers
  // I[0-2]  - input number
  // N[0-..] - norm XV_Video_Norms
  // S[1-2]  - full size, half size...
  virtual int  set_params(char *paramstring)=0;
  // This allow remapping of video buffers --- for example the
  // buffering class manages it's own; many framegrabber remap memory, etc.

  XVImageRGB<PIXTYPE> *remap(PIXTYPE *mm_buf[],int n_buffers);

};
#endif

---