mirror
/
fm_transmitter
kopia lustrzana https://github.com/markondej/fm_transmitter
1
0
Forkuj 0
Kod Zgłoszenia Projekty Wydania Wiki Aktywność

Removed windows 0xD/CR characters, fixed freezing when sudo not used

master
Marcin Kondej 2023-09-29 00:48:32 +02:00
rodzic e4b75e38d1
commit 430923a05a
2 zmienionych plików z 828 dodań i 828 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

1200
transmitter.cpp
Wyświetl plik

Plik diff jest za duży Load Diff

456
wave_reader.cpp
Wyświetl plik

@ -1,228 +1,228 @@
/* /*
FM Transmitter - use Raspberry Pi as FM transmitter FM Transmitter - use Raspberry Pi as FM transmitter
Copyright (c) 2021, Marcin Kondej Copyright (c) 2021, Marcin Kondej
All rights reserved. All rights reserved.
See https://github.com/markondej/fm_transmitter See https://github.com/markondej/fm_transmitter
Redistribution and use in source and binary forms, with or without modification, are Redistribution and use in source and binary forms, with or without modification, are
permitted provided that the following conditions are met: permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice, this list 1. Redistributions of source code must retain the above copyright notice, this list
of conditions and the following disclaimer. of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice, this 2. Redistributions in binary form must reproduce the above copyright notice, this
list of conditions and the following disclaimer in the documentation and/or other list of conditions and the following disclaimer in the documentation and/or other
materials provided with the distribution. materials provided with the distribution.
3. Neither the name of the copyright holder nor the names of its contributors may be 3. Neither the name of the copyright holder nor the names of its contributors may be
used to endorse or promote products derived from this software without specific used to endorse or promote products derived from this software without specific
prior written permission. prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#include "wave_reader.hpp" #include "wave_reader.hpp"
#include <stdexcept> #include <stdexcept>
#include <cstring> #include <cstring>
#include <thread> #include <thread>
#include <chrono> #include <chrono>
#include <unistd.h> #include <unistd.h>
#include <fcntl.h> #include <fcntl.h>
#include <climits> #include <climits>
Sample::Sample(uint8_t *data, unsigned channels, unsigned bitsPerChannel) Sample::Sample(uint8_t *data, unsigned channels, unsigned bitsPerChannel)
: value(0.f) : value(0.f)
{ {
int sum = 0; int sum = 0;
int16_t *channelValues = new int16_t[channels]; int16_t *channelValues = new int16_t[channels];
for (unsigned i = 0; i < channels; i++) { for (unsigned i = 0; i < channels; i++) {
switch (bitsPerChannel >> 3) { switch (bitsPerChannel >> 3) {
case 2: case 2:
channelValues[i] = (data[((i + 1) << 1) - 1] << 8) | data[((i + 1) << 1) - 2]; channelValues[i] = (data[((i + 1) << 1) - 1] << 8) | data[((i + 1) << 1) - 2];
break; break;
case 1: case 1:
channelValues[i] = (static_cast<int16_t>(data[i]) - 0x80) << 8; channelValues[i] = (static_cast<int16_t>(data[i]) - 0x80) << 8;
break; break;
} }
sum += channelValues[i]; sum += channelValues[i];
} }
value = 2 * sum / (static_cast<float>(USHRT_MAX) * channels); value = 2 * sum / (static_cast<float>(USHRT_MAX) * channels);
delete[] channelValues; delete[] channelValues;
} }
float Sample::GetMonoValue() const float Sample::GetMonoValue() const
{ {
return value; return value;
} }
WaveReader::WaveReader(const std::string &filename, bool &enable, std::mutex &mtx) : WaveReader::WaveReader(const std::string &filename, bool &enable, std::mutex &mtx) :
filename(filename), headerOffset(0), currentDataOffset(0) filename(filename), headerOffset(0), currentDataOffset(0)
{ {
if (!filename.empty()) { if (!filename.empty()) {
fileDescriptor = open(filename.c_str(), O_RDONLY); fileDescriptor = open(filename.c_str(), O_RDONLY);
} else { } else {
fcntl(STDIN_FILENO, F_SETFL, fcntl(STDIN_FILENO, F_GETFL, 0) | O_NONBLOCK); fcntl(STDIN_FILENO, F_SETFL, fcntl(STDIN_FILENO, F_GETFL, 0) | O_NONBLOCK);
fileDescriptor = STDIN_FILENO; fileDescriptor = STDIN_FILENO;
} }
if (fileDescriptor == -1) { if (fileDescriptor == -1) {
throw std::runtime_error(std::string("Cannot open ") + GetFilename() + std::string(", file does not exist")); throw std::runtime_error(std::string("Cannot open ") + GetFilename() + std::string(", file does not exist"));
} }
try { try {
ReadData(sizeof(WaveHeader::chunkID) + sizeof(WaveHeader::chunkSize) + sizeof(WaveHeader::format), true, enable, mtx); ReadData(sizeof(WaveHeader::chunkID) + sizeof(WaveHeader::chunkSize) + sizeof(WaveHeader::format), true, enable, mtx);
if ((std::string(reinterpret_cast<char *>(header.chunkID), 4) != std::string("RIFF")) || (std::string(reinterpret_cast<char *>(header.format), 4) != std::string("WAVE"))) { if ((std::string(reinterpret_cast<char *>(header.chunkID), 4) != std::string("RIFF")) || (std::string(reinterpret_cast<char *>(header.format), 4) != std::string("WAVE"))) {
throw std::runtime_error(std::string("Error while opening ") + GetFilename() + std::string(", WAVE file expected")); throw std::runtime_error(std::string("Error while opening ") + GetFilename() + std::string(", WAVE file expected"));
} }
ReadData(sizeof(WaveHeader::subchunk1ID) + sizeof(WaveHeader::subchunk1Size), true, enable, mtx); ReadData(sizeof(WaveHeader::subchunk1ID) + sizeof(WaveHeader::subchunk1Size), true, enable, mtx);
unsigned subchunk1MinSize = sizeof(WaveHeader::audioFormat) + sizeof(WaveHeader::channels) + unsigned subchunk1MinSize = sizeof(WaveHeader::audioFormat) + sizeof(WaveHeader::channels) +
sizeof(WaveHeader::sampleRate) + sizeof(WaveHeader::byteRate) + sizeof(WaveHeader::blockAlign) + sizeof(WaveHeader::sampleRate) + sizeof(WaveHeader::byteRate) + sizeof(WaveHeader::blockAlign) +
sizeof(WaveHeader::bitsPerSample); sizeof(WaveHeader::bitsPerSample);
if ((std::string(reinterpret_cast<char *>(header.subchunk1ID), 4) != std::string("fmt ")) || (header.subchunk1Size < subchunk1MinSize)) { if ((std::string(reinterpret_cast<char *>(header.subchunk1ID), 4) != std::string("fmt ")) || (header.subchunk1Size < subchunk1MinSize)) {
throw std::runtime_error(std::string("Error while opening ") + GetFilename() + std::string(", data corrupted")); throw std::runtime_error(std::string("Error while opening ") + GetFilename() + std::string(", data corrupted"));
} }
ReadData(header.subchunk1Size, true, enable, mtx); ReadData(header.subchunk1Size, true, enable, mtx);
if ((header.audioFormat != WAVE_FORMAT_PCM) || if ((header.audioFormat != WAVE_FORMAT_PCM) ||
(header.byteRate != (header.bitsPerSample >> 3) * header.channels * header.sampleRate) || (header.byteRate != (header.bitsPerSample >> 3) * header.channels * header.sampleRate) ||
(header.blockAlign != (header.bitsPerSample >> 3) * header.channels) || (header.blockAlign != (header.bitsPerSample >> 3) * header.channels) ||
(((header.bitsPerSample >> 3) != 1) && ((header.bitsPerSample >> 3) != 2))) { (((header.bitsPerSample >> 3) != 1) && ((header.bitsPerSample >> 3) != 2))) {
throw std::runtime_error(std::string("Error while opening ") + GetFilename() + std::string(", unsupported WAVE format")); throw std::runtime_error(std::string("Error while opening ") + GetFilename() + std::string(", unsupported WAVE format"));
} }
ReadData(sizeof(WaveHeader::subchunk2ID) + sizeof(WaveHeader::subchunk2Size), true, enable, mtx); ReadData(sizeof(WaveHeader::subchunk2ID) + sizeof(WaveHeader::subchunk2Size), true, enable, mtx);
if (std::string(reinterpret_cast<char *>(header.subchunk2ID), 4) != std::string("data")) { if (std::string(reinterpret_cast<char *>(header.subchunk2ID), 4) != std::string("data")) {
throw std::runtime_error(std::string("Error while opening ") + GetFilename() + std::string(", data corrupted")); throw std::runtime_error(std::string("Error while opening ") + GetFilename() + std::string(", data corrupted"));
} }
} catch (...) { } catch (...) {
if (fileDescriptor != STDIN_FILENO) { if (fileDescriptor != STDIN_FILENO) {
close(fileDescriptor); close(fileDescriptor);
} }
throw; throw;
} }
if (fileDescriptor != STDIN_FILENO) { if (fileDescriptor != STDIN_FILENO) {
dataOffset = lseek(fileDescriptor, 0, SEEK_CUR); dataOffset = lseek(fileDescriptor, 0, SEEK_CUR);
} }
} }
WaveReader::~WaveReader() WaveReader::~WaveReader()
{ {
if (fileDescriptor != STDIN_FILENO) { if (fileDescriptor != STDIN_FILENO) {
close(fileDescriptor); close(fileDescriptor);
} }
} }
std::string WaveReader::GetFilename() const std::string WaveReader::GetFilename() const
{ {
return fileDescriptor != STDIN_FILENO ? filename : "STDIN"; return fileDescriptor != STDIN_FILENO ? filename : "STDIN";
} }
const WaveHeader &WaveReader::GetHeader() const const WaveHeader &WaveReader::GetHeader() const
{ {
return header; return header;
} }
std::vector<Sample> WaveReader::GetSamples(unsigned quantity, bool &enable, std::mutex &mtx) { std::vector<Sample> WaveReader::GetSamples(unsigned quantity, bool &enable, std::mutex &mtx) {
unsigned bytesPerSample = (header.bitsPerSample >> 3) * header.channels; unsigned bytesPerSample = (header.bitsPerSample >> 3) * header.channels;
unsigned bytesToRead = quantity * bytesPerSample; unsigned bytesToRead = quantity * bytesPerSample;
unsigned bytesLeft = header.subchunk2Size - currentDataOffset; unsigned bytesLeft = header.subchunk2Size - currentDataOffset;
if (bytesToRead > bytesLeft) { if (bytesToRead > bytesLeft) {
bytesToRead = bytesLeft - bytesLeft % bytesPerSample; bytesToRead = bytesLeft - bytesLeft % bytesPerSample;
quantity = bytesToRead / bytesPerSample; quantity = bytesToRead / bytesPerSample;
} }
std::vector<uint8_t> data = std::move(ReadData(bytesToRead, false, enable, mtx)); std::vector<uint8_t> data = std::move(ReadData(bytesToRead, false, enable, mtx));
if (data.size() < bytesToRead) { if (data.size() < bytesToRead) {
quantity = data.size() / bytesPerSample; quantity = data.size() / bytesPerSample;
} }
std::vector<Sample> samples; std::vector<Sample> samples;
samples.reserve(quantity); samples.reserve(quantity);
for (unsigned i = 0; i < quantity; i++) { for (unsigned i = 0; i < quantity; i++) {
samples.push_back(Sample(&data[bytesPerSample * i], header.channels, header.bitsPerSample)); samples.push_back(Sample(&data[bytesPerSample * i], header.channels, header.bitsPerSample));
} }
return samples; return samples;
} }
bool WaveReader::SetSampleOffset(unsigned offset) { bool WaveReader::SetSampleOffset(unsigned offset) {
if (fileDescriptor != STDIN_FILENO) { if (fileDescriptor != STDIN_FILENO) {
currentDataOffset = offset * (header.bitsPerSample >> 3) * header.channels; currentDataOffset = offset * (header.bitsPerSample >> 3) * header.channels;
if (lseek(fileDescriptor, dataOffset + currentDataOffset, SEEK_SET) == -1) { if (lseek(fileDescriptor, dataOffset + currentDataOffset, SEEK_SET) == -1) {
return false; return false;
} }
} }
return true; return true;
} }
std::vector<uint8_t> WaveReader::ReadData(unsigned bytesToRead, bool headerBytes, bool &enable, std::mutex &mtx) std::vector<uint8_t> WaveReader::ReadData(unsigned bytesToRead, bool headerBytes, bool &enable, std::mutex &mtx)
{ {
unsigned bytesRead = 0; unsigned bytesRead = 0;
std::vector<uint8_t> data; std::vector<uint8_t> data;
data.resize(bytesToRead); data.resize(bytesToRead);
timeval timeout = { timeval timeout = {
.tv_sec = 1, .tv_sec = 1,
}; };
fd_set fds; fd_set fds;
while (bytesRead < bytesToRead) { while (bytesRead < bytesToRead) {
{ {
std::lock_guard<std::mutex> lock(mtx); std::lock_guard<std::mutex> lock(mtx);
if (!enable) { if (!enable) {
break; break;
} }
} }
int bytes = read(fileDescriptor, &data[bytesRead], bytesToRead - bytesRead); int bytes = read(fileDescriptor, &data[bytesRead], bytesToRead - bytesRead);
if (((bytes == -1) && ((fileDescriptor != STDIN_FILENO) || (errno != EAGAIN))) || if (((bytes == -1) && ((fileDescriptor != STDIN_FILENO) || (errno != EAGAIN))) ||
((static_cast<unsigned>(bytes) < bytesToRead) && headerBytes && (fileDescriptor != STDIN_FILENO))) { ((static_cast<unsigned>(bytes) < bytesToRead) && headerBytes && (fileDescriptor != STDIN_FILENO))) {
throw std::runtime_error(std::string("Error while opening ") + GetFilename() + std::string(", data corrupted")); throw std::runtime_error(std::string("Error while opening ") + GetFilename() + std::string(", data corrupted"));
} }
if (bytes > 0) { if (bytes > 0) {
bytesRead += bytes; bytesRead += bytes;
} }
if (bytesRead < bytesToRead) { if (bytesRead < bytesToRead) {
if (fileDescriptor != STDIN_FILENO) { if (fileDescriptor != STDIN_FILENO) {
data.resize(bytesRead); data.resize(bytesRead);
break; break;
} else { } else {
FD_ZERO(&fds); FD_ZERO(&fds);
FD_SET(STDIN_FILENO, &fds); FD_SET(STDIN_FILENO, &fds);
select(STDIN_FILENO + 1, &fds, nullptr, nullptr, &timeout); select(STDIN_FILENO + 1, &fds, nullptr, nullptr, &timeout);
if (FD_ISSET(STDIN_FILENO, &fds)) { if (FD_ISSET(STDIN_FILENO, &fds)) {
FD_CLR(STDIN_FILENO, &fds); FD_CLR(STDIN_FILENO, &fds);
} }
} }
} }
} }
if (headerBytes) { if (headerBytes) {
{ {
std::lock_guard<std::mutex> lock(mtx); std::lock_guard<std::mutex> lock(mtx);
if (!enable) { if (!enable) {
throw std::runtime_error("Cannot obtain header, program interrupted"); throw std::runtime_error("Cannot obtain header, program interrupted");
} }
} }
std::memcpy(&(reinterpret_cast<uint8_t *>(&header))[headerOffset], data.data(), bytesRead); std::memcpy(&(reinterpret_cast<uint8_t *>(&header))[headerOffset], data.data(), bytesRead);
headerOffset += bytesRead; headerOffset += bytesRead;
} else { } else {
{ {
std::lock_guard<std::mutex> lock(mtx); std::lock_guard<std::mutex> lock(mtx);
if (!enable) { if (!enable) {
data.resize(bytesRead); data.resize(bytesRead);
} }
} }
currentDataOffset += bytesRead; currentDataOffset += bytesRead;
} }
return data; return data;
} }