LibreMediaServer/lms-video
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

- Reestructuración de ficheros y directorios general

Browse source 
- merge v0.01 --> Añadido fileselector
- Añadidas fuentes de Gem y Pure Data
- pix2jpg incluído en Gem. Archivos de construcción de Gem modificados.
- Añadido fichero ompiling.txt con instrucciones de compilación
This commit is contained in:
Santi Noreña 2013-02-04 18:00:17 +01:00
parent c9adfd020b
commit e85d191b46
3100 changed files with 775434 additions and 3073 deletions
Download patch file Download diff file Expand all files Collapse all files

25
Gem/plugins/videoAVT/LICENSE.txt Normal file
View file

@ -0,0 +1,25 @@
Copyright (C) 2010 IOhannes m zmölnig
Institute of Electronic Music and Acoustics (IEM), Graz, Austria
University of Music and Performing Arts (KUG), Graz, Austria
forum::für::umläute
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 3 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, see <http://www.gnu.org/licenses>.
Additional permission under GNU GPL version 3 section 7
If you modify this Program, or any covered work, by linking or combining it
with AVT GiGE SDK (or a modified version of that library), containing parts
covered by the terms of the MVTec Software GmbH - Software License Agreement for
AVT GiGE SDK , the licensors of this Program grant you additional permission to
convey the resulting work.

43
Gem/plugins/videoAVT/Makefile.am Normal file
View file

@ -0,0 +1,43 @@
ACLOCAL_AMFLAGS = -I ../../m4 -I .
AM_CPPFLAGS = -I$(srcdir)/../../src
EXTRA_DIST = avt.m4 LICENSE.txt README.txt
EXTRA_DIST += win-vs2003/videoAVT.sln win-vs2003/videoAVT.vcproj
EXTRA_DIST += win-vs2008/videoAVT.sln win-vs2008/videoAVT.vcproj
plugindir=$(libdir)/Gem
plugin_LTLIBRARIES=
dist_plugin_DATA =
if HAVE_LIB_LIBPVAPI
plugin_LTLIBRARIES+= gem_videoAVT.la
dist_plugin_DATA += avt-videoplugin.pd
endif
gem_videoAVT_la_CXXFLAGS =
gem_videoAVT_la_LDFLAGS = -module -avoid-version -shared
if WINDOWS
gem_videoAVT_la_LDFLAGS += -no-undefined
endif
gem_videoAVT_la_LIBADD =
# RTE
gem_videoAVT_la_CXXFLAGS += @GEM_RTE_CFLAGS@
gem_videoAVT_la_LDFLAGS += @GEM_RTE_LIBS@
#gem_videoAVT_la_CXXFLAGS += @GEM_ARCH_CXXFLAGS@
#gem_videoAVT_la_LDFLAGS += @GEM_ARCH_LDFLAGS@
# #gem_videoAVT_la @MOREFLAGS@
# Dependencies
gem_videoAVT_la_CXXFLAGS += @GEM_LIB_LIBPVAPI_CFLAGS@
gem_videoAVT_la_LIBADD += @GEM_LIB_LIBPVAPI_LIBS@
# convenience symlinks
include $(srcdir)/../symlink_ltlib.mk
### SOURCES
gem_videoAVT_la_SOURCES= videoAVT.cpp videoAVT.h

138
Gem/plugins/videoAVT/README.txt Normal file
View file

