- Reestructuración de ficheros y directorios general
- 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
parent
c9adfd020b
commit
e85d191b46
3100 changed files with 775434 additions and 3073 deletions
35
Gem/plugins/recordV4L/Makefile.am
Normal file
35
Gem/plugins/recordV4L/Makefile.am
Normal file
|
|
@ -0,0 +1,35 @@
|
|||
|
||||
ACLOCAL_AMFLAGS = -I $(top_srcdir)/m4
|
||||
AM_CPPFLAGS = -I$(top_srcdir)/src @GEM_EXTERNAL_CPPFLAGS@
|
||||
|
||||
pkglib_LTLIBRARIES =
|
||||
if HAVE_V4L
|
||||
pkglib_LTLIBRARIES+= gem_recordV4L.la
|
||||
endif
|
||||
|
||||
gem_recordV4L_la_CXXFLAGS =
|
||||
gem_recordV4L_la_LDFLAGS = -module -avoid-version -shared
|
||||
if WINDOWS
|
||||
gem_recordV4L_la_LDFLAGS += -no-undefined
|
||||
endif
|
||||
gem_recordV4L_la_LIBADD =
|
||||
|
||||
# RTE
|
||||
gem_recordV4L_la_CXXFLAGS += @GEM_RTE_CFLAGS@ @GEM_ARCH_CXXFLAGS@
|
||||
gem_recordV4L_la_LDFLAGS += @GEM_RTE_LIBS@ @GEM_ARCH_LDFLAGS@
|
||||
# flags for building Gem externals
|
||||
gem_recordV4L_la_CXXFLAGS += @GEM_EXTERNAL_CFLAGS@
|
||||
gem_recordV4L_la_LIBADD += -L$(top_builddir) @GEM_EXTERNAL_LIBS@
|
||||
# gem_recordV4L_la @MOREFLAGS@
|
||||
|
||||
# Dependencies
|
||||
gem_recordV4L_la_CXXFLAGS += @GEM_LIB_LIBV4L1_CFLAGS@
|
||||
gem_recordV4L_la_LIBADD += @GEM_LIB_LIBV4L1_LIBS@
|
||||
|
||||
# convenience symlinks
|
||||
include $(srcdir)/../symlink_ltlib.mk
|
||||
|
||||
|
||||
### SOURCES
|
||||
gem_recordV4L_la_SOURCES= recordV4L.cpp recordV4L.h
|
||||
|
||||
480
Gem/plugins/recordV4L/recordV4L.cpp
Normal file
480
Gem/plugins/recordV4L/recordV4L.cpp
Normal file
|
|
@ -0,0 +1,480 @@
|
|||
////////////////////////////////////////////////////////
|
||||
//
|
||||
// GEM - Graphics Environment for Multimedia
|
||||
//
|
||||
// zmoelnig@iem.kug.ac.at
|
||||
//
|
||||
// Implementation file
|
||||
//
|
||||
// Copyright (c) 1997-1999 Mark Danks.
|
||||
// Copyright (c) Günther Geiger.
|
||||
// Copyright (c) 2001-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.
|
||||
//
|
||||
/////////////////////////////////////////////////////////
|
||||
#ifdef HAVE_CONFIG_H
|
||||
# include "config.h"
|
||||
#endif
|
||||
|
||||
#include "recordV4L.h"
|
||||
|
||||
#ifdef HAVE_VIDEO4LINUX
|
||||
|
||||
#include "Gem/Manager.h"
|
||||
#include "plugins/PluginFactory.h"
|
||||
|
||||
using namespace gem::plugins;
|
||||
|
||||
#include "Gem/Exception.h"
|
||||
|
||||
#include <sys/types.h>
|
||||
#include <sys/stat.h>
|
||||
#include <fcntl.h>
|
||||
#include <sys/ioctl.h>
|
||||
#include <stdio.h>
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <unistd.h>
|
||||
|
||||
REGISTER_RECORDFACTORY("V4L", recordV4L);
|
||||
/////////////////////////////////////////////////////////
|
||||
//
|
||||
// recordV4L
|
||||
//
|
||||
/////////////////////////////////////////////////////////
|
||||
// Constructor
|
||||
//
|
||||
/////////////////////////////////////////////////////////
|
||||
|
||||
recordV4L :: recordV4L(void):
|
||||
m_fd(-1),
|
||||
m_init(false),
|
||||
m_palette(0)
|
||||
{
|
||||
m_image.xsize=720;
|
||||
m_image.xsize=576;
|
||||
m_image.setCsizeByFormat(GL_YUV422_GEM);
|
||||
m_image.setCsizeByFormat(GL_RGBA);
|
||||
m_image.reallocate();
|
||||
|
||||
switch(m_image.format) {
|
||||
case GL_YUV422_GEM: m_palette = VIDEO_PALETTE_YUV422; break;
|
||||
case GL_LUMINANCE: m_palette = VIDEO_PALETTE_GREY; break;
|
||||
case GL_RGBA: m_palette = VIDEO_PALETTE_RGB32; break;
|
||||
default: throw(GemException("invalid colorspace"));
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////
|
||||
// Destructor
|
||||
//
|
||||
/////////////////////////////////////////////////////////
|
||||
recordV4L :: ~recordV4L(void)
|
||||
{
|
||||
stop();
|
||||
}
|
||||
|
||||
void recordV4L :: stop(void)
|
||||
{
|
||||
if(m_fd>=0)
|
||||
::close(m_fd);
|
||||
m_fd=-1;
|
||||
|
||||
}
|
||||
|
||||
bool recordV4L :: start(const std::string filename, gem::Properties&props)
|
||||
{
|
||||
stop();
|
||||
|
||||
m_fd=::open(filename.c_str(), O_RDWR);
|
||||
if(m_fd<0)return false;
|
||||
|
||||
struct video_picture vid_pic;
|
||||
if (ioctl(m_fd, VIDIOCGPICT, &vid_pic) == -1) {
|
||||
perror("VIDIOCGPICT");
|
||||
stop(); return false;
|
||||
}
|
||||
vid_pic.palette = m_palette;
|
||||
if (ioctl(m_fd, VIDIOCSPICT, &vid_pic) == -1) {
|
||||
perror("VIDIOCSPICT");
|
||||
stop(); return false;
|
||||
}
|
||||
|
||||
struct video_window vid_win;
|
||||
if (ioctl(m_fd, VIDIOCGWIN, &vid_win) == -1) {
|
||||
perror("(VIDIOCGWIN)");
|
||||
stop(); return false;
|
||||
}
|
||||
|
||||
m_init=false;
|
||||
return true;
|
||||
}
|
||||
|
||||
bool recordV4L::init(const imageStruct* dummyImage, const int framedur) {
|
||||
if(m_init)return true;
|
||||
if(m_fd<0)return false;
|
||||
|
||||
unsigned int w=dummyImage->xsize;
|
||||
unsigned int h=dummyImage->ysize;
|
||||
|
||||
struct video_picture vid_pic;
|
||||
struct video_window vid_win;
|
||||
|
||||
if (ioctl(m_fd, VIDIOCGPICT, &vid_pic) == -1) {
|
||||
perror("VIDIOCGPICT");
|
||||
stop(); return false;
|
||||
}
|
||||
|
||||
vid_pic.palette = m_palette;
|
||||
|
||||
if (ioctl(m_fd, VIDIOCSPICT, &vid_pic) == -1) {
|
||||
perror("VIDIOCSPICT");
|
||||
stop(); return false;
|
||||
}
|
||||
|
||||
if (ioctl(m_fd, VIDIOCGWIN, &vid_win) == -1) {
|
||||
perror("ioctl (VIDIOCGWIN)");
|
||||
stop(); return false;
|
||||
}
|
||||
|
||||
vid_win.width = w;
|
||||
vid_win.height = h;
|
||||
if (ioctl(m_fd, VIDIOCSWIN, &vid_win) == -1) {
|
||||
perror("ioctl (VIDIOCSWIN)");
|
||||
stop(); return false;
|
||||
}
|
||||
|
||||
m_image.xsize=w;
|
||||
m_image.ysize=h;
|
||||
m_image.reallocate();
|
||||
|
||||
m_init=true;
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/////////////////////////////////////////////////////////
|
||||
// do the actual encoding and writing to file
|
||||
//
|
||||
/////////////////////////////////////////////////////////
|
||||
bool recordV4L :: write(imageStruct*img)
|
||||
{
|
||||
if(!m_init){
|
||||
if(!init(img, 0))
|
||||
return false;
|
||||
}
|
||||
m_image.convertFrom(img);
|
||||
|
||||
// m_image.upsidedown=!m_image.upsidedown;
|
||||
m_image.fixUpDown();
|
||||
|
||||
int size=m_image.xsize*m_image.ysize*m_image.csize;
|
||||
|
||||
::write(m_fd, m_image.data, size);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/////////////////////////////////////////////////////////
|
||||
// get number of codecs
|
||||
//
|
||||
/////////////////////////////////////////////////////////
|
||||
|
||||
static const std::string s_codec_name=std::string("v4l");
|
||||
static const std::string s_codec_desc=std::string("v4l(1) loopback device");
|
||||
|
||||
/////////////////////////////////////////////////////////
|
||||
// set codec by name
|
||||
//
|
||||
/////////////////////////////////////////////////////////
|
||||
bool recordV4L :: setCodec(const std::string name)
|
||||
{
|
||||
if(name==s_codec_name)
|
||||
return true;
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/////////////////////////////////////////////////////////
|
||||
// get codecs
|
||||
//
|
||||
/////////////////////////////////////////////////////////
|
||||
std::vector<std::string>recordV4L::getCodecs(void) {
|
||||
std::vector<std::string>result;
|
||||
result.push_back(s_codec_name);
|
||||
return result;
|
||||
}
|
||||
const std::string recordV4L::getCodecDescription(const std::string codec) {
|
||||
std::string result;
|
||||
if(codec==s_codec_name)
|
||||
result=s_codec_desc;
|
||||
return result;
|
||||
}
|
||||
|
||||
bool recordV4L::enumProperties(gem::Properties&props) {
|
||||
props.clear();
|
||||
return false;
|
||||
}
|
||||
|
||||
#endif /* V4L */
|
||||
|
||||
#if 0
|
||||
/* handler for ioctls from the client */
|
||||
static int v4l_ioctlhandler(unsigned long int cmd, void *arg)
|
||||
{
|
||||
switch(cmd) {
|
||||
|
||||
/* capabilities */
|
||||
case VIDIOCGCAP: {
|
||||
struct video_capability *vidcap = arg;
|
||||
|
||||
snprintf(vidcap->name, 32, "Gem vloopback output");
|
||||
vidcap->type = VID_TYPE_CAPTURE;
|
||||
vidcap->channels = 1;
|
||||
vidcap->audios = 0;
|
||||
vidcap->maxwidth = MAX_WIDTH;
|
||||
vidcap->maxheight = MAX_HEIGHT;
|
||||
vidcap->minwidth = MIN_WIDTH;
|
||||
vidcap->minheight = MIN_HEIGHT;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* channel info (rather limited */
|
||||
case VIDIOCGCHAN: {
|
||||
struct video_channel *vidchan = arg;
|
||||
|
||||
if(vidchan->channel != 0)
|
||||
return EINVAL;
|
||||
vidchan->flags = 0;
|
||||
vidchan->tuners = 0;
|
||||
vidchan->type = VIDEO_TYPE_CAMERA;
|
||||
strncpy(vidchan->name, "Gem", 32);
|
||||
return 0;
|
||||
}
|
||||
/* setting channel (we only have one) */
|
||||
case VIDIOCSCHAN: {
|
||||
int *v = arg;
|
||||
if(v[0] != 0)
|
||||
return EINVAL;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* getting picture properties */
|
||||
case VIDIOCGPICT: {
|
||||
struct video_picture *vidpic = arg;
|
||||
|
||||
vidpic->colour = 0xffff;
|
||||
vidpic->hue = 0xffff;
|
||||
vidpic->brightness = 0xffff;
|
||||
vidpic->contrast = 0xffff;
|
||||
vidpic->whiteness = 0xffff;
|
||||
vidpic->depth = pixel_depth;
|
||||
vidpic->palette = pixel_format;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* setting picture properties: we just ignore this */
|
||||
/* LATER: don't we have to set the vidpic to the "real" values? */
|
||||
case VIDIOCSPICT: {
|
||||
struct video_picture *vidpic = arg;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
case VIDIOCGWIN: {
|
||||
struct video_window *vidwin = arg;
|
||||
|
||||
vidwin->x = 0;
|
||||
vidwin->y = 0;
|
||||
vidwin->width = vloopback_width;
|
||||
vidwin->height = vloopback_height;
|
||||
vidwin->chromakey = 0;
|
||||
vidwin->flags = 0;
|
||||
vidwin->clipcount = 0;
|
||||
}
|
||||
|
||||
case VIDIOCSWIN: {
|
||||
struct video_window *vidwin = arg;
|
||||
|
||||
if(vidwin->width > MAX_WIDTH || vidwin->height > MAX_HEIGHT)
|
||||
return EINVAL;
|
||||
if(vidwin->width < MIN_WIDTH || vidwin->height < MIN_HEIGHT)
|
||||
return EINVAL;
|
||||
if(vidwin->flags)
|
||||
return EINVAL;
|
||||
vloopback_width = vidwin->width;
|
||||
vloopback_height = vidwin->height;
|
||||
return 0;
|
||||
}
|
||||
|
||||
case VIDIOCSYNC: {
|
||||
int frame = *(int *)arg;
|
||||
int ret = 0;
|
||||
|
||||
if(frame < 0 || frame > 1)
|
||||
return EINVAL;
|
||||
gbuf_lock();
|
||||
switch(gbufstat[frame]) {
|
||||
case GBUFFER_UNUSED:
|
||||
ret = 0;
|
||||
break;
|
||||
case GBUFFER_GRABBING:
|
||||
while(gbufstat[frame] == GBUFFER_GRABBING) {
|
||||
pthread_cond_wait(&gbufcond, &gbufmutex);
|
||||
}
|
||||
if(gbufstat[frame] == GBUFFER_DONE) {
|
||||
gbufstat[frame] = GBUFFER_UNUSED;
|
||||
ret = 0;
|
||||
} else {
|
||||
gbufstat[frame] = GBUFFER_UNUSED;
|
||||
ret = EIO;
|
||||
}
|
||||
break;
|
||||
case GBUFFER_DONE:
|
||||
gbufstat[frame] = GBUFFER_UNUSED;
|
||||
ret = 0;
|
||||
break;
|
||||
case GBUFFER_ERROR:
|
||||
default:
|
||||
gbufstat[frame] = GBUFFER_UNUSED;
|
||||
ret = EIO;
|
||||
break;
|
||||
}
|
||||
gbuf_unlock();
|
||||
return ret;
|
||||
}
|
||||
|
||||
case VIDIOCMCAPTURE: {
|
||||
struct video_mmap *vidmmap = arg;
|
||||
|
||||
if(vidmmap->width > MAX_WIDTH || vidmmap->height > MAX_HEIGHT) {
|
||||
fprintf(stderr, "vloopback: requested capture size is too big(%dx%d).\n",vidmmap->width, vidmmap->height);
|
||||
return EINVAL;
|
||||
}
|
||||
if(vidmmap->width < MIN_WIDTH || vidmmap->height < MIN_HEIGHT) {
|
||||
fprintf(stderr, "vloopback: requested capture size is to small(%dx%d).\n",vidmmap->width, vidmmap->height);
|
||||
return EINVAL;
|
||||
}
|
||||
if(vidmmap->format != pixel_format) {
|
||||
converter = palette_get_supported_converter_fromRGB32(vidmmap->format);
|
||||
if(converter == NULL) {
|
||||
fprintf(stderr, "vloopback: unsupported pixel format(%d) is requested.\n",vidmmap->format);
|
||||
return EINVAL;
|
||||
}
|
||||
pixel_format = vidmmap->format;
|
||||
}
|
||||
if(vidmmap->frame > 1 || vidmmap->frame < 0)
|
||||
return EINVAL;
|
||||
vloopback_width = vidmmap->width;
|
||||
vloopback_height = vidmmap->height;
|
||||
|
||||
if(gbufstat[vidmmap->frame] != GBUFFER_UNUSED) {
|
||||
if(gbufqueue[0] == vidmmap->frame || gbufqueue[1] == vidmmap->frame) {
|
||||
return EBUSY;
|
||||
}
|
||||
}
|
||||
gbuf_lock();
|
||||
gbufstat[vidmmap->frame] = GBUFFER_GRABBING;
|
||||
if(gbufqueue[0] < 0) {
|
||||
gbufqueue[0] = vidmmap->frame;
|
||||
} else {
|
||||
gbufqueue[1] = vidmmap->frame;
|
||||
}
|
||||
gbuf_unlock();
|
||||
return 0;
|
||||
}
|
||||
|
||||
case VIDIOCGMBUF: {
|
||||
struct video_mbuf *vidmbuf = arg;
|
||||
|
||||
vidmbuf->size = max_gbufsize;
|
||||
vidmbuf->frames = 2;
|
||||
vidmbuf->offsets[0] = 0;
|
||||
vidmbuf->offsets[1] = max_framesize;
|
||||
return 0;
|
||||
}
|
||||
|
||||
default:
|
||||
{
|
||||
return EPERM;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static int signal_loop_init(void)
|
||||
{
|
||||
outputfd = open(output_devname, O_RDWR);
|
||||
if(outputfd < 0) {
|
||||
fprintf(stderr, "vloopback: couldn't open output device file %s\n",output_devname);
|
||||
return -1;
|
||||
}
|
||||
pixel_format = VIDEO_PALETTE_RGB32;
|
||||
pixel_depth = 4;
|
||||
converter = palette_get_supported_converter_fromRGB32(pixel_format);
|
||||
vloopback_width = screen_width;
|
||||
vloopback_height = screen_height;
|
||||
max_framesize = vloopback_width * vloopback_height * sizeof(RGB32);
|
||||
max_gbufsize = max_framesize * 2;
|
||||
gbuf = vloopback_mmap(outputfd, max_gbufsize);
|
||||
gbuf_clear();
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void *signal_loop(void *arg)
|
||||
{
|
||||
int signo;
|
||||
int size, ret;
|
||||
struct pollfd ufds;
|
||||
sigset_t sigset;
|
||||
unsigned long int cmd;
|
||||
|
||||
if(signal_loop_init()) {
|
||||
signal_loop_initialized = -1;
|
||||
return NULL;
|
||||
}
|
||||
signal_loop_initialized = 1;
|
||||
|
||||
sigemptyset(&sigset);
|
||||
sigaddset(&sigset, SIGIO);
|
||||
while(signal_loop_thread_flag) {
|
||||
sigwait(&sigset, &signo);
|
||||
if(signo != SIGIO)
|
||||
continue;
|
||||
ufds.fd = outputfd;
|
||||
ufds.events = POLLIN;
|
||||
ufds.revents = 0;
|
||||
poll(&ufds, 1, 1000);
|
||||
if(!ufds.revents & POLLIN) {
|
||||
fprintf(stderr, "vloopback: received signal but got negative on poll.\n");
|
||||
continue;
|
||||
}
|
||||
size = read(outputfd, ioctlbuf, MAXIOCTL);
|
||||
if(size >= sizeof(unsigned long int)) {
|
||||
memcpy(&cmd, ioctlbuf, sizeof(unsigned long int));
|
||||
if(cmd == 0) {
|
||||
fprintf(stderr, "vloopback: client closed device.\n");
|
||||
gbuf_lock();
|
||||
gbuf_clear();
|
||||
gbuf_unlock();
|
||||
continue;
|
||||
}
|
||||
ret = v4l_ioctlhandler(cmd, ioctlbuf+sizeof(unsigned long int));
|
||||
if(ret) {
|
||||
/* new vloopback patch supports a way to return EINVAL to
|
||||
* a client. */
|
||||
memset(ioctlbuf+sizeof(unsigned long int), 0xff, MAXIOCTL-sizeof(unsigned long int));
|
||||
fprintf(stderr, "vloopback: ioctl %lx unsuccessfully handled.\n", cmd);
|
||||
ioctl(outputfd, VIDIOCSINVALID);
|
||||
}
|
||||
if(ioctl(outputfd, cmd, ioctlbuf+sizeof(unsigned long int))) {
|
||||
fprintf(stderr, "vloopback: ioctl %lx unsuccessfull.\n", cmd);
|
||||
}
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
#endif
|
||||
113
Gem/plugins/recordV4L/recordV4L.h
Normal file
113
Gem/plugins/recordV4L/recordV4L.h
Normal file
|
|
@ -0,0 +1,113 @@
|
|||
/* -----------------------------------------------------------------
|
||||
|
||||
GEM - Graphics Environment for Multimedia
|
||||
|
||||
Load an digital video (like AVI, Mpeg, Quicktime) into a pix block
|
||||
(OS independant parent-class)
|
||||
|
||||
Copyright (c) 1997-1999 Mark Danks. mark@danks.org
|
||||
Copyright (c) Günther Geiger. geiger@epy.co.at
|
||||
Copyright (c) 2001-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.
|
||||
|
||||
-----------------------------------------------------------------*/
|
||||
|
||||
#ifndef _INCLUDE_GEMPLUGIN__RECORDV4L_RECORDV4L_H_
|
||||
#define _INCLUDE_GEMPLUGIN__RECORDV4L_RECORDV4L_H_
|
||||
|
||||
#include "plugins/record.h"
|
||||
|
||||
#if defined HAVE_LIBV4L1 || defined HAVE_LINUX_VIDEODEV_H
|
||||
# define HAVE_VIDEO4LINUX
|
||||
#endif
|
||||
|
||||
#if defined HAVE_LINUX_VIDEODEV_H
|
||||
# include <linux/videodev.h>
|
||||
#endif /* HAVE_LINUX_VIDEODEV_H */
|
||||
|
||||
#if defined HAVE_LIBV4L1
|
||||
# include <libv4l1.h>
|
||||
#endif /* HAVE_LIBV4L1 */
|
||||
|
||||
|
||||
/*---------------------------------------------------------------
|
||||
-------------------------------------------------------------------
|
||||
CLASS
|
||||
recordV4L
|
||||
|
||||
class for outputting video using a v4l loopback device
|
||||
|
||||
KEYWORDS
|
||||
pix record movie
|
||||
|
||||
DESCRIPTION
|
||||
|
||||
-----------------------------------------------------------------*/
|
||||
#if defined HAVE_VIDEO4LINUX
|
||||
|
||||
namespace gem { namespace plugins {
|
||||
class GEM_EXPORT recordV4L : public record {
|
||||
public:
|
||||
|
||||
//////////
|
||||
// Constructor
|
||||
|
||||
recordV4L(void);
|
||||
|
||||
////////
|
||||
// Destructor
|
||||
/* free what is apropriate */
|
||||
virtual ~recordV4L(void);
|
||||
|
||||
|
||||
//////////
|
||||
// close the movie file
|
||||
// stop recording, close the file and clean up temporary things
|
||||
virtual void stop(void);
|
||||
|
||||
//////////
|
||||
// open a movie up
|
||||
// open the recordV4L "filename" (think better about URIs ?)
|
||||
// returns TRUE if opening was successfull, FALSE otherwise
|
||||
virtual bool start(const std::string filename, gem::Properties&);
|
||||
|
||||
|
||||
//////////
|
||||
// initialize the encoder
|
||||
// dummyImage provides meta-information (e.g. size) that must not change during the encoding cycle
|
||||
// (if it does, abort the recording session)
|
||||
// framedur is the duration of one frame in [ms]
|
||||
//
|
||||
// returns TRUE if init was successfull, FALSE otherwise
|
||||
bool init(const imageStruct* dummyImage, const int framedur);
|
||||
|
||||
//////////
|
||||
// compress and write the next frame
|
||||
/* this is the core-function of this class !!!!
|
||||
* when called it returns something depending on success
|
||||
* (what? the framenumber and -1 (0?) on failure?)
|
||||
*/
|
||||
virtual bool write(imageStruct*);
|
||||
|
||||
virtual bool setCodec(const std::string);
|
||||
|
||||
/**
|
||||
* get a list of supported codecs (short-form names, e.g. "mjpa")
|
||||
*/
|
||||
virtual std::vector<std::string>getCodecs(void);
|
||||
virtual const std::string getCodecDescription(const std::string);
|
||||
virtual bool enumProperties(gem::Properties&);
|
||||
|
||||
virtual bool dialog(void) {return false;}
|
||||
|
||||
private:
|
||||
int m_fd;
|
||||
imageStruct m_image;
|
||||
bool m_init;
|
||||
int m_palette;
|
||||
};
|
||||
};};
|
||||
#endif /* V4L */
|
||||
|
||||
#endif // for header file
|
||||
Loading…
Add table
Add a link
Reference in a new issue