Made transcoding optional

src/ui/SettingsView.cpp

@@ -21,6 +21,7 @@
 
 #include <Wt/WString.h>
 #include <Wt/WPushButton.h>
+#include <Wt/WCheckBox.h>
 #include <Wt/WComboBox.h>
 #include <Wt/WLineEdit.h>
 
@@ -40,8 +41,9 @@ class SettingsModel : public Wt::WFormModel
 {
 	public:
 		// Associate each field with a unique string literal.
-		static const Field BitrateField;
-		static const Field EncodingField;
+		static const Field TranscodeEnableField;
+		static const Field TranscodeFormatField;
+		static const Field TranscodeBitrateField;
 		static const Field PasswordField;
 		static const Field PasswordConfirmField;
 
@@ -50,49 +52,57 @@ class SettingsModel : public Wt::WFormModel
 		{
 			initializeModels();
 
-			addField(BitrateField);
-			addField(EncodingField);
+			addField(TranscodeEnableField);
+			addField(TranscodeBitrateField);
+			addField(TranscodeFormatField);
 			addField(PasswordField);
 			addField(PasswordConfirmField);
 
-			setValidator(BitrateField, createMandatoryValidator());
-			setValidator(EncodingField, createMandatoryValidator());
+			setValidator(TranscodeBitrateField, createMandatoryValidator());
+			setValidator(TranscodeFormatField, createMandatoryValidator());
 
 			loadData();
 		}
 
-		std::shared_ptr<Wt::WAbstractItemModel> bitrateModel() { return _bitrateModel; }
-		std::shared_ptr<Wt::WAbstractItemModel> encodingModel() { return _encodingModel; }
+		std::shared_ptr<Wt::WAbstractItemModel> transcodeBitrateModel() { return _transcodeBitrateModel; }
+		std::shared_ptr<Wt::WAbstractItemModel> transcodeFormatModel() { return _transcodeFormatModel; }
 
 		void loadData()
 		{
-			Wt::Dbo::Transaction transaction(LmsApp->getDboSession());
+			Wt::Dbo::Transaction transaction {LmsApp->getDboSession()};
 
-			auto bitrate = getBitrateRow(LmsApp->getUser()->getAudioBitrate());
-			if (bitrate)
-				setValue(BitrateField, bitrateString(*bitrate));
+			setValue(TranscodeEnableField, LmsApp->getUser()->getAudioTranscodeEnable());
+			if (!LmsApp->getUser()->getAudioTranscodeEnable())
+			{
+				setReadOnly(TranscodeFormatField, true);
+				setReadOnly(TranscodeBitrateField, true);
+			}
 
-			auto encodingRow = getEncodingRow(LmsApp->getUser()->getAudioEncoding());
-			if (encodingRow)
-				setValue(EncodingField, encodingString(*encodingRow));
+			auto transcodeBitrateRow {getTranscodeBitrateRow(LmsApp->getUser()->getAudioTranscodeBitrate())};
+			if (transcodeBitrateRow)
+				setValue(TranscodeBitrateField, transcodeBitrateString(*transcodeBitrateRow));
 
+			auto transcodeFormatRow {getTranscodeFormatRow(LmsApp->getUser()->getAudioTranscodeFormat())};
+			if (transcodeFormatRow)
+				setValue(TranscodeFormatField, transcodeFormatString(*transcodeFormatRow));
 		}
 
 		void saveData()
 		{
-			Wt::Dbo::Transaction transaction(LmsApp->getDboSession());
+			Wt::Dbo::Transaction transaction {LmsApp->getDboSession()};
 
-			auto bitrateRow = getBitrateRow(Wt::asString(value(BitrateField)));
-			assert(bitrateRow);
-			LmsApp->getUser().modify()->setAudioBitrate(bitrate(*bitrateRow));
+			LmsApp->getUser().modify()->setAudioTranscodeEnable(Wt::asNumber(value(TranscodeEnableField)));
 
-			auto encodingRow = getEncodingRow(Wt::asString(value(EncodingField)));
-			LmsApp->getUser().modify()->setAudioEncoding(encoding(*encodingRow));
+			auto transcodeBitrateRow {getTranscodeBitrateRow(Wt::asString(value(TranscodeBitrateField)))};
+			if (transcodeBitrateRow)
+				LmsApp->getUser().modify()->setAudioTranscodeBitrate(transcodeBitrate(*transcodeBitrateRow));
+
+			auto transcodeFormatRow {getTranscodeFormatRow(Wt::asString(value(TranscodeFormatField)))};
+			if (transcodeFormatRow)
+				LmsApp->getUser().modify()->setAudioTranscodeFormat(transcodeFormat(*transcodeFormatRow));
 
 			if (!valueText(PasswordField).empty())
-			{
 				Database::Handler::getPasswordService().updatePassword(LmsApp->getAuthUser(), valueText(PasswordField));
-			}
 		}
 
 		bool validateField(Field field)
@@ -130,72 +140,72 @@ class SettingsModel : public Wt::WFormModel
 			return (validation(field).state() == Wt::ValidationState::Valid);
 		}
 
