LibreMediaServer/lms-audio
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity

cambio a un vector de CueTrack en vex de CueTrackWidget.

Browse source 
CueTrackListWidget ahora posee el contenedor de CueTracks y muestra un
QTableWidget con info de las CueTracks.
This commit is contained in:
snt 2024-06-20 14:56:15 +02:00
parent 3b98be8b14
commit 84702c5e44
15 changed files with 265 additions and 652 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

11
libremediaserver-audio.pro
View file

@ -4,7 +4,6 @@ QT += webkitwidgets widgets
HEADERS += src/libremediaserver-audio.h \
src/editcuetrackwidget.h \
src/cuetracklistwidget.h \
src/cuetrackwidget.h \
src/showplayer.h \
src/clickabledoublespinbox.h \
src/clickablelabel.h \
@ -24,11 +23,9 @@ HEADERS += src/libremediaserver-audio.h \
src/audiowidget.h \
src/defines.h \
src/settings.h \
src/slidergroup.h \
src/trackdialog.h
src/slidergroup.h
SOURCES += src/main.cpp \
src/editcuetrackwidget.cpp \
src/cuetrackwidget.cpp \
src/showplayer.cpp \
src/clickabledoublespinbox.cpp \
src/clickablelabel.cpp \
@ -45,8 +42,7 @@ SOURCES += src/main.cpp \
src/audiolayerwidget.cpp \
src/audiowidget.cpp \
src/settings.cpp \
src/slidergroup.cpp \
src/trackdialog.cpp
src/slidergroup.cpp
FORMS += \
src/showplayer.ui \
src/libremediaserver-audio-ui.ui
@ -61,3 +57,6 @@ OTHER_FILES += \
docs/changelog.txt \
docs/lms-audio.xlm \
docs/roadmap.txt
SOURCES += \
src/cuetracklistwidget.cpp

4
src/audiolayerwidget.cpp
View file

@ -275,10 +275,10 @@ void AudioLayerWidget::setMediaFile(QString file)
int size = list.size();
if (size >= 2) {
QString tmp = list.at(size - 2);
tmp.truncate(60);
tmp.truncate(64);
m_folderValue->setText(tmp);
tmp = list.at(size - 1);
tmp.truncate(40);
tmp.truncate(64);
m_fileValue->setText(tmp);
}
}

134
src/cuetracklistwidget.h
View file

@ -1,128 +1,46 @@
#ifndef CUETRACKLISTWIDGET_H
#define CUETRACKLISTWIDGET_H
#include <vector>
#include <QWidget>
#include <QScrollArea>
#include <QEvent>
#include <QKeyEvent>
#include <QShortcut>
#include "cuetrackwidget.h"
#include <QVBoxLayout>
#include <QTableWidget>
#include <QTableWidgetItem>
#include "defines.h"
#include "editcuetrackwidget.h"
class CueTrackListWidget : public QWidget {
Q_OBJECT
public:
size_t m_size = 0;
size_t size() const { return m_size; }
size_t selectedIndex = 0;
explicit CueTrackListWidget(QWidget *parent = nullptr) : QWidget(parent) {
layout = new QVBoxLayout();
containerWidget = new QWidget();
containerWidget->setLayout(layout);
scrollArea = new QScrollArea(this);
scrollArea->setWidgetResizable(true);
scrollArea->setWidget(containerWidget);
QVBoxLayout* mainLayout = new QVBoxLayout(this);
mainLayout->addWidget(scrollArea);
layout->setAlignment(Qt::AlignTop);
setLayout(mainLayout);
QShortcut *shortcut_up = new QShortcut(QKeySequence("Up"), parent);
QObject::connect(shortcut_up, SIGNAL(activated()), this, SLOT(key_up()));
QShortcut *shortcut_down = new QShortcut(QKeySequence("Down"), parent);
QObject::connect(shortcut_down, SIGNAL(activated()), this, SLOT(key_down()));
}
void addCueTrackWidget(CueTrackWidget* widget) {
widget->setParent(containerWidget);
layout->addWidget(widget);
if (m_size == 0)
widget->setStyle(true);
widget->show();
m_size++;
containerWidget->update();
containerWidget->adjustSize();
}
void removeCueTrackWidget(size_t index) {
if (index >= m_size) return;
QLayoutItem* item = layout->takeAt(index);
if (item) {
delete item->widget();
delete item;
m_size--;
}
}
CueTrackWidget* getTrackAtIndex(size_t index) {
if (index < m_size) {
return qobject_cast<CueTrackWidget*>(layout->itemAt(index)->widget());
}
return nullptr;
}
CueTrackWidget* getSelectedTrack() {
CueTrackWidget* track = getTrackAtIndex(selectedIndex);
key_down();
return track;
}
explicit CueTrackListWidget(QWidget *parent = nullptr);
CueTrack* getSelectedTrack();
void createNewCueTrack();
void editCueTrack();
void deleteCueTrack();
private:
QScrollArea* scrollArea;
QWidget* containerWidget;
std::vector<CueTrack *> cueTracks;
QVBoxLayout* layout;
QTableWidget* tableWidget;
int m_size = 0;
int size() { return m_size; }
int selectedIndex = 0;
size_t lastUserCueNumber = 0;
private slots:
void key_up() {
if (m_size > 0 && selectedIndex > 0) {
getTrackAtIndex(selectedIndex)->setStyle(false);
selectedIndex--;
getTrackAtIndex(selectedIndex)->setStyle(true);
}
}
void key_down() {
if (selectedIndex < m_size - 1 && m_size > 0) {
getTrackAtIndex(selectedIndex)->setStyle(false);
selectedIndex++;
getTrackAtIndex(selectedIndex)->setStyle(true);
}
}
void displayCueTrackInTable(QTableWidget* tableWidget, const CueTrack& cueTrack) {
// Configura las columnas si aún no están configuradas
if (tableWidget->columnCount() == 0) {
tableWidget->setColumnCount(5); // Ajusta según el número de propiedades a mostrar
QStringList headers = {"Nombre", "Volumen", "Pan", "Pitch", "Estado"};
tableWidget->setHorizontalHeaderLabels(headers);
}
int currentRow = tableWidget->rowCount();
tableWidget->insertRow(currentRow);
// Nombre
tableWidget->setItem(currentRow, 0, new QTableWidgetItem(cueTrack.name));
// Volumen
tableWidget->setItem(currentRow, 1, new QTableWidgetItem(QString::number(cueTrack.volume)));
// Pan
tableWidget->setItem(currentRow, 2, new QTableWidgetItem(QString::number(cueTrack.pan)));
// Pitch
tableWidget->setItem(currentRow, 3, new QTableWidgetItem(QString::number(cueTrack.pitch)));
// Estado
QString statusStr; // Asume que tienes una función para convertir el estado a QString
statusStr = statusToString(cueTrack.status); // Implementa esta función según tu lógica
tableWidget->setItem(currentRow, 4, new QTableWidgetItem(statusStr));
}
void addCueTrack(CueTrack* cue);
void removeCueTrack(int index);
CueTrack* getTrackAtIndex(int index);
void key_up();
void key_down();
void displayCueTrackInTable(CueTrack *cueTrack);
void keyPressEvent(QKeyEvent* event);
void updateSelectedCueTrack(bool highlightRow);
void cueTrackLoadDefaults(CueTrack * t);
void copyCueTrack(CueTrack *src, CueTrack *dst);
};
#endif

