src/player/playeradapter: make tracks values rather than pointers

ripose-jp · ripose-jp · commit d51a7f19d4b3 · 2025-05-18T22:33:41.000-07:00
Make tracks allocated in QList rather than allocated invididually. This
should simplify memory mangement since it isn't necessary.
diff --git a/src/gui/widgets/overlay/playermenu.cpp b/src/gui/widgets/overlay/playermenu.cpp
@@ -161,13 +161,8 @@ PlayerMenu::PlayerMenu(QPointer<Context> context, QWidget *parent) :
         m_context, &Context::playerFileLoaded, this,
         [this]
         {
-            QList<const Track *> tracks =
-                m_context->getPlayerAdapter()->getTracks();
+            QList<Track> tracks = m_context->getPlayerAdapter()->getTracks();
             setTracks(tracks);
-            for (const Track *track : tracks)
-            {
-                delete track;
-            }
         }
     );
 
@@ -395,19 +390,19 @@ void PlayerMenu::clearTracks()
 
 #define MAX_LENGTH 45
 
-QAction *PlayerMenu::createTrackAction(const Track *track) const
+QAction *PlayerMenu::createTrackAction(const Track &track) const
 {
     QAction *action = new QAction;
     action->setCheckable(true);
 
-    QString actionText = "Track " + QString::number(track->id);
-    if (!track->lang.isEmpty())
+    QString actionText = "Track " + QString::number(track.id);
+    if (!track.lang.isEmpty())
     {
-        actionText += " [" + track->lang + "]";
+        actionText += " [" + track.lang + "]";
     }
-    if (!track->title.isEmpty())
+    if (!track.title.isEmpty())
     {
-        actionText += " - " + track->title;
+        actionText += " - " + track.title;
     }
     if (actionText.length() > MAX_LENGTH)
     {
@@ -421,26 +416,26 @@ QAction *PlayerMenu::createTrackAction(const Track *track) const
 
 #undef MAX_LENGTH
 
-void PlayerMenu::setTracks(const QList<const Track *> &tracks)
+void PlayerMenu::setTracks(const QList<Track> &tracks)
 {
     clearTracks();
 
     m_actionGroups.audio->blockSignals(true);
     m_actionGroups.subtitle->blockSignals(true);
     m_actionGroups.subtitleTwo->blockSignals(true);
 
-    for (const Track *track : tracks)
+    for (const Track &track : tracks)
     {
         QAction *action = createTrackAction(track);
-        const int64_t id = track->id;
-        switch (track->type)
+        const int64_t id = track.id;
+        switch (track.type)
         {
         case Track::Type::audio:
             m_ui->menuAudio->addAction(action);
             action->setActionGroup(m_actionGroups.audio);
             m_actionGroups.audioActions.append(action);
 
-            if (track->selected)
+            if (track.selected)
             {
                 action->setChecked(true);
                 m_ui->actionAudioNone->setChecked(false);
@@ -469,13 +464,13 @@ void PlayerMenu::setTracks(const QList<const Track *> &tracks)
             actionSubTwo->setActionGroup(m_actionGroups.subtitleTwo);
             m_actionGroups.subtitleTwoActions.append(actionSubTwo);
 
-            if (track->selected && track->mainSelection == 0)
+            if (track.selected && track.mainSelection == 0)
             {
                 action->setChecked(true);
                 m_ui->actionSubtitleNone->setChecked(false);
                 actionSubTwo->setEnabled(false);
             }
-            else if (track->selected && track->mainSelection == 1)
+            else if (track.selected && track.mainSelection == 1)
             {
                 actionSubTwo->setChecked(true);
                 m_ui->actionSubtitleTwoNone->setChecked(false);
diff --git a/src/gui/widgets/overlay/playermenu.h b/src/gui/widgets/overlay/playermenu.h
@@ -93,7 +93,7 @@ private Q_SLOTS:
      * Updates the menu with the currently available tracks.
      * @param tracks A list of the currently available tracks.
      */
-    void setTracks(const QList<const Track *> &tracks);
+    void setTracks(const QList<Track> &tracks);
 
     /**
      * Changes audio track to the one specified.
@@ -196,7 +196,7 @@ private Q_SLOTS:
      * @param track The track to create an action for.
      * @return A QAction corresponding to the track. Belongs to the caller.
      */
-    QAction *createTrackAction(const Track *track) const;
+    QAction *createTrackAction(const Track &track) const;
 
     /**
      * Toggles pausing on subtitle end in response to the menu option.
diff --git a/src/gui/widgets/subtitlelistwidget.cpp b/src/gui/widgets/subtitlelistwidget.cpp
@@ -342,13 +342,8 @@ void SubtitleListWidget::initRegex()
 
     if (m_context->getPlayerAdapter())
     {
-        QList<const Track *> tracks =
-            m_context->getPlayerAdapter()->getTracks();
+        QList<Track> tracks = m_context->getPlayerAdapter()->getTracks();
         handleTracklistChange(tracks);
-        for (const Track *track : tracks)
-        {
-            delete track;
-        }
     }
 }
 
@@ -417,33 +412,32 @@ void SubtitleListWidget::resizeEvent(QResizeEvent *event)
 /* End Event Handlers */
 /* Begin Adder Methods */
 
-void SubtitleListWidget::handleTracklistChange(
-    const QList<const Track *> &tracks)
+void SubtitleListWidget::handleTracklistChange(const QList<Track> &tracks)
 {
     int64_t primarySid = -1;
     int64_t secondarySid = -1;
     QStringList extTracks;
     QList<int64_t> extSids;
-    for (const Track *track : tracks)
+    for (const Track &track : tracks)
     {
-        if (track->type == Track::subtitle)
+        if (track.type == Track::subtitle)
         {
-            if (track->selected)
+            if (track.selected)
             {
-                if (track->mainSelection == 0)
+                if (track.mainSelection == 0)
                 {
-                    primarySid = track->id;
+                    primarySid = track.id;
                 }
                 else
                 {
-                    secondarySid = track->id;
+                    secondarySid = track.id;
                 }
             }
 
-            if (track->external)
+            if (track.external)
             {
-                extTracks << track->externalFilename;
-                extSids << track->id;
+                extTracks.emplaceBack(track.externalFilename);
+                extSids.emplaceBack(track.id);
             }
         }
     }
diff --git a/src/gui/widgets/subtitlelistwidget.h b/src/gui/widgets/subtitlelistwidget.h
@@ -153,8 +153,9 @@ private Q_SLOTS:
 
     /**
      * Handles the track list changing.
+     * @param tracks The new tracklist.
      */
-    void handleTracklistChange(const QList<const Track *> &tracks);
+    void handleTracklistChange(const QList<Track> &tracks);
 
     /**
      * Refreshes the contents of the subtitle list.
diff --git a/src/player/mpvadapter.cpp b/src/player/mpvadapter.cpp
@@ -62,12 +62,8 @@ MpvAdapter::MpvAdapter(
         m_mpv, &MpvWidget::tracklistChanged, this,
         [this] (const mpv_node *node)
         {
-            QList<const Track *> tracks = processTracks(node);
+            QList<Track> tracks = processTracks(node);
             emit m_context->playerTracksChanged(tracks);
-            for (const Track *track : tracks)
-            {
-                delete track;
-            }
         }
     );
     connect(
@@ -493,15 +489,15 @@ double MpvAdapter::getAudioDelay() const
     return delay;
 }
 
-QList<const Track *> MpvAdapter::getTracks()
+QList<Track> MpvAdapter::getTracks()
 {
     mpv_node node;
     if (mpv_get_property(m_handle, "track-list", MPV_FORMAT_NODE, &node) < 0)
     {
         qDebug() << "Could not get track-list property";
-        return QList<const Track *>();
+        return {};
     }
-    QList<const Track *> tracks = processTracks(&node);
+    QList<Track> tracks = processTracks(&node);
     mpv_free_node_contents(&node);
     return tracks;
 }
@@ -1251,88 +1247,113 @@ void MpvAdapter::mouseWheelMoved(const QWheelEvent *event)
 
 /* Code modified from loadTracks() */
 /* https://github.com/u8sand/Baka-MPlayer/blob/master/src/mpvhandler.cpp */
-QList<const Track *> MpvAdapter::processTracks(const mpv_node *node)
+QList<Track> MpvAdapter::processTracks(const mpv_node *node)
 {
-    QList<const Track *> tracks;
+    QList<Track> tracks;
     if (node->format == MPV_FORMAT_NODE_ARRAY)
     {
         for (int i = 0; i < node->u.list->num; i++)
         {
-            Track *track = new Track;
+            tracks.emplaceBack(Track{});
             if (node->u.list->values[i].format == MPV_FORMAT_NODE_MAP)
             {
                 for (int n = 0; n < node->u.list->values[i].u.list->num; n++)
                 {
                     if (QString(node->u.list->values[i].u.list->keys[n]) == "id")
                     {
                         if (node->u.list->values[i].u.list->values[n].format == MPV_FORMAT_INT64)
-                            track->id = node->u.list->values[i].u.list->values[n].u.int64;
+                            tracks.back().id = node->u.list->values[i].u.list->values[n].u.int64;
                     }
                     else if (QString(node->u.list->values[i].u.list->keys[n]) == "type")
                     {
                         if (node->u.list->values[i].u.list->values[n].format == MPV_FORMAT_STRING)
                         {
                             QString type = node->u.list->values[i].u.list->values[n].u.string;
                             if (type == "audio")
-                                track->type = Track::Type::audio;
+                            {
+                                tracks.back().type = Track::Type::audio;
+                            }
                             else if (type == "video")
-                                track->type = Track::Type::video;
+                            {
+                                tracks.back().type = Track::Type::video;
+                            }
                             else if (type == "sub")
-                                track->type = Track::Type::subtitle;
+                            {
+                                tracks.back().type = Track::Type::subtitle;
+                            }
                         }
                     }
                     else if (QString(node->u.list->values[i].u.list->keys[n]) == "src-id")
                     {
                         if (node->u.list->values[i].u.list->values[n].format == MPV_FORMAT_INT64)
-                            track->srcId = node->u.list->values[i].u.list->values[n].u.int64;
+                        {
+                            tracks.back().srcId = node->u.list->values[i].u.list->values[n].u.int64;
+                        }
                     }
                     else if (QString(node->u.list->values[i].u.list->keys[n]) == "title")
                     {
                         if (node->u.list->values[i].u.list->values[n].format == MPV_FORMAT_STRING)
-                            track->title = node->u.list->values[i].u.list->values[n].u.string;
+                        {
+                            tracks.back().title = node->u.list->values[i].u.list->values[n].u.string;
+                        }
                     }
                     else if (QString(node->u.list->values[i].u.list->keys[n]) == "lang")
                     {
                         if (node->u.list->values[i].u.list->values[n].format == MPV_FORMAT_STRING)
-                            track->lang = node->u.list->values[i].u.list->values[n].u.string;
+                        {
+                            tracks.back().lang = node->u.list->values[i].u.list->values[n].u.string;
+                        }
                     }
                     else if (QString(node->u.list->values[i].u.list->keys[n]) == "albumart")
                     {
                         if (node->u.list->values[i].u.list->values[n].format == MPV_FORMAT_FLAG)
-                            track->albumart = node->u.list->values[i].u.list->values[n].u.flag != 0;
+                        {
+                            tracks.back().albumart = node->u.list->values[i].u.list->values[n].u.flag != 0;
+                        }
                     }
                     else if (QString(node->u.list->values[i].u.list->keys[n]) == "default")
                     {
                         if (node->u.list->values[i].u.list->values[n].format == MPV_FORMAT_FLAG)
-                            track->def = node->u.list->values[i].u.list->values[n].u.flag != 0;
+                        {
+                            tracks.back().def = node->u.list->values[i].u.list->values[n].u.flag != 0;
+                        }
                     }
                     else if (QString(node->u.list->values[i].u.list->keys[n]) == "selected")
                     {
                         if (node->u.list->values[i].u.list->values[n].format == MPV_FORMAT_FLAG)
-                            track->selected = node->u.list->values[i].u.list->values[n].u.flag != 0;
+                        {
+                            tracks.back().selected = node->u.list->values[i].u.list->values[n].u.flag != 0;
+                        }
                     }
                     else if (QString(node->u.list->values[i].u.list->keys[n]) == "main-selection")
                     {
                         if (node->u.list->values[i].u.list->values[n].format == MPV_FORMAT_INT64)
-                            track->mainSelection = node->u.list->values[i].u.list->values[n].u.int64;
+                        {
+                            tracks.back().mainSelection = node->u.list->values[i].u.list->values[n].u.int64;
+                        }
                     }
                     else if (QString(node->u.list->values[i].u.list->keys[n]) == "external")
                     {
                         if (node->u.list->values[i].u.list->values[n].format == MPV_FORMAT_FLAG)
-                            track->external = node->u.list->values[i].u.list->values[n].u.flag != 0;
+                        {
+                            tracks.back().external = node->u.list->values[i].u.list->values[n].u.flag != 0;
+                        }
                     }
                     else if (QString(node->u.list->values[i].u.list->keys[n]) == "external-filename")
                     {
                         if (node->u.list->values[i].u.list->values[n].format == MPV_FORMAT_STRING)
-                            track->externalFilename = node->u.list->values[i].u.list->values[n].u.string;
+                        {
+                            tracks.back().externalFilename = node->u.list->values[i].u.list->values[n].u.string;
+                        }
                     }
                     else if (QString(node->u.list->values[i].u.list->keys[n]) == "codec")
                     {
                         if (node->u.list->values[i].u.list->values[n].format == MPV_FORMAT_STRING)
-                            track->codec = node->u.list->values[i].u.list->values[n].u.string;
+                        {
+                            tracks.back().codec = node->u.list->values[i].u.list->values[n].u.string;
+                        }
                     }
                 }
-                tracks.push_back(track);
             }
         }
     }
diff --git a/src/player/mpvadapter.h b/src/player/mpvadapter.h
@@ -66,7 +66,7 @@ class MpvAdapter : public PlayerAdapter
 
     double getAudioDelay() const override;
 
-    QList<const Track *> getTracks() override;
+    QList<Track> getTracks() override;
 
     int64_t getAudioTrack() const override;
 
@@ -147,7 +147,8 @@ private Q_SLOTS:
      * @param node The mpv_node containing the raw track-list.
      * @return A list containing the tracks.
      */
-    QList<const Track *> processTracks(const mpv_node *node);
+    [[nodiscard]]
+    static QList<Track> processTracks(const mpv_node *node);
 
 private:
     /* Node in the command line argument multi-tree. */
diff --git a/src/player/playeradapter.h b/src/player/playeradapter.h
@@ -109,9 +109,9 @@ class PlayerAdapter : public QObject
 
     /**
      * Returns a list of the current tracks.
-     * @return A list of the current tracks. Tracks belong to the callee.
+     * @return A list of the current tracks.
      */
-    virtual QList<const Track *> getTracks() = 0;
+    virtual QList<Track> getTracks() = 0;
 
     /**
      * Get the id of the current audio track starting.
diff --git a/src/state/context.h b/src/state/context.h
@@ -175,10 +175,9 @@ class Context : public QObject
 
     /**
      * Emitted when the player tracks change.
-     * @param tracks A list of player tracks. All tracks are deleted when
-     *               callees return.
+     * @param tracks A list of player tracks.
      */
-    void playerTracksChanged(const QList<const Track *> &tracks) const;
+    void playerTracksChanged(const QList<Track> &tracks) const;
 
     /**
      * Emitted when the player chapters change.

Original file line number	Diff line number	Diff line change
`@@ -161,13 +161,8 @@ PlayerMenu::PlayerMenu(QPointer<Context> context, QWidget *parent) :`
`161`	`161`	`m_context, &Context::playerFileLoaded, this,`
`162`	`162`	`[this]`
`163`	`163`	`{`
`164`		`- QList<const Track *> tracks =`
`165`		`- m_context->getPlayerAdapter()->getTracks();`
	`164`	`+ QList<Track> tracks = m_context->getPlayerAdapter()->getTracks();`
`166`	`165`	`setTracks(tracks);`
`167`		`- for (const Track *track : tracks)`
`168`		`- {`
`169`		`- delete track;`
`170`		`- }`
`171`	`166`	`}`
`172`	`167`	`);`
`173`	`168`
`@@ -395,19 +390,19 @@ void PlayerMenu::clearTracks()`
`395`	`390`
`396`	`391`	`#define MAX_LENGTH 45`
`397`	`392`
`398`		`-QAction PlayerMenu::createTrackAction(const Track track) const`
	`393`	`+QAction *PlayerMenu::createTrackAction(const Track &track) const`
`399`	`394`	`{`
`400`	`395`	`QAction *action = new QAction;`
`401`	`396`	`action->setCheckable(true);`
`402`	`397`
`403`		`- QString actionText = "Track " + QString::number(track->id);`
`404`		`- if (!track->lang.isEmpty())`
	`398`	`+ QString actionText = "Track " + QString::number(track.id);`
	`399`	`+ if (!track.lang.isEmpty())`
`405`	`400`	`{`
`406`		`- actionText += " [" + track->lang + "]";`
	`401`	`+ actionText += " [" + track.lang + "]";`
`407`	`402`	`}`
`408`		`- if (!track->title.isEmpty())`
	`403`	`+ if (!track.title.isEmpty())`
`409`	`404`	`{`
`410`		`- actionText += " - " + track->title;`
	`405`	`+ actionText += " - " + track.title;`
`411`	`406`	`}`
`412`	`407`	`if (actionText.length() > MAX_LENGTH)`
`413`	`408`	`{`
`@@ -421,26 +416,26 @@ QAction PlayerMenu::createTrackAction(const Track track) const`
`421`	`416`
`422`	`417`	`#undef MAX_LENGTH`
`423`	`418`
`424`		`-void PlayerMenu::setTracks(const QList<const Track *> &tracks)`
	`419`	`+void PlayerMenu::setTracks(const QList<Track> &tracks)`
`425`	`420`	`{`
`426`	`421`	`clearTracks();`
`427`	`422`
`428`	`423`	`m_actionGroups.audio->blockSignals(true);`
`429`	`424`	`m_actionGroups.subtitle->blockSignals(true);`
`430`	`425`	`m_actionGroups.subtitleTwo->blockSignals(true);`
`431`	`426`
`432`		`- for (const Track *track : tracks)`
	`427`	`+ for (const Track &track : tracks)`
`433`	`428`	`{`
`434`	`429`	`QAction *action = createTrackAction(track);`
`435`		`- const int64_t id = track->id;`
`436`		`- switch (track->type)`
	`430`	`+ const int64_t id = track.id;`
	`431`	`+ switch (track.type)`
`437`	`432`	`{`
`438`	`433`	`case Track::Type::audio:`
`439`	`434`	`m_ui->menuAudio->addAction(action);`
`440`	`435`	`action->setActionGroup(m_actionGroups.audio);`
`441`	`436`	`m_actionGroups.audioActions.append(action);`
`442`	`437`
`443`		`- if (track->selected)`
	`438`	`+ if (track.selected)`
`444`	`439`	`{`
`445`	`440`	`action->setChecked(true);`
`446`	`441`	`m_ui->actionAudioNone->setChecked(false);`
`@@ -469,13 +464,13 @@ void PlayerMenu::setTracks(const QList<const Track *> &tracks)`
`469`	`464`	`actionSubTwo->setActionGroup(m_actionGroups.subtitleTwo);`
`470`	`465`	`m_actionGroups.subtitleTwoActions.append(actionSubTwo);`
`471`	`466`
`472`		`- if (track->selected && track->mainSelection == 0)`
	`467`	`+ if (track.selected && track.mainSelection == 0)`
`473`	`468`	`{`
`474`	`469`	`action->setChecked(true);`
`475`	`470`	`m_ui->actionSubtitleNone->setChecked(false);`
`476`	`471`	`actionSubTwo->setEnabled(false);`
`477`	`472`	`}`
`478`		`- else if (track->selected && track->mainSelection == 1)`
	`473`	`+ else if (track.selected && track.mainSelection == 1)`
`479`	`474`	`{`
`480`	`475`	`actionSubTwo->setChecked(true);`
`481`	`476`	`m_ui->actionSubtitleTwoNone->setChecked(false);`
Original file line number	Diff line number	Diff line change
`@@ -342,13 +342,8 @@ void SubtitleListWidget::initRegex()`
`342`	`342`
`343`	`343`	`if (m_context->getPlayerAdapter())`
`344`	`344`	`{`
`345`		`- QList<const Track *> tracks =`
`346`		`- m_context->getPlayerAdapter()->getTracks();`
	`345`	`+ QList<Track> tracks = m_context->getPlayerAdapter()->getTracks();`
`347`	`346`	`handleTracklistChange(tracks);`
`348`		`- for (const Track *track : tracks)`
`349`		`- {`
`350`		`- delete track;`
`351`		`- }`
`352`	`347`	`}`
`353`	`348`	`}`
`354`	`349`
`@@ -417,33 +412,32 @@ void SubtitleListWidget::resizeEvent(QResizeEvent *event)`
`417`	`412`	`/* End Event Handlers */`
`418`	`413`	`/* Begin Adder Methods */`
`419`	`414`
`420`		`-void SubtitleListWidget::handleTracklistChange(`
`421`		`- const QList<const Track *> &tracks)`
	`415`	`+void SubtitleListWidget::handleTracklistChange(const QList<Track> &tracks)`
`422`	`416`	`{`
`423`	`417`	`int64_t primarySid = -1;`
`424`	`418`	`int64_t secondarySid = -1;`
`425`	`419`	`QStringList extTracks;`
`426`	`420`	`QList<int64_t> extSids;`
`427`		`- for (const Track *track : tracks)`
	`421`	`+ for (const Track &track : tracks)`
`428`	`422`	`{`
`429`		`- if (track->type == Track::subtitle)`
	`423`	`+ if (track.type == Track::subtitle)`
`430`	`424`	`{`
`431`		`- if (track->selected)`
	`425`	`+ if (track.selected)`
`432`	`426`	`{`
`433`		`- if (track->mainSelection == 0)`
	`427`	`+ if (track.mainSelection == 0)`
`434`	`428`	`{`
`435`		`- primarySid = track->id;`
	`429`	`+ primarySid = track.id;`
`436`	`430`	`}`
`437`	`431`	`else`
`438`	`432`	`{`
`439`		`- secondarySid = track->id;`
	`433`	`+ secondarySid = track.id;`
`440`	`434`	`}`
`441`	`435`	`}`
`442`	`436`
`443`		`- if (track->external)`
	`437`	`+ if (track.external)`
`444`	`438`	`{`
`445`		`- extTracks << track->externalFilename;`
`446`		`- extSids << track->id;`
	`439`	`+ extTracks.emplaceBack(track.externalFilename);`
	`440`	`+ extSids.emplaceBack(track.id);`
`447`	`441`	`}`
`448`	`442`	`}`
`449`	`443`	`}`
Original file line number	Diff line number	Diff line change
`@@ -62,12 +62,8 @@ MpvAdapter::MpvAdapter(`
`62`	`62`	`m_mpv, &MpvWidget::tracklistChanged, this,`
`63`	`63`	`[this] (const mpv_node *node)`
`64`	`64`	`{`
`65`		`- QList<const Track *> tracks = processTracks(node);`
	`65`	`+ QList<Track> tracks = processTracks(node);`
`66`	`66`	`emit m_context->playerTracksChanged(tracks);`
`67`		`- for (const Track *track : tracks)`
`68`		`- {`
`69`		`- delete track;`
`70`		`- }`
`71`	`67`	`}`
`72`	`68`	`);`
`73`	`69`	`connect(`
`@@ -493,15 +489,15 @@ double MpvAdapter::getAudioDelay() const`
`493`	`489`	`return delay;`
`494`	`490`	`}`
`495`	`491`
`496`		`-QList<const Track *> MpvAdapter::getTracks()`
	`492`	`+QList<Track> MpvAdapter::getTracks()`
`497`	`493`	`{`
`498`	`494`	`mpv_node node;`
`499`	`495`	`if (mpv_get_property(m_handle, "track-list", MPV_FORMAT_NODE, &node) < 0)`
`500`	`496`	`{`
`501`	`497`	`qDebug() << "Could not get track-list property";`
`502`		`- return QList<const Track *>();`
	`498`	`+ return {};`
`503`	`499`	`}`
`504`		`- QList<const Track *> tracks = processTracks(&node);`
	`500`	`+ QList<Track> tracks = processTracks(&node);`
`505`	`501`	`mpv_free_node_contents(&node);`
`506`	`502`	`return tracks;`
`507`	`503`	`}`
`@@ -1251,88 +1247,113 @@ void MpvAdapter::mouseWheelMoved(const QWheelEvent *event)`
`1251`	`1247`
`1252`	`1248`	`/* Code modified from loadTracks() */`
`1253`	`1249`	`/* https://github.com/u8sand/Baka-MPlayer/blob/master/src/mpvhandler.cpp */`
`1254`		`-QList<const Track > MpvAdapter::processTracks(const mpv_node node)`
	`1250`	`+QList<Track> MpvAdapter::processTracks(const mpv_node *node)`
`1255`	`1251`	`{`
`1256`		`- QList<const Track *> tracks;`
	`1252`	`+ QList<Track> tracks;`
`1257`	`1253`	`if (node->format == MPV_FORMAT_NODE_ARRAY)`
`1258`	`1254`	`{`
`1259`	`1255`	`for (int i = 0; i < node->u.list->num; i++)`
`1260`	`1256`	`{`
`1261`		`- Track *track = new Track;`
	`1257`	`+ tracks.emplaceBack(Track{});`
`1262`	`1258`	`if (node->u.list->values[i].format == MPV_FORMAT_NODE_MAP)`
`1263`	`1259`	`{`
`1264`	`1260`	`for (int n = 0; n < node->u.list->values[i].u.list->num; n++)`
`1265`	`1261`	`{`
`1266`	`1262`	`if (QString(node->u.list->values[i].u.list->keys[n]) == "id")`
`1267`	`1263`	`{`
`1268`	`1264`	`if (node->u.list->values[i].u.list->values[n].format == MPV_FORMAT_INT64)`
`1269`		`- track->id = node->u.list->values[i].u.list->values[n].u.int64;`
	`1265`	`+ tracks.back().id = node->u.list->values[i].u.list->values[n].u.int64;`
`1270`	`1266`	`}`
`1271`	`1267`	`else if (QString(node->u.list->values[i].u.list->keys[n]) == "type")`
`1272`	`1268`	`{`
`1273`	`1269`	`if (node->u.list->values[i].u.list->values[n].format == MPV_FORMAT_STRING)`
`1274`	`1270`	`{`
`1275`	`1271`	`QString type = node->u.list->values[i].u.list->values[n].u.string;`
`1276`	`1272`	`if (type == "audio")`
`1277`		`- track->type = Track::Type::audio;`
	`1273`	`+ {`
	`1274`	`+ tracks.back().type = Track::Type::audio;`
	`1275`	`+ }`
`1278`	`1276`	`else if (type == "video")`
`1279`		`- track->type = Track::Type::video;`
	`1277`	`+ {`
	`1278`	`+ tracks.back().type = Track::Type::video;`
	`1279`	`+ }`
`1280`	`1280`	`else if (type == "sub")`
`1281`		`- track->type = Track::Type::subtitle;`
	`1281`	`+ {`
	`1282`	`+ tracks.back().type = Track::Type::subtitle;`
	`1283`	`+ }`
`1282`	`1284`	`}`
`1283`	`1285`	`}`
`1284`	`1286`	`else if (QString(node->u.list->values[i].u.list->keys[n]) == "src-id")`
`1285`	`1287`	`{`
`1286`	`1288`	`if (node->u.list->values[i].u.list->values[n].format == MPV_FORMAT_INT64)`
`1287`		`- track->srcId = node->u.list->values[i].u.list->values[n].u.int64;`
	`1289`	`+ {`
	`1290`	`+ tracks.back().srcId = node->u.list->values[i].u.list->values[n].u.int64;`
	`1291`	`+ }`
`1288`	`1292`	`}`
`1289`	`1293`	`else if (QString(node->u.list->values[i].u.list->keys[n]) == "title")`
`1290`	`1294`	`{`
`1291`	`1295`	`if (node->u.list->values[i].u.list->values[n].format == MPV_FORMAT_STRING)`
`1292`		`- track->title = node->u.list->values[i].u.list->values[n].u.string;`
	`1296`	`+ {`
	`1297`	`+ tracks.back().title = node->u.list->values[i].u.list->values[n].u.string;`
	`1298`	`+ }`
`1293`	`1299`	`}`
`1294`	`1300`	`else if (QString(node->u.list->values[i].u.list->keys[n]) == "lang")`
`1295`	`1301`	`{`
`1296`	`1302`	`if (node->u.list->values[i].u.list->values[n].format == MPV_FORMAT_STRING)`
`1297`		`- track->lang = node->u.list->values[i].u.list->values[n].u.string;`
	`1303`	`+ {`
	`1304`	`+ tracks.back().lang = node->u.list->values[i].u.list->values[n].u.string;`
	`1305`	`+ }`
`1298`	`1306`	`}`
`1299`	`1307`	`else if (QString(node->u.list->values[i].u.list->keys[n]) == "albumart")`
`1300`	`1308`	`{`
`1301`	`1309`	`if (node->u.list->values[i].u.list->values[n].format == MPV_FORMAT_FLAG)`
`1302`		`- track->albumart = node->u.list->values[i].u.list->values[n].u.flag != 0;`
	`1310`	`+ {`
	`1311`	`+ tracks.back().albumart = node->u.list->values[i].u.list->values[n].u.flag != 0;`
	`1312`	`+ }`
`1303`	`1313`	`}`
`1304`	`1314`	`else if (QString(node->u.list->values[i].u.list->keys[n]) == "default")`
`1305`	`1315`	`{`
`1306`	`1316`	`if (node->u.list->values[i].u.list->values[n].format == MPV_FORMAT_FLAG)`
`1307`		`- track->def = node->u.list->values[i].u.list->values[n].u.flag != 0;`
	`1317`	`+ {`
	`1318`	`+ tracks.back().def = node->u.list->values[i].u.list->values[n].u.flag != 0;`
	`1319`	`+ }`
`1308`	`1320`	`}`
`1309`	`1321`	`else if (QString(node->u.list->values[i].u.list->keys[n]) == "selected")`
`1310`	`1322`	`{`
`1311`	`1323`	`if (node->u.list->values[i].u.list->values[n].format == MPV_FORMAT_FLAG)`
`1312`		`- track->selected = node->u.list->values[i].u.list->values[n].u.flag != 0;`
	`1324`	`+ {`
	`1325`	`+ tracks.back().selected = node->u.list->values[i].u.list->values[n].u.flag != 0;`
	`1326`	`+ }`
`1313`	`1327`	`}`
`1314`	`1328`	`else if (QString(node->u.list->values[i].u.list->keys[n]) == "main-selection")`
`1315`	`1329`	`{`
`1316`	`1330`	`if (node->u.list->values[i].u.list->values[n].format == MPV_FORMAT_INT64)`
`1317`		`- track->mainSelection = node->u.list->values[i].u.list->values[n].u.int64;`
	`1331`	`+ {`
	`1332`	`+ tracks.back().mainSelection = node->u.list->values[i].u.list->values[n].u.int64;`
	`1333`	`+ }`
`1318`	`1334`	`}`
`1319`	`1335`	`else if (QString(node->u.list->values[i].u.list->keys[n]) == "external")`
`1320`	`1336`	`{`
`1321`	`1337`	`if (node->u.list->values[i].u.list->values[n].format == MPV_FORMAT_FLAG)`
`1322`		`- track->external = node->u.list->values[i].u.list->values[n].u.flag != 0;`
	`1338`	`+ {`
	`1339`	`+ tracks.back().external = node->u.list->values[i].u.list->values[n].u.flag != 0;`
	`1340`	`+ }`
`1323`	`1341`	`}`
`1324`	`1342`	`else if (QString(node->u.list->values[i].u.list->keys[n]) == "external-filename")`
`1325`	`1343`	`{`
`1326`	`1344`	`if (node->u.list->values[i].u.list->values[n].format == MPV_FORMAT_STRING)`
`1327`		`- track->externalFilename = node->u.list->values[i].u.list->values[n].u.string;`
	`1345`	`+ {`
	`1346`	`+ tracks.back().externalFilename = node->u.list->values[i].u.list->values[n].u.string;`
	`1347`	`+ }`
`1328`	`1348`	`}`
`1329`	`1349`	`else if (QString(node->u.list->values[i].u.list->keys[n]) == "codec")`
`1330`	`1350`	`{`
`1331`	`1351`	`if (node->u.list->values[i].u.list->values[n].format == MPV_FORMAT_STRING)`
`1332`		`- track->codec = node->u.list->values[i].u.list->values[n].u.string;`
	`1352`	`+ {`
	`1353`	`+ tracks.back().codec = node->u.list->values[i].u.list->values[n].u.string;`
	`1354`	`+ }`
`1333`	`1355`	`}`
`1334`	`1356`	`}`
`1335`		`- tracks.push_back(track);`
`1336`	`1357`	`}`
`1337`	`1358`	`}`
`1338`	`1359`	`}`