-		boost::optional<int> getBitrateRow(Wt::WString value)
+		boost::optional<int> getTranscodeBitrateRow(Wt::WString value)
 		{
-			for (int i = 0; i < _bitrateModel->rowCount(); ++i)
+			for (int i = 0; i < _transcodeBitrateModel->rowCount(); ++i)
 			{
-				if (bitrateString(i) == value)
+				if (transcodeBitrateString(i) == value)
 					return i;
 			}
 
 			return boost::none;
 		}
 
-		boost::optional<int> getBitrateRow(std::size_t value)
+		boost::optional<int> getTranscodeBitrateRow(std::size_t value)
 		{
-			for (int i = 0; i < _bitrateModel->rowCount(); ++i)
+			for (int i = 0; i < _transcodeBitrateModel->rowCount(); ++i)
 			{
-				if (bitrate(i) == value)
+				if (transcodeBitrate(i) == value)
 					return i;
 			}
 
 			return boost::none;
 		}
 
-		std::size_t bitrate(int row)
+		std::size_t transcodeBitrate(int row)
 		{
 			return Wt::cpp17::any_cast<std::size_t>
-				(_bitrateModel->data(_bitrateModel->index(row, 0), Wt::ItemDataRole::User));
+				(_transcodeBitrateModel->data(_transcodeBitrateModel->index(row, 0), Wt::ItemDataRole::User));
 		}
 
-		Wt::WString bitrateString(int row)
+		Wt::WString transcodeBitrateString(int row)
 		{
 			return Wt::cpp17::any_cast<Wt::WString>
-				(_bitrateModel->data(_bitrateModel->index(row, 0), Wt::ItemDataRole::Display));
+				(_transcodeBitrateModel->data(_transcodeBitrateModel->index(row, 0), Wt::ItemDataRole::Display));
 		}
 
-		boost::optional<int> getEncodingRow(Wt::WString value)
+		boost::optional<int> getTranscodeFormatRow(Wt::WString value)
 		{
-			for (int i = 0; i < _encodingModel->rowCount(); ++i)
+			for (int i = 0; i < _transcodeFormatModel->rowCount(); ++i)
 			{
-				if (encodingString(i) == value)
+				if (transcodeFormatString(i) == value)
 					return i;
 			}
 
 			return boost::none;
 		}
 
-		boost::optional<int> getEncodingRow(Database::AudioEncoding enc)
+		boost::optional<int> getTranscodeFormatRow(Database::AudioFormat format)
 		{
-			for (int i = 0; i < _encodingModel->rowCount(); ++i)
+			for (int i = 0; i < _transcodeFormatModel->rowCount(); ++i)
 			{
-				if (encoding(i) == enc)
+				if (transcodeFormat(i) == format)
 					return i;
 			}
 
 			return boost::none;
 		}
 
-		Database::AudioEncoding encoding(int row)
+		Database::AudioFormat transcodeFormat(int row)
 		{
-			return Wt::cpp17::any_cast<Database::AudioEncoding>
-				(_encodingModel->data(_encodingModel->index(row, 0), Wt::ItemDataRole::User));
+			return Wt::cpp17::any_cast<Database::AudioFormat>
+				(_transcodeFormatModel->data(_transcodeFormatModel->index(row, 0), Wt::ItemDataRole::User));
 		}
 