183
src/cuetrackwidget.cpp
View file

@ -1,183 +0,0 @@
#include "cuetrackwidget.h"
#include "editcuetrackwidget.h"
#include <QSplitter>
CueTrackWidget::CueTrackWidget(QWidget *parent) : QWidget(parent) {
setupUi();
}
void CueTrackWidget::setupUi() {
QVBoxLayout *layout = new QVBoxLayout(this);
QSplitter *row = new QSplitter(Qt::Horizontal);
active = new QCheckBox(this);
row->addWidget(active);
userNumberSpin = new QSpinBox(this);
userNumberSpin->setRange(0, 100000);
userNumberSpin->setToolTip("Cue user number");
row->addWidget(userNumberSpin);
audioLayer = new QSpinBox(this);
audioLayer->setRange(0, MAX_LAYERS);
audioLayer->setToolTip("Audio Layer");
row->addWidget(audioLayer);
nameEdit = new QLineEdit(this);
nameEdit->setToolTip("Cue Name");
row->addWidget(nameEdit);
descriptionEdit = new QLineEdit(this);
descriptionEdit->setToolTip("Cue Notes");
filePathEdit = new QLineEdit(this);
filePathEdit->setToolTip("File name");
volumeSpin = new ClickableDoubleSpinBox(this);
volumeSpin->setRange(0.0f, 100.0f);
volumeSpin->setToolTip("Volume");
volumeSpin->setSpecialValueText("-inf");
volumeSpin->setValue(75.0f);
bus1Spin = new ClickableDoubleSpinBox(this);
bus1Spin->setRange(0.0f, 100.0f);
bus1Spin->setToolTip("Bus 1");
bus1Spin->setSpecialValueText("-inf");
bus1Spin->setValue(100.0f);
bus2Spin = new ClickableDoubleSpinBox(this);
bus2Spin->setRange(0.0f, 100.0f);
bus2Spin->setToolTip("Bus 2");
bus2Spin->setSpecialValueText("-inf");
bus2Spin->setValue(100.0f);
panSpin = new ClickableDoubleSpinBox(this);
panSpin->setRange(-1, 1);
panSpin->setToolTip("Pan");
panSpin->setValue(0);
pitchSpin = new ClickableDoubleSpinBox(this);
pitchSpin->setRange(0, 2);
pitchSpin->setSpecialValueText("Stop");
pitchSpin->setToolTip("Pitch");
pitchSpin->setValue(1);
entryPointSpin = new QSpinBox(this);
entryPointSpin->setRange(0, 255);
entryPointSpin->setToolTip("Entry Point");
exitPointSpin = new QSpinBox(this);
exitPointSpin->setRange(0, 255);
exitPointSpin->setToolTip("Exit Point");
exitPointSpin->setValue(255);
setupStatusCombo();
statusCombo->setToolTip("Playback Status");
row->addWidget(userNumberSpin);
fadeInSpin = new QSpinBox(this);
fadeInSpin->setRange(0, 10000);
fadeInSpin->setToolTip("Fade In Time");
fadeInSpin->setValue(3);
fadeOutSpin = new QSpinBox(this);
fadeOutSpin->setRange(0, 10000);
fadeOutSpin->setToolTip("Fade Out Time");
fadeOutSpin->setValue(3);
waitInSpin = new QSpinBox(this);
waitInSpin->setRange(0, 10000);
waitInSpin->setToolTip("Wait In Time");
waitOutSpin = new QSpinBox(this);
waitOutSpin->setRange(0, 10000);
waitOutSpin->setToolTip("Wait Out Time");
stopAtEndCheck = new QCheckBox(this);
stopAtEndCheck->setToolTip("Halt");
stopAtEndCheck->setChecked("True");
editButton = new QPushButton("Edit", this);
editButton->setToolTip("Edit");
row->addWidget(editButton);
connect(editButton, &QPushButton::clicked, this, &CueTrackWidget::editButtonClicked);
layout->setSpacing(0);
layout->setContentsMargins(0, 0, 0, 0);
layout->addWidget(row);
setLayout(layout);
setStyle(false);
}
void CueTrackWidget::setStyle(bool highlight) {
QString style;
style.append("margin: 1px;");
if (highlight)
style.append("background-color: #e8e0f8;");
else
style.append("background-color: #b9b8a7;");
this->setStyleSheet(style);
}
void CueTrackWidget::setupStatusCombo() {
statusCombo = new QComboBox(this);
statusCombo->addItem("Stopped", Stopped);
statusCombo->addItem("Paused", Paused);
statusCombo->addItem("PlayingOnce", PlayingOnce);
statusCombo->addItem("PlayingLoop", PlayingLoop);
statusCombo->addItem("Iddle", Iddle);
statusCombo->addItem("PlayingFolder", PlayingFolder);
statusCombo->addItem("PlayingFolderLoop", PlayingFolderLoop);
statusCombo->addItem("PlayingFolderRandom", PlayingFolderRandom);
}
void CueTrackWidget::loadCueTrack(const CueTrack &cueTrack) {
filePathEdit->setText(QString::fromStdString(cueTrack.filePath));
volumeSpin->setValue(cueTrack.volume);
panSpin->setValue(cueTrack.pan);
pitchSpin->setValue(cueTrack.pitch);
bus1Spin->setValue(cueTrack.bus1);
bus2Spin->setValue(cueTrack.bus2);
fadeInSpin->setValue(cueTrack.fadeIn);
fadeOutSpin->setValue(cueTrack.fadeOut);
waitInSpin->setValue(cueTrack.waitIn);
waitOutSpin->setValue(cueTrack.waitOut);
stopAtEndCheck->setChecked(cueTrack.stopAtEnd);
nameEdit->setText(QString::fromStdString(cueTrack.name));
descriptionEdit->setText(QString::fromStdString(cueTrack.description));
userNumberSpin->setValue(cueTrack.userNumber);
entryPointSpin->setValue(cueTrack.entryPoint);
exitPointSpin->setValue(cueTrack.exitPoint);
statusCombo->setCurrentIndex(statusCombo->findData(cueTrack.status));
}
CueTrack CueTrackWidget::saveCueTrack() const {
CueTrack cueTrack;
cueTrack.filePath = filePathEdit->text().toStdString();
cueTrack.volume = volumeSpin->value();
cueTrack.pan = panSpin->value();
cueTrack.pitch = pitchSpin->value();
cueTrack.bus1 = bus1Spin->value();
cueTrack.bus2 = bus2Spin->value();
cueTrack.fadeIn = fadeInSpin->value();
cueTrack.fadeOut = fadeOutSpin->value();
cueTrack.waitIn = waitInSpin->value();
cueTrack.waitOut = waitOutSpin->value();
cueTrack.stopAtEnd = stopAtEndCheck->isChecked();
cueTrack.name = nameEdit->text().toStdString();
cueTrack.description = descriptionEdit->text().toStdString();
cueTrack.userNumber = userNumberSpin->value();
cueTrack.entryPoint = entryPointSpin->value();
cueTrack.exitPoint = exitPointSpin->value();
cueTrack.status = static_cast<Status>(statusCombo->currentData().toInt());
return cueTrack;
}
void CueTrackWidget::editButtonClicked() {
EditCueTrackWidget editor;
editor.loadCueTrack(saveCueTrack());
if (editor.exec() == QDialog::Accepted) {
loadCueTrack(editor.saveCueTrack());
}
}

