videodevice.h

gehe zur Dokumentation dieser Datei

/************************************************************************
                        videodevice.h - Copyright micha

**************************************************************************/

#ifndef VIDEODEVICE_H
#define VIDEODEVICE_H

extern "C"
{
#include <unistd.h>
#include <fcntl.h>
#include <linux/videodev.h>
}

#include <opencv/cv.hpp>
#include <string>
#include <iostream>
#include "imagesource.h"
#include "../image.h"

using namespace std;

namespace seemicro
{

class fileResource
{
  int f;

public:

  fileResource(const char *n, const int flags)
  {
    if((f = open(n, flags)) <= 0)
    {
      std::cerr << '"' << n << "\": "; perror("open");
      throw bad_alloc();
    }
  }

  fileResource(int ff) { f=ff; }

  ~fileResource() { if(f>=0) close(f); }

  operator int() { return f; }
};

struct videoDevice : public ImageSource
{
    fileResource video_fd;

    struct video_capability capability;
    struct video_window win;
    struct video_channel vc;
    struct video_picture pict;
    struct video_mbuf vm;
    struct video_mmap mm;
    struct video_info vinfo;

    unsigned char *pict_buf;

    int fmt;

    int imgFmt;

    int last_VIDIOCMCAPTURE_was_successful;

    int framesCaptured;

    int keyFrameRate;

    bool verbogen;

    unsigned char *imageDataOld;


  videoDevice(string device="/dev/video0", int imgFmt=VIDEO_PALETTE_GREY, int channel=-1,
    unsigned int reqWidth=0, unsigned int reqHeight=0);

  ~videoDevice();

  int setPicture(int *reqFmt, bool quiet=false);

  bool probeFmt(int fmt);

  CvSize* size();

  int captureFrame(void);

  int syncFrame(void);

  float framerate(void);

  void processKeyFrame(void)
  {
    processFrame();// ROI==NULL -> "alles"
  }

  void processFrame(myrect *AROI=NULL)
  {
    myrect ROI;
    if(AROI) ROI = *AROI;
    else ROI=myrect(0, 0, size()->width, size()->height);

    if(syncFrame())
    {
      cerr << "syncFrame(): error\n";
      return;
    }

    if(captureFrame())
    {
      cerr << "captureFrame(): error\n";
      // Groß rot ins Bild schreiben :)
      return;
    }

    // nun sind die Daten im Format fmt in pict_buf
    // sie sollen im Format imgFmt in img->imageData zur Verfügung stehen
    if(imgFmt==fmt==VIDEO_PALETTE_GREY || imgFmt==fmt==VIDEO_PALETTE_RGB24 ||
       (imgFmt==VIDEO_PALETTE_GREY && fmt==VIDEO_PALETTE_YUV420P))
    {
      // img->imageData auf pict_buf verbiegen
      // hoffentlich kommt kein Padding dazwischen

      // yuv420p2gray ist sehr einfach, da "y" der Grauwert ist und
      // die erste Plane am Anfang liegt
      // und "uv" nicht gebraucht werden - es liegt also schon
      // ein Graustufenbild vor

      if(!verbogen)
      {
        assert(img);
        imageDataOld = (unsigned char*)img->imageData;
        verbogen=true;
      }
      img->imageData = (char*)pict_buf + vm.offsets[mm.frame];
      return;
    }

    if(imgFmt==VIDEO_PALETTE_RGB24 && fmt==VIDEO_PALETTE_YUV420P)
    {
      // YUV420P 2 RGB 4 ROI
      // TODO: care for ROI
      yuv420p_unpack_2_rgb24(pict_buf + vm.offsets[mm.frame],
        img->imageData, win.width, win.height);
      return;
    }

    if(imgFmt==VIDEO_PALETTE_GREY && fmt==VIDEO_PALETTE_RGB24)
    {
      // RGB 2 GRAY 4 ROI
      __u32& w = win.width;
      //__u32& h = win.height;
      for(int y=0; y<ROI.r.height; y++)
      {
        int line = ROI.r.y + y;
        unsigned char *src = pict_buf + vm.offsets[mm.frame] + (line * w + ROI.r.x) * 3;
        unsigned char *dst = (unsigned char *)img->imageData + line * img->widthStep + ROI.r.x;
        for(int x=0;x<ROI.r.width; x++)
        {
          // pixel hernehmen
          // farbraum konvertieren
          // rgb2gray = (r+g+b)/3
          // into img->imgData speichern
          *dst++ = (src[0]+src[1]+src[2])/3;
          src += 3;
        }
      }
      return;
    }

    cerr << "Konvertierung nicht unterstützt! Ignoring.\n";
  }

}; // class

} // namespace

#endif // VIDEODEVICE_H

---