feat: load chapter data from metadata too

QTime::fromString() can lead a crash when build with icu-enabled
Qt 6.8.0, see QTBUG-130597. Anyway let's workaround this issue
by simply implement it by ourselves.

.editorconfig

@@ -0,0 +1,7 @@
+[*]
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+indent_style = space
+indent_size = 4

.github/workflows/windows.yml

@@ -7,9 +7,11 @@ jobs:
   
     strategy:
       matrix:
-        vs: ['2022']
+        include:
-        msvc_arch: ['x64']
+          - qt_ver: '6.9.0'
-        qt_ver: ['6.7.3']
+            vs: '2022'
+            aqt_arch: 'win64_msvc2022_64'
+            msvc_arch: 'x64'
 
     runs-on: windows-2022
 
@@ -18,9 +20,9 @@ jobs:
     - name: Install Qt
       uses: jurplel/install-qt-action@v4
       with:
-        arch: 'win64_msvc2019_64'
+        arch: ${{ matrix.aqt_arch }}
         version: ${{ matrix.qt_ver }}
-        modules: 'qtmultimedia'
+        modules: 'qtmultimedia qt5compat'
     - name: Build
       shell: cmd
       run: |
@@ -33,30 +35,35 @@ jobs:
         :: ------ dep ------
         set CMAKE_PREFIX_PATH=%PWD%/dependencies_bin
         mkdir dependencies_src
-        :: ===== uchardet =====
+        echo ::group::===== ECM =====
-        echo ::group::build uchardet
+        git clone -q https://invent.kde.org/frameworks/extra-cmake-modules.git dependencies_src/extra-cmake-modules
-        git clone -q https://gitlab.freedesktop.org/BLumia/uchardet.git --branch msvc dependencies_src/uchardet
+        cmake .\dependencies_src\extra-cmake-modules -Bbuild_dependencies/extra-cmake-modules -DCMAKE_INSTALL_PREFIX="dependencies_bin" -DBUILD_TESTING=OFF || goto :error
-        cmake .\dependencies_src\uchardet -Bbuild_dependencies/uchardet -DBUILD_BINARY=OFF -DCMAKE_INSTALL_PREFIX="dependencies_bin" || goto :error
+        cmake --build build_dependencies/extra-cmake-modules --config Release --target=install || goto :error
-        cmake --build build_dependencies/uchardet --config Release --target=install -j || goto :error
         echo ::endgroup::
-        :: ===== pkg-config =====
+        echo ::group::===== Gperf (required by KCodecs) =====
-        choco install pkgconfiglite
+        choco install gperf
-        set PKG_CONFIG_PATH=%PWD%/dependencies_bin/lib/pkgconfig
+        echo ::endgroup::
-        :: ===== taglib =====
+        echo ::group::===== KCodecs =====
+        git clone -q https://invent.kde.org/frameworks/kcodecs.git dependencies_src/kcodecs
+        cmake .\dependencies_src\kcodecs -Bbuild_dependencies/kcodecs -DCMAKE_INSTALL_PREFIX="dependencies_bin" -DBUILD_TESTING=OFF || goto :error
+        cmake --build build_dependencies/kcodecs --config Release --target=install || goto :error
+        echo ::endgroup::
+        echo ::group::===== taglib =====
         git clone --recurse-submodules -q https://github.com/taglib/taglib.git dependencies_src/taglib
         cmake .\dependencies_src\taglib -Bbuild_dependencies/taglib -DBUILD_SHARED_LIBS=ON -DCMAKE_INSTALL_PREFIX="dependencies_bin" || goto :error
         cmake --build build_dependencies/taglib --config Release --target=install -j || goto :error
+        echo ::endgroup::
         :: ------ app ------
-        cmake -Bbuild . -DCMAKE_INSTALL_PREFIX="%PWD%\build\" || goto :error
+        cmake -Bbuild . -DUSE_QTEXTCODEC=ON -DCMAKE_INSTALL_PREFIX='%PWD%\build\' || goto :error
         cmake --build build --config Release -j || goto :error
-        cmake --build build --config Release --target=install
+        cmake --build build --config Release --target=install || goto :error
         :: ------ pkg ------
-        windeployqt --verbose=2 --no-quick-import --no-translations --no-opengl-sw --no-system-d3d-compiler --no-system-dxc-compiler --multimedia --skip-plugin-types tls,networkinformation build\bin\pmusic.exe
+        windeployqt --verbose=2 --no-quick-import --no-translations --no-opengl-sw --no-system-d3d-compiler --no-system-dxc-compiler --multimedia --core5compat --skip-plugin-types tls,networkinformation build\bin\pmusic.exe
         robocopy ./dependencies_bin/bin build/bin *.dll
         if ErrorLevel 8 (exit /B 1)
         copy LICENSE build/bin/
         exit /B 0
     - uses: actions/upload-artifact@v4
       with:
