merge 3.0 from 2.0-ongoing@3243

git-svn-id: svn://localhost/ardour2/branches/3.0@3248 d708f5d6-7413-0410-9779-e7cbd77b26cf

1 files changed, 502 insertions, 0 deletions

diff --git a/gtk2_ardour/sfdb_freesound_mootcher.cc b/gtk2_ardour/sfdb_freesound_mootcher.cc
new file mode 100644
index 0000000000..6c62939493
--- /dev/null
+++ b/gtk2_ardour/sfdb_freesound_mootcher.cc
@@ -0,0 +1,502 @@
+/* sfdb_freesound_mootcher.cpp **********************************************************************

+	

+	Adapted for Ardour by Ben Loftis, March 2008

+		

+	Mootcher 23-8-2005

+

+	Mootcher Online Access to thefreesoundproject website

+	http://freesound.iua.upf.edu/

+

+	GPL 2005 Jorn Lemon

+	mail for questions/remarks: mootcher@twistedlemon.nl

+	or go to the freesound website forum

+

+	-----------------------------------------------------------------

+

+	Includes:

+		curl.h    (version 7.14.0)

+	Librarys:

+		libcurl.lib

+

+	-----------------------------------------------------------------

+	Licence GPL:

+

+	This program is free software; you can redistribute it and/or

+	modify it under the terms of the GNU General Public License

+	as published by the Free Software Foundation; either version 2

+	of the License, or (at your option) any later version.

+

+	This program is distributed in the hope that it will be useful,

+	but WITHOUT ANY WARRANTY; without even the implied warranty of

+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

+	GNU General Public License for more details.

+

+	You should have received a copy of the GNU General Public License

+	along with this program; if not, write to the Free Software

+	Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

+

+

+*************************************************************************************/

+#include "sfdb_freesound_mootcher.h"

+

+#include <pbd/xml++.h>

+

+#include <sys/stat.h>

+#include <sys/types.h>

+

+#include <ardour/audio_library.h>

+

+#define TRUE 1

+

+//------------------------------------------------------------------------

+Mootcher::	Mootcher(const char *saveLocation)

+	: curl( NULL )

+	, connection( 0 )

+{

+	changeWorkingDir(saveLocation);

+};

+//------------------------------------------------------------------------

+Mootcher::	~Mootcher()

+{

+	remove( "cookiejar.txt" );

+}

+//------------------------------------------------------------------------

+const char* Mootcher::changeWorkingDir(const char *saveLocation)

+{

+	basePath = saveLocation;

+#ifdef __WIN32__

+	std::string replace = "/";

+	int pos = (int)basePath.find("\\");

+	while( pos != std::string::npos ){

+		basePath.replace(pos, 1, replace);

+		pos = (int)basePath.find("\\");

+	}

+#endif

+	// 

+	int pos2 = basePath.find_last_of("/");

+	if(basePath.length() != (pos2+1)) basePath += "/";

+	

+	// create Freesound directory and sound dir

+	std::string sndLocation = basePath;

+	mkdir(sndLocation.c_str(), 0777);        

+	sndLocation += "snd";

+	mkdir(sndLocation.c_str(), 0777);        

+

+	return basePath.c_str();

+}

+

+//------------------------------------------------------------------------

+size_t		Mootcher::WriteMemoryCallback(void *ptr, size_t size, size_t nmemb, void *data)

+{

+	register int realsize = (int)(size * nmemb);

+	struct MemoryStruct *mem = (struct MemoryStruct *)data;

+

+	// There might be a realloc() out there that doesn't like 

+	// reallocing NULL pointers, so we take care of it here

+	if(mem->memory)	mem->memory = (char *)realloc(mem->memory, mem->size + realsize + 1);

+	else			mem->memory = (char *)malloc(mem->size + realsize + 1);

+

+	if (mem->memory) {

+		memcpy(&(mem->memory[mem->size]), ptr, realsize);

+		mem->size += realsize;

+		mem->memory[mem->size] = 0;

+	}

+	return realsize;

+}

+

+

+//------------------------------------------------------------------------

+void		Mootcher::toLog(std::string input)

+{

+printf("%s\n", input.c_str());// for debugging

+}

+

+

+//------------------------------------------------------------------------

+void		Mootcher::setcUrlOptions()

