src/song.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2008-2017 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 <cassert>
  22 #include <cstring>
  23 #include <boost/format.hpp>
  24 #include <boost/functional/hash.hpp>
  25 #include <boost/lexical_cast.hpp>
  26 #include <iostream>
  27 #include <memory>
  28
  29 #include "curses/window.h"
  30 #include "song.h"
  31 #include "utility/type_conversions.h"
  32 #include "utility/wide_string.h"
  33
  34 namespace {
  35
  36 // Prepend '0' if the tag is a single digit number so that we get "expected"
  37 // sort order with regular string comparison.
  38 void format_numeric_tag(std::string &s)
  39 {
  40         if ((s.length() == 1 && s[0] != '0')
  41             || (s.length() > 3 && s[1] == '/'))
  42                 s = "0"+s;
  43 }
  44
  45 size_t calc_hash(const char *s, size_t seed = 0)
  46 {
  47         for (; *s != '\0'; ++s)
  48                 boost::hash_combine(seed, *s);
  49         return seed;
  50 }
  51
  52 }
  53
  54 namespace MPD {
  55
  56 std::string Song::TagsSeparator = " | ";
  57
  58 bool Song::ShowDuplicateTags = true;
  59
  60 std::string Song::get(mpd_tag_type type, unsigned idx) const
  61 {
  62         std::string result;
  63         const char *tag = mpd_song_get_tag(m_song.get(), type, idx);
  64         if (tag)
  65                 result = tag;
  66         return result;
  67 }
  68
  69 Song::Song(mpd_song *s)
  70 {
  71         assert(s);
  72         m_song = std::shared_ptr<mpd_song>(s, mpd_song_free);
  73         m_hash = calc_hash(mpd_song_get_uri(s));
  74 }
  75
  76 std::string Song::getURI(unsigned idx) const
  77 {
  78         assert(m_song);
  79         if (idx > 0)
  80                 return "";
  81         else
  82                 return mpd_song_get_uri(m_song.get());
  83 }
  84
  85 std::string Song::getName(unsigned idx) const
  86 {
  87         assert(m_song);
  88         mpd_song *s = m_song.get();
  89         const char *res = mpd_song_get_tag(s, MPD_TAG_NAME, idx);
  90         if (res)
  91                 return res;
  92         else if (idx > 0)
  93                 return "";
  94         const char *uri = mpd_song_get_uri(s);
  95         const char *name = strrchr(uri, '/');
  96         if (name)
  97                 return name+1;
  98         else
  99                 return uri;
 100 }
 101
 102 std::string Song::getDirectory(unsigned idx) const
 103 {
 104         assert(m_song);
 105         if (idx > 0 || isStream())
 106                 return "";
 107         const char *uri = mpd_song_get_uri(m_song.get());
 108         const char *name = strrchr(uri, '/');
 109         if (name)
 110                 return std::string(uri, name-uri);
 111         else
 112                 return "/";
 113 }
 114
 115 std::string Song::getArtist(unsigned idx) const
 116 {
 117         assert(m_song);
 118         return get(MPD_TAG_ARTIST, idx);
 119 }
 120
 121 std::string Song::getTitle(unsigned idx) const
 122 {
 123         assert(m_song);
 124         return get(MPD_TAG_TITLE, idx);
 125 }
 126
 127 std::string Song::getAlbum(unsigned idx) const
 128 {
 129         assert(m_song);
 130         return get(MPD_TAG_ALBUM, idx);
 131 }
 132
 133 std::string Song::getAlbumArtist(unsigned idx) const
 134 {
 135         assert(m_song);
 136         return get(MPD_TAG_ALBUM_ARTIST, idx);
 137 }
 138
 139 std::string Song::getTrack(unsigned idx) const
 140 {
 141         assert(m_song);
 142         std::string track = get(MPD_TAG_TRACK, idx);
 143         format_numeric_tag(track);
 144         return track;
 145 }
 146
 147 std::string Song::getTrackNumber(unsigned idx) const
 148 {
 149         assert(m_song);
 150         std::string track = getTrack(idx);
 151         size_t slash = track.find('/');
 152         if (slash != std::string::npos)
 153                 track.resize(slash);
 154         return track;
 155 }
 156
 157 std::string Song::getDate(unsigned idx) const
 158 {
 159         assert(m_song);
 160         return get(MPD_TAG_DATE, idx);
 161 }
 162
 163 std::string Song::getGenre(unsigned idx) const
 164 {
 165         assert(m_song);
 166         return get(MPD_TAG_GENRE, idx);
 167 }
 168
 169 std::string Song::getComposer(unsigned idx) const
 170 {
 171         assert(m_song);
 172         return get(MPD_TAG_COMPOSER, idx);
 173 }
 174
 175 std::string Song::getPerformer(unsigned idx) const
 176 {
 177         assert(m_song);
 178         return get(MPD_TAG_PERFORMER, idx);
 179 }
 180
 181 std::string Song::getDisc(unsigned idx) const
 182 {
 183         assert(m_song);
 184         std::string disc = get(MPD_TAG_DISC, idx);
 185         format_numeric_tag(disc);
 186         return disc;
 187 }
 188
 189 std::string Song::getComment(unsigned idx) const
 190 {
 191         assert(m_song);
 192         return get(MPD_TAG_COMMENT, idx);
 193 }
 194
 195 std::string Song::getLength(unsigned idx) const
 196 {
 197         assert(m_song);
 198         if (idx > 0)
 199                 return "";
 200         unsigned len = getDuration();
 201         if (len > 0)
 202                 return ShowTime(len);
 203         else
 204                 return "-:--";
 205 }
 206
 207 std::string Song::getPriority(unsigned idx) const
 208 {
 209         assert(m_song);
 210         if (idx > 0)
 211                 return "";
 212         return boost::lexical_cast<std::string>(getPrio());
 213 }
 214
 215 std::string MPD::Song::getTags(GetFunction f) const
 216 {
 217         assert(m_song);
 218         unsigned idx = 0;
 219         std::string result;
 220         if (ShowDuplicateTags)
 221         {
 222                 for (std::string tag; !(tag = (this->*f)(idx)).empty(); ++idx)
 223                 {
 224                         if (!result.empty())
 225                                 result += TagsSeparator;
 226                         result += tag;
 227                 }
 228         }
 229         else
 230         {
 231                 bool already_present;
 232                 // This is O(n^2), but it doesn't really matter as a list of tags will have
 233                 // at most 2 or 3 items the vast majority of time.
 234                 for (std::string tag; !(tag = (this->*f)(idx)).empty(); ++idx)
 235                 {
 236                         already_present = false;
 237                         for (unsigned i = 0; i < idx; ++i)
 238                         {
 239                                 if ((this->*f)(i) == tag)
 240                                 {
 241                                         already_present = true;
 242                                         break;
 243                                 }
 244                         }
 245                         if (!already_present)
 246                         {
 247                                 if (idx > 0)
 248                                         result += TagsSeparator;
 249                                 result += tag;
 250                         }
 251                 }
 252         }
 253         return result;
 254 }
 255
 256 unsigned Song::getDuration() const
 257 {
 258         assert(m_song);
 259         return mpd_song_get_duration(m_song.get());
 260 }
 261
 262 unsigned Song::getPosition() const
 263 {
 264         assert(m_song);
 265         return mpd_song_get_pos(m_song.get());
 266 }
 267
 268 unsigned Song::getID() const
 269 {
 270         assert(m_song);
 271         return mpd_song_get_id(m_song.get());
 272 }
 273
 274 unsigned Song::getPrio() const
 275 {
 276         assert(m_song);
 277         return mpd_song_get_prio(m_song.get());
 278 }
 279
 280 time_t Song::getMTime() const
 281 {
 282         assert(m_song);
 283         return mpd_song_get_last_modified(m_song.get());
 284 }
 285
 286 bool Song::isFromDatabase() const
 287 {
 288         assert(m_song);
 289         const char *uri = mpd_song_get_uri(m_song.get());
 290         return uri[0] != '/' || !strrchr(uri, '/');
 291 }
 292
 293 bool Song::isStream() const
 294 {
 295         assert(m_song);
 296         return !strncmp(mpd_song_get_uri(m_song.get()), "http://", 7);
 297 }
 298
 299 bool Song::empty() const
 300 {
 301         return m_song.get() == 0;
 302 }
 303
 304 std::string Song::ShowTime(unsigned length)
 305 {
 306         int hours = length/3600;
 307         length -= hours*3600;
 308         int minutes = length/60;
 309         length -= minutes*60;
 310         int seconds = length;
 311
 312         std::string result;
 313         if (hours > 0)
 314                 result = (boost::format("%d:%02d:%02d") % hours % minutes % seconds).str();
 315         else
 316                 result = (boost::format("%d:%02d") % minutes % seconds).str();
 317         return result;
 318 }
 319
 320 }