moved broadcast settings to own class

9 files changed, 642 insertions, 218 deletions

diff --git a/build/depends.py b/build/depends.py
index a053970092..8c57f0f83f 100644
--- a/build/depends.py
+++ b/build/depends.py
@@ -647,6 +647,7 @@ class MixxxCore(Feature):
                    "preferences/dialog/dlgprefwaveform.cpp",
                    "preferences/settingsmanager.cpp",
                    "preferences/replaygainsettings.cpp",
+                   "preferences/broadcastsettings.cpp",
                    "preferences/upgrade.cpp",
                    "preferences/dlgpreferencepage.cpp",
 
diff --git a/src/engine/sidechain/enginebroadcast.cpp b/src/engine/sidechain/enginebroadcast.cpp
index ed3f427cb9..26047e0fef 100644
--- a/src/engine/sidechain/enginebroadcast.cpp
+++ b/src/engine/sidechain/enginebroadcast.cpp
@@ -37,7 +37,7 @@ EngineBroadcast::EngineBroadcast(UserSettingsPointer pConfig)
           m_iMetaDataLife(0),
           m_iShoutStatus(0),
           m_iShoutFailures(0),
-          m_pConfig(pConfig),
+          m_settings(pConfig),
           m_encoder(nullptr),
           m_pMasterSamplerate(new ControlProxy("[Master]", "samplerate")),
           m_custom_metadata(false),
