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 #ifdef HAVE_CONFIG_H
  22 #include <config.h>
  23 #endif
  24
  25 #include <cstring>
  26 #include <iomanip>
  27 #include <sstream>
  28 #include <stdexcept>
  29
  30 #include "charset.h"
  31 #include "conv.h"
  32 #include "error.h"
  33 #include "song.h"
  34
  35 namespace
  36 {
  37         unsigned calc_hash(const char *p)
  38         {
  39                 unsigned hash = 5381;
  40                 while (*p)
  41                         hash = (hash << 5) + hash + *p++;
  42                 return hash;
  43         }
  44 }
  45
  46 MPD::Song::Song(mpd_song *s, bool copy_ptr) :   itsSong(s),
  47                                                 itsFile(0),
  48                                                 itsTags(0),
  49                                                 itsSlash(std::string::npos),
  50                                                 itsHash(0),
  51                                                 copyPtr(copy_ptr),
  52                                                 isLocalised(0)
  53 {
  54         if (itsSong)
  55                 SetHashAndSlash();
  56 }
  57
  58 MPD::Song::Song(const Song &s) : itsSong(s.copyPtr ? s.itsSong : mpd_song_dup(s.itsSong)),
  59                                 itsFile(s.itsFile ? strdup(s.itsFile) : 0),
  60                                 itsTags(s.itsTags ? new TagMap(*s.itsTags) : 0),
  61                                 itsNewName(s.itsNewName),
  62                                 itsSlash(s.itsSlash),
  63                                 itsHash(s.itsHash),
  64                                 copyPtr(s.copyPtr),
  65                                 isLocalised(s.isLocalised)
  66 {
  67 }
  68
  69 MPD::Song::~Song()
  70 {
  71         if (itsSong)
  72                 mpd_song_free(itsSong);
  73         delete [] itsFile;
  74         delete itsTags;
  75 }
  76
  77 std::string MPD::Song::GetLength(unsigned pos) const
  78 {
  79         if (pos > 0)
  80                 return "";
  81         unsigned len = mpd_song_get_duration(itsSong);
  82         return !len ? "-:--" : ShowTime(len);
  83 }
  84
  85 void MPD::Song::Localize()
  86 {
  87 #       ifdef HAVE_ICONV_H
  88         if (isLocalised)
  89                 return;
  90         const char *tag, *conv_tag;
  91         conv_tag = tag = mpd_song_get_uri(itsSong);
  92         utf_to_locale(conv_tag, 0);
  93         if (tag != conv_tag) // file has been converted
  94         {
  95                 itsFile = conv_tag;
  96                 SetHashAndSlash();
  97         }
  98         for (unsigned t = MPD_TAG_ARTIST; t <= MPD_TAG_DISC; ++t)
  99         {
 100                 unsigned pos = 0;
 101                 for (; (tag = mpd_song_get_tag(itsSong, mpd_tag_type(t), pos)); ++pos)
 102                 {
 103                         conv_tag = tag;
 104                         utf_to_locale(conv_tag, 0);
 105                         if (tag != conv_tag) // tag has been converted
 106                         {
 107                                 SetTag(mpd_tag_type(t), pos, conv_tag);
 108                                 delete [] conv_tag;
 109                         }
 110                 }
 111         }
 112         isLocalised = 1;
 113 #       endif // HAVE_ICONV_H
 114 }
 115
 116 void MPD::Song::Clear()
 117 {
 118         if (itsSong)
 119                 mpd_song_free(itsSong);
 120         itsSong = 0;
 121
 122         delete [] itsFile;
 123         itsFile = 0;
 124
 125         delete itsTags;
 126         itsTags = 0;
 127
 128         itsNewName.clear();
 129         itsSlash = std::string::npos;
 130         itsHash = 0;
 131         isLocalised = 0;
 132         copyPtr = 0;
 133 }
 134
 135 bool MPD::Song::Empty() const
 136 {
 137         return !itsSong;
 138 }
 139
 140 bool MPD::Song::isFromDB() const
 141 {
 142         return (MyFilename()[0] != '/') || itsSlash == std::string::npos;
 143 }
 144
 145 bool MPD::Song::isStream() const
 146 {
 147         return !strncmp(MyFilename(), "http://", 7);
 148 }
 149
 150 std::string MPD::Song::GetFile(unsigned pos) const
 151 {
 152         return pos > 0 ? "" : MyFilename();
 153 }
 154
 155 std::string MPD::Song::GetName(unsigned pos) const
 156 {
 157         if (pos > 0)
 158                 return "";
 159         std::string name = GetTag(MPD_TAG_NAME, 0);
 160         if (!name.empty())
 161                 return name;
 162         else if (itsSlash != std::string::npos)
 163                 return MyFilename()+itsSlash+1;
 164         else
 165                 return MyFilename();
 166 }
 167
 168 std::string MPD::Song::GetDirectory(unsigned pos) const
 169 {
 170         if (pos > 0 || isStream())
 171                 return "";
 172         else if (itsSlash == std::string::npos)
 173                 return "/";
 174         else
 175                 return std::string(MyFilename(), itsSlash);
 176 }
 177
 178 std::string MPD::Song::GetArtist(unsigned pos) const
 179 {
 180         return GetTag(MPD_TAG_ARTIST, pos);
 181 }
 182
 183 std::string MPD::Song::GetTitle(unsigned pos) const
 184 {
 185         return GetTag(MPD_TAG_TITLE, pos);
 186 }
 187
 188 std::string MPD::Song::GetAlbum(unsigned pos) const
 189 {
 190         return GetTag(MPD_TAG_ALBUM, pos);
 191 }
 192
 193 std::string MPD::Song::GetTrack(unsigned pos) const
 194 {
 195         std::string track = GetTag(MPD_TAG_TRACK, pos);
 196         return (track.length() == 1 && track[0] != '0') || (track.length() > 3 && track[1] == '/') ? "0"+track : track;
 197 }
 198
 199 std::string MPD::Song::GetTrackNumber(unsigned pos) const
 200 {
 201         std::string track = GetTag(MPD_TAG_TRACK, pos);
 202         size_t slash = track.find('/');
 203         if (slash != std::string::npos)
 204                 track.resize(slash);
 205         return track.length() == 1 && track[0] != '0' ? "0"+track : track;
 206 }
 207
 208 std::string MPD::Song::GetDate(unsigned pos) const
 209 {
 210         return GetTag(MPD_TAG_DATE, pos);
 211 }
 212
 213 std::string MPD::Song::GetGenre(unsigned pos) const
 214 {
 215         return GetTag(MPD_TAG_GENRE, pos);
 216 }
 217
 218 std::string MPD::Song::GetComposer(unsigned pos) const
 219 {
 220         return GetTag(MPD_TAG_COMPOSER, pos);
 221 }
 222
 223 std::string MPD::Song::GetPerformer(unsigned pos) const
 224 {
 225         return GetTag(MPD_TAG_PERFORMER, pos);
 226 }
 227
 228 std::string MPD::Song::GetDisc(unsigned pos) const
 229 {
 230         return GetTag(MPD_TAG_DISC, pos);
 231 }
 232
 233 std::string MPD::Song::GetComment(unsigned pos) const
 234 {
 235         return GetTag(MPD_TAG_COMMENT, pos);
 236 }
 237
 238 std::string MPD::Song::GetTags(GetFunction f) const
 239 {
 240         unsigned pos = 0;
 241         std::string result;
 242         for (std::string tag; !(tag = (this->*f)(pos)).empty(); ++pos)
 243         {
 244                 if (!result.empty())
 245                         result += ", ";
 246                 result += tag;
 247         }
 248         return result;
 249 }
 250
 251 void MPD::Song::SetArtist(const std::string &str, unsigned pos)
 252 {
 253         SetTag(MPD_TAG_ARTIST, pos, str);
 254 }
 255
 256 void MPD::Song::SetTitle(const std::string &str, unsigned pos)
 257 {
 258         SetTag(MPD_TAG_TITLE, pos, str);
 259 }
 260
 261 void MPD::Song::SetAlbum(const std::string &str, unsigned pos)
 262 {
 263         SetTag(MPD_TAG_ALBUM, pos, str);
 264 }
 265
 266 void MPD::Song::SetTrack(const std::string &str, unsigned pos)
 267 {
 268         SetTag(MPD_TAG_TRACK, pos, str);
 269 }
 270
 271 void MPD::Song::SetTrack(unsigned track, unsigned pos)
 272 {
 273         SetTag(MPD_TAG_TRACK, pos, IntoStr(track));
 274 }
 275
 276 void MPD::Song::SetDate(const std::string &str, unsigned pos)
 277 {
 278         SetTag(MPD_TAG_DATE, pos, str);
 279 }
 280
 281 void MPD::Song::SetDate(unsigned year, unsigned pos)
 282 {
 283         SetTag(MPD_TAG_DATE, pos, IntoStr(year));
 284 }
 285
 286 void MPD::Song::SetGenre(const std::string &str, unsigned pos)
 287 {
 288         SetTag(MPD_TAG_GENRE, pos, str);
 289 }
 290
 291 void MPD::Song::SetComposer(const std::string &str, unsigned pos)
 292 {
 293         SetTag(MPD_TAG_COMPOSER, pos, str);
 294 }
 295
 296 void MPD::Song::SetPerformer(const std::string &str, unsigned pos)
 297 {
 298         SetTag(MPD_TAG_PERFORMER, pos, str);
 299 }
 300
 301 void MPD::Song::SetDisc(const std::string &str, unsigned pos)
 302 {
 303         SetTag(MPD_TAG_DISC, pos, str);
 304 }
 305
 306 void MPD::Song::SetComment(const std::string &str, unsigned pos)
 307 {
 308         SetTag(MPD_TAG_COMMENT, pos, str);
 309 }
 310
 311 void MPD::Song::SetPosition(unsigned pos)
 312 {
 313         mpd_song_set_pos(itsSong, pos);
 314 }
 315
 316 void MPD::Song::SetTags(SetFunction f, const std::string &value)
 317 {
 318         unsigned pos = 0;
 319         // tag editor can save multiple instances of performer and composer
 320         // tag, so we need to split them and allow it to read them separately.
 321         if (f == &Song::SetComposer || f == &Song::SetPerformer)
 322         {
 323                 for (size_t i = 0; i != std::string::npos; i = value.find(",", i))
 324                 {
 325                         if (i)
 326                                 ++i;
 327                         while (value[i] == ' ')
 328                                 ++i;
 329                         size_t j = value.find(",", i);
 330                         (this->*f)(value.substr(i, j-i), pos++);
 331                 }
 332         }
 333         else
 334                 (this->*f)(value, pos++);
 335         // there should be empty tag at the end since if we are
 336         // reading them, original tag from mpd_song at the position
 337         // after the last one locally set can be non-empty and in this
 338         // case GetTags() would read it, which is undesirable.
 339         (this->*f)("", pos);
 340 }
 341
 342 std::string MPD::Song::ParseFormat(std::string::const_iterator &it, const char *escape_chars) const
 343 {
 344         std::string result;
 345         bool has_some_tags = 0;
 346         MPD::Song::GetFunction get = 0;
 347         while (*++it != '}')
 348         {
 349                 while (*it == '{')
 350                 {
 351                         std::string tags = ParseFormat(it, escape_chars);
 352                         if (!tags.empty())
 353                         {
 354                                 has_some_tags = 1;
 355                                 result += tags;
 356                         }
 357                 }
 358                 if (*it == '}')
 359                         break;
 360
 361                 if (*it == '%')
 362                 {
 363                         switch (*++it)
 364                         {
 365                                 case 'l':
 366                                         get = &MPD::Song::GetLength;
 367                                         break;
 368                                 case 'D':
 369                                         get = &MPD::Song::GetDirectory;
 370                                         break;
 371                                 case 'f':
 372                                         get = &MPD::Song::GetName;
 373                                         break;
 374                                 case 'a':
 375                                         get = &MPD::Song::GetArtist;
 376                                         break;
 377                                 case 'b':
 378                                         get = &MPD::Song::GetAlbum;
 379                                         break;
 380                                 case 'y':
 381                                         get = &MPD::Song::GetDate;
 382                                         break;
 383                                 case 'n':
 384                                         get = &MPD::Song::GetTrackNumber;
 385                                         break;
 386                                 case 'N':
 387                                         get = &MPD::Song::GetTrack;
 388                                         break;
 389                                 case 'g':
 390                                         get = &MPD::Song::GetGenre;
 391                                         break;
 392                                 case 'c':
 393                                         get = &MPD::Song::GetComposer;
 394                                         break;
 395                                 case 'p':
 396                                         get = &MPD::Song::GetPerformer;
 397                                         break;
 398                                 case 'd':
 399                                         get = &MPD::Song::GetDisc;
 400                                         break;
 401                                 case 'C':
 402                                         get = &MPD::Song::GetComment;
 403                                         break;
 404                                 case 't':
 405                                         get = &MPD::Song::GetTitle;
 406                                         break;
 407                                 case '%':
 408                                         result += *it; // no break here
 409                                 default:
 410                                         get = 0;
 411                                         break;
 412                         }
 413                         if (get)
 414                         {
 415                                 std::string tag = GetTags(get);
 416                                 if (escape_chars) // prepend format escape character to all given chars to escape
 417                                         for (const char *ch = escape_chars; *ch; ++ch)
 418                                                 for (size_t i = 0; (i = tag.find(*ch, i)) != std::string::npos; i += 2)
 419                                                         tag.replace(i, 1, std::string(1, FormatEscapeCharacter) + ch);
 420                                 if (!tag.empty() && (get != &MPD::Song::GetLength || GetTotalLength()))
 421                                 {
 422                                         has_some_tags = 1;
 423                                         result += tag;
 424                                 }
 425                                 else
 426                                         break;
 427                         }
 428                 }
 429                 else
 430                         result += *it;
 431         }
 432         int brace_counter = 0;
 433         if (*it != '}' || !has_some_tags)
 434         {
 435                 for (; *it != '}' || brace_counter; ++it)
 436                 {
 437                         if (*it == '{')
 438                                 ++brace_counter;
 439                         else if (*it == '}')
 440                                 --brace_counter;
 441                 }
 442                 if (*++it == '|')
 443                         return ParseFormat(++it, escape_chars);
 444                 else
 445                         return "";
 446         }
 447         else
 448         {
 449                 if (*(it+1) == '|')
 450                 {
 451                         for (; *it != '}' || *(it+1) == '|' || brace_counter; ++it)
 452                         {
 453                                 if (*it == '{')
 454                                         ++brace_counter;
 455                                 else if (*it == '}')
 456                                         --brace_counter;
 457                         }
 458                 }
 459                 ++it;
 460                 return result;
 461         }
 462 }
 463
 464 std::string MPD::Song::toString(const std::string &format, const char *escape_chars) const
 465 {
 466         std::string::const_iterator it = format.begin();
 467         return ParseFormat(it, escape_chars);
 468 }
 469
 470 MPD::Song &MPD::Song::operator=(const MPD::Song &s)
 471 {
 472         if (this == &s)
 473                 return *this;
 474         if (itsSong)
 475                 mpd_song_free(itsSong);
 476         delete [] itsFile;
 477         delete itsTags;
 478         itsSong = s.copyPtr ? s.itsSong : (s.itsSong ? mpd_song_dup(s.itsSong) : 0);
 479         itsFile = s.itsFile ? strdup(s.itsFile) : 0;
 480         itsTags = s.itsTags ? new TagMap(*s.itsTags) : 0;
 481         itsNewName = s.itsNewName;
 482         itsSlash = s.itsSlash;
 483         itsHash = s.itsHash;
 484         copyPtr = s.copyPtr;
 485         isLocalised = s.isLocalised;
 486         return *this;
 487 }
 488
 489 std::string MPD::Song::ShowTime(int length)
 490 {
 491         std::ostringstream ss;
 492
 493         int hours = length/3600;
 494         length -= hours*3600;
 495         int minutes = length/60;
 496         length -= minutes*60;
 497         int seconds = length;
 498
 499         if (hours > 0)
 500         {
 501                 ss << hours << ":"
 502                 << std::setw(2) << std::setfill('0') << minutes << ":"
 503                 << std::setw(2) << std::setfill('0') << seconds;
 504         }
 505         else
 506         {
 507                 ss << minutes << ":"
 508                 << std::setw(2) << std::setfill('0') << seconds;
 509         }
 510         return ss.str();
 511 }
 512
 513 void MPD::Song::ValidateFormat(const std::string &type, const std::string &s)
 514 {
 515         int braces = 0;
 516         for (std::string::const_iterator it = s.begin(); it != s.end(); ++it)
 517         {
 518                 if (*it == '{')
 519                         ++braces;
 520                 else if (*it == '}')
 521                         --braces;
 522         }
 523         if (braces)
 524                 FatalError(type + ": number of opening and closing braces does not equal!");
 525 }
 526
 527 void MPD::Song::SetHashAndSlash()
 528 {
 529         const char *filename = MyFilename();
 530         if (!isStream())
 531         {
 532                 const char *tmp = strrchr(filename, '/');
 533                 itsSlash = tmp ? tmp-filename : std::string::npos;
 534         }
 535         if (!itsFile)
 536                 itsHash = calc_hash(filename);
 537 }
 538
 539 const char *MPD::Song::MyFilename() const
 540 {
 541         return itsFile ? itsFile : mpd_song_get_uri(itsSong);
 542 }
 543
 544 void MPD::Song::SetTag(mpd_tag_type type, unsigned pos, const std::string &value)
 545 {
 546         if (!itsTags)
 547                 itsTags = new TagMap;
 548         (*itsTags)[std::make_pair(type, pos)] = value;
 549 }
 550
 551 std::string MPD::Song::GetTag(mpd_tag_type type, unsigned pos) const
 552 {
 553         if (itsTags)
 554         {
 555                 TagMap::const_iterator it = itsTags->find(std::make_pair(type, pos));
 556                 if (it != itsTags->end())
 557                         return it->second;
 558         }
 559         const char *tag = mpd_song_get_tag(itsSong, type, pos);
 560         return tag ? tag : "";
 561 }
 562