@ -0,0 +1,138 @@
videoAVT
========
backend for [pix_video] using Prosilica's "AVT GiGE SDK"
"AVT GiGE SDK" is a commercial library that can do image-acquisition from
GiGE-cameras.
"AVT" stands for "Allied Vision Technologies" and is the consortium defining the
GiGE-standard.
You have to get Prosilica's SDK from either
- http://prosilica.com
- http://www.alliedvisiontec.com/us/products/software.html
- or whereever they have moved it now
in order to use it with Gem.
At the time of writing, the SDK runs on W32, linux, OSX and QNX
variable video-backends are available in Gem>=0.93
Installation on un*x
=====================
first you have to install the SDK from Prosilica: download and extract to
whereever you want; i will refer to this path as AVTSDKPATH.
$ tar xvzf AVT_GigE_SDK_1.24_Linux.tar.gz
$ cd AVT\ GigE\ SDK/
$ export AVTSDKPATH=$(pwd)
$
after installations you should have something like this:
$ cd ${AVTSDKPATH}
$ ls
bin-pc documents examples inc-pc lib-pc README.txt
$
static building
---------------
static linking has the great advantage, that you are not depending on the dylib
anymore - you basically only need the binary produced by make, and can move it
between computers,...
now let's go back to the videoAVT directory (where this README.txt lives in).
you have to tell the build-process where to find includes and libraries
$ ./configure PKG_LIBPVAPI_CFLAGS="-I${AVTSDKPATH}/inc-pc/" PKG_LIBPVAPI_LIBS="-L${AVTSDKPATH}/lib-pc/x86/4.4/ -lPvAPI"
$ make
$ make install
$
you might have to adjust the exact flags: "x86" is for x86-architectures, you
might want to x64, ppc, arm or whatelse, depending on your hardware.
also the exact library version might be different (e.g. "4.4" only seems to
exists on x86 and x64); see what's there...
dynamic linking
---------------
dynamic linking has the advantage, that the resulting binary is smaller (because
the code from the SDK-library is kept somewhere else), and multiple binaries can
share the very same code. also it makes bugfixing easier, as only the dylib has
to be replaced.
now let's go back to the videoAVT directory (where this README.txt lives in).
you have to tell the build-process where to find includes and libraries
$ ./configure PKG_LIBPVAPI_CFLAGS="-I${AVTSDKPATH}/inc-pc/" PKG_LIBPVAPI_LIBS="-L${AVTSDKPATH}/bin-pc/x86 -lPvAPI"
$ make
$ make install
$
again, you might have to adjust the exact flags to fit your system.
loading
=======
the plugin is called gem_videoAVT.so (un*x) or gem_videoAVT.dll (w32).
it has to live in the same folder as the Gem-binary (Gem.pd_linux on linux,
Gem.pd_darwin on OSX, Gem.dll on w32) if you want to use it.
the "make install" should make sure of this, but it's always better to
double-check.
start "pd -lib Gem" and create a [pix_video] object.
on the Pd-console you should see something like that (among other things):
[pix_video]: backend #0='avt' : avt gige
the exact backend-# will depend on your system.
if no kline with backend 'avt' shows up, check both the Pd-console and the
stderr for hints, why the library couldn't be loaded.
if you have linked dynamically, then the dlinker might not find the libPvApi.so
libary
either add it's path to the LD_LIBRARY_PATH:
$ LD_LIBRARY_PATH=${AVTSDKPATH}/bin-pc/x86:${LD_LIBRARY_PATH} pd -lib Gem
$
or install this the .so file somewhere the linker can find it (/usr/local/lib)
and/or make sure the linker looks for this path via ld.so.conf
using
=====
once [pix_video] has been initialized with the AVT backend, you can start using
it.
you can specify the device via the GiGE cam's IP-address, it's UniqueID,
SerialString or DisplayName.
The UniqueID, should be specified in hexadecimal.
If several cameras share the same SerialString or DisplayName, the 'first' one
found will be used.
the address can be specified both as an IP or a host-name.
e.g.
[device 192.168.1.34(
or
[device gige1.local(
TODO
====
testing
i don't have access to a GiGE-camera; so the entire code is currently untested
colorspaces
currently only Mono8, Rgb24, Bgr24, Rgba32 & Bgra32 are supported

2
Gem/plugins/videoAVT/avt-videoplugin.pd Normal file
View file

@ -0,0 +1,2 @@
#N canvas 8 49 505 112 10;
#X text 89 47 Nothing special about this backend...;

0
Gem/plugins/videoAVT/avt.m4 Normal file
View file

27
Gem/plugins/videoAVT/configure.ac Normal file
View file

@ -0,0 +1,27 @@
AC_PREREQ(2.60)
AC_INIT([videoAVT],[0.1],[zmoelnig@iem.at], [], [http://gem.iem.at])
AC_CONFIG_AUX_DIR([.])
AC_CONFIG_MACRO_DIR([../../m4])
AM_INIT_AUTOMAKE([foreign])
AC_CONFIG_SRCDIR([videoAVT.cpp])
AC_CONFIG_HEADER([config.h])
AC_CONFIG_FILES([Makefile])
AC_PROG_CXX
AC_PROG_LIBTOOL
#AM_SANITY_CHECK
GEM_CHECK_RTE
AC_LANG(C++)
## check for AVT!
GEM_CHECK_LIB(libPvAPI,PvAPI,main,,,,[video input (Prosilica)])
AC_OUTPUT

568
Gem/plugins/videoAVT/videoAVT.cpp Normal file
View file

@ -0,0 +1,568 @@
////////////////////////////////////////////////////////
//
// GEM - Graphics Environment for Multimedia
//
// zmoelnig@iem.kug.ac.at
//
// Implementation file
//
// Copyright (c) 2010-2011 IOhannes m zmölnig. forum::für::umläute. IEM. zmoelnig@iem.at
// For information on usage and redistribution, and for a DISCLAIMER OF ALL
// WARRANTIES, see the file, "LICENSE.txt"
//
/////////////////////////////////////////////////////////
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include "videoAVT.h"
#include "plugins/PluginFactory.h"
#include <sstream>
#include <sys/types.h>
#ifdef _WIN32
# include <winsock.h>
#else
# include <sys/socket.h>
# include <netdb.h>
#endif
#include <errno.h>
using namespace gem::plugins;
#include "Gem/RTE.h"
#include "Gem/Exception.h"
#if 0
# define debug ::post
#else
# define debug
#endif
/////////////////////////////////////////////////////////
//
// videoAVT
//
/////////////////////////////////////////////////////////
// Constructor
//
/////////////////////////////////////////////////////////
#ifdef HAVE_AVT
#define MAX_CAMERA_LIST 20
REGISTER_VIDEOFACTORY("avt", videoAVT);
struct PvApiInitClass {
PvApiInitClass(void) {
unsigned long major=0, minor=0;
PvVersion(&major, &minor);
// post("Prosilica AVT SDK %d.%d", major, minor);
if(ePvErrResources==PvInitialize()) {
throw(GemException("unable to initialization PvAPI"));
}
}
virtual ~PvApiInitClass(void) {
PvUnInitialize();
}
};
videoAVT :: videoAVT() : videoBase("avt"),
m_grabber(NULL)
{
m_width=0;
m_height=0;
static PvApiInitClass paic;
int i=0;
for(i=0;i<AVT_FRAMESCOUNT;i++) {
m_frames[i].ImageBuffer = NULL;
m_frames[i].ImageBufferSize = 0;
}
provide("gige");
}
////////////////////////////////////////////////////////
// Destructor
//
/////////////////////////////////////////////////////////
videoAVT :: ~videoAVT()
{
close();
resizeFrames(0);
}
void videoAVT::resizeFrames(unsigned long int size) {
int i=0;
for(i=0;i<AVT_FRAMESCOUNT;i++) {
if(m_frames[i].ImageBuffer) {
unsigned char*frame=(unsigned char*)m_frames[i].ImageBuffer;
delete[]frame;
m_frames[i].ImageBuffer = NULL;
}
m_frames[i].ImageBufferSize = 0;
if(size) {
m_frames[i].ImageBuffer = new unsigned char[size];
if(m_frames[i].ImageBuffer)
m_frames[i].ImageBufferSize = size;
}
m_frames[0].AncillaryBuffer=NULL;
m_frames[0].AncillaryBufferSize=0;
}
}
////////////////////////////////////////////////////////
// frame grabber
//
/////////////////////////////////////////////////////////
bool videoAVT :: grabFrame() {
return true;
}
void videoAVT::grabbedFrame(const tPvFrame&pFrame) {
/* frame successfully grabbed -> convert it into a pixbuf */
bool success=true;
lock();
m_image.image.xsize=pFrame.Width;
m_image.image.ysize=pFrame.Height;
m_image.image.setCsizeByFormat(GL_RGBA);
m_image.image.reallocate();
switch(pFrame.Format) {
case(ePvFmtMono8) : m_image.image.fromGray((unsigned char *)pFrame.ImageBuffer);break;
// case(ePvFmtMono16): m_image.image.fromGray((unsigned short*)pFrame.ImageBuffer);break;
case(ePvFmtRgb24) : m_image.image.fromRGB ((unsigned char *)pFrame.ImageBuffer);break;
case(ePvFmtBgr24) : m_image.image.fromBGR ((unsigned char *)pFrame.ImageBuffer);break;
case(ePvFmtRgba32): m_image.image.fromRGBA((unsigned char *)pFrame.ImageBuffer);break;
case(ePvFmtBgra32): m_image.image.fromBGRA((unsigned char *)pFrame.ImageBuffer);break;
case(ePvFmtBayer8): case(ePvFmtBayer16): do {
unsigned char*data=m_image.image.data;
// PixelPadding is most likely plain wrong; need to test what it really means
PvUtilityColorInterpolate(&pFrame,
&data[chRed],
&data[chGreen],
&data[chBlue],
2, // PixelPadding (Alpha)
0 // LinePadding
);
} while(0);
break;
case (ePvFmtRgb48):
case(ePvFmtMono12Packed): case(ePvFmtBayer12Packed):
case (ePvFmtYuv411): case(ePvFmtYuv422): case(ePvFmtYuv444):
default:
// ouch
success=false;
}
if(success) {
m_image.image.upsidedown=true;
m_image.newimage=true;
}
unlock();
}
void videoAVT::grabCB(tPvFrame*pFrame) {
videoAVT*me=(videoAVT*)pFrame->Context[0];
if(me && ePvErrSuccess==pFrame->Status)
me->grabbedFrame(*pFrame);
// if the frame was completed we re-enqueue it
if(pFrame->Status != ePvErrUnplugged && pFrame->Status != ePvErrCancelled)
{
PvCaptureQueueFrame(me->m_grabber, pFrame, grabCB);
}
}
pixBlock* videoAVT::getFrame(void) {
if(!(m_haveVideo && m_capturing))return NULL;
lock();
return &m_image;
}
/////////////////////////////////////////////////////////
// openDevice
//
/////////////////////////////////////////////////////////
bool videoAVT :: openDevice(gem::Properties&props)
{
if(m_grabber)closeDevice();
unsigned long cameraNum=PvCameraCount();
tPvCameraInfo*cameraList=new tPvCameraInfo[cameraNum];
if(m_devicenum>=0) {
verbose(1, "AVT trying to open #%d of %d devices", m_devicenum, cameraNum);
if(cameraNum>m_devicenum && (cameraList[m_devicenum].PermittedAccess == ePvAccessMaster)) {
if (PvCameraOpen(cameraList[m_devicenum].UniqueId, ePvAccessMaster, &m_grabber) != ePvErrSuccess) {
m_grabber=NULL;
}
}
} else {
verbose(1, "AVT trying to open device '%s'", m_devicename.c_str());
/*
cameraList[i].SerialString,
cameraList[i].DisplayName,
cameraList[i].UniqueId,
IP
*/
unsigned long i=0;
errno=0;
const unsigned long uid=strtoul(m_devicename.c_str(), NULL, 0);
if(NULL==m_grabber && 0==errno) {
verbose(1, "checking UniqueID: 0x% 8x", uid);
for(i=0; i<cameraNum; i++) {
if(uid==cameraList[i].UniqueId && PvCameraOpen(cameraList[i].UniqueId, ePvAccessMaster, &m_grabber) == ePvErrSuccess) {
break;
}
}
}
if(NULL==m_grabber) {
verbose(1, "checking SerialString: %s", m_devicename.c_str());
for(i=0; i<cameraNum; i++) {
if(m_devicename==cameraList[i].SerialString && PvCameraOpen(cameraList[i].UniqueId, ePvAccessMaster, &m_grabber) == ePvErrSuccess) {
break;
}
}
}
if(NULL==m_grabber) {
verbose(1, "checking DisplayName: %s", m_devicename.c_str());
for(i=0; i<cameraNum; i++) {
if(m_devicename==cameraList[i].DisplayName && PvCameraOpen(cameraList[i].UniqueId, ePvAccessMaster, &m_grabber) == ePvErrSuccess) {
break;
}
}
}
if(NULL==m_grabber) {
struct addrinfo *result=NULL, *rp=NULL;
struct addrinfo hints;
memset(&hints, 0, sizeof(struct addrinfo));
hints.ai_family=PF_INET;
if(0==getaddrinfo(m_devicename.c_str(), NULL, NULL, &result)) {
unsigned long OldAddr=0;
for(rp=result; rp!=NULL; rp=rp->ai_next) {
struct sockaddr_in*ipv4 = (struct sockaddr_in*)result->ai_addr;
unsigned long IpAddr=ipv4->sin_addr.s_addr ; // byte order??
if(OldAddr==IpAddr)continue;
OldAddr=IpAddr;
verbose(1, "AVT trying to connect to %3d.%3d.%3d.%3d",
(IpAddr & 0x0FF),
(IpAddr & 0x0FF00)>>8,
(IpAddr & 0x0FF0000)>>16,
(IpAddr & 0xFF000000)>>24
);
if(ePvErrSuccess == PvCameraOpenByAddr(IpAddr, ePvAccessMaster, &m_grabber)) {
break;
}
m_grabber=NULL;
}
freeaddrinfo(result);
}
}
}
delete[]cameraList;
if(m_grabber) {
unsigned long FrameSize = 0;
if(!PvAttrUint32Get(m_grabber,"TotalBytesPerFrame",&FrameSize)) {
resizeFrames(FrameSize);
} else {
close();
}
}
return (NULL!=m_grabber);
}
/////////////////////////////////////////////////////////
// closeDevice
//
/////////////////////////////////////////////////////////
void videoAVT :: closeDevice() {
if(m_grabber)PvCameraClose(m_grabber);
m_grabber=NULL;
}
/////////////////////////////////////////////////////////
// startTransfer
//
/////////////////////////////////////////////////////////
bool videoAVT :: startTransfer()
{
PvCaptureStart(m_grabber);
if(!PvCommandRun(m_grabber,"AcquisitionStart")) {
error("AVT::AcquistionStart failed");
} else {
PvCaptureQueueFrame(m_grabber, &m_frames[0], grabCB);
}
return true;
}
/////////////////////////////////////////////////////////
// stopTransfer
//
/////////////////////////////////////////////////////////
bool videoAVT :: stopTransfer()
{
PvCaptureQueueClear(m_grabber);
if(!PvCommandRun(m_grabber,"AcquisitionStop")) {
error("AVT::AcquistionStop failed");
}
PvCaptureEnd(m_grabber);
return true;
}
std::vector<std::string> videoAVT::enumerate() {
std::vector<std::string> result;
unsigned long cameraNum=PvCameraCount();
tPvCameraInfo*cameraList=new tPvCameraInfo[cameraNum];
cameraNum = PvCameraList(cameraList,cameraNum,NULL);
unsigned long i = 0;
for (i = 0; i < cameraNum; i++) {
result.push_back(cameraList[i].DisplayName);
}
delete[]cameraList;
return result;
}
bool videoAVT::enumProperties(gem::Properties&readable,
gem::Properties&writeable) {
tPvAttrListPtr listPtr;
unsigned long listLength;
if (PvAttrList(m_grabber, &listPtr, &listLength) == ePvErrSuccess) {
for (int i = 0; i < listLength; i++) {
const char* attributeName = listPtr[i];
std::cerr <<"Attribute["<<i<<"]: " << attributeName << std::endl;
tPvAttributeInfo pInfo;
if(ePvErrSuccess==PvAttrInfo(m_grabber, attributeName, &pInfo)) {
std::string name=attributeName;
gem::any type;
switch (pInfo.Datatype) {
case ePvDatatypeUnknown:
case ePvDatatypeRaw:
continue;
case ePvDatatypeCommand:
// type=notype;
break;
case ePvDatatypeString:
type=std::string("string");
break;
case ePvDatatypeEnum:
//PvAttrRangeEnum
type=0;
break;
case ePvDatatypeUint32:
//PvAttrRangeUint32
type=0;
break;
case ePvDatatypeFloat32:
//PvAttrRangeFloat32
type=0;
break;
case ePvDatatypeInt64:
//PvAttrRangeInt64
type=0;
break;
case ePvDatatypeBoolean:
type=1;
break;
}
if((pInfo.Flags & ePvFlagRead) || (pInfo.Flags & ePvFlagConst)) {
readable.set(name, type);
}
if(pInfo.Flags & ePvFlagWrite) {
writeable.set(name, type);
}
}
}
}
return true;
}
void videoAVT::setProperties(gem::Properties&props){
int i;
std::vector<std::string>keys=props.keys();
for(i=0; i<keys.size(); i++) {
tPvAttributeInfo pInfo;
std::string key=keys[i];
if(ePvErrSuccess!=PvAttrInfo(m_grabber, key.c_str(), &pInfo))
continue;
if(!(pInfo.Flags & ePvFlagWrite)) {
continue;
}
std::string s;
double d;
switch (pInfo.Datatype) {
default:
continue;
case ePvDatatypeCommand:
// type=notype;
break;
case ePvDatatypeString:
if(props.get(key, s)) {
PvAttrStringSet(m_grabber, key.c_str(), s.c_str());
}
break;
case ePvDatatypeEnum:
if(props.get(key, s)) {
PvAttrEnumSet(m_grabber, key.c_str(), s.c_str());
}
#if 0
else if(props.get(key, d)) {
std::vector<std::string>sv;
int index=d;
if(index<0)continue;
if (PvAttrRangeEnum(m_camera, "AcquisitionMode",
enumSet, sizeof(enumSet), NULL) == ePvErrSuccess) {
char* member = strtok(enumSet, ","); // strtok isn't always thread safe!
while (member != NULL) {
sv.push_back(member);
member = strtok(NULL, ",");
}
if(index>=sv.size()) {
continue;
}
PvAttrEnumSet(m_grabber, key.c_str(), sv[index].c_str());
}
#endif
break;
case ePvDatatypeUint32:
if(props.get(key, d)) {
tPvUint32 v=d;
PvAttrUint32Set(m_grabber, key.c_str(), d);
}
break;
case ePvDatatypeFloat32:
if(props.get(key, d)) {
tPvFloat32 v=d;
PvAttrFloat32Set(m_grabber, key.c_str(), d);
}
break;
case ePvDatatypeInt64:
if(props.get(key, d)) {
tPvInt64 v=d;
PvAttrInt64Set(m_grabber, key.c_str(), d);
}
break;
case ePvDatatypeBoolean:
if(props.get(key, d)) {
tPvBoolean v=d;
PvAttrBooleanSet(m_grabber, key.c_str(), d);
}
break;
}
} // loop
}
void videoAVT::getProperties(gem::Properties&props) {
int i;
std::vector<std::string>keys=props.keys();
for(i=0; i<keys.size(); i++) {
tPvAttributeInfo pInfo;
std::string key=keys[i];
if(ePvErrSuccess!=PvAttrInfo(m_grabber, key.c_str(), &pInfo))
continue;
if(!(pInfo.Flags & ePvFlagRead)) {
continue;
}
std::string s;
double d;
char svalue[MAXPDSTRING];
unsigned long size;
props.erase(key);
switch (pInfo.Datatype) {
default:
continue;
case ePvDatatypeString:
if (ePvErrSuccess==PvAttrStringGet(m_grabber, key.c_str(), svalue, MAXPDSTRING, &size)) {
s=svalue;
props.set(key, s);
}
break;
case ePvDatatypeEnum:
if (ePvErrSuccess==PvAttrEnumGet(m_grabber, key.c_str(), svalue, MAXPDSTRING, &size)) {
s=svalue;
props.set(key, s);
}
break;
case ePvDatatypeUint32: {
tPvUint32 value;
if (ePvErrSuccess==PvAttrUint32Get(m_grabber, key.c_str(), &value)) {
props.set(key, static_cast<double>(value));
}
}
break;
case ePvDatatypeFloat32: {
tPvFloat32 value;
if (ePvErrSuccess==PvAttrFloat32Get(m_grabber, key.c_str(), &value)) {
props.set(key, static_cast<double>(value));
}
}
break;
case ePvDatatypeInt64: {
tPvInt64 value;
if (ePvErrSuccess==PvAttrInt64Get(m_grabber, key.c_str(), &value)) {
props.set(key, static_cast<double>(value));
}
}
break;
case ePvDatatypeBoolean: {
tPvBoolean value;
if (ePvErrSuccess==PvAttrBooleanGet(m_grabber, key.c_str(), &value)) {
props.set(key, static_cast<double>(value));
}
}
break;
}
} // loop
}
#else
videoAVT :: videoAVT() : videoBase("")
{ }
videoAVT :: ~videoAVT()
{ }
#endif /* HAVE_AVT */

126
Gem/plugins/videoAVT/videoAVT.h Normal file
View file

@ -0,0 +1,126 @@
/*-----------------------------------------------------------------
GEM - Graphics Environment for Multimedia
video backend for Gem
Copyright (c) 2010-2011 IOhannes m zmölnig. forum::für::umläute. IEM. zmoelnig@iem.at
For information on usage and redistribution, and for a DISCLAIMER OF ALL
WARRANTIES, see the file, "GEM.LICENSE.TERMS" in this distribution.
Linux version by Miller Puckette. msp@ucsd.edu
-----------------------------------------------------------------*/
#ifndef _INCLUDE_GEMPLUGIN__VIDEOAVT_VIDEOAVT_H_
#define _INCLUDE_GEMPLUGIN__VIDEOAVT_VIDEOAVT_H_
#include "plugins/videoBase.h"
#if defined HAVE_LIBPVAPI
# define HAVE_AVT
#endif
#ifdef HAVE_AVT
/* olala, Prosilica re-invents the wheel and uses non-standard defines for OSs */
# ifdef __linux__
# define _LINUX
# endif
# ifdef __APPLE__
# define _OSX
# endif
// _QNX
/* Prosilica's ARCH defines */
# if !defined(_x86) && (defined(_X86_) || defined(__i386__) || defined(__i586__) || defined(__i686__))
# define _x86 1
# endif
# if !defined(_ppc) && ( defined(__ppc__))
# define _ppc 1
# endif
/* Prosilica decided to use "Status" as a field-name, but it gets defined to "int" in /usr/include/X11/Xlib.h */
#ifdef Status
# undef Status
#endif
# include "PvApi.h"
#endif
/*-----------------------------------------------------------------
-------------------------------------------------------------------
CLASS
videoAVT
Grabs in a video
KEYWORDS
pix
DESCRIPTION
support for the "AVT GiGE SDK" by Prosilica
-----------------------------------------------------------------*/
namespace gem { namespace plugins {
class GEM_EXPORT videoAVT : public videoBase {
public:
//////////
// Constructor
videoAVT(void);
//////////
// Destructor
virtual ~videoAVT(void);
#ifdef HAVE_AVT
////////
// open the video-device
virtual bool openDevice(gem::Properties&props);
virtual void closeDevice(void);
//////////
// Start up the video device
// [out] int - returns 0 if bad
virtual bool startTransfer(void);
//////////
// Stop the video device
// [out] int - returns 0 if bad
virtual bool stopTransfer(void);
//////////
// get the next frame
virtual bool grabFrame(void);
virtual std::vector<std::string>enumerate(void);
//////////
// properties
virtual bool enumProperties(gem::Properties&readable,
gem::Properties&writeable);
virtual void setProperties(gem::Properties&writeprops);
virtual void getProperties(gem::Properties&readprops);
protected:
tPvHandle m_grabber;
#define AVT_FRAMESCOUNT 4
tPvFrame m_frames[AVT_FRAMESCOUNT];
pixBlock* getFrame(void);
virtual void grabbedFrame(const tPvFrame&);
static void grabCB(tPvFrame*);
virtual void resizeFrames(unsigned long int);
#endif /* HAVE_AVT */
};
};};
#endif // for header file

21
Gem/plugins/videoAVT/win-vs2003/videoAVT.sln Normal file
View file

@ -0,0 +1,21 @@
Microsoft Visual Studio Solution File, Format Version 8.00
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "videoAVT", "videoAVT.vcproj", "{FF21A158-2BDE-483F-85C3-80C9DF0A0ABC}"
ProjectSection(ProjectDependencies) = postProject
EndProjectSection
EndProject
Global
GlobalSection(SolutionConfiguration) = preSolution
Release = Release
ReleaseDummy = ReleaseDummy
EndGlobalSection
GlobalSection(ProjectConfiguration) = postSolution
{FF21A158-2BDE-483F-85C3-80C9DF0A0ABC}.Release.ActiveCfg = Release|Win32
{FF21A158-2BDE-483F-85C3-80C9DF0A0ABC}.Release.Build.0 = Release|Win32
{FF21A158-2BDE-483F-85C3-80C9DF0A0ABC}.ReleaseDummy.ActiveCfg = ReleaseDummy|Win32
{FF21A158-2BDE-483F-85C3-80C9DF0A0ABC}.ReleaseDummy.Build.0 = ReleaseDummy|Win32
EndGlobalSection
GlobalSection(ExtensibilityGlobals) = postSolution
EndGlobalSection
GlobalSection(ExtensibilityAddIns) = postSolution
EndGlobalSection
EndGlobal

146
Gem/plugins/videoAVT/win-vs2003/videoAVT.vcproj Normal file
View file

@ -0,0 +1,146 @@
<?xml version="1.0" encoding="Windows-1252"?>
<VisualStudioProject
ProjectType="Visual C++"
Version="7.10"
Name="videoAVT"
ProjectGUID="{FF21A158-2BDE-483F-85C3-80C9DF0A0ABC}"
RootNamespace="gem"
SccProjectName=""
SccLocalPath="">
<Platforms>
<Platform
Name="Win32"/>
</Platforms>
<Configurations>
<Configuration
Name="Release|Win32"
OutputDirectory="$(SolutionDir)"
IntermediateDirectory="$(ProjectDir)/$(ConfigurationName)"
ConfigurationType="2"
UseOfMFC="0"
ATLMinimizesCRunTimeLibraryUsage="FALSE">
<Tool
Name="VCCLCompilerTool"
GlobalOptimizations="TRUE"
InlineFunctionExpansion="2"
FavorSizeOrSpeed="1"
OptimizeForProcessor="2"
AdditionalIncludeDirectories="&quot;$(SolutionDir)\..\..\src&quot;;&quot;$(ProjectDir)\..\..\src&quot;;&quot;$(ProjectDir)\..\..\..\..\pd\src&quot;;&quot;$(ProgramFiles)\pd\src&quot;;&quot;$(AVTROOT)\include&quot;;&quot;$(AVTROOT)\include\cpp&quot;"
PreprocessorDefinitions="NT;WIN32;_WINDOWS;__WIN32__;_LANGUAGE_C_PLUS_PLUS;WIN32_LEAN_AND_MEAN;HAVE_AVT"
StringPooling="TRUE"
RuntimeLibrary="2"
EnableFunctionLevelLinking="TRUE"
EnableEnhancedInstructionSet="0"
DefaultCharIsUnsigned="FALSE"/>
<Tool
Name="VCCustomBuildTool"/>
<Tool
Name="VCLinkerTool"
AdditionalOptions="/MACHINE:I386"
AdditionalDependencies="Gem.lib pd.lib OLDNAMES.lib PvAPI.lib"
OutputFile="$(OutDir)/gem_$(ProjectName).dll"
LinkIncremental="1"
AdditionalLibraryDirectories="&quot;$(SolutionDir)&quot;;&quot;$(ProjectDir)\..\..\build\win-vs2003&quot;;&quot;$(ProjectDir)\..\..\..\..\pd\bin&quot;;&quot;$(ProgramFiles)\pd\bin&quot;;&quot;$(AVTROOT)\lib\$(AVTARCH)&quot;"
ProgramDatabaseFile="$(ProjectDir)/$(ProjectName).pdb"
ImportLibrary="$(ProjectDir)/$(TargetName).lib"/>
<Tool
Name="VCMIDLTool"
PreprocessorDefinitions="NDEBUG"
MkTypLibCompatible="TRUE"
SuppressStartupBanner="TRUE"
TargetEnvironment="1"
TypeLibraryName=".\./gem.tlb"/>
<Tool
Name="VCPostBuildEventTool"/>
<Tool
Name="VCPreBuildEventTool"/>
<Tool
Name="VCPreLinkEventTool"/>
<Tool
Name="VCResourceCompilerTool"
PreprocessorDefinitions="NDEBUG"
Culture="1033"/>
<Tool
Name="VCWebServiceProxyGeneratorTool"/>
<Tool
Name="VCXMLDataGeneratorTool"/>
<Tool
Name="VCWebDeploymentTool"/>
<Tool
Name="VCManagedWrapperGeneratorTool"/>
<Tool
Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
</Configuration>
<Configuration
Name="ReleaseDummy|Win32"
OutputDirectory="$(SolutionDir)"
IntermediateDirectory="$(ProjectDir)/$(ConfigurationName)"
ConfigurationType="2"
UseOfMFC="0"
ATLMinimizesCRunTimeLibraryUsage="FALSE">
<Tool
Name="VCCLCompilerTool"
GlobalOptimizations="TRUE"
InlineFunctionExpansion="2"
FavorSizeOrSpeed="1"
OptimizeForProcessor="2"
AdditionalIncludeDirectories="&quot;$(SolutionDir)\..\..\src&quot;;&quot;$(ProjectDir)\..\..\src&quot;;&quot;$(ProjectDir)\..\..\..\..\pd\src&quot;;&quot;$(ProgramFiles)\pd\src&quot;"
PreprocessorDefinitions="NT;WIN32;_WINDOWS;__WIN32__;_LANGUAGE_C_PLUS_PLUS;WIN32_LEAN_AND_MEAN"
StringPooling="TRUE"
RuntimeLibrary="2"
EnableFunctionLevelLinking="TRUE"
EnableEnhancedInstructionSet="0"
DefaultCharIsUnsigned="FALSE"/>
<Tool
Name="VCCustomBuildTool"/>
<Tool
Name="VCLinkerTool"
AdditionalOptions="/MACHINE:I386"
AdditionalDependencies="Gem.lib pd.lib OLDNAMES.lib"
OutputFile="$(OutDir)/gem_$(ProjectName).dll"
LinkIncremental="1"
AdditionalLibraryDirectories="&quot;$(SolutionDir)&quot;;&quot;$(ProjectDir)\..\..\build\win-vs2003&quot;;&quot;$(ProjectDir)\..\..\..\..\pd\bin&quot;;&quot;$(ProgramFiles)\pd\bin&quot;"
ProgramDatabaseFile="$(ProjectDir)/$(ProjectName).pdb"
ImportLibrary="$(ProjectDir)/$(TargetName).lib"/>
<Tool
Name="VCMIDLTool"
PreprocessorDefinitions="NDEBUG"
MkTypLibCompatible="TRUE"
SuppressStartupBanner="TRUE"
TargetEnvironment="1"
TypeLibraryName=".\./gem.tlb"/>
<Tool
Name="VCPostBuildEventTool"/>
<Tool
Name="VCPreBuildEventTool"/>
<Tool
Name="VCPreLinkEventTool"/>
<Tool
Name="VCResourceCompilerTool"
PreprocessorDefinitions="NDEBUG"
Culture="1033"/>
<Tool
Name="VCWebServiceProxyGeneratorTool"/>
<Tool
Name="VCXMLDataGeneratorTool"/>
<Tool
Name="VCWebDeploymentTool"/>
<Tool
Name="VCManagedWrapperGeneratorTool"/>
<Tool
Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
</Configuration>
</Configurations>
<References>
</References>
<Files>
<File
RelativePath="..\videoAVT.cpp">
</File>
<File
RelativePath="..\videoAVT.h">
</File>
</Files>
<Globals>
</Globals>
</VisualStudioProject>

21
Gem/plugins/videoAVT/win-vs2008/videoAVT.sln Normal file
View file

@ -0,0 +1,21 @@
Microsoft Visual Studio Solution File, Format Version 8.00
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "videoAVT", "videoAVT.vcproj", "{FF21A158-2BDE-483F-85C3-80C9DF0A0ABC}"
ProjectSection(ProjectDependencies) = postProject
EndProjectSection
EndProject
Global
GlobalSection(SolutionConfiguration) = preSolution
Release = Release
ReleaseDummy = ReleaseDummy
EndGlobalSection
GlobalSection(ProjectConfiguration) = postSolution
{FF21A158-2BDE-483F-85C3-80C9DF0A0ABC}.Release.ActiveCfg = Release|Win32
{FF21A158-2BDE-483F-85C3-80C9DF0A0ABC}.Release.Build.0 = Release|Win32
{FF21A158-2BDE-483F-85C3-80C9DF0A0ABC}.ReleaseDummy.ActiveCfg = ReleaseDummy|Win32
{FF21A158-2BDE-483F-85C3-80C9DF0A0ABC}.ReleaseDummy.Build.0 = ReleaseDummy|Win32
EndGlobalSection
GlobalSection(ExtensibilityGlobals) = postSolution
EndGlobalSection
GlobalSection(ExtensibilityAddIns) = postSolution
EndGlobalSection
EndGlobal

146
Gem/plugins/videoAVT/win-vs2008/videoAVT.vcproj Normal file
View file

@ -0,0 +1,146 @@
<?xml version="1.0" encoding="Windows-1252"?>
<VisualStudioProject
ProjectType="Visual C++"
Version="7.10"
Name="videoAVT"
ProjectGUID="{FF21A158-2BDE-483F-85C3-80C9DF0A0ABC}"
RootNamespace="gem"
SccProjectName=""
SccLocalPath="">
<Platforms>
<Platform
Name="Win32"/>
</Platforms>
<Configurations>
<Configuration
Name="Release|Win32"
OutputDirectory="$(SolutionDir)"
IntermediateDirectory="$(ProjectDir)/$(ConfigurationName)"
ConfigurationType="2"
UseOfMFC="0"
ATLMinimizesCRunTimeLibraryUsage="FALSE">
<Tool
Name="VCCLCompilerTool"
GlobalOptimizations="TRUE"
InlineFunctionExpansion="2"
FavorSizeOrSpeed="1"
OptimizeForProcessor="2"
AdditionalIncludeDirectories="&quot;$(SolutionDir)\..\..\src&quot;;&quot;$(ProjectDir)\..\..\src&quot;;&quot;$(ProjectDir)\..\..\..\..\pd\src&quot;;&quot;$(ProgramFiles)\pd\src&quot;;&quot;$(AVTROOT)\include&quot;;&quot;$(AVTROOT)\include\cpp&quot;"
PreprocessorDefinitions="NT;WIN32;_WINDOWS;__WIN32__;_LANGUAGE_C_PLUS_PLUS;WIN32_LEAN_AND_MEAN;HAVE_AVT"
StringPooling="TRUE"
RuntimeLibrary="2"
EnableFunctionLevelLinking="TRUE"
EnableEnhancedInstructionSet="0"
DefaultCharIsUnsigned="FALSE"/>
<Tool
Name="VCCustomBuildTool"/>
<Tool
Name="VCLinkerTool"
AdditionalOptions="/MACHINE:I386"
AdditionalDependencies="Gem.lib pd.lib PvAPI.lib"
OutputFile="$(OutDir)/gem_$(ProjectName).dll"
LinkIncremental="1"
AdditionalLibraryDirectories="&quot;$(SolutionDir)&quot;;&quot;$(ProjectDir)\..\..\build\win-vs2003&quot;;&quot;$(ProjectDir)\..\..\..\..\pd\bin&quot;;&quot;$(ProgramFiles)\pd\bin&quot;;&quot;$(AVTROOT)\lib\$(AVTARCH)&quot;"
ProgramDatabaseFile="$(ProjectDir)/$(ProjectName).pdb"
ImportLibrary="$(ProjectDir)/$(TargetName).lib"/>
<Tool
Name="VCMIDLTool"
PreprocessorDefinitions="NDEBUG"
MkTypLibCompatible="TRUE"
SuppressStartupBanner="TRUE"
TargetEnvironment="1"
TypeLibraryName=".\./gem.tlb"/>
<Tool
Name="VCPostBuildEventTool"/>
<Tool
Name="VCPreBuildEventTool"/>
<Tool
Name="VCPreLinkEventTool"/>
<Tool
Name="VCResourceCompilerTool"
PreprocessorDefinitions="NDEBUG"
Culture="1033"/>
<Tool
Name="VCWebServiceProxyGeneratorTool"/>
<Tool
Name="VCXMLDataGeneratorTool"/>
<Tool
Name="VCWebDeploymentTool"/>
<Tool
Name="VCManagedWrapperGeneratorTool"/>
<Tool
Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
</Configuration>
<Configuration
Name="ReleaseDummy|Win32"
OutputDirectory="$(SolutionDir)"
IntermediateDirectory="$(ProjectDir)/$(ConfigurationName)"
ConfigurationType="2"
UseOfMFC="0"
ATLMinimizesCRunTimeLibraryUsage="FALSE">
<Tool
Name="VCCLCompilerTool"
GlobalOptimizations="TRUE"
InlineFunctionExpansion="2"
FavorSizeOrSpeed="1"
OptimizeForProcessor="2"
AdditionalIncludeDirectories="&quot;$(SolutionDir)\..\..\src&quot;;&quot;$(ProjectDir)\..\..\src&quot;;&quot;$(ProjectDir)\..\..\..\..\pd\src&quot;;&quot;$(ProgramFiles)\pd\src&quot;"
PreprocessorDefinitions="NT;WIN32;_WINDOWS;__WIN32__;_LANGUAGE_C_PLUS_PLUS;WIN32_LEAN_AND_MEAN"
StringPooling="TRUE"
RuntimeLibrary="2"
EnableFunctionLevelLinking="TRUE"
EnableEnhancedInstructionSet="0"
DefaultCharIsUnsigned="FALSE"/>
<Tool
Name="VCCustomBuildTool"/>
<Tool
Name="VCLinkerTool"
AdditionalOptions="/MACHINE:I386"
AdditionalDependencies="Gem.lib pd.lib"
OutputFile="$(OutDir)/gem_$(ProjectName).dll"
LinkIncremental="1"
AdditionalLibraryDirectories="&quot;$(SolutionDir)&quot;;&quot;$(ProjectDir)\..\..\build\win-vs2003&quot;;&quot;$(ProjectDir)\..\..\..\..\pd\bin&quot;;&quot;$(ProgramFiles)\pd\bin&quot;"
ProgramDatabaseFile="$(ProjectDir)/$(ProjectName).pdb"
ImportLibrary="$(ProjectDir)/$(TargetName).lib"/>
<Tool
Name="VCMIDLTool"
PreprocessorDefinitions="NDEBUG"
MkTypLibCompatible="TRUE"
SuppressStartupBanner="TRUE"
TargetEnvironment="1"
TypeLibraryName=".\./gem.tlb"/>
<Tool
Name="VCPostBuildEventTool"/>
<Tool
Name="VCPreBuildEventTool"/>
<Tool
Name="VCPreLinkEventTool"/>
<Tool
Name="VCResourceCompilerTool"
PreprocessorDefinitions="NDEBUG"
Culture="1033"/>
<Tool
Name="VCWebServiceProxyGeneratorTool"/>
<Tool
Name="VCXMLDataGeneratorTool"/>
<Tool
Name="VCWebDeploymentTool"/>
<Tool
Name="VCManagedWrapperGeneratorTool"/>
<Tool
Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
</Configuration>
</Configurations>
<References>
</References>
<Files>
<File
RelativePath="..\videoAVT.cpp">
</File>
<File
RelativePath="..\videoAVT.h">
</File>
</Files>
<Globals>
</Globals>
</VisualStudioProject>