-		Wt::WString encodingString(int row)
+		Wt::WString transcodeFormatString(int row)
 		{
 			return Wt::cpp17::any_cast<Wt::WString>
-				(_encodingModel->data(_encodingModel->index(row, 0), Wt::ItemDataRole::Display));
+				(_transcodeFormatModel->data(_transcodeFormatModel->index(row, 0), Wt::ItemDataRole::Display));
 		}
 
 
@@ -203,52 +213,50 @@ class SettingsModel : public Wt::WFormModel
 
 		void initializeModels()
 		{
-			_bitrateModel = std::make_shared<Wt::WStringListModel>();
+			_transcodeBitrateModel = std::make_shared<Wt::WStringListModel>();
 
-			std::size_t maxAudioBitrate;
+			Database::Bitrate maxAudioBitrate;
 			{
-				Wt::Dbo::Transaction transaction(LmsApp->getDboSession());
-				maxAudioBitrate = LmsApp->getUser()->getMaxAudioBitrate();
+				Wt::Dbo::Transaction transaction {LmsApp->getDboSession()};
+				maxAudioBitrate = LmsApp->getUser()->getMaxAudioTranscodeBitrate();
 			}
 
 			std::size_t id = 0;
-			for (std::size_t bitrate : Database::User::audioBitrates)
+			for (Database::Bitrate bitrate : Database::User::audioTranscodeAllowedBitrates)
 			{
 				if (bitrate > maxAudioBitrate)
 					break;
 
-				_bitrateModel->addString( Wt::WString::fromUTF8(std::to_string(bitrate / 1000)) );
-				_bitrateModel->setData( id, 0, bitrate, Wt::ItemDataRole::User);
+				_transcodeBitrateModel->addString( Wt::WString::fromUTF8(std::to_string(bitrate / 1000)) );
+				_transcodeBitrateModel->setData( id, 0, bitrate, Wt::ItemDataRole::User);
 				id++;
 			}
 
-			_encodingModel = std::make_shared<Wt::WStringListModel>();
+			_transcodeFormatModel = std::make_shared<Wt::WStringListModel>();
 
-			_encodingModel->addString(Wt::WString::tr("Lms.Settings.encoding.auto"));
-			_encodingModel->setData(0, 0, Database::AudioEncoding::AUTO, Wt::ItemDataRole::User);
+			_transcodeFormatModel->addString(Wt::WString::tr("Lms.Settings.transcoding.mp3"));
+			_transcodeFormatModel->setData(0, 0, Database::AudioFormat::MP3, Wt::ItemDataRole::User);
 
-			_encodingModel->addString(Wt::WString::tr("Lms.Settings.encoding.mp3"));
-			_encodingModel->setData(1, 0, Database::AudioEncoding::MP3, Wt::ItemDataRole::User);
+			_transcodeFormatModel->addString(Wt::WString::tr("Lms.Settings.transcoding.ogg_opus"));
+			_transcodeFormatModel->setData(1, 0, Database::AudioFormat::OGG_OPUS, Wt::ItemDataRole::User);
 
-			_encodingModel->addString(Wt::WString::tr("Lms.Settings.encoding.ogg_opus"));
-			_encodingModel->setData(2, 0, Database::AudioEncoding::OGG_OPUS, Wt::ItemDataRole::User);
+			_transcodeFormatModel->addString(Wt::WString::tr("Lms.Settings.transcoding.ogg_vorbis"));
+			_transcodeFormatModel->setData(2, 0, Database::AudioFormat::OGG_VORBIS, Wt::ItemDataRole::User);
 
-			_encodingModel->addString(Wt::WString::tr("Lms.Settings.encoding.ogg_vorbis"));
-			_encodingModel->setData(3, 0, Database::AudioEncoding::OGG_VORBIS, Wt::ItemDataRole::User);
-
-			_encodingModel->addString(Wt::WString::tr("Lms.Settings.encoding.webm_vorbis"));
-			_encodingModel->setData(4, 0, Database::AudioEncoding::WEBM_VORBIS, Wt::ItemDataRole::User);
+			_transcodeFormatModel->addString(Wt::WString::tr("Lms.Settings.transcoding.webm_vorbis"));
+			_transcodeFormatModel->setData(3, 0, Database::AudioFormat::WEBM_VORBIS, Wt::ItemDataRole::User);
 		}
 
