Autres/Rivendellaudio
1
0
Fork 0
mirror of https://github.com/ElvishArtisan/rivendell.git synced 2025-11-03 23:53:59 +01:00
Code Issues Projects Releases Wiki Activity
Files
2466c4dd80a4d79d482d65759c22f00873fa59b8
Rivendellaudio/cae/cae.cpp
Fred Gleason 945aae0297 2019-08-26 Fred Gleason <fredg@paravelsystems.com> 
* Fixed a regression in caed(8) that broke timescaling support.
2019-08-26 19:05:39 -04:00

2195 lines
59 KiB
C++
Raw Blame History

// cae.cpp
//
// The Core Audio Engine component of Rivendell
//
// (C) Copyright 2002-2019 Fred Gleason <fredg@paravelsystems.com>
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2 as
// published by the Free Software Foundation.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public
// License along with this program; if not, write to the Free Software
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
//
#include <syslog.h>
#include <qcoreapplication.h>
#include <qobject.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <pwd.h>
#include <grp.h>
#include <unistd.h>
#include <stdio.h>
#include <signal.h>
#include <string.h>
#include <math.h>
#include <ctype.h>
#include <errno.h>
#include <dlfcn.h>
#include <qdir.h>
#include <rdapplication.h>
#include <rdaudio_port.h>
#include <rdcmd_switch.h>
#include <rdconf.h>
#include <rddb.h>
#include <rdescape_string.h>
#include <rdsocket.h>
#include <rdsvc.h>
#include <rdsystem.h>
#include <cae.h>
volatile bool exiting=false;
RDConfig *rd_config;
#ifdef JACK
extern jack_client_t *jack_client;
#endif // JACK
#define PRINT_COMMANDS
#ifndef HAVE_SRC_CONV
void src_int_to_float_array (const int *in, float *out, int len)
{
for(int i=0;i<len;i++) {
out[i]=(double)in[i]/2147483648.0;
}
}
void src_float_to_int_array (const float *in, int *out, int len)
{
for(int i=0;i<len;i++) {
out[i]=(int)(in[i]*2147483648.0);
}
}
#endif // HAVE_SRC_CONV
void SigHandler(int signum)
{
switch(signum) {
case SIGINT:
case SIGTERM:
case SIGHUP:
exiting=true;
break;
}
}
MainObject::MainObject(QObject *parent,const char *name)
:QObject(parent,name)
{
//
// Read Command Options
//
new RDCmdSwitch(qApp->argc(),qApp->argv(),"caed",CAED_USAGE);
//
// LogLine references rd_config
//
rd_config=new RDConfig(RD_CONF_FILE);
rd_config->load();
rd_config->setModuleName("caed");
RDApplication::syslog(rd_config,LOG_INFO,"cae starting");
//
// Initialize Data Structures
//
debug=false;
twolame_handle=NULL;
mad_handle=NULL;
if(qApp->argc()>1) {
for(int i=1;i<qApp->argc();i++) {
if(!strcmp(qApp->argv()[i],"-d")) {
debug=true;
}
}
}
for(int i=0;i<256;i++) {
play_handle[i].card=-1;
play_handle[i].stream=-1;
play_handle[i].owner=-1;
}
next_play_handle=0;
for(int i=0;i<RD_MAX_CARDS;i++) {
cae_driver[i]=RDStation::None;
for(int j=0;j<RD_MAX_STREAMS;j++) {
record_length[i][j]=0;
record_threshold[i][j]=-10000;
record_owner[i][j]=-1;
play_owner[i][j]=-1;
play_length[i][j]=0;
play_speed[i][j]=100;
play_pitch[i][j]=false;
for(int k=0;k<RD_MAX_PORTS;k++) {
output_status_flag[i][k][j]=false;
}
#ifdef HAVE_TWOLAME
twolame_lameopts[i][j]=NULL;
#endif // HAVE_TWOLAME
#ifdef HAVE_MAD
mad_active[i][j]=false;
#endif // HAVE_MAD
}
}
#ifdef JACK
jack_client=NULL;
#endif // JACK
cae_server=new CaeServer(rd_config,this);
if(!cae_server->listen(QHostAddress::Any,CAED_TCP_PORT)) {
RDApplication::syslog(rd_config,LOG_ERR,
"caed: failed to bind port %d",CAED_TCP_PORT);
exit(1);
}
connect(cae_server,SIGNAL(connectionDropped(int)),
this,SLOT(connectionDroppedData(int)));
connect(cae_server,SIGNAL(loadPlaybackReq(int,unsigned,const QString &)),
this,SLOT(loadPlaybackData(int,unsigned,const QString &)));
connect(cae_server,SIGNAL(unloadPlaybackReq(int,unsigned)),
this,SLOT(unloadPlaybackData(int,unsigned)));
connect(cae_server,SIGNAL(playPositionReq(int,unsigned,unsigned)),
this,SLOT(playPositionData(int,unsigned,unsigned)));
connect(cae_server,SIGNAL(playReq(int,unsigned,unsigned,unsigned,unsigned)),
this,SLOT(playData(int,unsigned,unsigned,unsigned,unsigned)));
connect(cae_server,SIGNAL(stopPlaybackReq(int,unsigned)),
this,SLOT(stopPlaybackData(int,unsigned)));
connect(cae_server,SIGNAL(timescalingSupportReq(int,unsigned)),
this,SLOT(timescalingSupportData(int,unsigned)));
connect(cae_server,
SIGNAL(loadRecordingReq(int,unsigned,unsigned,unsigned,unsigned,
unsigned,unsigned,const QString &)),
this,
SLOT(loadRecordingData(int,unsigned,unsigned,unsigned,unsigned,
unsigned,unsigned,const QString &)));
connect(cae_server,SIGNAL(unloadRecordingReq(int,unsigned,unsigned)),
this,SLOT(unloadRecordingData(int,unsigned,unsigned)));
connect(cae_server,SIGNAL(recordReq(int,unsigned,unsigned,unsigned,int)),
this,SLOT(recordData(int,unsigned,unsigned,unsigned,int)));
connect(cae_server,SIGNAL(stopRecordingReq(int,unsigned,unsigned)),
this,SLOT(stopRecordingData(int,unsigned,unsigned)));
connect(cae_server,SIGNAL(setInputVolumeReq(int,unsigned,unsigned,int)),
this,SLOT(setInputVolumeData(int,unsigned,unsigned,int)));
connect(cae_server,
SIGNAL(setOutputVolumeReq(int,unsigned,unsigned,unsigned,int)),
this,
SLOT(setOutputVolumeData(int,unsigned,unsigned,unsigned,int)));
connect(cae_server,SIGNAL(fadeOutputVolumeReq(int,unsigned,unsigned,
unsigned,int,unsigned)),
this,SLOT(fadeOutputVolumeData(int,unsigned,unsigned,
unsigned,int,unsigned)));
connect(cae_server,SIGNAL(setInputLevelReq(int,unsigned,unsigned,int)),
this,SLOT(setInputLevelData(int,unsigned,unsigned,int)));
connect(cae_server,SIGNAL(setOutputLevelReq(int,unsigned,unsigned,int)),
this,SLOT(setOutputLevelData(int,unsigned,unsigned,int)));
connect(cae_server,SIGNAL(setInputModeReq(int,unsigned,unsigned,unsigned)),
this,SLOT(setInputModeData(int,unsigned,unsigned,unsigned)));
connect(cae_server,SIGNAL(setOutputModeReq(int,unsigned,unsigned,unsigned)),
this,SLOT(setOutputModeData(int,unsigned,unsigned,unsigned)));
connect(cae_server,SIGNAL(setInputVoxLevelReq(int,unsigned,unsigned,int)),
this,SLOT(setInputVoxLevelData(int,unsigned,unsigned,int)));
connect(cae_server,SIGNAL(setInputTypeReq(int,unsigned,unsigned,unsigned)),
this,SLOT(setInputTypeData(int,unsigned,unsigned,unsigned)));
connect(cae_server,SIGNAL(getInputStatusReq(int,unsigned,unsigned)),
this,SLOT(getInputStatusData(int,unsigned,unsigned)));
connect(cae_server,
SIGNAL(setAudioPassthroughLevelReq(int,unsigned,unsigned,unsigned,int)),
this,
SLOT(setAudioPassthroughLevelData(int,unsigned,unsigned,unsigned,int)));
connect(cae_server,SIGNAL(setClockSourceReq(int,unsigned,int)),
this,SLOT(setClockSourceData(int,unsigned,int)));
connect(cae_server,
SIGNAL(setOutputStatusFlagReq(int,unsigned,unsigned,unsigned,bool)),
this,
SLOT(setOutputStatusFlagData(int,unsigned,unsigned,unsigned,bool)));
connect(cae_server,
SIGNAL(openRtpCaptureChannelReq(int,unsigned,unsigned,uint16_t,
unsigned,unsigned)),
this,
SLOT(openRtpCaptureChannelData(int,unsigned,unsigned,uint16_t,
unsigned,unsigned)));
connect(cae_server,
SIGNAL(meterEnableReq(int,uint16_t,const QList<unsigned> &)),
this,
SLOT(meterEnableData(int,uint16_t,const QList<unsigned> &)));
signal(SIGHUP,SigHandler);
signal(SIGINT,SigHandler);
signal(SIGTERM,SigHandler);
//
// Meter Socket
//
meter_socket=new QUdpSocket(this);
//
// Open Database
//
QSqlDatabase db=QSqlDatabase::addDatabase(rd_config->mysqlDriver());
db.setDatabaseName(rd_config->mysqlDbname());
db.setUserName(rd_config->mysqlUsername());
db.setPassword(rd_config->mysqlPassword());
db.setHostName(rd_config->mysqlHostname());
if(!db.open()) {
RDApplication::syslog(rd_config,LOG_ERR,
"unable to connect to mySQL Server");
printf("caed: unable to connect to mySQL Server");
exit(1);
}
//
// Provisioning
//
InitProvisioning();
//
// Start Up the Drivers
//
cae_station=new RDStation(rd_config->stationName());
RDSystem *sys=new RDSystem();
system_sample_rate=sys->sampleRate();
delete sys;
hpiInit(cae_station);
alsaInit(cae_station);
jackInit(cae_station);
ClearDriverEntries(cae_station);
//
// Probe Capabilities
//
ProbeCaps(cae_station);
//
// Close Database Connection
//
cae_station->setScanned(true);
//
// Initialize Mixers
//
InitMixers();
//
// Meter Update Timer
//
QTimer *timer=new QTimer(this);
connect(timer,SIGNAL(timeout()),this,SLOT(updateMeters()));
timer->start(RD_METER_UPDATE_INTERVAL);
//
// Initialize Thread Priorities
//
bool jack_running=false;
int sched_policy=SCHED_OTHER;
struct sched_param sched_params;
int result = 0;
memset(&sched_params,0,sizeof(struct sched_param));
#ifdef JACK
if(jack_client!=NULL) {
pthread_getschedparam(jack_client_thread_id(jack_client),&sched_policy,
&sched_params);
#ifdef ALSA
for(int i=0;i<RD_MAX_CARDS;i++) {
if(cae_driver[i]==RDStation::Alsa) {
if (!alsa_play_format[i].exiting) {
int r = pthread_setschedparam(alsa_play_format[i].thread,sched_policy,
&sched_params);
if (r) {
result = r;
}
}
if (!alsa_capture_format[i].exiting) {
int r = pthread_setschedparam(alsa_capture_format[i].thread,sched_policy,
&sched_params);
if (r) {
result = r;
}
}
}
}
#endif // ALSA
jack_running=true;
}
#endif // JACK
if(rd_config->useRealtime()) {
if(!jack_running) {
sched_params.sched_priority=rd_config->realtimePriority();
}
sched_policy=SCHED_FIFO;
#ifdef ALSA
for(int i=0;i<RD_MAX_CARDS;i++) {
if(cae_driver[i]==RDStation::Alsa) {
if (!alsa_play_format[i].exiting) {
int r = pthread_setschedparam(alsa_play_format[i].thread,sched_policy,
&sched_params);
if (r) {
result = r;
}
}
if (!alsa_capture_format[i].exiting) {
int r = pthread_setschedparam(alsa_capture_format[i].thread,sched_policy,
&sched_params);
if (r) {
result = r;
}
}
}
}
#endif // ALSA
if(sched_params.sched_priority>sched_get_priority_min(sched_policy)) {
sched_params.sched_priority--;
}
int r=pthread_setschedparam(pthread_self(),sched_policy,&sched_params);
if(r) {
result=r;
}
mlockall(MCL_CURRENT|MCL_FUTURE);
if(result) {
RDApplication::syslog(rd_config,LOG_WARNING,
"unable to set realtime scheduling: %s",
strerror(result));
}
else {
RDApplication::syslog(rd_config,LOG_DEBUG,
"using realtime scheduling, priority=%d",
sched_params.sched_priority);
}
}
//
// Relinquish Root Permissions (if present)
//
/*
if(getuid()==0) {
if(setuid(rd_config->uid())<0) {
perror("cae");
exit(1);
}
// if(setegid(rd_config->gid())<0) {
// perror("cae");
// exit(1);
// }
}
*/
if(rd_config->enableMixerLogging()) {
RDApplication::syslog(rd_config,LOG_INFO,"mixer logging enabled");
}
RDApplication::syslog(rd_config,LOG_INFO,"cae started");
}
void MainObject::loadPlaybackData(int id,unsigned card,const QString &name)
{
QString wavename;
int new_stream=-1;
int handle;
wavename=rd_config->audioFileName(name);
switch(cae_driver[card]) {
case RDStation::Hpi:
if(!hpiLoadPlayback(card,wavename,&new_stream)) {
cae_server->
sendCommand(id,QString().sprintf("LP %d %s -1 -1 -!",card,
(const char *)name.toUtf8()));
RDApplication::syslog(rd_config,LOG_WARNING,
"unable to allocate stream for card %d",card);
return;
}
break;
case RDStation::Alsa:
if(!alsaLoadPlayback(card,wavename,&new_stream)) {
cae_server->
sendCommand(id,QString().sprintf("LP %d %s -1 -1 -!",card,
(const char *)name.toUtf8()));
RDApplication::syslog(rd_config,LOG_WARNING,
"unable to allocate stream for card %d",card);
return;
}
break;
case RDStation::Jack:
if(!jackLoadPlayback(card,wavename,&new_stream)) {
cae_server->
sendCommand(id,QString().sprintf("LP %d %s -1 -1 -!",card,
(const char *)name.toUtf8()));
RDApplication::syslog(rd_config,LOG_WARNING,
"unable to allocate stream for card %d",card);
return;
}
break;
default:
cae_server->
sendCommand(id,QString().sprintf("LP %d %s -1 -1 -!",card,
(const char *)name.toUtf8()));
return;
}
if((handle=GetHandle(card,new_stream))>=0) {
RDApplication::syslog(rd_config,LOG_WARNING,
"*** clearing stale stream assignment, card=%d stream=%d ***",
card,new_stream);
play_handle[handle].card=-1;
play_handle[handle].stream=-1;
play_handle[handle].owner=-1;
}
handle=GetNextHandle();
play_handle[handle].card=card;
play_handle[handle].stream=new_stream;
play_handle[handle].owner=id;
play_owner[card][new_stream]=id;
RDApplication::syslog(rd_config,LOG_INFO,
"LoadPlayback Card: %d Stream: %d Name: %s Handle: %d",
card,new_stream,(const char *)wavename.toUtf8(),handle);
cae_server->
sendCommand(id,QString().sprintf("LP %d %s %d %d +!",card,
(const char *)name.toUtf8(),
new_stream,handle));
}
void MainObject::unloadPlaybackData(int id,unsigned handle)
{
int card=play_handle[handle].card;
int stream=play_handle[handle].stream;
if((play_owner[card][stream]==-1)||(play_owner[card][stream]==id)) {
switch(cae_driver[card]) {
case RDStation::Hpi:
if(hpiUnloadPlayback(card,stream)) {
play_owner[card][stream]=-1;
RDApplication::syslog(rd_config,LOG_INFO,
"UnloadPlayback - Card: %d Stream: %d Handle: %d",
card,stream,handle);
cae_server->sendCommand(id,QString().sprintf("UP %d +!",handle));
}
else {
cae_server->sendCommand(id,QString().sprintf("UP %d -!",handle));
}
break;
case RDStation::Alsa:
if(alsaUnloadPlayback(card,stream)) {
play_owner[card][stream]=-1;
RDApplication::syslog(rd_config,LOG_INFO,
"UnloadPlayback - Card: %d Stream: %d Handle: %d",
card,stream,handle);
cae_server->sendCommand(id,QString().sprintf("UP %d +!",handle));
}
else {
cae_server->sendCommand(id,QString().sprintf("UP %d -!",handle));
}
break;
case RDStation::Jack:
if(jackUnloadPlayback(card,stream)) {
play_owner[card][stream]=-1;
RDApplication::syslog(rd_config,LOG_INFO,
"UnloadPlayback - Card: %d Stream: %d Handle: %d",
card,stream,handle);
cae_server->sendCommand(id,QString().sprintf("UP %d +!",handle));
}
else {
cae_server->sendCommand(id,QString().sprintf("UP %d -!",handle));
}
break;
default:
cae_server->sendCommand(id,QString().sprintf("UP %d -!",handle));
return;
}
play_handle[handle].card=-1;
play_handle[handle].stream=-1;
play_handle[handle].owner=-1;
return;
}
else {
cae_server->sendCommand(id,QString().sprintf("UP %d -!",handle));
}
}
void MainObject::playPositionData(int id,unsigned handle,unsigned pos)
{
int card=play_handle[handle].card;
int stream=play_handle[handle].stream;
if(play_owner[card][stream]==id) {
switch(cae_driver[card]) {
case RDStation::Hpi:
if(hpiPlaybackPosition(card,stream,pos)) {
RDApplication::syslog(rd_config,LOG_INFO,
"PlaybackPosition - Card: %d Stream: %d Pos: %d Handle: %d",
card,stream,pos,handle);
cae_server->sendCommand(id,QString().sprintf("PP %d %d +!",handle,pos));
}
else {
cae_server->sendCommand(id,QString().sprintf("PP %d %d -!",handle,pos));
}
break;
case RDStation::Alsa:
if(alsaPlaybackPosition(card,stream,pos)) {
RDApplication::syslog(rd_config,LOG_INFO,
"PlaybackPosition - Card: %d Stream: %d Pos: %d Handle: %d",
card,stream,pos,handle);
cae_server->sendCommand(id,QString().sprintf("PP %d %d +!",handle,pos));
}
else {
cae_server->sendCommand(id,QString().sprintf("PP %d %d -!",handle,pos));
}
break;
case RDStation::Jack:
if(jackPlaybackPosition(card,stream,pos)) {
RDApplication::syslog(rd_config,LOG_INFO,
"PlaybackPosition - Card: %d Stream: %d Pos: %d Handle: %d",
card,stream,pos,handle);
cae_server->sendCommand(id,QString().sprintf("PP %d %d +!",handle,pos));
}
else {
cae_server->sendCommand(id,QString().sprintf("PP %d %d -!",handle,pos));
}
break;
default:
cae_server->sendCommand(id,QString().sprintf("PP %d %d -!",handle,pos));
return;
}
return;
}
cae_server->sendCommand(id,QString().sprintf("PP %d %d -!",handle,pos));
}
void MainObject::playData(int id,unsigned handle,unsigned length,unsigned speed,
unsigned pitch_flag)
{
int card=play_handle[handle].card;
int stream=play_handle[handle].stream;
play_length[card][stream]=length;
play_speed[card][stream]=speed;
switch(pitch_flag) {
case 0:
play_pitch[card][stream]=false;
break;
case 1:
play_pitch[card][stream]=true;
break;
default:
cae_server->
sendCommand(id,QString().sprintf("PY %u %u %u %u -!",
handle,length,speed,pitch_flag));
return;
}
if(play_owner[card][stream]==id) {
switch(cae_driver[card]) {
case RDStation::Hpi:
if(!hpiPlay(card,stream,play_length[card][stream],
play_speed[card][stream],play_pitch[card][stream],
RD_ALLOW_NONSTANDARD_RATES)) {
cae_server->
sendCommand(id,QString().sprintf("PY %u %u %u %u -!",
handle,length,speed,pitch_flag));
return;
}
break;
case RDStation::Alsa:
if(!alsaPlay(card,stream,play_length[card][stream],
play_speed[card][stream],play_pitch[card][stream],
RD_ALLOW_NONSTANDARD_RATES)) {
cae_server->
sendCommand(id,QString().sprintf("PY %u %u %u %u -!",
handle,length,speed,pitch_flag));
return;
}
break;
case RDStation::Jack:
if(!jackPlay(card,stream,play_length[card][stream],
play_speed[card][stream],play_pitch[card][stream],
RD_ALLOW_NONSTANDARD_RATES)) {
cae_server->
sendCommand(id,QString().sprintf("PY %u %u %u %u -!",
handle,length,speed,pitch_flag));
return;
}
break;
default:
cae_server->
sendCommand(id,QString().sprintf("PY %u %u %u %u -!",
handle,length,speed,pitch_flag));
return;
}
RDApplication::syslog(rd_config,LOG_INFO,
"Play - Card: %d Stream: %d Handle: %d Length: %d Speed: %d Pitch: %d",
card,stream,handle,play_length[card][stream],
play_speed[card][stream],pitch_flag);
// No command echo for success -- statePlayUpdate() sends it!
return;
}
cae_server->
sendCommand(id,QString().sprintf("PY %u %u %u %u -!",
handle,length,speed,pitch_flag));
}
void MainObject::stopPlaybackData(int id,unsigned handle)
{
int card=play_handle[handle].card;
int stream=play_handle[handle].stream;
if(play_owner[card][stream]==id) {
switch(cae_driver[card]) {
case RDStation::Hpi:
if(!hpiStopPlayback(card,stream)) {
cae_server->sendCommand(id,QString().sprintf("SP %u -!",handle));
return;
}
break;
case RDStation::Alsa:
if(!alsaStopPlayback(card,stream)) {
cae_server->sendCommand(id,QString().sprintf("SP %u -!",handle));
return;
}
break;
case RDStation::Jack:
if(!jackStopPlayback(card,stream)) {
cae_server->sendCommand(id,QString().sprintf("SP %u -!",handle));
return;
}
break;
default:
cae_server->sendCommand(id,QString().sprintf("SP %u -!",handle));
return;
}
RDApplication::syslog(rd_config,LOG_INFO,
"StopPlayback - Card: %d Stream: %d Handle: %d",
card,stream,handle);
return;
}
cae_server->sendCommand(id,QString().sprintf("SP %u -!",handle));
}
void MainObject::timescalingSupportData(int id,unsigned card)
{
bool state=false;
switch(cae_driver[card]) {
case RDStation::Hpi:
state=hpiTimescaleSupported(card);
break;
case RDStation::Jack:
state=jackTimescaleSupported(card);
break;
case RDStation::Alsa:
state=alsaTimescaleSupported(card);
break;
case RDStation::None:
break;
}
if(state) {
cae_server->sendCommand(id,QString().sprintf("TS %u +!",card));
}
else {
cae_server->sendCommand(id,QString().sprintf("TS %u -!",card));
}
}
void MainObject::loadRecordingData(int id,unsigned card,unsigned port,
unsigned coding,unsigned channels,
unsigned samprate,unsigned bitrate,
const QString &name)
{
QString wavename;
if(record_owner[card][port]==-1) {
wavename=rd_config->audioFileName(name);
unlink(wavename); // So we don't trainwreck any current playouts!
unlink(wavename+".energy");
switch(cae_driver[card]) {
case RDStation::Hpi:
if(!hpiLoadRecord(card,port,coding,channels,samprate,bitrate,
wavename)) {
cae_server->
sendCommand(id,QString().sprintf("LR %u %u %u %u %u %u %s -!",
card,port,coding,channels,samprate,
bitrate,(const char *)name.toUtf8()));
return;
}
break;
case RDStation::Alsa:
if(!alsaLoadRecord(card,port,coding,channels,samprate,
bitrate,wavename)) {
cae_server->
sendCommand(id,QString().sprintf("LR %u %u %u %u %u %u %s -!",
card,port,coding,channels,samprate,
bitrate,(const char *)name.toUtf8()));
return;
}
break;
case RDStation::Jack:
if(!jackLoadRecord(card,port,coding,channels,samprate,
bitrate,wavename)) {
cae_server->
sendCommand(id,QString().sprintf("LR %u %u %u %u %u %u %s -!",
card,port,coding,channels,samprate,
bitrate,(const char *)name.toUtf8()));
return;
}
break;
default:
cae_server->
sendCommand(id,QString().sprintf("LR %u %u %u %u %u %u %s -!",
card,port,coding,channels,samprate,
bitrate,(const char *)name.toUtf8()));
return;
}
RDApplication::syslog(rd_config,LOG_INFO,
"LoadRecord - Card: %d Stream: %d Coding: %d Chans: %d SampRate: %d BitRate: %d Name: %s",
card,port,coding,channels,samprate,bitrate,
(const char *)wavename.toUtf8());
record_owner[card][port]=id;
cae_server->
sendCommand(id,QString().sprintf("LR %u %u %u %u %u %u %s +!",
card,port,coding,channels,samprate,
bitrate,(const char *)name.toUtf8()));
}
else {
cae_server->
sendCommand(id,QString().sprintf("LR %u %u %u %u %u %u %s -!",
card,port,coding,channels,samprate,
bitrate,(const char *)name.toUtf8()));
}
}
void MainObject::unloadRecordingData(int id,unsigned card,unsigned stream)
{
if((record_owner[card][stream]==-1)||(record_owner[card][stream]==id)) {
unsigned len=0;
switch(cae_driver[card]) {
case RDStation::Hpi:
if(!hpiUnloadRecord(card,stream,&len)) {
cae_server->sendCommand(id,QString().sprintf("UR %u %u -!",card,stream));
return;
}
break;
case RDStation::Alsa:
if(!alsaUnloadRecord(card,stream,&len)) {
cae_server->sendCommand(id,QString().sprintf("UR %u %u -!",card,stream));
return;
}
break;
case RDStation::Jack:
if(!jackUnloadRecord(card,stream,&len)) {
cae_server->sendCommand(id,QString().sprintf("UR %u %u -!",card,stream));
return;
}
break;
default:
cae_server->sendCommand(id,QString().sprintf("UR %u %u -!",card,stream));
return;
}
record_owner[card][stream]=-1;
RDApplication::syslog(rd_config,LOG_INFO,
"UnloadRecord - Card: %d Stream: %d, Length: %u",
card,stream,len);
cae_server->
sendCommand(id,QString().sprintf("UR %u %u %u +!",card,stream,
(unsigned)((double)len*1000.0/(double)system_sample_rate)));
return;
}
else {
cae_server->sendCommand(id,QString().sprintf("UR %u %u -!",card,stream));
return;
}
}
void MainObject::recordData(int id,unsigned card,unsigned stream,unsigned len,
int threshold_level)
{
record_length[card][stream]=len;
record_threshold[card][stream]=threshold_level;
if(record_owner[card][stream]==id) {
switch(cae_driver[card]) {
case RDStation::Hpi:
if(!hpiRecord(card,stream,record_length[card][stream],
record_threshold[card][stream])) {
cae_server->
sendCommand(id,QString().sprintf("RD %u %u %u %d -!",
card,stream,len,threshold_level));
return;
}
break;
case RDStation::Alsa:
if(!alsaRecord(card,stream,record_length[card][stream],
record_threshold[card][stream])) {
cae_server->
sendCommand(id,QString().sprintf("RD %u %u %u %d -!",
card,stream,len,threshold_level));
return;
}
break;
case RDStation::Jack:
if(!jackRecord(card,stream,record_length[card][stream],
record_threshold[card][stream])) {
cae_server->
sendCommand(id,QString().sprintf("RD %u %u %u %d -!",
card,stream,len,threshold_level));
return;
}
break;
default:
cae_server->
sendCommand(id,QString().sprintf("RD %u %u %u %d -!",
card,stream,len,threshold_level));
return;
}
RDApplication::syslog(rd_config,LOG_INFO,
"Record - Card: %d Stream: %d Length: %d Thres: %d",
card,stream,record_length[card][stream],
record_threshold[card][stream]);
// No positive echo required here!
return;
}
cae_server->
sendCommand(id,QString().sprintf("RD %u %u %u %d -!",
card,stream,len,threshold_level));
}
void MainObject::stopRecordingData(int id,unsigned card,unsigned stream)
{
switch(cae_driver[card]) {
case RDStation::Hpi:
if(!hpiStopRecord(card,stream)) {
cae_server->sendCommand(id,QString().sprintf("SR %u %u -!",card,stream));
return;
}
break;
case RDStation::Alsa:
if(!alsaStopRecord(card,stream)) {
cae_server->sendCommand(id,QString().sprintf("SR %u %u -!",card,stream));
return;
}
cae_server->sendCommand(id,QString().sprintf("SR %u %u +!",card,stream));
break;
case RDStation::Jack:
if(!jackStopRecord(card,stream)) {
cae_server->sendCommand(id,QString().sprintf("SR %u %u -!",card,stream));
return;
}
cae_server->sendCommand(id,QString().sprintf("SR %u %u +!",card,stream));
break;
default:
cae_server->sendCommand(id,QString().sprintf("SR %u %u -!",card,stream));
return;
}
RDApplication::syslog(rd_config,LOG_INFO,
"StopRecord - Card: %d Stream: %d",card,stream);
}
void MainObject::setInputVolumeData(int id,unsigned card,unsigned stream,
int level)
{
switch(cae_driver[card]) {
case RDStation::Hpi:
if(!hpiSetInputVolume(card,stream,level)) {
cae_server->
sendCommand(id,QString().sprintf("IV %u %u %d -!",card,stream,level));
return;
}
case RDStation::Alsa:
if(!alsaSetInputVolume(card,stream,level)) {
cae_server->
sendCommand(id,QString().sprintf("IV %u %u %d -!",card,stream,level));
return;
}
case RDStation::Jack:
if(!jackSetInputVolume(card,stream,level)) {
cae_server->
sendCommand(id,QString().sprintf("IV %u %u %d -!",card,stream,level));
return;
}
default:
cae_server->
sendCommand(id,QString().sprintf("IV %u %u %d -!",card,stream,level));
return;
}
if(rd_config->enableMixerLogging()) {
RDApplication::syslog(rd_config,LOG_INFO,
"SetInputVolume - Card: %d Stream: %d Level: %d",
card,stream,level);
}
cae_server->
sendCommand(id,QString().sprintf("IV %u %u %d +!",card,stream,level));
}
void MainObject::setOutputVolumeData(int id,unsigned card,unsigned stream,
unsigned port,int level)
{
switch(cae_driver[card]) {
case RDStation::Hpi:
if(!hpiSetOutputVolume(card,stream,port,level)) {
cae_server->sendCommand(id,QString().sprintf("OV %u %u %u %d -!",
card,stream,port,level));
return;
}
break;
case RDStation::Alsa:
if(!alsaSetOutputVolume(card,stream,port,level)) {
cae_server->sendCommand(id,QString().sprintf("OV %u %u %u %d -!",
card,stream,port,level));
return;
}
break;
case RDStation::Jack:
if(!jackSetOutputVolume(card,stream,port,level)) {
cae_server->sendCommand(id,QString().sprintf("OV %u %u %u %d -!",
card,stream,port,level));
return;
}
break;
default:
cae_server->sendCommand(id,QString().sprintf("OV %u %u %u %d -!",
card,stream,port,level));
return;
}
if(rd_config->enableMixerLogging()) {
RDApplication::syslog(rd_config,LOG_INFO,
"SetOutputVolume - Card: %d Stream: %d Port: %d Level: %d",
card,stream,port,level);
}
cae_server->sendCommand(id,QString().sprintf("OV %u %u %u %d +!",
card,stream,port,level));
}
void MainObject::fadeOutputVolumeData(int id,unsigned card,unsigned stream,
unsigned port,int level,unsigned length)
{
switch(cae_driver[card]) {
case RDStation::Hpi:
if(!hpiFadeOutputVolume(card,stream,port,level,length)) {
cae_server->
sendCommand(id,QString().sprintf("FV %u %u %u %d %u -!",
card,stream,port,level,length));
return;
}
break;
case RDStation::Alsa:
if(!alsaFadeOutputVolume(card,stream,port,level,length)) {
cae_server->
sendCommand(id,QString().sprintf("FV %u %u %u %d %u -!",
card,stream,port,level,length));
return;
}
break;
case RDStation::Jack:
if(!jackFadeOutputVolume(card,stream,port,level,length)) {
cae_server->
sendCommand(id,QString().sprintf("FV %u %u %u %d %u -!",
card,stream,port,level,length));
return;
}
break;
default:
cae_server->
sendCommand(id,QString().sprintf("FV %u %u %u %d %u -!",
card,stream,port,level,length));
return;
}
if(rd_config->enableMixerLogging()) {
RDApplication::syslog(rd_config,LOG_INFO,
"FadeOutputVolume - Card: %d Stream: %d Port: %d Level: %d Length: %d",
card,stream,port,level,length);
}
cae_server->
sendCommand(id,QString().sprintf("FV %u %u %u %d %u +!",
card,stream,port,level,length));
}
void MainObject::setInputLevelData(int id,unsigned card,unsigned port,
int level)
{
switch(cae_driver[card]) {
case RDStation::Hpi:
if(!hpiSetInputLevel(card,port,level)) {
cae_server->sendCommand(id,QString().sprintf("IL %u %u %d -!",
card,port,level));
return;
}
break;
case RDStation::Alsa:
if(!alsaSetInputLevel(card,port,level)) {
cae_server->sendCommand(id,QString().sprintf("IL %u %u %d -!",
card,port,level));
return;
}
break;
case RDStation::Jack:
if(!jackSetInputLevel(card,port,level)) {
cae_server->sendCommand(id,QString().sprintf("IL %u %u %d -!",
card,port,level));
return;
}
break;
default:
cae_server->sendCommand(id,QString().sprintf("IL %u %u %d -!",
card,port,level));
return;
}
if(rd_config->enableMixerLogging()) {
RDApplication::syslog(rd_config,LOG_INFO,
"SetInputLevel - Card: %d Port: %d Level: %d",
card,port,level);
}
cae_server->sendCommand(id,QString().sprintf("IL %u %u %d +!",
card,port,level));
}
void MainObject::setOutputLevelData(int id,unsigned card,unsigned port,
int level)
{
switch(cae_driver[card]) {
case RDStation::Hpi:
if(!hpiSetOutputLevel(card,port,level)) {
cae_server->sendCommand(id,QString().sprintf("OL %u %u %d -!",
card,port,level));
return;
}
break;
case RDStation::Alsa:
if(!alsaSetOutputLevel(card,port,level)) {
cae_server->sendCommand(id,QString().sprintf("OL %u %u %d -!",
card,port,level));
return;
}
break;
case RDStation::Jack:
if(!jackSetOutputLevel(card,port,level)) {
cae_server->sendCommand(id,QString().sprintf("OL %u %u %d -!",
card,port,level));
return;
}
break;
default:
cae_server->sendCommand(id,QString().sprintf("OL %u %u %d -!",
card,port,level));
return;
}
if(rd_config->enableMixerLogging()) {
RDApplication::syslog(rd_config,LOG_INFO,
"SetOutputLevel - Card: %d Port: %d Level: %d",
card,port,level);
}
cae_server->sendCommand(id,QString().sprintf("OL %u %u %d +!",
card,port,level));
}
void MainObject::setInputModeData(int id,unsigned card,unsigned stream,
unsigned mode)
{
switch(cae_driver[card]) {
case RDStation::Hpi:
if(!hpiSetInputMode(card,stream,mode)) {
cae_server->sendCommand(id,QString().sprintf("IM %u %u %u -!",
card,stream,mode));
return;
}
break;
case RDStation::Alsa:
if(!alsaSetInputMode(card,stream,mode)) {
cae_server->sendCommand(id,QString().sprintf("IM %u %u %u -!",
card,stream,mode));
return;
}
break;
case RDStation::Jack:
if(!jackSetInputMode(card,stream,mode)) {
cae_server->sendCommand(id,QString().sprintf("IM %u %u %u -!",
card,stream,mode));
return;
}
break;
default:
cae_server->sendCommand(id,QString().sprintf("IM %u %u %u -!",
card,stream,mode));
return;
}
if(rd_config->enableMixerLogging()) {
RDApplication::syslog(rd_config,LOG_INFO,
"SetInputMode - Card: %d Stream: %d Mode: %d",
card,stream,mode);
}
cae_server->sendCommand(id,QString().sprintf("IM %u %u %u +!",
card,stream,mode));
}
void MainObject::setOutputModeData(int id,unsigned card,unsigned stream,
unsigned mode)
{
switch(cae_driver[card]) {
case RDStation::Hpi:
if(!hpiSetOutputMode(card,stream,mode)) {
cae_server->sendCommand(id,QString().sprintf("OM %u %u %u -!",
card,stream,mode));
return;
}
break;
case RDStation::Alsa:
if(!alsaSetOutputMode(card,stream,mode)) {
cae_server->sendCommand(id,QString().sprintf("OM %u %u %u -!",
card,stream,mode));
return;
}
break;
case RDStation::Jack:
if(!jackSetOutputMode(card,stream,mode)) {
cae_server->sendCommand(id,QString().sprintf("OM %u %u %u -!",
card,stream,mode));
return;
}
break;
default:
cae_server->sendCommand(id,QString().sprintf("OM %u %u %u -!",
card,stream,mode));
return;
}
if(rd_config->enableMixerLogging()) {
RDApplication::syslog(rd_config,LOG_INFO,
"SetOutputMode - Card: %d Stream: %d Mode: %d",
card,stream,mode);
}
cae_server->sendCommand(id,QString().sprintf("OM %u %u %u +!",
card,stream,mode));
}
void MainObject::setInputVoxLevelData(int id,unsigned card,unsigned stream,
int level)
{
switch(cae_driver[card]) {
case RDStation::Hpi:
if(!hpiSetInputVoxLevel(card,stream,level)) {
cae_server->sendCommand(id,QString().sprintf("IX %u %u %d -!",
card,stream,level));
return;
}
break;
case RDStation::Alsa:
if(!alsaSetInputVoxLevel(card,stream,level)) {
cae_server->sendCommand(id,QString().sprintf("IX %u %u %d -!",
card,stream,level));
return;
}
break;
case RDStation::Jack:
if(!jackSetInputVoxLevel(card,stream,level)) {
cae_server->sendCommand(id,QString().sprintf("IX %u %u %d -!",
card,stream,level));
return;
}
break;
default:
cae_server->sendCommand(id,QString().sprintf("IX %u %u %d -!",
card,stream,level));
return;
}
if(rd_config->enableMixerLogging()) {
RDApplication::syslog(rd_config,LOG_INFO,
"SetInputVOXLevel - Card: %d Stream: %d Level: %d",
card,stream,level);
}
cae_server->sendCommand(id,QString().sprintf("IX %u %u %d +!",
card,stream,level));
}
void MainObject::setInputTypeData(int id,unsigned card,unsigned port,
unsigned type)
{
switch(cae_driver[card]) {
case RDStation::Hpi:
if(!hpiSetInputType(card,port,type)) {
cae_server->sendCommand(id,QString().sprintf("IT %u %u %u -!",
card,port,type));
return;
}
break;
case RDStation::Alsa:
if(!alsaSetInputType(card,port,type)) {
cae_server->sendCommand(id,QString().sprintf("IT %u %u %u -!",
card,port,type));
return;
}
break;
case RDStation::Jack:
if(!jackSetInputType(card,port,type)) {
cae_server->sendCommand(id,QString().sprintf("IT %u %u %u -!",
card,port,type));
return;
}
break;
default:
cae_server->sendCommand(id,QString().sprintf("IT %u %u %u -!",
card,port,type));
return;
}
if(rd_config->enableMixerLogging()) {
RDApplication::syslog(rd_config,LOG_INFO,
"SetInputType - Card: %d Port: %d Type: %d",
card,port,type);
}
cae_server->sendCommand(id,QString().sprintf("IT %u %u %u +!",
card,port,type));
}
void MainObject::getInputStatusData(int id,unsigned card,unsigned port)
{
if(hpiGetInputStatus(card,port)) {
cae_server->sendCommand(id,QString().sprintf("IS %d %d 0 +!",card,port));
}
else {
cae_server->sendCommand(id,QString().sprintf("IS %d %d 1 +!",card,port));
}
}
void MainObject::setAudioPassthroughLevelData(int id,unsigned card,
unsigned input,unsigned output,
int level)
{
switch(cae_driver[card]) {
case RDStation::Hpi:
if(!hpiSetPassthroughLevel(card,input,output,level)) {
cae_server->sendCommand(id,QString().sprintf("AL %u %u %u %d -!",
card,input,output,level));
return;
}
break;
case RDStation::Alsa:
if(!alsaSetPassthroughLevel(card,input,output,level)) {
cae_server->sendCommand(id,QString().sprintf("AL %u %u %u %d -!",
card,input,output,level));
return;
}
break;
case RDStation::Jack:
if(!jackSetPassthroughLevel(card,input,output,level)) {
cae_server->sendCommand(id,QString().sprintf("AL %u %u %u %d -!",
card,input,output,level));
return;
}
break;
default:
cae_server->sendCommand(id,QString().sprintf("AL %u %u %u %d -!",
card,input,output,level));
return;
}
if(rd_config->enableMixerLogging()) {
RDApplication::syslog(rd_config,LOG_INFO,
"SetPassthroughLevel - Card: %d InPort: %d OutPort: %d Level: %d",
card,input,output,level);
}
cae_server->sendCommand(id,QString().sprintf("AL %u %u %u %d +!",
card,input,output,level));
}
void MainObject::setClockSourceData(int id,unsigned card,int input)
{
if((card<0)||(input<0)) {
cae_server->sendCommand(id,QString().sprintf("CS %u %u -!",card,input));
return;
}
switch(cae_driver[card]) {
case RDStation::Hpi:
if(!hpiSetClockSource(card,input)) {
cae_server->sendCommand(id,QString().sprintf("CS %u %u -!",card,input));
return;
}
default:
cae_server->sendCommand(id,QString().sprintf("CS %u %u +!",card,input));
return;
}
if(rd_config->enableMixerLogging()) {
RDApplication::syslog(rd_config,LOG_INFO,
"SetClockSource - Card: %d Source: %d",card,input);
}
cae_server->sendCommand(id,QString().sprintf("CS %u %u +!",card,input));
}
void MainObject::setOutputStatusFlagData(int id,unsigned card,unsigned port,
unsigned stream,bool state)
{
output_status_flag[card][port][stream]=state;
SendMeterOutputStatusUpdate(card,port,stream);
cae_server->sendCommand(id,QString().sprintf("OS %u %u %u %u +!",
card,port,stream,state));
}
void MainObject::openRtpCaptureChannelData(int id,unsigned card,unsigned port,
uint16_t udp_port,unsigned samprate,
unsigned chans)
{
}
void MainObject::meterEnableData(int id,uint16_t udp_port,
const QList<unsigned> &cards)
{
QString cmd=QString().sprintf("ME %u",0xFFFF&udp_port);
for(int i=0;i<cards.size();i++) {
cmd+=QString().sprintf(" %u",cards.at(i));
}
if((udp_port<0)||(udp_port>0xFFFF)) {
cae_server->sendCommand(id,cmd+" -!");
return;
}
cae_server->setMeterPort(id,udp_port);
for(int i=0;i<cards.size();i++) {
if((cards.at(i)<0)||(cards.at(i)>=RD_MAX_CARDS)) {
cae_server->sendCommand(id,cmd+" -!");
return;
}
cae_server->setMetersEnabled(id,cards.at(i),true);
}
cae_server->sendCommand(id,cmd+" +!");
SendMeterOutputStatusUpdate();
}
void MainObject::connectionDroppedData(int id)
{
KillSocket(id);
}
void MainObject::statePlayUpdate(int card,int stream,int state)
{
int handle=GetHandle(card,stream);
if(handle<0) {
return;
}
if(play_owner[card][stream]!=-1) {
switch(state) {
case 1: // Playing
cae_server->sendCommand(play_owner[card][stream],
(const char *)QString().
sprintf("PY %d %d %d +!",handle,
play_length[card][stream],
play_speed[card][stream]));
break;
case 2: // Paused
cae_server->
sendCommand(play_owner[card][stream],(const char *)QString().
sprintf("SP %d +!",handle));
break;
case 0: // Stopped
cae_server->
sendCommand(play_owner[card][stream],(const char *)QString().
sprintf("SP %d +!",handle));
break;
}
}
}
void MainObject::stateRecordUpdate(int card,int stream,int state)
{
if(record_owner[card][stream]!=-1) {
switch(state) {
case 0: // Recording
cae_server->
sendCommand(record_owner[card][stream],(const char *)QString().
sprintf("RD %d %d %d %d +!",card,stream,
record_length[card][stream],
record_threshold[card][stream]));
break;
case 4: // Record Started
cae_server->
sendCommand(record_owner[card][stream],(const char *)QString().
sprintf("RS %d %d +!",card,stream));
break;
case 2: // Paused
case 3: // Stopped
cae_server->
sendCommand(record_owner[card][stream],(const char *)QString().
sprintf("SR %d %d +!",card,stream));
break;
}
}
}
void MainObject::updateMeters()
{
short levels[2];
unsigned positions[RD_MAX_STREAMS];
if(exiting) {
jackFree();
alsaFree();
hpiFree();
RDApplication::syslog(rd_config,LOG_INFO,"cae exiting");
exit(0);
}
AlsaClock();
JackClock();
for(int i=0;i<RD_MAX_CARDS;i++) {
switch(cae_driver[i]) {
case RDStation::Hpi:
for(int j=0;j<RD_MAX_PORTS;j++) {
if(hpiGetInputStatus(i,j)!=port_status[i][j]) {
port_status[i][j]=hpiGetInputStatus(i,j);
if(port_status[i][j]) {
cae_server->sendCommand(QString().sprintf("IS %d %d 0!",i,j));
}
else {
cae_server->sendCommand(QString().sprintf("IS %d %d 1!",i,j));
}
}
if(hpiGetInputMeters(i,j,levels)) {
SendMeterLevelUpdate("I",i,j,levels);
}
if(hpiGetOutputMeters(i,j,levels)) {
SendMeterLevelUpdate("O",i,j,levels);
}
}
hpiGetOutputPosition(i,positions);
SendMeterPositionUpdate(i,positions);
for(int j=0;j<RD_MAX_STREAMS;j++) {
if(hpiGetStreamOutputMeters(i,j,levels)) {
SendStreamMeterLevelUpdate(i,j,levels);
}
}
break;
case RDStation::Jack:
for(int j=0;j<RD_MAX_PORTS;j++) {
if(jackGetInputStatus(i,j)!=port_status[i][j]) {
port_status[i][j]=!port_status[i][j];
cae_server->sendCommand(QString().sprintf("IS %d %d %d",i,j,
port_status[i][j]));
}
if(jackGetInputMeters(i,j,levels)) {
SendMeterLevelUpdate("I",i,j,levels);
}
if(jackGetOutputMeters(i,j,levels)) {
SendMeterLevelUpdate("O",i,j,levels);
}
}
jackGetOutputPosition(i,positions);
SendMeterPositionUpdate(i,positions);
for(int j=0;j<RD_MAX_STREAMS;j++) {
if(jackGetStreamOutputMeters(i,j,levels)) {
SendStreamMeterLevelUpdate(i,j,levels);
}
}
break;
case RDStation::Alsa:
for(int j=0;j<RD_MAX_PORTS;j++) {
if(alsaGetInputStatus(i,j)!=port_status[i][j]) {
port_status[i][j]=!port_status[i][j];
cae_server->sendCommand(QString().sprintf("IS %d %d %d",i,j,
port_status[i][j]));
}
if(alsaGetInputMeters(i,j,levels)) {
SendMeterLevelUpdate("I",i,j,levels);
}
if(alsaGetOutputMeters(i,j,levels)) {
SendMeterLevelUpdate("O",i,j,levels);
}
}
alsaGetOutputPosition(i,positions);
SendMeterPositionUpdate(i,positions);
for(int j=0;j<RD_MAX_STREAMS;j++) {
if(alsaGetStreamOutputMeters(i,j,levels)) {
SendStreamMeterLevelUpdate(i,j,levels);
}
}
break;
case RDStation::None:
break;
}
}
}
void MainObject::InitProvisioning() const
{
QString sql;
RDSqlQuery *q;
QString err_msg;
//
// Provision a Host
//
if(rd_config->provisioningCreateHost()) {
if(!rd_config->provisioningHostTemplate().isEmpty()) {
sql=QString("select NAME from STATIONS where ")+
"NAME=\""+RDEscapeString(rd_config->stationName())+"\"";
q=new RDSqlQuery(sql);
if(!q->first()) {
if(RDStation::create(rd_config->stationName(),&err_msg,rd_config->provisioningHostTemplate(),rd_config->provisioningHostIpAddress())) {
RDApplication::syslog(rd_config,LOG_INFO,
"created new host entry \"%s\"",
(const char *)rd_config->stationName());
if(!rd_config->provisioningHostShortName(rd_config->stationName()).
isEmpty()) {
RDStation *station=new RDStation(rd_config->stationName());
station->setShortName(rd_config->
provisioningHostShortName(rd_config->stationName()));
delete station;
}
}
else {
fprintf(stderr,"caed: unable to provision host [%s]\n",
(const char *)err_msg);
exit(256);
}
}
delete q;
}
}
//
// Provision a Service
//
if(rd_config->provisioningCreateService()) {
if(!rd_config->provisioningServiceTemplate().isEmpty()) {
QString svcname=
rd_config->provisioningServiceName(rd_config->stationName());
sql=QString("select NAME from SERVICES where ")+
"NAME=\""+RDEscapeString(svcname)+"\"";
q=new RDSqlQuery(sql);
if(!q->first()) {
if(RDSvc::create(svcname,&err_msg,
rd_config->provisioningServiceTemplate(),rd_config)) {
RDApplication::syslog(rd_config,LOG_INFO,
"created new service entry \"%s\"",
(const char *)svcname);
}
else {
fprintf(stderr,"caed: unable to provision service [%s]\n",
(const char *)err_msg);
exit(256);
}
}
delete q;
}
}
}
void MainObject::InitMixers()
{
for(int i=0;i<RD_MAX_CARDS;i++) {
RDAudioPort *port=new RDAudioPort(rd_config->stationName(),i);
switch(cae_driver[i]) {
case RDStation::Hpi:
hpiSetClockSource(i,port->clockSource());
for(int j=0;j<RD_MAX_PORTS;j++) {
for(int k=0;k<RD_MAX_PORTS;k++) {
hpiSetPassthroughLevel(i,j,k,RD_MUTE_DEPTH);
}
if(port->inputPortType(j)==RDAudioPort::Analog) {
hpiSetInputType(i,j,RDCae::Analog);
}
else {
hpiSetInputType(i,j,RDCae::AesEbu);
}
hpiSetInputLevel(i,j,RD_BASE_ANALOG+port->inputPortLevel(j));
hpiSetOutputLevel(i,j,RD_BASE_ANALOG+port->outputPortLevel(j));
hpiSetInputMode(i,j,port->inputPortMode(j));
}
break;
case RDStation::Jack:
for(int j=0;j<RD_MAX_PORTS;j++) {
for(int k=0;k<RD_MAX_PORTS;k++) {
jackSetPassthroughLevel(i,j,k,RD_MUTE_DEPTH);
}
if(port->inputPortType(j)==RDAudioPort::Analog) {
jackSetInputType(i,j,RDCae::Analog);
}
else {
jackSetInputType(i,j,RDCae::AesEbu);
}
jackSetInputLevel(i,j,RD_BASE_ANALOG+port->inputPortLevel(j));
jackSetOutputLevel(i,j,RD_BASE_ANALOG+port->outputPortLevel(j));
jackSetInputMode(i,j,port->inputPortMode(j));
}
break;
case RDStation::Alsa:
for(int j=0;j<RD_MAX_PORTS;j++) {
for(int k=0;k<RD_MAX_PORTS;k++) {
alsaSetPassthroughLevel(i,j,k,RD_MUTE_DEPTH);
}
if(port->inputPortType(j)==RDAudioPort::Analog) {
alsaSetInputType(i,j,RDCae::Analog);
}
else {
alsaSetInputType(i,j,RDCae::AesEbu);
}
alsaSetInputLevel(i,j,RD_BASE_ANALOG+port->inputPortLevel(j));
alsaSetOutputLevel(i,j,RD_BASE_ANALOG+port->outputPortLevel(j));
alsaSetInputMode(i,j,port->inputPortMode(j));
}
break;
case RDStation::None:
break;
}
delete port;
}
}
void MainObject::KillSocket(int ch)
{
for(int i=0;i<RD_MAX_CARDS;i++) {
for(int j=0;j<RD_MAX_STREAMS;j++) {
if(record_owner[i][j]==ch) {
unsigned len=0;
switch(cae_driver[i]) {
case RDStation::Hpi:
hpiUnloadRecord(i,j,&len);
break;
case RDStation::Jack:
jackUnloadRecord(i,j,&len);
break;
case RDStation::Alsa:
alsaUnloadRecord(i,j,&len);
break;
default:
RDApplication::syslog(rd_config,LOG_DEBUG,
"tried to kill unowned socket!");
break;
}
record_length[i][j]=0;
record_threshold[i][j]=-10000;
record_owner[i][j]=-1;
}
if(play_owner[i][j]==ch) {
switch(cae_driver[i]) {
case RDStation::Hpi:
hpiUnloadPlayback(i,j);
break;
case RDStation::Jack:
jackUnloadPlayback(i,j);
break;
case RDStation::Alsa:
alsaUnloadPlayback(i,j);
break;
case RDStation::None:
break;
}
play_owner[i][j]=-1;
play_length[i][j]=0;
play_speed[i][j]=100;
play_pitch[i][j]=false;
}
}
for(int i=0;i<256;i++) {
if(play_handle[i].owner==ch) {
play_handle[i].card=-1;
play_handle[i].stream=-1;
play_handle[i].owner=-1;
}
}
}
}
pid_t MainObject::GetPid(QString pidfile)
{
FILE *handle;
pid_t ret;
if((handle=fopen((const char *)pidfile,"r"))==NULL) {
return -1;
}
if(fscanf(handle,"%d",&ret)!=1) {
ret=-1;
}
fclose(handle);
return ret;
}
bool MainObject::CheckDaemon(QString name)
{
QDir dir;
QString path;
path=QString(RD_PROC_DIR)+QString("/")+QString().sprintf("%d",GetPid(name));
dir.setPath(path);
return dir.exists();
}
int MainObject::GetNextHandle()
{
while(play_handle[next_play_handle].card>=0) {
next_play_handle++;
next_play_handle&=0xFF;
}
int handle=next_play_handle;
next_play_handle++;
next_play_handle&=0xFF;
return handle;
}
int MainObject::GetHandle(int card,int stream)
{
for(int i=0;i<256;i++) {
if((play_handle[i].card==card)&&(play_handle[i].stream==stream)) {
return i;
}
}
return -1;
}
void MainObject::ProbeCaps(RDStation *station)
{
//
// Patent-clear codecs
//
#ifdef HAVE_VORBIS
station->setHaveCapability(RDStation::HaveOggenc,true);
station->setHaveCapability(RDStation::HaveOgg123,true);
#else
station->setHaveCapability(RDStation::HaveOggenc,false);
station->setHaveCapability(RDStation::HaveOgg123,false);
#endif // HAVE_VORBIS
#ifdef HAVE_FLAC
station->setHaveCapability(RDStation::HaveFlac,true);
#else
station->setHaveCapability(RDStation::HaveFlac,false);
#endif // HAVE_FLAC
//
// MPEG Codecs
//
station->setHaveCapability(RDStation::HaveLame,CheckLame());
station->setHaveCapability(RDStation::HaveTwoLame,LoadTwoLame());
station->setHaveCapability(RDStation::HaveMpg321,LoadMad());
//
// MP4 Decoder
//
station->setHaveCapability(RDStation::HaveMp4Decode,CheckMp4Decode());
#ifdef HPI
station->setDriverVersion(RDStation::Hpi,hpiVersion());
#else
station->setDriverVersion(RDStation::Hpi,"[not enabled]");
#endif // HPI
#ifdef JACK
//
// FIXME: How can we detect the current JACK version?
//
station->setDriverVersion(RDStation::Jack,"Generic");
#else
station->setDriverVersion(RDStation::Jack,"");
#endif // JACK
#ifdef ALSA
station->setDriverVersion(RDStation::Alsa,
QString().sprintf("%d.%d.%d",
SND_LIB_MAJOR,
SND_LIB_MINOR,
SND_LIB_SUBMINOR));
#else
station->setDriverVersion(RDStation::Alsa,"");
#endif // ALSA
}
void MainObject::ClearDriverEntries(RDStation *station)
{
for(int i=0;i<RD_MAX_CARDS;i++) {
if(cae_driver[i]==RDStation::None) {
station->setCardDriver(i,RDStation::None);
station->setCardName(i,"");
station->setCardInputs(i,-1);
station->setCardOutputs(i,-1);
}
}
}
bool MainObject::CheckLame()
{
#ifdef HAVE_LAME
return dlopen("libmp3lame.so.0",RTLD_LAZY)!=NULL;
#else
return false;
#endif // HAVE_LAME
}
bool MainObject::CheckMp4Decode()
{
#ifdef HAVE_MP4_LIBS
return (dlopen("libfaad.so.2",RTLD_LAZY)!=NULL)&&
(dlopen("libmp4v2.so.2",RTLD_LAZY)!=NULL);
#else
return false;
#endif // HAVE_MP4_LIBS
}
bool MainObject::LoadTwoLame()
{
#ifdef HAVE_TWOLAME
if((twolame_handle=dlopen("libtwolame.so.0",RTLD_NOW))==NULL) {
RDApplication::syslog(rd_config,LOG_INFO,
"TwoLAME encoder library not found, MPEG L2 encoding not supported");
return false;
}
*(void **)(&twolame_init)=dlsym(twolame_handle,"twolame_init");
*(void **)(&twolame_set_mode)=dlsym(twolame_handle,"twolame_set_mode");
*(void **)(&twolame_set_num_channels)=
dlsym(twolame_handle,"twolame_set_num_channels");
*(void **)(&twolame_set_in_samplerate)=
dlsym(twolame_handle,"twolame_set_in_samplerate");
*(void **)(&twolame_set_out_samplerate)=
dlsym(twolame_handle,"twolame_set_out_samplerate");
*(void **)(&twolame_set_bitrate)=
dlsym(twolame_handle,"twolame_set_bitrate");
*(void **)(&twolame_init_params)=
dlsym(twolame_handle,"twolame_init_params");
*(void **)(&twolame_close)=dlsym(twolame_handle,"twolame_close");
*(void **)(&twolame_encode_buffer_interleaved)=
dlsym(twolame_handle,"twolame_encode_buffer_interleaved");
*(void **)(&twolame_encode_buffer_float32_interleaved)=
dlsym(twolame_handle,"twolame_encode_buffer_float32_interleaved");
*(void **)(&twolame_encode_flush)=
dlsym(twolame_handle,"twolame_encode_flush");
*(void **)(&twolame_set_energy_levels)=
dlsym(twolame_handle,"twolame_set_energy_levels");
RDApplication::syslog(rd_config,LOG_INFO,
"Found TwoLAME encoder library, MPEG L2 encoding supported");
return true;
#else
RDApplication::syslog(rd_config,LOG_INFO,"MPEG L2 encoding not enabled");
return false;
#endif // HAVE_TWOLAME
}
bool MainObject::InitTwoLameEncoder(int card,int stream,int chans,int samprate,
int bitrate)
{
#ifdef HAVE_TWOLAME
TWOLAME_MPEG_mode mpeg_mode=TWOLAME_STEREO;
switch(chans) {
case 1:
mpeg_mode=TWOLAME_MONO;
break;
case 2:
mpeg_mode=TWOLAME_STEREO;
break;
}
if((twolame_lameopts[card][stream]=twolame_init())==NULL) {
RDApplication::syslog(rd_config,LOG_WARNING,
"unable to initialize twolame instance, card=%d, stream=%d",
card,stream);
return false;
}
twolame_set_mode(twolame_lameopts[card][stream],mpeg_mode);
twolame_set_num_channels(twolame_lameopts[card][stream],chans);
twolame_set_in_samplerate(twolame_lameopts[card][stream],samprate);
twolame_set_out_samplerate(twolame_lameopts[card][stream],samprate);
twolame_set_bitrate(twolame_lameopts[card][stream],bitrate/1000);
twolame_set_energy_levels(twolame_lameopts[card][stream],1);
if(twolame_init_params(twolame_lameopts[card][stream])!=0) {
RDApplication::syslog(rd_config,LOG_WARNING,
"invalid twolame parameters, card=%d, stream=%d, chans=%d, samprate=%d bitrate=%d",
card,stream,chans,samprate,bitrate);
return false;
}
return true;
#else
return false;
#endif // HAVE_TWOLAME
}
void MainObject::FreeTwoLameEncoder(int card,int stream)
{
#ifdef HAVE_TWOLAME
if(twolame_lameopts[card][stream]!=NULL) {
twolame_close(&twolame_lameopts[card][stream]);
twolame_lameopts[card][stream]=NULL;
}
#endif // HAVE_TWOLAME
}
bool MainObject::LoadMad()
{
#ifdef HAVE_MAD
if((mad_handle=dlopen("libmad.so.0",RTLD_NOW))==NULL) {
RDApplication::syslog(rd_config,LOG_INFO,
"MAD decoder library not found, MPEG L2 decoding not supported");
return false;
}
*(void **)(&mad_stream_init)=
dlsym(mad_handle,"mad_stream_init");
*(void **)(&mad_frame_init)=
dlsym(mad_handle,"mad_frame_init");
*(void **)(&mad_synth_init)=
dlsym(mad_handle,"mad_synth_init");
*(void **)(&mad_stream_buffer)=
dlsym(mad_handle,"mad_stream_buffer");
*(void **)(&mad_frame_decode)=
dlsym(mad_handle,"mad_frame_decode");
*(void **)(&mad_synth_frame)=
dlsym(mad_handle,"mad_synth_frame");
*(void **)(&mad_frame_finish)=
dlsym(mad_handle,"mad_frame_finish");
*(void **)(&mad_stream_finish)=
dlsym(mad_handle,"mad_stream_finish");
RDApplication::syslog(rd_config,LOG_INFO,
"Found MAD decoder library, MPEG L2 decoding supported");
return true;
#else
RDApplication::syslog(rd_config,LOG_INFO,"MPEG L2 decoding not enabled");
return false;
#endif // HAVE_MAD
}
void MainObject::InitMadDecoder(int card,int stream,RDWaveFile *wave)
{
#ifdef HAVE_MAD
if(mad_active[card][stream]) {
FreeMadDecoder(card,stream);
}
mad_stream_init(&mad_stream[card][stream]);
mad_frame_init(&mad_frame[card][stream]);
mad_synth_init(&mad_synth[card][stream]);
mad_frame_size[card][stream]=
144*wave->getHeadBitRate()/wave->getSamplesPerSec();
mad_left_over[card][stream]=0;
mad_active[card][stream]=true;
#endif // HAVE_MAD
}
void MainObject::FreeMadDecoder(int card,int stream)
{
#ifdef HAVE_MAD
if(mad_active[card][stream]) {
mad_synth_finish(&mad_synth[card][stream]);
mad_frame_finish(&mad_frame[card][stream]);
mad_stream_finish(&mad_stream[card][stream]);
mad_frame_size[card][stream]=0;
mad_left_over[card][stream]=0;
mad_active[card][stream]=false;
}
#endif // HAVE_MAD
}
void MainObject::SendMeterLevelUpdate(const QString &type,int cardnum,
int portnum,short levels[])
{
QList<int> ids=cae_server->connectionIds();
for(int l=0;l<ids.size();l++) {
if((cae_server->meterPort(ids.at(l))>0)&&
cae_server->metersEnabled(ids.at(l),cardnum)) {
SendMeterUpdate(QString().sprintf("ML %s %d %d %d %d",
(const char *)type,cardnum,portnum,levels[0],levels[1]),
ids.at(l));
}
}
}
void MainObject::SendStreamMeterLevelUpdate(int cardnum,int streamnum,
short levels[])
{
QList<int> ids=cae_server->connectionIds();
for(int l=0;l<ids.size();l++) {
if((cae_server->meterPort(ids.at(l))>0)&&
cae_server->metersEnabled(ids.at(l),cardnum)) {
SendMeterUpdate(QString().sprintf("MO %d %d %d %d",
cardnum,streamnum,levels[0],levels[1]),ids.at(l));
}
}
}
void MainObject::SendMeterPositionUpdate(int cardnum,unsigned pos[])
{
QList<int> ids=cae_server->connectionIds();
for(unsigned k=0;k<RD_MAX_STREAMS;k++) {
for(int l=0;l<ids.size();l++) {
if((cae_server->meterPort(ids.at(l))>0)&&
cae_server->metersEnabled(ids.at(l),cardnum)) {
SendMeterUpdate(QString().sprintf("MP %d %d %d",cardnum,k,pos[k]),
ids.at(l));
}
}
}
}
void MainObject::SendMeterOutputStatusUpdate()
{
QList<int> ids=cae_server->connectionIds();
for(unsigned i=0;i<RD_MAX_CARDS;i++) {
if(cae_driver[i]!=RDStation::None) {
for(unsigned j=0;j<RD_MAX_PORTS;j++) {
for(unsigned k=0;k<RD_MAX_STREAMS;k++) {
for(int l=0;l<ids.size();l++) {
if((cae_server->meterPort(ids.at(l))>0)&&
cae_server->metersEnabled(ids.at(l),i)) {
SendMeterUpdate(QString().sprintf("MS %d %d %d %d",i,j,k,
output_status_flag[i][j][k]),ids.at(l));
}
}
}
}
}
}
}
void MainObject::SendMeterOutputStatusUpdate(int card,int port,int stream)
{
QList<int> ids=cae_server->connectionIds();
for(int l=0;l<ids.size();l++) {
if((cae_server->meterPort(ids.at(l))>0)&&
cae_server->metersEnabled(ids.at(l),card)) {
SendMeterUpdate(QString().sprintf("MS %d %d %d %d",card,port,stream,
output_status_flag[card][port][stream]),ids.at(l));
}
}
}
void MainObject::SendMeterUpdate(const QString &msg,int conn_id)
{
meter_socket->writeDatagram(msg,msg.length(),cae_server->peerAddress(conn_id),
cae_server->meterPort(conn_id));
}
int main(int argc,char *argv[])
{
int rc;
QCoreApplication a(argc,argv,false);
new MainObject(NULL,"main");
rc=a.exec();
RDApplication::syslog(rd_config,LOG_DEBUG,"cae post a.exec() rc: %d",rc);
return rc;
}
Reference in New Issue View Git Blame Copy Permalink