src/PlaylistImporter.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // LameXP - Audio Encoder Front-End
   3 // Copyright (C) 2004-2013 LoRd_MuldeR <MuldeR2@GMX.de>
   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 along
  16 // with this program; if not, write to the Free Software Foundation, Inc.,
  17 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 //
  19 // http://www.gnu.org/licenses/gpl-2.0.txt
  20 ///////////////////////////////////////////////////////////////////////////////
  21
  22 #include "PlaylistImporter.h"
  23
  24 #include <QString>
  25 #include <QStringList>
  26 #include <QDir>
  27 #include <QFileInfo>
  28 #include <QProcess>
  29 #include <QDate>
  30 #include <QTime>
  31 #include <QDebug>
  32 #include <QTextCodec>
  33
  34 //Un-escape XML characters
  35 static const struct
  36 {
  37         char *escape;
  38         char *output;
  39 }
  40 g_xmlEscapeSequence[] =
  41 {
  42         {"&amp;", "&"},
  43         {"&lt;", "<"},
  44         {"&gt;", ">"},
  45         {"&apos;", "'"},
  46         {"&nbsp;", " "},
  47         {"&quot;", "\""},
  48         {NULL, NULL}
  49 };
  50
  51 const char *PlaylistImporter::supportedExtensions = "*.m3u *.m3u8 *.pls *.asx *.wpl";
  52
  53
  54 ////////////////////////////////////////////////////////////
  55 // Public Functions
  56 ////////////////////////////////////////////////////////////
  57
  58 bool PlaylistImporter::importPlaylist(QStringList &fileList, const QString &playlistFile)
  59 {
  60         QFileInfo file(playlistFile);
  61         QDir baseDir(file.canonicalPath());
  62
  63         QDir rootDir(baseDir);
  64         while(rootDir.cdUp());
  65
  66         //Detect playlist type
  67         playlist_t playlistType = isPlaylist(file.canonicalFilePath());
  68
  69         //Exit if not a playlist
  70         if(playlistType == notPlaylist)
  71         {
  72                 return false;
  73         }
  74
  75         QFile data(playlistFile);
  76
  77         //Open file for reading
  78         if(!data.open(QIODevice::ReadOnly))
  79         {
  80                 return false;
  81         }
  82
  83         //Skip very large files (parsing could take very long)
  84         if((file.size() < 3) || (file.size() > 524288))
  85         {
  86                 qWarning("File is very big. Probably not a Playlist. Rejecting...");
  87                 return false;
  88         }
  89
  90         //Parse playlist depending on type
  91         switch(playlistType)
  92         {
  93         case m3uPlaylist:
  94                 return parsePlaylist_m3u(data, fileList, baseDir, rootDir);
  95                 break;
  96         case plsPlaylist:
  97                 return parsePlaylist_pls(data, fileList, baseDir, rootDir);
  98                 break;
  99         case wplPlaylist:
 100                 return parsePlaylist_wpl(data, fileList, baseDir, rootDir);
 101                 break;
 102         default:
 103                 return false;
 104                 break;
 105         }
 106 }
 107
 108 ////////////////////////////////////////////////////////////
 109 // Private Functions
 110 ////////////////////////////////////////////////////////////
 111
 112 PlaylistImporter::playlist_t PlaylistImporter::isPlaylist(const QString &fileName)
 113 {
 114         QFileInfo file (fileName);
 115
 116         if(file.suffix().compare("m3u", Qt::CaseInsensitive) == 0 || file.suffix().compare("m3u8", Qt::CaseInsensitive) == 0)
 117         {
 118                 return m3uPlaylist;
 119         }
 120         else if(file.suffix().compare("pls", Qt::CaseInsensitive) == 0)
 121         {
 122                 return  plsPlaylist;
 123         }
 124         else if(file.suffix().compare("asx", Qt::CaseInsensitive) == 0 || file.suffix().compare("wpl", Qt::CaseInsensitive) == 0)
 125         {
 126                 return  wplPlaylist;
 127         }
 128         else
 129         {
 130                 return notPlaylist;
 131         }
 132 }
 133
 134 bool PlaylistImporter::parsePlaylist_m3u(QFile &data, QStringList &fileList, const QDir &baseDir, const QDir &rootDir)
 135 {
 136         const QTextCodec *codec = QTextCodec::codecForName("System");
 137         const bool preferUTF8 = data.fileName().endsWith(".m3u8", Qt::CaseInsensitive);
 138         bool foundAtLeastOneFile = false;
 139
 140         data.reset();
 141
 142         while(!data.atEnd())
 143         {
 144                 QString filePath[3];
 145                 QByteArray line = data.readLine();
 146
 147                 if(preferUTF8)
 148                 {
 149                         filePath[0] = QString(QDir::fromNativeSeparators(QString::fromUtf8(line.constData(), line.size()).trimmed()));
 150                         filePath[1] = QString(QDir::fromNativeSeparators(codec->toUnicode(line.constData(), line.size()).trimmed()));
 151                         filePath[2] = QString(QDir::fromNativeSeparators(QString::fromLatin1(line.constData(), line.size()).trimmed()));
 152                 }
 153                 else
 154                 {
 155                         filePath[0] = QString(QDir::fromNativeSeparators(codec->toUnicode(line.constData(), line.size()).trimmed()));
 156                         filePath[1] = QString(QDir::fromNativeSeparators(QString::fromLatin1(line.constData(), line.size()).trimmed()));
 157                         filePath[2] = QString(QDir::fromNativeSeparators(QString::fromUtf8(line.constData(), line.size()).trimmed()));
 158                 }
 159
 160                 for(size_t i = 0; i < 3; i++)
 161                 {
 162                         if(!(filePath[i].isEmpty() || filePath[i].startsWith("#") || filePath[i].contains(QChar(QChar::ReplacementCharacter))))
 163                         {
 164                                 QFileInfo filename(filePath[i]);
 165                                 filename.setCaching(false);
 166                                 fixFilePath(filename, baseDir, rootDir);
 167
 168                                 if(filename.exists() && filename.isFile())
 169                                 {
 170                                         qDebug("Found: \"%s\"", filePath[i].toUtf8().constData());
 171                                         if(isPlaylist(filename.canonicalFilePath()) == notPlaylist)
 172                                         {
 173                                                 fileList << filename.canonicalFilePath();
 174                                         }
 175                                         foundAtLeastOneFile = true;
 176                                         break;
 177                                 }
 178                         }
 179                 }
 180         }
 181
 182         //If we did not find any files yet, try UTF-16 now
 183         if(!foundAtLeastOneFile)
 184         {
 185                 const char* codecs[2] = {"UTF-16LE", "UTF-16BE"};
 186
 187                 for(size_t i = 0; i < 2; i++)
 188                 {
 189                         QTextStream stream(&data);
 190                         stream.setAutoDetectUnicode(false);
 191                         stream.setCodec(codecs[i]);
 192                         stream.seek(0i64);
 193
 194                         while(!stream.atEnd())
 195                         {
 196                                 QString filePath = stream.readLine().trimmed();
 197
 198                                 if(!(filePath.isEmpty() || filePath.startsWith("#") || filePath.contains(QChar(QChar::ReplacementCharacter))))
 199                                 {
 200                                         QFileInfo filename(filePath);
 201                                         filename.setCaching(false);
 202                                         fixFilePath(filename, baseDir, rootDir);
 203
 204                                         if(filename.exists() && filename.isFile())
 205                                         {
 206                                                 if(isPlaylist(filename.canonicalFilePath()) == notPlaylist)
 207                                                 {
 208                                                         fileList << filename.canonicalFilePath();
 209                                                 }
 210                                                 foundAtLeastOneFile = true;
 211                                         }
 212                                 }
 213                         }
 214
 215                         if(foundAtLeastOneFile) break;
 216                 }
 217         }
 218
 219         return foundAtLeastOneFile;
 220 }
 221
 222 bool PlaylistImporter::parsePlaylist_pls(QFile &data, QStringList &fileList, const QDir &baseDir, const QDir &rootDir)
 223 {
 224         QRegExp plsEntry("File(\\d+)=(.+)", Qt::CaseInsensitive);
 225         const QTextCodec *codec = QTextCodec::codecForName("System");
 226         bool foundAtLeastOneFile = false;
 227
 228         data.reset();
 229
 230         while(!data.atEnd())
 231         {
 232                 QString filePath[3];
 233                 QByteArray line = data.readLine();
 234
 235                 filePath[0] = QString(QDir::fromNativeSeparators(codec->toUnicode(line.constData(), line.size()).trimmed()));
 236                 filePath[1] = QString(QDir::fromNativeSeparators(QString::fromLatin1(line.constData(), line.size()).trimmed()));
 237                 filePath[2] = QString(QDir::fromNativeSeparators(QString::fromUtf8(line.constData(), line.size()).trimmed()));
 238
 239                 for(size_t i = 0; i < 3; i++)
 240                 {
 241                         if(!filePath[i].contains(QChar(QChar::ReplacementCharacter)))
 242                         {
 243                                 if(plsEntry.indexIn(filePath[i]) >= 0)
 244                                 {
 245                                         QFileInfo filename(QDir::fromNativeSeparators(plsEntry.cap(2)).trimmed());
 246                                         filename.setCaching(false);
 247                                         fixFilePath(filename, baseDir, rootDir);
 248
 249                                         if(filename.exists() && filename.isFile())
 250                                         {
 251                                                 if(isPlaylist(filename.canonicalFilePath()) == notPlaylist)
 252                                                 {
 253                                                         fileList << filename.canonicalFilePath();
 254                                                 }
 255                                                 foundAtLeastOneFile = true;
 256                                                 break;
 257                                         }
 258                                 }
 259                         }
 260                 }
 261         }
 262
 263         //If we did not find any files yet, try UTF-16 now
 264         if(!foundAtLeastOneFile)
 265         {
 266                 const char* codecs[2] = {"UTF-16LE", "UTF-16BE"};
 267
 268                 for(size_t i = 0; i < 2; i++)
 269                 {
 270                         QTextStream stream(&data);
 271                         stream.setAutoDetectUnicode(false);
 272                         stream.setCodec(codecs[i]);
 273                         stream.seek(0i64);
 274
 275                         while(!stream.atEnd())
 276                         {
 277                                 QString filePath = stream.readLine().trimmed();
 278
 279                                 if(!filePath.contains(QChar(QChar::ReplacementCharacter)))
 280                                 {
 281                                         if(plsEntry.indexIn(filePath) >= 0)
 282                                         {
 283                                                 QFileInfo filename(QDir::fromNativeSeparators(plsEntry.cap(2)).trimmed());
 284                                                 filename.setCaching(false);
 285                                                 fixFilePath(filename, baseDir, rootDir);
 286
 287                                                 if(filename.exists() && filename.isFile())
 288                                                 {
 289                                                         if(isPlaylist(filename.canonicalFilePath()) == notPlaylist)
 290                                                         {
 291                                                                 fileList << filename.canonicalFilePath();
 292                                                         }
 293                                                         foundAtLeastOneFile = true;
 294                                                 }
 295                                         }
 296                                 }
 297                         }
 298
 299                         if(foundAtLeastOneFile) break;
 300                 }
 301         }
 302
 303         return foundAtLeastOneFile;
 304 }
 305
 306 bool PlaylistImporter::parsePlaylist_wpl(QFile &data, QStringList &fileList, const QDir &baseDir, const QDir &rootDir)
 307 {
 308         bool foundAtLeastOneFile = false;
 309
 310         QRegExp skipData("<!--(.+)-->", Qt::CaseInsensitive);
 311         QRegExp wplEntry("<(media|ref)[^<>]*(src|href)=\"([^\"]+)\"[^<>]*>", Qt::CaseInsensitive);
 312
 313         skipData.setMinimal(true);
 314
 315         QByteArray buffer = data.readAll();
 316         QString line = QString::fromUtf8(buffer.constData(), buffer.size()).simplified();
 317         buffer.clear();
 318
 319         int index = 0;
 320
 321         while((index = skipData.indexIn(line)) >= 0)
 322         {
 323                 line.remove(index, skipData.matchedLength());
 324         }
 325
 326         int offset = 0;
 327
 328         while((offset = wplEntry.indexIn(line, offset) + 1) > 0)
 329         {
 330                 QFileInfo filename(QDir::fromNativeSeparators(unescapeXml(wplEntry.cap(3)).trimmed()));
 331                 filename.setCaching(false);
 332                 fixFilePath(filename, baseDir, rootDir);
 333
 334                 if(filename.exists() && filename.isFile())
 335                 {
 336                         if(isPlaylist(filename.canonicalFilePath()) == notPlaylist)
 337                         {
 338                                 fileList << filename.canonicalFilePath();
 339                                 foundAtLeastOneFile = true;
 340                         }
 341                 }
 342         }
 343
 344         return foundAtLeastOneFile;
 345 }
 346
 347 void PlaylistImporter::fixFilePath(QFileInfo &filename, const QDir &baseDir, const QDir &rootDir)
 348 {
 349         if(filename.filePath().startsWith("/"))
 350         {
 351                 while(filename.filePath().startsWith("/"))
 352                 {
 353                         filename.setFile(filename.filePath().mid(1));
 354                 }
 355                 filename.setFile(rootDir.filePath(filename.filePath()));
 356         }
 357
 358         if(!filename.isAbsolute())
 359         {
 360                 filename.setFile(baseDir.filePath(filename.filePath()));
 361         }
 362 }
 363
 364 QString &PlaylistImporter::unescapeXml(QString &str)
 365 {
 366         for(int i = 0; (g_xmlEscapeSequence[i].escape && g_xmlEscapeSequence[i].output); i++)
 367         {
 368                 str.replace(g_xmlEscapeSequence[i].escape, g_xmlEscapeSequence[i].output);
 369         }
 370
 371         return str;
 372 }