225
src/cuetrackwidget.h
View file

@ -1,225 +0,0 @@
#ifndef CUETRACKWIDGET_H
#define CUETRACKWIDGET_H
#include <QWidget>
#include <QLineEdit>
#include <QSpinBox>
#include <QComboBox>
#include <QFormLayout>
#include <QCheckBox>
#include <QLabel>
#include <QPushButton>
#include <QDialog>
#include "defines.h"
#include "clickabledoublespinbox.h"
class CueTrackWidget : public QWidget {
Q_OBJECT
public:
explicit CueTrackWidget(QWidget *parent = nullptr);
CueTrack track;
CueTrack saveCueTrack() const;
void loadCueTrack(const CueTrack &cueTrack);
int getVolume() const { return volumeSpin->value() * 2.55f * 255.0f; }
int getPan() const { return (panSpin->value() * 128) + 128; }
int getPitch() const { return pitchSpin->value() * 128; }
int getBus1() const { return bus1Spin->value() * 2.55f * 255.0f; }
int getBus2() const { return bus2Spin->value() * 2.55f * 255.0f; }
Status getStatus() const { return static_cast<Status>(statusCombo->currentIndex()); }
QString getFilePath() const { return filePathEdit->text(); }
void setFilePath(QString text) const { filePathEdit->setText(text);};
int getFadeIn() const { return fadeInSpin->value(); }
int getFadeOut() const { return fadeOutSpin->value(); }
int getWaitIn() const { return waitInSpin->value(); }
int getWaitOut() const { return waitOutSpin->value(); }
bool getStopAtEnd() const { return stopAtEndCheck->isChecked(); }
QString getName() const { return nameEdit->text(); }
QString getDescription() const { return descriptionEdit->text(); }
int getUserNumber() const { return userNumberSpin->value(); }
int getEntryPoint() const { return entryPointSpin->value(); }
int getExitPoint() const { return exitPointSpin->value(); }
void setStyle(bool highlight);
QCheckBox* active;
QSpinBox* audioLayer;
QLineEdit* filePathEdit;
ClickableDoubleSpinBox* volumeSpin;
ClickableDoubleSpinBox* panSpin;
ClickableDoubleSpinBox* pitchSpin;
ClickableDoubleSpinBox* bus1Spin;
ClickableDoubleSpinBox* bus2Spin;
QComboBox* statusCombo;
QSpinBox* fadeOutSpin;
QSpinBox* fadeInSpin;
QSpinBox* waitInSpin;
QSpinBox* waitOutSpin;
QCheckBox* stopAtEndCheck;
QLineEdit* nameEdit;
QLineEdit* descriptionEdit;
QSpinBox* userNumberSpin;
QSpinBox* entryPointSpin;
QSpinBox* exitPointSpin;
QPushButton* editButton;
private:
void setupUi();
void setupStatusCombo();
private slots:
void editButtonClicked();
/*
#include <QFile>
#include <QTextStream>
bool CueTrack::saveToFile(const QString& filePath) const {
QFile file(filePath);
if (!file.open(QIODevice::WriteOnly | QIODevice::Text)) {
return false; // No se pudo abrir el archivo para escritura
}
QTextStream out(&file);
// Escribir los datos en el archivo
out << "Volume: " << getVolume() << "\n";
out << "Pan: " << getPan() << "\n";
out << "Pitch: " << getPitch() << "\n";
out << "Bus1: " << getBus1() << "\n";
out << "Bus2: " << getBus2() << "\n";
out << "Status: " << static_cast<int>(getStatus()) << "\n";
out << "FilePath: " << getFilePath() << "\n";
out << "FadeIn: " << getFadeIn() << "\n";
out << "FadeOut: " << getFadeOut() << "\n";
out << "WaitIn: " << getWaitIn() << "\n";
out << "WaitOut: " << getWaitOut() << "\n";
out << "StopAtEnd: " << getStopAtEnd() << "\n";
out << "Name: " << getName() << "\n";
out << "Description: " << getDescription() << "\n";
out << "UserNumber: " << getUserNumber() << "\n";
out << "EntryPoint: " << getEntryPoint() << "\n";
out << "ExitPoint: " << getExitPoint() << "\n";
file.close();
return true;
}
#include <QFile>
#include <QTextStream>
bool CueTrack::loadFromFile(const QString& filePath) {
QFile file(filePath);
if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
return false; // No se pudo abrir el archivo para lectura
}
QTextStream in(&file);
// Leer los datos del archivo
while (!in.atEnd()) {
QString line = in.readLine();
QStringList parts = line.split(": ");
if (parts.size() != 2) continue; // Omitir líneas mal formadas
QString key = parts[0].trimmed();
QString value = parts[1].trimmed();
if (key == "Volume") setVolume(value.toDouble());
else if (key == "Pan") setPan(value.toDouble());
else if (key == "Pitch") setPitch(value.toDouble());
else if (key == "Bus1") setBus1(value.toInt());
else if (key == "Bus2") setBus2(value.toInt());
else if (key == "Status") setStatus(static_cast<Status>(value.toInt()));
else if (key == "FilePath") setFilePath(value);
else if (key == "FadeIn") setFadeIn(value.toDouble());
else if (key == "FadeOut") setFadeOut(value.toDouble());
else if (key == "WaitIn") setWaitIn(value.toDouble());
else if (key == "WaitOut") setWaitOut(value.toDouble());
else if (key == "StopAtEnd") setStopAtEnd(value.toInt() != 0);
else if (key == "Name") setName(value);
else if (key == "Description") setDescription(value);
else if (key == "UserNumber") setUserNumber(value.toInt());
else if (key == "EntryPoint") setEntryPoint(value.toDouble());
else if (key == "ExitPoint") setExitPoint(value.toDouble());
// Añadir más campos según sea necesario
}
file.close();
return true;
}
};
#include <QFile>
#include <QXmlStreamWriter>
void saveCueTrackToXml(const CueTrack& cueTrack, const QString& filePath) {
QFile file(filePath);
if (!file.open(QIODevice::WriteOnly)) {
qWarning("No se pudo abrir el archivo para escritura.");
return;
}
QXmlStreamWriter xmlWriter(&file);
xmlWriter.setAutoFormatting(true); // Para una salida más legible
xmlWriter.writeStartDocument();
xmlWriter.writeStartElement("CueTrack");
// Escribe los datos del objeto CueTrack como elementos o atributos
xmlWriter.writeTextElement("Name", cueTrack.name());
xmlWriter.writeTextElement("Volume", QString::number(cueTrack.volume()));
xmlWriter.writeTextElement("Pan", QString::number(cueTrack.pan()));
xmlWriter.writeTextElement("Pitch", QString::number(cueTrack.pitch()));
// Añade más elementos según sea necesario
xmlWriter.writeEndElement(); // Cierra el elemento CueTrack
xmlWriter.writeEndDocument();
file.close(); // No olvides cerrar el archivo
}
#include <QFile>
#include <QXmlStreamReader>
bool loadCueTrackFromXml(CueTrack& cueTrack, const QString& filePath) {
QFile file(filePath);
if (!file.open(QIODevice::ReadOnly)) {
qWarning("No se pudo abrir el archivo para lectura.");
return false;
}
QXmlStreamReader xmlReader(&file);
while (!xmlReader.atEnd() && !xmlReader.hasError()) {
// Lee el siguiente elemento
QXmlStreamReader::TokenType token = xmlReader.readNext();
// Si es un elemento de inicio y el nombre del elemento es el esperado
if (token == QXmlStreamReader::StartElement) {
if (xmlReader.name() == "filePath") {
cueTrack.filePath = xmlReader.readElementText().toStdString();
} else if (xmlReader.name() == "volume") {
cueTrack.volume = xmlReader.readElementText().toInt();
} else if (xmlReader.name() == "pan") {
cueTrack.pan = xmlReader.readElementText().toInt();
} else if (xmlReader.name() == "pitch") {
cueTrack.pitch = xmlReader.readElementText().toInt();
} else if (xmlReader.name() == "status") {
QString statusStr = xmlReader.readElementText();
cueTrack.status = stringToStatus(&statusStr); // Asegúrate de que esta función maneje QString correctamente
}
// Añade más campos según sea necesario
}
}
if (xmlReader.hasError()) {
qWarning("Error al leer el archivo XML: %s", xmlReader.errorString().toUtf8().constData());
return false;
}
file.close();
return true;
}
}
*/
#endif // CUETRACKWIDGET_H

1
src/defines.h
View file

@ -112,6 +112,7 @@ struct CueTrack {
int entryPoint; // 0 - 255
int exitPoint; // 0 - 255
int audioLayer; // internal audio layer used when cue is loaded
bool active;
};
#endif // __cplusplus

139
src/editcuetrackwidget.cpp Normal file
View file

@ -0,0 +1,139 @@
#include "editcuetrackwidget.h"
#include <QLineEdit>
#include <QFormLayout>
#include <QVBoxLayout>
#include <QFileDialog>
EditCueTrackWidget::EditCueTrackWidget(CueTrack *cueTrack, QWidget *parent)
: QDialog(parent) {
setupUi();
connectSignals();
this->cueTrack = cueTrack;
loadCueTrack(*cueTrack);
}
void EditCueTrackWidget::setupUi() {
userNumberSpin = new QSpinBox(this);
nameEdit = new QLineEdit(this);
audioLayerSpin = new QSpinBox(this);
audioLayerSpin->setRange(0, MAX_LAYERS - 1);
filePathEdit = new QLineEdit(this);
statusCombo = new QComboBox(this);
volumeSpin = new QDoubleSpinBox(this);
volumeSpin->setRange(0, 100.01f);
panSpin = new QDoubleSpinBox(this);
pitchSpin = new QDoubleSpinBox(this);
bus1Spin = new QDoubleSpinBox(this);
bus1Spin->setRange(0, 100.01f);
bus2Spin = new QDoubleSpinBox(this);
bus2Spin->setRange(0, 100.01f);
fadeInSpin = new QSpinBox(this);
fadeOutSpin = new QSpinBox(this);
waitInSpin = new QSpinBox(this);
waitOutSpin = new QSpinBox(this);
stopAtEndCheck = new QCheckBox(this);
descriptionEdit = new QLineEdit(this);
entryPointSpin = new QSpinBox(this);
exitPointSpin = new QSpinBox(this);
statusCombo->addItem("Stopped");
statusCombo->addItem("Paused");
statusCombo->addItem("PlayingOnce");
statusCombo->addItem("PlayingLoop");
statusCombo->addItem("Iddle");
statusCombo->addItem("PlayingFolder");
statusCombo->addItem("PlayingFolderLoop");
statusCombo->addItem("PlayingFolderRandom");
statusCombo->addItem("PlayingFolderRandomLoop");
browseButton = new QPushButton("Browse...", this);
saveButton = new QPushButton("Save", this);
cancelButton = new QPushButton("Cancel", this);
QFormLayout *layout = new QFormLayout(this);
layout->addRow("User Number", userNumberSpin);
layout->addRow("Name", nameEdit);
layout->addRow("Audio Layer", audioLayerSpin);
layout->addRow("File Path", filePathEdit);
layout->addRow(browseButton);
layout->addRow("Status", statusCombo);
layout->addRow("Fade In", fadeInSpin);
layout->addRow("Fade Out", fadeOutSpin);
layout->addRow("Wait In", waitInSpin);
layout->addRow("Wait Out", waitOutSpin);
layout->addRow("Stop At End", stopAtEndCheck);
layout->addRow("Volume", volumeSpin);
layout->addRow("Bus 1", bus1Spin);
layout->addRow("Bus 2", bus2Spin);
layout->addRow("Pan", panSpin);
layout->addRow("Pitch", pitchSpin);
layout->addRow("Entry Point", entryPointSpin);
layout->addRow("Exit Point", exitPointSpin);
layout->addRow("Description", descriptionEdit);
layout->addRow(saveButton);
layout->addRow(cancelButton);
}
void EditCueTrackWidget::loadCueTrack(CueTrack cueTrack) {
filePathEdit->setText(cueTrack.filePath.data());
volumeSpin->setValue(cueTrack.volume);
panSpin->setValue(cueTrack.pan);
pitchSpin->setValue(cueTrack.pitch);
bus1Spin->setValue(cueTrack.bus1);
bus2Spin->setValue(cueTrack.bus2);
fadeInSpin->setValue(cueTrack.fadeIn);
fadeOutSpin->setValue(cueTrack.fadeOut);
waitInSpin->setValue(cueTrack.waitIn);
waitOutSpin->setValue(cueTrack.waitOut);
stopAtEndCheck->setChecked(cueTrack.stopAtEnd);
nameEdit->setText(cueTrack.name.data());
descriptionEdit->setText(cueTrack.description.data());
userNumberSpin->setValue(cueTrack.userNumber);
entryPointSpin->setValue(cueTrack.entryPoint);
exitPointSpin->setValue(cueTrack.exitPoint);
statusCombo->setCurrentIndex(statusCombo->findText(statusToString(cueTrack.status)));
audioLayerSpin->setValue(cueTrack.audioLayer);
}
CueTrack EditCueTrackWidget::saveCueTrack() {
CueTrack cueTrack;
cueTrack.userNumber = userNumberSpin->value();
cueTrack.name.append(nameEdit->text().toUtf8().constData());
cueTrack.audioLayer = audioLayerSpin->value();
cueTrack.filePath.append(filePathEdit->text().toUtf8().constData());
cueTrack.status = static_cast<Status>(statusCombo->currentIndex());
cueTrack.fadeIn = fadeInSpin->value();
cueTrack.fadeOut = fadeOutSpin->value();
cueTrack.waitIn = waitInSpin->value();
cueTrack.waitOut = waitOutSpin->value();
cueTrack.stopAtEnd = stopAtEndCheck->isChecked();
cueTrack.entryPoint = entryPointSpin->value();
cueTrack.exitPoint = exitPointSpin->value();
cueTrack.volume = volumeSpin->value();
cueTrack.bus1 = bus1Spin->value();
cueTrack.bus2 = bus2Spin->value();
cueTrack.pan = panSpin->value();
cueTrack.pitch = pitchSpin->value();
cueTrack.description.append(descriptionEdit->text().toUtf8().constData());
return cueTrack;
}
void EditCueTrackWidget::accept() {
*cueTrack = saveCueTrack();
QDialog::accept();
}
void EditCueTrackWidget::connectSignals() {
connect(saveButton, &QPushButton::clicked, this, &EditCueTrackWidget::accept);
connect(cancelButton, &QPushButton::clicked, this, &EditCueTrackWidget::reject);
connect(browseButton, &QPushButton::clicked, this, &EditCueTrackWidget::onBrowseButtonClicked);
}
void EditCueTrackWidget::onBrowseButtonClicked() {
QString filePath = QFileDialog::getOpenFileName(this, tr("Select File"), Settings::getInstance()->getPathMedia(), tr("Audio Files (*.mp3 *.wav *.flac)"));
if (!filePath.isEmpty()) {
filePathEdit->setText(filePath);
QDir dir;
Settings::getInstance()->setPathMedia(dir.absoluteFilePath(filePath));
}
}

54
src/editcuetrackwidget.h Normal file
View file

@ -0,0 +1,54 @@
#ifndef EDITCUETRACKWIDGET_H
#define EDITCUETRACKWIDGET_H
#include <QDialog>
#include <QLineEdit>
#include <QSpinBox>
#include <QCheckBox>
#include <QPushButton>
#include <QFormLayout>
#include <QDoubleSpinBox>
#include <QComboBox>
#include "settings.h"
#include "defines.h"
class EditCueTrackWidget : public QDialog
{
Q_OBJECT
public:
explicit EditCueTrackWidget(CueTrack *cueTrack, QWidget *parent = nullptr);
CueTrack *cueTrack;
void loadCueTrack(CueTrack cueTrack);
CueTrack saveCueTrack();
private:
void setupUi();
void connectSignals();
void onBrowseButtonClicked();
void accept() override;
QLineEdit *filePathEdit;
QDoubleSpinBox *volumeSpin;
QDoubleSpinBox *panSpin;
QDoubleSpinBox *pitchSpin;
QDoubleSpinBox *bus1Spin;
QDoubleSpinBox *bus2Spin;
QSpinBox *fadeInSpin;
QSpinBox *fadeOutSpin;
QSpinBox *waitInSpin;
QSpinBox *waitOutSpin;
QCheckBox *stopAtEndCheck;
QLineEdit *nameEdit;
QLineEdit *descriptionEdit;
QSpinBox *userNumberSpin;
QSpinBox *entryPointSpin;
QSpinBox *exitPointSpin;
QComboBox *statusCombo;
QSpinBox *audioLayerSpin;
QPushButton *browseButton;
QPushButton *saveButton;
QPushButton *cancelButton;
};
#endif // EDITCUETRACKWIDGET_H

4
src/libremediaserver-audio.cpp
View file

@ -280,7 +280,9 @@ void libreMediaServerAudio::uiLoadMedia(int layer, QString mediaFile)
{
ma_result result;
if (strcmp(mediaFile.toLatin1().constData(), m_currentMedia[layer].toLatin1().constData()) == 0)
if (mediaFile.isEmpty())
return ;
if (mediaFile.compare(m_currentMedia[layer]) == 0)
return;
result = m_mae.loadMedia(layer, mediaFile.toLatin1().data());
if (result == MA_SUCCESS) {

14
src/miniaudioengine.cpp
View file

@ -58,7 +58,7 @@ bool MiniAudioEngine::startEngine(uint layers, uint* audioDevicesId, uint audioD
m_mae.currentStatus[i].pitch = 128;
m_mae.currentStatus[i].vol = 0.0f;
m_mae.currentStatus[i].cursor = 0;
m_mae.currentStatus[i].updated = false;
m_mae.currentStatus[i].updated = MA_FALSE;
}
result = this->startContext();
if (result != MA_SUCCESS) return false;
@ -351,6 +351,8 @@ ma_result MiniAudioEngine::loadMedia(int layer, char *file)
{
ma_result result;
if (!file || !*file)
return MA_INVALID_ARGS;
if (m_mae.mediaLoaded[layer] == MA_TRUE)
{
m_mae.mediaLoaded[layer] = MA_FALSE;
@ -372,7 +374,7 @@ ma_result MiniAudioEngine::loadMedia(int layer, char *file)
return result;
}
m_mae.currentStatus[layer].media = file;
m_mae.currentStatus[layer].updated = true;
m_mae.currentStatus[layer].updated = MA_TRUE;
m_mae.mediaLoaded[layer] = MA_TRUE;
this->refreshValues(layer);
return result;
@ -434,6 +436,8 @@ ma_result MiniAudioEngine::printFormatInfo(int layer)
void MiniAudioEngine::volChanged(int layer, int vol)
{
m_mae.currentStatus[layer].vol = vol;
if (m_mae.mediaLoaded[layer] != MA_TRUE)
return;
if (m_mae.mediaLoaded[layer] == MA_FALSE && m_mae.currentStatus[layer].updated)
return;
float db = ((float)vol / 771.0f) - 85.0f;
@ -449,7 +453,7 @@ void MiniAudioEngine::panChanged(int layer, float value)
float result;
m_mae.currentStatus[layer].pan = value;
if (m_mae.mediaLoaded[layer] == false)
if (m_mae.mediaLoaded[layer] != MA_TRUE)
return;
result = (value / 128.0) - 1.0;
ma_sound_group_set_pan(&m_mae.sounds[layer], result);
@ -460,7 +464,7 @@ void MiniAudioEngine::pitchChanged(int layer, float value)
float pitch;
m_mae.currentStatus[layer].pitch = value;
if (m_mae.mediaLoaded[layer] == false)
if (m_mae.mediaLoaded[layer] != MA_TRUE)
return;
pitch = value / 128.0;
ma_sound_group_set_pitch(&m_mae.sounds[layer], pitch);
@ -473,7 +477,7 @@ ma_result MiniAudioEngine::playbackChanged(int layer, Status status)
bool loop = false;
m_mae.currentStatus[layer].status = status;
if (m_mae.mediaLoaded[layer] == MA_FALSE)
if (m_mae.mediaLoaded[layer] != MA_TRUE)
return MA_DOES_NOT_EXIST;
m_mae.currentStatus[layer].updated = false;
switch (status) {

34
src/showplayer.cpp
View file

@ -17,39 +17,33 @@ ShowPlayer::ShowPlayer(QWidget *parent) :
ShowPlayer::~ShowPlayer() {}
void ShowPlayer::onAddTrack() {
CueTrackWidget* track = new CueTrackWidget();
EditCueTrackWidget editor;
editor.loadCueTrack(track->saveCueTrack());
if (editor.exec() == QDialog::Accepted) {
track->loadCueTrack(editor.saveCueTrack());
ui->cueListWidget->addCueTrackWidget(track);
}
ui->cueListWidget->createNewCueTrack();
}
void ShowPlayer::go()
{
CueTrackWidget* current = ui->cueListWidget->getSelectedTrack();
CueTrack* current = ui->cueListWidget->getSelectedTrack();
if (!current)
return;
if (!current->getFilePath().isEmpty())
{
if (current->audioLayer < 0)
return;
for (int i = 0; i < MAX_LAYERS; i++) {
if (layersUsed[i] == -1) {
layersUsed[i] = current->userNumberSpin->value();
layersUsed[i] = current->userNumber;
break;
}
}
emit uiLoadMedia(current->audioLayer->value(), current->getFilePath());
}
if (!current->filePath.empty())
emit uiLoadMedia(current->audioLayer, current->filePath.data());
updateTrackStateInEngine(current);
emit uiPlaybackChanged(current->audioLayer->value(), current->getStatus());
emit uiPlaybackChanged(current->audioLayer, current->status);
filesLoaded++;
}
void ShowPlayer::updateTrackStateInEngine(CueTrackWidget *track) {
emit uiSliderChanged(track->audioLayer->value(), Slider::Volume, track->getVolume());
emit uiSliderChanged(track->audioLayer->value(), Slider::Pan, track->getPan());
emit uiSliderChanged(track->audioLayer->value(), Slider::Pitch, track->getPitch());
emit uiSliderChanged(track->audioLayer->value(), Slider::Bus1, track->getBus1());
emit uiSliderChanged(track->audioLayer->value(), Slider::Bus2, track->getBus2());
void ShowPlayer::updateTrackStateInEngine(CueTrack *track) {
emit uiSliderChanged(track->audioLayer, Slider::Volume, track->volume * 655.35);
emit uiSliderChanged(track->audioLayer, Slider::Pan, (track->pan + 1) * 128);
emit uiSliderChanged(track->audioLayer, Slider::Pitch, track->pitch * 128);
emit uiSliderChanged(track->audioLayer, Slider::Bus1, track->bus1 * 255 * 2.55);
emit uiSliderChanged(track->audioLayer, Slider::Bus2, track->bus2 * 255 * 2.55);
};

4
src/showplayer.h
View file

@ -8,9 +8,7 @@
#include <QFileDialog>
#include "defines.h"
#include "cuetrackwidget.h"
#include "cuetracklistwidget.h"
#include "trackdialog.h"
#include "settings.h"
#include "ui_showplayer.h"
@ -32,7 +30,7 @@ private:
size_t filesLoaded = 0;
int layersUsed[MAX_LAYERS];
void updateTrackStateInEngine(CueTrackWidget *track);
void updateTrackStateInEngine(CueTrack *track);
private slots:
void onAddTrack();

10
src/showplayer.ui
View file

@ -6,8 +6,8 @@
<rect>
<x>0</x>
<y>0</y>
<width>276</width>
<height>112</height>
<width>538</width>
<height>554</height>
</rect>
</property>
<property name="sizePolicy">
@ -22,6 +22,12 @@
<layout class="QVBoxLayout" name="verticalLayout">
<item>
<widget class="QSplitter" name="splitter">
<property name="sizePolicy">
<sizepolicy hsizetype="Preferred" vsizetype="Preferred">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="orientation">
<enum>Qt::Vertical</enum>
</property>

60
src/trackdialog.cpp
View file

@ -1,60 +0,0 @@
#include "trackdialog.h"
#include "settings.h"
TrackDialog::TrackDialog(QWidget *parent) : QDialog(parent) {
setupUi();
connectSignals();
}
void TrackDialog::setupUi() {
okButton = new QPushButton(tr("OK"), this);
cancelButton = new QPushButton(tr("Cancelar"), this);
browseButton = new QPushButton(tr("Buscar..."), this);
QFormLayout *layout = new QFormLayout(this);
//track = new CueTrackWidget();
//track->editButtonClicked();
/* layout->addRow(tr("&User number"), track->userNumberSpin);
layout->addRow(tr("&Name"), track->nameEdit);
layout->addRow(tr("&Description"), track->descriptionEdit);
layout->addRow(tr("&File"), track->filePathEdit);
layout->addRow(tr("&Status"), track->statusCombo);
layout->addRow(tr("&Fade in"), track->fadeInSpin);
layout->addRow(tr("Fade &Out"), track->fadeOutSpin);
layout->addRow(tr("&Wait In"), track->waitInSpin);
layout->addRow(tr("&Wait Ou&t"), track->waitOutSpin);
layout->addRow(tr("Sto&p at end"), track->stopAtEndCheck);
layout->addRow(tr("&Volume"), track->volumeSpin);
layout->addRow(tr("pan"), track->panSpin);
layout->addRow(tr("pitch"), track->pitchSpin);
layout->addRow(tr("Bus&1"), track->bus1Spin);
layout->addRow(tr("Bus&2"), track->bus2Spin);
layout->addRow(tr("&Entry Point"), track->entryPointSpin);
layout->addRow(tr("E&xit Point"), track->exitPointSpin);*/
//layout->addRow(tr("&Browse files"), browseButton);
//layout->addWidget(track);
layout->addWidget(okButton);
layout->addWidget(cancelButton);
setLayout(layout);
}
void TrackDialog::connectSignals() {
connect(okButton, &QPushButton::clicked, this, &TrackDialog::accept);
connect(cancelButton, &QPushButton::clicked, this, &TrackDialog::reject);
//connect(browseButton, &QPushButton::clicked, this, &TrackDialog::browseFiles);
}
QString TrackDialog::browseFiles() const {
QString filePath = QFileDialog::getOpenFileName(
const_cast<TrackDialog*>(this),
tr("Select File"),
Settings::getInstance()->getPathMedia(),
tr("Archivos de audio (*.mp3 *.wav *.flac);;Todos los archivos (*)")
);
if (!filePath.isEmpty()) {
track->setFilePath(filePath);
QDir dir;
Settings::getInstance()->setPathMedia(dir.absoluteFilePath(filePath));
}
return filePath;
}

34
src/trackdialog.h
View file

@ -1,34 +0,0 @@
#ifndef TRACKDIALOG_H
#define TRACKDIALOG_H
#include <QLineEdit>
#include <QSpinBox>
#include <QPushButton>
#include <QFormLayout>
#include <QFileDialog>
#include "defines.h"
#include "cuetrackwidget.h"
class TrackDialog : public QDialog {
Q_OBJECT
public:
CueTrackWidget *track;
explicit TrackDialog(QWidget *parent = nullptr);
private:
QPushButton *okButton;
QPushButton *cancelButton;
QPushButton *browseButton;
void setupUi();
void connectSignals();
private slots:
QString browseFiles() const;
};
#endif