Ticket #4222: 4222-v3.patch

mythmusic/playbackbox.cpp

@@ -27 +27 @@
 #include "mainvisual.h"
 #include "smartplaylist.h"
 #include "search.h"
+#include "musicplayer.h"
 
 PlaybackBoxMusic::PlaybackBoxMusic(MythMainWindow *parent, QString window_name,
                                    QString theme_filename, 
@@ -37 +38 @@
                 : MythThemedDialog(parent, window_name, theme_filename, name)
 {
     //  A few internal variable defaults
- 
-    input = NULL;
-    output = NULL;
-    decoder = NULL;
     mainvisual = NULL;
     visual_mode_timer = NULL;
     lcd_update_timer = NULL;
     waiting_for_playlists_timer = NULL;
     speed_scroll_timer = NULL;
-    playlist_tree = NULL;
     playlist_popup = NULL;
     progress = NULL;
 
-    isplaying = false;
+    gPlayer->setListener(this);
+
     tree_is_done = false;
     first_playlist_check = true;
     outputBufferSize = 256;
@@ -112 +109 @@
                 this, SLOT(hideVolume()));
     }
 
-    // Figure out the shuffle mode
+    setShuffleMode(gPlayer->getShuffleMode());
 
-    QString playmode = gContext->GetSetting("PlayMode", "none");
-    if (playmode.lower() == "random")
-        setShuffleMode(SHUFFLE_RANDOM);
-    else if (playmode.lower() == "intelligent")
-        setShuffleMode(SHUFFLE_INTELLIGENT);
-    else if (playmode.lower() == "album")
-        setShuffleMode(SHUFFLE_ALBUM);
-    else if (playmode.lower() == "artist")
-        setShuffleMode(SHUFFLE_ARTIST);
-    else
-        setShuffleMode(SHUFFLE_OFF);
-
     QString resumestring = gContext->GetSetting("ResumeMode", "off");
     if (resumestring.lower() == "off")
         resumemode = RESUME_OFF;
@@ -134 +119 @@
     else
         resumemode = RESUME_EXACT;
 
-    QString repeatmode = gContext->GetSetting("RepeatMode", "all");
-    if (repeatmode.lower() == "track")
-        setRepeatMode(REPEAT_TRACK);
-    else if (repeatmode.lower() == "all")
-        setRepeatMode(REPEAT_ALL);
-    else
-        setRepeatMode(REPEAT_OFF);
+    setRepeatMode(gPlayer->getRepeatMode());
 
     // Set some button values
 
@@ -170 +149 @@
         // Set please wait on the LCD
         QPtrList<LCDTextItem> textItems;
         textItems.setAutoDelete(true);
-        
+
         textItems.append(new LCDTextItem(1, ALIGN_CENTERED, "Please Wait", 
                          "Generic"));
         lcd->switchToGeneric(&textItems);
@@ -196 +175 @@
         mainvisual->setGeometry(screenwidth + 10, screenheight + 10, 160, 160);
     mainvisual->show();
 
+    gPlayer->setVisual(mainvisual);
+
     fullscreen_blank = false; 
 
     visual_modes = QStringList::split(';', gContext->GetSetting("VisualMode"));
@@ -240 +221 @@
 {
     savePosition(currentTime);
 
-    stopAll();
-
-    if (output)
-    {
-        delete output;
-        output = NULL;
-    }
-
     if (progress)
     {
         progress->Close();
@@ -262 +235 @@
         delete cd_reader_thread;
     }
 
-    if (playlist_tree)
-        delete playlist_tree;
-
-    if (shufflemode == SHUFFLE_INTELLIGENT)
+    MusicPlayer::ShuffleMode shufflemode = gPlayer->getShuffleMode();
+    if (shufflemode == MusicPlayer::SHUFFLE_INTELLIGENT)
         gContext->SaveSetting("PlayMode", "intelligent");
-    else if (shufflemode == SHUFFLE_RANDOM)
+    else if (shufflemode == MusicPlayer::SHUFFLE_RANDOM)
         gContext->SaveSetting("PlayMode", "random");
-    else if (shufflemode == SHUFFLE_ALBUM)
+    else if (shufflemode == MusicPlayer::SHUFFLE_ALBUM)
         gContext->SaveSetting("PlayMode", "album");
-    else if (shufflemode == SHUFFLE_ARTIST)
+    else if (shufflemode == MusicPlayer::SHUFFLE_ARTIST)
         gContext->SaveSetting("PlayMode", "artist");
     else
         gContext->SaveSetting("PlayMode", "none");
 
-    if (repeatmode == REPEAT_TRACK)
+    MusicPlayer::RepeatMode repeatmode = gPlayer->getRepeatMode();
+    if (repeatmode == MusicPlayer::REPEAT_TRACK)
         gContext->SaveSetting("RepeatMode", "track");
-    else if (repeatmode == REPEAT_ALL)
+    else if (repeatmode == MusicPlayer::REPEAT_ALL)
         gContext->SaveSetting("RepeatMode", "all");
     else
         gContext->SaveSetting("RepeatMode", "none");
+
     if (class LCD *lcd = LCD::Get())
         lcd->switchToTime();
 }
@@ -304 +277 @@
     resetTimer();
 
     QStringList actions;
-    gContext->GetMainWindow()->TranslateKeyPress("Music", e, actions);
+    gContext->GetMainWindow()->TranslateKeyPress("Music", e, actions, false);
 
     int scrollAmt = 1;
 
@@ -343 +316 @@
         }
         else if (action == "PAUSE")
         { 
-            if (isplaying)
+            if (gPlayer->isPlaying())
             {
                 if (pause_button)
                     pause_button->push();
@@ -371 +344 @@
                 stop_button->push();
             else
                 stop();
-
             currentTime = 0;
         }
         else if (action == "THMBUP")
@@ -427 +399 @@
                 bannerToggle(curMeta);
             else
                 showEditMetadataDialog();
+        else if (action == "ESCAPE" && visualizer_status != 2)
+        {
+            DialogBox *dialog = new DialogBox(gContext->GetMainWindow(),
+                             tr("Exiting Music Player\n"
+                             "Do you want to continue playing in the background?"));
+            dialog->AddButton("No - Exit, Stop Playing");
+            dialog->AddButton("Yes - Exit, Continue Playing");
+            dialog->AddButton("Cancel");
+            int res = dialog->exec();
+            dialog->deleteLater();
+
+            if (res == kDialogCodeButton0)
+            {
+                stopAll();
+                done(kDialogCodeAccepted);
+            }
+            else if (res == kDialogCodeButton1)
+            {
+                gPlayer->setListener(NULL);
+                gPlayer->setVisual(NULL);
+                done(kDialogCodeAccepted);
+            }
+            else
+                handled = true;
+        }
         else
             handled = false;
     }
@@ -541 +538 @@
                 music_tree_list->incSearchStart();
             else if (action == "INCSEARCHNEXT")
                 music_tree_list->incSearchNext();
-            else
-                handled = false;
         }
     }
     else
@@ -565 +560 @@
                 handled = false;
         }
     }
-
-    if (!handled)
-        MythThemedDialog::keyPressEvent(e);
 }
 
 void PlaybackBoxMusic::handlePush(QString buttonname)
@@ -949 +941 @@
     if (cd_reader_thread->getLock()->locked())
         return;
 
