Ticket #6564: mediaplayer.patch

src/apps/mediaplayer/Controller.cpp

@@ -302 +302 @@
     trackSupplierDeleter.Detach();
 
     // prevent blocking the creation of new overlay buffers
-    fVideoView->DisableOverlay();
+    if (fVideoView)
+        fVideoView->DisableOverlay();
 
     // get video properties (if there is video at all)
     bool useOverlays = fVideoView ? fVideoView->UseOverlays() : true;

src/apps/mediaplayer/playlist/PlaylistWindow.cpp

@@ -22 +22 @@
 #include <File.h>
 #include <FilePanel.h>
 #include <Locale.h>
+#include <MediaFile.h>
+#include <MediaTrack.h>
 #include <Menu.h>
 #include <MenuBar.h>
 #include <MenuItem.h>
@@ -31 +33 @@
 #include <ScrollBar.h>
 #include <ScrollView.h>
 #include <String.h>
+#include <StringView.h>
 
+#include "AudioTrackSupplier.h"
 #include "CommandStack.h"
+#include "DurationToString.h"
 #include "MainApp.h"
 #include "PlaylistListView.h"
 #include "RWLocker.h"
-
+#include "TrackSupplier.h"
+#include "VideoTrackSupplier.h"
 
 #undef B_TRANSLATION_CONTEXT
 #define B_TRANSLATION_CONTEXT "MediaPlayer-PlaylistWindow"
@@ -82 +88 @@
     fPlaylist(playlist),
     fLocker(new RWLocker("command stack lock")),
     fCommandStack(new CommandStack(fLocker)),
-    fCommandStackListener(this)
+    fCommandStackListener(this),
+    fDurationListener(*this)
 {
     frame = Bounds();
 
@@ -90 +97 @@
         // will adjust frame to account for menubar
 
     frame.right -= B_V_SCROLL_BAR_WIDTH;
+    frame.bottom -= B_H_SCROLL_BAR_HEIGHT;
     fListView = new PlaylistListView(frame, playlist, controller,
         fCommandStack);
 
@@ -104 +112 @@
         // make it so the frame of the menubar is also the frame of
         // the scroll bar (appears to be)
         scrollBar->MoveBy(0, -1);
-        scrollBar->ResizeBy(0, -(B_H_SCROLL_BAR_HEIGHT - 2));
+        scrollBar->ResizeBy(0, 2);
+    }
+
+    frame.top += frame.Height();
+    frame.bottom += B_H_SCROLL_BAR_HEIGHT;
+
+    fDuration = new BStringView(frame, "fDuration", "",
+        B_FOLLOW_BOTTOM | B_FOLLOW_LEFT_RIGHT);
+    AddChild(fDuration);
+
+    _UpdateDuration(0);
+
+    {
+        BAutolock _(fPlaylist);
+
+        _GetInitialDuration();
+        fPlaylist->AddListener(&fDurationListener);
     }
 
     fCommandStack->AddListener(&fCommandStackListener);
@@ -121 +145 @@
     fCommandStack->RemoveListener(&fCommandStackListener);
     delete fCommandStack;
     delete fLocker;
+
+    fPlaylist->RemoveListener(&fDurationListener);
 }
 
 
@@ -422 +448 @@
     info.SetType("application/x-vnd.haiku-playlist");
 }
 
