summaryrefslogtreecommitdiff
path: root/rotord
diff options
context:
space:
mode:
Diffstat (limited to 'rotord')
-rw-r--r--rotord/src/graph.cpp9
-rw-r--r--rotord/src/graph.h63
-rw-r--r--rotord/src/libavwrapper.cpp22
-rw-r--r--rotord/src/nodes_audio_analysis.cpp84
-rw-r--r--rotord/src/nodes_audio_analysis.h83
-rw-r--r--rotord/src/nodes_drawing.h7
-rw-r--r--rotord/src/rendercontext.cpp3
-rw-r--r--rotord/src/rotor.cpp315
-rw-r--r--rotord/src/rotor.h52
-rw-r--r--rotord/src/rotord.cpp14
-rw-r--r--rotord/src/rotord.h6
-rw-r--r--rotord/src/vampHost.cpp38
-rw-r--r--rotord/src/vampHost.h2
13 files changed, 447 insertions, 251 deletions
diff --git a/rotord/src/graph.cpp b/rotord/src/graph.cpp
index c33c59d..3f1d02b 100644
--- a/rotord/src/graph.cpp
+++ b/rotord/src/graph.cpp
@@ -566,9 +566,12 @@ bool Graph::load_audio(const string &filename,vector<Audio_processor*> processor
Logger& logger = Logger::get("Rotor");
logger.information("Analysing "+filename);
- audio_loaded=false;
+ //audio_loaded=false;
libav::audio_decoder loader;
- loader.open(filename);
+ if (!loader.open(filename)) {
+ logger.error("ERROR: Could not open audio: "+filename);
+ return false;
+ }
duration=loader.get_duration();
@@ -612,7 +615,7 @@ bool Graph::load_audio(const string &filename,vector<Audio_processor*> processor
}
logger.information("Finished audio analysis");
- audio_loaded=true;
+ //audio_loaded=true;
return true;
}
bool Graph::load_video(const string &nodeID,const string &filename){
diff --git a/rotord/src/graph.h b/rotord/src/graph.h
index 6f2ee79..ddf2471 100644
--- a/rotord/src/graph.h
+++ b/rotord/src/graph.h
@@ -97,6 +97,34 @@ namespace Rotor {
class Thumbnailer{
public:
bool make(const string &inputfilename,int w,int h,const string &outputfilename) {
+ //first try svg
+ RsvgHandle * rsvg=rsvg_handle_new_from_file(inputfilename.c_str(),nullptr);
+ if (rsvg) {
+ RsvgDimensionData dims;
+ rsvg_handle_get_dimensions(rsvg,&dims);
+ cerr<<"Rotor: SVG loaded "<<inputfilename<<" , "<<dims.width<<"x"<<dims.height<<endl;
+ cv::Mat cp=cv::Mat::zeros(h,w,CV_8UC4);
+ cv::Mat co=cv::Mat(h,w,CV_8UC3);
+ cairo_surface_t * cs = cairo_image_surface_create_for_data (cp.data,
+ CAIRO_FORMAT_RGB24,
+ w,
+ h,
+ w*4);
+ cairo_t * cr = cairo_create (cs);
+ cairo_translate(cr, w/2, h/2);
+ cairo_scale(cr, ((float)w)/640.0f,((float)w)/640.0f);
+ cairo_translate(cr, -w/2, -h/2);
+ cairo_translate(cr, w/2-(dims.width/2), h/2-(dims.height/2));
+ rsvg_handle_render_cairo(rsvg,cr);
+ cv::cvtColor(cp,co,CV_RGBA2BGR,3);
+ cv::imwrite(outputfilename.c_str(),co);
+ cairo_destroy(cr);
+ cairo_surface_destroy(cs);
+ rsvg_handle_close(rsvg,nullptr);
+ //g_object_unref(rsvg);
+ return true;
+ }
+ //if not svg feed to FFMS2
if (player.open(inputfilename)){
if (player.fetch_frame(w,h,player.get_number_frames()/4)) {
Image i;
@@ -105,9 +133,42 @@ namespace Rotor {
cvtColor(i.rgb,cp,CV_RGB2BGR);
cv::imwrite(outputfilename.c_str(),cp);
return true;
-
}
}
+ //fall back to audio
+ libav::audio_decoder loader;
+ if (loader.open(inputfilename)) {
+ Audio_thumbnailer at;
+ at.width=w;
+ at.height=h;
+ int rate = loader.get_sample_rate();
+ int samples = loader.get_number_samples();
+ int channels= loader.get_number_channels();
+ int bits = loader.get_bit_depth();
+ at.init(channels,bits,samples,rate);
+ bool finished=false;
+ uint16_t *audio=new uint16_t[1024*loader.get_number_channels()];
+ uint64_t sample=0;
+ while (loader.get_samples(audio,sample,1024)) {
+ at.process_frame((uint8_t*)audio,1024);
+ sample+=1024;
+ }
+ cv::Mat co=cv::Mat(h,w,CV_8UC3);
+ uchar op;
+ for (int i=0;i<h;i++){
+ uchar* r=co.ptr(i); //pointer to row
+ for (int j=0;j<w;j++){
+ //audio rms in 0..1 range
+ if (at.audiodata[j]>abs(((float)i-h/2)/(h/2))) op=0xFF;
+ else op=0x00;
+ r[j*3]=op/4;
+ r[j*3+1]=op;
+ r[j*3+2]=op/4;
+ }
+ }
+ cv::imwrite(outputfilename.c_str(),co);
+ return true;
+ }
return false;
}
private:
diff --git a/rotord/src/libavwrapper.cpp b/rotord/src/libavwrapper.cpp
index 26523fc..2ee9985 100644
--- a/rotord/src/libavwrapper.cpp
+++ b/rotord/src/libavwrapper.cpp
@@ -33,15 +33,25 @@ bool libav::video_decoder::open(const std::string& filename){
Mutex::ScopedLock lock(mutex);
loaded=false;
+ Poco::File f=Poco::File(filename);
+ if (!f.exists()) {
+ cerr<<"ERROR: "<<filename<<" does not exist"<<endl;
+ return false;
+ }
+
//first check if an index object exists
Poco::StringTokenizer tokens(filename,".");
string idxfile="";
- for (int i=0;i<tokens.count()-1;i++){
- idxfile+=tokens[i];
- idxfile+=".";
+ if (tokens.count()>1){
+ for (int i=0;i<tokens.count()-1;i++){
+ idxfile+=tokens[i];
+ idxfile+=".";
+ }
+ idxfile+="idx";
}
- idxfile+="idx";
- Poco::File f=Poco::File(idxfile);
+ else idxfile=filename+".idx";
+
+ f=Poco::File(idxfile);
bool makeindex=true;
FFMS_Index *index;
if (f.exists()) {
@@ -54,7 +64,7 @@ bool libav::video_decoder::open(const std::string& filename){
}
}
if (makeindex) {
- cerr<<"FFMS2: created index "<<idxfile<<endl;
+ cerr<<"FFMS2: creating index "<<idxfile<<endl;
index = FFMS_MakeIndex(filename.c_str(), 0, 0, NULL, NULL, FFMS_IEH_IGNORE, NULL, NULL, &err);
FFMS_WriteIndex(idxfile.c_str(),index,&err);
}
diff --git a/rotord/src/nodes_audio_analysis.cpp b/rotord/src/nodes_audio_analysis.cpp
index 220f14b..a2a9c63 100644
--- a/rotord/src/nodes_audio_analysis.cpp
+++ b/rotord/src/nodes_audio_analysis.cpp
@@ -83,11 +83,11 @@ namespace Rotor{
}
void Vamp_node::cleanup() {
analyser.cleanup();
- //print_features();
+ features=analyser.features;
}
string Vamp_node::get_features(){
string data;
- for (auto i: analyser.features) {
+ for (auto i: features) {
data=data+" ["+toString(i.second.number)+":"+toString(i.first);
if (i.second.values.size()) {
data+=" (";
@@ -105,4 +105,84 @@ namespace Rotor{
}
return data;
}
+ bool sortsegments(std::pair<int,float> i,std::pair<int,float> j){
+ return (i.second<j.second);
+ }
+ void Intensity_segmenter::cleanup(){
+ //algorithm idea:
+ //get average tempo and intensity for each segment and store them
+ //scale by the range to get a value from 0.0 to 1.0
+ //add tempo and intensity according to a weighting
+ //score the results (ie 1st place, 2nd place) to end up with a set of integer numbers
+
+ //for (auto a:analysers) a.second.cleanup(); //WHY NOT WORK - its as if the call is const
+ analysers["segmenter"].cleanup();
+ analysers["tempo"].cleanup();
+ analysers["intensity"].cleanup();
+ cerr<<analysers["segmenter"].features.size()<<" segments"<<endl;
+ cerr<<analysers["tempo"].features.size()<<" tempo features"<<endl;
+ cerr<<analysers["intensity"].features.size()<<" intensity features"<<endl;
+ int i=0;
+ float min_tempo=9999999.0f;
+ float min_intensity=9999999.0f;
+ float max_tempo=0.0f;
+ float max_intensity=0.0f;
+ vector<float> tempos;
+ vector<float> intensities;
+ vector<float> times;
+ auto g=++analysers["segmenter"].features.begin();
+ for (auto f=analysers["segmenter"].features.begin();g!=analysers["segmenter"].features.end();f++,g++,i++){
+ cerr<<"segment "<<i<<": "<<f->first<<" to "<<g->first<<endl;
+ times.push_back(f->first);
+ //integrate tempo and intensity algorithmically
+ float tempo=0;
+ if (analysers["tempo"].features.size()) {
+ float pt=f->first;
+ float pv=analysers["tempo"].get_value(f->first);
+ for (auto u=analysers["tempo"].features.upper_bound(f->first);u!=analysers["tempo"].features.upper_bound(g->first);u++){
+ tempo +=(u->first-pt)*(u->second.values[0]+pv)*0.5f; //area of the slice
+ pt=u->first;
+ pv=u->second.values[0];
+ }
+ tempo +=(g->first-pt)*(analysers["tempo"].get_value(g->first)+pv)*0.5f; //area of the last slice
+ tempo /=g->first-f->first; //average value;
+ }
+ if (tempo>max_tempo) max_tempo=tempo;
+ if (tempo<min_tempo) min_tempo=tempo;
+ tempos.push_back(tempo);
+ cerr<<"segment "<<i<<" average tempo: "<<tempo<<endl;
+
+ float intensity=0;
+ if (analysers["intensity"].features.size()) {
+ float pt=f->first;
+ float pv=analysers["intensity"].get_value(f->first);
+ for (auto u=analysers["intensity"].features.upper_bound(f->first);u!=analysers["intensity"].features.upper_bound(g->first);u++){
+ intensity +=(u->first-pt)*(u->second.values[0]+pv)*0.5f; //area of the slice
+ pt=u->first;
+ pv=u->second.values[0];
+ }
+ intensity +=(g->first-pt)*(analysers["intensity"].get_value(g->first)+pv)*0.5f; //area of the last slice
+ intensity /=g->first-f->first; //average value;
+ }
+ if (intensity>max_intensity) max_intensity=intensity;
+ if (intensity<min_intensity) min_intensity=intensity;
+ intensities.push_back(intensity);
+ cerr<<"segment "<<i<<" average intensity: "<<intensity<<endl;
+ }
+ //make relative scale 0.0-1.0 and save weighted totals
+ vector< pair<int,float>> totals;
+ for (i=0;i<tempos.size();i++){
+ tempos[i]=(tempos[i]-min_tempo)/(max_tempo-min_tempo);
+ intensities[i]=(intensities[i]-min_intensity)/(max_intensity-min_intensity);
+ totals.push_back(make_pair(i,(tempos[i]*parameters["tempo_weight"]->value)+(intensities[i]*parameters["intensity_weight"]->value)));
+ }
+ //sort and convert to features
+ std::sort(totals.begin(),totals.end(),sortsegments);
+ for (int i=0;i<totals.size();i++){
+ vampHost::feature f;
+ f.values.push_back((float)i);
+ features[times[totals[i].first]]=f;
+ }
+ return true;
+ }
} \ No newline at end of file
diff --git a/rotord/src/nodes_audio_analysis.h b/rotord/src/nodes_audio_analysis.h
index db33b1f..a3fe5b8 100644
--- a/rotord/src/nodes_audio_analysis.h
+++ b/rotord/src/nodes_audio_analysis.h
@@ -9,6 +9,18 @@ namespace Rotor {
#define VAMPHOST_Timesteps 2
#define VAMPHOST_Valueline 3
#define VAMPHOST_Values 4
+ class Audio_processor: public Signal_node {
+ public:
+ virtual Audio_processor(){};
+ virtual ~Audio_processor(){};
+ virtual int process_frame(uint8_t *data,int samples)=0;
+ virtual bool init(int _channels,int _bits,int _samples,int _rate)=0;
+ virtual void cleanup()=0;
+ virtual void print_summary(){};
+ virtual string get_features(){};
+ int channels,bits,samples,rate;
+ };
+ //actual nodes-------------------------------------------------
class Audio_thumbnailer: public Audio_processor {
public:
Audio_thumbnailer(){
@@ -43,9 +55,9 @@ namespace Rotor {
void cleanup();
int process_frame(uint8_t *data,int samples_in_frame);
const float output(const Time_spec &time) {
- if (analyser.features.size()) {
- auto i=analyser.features.upper_bound(time.time); //the first element in the container whose key is considered to go after k
- if (i!=analyser.features.end()){
+ if (features.size()) {
+ auto i=features.upper_bound(time.time); //the first element in the container whose key is considered to go after k
+ if (i!=features.end()){
float uk=i->first;
float v1,v2;
v1=v2=0.0f;
@@ -72,15 +84,15 @@ namespace Rotor {
}
string get_features();
void print_summary(){
- cerr<<"vamp plugin "<<id<<" of library "<<soname<<" found "<<analyser.features.size()<<" features "<<endl;
+ cerr<<"vamp plugin "<<id<<" of library "<<soname<<" found "<<features.size()<<" features "<<endl;
};
protected:
string soname,id;
- int outputNo;
- vampHost::Analyser analyser;
+ int outputNo;
map <string,float> params;
- private:
- //??
+ map<float,vampHost::feature> features;
+ private:
+ vampHost::Analyser analyser;
};
class Audio_analysis: public Vamp_node {
//vamp node that allows the user to choose a plugin
@@ -170,20 +182,20 @@ namespace Rotor {
vector<int> act_count;
for (int i=0;i<(int)parameters["acts"]->value;i++) act_count.push_back(0);
- if (analyser.features.size()<=(int)parameters["acts"]->value+1){
+ if (features.size()<=(int)parameters["acts"]->value+1){
//iteratively split segments and refresh durations
//this could work well on the original data
//pick the longest and split it in two
//refresh durations - this can be a function
//keep going
//finally copy out
- while (analyser.features.size()<(int)parameters["acts"]->value+1){
+ while (features.size()<(int)parameters["acts"]->value+1){
map<int,float> durations;
map<int,float> times;
int i=0;
- for (map<float,vampHost::feature>::iterator f=analyser.features.begin();f!=analyser.features.end();++f){
+ for (map<float,vampHost::feature>::iterator f=features.begin();f!=features.end();++f){
auto g=f;
- if (++g!=analyser.features.end()){
+ if (++g!=features.end()){
durations[i]=g->first-f->first;
times[i]=f->first;
}
@@ -197,10 +209,10 @@ namespace Rotor {
n=d.first;
}
}
- analyser.features[times[n]+(durations[n]/2)]=analyser.features[times[n]];
+ features[times[n]+(durations[n]/2)]=features[times[n]];
}
int j=0;
- for (auto f: analyser.features){
+ for (auto f: features){
f.second.number=j;
acts[f.first]=f.second;
j++;
@@ -216,7 +228,7 @@ namespace Rotor {
//start with a set of the segments numbers
//(the aim: to access the segment numbers by the time that they start)
- map<float,vampHost::feature> segments=analyser.features;
+ map<float,vampHost::feature> segments=features;
segments.erase(--segments.end());
//assign the acts from the beginning and end in towards the middle
@@ -260,8 +272,8 @@ namespace Rotor {
}
}
//add last item back on
- acts[(*--analyser.features.end()).first]=analyser.features[(*--analyser.features.end()).first];
- analyser.features=acts;
+ acts[(*--features.end()).first]=features[(*--features.end()).first];
+ features=acts;
}
private:
@@ -271,41 +283,40 @@ namespace Rotor {
public:
Intensity_segmenter(){
title="Intensity segmenter";
- description="Combines segmentation, tempo and intensity";
- UID="74e05d10-3ffa-11e3-b5f9-7335309da36a";
+ description="Combines the output of segmentation, tempo, and intensity analysis plugins";
+ UID="6ce236b6-4080-11e3-90b7-74d02b29f6a6";
analysers["segmenter"]=vampHost::Analyser();
analysers["tempo"]=vampHost::Analyser();
analysers["intensity"]=vampHost::Analyser();
+ create_parameter("intensity_weight","number","intensity weight","Intensity weighting",1.0f);
+ create_parameter("tempo_weight","number","tempo weight","Tempo weighting",1.0f);
};
Intensity_segmenter(map<string,string> &settings):Intensity_segmenter() {
base_settings(settings);
};
~Intensity_segmenter(){};
Intensity_segmenter* clone(map<string,string> &_settings) { return new Intensity_segmenter(_settings);};
- bool init(int _channels,int _bits,int _samples, int _rate) {
- //params needed?
- analysers["segmenter"].init("qm-vamp-plugins","qm-segmenter",_channels,_bits,_samples,_rate,0,params);
- analysers["tempo"].init("qm-vamp-plugins","qm-tempotracker",_channels,_bits,_samples,_rate,2,params);
- analysers["tempo"].init("bbc-vamp-plugins","bbc-intensity",_channels,_bits,_samples,_rate,0,params);
- return true;
+ bool init(int _channels,int _bits,int _samples,int _rate) {
+ return analysers["segmenter"].init("qm-vamp-plugins","qm-segmenter",_channels,_bits,_samples,_rate,0,params)\
+ &&analysers["tempo"].init("qm-vamp-plugins","qm-tempotracker",_channels,_bits,_samples,_rate,2,params)\
+ &&analysers["intensity"].init("bbc-vamp-plugins","bbc-intensity",_channels,_bits,_samples,_rate,0,params);
}
int process_frame(uint8_t *data,int samples_in_frame) {
- for (auto a:analysers) a.second.process_frame(data,samples_in_frame);
+ //for (auto a:analysers) a.second.process_frame(data,samples_in_frame); //WHY NOT WORK
+ analysers["segmenter"].process_frame(data,samples_in_frame);
+ analysers["tempo"].process_frame(data,samples_in_frame);
+ analysers["intensity"].process_frame(data,samples_in_frame);
return 1;
}
- void cleanup() {
- for (auto a:analysers) a.second.cleanup();
-
- for (auto f:analysers["segmenter"].features){
-
- }
- //add last item back on
- //acts[(*--analyser.features.end()).first]=analyser.features[(*--analyser.features.end()).first];
- //analyser.features=acts;
- }
+ void cleanup(); //all the fun happens here
+ void print_summary(){
+ cerr<<"Intensity segmenter found "<<features.size()<<" features "<<endl;
+ };
private:
map<string,vampHost::Analyser> analysers;
};
}
+
+
#endif
diff --git a/rotord/src/nodes_drawing.h b/rotord/src/nodes_drawing.h
index b26841e..f46c2b0 100644
--- a/rotord/src/nodes_drawing.h
+++ b/rotord/src/nodes_drawing.h
@@ -3,7 +3,6 @@
#include "rotor.h"
#include <cairo.h>
-#include <rsvg.h>
namespace Rotor {
class Draw_node: public Image_node {
@@ -217,6 +216,7 @@ namespace Rotor {
};
class Svg: public Draw_node {
public:
+ //rsvg should be cleanup?
Svg(){
title="SVG";
description="Draws svg files";
@@ -238,7 +238,10 @@ namespace Rotor {
}
else cerr<<"Rotor: SVG failed to load "<<attributes["filename"]->value<<endl;
};
- ~Svg(){};
+ ~Svg(){
+ rsvg_handle_close(rsvg,nullptr);
+ //g_object_unref(rsvg);
+ };
Svg* clone(map<string,string> &_settings) { return new Svg(_settings);};
void vector_output(cairo_t * cr,const Frame_spec &frame){
//to make it resolution independent
diff --git a/rotord/src/rendercontext.cpp b/rotord/src/rendercontext.cpp
index bba8d31..779a1b7 100644
--- a/rotord/src/rendercontext.cpp
+++ b/rotord/src/rendercontext.cpp
@@ -24,6 +24,7 @@ void Render_context::runTask() {
}
}
if (graph.load_audio(graph.audio_filename,processors)) {
+ graph.audio_loaded=false;
state=IDLE;
}
else {
@@ -428,7 +429,7 @@ void Render_context::session_command(const Session_command& command,xmlIO& XML,H
}
else {
status=HTTPResponse::HTTP_BAD_REQUEST;
- logger.error("ERROR: Could not print features for node "+features_node);
+ logger.error("ERROR: Could not print features for node /"+features_node+"/");
}
}
else {
diff --git a/rotord/src/rotor.cpp b/rotord/src/rotor.cpp
index 88284c9..840298e 100644
--- a/rotord/src/rotor.cpp
+++ b/rotord/src/rotor.cpp
@@ -19,61 +19,62 @@ Node_factory::Node_factory(){
//this can be hard coded also
//
- category["signals"]=vector<Node*>();
- add_type("time",new Time(),category["signals"]);
- add_type("track_time",new Track_time(),category["signals"]);
- add_type("at_track_time",new At_track_time(),category["signals"]);
+ category["Signals"]=vector<Node*>();
+ add_type("time",new Time(),category["Signals"]);
+ add_type("track_time",new Track_time(),category["Signals"]);
+ add_type("at_track_time",new At_track_time(),category["Signals"]);
//
add_type("signal_output",new Signal_output());
add_type("testcard",new Testcard());
//
- category["channels"]=vector<Node*>();
- add_type("invert",new Invert(),category["channels"]);
- add_type("monochrome",new Monochrome(),category["channels"]);
- add_type("blend",new Blend(),category["channels"]);
- add_type("image_arithmetic",new Image_arithmetic(),category["channels"]);
- add_type("alpha_merge",new Alpha_merge(),category["channels"]);
- add_type("difference_matte",new Difference_matte(),category["channels"]);
- add_type("rgb_levels",new RGB_levels(),category["channels"]);
- add_type("luma_levels",new Luma_levels(),category["channels"]);
+ category["Channels"]=vector<Node*>();
+ add_type("invert",new Invert(),category["Channels"]);
+ add_type("monochrome",new Monochrome(),category["Channels"]);
+ add_type("blend",new Blend(),category["Channels"]);
+ add_type("image_arithmetic",new Image_arithmetic(),category["Channels"]);
+ add_type("alpha_merge",new Alpha_merge(),category["Channels"]);
+ add_type("difference_matte",new Difference_matte(),category["Channels"]);
+ add_type("rgb_levels",new RGB_levels(),category["Channels"]);
+ add_type("luma_levels",new Luma_levels(),category["Channels"]);
- category["source"]=vector<Node*>();
- add_type("signal_colour",new Signal_colour(),category["source"]);
- add_type("signal_greyscale",new Signal_greyscale(),category["source"]);
- add_type("shape",new Shape(),category["source"]);
- add_type("text",new Text(),category["source"]);
- add_type("waves",new Waves(),category["source"]);
- add_type("still_image",new Still_image(),category["source"]);
- add_type("video_loader",new Video_loader(),category["source"]);
- add_type("svg",new Svg(),category["source"]);
+ category["Source"]=vector<Node*>();
+ add_type("signal_colour",new Signal_colour(),category["Source"]);
+ add_type("signal_greyscale",new Signal_greyscale(),category["Source"]);
+ add_type("shape",new Shape(),category["Source"]);
+ add_type("text",new Text(),category["Source"]);
+ add_type("waves",new Waves(),category["Source"]);
+ add_type("still_image",new Still_image(),category["Source"]);
+ add_type("video_loader",new Video_loader(),category["Source"]);
+ add_type("video_bank",new Video_bank(),category["Source"]);
+ add_type("svg",new Svg(),category["Source"]);
- category["distort"]=vector<Node*>();
- add_type("mirror",new Mirror(),category["distort"]);
- add_type("transform",new Transform(),category["distort"]);
+ category["Distort"]=vector<Node*>();
+ add_type("mirror",new Mirror(),category["Distort"]);
+ add_type("transform",new Transform(),category["Distort"]);
- category["editing"]=vector<Node*>();
- add_type("video_cycler",new Video_cycler(),category["editing"]);
- add_type("video_output",new Video_output(),category["editing"]);
- add_type("act_segmenter",new Act_segmenter(),category["editing"]);
+ category["Editing"]=vector<Node*>();
+ add_type("video_cycler",new Video_cycler(),category["Editing"]);
+ add_type("video_output",new Video_output(),category["Editing"]);
+ add_type("act_segmenter",new Act_segmenter(),category["Editing"]);
- category["audio"]=vector<Node*>();
- add_type("audio_analysis",new Audio_analysis(),category["audio"]);
- add_type("audio_analysis2",new Audio_analysis2(),category["audio"]);
- add_type("intensity_segmenter",new Intensity_segmenter(),category["audio"]);
+ category["Audio"]=vector<Node*>();
+ add_type("audio_analysis",new Audio_analysis(),category["Audio"]);
+ add_type("audio_analysis2",new Audio_analysis2(),category["Audio"]);
+ add_type("intensity_segmenter",new Intensity_segmenter(),category["Audio"]);
- category["maths"]=vector<Node*>();
- add_type("comparison",new Comparison(),category["maths"]); //TODO: alias to symbols
- add_type("arithmetic",new Arithmetic(),category["maths"]); //TODO: alias to symbols
- add_type("bang",new Is_new_integer(),category["maths"]);
- add_type("on_off",new On_off(),category["maths"]);
- add_type("random",new Random(),category["maths"]);
- add_type("noise",new Noise(),category["maths"]);
+ category["Maths"]=vector<Node*>();
+ add_type("comparison",new Comparison(),category["Maths"]); //TODO: alias to symbols
+ add_type("arithmetic",new Arithmetic(),category["Maths"]); //TODO: alias to symbols
+ add_type("bang",new Is_new_integer(),category["Maths"]);
+ add_type("on_off",new On_off(),category["Maths"]);
+ add_type("random",new Random(),category["Maths"]);
+ add_type("noise",new Noise(),category["Maths"]);
- category["fx"]=vector<Node*>();
- add_type("blur",new Blur(),category["fx"]);
- add_type("vhs",new VHS(),category["fx"]);
- add_type("echo_trails",new Echo_trails(),category["fx"]);
- add_type("video_feedback",new Video_feedback(),category["fx"]);
+ category["FX"]=vector<Node*>();
+ add_type("blur",new Blur(),category["FX"]);
+ add_type("vhs",new VHS(),category["FX"]);
+ add_type("echo_trails",new Echo_trails(),category["FX"]);
+ add_type("video_feedback",new Video_feedback(),category["FX"]);
}
bool Signal_input::connect(Node* source) {
@@ -112,7 +113,89 @@ bool Node_factory::list_node(const string &t,xmlIO XML){
}
}
XML.addValue("error","Node /"+t+"/ not found");
+ return false;
};
+bool Node_factory::list_node(const string &t,Json::Value &JSON){
+ for (auto& type: type_map) {
+ if (type.first==t) {
+ JSON["node"]=list_node(type.second);
+ return true;
+ }
+ }
+ JSON["error"]="Node /"+t+"/ not found";
+ return false;
+};
+Json::Value Node_factory::list_node(Rotor::Node* _node){
+ Json::Value node;
+ node["type"]=_node->type;
+ node["title"]=_node->title;
+ node["inputs"]=_node->duplicate_inputs?"expandable":"fixed";
+ if (dynamic_cast<Signal_node*> (_node)!=nullptr) node["output"]="signal";
+ if (dynamic_cast<Image_node*> (_node)!=nullptr) node["output"]="image";
+ node["description"]=_node->description;
+ node["UID"]=_node->UID;
+ if (_node->inputs.size()){
+ node["signal_inputs"]=Json::arrayValue;
+ for (auto& input: _node->inputs) {
+ Json::Value signal_input;
+ signal_input["title"]=input->title;
+ signal_input["description"]=input->description;
+ node["signal_inputs"].append(signal_input);
+ }
+ }
+ if (dynamic_cast<Image_node*> (_node)!=nullptr) {
+ if ((dynamic_cast<Image_node*>(_node))->image_inputs.size()){
+ node["image_inputs"]=Json::arrayValue;
+ for (auto& input: (dynamic_cast<Image_node*>(_node))->image_inputs) {
+ Json::Value image_input;
+ image_input["title"]=input->title;
+ image_input["description"]=input->description;
+ node["image_inputs"].append(image_input);
+ }
+ }
+ }
+ if (_node->parameters.size()){
+ node["parameters"]=Json::arrayValue;
+ for (auto& param: _node->parameters) {
+ Json::Value parameter;
+ parameter["name"]=param.first;
+ parameter["type"]=param.second->type;
+ parameter["title"]=param.second->title;
+ parameter["description"]=param.second->description;
+ parameter["value"]=param.second->value;
+ parameter["min"]=param.second->min;
+ parameter["max"]=param.second->max;
+ parameter["step"]=param.second->step;
+ node["parameters"].append(parameter);
+ }
+ }
+ if (_node->attributes.size()){
+ node["attributes"]=Json::arrayValue;
+ for (auto& attr: _node->attributes) {
+ Json::Value attribute;
+ attribute["name"]=attr.first;
+ attribute["title"]=attr.second->title;
+ attribute["description"]=attr.second->description;
+ if (attr.second->vals.size()){ //document attribute enumeration
+ attribute["value"]=attr.second->value;
+ attribute["type"]="enum";
+ attribute["options"]=Json::arrayValue;
+ for (auto val: attr.second->vals){
+ attribute["options"].append(val);
+ }
+ }
+ else {
+ attribute["type"]=attr.second->type;
+ if (attr.second->type=="array"){
+ attribute["value"]=Json::arrayValue;
+ }
+ else attribute["value"]=attr.second->value;
+ }
+ node["attributes"].append(attribute);
+ }
+ }
+ return node;
+}
void Node_factory::list_node(Rotor::Node* type,xmlIO XML,int i=0){
XML.addTag("node");
XML.addAttribute("node","type",type->type,i);
@@ -162,8 +245,8 @@ void Node_factory::list_node(Rotor::Node* type,xmlIO XML,int i=0){
XML.addAttribute("attribute","name",attribute.first,j);
XML.addAttribute("attribute","title",attribute.second->title,j);
XML.addAttribute("attribute","description",attribute.second->description,j);
- XML.addAttribute("attribute","value",attribute.second->value,j);
if (attribute.second->vals.size()){ //document attribute enumeration
+ XML.addAttribute("attribute","value",attribute.second->value,j);
XML.addAttribute("attribute","type","enum",j);
XML.pushTag("attribute",j);
int k=0;
@@ -174,7 +257,15 @@ void Node_factory::list_node(Rotor::Node* type,xmlIO XML,int i=0){
}
XML.popTag();
}
- else XML.addAttribute("attribute","type","string",j);
+ else {
+ XML.addAttribute("attribute","type",attribute.second->type,j);
+ if (attribute.second->type=="array"){
+ XML.pushTag("attribute",j);
+ XML.addTag("value");
+ XML.popTag();
+ }
+ else XML.addAttribute("attribute","value",attribute.second->value,j);
+ }
j++;
}
XML.popTag();
@@ -210,69 +301,9 @@ void Node_factory::list_categories(Json::Value &JSON){
category["name"]=_category.first;
category["nodes"]=Json::arrayValue;
for (auto& _node: _category.second){
- Json::Value node;
- node["type"]=_node->type;
- node["title"]=_node->title;
- node["inputs"]=_node->duplicate_inputs?"expandable":"fixed";
- if (dynamic_cast<Signal_node*> (_node)!=nullptr) node["output"]="signal";
- if (dynamic_cast<Image_node*> (_node)!=nullptr) node["output"]="image";
- node["description"]=_node->description;
- node["UID"]=_node->UID;
- if (_node->inputs.size()){
- node["signal_inputs"]=Json::arrayValue;
- for (auto& input: _node->inputs) {
- Json::Value signal_input;
- signal_input["title"]=input->title;
- signal_input["description"]=input->description;
- node["signal_inputs"].append(signal_input);
- }
- }
- if (dynamic_cast<Image_node*> (_node)!=nullptr) {
- if ((dynamic_cast<Image_node*>(_node))->image_inputs.size()){
- node["image_inputs"]=Json::arrayValue;
- for (auto& input: (dynamic_cast<Image_node*>(_node))->image_inputs) {
- Json::Value image_input;
- image_input["title"]=input->title;
- image_input["description"]=input->description;
- node["image_inputs"].append(image_input);
- }
- }
- }
- if (_node->parameters.size()){
- node["parameters"]=Json::arrayValue;
- for (auto& param: _node->parameters) {
- Json::Value parameter;
- parameter["name"]=param.first;
- parameter["type"]=param.second->type;
- parameter["title"]=param.second->title;
- parameter["description"]=param.second->description;
- parameter["value"]=param.second->value;
- parameter["min"]=param.second->min;
- parameter["max"]=param.second->max;
- parameter["step"]=param.second->step;
- node["parameters"].append(parameter);
- }
- }
- if (_node->attributes.size()){
- node["attributes"]=Json::arrayValue;
- for (auto& attr: _node->attributes) {
- Json::Value attribute;
- attribute["name"]=attr.first;
- attribute["title"]=attr.second->title;
- attribute["description"]=attr.second->description;
- attribute["value"]=attr.second->value;
- if (attr.second->vals.size()){ //document attribute enumeration
- attribute["type"]="enum";
- attribute["options"]=Json::arrayValue;
- for (auto val: attr.second->vals){
- attribute["options"].append(val);
- }
- }
- else attribute["type"]="string";
- node["attributes"].append(attribute);
- }
- }
- category["nodes"].append(node);
+ //cerr<<"Adding "<<_category.first<<":"<<_node->type<<endl;
+
+ category["nodes"].append(list_node(_node));
}
JSON["category"].append(category);
}
@@ -281,69 +312,7 @@ void Node_factory::list_nodes(Json::Value &JSON){
JSON["nodeslist"]=Json::arrayValue;
for (auto& type: type_map) {
if (type.second->description!="") { //blank description = internal/ testing node
- Json::Value node;
- node["type"]=type.first;
- node["title"]=type.second->title;
- node["inputs"]=type.second->duplicate_inputs?"expandable":"fixed";
- if (dynamic_cast<Signal_node*> (type.second)!=nullptr) node["output"]="signal";
- if (dynamic_cast<Image_node*> (type.second)!=nullptr) node["output"]="image";
- node["description"]=type.second->description;
- node["UID"]=type.second->UID;
- if (type.second->inputs.size()){
- node["signal_inputs"]=Json::arrayValue;
- for (auto& input: type.second->inputs) {
- Json::Value signal_input;
- signal_input["title"]=input->title;
- signal_input["description"]=input->description;
- node["signal_inputs"].append(signal_input);
- }
- }
- if (dynamic_cast<Image_node*> (type.second)!=nullptr) {
- if ((dynamic_cast<Image_node*>(type.second))->image_inputs.size()){
- node["image_inputs"]=Json::arrayValue;
- for (auto& input: (dynamic_cast<Image_node*>(type.second))->image_inputs) {
- Json::Value image_input;
- image_input["title"]=input->title;
- image_input["description"]=input->description;
- node["image_inputs"].append(image_input);
- }
- }
- }
- if (type.second->parameters.size()){
- node["parameters"]=Json::arrayValue;
- for (auto& param: type.second->parameters) {
- Json::Value parameter;
- parameter["name"]=param.first;
- parameter["type"]=param.second->type;
- parameter["title"]=param.second->title;
- parameter["description"]=param.second->description;
- parameter["value"]=param.second->value;
- parameter["min"]=param.second->min;
- parameter["max"]=param.second->max;
- parameter["step"]=param.second->step;
- node["parameters"].append(parameter);
- }
- }
- if (type.second->attributes.size()){
- node["attributes"]=Json::arrayValue;
- for (auto& attr: type.second->attributes) {
- Json::Value attribute;
- attribute["name"]=attr.first;
- attribute["title"]=attr.second->title;
- attribute["description"]=attr.second->description;
- attribute["value"]=attr.second->value;
- if (attr.second->vals.size()){ //document attribute enumeration
- attribute["type"]="enum";
- attribute["options"]=Json::arrayValue;
- for (auto val: attr.second->vals){
- attribute["options"].append(val);
- }
- }
- else attribute["type"]="string";
- node["attributes"].append(attribute);
- }
- }
- JSON["nodeslist"].append(node);
+ JSON["nodeslist"].append(list_node(type.second));
}
}
} \ No newline at end of file
diff --git a/rotord/src/rotor.h b/rotord/src/rotor.h
index d9ba66d..94ec643 100644
--- a/rotord/src/rotor.h
+++ b/rotord/src/rotor.h
@@ -75,6 +75,7 @@ Requirements
#include <iostream>
#include <json/json.h>
+#include <rsvg.h>
#include "Poco/Net/HTTPResponse.h"
#include "Poco/Logger.h"
@@ -205,7 +206,7 @@ namespace Rotor {
class Attribute{ //description of a static attribute which can be an enumerated string array
public:
virtual ~Attribute(){};
- Attribute(const string &_desc,const string &_title,const string &_value,std::vector<std::string> _vals={}): description(_desc),title(_title),value(_value),intVal(0){
+ Attribute(const string &_desc,const string &_title,const string &_value,std::vector<std::string> _vals={},std::string _type="string"): description(_desc),title(_title),value(_value),intVal(0),type(_type){
vals=_vals;
init(_value);
};
@@ -217,7 +218,7 @@ namespace Rotor {
}
else intVal=0;
}
- string value,description,title;
+ string value,description,title,type;
std::vector<std::string> vals;
int intVal;
};
@@ -239,15 +240,15 @@ namespace Rotor {
void create_parameter(const string &_name,const string &_type,const string &_desc,const string &_title,float _value=1.0f,float _min=0.0f,float _max=0.0f,float _step=0.0f,Node* _connect=nullptr) {
parameters[_name]=new Parameter(_type,_desc,_title,_value,_min,_max,_step,_connect);
};
- void create_attribute(const string &_attr,const string &_desc,const string &_title,const string &_value,std::vector<std::string> _vals={}) {
- attributes[_attr]=new Attribute(_desc,_title,_value,_vals);
+ void create_attribute(const string &_attr,const string &_desc,const string &_title,const string &_value,std::vector<std::string> _vals={},std::string _type="string") {
+ attributes[_attr]=new Attribute(_desc,_title,_value,_vals,_type);
};
- void create_attribute(string *alias,const string &_attr,const string &_desc,const string &_title,const string &_value,std::vector<std::string> _vals={}) {
- create_attribute(_attr,_desc,_title,_value,_vals);
+ void create_attribute(string *alias,const string &_attr,const string &_desc,const string &_title,const string &_value,std::vector<std::string> _vals={},std::string _type="string") {
+ create_attribute(_attr,_desc,_title,_value,_vals,_type);
alias=&(attributes[_attr]->value);
};
- void create_attribute(int *alias,const string &_attr,const string &_desc,const string &_title,const string &_value,std::vector<std::string> _vals={}) {
- create_attribute(_attr,_desc,_title,_value,_vals);
+ void create_attribute(int *alias,const string &_attr,const string &_desc,const string &_title,const string &_value,std::vector<std::string> _vals={},std::string _type="string") {
+ create_attribute(_attr,_desc,_title,_value,_vals,_type);
alias=&(attributes[_attr]->intVal);
};
virtual void init_attribute(const string &attr){};
@@ -342,17 +343,6 @@ namespace Rotor {
protected:
unsigned char *lut;
};
- class Audio_processor: public Signal_node {
- public:
- virtual Audio_processor(){};
- virtual ~Audio_processor(){};
- virtual int process_frame(uint8_t *data,int samples)=0;
- virtual bool init(int _channels,int _bits,int _samples,int _rate)=0;
- virtual void cleanup()=0;
- virtual void print_summary(){};
- virtual string get_features(){};
- int channels,bits,samples,rate;
- };
//actual nodes-------------------------------------------------
#define CYCLER_cut 1
#define CYCLER_mix 2
@@ -578,6 +568,24 @@ namespace Rotor {
Image in1,in2,in2t,temp; //for blend frames;
string *filename;
};
+ class Video_bank: public Image_node {
+ public:
+ Video_bank(){
+ create_attribute("filenames","names of video files to load","File names","",{},"array");
+ UID="73616e66-4306-11e3-981e-74d02b29f6a6";
+ title="Video bank";
+ description="Loads a banks of video files";
+ };
+ Video_bank(map<string,string> &settings): Video_bank() {
+ base_settings(settings);
+ };
+ Image *output(const Frame_spec &frame){
+ return nullptr;
+ }
+ Video_bank* clone(map<string,string> &_settings) { return new Video_bank(_settings);};
+ ~Video_bank(){};
+ private:
+ };
class Video_output: public Image_node {
//Video_output 'presents' the output movie. Aspect ratio, bars, fadein/fadeout would happen here
public:
@@ -706,14 +714,16 @@ namespace Rotor {
return NULL;
};
bool list_node(const string &t,xmlIO XML);
+ bool list_node(const string &t,Json::Value &JSON);
void list_node(Rotor::Node* type,xmlIO XML,int i=0);
+ Json::Value list_node(Rotor::Node* type);
void list_nodes(xmlIO XML);
void list_nodes(Json::Value &JSON);
void list_categories(xmlIO XML);
void list_categories(Json::Value &JSON);
private:
- unordered_map<string,Node*> type_map;
- unordered_map<string,vector<Rotor::Node*> > category;
+ map<string,Node*> type_map;
+ map<string,vector<Rotor::Node*> > category;
};
}
diff --git a/rotord/src/rotord.cpp b/rotord/src/rotord.cpp
index de853e4..c4c562e 100644
--- a/rotord/src/rotord.cpp
+++ b/rotord/src/rotord.cpp
@@ -212,8 +212,20 @@ HTTPRequestHandler* RotorRequestHandlerFactory::createRequestHandler(const HTTPS
}
}
else if (command[0]=="listnode") {
- XML.pushTag("rotor");
if (request.getMethod()=="GET") {
+ if (command.size()>1){
+ if (command[1]=="json") {
+ Json::Value root;
+ Json::StyledWriter writer;
+
+ Node_factory factory;
+ factory.list_node(body,root);
+ string content = writer.write(root);
+ status=HTTPResponse::HTTP_OK;
+ return new RenderContextHandler(content, status);
+ }
+ }
+ XML.pushTag("rotor");
Node_factory factory;
if (factory.list_node(body,XML)) status=HTTPResponse::HTTP_OK;
}
diff --git a/rotord/src/rotord.h b/rotord/src/rotord.h
index 0eb1eb3..dd6a25c 100644
--- a/rotord/src/rotord.h
+++ b/rotord/src/rotord.h
@@ -86,12 +86,15 @@ class RenderContextHandler: public HTTPRequestHandler
class RotorRequestHandlerFactory: public HTTPRequestHandlerFactory
{
public:
- RotorRequestHandlerFactory(){
+ RotorRequestHandlerFactory(): manager(pool){
xmlIO xml;
if(xml.loadFile("settings.xml") ){
media_dir=xml.getAttribute("Rotor","media_dir","",0);
thumbnail_dir=xml.getAttribute("Rotor","thumbnail_dir","",0);
}
+ pool.addCapacity(300);
+
+ //manager=Poco::TaskManager(pool);
}
HTTPRequestHandler* createRequestHandler(const HTTPServerRequest& request);
private:
@@ -100,6 +103,7 @@ class RotorRequestHandlerFactory: public HTTPRequestHandlerFactory
std::unordered_map<std::string,std::string> renders;
Poco::UUIDGenerator idGen;
Poco::TaskManager manager;
+ Poco::ThreadPool pool;
std::string media_dir;
std::string thumbnail_dir;
};
diff --git a/rotord/src/vampHost.cpp b/rotord/src/vampHost.cpp
index c1340f2..2ddc62f 100644
--- a/rotord/src/vampHost.cpp
+++ b/rotord/src/vampHost.cpp
@@ -275,6 +275,10 @@ bool vampHost::Analyser::init(const string &soname,const string &id,const int &_
return false;
}
+ cerr << "Vamphost Plugin initialised: (channels = " << channels
+ << ", stepSize = " << stepSize << ", blockSize = "
+ << blockSize << ")" << endl;
+
wrapper = dynamic_cast<PluginWrapper *>(plugin);
if (wrapper) {
// See documentation for
@@ -294,6 +298,7 @@ bool vampHost::Analyser::init(const string &soname,const string &id,const int &_
return true;
}
void vampHost::Analyser::process_frame(uint8_t *data,int samples_in_frame){
+
int sample=0;
uint16_t *_data=(uint16_t*)data;
@@ -317,17 +322,25 @@ void vampHost::Analyser::process_frame(uint8_t *data,int samples_in_frame){
//I /think/ that the vamp plugin keeps processing through the plugbuf until it encounters 0s
rt = RealTime::frame2RealTime(currentStep * stepSize, rate); //48000); //setting different rate doesn't affect it
+
Plugin::FeatureSet feat=plugin->process(plugbuf, rt);
+ float t;
+
for (unsigned int i = 0; i < feat[outputNo].size(); ++i) {
feature f;
f.number=featureNo;
f.values=feat[outputNo][i].values;
- features[((float)feat[outputNo][i].timestamp.sec)+(((float)feat[outputNo][i].timestamp.nsec)*.000000001)]=f;
+ //fix for plugins that don't set timestamp properly
+ t=((float)feat[outputNo][i].timestamp.sec)+(((float)feat[outputNo][i].timestamp.nsec)*.000000001);
+ if (t<.01) t=((rt.sec)+(rt.nsec)*.000000001);
+ features[t]=f;
featureNo++;
}
+ //if (feat[outputNo].size()>0) cerr<<"vamphost: "<<t<<":"<<features.size()<<" features"<<endl;
+
//shunt it down
for (int i=0;i<blockSize-stepSize;i++){
for (int j=0;j<channels;j++){
@@ -335,13 +348,14 @@ void vampHost::Analyser::process_frame(uint8_t *data,int samples_in_frame){
}
}
+ //if (feat[outputNo].size()>0) cerr<<plugin->getIdentifier()<<" step:"<<currentStep<<" sample:"<<currentStep * stepSize<<" features:"<<features.size()<<endl;
+
in_block-=stepSize;
- currentStep++;
+ currentStep++; //WTF this number does not increase when called the 2nd way
}
}
}
void vampHost::Analyser::cleanup(){
-
//process final block
while(in_block<blockSize) {
for (int i=0;i<channels;i++) {
@@ -386,3 +400,21 @@ void vampHost::Analyser::cleanup(){
delete[] plugbuf;
delete plugin;
}
+float vampHost::Analyser::get_value(const float &time) {
+ if (features.size()) {
+ auto i=features.upper_bound(time); //the first element in the container whose key is considered to go after k
+ if (i!=features.end()){
+ float uk=i->first;
+ float v1,v2;
+ v1=v2=0.0f;
+ if (i->second.values.size()) v2=i->second.values[0];
+ i--;
+ float lk=i->first;
+ int ln=i->second.number;
+ if (i->second.values.size()) v1=i->second.values[0];
+
+ return ((((time-lk)/(uk-lk))*(v2-v1))+v1);
+ }
+ }
+ return 0.0f;
+}
diff --git a/rotord/src/vampHost.h b/rotord/src/vampHost.h
index 56de901..856a2cc 100644
--- a/rotord/src/vampHost.h
+++ b/rotord/src/vampHost.h
@@ -64,7 +64,7 @@ namespace vampHost {
bool init(const string &soname,const string &id,const int &_channels,const int &_bits,const int &_samples,const int &_rate,int outputNo,const map<string,float> &params);
void process_frame(uint8_t *data,int samples_in_frame);
void cleanup();
-
+ float get_value(const float &time);
//map<double,int> features;
map<float,feature> features;
//map<time,featureNo>
generated by cgit v1.2.3 (git 2.39.1) at 2025-12-06 16:02:06 +0000