Support for the improved lrc format has been added.

Priority has been given to the first stave and the first voices.
Tests have been added.

Author: pacebes

src/importexport/lyricsexport/CMakeLists.txt

@@ -41,3 +41,6 @@ endif()
 
 setup_module()
 
+if (MUE_BUILD_IMPORTEXPORT_TESTS)
+    add_subdirectory(tests)
+endif()

src/importexport/lyricsexport/internal/iex_lyricsexport.cpp

@@ -20,15 +20,18 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-#include "iex_lyricsexport.h"
+#include "io/file.h"
 
 #include <QBuffer>
 
 #include "engraving/dom/masterscore.h"
 #include "engraving/dom/repeatlist.h"
 #include "engraving/dom/lyrics.h"
 
+#include "iex_lyricsexport.h"
+
 using namespace mu::engraving;
+using namespace muse::io;
 
 namespace mu::iex::lrcexport {
 // Interface implementation
@@ -37,43 +40,65 @@ std::vector<project::INotationWriter::UnitType> LRCWriter::supportedUnitTypes()
     return { UnitType::PER_PART };
 }
 
+//
+// LRCWriter::supportsUnitType
+//
+
 bool LRCWriter::supportsUnitType(UnitType ut) const { return ut == UnitType::PER_PART; }
 
+//
+// LRCWriter::write
+//
+
 muse::Ret LRCWriter::write(notation::INotationPtr notation, muse::io::IODevice& device, const Options&)
 {
     Score* score = notation->elements()->msScore();
-    QByteArray data;
-    QBuffer buffer(&data);
-    bool enhancedFormat = configuration()->lrcUseEnhancedFormat();
+    bool enhancedLrc = configuration()->lrcUseEnhancedFormat();
 
-    /***********
-    *
-    * PENDING....
-    Is there any advantage to writing to a buffer first, and then writing that buffer to the device? It would seem more efficient to me to write to the device directly.
-
-    ******/
+    return write(score, &device, enhancedLrc);
+}
 
-    buffer.open(QIODevice::WriteOnly);
+//
+// LRCWriter::exportLrc
+//
 
-    writeMetadata(buffer, score);
+bool LRCWriter::exportLrc(mu::engraving::Score* score, muse::io::IODevice* device, bool enhancedLrc)
+{
+    write(score, device, enhancedLrc);
+    return true;
+}
 
-    const auto lyrics = collectLyrics(score);
+//
+// LRCWriter::writeScore
+//
 
-    // Write lyrics
-    for (auto it = lyrics.constBegin(); it != lyrics.constEnd(); ++it) {
-        buffer.write(QString("[%1]%2\n").arg(formatTimestamp(it.key()), it.value()).toUtf8());
+bool LRCWriter::writeScore(mu::engraving::Score* score, const muse::io::path_t& path, bool enhancedLrc)
+{
+    File f(path);
+    if (!f.open(IODevice::WriteOnly)) {
+        return false;
     }
 
-    device.write(data);
-    return muse::Ret(muse::Ret::Code::Ok);
+    bool res = exportLrc(score, &f, enhancedLrc) && !f.hasError();
+    f.close();
+
+    return res;
 }
 
+//
+// LRCWriter::writeList
+//
+
 muse::Ret LRCWriter::writeList(const notation::INotationPtrList&, muse::io::IODevice&, const Options&)
 {
     return muse::Ret(muse::Ret::Code::NotSupported);
 }
 
-void LRCWriter::writeMetadata(QIODevice& device, const engraving::Score* score) const
+//
+// LRCWriter::writeMetadata
+//
+
+void LRCWriter::writeMetadata(muse::io::IODevice* device, const engraving::Score* score) const
 {
     QString metadata;
 
@@ -90,69 +115,80 @@ void LRCWriter::writeMetadata(QIODevice& device, const engraving::Score* score)
     }
 
     if (!metadata.isEmpty()) {
-        device.write(metadata.toUtf8());
+        device->write(metadata.toUtf8());
     }
 }
 
