Fixed bug which caused a crash while track's graph was drawing and user used 'move up'/'move down'/'delete' functions.

Flone-dnb · Flone-dnb · commit 7aa9363eb6ad · 2019-08-17T12:04:49.000+05:00
diff --git a/ide/BloodyPlayer.pro.user b/ide/BloodyPlayer.pro.user
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE QtCreatorProject>
-<!-- Written by QtCreator 4.9.2, 2019-08-16T18:43:51. -->
+<!-- Written by QtCreator 4.9.2, 2019-08-17T12:01:37. -->
 <qtcreator>
  <data>
   <variable>EnvironmentId</variable>
diff --git a/src/Model/AudioService/audioservice.cpp b/src/Model/AudioService/audioservice.cpp
@@ -22,6 +22,7 @@ AudioService::AudioService(MainWindow* pMainWindow)
     this->pMainWindow   = pMainWindow;
     pSystem              = nullptr;
     pRndGen              = new std::mt19937_64(time(nullptr));
+    iCurrentlyDrawingTrackIndex = new size_t(0);
 
     bMonitorTracks      = false;
     bIsSomeTrackPlaying = false;
@@ -377,8 +378,17 @@ void AudioService::playTrack(size_t iTrackIndex, bool bDontLockMutex)
     {
         if ( ((bCurrentTrackPaused == false) && (bIsSomeTrackPlaying == false)) || (iTrackIndex != iCurrentlyPlayingTrackIndex) )
         {
+            if (bDrawing)
+            {
+                // Some thread is drawing, stop it
+                bDrawing = false;
+                mtxDrawGraph.lock();
+                mtxDrawGraph.unlock();
+            }
+
             // Add new graph
-            std::thread drawGraphThread(&AudioService::drawGraph, this, iTrackIndex);
+            *iCurrentlyDrawingTrackIndex = iTrackIndex;
+            std::thread drawGraphThread(&AudioService::drawGraph, this, iCurrentlyDrawingTrackIndex);
             drawGraphThread.detach();
         }
 
@@ -562,15 +572,7 @@ void AudioService::removeTrack(size_t iTrackIndex)
 
     if ( iTrackIndex < tracks.size() )
     {
-        if ((bIsSomeTrackPlaying || bCurrentTrackPaused) && (iCurrentlyPlayingTrackIndex == iTrackIndex))
-        {
-            bDrawing = false;
-            mtxDrawGraph.lock();
-            mtxDrawGraph.unlock();
-        }
-
-        delete tracks[iTrackIndex];
-        tracks.erase( tracks.begin() + iTrackIndex );
+        mtxGetCurrentDrawingIndex.lock();
 
         if ( tracks.size() == 0)
         {
@@ -584,6 +586,12 @@ void AudioService::removeTrack(size_t iTrackIndex)
         {
             if (iTrackIndex == iCurrentlyPlayingTrackIndex)
             {
+                mtxGetCurrentDrawingIndex.unlock();
+                bDrawing = false;
+                mtxDrawGraph.lock();
+                mtxDrawGraph.unlock();
+                mtxGetCurrentDrawingIndex.lock();
+
                 bIsSomeTrackPlaying = false;
                 bCurrentTrackPaused = false;
                 iCurrentlyPlayingTrackIndex = 0;
@@ -597,8 +605,14 @@ void AudioService::removeTrack(size_t iTrackIndex)
             {
                 // Move 'iCurrentlyPlayingTrackIndex' to the left in the 'tracks' vector because of the delete.
                 iCurrentlyPlayingTrackIndex--;
+                *iCurrentlyDrawingTrackIndex -= 1;
             }
         }
+
+        delete tracks[iTrackIndex];
+        tracks.erase( tracks.begin() + iTrackIndex );
+
+        mtxGetCurrentDrawingIndex.unlock();
     }
     else
     {
@@ -890,6 +904,8 @@ void AudioService::moveDown(size_t iTrackIndex)
 {
     mtxTracksVec.lock();
 
+    mtxGetCurrentDrawingIndex.lock();
+
     if (iTrackIndex == tracks.size() - 1)
     {
         Track* pTemp = tracks[iTrackIndex];
@@ -901,10 +917,12 @@ void AudioService::moveDown(size_t iTrackIndex)
             if (iTrackIndex == iCurrentlyPlayingTrackIndex)
             {
                 iCurrentlyPlayingTrackIndex = 0;
+                *iCurrentlyDrawingTrackIndex = 0;
             }
             else
             {
                 iCurrentlyPlayingTrackIndex++;
+                *iCurrentlyDrawingTrackIndex += 1;
             }
         }
     }
@@ -919,24 +937,30 @@ void AudioService::moveDown(size_t iTrackIndex)
             if (iTrackIndex == iCurrentlyPlayingTrackIndex)
             {
                 iCurrentlyPlayingTrackIndex++;
+                *iCurrentlyDrawingTrackIndex += 1;
             }
             else if (iCurrentlyPlayingTrackIndex != 0)
             {
                 if (iTrackIndex == iCurrentlyPlayingTrackIndex - 1)
                 {
                     iCurrentlyPlayingTrackIndex--;
+                    *iCurrentlyDrawingTrackIndex -= 1;
                 }
             }
         }
     }
 
+    mtxGetCurrentDrawingIndex.unlock();
+
     mtxTracksVec.unlock();
 }
 
 void AudioService::moveUp(size_t iTrackIndex)
 {
     mtxTracksVec.lock();
 
+    mtxGetCurrentDrawingIndex.lock();
+
     if (iTrackIndex == 0)
     {
         Track* pTemp = tracks[iTrackIndex];
@@ -948,10 +972,12 @@ void AudioService::moveUp(size_t iTrackIndex)
             if (iTrackIndex == iCurrentlyPlayingTrackIndex)
             {
                 iCurrentlyPlayingTrackIndex = tracks.size() - 1;
+                *iCurrentlyDrawingTrackIndex = tracks.size() - 1;
             }
             else
             {
                 iCurrentlyPlayingTrackIndex--;
+                *iCurrentlyDrawingTrackIndex -= 1;
             }
         }
     }
@@ -966,14 +992,18 @@ void AudioService::moveUp(size_t iTrackIndex)
             if (iTrackIndex == iCurrentlyPlayingTrackIndex)
             {
                 iCurrentlyPlayingTrackIndex--;
+                *iCurrentlyDrawingTrackIndex -= 1;
             }
             else if (iTrackIndex == iCurrentlyPlayingTrackIndex + 1)
             {
                 iCurrentlyPlayingTrackIndex++;
+                *iCurrentlyDrawingTrackIndex += 1;
             }
         }
     }
 
