xbmc/cores/paplayer/PAPlayer.cpp

   1 /*
   2  *  Copyright (C) 2005-2018 Team Kodi
   3  *  This file is part of Kodi - https://kodi.tv
   4  *
   5  *  SPDX-License-Identifier: GPL-2.0-or-later
   6  *  See LICENSES/README.md for more information.
   7  */
   8
   9 #include "PAPlayer.h"
  10
  11 #include "FileItem.h"
  12 #include "ICodec.h"
  13 #include "ServiceBroker.h"
  14 #include "URL.h"
  15 #include "Util.h"
  16 #include "cores/AudioEngine/Interfaces/AE.h"
  17 #include "cores/AudioEngine/Interfaces/AEStream.h"
  18 #include "cores/AudioEngine/Utils/AEStreamData.h"
  19 #include "cores/AudioEngine/Utils/AEUtil.h"
  20 #include "cores/DataCacheCore.h"
  21 #include "cores/VideoPlayer/Process/ProcessInfo.h"
  22 #include "messaging/ApplicationMessenger.h"
  23 #include "music/MusicFileItemClassify.h"
  24 #include "music/tags/MusicInfoTag.h"
  25 #include "settings/AdvancedSettings.h"
  26 #include "settings/Settings.h"
  27 #include "settings/SettingsComponent.h"
  28 #include "threads/SystemClock.h"
  29 #include "utils/JobManager.h"
  30 #include "utils/log.h"
  31 #include "video/Bookmark.h"
  32
  33 #include <memory>
  34 #include <mutex>
  35
  36 using namespace KODI;
  37 using namespace std::chrono_literals;
  38
  39 #define TIME_TO_CACHE_NEXT_FILE 5000 /* 5 seconds before end of song, start caching the next song */
  40 #define FAST_XFADE_TIME           80 /* 80 milliseconds */
  41 #define MAX_SKIP_XFADE_TIME     2000 /* max 2 seconds crossfade on track skip */
  42
  43 // PAP: Psycho-acoustic Audio Player
  44 // Supporting all open  audio codec standards.
  45 // First one being nullsoft's nsv audio decoder format
  46
  47 PAPlayer::PAPlayer(IPlayerCallback& callback)
  48   : IPlayer(callback), CThread("PAPlayer"), m_playbackSpeed(1), m_audioCallback(NULL)
  49 {
  50   memset(&m_playerGUIData, 0, sizeof(m_playerGUIData));
  51   m_processInfo.reset(CProcessInfo::CreateInstance());
  52   m_processInfo->SetDataCache(&CServiceBroker::GetDataCacheCore());
  53 }
  54
  55 PAPlayer::~PAPlayer()
  56 {
  57   CloseFile();
  58 }
  59
  60 void PAPlayer::SoftStart(bool wait/* = false */)
  61 {
  62   std::unique_lock<CCriticalSection> lock(m_streamsLock);
  63   for(StreamList::iterator itt = m_streams.begin(); itt != m_streams.end(); ++itt)
  64   {
  65     StreamInfo* si = *itt;
  66     if (si->m_fadeOutTriggered)
  67       continue;
  68
  69     si->m_stream->Resume();
  70     si->m_stream->FadeVolume(0.0f, 1.0f, FAST_XFADE_TIME);
  71   }
  72
  73   if (wait)
  74   {
  75     /* wait for them to fade in */
  76     lock.unlock();
  77     CThread::Sleep(std::chrono::milliseconds(FAST_XFADE_TIME));
  78     lock.lock();
  79
  80     /* be sure they have faded in */
  81     while(wait)
  82     {
  83       wait = false;
  84       for(StreamList::iterator itt = m_streams.begin(); itt != m_streams.end(); ++itt)
  85       {
  86         StreamInfo* si = *itt;
  87         if (si->m_stream->IsFading())
  88         {
  89           lock.unlock();
  90           wait = true;
  91           CThread::Sleep(1ms);
  92           lock.lock();
  93           break;
  94         }
  95       }
  96     }
  97   }
  98 }
  99
 100 void PAPlayer::SoftStop(bool wait/* = false */, bool close/* = true */)
 101 {
 102   /* fade all the streams out fast for a nice soft stop */
 103   std::unique_lock<CCriticalSection> lock(m_streamsLock);
 104   for(StreamList::iterator itt = m_streams.begin(); itt != m_streams.end(); ++itt)
 105   {
 106     StreamInfo* si = *itt;
 107     if (si->m_stream)
 108       si->m_stream->FadeVolume(1.0f, 0.0f, FAST_XFADE_TIME);
 109
 110     if (close)
 111     {
 112       si->m_prepareTriggered  = true;
 113       si->m_playNextTriggered = true;
 114       si->m_fadeOutTriggered  = true;
 115     }
 116   }
 117
 118   /* if we are going to wait for them to finish fading */
 119   if(wait)
 120   {
 121     // fail safe timer, do not wait longer than 1000ms
 122     XbmcThreads::EndTime<> timer(1000ms);
 123
 124     /* wait for them to fade out */
 125     lock.unlock();
 126     CThread::Sleep(std::chrono::milliseconds(FAST_XFADE_TIME));
 127     lock.lock();
 128
 129     /* be sure they have faded out */
 130     while(wait && !CServiceBroker::GetActiveAE()->IsSuspended() && !timer.IsTimePast())
 131     {
 132       wait = false;
 133       for(StreamList::iterator itt = m_streams.begin(); itt != m_streams.end(); ++itt)
 134       {
 135         StreamInfo* si = *itt;
 136         if (si->m_stream && si->m_stream->IsFading())
 137         {
 138           lock.unlock();
 139           wait = true;
 140           CThread::Sleep(1ms);
 141           lock.lock();
 142           break;
 143         }
 144       }
 145     }
 146
 147     /* if we are not closing the streams, pause them */
 148     if (!close)
 149     {
 150       for(StreamList::iterator itt = m_streams.begin(); itt != m_streams.end(); ++itt)
 151       {
 152         StreamInfo* si = *itt;
 153         si->m_stream->Pause();
 154       }
 155     }
 156   }
 157 }
 158
 159 void PAPlayer::CloseAllStreams(bool fade/* = true */)
 160 {
 161   if (!fade)
 162   {
 163     std::unique_lock<CCriticalSection> lock(m_streamsLock);
 164     while (!m_streams.empty())
 165     {
 166       StreamInfo* si = m_streams.front();
 167       m_streams.pop_front();
 168
 169       if (si->m_stream)
 170       {
 171         CloseFileCB(*si);
 172         si->m_stream.reset();
 173       }
 174
 175       si->m_decoder.Destroy();
 176       delete si;
 177     }
 178
 179     while (!m_finishing.empty())
 180     {
 181       StreamInfo* si = m_finishing.front();
 182       m_finishing.pop_front();
 183
 184       if (si->m_stream)
 185       {
 186         CloseFileCB(*si);
 187         si->m_stream.reset();
 188       }
 189
 190       si->m_decoder.Destroy();
 191       delete si;
 192     }
 193     m_currentStream = nullptr;
 194   }
 195   else
 196   {
 197     SoftStop(false, true);
 198     std::unique_lock<CCriticalSection> lock(m_streamsLock);
 199     m_currentStream = NULL;
 200   }
 201 }
 202
 203 bool PAPlayer::OpenFile(const CFileItem& file, const CPlayerOptions &options)
 204 {
 205   m_defaultCrossfadeMS = CServiceBroker::GetSettingsComponent()->GetSettings()->GetInt(CSettings::SETTING_MUSICPLAYER_CROSSFADE) * 1000;
 206   m_fullScreen = options.fullscreen;
 207
 208   if (m_streams.size() > 1 || !m_defaultCrossfadeMS || m_isPaused)
 209   {
 210     CloseAllStreams(!m_isPaused);
 211     StopThread();
 212     m_isPaused = false; // Make sure to reset the pause state
 213   }
 214
 215   {
 216     std::unique_lock<CCriticalSection> lock(m_streamsLock);
 217     m_jobCounter++;
 218   }
 219   CServiceBroker::GetJobManager()->Submit([=, this]() { QueueNextFileEx(file, false); }, this,
 220                                           CJob::PRIORITY_NORMAL);
 221
 222   std::unique_lock<CCriticalSection> lock(m_streamsLock);
 223   if (m_streams.size() == 2)
 224   {
 225     //do a short crossfade on trackskip, set to max 2 seconds for these prev/next transitions
 226     m_upcomingCrossfadeMS = std::min(m_defaultCrossfadeMS, (unsigned int)MAX_SKIP_XFADE_TIME);
 227
 228     //start transition to next track
 229     StreamInfo* si = m_streams.front();
 230     si->m_playNextAtFrame  = si->m_framesSent; //start next track at current frame
 231     si->m_prepareTriggered = true; //next track is ready to go
 232   }
 233   lock.unlock();
 234
 235   if (!IsRunning())
 236     Create();
 237
 238   /* trigger playback start */
 239   m_isPlaying = true;
 240   m_startEvent.Set();
 241
 242   // OnPlayBackStarted to be made only once. Callback processing may be slower than player process
 243   // so clear signal flag first otherwise async stream processing could also make callback
 244   m_signalStarted = false;
 245   m_callback.OnPlayBackStarted(file);
 246
 247   return true;
 248 }
 249
 250 void PAPlayer::UpdateCrossfadeTime(const CFileItem& file)
 251 {
 252   // we explicitly disable crossfading for audio cds
 253   if (MUSIC::IsCDDA(file))
 254     m_upcomingCrossfadeMS = 0;
 255   else
 256     m_upcomingCrossfadeMS = m_defaultCrossfadeMS = CServiceBroker::GetSettingsComponent()->GetSettings()->GetInt(CSettings::SETTING_MUSICPLAYER_CROSSFADE) * 1000;
 257
 258   if (m_upcomingCrossfadeMS)
 259   {
 260     if (!m_currentStream || (file.HasMusicInfoTag() &&
 261                              !CServiceBroker::GetSettingsComponent()->GetSettings()->GetBool(
 262                                  CSettings::SETTING_MUSICPLAYER_CROSSFADEALBUMTRACKS) &&
 263                              m_currentStream->m_fileItem->HasMusicInfoTag() &&
 264                              (m_currentStream->m_fileItem->GetMusicInfoTag()->GetAlbum() != "") &&
 265                              (m_currentStream->m_fileItem->GetMusicInfoTag()->GetAlbum() ==
 266                               file.GetMusicInfoTag()->GetAlbum()) &&
 267                              (m_currentStream->m_fileItem->GetMusicInfoTag()->GetDiscNumber() ==
 268                               file.GetMusicInfoTag()->GetDiscNumber()) &&
 269                              (m_currentStream->m_fileItem->GetMusicInfoTag()->GetTrackNumber() ==
 270                               file.GetMusicInfoTag()->GetTrackNumber() - 1)))
 271     {
 272       //do not crossfade when playing consecutive albumtracks
 273       m_upcomingCrossfadeMS = 0;
 274     }
 275   }
 276 }
 277
 278 bool PAPlayer::QueueNextFile(const CFileItem &file)
 279 {
 280   {
 281     std::unique_lock<CCriticalSection> lock(m_streamsLock);
 282     m_jobCounter++;
 283   }
 284   CServiceBroker::GetJobManager()->Submit([this, file]() { QueueNextFileEx(file, true); }, this,
 285                                           CJob::PRIORITY_NORMAL);
 286
 287   return true;
 288 }
 289
 290 bool PAPlayer::QueueNextFileEx(const CFileItem &file, bool fadeIn)
 291 {
 292   if (m_currentStream)
 293   {
 294     // check if we advance a track of a CUE sheet
 295     // if this is the case we don't need to open a new stream
 296     std::string newURL = file.GetDynURL().GetFileName();
 297     std::string oldURL = m_currentStream->m_fileItem->GetDynURL().GetFileName();
 298     if (newURL.compare(oldURL) == 0 && file.GetStartOffset() &&
 299         file.GetStartOffset() == m_currentStream->m_fileItem->GetEndOffset() && m_currentStream &&
 300         m_currentStream->m_prepareTriggered)
 301     {
 302       m_currentStream->m_nextFileItem = std::make_unique<CFileItem>(file);
 303       m_upcomingCrossfadeMS = 0;
 304       return true;
 305     }
 306     m_currentStream->m_nextFileItem.reset();
 307   }
 308
 309   StreamInfo *si = new StreamInfo();
 310   si->m_fileItem = std::make_unique<CFileItem>(file);
 311
 312   // Start stream at zero offset
 313   si->m_startOffset = 0;
 314   //File item start offset defines where in song to resume
 315   double starttime = CUtil::ConvertMilliSecsToSecs(si->m_fileItem->GetStartOffset());
 316
 317   // Music from cuesheet => "item_start" and offset match
 318   // Start offset defines where this song starts in file of multiple songs
 319   if (si->m_fileItem->HasProperty("item_start") &&
 320       (si->m_fileItem->GetProperty("item_start").asInteger() == si->m_fileItem->GetStartOffset()))
 321   {
 322     // Start stream at offset from cuesheet
 323     si->m_startOffset = si->m_fileItem->GetStartOffset();
 324     starttime = 0; // No resume point
 325   }
 326
 327   if (!si->m_decoder.Create(file, si->m_startOffset))
 328   {
 329     CLog::Log(LOGWARNING, "PAPlayer::QueueNextFileEx - Failed to create the decoder");
 330
 331     // advance playlist
 332     AdvancePlaylistOnError(*si->m_fileItem);
 333     m_callback.OnQueueNextItem();
 334
 335     delete si;
 336     return false;
 337   }
 338
 339   /* decode until there is data-available */
 340   si->m_decoder.Start();
 341   while (si->m_decoder.GetDataSize(true) == 0)
 342   {
 343     int status = si->m_decoder.GetStatus();
 344     if (status == STATUS_ENDED   ||
 345         status == STATUS_NO_FILE ||
 346         si->m_decoder.ReadSamples(PACKET_SIZE) == RET_ERROR)
 347     {
 348       CLog::Log(LOGINFO, "PAPlayer::QueueNextFileEx - Error reading samples");
 349
 350       si->m_decoder.Destroy();
 351       // advance playlist
 352       AdvancePlaylistOnError(*si->m_fileItem);
 353       m_callback.OnQueueNextItem();
 354       delete si;
 355       return false;
 356     }
 357
 358     /* yield our time so that the main PAP thread doesn't stall */
 359     CThread::Sleep(1ms);
 360   }
 361
 362   // set m_upcomingCrossfadeMS depending on type of file and user settings
 363   UpdateCrossfadeTime(*si->m_fileItem);
 364
 365   /* init the streaminfo struct */
 366   si->m_audioFormat = si->m_decoder.GetFormat();
 367   // si->m_startOffset already initialized
 368   si->m_endOffset = file.GetEndOffset();
 369   si->m_bytesPerSample = CAEUtil::DataFormatToBits(si->m_audioFormat.m_dataFormat) >> 3;
 370   si->m_bytesPerFrame = si->m_bytesPerSample * si->m_audioFormat.m_channelLayout.Count();
 371   si->m_started = false;
 372   si->m_finishing = false;
 373   si->m_framesSent = 0;
 374   si->m_seekNextAtFrame = 0;
 375   si->m_seekFrame = -1;
 376   si->m_stream = NULL;
 377   si->m_volume = (fadeIn && m_upcomingCrossfadeMS) ? 0.0f : 1.0f;
 378   si->m_fadeOutTriggered = false;
 379   si->m_isSlaved = false;
 380
 381   si->m_decoderTotal = si->m_decoder.TotalTime();
 382   int64_t streamTotalTime = si->m_decoderTotal;
 383   if (si->m_endOffset)
 384     streamTotalTime = si->m_endOffset - si->m_startOffset;
 385
 386   // Seek to a resume point
 387   if (si->m_fileItem->HasProperty("StartPercent") &&
 388       (si->m_fileItem->GetProperty("StartPercent").asDouble() > 0) &&
 389       (si->m_fileItem->GetProperty("StartPercent").asDouble() <= 100))
 390   {
 391     si->m_seekFrame =
 392         si->m_audioFormat.m_sampleRate *
 393         CUtil::ConvertMilliSecsToSecs(static_cast<int>(+(static_cast<double>(
 394             streamTotalTime * (si->m_fileItem->GetProperty("StartPercent").asDouble() / 100.0)))));
 395   }
 396   else if (starttime > 0)
 397     si->m_seekFrame = si->m_audioFormat.m_sampleRate * starttime;
 398   else if (si->m_fileItem->HasProperty("audiobook_bookmark"))
 399     si->m_seekFrame = si->m_audioFormat.m_sampleRate *
 400                       CUtil::ConvertMilliSecsToSecs(
 401                           si->m_fileItem->GetProperty("audiobook_bookmark").asInteger());
 402
 403   si->m_prepareNextAtFrame = 0;
 404   // cd drives don't really like it to be crossfaded or prepared
 405   if (!MUSIC::IsCDDA(file))
 406   {
 407     if (streamTotalTime >= TIME_TO_CACHE_NEXT_FILE + m_defaultCrossfadeMS)
 408       si->m_prepareNextAtFrame = (int)((streamTotalTime - TIME_TO_CACHE_NEXT_FILE - m_defaultCrossfadeMS) * si->m_audioFormat.m_sampleRate / 1000.0f);
 409   }
 410
 411   if (m_currentStream && ((m_currentStream->m_audioFormat.m_dataFormat == AE_FMT_RAW) || (si->m_audioFormat.m_dataFormat == AE_FMT_RAW)))
 412   {
 413     m_currentStream->m_prepareTriggered = false;
 414     m_currentStream->m_waitOnDrain = true;
 415     m_currentStream->m_prepareNextAtFrame = 0;
 416     si->m_decoder.Destroy();
 417     delete si;
 418     return false;
 419   }
 420
 421   si->m_prepareTriggered = false;
 422   si->m_playNextAtFrame = 0;
 423   si->m_playNextTriggered = false;
 424   si->m_waitOnDrain = false;
 425
 426   if (!PrepareStream(si))
 427   {
 428     CLog::Log(LOGINFO, "PAPlayer::QueueNextFileEx - Error preparing stream");
 429
 430     si->m_decoder.Destroy();
 431     // advance playlist
 432     AdvancePlaylistOnError(*si->m_fileItem);
 433     m_callback.OnQueueNextItem();
 434     delete si;
 435     return false;
 436   }
 437
 438   /* add the stream to the list */
 439   std::unique_lock<CCriticalSection> lock(m_streamsLock);
 440   m_streams.push_back(si);
 441   //update the current stream to start playing the next track at the correct frame.
 442   UpdateStreamInfoPlayNextAtFrame(m_currentStream, m_upcomingCrossfadeMS);
 443
 444   return true;
 445 }
 446
 447 void PAPlayer::UpdateStreamInfoPlayNextAtFrame(StreamInfo *si, unsigned int crossFadingTime)
 448 {
 449   // if no crossfading or cue sheet, wait for eof
 450   if (si && (crossFadingTime || si->m_endOffset))
 451   {
 452     int64_t streamTotalTime = si->m_decoder.TotalTime();
 453     if (si->m_endOffset)
 454       streamTotalTime = si->m_endOffset - si->m_startOffset;
 455     if (streamTotalTime < crossFadingTime)
 456       si->m_playNextAtFrame = (int)((streamTotalTime / 2) * si->m_audioFormat.m_sampleRate / 1000.0f);
 457     else
 458       si->m_playNextAtFrame = (int)((streamTotalTime - crossFadingTime) * si->m_audioFormat.m_sampleRate / 1000.0f);
 459   }
 460 }
 461
 462 inline bool PAPlayer::PrepareStream(StreamInfo *si)
 463 {
 464   /* if we have a stream we are already prepared */
 465   if (si->m_stream)
 466     return true;
 467
 468   /* get a paused stream */
 469   AEAudioFormat format = si->m_audioFormat;
 470   si->m_stream = CServiceBroker::GetActiveAE()->MakeStream(
 471     format,
 472     AESTREAM_PAUSED
 473   );
 474
 475   if (!si->m_stream)
 476   {
 477     CLog::Log(LOGDEBUG, "PAPlayer::PrepareStream - Failed to get IAEStream");
 478     return false;
 479   }
 480
 481   si->m_stream->SetVolume(si->m_volume);
 482   float peak = 1.0;
 483   float gain = si->m_decoder.GetReplayGain(peak);
 484   if (peak * gain <= 1.0f)
 485     // No clipping protection needed
 486     si->m_stream->SetReplayGain(gain);
 487   else if (CServiceBroker::GetSettingsComponent()->GetSettings()->GetBool(CSettings::SETTING_MUSICPLAYER_REPLAYGAINAVOIDCLIPPING))
 488     // Normalise volume reducing replaygain to avoid needing clipping protection, plays file at lower level
 489     si->m_stream->SetReplayGain(1.0f / fabs(peak));
 490   else
 491     // Clipping protection (when enabled in AE) by audio limiting, applied just where needed
 492     si->m_stream->SetAmplification(gain);
 493
 494   /* if its not the first stream and crossfade is not enabled */
 495   if (m_currentStream && m_currentStream != si && !m_upcomingCrossfadeMS)
 496   {
 497     /* slave the stream for gapless */
 498     si->m_isSlaved = true;
 499     m_currentStream->m_stream->RegisterSlave(si->m_stream.get());
 500   }
 501
 502   /* fill the stream's buffer */
 503   while(si->m_stream->IsBuffering())
 504   {
 505     int status = si->m_decoder.GetStatus();
 506     if (status == STATUS_ENDED   ||
 507         status == STATUS_NO_FILE ||
 508         si->m_decoder.ReadSamples(PACKET_SIZE) == RET_ERROR)
 509     {
 510       CLog::Log(LOGINFO, "PAPlayer::PrepareStream - Stream Finished");
 511       break;
 512     }
 513
 514     if (!QueueData(si))
 515       break;
 516
 517     /* yield our time so that the main PAP thread doesn't stall */
 518     CThread::Sleep(1ms);
 519   }
 520
 521   CLog::Log(LOGINFO, "PAPlayer::PrepareStream - Ready");
 522
 523   return true;
 524 }
 525
 526 bool PAPlayer::CloseFile(bool reopen)
 527 {
 528   if (reopen)
 529     CServiceBroker::GetActiveAE()->KeepConfiguration(3000);
 530
 531   if (!m_isPaused)
 532     SoftStop(true, true);
 533   CloseAllStreams(false);
 534
 535   /* wait for the thread to terminate */
 536   StopThread(true);//true - wait for end of thread
 537
 538   // wait for any pending jobs to complete
 539   {
 540     std::unique_lock<CCriticalSection> lock(m_streamsLock);
 541     while (m_jobCounter > 0)
 542     {
 543       lock.unlock();
 544       m_jobEvent.Wait(100ms);
 545       lock.lock();
 546     }
 547   }
 548   CServiceBroker::GetDataCacheCore().Reset();
 549   return true;
 550 }
 551
 552 void PAPlayer::Process()
 553 {
 554   if (!m_startEvent.Wait(100ms))
 555   {
 556     CLog::Log(LOGDEBUG, "PAPlayer::Process - Failed to receive start event");
 557     return;
 558   }
 559
 560   CLog::Log(LOGDEBUG, "PAPlayer::Process - Playback started");
 561   while(m_isPlaying && !m_bStop)
 562   {
 563     /* this needs to happen outside of any locks to prevent deadlocks */
 564     if (m_signalSpeedChange)
 565     {
 566       m_callback.OnPlayBackSpeedChanged(m_playbackSpeed);
 567       m_signalSpeedChange = false;
 568     }
 569
 570     double freeBufferTime = 0.0;
 571     ProcessStreams(freeBufferTime);
 572
 573     // if none of our streams wants at least 10ms of data, we sleep
 574     if (freeBufferTime < 0.01)
 575     {
 576       CThread::Sleep(10ms);
 577     }
 578
 579     if (m_newForcedPlayerTime != -1)
 580     {
 581       if (SetTimeInternal(m_newForcedPlayerTime))
 582       {
 583         m_newForcedPlayerTime = -1;
 584       }
 585     }
 586
 587     if (m_newForcedTotalTime != -1)
 588     {
 589       if (SetTotalTimeInternal(m_newForcedTotalTime))
 590       {
 591         m_newForcedTotalTime = -1;
 592       }
 593     }
 594
 595     GetTimeInternal(); //update for GUI
 596   }
 597   m_isPlaying = false;
 598 }
 599
 600 inline void PAPlayer::ProcessStreams(double &freeBufferTime)
 601 {
 602   std::unique_lock<CCriticalSection> sharedLock(m_streamsLock);
 603   if (m_isFinished && m_streams.empty() && m_finishing.empty())
 604   {
 605     m_isPlaying = false;
 606     freeBufferTime = 1.0;
 607     return;
 608   }
 609
 610   /* destroy any drained streams */
 611   for (auto itt = m_finishing.begin(); itt != m_finishing.end();)
 612   {
 613     StreamInfo* si = *itt;
 614     if (si->m_stream->IsDrained())
 615     {
 616       itt = m_finishing.erase(itt);
 617       CloseFileCB(*si);
 618       delete si;
 619       CLog::Log(LOGDEBUG, "PAPlayer::ProcessStreams - Stream Freed");
 620     }
 621     else
 622       ++itt;
 623   }
 624
 625   sharedLock.unlock();
 626   std::unique_lock<CCriticalSection> lock(m_streamsLock);
 627
 628   for(StreamList::iterator itt = m_streams.begin(); itt != m_streams.end(); ++itt)
 629   {
 630     StreamInfo* si = *itt;
 631     if (!m_currentStream && !si->m_started)
 632     {
 633       m_currentStream = si;
 634       UpdateGUIData(si); //update for GUI
 635     }
 636     /* if the stream is finishing */
 637     if ((si->m_playNextTriggered && si->m_stream && !si->m_stream->IsFading()) || !ProcessStream(si, freeBufferTime))
 638     {
 639       if (!si->m_prepareTriggered)
 640       {
 641         if (si->m_waitOnDrain)
 642         {
 643           si->m_stream->Drain(true);
 644           si->m_waitOnDrain = false;
 645         }
 646         si->m_prepareTriggered = true;
 647         m_callback.OnQueueNextItem();
 648       }
 649
 650       /* remove the stream */
 651       itt = m_streams.erase(itt);
 652       /* if its the current stream */
 653       if (si == m_currentStream)
 654       {
 655         /* if it was the last stream */
 656         if (itt == m_streams.end())
 657         {
 658           /* if it didn't trigger the next queue item */
 659           if (!si->m_prepareTriggered)
 660           {
 661             if (si->m_waitOnDrain)
 662             {
 663               si->m_stream->Drain(true);
 664               si->m_waitOnDrain = false;
 665             }
 666             m_callback.OnQueueNextItem();
 667             si->m_prepareTriggered = true;
 668           }
 669           m_currentStream = NULL;
 670         }
 671         else
 672         {
 673           m_currentStream = *itt;
 674           UpdateGUIData(*itt); //update for GUI
 675         }
 676       }
 677
 678       /* unregister the audio callback */
 679       si->m_stream->UnRegisterAudioCallback();
 680       si->m_decoder.Destroy();
 681       si->m_stream->Drain(false);
 682       m_finishing.push_back(si);
 683       return;
 684     }
 685
 686     if (!si->m_started)
 687       continue;
 688
 689     // is it time to prepare the next stream?
 690     if (si->m_prepareNextAtFrame > 0 && !si->m_prepareTriggered && si->m_framesSent >= si->m_prepareNextAtFrame)
 691     {
 692       si->m_prepareTriggered = true;
 693       m_callback.OnQueueNextItem();
 694     }
 695
 696     // it is time to start playing the next stream?
 697     if (si->m_playNextAtFrame > 0 && !si->m_playNextTriggered && !si->m_nextFileItem && si->m_framesSent >= si->m_playNextAtFrame)
 698     {
 699       if (!si->m_prepareTriggered)
 700       {
 701         si->m_prepareTriggered = true;
 702         m_callback.OnQueueNextItem();
 703       }
 704
 705       if (!m_isFinished)
 706       {
 707         if (m_upcomingCrossfadeMS)
 708         {
 709           si->m_stream->FadeVolume(1.0f, 0.0f, m_upcomingCrossfadeMS);
 710           si->m_fadeOutTriggered = true;
 711         }
 712         m_currentStream = NULL;
 713
 714         /* unregister the audio callback */
 715         si->m_stream->UnRegisterAudioCallback();
 716       }
 717
 718       si->m_playNextTriggered = true;
 719     }
 720   }
 721 }
 722
 723 inline bool PAPlayer::ProcessStream(StreamInfo *si, double &freeBufferTime)
 724 {
 725   /* if playback needs to start on this stream, do it */
 726   if (si == m_currentStream && !si->m_started)
 727   {
 728     si->m_started = true;
 729     si->m_stream->RegisterAudioCallback(m_audioCallback);
 730     if (!si->m_isSlaved)
 731       si->m_stream->Resume();
 732     si->m_stream->FadeVolume(0.0f, 1.0f, m_upcomingCrossfadeMS);
 733     if (m_signalStarted)
 734       m_callback.OnPlayBackStarted(*si->m_fileItem);
 735     m_signalStarted = true;
 736     if (m_fullScreen)
 737     {
 738       CServiceBroker::GetAppMessenger()->PostMsg(TMSG_SWITCHTOFULLSCREEN);
 739       m_fullScreen = false;
 740     }
 741     m_callback.OnAVStarted(*si->m_fileItem);
 742   }
 743
 744   /* if we have not started yet and the stream has been primed */
 745   unsigned int space = si->m_stream->GetSpace();
 746   if (!si->m_started && !space)
 747     return true;
 748
 749   if (!m_playbackSpeed)
 750     return true;
 751
 752   /* see if it is time yet to FF/RW or a direct seek */
 753   if (!si->m_playNextTriggered && ((m_playbackSpeed != 1 && si->m_framesSent >= si->m_seekNextAtFrame) || si->m_seekFrame > -1))
 754   {
 755     int64_t time = (int64_t)0;
 756     /* if its a direct seek */
 757     if (si->m_seekFrame > -1)
 758     {
 759       time = (int64_t)((float)si->m_seekFrame / (float)si->m_audioFormat.m_sampleRate * 1000.0f);
 760       si->m_framesSent = (int)(si->m_seekFrame - ((float)si->m_startOffset * (float)si->m_audioFormat.m_sampleRate) / 1000.0f);
 761       si->m_seekFrame  = -1;
 762       m_playerGUIData.m_time = time; //update for GUI
 763       si->m_seekNextAtFrame = 0;
 764       CDataCacheCore::GetInstance().SetPlayTimes(0, time, 0, m_playerGUIData.m_totalTime);
 765     }
 766     /* if its FF/RW */
 767     else
 768     {
 769       si->m_framesSent      += si->m_audioFormat.m_sampleRate * (m_playbackSpeed  - 1);
 770       si->m_seekNextAtFrame  = si->m_framesSent + si->m_audioFormat.m_sampleRate / 2;
 771       time = (int64_t)(((float)si->m_framesSent / (float)si->m_audioFormat.m_sampleRate * 1000.0f) + (float)si->m_startOffset);
 772     }
 773
 774     /* if we are seeking back before the start of the track start normal playback */
 775     if (time < si->m_startOffset || si->m_framesSent < 0)
 776     {
 777       time = si->m_startOffset;
 778       si->m_framesSent      = 0;
 779       si->m_seekNextAtFrame = 0;
 780       SetSpeed(1);
 781     }
 782
 783     si->m_decoder.Seek(time);
 784   }
 785
 786   int status = si->m_decoder.GetStatus();
 787   if (status == STATUS_ENDED   ||
 788       status == STATUS_NO_FILE ||
 789       si->m_decoder.ReadSamples(PACKET_SIZE) == RET_ERROR ||
 790       ((si->m_endOffset) && (si->m_framesSent / si->m_audioFormat.m_sampleRate >= (si->m_endOffset - si->m_startOffset) / 1000)))
 791   {
 792     if (si == m_currentStream && si->m_nextFileItem)
 793     {
 794       CloseFileCB(*si);
 795
 796       // update current stream with info of next track
 797       si->m_startOffset = si->m_nextFileItem->GetStartOffset();
 798       if (si->m_nextFileItem->GetEndOffset())
 799         si->m_endOffset = si->m_nextFileItem->GetEndOffset();
 800       else
 801         si->m_endOffset = 0;
 802       si->m_framesSent = 0;
 803
 804       *si->m_fileItem = *si->m_nextFileItem;
 805       si->m_nextFileItem.reset();
 806
 807       int64_t streamTotalTime = si->m_decoder.TotalTime() - si->m_startOffset;
 808       if (si->m_endOffset)
 809         streamTotalTime = si->m_endOffset - si->m_startOffset;
 810
 811       // calculate time when to prepare next stream
 812       si->m_prepareNextAtFrame = 0;
 813       if (streamTotalTime >= TIME_TO_CACHE_NEXT_FILE + m_defaultCrossfadeMS)
 814         si->m_prepareNextAtFrame = (int)((streamTotalTime - TIME_TO_CACHE_NEXT_FILE - m_defaultCrossfadeMS) * si->m_audioFormat.m_sampleRate / 1000.0f);
 815
 816       si->m_prepareTriggered = false;
 817       si->m_playNextAtFrame = 0;
 818       si->m_playNextTriggered = false;
 819       si->m_seekNextAtFrame = 0;
 820
 821       //update the current stream to start playing the next track at the correct frame.
 822       UpdateStreamInfoPlayNextAtFrame(m_currentStream, m_upcomingCrossfadeMS);
 823
 824       UpdateGUIData(si);
 825       if (m_signalStarted)
 826         m_callback.OnPlayBackStarted(*si->m_fileItem);
 827       m_signalStarted = true;
 828       m_callback.OnAVStarted(*si->m_fileItem);
 829     }
 830     else
 831     {
 832       CLog::Log(LOGINFO, "PAPlayer::ProcessStream - Stream Finished");
 833       return false;
 834     }
 835   }
 836
 837   if (!QueueData(si))
 838     return false;
 839
 840   /* update free buffer time if we are running */
 841   if (si->m_started)
 842   {
 843     if (si->m_stream->IsBuffering())
 844       freeBufferTime = 1.0;
 845     else
 846     {
 847       double free_space;
 848       if (si->m_audioFormat.m_dataFormat != AE_FMT_RAW)
 849         free_space = (double)(si->m_stream->GetSpace() / si->m_bytesPerSample) / si->m_audioFormat.m_sampleRate;
 850       else
 851       {
 852         free_space = static_cast<double>(si->m_stream->GetSpace()) *
 853                      si->m_audioFormat.m_streamInfo.GetDuration() / 1000;
 854       }
 855
 856       freeBufferTime = std::max(freeBufferTime , free_space);
 857     }
 858   }
 859
 860   return true;
 861 }
 862
 863 bool PAPlayer::QueueData(StreamInfo *si)
 864 {
 865   unsigned int space = si->m_stream->GetSpace();
 866
 867   if (si->m_audioFormat.m_dataFormat != AE_FMT_RAW)
 868   {
 869     unsigned int samples = std::min(si->m_decoder.GetDataSize(false), space / si->m_bytesPerSample);
 870     if (!samples)
 871       return true;
 872
 873     // we want complete frames
 874     samples -= samples % si->m_audioFormat.m_channelLayout.Count();
 875
 876     uint8_t* data = (uint8_t*)si->m_decoder.GetData(samples);
 877     if (!data)
 878     {
 879       CLog::Log(LOGERROR, "PAPlayer::QueueData - Failed to get data from the decoder");
 880       return false;
 881     }
 882
 883     unsigned int frames = samples/si->m_audioFormat.m_channelLayout.Count();
 884     unsigned int added = si->m_stream->AddData(&data, 0, frames, nullptr);
 885     si->m_framesSent += added;
 886   }
 887   else
 888   {
 889     if (!space)
 890       return true;
 891
 892     int size;
 893     uint8_t *data = si->m_decoder.GetRawData(size);
 894     if (data && size)
 895     {
 896       int added = si->m_stream->AddData(&data, 0, size, nullptr);
 897       if (added != size)
 898       {
 899         CLog::Log(LOGERROR, "PAPlayer::QueueData - unknown error");
 900         return false;
 901       }
 902
 903       si->m_framesSent += si->m_audioFormat.m_streamInfo.GetDuration() / 1000 *
 904                           si->m_audioFormat.m_streamInfo.m_sampleRate;
 905     }
 906   }
 907
 908   const ICodec* codec = si->m_decoder.GetCodec();
 909   m_playerGUIData.m_cacheLevel = codec ? codec->GetCacheLevel() : 0; //update for GUI
 910
 911   return true;
 912 }
 913
 914 void PAPlayer::OnExit()
 915 {
 916   //@todo signal OnPlayBackError if there was an error on last stream
 917   if (m_isFinished && !m_bStop)
 918     m_callback.OnPlayBackEnded();
 919   else
 920     m_callback.OnPlayBackStopped();
 921 }
 922
 923 void PAPlayer::OnNothingToQueueNotify()
 924 {
 925   m_isFinished = true;
 926 }
 927
 928 bool PAPlayer::IsPlaying() const
 929 {
 930   return m_isPlaying;
 931 }
 932
 933 void PAPlayer::Pause()
 934 {
 935   if (m_isPaused)
 936   {
 937     SetSpeed(1);
 938   }
 939   else
 940   {
 941     SetSpeed(0);
 942   }
 943 }
 944
 945 void PAPlayer::SetVolume(float volume)
 946 {
 947
 948 }
 949
 950 void PAPlayer::SetDynamicRangeCompression(long drc)
 951 {
 952
 953 }
 954
 955 void PAPlayer::SetSpeed(float speed)
 956 {
 957   m_playbackSpeed = static_cast<int>(speed);
 958   CDataCacheCore::GetInstance().SetSpeed(1.0, speed);
 959   if (m_playbackSpeed != 0 && m_isPaused)
 960   {
 961     m_isPaused = false;
 962     SoftStart();
 963     m_callback.OnPlayBackResumed();
 964   }
 965   else if (m_playbackSpeed == 0 && !m_isPaused)
 966   {
 967     m_isPaused = true;
 968     SoftStop(true, false);
 969     m_callback.OnPlayBackPaused();
 970   }
 971   m_signalSpeedChange = true;
 972 }
 973
 974 int64_t PAPlayer::GetTimeInternal()
 975 {
 976   std::unique_lock<CCriticalSection> lock(m_streamsLock);
 977   if (!m_currentStream)
 978     return 0;
 979
 980   double time = ((double)m_currentStream->m_framesSent / (double)m_currentStream->m_audioFormat.m_sampleRate);
 981   if (m_currentStream->m_stream)
 982     time -= m_currentStream->m_stream->GetDelay();
 983   time = time * 1000.0;
 984
 985   m_playerGUIData.m_time = (int64_t)time; //update for GUI
 986   CDataCacheCore::GetInstance().SetPlayTimes(0, time, 0, m_playerGUIData.m_totalTime);
 987
 988   return (int64_t)time;
 989 }
 990
 991 bool PAPlayer::SetTotalTimeInternal(int64_t time)
 992 {
 993   std::unique_lock<CCriticalSection> lock(m_streamsLock);
 994   if (!m_currentStream)
 995   {
 996     return false;
 997   }
 998
 999   m_currentStream->m_decoder.SetTotalTime(time);
1000   UpdateGUIData(m_currentStream);
1001
1002   return true;
1003 }
1004
1005 bool PAPlayer::SetTimeInternal(int64_t time)
1006 {
1007   std::unique_lock<CCriticalSection> lock(m_streamsLock);
1008   if (!m_currentStream)
1009     return false;
1010
1011   m_currentStream->m_framesSent = time / 1000 * m_currentStream->m_audioFormat.m_sampleRate;
1012
1013   if (m_currentStream->m_stream)
1014     m_currentStream->m_framesSent += m_currentStream->m_stream->GetDelay() * m_currentStream->m_audioFormat.m_sampleRate;
1015
1016   return true;
1017 }
1018
1019 void PAPlayer::SetTime(int64_t time)
1020 {
1021   m_newForcedPlayerTime = time;
1022 }
1023
1024 int64_t PAPlayer::GetTotalTime64()
1025 {
1026   std::unique_lock<CCriticalSection> lock(m_streamsLock);
1027   if (!m_currentStream)
1028     return 0;
1029
1030   int64_t total = m_currentStream->m_decoder.TotalTime();
1031   if (m_currentStream->m_endOffset)
1032     total = m_currentStream->m_endOffset;
1033   total -= m_currentStream->m_startOffset;
1034   return total;
1035 }
1036
1037 void PAPlayer::SetTotalTime(int64_t time)
1038 {
1039   m_newForcedTotalTime = time;
1040 }
1041
1042 int PAPlayer::GetCacheLevel() const
1043 {
1044   return m_playerGUIData.m_cacheLevel;
1045 }
1046
1047 void PAPlayer::GetAudioStreamInfo(int index, AudioStreamInfo& info) const
1048 {
1049   info.bitrate = m_playerGUIData.m_audioBitrate;
1050   info.channels = m_playerGUIData.m_channelCount;
1051   info.codecName = m_playerGUIData.m_codec;
1052   info.samplerate = m_playerGUIData.m_sampleRate;
1053   info.bitspersample = m_playerGUIData.m_bitsPerSample;
1054 }
1055
1056 bool PAPlayer::CanSeek() const
1057 {
1058   return m_playerGUIData.m_canSeek;
1059 }
1060
1061 void PAPlayer::Seek(bool bPlus, bool bLargeStep, bool bChapterOverride)
1062 {
1063   if (!CanSeek()) return;
1064
1065   long long seek;
1066   const std::shared_ptr<CAdvancedSettings> advancedSettings = CServiceBroker::GetSettingsComponent()->GetAdvancedSettings();
1067   if (advancedSettings->m_musicUseTimeSeeking && m_playerGUIData.m_totalTime > 2 * advancedSettings->m_musicTimeSeekForwardBig)
1068   {
1069     if (bLargeStep)
1070       seek = bPlus ? advancedSettings->m_musicTimeSeekForwardBig : advancedSettings->m_musicTimeSeekBackwardBig;
1071     else
1072       seek = bPlus ? advancedSettings->m_musicTimeSeekForward : advancedSettings->m_musicTimeSeekBackward;
1073     seek *= 1000;
1074     seek += m_playerGUIData.m_time;
1075   }
1076   else
1077   {
1078     float percent;
1079     if (bLargeStep)
1080       percent = bPlus ? static_cast<float>(advancedSettings->m_musicPercentSeekForwardBig) : static_cast<float>(advancedSettings->m_musicPercentSeekBackwardBig);
1081     else
1082       percent = bPlus ? static_cast<float>(advancedSettings->m_musicPercentSeekForward) : static_cast<float>(advancedSettings->m_musicPercentSeekBackward);
1083     seek = static_cast<long long>(GetTotalTime64() * (GetPercentage() + percent) / 100);
1084   }
1085
1086   SeekTime(seek);
1087 }
1088
1089 void PAPlayer::SeekTime(int64_t iTime /*=0*/)
1090 {
1091   if (!CanSeek()) return;
1092
1093   std::unique_lock<CCriticalSection> lock(m_streamsLock);
1094   if (!m_currentStream)
1095     return;
1096
1097   int64_t seekOffset = iTime - GetTimeInternal();
1098
1099   if (m_playbackSpeed != 1)
1100     SetSpeed(1);
1101
1102   m_currentStream->m_seekFrame = (int)((float)m_currentStream->m_audioFormat.m_sampleRate * ((float)iTime + (float)m_currentStream->m_startOffset) / 1000.0f);
1103   m_callback.OnPlayBackSeek(iTime, seekOffset);
1104 }
1105
1106 void PAPlayer::SeekPercentage(float fPercent /*=0*/)
1107 {
1108   if (fPercent < 0.0f  ) fPercent = 0.0f;
1109   if (fPercent > 100.0f) fPercent = 100.0f;
1110   SeekTime((int64_t)(fPercent * 0.01f * (float)GetTotalTime64()));
1111 }
1112
1113 float PAPlayer::GetPercentage()
1114 {
1115   if (m_playerGUIData.m_totalTime > 0)
1116     return m_playerGUIData.m_time * 100.0f / m_playerGUIData.m_totalTime;
1117
1118   return 0.0f;
1119 }
1120
1121 void PAPlayer::UpdateGUIData(StreamInfo *si)
1122 {
1123   /* Store data need by external threads in member
1124    * structure to prevent locking conflicts when
1125    * data required by GUI and main application
1126    */
1127   std::unique_lock<CCriticalSection> lock(m_streamsLock);
1128
1129   m_playerGUIData.m_sampleRate    = si->m_audioFormat.m_sampleRate;
1130   m_playerGUIData.m_channelCount  = si->m_audioFormat.m_channelLayout.Count();
1131   m_playerGUIData.m_canSeek       = si->m_decoder.CanSeek();
1132
1133   const ICodec* codec = si->m_decoder.GetCodec();
1134
1135   m_playerGUIData.m_audioBitrate = codec ? codec->m_bitRate : 0;
1136   strncpy(m_playerGUIData.m_codec,codec ? codec->m_CodecName.c_str() : "",20);
1137   m_playerGUIData.m_cacheLevel   = codec ? codec->GetCacheLevel() : 0;
1138   m_playerGUIData.m_bitsPerSample = (codec && codec->m_bitsPerCodedSample) ? codec->m_bitsPerCodedSample : si->m_bytesPerSample << 3;
1139
1140   int64_t total = si->m_decoder.TotalTime();
1141   if (si->m_endOffset)
1142     total = m_currentStream->m_endOffset;
1143   total -= m_currentStream->m_startOffset;
1144   m_playerGUIData.m_totalTime = total;
1145
1146   CServiceBroker::GetDataCacheCore().SignalAudioInfoChange();
1147 }
1148
1149 void PAPlayer::OnJobComplete(unsigned int jobID, bool success, CJob *job)
1150 {
1151   std::unique_lock<CCriticalSection> lock(m_streamsLock);
1152   m_jobCounter--;
1153   m_jobEvent.Set();
1154 }
1155
1156 void PAPlayer::CloseFileCB(StreamInfo &si)
1157 {
1158   IPlayerCallback *cb = &m_callback;
1159   CFileItem fileItem(*si.m_fileItem);
1160   CBookmark bookmark;
1161   double total = si.m_decoderTotal;
1162   if (si.m_endOffset)
1163     total = si.m_endOffset;
1164   total -= si.m_startOffset;
1165   bookmark.totalTimeInSeconds = total / 1000;
1166   bookmark.timeInSeconds = (static_cast<double>(si.m_framesSent) /
1167                             static_cast<double>(si.m_audioFormat.m_sampleRate));
1168   bookmark.timeInSeconds -= si.m_stream->GetDelay();
1169   bookmark.player = m_name;
1170   bookmark.playerState = GetPlayerState();
1171   CServiceBroker::GetJobManager()->Submit([=]() { cb->OnPlayerCloseFile(fileItem, bookmark); },
1172                                           CJob::PRIORITY_NORMAL);
1173 }
1174
1175 void PAPlayer::AdvancePlaylistOnError(CFileItem &fileItem)
1176 {
1177   if (m_signalStarted)
1178     m_callback.OnPlayBackStarted(fileItem);
1179   m_signalStarted = true;
1180   m_callback.OnAVStarted(fileItem);
1181 }