-// Core lyric collection (simplified)
-QMap<qreal, QString> LRCWriter::collectLyrics(const Score* score) const
+//
+// LRCWriter::write
+//
+
+muse::Ret LRCWriter::write(mu::engraving::Score* score, muse::io::IODevice* device, bool enhancedLrc)
 {
-    QMap<qreal, QString> lyrics;
-    const RepeatList& repeats = score->repeatList();
+    writeMetadata(device, score);
 
-    LOGI() << "tpacebes ";
+    const auto lyrics = collectLyrics(score);
 
-    int paabRepeatSegment = 0;
+    // Write lyrics
+    for (auto it = lyrics.constBegin(); it != lyrics.constEnd(); ++it) {
+        if (enhancedLrc) {
+            // As there should only be words we replace spaces by "-"
+            QString lyricsText = it.value();
+            lyricsText.replace(QRegularExpression("\\s"), "-");
+            lyricsText.replace(QChar(0x00A0), QChar('-'));
+
+            device->write(QString("[%1] <%1> %2\n").arg(formatTimestamp(it.key()), lyricsText).toUtf8());
+        } else {
+            device->write(QString("[%1]%2\n").arg(formatTimestamp(it.key()), it.value()).toUtf8());
+        }
+    }
 
-    for (const RepeatSegment* rs : repeats) {
-        const int tickOffset = rs->utick - rs->tick;
+    return muse::Ret(muse::Ret::Code::Ok);
+}
 
-        ++paabRepeatSegment;
+//
+// LRCWriter::collectLyrics
+//
 
-        LOGI() << "tpacebes repeat segment " << paabRepeatSegment;
+QMap<qreal, QString> LRCWriter::collectLyrics(const mu::engraving::Score* score)
+{
+    QMap<qreal, QString> lyrics;
+    const RepeatList& repeats = score->repeatList();
 
-        int paabMeasureBase = 0;
+    staff_idx_t lyricsStaff;
+    voice_idx_t lyricsVoice;
+    int lyricNumber;
 
-        for (const MeasureBase* mb = rs->firstMeasure(); mb; mb = mb->next()) {
+    findStaffVoiceAndLyricToExport(score, lyricsStaff, lyricsVoice, lyricNumber);
 
-            ++paabMeasureBase;
+    for (const RepeatSegment* rs : repeats) {
+        const int tickOffset = rs->utick - rs->tick;
 
+        for (const MeasureBase* mb = rs->firstMeasure(); mb; mb = mb->next()) {
             if (!mb->isMeasure()) {
                 continue;
             }
 
-            LOGI() << "tpacebes measure base " << paabMeasureBase;
-
-            int paabSegment = 0;
             for (Segment* seg = toMeasure(mb)->first(); seg; seg = seg->next()) {
-                ++paabSegment;
                 if (!seg->isChordRestType()) {
                     continue;
                 }
 
-                LOGI() << "tpacebes paabSegment " << paabSegment;
-
-                int paabEngravingItem = 0;
                 for (EngravingItem* e : seg->elist()) {
-                    ++paabEngravingItem;
                     if (!e || !e->isChordRest()) {
                         continue;
                     }
 
-                    LOGI() << "tpacebes paabEngravingItem " << paabEngravingItem;
-
-                    int paabLyrics = 0;
                     for (Lyrics* l : toChordRest(e)->lyrics()) {
-                        ++paabLyrics;
                         // if (l->text().empty())
                         if (l->plainText().isEmpty()) {
                             continue;
                         }
-                        LOGI() << "tpacebes paabLyrics " << paabLyrics;
 
-                        const qreal time = score->utick2utime(l->tick().ticks() + tickOffset) * 1000;
-                        lyrics.insert(time, l->plainText());
-                        LOGI() << "tpacebes insertamos Time " << time << "==>" << l->plainText() << "<==";
+                        if ((lyricsStaff == e->staffIdx()) && (lyricsVoice == e->voice()) && (lyricNumber == l->subtype())) {
+                            const qreal time = score->utick2utime(l->tick().ticks() + tickOffset) * 1000;
+                            lyrics.insert(time, l->plainText());
+                        }
                     }
                 }
             }
@@ -161,6 +197,10 @@ QMap<qreal, QString> LRCWriter::collectLyrics(const Score* score) const
     return lyrics;
 }
 
+//
+// LRCWriter::formatTimestamp
+//
+
 QString LRCWriter::formatTimestamp(qreal ms) const
 {
     const int totalSec = static_cast<int>(ms / 1000);
@@ -169,4 +209,68 @@ QString LRCWriter::formatTimestamp(qreal ms) const
            .arg(totalSec % 60, 2, 10, QLatin1Char('0'))
            .arg(static_cast<int>(ms) % 1000 / 10, 2, 10, QLatin1Char('0'));
 }
+
+//
+// LRCWriter::findStaffVoiceAndLyricToExport
+//
+
+void LRCWriter::findStaffVoiceAndLyricToExport(const mu::engraving::Score* score, mu::engraving::staff_idx_t& staff,
+                                               mu::engraving::voice_idx_t& voice, int& lyricNumber)
+{
+    bool lyricsFound = false;
+    staff = 0;
+    voice = 0;
+    lyricNumber = 0;
+
+    const RepeatList& repeats = score->repeatList();
+
+    for (const RepeatSegment* rs : repeats) {
+        const int tickOffset = rs->utick - rs->tick;
+
+        for (const MeasureBase* mb = rs->firstMeasure(); mb; mb = mb->next()) {
+            if (!mb->isMeasure()) {
+                continue;
+            }
+
+            for (Segment* seg = toMeasure(mb)->first(); seg; seg = seg->next()) {
+                if (!seg->isChordRestType()) {
+                    continue;
+                }
+
+                for (EngravingItem* e : seg->elist()) {
+                    if (!e || !e->isChordRest()) {
+                        continue;
+                    }
+
+                    for (Lyrics* l : toChordRest(e)->lyrics()) {
+                        // if (l->text().empty())
+                        if (l->plainText().isEmpty()) {
+                            continue;
+                        } else {
+                            if (!lyricsFound) {
+                                lyricsFound = true;
+                                staff = e->staffIdx();
+                                voice = e->voice();
+                                lyricNumber = l->subtype();
+                            } else {
+                                if (staff > e->staffIdx()) {
+                                    staff = e->staffIdx();
+                                    voice = e->voice();
+                                    lyricNumber = l->subtype();
+                                } else if (staff == e->staffIdx()) {
+                                    if (voice > e->voice()) {
+                                        voice = e->voice();
+                                        lyricNumber = l->subtype();
+                                    } else if (voice == e->voice()) {
+                                        lyricNumber = min(lyricNumber, l->subtype());
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
 } // namespace mu::iex::lrcexport

src/importexport/lyricsexport/internal/iex_lyricsexport.h

@@ -25,7 +25,9 @@
 #include <QIODevice>
 
 #include "project/inotationwriter.h"
-#include "../ilyricsexportconfiguration.h"
+#include "engraving/engravingerrors.h"
+
+#include "importexport/lyricsexport/ilyricsexportconfiguration.h"
 
 namespace mu::engraving {
 class Score;
@@ -35,19 +37,23 @@ namespace mu::iex::lrcexport {
 class LRCWriter : public project::INotationWriter
 {
 public:
-    INJECT_STATIC(mu::iex::lrcexport::LyricsExportConfiguration, configuration)
+    INJECT_STATIC(mu::iex::lrcexport::ILyricsExportConfiguration, configuration)
 
 public:
     // Interface implementation
     std::vector<UnitType> supportedUnitTypes() const override;
     bool supportsUnitType(UnitType) const override;
     muse::Ret write(notation::INotationPtr, muse::io::IODevice&, const Options&) override;
-    void writeMetadata(QIODevice& device, const engraving::Score* score) const;
+    void writeMetadata(muse::io::IODevice* device, const engraving::Score* score) const;
     muse::Ret writeList(const notation::INotationPtrList&, muse::io::IODevice&, const Options&) override;
+    bool writeScore(mu::engraving::Score* score, const muse::io::path_t& path, bool enhancedLrc);
 
 private:
+    muse::Ret write(mu::engraving::Score* score, muse::io::IODevice*, bool);
     // Core lyric functionality
-    QMap<qreal, QString> collectLyrics(const engraving::Score*) const;
+    QMap<qreal, QString> collectLyrics(const mu::engraving::Score*);
     QString formatTimestamp(qreal ms) const;
+    bool exportLrc(mu::engraving::Score*, muse::io::IODevice*, bool);
+    void findStaffVoiceAndLyricToExport(const mu::engraving::Score*, mu::engraving::staff_idx_t&, mu::engraving::voice_idx_t&, int&);
 };
 } // namespace mu::iex::lrcexport

src/importexport/lyricsexport/internal/lyricsexportconfiguration.cpp

@@ -35,7 +35,7 @@ static const Settings::Key LRC_USE_ENHANCED_FORMAT_KEY(module_name, "export/lrc/
 
 void LyricsExportConfiguration::init()
 {
-    settings()->setDefaultValue(LRC_USE_ENHANCED_FORMAT_KEY, Val(false));
+    settings()->setDefaultValue(LRC_USE_ENHANCED_FORMAT_KEY, Val(true));
 }
 
 async::Channel<bool> LyricsExportConfiguration::lrcUseEnhancedFormatChanged() const

src/importexport/lyricsexport/tests/CMakeLists.txt

@@ -0,0 +1,41 @@
+# SPDX-License-Identifier: GPL-3.0-only
+# MuseScore-Studio-CLA-applies
+#
+# MuseScore Studio
+# Music Composition & Notation
+#
+# Copyright (C) 2021 MuseScore Limited
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 3 as
+# published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+set(MODULE_TEST iex_lyricsexport_tests)
+
+set(MODULE_TEST_SRC
+    ${PROJECT_SOURCE_DIR}/src/engraving/tests/utils/scorerw.cpp
+    ${PROJECT_SOURCE_DIR}/src/engraving/tests/utils/scorerw.h
+    ${PROJECT_SOURCE_DIR}/src/engraving/tests/utils/scorecomp.cpp
+    ${PROJECT_SOURCE_DIR}/src/engraving/tests/utils/scorecomp.h
+
+    ${CMAKE_CURRENT_LIST_DIR}/environment.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/lrc_tests.cpp
+)
+
+set(MODULE_TEST_LINK
+    engraving
+    iex_lyricsexport
+    )
+
+set(MODULE_TEST_DATA_ROOT ${CMAKE_CURRENT_LIST_DIR})
+
+include(SetupGTest)
+