-        name: "windows-msvc${{ matrix.vs }}-qt${{ matrix.qt_ver }}-cmake-package"
+        name: "${{ matrix.aqt_arch }}-qt${{ matrix.qt_ver }}-cmake-package"
         path: build/bin/*

.gitignore

@@ -6,3 +6,6 @@
 
 # User config file
 CMakeLists.txt.user*
+
+# Why, macOS, why?
+.DS_Store

CMakeLists.txt

@@ -1,118 +1,162 @@
-cmake_minimum_required(VERSION 3.12)
+cmake_minimum_required(VERSION 3.12)
-
+
-project(pineapple-music LANGUAGES CXX)
+project(pineapple-music LANGUAGES CXX VERSION 0.3.0)
-
+
-include (GNUInstallDirs)
+include (GNUInstallDirs)
-include (FeatureSummary)
+include (FeatureSummary)
-
+include (FetchContent)
-set(CMAKE_INCLUDE_CURRENT_DIR ON)
+
-
+set(CMAKE_INCLUDE_CURRENT_DIR ON)
-set(CMAKE_AUTOUIC ON)
+
-set(CMAKE_AUTOMOC ON)
+set(CMAKE_AUTOUIC ON)
-set(CMAKE_AUTORCC ON)
+set(CMAKE_AUTOMOC ON)
-
+set(CMAKE_AUTORCC ON)
-set(CMAKE_CXX_STANDARD 17)
+
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_STANDARD 17)
-
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
-find_package(Qt6 6.6 COMPONENTS Widgets Multimedia Network LinguistTools REQUIRED)
+
-find_package(uchardet)
+option(USE_QTEXTCODEC "Use QTextCodec instead of QStringConverter, in case Qt is not built with ICU" OFF)
-find_package(PkgConfig)
+
-
+find_package(Qt6 6.6 COMPONENTS Widgets Multimedia Network LinguistTools REQUIRED)
-if (PKG_CONFIG_FOUND)
+find_package(FFmpeg COMPONENTS avutil avformat)
-pkg_check_modules(TagLib taglib IMPORTED_TARGET)
+find_package(TagLib 2.0.0)
-endif ()
+find_package(KF6Codecs 6.1.0)
-
+
-set (PMUSIC_CPP_FILES
+FetchContent_Declare(
-    main.cpp
+    kissfft
-    mainwindow.cpp
+    GIT_REPOSITORY https://github.com/mborgerding/kissfft.git
-    seekableslider.cpp
+    GIT_TAG f5f2a3b2f2cd02bf80639adb12cbeed125bdf420
-    playlistmanager.cpp
+)
-    singleapplicationmanager.cpp
+set(KISSFFT_PKGCONFIG OFF CACHE BOOL "dep(kissfft): pkgconfig support")
-    lrcbar.cpp
+set(KISSFFT_STATIC ON CACHE BOOL "dep(kissfft): static linking")
-    lyricsmanager.cpp
+set(KISSFFT_TEST OFF CACHE BOOL "dep(kissfft): enable testing")
-)
+set(KISSFFT_TOOLS OFF CACHE BOOL "dep(kissfft): build tools")
-
+FetchContent_MakeAvailable(kissfft)
-set (PMUSIC_HEADER_FILES
+
-    mainwindow.h
+if (USE_QTEXTCODEC)
-    seekableslider.h
+    find_package(Qt6 6.6 COMPONENTS Core5Compat REQUIRED)
-    playlistmanager.h
+endif()
-    singleapplicationmanager.h
+
-    lrcbar.h
+set (PMUSIC_CPP_FILES
-    lyricsmanager.h
+    main.cpp
-)
+    mainwindow.cpp
-
+    seekableslider.cpp
-set (PMUSIC_UI_FILES
+    playlistmanager.cpp
-    mainwindow.ui
+    singleapplicationmanager.cpp
-)
+    lrcbar.cpp
-
+    lyricsmanager.cpp
-set (EXE_NAME pmusic)
+    fftspectrum.cpp
-
+    playbackprogressindicator.cpp
-# Translation
+)
-file (GLOB PMUSIC_TS_FILES languages/*.ts)
+
-set (PMUSIC_CPP_FILES_FOR_I18N ${PMUSIC_CPP_FILES} ${PMUSIC_UI_FILES})
+set (PMUSIC_HEADER_FILES
-
+    mainwindow.h
-add_executable(${EXE_NAME} WIN32
+    seekableslider.h
-    ${PMUSIC_HEADER_FILES}
+    playlistmanager.h
-    ${PMUSIC_CPP_FILES}
+    singleapplicationmanager.h
-    ${PMUSIC_UI_FILES}
+    lrcbar.h
-    resources.qrc
+    lyricsmanager.h
-)
+    fftspectrum.h
-
+    playbackprogressindicator.h
-qt_add_translations(${EXE_NAME}
+)
-TS_FILES
+
-    ${PMUSIC_TS_FILES}
+set (PMUSIC_UI_FILES
-)
+    mainwindow.ui
-
+)
-if (WIN32)
+
-    target_sources(${EXE_NAME} PRIVATE assets/pineapple-music.rc)
+set (EXE_NAME pmusic)
-endif ()
+
-
+# Translation
-if (NOT TagLib_FOUND)
+file (GLOB PMUSIC_TS_FILES languages/*.ts)
-    target_compile_definitions(${EXE_NAME} PRIVATE NO_TAGLIB=1)
+set (PMUSIC_CPP_FILES_FOR_I18N ${PMUSIC_CPP_FILES} ${PMUSIC_UI_FILES})
-else ()
+
-    target_link_libraries(${EXE_NAME} PRIVATE PkgConfig::TagLib)
+add_executable(${EXE_NAME}
-endif ()
+    ${PMUSIC_HEADER_FILES}
-
+    ${PMUSIC_CPP_FILES}
-if (NOT uchardet_FOUND)
+    ${PMUSIC_UI_FILES}
-    target_compile_definitions(${EXE_NAME} PRIVATE NO_UCHARDET=1)
+    resources.qrc
-else ()
+)
-    target_link_libraries (${EXE_NAME} PRIVATE uchardet::libuchardet)
+
-endif ()
+qt_add_translations(${EXE_NAME}
-
+TS_FILES
-target_link_libraries(${EXE_NAME} PRIVATE Qt::Widgets Qt::Multimedia Qt::Network)
+    ${PMUSIC_TS_FILES}
-
+)
-# Install settings
+
-if (WIN32)
+if (WIN32)
-    # FIXME: try to avoid install to a "bin" subfolder under windows...
+    target_sources(${EXE_NAME} PRIVATE assets/pineapple-music.rc)
-    #        when fixed, don't forget to update the CI config file...
+endif ()
-elseif (UNIX)
+
-    if (CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT)
+if (NOT TagLib_FOUND)
-        set(CMAKE_INSTALL_PREFIX /usr)
+    target_compile_definitions(${EXE_NAME} PRIVATE NO_TAGLIB=1)
-    endif ()
+else ()
-
+    target_link_libraries(${EXE_NAME} PRIVATE TagLib::tag)
-    # install icon
+endif ()
-    install(
+
-        FILES icons/app-icon.svg
+if (TARGET KF6::Codecs)
-        DESTINATION "${CMAKE_INSTALL_DATADIR}/icons/hicolor/48x48/apps"
+    target_compile_definitions(${EXE_NAME} PRIVATE HAVE_KCODECS=1)
-        RENAME net.blumia.pineapple-music.svg
+    target_link_libraries (${EXE_NAME} PRIVATE KF6::Codecs)
-    )
+endif ()
-
+
-    # install shortcut
+if (FFmpeg_FOUND)
-    install(
+    target_compile_definitions(${EXE_NAME} PRIVATE HAVE_FFMPEG=1)
-        FILES dist/net.blumia.pineapple-music.desktop
+    target_link_libraries (${EXE_NAME} PRIVATE FFmpeg::avutil FFmpeg::avformat)
-        DESTINATION "${CMAKE_INSTALL_DATAROOTDIR}/applications"
+endif ()
-    )
+
-endif()
+target_link_libraries(${EXE_NAME} PRIVATE Qt::Widgets Qt::Multimedia Qt::Network kissfft::kissfft)
-
+
-set (INSTALL_TARGETS_DEFAULT_ARGS
+if (USE_QTEXTCODEC)
-    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+    target_compile_definitions(${EXE_NAME} PRIVATE USE_QTEXTCODEC=1)
-    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    target_link_libraries(${EXE_NAME} PRIVATE Qt6::Core5Compat)
-    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT Devel
+endif()
-)
+
-
+# Install settings
-install (
+if (WIN32)
-    TARGETS ${EXE_NAME}
+    set_target_properties(${EXE_NAME} PROPERTIES
-    ${INSTALL_TARGETS_DEFAULT_ARGS}
+        WIN32_EXECUTABLE TRUE
-)
+    )
-
+elseif (APPLE)
-feature_summary(WHAT ALL INCLUDE_QUIET_PACKAGES FATAL_ON_MISSING_REQUIRED_PACKAGES)
+    set_source_files_properties(assets/icons/app-icon.icns PROPERTIES
+        MACOSX_PACKAGE_LOCATION "Resources"
+    )
+    target_sources(${EXE_NAME} PUBLIC assets/icons/app-icon.icns)
+    # See https://cmake.org/cmake/help/v3.15/prop_tgt/MACOSX_BUNDLE_INFO_PLIST.html
+    set_target_properties(${EXE_NAME} PROPERTIES
+        MACOSX_BUNDLE TRUE
+        MACOSX_BUNDLE_BUNDLE_NAME "Pineapple Music"
+        MACOSX_BUNDLE_GUI_IDENTIFIER net.blumia.pineapple-music
+        MACOSX_BUNDLE_ICON_FILE app-icon.icns # contains the .icns file name, *without* the path.
+        MACOSX_BUNDLE_BUNDLE_VERSION ${PROJECT_VERSION}
+        MACOSX_BUNDLE_SHORT_VERSION_STRING ${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}
+    )
+elseif (UNIX)
+    if (CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT)
+        set(CMAKE_INSTALL_PREFIX /usr)
+    endif ()
+
+    # install icon
+    install(
+        FILES icons/app-icon.svg
+        DESTINATION "${CMAKE_INSTALL_DATADIR}/icons/hicolor/48x48/apps"
+        RENAME net.blumia.pineapple-music.svg
+    )
+
+    # install shortcut
+    install(
+        FILES dist/net.blumia.pineapple-music.desktop
+        DESTINATION "${CMAKE_INSTALL_DATAROOTDIR}/applications"
+    )
+endif()
+
+set (INSTALL_TARGETS_DEFAULT_ARGS
+    BUNDLE DESTINATION .
+    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT Devel
+)
+
+install (
+    TARGETS ${EXE_NAME}
+    ${INSTALL_TARGETS_DEFAULT_ARGS}
+)
+
+feature_summary(WHAT ALL INCLUDE_QUIET_PACKAGES FATAL_ON_MISSING_REQUIRED_PACKAGES)

README.md

@@ -2,12 +2,26 @@
 
 Since **I** just need a simple player which *just works* right now, so I did many things in a dirty way. Don't feel so weird if you saw something I did in this project is using a bad approach.
 
-### Feature Notice
+### Features
+
+We have the following features:
+
+- [Sidecar](https://en.wikipedia.org/wiki/Sidecar_file) lyrics file (`.lrc`) support with an optional desktop lyrics bar widget
+- Sidecar chapter file support
+  - [YouTube-style chapter](https://support.google.com/youtube/answer/9884579) saved to a plain text file with `.chp` suffix
+  - PotPlayer `.pbf` file, `[Bookmark]`s as chapters
+- Auto-load all audio files in the same folder of the file that you attempted to play, into a playlist
+
+These features are not available, some of them are TBD and others are not planned:
 
 - File format support will be limited by the [FFmpeg version that Qt 6 uses](https://doc.qt.io/qt-6/qtmultimedia-attribution-ffmpeg.html).
   - ...which if you use Qt's official binary, only contains the LGPLv2.1+ part. (already good enough, tho)
 - No music library management support and there won't be one!
   - It'll auto-load music files in the same folder of the file that you attempted to play, so organize your music files on a folder-basis.
+- Limited system integration:
+  - No [SMTC](https://learn.microsoft.com/en-us/uwp/api/windows.media.systemmediatransportcontrols) support under Windows for now
+  - No [MPRIS](https://www.freedesktop.org/wiki/Specifications/mpris-spec/) support under Linux desktop for now
+  - No "playback progress on taskbar icon" and "taskbar thumbnail buttons" support whatever on Windows or Linux desktop for now
 - Limited lyrics (`.lrc`) loading support:
   - Currently no `.tlrc` (for translated lyrics) or `.rlrc` (for romanized lyrics) support.
   - Multi-line lyrics and duplicated timestamps are not supported
@@ -20,7 +34,7 @@ Current state, we need:
  - `cmake` as the build system.
  - `qt6` with `qt6-multimedia` since we use it for playback.
  - `taglib` to get the audio file properties.
- - `pkg-config` to find the installed taglib.
+ - `kissfft` for FFT support (will be downloaded at configure-time by `cmake`).
 
 Then we can build it with any proper c++ compiler like g++ or msvc.
 

appveyor.yml

@@ -3,11 +3,10 @@ image:
 environment:
   CMAKE_INSTALL_ROOT: C:\projects\cmake
   PACKAGE_INSTALL_ROOT: C:\projects\pir
-  PKG_CONFIG_PATH: C:\projects\pir\lib\pkgconfig
   matrix:
     - build_name: mingw1120_64_qt6_7
-      QTPATH: C:\Qt\6.7\mingw_64
+      QTPATH: C:\Qt\6.8\mingw_64
-      MINGW64: C:\Qt\Tools\mingw1120_64
+      MINGW64: C:\Qt\Tools\mingw1310_64
 
 install:
   - mkdir %CMAKE_INSTALL_ROOT%
@@ -22,12 +21,19 @@ build_script:
 # prepare
   - mkdir 3rdparty
   - choco install ninja
-  - choco install pkgconfiglite
+  - choco install gperf
   - cd 3rdparty
-# build uchardet
+# install ECM
-  - git clone -q https://gitlab.freedesktop.org/uchardet/uchardet.git
+  - git clone -q https://invent.kde.org/frameworks/extra-cmake-modules.git
-  - cd uchardet
+  - git rev-parse HEAD
-  - cmake -G "Ninja" . -DCMAKE_INSTALL_PREFIX=%PACKAGE_INSTALL_ROOT% -DBUILD_BINARY=OFF
+  - cd extra-cmake-modules
+  - cmake -G "Ninja" . -DCMAKE_INSTALL_PREFIX=%PACKAGE_INSTALL_ROOT% -DBUILD_TESTING=OFF
+  - cmake --build . --target install
+  - cd %APPVEYOR_BUILD_FOLDER%
+# build kcodecs
+  - git clone -q https://invent.kde.org/frameworks/kcodecs.git
+  - cd kcodecs
+  - cmake -G "Ninja" . -DCMAKE_INSTALL_PREFIX=%PACKAGE_INSTALL_ROOT% -DBUILD_TESTING=OFF
   - cmake --build . --target install
   - cd %APPVEYOR_BUILD_FOLDER%
 # build taglib

fftspectrum.cpp

@@ -0,0 +1,125 @@
+// SPDX-FileCopyrightText: 2024 Gary Wang <git@blumia.net>
+//
+// SPDX-License-Identifier: MIT
+
+#include "fftspectrum.h"
+
+#include <QAudioBuffer>
+#if QT_VERSION >= QT_VERSION_CHECK(6, 8, 0)
+#include <QAudioBufferOutput>
+#endif // QT_VERSION >= QT_VERSION_CHECK(6, 8, 0)
+#include <QPainter>
+
+#include <kissfft.hh>
+
+FFTSpectrum::FFTSpectrum(QWidget* parent)
+    : QWidget(parent)
+#if QT_VERSION >= QT_VERSION_CHECK(6, 8, 0)
+    , m_audioBufferOutput(new QAudioBufferOutput(this))
+#endif // #if QT_VERSION >= QT_VERSION_CHECK(6, 8, 0)
+{
+#if QT_VERSION >= QT_VERSION_CHECK(6, 8, 0)
+    connect(this, &FFTSpectrum::mediaPlayerChanged, this, [=]() {
+        if (m_mediaPlayer) {
+            m_mediaPlayer->setAudioBufferOutput(m_audioBufferOutput);
+        }
+    });
+
+    connect(m_audioBufferOutput, &QAudioBufferOutput::audioBufferReceived, this, [=](const QAudioBuffer& buffer) {
+        if (!isVisible()) return;
+        const QAudioFormat& fmt = buffer.format();
+        const QAudioFormat::SampleFormat sampleFormat = fmt.sampleFormat();
+        QAudioFormat::ChannelConfig channelConfig = fmt.channelConfig();
+        const QFlags supportedChannelConfig({ QAudioFormat::ChannelConfigMono, QAudioFormat::ChannelConfigStereo });
+        const int frameCount = buffer.frameCount();
+        kissfft<float> fft(frameCount, false);
+        std::vector<kissfft<float>::cpx_t> samples(frameCount);
+        std::vector<kissfft<float>::cpx_t> mass(frameCount);
+        if (sampleFormat == QAudioFormat::Int16 && supportedChannelConfig.testFlag(channelConfig)) {
+            if (channelConfig == QAudioFormat::ChannelConfigMono) {
+                const QAudioBuffer::S16M* data = buffer.constData<QAudioBuffer::S16M>();
+                for (int i = 0; i < frameCount; ++i) {
+                    samples[i].real(data[i].value(QAudioFormat::FrontCenter) / float(32768));
+                    samples[i].imag(0);
+                }
+            } else {
+                const QAudioBuffer::S16S* data = buffer.constData<QAudioBuffer::S16S>();
+                for (int i = 0; i < frameCount; ++i) {
+                    samples[i].real(data[i].value(QAudioFormat::FrontLeft) / float(32768));
+                    samples[i].imag(0);
+                }
+            }
+        } else if (sampleFormat == QAudioFormat::Int32 && supportedChannelConfig.testFlag(channelConfig)) {
+            if (channelConfig == QAudioFormat::ChannelConfigMono) {
+                const QAudioBuffer::S32M* data = buffer.constData<QAudioBuffer::S32M>();
+                for (int i = 0; i < frameCount; ++i) {
+                    samples[i].real(data[i].value(QAudioFormat::FrontCenter) / float(2147483647));
+                    samples[i].imag(0);
+                }
+            } else {
+                const QAudioBuffer::S32S* data = buffer.constData<QAudioBuffer::S32S>();
+                for (int i = 0; i < frameCount; ++i) {
+                    samples[i].real(data[i].value(QAudioFormat::FrontLeft) / float(2147483647));
+                    samples[i].imag(0);
+                }
+            }
+        } else if (sampleFormat == QAudioFormat::Float && supportedChannelConfig.testFlag(channelConfig)) {
+            if (channelConfig == QAudioFormat::ChannelConfigMono) {
+                const QAudioBuffer::F32M* data = buffer.constData<QAudioBuffer::F32M>();
+                for (int i = 0; i < frameCount; ++i) {
+                    samples[i].real(data[i].value(QAudioFormat::FrontCenter));
+                    samples[i].imag(0);
+                }
+            } else {
+                const QAudioBuffer::F32S* data = buffer.constData<QAudioBuffer::F32S>();
+                for (int i = 0; i < frameCount; ++i) {
+                    samples[i].real(data[i].value(QAudioFormat::FrontLeft));
+                    samples[i].imag(0);
+                }
+            }
+        } else {
+            qWarning() << "Unsupported format or channel config:" << sampleFormat << channelConfig;
+            return;
+        }
+        fft.transform(samples.data(), mass.data());
+        m_freq.resize(frameCount);
+        for (int i = 0; i < frameCount; i++) {
+            m_freq[i] = sqrt(mass[i].real() * mass[i].real() + mass[i].imag() * mass[i].imag());
+        }
+        for (auto& val : m_freq) {
+            val = log10(val + 1);
+        }
+        update();
+    });
+#endif // QT_VERSION >= QT_VERSION_CHECK(6, 8, 0)
+    resize(490, 420);
+}
+
+FFTSpectrum::~FFTSpectrum()
+{
+
+}
+
+void FFTSpectrum::setMediaPlayer(QMediaPlayer* player)
+{
+    m_mediaPlayer = player;
+    emit mediaPlayerChanged();
+}
+
+void FFTSpectrum::paintEvent(QPaintEvent* e)
+{
+    QPainter painter(this);
+
+    if (!m_freq.empty()) {
+        int width = this->width();
+        int height = this->height();
+        int barWidth = std::max(1, (int)(width / m_freq.size()));
+        for (int i = 0; i < m_freq.size(); i++) {
+            int barHeight = static_cast<int>(sqrt(m_freq[i]) * height * 0.5);
+            QColor color(70, 130, 180, std::min(255, (int)(140 * m_freq[i]) + 90));
+            painter.fillRect(i * barWidth, height - barHeight, barWidth, barHeight, color);
+        }
+    }
+}
+
+

fftspectrum.h

@@ -0,0 +1,31 @@
+// SPDX-FileCopyrightText: 2024 Gary Wang <git@blumia.net>
+//
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <QWidget>
+#include <QMediaPlayer>
+
+class QAudioBufferOutput;
+class FFTSpectrum : public QWidget
+{
+    Q_OBJECT
+    Q_PROPERTY(QMediaPlayer * mediaPlayer MEMBER m_mediaPlayer WRITE setMediaPlayer NOTIFY mediaPlayerChanged)
+public:
+    explicit FFTSpectrum(QWidget* parent);
+    ~FFTSpectrum();
+
+    void setMediaPlayer(QMediaPlayer* player);
+
+signals:
+    void mediaPlayerChanged();
+
+protected:
+    void paintEvent(QPaintEvent* e) override;
+
+private:
+    QMediaPlayer* m_mediaPlayer = nullptr;
+    QAudioBufferOutput* m_audioBufferOutput = nullptr;
+    std::vector<float> m_freq;
+};

lyricsmanager.cpp

@@ -9,8 +9,14 @@
 #include <QRegularExpression>
 #include <QStringConverter>
 
-#ifndef NO_UCHARDET
+#ifdef HAVE_KCODECS
-#include <uchardet/uchardet.h>
+#include <KCharsets>
+#include <KCodecs>
+#include <KEncodingProber>
+#endif
+
+#ifdef USE_QTEXTCODEC
+#include <QTextCodec>
 #endif
 
 Q_LOGGING_CATEGORY(lcLyrics, "pmusic.lyrics")
@@ -44,24 +50,38 @@ bool LyricsManager::loadLyrics(QString filepath)
         return false;
     }
     QByteArray fileContent(file.readAll());
-#ifndef NO_UCHARDET
-    uchardet_t handle = uchardet_new();
-    uchardet_handle_data(handle, fileContent.data(), fileContent.length());
-    uchardet_data_end(handle);
-    const char* encoding = uchardet_get_charset(handle);
-    qCDebug(lcLyrics) << "Detected encoding:" << (encoding == NULL ? "unknown" : encoding);
     QStringList lines;
-    if (QStringConverter::availableCodecs().contains(QString(encoding))) {
+#ifdef HAVE_KCODECS
-        auto toUtf16 = QStringDecoder(encoding);
+    KEncodingProber prober(KEncodingProber::Universal);
+    prober.feed(fileContent);
+    QByteArray encoding(prober.encoding());
+    qCDebug(lcLyrics) << "Detected encoding:" << QString(encoding) << "with confidence" << prober.confidence();
+#ifdef USE_QTEXTCODEC
+    qCDebug(lcLyrics) << "QTextCodec is used instead of QStringConverter.";
+    QTextCodec *codec = QTextCodec::codecForName(encoding);
+    if (codec) {
+        lines = codec->toUnicode(fileContent).split('\n');
+    } else {
+        lines = QString(fileContent).split('\n');
+        qCDebug(lcLyrics) << "No codec for the detected encoding. Available codecs are:" << QTextCodec::availableCodecs();
+        qCDebug(lcLyrics) << "KCodecs offers these encodings:" << KCharsets::charsets()->availableEncodingNames();
+    }
+#else // NOT USE_QTEXTCODEC
+    auto toUtf16 = QStringDecoder(encoding);
+    // Don't use `QStringConverter::availableCodecs().contains(QString(encoding))` here, since the charset
+    // encoding name might not match, e.g. GB18030 (from availableCodecs) != gb18030 (from KEncodingProber)
+    if (toUtf16.isValid()) {
         QString decodedResult = toUtf16(fileContent);
         lines = decodedResult.split('\n');
     } else {
+        qCDebug(lcLyrics) << "No codec for the detected encoding. Available codecs are:" << QStringConverter::availableCodecs();
+        qCDebug(lcLyrics) << "KCodecs offers these encodings:" << KCharsets::charsets()->availableEncodingNames();
         lines = QString(fileContent).split('\n');
     }
-    uchardet_delete(handle);
+#endif // USE_QTEXTCODEC
-#else
+#else // NOT HAVE_KCODECS
-    QStringList lines = QString(fileContent).split('\n');
+    lines = QString(fileContent).split('\n');
-#endif
+#endif // HAVE_KCODECS
     file.close();
 
     // parse lyrics timestamp
@@ -92,8 +112,7 @@ bool LyricsManager::loadLyrics(QString filepath)
         QRegularExpressionMatch match = lrcRegex.match(line);
         while (match.hasMatch()) {
             tagSectionPassed = true;
-            QTime timestamp(QTime::fromString(match.captured(1), "m:s.zz"));
+            timestamps.append(parseTimeToMilliseconds(match.captured(1)));
-            timestamps.append(timestamp.msecsSinceStartOfDay());
             currentLrc = match.captured(2);
             match = lrcRegex.match(currentLrc);
         }
@@ -157,6 +176,23 @@ double LyricsManager::maskPercent(int curTimeMs)
     return (double)(curTimeMs - currentLyricsTime()) / (m_nextLyricsTime - m_currentLyricsTime);
 }
 
+int LyricsManager::parseTimeToMilliseconds(const QString &timeString)
+{
+    QRegularExpression timeRegex(R"((\d{2,3}):(\d{2})\.(\d{2,3}))");
+    QRegularExpressionMatch match = timeRegex.match(timeString);
+
+    if (match.hasMatch()) {
+        int minutes = match.captured(1).toInt();
+        int seconds = match.captured(2).toInt();
+        int milliseconds = match.captured(3).toInt();
+
+        return minutes * 60000 + seconds * 1000 + milliseconds;
+    } else {
+        qCWarning(lcLyricsParser) << "Invalid time format:" << timeString;
+        return -1;
+    }
+}
+
 void LyricsManager::reset()
 {
     m_currentLyricsTime = 0;

lyricsmanager.h

@@ -25,6 +25,8 @@ public:
     QString lyrics(int lineOffset = 0) const;
     double maskPercent(int curTimeMs);
 
+    static int parseTimeToMilliseconds(const QString& timeString);
+
 protected:
 
 

main.cpp

@@ -21,7 +21,6 @@ int main(int argc, char *argv[])
     if (translator.load(QLocale(), QLatin1String("pineapple-music"), QLatin1String("_"), QLatin1String(":/i18n"))) {
         a.installTranslator(&translator);
     }
-    a.installTranslator(&translator);
 
     // parse commandline arguments
     QCommandLineParser parser;

mainwindow.cpp

@@ -6,6 +6,7 @@
 #include "./ui_mainwindow.h"
 
 #include "playlistmanager.h"
+#include "fftspectrum.h"
 #include "lrcbar.h"
 
 // taglib
@@ -31,6 +32,8 @@
 #include <QAudioDevice>
 #include <QMessageBox>
 #include <QStringBuilder>
+#include <QSettings>
+#include <QGraphicsDropShadowEffect>
 
 constexpr QSize miniSize(490, 160);
 constexpr QSize fullSize(490, 420);
@@ -41,23 +44,33 @@ MainWindow::MainWindow(QWidget *parent)
     , m_mediaDevices(new QMediaDevices(this))
     , m_mediaPlayer(new QMediaPlayer(this))
     , m_audioOutput(new QAudioOutput(this))
+    , m_fftSpectrum(new FFTSpectrum(this))
     , m_lrcbar(new LrcBar(nullptr))
     , m_playlistManager(new PlaylistManager(this))
 {
     ui->setupUi(this);
     m_playlistManager->setAutoLoadFilterSuffixes({
-        "*.mp3", "*.wav", "*.aiff", "*.ape", "*.flac", "*.ogg", "*.oga", "*.mpga", "*.aac"
+        "*.mp3", "*.wav", "*.aiff", "*.ape", "*.flac", "*.ogg", "*.oga", "*.mpga", "*.aac", "*.tta"
     });
+    m_fftSpectrum->setMediaPlayer(m_mediaPlayer);
     m_mediaPlayer->setAudioOutput(m_audioOutput);
     m_mediaPlayer->setLoops(QMediaPlayer::Infinite);
     ui->playlistView->setModel(m_playlistManager->model());
 
     ui->actionHelp->setShortcut(QKeySequence::HelpContents);
     addAction(ui->actionHelp);
+    ui->actionOpen->setShortcut(QKeySequence::Open);
+    addAction(ui->actionOpen);
+
+    ui->titleLabel->setGraphicsEffect(createLabelShadowEffect());
+    ui->propLabel->setGraphicsEffect(createLabelShadowEffect());
+    ui->nowTimeLabel->setGraphicsEffect(createLabelShadowEffect());
+    ui->totalTimeLabel->setGraphicsEffect(createLabelShadowEffect());
 
     setWindowFlags(Qt::FramelessWindowHint | Qt::WindowSystemMenuHint | Qt::WindowMinimizeButtonHint);
     setAttribute(Qt::WA_TranslucentBackground, true);
 
+    loadConfig();
     loadSkinData();
     initConnections();
     initUiAndAnimation();
@@ -67,6 +80,7 @@ MainWindow::MainWindow(QWidget *parent)
 
 MainWindow::~MainWindow()
 {
+    saveConfig();
     delete m_lrcbar;
     delete ui;
 }
@@ -100,12 +114,12 @@ void MainWindow::setAudioPropertyInfoForDisplay(int sampleRate, int bitrate, int
         }
     };
 
-    if (sampleRate >= 0) {
+    if (sampleRate > 0) {
         uiStrs << QString("%1 Hz").arg(sampleRate);
         tooltipStrs << tr("Sample Rate: %1 Hz").arg(sampleRate);
     }
 
-    if (bitrate >= 0) {
+    if (bitrate > 0) {
         uiStrs << QString("%1 Kbps").arg(bitrate);
         tooltipStrs << tr("Bitrate: %1 Kbps").arg(bitrate);
     }
@@ -228,6 +242,12 @@ void MainWindow::dropEvent(QDropEvent *e)
         return;
     }
 
+    if (fileName.endsWith(".chp") || fileName.endsWith(".pbf")) {
+        QList<std::pair<qint64, QString>> chapters(PlaybackProgressIndicator::tryLoadSidecarChapterFile(fileName));
+        ui->playbackProgressIndicator->setChapters(chapters);
+        return;
+    }
+
     const QModelIndex & modelIndex = m_playlistManager->loadPlaylist(urls);
     if (modelIndex.isValid()) {
         loadByModelIndex(modelIndex);
@@ -250,14 +270,22 @@ void MainWindow::loadFile()
     }
 
     m_playlistManager->loadPlaylist(urlList);
-    m_mediaPlayer->setSource(urlList.first());
+    const QUrl & firstUrl = urlList.first();
-    m_lrcbar->loadLyrics(urlList.first().toLocalFile());
+    loadFile(firstUrl);
+}
+
+void MainWindow::loadFile(const QUrl &url)
+{
+    const QString filePath = url.toLocalFile();
+    m_mediaPlayer->setSource(url);
+    m_lrcbar->loadLyrics(filePath);
+    QList<std::pair<qint64, QString>> chapters(PlaybackProgressIndicator::tryLoadChapters(filePath));
+    ui->playbackProgressIndicator->setChapters(chapters);
 }
 
 void MainWindow::loadByModelIndex(const QModelIndex & index)
 {
-    m_mediaPlayer->setSource(m_playlistManager->urlByIndex(index));
+    loadFile(m_playlistManager->urlByIndex(index));
-    m_lrcbar->loadLyrics(m_playlistManager->localFileByIndex(index));
 }
 
 void MainWindow::play()
@@ -345,14 +373,6 @@ void MainWindow::on_stopBtn_clicked()
     m_mediaPlayer->stop();
 }
 
-void MainWindow::on_playbackSlider_valueChanged(int value)
-{
-    qint64 currPos = m_mediaPlayer->duration() == 0 ? value : m_mediaPlayer->position() * ui->playbackSlider->maximum() / m_mediaPlayer->duration();
-    if (qAbs(currPos - value) > 2) {
-        m_mediaPlayer->setPosition(ui->playbackSlider->value() * 1.0 / ui->playbackSlider->maximum() * m_mediaPlayer->duration());
-    }
-}
-
 void MainWindow::on_prevBtn_clicked()
 {
     QModelIndex index(m_playlistManager->previousIndex());
@@ -400,6 +420,10 @@ void MainWindow::initConnections()
         m_audioOutput->setDevice(m_mediaDevices->defaultAudioOutput());
     });
 
+    connect(ui->playbackProgressIndicator, &PlaybackProgressIndicator::seekingRequested, this, [=](qint64 pos){
+        m_mediaPlayer->setPosition(pos);
+    });
+
     connect(m_mediaPlayer, &QMediaPlayer::sourceChanged, this, [=](){
         QUrl fileUrl(m_mediaPlayer->source());
 
@@ -417,6 +441,8 @@ void MainWindow::initConnections()
             if (!fileRef.isNull() && fileRef.audioProperties()) {
                 TagLib::AudioProperties *prop = fileRef.audioProperties();
                 setAudioPropertyInfoForDisplay(prop->sampleRate(), prop->bitrate(), prop->channels(), suffix);
+            } else {
+                qDebug() << "No Audio Properties from TagLib";
             }
 
             if (!fileRef.isNull() && fileRef.tag()) {
@@ -424,6 +450,10 @@ void MainWindow::initConnections()
                 setAudioMetadataForDisplay(QString::fromStdString(tag->title().to8Bit(true)),
                                            QString::fromStdString(tag->artist().to8Bit(true)),
                                            QString::fromStdString(tag->album().to8Bit(true)));
+                m_urlMissingTagLibMetadata.clear();
+            } else {
+                qDebug() << "No Audio Metadata from TagLib";
+                m_urlMissingTagLibMetadata = fileUrl;
             }
 #endif // NO_TAGLIB
         }
@@ -435,10 +465,17 @@ void MainWindow::initConnections()
         // see `02  Yoiyami Hanabi.mp3`'s Title. So we don't use Qt's one if tablib is available.
         qDebug() << metadata.stringValue(QMediaMetaData::Title) << metadata.stringValue(QMediaMetaData::Author);
 #ifdef NO_TAGLIB
-        setAudioMetadataForDisplay(metadata.stringValue(QMediaMetaData::Title),
+        bool needMetadataFromQt = true;
-                                   metadata.stringValue(QMediaMetaData::Author),
+#else
-                                   metadata.stringValue(QMediaMetaData::AlbumTitle));
+        bool needMetadataFromQt = m_urlMissingTagLibMetadata == m_mediaPlayer->source();
 #endif // NO_TAGLIB
+        if (needMetadataFromQt) {
+            setAudioMetadataForDisplay(metadata.stringValue(QMediaMetaData::Title),
+                                       metadata.stringValue(QMediaMetaData::Author),
+                                       metadata.stringValue(QMediaMetaData::AlbumTitle));
+            setAudioPropertyInfoForDisplay(-1, metadata.value(QMediaMetaData::AudioBitRate).toInt() / 1000,
+                                           -1, metadata.stringValue(QMediaMetaData::FileFormat));
+        }
         QVariant coverArt(metadata.value(QMediaMetaData::ThumbnailImage));
         if (!coverArt.isNull()) {
             ui->coverLabel->setPixmap(QPixmap::fromImage(coverArt.value<QImage>()));
@@ -454,7 +491,7 @@ void MainWindow::initConnections()
     connect(m_mediaPlayer, &QMediaPlayer::positionChanged, this, [=](qint64 pos) {
         ui->nowTimeLabel->setText(ms2str(pos));
         if (m_mediaPlayer->duration() != 0) {
-            ui->playbackSlider->setSliderPosition(ui->playbackSlider->maximum() * pos / m_mediaPlayer->duration());
+            ui->playbackProgressIndicator->setPosition(pos);
         }
         m_lrcbar->playbackPositionChanged(pos, m_mediaPlayer->duration());
     });
@@ -468,6 +505,7 @@ void MainWindow::initConnections()
     });
 
     connect(m_mediaPlayer, &QMediaPlayer::durationChanged, this, [=](qint64 dua) {
+        ui->playbackProgressIndicator->setDuration(dua);
         ui->totalTimeLabel->setText(ms2str(dua));
     });
 
@@ -526,9 +564,27 @@ void MainWindow::initConnections()
    });
 }
 
+void MainWindow::loadConfig()
+{
+    QDir configDir(QStandardPaths::writableLocation(QStandardPaths::AppConfigLocation));
+    QSettings settings(configDir.filePath("settings.ini"), QSettings::IniFormat);
+    ui->volumeSlider->setValue(settings.value("volume", 100).toInt());
+}
+
+void MainWindow::saveConfig()
+{
+    QDir configDir(QStandardPaths::writableLocation(QStandardPaths::AppConfigLocation));
+    if (!configDir.exists()) {
+        configDir.mkpath(".");
+    }
+    QSettings settings(configDir.filePath("settings.ini"), QSettings::IniFormat);
+    settings.setValue("volume", ui->volumeSlider->value());
+}
+
 void MainWindow::loadSkinData()
 {
-    QFile file(QStandardPaths::writableLocation(QStandardPaths::AppConfigLocation) + "/skin.dat");
+    QDir configDir(QStandardPaths::writableLocation(QStandardPaths::AppConfigLocation));
+    QFile file(configDir.filePath("skin.dat"));
     bool canOpen = file.open(QIODevice::ReadOnly);
     if (!canOpen) return;
     QDataStream stream(&file);
@@ -604,6 +660,10 @@ void MainWindow::on_lrcBtn_clicked()
     }
 }
 
+void MainWindow::on_actionOpen_triggered()
+{
+    loadFile();
+}
 
 void MainWindow::on_actionHelp_triggered()
 {
@@ -616,19 +676,32 @@ void MainWindow::on_actionHelp_triggered()
         "\n\n" %
         tr("Based on the following free software libraries:") %
         "\n\n" %
-        QStringLiteral("- [Qt](https://www.qt.io/) %1\n").arg(QT_VERSION_STR) %
+        QStringLiteral("- [Qt](https://www.qt.io/) %1 with the following module(s):\n").arg(QT_VERSION_STR) %
+        QStringLiteral("  - multimedia\n") %
+#ifdef USE_QTEXTCODEC
+        QStringLiteral("  - core5compat\n") %
+#endif
 #ifndef NO_TAGLIB
         QStringLiteral("- [TagLib](https://github.com/taglib/taglib)\n") %
 #endif // NO_TAGLIB
-#ifndef NO_UCHARDET
+#ifdef HAVE_KCODECS
-        QStringLiteral("- [uchardet](https://www.freedesktop.org/wiki/Software/uchardet/)\n") %
+        QStringLiteral("- [KCodecs](https://invent.kde.org/frameworks/kcodecs)\n") %
 #endif // NO_TAGLIB
         "\n"
         "[Source Code](https://github.com/BLumia/pineapple-music)\n"
         "\n"
-        "Copyright &copy; 2024 [BLumia](https://github.com/BLumia/)"
+        "Copyright &copy; 2025 [BLumia](https://github.com/BLumia/)"
         );
     infoBox.setTextFormat(Qt::MarkdownText);
     infoBox.exec();
 }
 
+QGraphicsDropShadowEffect *MainWindow::createLabelShadowEffect()
+{
+    QGraphicsDropShadowEffect * effect = new QGraphicsDropShadowEffect(this);
+    effect->setBlurRadius(3);
+    effect->setColor(QColor(0, 0, 0, 180));
+    effect->setOffset(1, 1);
+    return effect;
+}
+

mainwindow.h

@@ -7,6 +7,7 @@
 
 #include <QMainWindow>
 #include <QVariant>
+#include <QUrl>
 
 QT_BEGIN_NAMESPACE
 namespace Ui { class MainWindow; }
@@ -15,8 +16,10 @@ class QMediaDevices;
 class QMediaPlayer;
 class QAudioOutput;
 class QPropertyAnimation;
+class QGraphicsDropShadowEffect;
 QT_END_NAMESPACE
 
+class FFTSpectrum;
 class LrcBar;
 class PlaylistManager;
 class MainWindow : public QMainWindow
@@ -53,6 +56,7 @@ protected:
     void dropEvent(QDropEvent *e) override;
 
     void loadFile();
+    void loadFile(const QUrl &url);
     void loadByModelIndex(const QModelIndex &index);
     void play();
 
@@ -66,7 +70,6 @@ private slots:
     void on_playBtn_clicked();
     void on_volumeSlider_valueChanged(int value);
     void on_stopBtn_clicked();
-    void on_playbackSlider_valueChanged(int value);
     void on_prevBtn_clicked();
     void on_nextBtn_clicked();
     void on_volumeBtn_clicked();
@@ -75,16 +78,20 @@ private slots:
     void on_playListBtn_clicked();
     void on_playlistView_activated(const QModelIndex &index);
     void on_lrcBtn_clicked();
+    void on_actionOpen_triggered();
     void on_actionHelp_triggered();
 
 signals:
     void playbackModeChanged(enum PlaybackMode mode);
 
 private:
+    QGraphicsDropShadowEffect * createLabelShadowEffect();
+
     bool m_clickedOnWindow = false;
     bool m_playbackSliderPressed = false;
     QLinearGradient m_bgLinearGradient;
     QPixmap m_skin;
+    QUrl m_urlMissingTagLibMetadata;
     enum PlaybackMode m_playbackMode = CurrentItemInLoop;
 
     Ui::MainWindow *ui;
@@ -92,6 +99,7 @@ private:
     QMediaDevices *m_mediaDevices;
     QMediaPlayer *m_mediaPlayer;
     QAudioOutput *m_audioOutput;
+    FFTSpectrum* m_fftSpectrum;
     LrcBar *m_lrcbar;
     QPropertyAnimation *m_fadeOutAnimation;
     PlaylistManager *m_playlistManager;
@@ -99,6 +107,8 @@ private:
     void initUiAndAnimation();
     void initConnections();
 
+    void loadConfig();
+    void saveConfig();
     void loadSkinData();
     void saveSkinData();
 

mainwindow.ui

@@ -72,6 +72,7 @@ QSlider::add-page:vertical {
 /****** PushButton ******/
 
 QPushButton {
+	color: white;
 	border: 0px solid grey;
 	background-color: transparent;
 }
