Skip to content

OpenToonz - An open-source full-featured 2D animation creation software

C

Improvements to Audio Recording III: Peak menace!

justburner557cf01c2cab
diff --git a/toonz/sources/toonz/audiorecordingpopup.cpp b/toonz/sources/toonz/audiorecordingpopup.cpp
index f55a007a7..8c8e3fd51 100644
--- a/toonz/sources/toonz/audiorecordingpopup.cpp
+++ b/toonz/sources/toonz/audiorecordingpopup.cpp
@@ -273,6 +273,16 @@ void AudioRecordingPopup::onRecordButtonPressed() {
if (TSystem::doesExistFileOrLevel(m_filePath)) {
TSystem::removeFileOrLevel(m_filePath);
}
+ // The audio writer support either writing to buffer or directly to disk
+ // each method have their own pros and cons
+ // For now using false to mimic previous QAudioRecorder behaviour
+ m_audioWriterWAV->restart(m_audioInput->format());
+ if (!m_audioWriterWAV->start(m_filePath.getQString(), false)) {
+ DVGui::warning(
+ tr("Failed to save WAV file:\nMake sure you have write permissions "
+ "in folder."));
+ return;
+ }
m_recordButton->setIcon(m_stopIcon);
m_saveButton->setDisabled(true);
m_playButton->setDisabled(true);
@@ -289,8 +299,6 @@ void AudioRecordingPopup::onRecordButtonPressed() {
m_stoppedAtEnd = false;
m_playDuration->setText("00:00.000");
m_timer->restart();
- m_audioWriterWAV->restart(m_audioInput->format());
- m_audioWriterWAV->start();
m_audioInput->start(m_audioWriterWAV);
// this sometimes sets to one frame off, so + 1.
m_currentFrame = TApp::instance()->getCurrentFrame()->getFrame() + 1;
@@ -302,13 +310,12 @@ void AudioRecordingPopup::onRecordButtonPressed() {
} else {
m_audioInput->stop();
- m_audioWriterWAV->stop();
- if (m_audioWriterWAV->save(m_filePath.getQString())) {
+ bool success = m_audioWriterWAV->stop();
+ if (success) {
m_saveButton->setEnabled(true);
m_playButton->setEnabled(true);
}
- m_audioWriterWAV->freeup();
- m_audioLevelsDisplay->setLevel(-1);
+ m_audioLevelsDisplay->setLevel(-1, -1);
m_recordButton->setIcon(m_recordIcon);
m_pauseRecordingButton->setDisabled(true);
m_pauseRecordingButton->setIcon(m_pauseIcon);
@@ -324,6 +331,10 @@ void AudioRecordingPopup::onRecordButtonPressed() {
TApp::instance()->getCurrentFrame()->setCurrentFrame(m_currentFrame);
}
m_isPlaying = false;
+ if (!success) {
+ DVGui::warning(tr(
+ "Failed to save WAV file:\nMake sure you have write permissions in folder."));
+ }
}
}
@@ -340,7 +351,8 @@ void AudioRecordingPopup::updateRecordDuration(qint64 duration) {
// Show and record amplitude
qreal level = m_audioWriterWAV->level();
- m_audioLevelsDisplay->setLevel(level);
+ qreal peakL = m_audioWriterWAV->peakLevel();
+ m_audioLevelsDisplay->setLevel(level, peakL);
m_recordedLevels[duration / 20] = level;
}
@@ -359,7 +371,7 @@ void AudioRecordingPopup::updatePlaybackDuration(qint64 duration) {
// using
// a map that is made during recording
if (m_recordedLevels.contains(duration / 20)) {
- m_audioLevelsDisplay->setLevel(m_recordedLevels.value(duration / 20));
+ m_audioLevelsDisplay->setLevel(m_recordedLevels.value(duration / 20), -1);
}
}
@@ -456,7 +468,7 @@ void AudioRecordingPopup::onPausePlaybackButtonPressed() {
void AudioRecordingPopup::onMediaStateChanged(QMediaPlayer::State state) {
// stopping can happen through the stop button or the file ending
if (state == QMediaPlayer::StoppedState) {
- m_audioLevelsDisplay->setLevel(-1);
+ m_audioLevelsDisplay->setLevel(-1, -1);
if (m_syncPlayback) {
if (m_isPlaying) {
m_console->pressButton(FlipConsole::ePause);
@@ -513,11 +525,11 @@ void AudioRecordingPopup::onAudioSettingChanged() {
void AudioRecordingPopup::onSaveButtonPressed() {
if (m_audioInput->state() != QAudio::StoppedState) {
m_audioInput->stop();
- m_audioLevelsDisplay->setLevel(-1);
+ m_audioLevelsDisplay->setLevel(-1, -1);
}
if (m_player->state() != QMediaPlayer::StoppedState) {
m_player->stop();
- m_audioLevelsDisplay->setLevel(-1);
+ m_audioLevelsDisplay->setLevel(-1, -1);
}
if (!TSystem::doesExistFileOrLevel(m_filePath)) return;
@@ -589,7 +601,7 @@ void AudioRecordingPopup::resetEverything() {
m_recordedLevels.clear();
m_duration->setText("00:00.000");
m_playDuration->setText("00:00.000");
- m_audioLevelsDisplay->setLevel(-1);
+ m_audioLevelsDisplay->setLevel(-1, -1);
if (!m_console) {
m_console = FlipConsole::getCurrent();
if (m_console)
@@ -603,6 +615,7 @@ void AudioRecordingPopup::resetEverything() {
void AudioRecordingPopup::hideEvent(QHideEvent *event) {
if (m_audioInput->state() != QAudio::StoppedState) {
m_audioInput->stop();
+ m_audioWriterWAV->stop();
}
if (m_player->state() != QMediaPlayer::StoppedState) {
m_player->stop();
@@ -617,7 +630,6 @@ void AudioRecordingPopup::hideEvent(QHideEvent *event) {
}
// Free up memory used in recording
m_recordedLevels.clear();
- m_audioWriterWAV->freeup();
}
//-----------------------------------------------------------------------------
@@ -691,7 +703,12 @@ void AudioRecordingPopup::reinitAudioInput() {
// 32-bits isn't supported
AudioWriterWAV::AudioWriterWAV(const QAudioFormat &format)
- : m_level(0.0), m_maxAmp(0.0) {
+ : m_level(0.0)
+ , m_peakL(0.0)
+ , m_maxAmp(0.0)
+ , m_wrRawB(0)
+ , m_wavFile(NULL)
+ , m_wavBuff(NULL) {
restart(format);
}
@@ -708,16 +725,79 @@ bool AudioWriterWAV::restart(const QAudioFormat &format) {
m_rbytesms = 250.0 / (m_format.sampleRate() * m_format.channelCount());
m_maxAmp = 1.0;
}
- m_barray.clear();
+ m_wrRawB = 0;
+ m_peakL = 0.0;
+ if (m_wavBuff) m_wavBuff->clear();
return this->reset();
}
-void AudioWriterWAV::start() {
- open(QIODevice::WriteOnly);
+// Just a tiny define to avoid a magic number
+// this is the size of a WAV header with PCM format
+#define AWWAV_HEADER_SIZE 44
+
+bool AudioWriterWAV::start(const QString &filename, bool useMem) {
+ open(QIODevice::WriteOnly);
+ m_filename = filename;
+
+ if (useMem) {
+ m_wavBuff = new QByteArray();
+ } else {
+ m_wavFile = new QFile(m_filename);
+ if (!m_wavFile->open(QIODevice::WriteOnly | QIODevice::Truncate))
+ return false;
+ m_wavFile->seek(AWWAV_HEADER_SIZE); // skip header
+ }
+
+ m_wrRawB = 0;
+ m_peakL = 0.0;
+ return true;
}
-void AudioWriterWAV::stop() {
- close();
+bool AudioWriterWAV::stop() {
+ close();
+
+ if (m_wavBuff) {
+ // Using memory
+ QFile file;
+ file.setFileName(m_filename);
+ if (!file.open(QIODevice::WriteOnly | QIODevice::Truncate)) return false;
+ writeWAVHeader(file);
+ file.write(m_wavBuff->constData(), m_wavBuff->size());
+ delete m_wavBuff;
+ m_wavBuff = NULL;
+ } else {
+ // Using disk directly
+ writeWAVHeader(*m_wavFile);
+ m_wavFile->close();
+ delete m_wavFile;
+ m_wavFile = NULL;
+ }
+
+ m_wrRawB = 0;
+ m_peakL = 0.0;
+ return true;
+}
+
+void AudioWriterWAV::writeWAVHeader(QFile &file) {
+ quint16 channels = m_format.channelCount();
+ quint32 samplerate = m_format.sampleRate();
+ quint16 bitrate = m_format.sampleSize();
+
+ qint64 pos = file.pos();
+ file.seek(0);
+
+ QDataStream out(&file);
+ out.setByteOrder(QDataStream::LittleEndian);
+ out.writeRawData("RIFF", 4);
+ out << (quint32)(m_wrRawB + AWWAV_HEADER_SIZE);
+ out.writeRawData("WAVEfmt ", 8);
+ out << (quint32)16 << (quint16)1; // magic numbers!
+ out << channels << samplerate;
+ out << quint32(samplerate * channels * bitrate / 8);
+ out << quint16(channels * bitrate / 8);
+ out << bitrate;
+ out.writeRawData("data", 4);
+ out << (quint32)m_wrRawB;
}
qint64 AudioWriterWAV::readData(char *data, qint64 maxlen) {
@@ -727,80 +807,57 @@ qint64 AudioWriterWAV::readData(char *data, qint64 maxlen) {
}
qint64 AudioWriterWAV::writeData(const char *data, qint64 len) {
- qreal tmp, peak = 0.0;
+ int tmp, peak = 0.0;
// Measure peak
if (m_format.sampleSize() == 8) {
const quint8 *sdata = (const quint8 *)data;
int slen = len;
for (int i = 0; i < slen; ++i) {
- tmp = qAbs(qreal(sdata[i]) - 128.0);
+ tmp = qAbs<int>(sdata[i] - 128);
if (tmp > peak) peak = tmp;
}
} else if (m_format.sampleSize() == 16) {
const qint16 *sdata = (const qint16 *)data;
int slen = len / 2;
for (int i = 0; i < slen; ++i) {
- tmp = qAbs(qreal(sdata[i]));
+ tmp = qAbs<int>(sdata[i]);
if (tmp > peak) peak = tmp;
}
} else {
// 32-bits isn't supported
- peak = -1.0;
+ peak = -1;
}
- m_level = peak / m_maxAmp;
+ m_level = qreal(peak) / m_maxAmp;
+ if (m_level > m_peakL) m_peakL = m_level;
- // Write to buffer
- m_barray.append(data, len);
+ // Write to memory or disk
+ if (m_wavBuff) {
+ m_wavBuff->append(data, len);
+ } else {
+ m_wavFile->write(data, len);
+ }
+ m_wrRawB += len;
// Emit an update
- emit update(m_barray.size() * m_rbytesms);
+ emit update(qreal(m_wrRawB) * m_rbytesms);
return len;
}
-bool AudioWriterWAV::save(const QString &filename)
-{
- QFile file;
- quint16 channels = m_format.channelCount();
- quint32 samplerate = m_format.sampleRate();
- quint16 bitrate = m_format.sampleSize();
- file.setFileName(filename);
- if (!file.open(QIODevice::WriteOnly | QIODevice::Truncate)) {
- DVGui::warning(tr(
- "Failed to save WAV file:\nMake sure you have folder permissions."));
- return false;
- }
- QDataStream out(&file);
- out.setByteOrder(QDataStream::LittleEndian);
- out.writeRawData("RIFF", 4);
- out << (quint32)(m_barray.size() + 44);
- out.writeRawData("WAVEfmt ", 8);
- out << (quint32)16 << (quint16)1;
- out << channels << samplerate;
- out << quint32(samplerate * channels * bitrate / 8);
- out << quint16(channels * bitrate / 8);
- out << bitrate;
- out.writeRawData("data", 4);
- out << (quint32)m_barray.size();
- out.writeRawData(m_barray.constData(), m_barray.size());
- return true;
-}
-
-void AudioWriterWAV::freeup() { m_barray.clear(); }
-
//-----------------------------------------------------------------------------
// AudioLevelsDisplay Class
//-----------------------------------------------------------------------------
AudioLevelsDisplay::AudioLevelsDisplay(QWidget *parent)
- : QWidget(parent), m_level(0.0) {
+ : QWidget(parent), m_level(0.0), m_peakL(0.0) {
setFixedHeight(20);
setFixedWidth(300);
}
-void AudioLevelsDisplay::setLevel(qreal level) {
- if (m_level != level) {
+void AudioLevelsDisplay::setLevel(qreal level, qreal peakLevel) {
+ if (m_level != level || m_peakL != peakLevel) {
m_level = level;
+ m_peakL = peakLevel;
update();
}
}
@@ -822,9 +879,18 @@ void AudioLevelsDisplay::paintEvent(QPaintEvent *event) {
} else
color = Qt::red;
- qreal widthLevel = m_level * width();
- painter.fillRect(0, 0, widthLevel, height(), color);
+ int widthLevel = m_level * width();
+ int widthPeakL = m_peakL * width();
painter.fillRect(widthLevel, 0, width(), height(), Qt::black);
+ if (widthPeakL >= 0) {
+ if (m_peakL >= 0.995) {
+ painter.fillRect(width() - 4, 0, 4, height(), Qt::red);
+ } else {
+ painter.setPen(QColor(64, 64, 64)); // very dark gray
+ painter.drawLine(widthPeakL, 0, widthPeakL, height());
+ }
+ }
+ painter.fillRect(0, 0, widthLevel, height(), color);
}
//-----------------------------------------------------------------------------
diff --git a/toonz/sources/toonz/audiorecordingpopup.h b/toonz/sources/toonz/audiorecordingpopup.h
index ec3e3f884..e01495721 100644
--- a/toonz/sources/toonz/audiorecordingpopup.h
+++ b/toonz/sources/toonz/audiorecordingpopup.h
@@ -97,22 +97,26 @@ public:
AudioWriterWAV(const QAudioFormat &format);
bool restart(const QAudioFormat &format);
- void start();
- void stop();
- bool save(const QString &filename);
- void freeup();
+ bool start(const QString &filename, bool useMem);
+ bool stop();
qint64 readData(char *data, qint64 maxlen) override;
qint64 writeData(const char *data, qint64 len) override;
qreal level() const { return m_level; }
+ qreal peakLevel() const { return m_peakL; }
private:
- QByteArray m_barray;
+ QString m_filename;
+ QFile *m_wavFile;
+ QByteArray *m_wavBuff; // if not null then use memory
QAudioFormat m_format;
+ quint64 m_wrRawB; // Written raw bytes
qreal m_rbytesms;
qreal m_maxAmp;
- qreal m_level;
+ qreal m_level, m_peakL;
+
+ void writeWAVHeader(QFile &file);
signals:
void update(qint64 duration);
@@ -128,12 +132,13 @@ public:
explicit AudioLevelsDisplay(QWidget *parent = 0);
// Using [0; 1.0] range
- void setLevel(qreal level);
+ void setLevel(qreal level, qreal peak);
protected:
void paintEvent(QPaintEvent *event);
private:
qreal m_level;
+ qreal m_peakL;
};
#endif
\ No newline at end of file