-		std::shared_ptr<Wt::WStringListModel>	_bitrateModel;
-		std::shared_ptr<Wt::WStringListModel>	_encodingModel;
+		std::shared_ptr<Wt::WStringListModel>	_transcodeBitrateModel;
+		std::shared_ptr<Wt::WStringListModel>	_transcodeFormatModel;
 
 };
 
-const Wt::WFormModel::Field SettingsModel::BitrateField		= "bitrate";
-const Wt::WFormModel::Field SettingsModel::EncodingField	= "encoding";
-const Wt::WFormModel::Field SettingsModel::PasswordField	= "password";
-const Wt::WFormModel::Field SettingsModel::PasswordConfirmField	= "password-confirm";
+const Wt::WFormModel::Field SettingsModel::TranscodeEnableField		= "transcoding-enable";
+const Wt::WFormModel::Field SettingsModel::TranscodeBitrateField	= "transcoding-bitrate";
+const Wt::WFormModel::Field SettingsModel::TranscodeFormatField		= "transcoding-format";
+const Wt::WFormModel::Field SettingsModel::PasswordField		= "password";
+const Wt::WFormModel::Field SettingsModel::PasswordConfirmField		= "password-confirm";
 
 SettingsView::SettingsView()
 {
@@ -268,39 +276,53 @@ SettingsView::refreshView()
 
 	clear();
 
-	auto t = addNew<Wt::WTemplateFormView>(Wt::WString::tr("Lms.Settings.template"));
+	auto t {addNew<Wt::WTemplateFormView>(Wt::WString::tr("Lms.Settings.template"))};
 
-	auto model = std::make_shared<SettingsModel>();
+	auto model {std::make_shared<SettingsModel>()};
 
 	// Password
-	auto password = std::make_unique<Wt::WLineEdit>();
+	auto password {std::make_unique<Wt::WLineEdit>()};
 	password->setEchoMode(Wt::EchoMode::Password);
 	t->setFormWidget(SettingsModel::PasswordField, std::move(password));
 
 	// Password confirm
-	auto passwordConfirm = std::make_unique<Wt::WLineEdit>();
+	auto passwordConfirm {std::make_unique<Wt::WLineEdit>()};
 	passwordConfirm->setEchoMode(Wt::EchoMode::Password);
 	t->setFormWidget(SettingsModel::PasswordConfirmField, std::move(passwordConfirm));
 
-	// Bitrate
-	auto bitrate = std::make_unique<Wt::WComboBox>();
-	bitrate->setModel(model->bitrateModel());
-	t->setFormWidget(SettingsModel::BitrateField, std::move(bitrate));
+	// Transcoding
+	auto transcode {std::make_unique<Wt::WCheckBox>()};
+	auto* transcodeRaw {transcode.get()};
+	t->setFormWidget(SettingsModel::TranscodeEnableField, std::move(transcode));
 
-	// Encoding
-	auto encoding = std::make_unique<Wt::WComboBox>();
-	encoding->setModel(model->encodingModel());
-	t->setFormWidget(SettingsModel::EncodingField, std::move(encoding));
+	// Format
+	auto transcodeFormat {std::make_unique<Wt::WComboBox>()};
+	transcodeFormat->setModel(model->transcodeFormatModel());
+	t->setFormWidget(SettingsModel::TranscodeFormatField, std::move(transcodeFormat));
+
+	// Bitrate
+	auto transcodeBitrate {std::make_unique<Wt::WComboBox>()};
+	transcodeBitrate->setModel(model->transcodeBitrateModel());
+	t->setFormWidget(SettingsModel::TranscodeBitrateField, std::move(transcodeBitrate));
+
+	transcodeRaw->changed().connect([=]()
+	{
+		bool enable {transcodeRaw->checkState() == Wt::CheckState::Checked};
+		model->setReadOnly(SettingsModel::TranscodeFormatField, !enable);
+		model->setReadOnly(SettingsModel::TranscodeBitrateField, !enable);
+		t->updateModel(model.get());
+		t->updateView(model.get());
+	});
 
 	// Buttons
-	Wt::WPushButton *saveBtn = t->bindWidget("apply-btn", std::make_unique<Wt::WPushButton>(Wt::WString::tr("Lms.apply")));
-	Wt::WPushButton *discardBtn = t->bindWidget("discard-btn", std::make_unique<Wt::WPushButton>(Wt::WString::tr("Lms.discard")));
+	Wt::WPushButton *saveBtn {t->bindWidget("apply-btn", std::make_unique<Wt::WPushButton>(Wt::WString::tr("Lms.apply")))};
+	Wt::WPushButton *discardBtn {t->bindWidget("discard-btn", std::make_unique<Wt::WPushButton>(Wt::WString::tr("Lms.discard")))};
 
 	saveBtn->clicked().connect(std::bind([=] ()
 	{
 
 		{
-			Wt::Dbo::Transaction transaction(LmsApp->getDboSession());
+			Wt::Dbo::Transaction transaction {LmsApp->getDboSession()};
 
 			if (LmsApp->getUser()->isDemo())
 			{

src/ui/admin/UserView.cpp

@@ -45,7 +45,7 @@ class UserModel : public Wt::WFormModel
 	public:
 		static const Field LoginField;
 		static const Field PasswordField;
-		static const Field BitrateLimitField;
+		static const Field AudioTranscodeBitrateLimitField;
 		static const Field DemoField;
 
 		UserModel(boost::optional<Database::IdType> userId)
@@ -59,7 +59,7 @@ class UserModel : public Wt::WFormModel
 			}
 
 			addField(PasswordField);
-			addField(BitrateLimitField);
+			addField(AudioTranscodeBitrateLimitField);
 			addField(DemoField);
 
 			if (!_userId)
@@ -76,7 +76,7 @@ class UserModel : public Wt::WFormModel
 			if (!_userId)
 				return;
 
-			Wt::Dbo::Transaction transaction(LmsApp->getDboSession());
+			Wt::Dbo::Transaction transaction {LmsApp->getDboSession()};
 
 			auto authUser = LmsApp->getDb().getUserDatabase().findWithId( std::to_string(*_userId) );
 			auto user = LmsApp->getDb().getUser(authUser);
@@ -84,14 +84,14 @@ class UserModel : public Wt::WFormModel
 			if (user == LmsApp->getUser())
 				throw LmsException("Cannot edit ourselves");
 
-			auto bitrate = getBitrateLimitRow(user->getMaxAudioBitrate());
+			auto bitrate {getTranscodeBitrateLimitRow(user->getMaxAudioTranscodeBitrate())};
 			if (bitrate)
-				setValue(BitrateLimitField, bitrateLimitString(*bitrate));
+				setValue(AudioTranscodeBitrateLimitField, transcodeBitrateLimitString(*bitrate));
 		}
 
 		void saveData()
 		{
-			Wt::Dbo::Transaction transaction(LmsApp->getDboSession());
+			Wt::Dbo::Transaction transaction {LmsApp->getDboSession()};
 
 			if (_userId)
 			{
@@ -103,9 +103,9 @@ class UserModel : public Wt::WFormModel
 				if (!valueText(PasswordField).empty())
 					Database::Handler::getPasswordService().updatePassword(authUser, valueText(PasswordField));
 
-				auto bitrateLimitRow = getBitrateLimitRow(Wt::asString(value(BitrateLimitField)));
-				user.modify()->setMaxAudioBitrate(bitrateLimit(*bitrateLimitRow));
-				LMS_LOG(UI, DEBUG) << "Max audio bitrate set to " << bitrateLimit(*bitrateLimitRow);
+				auto transcodeBitrateLimitRow = getTranscodeBitrateLimitRow(Wt::asString(value(AudioTranscodeBitrateLimitField)));
+				user.modify()->setMaxAudioTranscodeBitrate(transcodeBitrateLimit(*transcodeBitrateLimitRow));
+				LMS_LOG(UI, DEBUG) << "Max audio bitrate set to " << transcodeBitrateLimit(*transcodeBitrateLimitRow);
 			}
 			else
 			{
@@ -117,8 +117,8 @@ class UserModel : public Wt::WFormModel
 				authUser.setIdentity(Wt::Auth::Identity::LoginName, valueText(LoginField));
 				Database::Handler::getPasswordService().updatePassword(authUser, valueText(PasswordField));
 
-				auto bitrateLimitRow = getBitrateLimitRow(Wt::asString(value(BitrateLimitField)));
-				user.modify()->setMaxAudioBitrate(bitrateLimit(*bitrateLimitRow));
+				auto transcodeBitrateLimitRow = getTranscodeBitrateLimitRow(Wt::asString(value(AudioTranscodeBitrateLimitField)));
+				user.modify()->setMaxAudioTranscodeBitrate(transcodeBitrateLimit(*transcodeBitrateLimitRow));
 
 				if (Wt::asNumber(value(DemoField)))
 					user.modify()->setType(Database::User::Type::DEMO);
@@ -168,7 +168,7 @@ class UserModel : public Wt::WFormModel
 			}
 			else if (field == DemoField)
 			{
-				Wt::Dbo::Transaction transaction(LmsApp->getDboSession());
+				Wt::Dbo::Transaction transaction {LmsApp->getDboSession()};
 
 				if (Wt::asNumber(value(DemoField)) && Database::User::getDemo(LmsApp->getDboSession()))
 					error = Wt::WString::tr("Lms.Admin.User.demo-account-already-exists");
@@ -182,35 +182,35 @@ class UserModel : public Wt::WFormModel
 			return false;
 		}
 
-		boost::optional<int> getBitrateLimitRow(Wt::WString value)
+		boost::optional<int> getTranscodeBitrateLimitRow(Wt::WString value)
 		{
 			for (int i = 0; i < _bitrateModel->rowCount(); ++i)
 			{
-				if (bitrateLimitString(i) == value)
+				if (transcodeBitrateLimitString(i) == value)
 					return i;
 			}
 
 			return boost::none;
 		}
 
-		boost::optional<int> getBitrateLimitRow(std::size_t value)
+		boost::optional<int> getTranscodeBitrateLimitRow(std::size_t value)
 		{
 			for (int i = 0; i < _bitrateModel->rowCount(); ++i)
 			{
-				if (bitrateLimit(i) == value)
+				if (transcodeBitrateLimit(i) == value)
 					return i;
 			}
 
 			return boost::none;
 		}
 
-		std::size_t bitrateLimit(int row)
+		std::size_t transcodeBitrateLimit(int row)
 		{
 			return Wt::cpp17::any_cast<std::size_t>
 				(_bitrateModel->data(_bitrateModel->index(row, 0), Wt::ItemDataRole::User));
 		}
 
-		Wt::WString bitrateLimitString(int row)
+		Wt::WString transcodeBitrateLimitString(int row)
 		{
 			return Wt::cpp17::any_cast<Wt::WString>
 				(_bitrateModel->data(_bitrateModel->index(row, 0), Wt::ItemDataRole::Display));
@@ -225,7 +225,7 @@ class UserModel : public Wt::WFormModel
 			_bitrateModel = std::make_shared<Wt::WStringListModel>();
 
 			std::size_t id = 0;
-			for (auto bitrate : Database::User::audioBitrates)
+			for (auto bitrate : Database::User::audioTranscodeAllowedBitrates)
 			{
 				_bitrateModel->addString( Wt::WString::fromUTF8(std::to_string(bitrate / 1000)) );
 				_bitrateModel->setData( id++, 0, bitrate, Wt::ItemDataRole::User);
@@ -240,7 +240,7 @@ class UserModel : public Wt::WFormModel
 
 const Wt::WFormModel::Field UserModel::LoginField = "login";
 const Wt::WFormModel::Field UserModel::PasswordField = "password";
-const Wt::WFormModel::Field UserModel::BitrateLimitField = "audio-bitrate-limit";
+const Wt::WFormModel::Field UserModel::AudioTranscodeBitrateLimitField = "audio-transcode-bitrate-limit";
 const Wt::WFormModel::Field UserModel::DemoField = "demo";
 
 UserView::UserView()
@@ -293,10 +293,10 @@ UserView::refreshView()
 	passwordEdit->setEchoMode(Wt::EchoMode::Password);
 	t->setFormWidget(UserModel::PasswordField, std::move(passwordEdit));
 
-	// Bitrate
+	// Transcode bitrate limit
 	auto bitrate = std::make_unique<Wt::WComboBox>();
 	bitrate->setModel(model->bitrateModel());
-	t->setFormWidget(UserModel::BitrateLimitField, std::move(bitrate));
+	t->setFormWidget(UserModel::AudioTranscodeBitrateLimitField, std::move(bitrate));
 
 	// Demo account
 	t->setFormWidget(UserModel::DemoField, std::make_unique<Wt::WCheckBox>());

src/ui/explore/TracksView.cpp

@@ -77,12 +77,12 @@ _filters(filters)
 }
 
 std::vector<Database::Track::pointer>
-Tracks::getTracks(int offset, int size, bool& moreResults)
+Tracks::getTracks(boost::optional<std::size_t> offset, boost::optional<std::size_t> size, bool& moreResults)
 {
-	auto searchKeywords = splitString(_search->text().toUTF8(), " ");
-	auto clusterIds = _filters->getClusterIds();
+	auto searchKeywords {splitString(_search->text().toUTF8(), " ")};
+	auto clusterIds {_filters->getClusterIds()};
 
-	Wt::Dbo::Transaction transaction(LmsApp->getDboSession());
+	Wt::Dbo::Transaction transaction {LmsApp->getDboSession()};
 
 	return Track::getByFilter(LmsApp->getDboSession(), clusterIds, searchKeywords, offset, size, moreResults);
 }
@@ -91,7 +91,7 @@ std::vector<Database::Track::pointer>
 Tracks::getTracks()
 {
 	bool moreResults;
-	return getTracks(-1, -1, moreResults);
+	return getTracks({}, {}, moreResults);
 }
 
 void
@@ -104,15 +104,15 @@ Tracks::refresh()
 void
 Tracks::addSome()
 {
-	Wt::Dbo::Transaction transaction(LmsApp->getDboSession());
+	Wt::Dbo::Transaction transaction {LmsApp->getDboSession()};
 
 	bool moreResults;
-	auto tracks = getTracks(_tracksContainer->count(), 20, moreResults);
+	auto tracks {getTracks(_tracksContainer->count(), 20, moreResults)};
 
 	for (auto track : tracks)
 	{
-		auto trackId = track.id();
-		Wt::WTemplate* entry = _tracksContainer->addNew<Wt::WTemplate>(Wt::WString::tr("Lms.Explore.Tracks.template.entry"));
+		auto trackId {track.id()};
+		Wt::WTemplate* entry {_tracksContainer->addNew<Wt::WTemplate>(Wt::WString::tr("Lms.Explore.Tracks.template.entry"))};
 
 		entry->bindString("name", Wt::WString::fromUTF8(track->getName()), Wt::TextFormat::Plain);
 

src/ui/explore/TracksView.hpp

@@ -45,7 +45,7 @@ class Tracks : public Wt::WTemplate
 		void refresh();
 		void addSome();
 
-		std::vector<Database::Track::pointer> getTracks(int offset, int size, bool& moreResults);
+		std::vector<Database::Track::pointer> getTracks(boost::optional<std::size_t> offset, boost::optional<std::size_t> size, bool& moreResults);
 		std::vector<Database::Track::pointer> getTracks();
 
 		Wt::WContainerWidget* _tracksContainer;

src/ui/resource/AudioResource.cpp

@@ -49,8 +49,6 @@ AudioResource::handleRequest(const Wt::Http::Request& request,
 {
 	std::shared_ptr<Av::Transcoder> transcoder;
 
-	LMS_LOG(UI, DEBUG) << "Handling new request...";
-
 	// First, see if this request is for a continuation
 	Wt::Http::ResponseContinuation *continuation = request.continuation();
 	if (continuation)
@@ -62,8 +60,9 @@ AudioResource::handleRequest(const Wt::Http::Request& request,
 	{
 		Database::IdType trackId;
 		Av::TranscodeParameters parameters {};
+		parameters.stripMetadata = true;
 
-		LMS_LOG(UI, DEBUG) << "No continuation yet";
+		LMS_LOG(UI, DEBUG) << "First request: creating transcoder";
 		try
 		{
 			auto trackIdStr = request.getParameter("trackid");
@@ -75,8 +74,7 @@ AudioResource::handleRequest(const Wt::Http::Request& request,
 			trackId = std::stol(*request.getParameter("trackid"));
 
 			auto offsetStr = request.getParameter("offset");
-			if (offsetStr)
-				parameters.offset = std::chrono::seconds(std::stol(*offsetStr));
+			parameters.offset = std::chrono::seconds(offsetStr ? std::stol(*offsetStr) : 0);
 		}
 		catch (std::exception &e)
 		{
@@ -98,34 +96,35 @@ AudioResource::handleRequest(const Wt::Http::Request& request,
 				return;
 			}
 
-			parameters.bitrate = LmsApp->getUser()->getAudioBitrate();
-
-			switch (LmsApp->getUser()->getAudioEncoding())
+			if (LmsApp->getUser()->getAudioTranscodeEnable())
 			{
-				case Database::AudioEncoding::AUTO:
-				case Database::AudioEncoding::MP3:
-					parameters.encoding = Av::Encoding::MP3;
-					break;
-				case Database::AudioEncoding::OGG_OPUS:
-					parameters.encoding = Av::Encoding::OGG_OPUS;
-					break;
-				case Database::AudioEncoding::OGG_VORBIS:
-					parameters.encoding = Av::Encoding::OGG_VORBIS;
-					break;
-				case Database::AudioEncoding::WEBM_VORBIS:
-					parameters.encoding = Av::Encoding::WEBM_VORBIS;
-					break;
-				default:
-					parameters.encoding = Av::Encoding::MP3;
-					break;
+				parameters.bitrate = LmsApp->getUser()->getAudioTranscodeBitrate();
+
+				switch (LmsApp->getUser()->getAudioTranscodeFormat())
+				{
+					case Database::AudioFormat::MP3:
+						parameters.encoding = Av::Encoding::MP3;
+						break;
+					case Database::AudioFormat::OGG_OPUS:
+						parameters.encoding = Av::Encoding::OGG_OPUS;
+						break;
+					case Database::AudioFormat::OGG_VORBIS:
+						parameters.encoding = Av::Encoding::OGG_VORBIS;
+						break;
+					case Database::AudioFormat::WEBM_VORBIS:
+						parameters.encoding = Av::Encoding::WEBM_VORBIS;
+						break;
+					default:
+						parameters.encoding = Av::Encoding::OGG_OPUS;
+						break;
+				}
 			}
+			else
+				parameters.bitrate = 0;
+
 			transcoder = std::make_shared<Av::Transcoder>(track->getPath(), parameters);
 		}
 
-		std::string mimeType = Av::encodingToMimetype(transcoder->getParameters().encoding);
-
-		LMS_LOG(UI, DEBUG) << "Mime type set to '" << mimeType << "'";
-		response.setMimeType(mimeType);
 
 		if (!transcoder->start())
 		{
@@ -134,6 +133,11 @@ AudioResource::handleRequest(const Wt::Http::Request& request,
 		}
 
 		LMS_LOG(UI, DEBUG) << "Transcoder started";
+
+		std::string mimeType {transcoder->getOutputMimeType()};
+		response.setMimeType(mimeType);
+		LMS_LOG(UI, DEBUG) << "Mime type set to '" << mimeType << "'";
+
 	}
 
 	if (!transcoder->isComplete())
@@ -144,7 +148,7 @@ AudioResource::handleRequest(const Wt::Http::Request& request,
 		transcoder->process(data, _chunkSize);
 
 		response.out().write(reinterpret_cast<char*>(&data[0]), data.size());
-		LMS_LOG(UI, DEBUG) << "Written " << data.size() << " bytes! complete = " << std::boolalpha << transcoder->isComplete();
+		LMS_LOG(UI, DEBUG) << "Written " << data.size() << " bytes! complete = " << (transcoder->isComplete() ? "true" : "false");
 
 		if (!response.out())
 		{