v0.6

.gitignore

@@ -36,3 +36,4 @@ src/www/.vscode/settings.json
 /src/build
 /build
 .DS_Store
+/src/.qtc_clangd

src/XTEngine.pro

@@ -59,7 +59,9 @@ SOURCES += \
     lib/tool/funscriptsearch.cpp \
     lib/tool/heatmap.cpp \
     lib/tool/imagefactory.cpp \
+    lib/tool/mediaformat.cpp \
     lib/tool/medialibrarycache.cpp \
+    lib/tool/migration.cpp \
     lib/tool/qsettings_json.cpp \
     lib/tool/simplecrypt.cpp \
     lib/tool/tcodefactory.cpp \
@@ -127,15 +129,19 @@ HEADERS += \
     lib/struct/OutputConnectionPacket.h \
     lib/struct/ScriptInfo.h \
     lib/struct/SerialComboboxItem.h \
+    lib/struct/TCodeCommand.h \
     lib/struct/connection.h \
     lib/struct/device.h \
+    lib/struct/xmessage.h \
     lib/tool/array-util.h \
     lib/tool/boolinq.h \
     lib/tool/file-util.h \
     lib/tool/funscriptsearch.h \
     lib/tool/heatmap.h \
     lib/tool/imagefactory.h \
+    lib/tool/mediaformat.h \
     lib/tool/medialibrarycache.h \
+    lib/tool/migration.h \
     lib/tool/qsettings_json.h \
     lib/tool/simplecrypt.h \
     lib/tool/string-util.h \

src/XTEngine_global.h

@@ -3,7 +3,7 @@
 
 #include <QtCore/qglobal.h>
 
-#if defined(XTENGINE_LIBRARY)
+#ifdef XTENGINE_LIBRARY
 #  define XTENGINE_EXPORT Q_DECL_EXPORT
 #else
 #  define XTENGINE_EXPORT Q_DECL_IMPORT

src/lib/handler/connectionhandler.cpp

@@ -129,6 +129,13 @@ void ConnectionHandler::sendTCode(QString tcode)
         m_outputConnection->sendTCode(tcode);
 }
 
+void ConnectionHandler::delayTCode(QString tcode, int delayMS)
+{
+    QTimer::singleShot(delayMS, [this, tcode]() {
+        sendTCode(tcode);
+    });
+}
+
 void ConnectionHandler::stopOutputConnection()
 {
     sendTCode("DSTOP");

src/lib/handler/connectionhandler.h

@@ -44,6 +44,7 @@ private slots:
     explicit ConnectionHandler(QObject *parent = nullptr);
     void init();
     void sendTCode(QString tcode);
+    void delayTCode(QString tcode, int delayMS);
     void stopOutputConnection();
 
     bool isOutputConnected();

src/lib/handler/funscripthandler.cpp

@@ -291,28 +291,57 @@ const QList<Track> FunscriptHandler::getLoaded()
     return m_funscripts.keys();
 }
 