+{

+	// basic init for curl

+	curl_global_init(CURL_GLOBAL_ALL);

+	// some servers don't like requests that are made without a user-agent field, so we provide one

+	curl_easy_setopt(curl, CURLOPT_USERAGENT, "libcurl-agent/1.0");

+	// setup curl error buffer

+	CURLcode res = curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, errorBuffer);

+	// always use the cookie with session id which is received at the login

+	curl_easy_setopt(curl, CURLOPT_COOKIEFILE, "cookiejar.txt");

+	// Allow redirection

+	curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1);

+}

+

+//------------------------------------------------------------------------

+int			Mootcher::doLogin(std::string login, std::string password)

+{

+	if(connection==1)

+		return 1;

+	

+	struct MemoryStruct xml_page;

+	xml_page.memory = NULL;

+	xml_page.size = 0;

+

+	// create the post message from the login and password

+	std::string postMessage;

+	postMessage += "username=";

+	postMessage += curl_escape(login.c_str(), 0);

+	postMessage += "&password=";

+	postMessage += curl_escape(password.c_str(), 0);

+	postMessage += "&login=";

+	postMessage += curl_escape("1", 0);

+	postMessage += "&redirect=";

+	postMessage += curl_escape("../tests/login.php", 0);

+

+	// Do the setup for libcurl

+	curl = curl_easy_init();

+

+	if(curl)

+	{

+		setcUrlOptions();

+		curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteMemoryCallback); 

+		curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&xml_page);

+		// save the sessoin id that is given back by the server in a cookie

+		curl_easy_setopt(curl, CURLOPT_COOKIEJAR, "cookiejar.txt");

+		// use POST for login variables

+		curl_easy_setopt(curl, CURLOPT_POST, TRUE);

+		curl_easy_setopt(curl, CURLOPT_POSTFIELDS, postMessage.c_str());

+		curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, -1);

+

+		// the url to get

+		std::string login_url = "http://freesound.iua.upf.edu/forum/login.php";

+		curl_easy_setopt(curl, CURLOPT_URL, login_url.c_str() );

+

+		// perform online request

+		connection = 1;

+		CURLcode res = curl_easy_perform(curl);

+		if( res != 0 ) {

+			toLog("curl login error\n");

+			toLog(curl_easy_strerror(res));

+			connection = 0;

+		}

+		

+		if (connection == 1){

+			std::string check_page = xml_page.memory;

+			int test = (int)check_page.find("login");   //logged

+			if(	strcmp(xml_page.memory, "login") == 0 )

+				toLog("Logged in.\n");

+			else {

+				toLog("Login failed: Check username and password.\n");

+				connection = 0;

+			}

+		}

+

+		// free the memory

+		if(xml_page.memory){		

+			free( xml_page.memory );

+			xml_page.memory = NULL;

+			xml_page.size = 0;

+		}

+

+		std::cerr << "Login was cool, connection = "  << connection << std::endl;

+		return connection;

+	}

+	else return 3; // will be returned if a curl related problem ocurrs

+}

+//------------------------------------------------------------------------

+std::string	Mootcher::searchText(std::string word)

+{

+	struct MemoryStruct xml_page;

+	xml_page.memory = NULL;

+	xml_page.size = 0;

+	

+	std::string result;

+

+	if(connection != 0)

+	{

+		// create a url encoded post message

+		std::string postMessage;

+		char tempString[ 128 ];

+		char *tempPointer = &tempString[0];

+

+		postMessage = "search=";

+		postMessage += curl_escape(word.c_str(), 0);

+		sprintf( tempPointer, "&searchDescriptions=1");

+		postMessage += tempPointer;

+		sprintf( tempPointer, "&searchtags=1");

+		postMessage += tempPointer;

+		

+		if(curl)

+		{

+			// basic init for curl 

+			setcUrlOptions();	

+			curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteMemoryCallback); 

+			curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&xml_page);

+			// setup the post message

+			curl_easy_setopt(curl, CURLOPT_POST, TRUE);

+			curl_easy_setopt(curl, CURLOPT_POSTFIELDS, postMessage.c_str());

+			curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, -1);

+			

+			// the url to get

+			std::string search_url = "http://freesound.iua.upf.edu/searchTextXML.php";

+			curl_easy_setopt(curl, CURLOPT_URL, search_url.c_str());

+

+			// perform the online search 

