bool initParameters_(void) {
m_parameterNames.clear();
m_parameter.clear();
unsigned int count=getNumParameters_();
unsigned int i;
m_parameterNames.push_back(""); // dummy parameter
for(i=0; i<count; i++) {
std::string name=getParameterName_(i);
FFUInt32 type = getParameterType_ (i);
FFMixed def = getParameterDefault_(i);
gem::any val;
switch(type) {
case FF_TYPE_EVENT:
//?
break;
case FF_TYPE_TEXT:
val = std::string(reinterpret_cast<const char*>(def.PointerValue));
break;
default:
val = def.FloatValue;
}
std::cout << "param#"<<i<<": "<<name<<std::endl;
m_parameterNames.push_back(name);
m_parameter.set(name, val);
}
return true;
}
bool imageBase :: enumProperties(gem::Properties&readable,
gem::Properties&writeable)
{
readable.clear();
writeable.clear();
return false;
}
void videoVLC::setProperties(gem::Properties&props)
{
int width=-1;
int height=-1;
m_props=props;
double d;
if(props.get("width", d)) {
if(d>0) {
width = d;
}
}
if(props.get("height", d)) {
if(d>0) {
height=d;
}
}
if(!m_mediaplayer) {
if(width>0) {
m_pixBlock.image.xsize=width;
}
if(height>0) {
m_pixBlock.image.ysize=height;
}
} else {
// changes will take effect with next restart
}
}
static void addProperties(gem::Properties&props, int argc, t_atom*argv)
{
if(!argc)return;
if(argv->a_type != A_SYMBOL) {
::error("no key given...");
return;
}
std::string key=std::string(atom_getsymbol(argv)->s_name);
std::vector<gem::any> values;
argc--; argv++;
while(argc-->0) {
values.push_back(atom2any(argv++));
}
switch(values.size()) {
default:
props.set(key, values);
break;
case 1:
props.set(key, values[0]);
break;
case 0:
{
gem::any dummy;
props.set(key, dummy);
}
break;
}
}
bool videoUNICAP :: enumProperties(gem::Properties&readable,
gem::Properties&writeable) {
readable.clear();
writeable.clear();
if(m_handle) {
int count=0;
unicap_status_t status= unicap_reenumerate_properties(m_handle, &count );
if(!SUCCESS(status))
return false;
int id=0;
for(id=0; id<count; id++) {
unicap_property_t prop;
gem::any typ;
status = unicap_enumerate_properties(m_handle, NULL, &prop, id);
if(!SUCCESS(status))
continue;
debugPost("id='%s'\tcat='%s'\tunit='%s'\tflags=%d",
prop.identifier,
prop.category,
prop.unit,
prop.flags);
switch(prop.type) {
case UNICAP_PROPERTY_TYPE_RANGE:
debugPost("range %f-%f", prop.range.min, prop.range.min);
typ=prop.range.max;
break;
case UNICAP_PROPERTY_TYPE_VALUE_LIST:
debugPost("value_list %d", prop.value_list.value_count);
typ=prop.value_list.value_count;
break;
case UNICAP_PROPERTY_TYPE_MENU:
debugPost("menu '%s' of %d", prop.menu_item, prop.menu.menu_item_count);
typ=std::string(prop.menu_item);//prop.menu.menu_item_count;
break;
case UNICAP_PROPERTY_TYPE_FLAGS:
debugPost("flags");
break;
default:
debugPost("unknown");
// ?
break;
}
readable.set(prop.identifier, typ);
if(!(prop.flags & UNICAP_FLAGS_READ_ONLY))
writeable.set(prop.identifier, typ);
#warning check UNICAP_FLAGS_ON_OFF & UNICAP_FLAGS_ONE_PUSH
}
}
return true;
}
void imageBase :: getProperties(gem::Properties&props) {
// nada
std::vector<std::string>keys=props.keys();
unsigned int i=0;
for(i=0; i<keys.size(); i++) {
gem::any unset;
props.set(keys[i], unset);
}
}
void setParameters(gem::Properties&parms) {
unsigned int i=0;
for(i=0; i<m_parameterNames.size(); i++) {
std::string key=m_parameterNames[i];
std::string s1, s2;
double d1, d2;
switch(m_parameter.type(key)) {
case gem::Properties::NONE:
if(gem::Properties::NONE==parms.type(key)) {
parms.erase(key);
setParameter(i);
}
break;
case gem::Properties::DOUBLE:
if(m_parameter.get(key, d1) && parms.get(key, d2)) {
if(d1!=d2) {
m_parameter.set(key, d2);
setParameter(i, d2);
}
}
break;
case gem::Properties::STRING:
if(m_parameter.get(key, s1) && parms.get(key, s2)) {
if(s1!=s2) {
m_parameter.set(key, s2);
setParameter(i, s2);
}
}
break;
default: break;
}
}
}
void imageMAGICK::getWriteCapabilities(std::vector<std::string>&mimetypes, gem::Properties&props) {
mimetypes.clear();
props.clear();
mimetypes = m_mimetypes;
gem::any value;
value=100.f;
props.set("quality", value);
}
void imageJPEG::getWriteCapabilities(std::vector<std::string>&mimetypes, gem::Properties&props) {
mimetypes.clear();
props.clear();
mimetypes.push_back("image/jpeg");
mimetypes.push_back("image/pjpeg");
gem::any value;
value=100.f;
props.set("quality", value);
}
bool videoVFW :: enumProperties(gem::Properties&readable, gem::Properties&writeable) {
readable.clear();
writeable.clear();
gem::any type=0;
writeable.set("width", type);
writeable.set("height", type);
return true;
}
void videoDECKLINK::getProperties(gem::Properties&props)
{
std::vector<std::string>keys=props.keys();
unsigned int i;
for(i=0; i<keys.size(); i++) {
if("width"==keys[i]) {
props.set(keys[i], m_pixBlock.image.xsize);
}
if("height"==keys[i]) {
props.set(keys[i], m_pixBlock.image.ysize);
}
}
}
void modelASSIMP3 :: setProperties(gem::Properties&props) {
double d;
#if 0
std::vector<std::string>keys=props.keys();
unsigned int i;
for(i=0; i<keys.size(); i++) {
post("key[%d]=%s ... %d", i, keys[i].c_str(), props.type(keys[i]));
}
#endif
std::string s;
if(props.get("textype", s)) {
// if there are NO texcoords, we only accept 'linear' and 'spheremap'
// else, we also allow 'UV'
// not-accepted textype, simply use the last one
if(m_have_texcoords && "UV" == s)
m_textype = "";
else
if(("linear" == s) || ("spheremap" == s))
m_textype = s;
m_rebuild = true;
}
if(props.get("rescale", d)) {
bool b=(bool)d;
if(b) {
float tmp;
tmp = m_max.x-m_min.x;
tmp = aisgl_max(m_max.y - m_min.y,tmp);
tmp = aisgl_max(m_max.z - m_min.z,tmp);
m_scale = 2.f / tmp;
m_offset.x=-m_center.x;
m_offset.y=-m_center.y;
m_offset.z=-m_center.z;
} else {
// FIXXME shouldn't this be the default???
m_scale=1.;
m_offset.x=m_offset.y=m_offset.z=0.f;
}
}
if(props.get("usematerials", d)) {
bool useMaterial=d;
if(useMaterial!=m_useMaterial)
m_rebuild=true;
m_useMaterial=useMaterial;
}
render();
}
void imageQT::getWriteCapabilities(std::vector<std::string>&mimetypes, gem::Properties&props) {
mimetypes.clear();
props.clear();
std::map<std::string, OSType>::iterator it;
for(it = s_mime2type.begin(); it!=s_mime2type.end(); ++it) {
mimetypes.push_back(it->first);
}
gem::any value;
value=100.f;
props.set("quality", value);
}
float imageTIFF::estimateSave(const imageStruct&img, const std::string&filename, const std::string&mimetype, const gem::Properties&props) {
float result=0;
if(mimetype == "image/tiff" || mimetype == "image/x-tiff")
result += 100;
if(gem::Properties::UNSET != props.type("xresolution"))result+=1.;
if(gem::Properties::UNSET != props.type("yresolution"))result+=1.;
if(gem::Properties::UNSET != props.type("resolutionunit"))result+=1.;
if(gem::Properties::UNSET != props.type("software"))result+=1.;
if(gem::Properties::UNSET != props.type("artist"))result+=1.;
if(gem::Properties::UNSET != props.type("hostcomputer"))result+=1.;
return result;
}
void filmTEST::getProperties(gem::Properties&props) {
std::vector<std::string> keys=props.keys();
unsigned int i=0;
for(i=0; i<keys.size(); i++) {
std::string key=keys[i];
props.erase(key);
#define SETPROP(k, v) } else if(k == key) { double d=(double)v; props.set(key, v)
if(""==key) {
SETPROP("fps", m_fps);
SETPROP("frames", m_numFrames);
SETPROP("width", m_image.image.xsize);
SETPROP("height", m_image.image.ysize);
}
}
}
virtual bool enumProperties(gem::Properties&readable,
gem::Properties&writeable) {
// LATER: shouldn't we merge properties of all handles?
#ifdef __GNUC__
# warning enumProperties stub
#endif
readable.clear();
writeable.clear();
if(m_handle)
return m_handle->enumProperties(readable, writeable);
return false;
}
void filmQT4L::setProperties(gem::Properties&props)
{
double d;
if(props.get("colorspace", d)) {
m_wantedFormat=d;
}
}
/////////////////////////////////////////////////////////
// really open the file ! (OS dependent)
//
/////////////////////////////////////////////////////////
bool filmQT4L :: open(const std::string&filename,
const gem::Properties&wantProps)
{
int wantedFormat=GEM_RGBA;
double d;
unsigned int format=0;
if(wantProps.get("format", d)) {
format=d;
}
switch(format) {
default:
break;
case GEM_RGBA:
case GEM_YUV:
case GEM_GRAY:
m_wantedFormat=format;
break;
}
char*cfilename=const_cast<char*>(filename.c_str());
if (quicktime_check_sig(cfilename)) { /* ok, this is quicktime */
if (!(m_quickfile = quicktime_open(filename.c_str(), 1, 0))) {
verbose(0, "[GEM:filmQT4L] Unable to open file: %s", filename.c_str());
return false;
}
m_curFrame = -1;
// Get the number of tracks
m_numTracks = quicktime_video_tracks(m_quickfile);
// Get the length of the movie (on track current track)
m_numFrames = quicktime_video_length(m_quickfile, m_curTrack);
// Get the frame-rate
m_fps = quicktime_frame_rate(m_quickfile, m_curTrack);
// Get the video dimensions
m_image.image.xsize = quicktime_video_width (m_quickfile, m_curTrack);
m_image.image.ysize = quicktime_video_height(m_quickfile, m_curTrack);
if (!quicktime_supported_video(m_quickfile, m_curTrack)) {
char *codec = quicktime_video_compressor(m_quickfile, m_curTrack);
verbose(0, "[GEM:filmQT4L] unsupported CODEC '%s'!", codec);
quicktime_close(m_quickfile);
m_quickfile=0;
return false;
}
m_image.image.setCsizeByFormat(wantedFormat);
m_image.image.reallocate();
m_qtimage.xsize=m_image.image.xsize;
m_qtimage.ysize=m_image.image.ysize;
m_qtimage.setCsizeByFormat(GEM_RGB);
m_qtimage.reallocate();
m_newfilm = true;
return true;
}
goto unsupported;
unsupported:
close();
return false;
}
void videoVFW :: setProperties(gem::Properties&props) {
double d;
bool dorestart=false;
if (props.get("width", d)) {
m_width=d;
dorestart=true;
}
if (props.get("height", d)) {
m_height=d;
dorestart=true;
}
if(dorestart && m_hWndC)
reset();
}
void filmQT4L::getProperties(gem::Properties&props) {
std::vector<std::string> keys=props.keys();
gem::any value;
double d;
unsigned int i=0;
for(i=0; i<keys.size(); i++) {
std::string key=keys[i];
props.erase(key);
if("fps"==key) {
d=m_fps;
value=d; props.set(key, value);
}
if("frames"==key) {
d=m_numFrames;
value=d; props.set(key, value);
}
if("tracks"==key) {
d=m_numTracks;
value=d; props.set(key, value);
}
if("width"==key) {
d=m_image.image.xsize;
value=d; props.set(key, value);
}
if("height"==key) {
d=m_image.image.ysize;
value=d; props.set(key, value);
}
}
}
virtual void getProperties(gem::Properties&props) {
std::vector<std::string> ids;
if(props.type("backends")!=gem::Properties::UNSET) {
unsigned int i;
for(i=0; i<m_ids.size(); i++) {
ids.push_back(m_ids[i]);
}
}
props.erase("backends");
if(m_handle)
m_handle->getProperties(props);
else
props.clear();
if(!ids.empty()) {
props.set("backends", ids);
}
}
bool imageMAGICK::save(const imageStruct&image, const std::string&filename, const std::string&mimetype, const gem::Properties&props) {
imageStruct*img=const_cast<imageStruct*>(&image);
imageStruct*pImage=img;
std::string cs;
switch(img->format) {
case GL_LUMINANCE:
cs="K";
break;
case GL_RGBA:
cs="RGBA";
break;
default:
pImage=new imageStruct();
pImage->convertFrom(img, GL_RGB);
case GL_RGB:
cs="RGB";
break;
case GL_BGRA_EXT:
cs="BGRA";
break;
}
try{
Magick::Image mimage(pImage->xsize, pImage->ysize, cs, Magick::CharPixel, pImage->data);
// since openGL is upside down
if(!pImage->upsidedown) {
mimage.flip();
}
// 8 bits per channel are enough!
// LATER make this dependent on the image->type
mimage.depth(8);
double quality;
if(props.get("quality", quality)) {
mimage.quality(quality);
}
try {
// finally convert and export
mimage.write(filename);
} catch (Magick::Warning e) {
verbose(1, "magick saving problem: %s", e.what());
}
} catch (Magick::Exception e){
error("%s", e.what());
if(pImage!=&image)delete pImage; pImage=NULL;
return false;
} catch (...) {
error("imageMAGICK:: uncaught exception!");
return false;
}
if(pImage!=&image)delete pImage; pImage=NULL;
return true;
}
float imageJPEG::estimateSave(const imageStruct&img, const std::string&filename, const std::string&mimetype, const gem::Properties&props) {
float result=0.;
if(mimetype == "image/jpeg")// || mimetype == "image/pjpeg")
result += 100.;
// LATER check some properties....
if(gem::Properties::UNSET != props.type("quality"))
result += 1.;
return result;
}
void imageBase :: setProperties(gem::Properties&props) {
// nada
m_properties=props;
#if 0
std::vector<std::string> keys=props.keys();
int i=0;
for(i=0; i<keys.size(); i++) {
enum gem::Properties::PropertyType typ=props.type(keys[i]);
std::cerr << "key["<<keys[i]<<"]: "<<typ<<" :: ";
switch(typ) {
case (gem::Properties::NONE):
props.erase(keys[i]);
break;
case (gem::Properties::DOUBLE):
std::cerr << gem::any_cast<double>(props.get(keys[i]));
break;
case (gem::Properties::STRING):
std::cerr << "'" << gem::any_cast<std::string>(props.get(keys[i])) << "'";
break;
default:
std::cerr << "<unknown:" << props.get(keys[i]).get_type().name() << ">";
break;
}
}
std::cerr << std::endl;
#endif
}
virtual bool open(const std::string&name, const gem::Properties&requestprops) {
if(m_handle)close();
std::vector<std::string> backends;
if(requestprops.type("backends")!=gem::Properties::UNSET) {
requestprops.get("backends", backends);
}
// requestprops.erase("backends");
bool tried=false;
if(!backends.empty()) {
unsigned int i, j;
for(j=0; !m_handle && j<backends.size(); j++) {
std::string id=backends[j];
for(i=0; i<m_handles.size(); i++) {
/* coverity[assign_where_compare_meant] we set 'tried' to true if we have found at least one matching backend */
if(id==m_ids[i]&& (tried=true) && m_handles[i]->open(name, requestprops)) {
m_handle=m_handles[i];
}
}
}
}
if(!m_handle && !tried) {
if(!backends.empty() && !m_handles.empty()) {
verbose(2, "no available loader selected, falling back to valid ones");
}
unsigned int i=0;
for(i=0; i<m_handles.size(); i++) {
if(m_handles[i] && m_handles[i]->open(name, requestprops)) {
m_handle=m_handles[i];
break;
} else {
}
}
}
return (NULL!=m_handle);
}
float imageQT::estimateSave(const imageStruct&img, const std::string&filename, const std::string&mimetype, const gem::Properties&props) {
float result=0.;
OSType filetype; // just a dummy
if(mime2type(mimetype, filetype))
result+=100.;
// LATER check some properties....
if(gem::Properties::UNSET != props.type("quality"))
result += 1.;
return result;
}
bool videoTEST::enumProperties(gem::Properties&readable,
gem::Properties&writeable) {
readable.clear();
writeable.clear();
writeable.set("width", 64); readable.set("width", 64);
writeable.set("height", 64); readable.set("height", 64);
writeable.set("type", std::string("noise"));
return true;
}
void videoOptiTrack::getProperties(gem::Properties&props)
{
std::vector<std::string>keys=props.keys();
double d;
std::string s;
props.clear();
if(!m_camera) {
return;
}
unsigned int i;
for(i=0; i<keys.size(); i++) {
const std::string key=keys[i];
if("width"==key) {
props.set(key, m_pixBlock.image.xsize);
continue;
}
if("height"==key) {
props.set(key, m_pixBlock.image.ysize);
continue;
}
if("fanspeed"==key && m_camera->IsCameraFanSpeedValid()) {
d=m_camera->CameraFanSpeed();
props.set(key, d);
continue;
}
if("temperature"==key && m_camera->IsCameraTempValid()) {
d=m_camera->CameraTemp();
props.set(key, d);
continue;
}
#define GETCAMERAPROP_BOOL(name) if(#name == key) {d=m_camera->##name(); props.set(key, d); continue; } else d=0
#define GETCAMERAPROP_INT(name) if(#name == key) {d=m_camera->##name(); props.set(key, d); continue; } else d=0
#define GETCAMERAPROP_STR(name) if(#name == key) {s=m_camera->##name(); props.set(key, s); continue; } else d=0
GETCAMERAPROP_BOOL(AEC);
GETCAMERAPROP_BOOL(AGC);
GETCAMERAPROP_BOOL(ContinuousIR);
GETCAMERAPROP_BOOL(HighPowerMode);
GETCAMERAPROP_BOOL(IRFilter);
GETCAMERAPROP_BOOL(MarkerOverlay);
GETCAMERAPROP_BOOL(TextOverlay);
GETCAMERAPROP_INT(Exposure);
GETCAMERAPROP_INT(FrameDecimation);
GETCAMERAPROP_INT(FrameRate);
GETCAMERAPROP_INT(GrayscaleDecimation);
GETCAMERAPROP_INT(Intensity);
GETCAMERAPROP_INT(PrecisionCap);
GETCAMERAPROP_INT(ShutterDelay);
GETCAMERAPROP_INT(Threshold);
GETCAMERAPROP_STR(Name);
#undef GETCAMERAPROP_BOOL
#undef GETCAMERAPROP_INT
#undef GETCAMERAPROP_STR
}
}
virtual void getWriteCapabilities(std::vector<std::string>&mimetypes, gem::Properties&props) {
mimetypes.clear();
props.clear();
unsigned int i;
for(i=0; i<m_savers.size(); i++) {
unsigned int j;
std::vector<std::string>mimetypes_;
gem::Properties props_;
m_savers[i]->getWriteCapabilities(mimetypes_, props_);
for(j=0; j<mimetypes_.size(); j++) {
const std::string&mimetype=mimetypes_[j];
if(std::find(mimetypes.begin(), mimetypes.end(), mimetype)==mimetypes.end()) {
mimetypes.push_back(mimetypes_[j]);
}
}
std::vector<std::string>keys=props_.keys();
for(j=0; j<keys.size(); j++) {
props.set(keys[j], props_.get(keys[j]));
}
}
}
float imageMAGICK::estimateSave(const imageStruct&image, const std::string&filename, const std::string&mimetype, const gem::Properties&props) {
float result=0.5; // slightly preference for MAGICK
int i;
for(i=0; i<m_mimetypes.size(); i++) {
if(mimetype==m_mimetypes[i]) {
result+=100.;
break;
}
}
if(gem::Properties::UNSET != props.type("quality"))
result += 1.;
return result;
}
