gtk2_ardour/sfdb_freesound_mootcher.cc

   1 /* sfdb_freesound_mootcher.cpp **********************************************************************
   2
   3         Adapted for Ardour by Ben Loftis, March 2008
   4         Updated to new Freesound API by Colin Fletcher, November 2011
   5
   6         Mootcher 23-8-2005
   7
   8         Mootcher Online Access to thefreesoundproject website
   9         http://freesound.iua.upf.edu/
  10
  11         GPL 2005 Jorn Lemon
  12         mail for questions/remarks: mootcher@twistedlemon.nl
  13         or go to the freesound website forum
  14
  15         -----------------------------------------------------------------
  16
  17         Includes:
  18                 curl.h    (version 7.14.0)
  19         Librarys:
  20                 libcurl.lib
  21
  22         -----------------------------------------------------------------
  23         Licence GPL:
  24
  25         This program is free software; you can redistribute it and/or
  26         modify it under the terms of the GNU General Public License
  27         as published by the Free Software Foundation; either version 2
  28         of the License, or (at your option) any later version.
  29
  30         This program is distributed in the hope that it will be useful,
  31         but WITHOUT ANY WARRANTY; without even the implied warranty of
  32         MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  33         GNU General Public License for more details.
  34
  35         You should have received a copy of the GNU General Public License
  36         along with this program; if not, write to the Free Software
  37         Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  38
  39
  40 *************************************************************************************/
  41 #include "sfdb_freesound_mootcher.h"
  42
  43 #include "pbd/xml++.h"
  44 #include "pbd/error.h"
  45
  46 #include <sys/stat.h>
  47 #include <sys/types.h>
  48 #include <iostream>
  49
  50 #include <glib.h>
  51 #include "pbd/gstdio_compat.h"
  52
  53 #include "pbd/i18n.h"
  54
  55 #include "ardour/audio_library.h"
  56 #include "ardour/rc_configuration.h"
  57 #include "pbd/pthread_utils.h"
  58 #include "gui_thread.h"
  59
  60 using namespace PBD;
  61
  62 static const std::string base_url = "http://www.freesound.org/api";
  63 static const std::string api_key = "9d77cb8d841b4bcfa960e1aae62224eb"; // ardour3
  64
  65 //------------------------------------------------------------------------
  66 Mootcher::Mootcher()
  67         : curl(curl_easy_init())
  68 {
  69         cancel_download_btn.set_label (_("Cancel"));
  70         progress_hbox.pack_start (progress_bar, true, true);
  71         progress_hbox.pack_end (cancel_download_btn, false, false);
  72         progress_bar.show();
  73         cancel_download_btn.show();
  74         cancel_download_btn.signal_clicked().connect(sigc::mem_fun (*this, &Mootcher::cancelDownload));
  75 };
  76 //------------------------------------------------------------------------
  77 Mootcher:: ~Mootcher()
  78 {
  79         curl_easy_cleanup(curl);
  80 }
  81
  82 //------------------------------------------------------------------------
  83
  84 void Mootcher::ensureWorkingDir ()
  85 {
  86         std::string p = ARDOUR::Config->get_freesound_download_dir();
  87
  88         if (!Glib::file_test (p, Glib::FILE_TEST_IS_DIR)) {
  89                 if (g_mkdir_with_parents (p.c_str(), 0775) != 0) {
  90                         PBD::error << "Unable to create Mootcher working dir" << endmsg;
  91                 }
  92         }
  93         basePath = p;
  94 #ifdef PLATFORM_WINDOWS
  95         std::string replace = "/";
  96         size_t pos = basePath.find("\\");
  97         while( pos != std::string::npos ){
  98                 basePath.replace(pos, 1, replace);
  99                 pos = basePath.find("\\");
 100         }
 101 #endif
 102 }
 103
 104
 105 //------------------------------------------------------------------------
 106 size_t Mootcher::WriteMemoryCallback(void *ptr, size_t size, size_t nmemb, void *data)
 107 {
 108         int realsize = (int)(size * nmemb);
 109         struct MemoryStruct *mem = (struct MemoryStruct *)data;
 110
 111         mem->memory = (char *)realloc(mem->memory, mem->size + realsize + 1);
 112
 113         if (mem->memory) {
 114                 memcpy(&(mem->memory[mem->size]), ptr, realsize);
 115                 mem->size += realsize;
 116                 mem->memory[mem->size] = 0;
 117         }
 118         return realsize;
 119 }
 120
 121
 122 //------------------------------------------------------------------------
 123
 124 std::string Mootcher::sortMethodString(enum sortMethod sort)
 125 {
 126 // given a sort type, returns the string value to be passed to the API to
 127 // sort the results in the requested way.
 128
 129         switch (sort) {
 130                 case sort_duration_desc:        return "duration_desc";
 131                 case sort_duration_asc:         return "duration_asc";
 132                 case sort_created_desc:         return "created_desc";
 133                 case sort_created_asc:          return "created_asc";
 134                 case sort_downloads_desc:       return "downloads_desc";
 135                 case sort_downloads_asc:        return "downloads_asc";
 136                 case sort_rating_desc:          return "rating_desc";
 137                 case sort_rating_asc:           return "rating_asc";
 138                 default:                        return "";
 139         }
 140 }
 141
 142 //------------------------------------------------------------------------
 143 void Mootcher::setcUrlOptions()
 144 {
 145         // basic init for curl
 146         curl_global_init(CURL_GLOBAL_ALL);
 147         // some servers don't like requests that are made without a user-agent field, so we provide one
 148         curl_easy_setopt(curl, CURLOPT_USERAGENT, "libcurl-agent/1.0");
 149         // setup curl error buffer
 150         curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, errorBuffer);
 151         // Allow redirection
 152         curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1);
 153
 154         // Allow connections to time out (without using signals)
 155         curl_easy_setopt(curl, CURLOPT_NOSIGNAL, 1);
 156         curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 30);
 157
 158
 159 }
 160
 161 std::string Mootcher::doRequest(std::string uri, std::string params)
 162 {
 163         std::string result;
 164         struct MemoryStruct xml_page;
 165         xml_page.memory = NULL;
 166         xml_page.size = 0;
 167
 168         setcUrlOptions();
 169         curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteMemoryCallback);
 170         curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *) &xml_page);
 171
 172         // curl_easy_setopt(curl, CURLOPT_HTTPGET, 1);
 173         // curl_easy_setopt(curl, CURLOPT_POSTFIELDS, postMessage.c_str());
 174         // curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, -1);
 175
 176         // the url to get
 177         std::string url = base_url + uri + "?";
 178         if (params != "") {
 179                 url += params + "&api_key=" + api_key + "&format=xml";
 180         } else {
 181                 url += "api_key=" + api_key + "&format=xml";
 182         }
 183
 184         curl_easy_setopt(curl, CURLOPT_URL, url.c_str() );
 185
 186         // perform online request
 187         CURLcode res = curl_easy_perform(curl);
 188         if( res != 0 ) {
 189                 error << string_compose (_("curl error %1 (%2)"), res, curl_easy_strerror(res)) << endmsg;
 190                 return "";
 191         }
 192
 193         // free the memory
 194         if (xml_page.memory) {
 195                 result = xml_page.memory;
 196         }
 197
 198         free (xml_page.memory);
 199         xml_page.memory = NULL;
 200         xml_page.size = 0;
 201
 202         return result;
 203 }
 204
 205
 206 std::string Mootcher::searchSimilar(std::string id)
 207 {
 208         std::string params = "";
 209
 210         params += "&fields=id,original_filename,duration,filesize,samplerate,license,serve";
 211         params += "&num_results=100";
 212
 213         return doRequest("/sounds/" + id + "/similar", params);
 214 }
 215
 216 //------------------------------------------------------------------------
 217
 218 std::string Mootcher::searchText(std::string query, int page, std::string filter, enum sortMethod sort)
 219 {
 220         std::string params = "";
 221         char buf[24];
 222
 223         if (page > 1) {
 224                 snprintf(buf, 23, "p=%d&", page);
 225                 params += buf;
 226         }
 227
 228         char *eq = curl_easy_escape(curl, query.c_str(), query.length());
 229         params += "q=\"" + std::string(eq) + "\"";
 230         free(eq);
 231
 232         if (filter != "") {
 233                 char *ef = curl_easy_escape(curl, filter.c_str(), filter.length());
 234                 params += "&f=" + std::string(ef);
 235                 free(ef);
 236         }
 237
 238         if (sort)
 239                 params += "&s=" + sortMethodString(sort);
 240
 241         params += "&fields=id,original_filename,duration,filesize,samplerate,license,serve";
 242         params += "&sounds_per_page=100";
 243
 244         return doRequest("/sounds/search", params);
 245 }
 246
 247 //------------------------------------------------------------------------
 248
 249 std::string Mootcher::getSoundResourceFile(std::string ID)
 250 {
 251
 252         std::string originalSoundURI;
 253         std::string audioFileName;
 254         std::string xml;
 255
 256
 257         // download the xmlfile into xml_page
 258         xml = doRequest("/sounds/" + ID, "");
 259
 260         XMLTree doc;
 261         doc.read_buffer( xml.c_str() );
 262         XMLNode *freesound = doc.root();
 263
 264         // if the page is not a valid xml document with a 'freesound' root
 265         if (freesound == NULL) {
 266                 error << _("getSoundResourceFile: There is no valid root in the xml file") << endmsg;
 267                 return "";
 268         }
 269
 270         if (strcmp(doc.root()->name().c_str(), "response") != 0) {
 271                 error << string_compose (_("getSoundResourceFile: root = %1, != response"), doc.root()->name()) << endmsg;
 272                 return "";
 273         }
 274
 275         XMLNode *name = freesound->child("original_filename");
 276
 277         // get the file name and size from xml file
 278         if (name) {
 279
 280                 audioFileName = Glib::build_filename (basePath, ID + "-" + name->child("text")->content());
 281
 282                 //store all the tags in the database
 283                 XMLNode *tags = freesound->child("tags");
 284                 if (tags) {
 285                         XMLNodeList children = tags->children();
 286                         XMLNodeConstIterator niter;
 287                         std::vector<std::string> strings;
 288                         for (niter = children.begin(); niter != children.end(); ++niter) {
 289                                 XMLNode *node = *niter;
 290                                 if( strcmp( node->name().c_str(), "resource") == 0 ) {
 291                                         XMLNode *text = node->child("text");
 292                                         if (text) {
 293                                                 // std::cerr << "tag: " << text->content() << std::endl;
 294                                                 strings.push_back(text->content());
 295                                         }
 296                                 }
 297                         }
 298                         ARDOUR::Library->set_tags (std::string("//")+audioFileName, strings);
 299                         ARDOUR::Library->save_changes ();
 300                 }
 301         }
 302
 303         return audioFileName;
 304 }
 305
 306 int audioFileWrite(void *buffer, size_t size, size_t nmemb, void *file)
 307 {
 308         return (int)fwrite(buffer, size, nmemb, (FILE*) file);
 309 };
 310
 311 //------------------------------------------------------------------------
 312
 313 void *
 314 Mootcher::threadFunc() {
 315 CURLcode res;
 316
 317         res = curl_easy_perform (curl);
 318         fclose (theFile);
 319         curl_easy_setopt (curl, CURLOPT_NOPROGRESS, 1); // turn off the progress bar
 320
 321         if (res != CURLE_OK) {
 322                 /* it's not an error if the user pressed the stop button */
 323                 if (res != CURLE_ABORTED_BY_CALLBACK) {
 324                         error <<  string_compose (_("curl error %1 (%2)"), res, curl_easy_strerror(res)) << endmsg;
 325                 }
 326                 remove ( (audioFileName+".part").c_str() );
 327         } else {
 328                 rename ( (audioFileName+".part").c_str(), audioFileName.c_str() );
 329                 // now download the tags &c.
 330                 getSoundResourceFile(ID);
 331         }
 332
 333         return (void *) res;
 334 }
 335
 336 void
 337 Mootcher::doneWithMootcher()
 338 {
 339
 340         // update the sound info pane if the selection in the list box is still us
 341         sfb->refresh_display(ID, audioFileName);
 342
 343         delete this; // this should be OK to do as long as Progress and Finished signals are always received in the order in which they are emitted
 344 }
 345
 346 static void *
 347 freesound_download_thread_func(void *arg)
 348 {
 349         Mootcher *thisMootcher = (Mootcher *) arg;
 350         void *res;
 351
 352         // std::cerr << "freesound_download_thread_func(" << arg << ")" << std::endl;
 353         res = thisMootcher->threadFunc();
 354
 355         thisMootcher->Finished(); /* EMIT SIGNAL */
 356         return res;
 357 }
 358
 359
 360 //------------------------------------------------------------------------
 361
 362 bool Mootcher::checkAudioFile(std::string originalFileName, std::string theID)
 363 {
 364         ensureWorkingDir();
 365         ID = theID;
 366         audioFileName = Glib::build_filename (basePath, ID + "-" + originalFileName);
 367
 368         // check to see if audio file already exists
 369         FILE *testFile = g_fopen(audioFileName.c_str(), "r");
 370         if (testFile) {
 371                 fseek (testFile , 0 , SEEK_END);
 372                 if (ftell (testFile) > 256) {
 373                         fclose (testFile);
 374                         return true;
 375                 }
 376
 377                 // else file was small, probably an error, delete it
 378                 fclose(testFile);
 379                 remove( audioFileName.c_str() );
 380         }
 381         return false;
 382 }
 383
 384
 385 bool Mootcher::fetchAudioFile(std::string originalFileName, std::string theID, std::string audioURL, SoundFileBrowser *caller)
 386 {
 387         ensureWorkingDir();
 388         ID = theID;
 389         audioFileName = Glib::build_filename (basePath, ID + "-" + originalFileName);
 390
 391         if (!curl) {
 392                 return false;
 393         }
 394         // now download the actual file
 395         theFile = g_fopen( (audioFileName + ".part").c_str(), "wb" );
 396
 397         if (!theFile) {
 398                 return false;
 399         }
 400
 401         // create the download url
 402         audioURL += "?api_key=" + api_key;
 403
 404         setcUrlOptions();
 405         curl_easy_setopt(curl, CURLOPT_URL, audioURL.c_str() );
 406         curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, audioFileWrite);
 407         curl_easy_setopt(curl, CURLOPT_WRITEDATA, theFile);
 408
 409         std::string prog;
 410         prog = string_compose (_("%1"), originalFileName);
 411         progress_bar.set_text(prog);
 412
 413         Gtk::VBox *freesound_vbox = dynamic_cast<Gtk::VBox *> (caller->notebook.get_nth_page(2));
 414         freesound_vbox->pack_start(progress_hbox, Gtk::PACK_SHRINK);
 415         progress_hbox.show();
 416         cancel_download = false;
 417         sfb = caller;
 418
 419         curl_easy_setopt (curl, CURLOPT_NOPROGRESS, 0); // turn on the progress bar
 420         curl_easy_setopt (curl, CURLOPT_PROGRESSFUNCTION, progress_callback);
 421         curl_easy_setopt (curl, CURLOPT_PROGRESSDATA, this);
 422
 423         Progress.connect(*this, invalidator (*this), boost::bind(&Mootcher::updateProgress, this, _1, _2), gui_context());
 424         Finished.connect(*this, invalidator (*this), boost::bind(&Mootcher::doneWithMootcher, this), gui_context());
 425         pthread_t freesound_download_thread;
 426         pthread_create_and_store("freesound_import", &freesound_download_thread, freesound_download_thread_func, this);
 427
 428         return true;
 429 }
 430
 431 //---------
 432
 433 void
 434 Mootcher::updateProgress(double dlnow, double dltotal)
 435 {
 436         if (dltotal > 0) {
 437                 double fraction = dlnow / dltotal;
 438                 // std::cerr << "progress idle: " << progress->bar->get_text() << ". " << progress->dlnow << " / " << progress->dltotal << " = " << fraction << std::endl;
 439                 if (fraction > 1.0) {
 440                         fraction = 1.0;
 441                 } else if (fraction < 0.0) {
 442                         fraction = 0.0;
 443                 }
 444                 progress_bar.set_fraction(fraction);
 445         }
 446 }
 447
 448 int
 449 Mootcher::progress_callback(void *caller, double dltotal, double dlnow, double /*ultotal*/, double /*ulnow*/)
 450 {
 451         // It may seem curious to pass a pointer to an instance of an object to a static
 452         // member function, but we can't use a normal member function as a curl progress callback,
 453         // and we want access to some private members of Mootcher.
 454
 455         Mootcher *thisMootcher = (Mootcher *) caller;
 456
 457         if (thisMootcher->cancel_download) {
 458                 return -1;
 459         }
 460
 461         thisMootcher->Progress(dlnow, dltotal); /* EMIT SIGNAL */
 462         return 0;
 463 }
 464