+			connection = 1;

+			CURLcode res = curl_easy_perform(curl);

+			if( res != 0 ) {

+				toLog("curl login error\n");

+				toLog(curl_easy_strerror(res));

+				connection = 0;

+			}

+			

+			result = xml_page.memory;

+			toLog( result.c_str() );

+

+			// free the memory

+			if(xml_page.memory){

+				free( xml_page.memory );

+				xml_page.memory = NULL;

+				xml_page.size = 0;

+			}

+

+		}

+	}

+

+	return result;

+}

+

+//------------------------------------------------------------------------

+std::string Mootcher::changeExtension(std::string filename)

+{

+	std::string aiff = ".aiff";

+	std::string aif = ".aif";

+	std::string wav = ".wav";

+	std::string mp3 = ".mp3";

+	std::string ogg = ".ogg";

+	std::string flac = ".flac";

+

+	std::string replace = ".xml";

+	int pos = 0;

+

+ 	pos = (int)filename.find(aiff);

+	if(pos != std::string::npos) filename.replace(pos, aiff.size(), replace); 

+ 	pos = (int)filename.find(aif);

+	if(pos != std::string::npos) filename.replace(pos, aif.size(), replace); 

+ 	pos = (int)filename.find(wav);

+	if(pos != std::string::npos) filename.replace(pos, wav.size(), replace); 

+ 	pos = (int)filename.find(mp3);

+	if(pos != std::string::npos) filename.replace(pos, mp3.size(), replace); 

+ 	pos = (int)filename.find(ogg);

+	if(pos != std::string::npos) filename.replace(pos, ogg.size(), replace); 

+ 	pos = (int)filename.find(flac);

+	if(pos != std::string::npos) filename.replace(pos, flac.size(), replace); 

+

+	return filename;

+}

+//------------------------------------------------------------------------

+void		Mootcher::GetXml(std::string ID, struct MemoryStruct &xml_page)

+{

+

+	if(curl) {

+		setcUrlOptions();

+		curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteMemoryCallback); 

+		curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&xml_page);

+

+		// URL to get

+		std::string getxml_url = "http://freesound.iua.upf.edu/samplesViewSingleXML.php?id=";

+		getxml_url += ID;

+

+		curl_easy_setopt(curl, CURLOPT_URL, getxml_url.c_str() );

+ 		

+		// get it!

+		connection = 1;

+		CURLcode res = curl_easy_perform(curl);

+		if( res != 0 ) {

+			toLog("curl login error\n");

+			toLog(curl_easy_strerror(res));

+			connection = 0;

+		}

+	}

+}

+//------------------------------------------------------------------------

+std::string	Mootcher::getXmlFile(std::string ID, int &length)

+{

+	struct MemoryStruct xml_page;

+	xml_page.memory = NULL;

+	xml_page.size = NULL;

+

+	std::string xmlFileName;

+	std::string audioFileName;

+	std::string filename;

+	

+	if(connection != 0) {

+		// download the xmlfile into xml_page

+		GetXml(ID, xml_page);

+

+		// if sample ID does not exist on the freesound website

+		if(strcmp(xml_page.memory, "sample non existant") == 0){

+			free( xml_page.memory );

+			sprintf(message, "getXmlFile: sample with ID:%s does not exist!\n", ID.c_str() );

+			toLog(message);

+			return filename;

+		} else {

+			XMLTree doc;

+			doc.read_buffer( xml_page.memory );

+			XMLNode *freesound = doc.root();

+			

+			// if the page is not a valid xml document with a 'freesound' root

+			if( freesound == NULL){

+				sprintf(message, "getXmlFile: There is no valid root in the xml file");

+				toLog(message);

+			} else {

+				XMLNode *sample = freesound->child("sample");

+				XMLNode *name = NULL;

+				XMLNode *filesize = NULL;

+				if (sample) {

+					name = sample->child("originalFilename");

+					filesize = sample->child("filesize");

+				}

+				

+				// get the file name and size from xml file

+				if (sample && name && filesize) {

+					

+					audioFileName = name->child("text")->content();

+					sprintf( message, "getXmlFile: %s needs to be downloaded\n", audioFileName.c_str() );

+					toLog(message);

+

+					length = atoi(filesize->child("text")->content().c_str());

+

+					// create new filename with the ID number

+					filename = basePath;

+					filename += "snd/";

+					filename += sample->property("id")->value();

+					filename += "-";

+					filename += audioFileName;

+					// change the extention into .xml

+					xmlFileName = changeExtension( filename );

+

+					sprintf(message, "getXmlFile: saving XML: %s\n", xmlFileName.c_str() );

+					toLog(message);

+					

+					// save the xml file to disk

+					doc.write(xmlFileName.c_str());

+

+					//store all the tags in the database

+					XMLNode *tags = sample->child("tags");

+					if (tags) {

+						XMLNodeList children = tags->children();

+						XMLNodeConstIterator niter;

+						vector<string> strings;

+						for (niter = children.begin(); niter != children.end(); ++niter) {

+							XMLNode *node = *niter;

+							if( strcmp( node->name().c_str(), "tag") == 0 ) {

+								XMLNode *text = node->child("text");

+								if (text) strings.push_back(text->content());

+							}

+						}

+						ARDOUR::Library->set_tags (string("//")+filename, strings);

+						ARDOUR::Library->save_changes ();

+					}

+				}

+				

+				// clear the memory

+				if(xml_page.memory){

+					free( xml_page.memory );

+					xml_page.memory = NULL;

+					xml_page.size = 0;

+				}

+				return audioFileName;

+			}

+		}

+	}

+	else {

+		return audioFileName;

+	}

+

+}

