feat: add synchronized lyrics to lyrics-gtk

- Parse LRC time tags and global offsets
- Handle multi-timestamp lines and chronological sorting
- Add a timer to update and highlight lyrics during playback
- Add configuration option for synchronization

Author: lecheel

src/lyrics-common/preferences.h

@@ -71,6 +71,8 @@ static const PreferencesWidget widgets[] = {
         {{remote_sources}}),
     WidgetCheck (N_("Store fetched lyrics in local cache"),
         WidgetBool (CFG_SECTION, "enable-cache")),
+    WidgetCheck(N_("Enable lyric synchronization"),                
+        WidgetBool("lyricwiki", "sync_lyrics")),
     WidgetLabel (N_("<b>Local Storage</b>")),
     WidgetCheck (N_("Load lyric files (.lrc) from local storage"),
         WidgetBool (CFG_SECTION, "enable-file-provider"))

src/lyrics-gtk/lyrics-gtk.cc

@@ -29,6 +29,21 @@
 #include "../lyrics-common/lyrics.h"
 #include "../lyrics-common/preferences.h"
 
+#include <algorithm> // For std::sort
+#include <clocale>
+#include <regex>   // For std::regex and std::smatch
+#include <sstream> // For std::istringstream
+#include <vector>
+
+struct TimedLyricLine
+{
+    int timestamp_ms; // Timestamp in milliseconds
+    String text;      // Lyric text at this timestamp
+};
+
+std::vector<TimedLyricLine>
+    timed_lyrics; // Stores parsed lyrics with timestamps
+
 class LyricsGtk : public GeneralPlugin
 {
 public:
@@ -88,8 +103,100 @@ void update_lyrics_window (const char * title, const char * artist, const char *
     gtk_text_buffer_insert (textbuffer, & iter, "\n\n", -1);
     gtk_text_buffer_insert (textbuffer, & iter, lyrics, -1);
 
-    gtk_text_buffer_get_start_iter (textbuffer, & iter);
-    gtk_text_view_scroll_to_iter (textview, & iter, 0, true, 0, 0);
+    // Parse the lyrics and populate timed_lyrics
+    timed_lyrics.clear ();
+
+    // Add a dummy timestamp for the first line (at -1ms to ensure it's always
+    // before the actual lyrics)
+    TimedLyricLine title_line;
+    title_line.timestamp_ms = -1;
+    title_line.text = String (title);
+    timed_lyrics.push_back (title_line);
+
+    std::istringstream iss (lyrics);
+    std::string line;
+
+    int global_offset = 0;
+    std::regex time_re (R"(\[\s*(\d+)\s*:\s*(\d+(?:\.\d+)?)\s*\])");
+    std::regex offset_re (R"(\[\s*offset\s*:\s*([+-]?\d+)\s*\])",
+                         std::regex_constants::icase);
+
+    while (std::getline (iss, line))
+    {
+        // Sanitize the line: remove leading/trailing spaces and carriage return
+        line.erase (0, line.find_first_not_of (" \t\r")); // Remove leading whitespace and \r
+        line.erase (line.find_last_not_of (" \t\r") + 1); // Remove trailing whitespace and \r
+
+        if (line.empty ())
+            continue;
+
+        // 1. Check for the global offset tag
+        std::smatch offset_match;
+        if (std::regex_search (line, offset_match, offset_re))
+        {
+            global_offset = std::stoi (offset_match[1].str());
+            continue;
+        }
+
+        // 2. Extract MULTIPLE time tags from a single line
+        std::sregex_iterator it (line.begin (), line.end (), time_re);
+        std::sregex_iterator end;
+
+        std::vector <int> timestamps;
+        size_t last_pos = 0;
+
+        for (; it != end; ++it)
+        {
+            int minutes = std::stoi (it->str (1));
+            float seconds = std::stof (it->str (2));
+            int timestamp_ms =
+                static_cast <int> ((minutes * 60 + seconds) * 1000);
+
+            timestamps.push_back (timestamp_ms);
+            last_pos = it->position () + it->length ();
+        }
+
+        // 3. If timestamps were found, attach the remaining text to all of them
+        if (!timestamps.empty ())
+        {
+            std::string text = line.substr (last_pos);
+            text.erase (0, text.find_first_not_of (" \t")); // Trim leading spaces
+
+            for (int ts : timestamps)
+            {
+                TimedLyricLine timed_line;
+                timed_line.timestamp_ms = ts;
+                timed_line.text = String (text.c_str ());
+
+                timed_lyrics.push_back (timed_line);
+            }
+        }
+    }
+
+    // 4. Apply offsets and sort chronologically (skipping the dummy title line
+    // at index 0)
+    if (timed_lyrics.size () > 1)
+    {
+        for (size_t i = 1; i < timed_lyrics.size (); ++i)
+        {
+            timed_lyrics[i].timestamp_ms -= global_offset;
+        }
+
+        std::sort (timed_lyrics.begin () + 1, timed_lyrics.end (),
+                  [](const TimedLyricLine & a, const TimedLyricLine & b) {
+                      return a.timestamp_ms < b.timestamp_ms;
+                  });
+
+        // Ensure the dummy title line stays chronologically before the first
+        // actual lyric
+        if (timed_lyrics[1].timestamp_ms <= timed_lyrics[0].timestamp_ms)
+        {
+            timed_lyrics[0].timestamp_ms = timed_lyrics[1].timestamp_ms - 1000;
+        }
+    }
+
+    // gtk_text_buffer_get_start_iter (textbuffer, & iter);
+    // gtk_text_view_scroll_to_iter (textview, & iter, 0, true, 0, 0);
 }
 
 bool try_parse_json (const Index<char> & buf, const char * key, String & output)
@@ -224,7 +331,7 @@ static GtkWidget * build_widget ()
     gtk_box_pack_start ((GtkBox *) vbox, scrollview, true, true, 0);
 
     gtk_widget_show_all (vbox);
-
+    gtk_text_buffer_create_tag (textbuffer, "highlight", "foreground", "yellow", nullptr);
     gtk_text_buffer_create_tag (textbuffer, "weight_bold", "weight", PANGO_WEIGHT_BOLD, nullptr);
     gtk_text_buffer_create_tag (textbuffer, "scale_large", "scale", PANGO_SCALE_LARGE, nullptr);
     gtk_text_buffer_create_tag (textbuffer, "style_italic", "style", PANGO_STYLE_ITALIC, nullptr);
@@ -235,6 +342,103 @@ static GtkWidget * build_widget ()
     return vbox;
 }
 
