2218 lines
77 KiB
C++
2218 lines
77 KiB
C++
|
|
|
|
#include "tfilepath.h"
|
|
#include "tsound.h"
|
|
#include "tsound_io.h"
|
|
#include "tsop.h"
|
|
#include "tthread.h"
|
|
#include "texception.h"
|
|
#include "tsystem.h"
|
|
#include <iostream>
|
|
#include <linux/soundcard.h>
|
|
#include <set>
|
|
#include <sys/time.h>
|
|
|
|
#include <unistd.h>
|
|
|
|
#include <fcntl.h>
|
|
#include <sys/ioctl.h>
|
|
|
|
// using namespace std;
|
|
|
|
// forward declaration
|
|
namespace {
|
|
int openMixer();
|
|
int getCurrentRecordSource(int mixer);
|
|
bool writeVolume(int volume, int mixer, int indexDev);
|
|
bool selectInputDevice(TSoundInputDevice::Source dev);
|
|
string parseError(int error);
|
|
}
|
|
|
|
// bisogna interagire con /dev/dsp per il settaggio delle
|
|
// caratteristiche della traccia tipo bit, rate, canali e
|
|
// per effettuare lettura/scrittura ossia record/play
|
|
//
|
|
// mentre bisogna interagire con /dev/mixer per modificare
|
|
// i valori del volume e per selezionare il dispositivo da
|
|
// cui registrare e ascoltare
|
|
|
|
class SmartWatch {
|
|
struct timeval m_start_tv;
|
|
TINT32 m_totalus;
|
|
bool m_stopped;
|
|
|
|
public:
|
|
SmartWatch() : m_totalus(0), m_stopped(true) { timerclear(&m_start_tv); }
|
|
void start() {
|
|
m_stopped = false;
|
|
gettimeofday(&m_start_tv, 0);
|
|
}
|
|
void stop() {
|
|
m_stopped = true;
|
|
struct timeval tv;
|
|
gettimeofday(&tv, 0);
|
|
m_totalus = (tv.tv_sec - m_start_tv.tv_sec) * 1000000 +
|
|
(tv.tv_usec - m_start_tv.tv_usec);
|
|
}
|
|
double getTotalTime() {
|
|
if (!m_stopped) // questa e' una porcata!
|
|
{
|
|
stop();
|
|
m_stopped = false;
|
|
}
|
|
return m_totalus / 1000.;
|
|
}
|
|
|
|
void addDelay(double ms) { m_start_tv.tv_usec += (long)(ms * 1000.); }
|
|
};
|
|
|
|
//======================================================================
|
|
//======================================================================
|
|
// CLASSI PER IL PLAYBACK
|
|
//======================================================================
|
|
//======================================================================
|
|
class TSoundOutputDeviceImp {
|
|
private:
|
|
static int m_count;
|
|
|
|
public:
|
|
int m_dev;
|
|
bool m_stopped;
|
|
bool m_isPlaying;
|
|
bool m_looped;
|
|
TSoundTrackFormat m_currentFormat;
|
|
std::set<int> m_supportedRate;
|
|
static std::multimap<TUINT32, TSoundTrackFormat> m_supportFormats;
|
|
|
|
typedef pair<TSoundTrackP, bool> WaitPair;
|
|
vector<WaitPair> m_waitingTracks;
|
|
std::set<TSoundOutputDeviceListener *> m_listeners;
|
|
TThread::Executor m_executor;
|
|
TThread::Mutex m_mutex;
|
|
|
|
TSoundOutputDeviceImp()
|
|
: m_dev(-1)
|
|
, m_stopped(false)
|
|
, m_isPlaying(false)
|
|
, m_looped(false)
|
|
, m_supportedRate() {
|
|
/*
|
|
if (m_count != 0)
|
|
throw TException("unable to create second instance of TSoundOutputDeviceImp");
|
|
*/
|
|
++m_count;
|
|
checkSupportedFormat();
|
|
};
|
|
|
|
~TSoundOutputDeviceImp() { --m_count; };
|
|
|
|
bool doOpenDevice();
|
|
bool doCloseDevice();
|
|
bool verifyRate();
|
|
void insertAllRate();
|
|
void checkSupportedFormat();
|
|
bool isSupportFormat(const TSoundTrackFormat &fmt);
|
|
void setFormat(const TSoundTrackFormat &fmt);
|
|
};
|
|
|
|
int TSoundOutputDeviceImp::m_count = 0;
|
|
std::multimap<TUINT32, TSoundTrackFormat>
|
|
TSoundOutputDeviceImp::m_supportFormats;
|
|
//----------------------------------------------------------------------------
|
|
|
|
bool TSoundOutputDeviceImp::doOpenDevice() {
|
|
if (m_dev >= 0) return true;
|
|
|
|
TThread::ScopedLock sl(m_mutex);
|
|
m_dev = open("/dev/dsp", O_WRONLY, 0);
|
|
if (m_dev < 0) {
|
|
string errMsg = strerror(errno);
|
|
throw TSoundDeviceException(
|
|
TSoundDeviceException::UnableOpenDevice, errMsg + " /dev/dsp"
|
|
/*"Unable to open device /dev/dsp; check permissions"*/);
|
|
}
|
|
|
|
// le chiamate a questa ioctl sono state commentate perche' pag 36 doc OSS
|
|
//"this ioctl stop the device immadiately and returns it to a state where
|
|
// it
|
|
// can accept new parameters. It Should not be called after opening the device
|
|
// as it may cause unwanted side effect in his situation. require to abort
|
|
// play
|
|
// or secord.Generally recommended to open and close device after using the
|
|
// RESET"
|
|
// ioctl(m_dev, SNDCTL_DSP_RESET,0);
|
|
|
|
// N.B. e' bene che la dimensione sia piccola cosi' l'attesa, in seguito
|
|
// alla richiesta di stop,
|
|
// e' minore in questo caso vogliamo 32 frammenti ognuno di 256 byte
|
|
// Se non chiamata questa ioctl il device la calcola per conto suo
|
|
// ma alcune volte la dimensione dei frammenti potrebbe essere eccessiva e
|
|
// creare dei click e dei silenzi in attesi ad esempio nel playback dentro
|
|
// zcomp, quindi e' meglio settarla. 32 rappresenta il numero di frammenti
|
|
// di solito e' documentato che 2 siano sufficienti ma potrebbero essere pochi
|
|
// soprattutto se si interagisce con altre console
|
|
// int fraginfo = ( 32<<16)|8;
|
|
|
|
int fraginfo = 0xffffffff;
|
|
if (ioctl(m_dev, SNDCTL_DSP_SETFRAGMENT, &fraginfo) == -1)
|
|
perror("SETFRAGMENT");
|
|
// if(fraginfo != ((32<<16)|8))
|
|
// std::cout << std::hex << fraginfo<<std::endl;
|
|
// exit(0);
|
|
audio_buf_info info;
|
|
if (ioctl(m_dev, SNDCTL_DSP_GETOSPACE, &info) == -1) perror("GETOSPACE");
|
|
|
|
// std::cout << info.fragments << " frammenti " << " da " << info.fragsize <<
|
|
// " = " << info.fragsize*info.fragments << " bytes" <<std::endl;
|
|
|
|
return true;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
|
|
bool TSoundOutputDeviceImp::doCloseDevice() {
|
|
if (m_dev < 0) return true;
|
|
|
|
TThread::ScopedLock sl(m_mutex);
|
|
ioctl(m_dev, SNDCTL_DSP_POST, 0);
|
|
ioctl(m_dev, SNDCTL_DSP_RESET, 0);
|
|
int tmpDev = m_dev;
|
|
bool not_closed = (close(m_dev) < 0);
|
|
if (not_closed) {
|
|
while (true) {
|
|
m_dev = tmpDev;
|
|
perror("non chiude il device :");
|
|
not_closed = (close(m_dev) < 0);
|
|
if (!not_closed) break;
|
|
}
|
|
// return false;
|
|
}
|
|
ioctl(m_dev, SNDCTL_DSP_RESET, 0);
|
|
m_dev = -1;
|
|
return true;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
|
|
void TSoundOutputDeviceImp::insertAllRate() {
|
|
m_supportedRate.insert(8000);
|
|
m_supportedRate.insert(11025);
|
|
m_supportedRate.insert(16000);
|
|
m_supportedRate.insert(22050);
|
|
m_supportedRate.insert(32000);
|
|
m_supportedRate.insert(44100);
|
|
m_supportedRate.insert(48000);
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
|
|
bool TSoundOutputDeviceImp::verifyRate() {
|
|
std::set<int>::iterator it;
|
|
|
|
for (it = m_supportedRate.begin(); it != m_supportedRate.end(); ++it) {
|
|
int sampleRate = *it;
|
|
if (ioctl(m_dev, SNDCTL_DSP_SPEED, &sampleRate) == -1)
|
|
throw TSoundDeviceException(
|
|
TSoundDeviceException::UnablePrepare,
|
|
"Failed setting the specified sample rate aaaa");
|
|
if (sampleRate != *it) m_supportedRate.erase(*it);
|
|
}
|
|
if (m_supportedRate.end() == m_supportedRate.begin()) return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
void TSoundOutputDeviceImp::checkSupportedFormat() {
|
|
if (!m_supportFormats.empty()) return;
|
|
int test_formats[] = {
|
|
AFMT_U8, AFMT_S8, AFMT_S16_LE, AFMT_S16_BE,
|
|
/* // servono per supportare traccie a 24 e 32 bit ma non compaiono in
|
|
// nessun file linux/soundcard.h in distribuzione sulle macchine che abbiamo
|
|
// il che fa pensare che non sono supportati ancora
|
|
AFMT_S32_LE,
|
|
AFMT_S32_BE,
|
|
*/
|
|
0};
|
|
|
|
int test_channels[] = {1, 2, 0};
|
|
|
|
TUINT32 test_sample_rates[] = {8000, 11025, 16000, 22050,
|
|
32000, 44100, 48000, 0};
|
|
|
|
// Open the device nonblocking, so the open call returns immediately.
|
|
if (m_dev)
|
|
if ((m_dev = open("/dev/dsp", O_WRONLY | O_NONBLOCK)) == -1) {
|
|
/*
|
|
m_dev = -1;
|
|
string errMsg = strerror(errno);
|
|
throw TSoundDeviceException(
|
|
TSoundDeviceException::UnableOpenDevice, errMsg + " /dev/dsp\n:
|
|
impossible check supported formats");
|
|
*/
|
|
return;
|
|
}
|
|
|
|
int mask;
|
|
// Querying hardware supported formats.
|
|
if (ioctl(m_dev, SNDCTL_DSP_GETFMTS, &mask) == -1) {
|
|
/*
|
|
throw TSoundDeviceException(
|
|
TSoundDeviceException::UnsupportedFormat,
|
|
"Getting supported formats failed.");
|
|
*/
|
|
return;
|
|
} else {
|
|
for (int i = 0; test_formats[i] != 0; i++) {
|
|
// Test all the formats in test_formats which are supported by the
|
|
// hardware.
|
|
|
|
if (mask & test_formats[i]) {
|
|
// Test the format only if it is supported by the hardware.
|
|
// Note: We also could test formats that are not supported by the
|
|
// hardware.
|
|
// In some cases there exist OSS software converter, so that some
|
|
// formats
|
|
// work but are not reported by the above SNDCTL_DSP_GETFMTS.
|
|
|
|
int fmt = test_formats[i];
|
|
// Try to set the format...
|
|
if (ioctl(m_dev, SNDCTL_DSP_SETFMT, &fmt) == -1)
|
|
continue; // gli altri formati potrebbero essere supportati
|
|
else {
|
|
// and always check the variable after doing an ioctl!
|
|
if (fmt == test_formats[i]) {
|
|
// Test the supported channel numbers for this format.
|
|
// Note: If you need a channel that is not tested here, simply add
|
|
// it to
|
|
// the definition of the array test_channels in this file.
|
|
for (int j = 0; test_channels[j] != 0; j++) {
|
|
int test_channel = test_channels[j];
|
|
|
|
// Try to set the channel number.
|
|
if (ioctl(m_dev, SNDCTL_DSP_CHANNELS, &test_channel) == -1)
|
|
continue; // altri canali potrebbero essere supportati
|
|
else {
|
|
if (test_channel == test_channels[j]) {
|
|
// Last step: Test the supported sample rates for the current
|
|
// channel number
|
|
// and format.
|
|
// Note: If you need a sample rate that is not tested here,
|
|
// simply add it to
|
|
// the definition of the array test_sample_rates in this
|
|
// file.
|
|
for (int k = 0; test_sample_rates[k] != 0; k++) {
|
|
TUINT32 test_rate = test_sample_rates[k];
|
|
if (ioctl(m_dev, SNDCTL_DSP_SPEED, &test_rate) == -1)
|
|
continue; // altri rates ppotrebbero essere supportati
|
|
else {
|
|
bool sign = true;
|
|
int bits;
|
|
|
|
if (fmt == AFMT_U8 || fmt == AFMT_S8) {
|
|
bits = 8;
|
|
if (fmt == AFMT_U8) sign = false;
|
|
} else if (fmt == AFMT_S16_LE || fmt == AFMT_S16_BE)
|
|
bits = 16;
|
|
/*// vedi commento alla variabile test_formats
|
|
else if(fmt == AFMT_S32_LE || fmt == AFMT_S32_BE)
|
|
bits = 24;
|
|
*/
|
|
// Add it to the format in the input property.
|
|
// std::cout << test_rate << " " <<bits<<"
|
|
// "<<test_channel<<std::endl;
|
|
m_supportFormats.insert(std::make_pair(
|
|
test_rate, TSoundTrackFormat(test_rate, bits,
|
|
test_channel, sign)));
|
|
}
|
|
}
|
|
} // loop over the test_sample_rates
|
|
} // channel set correctly ?
|
|
} // ioctl for sample rate worked ?
|
|
} // loop over the test_channels
|
|
} // channel set correctly ?
|
|
} // ioctl for channel worked ?
|
|
|
|
// After testing all configurations for one format, the device is closed
|
|
// and reopened.
|
|
// This is necessary to configure it to another format in a secure way.
|
|
if (close(m_dev) == -1) {
|
|
/*
|
|
throw TSoundDeviceException(
|
|
TSoundDeviceException::UnableCloseDevice,
|
|
"Problem to close the output device checking formats");
|
|
*/
|
|
continue;
|
|
} else if ((m_dev = open("/dev/dsp", O_WRONLY | O_NONBLOCK)) == -1) {
|
|
/*
|
|
m_dev = -1;
|
|
string errMsg = strerror(errno);
|
|
throw TSoundDeviceException(
|
|
TSoundDeviceException::UnableOpenDevice, errMsg + " /dev/dsp\n:
|
|
impossible check supported formats");
|
|
*/
|
|
return;
|
|
}
|
|
} // format set correctly ?
|
|
} // loop over the test_formats
|
|
|
|
// Close the device to make it forget the last format configurations.
|
|
|
|
if (close(m_dev) == -1) {
|
|
/*
|
|
throw TSoundDeviceException(
|
|
TSoundDeviceException::UnableCloseDevice,
|
|
"Problem to close the output device checking formats");
|
|
*/
|
|
return;
|
|
} else
|
|
m_dev = -1;
|
|
// std::cout << "FINITO " << m_supportFormats.size()<< std::endl;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
bool TSoundOutputDeviceImp::isSupportFormat(const TSoundTrackFormat &fmt) {
|
|
try {
|
|
if (m_supportFormats.empty()) checkSupportedFormat();
|
|
} catch (TSoundDeviceException &e) {
|
|
return false;
|
|
}
|
|
|
|
std::multimap<TUINT32, TSoundTrackFormat>::iterator it;
|
|
pair<std::multimap<TUINT32, TSoundTrackFormat>::iterator,
|
|
std::multimap<TUINT32, TSoundTrackFormat>::iterator>
|
|
findRange;
|
|
findRange = m_supportFormats.equal_range(fmt.m_sampleRate);
|
|
|
|
it = findRange.first;
|
|
for (; it != findRange.second; ++it) {
|
|
assert(it->first == fmt.m_sampleRate);
|
|
if (it->second == fmt) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
void TSoundOutputDeviceImp::setFormat(const TSoundTrackFormat &fmt) {
|
|
int bps, ch, status;
|
|
TUINT32 sampleRate;
|
|
|
|
ch = fmt.m_channelCount;
|
|
sampleRate = fmt.m_sampleRate;
|
|
|
|
if (m_dev == -1)
|
|
if (!doOpenDevice()) return;
|
|
|
|
if (fmt.m_bitPerSample == 8) {
|
|
if (fmt.m_signedSample)
|
|
bps = AFMT_S8;
|
|
else
|
|
bps = AFMT_U8;
|
|
} else if (fmt.m_bitPerSample == 16) {
|
|
bps = AFMT_S16_NE;
|
|
}
|
|
int bitPerSample = bps;
|
|
|
|
status = ioctl(m_dev, SNDCTL_DSP_SETFMT, &bps);
|
|
if (status == -1) {
|
|
throw TSoundDeviceException(TSoundDeviceException::UnablePrepare,
|
|
"Failed setting the specified number of bits");
|
|
}
|
|
|
|
status = ioctl(m_dev, SNDCTL_DSP_CHANNELS, &ch);
|
|
if (status == -1)
|
|
throw TSoundDeviceException(
|
|
TSoundDeviceException::UnablePrepare,
|
|
"Failed setting the specified number of channel");
|
|
|
|
if (ioctl(m_dev, SNDCTL_DSP_SPEED, &sampleRate) == -1)
|
|
throw TSoundDeviceException(TSoundDeviceException::UnablePrepare,
|
|
"Failed setting the specified sample rate");
|
|
|
|
if (ch != fmt.m_channelCount || bps != bitPerSample ||
|
|
sampleRate != fmt.m_sampleRate) {
|
|
doCloseDevice();
|
|
m_currentFormat = TSoundTrackFormat();
|
|
return;
|
|
}
|
|
m_currentFormat = fmt;
|
|
}
|
|
|
|
//==============================================================================
|
|
|
|
class TPlayTask : public TThread::Runnable {
|
|
SmartWatch *m_stopWatch;
|
|
|
|
public:
|
|
TSoundOutputDeviceImp *m_devImp;
|
|
TSoundTrackP m_sndtrack;
|
|
static int m_skipBytes;
|
|
|
|
TPlayTask(TSoundOutputDeviceImp *devImp, const TSoundTrackP &st);
|
|
|
|
~TPlayTask() { delete m_stopWatch; }
|
|
|
|
void run();
|
|
void run2();
|
|
};
|
|
|
|
//-------------------------------------------------------------------------------
|
|
|
|
TPlayTask::TPlayTask(TSoundOutputDeviceImp *devImp, const TSoundTrackP &st)
|
|
: Runnable()
|
|
, m_stopWatch(new SmartWatch)
|
|
, m_devImp(devImp)
|
|
, m_sndtrack(st) {
|
|
if (st->getFormat() != m_devImp->m_currentFormat)
|
|
if (m_devImp->doCloseDevice()) m_devImp->setFormat(st->getFormat());
|
|
m_stopWatch->start();
|
|
};
|
|
|
|
//-------------------------------------------------------------------------------
|
|
|
|
void TPlayTask::run() {
|
|
int bytesLeft = m_sndtrack->getSampleCount() * m_sndtrack->getSampleSize();
|
|
char *buf = (char *)m_sndtrack->getRawData();
|
|
int done = 0;
|
|
int written = 0;
|
|
TINT32 sampleSize = (TINT32)m_sndtrack->getSampleSize();
|
|
const double msToBytes = sampleSize * m_sndtrack->getSampleRate() / 1000.;
|
|
|
|
TThread::milestone();
|
|
double startupDelay = m_stopWatch->getTotalTime();
|
|
// std::cout << "ritardo iniziale " << startupDelay << std::endl;
|
|
int miss = 0;
|
|
m_stopWatch->start(); // e' meglio ignorare il ritardo iniziale
|
|
if (done > 0) {
|
|
m_stopWatch->addDelay(((done / sampleSize) * 1000) /
|
|
double(m_sndtrack->getSampleRate()));
|
|
}
|
|
int auxbuffersize = 0;
|
|
int preWrittenBytes = 0;
|
|
int bytesToSkipNext;
|
|
TSoundTrackP src = TSoundTrack::create(m_sndtrack->getFormat(), 1);
|
|
TSoundTrackP dst = src;
|
|
TSoundTrackP newSrc = src;
|
|
try {
|
|
do // gia' tracce accodate
|
|
{
|
|
bool changeSnd = false;
|
|
do // c'e' il flag loop settato
|
|
{
|
|
while ((bytesLeft > 0)) {
|
|
TThread::milestone();
|
|
changeSnd = false;
|
|
audio_buf_info info;
|
|
TINT32 bytesToWrite = 0;
|
|
TINT32 bytesToWriteNext = 0;
|
|
double samplesDone = done / (double)sampleSize;
|
|
double trackTime =
|
|
(samplesDone * 1000.) / m_sndtrack->getSampleRate();
|
|
double curTime = m_stopWatch->getTotalTime();
|
|
double delta = curTime - trackTime;
|
|
|
|
/*
|
|
delta
|
|
== 0 sync
|
|
< 0 audio piu' veloce del tempo
|
|
di playback --> simuliamo un ritardo con un continue;
|
|
> 0 audio piu' lento del playback ->
|
|
skip una porzione di audio
|
|
*/
|
|
|
|
const double minDelay = -10;
|
|
const double maxDelay = 0;
|
|
// if (delta>maxDelay)
|
|
// std::cout << "buffer underrun:" << delta << std::endl;
|
|
// std::cout << "buffer " <<
|
|
// (delta<minDelay?"overrun":delta>maxDelay?"underrun":"sync") << " "
|
|
// << delta<< std::endl;
|
|
|
|
if (delta < minDelay) // overrun
|
|
{
|
|
// std::cout << "out of sync -> audio troppo veloce" << std::endl;
|
|
continue;
|
|
}
|
|
|
|
if (ioctl(m_devImp->m_dev, SNDCTL_DSP_GETOSPACE, &info) == -1) {
|
|
miss++;
|
|
break;
|
|
}
|
|
|
|
int fragmentsFree_bytes = info.fragsize * info.fragments;
|
|
if (fragmentsFree_bytes == 0) {
|
|
// std::cout << "no bytes left on device" << std::endl;
|
|
continue;
|
|
}
|
|
|
|
int bytesToSkip = 0;
|
|
bytesToSkipNext = 0;
|
|
if (delta > maxDelay) // underrun
|
|
{
|
|
// std::cout << "out of sync -> audio troppo lento"<<std::endl;
|
|
// skip di una porzione... delta in ms
|
|
bytesToSkip =
|
|
tceil(delta * msToBytes); // numero di bytes da skippare
|
|
// lo arrotondo al sample size
|
|
bytesToSkip += sampleSize - (bytesToSkip % sampleSize);
|
|
// std::cout << "bytes skippati "<< bytesToSkip << std::endl;
|
|
} else { // sto fra minDelay e maxDelay
|
|
bytesToSkip = 0;
|
|
}
|
|
|
|
bytesToSkipNext = bytesToSkip;
|
|
bytesToSkip = tmin(bytesLeft, bytesToSkip);
|
|
bytesToSkipNext -= bytesToSkip; // se !=0 => la corrente traccia non
|
|
// basta per avere il sync
|
|
bytesLeft -= bytesToSkip;
|
|
done += bytesToSkip;
|
|
|
|
bytesToWrite = tmin(bytesLeft, fragmentsFree_bytes);
|
|
bytesToWriteNext = fragmentsFree_bytes - bytesToWrite;
|
|
assert(bytesToWrite >= 0);
|
|
assert(bytesToWriteNext >= 0);
|
|
|
|
if (bytesToWrite % info.fragsize !=
|
|
0) { // cerco di gestire il write di un frammento non intero
|
|
auxbuffersize =
|
|
((bytesToWrite / info.fragsize) + 1) * info.fragsize;
|
|
} else
|
|
auxbuffersize = 0;
|
|
|
|
//--------------write
|
|
if (bytesToSkipNext == 0) // la corrente traccia basta per lo skip
|
|
{
|
|
std::cout << " QUI 0 " << std::endl;
|
|
dst = m_sndtrack->extract(done / sampleSize,
|
|
(done + bytesToWrite) / sampleSize);
|
|
if (bytesToSkip != 0) {
|
|
// costruisco traccia su cui fare il crossfade
|
|
// utilizzo il contenuto della traccia di crossfade
|
|
dst = TSop::crossFade(0.2, src, dst);
|
|
}
|
|
char *auxbuf = new char[fragmentsFree_bytes];
|
|
memcpy(auxbuf, (char *)dst->getRawData(), bytesToWrite);
|
|
if (bytesToWriteNext != 0) {
|
|
int offset = bytesToWrite;
|
|
if (m_devImp->m_looped) {
|
|
offset += bytesToWriteNext;
|
|
preWrittenBytes = bytesToWriteNext;
|
|
memcpy(auxbuf + offset, buf, preWrittenBytes);
|
|
newSrc = m_sndtrack->extract(preWrittenBytes / sampleSize,
|
|
preWrittenBytes / sampleSize);
|
|
std::cout << " QUI 1" << std::endl;
|
|
} else {
|
|
while (!m_devImp->m_waitingTracks.empty()) {
|
|
TSoundTrackP st = m_devImp->m_waitingTracks[0].first;
|
|
int count = st->getSampleCount() * sampleSize;
|
|
if (bytesToWriteNext >= count) {
|
|
char *buffer = (char *)st->getRawData();
|
|
memcpy(auxbuf + offset, buffer, count);
|
|
bytesToWriteNext -= count;
|
|
offset += count;
|
|
std::cout << " QUI 2" << std::endl;
|
|
if (m_devImp->m_waitingTracks[0].second) {
|
|
m_devImp->m_looped = m_devImp->m_waitingTracks[0].second;
|
|
m_devImp->m_waitingTracks.erase(
|
|
m_devImp->m_waitingTracks.begin());
|
|
newSrc = m_sndtrack->extract(count / sampleSize,
|
|
count / sampleSize);
|
|
m_sndtrack = st;
|
|
preWrittenBytes = 0;
|
|
std::cout << " QUI 3" << std::endl;
|
|
break;
|
|
}
|
|
m_devImp->m_waitingTracks.erase(
|
|
m_devImp->m_waitingTracks.begin());
|
|
newSrc = m_sndtrack->extract(count / sampleSize,
|
|
count / sampleSize);
|
|
} else {
|
|
m_sndtrack = st;
|
|
m_devImp->m_looped = m_devImp->m_waitingTracks[0].second;
|
|
preWrittenBytes = bytesToWriteNext;
|
|
buf = (char *)m_sndtrack->getRawData();
|
|
memcpy(auxbuf + offset, buf, bytesToWriteNext);
|
|
m_devImp->m_waitingTracks.erase(
|
|
m_devImp->m_waitingTracks.begin());
|
|
newSrc =
|
|
m_sndtrack->extract((bytesToWriteNext) / sampleSize,
|
|
(bytesToWriteNext) / sampleSize);
|
|
std::cout << " QUI 4" << std::endl;
|
|
break;
|
|
}
|
|
} // end while
|
|
}
|
|
|
|
if (fragmentsFree_bytes > offset) {
|
|
std::cout << " QUI 5" << std::endl;
|
|
int val = m_sndtrack->isSampleSigned() ? 0 : 127;
|
|
memset(auxbuf + offset, val,
|
|
fragmentsFree_bytes - offset); // ci metto silenzio
|
|
newSrc = TSoundTrack::create(m_sndtrack->getFormat(), 1);
|
|
}
|
|
}
|
|
|
|
written = write(m_devImp->m_dev, auxbuf, fragmentsFree_bytes);
|
|
delete[] auxbuf;
|
|
} else // devo skippare anche parte di una delle seguenti
|
|
{
|
|
std::cout << " QUI 6a" << std::endl;
|
|
assert(bytesToWriteNext > 0);
|
|
assert(bytesToWriteNext == fragmentsFree_bytes - bytesToWrite);
|
|
assert(bytesToWrite == 0);
|
|
assert(bytesToSkip != 0);
|
|
char *auxbuf = new char[fragmentsFree_bytes];
|
|
// memcpy(auxbuf, buf+done, bytesToWrite);
|
|
// TSoundTrackP subCross =
|
|
// m_sndtrack->extract((done+bytesToWrite)/sampleSize,
|
|
// (done+bytesToWrite)/sampleSize);
|
|
// togli quelle da skippare
|
|
int backupSkipNext = bytesToSkipNext;
|
|
while (!m_devImp->m_waitingTracks.empty()) {
|
|
TSoundTrackP st = m_devImp->m_waitingTracks[0].first;
|
|
int count = st->getSampleCount() * sampleSize;
|
|
if (bytesToSkipNext >= count) {
|
|
std::cout << " QUI 6b" << std::endl;
|
|
m_devImp->m_waitingTracks.erase(
|
|
m_devImp->m_waitingTracks.begin());
|
|
bytesToSkipNext -= count;
|
|
} else {
|
|
std::cout << " QUI 7" << std::endl;
|
|
m_devImp->m_waitingTracks.erase(
|
|
m_devImp->m_waitingTracks.begin());
|
|
m_devImp->m_looped = m_devImp->m_waitingTracks[0].second;
|
|
m_sndtrack = st;
|
|
buf = (char *)st->getRawData();
|
|
break;
|
|
}
|
|
}
|
|
// scrivi byteWriteNext fai crossfade e cerca quella successiva
|
|
// con cui riempire
|
|
TINT32 displacement =
|
|
0; // deve essere in munero di campioni non bytes
|
|
dst = TSoundTrack::create(
|
|
m_sndtrack->getFormat(),
|
|
(fragmentsFree_bytes - bytesToWrite) / sampleSize);
|
|
int count = m_sndtrack->getSampleCount() * sampleSize;
|
|
if (count >= bytesToSkipNext + bytesToWriteNext) // la traccia
|
|
// trovata e' suff
|
|
// sia per
|
|
// skippare che
|
|
// per scrivere
|
|
{
|
|
preWrittenBytes = bytesToSkipNext + bytesToWriteNext;
|
|
dst = m_sndtrack->extract(bytesToSkipNext / sampleSize,
|
|
preWrittenBytes / sampleSize);
|
|
newSrc = m_sndtrack->extract(preWrittenBytes / sampleSize,
|
|
preWrittenBytes / sampleSize);
|
|
} else // non e' suff per scrivere
|
|
{
|
|
dst->copy(m_sndtrack->extract(bytesToSkipNext / sampleSize,
|
|
m_sndtrack->getSampleCount() - 1),
|
|
0);
|
|
displacement =
|
|
m_sndtrack->getSampleCount() - bytesToSkipNext / sampleSize;
|
|
bytesToWriteNext -= displacement * sampleSize;
|
|
while (!m_devImp->m_waitingTracks.empty()) {
|
|
TSoundTrackP st = m_devImp->m_waitingTracks[0].first;
|
|
int count = st->getSampleCount() * sampleSize;
|
|
if (bytesToWriteNext >= count) {
|
|
std::cout << " QUI 8" << std::endl;
|
|
dst->copy(st, displacement);
|
|
bytesToWriteNext -= count;
|
|
displacement += count;
|
|
if (m_devImp->m_waitingTracks[0].second) {
|
|
std::cout << " QUI 9" << std::endl;
|
|
m_devImp->m_looped = m_devImp->m_waitingTracks[0].second;
|
|
m_devImp->m_waitingTracks.erase(
|
|
m_devImp->m_waitingTracks.begin());
|
|
newSrc = m_sndtrack->extract(count / sampleSize,
|
|
count / sampleSize);
|
|
m_sndtrack = st;
|
|
break;
|
|
}
|
|
m_devImp->m_waitingTracks.erase(
|
|
m_devImp->m_waitingTracks.begin());
|
|
newSrc = m_sndtrack->extract(count / sampleSize,
|
|
count / sampleSize);
|
|
} else {
|
|
std::cout << " QUI 10" << std::endl;
|
|
dst->copy(st->extract(0L, bytesToWriteNext / sampleSize),
|
|
displacement);
|
|
m_sndtrack = st;
|
|
m_devImp->m_looped = m_devImp->m_waitingTracks[0].second;
|
|
preWrittenBytes = bytesToWriteNext;
|
|
done = preWrittenBytes;
|
|
bytesLeft = m_sndtrack->getSampleCount() * sampleSize - done;
|
|
buf = (char *)m_sndtrack->getRawData();
|
|
m_devImp->m_waitingTracks.erase(
|
|
m_devImp->m_waitingTracks.begin());
|
|
newSrc = m_sndtrack->extract(preWrittenBytes / sampleSize,
|
|
preWrittenBytes / sampleSize);
|
|
break;
|
|
}
|
|
}
|
|
bytesToSkipNext = backupSkipNext;
|
|
}
|
|
|
|
TSoundTrackP st = TSop::crossFade(0.2, src, dst);
|
|
memcpy(auxbuf + bytesToWrite, (char *)st->getRawData(),
|
|
fragmentsFree_bytes - bytesToWrite);
|
|
|
|
// devo ricercare quella giusta che non deve essere skippata
|
|
// ma sostitutita come traccia corrente
|
|
// devo fare un cross fade
|
|
written = write(m_devImp->m_dev, auxbuf, fragmentsFree_bytes);
|
|
delete[] auxbuf;
|
|
}
|
|
//----------- end write
|
|
src = newSrc;
|
|
if (written == -1) break;
|
|
std::cout << written << " " << (bytesToWrite + preWrittenBytes)
|
|
<< std::endl;
|
|
if (written != bytesToWrite + preWrittenBytes) break;
|
|
std::cout << " update done 2" << std::endl;
|
|
bytesLeft -= written;
|
|
done += written;
|
|
} // chiudo il while((bytesLeft > 0))
|
|
std::cout << " QUI 11" << std::endl;
|
|
done = preWrittenBytes + bytesToSkipNext;
|
|
written = 0;
|
|
bytesLeft = m_sndtrack->getSampleCount() * sampleSize - done;
|
|
m_stopWatch->start();
|
|
if (done > 0) {
|
|
m_stopWatch->addDelay(((done / m_sndtrack->getSampleSize()) * 1000) /
|
|
double(m_sndtrack->getSampleRate()));
|
|
}
|
|
preWrittenBytes = 0;
|
|
} while (m_devImp->m_looped || changeSnd);
|
|
|
|
if (m_devImp->m_waitingTracks.empty()) break;
|
|
m_sndtrack = m_devImp->m_waitingTracks[0].first;
|
|
m_devImp->m_looped = m_devImp->m_waitingTracks[0].second;
|
|
m_devImp->m_waitingTracks.erase(m_devImp->m_waitingTracks.begin());
|
|
bytesLeft = m_sndtrack->getSampleCount() * m_sndtrack->getSampleSize();
|
|
buf = (char *)m_sndtrack->getRawData();
|
|
done = 0;
|
|
written = 0;
|
|
|
|
m_stopWatch->start(); // ignoro il ritardo iniziale
|
|
if (done > 0) {
|
|
m_stopWatch->addDelay(((done / m_sndtrack->getSampleSize()) * 1000) /
|
|
double(m_sndtrack->getSampleRate()));
|
|
}
|
|
} while (true); // ci sono gia' tracce accodate
|
|
|
|
if (!m_devImp->m_waitingTracks.empty()) {
|
|
m_devImp->m_looped = m_devImp->m_waitingTracks[0].second;
|
|
m_devImp->m_executor.addTask(
|
|
new TPlayTask(m_devImp, m_devImp->m_waitingTracks[0].first));
|
|
m_devImp->m_waitingTracks.erase(m_devImp->m_waitingTracks.begin());
|
|
// std::cout<<"OPS ..... erase 4"<<std::endl;
|
|
} else if (m_devImp->m_dev != -1) {
|
|
if (ioctl(m_devImp->m_dev, SNDCTL_DSP_SYNC) == -1) {
|
|
std::cout << "unable to sync! " << std::endl;
|
|
throw TException("unable to sync!");
|
|
}
|
|
|
|
m_devImp->m_isPlaying = false;
|
|
m_devImp->m_stopped = true;
|
|
m_devImp->m_looped = false;
|
|
|
|
// std::cout << "miss = " << miss << std::endl;
|
|
}
|
|
} catch (TThread::Interrupt &e) {
|
|
std::cout << "Play interrupted " << e.getMessage() << std::endl;
|
|
m_devImp->m_isPlaying = false;
|
|
m_devImp->m_stopped = true;
|
|
m_devImp->m_looped = false;
|
|
} catch (TException &e) {
|
|
std::cout << "esco dal play " << e.getMessage() << std::endl;
|
|
m_devImp->m_isPlaying = false;
|
|
m_devImp->m_stopped = true;
|
|
m_devImp->m_looped = false;
|
|
}
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
|
|
void TPlayTask::run2() {
|
|
int bytesLeft = m_sndtrack->getSampleCount() * m_sndtrack->getSampleSize();
|
|
char *buf = (char *)m_sndtrack->getRawData();
|
|
int done = 0;
|
|
int written = 0;
|
|
TINT32 sampleSize = (TINT32)m_sndtrack->getSampleSize();
|
|
const double msToBytes = sampleSize * m_sndtrack->getSampleRate() / 1000.;
|
|
|
|
TThread::milestone();
|
|
double startupDelay = m_stopWatch->getTotalTime();
|
|
// std::cout << "ritardo iniziale " << startupDelay << std::endl;
|
|
int miss = 0;
|
|
m_stopWatch->start(); // e' meglio ignorare il ritardo iniziale
|
|
if (done > 0) {
|
|
m_stopWatch->addDelay(((done / sampleSize) * 1000) /
|
|
double(m_sndtrack->getSampleRate()));
|
|
}
|
|
int auxbuffersize = 0;
|
|
int preWrittenBytes = 0;
|
|
TSoundTrackP src = TSoundTrack::create(m_sndtrack->getFormat(), 1);
|
|
TSoundTrackP dst = src;
|
|
try {
|
|
do // gia' tracce accodate
|
|
{
|
|
bool changeSnd = false;
|
|
do // c'e' il flag loop settato
|
|
{
|
|
while ((bytesLeft > 0)) {
|
|
changeSnd = false;
|
|
TThread::milestone();
|
|
audio_buf_info info;
|
|
TINT32 bytesToWrite;
|
|
double samplesDone = done / (double)sampleSize;
|
|
double trackTime =
|
|
(samplesDone * 1000.) / m_sndtrack->getSampleRate();
|
|
double curTime = m_stopWatch->getTotalTime();
|
|
double delta = curTime - trackTime;
|
|
|
|
/*
|
|
delta
|
|
== 0 sync
|
|
< 0 audio piu' veloce del tempo
|
|
di playback --> simuliamo un ritardo con un continue;
|
|
> 0 audio piu' lento del playback ->
|
|
skip una porzione di audio
|
|
*/
|
|
|
|
const double minDelay = -10;
|
|
const double maxDelay = 0;
|
|
// if (delta>maxDelay)
|
|
// std::cout << "buffer underrun:" << delta << std::endl;
|
|
// std::cout << "buffer " <<
|
|
// (delta<minDelay?"overrun":delta>maxDelay?"underrun":"sync") << " "
|
|
// << delta<< std::endl;
|
|
|
|
if (delta < minDelay) // overrun
|
|
{
|
|
// std::cout << "out of sync -> audio troppo veloce" << std::endl;
|
|
continue;
|
|
}
|
|
|
|
if (ioctl(m_devImp->m_dev, SNDCTL_DSP_GETOSPACE, &info) == -1) {
|
|
miss++;
|
|
break;
|
|
}
|
|
|
|
int fragmentsFree_bytes = info.fragsize * info.fragments;
|
|
if (fragmentsFree_bytes == 0) {
|
|
// std::cout << "no bytes left on device" << std::endl;
|
|
continue;
|
|
}
|
|
|
|
int bytesToSkip = 0;
|
|
int bigSkip = 0;
|
|
if (delta > maxDelay) // underrun
|
|
{
|
|
// std::cout << "out of sync -> audio troppo lento"<<std::endl;
|
|
// skip di una porzione... delta in ms
|
|
bytesToSkip =
|
|
tceil(delta * msToBytes); // numero di bytes da skippare
|
|
// lo arrotondo al sample size
|
|
bytesToSkip += sampleSize - (bytesToSkip % sampleSize);
|
|
// std::cout << "bytes skippati "<< bytesToSkip << std::endl;
|
|
bigSkip = bytesToSkip;
|
|
} else { // sto fra minDelay e maxDelay
|
|
bytesToSkip = 0;
|
|
}
|
|
|
|
bytesToSkip = tmin(bytesLeft, bytesToSkip);
|
|
bigSkip -= bytesToSkip;
|
|
bytesLeft -= bytesToSkip;
|
|
done += bytesToSkip;
|
|
|
|
bytesToWrite = tmin(bytesLeft, fragmentsFree_bytes);
|
|
|
|
if (bytesToWrite % info.fragsize !=
|
|
0) { // cerco di gestire il write di un frammento non intero
|
|
auxbuffersize =
|
|
((bytesToWrite / info.fragsize) + 1) * info.fragsize;
|
|
}
|
|
|
|
if (bigSkip)
|
|
while (!m_devImp->m_waitingTracks.empty()) {
|
|
TSoundTrackP st = m_devImp->m_waitingTracks[0].first;
|
|
int count = st->getSampleCount() * sampleSize;
|
|
if (bigSkip >= count) {
|
|
m_devImp->m_waitingTracks.erase(
|
|
m_devImp->m_waitingTracks.begin());
|
|
bigSkip -= count;
|
|
} else
|
|
break;
|
|
}
|
|
|
|
preWrittenBytes = 0;
|
|
if (auxbuffersize == 0) {
|
|
if (bytesToSkip != 0) {
|
|
// costruisco traccia su cui fare il crossfade
|
|
// utilizzo il contenuto della traccia di crossfade
|
|
dst = m_sndtrack->extract(done / sampleSize,
|
|
(done + bytesToWrite) / sampleSize);
|
|
TSoundTrackP st = TSop::crossFade(0.2, src, dst);
|
|
char *buffer = (char *)st->getRawData();
|
|
written = write(m_devImp->m_dev, buffer, bytesToWrite);
|
|
} else
|
|
written = write(m_devImp->m_dev, buf + done, bytesToWrite);
|
|
src = m_sndtrack->extract((done + bytesToWrite) / sampleSize,
|
|
(done + bytesToWrite) / sampleSize);
|
|
} else { // auxbuffersize != 0 sse il numero di bytes residui nella
|
|
// traccia e' inferiore alla dimensione del frammento
|
|
char *auxbuf = new char[auxbuffersize];
|
|
TSoundTrackP newSrc;
|
|
dst = TSoundTrack::create(m_sndtrack->getFormat(),
|
|
auxbuffersize / sampleSize);
|
|
memcpy(auxbuf, buf + done, bytesToWrite);
|
|
dst->copy(m_sndtrack->extract(done / sampleSize,
|
|
(done + bytesToWrite) / sampleSize),
|
|
0);
|
|
preWrittenBytes = auxbuffersize - bytesToWrite;
|
|
if (m_devImp->m_looped) {
|
|
memcpy(auxbuf + bytesToWrite, buf, preWrittenBytes);
|
|
dst->copy(m_sndtrack->extract(0, preWrittenBytes / sampleSize),
|
|
bytesToWrite / sampleSize);
|
|
newSrc = m_sndtrack->extract(preWrittenBytes / sampleSize,
|
|
preWrittenBytes / sampleSize);
|
|
} else {
|
|
newSrc = TSoundTrack::create(m_sndtrack->getFormat(), 1);
|
|
static int added = 0;
|
|
// se non c'e' alcuna altra traccia o e di diverso format
|
|
// riempo il frammento con del silenzio
|
|
if (m_devImp->m_waitingTracks.empty() ||
|
|
(m_sndtrack->getFormat() !=
|
|
m_devImp->m_waitingTracks[0].first->getFormat())) {
|
|
int val = m_sndtrack->isSampleSigned() ? 0 : 127;
|
|
memset(auxbuf + bytesToWrite, val,
|
|
preWrittenBytes); // ci metto silenzio
|
|
} else
|
|
while (true) // ci sono altre tracce accodate
|
|
{
|
|
TSoundTrackP st = m_devImp->m_waitingTracks[0].first;
|
|
int sampleBytes = st->getSampleCount() * st->getSampleSize();
|
|
if (sampleBytes >= preWrittenBytes - added) {
|
|
// La traccia ha abbastanza campioni per riempire il
|
|
// frammento
|
|
// quindi la sostituisco alla corrente del runnable e
|
|
// continuo
|
|
buf = (char *)st->getRawData();
|
|
memcpy(auxbuf + bytesToWrite, buf, preWrittenBytes - added);
|
|
m_sndtrack = st;
|
|
m_devImp->m_looped = m_devImp->m_waitingTracks[0].second;
|
|
m_devImp->m_waitingTracks.erase(
|
|
m_devImp->m_waitingTracks.begin());
|
|
changeSnd = true;
|
|
dst->copy(m_sndtrack->extract(
|
|
0, (preWrittenBytes - added) / sampleSize),
|
|
bytesToWrite / sampleSize + added);
|
|
newSrc = m_sndtrack->extract(
|
|
(preWrittenBytes - added) / sampleSize,
|
|
(preWrittenBytes - added) / sampleSize);
|
|
break;
|
|
} else { // occhio al loop
|
|
// La traccia successiva e' piu corta del frammento da
|
|
// riempire quindi
|
|
// ce la metto tutta e se non ha il flag di loop settato
|
|
// cerco di aggiungere
|
|
// i byte della successiva
|
|
memcpy(auxbuf + bytesToWrite, st->getRawData(),
|
|
sampleBytes);
|
|
dst->copy(st->extract(0, st->getSampleCount() - 1),
|
|
bytesToWrite / sampleSize);
|
|
added += st->getSampleCount();
|
|
if (m_devImp->m_waitingTracks[0]
|
|
.second) // e' quella che deve essere in loop
|
|
{
|
|
buf = (char *)st->getRawData();
|
|
m_sndtrack = st;
|
|
m_devImp->m_looped = m_devImp->m_waitingTracks[0].second;
|
|
preWrittenBytes = 0;
|
|
bytesLeft = 0;
|
|
m_devImp->m_waitingTracks.erase(
|
|
m_devImp->m_waitingTracks.begin());
|
|
changeSnd = true;
|
|
break;
|
|
}
|
|
|
|
// la elimino e vedo se esiste la successiva altrimenti
|
|
// metto campioni "zero"
|
|
m_devImp->m_waitingTracks.erase(
|
|
m_devImp->m_waitingTracks.begin());
|
|
if (!m_devImp->m_waitingTracks.empty()) {
|
|
st = m_devImp->m_waitingTracks[0].first;
|
|
std::cout
|
|
<< " Traccia con meno campioni cerco la successiva"
|
|
<< std::endl;
|
|
} else {
|
|
int val = m_sndtrack->isSampleSigned() ? 0 : 127;
|
|
memset(
|
|
auxbuf + bytesToWrite, val,
|
|
preWrittenBytes - sampleBytes); // ci metto silenzio
|
|
std::cout << "OPS ..... silence" << std::endl;
|
|
break;
|
|
}
|
|
}
|
|
} // end while(true)
|
|
}
|
|
// qui andrebbe fatto un cross-fade se c'erano da skippare campioni
|
|
// => bytesToSkip != 0
|
|
if (bytesToSkip != 0) {
|
|
TSoundTrackP st = TSop::crossFade(0.2, src, dst);
|
|
char *buffer = (char *)st->getRawData();
|
|
written = write(m_devImp->m_dev, buffer, bytesToWrite);
|
|
} else
|
|
written = write(m_devImp->m_dev, auxbuf, auxbuffersize);
|
|
src = newSrc;
|
|
auxbuffersize = 0;
|
|
delete[] auxbuf;
|
|
}
|
|
if (written == -1) break;
|
|
if (written != bytesToWrite + preWrittenBytes) break;
|
|
bytesLeft -= written;
|
|
done += written;
|
|
} // chiudo il while((bytesLeft > 0))
|
|
done = preWrittenBytes;
|
|
written = 0;
|
|
bytesLeft =
|
|
m_sndtrack->getSampleCount() * m_sndtrack->getSampleSize() - done;
|
|
m_stopWatch->start();
|
|
if (done > 0) {
|
|
m_stopWatch->addDelay(((done / m_sndtrack->getSampleSize()) * 1000) /
|
|
double(m_sndtrack->getSampleRate()));
|
|
}
|
|
} while (m_devImp->m_looped || changeSnd);
|
|
|
|
if (m_devImp->m_waitingTracks.empty()) {
|
|
// std::cout<<"OPS ..... non accodato"<<std::endl;
|
|
break;
|
|
}
|
|
|
|
// std::cout<<"OPS ..... accodato"<<std::endl;
|
|
m_sndtrack = m_devImp->m_waitingTracks[0].first;
|
|
m_devImp->m_looped = m_devImp->m_waitingTracks[0].second;
|
|
m_devImp->m_waitingTracks.erase(m_devImp->m_waitingTracks.begin());
|
|
bytesLeft = m_sndtrack->getSampleCount() * m_sndtrack->getSampleSize();
|
|
buf = (char *)m_sndtrack->getRawData();
|
|
done = 0;
|
|
written = 0;
|
|
|
|
m_stopWatch->start(); // ignoro il ritardo iniziale
|
|
if (done > 0) {
|
|
m_stopWatch->addDelay(((done / m_sndtrack->getSampleSize()) * 1000) /
|
|
double(m_sndtrack->getSampleRate()));
|
|
}
|
|
} while (true); // ci sono gia' tracce accodate
|
|
|
|
if (!m_devImp->m_waitingTracks.empty()) {
|
|
m_devImp->m_looped = m_devImp->m_waitingTracks[0].second;
|
|
m_devImp->m_executor.addTask(
|
|
new TPlayTask(m_devImp, m_devImp->m_waitingTracks[0].first));
|
|
m_devImp->m_waitingTracks.erase(m_devImp->m_waitingTracks.begin());
|
|
// std::cout<<"OPS ..... erase 4"<<std::endl;
|
|
} else if (m_devImp->m_dev != -1) {
|
|
if (ioctl(m_devImp->m_dev, SNDCTL_DSP_SYNC) == -1) {
|
|
std::cout << "unable to sync! " << std::endl;
|
|
throw TException("unable to sync!");
|
|
}
|
|
|
|
m_devImp->m_isPlaying = false;
|
|
m_devImp->m_stopped = true;
|
|
m_devImp->m_looped = false;
|
|
|
|
// std::cout << "miss = " << miss << std::endl;
|
|
}
|
|
} catch (TThread::Interrupt &e) {
|
|
std::cout << "Play interrupted " << e.getMessage() << std::endl;
|
|
m_devImp->m_isPlaying = false;
|
|
m_devImp->m_stopped = true;
|
|
m_devImp->m_looped = false;
|
|
} catch (TException &e) {
|
|
std::cout << "esco dal play " << e.getMessage() << std::endl;
|
|
m_devImp->m_isPlaying = false;
|
|
m_devImp->m_stopped = true;
|
|
m_devImp->m_looped = false;
|
|
}
|
|
}
|
|
|
|
//==============================================================================
|
|
|
|
TSoundOutputDevice::TSoundOutputDevice() : m_imp(new TSoundOutputDeviceImp) {
|
|
if (m_imp->doOpenDevice()) {
|
|
m_imp->insertAllRate();
|
|
try {
|
|
if (!m_imp->verifyRate())
|
|
throw TSoundDeviceException(TSoundDeviceException::UnablePrepare,
|
|
"No default samplerate are supported");
|
|
} catch (TSoundDeviceException &e) {
|
|
throw TSoundDeviceException(e.getType(), e.getMessage());
|
|
}
|
|
m_imp->doCloseDevice();
|
|
}
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
TSoundOutputDevice::~TSoundOutputDevice() { close(); }
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
bool TSoundOutputDevice::installed() {
|
|
bool ret = false;
|
|
int dev = ::open("/dev/dsp", O_WRONLY, 0);
|
|
if (dev >= 0) {
|
|
ret = true;
|
|
::close(dev);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
bool TSoundOutputDevice::open(const TSoundTrackP &st) {
|
|
m_imp->m_currentFormat = st->getFormat();
|
|
try {
|
|
m_imp->doOpenDevice();
|
|
} catch (TSoundDeviceException &e) {
|
|
throw TSoundDeviceException(e.getType(), e.getMessage());
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
bool TSoundOutputDevice::close() {
|
|
stop();
|
|
if (m_imp->m_dev != -1) {
|
|
bool closed = m_imp->doCloseDevice();
|
|
if (!closed)
|
|
throw TSoundDeviceException(
|
|
TSoundDeviceException::UnableCloseDevice,
|
|
"Error during the closing of the output device");
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
void TSoundOutputDevice::attach(TSoundOutputDeviceListener *listener) {
|
|
m_imp->m_listeners.insert(listener);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
void TSoundOutputDevice::detach(TSoundOutputDeviceListener *listener) {
|
|
m_imp->m_listeners.erase(listener);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
void TSoundOutputDevice::play(const TSoundTrackP &st, TINT32 s0, TINT32 s1,
|
|
bool loop, bool scrubbing) {
|
|
assert((scrubbing && !loop) || !scrubbing);
|
|
if (!st->getSampleCount()) return;
|
|
|
|
TThread::ScopedLock sl(m_imp->m_mutex);
|
|
if (m_imp->m_looped)
|
|
throw TSoundDeviceException(
|
|
TSoundDeviceException::Busy,
|
|
"Unable to queue another playback when the sound player is looping");
|
|
|
|
TSoundTrackFormat format = st->getFormat();
|
|
if (!m_imp->isSupportFormat(format)) {
|
|
throw TSoundDeviceException(TSoundDeviceException::UnsupportedFormat,
|
|
"Unsupported format for playback");
|
|
}
|
|
|
|
if (m_imp->m_isPlaying) {
|
|
assert(s1 >= s0);
|
|
TSoundTrackP subTrack = st->extract(s0, s1);
|
|
m_imp->m_waitingTracks.push_back(std::make_pair(subTrack, loop));
|
|
// std::cout<<"Sono in pushback"<<std::endl;
|
|
return;
|
|
}
|
|
|
|
if ((m_imp->m_dev == -1)) try {
|
|
if (m_imp->doOpenDevice()) m_imp->setFormat(format);
|
|
} catch (TSoundDeviceException &e) {
|
|
m_imp->doCloseDevice();
|
|
throw TSoundDeviceException(e.getType(), e.getMessage());
|
|
}
|
|
|
|
m_imp->m_isPlaying = true;
|
|
m_imp->m_stopped = false;
|
|
m_imp->m_looped = loop;
|
|
// m_imp->m_currentFormat = st->getFormat();
|
|
|
|
assert(s1 >= s0);
|
|
TSoundTrackP subTrack = st->extract(s0, s1);
|
|
|
|
m_imp->m_executor.addTask(new TPlayTask(m_imp, subTrack));
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
|
|
void TSoundOutputDevice::stop() {
|
|
TThread::ScopedLock sl(m_imp->m_mutex);
|
|
if (!m_imp->m_isPlaying) return;
|
|
m_imp->m_executor.cancel();
|
|
ioctl(m_imp->m_dev, SNDCTL_DSP_POST, 0);
|
|
m_imp->m_isPlaying = false;
|
|
m_imp->m_stopped = true;
|
|
m_imp->m_looped = false;
|
|
m_imp->m_waitingTracks.clear();
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
double TSoundOutputDevice::getVolume() {
|
|
int mixer;
|
|
if ((mixer = openMixer()) < 0)
|
|
throw TSoundDeviceException(TSoundDeviceException::NoMixer,
|
|
"Can't open the mixer device");
|
|
|
|
int devmask;
|
|
if (ioctl(mixer, SOUND_MIXER_READ_DEVMASK, &devmask) == -1) {
|
|
::close(mixer);
|
|
throw TSoundDeviceException(TSoundDeviceException::NoMixer,
|
|
"Error in ioctl with mixer device");
|
|
}
|
|
|
|
int recmask;
|
|
if (ioctl(mixer, SOUND_MIXER_READ_RECMASK, &recmask) == -1) {
|
|
::close(mixer);
|
|
throw TSoundDeviceException(TSoundDeviceException::NoMixer,
|
|
"Error in ioctl with mixer device");
|
|
}
|
|
|
|
int stereo;
|
|
if (ioctl(mixer, SOUND_MIXER_READ_STEREODEVS, &stereo) == -1) {
|
|
::close(mixer);
|
|
throw TSoundDeviceException(TSoundDeviceException::NoMixer,
|
|
"Error in ioctl with mixer device");
|
|
}
|
|
|
|
int outmask = devmask | ~recmask;
|
|
|
|
int index;
|
|
if (outmask & (1 << SOUND_MIXER_ALTPCM))
|
|
index = SOUND_MIXER_ALTPCM;
|
|
else if (outmask & (1 << SOUND_MIXER_PCM))
|
|
index = SOUND_MIXER_PCM;
|
|
|
|
int level;
|
|
if (ioctl(mixer, MIXER_READ(index), &level) == -1) {
|
|
::close(mixer);
|
|
throw TSoundDeviceException(TSoundDeviceException::UnableVolume,
|
|
"Error to read the volume");
|
|
}
|
|
if ((1 << index) & stereo) {
|
|
int left = level & 0xff;
|
|
int right = ((level & 0xff00) >> 8);
|
|
::close(mixer);
|
|
return (left + right) / 20.0;
|
|
} else {
|
|
::close(mixer);
|
|
return (level & 0xff) / 10.0;
|
|
}
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
bool TSoundOutputDevice::setVolume(double volume) {
|
|
int mixer;
|
|
if ((mixer = openMixer()) < 0)
|
|
throw TSoundDeviceException(TSoundDeviceException::NoMixer,
|
|
"Can't open the mixer device");
|
|
|
|
int devmask;
|
|
if (ioctl(mixer, SOUND_MIXER_READ_DEVMASK, &devmask) == -1) {
|
|
::close(mixer);
|
|
throw TSoundDeviceException(TSoundDeviceException::NoMixer,
|
|
"Error in ioctl with mixer device");
|
|
}
|
|
|
|
int recmask;
|
|
if (ioctl(mixer, SOUND_MIXER_READ_DEVMASK, &recmask) == -1) {
|
|
::close(mixer);
|
|
throw TSoundDeviceException(TSoundDeviceException::NoMixer,
|
|
"Error in ioctl with mixer device");
|
|
}
|
|
|
|
int stereo;
|
|
if (ioctl(mixer, SOUND_MIXER_READ_STEREODEVS, &stereo) == -1) {
|
|
::close(mixer);
|
|
throw TSoundDeviceException(TSoundDeviceException::NoMixer,
|
|
"Error in ioctl with mixer device");
|
|
}
|
|
|
|
int outmask = devmask | ~recmask;
|
|
|
|
if (outmask & (1 << SOUND_MIXER_ALTPCM)) {
|
|
int vol, index = SOUND_MIXER_ALTPCM;
|
|
if ((1 << index) & stereo) {
|
|
volume *= 10.0;
|
|
vol = (int)volume + ((int)(volume * 256.0));
|
|
} else
|
|
vol = (int)(volume * 10.0);
|
|
|
|
if (!writeVolume(vol, mixer, index)) {
|
|
::close(mixer);
|
|
throw TSoundDeviceException(TSoundDeviceException::UnableVolume,
|
|
"Can't write the volume");
|
|
}
|
|
|
|
// metto anche l'altro ad un livello di sensibilita' adeguata
|
|
if (outmask & (1 << SOUND_MIXER_PCM)) {
|
|
int vol, index = SOUND_MIXER_PCM;
|
|
double volDefault = 6.7;
|
|
if ((1 << index) & stereo) {
|
|
volDefault *= 10.0;
|
|
vol = (int)volDefault + ((int)(volDefault * 256.0));
|
|
} else
|
|
vol = (int)(volDefault * 10.0);
|
|
|
|
if (!writeVolume(vol, mixer, index)) {
|
|
::close(mixer);
|
|
throw TSoundDeviceException(TSoundDeviceException::UnableVolume,
|
|
"Can't write the volume");
|
|
}
|
|
}
|
|
} else if (outmask & (1 << SOUND_MIXER_PCM)) {
|
|
int vol, index = SOUND_MIXER_PCM;
|
|
if ((1 << index) & stereo) {
|
|
volume *= 10.0;
|
|
vol = (int)volume + ((int)(volume * 256.0));
|
|
} else
|
|
vol = (int)(volume * 10.0);
|
|
|
|
if (!writeVolume(vol, mixer, index)) {
|
|
::close(mixer);
|
|
throw TSoundDeviceException(TSoundDeviceException::NoMixer,
|
|
"Can't write the volume");
|
|
}
|
|
}
|
|
|
|
::close(mixer);
|
|
return true;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
bool TSoundOutputDevice::isPlaying() const {
|
|
TThread::ScopedLock sl(m_imp->m_mutex);
|
|
return m_imp->m_isPlaying;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
bool TSoundOutputDevice::isLooping() {
|
|
TThread::ScopedLock sl(m_imp->m_mutex);
|
|
return m_imp->m_looped;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
void TSoundOutputDevice::setLooping(bool loop) {
|
|
TThread::ScopedLock sl(m_imp->m_mutex);
|
|
m_imp->m_looped = loop;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
bool TSoundOutputDevice::supportsVolume() {
|
|
int mixer;
|
|
if ((mixer = openMixer()) < 0)
|
|
throw TSoundDeviceException(TSoundDeviceException::NoMixer,
|
|
"Can't open the mixer device");
|
|
|
|
int devmask;
|
|
if (ioctl(mixer, SOUND_MIXER_READ_DEVMASK, &devmask) == -1) {
|
|
::close(mixer);
|
|
throw TSoundDeviceException(TSoundDeviceException::NoMixer,
|
|
"Error in ioctl with mixer device");
|
|
}
|
|
|
|
int recmask;
|
|
if (ioctl(mixer, SOUND_MIXER_READ_DEVMASK, &recmask) == -1) {
|
|
::close(mixer);
|
|
throw TSoundDeviceException(TSoundDeviceException::NoMixer,
|
|
"Error in ioctl with mixer device");
|
|
}
|
|
|
|
int stereo;
|
|
if (ioctl(mixer, SOUND_MIXER_READ_STEREODEVS, &stereo) == -1) {
|
|
::close(mixer);
|
|
throw TSoundDeviceException(TSoundDeviceException::NoMixer,
|
|
"Error in ioctl with mixer device");
|
|
}
|
|
|
|
int outmask = devmask | ~recmask;
|
|
|
|
if ((outmask & (1 << SOUND_MIXER_ALTPCM)) ||
|
|
(outmask & (1 << SOUND_MIXER_PCM))) {
|
|
::close(mixer);
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
TSoundTrackFormat TSoundOutputDevice::getPreferredFormat(TUINT32 sampleRate,
|
|
int channelCount,
|
|
int bitPerSample) {
|
|
TSoundTrackFormat fmt;
|
|
if (bitPerSample == 8)
|
|
fmt = TSoundTrackFormat(sampleRate, channelCount, bitPerSample, false);
|
|
else
|
|
fmt = TSoundTrackFormat(sampleRate, channelCount, bitPerSample);
|
|
if (m_imp->isSupportFormat(fmt)) return fmt;
|
|
|
|
int bps, ch, status;
|
|
|
|
bps = bitPerSample;
|
|
ch = channelCount;
|
|
|
|
if (m_imp->m_dev == -1) m_imp->doOpenDevice();
|
|
|
|
if (bitPerSample <= 8) {
|
|
bitPerSample = AFMT_U8;
|
|
fmt.m_signedSample = false;
|
|
} else if ((bitPerSample > 8 && bitPerSample < 16) || bitPerSample >= 16) {
|
|
bitPerSample = AFMT_S16_NE;
|
|
fmt.m_signedSample = true;
|
|
}
|
|
|
|
status = ioctl(m_imp->m_dev, SNDCTL_DSP_SETFMT, &bitPerSample);
|
|
if (status == -1) {
|
|
perror("CHE palle ");
|
|
throw TSoundDeviceException(TSoundDeviceException::UnablePrepare,
|
|
"Failed setting the specified number of bits");
|
|
}
|
|
fmt.m_bitPerSample = bitPerSample;
|
|
|
|
status = ioctl(m_imp->m_dev, SNDCTL_DSP_CHANNELS, &channelCount);
|
|
if (status == -1)
|
|
throw TSoundDeviceException(
|
|
TSoundDeviceException::UnablePrepare,
|
|
"Failed setting the specified number of channel");
|
|
fmt.m_channelCount = channelCount;
|
|
|
|
if (m_imp->m_supportedRate.find((int)sampleRate) ==
|
|
m_imp->m_supportedRate.end()) {
|
|
std::set<int>::iterator it =
|
|
m_imp->m_supportedRate.lower_bound((int)sampleRate);
|
|
if (it == m_imp->m_supportedRate.end()) {
|
|
it = std::max_element(m_imp->m_supportedRate.begin(),
|
|
m_imp->m_supportedRate.end());
|
|
if (it != m_imp->m_supportedRate.end())
|
|
sampleRate = *(m_imp->m_supportedRate.rbegin());
|
|
else
|
|
throw TSoundDeviceException(TSoundDeviceException::UnsupportedFormat,
|
|
"There isn't a supported rate");
|
|
} else
|
|
sampleRate = *it;
|
|
}
|
|
|
|
if (ioctl(m_imp->m_dev, SNDCTL_DSP_SPEED, &sampleRate) == -1)
|
|
throw TSoundDeviceException(TSoundDeviceException::UnablePrepare,
|
|
"Failed setting the specified sample rate");
|
|
fmt.m_sampleRate = sampleRate;
|
|
|
|
if (ch != channelCount || bps != bitPerSample) {
|
|
m_imp->doCloseDevice();
|
|
}
|
|
|
|
return fmt;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
TSoundTrackFormat TSoundOutputDevice::getPreferredFormat(
|
|
const TSoundTrackFormat &format) {
|
|
try {
|
|
return getPreferredFormat(format.m_sampleRate, format.m_channelCount,
|
|
format.m_bitPerSample);
|
|
} catch (TSoundDeviceException &e) {
|
|
throw TSoundDeviceException(e.getType(), e.getMessage());
|
|
}
|
|
}
|
|
|
|
//======================================================================
|
|
//======================================================================
|
|
// CLASSI PER IL RECORD
|
|
//======================================================================
|
|
//======================================================================
|
|
|
|
class TSoundInputDeviceImp {
|
|
public:
|
|
int m_dev;
|
|
bool m_stopped;
|
|
bool m_isRecording;
|
|
TSoundTrackFormat m_currentFormat;
|
|
TSoundTrackP m_st;
|
|
std::set<int> m_supportedRate;
|
|
|
|
TINT32 m_recordedSampleCount;
|
|
vector<char *> m_recordedBlocks;
|
|
vector<int> m_samplePerBlocks;
|
|
bool m_oneShotRecording;
|
|
|
|
TThread::Executor m_executor;
|
|
|
|
TSoundInputDeviceImp()
|
|
: m_dev(-1)
|
|
, m_stopped(false)
|
|
, m_isRecording(false)
|
|
, m_st(0)
|
|
, m_supportedRate()
|
|
, m_recordedBlocks()
|
|
, m_samplePerBlocks()
|
|
, m_oneShotRecording(false) {}
|
|
|
|
~TSoundInputDeviceImp() {}
|
|
|
|
bool doOpenDevice(const TSoundTrackFormat &format,
|
|
TSoundInputDevice::Source devType);
|
|
bool doCloseDevice();
|
|
void insertAllRate();
|
|
bool verifyRate();
|
|
};
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
bool TSoundInputDeviceImp::doOpenDevice(const TSoundTrackFormat &format,
|
|
TSoundInputDevice::Source devType) {
|
|
m_dev = open("/dev/dsp", O_RDONLY);
|
|
if (m_dev < 0)
|
|
throw TSoundDeviceException(TSoundDeviceException::UnableOpenDevice,
|
|
"Cannot open the dsp device");
|
|
|
|
// ioctl(m_dev, SNDCTL_DSP_RESET,0);
|
|
|
|
return true;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
bool TSoundInputDeviceImp::doCloseDevice() {
|
|
if (close(m_dev) < 0)
|
|
throw TSoundDeviceException(TSoundDeviceException::UnableCloseDevice,
|
|
"Cannot close the dsp device");
|
|
m_dev = -1;
|
|
return true;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
|
|
void TSoundInputDeviceImp::insertAllRate() {
|
|
m_supportedRate.insert(8000);
|
|
m_supportedRate.insert(11025);
|
|
m_supportedRate.insert(16000);
|
|
m_supportedRate.insert(22050);
|
|
m_supportedRate.insert(32000);
|
|
m_supportedRate.insert(44100);
|
|
m_supportedRate.insert(48000);
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
|
|
bool TSoundInputDeviceImp::verifyRate() {
|
|
std::set<int>::iterator it;
|
|
|
|
for (it = m_supportedRate.begin(); it != m_supportedRate.end(); ++it) {
|
|
int sampleRate = *it;
|
|
if (ioctl(m_dev, SNDCTL_DSP_SPEED, &sampleRate) == -1)
|
|
throw TSoundDeviceException(TSoundDeviceException::UnablePrepare,
|
|
"Failed setting the specified sample rate");
|
|
if (sampleRate != *it) m_supportedRate.erase(*it);
|
|
}
|
|
if (m_supportedRate.end() == m_supportedRate.begin()) return false;
|
|
|
|
return true;
|
|
}
|
|
//==============================================================================
|
|
|
|
class TRecordTask : public TThread::Runnable {
|
|
public:
|
|
TSoundInputDeviceImp *m_devImp;
|
|
|
|
TRecordTask(TSoundInputDeviceImp *devImp) : Runnable(), m_devImp(devImp){};
|
|
|
|
~TRecordTask(){};
|
|
|
|
void run();
|
|
};
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
void TRecordTask::run() {
|
|
// N.B. e' bene che la dimensione sia piccola cosi' l'attesa perche' termini
|
|
// e' minore in questo caso vogliamo 16 frammenti ognuno di 4096 byte
|
|
int fraginfo = (16 << 16) | 12;
|
|
if (ioctl(m_devImp->m_dev, SNDCTL_DSP_SETFRAGMENT, &fraginfo) == -1)
|
|
perror("SETFRAGMENT");
|
|
|
|
int fragsize = 0;
|
|
if (ioctl(m_devImp->m_dev, SNDCTL_DSP_GETBLKSIZE, &fragsize) == -1)
|
|
perror("GETFRAGMENT");
|
|
TINT32 byteRecordedSample = 0;
|
|
|
|
if (m_devImp->m_oneShotRecording) {
|
|
TINT32 byteToSample =
|
|
m_devImp->m_st->getSampleSize() * m_devImp->m_st->getSampleCount();
|
|
char *buf = (char *)m_devImp->m_st->getRawData();
|
|
|
|
while ((byteRecordedSample < byteToSample) && m_devImp->m_isRecording) {
|
|
int sample;
|
|
if (fragsize > (byteToSample - byteRecordedSample))
|
|
sample = byteToSample - byteRecordedSample;
|
|
else
|
|
sample = fragsize;
|
|
int nread = read(m_devImp->m_dev, buf + byteRecordedSample, sample);
|
|
if (nread == -1) break;
|
|
if (nread != sample) break;
|
|
|
|
byteRecordedSample += nread;
|
|
}
|
|
} else {
|
|
int bytePerSample = m_devImp->m_currentFormat.m_bitPerSample >> 3;
|
|
switch (bytePerSample) {
|
|
case 3:
|
|
bytePerSample++;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
bytePerSample *= m_devImp->m_currentFormat.m_channelCount;
|
|
|
|
while (m_devImp->m_isRecording) {
|
|
char *dataBuffer = new char[fragsize];
|
|
m_devImp->m_recordedBlocks.push_back(dataBuffer);
|
|
m_devImp->m_samplePerBlocks.push_back(fragsize);
|
|
|
|
int nread = read(m_devImp->m_dev, dataBuffer, fragsize);
|
|
if (nread == -1) break;
|
|
if (nread != fragsize) break;
|
|
|
|
m_devImp->m_recordedSampleCount += (fragsize / bytePerSample);
|
|
}
|
|
}
|
|
ioctl(m_devImp->m_dev, SNDCTL_DSP_RESET, 0);
|
|
}
|
|
|
|
//==============================================================================
|
|
|
|
TSoundInputDevice::TSoundInputDevice() : m_imp(new TSoundInputDeviceImp) {
|
|
m_imp->m_dev = open("/dev/dsp", O_RDONLY);
|
|
if (m_imp->m_dev < 0)
|
|
throw TSoundDeviceException(TSoundDeviceException::UnableOpenDevice,
|
|
"Cannot open the dsp device");
|
|
|
|
m_imp->insertAllRate();
|
|
try {
|
|
if (!m_imp->verifyRate())
|
|
throw TSoundDeviceException(TSoundDeviceException::UnablePrepare,
|
|
"No default samplerate are supported");
|
|
} catch (TSoundDeviceException &e) {
|
|
throw TSoundDeviceException(e.getType(), e.getMessage());
|
|
}
|
|
m_imp->doCloseDevice();
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
TSoundInputDevice::~TSoundInputDevice() {
|
|
if (m_imp->m_dev != -1) m_imp->doCloseDevice();
|
|
delete m_imp;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
bool TSoundInputDevice::installed() {
|
|
bool ret = false;
|
|
int dev = ::open("/dev/dsp", O_RDONLY);
|
|
if (dev >= 0) {
|
|
ret = true;
|
|
::close(dev);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
void TSoundInputDevice::record(const TSoundTrackFormat &format,
|
|
TSoundInputDevice::Source type) {
|
|
m_imp->m_recordedBlocks.clear();
|
|
m_imp->m_samplePerBlocks.clear();
|
|
|
|
// registra creando una nuova traccia
|
|
m_imp->m_oneShotRecording = false;
|
|
try {
|
|
if (m_imp->m_dev == -1) m_imp->doOpenDevice(format, type);
|
|
|
|
if (!selectInputDevice(type))
|
|
throw TSoundDeviceException(
|
|
TSoundDeviceException::UnableSetDevice,
|
|
"Input device is not supported for recording");
|
|
|
|
TSoundTrackFormat fmt = getPreferredFormat(format);
|
|
if (fmt != format)
|
|
throw TSoundDeviceException(TSoundDeviceException::UnsupportedFormat,
|
|
"Unsupported format");
|
|
} catch (TSoundDeviceException &e) {
|
|
throw TSoundDeviceException(e.getType(), e.getMessage());
|
|
}
|
|
|
|
try {
|
|
if (getVolume() == 0.0) {
|
|
double volume = 5.0;
|
|
setVolume(volume);
|
|
}
|
|
} catch (TSoundDeviceException &e) {
|
|
throw TSoundDeviceException(e.getType(), e.getMessage());
|
|
}
|
|
|
|
m_imp->m_currentFormat = format;
|
|
m_imp->m_isRecording = true;
|
|
m_imp->m_stopped = false;
|
|
m_imp->m_recordedSampleCount = 0;
|
|
|
|
// far partire il thread
|
|
/*TRecordThread *recordThread = new TRecordThread(m_imp);
|
|
if (!recordThread)
|
|
throw TSoundDeviceException(
|
|
TSoundDeviceException::UnablePrepare,
|
|
"Problemi per creare il thread");
|
|
recordThread->start();*/
|
|
m_imp->m_executor.addTask(new TRecordTask(m_imp));
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
void TSoundInputDevice::record(const TSoundTrackP &st,
|
|
TSoundInputDevice::Source type) {
|
|
m_imp->m_recordedBlocks.clear();
|
|
m_imp->m_samplePerBlocks.clear();
|
|
|
|
try {
|
|
if (m_imp->m_dev == -1) m_imp->doOpenDevice(st->getFormat(), type);
|
|
|
|
if (!selectInputDevice(type))
|
|
throw TSoundDeviceException(
|
|
TSoundDeviceException::UnableSetDevice,
|
|
"Input device is not supported for recording");
|
|
|
|
TSoundTrackFormat fmt = getPreferredFormat(st->getFormat());
|
|
if (fmt != st->getFormat())
|
|
throw TSoundDeviceException(TSoundDeviceException::UnsupportedFormat,
|
|
"Unsupported format");
|
|
|
|
if (getVolume() == 0.0) {
|
|
double volume = 5.0;
|
|
setVolume(volume);
|
|
}
|
|
} catch (TSoundDeviceException &e) {
|
|
throw TSoundDeviceException(e.getType(), e.getMessage());
|
|
}
|
|
|
|
// Sovrascive un'intera o parte di traccia gia' esistente
|
|
m_imp->m_oneShotRecording = true;
|
|
m_imp->m_currentFormat = st->getFormat();
|
|
m_imp->m_isRecording = true;
|
|
m_imp->m_stopped = false;
|
|
m_imp->m_recordedSampleCount = 0;
|
|
m_imp->m_st = st;
|
|
|
|
m_imp->m_recordedBlocks.push_back((char *)st->getRawData());
|
|
|
|
// far partire il thread
|
|
/*TRecordThread *recordThread = new TRecordThread(m_imp);
|
|
if (!recordThread)
|
|
throw TSoundDeviceException(
|
|
TSoundDeviceException::UnablePrepare,
|
|
"Problemi per creare il thread");
|
|
recordThread->start();*/
|
|
m_imp->m_executor.addTask(new TRecordTask(m_imp));
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
TSoundTrackP TSoundInputDevice::stop() {
|
|
TSoundTrackP st;
|
|
|
|
if (!m_imp->m_isRecording) return st;
|
|
|
|
m_imp->m_isRecording = false;
|
|
|
|
// mettere istruzioni per fermare il rec
|
|
ioctl(m_imp->m_dev, SNDCTL_DSP_SYNC, 0);
|
|
try {
|
|
m_imp->doCloseDevice();
|
|
} catch (TSoundDeviceException &e) {
|
|
throw TSoundDeviceException(e.getType(), e.getMessage());
|
|
}
|
|
|
|
// attendo 1/5 di secondo
|
|
usleep(200000);
|
|
if (m_imp->m_oneShotRecording)
|
|
st = m_imp->m_st;
|
|
else {
|
|
st = TSoundTrack::create(m_imp->m_currentFormat,
|
|
m_imp->m_recordedSampleCount);
|
|
TINT32 bytesCopied = 0;
|
|
|
|
for (int i = 0; i < (int)m_imp->m_recordedBlocks.size(); ++i) {
|
|
memcpy((void *)(st->getRawData() + bytesCopied),
|
|
m_imp->m_recordedBlocks[i], m_imp->m_samplePerBlocks[i]);
|
|
delete[] m_imp->m_recordedBlocks[i];
|
|
|
|
bytesCopied += m_imp->m_samplePerBlocks[i];
|
|
}
|
|
m_imp->m_samplePerBlocks.clear();
|
|
}
|
|
|
|
return st;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
double TSoundInputDevice::getVolume() {
|
|
int mixer;
|
|
if ((mixer = openMixer()) < 0)
|
|
throw TSoundDeviceException(TSoundDeviceException::NoMixer,
|
|
"Can't have the mixer");
|
|
|
|
int index;
|
|
if ((index = getCurrentRecordSource(mixer)) == -1) {
|
|
::close(mixer);
|
|
throw TSoundDeviceException(TSoundDeviceException::NoMixer,
|
|
"Can't obtain information by mixer");
|
|
}
|
|
|
|
int stereo;
|
|
if (ioctl(mixer, SOUND_MIXER_READ_STEREODEVS, &stereo) == -1) {
|
|
::close(mixer);
|
|
throw TSoundDeviceException(TSoundDeviceException::NoMixer,
|
|
"Can't obtain information by mixer");
|
|
}
|
|
|
|
int level;
|
|
if (ioctl(mixer, MIXER_READ(index), &level) == -1) {
|
|
::close(mixer);
|
|
throw TSoundDeviceException(TSoundDeviceException::UnableVolume,
|
|
"Can't read the volume value");
|
|
}
|
|
|
|
if ((1 << index) & stereo) {
|
|
int left = level & 0xff;
|
|
int right = ((level & 0xff00) >> 8);
|
|
::close(mixer);
|
|
return (left + right) / 20.0;
|
|
} else {
|
|
::close(mixer);
|
|
return (level & 0xff) / 10.0;
|
|
}
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
bool TSoundInputDevice::setVolume(double volume) {
|
|
int mixer;
|
|
if ((mixer = openMixer()) < 0)
|
|
throw TSoundDeviceException(TSoundDeviceException::NoMixer,
|
|
"Can't have the mixer");
|
|
|
|
int caps;
|
|
if (ioctl(mixer, SOUND_MIXER_READ_CAPS, &caps) == -1) {
|
|
::close(mixer);
|
|
throw TSoundDeviceException(TSoundDeviceException::NoMixer,
|
|
"Can't obtain information by mixer");
|
|
}
|
|
|
|
if (!(caps & SOUND_CAP_EXCL_INPUT)) {
|
|
int rec;
|
|
if (ioctl(mixer, SOUND_MIXER_READ_RECMASK, &rec) == -1) {
|
|
::close(mixer);
|
|
throw TSoundDeviceException(TSoundDeviceException::NoMixer,
|
|
"Can't obtain information by mixer");
|
|
}
|
|
int i;
|
|
int nosound = 0;
|
|
for (i = 0; i < 32; ++i)
|
|
if (rec & (1 << i))
|
|
if (!writeVolume(nosound, mixer, i)) {
|
|
::close(mixer);
|
|
throw TSoundDeviceException(TSoundDeviceException::UnableVolume,
|
|
"Can't set the volume value");
|
|
}
|
|
}
|
|
|
|
int index;
|
|
if ((index = getCurrentRecordSource(mixer)) == -1) {
|
|
::close(mixer);
|
|
throw TSoundDeviceException(TSoundDeviceException::NoMixer,
|
|
"Can't obtain information by mixer");
|
|
}
|
|
|
|
int stereo;
|
|
if (ioctl(mixer, SOUND_MIXER_READ_STEREODEVS, &stereo) == -1) {
|
|
::close(mixer);
|
|
throw TSoundDeviceException(TSoundDeviceException::NoMixer,
|
|
"Can't obtain information by mixer");
|
|
}
|
|
|
|
int vol;
|
|
if ((1 << index) & stereo) {
|
|
volume *= 10.0;
|
|
vol = (int)volume + ((int)(volume * 256.0));
|
|
} else
|
|
vol = (int)(volume * 10.0);
|
|
|
|
if (!writeVolume(vol, mixer, index)) {
|
|
::close(mixer);
|
|
throw TSoundDeviceException(TSoundDeviceException::UnableVolume,
|
|
"Can't write the volume value");
|
|
}
|
|
::close(mixer);
|
|
return true;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
bool TSoundInputDevice::isRecording() { return m_imp->m_isRecording; }
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
TSoundTrackFormat TSoundInputDevice::getPreferredFormat(TUINT32 sampleRate,
|
|
int channelCount,
|
|
int bitPerSample) {
|
|
TSoundTrackFormat fmt;
|
|
int status;
|
|
|
|
if (bitPerSample <= 8) {
|
|
bitPerSample = AFMT_U8;
|
|
fmt.m_signedSample = false;
|
|
} else if ((bitPerSample > 8 && bitPerSample < 16) || bitPerSample >= 16) {
|
|
bitPerSample = AFMT_S16_NE;
|
|
fmt.m_signedSample = true;
|
|
}
|
|
|
|
status = ioctl(m_imp->m_dev, SNDCTL_DSP_SETFMT, &bitPerSample);
|
|
if (status == -1)
|
|
throw TSoundDeviceException(TSoundDeviceException::UnablePrepare,
|
|
"Failed setting the specified number of bits");
|
|
fmt.m_bitPerSample = bitPerSample;
|
|
|
|
status = ioctl(m_imp->m_dev, SNDCTL_DSP_CHANNELS, &channelCount);
|
|
if (status == -1)
|
|
throw TSoundDeviceException(
|
|
TSoundDeviceException::UnablePrepare,
|
|
"Failed setting the specified number of channel");
|
|
fmt.m_channelCount = channelCount;
|
|
|
|
if (m_imp->m_supportedRate.find((int)sampleRate) ==
|
|
m_imp->m_supportedRate.end()) {
|
|
std::set<int>::iterator it =
|
|
m_imp->m_supportedRate.lower_bound((int)sampleRate);
|
|
if (it == m_imp->m_supportedRate.end()) {
|
|
it = std::max_element(m_imp->m_supportedRate.begin(),
|
|
m_imp->m_supportedRate.end());
|
|
if (it != m_imp->m_supportedRate.end())
|
|
sampleRate = *(m_imp->m_supportedRate.rbegin());
|
|
else
|
|
throw TSoundDeviceException(TSoundDeviceException::UnsupportedFormat,
|
|
"There isn't a supported rate");
|
|
} else
|
|
sampleRate = *it;
|
|
}
|
|
|
|
if (ioctl(m_imp->m_dev, SNDCTL_DSP_SPEED, &sampleRate) == -1)
|
|
throw TSoundDeviceException(TSoundDeviceException::UnablePrepare,
|
|
"Failed setting the specified sample rate");
|
|
fmt.m_sampleRate = sampleRate;
|
|
|
|
return fmt;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
TSoundTrackFormat TSoundInputDevice::getPreferredFormat(
|
|
const TSoundTrackFormat &format) {
|
|
try {
|
|
return getPreferredFormat(format.m_sampleRate, format.m_channelCount,
|
|
format.m_bitPerSample);
|
|
} catch (TSoundDeviceException &e) {
|
|
throw TSoundDeviceException(e.getType(), e.getMessage());
|
|
}
|
|
}
|
|
|
|
//******************************************************************************
|
|
//******************************************************************************
|
|
// funzioni per l'interazione con
|
|
// la
|
|
// libreria
|
|
// OSS
|
|
//******************************************************************************
|
|
//******************************************************************************
|
|
namespace {
|
|
string parseError(int error) {
|
|
switch (error) {
|
|
case EBADF:
|
|
return string("Bad file descriptor");
|
|
case EFAULT:
|
|
return string("Pointer to/from buffer data is invalid");
|
|
case EINTR:
|
|
return string("Signal interrupt the signal");
|
|
case EINVAL:
|
|
return string("Request/arg isn't valid for this device");
|
|
case EIO:
|
|
return string("Some phisical I/O error has occurred");
|
|
case ENOTTY:
|
|
return string(
|
|
"Fieldes isn't associated with a device that accepts control");
|
|
case ENXIO:
|
|
return string(
|
|
"Request/arg valid, but the requested cannot be performed on this "
|
|
"subdevice");
|
|
default:
|
|
return string("Unknown error");
|
|
break;
|
|
}
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
TSoundInputDevice::Source stringToSource(string dev) {
|
|
if (dev == "mic")
|
|
return TSoundInputDevice::Mic;
|
|
else if (dev == "line")
|
|
return TSoundInputDevice::LineIn;
|
|
else if (dev == "cd")
|
|
return TSoundInputDevice::CdAudio;
|
|
else
|
|
return TSoundInputDevice::DigitalIn;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
string sourceToString(TSoundInputDevice::Source dev) {
|
|
switch (dev) {
|
|
case TSoundInputDevice::Mic:
|
|
return string("mic");
|
|
case TSoundInputDevice::LineIn:
|
|
return string("line");
|
|
case TSoundInputDevice::DigitalIn:
|
|
return string("digital");
|
|
default:
|
|
return string("cd");
|
|
}
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
int openMixer() {
|
|
int mixer = open("/dev/mixer", O_RDWR);
|
|
if (mixer == -1) return false;
|
|
return mixer;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
|
|
int getCurrentRecordSource(int mixer) {
|
|
int recsrc;
|
|
if (ioctl(mixer, SOUND_MIXER_READ_RECSRC, &recsrc) == -1) return -1;
|
|
int index = -1;
|
|
for (index = 0; index < 32; ++index)
|
|
if (recsrc & 1 << index) break;
|
|
return index;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
|
|
bool writeVolume(int volume, int mixer, int indexDev) {
|
|
if (ioctl(mixer, MIXER_WRITE(indexDev), &volume) == -1) return false;
|
|
return true;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
bool controlEnableRecord(int mixer) {
|
|
int recmask;
|
|
if (ioctl(mixer, SOUND_MIXER_READ_RECMASK, &recmask) == -1) {
|
|
perror("Read recmask");
|
|
return false;
|
|
}
|
|
if (recmask & (1 << SOUND_MIXER_IGAIN)) {
|
|
int volume;
|
|
if (ioctl(mixer, MIXER_READ(SOUND_MIXER_IGAIN), &volume) == -1)
|
|
return false;
|
|
|
|
int app = (volume & 0xff);
|
|
if (app <= 30) {
|
|
volume = 80 | 80 << 8;
|
|
if (!writeVolume(volume, mixer, SOUND_MIXER_IGAIN)) return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
int isInputDeviceSupported(TSoundInputDevice::Source dev, int &mixer) {
|
|
int recmask;
|
|
if (ioctl(mixer, SOUND_MIXER_READ_RECMASK, &recmask) == -1) {
|
|
perror("Read recmask");
|
|
return -1;
|
|
}
|
|
|
|
int i;
|
|
string devS = sourceToString(dev);
|
|
const char *deviceName[] = SOUND_DEVICE_NAMES;
|
|
for (i = 0; i < 32; ++i) {
|
|
if (!(recmask & 1 << i)) continue;
|
|
if (strcmp(devS.c_str(), deviceName[i]) == 0) return i;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
bool selectInputDevice(TSoundInputDevice::Source dev) {
|
|
int mixer;
|
|
if ((mixer = openMixer()) < 0) {
|
|
close(mixer);
|
|
return false; // throw TException("Can't open the mixer device");
|
|
}
|
|
int index = isInputDeviceSupported(dev, mixer);
|
|
if (index == -1) return false;
|
|
int recsrc;
|
|
if (ioctl(mixer, SOUND_MIXER_READ_RECSRC, &recsrc) == -1) {
|
|
perror("Read recsrc");
|
|
close(mixer);
|
|
return false;
|
|
}
|
|
if (!(recsrc & 1 << index)) {
|
|
recsrc = 1 << index;
|
|
if (ioctl(mixer, SOUND_MIXER_WRITE_RECSRC, &recsrc) == -1) {
|
|
perror("Write recsrc");
|
|
::close(mixer);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (!controlEnableRecord(mixer)) {
|
|
close(mixer);
|
|
return false; // throw TException("Can't enable recording");
|
|
}
|
|
::close(mixer);
|
|
return true;
|
|
}
|
|
}
|