+

+int audioFileWrite(void *buffer, size_t size, size_t nmemb, void *file)

+{

+	return (int)fwrite(buffer, size, nmemb, (FILE*) file);

+};

+

+//------------------------------------------------------------------------

+std::string	Mootcher::getFile(std::string ID)

+{

+	CURLcode result_curl;

+

+	std::string audioFileName;

+

+	if(connection != 0)

+	{

+		int length;

+		std::string name = getXmlFile(ID, length);

+		if( name != "" ){

+

+			// create new filename with the ID number

+			audioFileName += basePath;

+			audioFileName += "snd/";

+			audioFileName += ID;

+			audioFileName += "-";			

+			audioFileName += name;

+			

+			//check to see if audio file already exists

+			FILE *testFile = fopen(audioFileName.c_str(), "r");

+			if (testFile) {  //TODO:  should also check length to see if file is complete

+				fseek (testFile , 0 , SEEK_END);

+				if (ftell (testFile) == length) {

+					sprintf(message, "%s already exists\n", audioFileName.c_str() );

+					toLog(message);

+					fclose (testFile);

+					return audioFileName;

+				} else {

+					remove( audioFileName.c_str() );  //file was not correct length, delete it and try again

+				}					

+			}

+			

+

+			//now download the actual file

+			if (curl) {

+

+				FILE* theFile;

+				theFile = fopen( audioFileName.c_str(), "wb" );

+

+				// create the download url, this url will also update the download statics on the site

+				std::string audioURL;

+				audioURL += "http://freesound.iua.upf.edu/samplesDownload.php?id=";

+				audioURL += ID;

+

+				setcUrlOptions();

+				curl_easy_setopt(curl, CURLOPT_URL, audioURL.c_str() );

+				curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, audioFileWrite);

+				curl_easy_setopt(curl, CURLOPT_WRITEDATA, theFile);

+

+				connection = 1;

+				CURLcode res = curl_easy_perform(curl);

+				if( res != 0 ) {

+					toLog("curl login error\n");

+					toLog(curl_easy_strerror(res));

+					connection = 0;

+				}

+

+				fclose(theFile);

+			}

+	

+/*

+			bar.dlnowMoo = 0;

+			bar.dltotalMoo = 0;

+			curl_easy_setopt (curl, CURLOPT_NOPROGRESS, 0); // turn on the process bar thingy

+			curl_easy_setopt (curl, CURLOPT_PROGRESSFUNCTION, progress_callback);

+			curl_easy_setopt (curl, CURLOPT_PROGRESSDATA, &bar);

+*/				

+		}

+	}

+

+	return audioFileName;

+}

+

+//---------

+int Mootcher::progress_callback(void *bar, double dltotal, double dlnow, double ultotal, double ulnow)

+{

+	struct dlprocess *lbar = (struct dlprocess *) bar;

+	lbar->dltotalMoo = dltotal;

+	lbar->dlnowMoo = dlnow;

+	return 0;

+}