-std::shared_ptr<FunscriptAction> FunscriptHandler::getPosition(const Track& channelName, const qint64& at)
+int lastOffset = -1;
+///
+/// \brief FunscriptHandler::getPosition
+/// This method finds the action to execute to move to the next point in the script.
+/// This point is in the future so wehn the previous action has finished executing
+/// over the interval of time, the next action will start
+/// \param channelName the track you need to fine the position via the media time
+/// \param at The current media time
+/// \param offset Shift the time before or after the actual time.
+/// negative values is before so the current time is 100 and you shift -10 then the time will be 90
+/// \return nullptr if no action is ready to be executed
+///
+std::shared_ptr<FunscriptAction> FunscriptHandler::getPosition(const Track& channelName, const qint64& at, const int offset)
 {
     QMutexLocker locker(&mutex);
-    qint64 millis = at + getOffSet();
+    int offsetLocal =  offset ?: getOffSet();
+    if(lastOffset != offsetLocal) {
+        lastOffset = offsetLocal;
+        LogHandler::Debug("FunscriptHandler::getPosition offset changed: "+ QString::number(offsetLocal));
+    }
+    qint64 millis = at + offsetLocal;
     if(!m_funscripts.contains(channelName))
         return nullptr;
     Funscript* funscript = &m_funscripts[channelName];
     auto atList = funscript->settings.atList;
     qint64 closestMillis = findClosest(millis, atList);
     if(closestMillis == -1)
         return nullptr;
-    funscript->settings.nextActionIndex = atList.indexOf(closestMillis) + 1;
-    if(funscript->settings.nextActionIndex >= atList.length())
+    qint64 closestIndex = atList.indexOf(closestMillis);
+    qint64 nextAction = closestIndex + 1;
+    // We are still moving to the next funcript point.
+    if(funscript->settings.lastActionIndex == nextAction)
+        return nullptr;
+    // We are at the end of the funscript points.
+    if(nextAction >= atList.length())
         return nullptr;
-    qint64 nextMillis = atList[funscript->settings.nextActionIndex];
     //LogHandler::Debug("millis: "+ QString::number(millis));
     //LogHandler::Debug("closestMillis: "+ QString::number(closestMillis));
     //LogHandler::Debug("lastActionIndex: "+ QString::number(lastActionIndex));
+    //LogHandler::Debug("nextAction: "+ QString::number(nextAction));
     //LogHandler::Debug("nextActionIndex: "+ QString::number(nextActionIndex));
 //    LogHandler::Debug("nextMillis: "+ QString::number(nextMillis));
-    if ((funscript->settings.lastActionIndex != funscript->settings.nextActionIndex && millis >= closestMillis) || funscript->settings.lastActionIndex == -1)
+    if (millis >= closestMillis || funscript->settings.lastActionIndex == -1)
     {
+        // if(nextAction != funscript->settings.nextActionIndex)
+        // {
+        //     LogHandler::Warn("Potential action skip nextActionIndex: "+ QString::number(funscript->settings.nextActionIndex) + ", closestIndex: "+ QString::number(closestIndex));
+        //     LogHandler::Warn("at: " + QString::number(closestMillis) + ", pos: "+QString::number(funscript->actions.value(closestMillis)));
+        // }
+        qint64 currentIndex = nextAction;
+        qint64 nextMillis = atList[nextAction];
         int interval = funscript->settings.lastActionIndex == -1 ? closestMillis : nextMillis - closestMillis;
         if(!_firstActionExecuted)
         {
@@ -330,28 +359,28 @@ std::shared_ptr<FunscriptAction> FunscriptHandler::getPosition(const Track& chan
 //        LogHandler::Debug("lastActionIndex: "+ QString::number(lastActionIndex));
 //        LogHandler::Debug("nextActionIndex: "+ QString::number(nextActionIndex));
         //LogHandler::Debug("nextActionPos: "+ QString::number(funscript->actions.value(nextMillis)));
-        qint64 executionMillis = funscript->settings.lastActionIndex == -1 ? closestMillis : nextMillis;
-        int pos = funscript->actions.value(executionMillis);
+        qint64 currentMillis = funscript->settings.lastActionIndex == -1 ? closestMillis : nextMillis;
+        int currentPos = funscript->actions.value(currentMillis);
         if(funscript->settings.lastActionIndex > -1 && funscript->settings.modifier != 1)
         {
-            if(pos == funscript->settings.lastActionPos && funscript->settings.lastActionPosModified)
+            if(currentPos == funscript->settings.lastActionPos && funscript->settings.lastActionPosModified)
             {
-                pos = funscript->settings.lastActionPosModified;
+                currentPos = funscript->settings.lastActionPosModified;
                 if(funscript->settings.channel == Track::Stroke)
-                    LogHandler::Debug(funscript->settings.trackName + " Modified pos unchanged: "+QString::number(pos));
+                    LogHandler::Debug(funscript->settings.trackName + " Modified pos unchanged: "+QString::number(currentPos));
             }
             else
             {
-                int ogPos = pos;
-                double distance = pos - funscript->settings.lastActionPos;
+                int ogPos = currentPos;
+                double distance = currentPos - funscript->settings.lastActionPos;
                 double amplitude = distance / 2.0;
                 if(funscript->settings.modifier > 1)
                 {
-                    pos = qRound(pos + (amplitude * (funscript->settings.modifier - 1)));
+                    currentPos = qRound(currentPos + (amplitude * (funscript->settings.modifier - 1)));
                 }
                 else if(funscript->settings.modifier > 0)
                 {
-                    pos = qRound(pos - (amplitude * (1 - funscript->settings.modifier)));
+                    currentPos = qRound(currentPos - (amplitude * (1 - funscript->settings.modifier)));
                 }
                 // double modifier = funscript->settings.modifier;
                 // if(modifier > 1 )
@@ -367,32 +396,45 @@ std::shared_ptr<FunscriptAction> FunscriptHandler::getPosition(const Track& chan
                 // {
                 //     pos = qRound(pos - (modifier * 100));// Subtract % from the top end (current position)
                 // }
-                pos = XMath::constrain(pos, 0, 100);
-                funscript->settings.lastActionPosModified = pos;
+                currentPos = XMath::constrain(currentPos, 0, 100);
+                funscript->settings.lastActionPosModified = currentPos;
                 if(funscript->settings.channel == Track::Stroke)
                 {
                     LogHandler::Debug(funscript->settings.trackName + " Modifier: "+QString::number(funscript->settings.modifier));
                     LogHandler::Debug(funscript->settings.trackName + " last pos: "+QString::number(funscript->settings.lastActionPos));
                     LogHandler::Debug(funscript->settings.trackName + " pos: "+QString::number(ogPos));
                     LogHandler::Debug(funscript->settings.trackName + " distance: "+QString::number(distance));
                     // LogHandler::Debug(funscript->settings.trackName + " amplitude: "+QString::number(amplitude));
-                    LogHandler::Debug(funscript->settings.trackName + " Modified pos: "+QString::number(pos));
+                    LogHandler::Debug(funscript->settings.trackName + " Modified pos: "+QString::number(currentPos));
                 }
             }
         }
-        qreal speedmodifier = XMediaStateHandler::getPlaybackSpeed();
-        if(speedmodifier > 0 && speedmodifier != 1.0 && speedmodifier < 2.0)
+
+        calculateSpeedModifier(interval);
+
+        int nextIndex = currentIndex + 1;
+        // int nextNextIndex = funscript->settings.nextActionIndex + 2;
+        if(nextIndex < atList.length())
+        {
+            qint64 nextActionMillis = atList[nextIndex];
+            // qint64 nextNextActionMillis = atList[nextNextIndex];
+            funscript->settings.nextActionPos = funscript->actions.value(nextActionMillis);
+            funscript->settings.nextActionInterval = nextActionMillis - currentMillis;
+            calculateSpeedModifier(funscript->settings.nextActionInterval);
+        }
+        else
         {
-            LogHandler::Debug("interval before: "+ QString::number(interval));
-            interval = round(speedmodifier < 1.0 ? interval / speedmodifier :
-                                  interval - ((interval * speedmodifier) - interval));
-            LogHandler::Debug("interval after: "+ QString::number(interval));
+            funscript->settings.nextActionPos = -1;
+            funscript->settings.nextActionInterval = -1;
         }
-        std::shared_ptr<FunscriptAction> nextAction(new FunscriptAction { funscript->settings.trackName, executionMillis, pos, interval, funscript->settings.lastActionPos, funscript->settings.lastActionInterval });
+
+        std::shared_ptr<FunscriptAction> nextAction(new FunscriptAction { funscript->settings.trackName, currentMillis, currentPos, interval, funscript->settings.lastActionPos, funscript->settings.lastActionInterval, funscript->settings.nextActionPos, funscript->settings.nextActionInterval, currentIndex });
         //LogHandler::Debug("nextAction.speed: "+ QString::number(nextAction->speed));
-        funscript->settings.lastActionIndex = funscript->settings.nextActionIndex;
-        funscript->settings.lastActionPos = funscript->actions.value(executionMillis);
+        funscript->settings.lastActionIndex = currentIndex;
+        funscript->settings.lastActionPos = funscript->actions.value(currentMillis);
         funscript->settings.lastActionInterval = interval;
+        funscript->settings.nextActionIndex = currentIndex + 1;
+
         return nextAction;
     }
     return nullptr;
@@ -468,6 +510,18 @@ qint64 FunscriptHandler::findClosest(const qint64& value, const QList<qint64>& a
     return (a[lo] - value) < (value - a[hi]) ? a[lo] : a[hi];
 }
 
+void FunscriptHandler::calculateSpeedModifier(int& interval)
+{
+    qreal speedmodifier = XMediaStateHandler::getPlaybackSpeed();
+    if(speedmodifier > 0 && speedmodifier != 1.0 && speedmodifier < 2.0)
+    {
+        LogHandler::Debug("interval before: "+ QString::number(interval));
+        interval = round(speedmodifier < 1.0 ? interval / speedmodifier :
+                             interval - ((interval * speedmodifier) - interval));
+        LogHandler::Debug("interval after: "+ QString::number(interval));
+    }
+}
+
 
 //static
 
@@ -526,7 +580,7 @@ double FunscriptHandler::getModifier(const Track& channelName)
 void FunscriptHandler::updateMetadata(LibraryListItemMetaData258 value)
 {
     setModifier(value.funscriptModifier);
-    setOffset(value.offset);
+    setScriptOffset(value.offset);
 }
 
 void FunscriptHandler::resetModifier(const Track& channelName)
@@ -535,13 +589,33 @@ void FunscriptHandler::resetModifier(const Track& channelName)
 }
 
 int FunscriptHandler::getOffSet()
+{
+    return m_offset ?: m_globalOffset;
+}
+
+int FunscriptHandler::getScriptOffSet()
 {
     return m_offset;
 }
 
-void FunscriptHandler::setOffset(int value)
+void FunscriptHandler::setScriptOffset(int value)
+{
+    m_offset = value;
+}
+
+void FunscriptHandler::setGlobalOffset(int value)
+{
+    m_globalOffset = value;
+}
+
+void FunscriptHandler::setGlobalOffsetWeb(int value)
+{
+    m_globalOffsetWeb = value;
+}
+
+int FunscriptHandler::getGlobalOffsetWeb()
 {
-    m_offset = value ? value : SettingsHandler::getoffSet();
+    return m_globalOffsetWeb;
 }
 
 QList<ScriptInfo> FunscriptHandler::getSFMATracks(QString libraryItemMediaPath)

src/lib/handler/funscripthandler.h

@@ -38,7 +38,7 @@ public slots:
     qint64 getMin(const Track& channelName) const;
     qint64 getMax(const Track& channelName) const;
     qint64 getNext(const Track& channelName) const;
-    std::shared_ptr<FunscriptAction> getPosition(const Track& channelName, const qint64& at);
+    std::shared_ptr<FunscriptAction> getPosition(const Track& channelName, const qint64& at, const int offset = 0);
 
     void play(QString funscript);
     void stop();
@@ -53,7 +53,11 @@ public slots:
     static void resetModifier();
     static void resetModifier(const Track& channelName);
     static int getOffSet();
-    static void setOffset(int value);
+    static int getScriptOffSet();
+    static void setScriptOffset(int value);
+    static void setGlobalOffset(int value);
+    static void setGlobalOffsetWeb(int value);
+    static int getGlobalOffsetWeb();
     static void resetOffset(int value);
 
     static bool isSFMA(QString libraryItemMediaPath);
@@ -69,6 +73,8 @@ public slots:
     bool m_loaded = false;
     bool _firstActionExecuted;
     static inline int m_offset;
+    static inline int m_globalOffset;
+    static inline int m_globalOffsetWeb;
     static QByteArray readFile(QString file);
     static QJsonObject readJson(QByteArray data);
     void jsonToFunscript(QJsonObject json);
@@ -77,6 +83,7 @@ public slots:
     void jsonToFunscript(const QJsonObject& json, QHash<qint64, int>& actions);
     void setFunscriptSettings(const Track& channelName, Funscript& funscript);
     qint64 findClosest(const qint64& value, const QList<qint64>& a);
+    void calculateSpeedModifier(int& interval);
 };
 
 #endif // FUNSCRIPTHANDLER_H