#include "graph.h"

using namespace Rotor;
using Poco::Logger;

const string Graph::graphToString(){
	string xmlgraph;
	if (loaded) {
		xml.copyXmlToString(xmlgraph);
		return xmlgraph;
	}
	else return "";
}
vector<Node*> Graph::find_nodes(const string &type){
	vector<Node*> found;
	for (std::unordered_map<string,Node*>::iterator it=nodes.begin();it!=nodes.end();++it) {
		if (it->second->type==type) found.push_back(it->second);
	}
	return found;
};
Node* Graph::find_node(const string &type){
	for (std::unordered_map<string,Node*>::iterator it=nodes.begin();it!=nodes.end();++it) {
		if (it->second->type==type) return it->second;
	}
	return nullptr; //can be tested against
};
bool Graph::signal_render(xmlIO &XML,const string &node,const float framerate) {
	if (nodes.find(node)!=nodes.end()){
		Signal_node *signal_output=dynamic_cast<Signal_node*>(nodes[node]);
		if (signal_output) {
			//return signal_output->render(duration,framerate,signal_xml);
			XML.addValue("signal_duration",duration);
			XML.addValue("signal_framerate",framerate);
			float sig=0.0f;
			string val="";
			for (float i=0;i<duration;i+=1.0f/framerate){
				float s=(signal_output->get_output(Time_spec(i,framerate,duration))+1.0f)/10.0f;
				if (!fequal(sig,s)){
					val+=toString(i)+","+toString(s)+" ";
					sig=s;
				}
			}
			XML.addValue("signal",val);
			return true;
		}
		cerr<<"Error: /"<<node<<"/ is not a signal node"<<endl;

		return false;
	}
	cerr<<"Error: signal output node not found"<<endl;

	return false;
}
bool Graph::print_features(xmlIO &XML,string &node){
	if (nodes.find(node)!=nodes.end()){
		if (dynamic_cast<Audio_processor*>(nodes[node])){
			XML.addValue("features",dynamic_cast<Audio_processor*>(nodes[node])->get_features());
			return true;
		}
		XML.addValue("ERROR","node /"+node+"/ is not an Audio processor");
		return false;
	}
	XML.addValue("ERROR","could not find node /"+node+"/");
	return false;
}
bool Graph::preview(xmlIO &XML,string &node,string &_format,int frame,int w,int h){
	if (nodes.find(node)!=nodes.end()){
		float t=frame/framerate;
		XML.addTag("preview");
		XML.addAttribute("preview","frame",toString(frame),0);
		XML.addAttribute("preview","nodeID",node,0);
		XML.pushTag("preview");
		if (dynamic_cast<Signal_node*>(nodes[node])){
			Time_spec ts=Time_spec(t,framerate,0.0f);
			XML.addValue("signal",dynamic_cast<Signal_node*>(nodes[node])->get_output(ts));
		}
		if (dynamic_cast<Image_node*>(nodes[node])){
			Frame_spec fs=Frame_spec(t,framerate,0.0f,w,h);
			Image *img=dynamic_cast<Image_node*>(nodes[node])->get_image_output(fs);
			vector<unsigned char> buf;
			string format=(_format==""?".png":_format);
			if (cv::imencode(format,img->rgb,buf)){ //, const vector<int>& params=vector<int>())
				stringstream output;
				Poco::Base64Encoder *enc=new Poco::Base64Encoder(output);
				enc->write((char*)buf.data(),buf.size());
				enc->close();
				delete enc;
				XML.addValue("image",output.str());
				XML.addAttribute("image","format",format,0);
			}
		}
		XML.popTag();
		return true;
	}
	return false;
}

