fix bug #1605921 : Improve recording split size options

3 files changed, 91 insertions, 28 deletions

diff --git a/src/recording/defs_recording.h b/src/recording/defs_recording.h
index 4fbb6f52ac..7bcc90441e 100644
--- a/src/recording/defs_recording.h
+++ b/src/recording/defs_recording.h
@@ -18,14 +18,17 @@
 #define SPLIT_1024MB "1 GB"
 #define SPLIT_2048MB "2 GB"
 #define SPLIT_4096MB "4 GB"
+#define SPLIT_60MIN "60 Minutes"
+#define SPLIT_74MIN "74 Minutes (CD)"
+#define SPLIT_80MIN "80 Minutes (CD)"
+#define SPLIT_120MIN "120 Minutes"
 
-// Byte conversions Instead of multiplying megabytes with 1024 to get kilobytes
-// I use 1000 Once the recording size has reached there's enough room to add
+// Byte conversions. Slightly rounded to leave enough room to add
 // closing frames by the encoder. All sizes are in bytes.
-#define SIZE_650MB  Q_UINT64_C(650000000)
-#define SIZE_700MB  Q_UINT64_C(750000000)
-#define SIZE_1GB    Q_UINT64_C(1000000000)
-#define SIZE_2GB    Q_UINT64_C(2000000000)
-#define SIZE_4GB    Q_UINT64_C(4000000000)
+#define SIZE_650MB  Q_UINT64_C(680000000)
+#define SIZE_700MB  Q_UINT64_C(730000000)
+#define SIZE_1GB    Q_UINT64_C(1070000000)
+#define SIZE_2GB    Q_UINT64_C(2140000000)
+#define SIZE_4GB    Q_UINT64_C(4280000000)
 
 #endif
