1 /* This file is part of Clementine.
2 Copyright 2011-2013, Alan Briolat <alan.briolat@gmail.com>
3 Copyright 2013, David Sansome <me@davidsansome.com>
4 Copyright 2013, Ross Wolfson <ross.wolfson@gmail.com>
5 Copyright 2013-2014, John Maguire <john.maguire@gmail.com>
6 Copyright 2014, Chocobozzz <florian.bigard@gmail.com>
7 Copyright 2014, Krzysztof Sobiecki <sobkas@gmail.com>
8
9 Clementine is free software: you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation, either version 3 of the License, or
12 (at your option) any later version.
13
14 Clementine is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with Clementine. If not, see <http://www.gnu.org/licenses/>.
21 */
22
23 #include "subsonicservice.h"
24
25 #include <QMenu>
26 #include <QNetworkAccessManager>
27 #include <QNetworkCookieJar>
28 #include <QNetworkReply>
29 #include <QSortFilterProxyModel>
30 #include <QSslConfiguration>
31 #include <QXmlStreamReader>
32 #include <QUrlQuery>
33
34 #include "core/application.h"
35 #include "core/closure.h"
36 #include "core/database.h"
37 #include "core/logging.h"
38 #include "core/mergedproxymodel.h"
39 #include "core/player.h"
40 #include "core/taskmanager.h"
41 #include "core/timeconstants.h"
42 #include "core/utilities.h"
43 #include "globalsearch/globalsearch.h"
44 #include "globalsearch/librarysearchprovider.h"
45 #include "internet/core/internetmodel.h"
46 #include "internet/subsonic/subsonicurlhandler.h"
47 #include "internet/subsonic/subsonicdynamicplaylist.h"
48 #include "library/librarybackend.h"
49 #include "library/libraryfilterwidget.h"
50 #include "smartplaylists/generator.h"
51 #include "smartplaylists/querygenerator.h"
52 #include "ui/iconloader.h"
53
54 const char* SubsonicService::kServiceName = "Subsonic";
55 const char* SubsonicService::kSettingsGroup = "Subsonic";
56 const char* SubsonicService::kApiVersion = "1.8.0";
57 const char* SubsonicService::kApiClientName = "Clementine";
58
59 const char* SubsonicService::kSongsTable = "subsonic_songs";
60 const char* SubsonicService::kFtsTable = "subsonic_songs_fts";
61
62 const int SubsonicService::kMaxRedirects = 10;
63
SubsonicService(Application * app,InternetModel * parent)64 SubsonicService::SubsonicService(Application* app, InternetModel* parent)
65 : InternetService(kServiceName, app, parent, parent),
66 network_(new QNetworkAccessManager(this)),
67 url_handler_(new SubsonicUrlHandler(this, this)),
68 scanner_(new SubsonicLibraryScanner(this, this)),
69 load_database_task_id_(0),
70 context_menu_(nullptr),
71 root_(nullptr),
72 library_backend_(nullptr),
73 library_model_(nullptr),
74 library_filter_(nullptr),
75 library_sort_model_(new QSortFilterProxyModel(this)),
76 total_song_count_(0),
77 login_state_(LoginState_OtherError),
78 redirect_count_(0),
79 is_ampache_(false) {
80 app_->player()->RegisterUrlHandler(url_handler_);
81
82 connect(scanner_, SIGNAL(ScanFinished()), SLOT(ReloadDatabaseFinished()));
83
84 library_backend_ = new LibraryBackend;
85 library_backend_->moveToThread(app_->database()->thread());
86 library_backend_->Init(app_->database(), kSongsTable, QString(), QString(),
87 kFtsTable);
88 connect(library_backend_, SIGNAL(TotalSongCountUpdated(int)),
89 SLOT(UpdateTotalSongCount(int)));
90
91 using smart_playlists::Generator;
92 using smart_playlists::GeneratorPtr;
93
94 library_model_ = new LibraryModel(library_backend_, app_, this);
95 library_model_->set_show_various_artists(false);
96 library_model_->set_show_smart_playlists(true);
97 library_model_->set_default_smart_playlists(
98 LibraryModel::DefaultGenerators()
99 << (LibraryModel::GeneratorList()
100 << GeneratorPtr(new SubsonicDynamicPlaylist(
101 tr("Newest"),
102 SubsonicDynamicPlaylist::QueryStat_Newest))
103 << GeneratorPtr(new SubsonicDynamicPlaylist(
104 tr("Random"),
105 SubsonicDynamicPlaylist::QueryStat_Random))
106 << GeneratorPtr(new SubsonicDynamicPlaylist(
107 tr("Frequently Played"),
108 SubsonicDynamicPlaylist::QueryStat_Frequent))
109 << GeneratorPtr(new SubsonicDynamicPlaylist(
110 tr("Top Rated"),
111 SubsonicDynamicPlaylist::QueryStat_Highest))
112 << GeneratorPtr(new SubsonicDynamicPlaylist(
113 tr("Recently Played"),
114 SubsonicDynamicPlaylist::QueryStat_Recent))
115 << GeneratorPtr(new SubsonicDynamicPlaylist(
116 tr("Starred"),
117 SubsonicDynamicPlaylist::QueryStat_Starred))
118 ));
119
120 library_filter_ = new LibraryFilterWidget(0);
121 library_filter_->SetSettingsGroup(kSettingsGroup);
122 library_filter_->SetLibraryModel(library_model_);
123 library_filter_->SetFilterHint(tr("Search Subsonic"));
124 library_filter_->SetAgeFilterEnabled(false);
125
126 library_sort_model_->setSourceModel(library_model_);
127 library_sort_model_->setSortRole(LibraryModel::Role_SortText);
128 library_sort_model_->setDynamicSortFilter(true);
129 library_sort_model_->setSortLocaleAware(true);
130 library_sort_model_->sort(0);
131
132 connect(this, SIGNAL(LoginStateChanged(SubsonicService::LoginState)),
133 SLOT(OnLoginStateChanged(SubsonicService::LoginState)));
134
135 context_menu_ = new QMenu;
136 context_menu_->addActions(GetPlaylistActions());
137 context_menu_->addSeparator();
138 context_menu_->addAction(IconLoader::Load("view-refresh", IconLoader::Base),
139 tr("Refresh catalogue"), this,
140 SLOT(ReloadDatabase()));
141 QAction* config_action = context_menu_->addAction(
142 IconLoader::Load("configure", IconLoader::Base), tr("Configure Subsonic..."),
143 this, SLOT(ShowConfig()));
144 context_menu_->addSeparator();
145 context_menu_->addMenu(library_filter_->menu());
146
147 library_filter_->AddMenuAction(config_action);
148
149 app_->global_search()->AddProvider(new LibrarySearchProvider(
150 library_backend_, tr("Subsonic"), "subsonic",
151 IconLoader::Load("subsonic", IconLoader::Provider), true, app_, this));
152 }
153
~SubsonicService()154 SubsonicService::~SubsonicService() {}
155
CreateRootItem()156 QStandardItem* SubsonicService::CreateRootItem() {
157 root_ = new QStandardItem(IconLoader::Load("subsonic", IconLoader::Provider),
158 kServiceName);
159 root_->setData(true, InternetModel::Role_CanLazyLoad);
160 return root_;
161 }
162
LazyPopulate(QStandardItem * item)163 void SubsonicService::LazyPopulate(QStandardItem* item) {
164 switch (item->data(InternetModel::Role_Type).toInt()) {
165 case InternetModel::Type_Service:
166 library_model_->Init();
167 if (login_state() != LoginState_Loggedin) {
168 ShowConfig();
169 } else if (total_song_count_ == 0 && !load_database_task_id_) {
170 ReloadDatabase();
171 }
172 model()->merged_model()->AddSubModel(item->index(), library_sort_model_);
173 break;
174
175 default:
176 break;
177 }
178 }
179
ShowContextMenu(const QPoint & global_pos)180 void SubsonicService::ShowContextMenu(const QPoint& global_pos) {
181 const bool is_valid = model()->current_index().model() == library_sort_model_;
182
183 GetAppendToPlaylistAction()->setEnabled(is_valid);
184 GetReplacePlaylistAction()->setEnabled(is_valid);
185 GetOpenInNewPlaylistAction()->setEnabled(is_valid);
186 context_menu_->popup(global_pos);
187 }
188
HeaderWidget() const189 QWidget* SubsonicService::HeaderWidget() const { return library_filter_; }
190
ReloadSettings()191 void SubsonicService::ReloadSettings() {
192 QSettings s;
193 s.beginGroup(kSettingsGroup);
194
195 UpdateServer(s.value("server").toString());
196 username_ = s.value("username").toString();
197 password_ = s.value("password").toString();
198 usesslv3_ = s.value("usesslv3").toBool();
199 verifycert_ = s.value("verifycert", true).toBool();
200
201 Login();
202 }
203
IsConfigured() const204 bool SubsonicService::IsConfigured() const {
205 return !configured_server_.isEmpty() && !username_.isEmpty() &&
206 !password_.isEmpty();
207 }
208
IsAmpache() const209 bool SubsonicService::IsAmpache() const { return is_ampache_; }
210
Login()211 void SubsonicService::Login() {
212 // Recreate fresh network state, otherwise old HTTPS settings seem to get
213 // reused
214 network_->deleteLater();
215 network_ = new QNetworkAccessManager(this);
216 network_->setCookieJar(new QNetworkCookieJar(network_));
217 // Forget login state whilst waiting
218 login_state_ = LoginState_Unknown;
219
220 if (IsConfigured()) {
221 // Ping is enough to check credentials
222 Ping();
223 } else {
224 login_state_ = LoginState_IncompleteCredentials;
225 emit LoginStateChanged(login_state_);
226 }
227 }
228
Login(const QString & server,const QString & username,const QString & password,const bool & usesslv3,const bool & verifycert)229 void SubsonicService::Login(const QString& server, const QString& username,
230 const QString& password, const bool& usesslv3,
231 const bool& verifycert) {
232 UpdateServer(server);
233 username_ = username;
234 password_ = password;
235 usesslv3_ = usesslv3;
236 verifycert_ = verifycert;
237 Login();
238 }
239
Ping()240 void SubsonicService::Ping() {
241 QNetworkReply* reply = Send(BuildRequestUrl("ping"));
242 NewClosure(reply, SIGNAL(finished()), this,
243 SLOT(OnPingFinished(QNetworkReply*)), reply);
244 }
245
BuildRequestUrl(const QString & view) const246 QUrl SubsonicService::BuildRequestUrl(const QString& view) const {
247 QUrl url(working_server_ + "/rest/" + view + ".view");
248 QUrlQuery url_query;
249 url_query.addQueryItem("v", kApiVersion);
250 url_query.addQueryItem("c", kApiClientName);
251 url_query.addQueryItem("u", username_);
252 url_query.addQueryItem("p", QString("enc:" + password_.toUtf8().toHex()));
253 url.setQuery(url_query);
254 return url;
255 }
256
ScrubUrl(const QUrl & url)257 QUrl SubsonicService::ScrubUrl(const QUrl& url) {
258 QUrl return_url(url);
259 QString path = url.path();
260 int rest_location = path.lastIndexOf("/rest", -1, Qt::CaseInsensitive);
261 if (rest_location >= 0) {
262 return_url.setPath(path.left(rest_location));
263 }
264 return return_url;
265 }
266
Send(const QUrl & url)267 QNetworkReply* SubsonicService::Send(const QUrl& url) {
268 QNetworkRequest request(url);
269 // Don't try and check the authenticity of the SSL certificate - it'll almost
270 // certainly be self-signed.
271 QSslConfiguration sslconfig = QSslConfiguration::defaultConfiguration();
272 sslconfig.setPeerVerifyMode(verifycert_ ? QSslSocket::VerifyPeer
273 : QSslSocket::VerifyNone);
274 if (usesslv3_) {
275 sslconfig.setProtocol(QSsl::SslV3);
276 }
277 request.setSslConfiguration(sslconfig);
278 QNetworkReply* reply = network_->get(request);
279 return reply;
280 }
281
UpdateTotalSongCount(int count)282 void SubsonicService::UpdateTotalSongCount(int count) {
283 total_song_count_ = count;
284 }
285
ReloadDatabase()286 void SubsonicService::ReloadDatabase() {
287 if (!load_database_task_id_) {
288 load_database_task_id_ =
289 app_->task_manager()->StartTask(tr("Fetching Subsonic library"));
290 }
291 scanner_->Scan();
292 }
293
ReloadDatabaseFinished()294 void SubsonicService::ReloadDatabaseFinished() {
295 app_->task_manager()->SetTaskFinished(load_database_task_id_);
296 load_database_task_id_ = 0;
297
298 library_backend_->DeleteAll();
299 library_backend_->AddOrUpdateSongs(scanner_->GetSongs());
300 library_model_->Reset();
301 }
302
OnLoginStateChanged(SubsonicService::LoginState newstate)303 void SubsonicService::OnLoginStateChanged(
304 SubsonicService::LoginState newstate) {
305 // TODO(Alan Briolat): library refresh logic?
306 if (newstate != LoginState_Loggedin) library_backend_->DeleteAll();
307 }
308
OnPingFinished(QNetworkReply * reply)309 void SubsonicService::OnPingFinished(QNetworkReply* reply) {
310 reply->deleteLater();
311
312 if (reply->error() != QNetworkReply::NoError) {
313 switch (reply->error()) {
314 case QNetworkReply::ConnectionRefusedError:
315 login_state_ = LoginState_ConnectionRefused;
316 break;
317 case QNetworkReply::HostNotFoundError:
318 login_state_ = LoginState_HostNotFound;
319 break;
320 case QNetworkReply::TimeoutError:
321 login_state_ = LoginState_Timeout;
322 break;
323 case QNetworkReply::SslHandshakeFailedError:
324 login_state_ = LoginState_SslError;
325 break;
326 default: // Treat uncaught error types here as generic
327 login_state_ = LoginState_BadServer;
328 break;
329 }
330 qLog(Error) << "Failed to connect ("
331 << Utilities::EnumToString(QNetworkReply::staticMetaObject,
332 "NetworkError", reply->error())
333 << "):" << reply->errorString();
334 } else {
335 QXmlStreamReader reader(reply);
336 reader.readNextStartElement();
337 is_ampache_ = (reader.attributes().value("type") == "ampache");
338 QStringRef status = reader.attributes().value("status");
339 int http_status_code =
340 reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
341 if (status == "ok") {
342 login_state_ = LoginState_Loggedin;
343 } else if (http_status_code >= 300 && http_status_code <= 399) {
344 // Received a redirect status code, follow up on it.
345 QUrl redirect_url =
346 reply->attribute(QNetworkRequest::RedirectionTargetAttribute).toUrl();
347 if (redirect_url.isEmpty()) {
348 qLog(Debug) << "Received HTTP code " << http_status_code
349 << ", but no URL";
350 login_state_ = LoginState_RedirectNoUrl;
351 } else {
352 redirect_count_++;
353 qLog(Debug) << "Redirect received to "
354 << redirect_url.toString(QUrl::RemoveQuery)
355 << ", current redirect count is " << redirect_count_;
356 if (redirect_count_ <= kMaxRedirects) {
357 working_server_ = ScrubUrl(redirect_url).toString(QUrl::RemoveQuery);
358 Ping();
359 // To avoid the LoginStateChanged, as it will come from the recursive
360 // request.
361 return;
362 } else {
363 // Redirect limit exceeded
364 login_state_ = LoginState_RedirectLimitExceeded;
365 }
366 }
367 } else {
368 reader.readNextStartElement();
369 int error = reader.attributes().value("code").toString().toInt();
370 qLog(Error) << "Subsonic error ("
371 << Utilities::EnumToString(SubsonicService::staticMetaObject,
372 "ApiError", error)
373 << "):" << reader.attributes().value("message").toString();
374 switch (error) {
375 // "Parameter missing" for "ping" is always blank username or password
376 case ApiError_ParameterMissing:
377 case ApiError_BadCredentials:
378 login_state_ = LoginState_BadCredentials;
379 break;
380 case ApiError_OutdatedClient:
381 login_state_ = LoginState_OutdatedClient;
382 break;
383 case ApiError_OutdatedServer:
384 login_state_ = LoginState_OutdatedServer;
385 break;
386 case ApiError_Unlicensed:
387 login_state_ = LoginState_Unlicensed;
388 break;
389 default:
390 login_state_ = LoginState_OtherError;
391 break;
392 }
393 }
394 }
395 qLog(Debug) << "Login state changed:"
396 << Utilities::EnumToString(SubsonicService::staticMetaObject,
397 "LoginState", login_state_);
398 emit LoginStateChanged(login_state_);
399 }
400
ShowConfig()401 void SubsonicService::ShowConfig() {
402 app_->OpenSettingsDialogAtPage(SettingsDialog::Page_Subsonic);
403 }
404
UpdateServer(const QString & server)405 void SubsonicService::UpdateServer(const QString& server) {
406 configured_server_ = server;
407 working_server_ = server;
408 redirect_count_ = 0;
409 }
410
411 const int SubsonicLibraryScanner::kAlbumChunkSize = 500;
412 const int SubsonicLibraryScanner::kConcurrentRequests = 8;
413 const int SubsonicLibraryScanner::kCoverArtSize = 1024;
414
SubsonicLibraryScanner(SubsonicService * service,QObject * parent)415 SubsonicLibraryScanner::SubsonicLibraryScanner(SubsonicService* service,
416 QObject* parent)
417 : QObject(parent), service_(service), scanning_(false) {}
418
~SubsonicLibraryScanner()419 SubsonicLibraryScanner::~SubsonicLibraryScanner() {}
420
Scan()421 void SubsonicLibraryScanner::Scan() {
422 if (scanning_) {
423 return;
424 }
425
426 album_queue_.clear();
427 pending_requests_.clear();
428 songs_.clear();
429 scanning_ = true;
430 GetAlbumList(0);
431 }
432
OnGetAlbumListFinished(QNetworkReply * reply,int offset)433 void SubsonicLibraryScanner::OnGetAlbumListFinished(QNetworkReply* reply,
434 int offset) {
435 reply->deleteLater();
436
437 bool skip_read_albums = false;
438
439 QXmlStreamReader reader(reply);
440 reader.readNextStartElement();
441
442 if (reader.name() != "subsonic-response") {
443 ParsingError("Not a subsonic-response. Aborting scan.");
444 return;
445 }
446
447 if (reader.attributes().value("status") != "ok") {
448 reader.readNextStartElement();
449 int error = reader.attributes().value("code").toString().toInt();
450
451 // Compatibility with Ampache :
452 // When there is no data, Ampache returns NotFound
453 // whereas Subsonic returns empty albumList2 tag
454 switch (error) {
455 case SubsonicService::ApiError_NotFound:
456 skip_read_albums = true;
457 break;
458 default:
459 ParsingError("Response status not ok. Aborting scan.");
460 return;
461 }
462 }
463
464 int albums_added = 0;
465 if (!skip_read_albums) {
466 reader.readNextStartElement();
467 if (reader.name() != "albumList2") {
468 ParsingError("albumList2 tag expected. Aborting scan.");
469 return;
470 }
471
472 while (reader.readNextStartElement()) {
473 if (reader.name() != "album") {
474 ParsingError("album tag expected. Aborting scan.");
475 return;
476 }
477
478 album_queue_ << reader.attributes().value("id").toString();
479 albums_added++;
480 reader.skipCurrentElement();
481 }
482 }
483
484 if (albums_added > 0) {
485 // Non-empty reply means potentially more albums to fetch
486 GetAlbumList(offset + kAlbumChunkSize);
487 } else if (album_queue_.empty()) {
488 // Empty reply and no albums means an empty Subsonic server
489 scanning_ = false;
490 emit ScanFinished();
491 } else {
492 // Empty reply but we have some albums, time to start fetching songs
493 // Start up the maximum number of concurrent requests, finished requests get
494 // replaced with new ones
495 for (int i = 0; i < kConcurrentRequests && !album_queue_.empty(); ++i) {
496 GetAlbum(album_queue_.dequeue());
497 }
498 }
499 }
500
OnGetAlbumFinished(QNetworkReply * reply)501 void SubsonicLibraryScanner::OnGetAlbumFinished(QNetworkReply* reply) {
502 reply->deleteLater();
503 pending_requests_.remove(reply);
504
505 QXmlStreamReader reader(reply);
506 reader.readNextStartElement();
507
508 if (reader.name() != "subsonic-response") {
509 ParsingError("Not a subsonic-response. Aborting scan.");
510 return;
511 }
512
513 if (reader.attributes().value("status") != "ok") {
514 // TODO(Alan Briolat): error handling
515 return;
516 }
517
518 // Read album information
519 reader.readNextStartElement();
520 if (reader.name() != "album") {
521 ParsingError("album tag expected. Aborting scan.");
522 return;
523 }
524
525 QString album_artist = reader.attributes().value("artist").toString();
526
527 // Read song information
528 while (reader.readNextStartElement()) {
529 if (reader.name() != "song") {
530 ParsingError("song tag expected. Aborting scan.");
531 return;
532 }
533
534 Song song;
535 QString id = reader.attributes().value("id").toString();
536 song.set_title(reader.attributes().value("title").toString());
537 song.set_album(reader.attributes().value("album").toString());
538 song.set_track(reader.attributes().value("track").toString().toInt());
539 song.set_disc(reader.attributes().value("discNumber").toString().toInt());
540 song.set_artist(reader.attributes().value("artist").toString());
541 song.set_albumartist(album_artist);
542 song.set_bitrate(reader.attributes().value("bitRate").toString().toInt());
543 song.set_year(reader.attributes().value("year").toString().toInt());
544 song.set_genre(reader.attributes().value("genre").toString());
545 qint64 length = reader.attributes().value("duration").toString().toInt();
546 length *= kNsecPerSec;
547 song.set_length_nanosec(length);
548 QUrl url = QUrl(QString("subsonic://"));
549 QUrlQuery song_query(url.query());
550 song_query.addQueryItem("id", id);
551 url.setQuery(song_query);
552 QUrl cover_url = service_->BuildRequestUrl("getCoverArt");
553 QUrlQuery cover_url_query(url.query());
554 cover_url_query.addQueryItem("id", id);
555 cover_url.setQuery(cover_url_query);
556 song.set_art_automatic(cover_url.toEncoded());
557 song.set_url(url);
558 song.set_filesize(reader.attributes().value("size").toString().toInt());
559 // We need to set these to satisfy the database constraints
560 song.set_directory_id(0);
561 song.set_mtime(0);
562 song.set_ctime(0);
563
564 if (reader.attributes().hasAttribute("playCount")) {
565 song.set_playcount(
566 reader.attributes().value("playCount").toString().toInt());
567 }
568
569 songs_ << song;
570 reader.skipCurrentElement();
571 }
572
573 // Start the next request if albums remain
574 if (!album_queue_.empty()) {
575 GetAlbum(album_queue_.dequeue());
576 }
577
578 // If this was the last response, we're done!
579 if (album_queue_.empty() && pending_requests_.empty()) {
580 scanning_ = false;
581 emit ScanFinished();
582 }
583 }
584
GetAlbumList(int offset)585 void SubsonicLibraryScanner::GetAlbumList(int offset) {
586 QUrl url = service_->BuildRequestUrl("getAlbumList2");
587 QUrlQuery url_query(url.query());
588 url_query.addQueryItem("type", "alphabeticalByName");
589 url_query.addQueryItem("size", QString::number(kAlbumChunkSize));
590 url_query.addQueryItem("offset", QString::number(offset));
591 url.setQuery(url_query);
592 QNetworkReply* reply = service_->Send(url);
593 NewClosure(reply, SIGNAL(finished()), this,
594 SLOT(OnGetAlbumListFinished(QNetworkReply*, int)), reply, offset);
595 }
596
GetAlbum(const QString & id)597 void SubsonicLibraryScanner::GetAlbum(const QString& id) {
598 QUrl url = service_->BuildRequestUrl("getAlbum");
599 QUrlQuery url_query(url.query());
600 url_query.addQueryItem("id", id);
601 if (service_->IsAmpache()) {
602 url_query.addQueryItem("ampache", "1");
603 }
604 url.setQuery(url_query);
605 QNetworkReply* reply = service_->Send(url);
606 NewClosure(reply, SIGNAL(finished()), this,
607 SLOT(OnGetAlbumFinished(QNetworkReply*)), reply);
608 pending_requests_.insert(reply);
609 }
610
ParsingError(const QString & message)611 void SubsonicLibraryScanner::ParsingError(const QString& message) {
612 qLog(Warning) << "Subsonic parsing error: " << message;
613 scanning_ = false;
614 emit ScanFinished();
615 }
616