bool Graph::video_render(const string &output_filename,const float framerate,int start, int stop) {
	if (output_filename.size()==0) return false;
	//https://www.adobe.com/devnet/video/articles/mp4_movie_atom.html
	//https://www.google.ie/search?q=ffmbc&aq=f&oq=ffmbc&aqs=chrome.0.57j0l2j60j0j60.4360j0&sourceid=chrome&ie=UTF-8#q=ffmbc+git

	//vector<Node*> loaders=find_nodes("video_loader");
	//for (auto i:loaders){
	//	if (!dynamic_cast<Video_loader*>(i)->isLoaded) {
	//		cerr<<"Rotor: all loaders must be populated before rendering"<<endl;
	//		return false;
	//	}
	//}
	if (find_node("video_output")) {
		Video_output *video_output=dynamic_cast<Video_output*>(find_node("video_output"));

		if (audio_filename!=""){ //BETTER WAY TO KNOW IF WE ARE USING AUDIO?
			video_output->create_envelope(audio_thumb->audiodata);
		}

		for (auto f: find_nodes("video_feedback")){
			video_output->clear_output(outW,outH);
			(dynamic_cast<Video_feedback*>(f))->set_feedback(&(video_output->image));
		}
		//
		//setup defaults

		std::string container;
		Poco::StringTokenizer t(output_filename,".");
        if (t.count()>1){
            container="."+t[t.count()-1];
        }
        else container=".mp4";

	    libav::exporter exporter;

	    Image* i;

		if (exporter.setup(outW,outH,bitRate,framerate,container,use_fragmentation)) { //codecId,
			if (exporter.record(output_filename)) {

				libav::audio_decoder audioloader;

				bool usingaudio=audioloader.open(audio_filename);
				
				Logger& logger = Logger::get("Rotor");
				logger.information("Video_output rendering "+output_filename+": "+toString(duration)+" seconds at "+toString(framerate)+" fps, audio frame size: "+toString(exporter.get_audio_framesize()));
				//25fps video and 43.06640625fps audio? hmm
				//how to get the timecodes correct for the interleaved files

				struct timeval _start, _end;

			    gettimeofday(&_start, NULL);

			    uint16_t *audioframe=nullptr;
			    uint16_t *audio=nullptr;
			    int samples_in_frame;

			    for (auto n:nodes) n.second->reset();

			    if (usingaudio){
				    samples_in_frame=(audioloader.get_sample_rate())/framerate;
				    string whether=usingaudio?"Loading":"Cannot load";
				    logger.information(whether+" audio file: "+audio_filename+", each frame contains "+toString(samples_in_frame)+" samples at "+toString(audioloader.get_sample_rate())+" hz");
				    audioframe=new uint16_t[(samples_in_frame+exporter.get_audio_framesize())*audioloader.get_number_channels()];
				    audio=new uint16_t[samples_in_frame*audioloader.get_number_channels()];
				}

				float vstep=1.0f/framerate;
				float vf=start*vstep;
				float af=start*vstep;
				int aoffs=0;
				int audioend=0;
				Audio_frame *a;
				int64_t sample_start=(start*audioloader.get_sample_rate())/framerate;
				while (vf<min(duration,stop*vstep)&&!cancelled){ //-vstep) {

					if (usingaudio) {
						if (audioloader.get_samples(audio,sample_start,samples_in_frame)) {
							if (aoffs>0){
								//shift down samples
								int s=0;
								while ((s+aoffs)<audioend) {
									for (int j=0;j<audioloader.get_number_channels();j++){
										audioframe[s*audioloader.get_number_channels()+j]=audioframe[(s+aoffs)*audioloader.get_number_channels()+j];
									}
									s++;
								}
								aoffs=s;
							}
							for (int i=0;i<samples_in_frame;i++){
								for (int j=0;j<audioloader.get_number_channels();j++){
									audioframe[(aoffs+i)*audioloader.get_number_channels()+j]=audio[i*audioloader.get_number_channels()+j];
								}
							}
							audioend=aoffs+samples_in_frame;
							aoffs=0;
						    while (aoffs+exporter.get_audio_framesize()<audioend) {
			                    //insert audio frames until we are only 1 audio frame behind the next video frame
			                    //send audio_framesize() of them through until buffer is used
			                    //pass full buffer within frame_spec for av nodes
			                    exporter.encodeFrame(audioframe+(aoffs*audioloader.get_number_channels()));
			                    af+=exporter.get_audio_step();
			                    aoffs+=exporter.get_audio_framesize();
			                }
			                a=new Audio_frame(audio,audioloader.get_number_channels(),samples_in_frame);
			                sample_start+=samples_in_frame;
						}
						else usingaudio=false;

		            }


	                //[mp3 @ 0x7fffe40330e0] max_analyze_duration 5000000 reached at 5015510 microseconds
	                //[mp3 @ 0x7fffe4033ec0] Insufficient thread locking around avcodec_open/close()
	                //[mp3 @ 0x7fffe40330e0] Estimating duration from bitrate, this may be inaccurate
	                //[libx264 @ 0x7fffe8003940] using cpu capabilities: MMX2 SSE2Fast SSSE3 FastShuffle SSE4.2
	                //[libx264 @ 0x7fffe8003940] profile High, level 3.0
	                //[libx264 @ 0x7fffe8003940] 264 - core 123 r2189 35cf912 - H.264/MPEG-4 AVC codec - Copyleft 2003-2012 - http://www.videolan.org/x264.html - options: cabac=1 ref=3 deblock=1:0:0 analyse=0x3:0x113 me=hex subme=7 psy=1 psy_rd=1.00:0.00 mixed_ref=1 me_range=16 chroma_me=1 trellis=1 8x8dct=1 cqm=0 deadzone=21,11 fast_pskip=1 chroma_qp_offset=-2 threads=12 sliced_threads=0 nr=0 decimate=1 interlaced=0 bluray_compat=0 constrained_intra=0 bframes=3 b_pyramid=2 b_adapt=1 b_bias=0 direct=1 weightb=1 open_gop=0 weightp=2 keyint=10 keyint_min=1 scenecut=40 intra_refresh=0 rc_lookahead=10 rc=abr mbtree=1 bitrate=400 ratetol=1.0 qcomp=0.60 qpmin=0 qpmax=69 qpstep=4 ip_ratio=1.40 aq=1:1.00
	                //Assertion ff_avcodec_locked failed at libavcodec/utils.c:2967

		            //cerr<<"videoloader: "<<vf<<" seconds, vstep "<<vstep<<" ,asking for frame "<<((int)((vf*framerate)+0.5))<<endl


		            if (usingaudio) {
				    	i=video_output->get_image_output(Frame_spec(vf,framerate,duration,outW,outH,a));
				    }
				    else i=video_output->get_image_output(Frame_spec(vf,framerate,duration,outW,outH));
				    if (i) {
				    	exporter.encodeFrame(i->RGBdata);
				    }
				    vf+=vstep;
				    //mutex.lock();
				    progress=vf/duration;
				    //mutex.unlock();
				    if (usingaudio) {delete a;};
				}


				//exporter.encodeFrame(i->RGBdata,true); //final keyframe;

				exporter.finishRecord();

				gettimeofday(&_end, NULL);

			    float mtime = ((_end.tv_sec-_start.tv_sec) + (_end.tv_usec-_start.tv_usec)/1000000.0);

				logger.information("Video_output: rendered "+output_filename+": in "+toString(mtime)+" seconds");
				logger.information("compression codec took "+toString(mtime-video_output->time_taken)+" seconds");

				for (auto n:nodes) {
					logger.information(n.second->type+" node '"+n.first+"' took "+toString(n.second->get_time_used())+" seconds");
				}

				if (usingaudio) {
					audioloader.cleanup();
					delete[] audioframe;
					delete[] audio;
				}



				return true;
			}
		}

		return false;
		}

	cerr<<"Rotor: video output node not found"<<endl;
	return false;
}