+void highlight_lyrics (int current_time_ms)
+{
+    if (!textbuffer)
+        return;
+
+    // Check if lyrics synchronization is enabled
+    if (!aud_get_bool ("lyricwiki", "sync_lyrics"))
+        return;
+
+    // Clear the text buffer
+    gtk_text_buffer_set_text (textbuffer, "", -1);
+
+    // Find the 4 lines closest to the current timestamp (current + 3 neighbors)
+    std::vector <TimedLyricLine> lines_to_display;
+
+    // Store up to 4 lines starting from the current one
+    for (size_t i = 0; i < timed_lyrics.size (); ++i)
+    {
+
+        if (timed_lyrics[i].timestamp_ms >= current_time_ms)
+        {
+            // Ensure we have the current line and its neighbors (3 more lines)
+            size_t start_index = (i > 1) ? i - 2 : 0; // Start 2 lines before the current line
+            size_t end_index = std::min (i + 2, timed_lyrics.size () - 1); // Limit to 3 more lines after
+
+            // Ensure no more than 4 lines are selected
+            size_t line_count = 0;
+
+            for (size_t j = start_index; j <= end_index && line_count < 4; ++j)
+            {
+                lines_to_display.push_back (timed_lyrics[j]);
+                line_count++;
+            }
+            break;
+        }
+    }
+
+    // Retrieve the tag table
+    GtkTextTagTable * tag_table = gtk_text_buffer_get_tag_table (textbuffer);
+
+    // Check if the enlarge tag exists, and create it if not
+    GtkTextTag * enlarge_tag =
+        gtk_text_tag_table_lookup (tag_table, "enlarge_tag");
+    if (!enlarge_tag)
+    {
+        enlarge_tag = gtk_text_tag_new ("enlarge_tag");
+        g_object_set (enlarge_tag, "scale", 1.5, NULL); // Enlarge by 1.5 times (adjust as needed)
+        gtk_text_tag_table_add (tag_table, enlarge_tag);
+    }
+
+    // Insert the selected lines into the text buffer
+    GtkTextIter iter;
+    gtk_text_buffer_get_start_iter (textbuffer, &iter);
+
+    for (size_t i = 0; i < lines_to_display.size (); ++i)
+    {
+        const TimedLyricLine & line = lines_to_display[i];
+        std::string text_with_newline = std::string (line.text);
+
+        // Special handling for the title line (dummy timestamp)
+        if (line.timestamp_ms < 0 && i == 0 &&
+            text_with_newline ==
+                static_cast <const char *> (timed_lyrics[0].text))
+        {
+            gtk_text_buffer_insert_with_tags_by_name (
+                textbuffer, &iter, text_with_newline.c_str (), -1, "weight_bold",
+                "scale_large", nullptr);
+        }
+        else if (i == 1 && line.timestamp_ms >= 0)
+        { // Current line (but not title)
+            gtk_text_buffer_insert_with_tags_by_name (textbuffer, &iter,
+                                                     text_with_newline.c_str (),
+                                                     -1, "highlight", nullptr);
+        }
+        else
+        {
+            gtk_text_buffer_insert (textbuffer, &iter, text_with_newline.c_str (), -1);
+        }
+
+        gtk_text_buffer_insert (textbuffer, &iter, "\n", -1);
+    }
+
+    // After inserting lines, force scroll to the last line
+    GtkTextIter end_iter;
+    gtk_text_buffer_get_end_iter (textbuffer, &end_iter);
+    gtk_text_view_scroll_to_iter (textview, &end_iter, 0, TRUE, 0, 0);
+}
+
+gboolean update_lyrics_display (gpointer data)
+{
+    int current_time_ms =
+        aud_drct_get_time (); // Get current time from player in ms
+    highlight_lyrics (current_time_ms);
+
+    return G_SOURCE_CONTINUE; // Continue calling this function
+}
+
 void * LyricsGtk::get_gtk_widget ()
 {
     GtkWidget * vbox = build_widget ();
@@ -246,6 +450,6 @@ void * LyricsGtk::get_gtk_widget ()
         lyrics_playback_began ();
 
     g_signal_connect (vbox, "destroy", (GCallback) destroy_cb, nullptr);
-
+    g_timeout_add (100, update_lyrics_display, nullptr);
     return vbox;
 }