@@ -106,6 +107,7 @@ QLabel#coverLabel {
 /****** ListView ******/
 
 QListView {
+	color: white;
 	background: rgba(0, 0, 0, 50);
 }</string>
   </property>
@@ -369,14 +371,7 @@ QListView {
             </layout>
            </item>
            <item>
-            <widget class="SeekableSlider" name="playbackSlider">
+            <widget class="PlaybackProgressIndicator" name="playbackProgressIndicator" native="true"/>
-             <property name="maximum">
-              <number>1000</number>
-             </property>
-             <property name="orientation">
-              <enum>Qt::Orientation::Horizontal</enum>
-             </property>
-            </widget>
            </item>
            <item>
             <layout class="QHBoxLayout" name="playbackControlLayout">
@@ -659,7 +654,10 @@ QListView {
   </widget>
   <action name="actionHelp">
    <property name="text">
-    <string>help</string>
+    <string>Help</string>
+   </property>
+   <property name="toolTip">
+    <string>Help</string>
    </property>
    <property name="shortcut">
     <string>F1</string>
@@ -668,6 +666,20 @@ QListView {
     <enum>QAction::MenuRole::NoRole</enum>
    </property>
   </action>
+  <action name="actionOpen">
+   <property name="icon">
+    <iconset theme="document-open"/>
+   </property>
+   <property name="text">
+    <string>Open</string>
+   </property>
+   <property name="shortcut">
+    <string>Ctrl+O</string>
+   </property>
+   <property name="menuRole">
+    <enum>QAction::MenuRole::NoRole</enum>
+   </property>
+  </action>
  </widget>
  <customwidgets>
   <customwidget>
@@ -675,6 +687,12 @@ QListView {
    <extends>QSlider</extends>
    <header>seekableslider.h</header>
   </customwidget>
+  <customwidget>
+   <class>PlaybackProgressIndicator</class>
+   <extends>QWidget</extends>
+   <header>playbackprogressindicator.h</header>
+   <container>1</container>
+  </customwidget>
  </customwidgets>
  <resources>
   <include location="resources.qrc"/>

playbackprogressindicator.cpp

@@ -0,0 +1,311 @@
+// SPDX-FileCopyrightText: 2025 Gary Wang <git@blumia.net>
+//
+// SPDX-License-Identifier: MIT
+
+#include "playbackprogressindicator.h"
+
+#include <QDir>
+#include <QFile>
+#include <QFileInfo>
+#include <QPainter>
+#include <QPainterPath>
+#include <QRegularExpression>
+
+#ifdef HAVE_FFMPEG
+extern "C" {
+#include <libavformat/avformat.h>
+#include <libavutil/avutil.h>
+#include <libavutil/dict.h>
+#include <libavutil/time.h> // Contains AV_TIME_BASE and AV_TIME_BASE_Q
+} // extern "C"
+#endif // HAVE_FFMPEG
+
+PlaybackProgressIndicator::PlaybackProgressIndicator(QWidget *parent) :
+    QWidget(parent)
+{
+}
+
+void PlaybackProgressIndicator::setPosition(qint64 pos)
+{
+    m_position = pos;
+    emit positionChanged(m_position);
+}
+
+void PlaybackProgressIndicator::setDuration(qint64 dur)
+{
+    m_duration = dur;
+    emit durationChanged(m_duration);
+}
+
+void PlaybackProgressIndicator::setChapters(QList<std::pair<qint64, QString> > chapters)
+{
+    qDebug() << chapters;
+    m_chapterModel.clear();
+    for (const std::pair<qint64, QString> & chapter : chapters) {
+        QStandardItem * chapterItem = new QStandardItem(chapter.second);
+        chapterItem->setData(chapter.first, StartTimeMsRole);
+        m_chapterModel.appendRow(chapterItem);
+    }
+    update();
+}
+
+QList<std::pair<qint64, QString> > PlaybackProgressIndicator::tryLoadChapters(const QString &filePath)
+{
+    auto chapters = tryLoadSidecarChapterFile(filePath);
+    if (chapters.size() == 0) {
+        chapters = tryLoadChaptersFromMetadata(filePath);
+    }
+    return chapters;
+}
+
+QList<std::pair<qint64, QString> > PlaybackProgressIndicator::tryLoadSidecarChapterFile(const QString &filePath)
+{
+    if (filePath.endsWith(".chp", Qt::CaseInsensitive)) {
+        return parseCHPChapterFile(filePath);
+    } else if (filePath.endsWith(".pbf", Qt::CaseInsensitive)) {
+        return parsePBFChapterFile(filePath);
+    }
+
+    QFileInfo fileInfo(filePath);
+    fileInfo.setFile(fileInfo.dir().filePath(fileInfo.completeBaseName() + ".chp"));
+    if (fileInfo.exists()) {
+        return parseCHPChapterFile(fileInfo.absoluteFilePath());
+    }
+    fileInfo.setFile(fileInfo.dir().filePath(fileInfo.completeBaseName() + ".pbf"));
+    if (fileInfo.exists()) {
+        return parsePBFChapterFile(fileInfo.absoluteFilePath());
+    }
+    fileInfo.setFile(filePath + ".chp");
+    if (fileInfo.exists()) {
+        return parseCHPChapterFile(fileInfo.absoluteFilePath());
+    }
+    return {};
+}
+
+#ifdef HAVE_FFMPEG
+
+// Helper function to convert FFmpeg time (in time_base units) to milliseconds
+qint64 convertTimestampToMilliseconds(int64_t timestamp, AVRational time_base) {
+    // Convert to seconds first, then to milliseconds and cast to qint64
+    return static_cast<qint64>((double)timestamp * av_q2d(time_base) * 1000.0);
+}
+
+// Helper function to print FFmpeg errors
+void printFFmpegError(int errnum) {
+    char errbuf[AV_ERROR_MAX_STRING_SIZE];
+    av_strerror(errnum, errbuf, sizeof(errbuf));
+    qCritical() << "FFmpeg error:" << errbuf;
+}
+
+#endif // HAVE_FFMPEG
+
+QList<std::pair<qint64, QString> > PlaybackProgressIndicator::tryLoadChaptersFromMetadata(const QString &filePath)
+{
+#ifdef HAVE_FFMPEG
+    if (!QFile::exists(filePath)) {
+        qCritical() << "Error: File not found" << filePath;
+        return {};
+    }
+
+    AVFormatContext* format_ctx = nullptr; // FFmpeg format context
+    int ret = 0; // Return value for FFmpeg functions
+
+    qInfo() << "Attempting to open file:" << filePath;
+
+    // Open the input file and read the header.
+    // The last two arguments (AVInputFormat*, AVDictionary**) are optional.
+    // Passing nullptr for them means FFmpeg will try to guess the format
+    // and no options will be passed to the demuxer.
+    ret = avformat_open_input(&format_ctx, filePath.toUtf8().constData(), nullptr, nullptr);
+    if (ret < 0) {
+        qCritical() << "Could not open input file:" << filePath;
+        printFFmpegError(ret);
+        return {};
+    }
+    qInfo() << "File opened successfully.";
+
+    // Read stream information from the file.
+    // This populates format_ctx->streams and other metadata, including chapters.
+    ret = avformat_find_stream_info(format_ctx, nullptr);
+    if (ret < 0) {
+        qCritical() << "Could not find stream information for file:" << filePath;
+        printFFmpegError(ret);
+        avformat_close_input(&format_ctx); // Close the context before returning
+        return {};
+    }
+    qInfo() << "Stream information found.";
+
+    QList<std::pair<qint64, QString>> chapterList;
+
+    // Check if there are any chapters
+    if (format_ctx->nb_chapters == 0) {
+        qInfo() << "No chapters found in file:" << filePath;
+    } else {
+        qInfo() << "Found" << format_ctx->nb_chapters << "chapters.";
+        // Iterate through each chapter
+        for (unsigned int i = 0; i < format_ctx->nb_chapters; ++i) {
+            AVChapter* chapter = format_ctx->chapters[i];
+
+            // Chapter timestamps are typically in AV_TIME_BASE units by default
+            // unless the chapter itself has a specific time_base.
+            // For simplicity and common cases, we use AV_TIME_BASE_Q.
+            qint64 start_ms = convertTimestampToMilliseconds(chapter->start, chapter->time_base);
+
+            // Get the chapter title from its metadata.
+            // av_dict_get(dictionary, key, prev, flags)
+            // prev is used for iterating through multiple entries with the same key,
+            // we want the first one so we pass nullptr. flags=0 for case-insensitive.
+            AVDictionaryEntry* title_tag = av_dict_get(chapter->metadata, "title", nullptr, 0);
+            QString chapter_title = (title_tag && title_tag->value) ? QString::fromUtf8(title_tag->value) : "Untitled Chapter";
+
+            chapterList.append(std::make_pair(start_ms, chapter_title));
+        }
+    }
+
+    // Close the input file.
+    // This also frees the format_ctx and associated data.
+    avformat_close_input(&format_ctx);
+    qInfo() << "File closed.";
+
+    return chapterList;
+#else
+    qInfo() << "FFmpeg not found during build.";
+    return {};
+#endif // HAVE_FFMPEG
+}
+
+QList<std::pair<qint64, QString> > PlaybackProgressIndicator::parseCHPChapterFile(const QString &filePath)
+{
+    QList<std::pair<qint64, QString>> chapters;
+    QFile file(filePath);
+    if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
+        return chapters;
+    }
+
+    QTextStream in(&file);
+    QRegularExpression timeRegex(R"((\d{1,2}):(\d{2})(?::(\d{2}))?(?:\.(\d{1,3}))?)");
+
+    while (!in.atEnd()) {
+        QString line = in.readLine().trimmed();
+        QRegularExpressionMatch match = timeRegex.match(line);
+        if (match.hasMatch()) {
+            int hours = match.capturedView(3).isEmpty() ? 0 : match.capturedView(1).toInt();
+            int minutes = match.capturedView(3).isEmpty() ? match.capturedView(1).toInt() : match.capturedView(2).toInt();
+            int seconds = match.capturedView(3).isEmpty() ? match.capturedView(2).toInt() : match.capturedView(3).toInt();
+            int milliseconds = 0;
+
+            QStringView millisecondsStr(match.capturedView(4));
+            if (!millisecondsStr.isEmpty()) {
+                milliseconds = millisecondsStr.toInt() * pow(10, 3 - millisecondsStr.length());
+            }
+
+            qint64 totalMilliseconds = (hours * 3600 + minutes * 60 + seconds) * 1000 + milliseconds;
+
+            QString chapterTitle = line.mid(match.capturedLength()).trimmed();
+            chapters.append(std::make_pair(totalMilliseconds, chapterTitle));
+        }
+    }
+
+    file.close();
+    return chapters;
+}
+
+QList<std::pair<qint64, QString> > PlaybackProgressIndicator::parsePBFChapterFile(const QString &filePath)
+{
+    QList<std::pair<qint64, QString>> chapters;
+    QFile file(filePath);
+    if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
+        return chapters;
+    }
+
+    QTextStream in(&file);
+    QRegularExpression chapterRegex(R"(^\d+=(\d+)\*([^*]*)\*.*$)");
+
+    while (!in.atEnd()) {
+        QString line = in.readLine().trimmed();
+        QRegularExpressionMatch match = chapterRegex.match(line);
+        if (match.hasMatch()) {
+            qint64 timestamp = match.captured(1).toLongLong();
+            QString title = match.captured(2).trimmed();
+            chapters.append(std::make_pair(timestamp, title));
+        }
+    }
+
+    file.close();
+    return chapters;
+}
+
+void PlaybackProgressIndicator::paintEvent(QPaintEvent *event)
+{
+    constexpr int progressBarHeight = 6;
+    constexpr QColor activeColor = QColor(85, 170, 0);
+    const QPointF topLeft(0, height() / 2.0 - progressBarHeight / 2.0);
+    const QSizeF barSize(width(), progressBarHeight);
+
+    const float currentProgress = m_duration <= 0 ? 0 : (m_seekingPosition >= 0 ? m_seekingPosition : m_position) / (float)m_duration;
+    const QSizeF progressSize(width() * currentProgress, progressBarHeight);
+
+    QPainterPath theProgress;
+    theProgress.addRoundedRect(QRectF(topLeft, progressSize), progressBarHeight / 2, progressBarHeight / 2);
+
+    QPainter painter(this);
+    painter.setRenderHint(QPainter::Antialiasing);
+    painter.save();
+
+    // the bar itself
+    painter.setPen(Qt::gray);
+    painter.drawRoundedRect(QRectF(topLeft, barSize), progressBarHeight / 2, progressBarHeight / 2);
+    painter.fillPath(theProgress, activeColor);
+
+    // progress
+    painter.setPen(activeColor);
+    painter.drawPath(theProgress);
+
+    // chapter markers
+    if (m_duration > 0) {
+        painter.setPen(Qt::lightGray);
+        for (int i = 0; i < m_chapterModel.rowCount(); i++) {
+            qint64 chapterStartTime = m_chapterModel.item(i)->data(StartTimeMsRole).toInt();
+            if (chapterStartTime == 0) continue;
+            if (chapterStartTime > m_duration) break;
+            float chapterPercent = chapterStartTime / (float)m_duration;
+            float chapterPosX = width() * chapterPercent;
+            painter.drawLine(topLeft + QPoint(chapterPosX, 0),
+                             topLeft + QPoint(chapterPosX, progressBarHeight));
+        }
+    }
+
+    painter.restore();
+}
+
+void PlaybackProgressIndicator::mousePressEvent(QMouseEvent *event)
+{
+    if (m_duration > 0) {
+        event->accept();
+    } else {
+        return QWidget::mousePressEvent(event);
+    }
+}
+
+void PlaybackProgressIndicator::mouseMoveEvent(QMouseEvent *event)
+{
+    if (m_duration > 0) {
+        m_seekingPosition = event->position().x() * m_duration / width();
+        if (m_seekOnMove) {
+            emit seekingRequested(m_seekingPosition);
+        }
+        update();
+    }
+    return QWidget::mouseMoveEvent(event);
+}
+
+void PlaybackProgressIndicator::mouseReleaseEvent(QMouseEvent *event)
+{
+    if (m_duration > 0) {
+        int seekingPosition = event->position().x() * m_duration / width();
+        m_seekingPosition = -1;
+        emit seekingRequested(seekingPosition);
+    }
+    update();
+    return QWidget::mouseReleaseEvent(event);
+}

playbackprogressindicator.h

@@ -0,0 +1,58 @@
+// SPDX-FileCopyrightText: 2025 Gary Wang <git@blumia.net>
+//
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <QWidget>
+#include <QMouseEvent>
+#include <QStandardItemModel>
+
+class PlaybackProgressIndicator : public QWidget
+{
+    Q_OBJECT
+
+    Q_PROPERTY(bool seekOnMove MEMBER m_seekOnMove NOTIFY seekOnMoveChanged)
+    Q_PROPERTY(qint64 position MEMBER m_position NOTIFY positionChanged)
+    Q_PROPERTY(qint64 duration MEMBER m_duration NOTIFY durationChanged)
+public:
+    enum Roles {
+        ChapterTitleRole = Qt::DisplayRole,
+        StartTimeMsRole = Qt::UserRole + 1,
+    };
+
+    explicit PlaybackProgressIndicator(QWidget *parent = nullptr);
+    ~PlaybackProgressIndicator() = default;
+
+    void setPosition(qint64 pos);
+    void setDuration(qint64 dur);
+    void setChapters(QList<std::pair<qint64, QString>> chapters);
+
+    static QList<std::pair<qint64, QString>> tryLoadChapters(const QString & filePath);
+    static QList<std::pair<qint64, QString>> tryLoadSidecarChapterFile(const QString & filePath);
+    static QList<std::pair<qint64, QString>> tryLoadChaptersFromMetadata(const QString & filePath);
+    static QList<std::pair<qint64, QString>> parseCHPChapterFile(const QString & filePath);
+    static QList<std::pair<qint64, QString>> parsePBFChapterFile(const QString & filePath);
+
+signals:
+    void seekOnMoveChanged(bool sow);
+    void positionChanged(qint64 newPosition);
+    void durationChanged(qint64 newDuration);
+    void seekingRequested(qint64 position);
+
+public slots:
+
+protected:
+    void paintEvent(QPaintEvent *event) override;
+    void mousePressEvent(QMouseEvent *event) override;
+    void mouseMoveEvent(QMouseEvent *event) override;
+    void mouseReleaseEvent(QMouseEvent *event) override;
+
+private:
+    bool m_seekOnMove = true;
+    qint64 m_position = -1;
+    qint64 m_seekingPosition = -1;
+    qint64 m_duration = -1;
+    QStandardItemModel m_chapterModel;
+};
+

playlistmanager.cpp

@@ -1,255 +1,253 @@
-// SPDX-FileCopyrightText: 2024 Gary Wang <git@blumia.net>
+// SPDX-FileCopyrightText: 2025 Gary Wang <git@blumia.net>
-//
+//
-// SPDX-License-Identifier: MIT
+// SPDX-License-Identifier: MIT
-
+
-#include "playlistmanager.h"
+#include "playlistmanager.h"
-
+
-#include <QCollator>
+#include <QCollator>
-#include <QDir>
+#include <QDir>
-#include <QFileInfo>
+#include <QFileInfo>
-#include <QUrl>
+#include <QUrl>
-
+
-PlaylistModel::PlaylistModel(QObject *parent)
+PlaylistModel::PlaylistModel(QObject *parent)
-    : QAbstractListModel(parent)
+    : QAbstractListModel(parent)
-{
+{
-
+
-}
+}
-
+
-PlaylistModel::~PlaylistModel()
+PlaylistModel::~PlaylistModel()
-{
+= default;
-
+
-}
+void PlaylistModel::setPlaylist(const QList<QUrl> &urls)
-
+{
-void PlaylistModel::setPlaylist(const QList<QUrl> &urls)
+    beginResetModel();
-{
+    m_playlist = urls;
-    beginResetModel();
+    endResetModel();
-    m_playlist = urls;
+}
-    endResetModel();
+
-}
+QModelIndex PlaylistModel::loadPlaylist(const QList<QUrl> & urls)
-
+{
-QModelIndex PlaylistModel::loadPlaylist(const QList<QUrl> & urls)
+    if (urls.isEmpty()) return {};
-{
+    if (urls.count() == 1) {
-    if (urls.isEmpty()) return QModelIndex();
+        return loadPlaylist(urls.constFirst());
-    if (urls.count() == 1) {
+    } else {
-        return loadPlaylist(urls.constFirst());
+        setPlaylist(urls);
-    } else {
+        return index(0);
-        setPlaylist(urls);
+    }
-        return index(0);
+}
-    }
+
-}
+QModelIndex PlaylistModel::loadPlaylist(const QUrl &url)
-
+{
-QModelIndex PlaylistModel::loadPlaylist(const QUrl &url)
+    QFileInfo info(url.toLocalFile());
-{
+    QDir dir(info.path());
-    QFileInfo info(url.toLocalFile());
+    QString && currentFileName = info.fileName();
-    QDir dir(info.path());
+
-    QString && currentFileName = info.fileName();
+    if (dir.path() == m_currentDir) {
-
+        int idx = indexOf(url);
-    if (dir.path() == m_currentDir) {
+        return idx == -1 ? appendToPlaylist(url) : index(idx);
-        int idx = indexOf(url);
+    }
-        return idx == -1 ? appendToPlaylist(url) : index(idx);
+
-    }
+    QStringList entryList = dir.entryList(
-
+        m_autoLoadSuffixes,
-    QStringList entryList = dir.entryList(
+        QDir::Files | QDir::NoSymLinks, QDir::NoSort);
-        m_autoLoadSuffixes,
+
-        QDir::Files | QDir::NoSymLinks, QDir::NoSort);
+    QCollator collator;
-
+    collator.setNumericMode(true);
-    QCollator collator;
+
-    collator.setNumericMode(true);
+    std::sort(entryList.begin(), entryList.end(), collator);
-
+
-    std::sort(entryList.begin(), entryList.end(), collator);
+    QList<QUrl> playlist;
-
+
-    QList<QUrl> playlist;
+    int idx = -1;
-
+    for (int i = 0; i < entryList.count(); i++) {
-    int idx = -1;
+        const QString & fileName = entryList.at(i);
-    for (int i = 0; i < entryList.count(); i++) {
+        const QString & oneEntry = dir.absoluteFilePath(fileName);
-        const QString & fileName = entryList.at(i);
+        const QUrl & url = QUrl::fromLocalFile(oneEntry);
-        const QString & oneEntry = dir.absoluteFilePath(fileName);
+        playlist.append(url);
-        const QUrl & url = QUrl::fromLocalFile(oneEntry);
+        if (fileName == currentFileName) {
-        playlist.append(url);
+            idx = i;
-        if (fileName == currentFileName) {
+        }
-            idx = i;
+    }
-        }
+    if (idx == -1) {
-    }
+        idx = playlist.count();
-    if (idx == -1) {
+        playlist.append(url);
-        idx = playlist.count();
+    }
-        playlist.append(url);
+    m_currentDir = dir.path();
-    }
+
-    m_currentDir = dir.path();
+    setPlaylist(playlist);
-
+
-    setPlaylist(playlist);
+    return index(idx);
-
+}
-    return index(idx);
+
-}
+QModelIndex PlaylistModel::appendToPlaylist(const QUrl &url)
-
+{
-QModelIndex PlaylistModel::appendToPlaylist(const QUrl &url)
+    const int lastIndex = rowCount();
-{
+    beginInsertRows(QModelIndex(), lastIndex, lastIndex);
-    const int lastIndex = rowCount();
+    m_playlist.append(url);
-    beginInsertRows(QModelIndex(), lastIndex, lastIndex);
+    endInsertRows();
-    m_playlist.append(url);
+    return index(lastIndex);
-    endInsertRows();
+}
-    return index(lastIndex);
+
-}
+bool PlaylistModel::removeAt(int index)
-
+{
-bool PlaylistModel::removeAt(int index)
+    if (index < 0 || index >= rowCount()) return false;
-{
+    beginRemoveRows(QModelIndex(), index, index);
-    if (index < 0 || index >= rowCount()) return false;
+    m_playlist.removeAt(index);
-    beginRemoveRows(QModelIndex(), index, index);
+    endRemoveRows();
-    m_playlist.removeAt(index);
+    return true;
-    endRemoveRows();
+}
-    return true;
+
-}
+int PlaylistModel::indexOf(const QUrl &url) const
-
+{
-int PlaylistModel::indexOf(const QUrl &url) const
+    return m_playlist.indexOf(url);
-{
+}
-    return m_playlist.indexOf(url);
+
-}
+QUrl PlaylistModel::urlByIndex(int index) const
-
+{
-QUrl PlaylistModel::urlByIndex(int index) const
+    return m_playlist.value(index);
-{
+}
-    return m_playlist.value(index);
+
-}
+QStringList PlaylistModel::autoLoadFilterSuffixes() const
-
+{
-QStringList PlaylistModel::autoLoadFilterSuffixes() const
+    return m_autoLoadSuffixes;
-{
+}
-    return m_autoLoadSuffixes;
+
-}
+QHash<int, QByteArray> PlaylistModel::roleNames() const
-
+{
-QHash<int, QByteArray> PlaylistModel::roleNames() const
+    QHash<int, QByteArray> result = QAbstractListModel::roleNames();
-{
+    result.insert(UrlRole, "url");
-    QHash<int, QByteArray> result = QAbstractListModel::roleNames();
+    return result;
-    result.insert(UrlRole, "url");
+}
-    return result;
+
-}
+int PlaylistModel::rowCount(const QModelIndex &parent) const
-
+{
-int PlaylistModel::rowCount(const QModelIndex &parent) const
+    return m_playlist.count();
-{
+}
-    return m_playlist.count();
+
-}
+QVariant PlaylistModel::data(const QModelIndex &index, int role) const
-
+{
-QVariant PlaylistModel::data(const QModelIndex &index, int role) const
+    if (!index.isValid()) return {};
-{
+
-    if (!index.isValid()) return QVariant();
+    switch (role) {
-
+    case Qt::DisplayRole:
-    switch (role) {
+        return m_playlist.at(index.row()).fileName();
-    case Qt::DisplayRole:
+    case UrlRole:
-        return m_playlist.at(index.row()).fileName();
+        return m_playlist.at(index.row());
-    case UrlRole:
+    }
-        return m_playlist.at(index.row());
+
-    }
+    return {};
-
+}
-    return QVariant();
+
-}
+PlaylistManager::PlaylistManager(QObject *parent)
-
+    : QObject(parent)
-PlaylistManager::PlaylistManager(QObject *parent)
+{
-    : QObject(parent)
+    connect(&m_model, &PlaylistModel::rowsRemoved, this,
-{
+            [this](const QModelIndex &, int, int) {
-    connect(&m_model, &PlaylistModel::rowsRemoved, this,
+                if (m_model.rowCount() <= m_currentIndex) {
-            [this](const QModelIndex &, int, int) {
+                    setProperty("currentIndex", m_currentIndex - 1);
-                if (m_model.rowCount() <= m_currentIndex) {
+                }
-                    setProperty("currentIndex", m_currentIndex - 1);
+            });
-                }
+
-            });
+    auto onRowCountChanged = [this](){
-
+        emit totalCountChanged(m_model.rowCount());
-    auto onRowCountChanged = [this](){
+    };
-        emit totalCountChanged(m_model.rowCount());
+
-    };
+    connect(&m_model, &PlaylistModel::rowsInserted, this, onRowCountChanged);
-
+    connect(&m_model, &PlaylistModel::rowsRemoved, this, onRowCountChanged);
-    connect(&m_model, &PlaylistModel::rowsInserted, this, onRowCountChanged);
+    connect(&m_model, &PlaylistModel::modelReset, this, onRowCountChanged);
-    connect(&m_model, &PlaylistModel::rowsRemoved, this, onRowCountChanged);
+}
-    connect(&m_model, &PlaylistModel::modelReset, this, onRowCountChanged);
+
-}
+PlaylistManager::~PlaylistManager()
-
+{
-PlaylistManager::~PlaylistManager()
+
-{
+}
-
+
-}
+PlaylistModel *PlaylistManager::model()
-
+{
-PlaylistModel *PlaylistManager::model()
+    return &m_model;
-{
+}
-    return &m_model;
+
-}
+void PlaylistManager::setPlaylist(const QList<QUrl> &urls)
-
+{
-void PlaylistManager::setPlaylist(const QList<QUrl> &urls)
+    m_model.setPlaylist(urls);
-{
+}
-    m_model.setPlaylist(urls);
+
-}
+QModelIndex PlaylistManager::loadPlaylist(const QList<QUrl> &urls)
-
+{
-QModelIndex PlaylistManager::loadPlaylist(const QList<QUrl> &urls)
+    QModelIndex idx = m_model.loadPlaylist(urls);
-{
+    setProperty("currentIndex", idx.row());
-    QModelIndex idx = m_model.loadPlaylist(urls);
+    return idx;
-    setProperty("currentIndex", idx.row());
+}
-    return idx;
+
-}
+QModelIndex PlaylistManager::loadPlaylist(const QUrl &url)
-
+{
-QModelIndex PlaylistManager::loadPlaylist(const QUrl &url)
+    QModelIndex idx = m_model.loadPlaylist(url);
-{
+    setProperty("currentIndex", idx.row());
-    QModelIndex idx = m_model.loadPlaylist(url);
+    return idx;
-    setProperty("currentIndex", idx.row());
+}
-    return idx;
+
-}
+int PlaylistManager::totalCount() const
-
+{
-int PlaylistManager::totalCount() const
+    return m_model.rowCount();
-{
+}
-    return m_model.rowCount();
+
-}
+QModelIndex PlaylistManager::previousIndex() const
-
+{
-QModelIndex PlaylistManager::previousIndex() const
+    int count = totalCount();
-{
+    if (count == 0) return {};
-    int count = totalCount();
+
-    if (count == 0) return QModelIndex();
+    return m_model.index(m_currentIndex - 1 < 0 ? count - 1 : m_currentIndex - 1);
-
+}
-    return m_model.index(m_currentIndex - 1 < 0 ? count - 1 : m_currentIndex - 1);
+
-}
+QModelIndex PlaylistManager::nextIndex() const
-
+{
-QModelIndex PlaylistManager::nextIndex() const
+    int count = totalCount();
-{
+    if (count == 0) return {};
-    int count = totalCount();
+
-    if (count == 0) return QModelIndex();
+    return m_model.index(m_currentIndex + 1 == count ? 0 : m_currentIndex + 1);
-
+}
-    return m_model.index(m_currentIndex + 1 == count ? 0 : m_currentIndex + 1);
+
-}
+QModelIndex PlaylistManager::curIndex() const
-
+{
-QModelIndex PlaylistManager::curIndex() const
+    return m_model.index(m_currentIndex);
-{
+}
-    return m_model.index(m_currentIndex);
+
-}
+void PlaylistManager::setCurrentIndex(const QModelIndex &index)
-
+{
-void PlaylistManager::setCurrentIndex(const QModelIndex &index)
+    if (index.isValid() && index.row() >= 0 && index.row() < totalCount()) {
-{
+        setProperty("currentIndex", index.row());
-    if (index.isValid() && index.row() >= 0 && index.row() < totalCount()) {
+    }
-        setProperty("currentIndex", index.row());
+}
-    }
+
-}
+QUrl PlaylistManager::urlByIndex(const QModelIndex &index)
-
+{
-QUrl PlaylistManager::urlByIndex(const QModelIndex &index)
+    return m_model.urlByIndex(index.row());
-{
+}
-    return m_model.urlByIndex(index.row());
+
-}
+QString PlaylistManager::localFileByIndex(const QModelIndex &index)
-
+{
-QString PlaylistManager::localFileByIndex(const QModelIndex &index)
+    return urlByIndex(index).toLocalFile();
-{
+}
-    return urlByIndex(index).toLocalFile();
+
-}
+bool PlaylistManager::removeAt(const QModelIndex &index)
-
+{
-bool PlaylistManager::removeAt(const QModelIndex &index)
+    return m_model.removeAt(index.row());
-{
+}
-    return m_model.removeAt(index.row());
+
-}
+void PlaylistManager::setAutoLoadFilterSuffixes(const QStringList &nameFilters)
-
+{
-void PlaylistManager::setAutoLoadFilterSuffixes(const QStringList &nameFilters)
+    m_model.setProperty("autoLoadFilterSuffixes", nameFilters);
-{
+}
-    m_model.setProperty("autoLoadFilterSuffixes", nameFilters);
+
-}
+QList<QUrl> PlaylistManager::convertToUrlList(const QStringList &files)
-
+{
-QList<QUrl> PlaylistManager::convertToUrlList(const QStringList &files)
+    QList<QUrl> urlList;
-{
+    for (const QString & str : std::as_const(files)) {
-    QList<QUrl> urlList;
+        QUrl url = QUrl::fromLocalFile(str);
-    for (const QString & str : std::as_const(files)) {
+        if (url.isValid()) {
-        QUrl url = QUrl::fromLocalFile(str);
+            urlList.append(url);
-        if (url.isValid()) {
+        }
-            urlList.append(url);
+    }
-        }
+
-    }
+    return urlList;
-
+}
-    return urlList;
-}

playlistmanager.h

@@ -1,85 +1,85 @@
-// SPDX-FileCopyrightText: 2024 Gary Wang <git@blumia.net>
+// SPDX-FileCopyrightText: 2025 Gary Wang <git@blumia.net>
-//
+//
-// SPDX-License-Identifier: MIT
+// SPDX-License-Identifier: MIT
-
+
-#pragma once
+#pragma once
-
+
-#include <QUrl>
+#include <QUrl>
-#include <QAbstractListModel>
+#include <QAbstractListModel>
-
+
-class PlaylistModel : public QAbstractListModel
+class PlaylistModel : public QAbstractListModel
-{
+{
-    Q_OBJECT
+    Q_OBJECT
-public:
+public:
-    enum PlaylistRole {
+    enum PlaylistRole {
-        UrlRole = Qt::UserRole
+        UrlRole = Qt::UserRole
-    };
+    };
-    Q_ENUM(PlaylistRole)
+    Q_ENUM(PlaylistRole)
-    Q_PROPERTY(QStringList autoLoadFilterSuffixes MEMBER m_autoLoadSuffixes NOTIFY autoLoadFilterSuffixesChanged)
+    Q_PROPERTY(QStringList autoLoadFilterSuffixes MEMBER m_autoLoadSuffixes NOTIFY autoLoadFilterSuffixesChanged)
-
+
-    explicit PlaylistModel(QObject *parent = nullptr);
+    explicit PlaylistModel(QObject *parent = nullptr);
-    ~PlaylistModel();
+    ~PlaylistModel() override;
-
+
-    void setPlaylist(const QList<QUrl> & urls);
+    void setPlaylist(const QList<QUrl> & urls);
-    QModelIndex loadPlaylist(const QList<QUrl> & urls);
+    QModelIndex loadPlaylist(const QList<QUrl> & urls);
-    QModelIndex loadPlaylist(const QUrl & url);
+    QModelIndex loadPlaylist(const QUrl & url);
-    QModelIndex appendToPlaylist(const QUrl & url);
+    QModelIndex appendToPlaylist(const QUrl & url);
-    bool removeAt(int index);
+    bool removeAt(int index);
-    int indexOf(const QUrl & url) const;
+    int indexOf(const QUrl & url) const;
-    QUrl urlByIndex(int index) const;
+    QUrl urlByIndex(int index) const;
-    QStringList autoLoadFilterSuffixes() const;
+    QStringList autoLoadFilterSuffixes() const;
-
+
-    QHash<int, QByteArray> roleNames() const override;
+    QHash<int, QByteArray> roleNames() const override;
-    int rowCount(const QModelIndex &parent = QModelIndex()) const override;
+    int rowCount(const QModelIndex &parent = QModelIndex()) const override;
-    QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
+    QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
-
+
-signals:
+signals:
-    void autoLoadFilterSuffixesChanged(QStringList suffixes);
+    void autoLoadFilterSuffixesChanged(QStringList suffixes);
-
+
-private:
+private:
-    // model data
+    // model data
-    QList<QUrl> m_playlist;
+    QList<QUrl> m_playlist;
-    // properties
+    // properties
-    QStringList m_autoLoadSuffixes = {};
+    QStringList m_autoLoadSuffixes = {};
-    // internal
+    // internal
-    QString m_currentDir;
+    QString m_currentDir;
-};
+};
-
+
-class PlaylistManager : public QObject
+class PlaylistManager : public QObject
-{
+{
-    Q_OBJECT
+    Q_OBJECT
-public:
+public:
-    Q_PROPERTY(int currentIndex MEMBER m_currentIndex NOTIFY currentIndexChanged)
+    Q_PROPERTY(int currentIndex MEMBER m_currentIndex NOTIFY currentIndexChanged)
-    Q_PROPERTY(QStringList autoLoadFilterSuffixes WRITE setAutoLoadFilterSuffixes)
+    Q_PROPERTY(QStringList autoLoadFilterSuffixes WRITE setAutoLoadFilterSuffixes)
-    Q_PROPERTY(PlaylistModel * model READ model CONSTANT)
+    Q_PROPERTY(PlaylistModel * model READ model CONSTANT)
-
+
-    explicit PlaylistManager(QObject *parent = nullptr);
+    explicit PlaylistManager(QObject *parent = nullptr);
-    ~PlaylistManager();
+    ~PlaylistManager();
-
+
-    PlaylistModel * model();
+    PlaylistModel * model();
-
+
-    void setPlaylist(const QList<QUrl> & url);
+    void setPlaylist(const QList<QUrl> & url);
-    Q_INVOKABLE QModelIndex loadPlaylist(const QList<QUrl> & urls);
+    Q_INVOKABLE QModelIndex loadPlaylist(const QList<QUrl> & urls);
-    Q_INVOKABLE QModelIndex loadPlaylist(const QUrl & url);
+    Q_INVOKABLE QModelIndex loadPlaylist(const QUrl & url);
-
+
-    int totalCount() const;
+    int totalCount() const;
-    QModelIndex previousIndex() const;
+    QModelIndex previousIndex() const;
-    QModelIndex nextIndex() const;
+    QModelIndex nextIndex() const;
-    QModelIndex curIndex() const;
+    QModelIndex curIndex() const;
-    void setCurrentIndex(const QModelIndex & index);
+    void setCurrentIndex(const QModelIndex & index);
-    QUrl urlByIndex(const QModelIndex & index);
+    QUrl urlByIndex(const QModelIndex & index);
-    QString localFileByIndex(const QModelIndex & index);
+    QString localFileByIndex(const QModelIndex & index);
-    bool removeAt(const QModelIndex & index);
+    bool removeAt(const QModelIndex & index);
-
+
-    void setAutoLoadFilterSuffixes(const QStringList &nameFilters);
+    void setAutoLoadFilterSuffixes(const QStringList &nameFilters);
-
+
-    static QList<QUrl> convertToUrlList(const QStringList & files);
+    static QList<QUrl> convertToUrlList(const QStringList & files);
-
+
-signals:
+signals:
-    void currentIndexChanged(int index);
+    void currentIndexChanged(int index);
-    void totalCountChanged(int count);
+    void totalCountChanged(int count);
-
+
-private:
+private:
-    int m_currentIndex = -1;
+    int m_currentIndex = -1;
-    PlaylistModel m_model;
+    PlaylistModel m_model;
-};
+};

seekableslider.h

@@ -1,24 +1,24 @@
-// SPDX-FileCopyrightText: 2024 Gary Wang <git@blumia.net>
+// SPDX-FileCopyrightText: 2025 Gary Wang <git@blumia.net>
-//
+//
-// SPDX-License-Identifier: MIT
+// SPDX-License-Identifier: MIT
-
+
-#pragma once
+#pragma once
-
+
-#include <QSlider>
+#include <QSlider>
-#include <QMouseEvent>
+#include <QMouseEvent>
-
+
-class SeekableSlider : public QSlider
+class SeekableSlider : public QSlider
-{
+{
-    Q_OBJECT
+    Q_OBJECT
-public:
+public:
-    explicit SeekableSlider(QWidget *parent = nullptr);
+    explicit SeekableSlider(QWidget *parent = nullptr);
-    ~SeekableSlider() = default;
+    ~SeekableSlider() override = default;
-
+
-signals:
+signals:
-
+
-public slots:
+public slots:
-
+
-protected:
+protected:
-    void mouseReleaseEvent(QMouseEvent *event) override;
+    void mouseReleaseEvent(QMouseEvent *event) override;
-};
+};
-
+