bool Graph::set_resolution(int w,int h){
	if (w>64&&h>48){
		outW=w;
		outH=h;
		return true;
	}
	else return false;
}
bool Graph::load(string data,string media_path){
	if (xml.loadFromBuffer(data)){
		return parseXml(media_path);
	}
	return parseJson(data,media_path);
	return false;
}
bool Graph::loadFile(string &filename,string media_path){
	//if (loaded)
	printf("loading graph: %s\n",(filename).c_str());
	if (xml.loadFile(filename)){
		return parseXml(media_path);
	}
	Poco::FileInputStream fis(filename);
	Poco::CountingInputStream countingIstr(fis);
	std::string str;
	Poco::StreamCopier::copyToString(countingIstr, str);
	return parseJson(str,media_path);
}
bool Graph::check_audio(string audio,string path){
	if (audio!="")	{
		Poco::File f=Poco::File(path+audio);
		if (f.exists()) {
			audio_filename=path+audio;
			audio_loaded=true;
			cerr<<"Rotor: loading "<<path+audio<<" from graph"<<endl;
			return true;
		}
		cerr<<"Rotor: audio file "<<path+audio<<" not found"<<endl;
	}
	return false;
}
bool Graph::parseJson(string &data,string &media_path){
	//cerr<<data<<endl;
	//cerr<<"Trying to load JSON"<<endl;
	Json::Value root;   // will contains the root value after parsing.
	Json::Reader reader;
	bool parsingSuccessful = reader.parse( data, root );
	if ( !parsingSuccessful )
	{
	    // report to the user the failure and their locations in the document.
	    std::cout  << "Failed to parse configuration\n"
	               << reader.getFormattedErrorMessages();
	    return false;
	}
	//we know the json validates so clear the existing graph
	clear();
	Node_factory factory;
	analysis_seed=root["seed"].asInt();
	check_audio(root["audio"].asString(),media_path);
	init(root["ID"].asString(),root["description"].asString());
	Json::Value jnodes = root["nodeDefinitions"];
	for ( uint32_t i = 0; i < jnodes.size(); ++i ) {
	   string nodeID=jnodes[i]["id"].asString();
	   //cerr<<"json found node: "<<jnodes[i]["type"].asString()<<endl;
	   map<string,string> settings;
	   vector<string> attrs;
	   settings["type"]=jnodes[i]["type"].asString();
		//attributes
		settings["media_path"]=media_path;
		for (uint32_t m=0;m<jnodes[i]["attributes"].size();m++) {
			if (jnodes[i]["attributes"][m]["type"].asString()!="array") {
				settings[jnodes[i]["attributes"][m]["name"].asString()]=jnodes[i]["attributes"][m]["value"].asString();
	  		}
	  	}
	  	Node* node=factory.create(settings);
	  	for (uint32_t m=0;m<jnodes[i]["attributes"].size();m++){
			string attribute=jnodes[i]["attributes"][m]["name"].asString();
			string val="";
			if (node->attributes.find(attribute)!=node->attributes.end()){
				Attribute *attr=node->attributes.find(attribute)->second;
				if (attr->type=="enum"){
				    val=jnodes[i]["attributes"][m]["value"].asString();
				    attr->init(val);		
				}
				if (attr->type=="string") {
				    val=jnodes[i]["attributes"][m]["value"].asString();
				    attr->init(val);
				}
				if (attr->type=="array"){
					std::vector<std::string> vals;

					for (uint32_t i5 = 0; i5 < jnodes[i]["attributes"][m]["value"].size(); i5++ )
					{
						vals.push_back(jnodes[i]["attributes"][m]["value"][i5].asString());
					}
					attr->init(vals);
				}
				if (attr->type=="lyrics"){
					std::map<float,std::pair<string,float> > lyrics;
					for (auto k:jnodes[i]["attributes"][m]["value"]){
						if (k.size()>2&&k[0].isString()&&k[1].isNumeric()&&k[2].isNumeric()) {
							lyrics[k[1].asFloat()]=std::make_pair(k[0].asString(),k[2].asFloat());
						}
					}
					((Lyrics_attribute*)attr)->init(lyrics);
				}
				node->init_attribute(attribute);
				//cerr << "Rotor: setting attribute '"<<attribute<<"' of "<<nodeID<<" type "<<attr->type<<" to "<<val<<endl;
				cerr << "Rotor: setting attribute '"<<attribute<<"' of "<<nodeID<<" type "<<attr->type<<" to "<<val<<endl;
					
			}
			//settings[attribute]=val;
		}
	   	if (node) {
			if (nodes.find(nodeID)==nodes.end()){
				cerr << "Rotor: creating node '"<<nodeID<<"': '"<< settings["type"] << "'" << endl;
				nodes[nodeID]=node;
				//signal inputs
			   	for (uint32_t j=0;j< jnodes[i]["signal_inputs"].size();j++){
			   		if ((nodes[nodeID])->inputs.size()>j) {
						string fromID=jnodes[i]["signal_inputs"][j]["from"].asString();
						if (fromID!=""){
							if (nodes.find(fromID)!=nodes.end()) {
								if (!nodes[nodeID]->inputs[j]->connect((Signal_node*)nodes[fromID])){
									cerr << "ERROR: graph loader cannot connect input " << j << " of node '" << nodeID << "' to node '" << fromID << "'" << endl;
									return false;
								}
								else cerr << "Rotor: linked input " << j << " of node '" << nodeID << "' to node '" << fromID << "'" << endl;
							}
							else cerr << "ERROR: linking input " << j << " of node: '" << nodeID << "', cannot find target '" << fromID << "'" << endl;
						}
					}
					else cerr << "ERROR: input " << j << " of node: '" << nodeID << "' does not exist" << endl;
				}


				//image inputs
				if (dynamic_cast<Image_node*>(nodes[nodeID])!=nullptr) {


					//handle expandable inputs
					if ((((Image_node*)nodes[nodeID])->image_inputs.size()<jnodes[i]["image_inputs"].size())&&((Image_node*)nodes[nodeID])->duplicate_inputs){
						string desc=((Image_node*)nodes[nodeID])->image_inputs[0]->description;
						string title=((Image_node*)nodes[nodeID])->image_inputs[0]->title;
						while(((Image_node*)nodes[nodeID])->image_inputs.size()<jnodes[i]["image_inputs"].size()){
							((Image_node*)nodes[nodeID])->create_image_input(desc,title);
							cerr<<"creating an image input"<<endl;
						}
					}


					for (uint32_t k=0;k<jnodes[i]["image_inputs"].size();k++){
						if (((Image_node*)nodes[nodeID])->image_inputs.size()<=k) {
							if (nodes[nodeID]->duplicate_inputs) {
								while(((Image_node*)nodes[nodeID])->image_inputs.size()<=k){
									((Image_node*)nodes[nodeID])->create_image_input(settings["description"],settings["title"]);
								}
							}
						}
						if (((Image_node*)nodes[nodeID])->image_inputs.size()>k) {
							string fromID=jnodes[i]["image_inputs"][k]["from"].asString();
							if (fromID!=""){
								if (nodes.find(fromID)!=nodes.end()) {
									if (dynamic_cast<Image_node*>(nodes[fromID])!=nullptr) {
										if (!dynamic_cast<Image_node*>(nodes[nodeID])->image_inputs[k]->connect((Image_node*)nodes[fromID])){
											cerr << "ERROR: graph loader cannot connect image input " << k << " of node '" << nodeID << "' to node '" << fromID << "'" << endl;
											return false;
										}
										else cerr << "Rotor: linked image input " << k << " of node '" << nodeID << "' to node '" << fromID << "'" << endl;
									}
									else cerr << "ERROR: cannot link image input "<< k << " of node '" << nodeID << "' to node '" << fromID << "' : not an image node" << endl;
								}
								else cerr << "ERROR: linking image input " << k << " of node: '" << nodeID << "', cannot find target '" << fromID << "'" << endl;
							}
						}
						else cerr << "ERROR: image input number " << k << " of node: '" << nodeID << "' does not exist" << endl;
					}
				}
				//parameters
				for (uint32_t l=0;l<jnodes[i]["parameters"].size();l++){

					string parameter=jnodes[i]["parameters"][l]["name"].asString();

					if (nodes[nodeID]->parameters.find(parameter)!=nodes[nodeID]->parameters.end()) {
						float val=jnodes[i]["parameters"][l]["value"].asFloat();
						if (val!=nodes[nodeID]->parameters.find(parameter)->second->value){
							nodes[nodeID]->parameters.find(parameter)->second->value=val;
							cerr << "Rotor: set parameter '"<<parameter<<"' of "<<nodeID<<" to "<<val<<endl;
						}
						string fromID=jnodes[i]["parameters"][l]["from"].asString();
						if (nodes.find(fromID)!=nodes.end()) {
							if (!nodes[nodeID]->parameters[parameter]->connect(nodes[fromID])){
								cerr << "ERROR: graph loader cannot connect parameter " << parameter << " of node '" << nodeID << "' to node '" << fromID << "'" << endl;
								return false;
							}
							else cerr << "Rotor: linked parameter " << parameter << " of node '" << nodeID << "' to node '" << fromID << "'" << endl;
						}
						else if (fromID!="") cerr << "Rotor: linking parameter " << parameter << " of node: '" << nodeID << "', cannot find target '" << fromID << "'" << endl;
					}
					else cerr << "ERROR: cannot find parameter '" << parameter << "' of "<<settings["type"]<<" "<< nodeID << endl;

				}
			}
			else cerr << "ERROR: duplicate node '"<<nodeID<<"' "<< endl;
   		}
	   	else {
			cerr << "ERROR: graph loader cannot find node '" << settings["type"] << "'" << endl;
			return false;
		}

	}
	loaded=true;
	return true;
}
bool Graph::parseXml(string media_path){
	clear();
	Node_factory factory;
	check_audio(xml.getAttribute("patchbay","audio","",0),media_path);
	analysis_seed=xml.getAttribute("patchbay","seed",0,0);
	init(xml.getAttribute("patchbay","ID","",0),xml.getValue("patchbay","",0));
		if(xml.pushTag("patchbay")) {
			int n1=xml.getNumTags("node");
			for (int i1=0;i1<n1;i1++){
				map<string,string> settings;
				vector<string> attrs;
				xml.getAttributeNames("node",attrs,i1);
				for (auto& attr: attrs) {
					settings[attr]=xml.getAttribute("node",attr,"",i1);
					//cerr << "Got attribute: " << attr << ":" << xml.getAttribute("node",attr,"",i1) << endl;
				}
				settings["media_path"]=media_path;
				Node* node=factory.create(settings);
				if (node) {
					string nodeID=xml.getAttribute("node","ID","",i1);
					if (nodes.find(nodeID)==nodes.end()){
						string nodetype=xml.getAttribute("node","type","",i1);
						cerr << "Rotor: creating node '"<<nodeID<<"': '"<< xml.getAttribute("node","type","",i1) << "'" << endl;
						nodes[nodeID]=node;
						if(xml.pushTag("node",i1)) {
							uint32_t n2=xml.getNumTags("signal_input");
							for (uint32_t i2=0;i2<n2;i2++){
								//TODO expand
								//nodes[nodeID]->create_signal_input(xml.getAttribute("signal_input","description","",i2),xml.getAttribute("signal_input","title","",i2));
								if ((nodes[nodeID])->inputs.size()>i2) {
									string fromID=xml.getAttribute("signal_input","from","",i2);
									if (nodes.find(fromID)!=nodes.end()) {
										if (!nodes[nodeID]->inputs[i2]->connect((Signal_node*)nodes[fromID])){
											cerr << "Rotor: graph loader cannot connect input " << i2 << " of node '" << nodeID << "' to node '" << fromID << "'" << endl;
											return false;
										}
										else cerr << "Rotor: linked input " << i2 << " of node '" << nodeID << "' to node '" << fromID << "'" << endl;
									}
									else cerr << "Rotor: linking input " << i2 << " of node: '" << nodeID << "', cannot find target '" << fromID << "'" << endl;
								}
								else cerr << "Rotor: input " << i2 << " of node: '" << nodeID << "' does not exist" << endl;

							}
							uint32_t n3=xml.getNumTags("image_input");
							for (uint32_t i3=0;i3<n3;i3++){
								//handle expandable inputs
								if ((((Image_node*)nodes[nodeID])->image_inputs.size()<i3)&&((Image_node*)nodes[nodeID])->duplicate_inputs){
									string desc=((Image_node*)nodes[nodeID])->image_inputs[0]->description;
									string title=((Image_node*)nodes[nodeID])->image_inputs[0]->title;
									while(((Image_node*)nodes[nodeID])->image_inputs.size()<i3){
										((Image_node*)nodes[nodeID])->create_image_input(desc,title);
									}
								}
								//((Image_node*)nodes[nodeID])->create_image_input(xml.getValue("image_input","",i3));
								if (((Image_node*)nodes[nodeID])->image_inputs.size()>i3) {
									string fromID=xml.getAttribute("image_input","from","",i3);
									if (nodes.find(fromID)!=nodes.end()) {
										if (!(((Image_node*)nodes[nodeID])->image_inputs[i3]->connect((Image_node*)nodes[fromID]))){
											cerr << "Rotor: graph loader cannot connect image input " << i3 << " of node '" << nodeID << "' to node '" << fromID << "'" << endl;
											return false;
										}
										else cerr << "Rotor: linked image input " << i3 << " of node '" << nodeID << "' to node '" << fromID << "'" << endl;
									}
									else cerr << "Rotor: linking image input " << i3 << " of node: '" << nodeID << "', cannot find target '" << fromID << "'" << endl;
								}
								else cerr << "Rotor: image input number " << i3 << " of node: '" << nodeID << "' does not exist" << endl;
							}
							int n4=xml.getNumTags("parameter");
							for (int i4=0;i4<n4;i4++){
								string parameter=xml.getAttribute("parameter","name","",i4);
								if (nodes[nodeID]->parameters.find(parameter)!=nodes[nodeID]->parameters.end()) {
									string val=xml.getAttribute("parameter","value","",i4);
									if (val!="") nodes[nodeID]->parameters.find(parameter)->second->value=toFloat(val);
									string fromID=xml.getAttribute("parameter","from","",i4);
									if (nodes.find(fromID)!=nodes.end()) {
										if (!nodes[nodeID]->parameters[parameter]->connect(nodes[fromID])){
											cerr << "Rotor: graph loader cannot connect parameter input " << i4 << " of node '" << nodeID << "' to node '" << fromID << "'" << endl;
											return false;
										}
										else cerr << "Rotor: linked parameter input " << i4 << " of node '" << nodeID << "' to node '" << fromID << "'" << endl;
									}
									else if (fromID!="") cerr << "Rotor: linking parameter input " << i4 << " of node: '" << nodeID << "', cannot find target '" << fromID << "'" << endl;
								}
								else cerr << "Rotor: cannot find parameter input '" << parameter << "' of "<<nodetype<<" "<< nodeID << endl;
							}
							//still support old parameter_input
							n4=xml.getNumTags("parameter_input");
							for (int i4=0;i4<n4;i4++){
								string parameter=xml.getAttribute("parameter_input","name","",i4);
								if (nodes[nodeID]->parameters.find(parameter)!=nodes[nodeID]->parameters.end()) {
									string val=xml.getAttribute("parameter_input","value","",i4);
									if (val!="") nodes[nodeID]->parameters.find(parameter)->second->value=toFloat(val);
									string fromID=xml.getAttribute("parameter_input","from","",i4);
									if (nodes.find(fromID)!=nodes.end()) {
										if (!nodes[nodeID]->parameters[parameter]->connect(nodes[fromID])){
											cerr << "Rotor: graph loader cannot connect parameter input " << i4 << " of node '" << nodeID << "' to node '" << fromID << "'" << endl;
											return false;
										}
										else cerr << "Rotor: linked parameter input " << i4 << " of node '" << nodeID << "' to node '" << fromID << "'" << endl;
									}
									else cerr << "Rotor: linking parameter input " << i4 << " of node: '" << nodeID << "', cannot find target '" << fromID << "'" << endl;
								}
								else cerr << "Rotor: cannot find parameter input '" << parameter << "' of "<<nodetype<<" "<< nodeID << endl;
							}
							//extra key/value pairs that can be specific to sub-settings - WHAT WAS THIS
							//int n5=xml.getNumTags("parameter");
							//for (int i5=0;i5<n5;i5++){
							//	nodes[nodeID]->set_parameter(xml.getAttribute("parameter","name","",i5),xml.getAttribute("parameter","value","",i5));
							//}
							//if (n5>0) cerr << "Rotor: found " << n5 << " extra parameters for node '" << nodeID << "'" << endl;
							//support attributes in tags
							n4=xml.getNumTags("attribute");
							for (int i4=0;i4<n4;i4++){
								string attribute=xml.getAttribute("attribute","name","",i4);
								if (nodes[nodeID]->attributes.find(attribute)!=nodes[nodeID]->attributes.end()) {
									string val=xml.getAttribute("attribute","value","",i4);
									if (val!="") nodes[nodeID]->attributes.find(attribute)->second->value=val;
									string type=xml.getAttribute("attribute","type","",i4);
									if (nodes[nodeID]->attributes.find(attribute)->second->type=="array"){
										if(xml.pushTag("attribute",i4)) {
											int n5=xml.getNumTags("value");
											std::vector<std::string> vals;
											for (int i5=0;i5<n5;i5++){
												vals.push_back(xml.getValue("value","",i5));
											}
											nodes[nodeID]->attributes.find(attribute)->second->init(vals);
											xml.popTag();
										}
									}
								}
								else cerr << "Rotor: cannot find attribute '" << attribute << "' of "<<nodetype<<" "<< nodeID << endl;
							}

							xml.popTag();
						}
					}
					else cerr << "Rotor: duplicate node '"<<nodeID<<"' "<< endl;
				}
				else {
					cerr << "Rotor: graph loader cannot find node '" << xml.getAttribute("node","type","",i1) << "'" << endl;
					return false;
				}
			}
			xml.popTag();
		}
		loaded=true;
		return true;
}
bool Graph::load_audio(const string &filename,vector<Audio_processor*> processors){
	if (filename.size()==0) return false;
	Logger& logger = Logger::get("Rotor");
	logger.information("Analysing "+filename+" seed:"+toString(analysis_seed));


	//audio_loaded=false;
	libav::audio_decoder loader;
	if (!loader.open(filename)) {
		logger.error("ERROR: Could not open audio: "+filename);
		return false;
	}

	duration=loader.get_duration();

    int rate = loader.get_sample_rate();
	int samples = loader.get_number_samples();
	int channels= loader.get_number_channels();
	int bits = loader.get_bit_depth();

	for (auto p: processors) {
		if(!p->init(channels,bits,samples,rate) ){
			logger.error("ERROR: Audio plugin failed to initialse");
			return false;
		}
	}

	bool finished=false;
	uint16_t *audio=new uint16_t[1024*loader.get_number_channels()];
	uint64_t sample=0;

	srand(analysis_seed);

	while (!finished&&!cancelled)
	{
		if (loader.get_samples(audio,sample,1024)) {
			//now we can pass the data to the processor(s)
			for (auto p: processors) {
				p->process_frame((uint8_t*)audio,1024);
			}
			sample+=1024;
			//mutex.lock();
			progress=((float)sample)/samples; //atomic on 64 bit?
			//mutex.unlock();

		}
		else finished=true;
	}

	loader.cleanup();

	for (auto p: processors) {
		p->cleanup();
		p->print_summary();
	}

	logger.information("Finished audio analysis");
	//audio_loaded=true;
	return true;
}
bool Graph::load_video(const string &nodeID,const string &filename){
	//this is a good standard example of how to find
	//a node of a specific type by ID and do something
	if (nodes.find(nodeID)!=nodes.end()){
		if (nodes[nodeID]->type=="video_loader") {
			if (((Video_loader*)nodes[nodeID])->load(filename)) {
				return true;
			}
		}
	}
	return false;
}