@@ -166,8 +166,7 @@ void EngineBroadcast::updateFromPreferences() {
     // Convert a bunch of QStrings to QByteArrays so we can get regular C char*
     // strings to pass to libshout.
 
-    QString codec = m_pConfig->getValue(
-            ConfigKey(BROADCAST_PREF_KEY, "metadata_charset"));
+    QString codec = m_settings.getMetadataCharset();
     QByteArray baCodec = codec.toLatin1();
     m_pTextCodec = QTextCodec::codecForName(baCodec);
     if (!m_pTextCodec) {
@@ -178,11 +177,9 @@ void EngineBroadcast::updateFromPreferences() {
     // Indicates our metadata is in the provided charset.
     shout_metadata_add(m_pShoutMetaData, "charset",  baCodec.constData());
 
-    QString serverType = m_pConfig->getValue(
-            ConfigKey(BROADCAST_PREF_KEY, "servertype"));
+    QString serverType = m_settings.getServertype();
 
-    QString host = m_pConfig->getValue(
-                ConfigKey(BROADCAST_PREF_KEY, "host"));
+    QString host = m_settings.getHost();
     int start = host.indexOf(QLatin1String("//"));
     if (start == -1) {
         // the host part requires preceding //.
@@ -192,15 +189,10 @@ void EngineBroadcast::updateFromPreferences() {
     }
     QUrl serverUrl = host;
 
-    bool ok = false;
-    unsigned int port = m_pConfig->getValueString(
-            ConfigKey(BROADCAST_PREF_KEY, "port")).toUInt(&ok);
-    if (ok) {
-        serverUrl.setPort(port);
-    }
+    int port = m_settings.getPort();
+    serverUrl.setPort(port);
 
-    QString mountPoint = m_pConfig->getValueString(
-            ConfigKey(BROADCAST_PREF_KEY, "mountpoint")).toLatin1();
+    QString mountPoint = m_settings.getMountpoint();
     if (!mountPoint.isEmpty()) {
         if (!mountPoint.startsWith('/')) {
             mountPoint.prepend('/');
@@ -208,63 +200,43 @@ void EngineBroadcast::updateFromPreferences() {
         serverUrl.setPath(mountPoint);
     }
 
-    QString login = m_pConfig->getValue(
-            ConfigKey(BROADCAST_PREF_KEY, "login"));
+    QString login = m_settings.getLogin();
     if (!login.isEmpty()) {
         serverUrl.setUserName(login);
     }
 
     qDebug() << "Using server URL:" << serverUrl;
 
-    QByteArray baPassword = m_pConfig->getValueString(
-            ConfigKey(BROADCAST_PREF_KEY, "password")).toLatin1();
-    QByteArray baFormat = m_pConfig->getValueString(
-            ConfigKey(BROADCAST_PREF_KEY, "format")).toLatin1();
-    QByteArray baBitrate = m_pConfig->getValueString(
-            ConfigKey(BROADCAST_PREF_KEY, "bitrate")).toLatin1();
+    QByteArray baPassword = m_settings.getPassword().toLatin1();
+    QByteArray baFormat = m_settings.getFormat().toLatin1();
+    int iBitrate = m_settings.getBitrate();
 
     // Encode metadata like stream name, website, desc, genre, title/author with
     // the chosen TextCodec.
-    QByteArray baStreamName = encodeString(m_pConfig->getValueString(
-            ConfigKey(BROADCAST_PREF_KEY, "stream_name")));
-    QByteArray baStreamWebsite = encodeString(m_pConfig->getValueString(
-            ConfigKey(BROADCAST_PREF_KEY, "stream_website")));
-    QByteArray baStreamDesc = encodeString(m_pConfig->getValueString(
-            ConfigKey(BROADCAST_PREF_KEY, "stream_desc")));
-    QByteArray baStreamGenre = encodeString(m_pConfig->getValueString(
-            ConfigKey(BROADCAST_PREF_KEY, "stream_genre")));
+    QByteArray baStreamName = encodeString(m_settings.getStreamName());
+    QByteArray baStreamWebsite = encodeString(m_settings.getStreamWebsite());
+    QByteArray baStreamDesc = encodeString(m_settings.getStreamDesc());
+    QByteArray baStreamGenre = encodeString(m_settings.getStreamGenre());
 
     // Whether the stream is public.
-    bool streamPublic = m_pConfig->getValue(
-            ConfigKey(BROADCAST_PREF_KEY, "stream_public"), false);
+    bool streamPublic = m_settings.getStreamPublic();
 
     // Dynamic Ogg metadata update
-    m_ogg_dynamic_update = m_pConfig->getValue(
-            ConfigKey(BROADCAST_PREF_KEY,"ogg_dynamicupdate"), false);
+    m_ogg_dynamic_update = m_settings.getOggDynamicUpdate();
 
-    m_custom_metadata = m_pConfig->getValue(
-            ConfigKey(BROADCAST_PREF_KEY, "enable_metadata"), false);
-    m_customTitle = m_pConfig->getValue(
-            ConfigKey(BROADCAST_PREF_KEY, "custom_title"));
-    m_customArtist = m_pConfig->getValue(
-            ConfigKey(BROADCAST_PREF_KEY, "custom_artist"));
+    m_custom_metadata = m_settings.getEnableMetadata();
+    m_customTitle = m_settings.getCustomTitle();
+    m_customArtist = m_settings.getCustomArtist();
 
-    m_metadataFormat = m_pConfig->getValue(
-            ConfigKey(BROADCAST_PREF_KEY, "metadata_format"));
+    m_metadataFormat = m_settings.getMetadataFormat();
 
-    bool enableReconnect = m_pConfig->getValue(
-            ConfigKey(BROADCAST_PREF_KEY, "enable_reconnect"), true);
+    bool enableReconnect = m_settings.getEnableReconnect();
     if (enableReconnect) {
-        m_reconnectFirstDelay = m_pConfig->getValue(
-                ConfigKey(BROADCAST_PREF_KEY, "reconnect_first_delay"), 5.0);
-        m_reconnectPeriod = m_pConfig->getValue(
-                ConfigKey(BROADCAST_PREF_KEY, "reconnect_period"), 5.0);
-        m_noDelayFirstReconnect = m_pConfig->getValue(
-                ConfigKey(BROADCAST_PREF_KEY, "no_delay_first_reconnect"), 1);
-        m_limitReconnects = m_pConfig->getValue(
-                ConfigKey(BROADCAST_PREF_KEY, "limit_reconnects"), true);
-        m_maximumRetries = m_pConfig->getValue(
-                ConfigKey(BROADCAST_PREF_KEY, "maximum_retries"), 10);
+        m_reconnectFirstDelay = m_settings.getReconnectFirstDelay();
+        m_reconnectPeriod = m_settings.getReconnectPeriod();
+        m_noDelayFirstReconnect = m_settings.getNoDelayFirstReconnect();
+        m_limitReconnects = m_settings.getLimitReconnects();
+        m_maximumRetries = m_settings.getMaximumRetries();
     } else {
         m_limitReconnects = true;
         m_maximumRetries = 0;
@@ -345,11 +317,8 @@ void EngineBroadcast::updateFromPreferences() {
         return;
     }
 
-    bool bitrate_is_int = false;
-    int iBitrate = baBitrate.toInt(&bitrate_is_int);
-
-    if (!bitrate_is_int) {
-        qWarning() << "Error: unknown bitrate:" << baBitrate.constData();
+    if (iBitrate < 0) {
+        qWarning() << "Error: unknown bit rate:" << iBitrate;
     }
 
     int iMasterSamplerate = m_pMasterSamplerate->get();
@@ -362,7 +331,9 @@ void EngineBroadcast::updateFromPreferences() {
         return;
     }
 
-    if (shout_set_audio_info(m_pShout, SHOUT_AI_BITRATE, baBitrate.constData()) != SHOUTERR_SUCCESS) {
+    if (shout_set_audio_info(
+            m_pShout, SHOUT_AI_BITRATE,
+            QByteArray::number(iBitrate).constData()) != SHOUTERR_SUCCESS) {
         errorDialog(tr("Error setting bitrate"), shout_get_error(m_pShout));
         return;
     }
@@ -620,7 +591,7 @@ bool EngineBroadcast::writeSingle(const unsigned char* data, size_t len) {
         // try to flush queue after a short sleep
         qDebug() << "EngineBroadcast::writeSingle() SHOUTERR_BUSY, trying again";
         QThread::msleep(10); // wait 10 ms until "busy" is over. TODO() tweak for an optimum.
-        // if this fails, the queue is transmitted later
+        // if this fails, the queue is transmitted after the next regular shout_send_raw()
         (void)shout_send_raw(m_pShout, nullptr, 0);
     } else if (ret < SHOUTERR_SUCCESS) {
         m_lastErrorStr = shout_get_error(m_pShout);
diff --git a/src/engine/sidechain/enginebroadcast.h b/src/engine/sidechain/enginebroadcast.h
index 72e493a7e8..2929eac5eb 100644
--- a/src/engine/sidechain/enginebroadcast.h
+++ b/src/engine/sidechain/enginebroadcast.h
@@ -18,6 +18,7 @@
 #include "preferences/usersettings.h"
 #include "track/track.h"
 #include "util/fifo.h"
+#include "preferences/broadcastsettings.h"
 
 class Encoder;
 class ControlPushButton;
@@ -116,7 +117,7 @@ class EngineBroadcast
     int m_iMetaDataLife;
     long m_iShoutStatus;
     long m_iShoutFailures;
-    UserSettingsPointer m_pConfig;
+    BroadcastSettings m_settings;
     Encoder* m_encoder;
     ControlPushButton* m_pBroadcastEnabled;
     ControlProxy* m_pMasterSamplerate;
@@ -152,7 +153,6 @@ class EngineBroadcast
 
     QMutex m_enabledMutex;
     QWaitCondition m_waitEnabled;
-
 };
 
 #endif // ENGINE_SIDECHAIN_ENGINEBROADCAST_H
diff --git a/src/preferences/broadcastsettings.cpp b/src/preferences/broadcastsettings.cpp
new file mode 100644
index 0000000000..b80a471b59
--- /dev/null
+++ b/src/preferences/broadcastsettings.cpp
@@ -0,0 +1,417 @@
+#include "preferences/broadcastsettings.h"
+#include "defs_urls.h"
+
+namespace {
+const char* kConfigKey = "[Shoutcast]";
+
+const char* kBitrate = "bitrate";
+const char* kChannels = "channels";
+const char* kCustomArtist = "custom_artist";
+const char* kCustomTitle = "custom_title";
+const char* kEnableMetadata = "enable_metadata";
+const char* kEnableReconnect = "enable_reconnect";
+const char* kEnabled = "enabled";
+const char* kFormat = "format";
+const char* kHost = "host";
+const char* kLimitReconnects = "limit_reconnects";
+const char* kLogin = "login";
+const char* kMaximumRetries = "maximum_retries";
+const char* kMetadataCharset = "metadata_charset";
+const char* kMetadataFormat = "metadata_format";
+const char* kMountPoint = "mountpoint";
+const char* kNoDelayFirstReconnect = "no_delay_first_reconnect";
+const char* kOggDynamicUpdate = "ogg_dynamicupdate";
+const char* kPassword = "password";
+const char* kPort = "port";
+const char* kReconnectFirstDelay = "reconnect_first_delay";
+const char* kReconnectPeriod = "reconnect_period";
+const char* kServertype = "servertype";
+const char* kStreamDesc = "stream_desc";
+const char* kStreamGenre = "stream_genre";
+const char* kStreamName = "stream_name";
+const char* kStreamPublic = "stream_public";
+const char* kStreamWebsite = "stream_website";
+
+const double kDefaultBitrate = 128;
+const int kDefaultChannels = 2;
+const bool kDefaultEnableMetadata = false;
+const bool kDefaultEnableReconnect = true;
+const bool kDefaultLimitReconnects = true;
+const int kDefaultMaximumRetries = 10;
+// No tr() here, see https://bugs.launchpad.net/mixxx/+bug/1419500
+const QString kDefaultMetadataFormat("$artist - $title");
+const bool kDefaultNoDelayFirstReconnect = true;
+const bool kDefaultOggDynamicupdate = false;
+double kDefaultReconnectFirstDelay = 0.0;
+double kDefaultReconnectPeriod = 5.0;
+const QString kDefaultStreamDesc = QObject::tr("This stream is online for testing purposes!");
+const QString kDefaultStreamGenre = QObject::tr("Live Mix");
+const bool kDefaultStreamPublic = false;
+} // anonymous namespace
+
+BroadcastSettings::BroadcastSettings(UserSettingsPointer pConfig)
+    : m_pConfig(pConfig) {
+}
+
+int BroadcastSettings::getBitrate() const {
+    return m_pConfig->getValue(
+            ConfigKey(kConfigKey, kBitrate), getDefaultBitrate());
+}
+
+void BroadcastSettings::setBitrate(int value) {
+    m_pConfig->setValue(ConfigKey(kConfigKey, kBitrate), value);
+}
+
+int BroadcastSettings::getDefaultBitrate() const {
+    return kDefaultBitrate;
+}
+
+int BroadcastSettings::getChannels() const {
+    return m_pConfig->getValue(
+            ConfigKey(kConfigKey, kChannels), getDefaultChannels());
+}
+
+void BroadcastSettings::setChannels(int value) {
+    m_pConfig->setValue(ConfigKey(kConfigKey, kChannels), value);
+}
+
+int BroadcastSettings::getDefaultChannels() const {
+    return kDefaultChannels;
+}
+
+QString BroadcastSettings::getCustomArtist() const {
+    return m_pConfig->getValue(
+            ConfigKey(kConfigKey, kCustomArtist), getDefaultCustomArtist());
+
+}
+
+void BroadcastSettings::setCustomArtist(const QString& value) {
+    m_pConfig->setValue(ConfigKey(kConfigKey, kCustomArtist), value);
+}
+
+QString BroadcastSettings::getDefaultCustomArtist() const {
+    return QString();
+}
+
+QString BroadcastSettings::getCustomTitle() const {
+    return m_pConfig->getValue(
+            ConfigKey(kConfigKey, kCustomTitle), getDefaultCustomTitle());
+}
+
+void BroadcastSettings::setCustomTitle(const QString& value) {
+    m_pConfig->setValue(ConfigKey(kConfigKey, kCustomTitle), value);
+}
+
+QString BroadcastSettings::getDefaultCustomTitle() const {
+    return QString();
+}
+
+bool BroadcastSettings::getEnableMetadata() const {
+    return m_pConfig->getValue(
+            ConfigKey(kConfigKey, kEnableMetadata), getDefaultEnableMetadata());
+}
+
+void BroadcastSettings::setEnableMetadata(bool value) {
+    m_pConfig->setValue(ConfigKey(kConfigKey, kEnableMetadata), value);
+}
+
+bool BroadcastSettings::getDefaultEnableMetadata() const {
+    return kDefaultEnableMetadata;
+}
+
+bool BroadcastSettings::getEnableReconnect() const {
+    return m_pConfig->getValue(
+            ConfigKey(kConfigKey, kEnableReconnect), getDefaultEnableReconnect());
+}
+
+void BroadcastSettings::setEnableReconnect(bool value) {
+    m_pConfig->setValue(ConfigKey(kConfigKey, kEnableReconnect), value);
+}
+
+bool BroadcastSettings::getDefaultEnableReconnect() const {
+    return kDefaultEnableReconnect;
+}
+
+// Unused, but we keep this to reserve the name
+bool BroadcastSettings::getEnabled() const {
+    return m_pConfig->getValue(
+            ConfigKey(kConfigKey, kEnabled), true);
+}
+
+void BroadcastSettings::setEnabled(bool value) {
+    m_pConfig->setValue(ConfigKey(kConfigKey, kEnabled), value);
+}
+
+QString BroadcastSettings::getFormat() const {
+    return m_pConfig->getValue(
+            ConfigKey(kConfigKey, kFormat), getDefaultFormat());
+}
+
+void BroadcastSettings::setFormat(const QString& value) {
+    m_pConfig->setValue(ConfigKey(kConfigKey, kFormat), value);
+}
+
+QString BroadcastSettings::getDefaultFormat() const {
+    return QString();
+}
+
+QString BroadcastSettings::getHost() const {
+    return m_pConfig->getValue(
+            ConfigKey(kConfigKey, kHost), getDefaultHost());
+}
+
+void BroadcastSettings::setHost(const QString& value) {
+    m_pConfig->setValue(ConfigKey(kConfigKey, kHost), value);
+}
+
+QString BroadcastSettings::getDefaultHost() const {
+    return QString();
+}
+
+bool BroadcastSettings::getLimitReconnects() const {
+    return m_pConfig->getValue(
+            ConfigKey(kConfigKey, kLimitReconnects), getDefaultLimitReconnects());
+}
+
+void BroadcastSettings::setLimitReconnects(bool value) {
+    m_pConfig->setValue(ConfigKey(kConfigKey, kLimitReconnects), value);
+}
+
+bool BroadcastSettings::getDefaultLimitReconnects() const {
+    return kDefaultLimitReconnects;
+}
+
+QString BroadcastSettings::getLogin() const {
+    return m_pConfig->getValue(
+            ConfigKey(kConfigKey, kLogin), getDefaultLogin());
+}
+
+void BroadcastSettings::setLogin(const QString& value) {
+    m_pConfig->setValue(ConfigKey(kConfigKey, kLogin), value);
+}
+
+QString BroadcastSettings::getDefaultLogin() const {
+    return QString();
+}
+
+int BroadcastSettings::getMaximumRetries() const {
+    return m_pConfig->getValue(
+            ConfigKey(kConfigKey, kMaximumRetries), getDefaultMaximumRetries());
+}
+
+void BroadcastSettings::setMaximumRetries(int value) {
+    m_pConfig->setValue(ConfigKey(kConfigKey, kMaximumRetries), value);
+}
+
+int BroadcastSettings::getDefaultMaximumRetries() const {
+    return kDefaultMaximumRetries;
+}
+
+QString BroadcastSettings::getMetadataCharset() const {
+    return m_pConfig->getValue(
+            ConfigKey(kConfigKey, kMetadataCharset));
+}
+
+void BroadcastSettings::setMetadataCharset(const QString& value) {
+    m_pConfig->setValue(ConfigKey(kConfigKey, kMetadataCharset), value);
+}
+
+QString BroadcastSettings::getDefaultMetadataCharset() const {
+    return QString();
+}
+
+QString BroadcastSettings::getMetadataFormat() const {
+    return m_pConfig->getValue(
+                ConfigKey(kConfigKey, kMetadataFormat),
+                // No tr() here, see https://bugs.launchpad.net/mixxx/+bug/1419500
+                getDefaultMetadataFormat());
+}
+
+void BroadcastSettings::setMetadataFormat(const QString& value) {
+    m_pConfig->setValue(ConfigKey(kConfigKey, kMetadataFormat), value);
+}
+
+QString BroadcastSettings::getDefaultMetadataFormat() const {
+    return kDefaultMetadataFormat;
+}
+
+QString BroadcastSettings::getMountpoint() const {
+    return m_pConfig->getValue(
+            ConfigKey(kConfigKey, kMountPoint));
+}
+
+void BroadcastSettings::setMountPoint(const QString& value) {
+    m_pConfig->setValue(ConfigKey(kConfigKey, kMountPoint), value);
+}
+
+QString BroadcastSettings::getDefaultMountpoint() const {
+    return QString();
+}
+
+bool BroadcastSettings::getNoDelayFirstReconnect() const {
+    return m_pConfig->getValue(
+            ConfigKey(kConfigKey, kNoDelayFirstReconnect),
+            getDefaultNoDelayFirstReconnect());
+}
+
+void BroadcastSettings::setNoDelayFirstReconnect(bool value) {
+    m_pConfig->setValue(ConfigKey(kConfigKey, kNoDelayFirstReconnect), value);
+}
+
+bool BroadcastSettings::getDefaultNoDelayFirstReconnect() const {
+    return kDefaultNoDelayFirstReconnect;
+}
+
+bool BroadcastSettings::getOggDynamicUpdate() const {
+    return m_pConfig->getValue(
+            ConfigKey(kConfigKey, kOggDynamicUpdate), false);
+}
+
+void BroadcastSettings::setOggDynamicUpdate(bool value) {
+    m_pConfig->setValue(ConfigKey(kConfigKey, kOggDynamicUpdate), value);
+}
+
+bool BroadcastSettings::getDefaultOggDynamicUpdate() const {
+    return kDefaultOggDynamicupdate;
+}
+
+QString BroadcastSettings::getPassword() const {
+    return m_pConfig->getValue(
+            ConfigKey(kConfigKey, kPassword), getDefaultPassword());
+}
+
+void BroadcastSettings::setPassword(const QString& value) {
+    m_pConfig->setValue(ConfigKey(kConfigKey, kPassword), value);
+}
+
+QString BroadcastSettings::getDefaultPassword() const {
+    return QString();
+}
+
+int BroadcastSettings::getPort() const {
+    // Valid port numbers are 0 .. 65535 (16 bit unsigned)
+    int port =  m_pConfig->getValue(
+            ConfigKey(kConfigKey, kPort), getDefaultPort());
+    if (port < 0 || port > 0xFFFF) {
+        return -1;
+    }
+    return port;
+}
+
+void BroadcastSettings::setPort(int value) {
+    m_pConfig->setValue(ConfigKey(kConfigKey, kPort), value);
+}
+
+int BroadcastSettings::getDefaultPort() const {
+    return -1;
+}
+
+double BroadcastSettings::getReconnectFirstDelay() const {
+    return m_pConfig->getValue(
+            ConfigKey(kConfigKey, kReconnectFirstDelay),
+            getDefaultReconnectFirstDelay());
+}
+
+void BroadcastSettings::setReconnectFirstDelay(double value) {
+    m_pConfig->setValue(ConfigKey(kConfigKey, kReconnectFirstDelay), value);
+}
+
+double BroadcastSettings::getDefaultReconnectFirstDelay() const {
+    return kDefaultReconnectFirstDelay;
+}
+
+double BroadcastSettings::getReconnectPeriod() const {
+    return m_pConfig->getValue(
+            ConfigKey(kConfigKey, kReconnectPeriod),
+            getDefaultReconnectPeriod());
+}
+
+void BroadcastSettings::setReconnectPeriod(double value) {
+    m_pConfig->setValue(ConfigKey(kConfigKey, kReconnectPeriod), value);
+}
+
+double BroadcastSettings::getDefaultReconnectPeriod() const {
+    return kDefaultReconnectPeriod;
+}
+
+QString BroadcastSettings::getServertype() const {
+    return m_pConfig->getValue(
+            ConfigKey(kConfigKey, kServertype), getDefaultServertype());
+}
+
+void BroadcastSettings::setServertype(const QString& value) {
+    m_pConfig->set(ConfigKey(kConfigKey, kServertype),
+            ConfigValue(value));
+}
+
+QString BroadcastSettings::getDefaultServertype() const {
+    return QString();
+}
+
+QString BroadcastSettings::getStreamDesc() const {
+    return m_pConfig->getValue(
+            ConfigKey(kConfigKey, kStreamDesc),
+            getDefaultStreamDesc());
+}
+
+void BroadcastSettings::setStreamDesc(const QString& value) {
+    m_pConfig->setValue(ConfigKey(kConfigKey, kStreamDesc), value);
+}
+
+QString BroadcastSettings::getDefaultStreamDesc() const {
+    return kDefaultStreamDesc;
+}
+
+QString BroadcastSettings::getStreamGenre() const {
+    return m_pConfig->getValue(
+            ConfigKey(kConfigKey, kStreamGenre),
+            getDefaultStreamGenre());
+}
+
+void BroadcastSettings::setStreamGenre(const QString& value) {
+    m_pConfig->setValue(ConfigKey(kConfigKey, kStreamGenre), value);
+}
+
+QString BroadcastSettings::getDefaultStreamGenre() const {
+    return kDefaultStreamGenre;
+}
+
+QString BroadcastSettings::getStreamName() const {
+    return m_pConfig->getValue(
+            ConfigKey(kConfigKey, kStreamName),
+            getDefaultStreamName());
+}
+
+void BroadcastSettings::setStreamName(const QString& value) {
+    m_pConfig->setValue(ConfigKey(kConfigKey, kStreamName), value);
+}
+
+QString BroadcastSettings::getDefaultStreamName() const {
+    return QString();
+}
+
+bool BroadcastSettings::getStreamPublic() const {
+    return m_pConfig->getValue(
+            ConfigKey(kConfigKey, kStreamPublic), false);
+}
+
+void BroadcastSettings::setStreamPublic(bool value) {
+    m_pConfig->setValue(ConfigKey(kConfigKey, kStreamPublic), value);
+}
+
+bool BroadcastSettings::getDefaultStreamPublic() const {
+    return kDefaultStreamPublic;
+}
+
+QString BroadcastSettings::getStreamWebsite() const {
+    return m_pConfig->getValue(
+            ConfigKey(kConfigKey, kStreamWebsite), getDefaultStreamWebsite());
+}
+
+void BroadcastSettings::setStreamWebsite(const QString& value) {
+    m_pConfig->setValue(ConfigKey(kConfigKey, kStreamWebsite), value);
+}
+
+QString BroadcastSettings::getDefaultStreamWebsite() const {
+    return MIXXX_WEBSITE_URL;
+}
diff --git a/src/preferences/broadcastsettings.h b/src/preferences/broadcastsettings.h
new file mode 100644
index 0000000000..9c759bed5b
--- /dev/null
+++ b/src/preferences/broadcastsettings.h
@@ -0,0 +1,97 @@
+#ifndef PREFERENCES_BROADCASTSETTINGS_H
+#define PREFERENCES_BROADCASTSETTINGS_H
+
+#include "preferences/usersettings.h"
+#include "track/track.h"
+
+class BroadcastSettings {
+  public:
+    BroadcastSettings(UserSettingsPointer pConfig);
+
+    int getBitrate() const;
+    void setBitrate(int value);
+    int getDefaultBitrate() const;
+    int getChannels() const;
+    void setChannels(int value);
+    int getDefaultChannels() const;
+    QString getCustomArtist() const;
+    void setCustomArtist(const QString& value);
+    QString getDefaultCustomArtist() const;
+    QString getCustomTitle() const;
+    void setCustomTitle(const QString& value);
+    QString getDefaultCustomTitle() const;
+    bool getEnableMetadata() const;
+    void setEnableMetadata(bool value);
+    bool getDefaultEnableMetadata() const;
+    bool getEnableReconnect() const;
+    void setEnableReconnect(bool value);
+    bool getDefaultEnableReconnect() const;
+    bool getEnabled() const;
+    void setEnabled(bool value);
+    QString getFormat() const;
+    void setFormat(const QString& value);
+    QString getDefaultFormat() const;
+    QString getHost() const;
+    void setHost(const QString& value);
+    QString getDefaultHost() const;
+    bool getLimitReconnects() const;
+    void setLimitReconnects(bool value);
+    bool getDefaultLimitReconnects() const;
+    QString getLogin() const;
+    void setLogin(const QString& value);
+    QString getDefaultLogin() const;
+    int getMaximumRetries() const;
+    void setMaximumRetries(int value);
+    int getDefaultMaximumRetries() const;
+    QString getMetadataCharset() const;
+    void setMetadataCharset(const QString& value);
+    QString getDefaultMetadataCharset() const;
+    QString getMetadataFormat() const;
+    void setMetadataFormat(const QString& value);
+    QString getDefaultMetadataFormat() const;
+    QString getMountpoint() const;
+    void setMountPoint(const QString& value);
+    QString getDefaultMountpoint() const;
+    bool getNoDelayFirstReconnect() const;
+    void setNoDelayFirstReconnect(bool value);
+    bool getDefaultNoDelayFirstReconnect() const;
+    bool getOggDynamicUpdate() const;
+    void setOggDynamicUpdate(bool value);
+    bool getDefaultOggDynamicUpdate() const;
+    QString getPassword() const;
+    void setPassword(const QString& value);
+    QString getDefaultPassword() const;
+    int getPort() const;
+    void setPort(int value);
+    int getDefaultPort() const;
+    double getReconnectFirstDelay() const;
+    void setReconnectFirstDelay(double value);
+    double getDefaultReconnectFirstDelay() const;
+    double getReconnectPeriod() const;
+    void setReconnectPeriod(double value);
+    double getDefaultReconnectPeriod() const;
+    QString getServertype() const;
+    void setServertype(const QString& value);
+    QString getDefaultServertype() const;
+    QString getStreamDesc() const;
+    void setStreamDesc(const QString& value);
+    QString getDefaultStreamDesc() const;
+    QString getStreamGenre() const;
+    void setStreamGenre(const QString& value);
+    QString getDefaultStreamGenre() const;
+    QString getStreamName() const;
+    void setStreamName(const QString& value);
+    QString getDefaultStreamName() const;
+    bool getStreamPublic() const;
+    void setStreamPublic(bool value);
+    bool getDefaultStreamPublic() const;
+    QString getStreamWebsite() const;
+    void setStreamWebsite(const QString& value);
+    QString getDefaultStreamWebsite() const;
+
+  private:
+    // Pointer to config object
+    UserSettingsPointer m_pConfig;
+};
+
+#endif /* PREFERENCES_BROADCASTSETTINGS_H */
diff --git a/src/preferences/configobject.cpp b/src/preferences/configobject.cpp
index 446c6d778c..fc0c5a4ddd 100644
--- a/src/preferences/configobject.cpp
+++ b/src/preferences/configobject.cpp
@@ -303,6 +303,12 @@ void ConfigObject<ConfigValue>::setValue(
 }
 
 template <> template <>
+void ConfigObject<ConfigValue>::setValue(
+        const ConfigKey& key, const double& value) {
+    set(key, ConfigValue(QString::number(value)));
+}
+
+template <> template <>
 bool ConfigObject<ConfigValue>::getValue(
         const ConfigKey& key, const bool& default_value) const {
     const ConfigValue value = get(key);
diff --git a/src/preferences/dialog/dlgprefbroadcast.cpp b/src/preferences/dialog/dlgprefbroadcast.cpp
index 3ce4bdcc76..5cba6f33ee 100644
--- a/src/preferences/dialog/dlgprefbroadcast.cpp
+++ b/src/preferences/dialog/dlgprefbroadcast.cpp
@@ -5,11 +5,9 @@
 #include "defs_urls.h"
 #include "preferences/dialog/dlgprefbroadcast.h"
 
-static const char* kDefaultMetadataFormat = "$artist - $title";
-
 DlgPrefBroadcast::DlgPrefBroadcast(QWidget *parent, UserSettingsPointer _config)
         : DlgPreferencePage(parent),
-          m_pConfig(_config) {
+          m_settings(_config) {
     setupUi(this);
 
     m_pBroadcastEnabled = new ControlProxy(
@@ -27,38 +25,31 @@ DlgPrefBroadcast::DlgPrefBroadcast(QWidget *parent, UserSettingsPointer _config)
     comboBoxServerType->addItem(tr("Shoutcast 1"), BROADCAST_SERVER_SHOUTCAST);
     comboBoxServerType->addItem(tr("Icecast 1"), BROADCAST_SERVER_ICECAST1);
 
-    int tmp_index = comboBoxServerType->findData(m_pConfig->getValueString(
-            ConfigKey(BROADCAST_PREF_KEY, "servertype")));
-    if (tmp_index < 0) { //Set default if invalid.
+    int tmp_index = comboBoxServerType->findData(m_settings.getServertype());
+    if (tmp_index < 0) { // Set default if invalid.
         tmp_index = 0;
     }
     comboBoxServerType->setCurrentIndex(tmp_index);
 
     // Mountpoint
-    mountpoint->setText(m_pConfig->getValueString(
-            ConfigKey(BROADCAST_PREF_KEY, "mountpoint")));
+    mountpoint->setText(m_settings.getMountpoint());
 
     // Host
-    host->setText(m_pConfig->getValueString(
-            ConfigKey(BROADCAST_PREF_KEY, "host")));
+    host->setText(m_settings.getHost());
 
     // Port
-    QString tmp_string = m_pConfig->getValueString(
-            ConfigKey(BROADCAST_PREF_KEY, "port"));
-    port->setText(tmp_string);
+    QString portString = QString::number(m_settings.getPort());
+    port->setText(portString);
 
     // Login
-    login->setText(m_pConfig->getValueString(
-            ConfigKey(BROADCAST_PREF_KEY, "login")));
+    login->setText(m_settings.getLogin());
 
     // Password
-    password->setText(m_pConfig->getValueString(
-            ConfigKey(BROADCAST_PREF_KEY, "password")));
+    password->setText(m_settings.getPassword());
 
 
     // Enable automatic reconnect
-    bool enableReconnect = m_pConfig->getValue(
-            ConfigKey(BROADCAST_PREF_KEY, "enable_reconnect"), true);
+    bool enableReconnect = m_settings.getEnableReconnect();
     checkBoxEnableReconnect->setChecked(enableReconnect);
     widgetReconnectControls->setEnabled(enableReconnect);
     connect(checkBoxEnableReconnect, SIGNAL(stateChanged(int)),
@@ -66,16 +57,13 @@ DlgPrefBroadcast::DlgPrefBroadcast(QWidget *parent, UserSettingsPointer _config)
 
 
     // Wait until first attempt
-    spinBoxFirstDelay->setValue(m_pConfig->getValue(
-            ConfigKey(BROADCAST_PREF_KEY, "reconnect_first_delay"), 0.0));
+    spinBoxFirstDelay->setValue(m_settings.getReconnectFirstDelay());
 
     // Retry Delay
-    spinBoxReconnectPeriod->setValue(m_pConfig->getValue(
-            ConfigKey(BROADCAST_PREF_KEY, "reconnect_period"), 5.0));
+    spinBoxReconnectPeriod->setValue(m_settings.getReconnectPeriod());
 
     // Use Maximum Retries
-    bool limitConnects = m_pConfig->getValue(
-            ConfigKey(BROADCAST_PREF_KEY, "limit_reconnects"), true);
+    bool limitConnects = m_settings.getLimitReconnects();
     checkBoxLimitReconnects->setChecked(
             limitConnects);
     spinBoxMaximumRetries->setEnabled(limitConnects);
@@ -83,42 +71,23 @@ DlgPrefBroadcast::DlgPrefBroadcast(QWidget *parent, UserSettingsPointer _config)
             this, SLOT(checkBoxLimitReconnectsChanged(int)));
 
     // Maximum Retries
-    spinBoxMaximumRetries->setValue(m_pConfig->getValue(
-            ConfigKey(BROADCAST_PREF_KEY, "maximum_retries"), 10));
+    spinBoxMaximumRetries->setValue(m_settings.getMaximumRetries());
 
 
     // Stream "public" checkbox
-    stream_public->setChecked(m_pConfig->getValue(
-            ConfigKey(BROADCAST_PREF_KEY, "stream_public"), false));
+    stream_public->setChecked(m_settings.getStreamPublic());
 
     // Stream name
-    stream_name->setText(m_pConfig->getValueString(
-            ConfigKey(BROADCAST_PREF_KEY, "stream_name")));
+    stream_name->setText(m_settings.getStreamName());
 
     // Stream website
-    tmp_string = m_pConfig->getValueString(
-            ConfigKey(BROADCAST_PREF_KEY,"stream_website"));
-    if (tmp_string.isEmpty()) {
-        tmp_string = MIXXX_WEBSITE_URL;
-    }
-    stream_website->setText(tmp_string);
+    stream_website->setText(m_settings.getStreamWebsite());
 
     // Stream description
-    tmp_string = m_pConfig->getValueString(
-            ConfigKey(BROADCAST_PREF_KEY,"stream_desc"));
-    if (tmp_string.isEmpty()) {
-        tmp_string = tr("This stream is online for testing purposes!");
-    }
-    stream_desc->setText(tmp_string);
+    stream_desc->setText(m_settings.getStreamDesc());
 
     // Stream genre
-    tmp_string = m_pConfig->getValueString(
-            ConfigKey(BROADCAST_PREF_KEY,"stream_genre"));
-    if (tmp_string.isEmpty()) {
-        tmp_string = tr("Live Mix");
-    }
-    stream_genre->setText(tmp_string);
-
+    stream_genre->setText(m_settings.getStreamGenre());
 
     // Encoding bitrate combobox
     QString kbps_pattern = QString("%1 kbps");
@@ -140,8 +109,7 @@ DlgPrefBroadcast::DlgPrefBroadcast(QWidget *parent, UserSettingsPointer _config)
                 kbps_pattern.arg(QString::number(kbps)), kbps);
     }
 
-    tmp_index = comboBoxEncodingBitrate->findData(m_pConfig->getValueString(
-            ConfigKey(BROADCAST_PREF_KEY, "bitrate")).toInt());
+    tmp_index = comboBoxEncodingBitrate->findData(m_settings.getBitrate());
     if (tmp_index < 0) {
         tmp_index = comboBoxEncodingBitrate->findData(BROADCAST_BITRATE_128KBPS);
     }
@@ -150,8 +118,7 @@ DlgPrefBroadcast::DlgPrefBroadcast(QWidget *parent, UserSettingsPointer _config)
     // Encoding format combobox
     comboBoxEncodingFormat->addItem(tr("MP3"), BROADCAST_FORMAT_MP3);
     comboBoxEncodingFormat->addItem(tr("Ogg Vorbis"), BROADCAST_FORMAT_OV);
-    tmp_index = comboBoxEncodingFormat->findData(m_pConfig->getValueString(
-            ConfigKey(BROADCAST_PREF_KEY, "format")));
+    tmp_index = comboBoxEncodingFormat->findData(m_settings.getFormat());
     if (tmp_index < 0) {
         // Set default of MP3 if invalid.
         tmp_index = 0;
@@ -160,33 +127,23 @@ DlgPrefBroadcast::DlgPrefBroadcast(QWidget *parent, UserSettingsPointer _config)
 
     // Encoding channels combobox
     comboBoxEncodingChannels->addItem(tr("Stereo"), BROADCAST_CHANNELS_ST