diff --git a/src/recording/recordingmanager.cpp b/src/recording/recordingmanager.cpp
index 33b758b59a..75d7317cb4 100644
--- a/src/recording/recordingmanager.cpp
+++ b/src/recording/recordingmanager.cpp
@@ -21,9 +21,12 @@ RecordingManager::RecordingManager(UserSettingsPointer pConfig, EngineMaster* pE
           m_recordingLocation(""),
           m_bRecording(false),
           m_iNumberOfBytesRecorded(0),
+          m_iNumberOfBytesRecordedSplit(0),
           m_split_size(0),
+		  m_split_time(0),
           m_iNumberSplits(0),
-          m_durationRecorded("") {
+		  m_secondsRecorded(0),
+		  m_secondsRecordedSplit(0) {
     m_pToggleRecording = new ControlPushButton(ConfigKey(RECORDING_PREF_KEY, "toggle_recording"));
     connect(m_pToggleRecording, SIGNAL(valueChanged(double)),
             this, SLOT(slotToggleRecording(double)));
@@ -31,6 +34,7 @@ RecordingManager::RecordingManager(UserSettingsPointer pConfig, EngineMaster* pE
     m_recReady = new ControlProxy(m_recReadyCO->getKey(), this);
 
     m_split_size = getFileSplitSize();
+	m_split_time = getFileSplitTime();
 
 
     // Register EngineRecord with the engine sidechain.
@@ -41,8 +45,8 @@ RecordingManager::RecordingManager(UserSettingsPointer pConfig, EngineMaster* pE
                 this, SLOT(slotIsRecording(bool, bool)));
         connect(pEngineRecord, SIGNAL(bytesRecorded(int)),
                 this, SLOT(slotBytesRecorded(int)));
-        connect(pEngineRecord, SIGNAL(durationRecorded(QString)),
-                this, SLOT(slotDurationRecorded(QString)));
+        connect(pEngineRecord, SIGNAL(durationRecorded(quint64)),
+                this, SLOT(slotDurationRecorded(quint64)));
         pSidechain->addSideChainWorker(pEngineRecord);
     }
 }
@@ -80,14 +84,22 @@ void RecordingManager::slotToggleRecording(double v) {
 }
 
 void RecordingManager::startRecording(bool generateFileName) {
-    m_iNumberOfBytesRecorded = 0;
-    m_split_size = getFileSplitSize();
-    qDebug() << "Split size is:" << m_split_size;
-    QString encodingType = m_pConfig->getValueString(
-            ConfigKey(RECORDING_PREF_KEY, "Encoding"));
+	QString encodingType = m_pConfig->getValueString(
+			ConfigKey(RECORDING_PREF_KEY, "Encoding"));
+
+	if(generateFileName) {
+		m_iNumberOfBytesRecorded = 0;
+		m_secondsRecorded=0;
+		m_split_size = getFileSplitSize();
+		m_split_time = getFileSplitTime();
+		if (m_split_time < 999999999) {
+			qDebug() << "Split time is:" << m_split_time;
+		}
+		else {
+			qDebug() << "Split size is:" << m_split_size;
+		}
 
-    if(generateFileName) {
-        m_iNumberSplits = 1;
+		m_iNumberSplits = 1;
         // Append file extension.
         QString date_time_str = formatDateTimeForFilename(QDateTime::currentDateTime());
         m_recordingFile = QString("%1.%2")
@@ -100,17 +112,21 @@ void RecordingManager::startRecording(bool generateFileName) {
         m_recordingLocation = m_recording_base_file + "."+ encodingType.toLower();
         m_pConfig->set(ConfigKey(RECORDING_PREF_KEY, "Path"), m_recordingLocation);
         m_pConfig->set(ConfigKey(RECORDING_PREF_KEY, "CuePath"), m_recording_base_file +".cue");
-    } else {
+	} else {
         // This is only executed if filesplit occurs.
         ++m_iNumberSplits;
+		m_secondsRecorded+=m_secondsRecordedSplit;
         QString new_base_filename = m_recording_base_file +"part"+QString::number(m_iNumberSplits);
         m_recordingLocation = new_base_filename + "." +encodingType.toLower();
 
         m_pConfig->set(ConfigKey(RECORDING_PREF_KEY, "Path"), m_recordingLocation);
         m_pConfig->set(ConfigKey(RECORDING_PREF_KEY, "CuePath"), new_base_filename +".cue");
         m_recordingFile = QFileInfo(m_recordingLocation).fileName();
-    }
+	}
     m_recReady->set(RECORD_READY);
+
+	m_iNumberOfBytesRecordedSplit = 0;
+	m_secondsRecordedSplit=0;
 }
 
 void RecordingManager::stopRecording()
@@ -120,6 +136,7 @@ void RecordingManager::stopRecording()
     m_recordingFile = "";
     m_recordingLocation = "";
     m_iNumberOfBytesRecorded = 0;
+	m_secondsRecorded = 0;
 }
 
 void RecordingManager::setRecordingDir() {
@@ -145,22 +162,38 @@ QString& RecordingManager::getRecordingDir() {
 }
 
 // Only called when recording is active.
-void RecordingManager::slotDurationRecorded(QString durationStr)
+void RecordingManager::slotDurationRecorded(quint64 duration)
 {
-    if(m_durationRecorded != durationStr)
+    if(m_secondsRecordedSplit != duration)
     {
-        m_durationRecorded = durationStr;
-        emit(durationRecorded(m_durationRecorded));
+        m_secondsRecordedSplit = duration;
+		if(duration >= m_split_time)
+		{
+			qDebug() << "Splitting after " << duration << " seconds";
+            stopRecording();
+			// Dont generate a new filename.
+			// This will reuse the previous filename but append a suffix.
+			startRecording(false);
+		}
+		emit(durationRecorded(getRecordedDurationStr(m_secondsRecorded+m_secondsRecordedSplit)));
     }
 }
+// Copy from the implementation in enginerecord.cpp
+QString RecordingManager::getRecordedDurationStr(quint64 duration) {
+    return QString("%1:%2")
+                 .arg(duration / 60, 2, 'f', 0, '0')   // minutes
+                 .arg(duration % 60, 2, 'f', 0, '0');  // seconds
+}
 
 // Only called when recording is active.
 void RecordingManager::slotBytesRecorded(int bytes)
 {
     // auto conversion to long
     m_iNumberOfBytesRecorded += bytes;
-    if(m_iNumberOfBytesRecorded >= m_split_size)
+	m_iNumberOfBytesRecordedSplit += bytes;
+    if(m_iNumberOfBytesRecordedSplit >= m_split_size)
     {
+		qDebug() << "Splitting after " << m_iNumberOfBytesRecorded << " bytes written";
         stopRecording();
         // Dont generate a new filename.
         // This will reuse the previous filename but append a suffix.
@@ -200,7 +233,7 @@ QString& RecordingManager::getRecordingLocation() {
     return m_recordingLocation;
 }
 
-long RecordingManager::getFileSplitSize()
+quint64 RecordingManager::getFileSplitSize()
 {
      QString fileSizeStr = m_pConfig->getValueString(ConfigKey(RECORDING_PREF_KEY, "FileSize"));
      if(fileSizeStr == SPLIT_650MB)
@@ -213,6 +246,28 @@ long RecordingManager::getFileSplitSize()
          return SIZE_2GB;
      else if(fileSizeStr == SPLIT_4096MB)
          return SIZE_4GB;
+     else if(fileSizeStr == SPLIT_60MIN)
+         return SIZE_4GB; //Ignore size limit. use time limit
+     else if(fileSizeStr == SPLIT_74MIN)
+         return SIZE_4GB; //Ignore size limit. use time limit
+     else if(fileSizeStr == SPLIT_80MIN)
+         return SIZE_4GB; //Ignore size limit. use time limit
+     else if(fileSizeStr == SPLIT_120MIN)
+         return SIZE_4GB; //Ignore size limit. use time limit
      else
          return SIZE_650MB;
 }
+long RecordingManager::getFileSplitTime()
+{
+    QString fileSizeStr = m_pConfig->getValueString(ConfigKey(RECORDING_PREF_KEY, "FileSize"));
+	if(fileSizeStr == SPLIT_60MIN)
+        return 60*60;
+    else if(fileSizeStr == SPLIT_74MIN)
+        return 74*60;
+    else if(fileSizeStr == SPLIT_80MIN)
+        return 8;//0*60;   //TODO: TEST!. Restore the correct value after that.
+    else if(fileSizeStr == SPLIT_120MIN)
+        return 120*60;
+    else // Do not limit by time for the rest.
+        return 999999999;
+}
diff --git a/src/recording/recordingmanager.h b/src/recording/recordingmanager.h
index 6a2f48b224..5b9d58c4b2 100644
--- a/src/recording/recordingmanager.h
+++ b/src/recording/recordingmanager.h
@@ -57,7 +57,7 @@ class RecordingManager : public QObject
   public slots:
     void slotIsRecording(bool recording, bool error);
     void slotBytesRecorded(int);
-    void slotDurationRecorded(QString);
+    void slotDurationRecorded(quint64);
 
   private slots:
     void slotSetRecording(bool recording);
@@ -69,7 +69,8 @@ class RecordingManager : public QObject
     ControlObject* m_recReadyCO;
     ControlPushButton* m_pToggleRecording;
 
-    long getFileSplitSize();
+    quint64 getFileSplitSize();
+	long getFileSplitTime();
 
     UserSettingsPointer m_pConfig;
     QString m_recordingDir;
@@ -83,9 +84,13 @@ class RecordingManager : public QObject
     bool m_bRecording;
     // will be a very large number
     quint64 m_iNumberOfBytesRecorded;
+    quint64 m_iNumberOfBytesRecordedSplit;
     quint64 m_split_size;
+	long m_split_time;
     int m_iNumberSplits;
-    QString m_durationRecorded;
+	long m_secondsRecorded;
+	long m_secondsRecordedSplit;
+	QString getRecordedDurationStr(quint64 duration);
 };
 
 #endif // RECORDINGMANAGER_H