+
+void
+PlaylistWindow::_GetInitialDuration()
+{
+    BAutolock lock(fPlaylist);
+
+    for (int32 i = 0; i < fPlaylist->CountItems(); i++) {
+        BMessage addMessage(MSG_PLAYLIST_ITEM_ADDED);
+        addMessage.AddPointer("item", fPlaylist->ItemAt(i));
+        addMessage.AddInt32("index", i);
+
+        BMessenger(&fDurationListener).SendMessage(&addMessage);
+    }
+}
+
+
+void
+PlaylistWindow::_UpdateDuration(bigtime_t duration)
+{
+    BAutolock lock(this);
+
+    BString text;
+
+    char buffer[64];
+    duration /= 1000000;
+    duration_to_string(duration, buffer, sizeof(buffer));
+
+    text << B_TRANSLATE("Total duration:") << " " << buffer;
+
+    fDuration->SetText(text.String());
+}
+
+
+// #pragma mark -
+
+
+PlaylistWindow::DurationListener::DurationListener(PlaylistWindow& parent)
+    :
+    PlaylistObserver(this),
+    fKnown(20, true),
+    fDuration(0),
+    fParent(parent)
+{
+    Run();
+}
+
+
+PlaylistWindow::DurationListener::~DurationListener()
+{
+}
+
+
+void
+PlaylistWindow::DurationListener::MessageReceived(BMessage* message)
+{
+    switch (message->what) {
+        case MSG_PLAYLIST_ITEM_ADDED:
+        {
+            void* item;
+            int32 index;
+
+            if (message->FindPointer("item", &item) == B_OK
+                && message->FindInt32("index", &index) == B_OK) {
+                _HandleItemAdded(static_cast<PlaylistItem*>(item), index);
+            }
+
+            break;
+        }
+
+        case MSG_PLAYLIST_ITEM_REMOVED:
+        {
+            int32 index;
+
+            if (message->FindInt32("index", &index) == B_OK) {
+                _HandleItemRemoved(index);
+            }
+
+            break;
+        }
+
+        default:
+            BLooper::MessageReceived(message);
+            break;
+    }
+}
+
+
+bigtime_t
+PlaylistWindow::DurationListener::Duration()
+{
+    return fDuration;
+}
+
+
+void
+PlaylistWindow::DurationListener::_HandleItemAdded(PlaylistItem* item,
+    int32 index)
+{
+    bigtime_t duration = _DetermineDuration(item);
+    fDuration += duration;
+    fParent._UpdateDuration(fDuration);
+    fKnown.AddItem(new bigtime_t(duration), index);
+}
+
+
+void
+PlaylistWindow::DurationListener::_HandleItemRemoved(int32 index)
+{
+    bigtime_t* deleted = fKnown.RemoveItemAt(index);
+    fDuration -= *deleted;
+    fParent._UpdateDuration(fDuration);
+
+    delete deleted;
+}
+
+
+bigtime_t
+PlaylistWindow::DurationListener::_DetermineDuration(PlaylistItem* item)
+{
+    // TODO: Save track duration to an attributee
+    if (FilePlaylistItem* file = dynamic_cast<FilePlaylistItem*>(item)) {
+        // We are dealing with a file
+        BMediaFile mediaFile(&file->Ref());
+
+        if (mediaFile.InitCheck() != B_OK || mediaFile.CountTracks() < 1)
+            return 0;
+
+        return mediaFile.TrackAt(0)->Duration();
+    } else {
+        // Not a file, so fall back to the generic TrackSupplier solution
+
+        TrackSupplier* supplier = item->CreateTrackSupplier();
+
+        AudioTrackSupplier* au = supplier->CreateAudioTrackForIndex(0);
+        VideoTrackSupplier* vi = supplier->CreateVideoTrackForIndex(0);
+
+        bigtime_t duration = max_c(au == NULL ? 0 : au->Duration(),
+            vi == NULL ? 0 : vi->Duration());
+
+        delete vi;
+        delete au;
+        delete supplier;
+
+        return duration;
+    }
+}
+

src/apps/mediaplayer/playlist/PlaylistWindow.h

@@ -11 +11 @@
 
 
 #include <Entry.h>
+#include <ObjectList.h>
 #include <Window.h>
 
+#include "PlaylistObserver.h"
 #include "ListenerAdapter.h"
 
 
@@ -21 +23 @@
 class CommandStack;
 class Controller;
 class Notifier;
-class Playlist;
 class PlaylistListView;
 class RWLocker;
 class BButton;
 class BFilePanel;
+class BStringView;
 
 
 enum {
@@ -53 +55 @@
     virtual void                MessageReceived(BMessage* message);
 
 private:
+
+    class DurationListener : public PlaylistObserver, public BLooper {
+    public:
+
+                                DurationListener(PlaylistWindow& parent);
+                                ~DurationListener();
+
+            void                MessageReceived(BMessage* message);
+
+            bigtime_t           Duration();
+
+    private:
+            void                _HandleItemAdded(PlaylistItem* item,
+                                    int32 index);
+            void                _HandleItemRemoved(int32 index);
+            bigtime_t           _DetermineDuration(PlaylistItem* item);
+
+            BObjectList<bigtime_t>
+                                fKnown;
+            bigtime_t           fDuration;
+            PlaylistWindow&     fParent;
+    };
+
+    friend class DurationListener;
+
             void                _CreateMenu(BRect& frame);
             void                _ObjectChanged(const Notifier* object);
             void                _SavePlaylist(const BMessage* filePanelMessage);
             void                _SavePlaylist(const entry_ref& ref);
             void                _SavePlaylist(BEntry& origEntry,
                                     BEntry& tempEntry, const char* finalName);
+            void                _GetInitialDuration();
+            void                _UpdateDuration(bigtime_t duration);
 
             Playlist*           fPlaylist;
             PlaylistListView*   fListView;
@@ -72 +101 @@
             ListenerAdapter     fCommandStackListener;
 
             entry_ref           fSavedPlaylistRef;
+
+            DurationListener    fDurationListener;
+            BStringView*        fDuration;
 };