+    mtxGetCurrentDrawingIndex.unlock();
+
     mtxTracksVec.unlock();
 }
 
@@ -1073,14 +1103,8 @@ void AudioService::monitorTrack()
     }
 }
 
-void AudioService::drawGraph(size_t iTrackIndex)
+void AudioService::drawGraph(size_t* iTrackIndex)
 {
-    if (bDrawing)
-    {
-        // Some thread is drawing, stop it
-        bDrawing = false;
-    }
-
     mtxDrawGraph.lock();
     bDrawing = true;
 
@@ -1097,14 +1121,16 @@ void AudioService::drawGraph(size_t iTrackIndex)
     // x    ('iSamplesInOne') - track length (in sec.)
 
     // here we do: 3000 * (tracks[iTrackIndex]->getLengthInMS() / 1000) / 6000, but we can replace this with just:
-    iSamplesInOne = tracks[iTrackIndex]->getLengthInMS() * 3 / 6000;
+    mtxGetCurrentDrawingIndex.lock();
+    iSamplesInOne = tracks[*iTrackIndex]->getLengthInMS() * 3 / 6000;
     if (iSamplesInOne == 0) iSamplesInOne = 1;
 
-    unsigned int iTempMax = tracks[iTrackIndex]->getLengthInPCMbytes() / 4 / iSamplesInOne;
+    unsigned int iTempMax = tracks[*iTrackIndex]->getLengthInPCMbytes() / 4 / iSamplesInOne;
     pMainWindow->setXMaxToGraph(iTempMax);
-    tracks[iTrackIndex]->setMaxPosInGraph(iTempMax);
+    tracks[*iTrackIndex]->setMaxPosInGraph(iTempMax);
 
-    tracks[iTrackIndex]->createDummySound();
+    tracks[*iTrackIndex]->createDummySound();
+    mtxGetCurrentDrawingIndex.unlock();
 
     // 2 MB because you need to multiply this value by 2 (because of short int type of buffer).
     unsigned int iBufferSize = 1048576;
@@ -1115,7 +1141,10 @@ void AudioService::drawGraph(size_t iTrackIndex)
     {
         short int* pSamples = new short int[iBufferSize];
         unsigned int iActuallyRead;
-        result = tracks[iTrackIndex]->getPCMSamples(pSamples, iBufferSize * 2, &iActuallyRead);
+
+        mtxGetCurrentDrawingIndex.lock();
+        result = tracks[*iTrackIndex]->getPCMSamples(pSamples, iBufferSize * 2, &iActuallyRead);
+        mtxGetCurrentDrawingIndex.unlock();
 
         if (result == 0)
         {
@@ -1131,14 +1160,17 @@ void AudioService::drawGraph(size_t iTrackIndex)
 
     }while ( (result == 1) && (bDrawing) );
 
+    mtxGetCurrentDrawingIndex.lock();
+
     if (bDrawing)
     {
         pMainWindow->setXMaxToGraph(iGraphMax);
-        tracks[iTrackIndex]->setMaxPosInGraph(iGraphMax);
+        tracks[*iTrackIndex]->setMaxPosInGraph(iGraphMax);
     }
 
-    tracks[iTrackIndex]->releaseDummySound();
+    tracks[*iTrackIndex]->releaseDummySound();
 
+    mtxGetCurrentDrawingIndex.unlock();
 
     bDrawing = false;
     mtxDrawGraph.unlock();
@@ -1166,6 +1198,8 @@ AudioService::~AudioService()
     mtxDrawGraph.lock();
     mtxDrawGraph.unlock();
 
+    delete iCurrentlyDrawingTrackIndex;
+
     delete pRndGen;
 
     bMonitorTracks = false;
diff --git a/src/Model/AudioService/audioservice.h b/src/Model/AudioService/audioservice.h
@@ -105,7 +105,7 @@ class AudioService
     // Will switch to next track if one's ended
     void monitorTrack();
 
-    void drawGraph(size_t iTrackIndex);
+    void drawGraph(size_t* iTrackIndex);
 
 
     FMOD::System*    pSystem;
@@ -126,6 +126,8 @@ class AudioService
     // Graph draw
     bool bDrawing;
     std::mutex mtxDrawGraph;
+    size_t* iCurrentlyDrawingTrackIndex;
+    std::mutex mtxGetCurrentDrawingIndex;
 
     bool bIsSomeTrackPlaying;
     bool bCurrentTrackPaused;
diff --git a/src/View/MainWindow/mainwindow.cpp b/src/View/MainWindow/mainwindow.cpp
@@ -299,7 +299,7 @@ void MainWindow::on_actionOpen_triggered()
 
 void MainWindow::on_actionAbout_triggered()
 {
-    QMessageBox::information(nullptr, "Bloody Player", "Bloody Player v1.15");
+    QMessageBox::information(nullptr, "Bloody Player", "Bloody Player v1.15.2");
 }
 
 void MainWindow::on_pushButton_Play_clicked()

Original file line number	Diff line number	Diff line change
`@@ -22,6 +22,7 @@ AudioService::AudioService(MainWindow* pMainWindow)`
`22`	`22`	`this->pMainWindow = pMainWindow;`
`23`	`23`	`pSystem = nullptr;`
`24`	`24`	`pRndGen = new std::mt19937_64(time(nullptr));`
	`25`	`+ iCurrentlyDrawingTrackIndex = new size_t(0);`
`25`	`26`
`26`	`27`	`bMonitorTracks = false;`
`27`	`28`	`bIsSomeTrackPlaying = false;`
`@@ -377,8 +378,17 @@ void AudioService::playTrack(size_t iTrackIndex, bool bDontLockMutex)`
`377`	`378`	`{`
`378`	`379`	`if ( ((bCurrentTrackPaused == false) && (bIsSomeTrackPlaying == false)) \|\| (iTrackIndex != iCurrentlyPlayingTrackIndex) )`
`379`	`380`	`{`
	`381`	`+ if (bDrawing)`
	`382`	`+ {`
	`383`	`+ // Some thread is drawing, stop it`
	`384`	`+ bDrawing = false;`
	`385`	`+ mtxDrawGraph.lock();`
	`386`	`+ mtxDrawGraph.unlock();`
	`387`	`+ }`
	`388`	`+`
`380`	`389`	`// Add new graph`
`381`		`- std::thread drawGraphThread(&AudioService::drawGraph, this, iTrackIndex);`
	`390`	`+ *iCurrentlyDrawingTrackIndex = iTrackIndex;`
	`391`	`+ std::thread drawGraphThread(&AudioService::drawGraph, this, iCurrentlyDrawingTrackIndex);`
`382`	`392`	`drawGraphThread.detach();`
`383`	`393`	`}`
`384`	`394`
`@@ -562,15 +572,7 @@ void AudioService::removeTrack(size_t iTrackIndex)`
`562`	`572`
`563`	`573`	`if ( iTrackIndex < tracks.size() )`
`564`	`574`	`{`
`565`		`- if ((bIsSomeTrackPlaying \|\| bCurrentTrackPaused) && (iCurrentlyPlayingTrackIndex == iTrackIndex))`
`566`		`- {`
`567`		`- bDrawing = false;`
`568`		`- mtxDrawGraph.lock();`
`569`		`- mtxDrawGraph.unlock();`
`570`		`- }`
`571`		`-`
`572`		`- delete tracks[iTrackIndex];`
`573`		`- tracks.erase( tracks.begin() + iTrackIndex );`
	`575`	`+ mtxGetCurrentDrawingIndex.lock();`
`574`	`576`
`575`	`577`	`if ( tracks.size() == 0)`
`576`	`578`	`{`
`@@ -584,6 +586,12 @@ void AudioService::removeTrack(size_t iTrackIndex)`
`584`	`586`	`{`
`585`	`587`	`if (iTrackIndex == iCurrentlyPlayingTrackIndex)`
`586`	`588`	`{`
	`589`	`+ mtxGetCurrentDrawingIndex.unlock();`
	`590`	`+ bDrawing = false;`
	`591`	`+ mtxDrawGraph.lock();`
	`592`	`+ mtxDrawGraph.unlock();`
	`593`	`+ mtxGetCurrentDrawingIndex.lock();`
	`594`	`+`
`587`	`595`	`bIsSomeTrackPlaying = false;`
`588`	`596`	`bCurrentTrackPaused = false;`
`589`	`597`	`iCurrentlyPlayingTrackIndex = 0;`
`@@ -597,8 +605,14 @@ void AudioService::removeTrack(size_t iTrackIndex)`
`597`	`605`	`{`
`598`	`606`	`// Move 'iCurrentlyPlayingTrackIndex' to the left in the 'tracks' vector because of the delete.`
`599`	`607`	`iCurrentlyPlayingTrackIndex--;`
	`608`	`+ *iCurrentlyDrawingTrackIndex -= 1;`
`600`	`609`	`}`
`601`	`610`	`}`
	`611`	`+`
	`612`	`+ delete tracks[iTrackIndex];`
	`613`	`+ tracks.erase( tracks.begin() + iTrackIndex );`
	`614`	`+`
	`615`	`+ mtxGetCurrentDrawingIndex.unlock();`
`602`	`616`	`}`
`603`	`617`	`else`
`604`	`618`	`{`
`@@ -890,6 +904,8 @@ void AudioService::moveDown(size_t iTrackIndex)`
`890`	`904`	`{`
`891`	`905`	`mtxTracksVec.lock();`
`892`	`906`
	`907`	`+ mtxGetCurrentDrawingIndex.lock();`
	`908`	`+`
`893`	`909`	`if (iTrackIndex == tracks.size() - 1)`
`894`	`910`	`{`
`895`	`911`	`Track* pTemp = tracks[iTrackIndex];`
`@@ -901,10 +917,12 @@ void AudioService::moveDown(size_t iTrackIndex)`
`901`	`917`	`if (iTrackIndex == iCurrentlyPlayingTrackIndex)`
`902`	`918`	`{`
`903`	`919`	`iCurrentlyPlayingTrackIndex = 0;`
	`920`	`+ *iCurrentlyDrawingTrackIndex = 0;`
`904`	`921`	`}`
`905`	`922`	`else`
`906`	`923`	`{`
`907`	`924`	`iCurrentlyPlayingTrackIndex++;`
	`925`	`+ *iCurrentlyDrawingTrackIndex += 1;`
`908`	`926`	`}`
`909`	`927`	`}`
`910`	`928`	`}`
`@@ -919,24 +937,30 @@ void AudioService::moveDown(size_t iTrackIndex)`
`919`	`937`	`if (iTrackIndex == iCurrentlyPlayingTrackIndex)`
`920`	`938`	`{`
`921`	`939`	`iCurrentlyPlayingTrackIndex++;`
	`940`	`+ *iCurrentlyDrawingTrackIndex += 1;`
`922`	`941`	`}`
`923`	`942`	`else if (iCurrentlyPlayingTrackIndex != 0)`
`924`	`943`	`{`
`925`	`944`	`if (iTrackIndex == iCurrentlyPlayingTrackIndex - 1)`
`926`	`945`	`{`
`927`	`946`	`iCurrentlyPlayingTrackIndex--;`
	`947`	`+ *iCurrentlyDrawingTrackIndex -= 1;`
`928`	`948`	`}`
`929`	`949`	`}`
`930`	`950`	`}`
`931`	`951`	`}`
`932`	`952`
	`953`	`+ mtxGetCurrentDrawingIndex.unlock();`
	`954`	`+`
`933`	`955`	`mtxTracksVec.unlock();`
`934`	`956`	`}`
`935`	`957`
`936`	`958`	`void AudioService::moveUp(size_t iTrackIndex)`
`937`	`959`	`{`
`938`	`960`	`mtxTracksVec.lock();`
`939`	`961`
	`962`	`+ mtxGetCurrentDrawingIndex.lock();`
	`963`	`+`
`940`	`964`	`if (iTrackIndex == 0)`
`941`	`965`	`{`
`942`	`966`	`Track* pTemp = tracks[iTrackIndex];`
`@@ -948,10 +972,12 @@ void AudioService::moveUp(size_t iTrackIndex)`
`948`	`972`	`if (iTrackIndex == iCurrentlyPlayingTrackIndex)`
`949`	`973`	`{`
`950`	`974`	`iCurrentlyPlayingTrackIndex = tracks.size() - 1;`
	`975`	`+ *iCurrentlyDrawingTrackIndex = tracks.size() - 1;`
`951`	`976`	`}`
`952`	`977`	`else`
`953`	`978`	`{`
`954`	`979`	`iCurrentlyPlayingTrackIndex--;`
	`980`	`+ *iCurrentlyDrawingTrackIndex -= 1;`
`955`	`981`	`}`
`956`	`982`	`}`
`957`	`983`	`}`
`@@ -966,14 +992,18 @@ void AudioService::moveUp(size_t iTrackIndex)`
`966`	`992`	`if (iTrackIndex == iCurrentlyPlayingTrackIndex)`
`967`	`993`	`{`
`968`	`994`	`iCurrentlyPlayingTrackIndex--;`
	`995`	`+ *iCurrentlyDrawingTrackIndex -= 1;`
`969`	`996`	`}`
`970`	`997`	`else if (iTrackIndex == iCurrentlyPlayingTrackIndex + 1)`
`971`	`998`	`{`
`972`	`999`	`iCurrentlyPlayingTrackIndex++;`
	`1000`	`+ *iCurrentlyDrawingTrackIndex += 1;`
`973`	`1001`	`}`
`974`	`1002`	`}`
`975`	`1003`	`}`
`976`	`1004`
	`1005`	`+ mtxGetCurrentDrawingIndex.unlock();`
	`1006`	`+`
`977`	`1007`	`mtxTracksVec.unlock();`
`978`	`1008`	`}`
`979`	`1009`
`@@ -1073,14 +1103,8 @@ void AudioService::monitorTrack()`
`1073`	`1103`	`}`
`1074`	`1104`	`}`
`1075`	`1105`
`1076`		`-void AudioService::drawGraph(size_t iTrackIndex)`
	`1106`	`+void AudioService::drawGraph(size_t* iTrackIndex)`
`1077`	`1107`	`{`
`1078`		`- if (bDrawing)`
`1079`		`- {`
`1080`		`- // Some thread is drawing, stop it`
`1081`		`- bDrawing = false;`
`1082`		`- }`
`1083`		`-`
`1084`	`1108`	`mtxDrawGraph.lock();`
`1085`	`1109`	`bDrawing = true;`
`1086`	`1110`
`@@ -1097,14 +1121,16 @@ void AudioService::drawGraph(size_t iTrackIndex)`
`1097`	`1121`	`// x ('iSamplesInOne') - track length (in sec.)`
`1098`	`1122`
`1099`	`1123`	`// here we do: 3000 * (tracks[iTrackIndex]->getLengthInMS() / 1000) / 6000, but we can replace this with just:`
`1100`		`- iSamplesInOne = tracks[iTrackIndex]->getLengthInMS() * 3 / 6000;`
	`1124`	`+ mtxGetCurrentDrawingIndex.lock();`
	`1125`	`+ iSamplesInOne = tracks[iTrackIndex]->getLengthInMS() 3 / 6000;`
`1101`	`1126`	`if (iSamplesInOne == 0) iSamplesInOne = 1;`
`1102`	`1127`
`1103`		`- unsigned int iTempMax = tracks[iTrackIndex]->getLengthInPCMbytes() / 4 / iSamplesInOne;`
	`1128`	`+ unsigned int iTempMax = tracks[*iTrackIndex]->getLengthInPCMbytes() / 4 / iSamplesInOne;`
`1104`	`1129`	`pMainWindow->setXMaxToGraph(iTempMax);`
`1105`		`- tracks[iTrackIndex]->setMaxPosInGraph(iTempMax);`
	`1130`	`+ tracks[*iTrackIndex]->setMaxPosInGraph(iTempMax);`
`1106`	`1131`
`1107`		`- tracks[iTrackIndex]->createDummySound();`
	`1132`	`+ tracks[*iTrackIndex]->createDummySound();`
	`1133`	`+ mtxGetCurrentDrawingIndex.unlock();`
`1108`	`1134`
`1109`	`1135`	`// 2 MB because you need to multiply this value by 2 (because of short int type of buffer).`
`1110`	`1136`	`unsigned int iBufferSize = 1048576;`
`@@ -1115,7 +1141,10 @@ void AudioService::drawGraph(size_t iTrackIndex)`
`1115`	`1141`	`{`
`1116`	`1142`	`short int* pSamples = new short int[iBufferSize];`
`1117`	`1143`	`unsigned int iActuallyRead;`
`1118`		`- result = tracks[iTrackIndex]->getPCMSamples(pSamples, iBufferSize * 2, &iActuallyRead);`
	`1144`	`+`
	`1145`	`+ mtxGetCurrentDrawingIndex.lock();`
	`1146`	`+ result = tracks[iTrackIndex]->getPCMSamples(pSamples, iBufferSize 2, &iActuallyRead);`
	`1147`	`+ mtxGetCurrentDrawingIndex.unlock();`
`1119`	`1148`
`1120`	`1149`	`if (result == 0)`
`1121`	`1150`	`{`
`@@ -1131,14 +1160,17 @@ void AudioService::drawGraph(size_t iTrackIndex)`
`1131`	`1160`
`1132`	`1161`	`}while ( (result == 1) && (bDrawing) );`
`1133`	`1162`
	`1163`	`+ mtxGetCurrentDrawingIndex.lock();`
	`1164`	`+`
`1134`	`1165`	`if (bDrawing)`
`1135`	`1166`	`{`
`1136`	`1167`	`pMainWindow->setXMaxToGraph(iGraphMax);`
`1137`		`- tracks[iTrackIndex]->setMaxPosInGraph(iGraphMax);`
	`1168`	`+ tracks[*iTrackIndex]->setMaxPosInGraph(iGraphMax);`
`1138`	`1169`	`}`
`1139`	`1170`
`1140`		`- tracks[iTrackIndex]->releaseDummySound();`
	`1171`	`+ tracks[*iTrackIndex]->releaseDummySound();`
`1141`	`1172`
	`1173`	`+ mtxGetCurrentDrawingIndex.unlock();`
`1142`	`1174`
`1143`	`1175`	`bDrawing = false;`
`1144`	`1176`	`mtxDrawGraph.unlock();`
`@@ -1166,6 +1198,8 @@ AudioService::~AudioService()`
`1166`	`1198`	`mtxDrawGraph.lock();`
`1167`	`1199`	`mtxDrawGraph.unlock();`
`1168`	`1200`
	`1201`	`+ delete iCurrentlyDrawingTrackIndex;`
	`1202`	`+`
`1169`	`1203`	`delete pRndGen;`
`1170`	`1204`
`1171`	`1205`	`bMonitorTracks = false;`
Original file line number	Diff line number	Diff line change
`@@ -299,7 +299,7 @@ void MainWindow::on_actionOpen_triggered()`
`299`	`299`
`300`	`300`	`void MainWindow::on_actionAbout_triggered()`
`301`	`301`	`{`
`302`		`- QMessageBox::information(nullptr, "Bloody Player", "Bloody Player v1.15");`
	`302`	`+ QMessageBox::information(nullptr, "Bloody Player", "Bloody Player v1.15.2");`
`303`	`303`	`}`
`304`	`304`
`305`	`305`	`void MainWindow::on_pushButton_Play_clicked()`