src/song.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2008-2009 by Andrzej Rybczak                            *
   3  *   electricityispower@gmail.com                                          *
   4  *                                                                         *
   5  *   This program is free software; you can redistribute it and/or modify  *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation; either version 2 of the License, or     *
   8  *   (at your option) any later version.                                   *
   9  *                                                                         *
  10  *   This program is distributed in the hope that it will be useful,       *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13  *   GNU General Public License for more details.                          *
  14  *                                                                         *
  15  *   You should have received a copy of the GNU General Public License     *
  16  *   along with this program; if not, write to the                         *
  17  *   Free Software Foundation, Inc.,                                       *
  18  *   51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.              *
  19  ***************************************************************************/
  20
  21 #include <curl/curl.h>
  22 #include <cstring>
  23 #include <fstream>
  24 #include <string>
  25
  26 #include "callback.h"
  27 #include "misc.h"
  28 #include "scrobby.h"
  29 #include "song.h"
  30
  31 using std::string;
  32
  33 extern Handshake myHandshake;
  34
  35 std::deque<std::string> MPD::Song::Queue;
  36
  37 MPD::Song::Song() : Data(0),
  38                     StartTime(0),
  39                     Playback(0),
  40                     itsIsStream(0)
  41 {
  42 }
  43
  44 MPD::Song::~Song()
  45 {
  46         if (Data)
  47                 mpd_freeSong(Data);
  48 }
  49
  50 void MPD::Song::Clear()
  51 {
  52         if (Data)
  53                 mpd_freeSong(Data);
  54         Data = 0;
  55         StartTime = 0;
  56         Playback = 0;
  57         itsIsStream = 0;
  58 }
  59
  60 void MPD::Song::SetData(mpd_Song *song)
  61 {
  62         if (!song)
  63                 return;
  64         if (Data)
  65                 mpd_freeSong(Data);
  66         Data = song;
  67         itsIsStream = strncmp("http://", Data->file, 7) == 0;
  68 }
  69
  70 void MPD::Song::Submit()
  71 {
  72         if (!Data)
  73                 return;
  74
  75         if (itsIsStream)
  76                 Data->time = Playback;
  77
  78         if (canBeSubmitted())
  79         {
  80                 if (!Queue.empty())
  81                 {
  82                         Log(llInfo, "Adding song to queue...");
  83                         Cache();
  84                         Clear();
  85                         SendQueue();
  86                         return;
  87                 }
  88
  89                 if (myHandshake.Status != "OK" || myHandshake.SubmissionURL.empty())
  90                 {
  91                         Log(llInfo, "Problem with handshake, queue song at position %d...", Song::Queue.size());
  92                         Cache();
  93                         Clear();
  94                         return;
  95                 }
  96
  97                 Log(llInfo, "Submitting song...");
  98
  99                 std::ostringstream postdata;
 100                 string result, postdata_str;
 101                 CURLcode code;
 102
 103                 char *c_artist = curl_easy_escape(0, Data->artist, 0);
 104                 char *c_title = curl_easy_escape(0, Data->title, 0);
 105                 char *c_album = Data->album ? curl_easy_escape(0, Data->album, 0) : NULL;
 106                 char *c_track = Data->track ? curl_easy_escape(0, Data->track, 0) : NULL;
 107                 char *c_mb_trackid = Data->musicbrainz_trackid ? curl_easy_escape(0, Data->musicbrainz_trackid, 0) : NULL;
 108
 109                 postdata
 110                 << "s=" << myHandshake.SessionID
 111                 << "&a[0]=" << c_artist
 112                 << "&t[0]=" << c_title
 113                 << "&i[0]=" << StartTime
 114                 << "&o[0]=P"
 115                 << "&r[0]="
 116                 << "&l[0]=" << Data->time
 117                 << "&b[0]=";
 118                 if (c_album)
 119                         postdata << c_album;
 120                 postdata << "&n[0]=";
 121                 if (c_track)
 122                         postdata << c_track;
 123                 postdata << "&m[0]=";
 124                 if (c_mb_trackid)
 125                         postdata << c_mb_trackid;
 126
 127                 curl_free(c_artist);
 128                 curl_free(c_title);
 129                 curl_free(c_album);
 130                 curl_free(c_track);
 131                 curl_free(c_mb_trackid);
 132
 133                 postdata_str = postdata.str();
 134
 135                 Log(llVerbose, "URL: %s", myHandshake.SubmissionURL.c_str());
 136                 Log(llVerbose, "Post data: %s", postdata_str.c_str());
 137
 138                 CURL *submission = curl_easy_init();
 139                 curl_easy_setopt(submission, CURLOPT_URL, myHandshake.SubmissionURL.c_str());
 140                 curl_easy_setopt(submission, CURLOPT_POST, 1);
 141                 curl_easy_setopt(submission, CURLOPT_POSTFIELDS, postdata_str.c_str());
 142                 curl_easy_setopt(submission, CURLOPT_WRITEFUNCTION, write_data);
 143                 curl_easy_setopt(submission, CURLOPT_WRITEDATA, &result);
 144                 curl_easy_setopt(submission, CURLOPT_CONNECTTIMEOUT, curl_connecttimeout);
 145                 curl_easy_setopt(submission, CURLOPT_TIMEOUT, curl_timeout);
 146                 curl_easy_setopt(submission, CURLOPT_DNS_CACHE_TIMEOUT, 0);
 147                 curl_easy_setopt(submission, CURLOPT_NOPROGRESS, 1);
 148                 curl_easy_setopt(submission, CURLOPT_NOSIGNAL, 1);
 149                 code = curl_easy_perform(submission);
 150                 curl_easy_cleanup(submission);
 151
 152                 IgnoreNewlines(result);
 153
 154                 if (result == "OK")
 155                 {
 156                         Log(llInfo, "Song submitted.");
 157                 }
 158                 else
 159                 {
 160                         if (result.empty())
 161                         {
 162                                 Log(llInfo, "Error while submitting song: %s", curl_easy_strerror(code));
 163                         }
 164                         else
 165                         {
 166                                 Log(llInfo, "Audioscrobbler returned status %s", result.c_str());
 167                                 myHandshake.Clear(); // handshake probably failed if we are here, so reset it
 168                                 Log(llVerbose, "Handshake reset");
 169                         }
 170                         Cache();
 171                 }
 172         }
 173         Clear();
 174 }
 175
 176 void MPD::Song::Cache()
 177 {
 178         std::ostringstream cache;
 179         string cache_str;
 180
 181         char *c_artist = curl_easy_escape(0, Data->artist, 0);
 182         char *c_title = curl_easy_escape(0, Data->title, 0);
 183         char *c_album = Data->album ? curl_easy_escape(0, Data->album, 0) : NULL;
 184         char *c_track = Data->track ? curl_easy_escape(0, Data->track, 0) : NULL;
 185         char *c_mb_trackid = Data->musicbrainz_trackid ? curl_easy_escape(0, Data->musicbrainz_trackid, 0) : NULL;
 186
 187         cache
 188         << "&a[" << Song::Queue.size() << "]=" << c_artist
 189         << "&t[" << Song::Queue.size() << "]=" << c_title
 190         << "&i[" << Song::Queue.size() << "]=" << StartTime
 191         << "&o[" << Song::Queue.size() << "]=P"
 192         << "&r[" << Song::Queue.size() << "]="
 193         << "&l[" << Song::Queue.size() << "]=" << Data->time
 194         << "&b[" << Song::Queue.size() << "]=";
 195         if (c_album)
 196                 cache << c_album;
 197         cache << "&n[" << Song::Queue.size() << "]=";
 198         if (c_track)
 199                 cache << c_track;
 200         cache << "&m[" << Song::Queue.size() << "]=";
 201         if (c_mb_trackid)
 202                 cache << c_mb_trackid;
 203
 204         cache_str = cache.str();
 205
 206         Log(llVerbose, "Metadata: %s", cache_str.c_str());
 207
 208         curl_free(c_artist);
 209         curl_free(c_title);
 210         curl_free(c_album);
 211         curl_free(c_track);
 212         curl_free(c_mb_trackid);
 213
 214         WriteCache(cache_str);
 215         Song::Queue.push_back(cache_str);
 216         Log(llInfo, "Song cached.");
 217 }
 218
 219 bool MPD::Song::isStream() const
 220 {
 221         return itsIsStream;
 222 }
 223
 224 bool MPD::Song::canBeSubmitted()
 225 {
 226         if (!StartTime || Data->time < 30 || !Data->artist || !Data->title)
 227         {
 228                 if (!StartTime)
 229                 {
 230                         Log(llInfo, "Song's start time wasn't known, not submitting.");
 231                 }
 232                 else if (Data->time < 30)
 233                 {
 234                         Log(llInfo, "Song's length is too short, not submitting.");
 235                 }
 236                 else if (!Data->artist || !Data->title)
 237                 {
 238                         Log(llInfo, "Song has missing tags, not submitting.");
 239                 }
 240                 return false;
 241         }
 242         else if (Playback < 4*60 && Playback < Data->time/2)
 243         {
 244                 Log(llInfo, "Noticed playback was too short, not submitting.");
 245                 return false;
 246         }
 247         return true;
 248 }
 249
 250 void MPD::Song::GetCached()
 251 {
 252         std::ifstream f(Config.file_cache.c_str());
 253         if (f.is_open())
 254         {
 255                 std::string line;
 256                 while (!f.eof())
 257                 {
 258                         getline(f, line);
 259                         if (!line.empty())
 260                                 Queue.push_back(line);
 261                 }
 262         }
 263 }
 264
 265 void MPD::Song::SendQueue()
 266 {
 267         if (Song::Queue.empty())
 268                 return;
 269
 270         Log(llInfo, "Submitting songs from queue...");
 271
 272         string result, postdata;
 273         CURLcode code;
 274
 275         postdata = "s=";
 276         postdata += myHandshake.SessionID;
 277
 278         for (std::deque<string>::const_iterator it = Song::Queue.begin(); it != Song::Queue.end(); it++)
 279                 postdata += *it;
 280
 281         Log(llVerbose, "URL: %s", myHandshake.SubmissionURL.c_str());
 282         Log(llVerbose, "Post data: %s", postdata.c_str());
 283
 284         CURL *submission = curl_easy_init();
 285         curl_easy_setopt(submission, CURLOPT_URL, myHandshake.SubmissionURL.c_str());
 286         curl_easy_setopt(submission, CURLOPT_POST, 1);
 287         curl_easy_setopt(submission, CURLOPT_POSTFIELDS, postdata.c_str());
 288         curl_easy_setopt(submission, CURLOPT_WRITEFUNCTION, write_data);
 289         curl_easy_setopt(submission, CURLOPT_WRITEDATA, &result);
 290         curl_easy_setopt(submission, CURLOPT_CONNECTTIMEOUT, curl_connecttimeout);
 291         curl_easy_setopt(submission, CURLOPT_TIMEOUT, curl_timeout);
 292         curl_easy_setopt(submission, CURLOPT_DNS_CACHE_TIMEOUT, 0);
 293         curl_easy_setopt(submission, CURLOPT_NOPROGRESS, 1);
 294         curl_easy_setopt(submission, CURLOPT_NOSIGNAL, 1);
 295         code = curl_easy_perform(submission);
 296         curl_easy_cleanup(submission);
 297
 298         IgnoreNewlines(result);
 299
 300         if (result == "OK")
 301         {
 302                 Log(llInfo, "Number of submitted songs: %d", Song::Queue.size());
 303                 Song::Queue.clear();
 304                 ClearCache();
 305         }
 306         else
 307         {
 308                 if (result.empty())
 309                 {
 310                         Log(llInfo, "Error while submitting songs: %s", curl_easy_strerror(code));
 311                 }
 312                 else
 313                 {
 314                         Log(llInfo, "Audioscrobbler returned status %s", result.c_str());
 315                 }
 316         }
 317 }
 318