-    if (!scan_for_cd) {
+    if (!scan_for_cd) 
+    {
         cd_watcher->stop();
         delete cd_watcher;
         cd_watcher = NULL;
@@ -1062 +1055 @@
         GenericTree *node = music_tree_list->getCurrentNode();
         curMeta = all_music->getMetadata(node->getInt());
 
-        setShuffleMode(shufflemode);
+        setShuffleMode(gPlayer->getShuffleMode());
 
         music_tree_list->refresh();
 
@@ -1104 +1097 @@
                 branches_to_current_node.append(1); //  We're on a playlist (not "My Music")
                 branches_to_current_node.append(0); //  Active play Queue
 
-                if (resumemode > RESUME_OFF)
-                    restorePosition();
+                if (gPlayer->isPlaying())
+                {
+                    restorePosition(gPlayer->getRouteToCurrent());
+                }
                 else
-                    music_tree_list->moveToNodesFirstChild(branches_to_current_node);
+                {
+                    if (resumemode > RESUME_OFF)
+                        restorePosition(gContext->GetSetting("MusicBookmark", ""));
+                    else
+                        music_tree_list->moveToNodesFirstChild(branches_to_current_node);
+                }
 
                 music_tree_list->refresh();
                 if (show_whole_tree)
@@ -1162 +1162 @@
 
 void PlaybackBoxMusic::changeVolume(bool up_or_down)
 {
-    if (volume_control && output)
+    if (volume_control && gPlayer->getOutput())
     {
         if (up_or_down)
-            output->AdjustCurrentVolume(2);
+            gPlayer->getOutput()->AdjustCurrentVolume(2);
         else
-            output->AdjustCurrentVolume(-2);
+            gPlayer->getOutput()->AdjustCurrentVolume(-2);
         showVolume(true);
     }
 }
 
 void PlaybackBoxMusic::toggleMute()
 {
-    if (volume_control && output)
+    if (volume_control && gPlayer->getOutput())
     {
-        output->ToggleMute();
+        gPlayer->getOutput()->ToggleMute();
         showVolume(true);
     }
 }
@@ -1184 +1184 @@
 void PlaybackBoxMusic::showProgressBar()
 {
 
-    if (progress_bar) {
-
+    if (progress_bar) 
+    {
              progress_bar->SetTotal(maxTime);
              progress_bar->SetUsed(currentTime);
     }
@@ -1194 +1194 @@
 void PlaybackBoxMusic::showVolume(bool on_or_off)
 {
     float volume_level;
-    if (volume_control && output)
+    if (volume_control && gPlayer->getOutput())
     {
         if (volume_status)
         {
             if (on_or_off)
             {
-                volume_status->SetUsed(output->GetCurrentVolume());
+                volume_status->SetUsed(gPlayer->getOutput()->GetCurrentVolume());
                 volume_status->SetOrder(0);
                 volume_status->refresh();
                 volume_display_timer->changeInterval(2000);
                 if (class LCD *lcd = LCD::Get())
                     lcd->switchToVolume("Music");
 
-                if (output->GetMute())
+                if (gPlayer->getOutput()->GetMute())
                     volume_level = 0.0;
                 else
-                    volume_level = (float)output->GetCurrentVolume() / 
+                    volume_level = (float)gPlayer->getOutput()->GetCurrentVolume() / 
                                    (float)100;
 
                 if (class LCD *lcd = LCD::Get())
@@ -1239 +1239 @@
 
 void PlaybackBoxMusic::play()
 {
+    if (gPlayer->isPlaying())
+        gPlayer->stop();
 
-    if (isplaying)
-        stop();
-
     if (curMeta)
         playfile = curMeta->Filename();
     else
@@ -1252 +1251 @@
         return;
     }
 
-    QUrl sourceurl(playfile);
-    QString sourcename(playfile);
-
-    if (!output)
-        openOutputDevice();
-
-    if (output->GetPause())
+    if (gPlayer->getOutput() && gPlayer->getOutput()->GetPause())
     {
-        pause();
+        gPlayer->pause();
         return;
     }
 
-    if (!sourceurl.isLocalFile()) 
-    {
-        StreamInput streaminput(sourceurl);
-        streaminput.setup();
-        input = streaminput.socket();
-    } 
-    else
-        input = new QFile(playfile);
-    
-    if (decoder && !decoder->factory()->supports(sourcename))
-    {
-        decoder->removeListener(this);
-        decoder = 0;
-    }
+    gPlayer->setCurrentNode(music_tree_list->getCurrentNode());
+    gPlayer->playFile(playfile);
 
-    if (!decoder)
-    {
-        decoder = Decoder::create(sourcename, input, output);
-
-        if (!decoder) 
-        {
-            printf("mythmusic: unsupported fileformat\n");
-            stopAll();
-            return;
-        }
-        if (sourcename.contains("cda") == 1)
-            dynamic_cast<CdDecoder*>(decoder)->setDevice(m_CDdevice);
-
-        decoder->setBlockSize(globalBlockSize);
-        decoder->addListener(this);
-    } 
-    else 
-    {
-        decoder->setInput(input);
-        decoder->setFilename(sourcename);
-        decoder->setOutput(output);
-    }
-
     currentTime = 0;
 
-    mainvisual->setDecoder(decoder);
-    mainvisual->setOutput(output);
+    mainvisual->setDecoder(gPlayer->getDecoder());
+    mainvisual->setOutput(gPlayer->getOutput());
     mainvisual->setMetadata(curMeta);
 
-    if (decoder->initialize()) 
+    if (!gPlayer->isPlaying())
     {
-        if (output)
+        if (resumemode == RESUME_EXACT && 
+                gContext->GetNumSetting("MusicBookmarkPosition", 0) > 0)
         {
-            output->Reset();
-        }
-
-        decoder->start();
-
-        if (resumemode == RESUME_EXACT && gContext->GetNumSetting("MusicBookmarkPosition", 0) > 0)
-        {
             seek(gContext->GetNumSetting("MusicBookmarkPosition", 0));
             gContext->SaveSetting("MusicBookmarkPosition", 0);
         }
-
-        bannerEnable(curMeta, show_album_art);
-        isplaying = true;
-        curMeta->setLastPlay();
-        curMeta->incPlayCount();
     }
+
+    bannerEnable(curMeta, show_album_art);
 }
 
 void PlaybackBoxMusic::visEnable()
 {
-    if (!visualizer_status != 2 && isplaying)
+    if (!visualizer_status != 2 && gPlayer->isPlaying())
     {
         setUpdatesEnabled(false);
         mainvisual->setGeometry(0, 0, screenwidth, screenheight);
@@ -1410 +1359 @@
 void PlaybackBoxMusic::setTrackOnLCD(Metadata *mdata)
 {
     LCD *lcd = LCD::Get();
-    if (!lcd)
+    if (!lcd || !mdata)
         return;
 
     // Set the Artist and Tract on the LCD
@@ -1421 +1370 @@
 
 void PlaybackBoxMusic::pause(void)
 {
-    if (output) 
-    {
-        isplaying = !isplaying;
-        output->Pause(!isplaying); //Note pause doesn't take effect instantly
-    }
-    // wake up threads
-    if (decoder) 
-    {
-        decoder->lock();
-        decoder->cond()->wakeAll();
-        decoder->unlock();
-    }
-
+    gPlayer->pause();
 }
 
-void PlaybackBoxMusic::stopDecoder(void)
-{
-    if (decoder && decoder->running()) 
-        decoder->stop();
-
-    if (decoder) 
-    {
-        decoder->lock();
-        decoder->cond()->wakeAll();
-        decoder->unlock();
-    }
-
-    if (decoder)
-        decoder->wait();
-}
-
 void PlaybackBoxMusic::stop(void)
 {
-    stopDecoder();
+    gPlayer->stop();
 
-    if (output)
-    {
-        if (output->GetPause())
-        {
-            pause();
-        }
-        output->Reset();
-    }
-
     mainvisual->setDecoder(0);
     mainvisual->setOutput(0);
     mainvisual->deleteMetadata();
 
-    delete input;
-    input = 0;
-
     QString time_string = getTimeString(maxTime, 0);
 
     if (time_text)
         time_text->SetText(time_string);
     if (info_text)
         info_text->SetText("");
-
-    isplaying = false;
 }
 
 void PlaybackBoxMusic::stopAll()
@@ -1489 +1396 @@
         lcd->switchToTime();
     }
 
-    stop();
+    mainvisual->setDecoder(0);
+    mainvisual->setOutput(0);
+    mainvisual->deleteMetadata();
 
-    if (decoder) 
-    {
-        decoder->removeListener(this);
-        decoder = 0;
-    }
+    gPlayer->stop(true);
 }
 
 void PlaybackBoxMusic::previous()
 {
-    if (repeatmode == REPEAT_ALL)
+    if (gPlayer->getRepeatMode() == MusicPlayer::REPEAT_ALL)
     {
         if (music_tree_list->prevActive(true, show_whole_tree))
             music_tree_list->activate();
@@ -1517 +1422 @@
 
 void PlaybackBoxMusic::next()
 {
-    if (repeatmode == REPEAT_ALL)
+    if (gPlayer->getRepeatMode() == MusicPlayer::REPEAT_ALL)
     {
         // Grab the next track after this one. First flag is to wrap around
         // to the beginning of the list. Second decides if we will traverse up 
@@ -1541 +1446 @@
 
 void PlaybackBoxMusic::nextAuto()
 {
-    stopDecoder();
-
-    isplaying = false;
-
-    if (repeatmode == REPEAT_TRACK)
+    if (gPlayer->getRepeatMode() == MusicPlayer::REPEAT_TRACK)
         play();
     else 
         next();
@@ -1569 +1470 @@
 
 void PlaybackBoxMusic::seek(int pos)
 {
-    if (output)
+    if (gPlayer->getOutput())
     {
-        output->Reset();
-        output->SetTimecode(pos*1000);
+        gPlayer->getOutput()->Reset();
+        gPlayer->getOutput()->SetTimecode(pos*1000);
 
-        if (decoder && decoder->running()) 
+        if (gPlayer->getDecoder() && gPlayer->getDecoder()->running()) 
         {
-            decoder->lock();
-            decoder->seek(pos);
+            gPlayer->getDecoder()->lock();
+            gPlayer->getDecoder()->seek(pos);
 
             if (mainvisual) 
             {
@@ -1586 +1487 @@
                 mainvisual->mutex()->unlock();
             }
 
-            decoder->unlock();
+            gPlayer->getDecoder()->unlock();
         }
 
-        if (!isplaying)
+        if (!gPlayer->isPlaying())
         {
             currentTime = pos;
             if (time_text)
@@ -1614 +1515 @@
     }
 }
 
-void PlaybackBoxMusic::setShuffleMode(unsigned int mode)
+void PlaybackBoxMusic::setShuffleMode(MusicPlayer::ShuffleMode mode)
 {
-    shufflemode = mode;
+    MusicPlayer::ShuffleMode shufflemode = mode;
     QString state;
 
     switch (shufflemode)
     {
-        case SHUFFLE_INTELLIGENT:
+        case MusicPlayer::SHUFFLE_INTELLIGENT:
             state = tr("Smart");
             if (class LCD *lcd = LCD::Get())
                 lcd->setMusicShuffle(LCD::MUSIC_SHUFFLE_SMART);
             break;
-        case SHUFFLE_RANDOM:
+        case MusicPlayer::SHUFFLE_RANDOM:
             state = tr("Rand");
             if (class LCD *lcd = LCD::Get())
                 lcd->setMusicShuffle(LCD::MUSIC_SHUFFLE_RAND);
             break;
-        case SHUFFLE_ALBUM:
+        case MusicPlayer::SHUFFLE_ALBUM:
             state = tr("Album");
             if (class LCD *lcd = LCD::Get())
                 lcd->setMusicShuffle(LCD::MUSIC_SHUFFLE_ALBUM);
             break;
-        case SHUFFLE_ARTIST:
+        case MusicPlayer::SHUFFLE_ARTIST:
             state = tr("Artist");
             if (class LCD *lcd = LCD::Get())
                 lcd->setMusicShuffle(LCD::MUSIC_SHUFFLE_ARTIST);
@@ -1663 +1564 @@
 
     bannerEnable(QString("%1: %2").arg(tr("Shuffle")).arg(state), 4000);
 
-    if (!shufflemode == SHUFFLE_OFF)
+    if (!shufflemode == MusicPlayer::SHUFFLE_OFF)
         music_tree_list->scrambleParents(true);
     else
         music_tree_list->scrambleParents(true);
@@ -1675 +1576 @@
         music_tree_list->setVisualOrdering(1);
     music_tree_list->refresh();
 
-    if (isplaying)
+    if (gPlayer->isPlaying())
         setTrackOnLCD(curMeta);
 }
 
 void PlaybackBoxMusic::toggleShuffle(void)
 {
-    setShuffleMode(++shufflemode % MAX_SHUFFLE_MODES);
+    setShuffleMode(gPlayer->toggleShuffleMode());
 }
 
 void PlaybackBoxMusic::increaseRating()
@@ -1713 +1614 @@
     }
 }
 
-void PlaybackBoxMusic::setRepeatMode(unsigned int mode)
+void PlaybackBoxMusic::setRepeatMode(MusicPlayer::RepeatMode mode)
 {
-    repeatmode = mode;
+    MusicPlayer::RepeatMode repeatmode = mode;
     QString state;
 
     switch (repeatmode)
     {
-        case REPEAT_ALL:
+        case MusicPlayer::REPEAT_ALL:
             state = tr("All");
             if (class LCD *lcd = LCD::Get())
                 lcd->setMusicRepeat (LCD::MUSIC_REPEAT_ALL);
             break;
-        case REPEAT_TRACK:
+        case MusicPlayer::REPEAT_TRACK:
             state = tr("Track");
             if (class LCD *lcd = LCD::Get())
                 lcd->setMusicRepeat (LCD::MUSIC_REPEAT_TRACK);
@@ -1787 +1688 @@
     gContext->SaveSetting("MusicBookmarkPosition", position);
 }
 
-void PlaybackBoxMusic::restorePosition()
+void PlaybackBoxMusic::restorePosition(const QString &position)
 {
     QValueList <int> branches_to_current_node;
-    QString s = gContext->GetSetting("MusicBookmark", "");
 
-    if (s != "")
+    if (position != "")
     {
-        QStringList list = QStringList::split(",", s);
+        QStringList list = QStringList::split(",", position);
 
         for (QStringList::Iterator it = list.begin(); it != list.end(); ++it)
             branches_to_current_node.append((*it).toInt());
@@ -1810 +1710 @@
             {
                 if (music_tree_list->tryToSetActive(branches_to_current_node))
                 {
-                    music_tree_list->select();
+                    if (gPlayer->isPlaying())
+                    {
+                        GenericTree *node = music_tree_list->getCurrentNode();
+                        if (node)
+                        {
+                            curMeta = all_music->getMetadata(node->getInt());
+                            updateTrackInfo(curMeta);
+
+                            maxTime = curMeta->Length() / 1000;
+
+                            QString time_string = getTimeString(maxTime, 0);
+
+                            if (showrating)
+                            {
+                                if (ratings_image)
+                                    ratings_image->setRepeat(curMeta->Rating());
+                            }
+
+                            mainvisual->setDecoder(gPlayer->getDecoder());
+                            mainvisual->setOutput(gPlayer->getOutput());
+                            mainvisual->setMetadata(curMeta);
+                            bannerEnable(curMeta, show_album_art);
+                        }
+                    }
+                    else
+                        music_tree_list->select();
                     return;
                 }
             }
@@ -1820 +1745 @@
             //we're in show all tree mode - try to restore the position
             if (music_tree_list->tryToSetActive(branches_to_current_node))
             {
-                music_tree_list->select();
+                if (gPlayer->isPlaying())
+                {
+                    GenericTree *node = music_tree_list->getCurrentNode();
+                    if (node)
+                    {
+                        curMeta = all_music->getMetadata(node->getInt());
+                        updateTrackInfo(curMeta);
+
+                        maxTime = curMeta->Length() / 1000;
+
+                        QString time_string = getTimeString(maxTime, 0);
+
+                        if (showrating)
+                        {
+                            if (ratings_image)
+                                ratings_image->setRepeat(curMeta->Rating());
+                        }
+
+                        mainvisual->setDecoder(gPlayer->getDecoder());
+                        mainvisual->setOutput(gPlayer->getOutput());
+                        mainvisual->setMetadata(curMeta);
+                        bannerEnable(curMeta, show_album_art);
+                    }
+                }
+                else
+                    music_tree_list->select();
+
                 return;
             }
         }
@@ -1835 +1786 @@
 
 void PlaybackBoxMusic::toggleRepeat()
 {
-    setRepeatMode(++repeatmode % MAX_REPEAT_MODES);
+    setRepeatMode(gPlayer->toggleRepeatMode());
 }
 
 void PlaybackBoxMusic::constructPlaylistTree()
 {
+    GenericTree *playlist_tree = gPlayer->getPlaylistTree();
+
     if (playlist_tree)
         delete playlist_tree;
 
@@ -1919 +1872 @@
         cd_watcher->start(1000);
 }
 
-void PlaybackBoxMusic::closeEvent(QCloseEvent *event)
-{
-    stopAll();
-
-    hide();
-    event->accept();
-}
-
-void PlaybackBoxMusic::showEvent(QShowEvent *event)
-{
-    QWidget::showEvent(event);
-}
-
 void PlaybackBoxMusic::customEvent(QCustomEvent *event)
 {
     switch ((int)event->type()) 
@@ -2061 +2001 @@
             break;
         }
     }
+    //cout << "status string: " << statusString << endl;
 
     QWidget::customEvent(event);
 }
@@ -2095 +2036 @@
     setTrackOnLCD(mdata);
 }
 
-void PlaybackBoxMusic::openOutputDevice(void)
-{
-    QString adevice;
-
-    if (gContext->GetSetting("MusicAudioDevice") == "default")
-        adevice = gContext->GetSetting("AudioOutputDevice");
-    else
-        adevice = gContext->GetSetting("MusicAudioDevice");
-
-    // TODO: Error checking that device is opened correctly!
-    output = AudioOutput::OpenAudio(adevice, "default", 16, 2, 44100,
-                                    AUDIOOUTPUT_MUSIC, true,
-                                    false /* AC3/DTS pass through */);
-    output->setBufferSize(outputBufferSize * 1024);
-    output->SetBlocking(false);
-    output->addListener(this);
-    output->addListener(mainvisual);
-    output->addVisual(mainvisual);    
-}
-
 void PlaybackBoxMusic::handleTreeListSignals(int node_int, IntVector *attributes)
 {
     if (attributes->size() < 4)
@@ -2146 +2067 @@
         }
     }
 
+    GenericTree *node = music_tree_list->getCurrentNode();
+    if (node && node->childCount() > 0)
+        return;
+
     if (attributes->at(0) == 1)
     {
         //  It's a track
@@ -2164 +2089 @@
                 ratings_image->setRepeat(curMeta->Rating());
         }
 
-        if (output && output->GetPause())
-            stop();
-
+        if (gPlayer->getOutput() && gPlayer->getOutput()->GetPause())
+        {
+            gPlayer->stop();
+        }
         if (m_pushedButton && m_pushedButton->Name() == "play_button")
         {
             // Play button already pushed, so don't push it again.
@@ -2349 +2275 @@
 
     // only give the user a choice of the track to play if shuffle mode is off
     MythComboBox *playCombo = NULL;
-    if (shufflemode == SHUFFLE_OFF)
+    if (gPlayer->getShuffleMode() == MusicPlayer::SHUFFLE_OFF)
     {
         playCombo = new MythComboBox(false, popup, "play_combo" );
         playCombo->insertItem(tr("Continue playing current track"));
@@ -2358 +2284 @@
         playCombo->setBackgroundOrigin(ParentOrigin);
         popup->addWidget(playCombo);
     }
-    
+
     MythCheckBox *dupsCheck = new MythCheckBox(popup);
     dupsCheck->setText(tr("Remove Duplicates"));
     dupsCheck->setChecked(false);
@@ -2388 +2314 @@
 
     // if shuffle mode != SHUFFLE_OFF we always try to continue playing
     // the current track
-    if (shufflemode == SHUFFLE_OFF)
+    if (gPlayer->getShuffleMode() == MusicPlayer::SHUFFLE_OFF)
     {
         switch (playCombo->currentItem())
         {

mythmusic/mythmusic.pro

@@ -39 +39 @@
 HEADERS += goom/mmx.h goom/mathtools.h goom/tentacle3d.h goom/v3d.h
 HEADERS += editmetadata.h smartplaylist.h search.h genres.h
 HEADERS += treebuilders.h importmusic.h directoryfinder.h
-HEADERS += filescanner.h libvisualplugin.h
+HEADERS += filescanner.h libvisualplugin.h musicplayer.h miniplayer.h
 
 SOURCES += cddecoder.cpp cdrip.cpp decoder.cpp 
 SOURCES += flacdecoder.cpp flacencoder.cpp maddecoder.cpp main.cpp
@@ -55 +55 @@
 SOURCES += goom/zoom_filter_mmx.c goom/zoom_filter_xmmx.c goom/mythgoom.cpp
 SOURCES += avfdecoder.cpp editmetadata.cpp smartplaylist.cpp search.cpp
 SOURCES += treebuilders.cpp importmusic.cpp directoryfinder.cpp
-SOURCES += filescanner.cpp libvisualplugin.cpp
+SOURCES += filescanner.cpp libvisualplugin.cpp musicplayer.cpp miniplayer.cpp
 
 macx {
     SOURCES -= cddecoder.cpp
@@ -67 +67 @@
     #QMAKE_LFLAGS += -flat_namespace -undefined suppress
     QMAKE_LFLAGS += -flat_namespace -undefined error
 }
+

mythmusic/music-ui.xml

@@ -1792 +1792 @@
        </container>
    </window>
 
+   <window name="miniplayer">
+
+    <font name="currenttitle" face="Arial">
+        <color>#ffffff</color>
+        <size>20</size>
+        <bold>yes</bold>
+    </font>
+
+    <font name="currentartist" face="Arial">
+        <color>#ffffff</color>
+        <size>16</size>
+        <bold>yes</bold>
+    </font>
+
+    <font name="infotext" face="Arial">
+        <color>#ffffff</color>
+        <size>12</size>
+        <bold>yes</bold>
+    </font>
+
+    <container name="player_container">
+        <area>0,0,590,170</area>
+        <image name="track_info_background" draworder="0" fleximage="no">
+            <filename>miniplayer_background.png</filename>
+            <position>10,10</position>
+        </image>
+
+        <image name="mm_blackhole_border" draworder="0" fleximage="no">
+            <filename>mm_blackhole_border.png</filename>
+            <position>20,20</position>
+        </image>
+
+        <textarea name="title_text" draworder="1" align="left">
+            <font>currenttitle</font>
+            <area>160,15,415,34</area>
+            <cutdown>yes</cutdown>
+        </textarea>
+
+        <textarea name="artist_text" draworder="1" align="left">
+            <font>currentartist</font>
+            <area>160,50,415,25</area>
+            <cutdown>yes</cutdown>
+        </textarea>
+
+        <textarea name="album_text" draworder="1" align="left">
+            <font>currentartist</font>
+            <area>160,73,415,25</area>
+            <cutdown>yes</cutdown>
+        </textarea>
+
+        <repeatedimage name="ratings_image" draworder="1" fleximage="no">
+            <filename>mm_rating.png</filename>
+            <position>160,105</position>
+            <orientation>LeftToRight</orientation>
+        </repeatedimage>
+
+        <textarea name="info_text" draworder="1" align="left">
+            <font>infotext</font>
+            <area>160,129,250,25</area>
+        </textarea>
+
+        <textarea name="time_text" draworder="1" align="right">
+            <font>currentartist</font>
+            <area>375,125,185,25</area>
+        </textarea>
+
+        <image name="cover_image" draworder="2">
+            <filename>mm_nothumb.png</filename>
+            <position>22,22</position>
+            <staticsize>122,124</staticsize>
+        </image>
+
+    </container>
+
+  </window>
+
 </mythuitheme>

mythmusic/miniplayer.cpp

@@ +1 @@
+#include <iostream>
+using namespace std;
+
+// qt
+#include <qpixmap.h>
+#include <qimage.h>
+#include <qapplication.h>
+
+// mythtv
+#include <mythtv/mythcontext.h>
+#include <mythtv/mythdialogs.h>
+#include <mythtv/uitypes.h>
+#include <mythtv/lcddevice.h>
+
+// mythmusic
+#include "miniplayer.h"
+#include "musicplayer.h"
+#include "decoder.h"
+
+MiniPlayer::MiniPlayer(MythMainWindow *parent,
+                    MusicPlayer *parentPlayer,
+                    const char *name,
+                    bool setsize)
+            : MythThemedDialog(parent, name, setsize)
+{
+    setFrameStyle(QFrame::Panel | QFrame::Raised);
+    setLineWidth(1);
+    m_parentPlayer = parentPlayer;
+
+    m_displayTimer = new QTimer(this);
+    connect(m_displayTimer, SIGNAL(timeout()), this, SLOT(timerTimeout()));
+
+    m_infoTimer = new QTimer(this);
+    connect(m_infoTimer, SIGNAL(timeout()), this, SLOT(showInfoTimeout()));
+
+    wireupTheme();
+
+    gPlayer->setListener(this);
+
+    if (gPlayer->isPlaying() && gPlayer->getCurrentMetadata())
+    {
+        m_maxTime = gPlayer->getCurrentMetadata()->Length() / 1000;
+        updateTrackInfo(gPlayer->getCurrentMetadata());
+    }
+
+    m_showingInfo = false;
+}
+
+MiniPlayer::~MiniPlayer(void)
+{
+    gPlayer->setListener(NULL);
+
+    m_displayTimer->deleteLater();
+    m_displayTimer = NULL;
+
+    m_infoTimer->deleteLater();
+    m_infoTimer = NULL;
+
+    if (class LCD *lcd = LCD::Get()) 
+        lcd->switchToTime ();
+}
+
+void MiniPlayer::showPlayer(int showTime)
+{
+    m_displayTimer->start(showTime * 1000, true);
+    exec();
+}
+
+void MiniPlayer::timerTimeout(void)
+{
+    done(Accepted);
+}
+
+void MiniPlayer::wireupTheme(void)
+{
+    QString theme_file = QString("music-");
+
+    if (!loadThemedWindow("miniplayer", theme_file))
+    {
+        VERBOSE(VB_GENERAL, "MiniPlayer: cannot load theme!");
+        done(0);
+        return;
+    }
+
+    // get dialog size from player_container area
+    LayerSet *container = getContainer("player_container");
+
+    if (!container)
+    {
+        cerr << "MiniPlayer: cannot find the 'player_container'"
+                " in your theme" << endl;
+        done(0);
+        return;
+    }
+
+    m_popupWidth = container->GetAreaRect().width();
+    m_popupHeight = container->GetAreaRect().height();
+    setFixedSize(QSize(m_popupWidth, m_popupHeight));
+
+    int xbase, width, ybase, height;
+    float wmult, hmult;
+    gContext->GetScreenSettings(xbase, width, wmult, ybase, height, hmult);
+    QRect tlwg = QRect(0, 0, width, height);
+
+    QPoint newpos;
+
+    PlayerPosition preferredPos = MP_POSTOPDIALOG;
+
+    if (preferredPos == MP_POSTOPDIALOG)
+    {
+        newpos = QPoint(tlwg.width() / 2 - m_popupWidth / 2, 5);
+        this->move(newpos);
+    }
+    else if (preferredPos == MP_POSBOTTOMDIALOG)
+    {
+        newpos = QPoint(tlwg.width() / 2 - m_popupWidth / 2, 
+                        tlwg.height() - 5 - m_popupHeight);
+        this->move(newpos);
+    }
+    else if (preferredPos == MP_POSCENTERDIALOG)
+    {
+        newpos = QPoint(tlwg.width() / 2 - m_popupWidth / 2, 
+                        tlwg.height() / 2 - m_popupHeight / 2);
+        this->move(newpos);
+    }
+
+    m_titleText = getUITextType("title_text");
+    m_artistText = getUITextType("artist_text");
+    m_timeText = getUITextType("time_text");
+    m_infoText = getUITextType("info_text");
+    m_albumText = getUITextType("album_text");
+    m_ratingsImage = getUIRepeatedImageType("ratings_image");
+    m_coverImage = getUIImageType("cover_image");
+}
+
+void MiniPlayer::show()
+{
+    grabKeyboard();
+
+    MythDialog::show();
+}
+
+void MiniPlayer::hide()
+{
+    releaseKeyboard();
+
+    MythDialog::hide();
+}
+
+void MiniPlayer::keyPressEvent(QKeyEvent *e)
+{
+    bool handled = false;
+    QStringList actions;
+    if (gContext->GetMainWindow()->TranslateKeyPress("Music", e, actions, false))
+    {
+        for (unsigned int i = 0; i < actions.size() && !handled; i++)
+        {
+            QString action = actions[i];
+            handled = true;
+            if (action == "ESCAPE")
+                done(0);
+            else if (action == "SELECT")
+                    m_displayTimer->stop();
+            else if (action == "NEXTTRACK")
+            {
+                gPlayer->next();
+            }
+            else if (action == "PREVTRACK")
+            {
+                gPlayer->previous();
+            }
+            else if (action == "FFWD")
+            {
+                seekforward();
+            }
+            else if (action == "RWND")
+            {
+                seekback();
+            }
+            else if (action == "PAUSE")
+            {
+                if (gPlayer->isPlaying())
+                    gPlayer->pause();
+                else
+                {
+                    if (gPlayer->isPlaying())
+                        gPlayer->stop();
+
+                    if (gPlayer->getOutput() && gPlayer->getOutput()->GetPause())
+                    {
+                        gPlayer->pause();
+                        return;
+                    }
+
+                    gPlayer->play();
+                }
+            }
+            else if (action == "STOP")
+            {
+                gPlayer->stop();
+
+                QString time_string = getTimeString(m_maxTime, 0);
+
+                if (m_timeText)
+                    m_timeText->SetText(time_string);
+                if (m_infoText)
+                    m_infoText->SetText("");
+            }
+            else if (action == "VOLUMEDOWN")
+            {
+                if (gPlayer->getOutput())
+                {
+                    gPlayer->getOutput()->AdjustCurrentVolume(-2);
+                    showVolume();
+                }
+            }
+            else if (action == "VOLUMEUP")
+            {
+                if (gPlayer->getOutput())
+                {
+                    gPlayer->getOutput()->AdjustCurrentVolume(2);
+                    showVolume();
+                }
+            }
+            else if (action == "MUTE")
+            {
+                if (gPlayer->getOutput())
+                {
+                    gPlayer->getOutput()->ToggleMute();
+
+                    if (m_infoText)
+                    {
+                        m_showingInfo = true;
+                        if (gPlayer->getOutput()->GetMute())
+                            m_infoText->SetText(tr("Mute: On"));
+                        else
+                            m_infoText->SetText(tr("Mute: Off"));
+
+                        m_infoTimer->start(5000, true);
+                    }
+                }
+            }
+            else if (action == "THMBUP")
+                increaseRating();
+            else if (action == "THMBDOWN")
+                decreaseRating();
+            else if (action == "1")
+            {
+                gPlayer->toggleShuffleMode();
+                showShuffleMode();
+            }
+            else if (action == "2")
+            {
+                gPlayer->toggleRepeatMode();
+                showRepeatMode();
+            }
+            else
+                handled = false;
+        }
+    }
+}
+
+void MiniPlayer::customEvent(QCustomEvent *event)
+{
+
+    switch ((int)event->type()) 
+    {
+        case OutputEvent::Playing:
+        {
+            if (gPlayer->getCurrentMetadata())
+            {
+                m_maxTime = gPlayer->getCurrentMetadata()->Length() / 1000;
+                updateTrackInfo(gPlayer->getCurrentMetadata());
+            }
+            break;
+        }
+
+        case OutputEvent::Buffering:
+        {
+            break;
+        }
+
+        case OutputEvent::Paused:
+        {
+            break;
+        }
+
+        case OutputEvent::Info:
+       {
+            OutputEvent *oe = (OutputEvent *) event;
+
+            int rs;
+            m_currTime = rs = oe->elapsedSeconds();
+
+            QString time_string = getTimeString(rs, m_maxTime);
+
+            QString info_string;
+
+            //  Hack around for cd bitrates
+            if (oe->bitrate() < 2000)
+            {
+                info_string.sprintf("%d "+tr("kbps")+ "   %.1f "+ tr("kHz")+ "   %s "+ tr("ch"),
+                                   oe->bitrate(), float(oe->frequency()) / 1000.0,
+                                   oe->channels() > 1 ? "2" : "1");
+            }
+            else
+            {
+                info_string.sprintf("%.1f "+ tr("kHz")+ "   %s "+ tr("ch"),
+                                   float(oe->frequency()) / 1000.0,
+                                   oe->channels() > 1 ? "2" : "1");
+            }
+
+            if (m_timeText)
+                m_timeText->SetText(time_string);
+            if (m_infoText && !m_showingInfo)
+                m_infoText->SetText(info_string);
+
+            if (gPlayer->getCurrentMetadata())
+            {
+                if (class LCD *lcd = LCD::Get())
+                {
+                    float percent_heard = m_maxTime <=0 ? 0.0 :
+                            ((float)rs / (float)gPlayer->getCurrentMetadata()->Length()) * 1000.0;
+
+                    QString lcd_time_string = time_string; 
+
+                    // if the string is longer than the LCD width, remove all spaces
+                    if (time_string.length() > lcd->getLCDWidth())
+                        lcd_time_string.remove(' ');
+
+                    lcd->setMusicProgress(lcd_time_string, percent_heard);
+                }
+            }
+            break;
+        }
+        case OutputEvent::Error:
+        {
+            break;
+        }
+        case DecoderEvent::Stopped:
+        {
+            break;
+        }
+        case DecoderEvent::Finished:
+        {
+            if (gPlayer->getRepeatMode() == MusicPlayer::REPEAT_TRACK)
+               gPlayer->play();
+            else 
+                gPlayer->next();
+            break;
+        }
+        case DecoderEvent::Error:
+        {
+            break;
+        }
+    }
+    QObject::customEvent(event);
+}
+
+QString MiniPlayer::getTimeString(int exTime, int maxTime)
+{
+    QString time_string;
+
+    int eh = exTime / 3600;
+    int em = (exTime / 60) % 60;
+    int es = exTime % 60;
+
+    int maxh = maxTime / 3600;
+    int maxm = (maxTime / 60) % 60;
+    int maxs = maxTime % 60;
+
+    if (maxTime <= 0) 
+    {
+        if (eh > 0) 
+            time_string.sprintf("%d:%02d:%02d", eh, em, es);
+        else 
+            time_string.sprintf("%02d:%02d", em, es);
+    } 
+    else
+    {
+        if (maxh > 0)
+            time_string.sprintf("%d:%02d:%02d / %02d:%02d:%02d", eh, em,
+                    es, maxh, maxm, maxs);
+        else
+            time_string.sprintf("%02d:%02d / %02d:%02d", em, es, maxm, 
+                    maxs);
+    }
+
+    return time_string;
+}
+
+void MiniPlayer::updateTrackInfo(Metadata *mdata)
+{
+    if (m_titleText)
+        m_titleText->SetText(mdata->FormatTitle());
+    if (m_artistText)
+        m_artistText->SetText(mdata->FormatArtist());
+    if (m_albumText)
+        m_albumText->SetText(mdata->Album());
+    if (m_ratingsImage)
+        m_ratingsImage->setRepeat(mdata->Rating());
+
+    if (m_coverImage)
+    {
+        QImage image = gPlayer->getCurrentMetadata()->getAlbumArt(IT_FRONTCOVER);
+        if (!image.isNull())
+            m_coverImage->SetImage(
+                    QPixmap(image.smoothScale(m_coverImage->GetSize(true))));
+        m_coverImage->refresh();
+    }
+
+    LCD *lcd = LCD::Get();
+    if (lcd)
+    {
+        // Set the Artist and Track on the LCD
+        lcd->switchToMusic(mdata->Artist(), 
+                       mdata->Album(), 
+                       mdata->Title());
+    }
+}
+
+void MiniPlayer::seekforward(void)
+{
+    int nextTime = m_currTime + 5;
+    if (nextTime > m_maxTime)
+        nextTime = m_maxTime;
+    seek(nextTime);
+}
+
+void MiniPlayer::seekback(void)
+{
+    int nextTime = m_currTime - 5;
+    if (nextTime < 0)
+        nextTime = 0;
+    seek(nextTime);
+}
+
+void MiniPlayer::seek(int pos)
+{
+    if (gPlayer->getOutput())
+    {
+        gPlayer->getOutput()->Reset();
+        gPlayer->getOutput()->SetTimecode(pos*1000);
+
+        if (gPlayer->getDecoder() && gPlayer->getDecoder()->running()) 
+        {
+            gPlayer->getDecoder()->lock();
+            gPlayer->getDecoder()->seek(pos);
+            gPlayer->getDecoder()->unlock();
+        }
+
+        if (!gPlayer->isPlaying())
+        {
+            m_currTime = pos;
+            if (m_timeText)
+                m_timeText->SetText(getTimeString(pos, m_maxTime));
+
+            //showProgressBar();
+
+            if (class LCD *lcd = LCD::Get())
+            {
+                float percent_heard = m_maxTime <= 0 ? 0.0 : ((float)pos /
+                                      (float)m_maxTime);
+
+                QString lcd_time_string = getTimeString(pos, m_maxTime);
+
+                // if the string is longer than the LCD width, remove all spaces
+                if (lcd_time_string.length() > lcd->getLCDWidth())
+                    lcd_time_string.remove(' ');
+
+                lcd->setMusicProgress(lcd_time_string, percent_heard);
+            }
+        }
+    }
+}
+
+void MiniPlayer::increaseRating(void)
+{
+    Metadata *curMeta = gPlayer->getCurrentMetadata();
+
+    if (!curMeta)
+        return;
+
+    if (m_ratingsImage)
+    {
+        curMeta->incRating();
+        m_ratingsImage->setRepeat(curMeta->Rating());
+    }
+}
+
+void MiniPlayer::decreaseRating(void)
+{
+    Metadata *curMeta = gPlayer->getCurrentMetadata();
+
+    if (!curMeta)
+        return;
+
+    if (m_ratingsImage)
+    {
+        curMeta->decRating();
+        m_ratingsImage->setRepeat(curMeta->Rating());
+    }
+}
+
+void MiniPlayer::showInfoTimeout(void) 
+{
+    m_showingInfo = false;
+    LCD *lcd = LCD::Get();
+    Metadata * mdata = gPlayer->getCurrentMetadata();
+
+    if (lcd && mdata)
+    {
+        // Set the Artist and Track on the LCD
+        lcd->switchToMusic(mdata->Artist(), 
+                       mdata->Album(), 
+                       mdata->Title());
+    }
+}
+
+void MiniPlayer::showShuffleMode(void)
+{
+    if (m_infoText)
+    {
+        m_infoTimer->stop();
+        QString msg = tr("Shuffle Mode: ");
+        switch (gPlayer->getShuffleMode())
+        {
+            case MusicPlayer::SHUFFLE_INTELLIGENT:
+                msg += tr("Smart");
+                if (class LCD *lcd = LCD::Get())
+                    lcd->setMusicShuffle(LCD::MUSIC_SHUFFLE_SMART);
+                break;
+            case MusicPlayer::SHUFFLE_RANDOM:
+                msg += tr("Rand");
+                if (class LCD *lcd = LCD::Get())
+                    lcd->setMusicShuffle(LCD::MUSIC_SHUFFLE_RAND);
+                break;
+            case MusicPlayer::SHUFFLE_ALBUM:
+                msg += tr("Album");
+                if (class LCD *lcd = LCD::Get())
+                    lcd->setMusicShuffle(LCD::MUSIC_SHUFFLE_ALBUM);
+                break;
+            case MusicPlayer::SHUFFLE_ARTIST:
+                msg += tr("Artist");
+                if (class LCD *lcd = LCD::Get())
+                    lcd->setMusicShuffle(LCD::MUSIC_SHUFFLE_ARTIST);
+                break;
+            default:
+                msg += tr("None");
+                if (class LCD *lcd = LCD::Get())
+                    lcd->setMusicShuffle(LCD::MUSIC_SHUFFLE_NONE);
+                break;
+        }
+
+        m_showingInfo = true;
+        m_infoText->SetText(msg);
+        m_infoTimer->start(5000, true);
+    }
+}
+
+void MiniPlayer::showRepeatMode(void)
+{
+    if (m_infoText)
+    {
+        m_infoTimer->stop();
+        QString msg = tr("Repeat Mode: ");
+        switch (gPlayer->getRepeatMode())
+        {
+            case MusicPlayer::REPEAT_ALL:
+                msg += tr("All");
+                if (class LCD *lcd = LCD::Get())
+                    lcd->setMusicRepeat (LCD::MUSIC_REPEAT_ALL);
+                break;
+            case MusicPlayer::REPEAT_TRACK:
+                msg += tr("Track");
+                if (class LCD *lcd = LCD::Get())
+                    lcd->setMusicRepeat (LCD::MUSIC_REPEAT_TRACK);
+                break;
+            default:
+                msg += tr("None");
+                if (class LCD *lcd = LCD::Get())
+                    lcd->setMusicRepeat (LCD::MUSIC_REPEAT_NONE);
+                break;
+        }
+
+        m_showingInfo = true;
+        m_infoText->SetText(msg);
+        m_infoTimer->start(5000, true);
+    }
+}
+
+void MiniPlayer::showVolume(void)
+{
+    if (m_infoText)
+    {
+        m_infoTimer->stop();
+        QString msg = tr("Volume: ");
+        float level;
+
+        level = (float)gPlayer->getOutput()->GetCurrentVolume();
+
+        if (gPlayer->getOutput()->GetMute())
+        {
+            if (class LCD *lcd = LCD::Get())
+            {
+                lcd->switchToVolume("Music (muted)");
+                lcd->setVolumeLevel(level / (float)100);
+            }
+            msg += QString::number((int) level) + "% " + tr("(muted)");
+        }
+        else
+        {
+            if (class LCD *lcd = LCD::Get())
+            {
+                lcd->switchToVolume("Music");
+                lcd->setVolumeLevel(level / (float)100);
+            }
+            msg += QString::number((int) level) + "%";
+        }
+
+        m_showingInfo = true;
+        m_infoText->SetText(msg);
+        m_infoTimer->start(5000, true);
+    }
+}

mythmusic/metadata.cpp

@@ -725 +725 @@
     return image;
 }
 
+// static function to get a matadata object given a track id
+// it's upto the caller to delete the returned object when finished
+Metadata *Metadata::getMetadataFromID(int id)
+{
+    Metadata *meta = NULL;
+
+    QString aquery = "SELECT music_songs.song_id, music_artists.artist_name, music_comp_artists.artist_name AS compilation_artist, "
+                     "music_albums.album_name, music_songs.name, music_genres.genre, music_songs.year, "
+                     "music_songs.track, music_songs.length, CONCAT_WS('/', "
+                     "music_directories.path, music_songs.filename) AS filename, "
+                     "music_songs.rating, music_songs.numplays, music_songs.lastplay, music_albums.compilation, "
+                     "music_songs.format "
+                     "FROM music_songs "
+                     "LEFT JOIN music_directories ON music_songs.directory_id=music_directories.directory_id "
+                     "LEFT JOIN music_artists ON music_songs.artist_id=music_artists.artist_id "
+                     "LEFT JOIN music_albums ON music_songs.album_id=music_albums.album_id "
+                     "LEFT JOIN music_artists AS music_comp_artists ON music_albums.artist_id=music_comp_artists.artist_id "
+                     "LEFT JOIN music_genres ON music_songs.genre_id=music_genres.genre_id "
+                     "WHERE music_songs.song_id = :TRACKID;";
+
+    QString filename, artist, album, title;
+
+    MSqlQuery query(MSqlQuery::InitCon());
+    query.prepare(aquery);
+    query.bindValue(":TRACKID", id);
+    query.exec();
+
+    if (query.isActive() && query.size() > 0)
+    {
+        query.next();
+        filename = QString::fromUtf8(query.value(9).toString());
+        if (!filename.contains("://"))
+            filename = m_startdir + filename;
+
+        artist = QString::fromUtf8(query.value(1).toString());
+        if (artist.isEmpty())
+            artist = QObject::tr("Unknown Artist");
+
+        album = QString::fromUtf8(query.value(3).toString());
+        if (album.isEmpty())
+            album = QObject::tr("Unknown Album");
+
+        title = QString::fromUtf8(query.value(4).toString());
+        if (title.isEmpty())
+            title = QObject::tr("Unknown Title");
+
+        meta = new Metadata(
+            filename,
+            artist,
+            QString::fromUtf8(query.value(2).toString()),
+            album,
+            title,
+            QString::fromUtf8(query.value(5).toString()),
+            query.value(6).toInt(),
+            query.value(7).toInt(),
+            query.value(8).toInt(),
+            query.value(0).toInt(),
+            query.value(10).toInt(), //rating
+            query.value(11).toInt(), //playcount
+            query.value(12).toString(), //lastplay
+            (query.value(13).toInt() > 0), //compilation
+            query.value(14).toString()); //format
+    }
+    else
+    {
+         VERBOSE(VB_IMPORTANT, QString("Track %1 not found!!").arg(id));
+         return NULL;
+    }
+
+    return meta;
+}
+
+//--------------------------------------------------------------------------
+
 MetadataLoadingThread::MetadataLoadingThread(AllMusic *parent_ptr)
 {
     parent = parent_ptr;

mythmusic/metadata.h

@@ -183 +183 @@
     static QString GetStartdir() { return m_startdir; }
 
     static QStringList fillFieldList(QString field);
+    static Metadata *getMetadataFromID(int id);
 
     QImage getAlbumArt(ImageType type);
 

mythmusic/musicplayer.h

@@ +1 @@
+#ifndef MUSICPLAYER_H_
+#define MUSICPLAYER_H_
+
+#include <iostream>
+
+#include <mythtv/mythdialogs.h>
+#include <mythtv/audiooutput.h>
+
+#include "metadata.h"
+
+class Decoder;
+class AudioOutput;
+class MainVisual;
+
+class MusicPlayer : public QObject
+{
+  //Q_OBJECT
+
+  public:
+
+     MusicPlayer(QObject *parent, const QString &dev);
+    ~MusicPlayer(void);
+
+    void playFile(const QString &filename);
+    void playFile(const Metadata &meta);
+
+    void addFile(const QString &filename) {};
+    void addFile(const Metadata &meta) {};
+
+    void setListener(QObject *listener);
+    void setVisual(MainVisual *visual);
+    void setCDDevice(const QString &dev) { m_CDdevice = dev; }
+
+    void mute(void) {};
+    void unMute(void) {};
+    void setVolume(void) {};
+
+    void play(void);
+    void stop(bool stopAll = false);
+    void pause(void);
+    void next(void);
+    void previous(void);
+
+    void nextAuto(void);
+
+    bool isPlaying(void) { return m_isPlaying; }
+    bool hasClient(void) { return (m_listener != NULL); }
+
+    Decoder     *getDecoder(void) { return m_decoder; }
+    AudioOutput *getOutput(void) { return m_output; }
+
+    GenericTree *getPlaylistTree() { return m_playlistTree; }
+    void         setCurrentNode(GenericTree *node) { m_currentNode = node; }
+    QString      getRouteToCurrent(void);
+
+    Metadata    *getCurrentMetadata(void);
+
+    void showMiniPlayer(void);
+
+    enum RepeatMode
+    { REPEAT_OFF = 0,
+      REPEAT_TRACK, 
+      REPEAT_ALL, 
+      MAX_REPEAT_MODES 
+    };
+    enum ShuffleMode
+    { SHUFFLE_OFF = 0, 
+      SHUFFLE_RANDOM, 
+      SHUFFLE_INTELLIGENT,
+      SHUFFLE_ALBUM,
+      SHUFFLE_ARTIST,
+      MAX_SHUFFLE_MODES 
+    };
+
+    RepeatMode getRepeatMode(void) { return m_repeatMode; }
+    void       setRepeatMode(RepeatMode mode) { m_repeatMode = mode; }
+    RepeatMode toggleRepeatMode(void);
+
+    ShuffleMode getShuffleMode(void) { return m_shuffleMode; }
+    void        setShuffleMode(ShuffleMode mode) { m_shuffleMode = mode; }
+    ShuffleMode toggleShuffleMode(void);
+
+  protected:
+    void customEvent(QCustomEvent *event);
+
+  private:
+    void stopDecoder(void);
+    void openOutputDevice(void);
+    QString getFilenameFromID(int id);
+
+    GenericTree *m_playlistTree;
+
+    GenericTree *m_currentNode;
+    Metadata    *m_currentMetadata;
+    QString      m_currentFile;
+
+    QIODevice   *m_input;
+    AudioOutput *m_output;
+    Decoder     *m_decoder;
+
+    QObject     *m_listener;
+    MainVisual  *m_visual;
+
+    QString      m_CDdevice;
+
+    bool         m_isPlaying;
+    bool         m_isAutoplay;
+
+    ShuffleMode  m_shuffleMode;
+    RepeatMode   m_repeatMode;
+};
+
+// This global variable contains the MusicPlayer instance for the application
+extern MPUBLIC MusicPlayer *gPlayer;
+
+#endif

mythmusic/main.cpp

@@ -29 +29 @@
 #include "dbcheck.h"
 #include "importmusic.h"
 #include "filescanner.h"
+#include "musicplayer.h"
 #include "config.h"
 
 // System header (relies on config.h define)
@@ -151 +152 @@
     pbb->exec();
     qApp->lock();
 
-    pbb->stop();
-
     qApp->processEvents();
 
     delete pbb;
@@ -313 +312 @@
 void runMusicSelection(void);
 void runRipCD(void);
 void runScan(void);
+void showMiniPlayer(void);
 
-
 void handleMedia(MythMediaDevice *cd)
 {
     // Note that we should deal with other disks that may contain music.
@@ -365 +364 @@
     REG_JUMP("Select music playlists", "", "", runMusicSelection);
     REG_JUMP("Rip CD",                 "", "", runRipCD);
     REG_JUMP("Scan music",             "", "", runScan);
+    REG_JUMPEX("Show Miniplayer",        "", "", showMiniPlayer, false);
 
     REG_KEY("Music", "DELETE",     "Delete track from playlist", "D");
     REG_KEY("Music", "NEXTTRACK",  "Move to the next track",     ">,.,Z,End");
@@ -423 +423 @@
 
     Decoder::SetLocationFormatUseTags();
 
+    gPlayer = new MusicPlayer(NULL, chooseCD());
+
     return 0;
 }
 
@@ -530 +532 @@
     return 0;
 }
 
+void mythplugin_destroy(void)
+{
+    delete gPlayer;
+}
+
 void runMusicPlayback(void)
 {
     MusicData mdata;
@@ -585 +592 @@
 
     postMusic(&mdata);
 }
+
+void showMiniPlayer(void)
+{
+    // only show the miniplayer if there isn't already a client attached
+    if (!gPlayer->hasClient())
+        gPlayer->showMiniPlayer();
+}

mythmusic/musicplayer.cpp

@@ +1 @@
+// ANSI C includes
+#include <cstdlib>
+
+// C++ includes
+#include <iostream>
+
+using namespace std;
+
+// qt
+#include <qapplication.h>
+#include <qurl.h>
+#include <qwidget.h>
+
+// mythtv
+#include <mythtv/mythcontext.h>
+#include <mythtv/audiooutput.h>
+#include <mythtv/mythdbcon.h>
+
+// mythmusic
+#include "musicplayer.h"
+#include "decoder.h"
+#include "cddecoder.h"
+#include "constants.h"
+#include "mainvisual.h"
+#include "miniplayer.h"
+
+MusicPlayer  *gPlayer = NULL;
+
+////////////////////////////////////////////////////////////////
+
+MusicPlayer::MusicPlayer(QObject *parent, const QString &dev)
+    :QObject(parent)
+{
+    m_CDdevice = dev;
+    m_decoder = NULL;
+    m_input = NULL;
+    m_output = NULL;
+
+    m_playlistTree = NULL;
+    m_currentNode = NULL;
+    m_currentMetadata = NULL;
+
+    m_listener = NULL;
+    m_visual = NULL;
+
+    m_isAutoplay = false;
+
+    QString playmode = gContext->GetSetting("PlayMode", "none");
+    if (playmode.lower() == "random")
+        setShuffleMode(SHUFFLE_RANDOM);
+    else if (playmode.lower() == "intelligent")
+        setShuffleMode(SHUFFLE_INTELLIGENT);
+    else if (playmode.lower() == "album")
+        setShuffleMode(SHUFFLE_ALBUM);
+    else if (playmode.lower() == "artist")
+        setShuffleMode(SHUFFLE_ARTIST);
+    else
+        setShuffleMode(SHUFFLE_OFF);
+
+    QString repeatmode = gContext->GetSetting("RepeatMode", "all");
+    if (repeatmode.lower() == "track")
+        setRepeatMode(REPEAT_TRACK);
+    else if (repeatmode.lower() == "all")
+        setRepeatMode(REPEAT_ALL);
+    else
+        setRepeatMode(REPEAT_OFF);
+}
+
+MusicPlayer::~MusicPlayer()
+{
+//    setListener(NULL);
+//    setVisual(NULL);
+
+    stop(true);
+
+    if (m_playlistTree)
+        delete m_playlistTree;
+
+    if (m_currentMetadata)
+        delete m_currentMetadata;
+    m_currentMetadata = NULL;
+}
+
+void MusicPlayer::setListener(QObject *listener)
+{
+    if (m_listener && m_output)
+        m_output->removeListener(m_listener);
+
+    if (m_listener && m_decoder)
+        m_decoder->removeListener(m_listener);
+
+    m_listener = listener;
+
+    if (m_listener && m_output)
+        m_output->addListener(m_listener);
+
+    if (m_listener && m_decoder)
+        m_decoder->addListener(m_listener);
+
+    (listener == NULL) ? m_isAutoplay = true :  m_isAutoplay = false;
+}
+
+void MusicPlayer::setVisual(MainVisual *visual)
+{
+    if (m_visual && m_output)
+    {
+        m_output->removeListener(m_visual);
+        m_output->removeVisual(m_visual);
+    }
+
+    m_visual = visual;
+
+    if (m_visual && m_output)
+    {
+        m_output->addListener(m_visual);
+        m_output->addVisual(m_visual);
+    }
+}
+
+void MusicPlayer::playFile(const Metadata &meta)
+{
+    playFile(meta.Filename());
+}
+
+void MusicPlayer::playFile(const QString &filename)
+{
+    m_currentFile = filename;
+    play();
+}
+
+void MusicPlayer::stop(bool stopAll)
+{
+    stopDecoder();
+
+    if (m_output)
+    {
+        if (m_output->GetPause())
+        {
+            pause();
+        }
+        m_output->Reset();
+    }
+
+    if (m_input)
+        delete m_input;
+    m_input = NULL;
+
+    m_isPlaying = false;
+
+    if (stopAll && m_decoder)
+    {
+        m_decoder->removeListener(this);
+        if (m_listener)
+            m_decoder->removeListener(m_listener);
+
+        delete m_decoder;
+        m_decoder = NULL;
+        m_listener = NULL;
+    }
+
+    if (stopAll && m_output)
+    {
+        m_output->removeListener(this);
+        if (m_listener)
+            m_output->removeListener(m_listener);
+
+        if (m_visual)
+        {
+            m_output->removeListener(m_visual);
+            m_output->removeVisual(m_visual);
+        }
+        delete m_output;
+        m_output = NULL;
+        m_visual = NULL;
+    }
+}
+
+void MusicPlayer::pause(void)
+{
+    if (m_output) 
+    {
+        m_isPlaying = !m_isPlaying;
+        m_output->Pause(!m_isPlaying);
+    }
+    // wake up threads
+    if (m_decoder) 
+    {
+        m_decoder->lock();
+        m_decoder->cond()->wakeAll();
+        m_decoder->unlock();
+    }
+}
+
+void MusicPlayer::play(void)
+{
+    stopDecoder();
+
+    if (!m_output)
+        openOutputDevice();
+
+    if (m_input)
+        delete m_input;
+
+    m_input = new QFile(m_currentFile);
+
+    if (m_decoder && !m_decoder->factory()->supports(m_currentFile))
+    {
+        m_decoder->removeListener(this);
+
+        if (m_listener)
+            m_decoder->removeListener(m_listener);
+
+        delete m_decoder;
+        m_decoder = NULL;
+    }
+
+    if (!m_decoder)
+    {
+        m_decoder = Decoder::create(m_currentFile, m_input, m_output, true);
+        if (!m_decoder)
+        {
+            VERBOSE(VB_IMPORTANT, "MusicPlayer: Failed to create decoder for playback");
+            return;
+        }
+
+        if (m_currentFile.contains("cda") == 1)
+            dynamic_cast<CdDecoder*>(m_decoder)->setDevice(m_CDdevice);
+
+        m_decoder->setBlockSize(2 * 1024);
+
+        m_decoder->addListener(this);
+
+        if (m_listener)
+            m_decoder->addListener(m_listener);
+    }
+    else
+    {
+        m_decoder->setInput(m_input);
+        m_decoder->setFilename(m_currentFile);
+        m_decoder->setOutput(m_output);
+    }
+
+    if (m_decoder->initialize())
+    {
+        if (m_output)
+            m_output->Reset();
+
+        m_decoder->start();
+
+        m_isPlaying = true;
+
+        if (m_currentNode)
+        {
+            if (m_currentNode->getInt() > 0)
+            {
+                m_currentMetadata = Metadata::getMetadataFromID(m_currentNode->getInt());
+                if (m_currentMetadata)
+                {
+                    m_currentMetadata->incPlayCount();
+                    m_currentMetadata->setLastPlay();
+                }
+            }
+            else
+            {
+                // CD track
+                CdDecoder *cddecoder = dynamic_cast<CdDecoder*>(m_decoder);
+                if (m_decoder)
+                    m_currentMetadata = cddecoder->getMetadata(-m_currentNode->getInt());
+            }
+        }
+    }
+}
+
+void MusicPlayer::stopDecoder(void)
+{
+    if (m_decoder && m_decoder->running())
+    {
+        m_decoder->lock();
+        m_decoder->stop();
+        m_decoder->unlock();
+    }
+
+    if (m_decoder) 
+    {
+        m_decoder->lock();
+        m_decoder->cond()->wakeAll();
+        m_decoder->unlock();
+    }
+
+    if (m_decoder)
+        m_decoder->wait();
+
+    if (m_currentMetadata)
+    {
+        if (m_currentMetadata->hasChanged())
+            m_currentMetadata->persist();
+        delete m_currentMetadata;
+    }
+    m_currentMetadata = NULL;
+}
+
+void MusicPlayer::openOutputDevice(void)
+{
+    QString adevice;
+
+    if (gContext->GetSetting("MusicAudioDevice") == "default")
+        adevice = gContext->GetSetting("AudioOutputDevice");
+    else
+        adevice = gContext->GetSetting("MusicAudioDevice");
+
+    // TODO: Error checking that device is opened correctly!
+    m_output = AudioOutput::OpenAudio(adevice, "default", 16, 2, 44100,
+                                    AUDIOOUTPUT_MUSIC, true, false);
+    m_output->setBufferSize(256 * 1024);
+    m_output->SetBlocking(false);
+
+    m_output->addListener(this);
+
+    if (m_listener)
+        m_output->addListener(m_listener);
+
+    if (m_visual)
+    {
+        m_output->addListener((QObject*) m_visual);
+        m_output->addVisual(m_visual);
+    }
+}
+
+void MusicPlayer::next(void)
+{
+    if (!m_currentNode)
+        return;
+
+    GenericTree *node = m_currentNode->nextSibling(1, ((int) m_shuffleMode) + 1);
+    if (node)
+    {
+        m_currentNode = node;
+    }
+    else
+    {
+        if (m_repeatMode == REPEAT_ALL)
+        {
+            // start playing again from first track
+            GenericTree *parent = m_currentNode->getParent();
+            if (parent)
+            {
+                node = parent->getChildAt(0, ((int) m_shuffleMode) + 1);
+                if (node)
+                    m_currentNode = node;
+                else
+                    return; // stop()
+            }
+        }
+        else
+            return; // stop()
+    }
+
+    QString filename = getFilenameFromID(node->getInt());
+    if (!filename.isEmpty())
+        playFile(filename);
+    else
+        stop();
+}
+
+void MusicPlayer::previous(void)
+{
+    if (!m_currentNode)
+        return;
+
+    GenericTree *node = m_currentNode->prevSibling(1, ((int) m_shuffleMode) + 1);
+    if (node)
+    {
+        m_currentNode = node;
+        QString filename = getFilenameFromID(node->getInt());
+        if (!filename.isEmpty())
+            playFile(filename);
+        else
+            return;//stop();
+    }
+    else
+    {
+        // FIXME take repeat mode into account
+        return; //stop();
+    }
+}
+
+void MusicPlayer::nextAuto(void)
+{
+    if (!m_isAutoplay)
+        return;
+
+    if (!m_currentNode)
+        return;
+
+    if (m_repeatMode == REPEAT_TRACK)
+    {
+        play();
+        return;
+    }
+    else
+        next();
+
+    MiniPlayer *popup = new MiniPlayer(gContext->GetMainWindow(), this);
+    popup->showPlayer(10);
+    popup->deleteLater();
+    popup = NULL;
+}
+
+void MusicPlayer::customEvent(QCustomEvent *event)
+{
+    if (m_isAutoplay)
+    {
+        switch ((int)event->type()) 
+        {
+            case OutputEvent::Error:
+            {
+                OutputEvent *aoe = (OutputEvent *) event;
+
+                VERBOSE(VB_IMPORTANT, QString("Output Error - %1")
+                        .arg(*aoe->errorMessage()));
+                MythPopupBox::showOkPopup(gContext->GetMainWindow(),
+                        "Output Error:",
+                        QString("MythMusic has encountered the following error:\n%1")
+                                .arg(*aoe->errorMessage()));
+                stop(true);
+
+                break;
+            }
+
+            case DecoderEvent::Finished:
+            {
+                nextAuto();
+                break;
+            }
+
+            case DecoderEvent::Error:
+            {
+                stop(true);
+
+                QApplication::sendPostedEvents();
+
+                DecoderEvent *dxe = (DecoderEvent *) event;
+
+                VERBOSE(VB_IMPORTANT, QString("Decoder Error - %1")
+                        .arg(*dxe->errorMessage()));
+                MythPopupBox::showOkPopup(gContext->GetMainWindow(), 
+                                        "Decoder Error",
+                                        QString("MythMusic has encountered the following error:\n%1")
+                                        .arg(*dxe->errorMessage()));
+                break;
+            }
+        }
+    }
+
+    QObject::customEvent(event);
+}
+
+QString MusicPlayer::getFilenameFromID(int id)
+{
+    QString filename = "";
+
+    if (id > 0)
+    {
+        QString aquery = "SELECT CONCAT_WS('/', "
+                        "music_directories.path, music_songs.filename) AS filename "
+                        "FROM music_songs "
+                        "LEFT JOIN music_directories ON music_songs.directory_id=music_directories.directory_id "
+                        "WHERE music_songs.song_id = :ID";
+
+        MSqlQuery query(MSqlQuery::InitCon());
+        query.prepare(aquery);
+        query.bindValue(":ID", id);
+        if (!query.exec() || query.numRowsAffected() < 1)
+            MythContext::DBError("get filename", query);
+
+        if (query.isActive() && query.size() > 0)
+        {
+            query.first();
+            filename = QString::fromUtf8(query.value(0).toString());
+            if (!filename.contains("://"))
+                filename = Metadata::GetStartdir() + filename;
+        }
+    }
+    else
+    {
+        // cd track
+        CdDecoder *cddecoder = dynamic_cast<CdDecoder*>(m_decoder);
+        if (m_decoder)
+        {
+            Metadata *meta = cddecoder->getMetadata(-id);
+            if (meta)
+                filename = meta->Filename();
+        }
+    }
+    return filename;
+}
+
+QString MusicPlayer::getRouteToCurrent(void)
+{
+    QStringList route;
+
+    if (m_currentNode)
+    {
+        GenericTree *climber = m_currentNode;
+
+        route.push_front(QString::number(climber->getInt()));
+        while((climber = climber->getParent()))
+        {
+            route.push_front(QString::number(climber->getInt()));
+        }
+    }
+    return route.join(",");
+}
+
+void MusicPlayer::showMiniPlayer(void)
+{
+    MiniPlayer *popup = new MiniPlayer(gContext->GetMainWindow(), this);
+    popup->exec();
+    popup->deleteLater();
+    popup = NULL;
+}
+
+Metadata *MusicPlayer::getCurrentMetadata(void)
+{
+    if (!m_currentNode)
+        return NULL;
+
+    if (m_currentMetadata)
+        return m_currentMetadata;
+
+    m_currentMetadata = Metadata::getMetadataFromID(m_currentNode->getInt());
+
+    return m_currentMetadata;
+}
+
+MusicPlayer::RepeatMode MusicPlayer::toggleRepeatMode(void)
+{
+    switch (m_repeatMode)
+    {
+        case REPEAT_OFF:
+            m_repeatMode = REPEAT_TRACK;
+            break;
+        case REPEAT_TRACK:
+            m_repeatMode = REPEAT_ALL;
+            break;
+        case REPEAT_ALL:
+            m_repeatMode = REPEAT_OFF;
+           break;
+        default:
+            m_repeatMode = REPEAT_OFF;
+            break;
+    }
+
+    return m_repeatMode;
+}
+
+MusicPlayer::ShuffleMode MusicPlayer::toggleShuffleMode(void)
+{
+    switch (m_shuffleMode)
+    {
+        case SHUFFLE_OFF:
+            m_shuffleMode = SHUFFLE_RANDOM;
+            break;
+        case SHUFFLE_RANDOM:
+            m_shuffleMode = SHUFFLE_INTELLIGENT;
+            break;
+        case SHUFFLE_INTELLIGENT:
+            m_shuffleMode = SHUFFLE_ALBUM;
+           break;
+        case SHUFFLE_ALBUM:
+            m_shuffleMode = SHUFFLE_ARTIST;
+           break;
+        case SHUFFLE_ARTIST:
+            m_shuffleMode = SHUFFLE_OFF;
+           break;
+        default:
+            m_shuffleMode = SHUFFLE_OFF;
+            break;
+    }
+
+    return m_shuffleMode;
+}

mythmusic/playbackbox.h

@@ -1 +1 @@
 #ifndef PLAYBACKBOX_H_
 #define PLAYBACKBOX_H_
 
+// qt
 #include <qtimer.h>
 #include <qmutex.h>
 #include <qvaluevector.h>
 
+// mythtv
 #include <mythtv/mythwidgets.h>
 #include <mythtv/dialogbox.h>
 #include <mythtv/audiooutput.h>
 
+// mythmusic
 #include "mainvisual.h"
 #include "metadata.h"
 #include "playlist.h"
 #include "editmetadata.h"
 #include "databasebox.h"
+#include "musicplayer.h"
 
 class Output;
 class Decoder;
@@ -33 +37 @@
 
     ~PlaybackBoxMusic(void);
 
-    void closeEvent(QCloseEvent *);
     void customEvent(QCustomEvent *);
-    void showEvent(QShowEvent *);
     void keyPressEvent(QKeyEvent *e);
     void constructPlaylistTree();
 
@@ -44 +46 @@
   public slots:
 
     void play();
-    void pause();
     void stop();
+    void pause();
     void stopDecoder();
     void previous();
     void next();
@@ -53 +55 @@
     void seekback();
     void seek(int);
     void stopAll();
-    void setShuffleMode(unsigned int mode);
+    void setShuffleMode(MusicPlayer::ShuffleMode mode);
     void toggleShuffle();
     void increaseRating();
     void decreaseRating();
-    void setRepeatMode(unsigned int mode);
+    void setRepeatMode(MusicPlayer::RepeatMode mode);
     void toggleRepeat();
     void editPlaylist();
     void nextAuto();
@@ -109 +111 @@
     void updatePlaylistFromCD(void);
     void setTrackOnLCD(Metadata *mdata);
     void updateTrackInfo(Metadata *mdata);
-    void openOutputDevice(void);
     void postUpdate();
     void playFirstTrack();
     void bannerEnable(QString text, int millis);
     void bannerEnable(Metadata *mdata, bool fullScreen = false);
     void bannerToggle(Metadata *mdata);
     void savePosition(uint position);
-    void restorePosition(void);
+    void restorePosition(const QString &position);
     void pushButton(UIPushButtonType *button);
     QString getTimeString(int exTime, int maxTime);
 
-    QIODevice *input;
-    AudioOutput *output;
-    Decoder *decoder;
-
     QString playfile;
     QString statusString;
     QString curSmartPlaylistCategory;
     QString curSmartPlaylistName;
 
-    enum RepeatMode
-    { REPEAT_OFF = 0,
-      REPEAT_TRACK, 
-      REPEAT_ALL, 
-      MAX_REPEAT_MODES 
-    };
-    enum ShuffleMode
-    { SHUFFLE_OFF = 0, 
-      SHUFFLE_RANDOM, 
-      SHUFFLE_INTELLIGENT,
-      SHUFFLE_ALBUM,
-      SHUFFLE_ARTIST,
-      MAX_SHUFFLE_MODES 
-    };
     enum ResumeMode
     { RESUME_OFF,
       RESUME_TRACK,
@@ -158 +141 @@
 
     Metadata *curMeta;
 
-
-    unsigned int shufflemode;
-    unsigned int repeatmode;
     unsigned int resumemode;
 
-    bool isplaying;
-
     bool menufilters;
 
     ReadCDThread *cd_reader_thread;
@@ -195 +173 @@
     QTimer  *waiting_for_playlists_timer;
     QTimer  *volume_display_timer;
 
-    GenericTree *playlist_tree;
-
     bool cycle_visualizer;
     bool random_visualizer;
     bool show_album_art;

mythmusic/mainvisual.cpp

@@ -217 +217 @@
 
     VisualNode *node = 0;
 
-    if (playing && output()) {
+    if (playing && output()) 
+    {
         long synctime = output()->GetAudiotime();
         mutex()->lock();
         VisualNode *prev = 0;
-        while ((node = nodes.first())) {
+        while ((node = nodes.first())) 
+        {
             if (node->offset > synctime)
                 break;
-
             delete prev;
             nodes.removeFirst();
             prev = node;
         }
         mutex()->unlock();
-        node = prev; 
+        node = prev;
     }
 
     bool stop = TRUE;
@@ -276 +277 @@
     switch (event->type()) 
     {
         case OutputEvent::Playing:
-        playing = TRUE;
-        // fall through intended
-
         case OutputEvent::Info:
         case OutputEvent::Buffering:
         case OutputEvent::Paused:
+            playing = TRUE;
+
             if (! timer->isActive())
                 timer->start(1000 / fps);
-
             break;
 
         case OutputEvent::Stopped:

mythmusic/miniplayer.h

@@ +1 @@
+#ifndef MINIPLAYER_H_
+#define MINIPLAYER_H_
+
+#include <qstring.h>
+
+#include "mythtv/mythdialogs.h"
+
+class MusicPlayer;
+class QTimer;
+class Metadata;
+
+/// Preferred position to place popup miniplayer.
+enum PlayerPosition 
+{
+    MP_POSTOPDIALOG,
+    MP_POSBOTTOMDIALOG,
+    MP_POSCENTERDIALOG
+};
+
+class MPUBLIC MiniPlayer : public MythThemedDialog
+{
+  Q_OBJECT
+
+  public:
+    MiniPlayer(MythMainWindow *parent, 
+                    MusicPlayer *parentPlayer,
+                    const char *name = 0,
+                    bool setsize = true);
+    ~MiniPlayer();
+
+  public slots:
+    virtual void show();
+    virtual void hide();
+    void timerTimeout(void);
+    void showPlayer(int showTime);
+    void showInfoTimeout(void);
+
+  protected:
+    virtual void keyPressEvent(QKeyEvent *e);
+    virtual void customEvent(QCustomEvent *event);
+
+  private:
+    void    wireupTheme(void);
+    QString getTimeString(int exTime, int maxTime);
+    void    updateTrackInfo(Metadata *mdata);
+    void    seekforward(void);
+    void    seekback(void);
+    void    seek(int pos);
+    void    increaseRating(void);
+    void    decreaseRating(void);
+    void    showShuffleMode(void);
+    void    showRepeatMode(void);
+    void    showVolume(void);
+
+    int           m_currTime, m_maxTime;
+
+    MusicPlayer  *m_parentPlayer;
+    int           m_popupWidth;
+    int           m_popupHeight;
+
+    QTimer       *m_displayTimer;
+    QTimer       *m_infoTimer;
+
+    bool          m_showingInfo;
+
+    UITextType   *m_titleText;
+    UITextType   *m_artistText;
+    UITextType   *m_albumText;
+    UITextType   *m_timeText;
+    UITextType   *m_infoText;
+    UIImageType  *m_coverImage;
+
+    UITextType   *m_shufflestateText;
+    UITextType   *m_repeatstateText;
+
+    UIRepeatedImageType *m_ratingsImage;
+};
+
+#endif