int main(void) {
// open file
FILE *fp;
fp = fopen("1.txt","wb");
if(fp== NULL)
exit(-1);
//--------------
int aPin = open(ADEV, O_RDONLY);
char tBuf[16];
//
int startime = gettimestamp() ;
for (int i = 0; i < numsample;i++)
{
lseek(aPin, 0 , SEEK_SET);
int ret = read(aPin,tBuf,sizeof(tBuf));
int aVal = atoi(tBuf+5) ;
data[i] = aVal*3.3/4095;
}
int stoptime = gettimestamp();
// Write to file
for (int i = 0; i < numsample;i++)
{
fprintf(fp,"%f\n", data[i]);
}
printf("1000 samples in %d millis\n", stoptime - startime);
fclose(fp);
}
/* function called every frame. Use GlobalObjects::lastTimeFrame */
void Test::update()
{
static double t1,t2,t3,t4;
static bool keyPres = false;
static bool runSim = false;
if(GLOBAL_KEYBOARD->isKeyDown(OIS::KC_SPACE)){
if(!keyPres){
keyPres = true;
runSim = runSim ? false : true;
std::cout << "Now runSim is: " << runSim << std::endl;
}
} else {
keyPres = false;
}
t1 = gettimestamp();
t3 = t2 - t1;
if (runSim) {
/* Specify the global time step of the simulation. */
sim->setTimeStep(GLOBAL_TIME_FRAME * 10.0f);
sim->doStep();
/* Output the current position of all the agents. */
for (size_t i = 0; i < sim->getNumAgents(); ++i) {
mUnits[i].updatePosition(sim->getAgentPosition(i));
}
// setPreferredVelocities(sim);
} else {
for(int i = mUnits.size()-1; i >=0; --i){
mUnits[i].updatePosition(mUnits[i].node->getPosition() +
Ogre::Vector3(1.0,0,0));
}
}
t2 = gettimestamp();
if(GLOBAL_KEYBOARD->isKeyDown(OIS::KC_P)){
if(!keyPres){
keyPres = true;
std::cout << "Printing Times:\n" <<
"LastFrameTime: " << GLOBAL_TIME_FRAME << "\n" <<
"Time of sim: " << t2 - t1 << "\n" <<
"Time of rendering and more: " << t3 << std::endl;
}
} else {
keyPres = false;
}
}
/* delay(milliseconds)
* Pauses for (at least) the requested number of milliseconds.
*/
static cell AMX_NATIVE_CALL n_delay(AMX *amx, const cell *params)
{
unsigned long stamp;
(void)amx;
assert(params[0]==(int)sizeof(cell));
INIT_TIMER();
stamp=gettimestamp();
while (gettimestamp()-stamp < (unsigned long)params[1])
/* nothing */;
return 0;
}
void *io_thread_a2dp_source_sbc(void *arg) {
struct ba_transport *t = (struct ba_transport *)arg;
while ((t->a2dp.pcm.fd = open(t->a2dp.pcm.fifo, O_RDONLY)) == -1)
usleep(10000);
int16_t buffer[1024 * 2];
ssize_t samples;
struct io_sync io_sync = {
.sampling = transport_get_sampling(t),
};
for (;;) {
fprintf(stderr, ".");
if (io_sync.frames == 0) {
gettimestamp(&io_sync.ts);
io_sync.ts0 = io_sync.ts;
}
const size_t in_samples = sizeof(buffer) / sizeof(int16_t);
if ((samples = io_thread_read_pcm(&t->a2dp.pcm, buffer, in_samples)) <= 0) {
if (samples == -1)
error("FIFO read error: %s", strerror(errno));
break;
}
io_thread_time_sync(&io_sync, samples / 2);
}
return NULL;
}
void demo_init(void) {
int i;
//some default values
for (i = 0; i < ALARMS; i++) {
g_settings.alarmHour[i] = 8;
g_settings.alarmMinute[i] = 0+i*5;
g_settings.alarmWeekdays[i] = 0x7F;
}
g_settings.timerMinutes = 5;
g_settings.brightnessAuto = 1;
g_settings.brightness = 70;
g_settings.clockShowSeconds = 1;
g_settings.soundAutoOffMinutes = 10;
g_settings.soundVolume = 20;
g_settings.soundFrequency = 500;
g_settings.displayRefresh = 100;
g_settings.batteryCapacity = 1000;
g_settings.currentResCal = CURRENTRESCAL_NORMAL;
g_settings.consumptionLedOneMax = CONSUMPTIONLEDONEMAX_NORMAL;
g_settings.dcf77Level = DCF77LEVEL_NORMAL;
g_state.time = gettimestamp();
g_state.timescache = g_state.time % 60;
g_state.timemcache = (g_state.time / 60) % 60;
g_state.timehcache = (g_state.time / (60*60)) % 24;
g_state.ldr = 2048;
g_state.brightnessLdr = 100;
g_state.keyDebugAd = 700;
g_state.gradcelsius10 = 123; //[1/10°C]
g_state.chargerCurrent = 10;
g_state.batteryCharged = 100*60*60; //100mAh
g_state.batVoltage = 3300;
g_state.performanceRcRunning = 100;
g_state.performanceCpuRunning = 25;
}
static int read_line(void)
{
const char** p;
int matches;
if (!ibuf_getstr(&inbuf, &last_line.line, LF)) {
exitasap = exitoneof || seq_next == seq_send;
if (!ibuf_eof(&inbuf))
error1sys("Could not read line from stdin");
stdin_eof = 1;
return 0;
}
--last_line.line.len; /* Strip off the trailing LF */
if (patterns != 0) {
matches = 1;
for (p = patterns; *p != 0; ++p) {
if (str_matchs(&last_line.line, (*p)+1))
matches = **p == '+';
}
if (!matches) return 0;
}
gettimestamp(&last_line.timestamp);
SET_SEQ(last_line.seq = seq_next++);
if (last_line.line.len > MAX_LINE) {
str_rcut(&last_line.line, last_line.line.len - MAX_LINE);
memcpy(last_line.line.s + MAX_LINE - 17, "[...truncated...]", 17);
}
buffer->push(&last_line);
return 1;
}
void set_Arm (unsigned char mode)
{
#ifdef CMM_ARM_EXPERIMENT
unsigned long cur_pos;
unsigned char old_mode;
unsigned char pct_deployed;
get_ArmPosition(&cur_pos, &old_mode);
if (mode == old_mode) return;
if (old_mode != ARM_STOP)
{
if (cur_pos != arm_pos)
{
pct_deployed = cur_pos / ARM_STROKE_PCT;
#ifdef ARM_POS_DEBUG
DBG("Arm moved ");
if (cur_pos > arm_pos)
DBG2("+%lu", cur_pos - arm_pos);
else
DBG2("-%lu", arm_pos - cur_pos);
DBG3(" to %lu (%lu)\n", cur_pos, pct_deployed);
#endif
arm_pos = cur_pos;
}
}
else
{
pct_deployed = cur_pos / ARM_STROKE_PCT;
}
if (mode != ARM_STOP) gettimestamp(&arm_start);
#endif
switch (mode) {
default:
case ARM_STOP:
ARM(LAT) &= ~(ARM_UPDOWN_MASK | ARM_ONOFF_MASK);
break;
case ARM_UP:
ARM(LAT) &= ~ARM_UPDOWN_MASK;
ARM(LAT) |= ARM_ONOFF_MASK;
break;
case ARM_DOWN:
ARM(LAT) |= ARM_UPDOWN_MASK;
ARM(LAT) |= ARM_ONOFF_MASK;
break;
}
#ifdef CMM_ARM_EXPERIMENT
// % deployed in lower bits, mode in upper bits
eventlog_track(EVENTLOG_ARM, (((uint16_t)pct_deployed) << 8) | mode);
#else
eventlog_track(EVENTLOG_ARM, mode);
#endif
}
/* settimer(milliseconds, bool: singleshot = false)
* Sets the delay until the @timer() callback is called. The timer may either
* be single-shot or repetitive.
*/
static cell AMX_NATIVE_CALL n_settimer(AMX *amx, const cell *params)
{
(void)amx;
assert(params[0]==(int)(2*sizeof(cell)));
timestamp=gettimestamp();
timelimit=params[1];
timerepeat=(int)(params[2]==0);
return 0;
}
/* function called every frame. Use GlobalObjects::lastTimeFrame */
void Test::update()
{
handleInput();
static double t1,t2,t3,t4;
static bool keyPres = false;
sm::Vector2 p;
t1 = gettimestamp();
t3 = t2 - t1;
// update the game objects
sm::Vector2 trans;
ZombieUnit *zu;
for(int i = mZombies.size()-1; i>= 0; --i){
mZombies[i]->update();
}
for(int i = mPlayers.size()-1; i>= 0; --i){
mPlayers[i]->update();
}
for(int i = mCivils.size()-1; i>= 0; --i){
mCivils[i]->update();
}
t2 = gettimestamp();
if (GLOBAL_KEYBOARD->isKeyDown(OIS::KC_P)) {
if (!keyPres) {
keyPres = true;
std::cout << "Printing Times:\n" << "LastFrameTime: "
<< GLOBAL_TIME_FRAME << "\n" << "Time of sim: " << t2 - t1
<< "\n" << "Time of rendering and more: " << t3
<< std::endl;
std::cout << mBodySceneNode->getPosition().x << "\t" <<
mBodySceneNode->getPosition().z << std::endl;
}
} else {
keyPres = false;
}
mUpdMngr.updateAllObjects();
}
/**
* Synchronize thread timing with the audio sampling frequency.
*
* Time synchronization relies on the frame counter being linear. This counter
* should be initialized upon transfer start and resume. With the size of this
* counter being 32 bits, it is possible to track up to ~24 hours of playback,
* with the sampling rate of 48 kHz. If this is insufficient, one can switch
* to 64 bits, which would be sufficient to play for 12 million years. */
static int io_thread_time_sync(struct io_sync *io_sync, uint32_t frames) {
const uint16_t sampling = io_sync->sampling;
struct timespec ts_audio;
struct timespec ts_clock;
struct timespec ts;
if (sampling == 0)
return 0;
/* calculate the playback duration of given frames */
unsigned int sec = frames / sampling;
unsigned int res = frames % sampling;
int duration = 1000000 * sec + 1000000 / sampling * res;
io_sync->frames += frames;
frames = io_sync->frames;
/* keep transfer 10ms ahead */
unsigned int overframes = sampling / 100;
frames = frames > overframes ? frames - overframes : 0;
ts_audio.tv_sec = frames / sampling;
ts_audio.tv_nsec = 1000000000 / sampling * (frames % sampling);
gettimestamp(&ts_clock);
/* Calculate delay since the last sync. Note, that we are not taking whole
* seconds into account, because if the delay is greater than one second,
* we are screwed anyway... */
difftimespec(&io_sync->ts, &ts_clock, &ts);
io_sync->delay = ts.tv_nsec / 100000;
/* maintain constant bit rate */
difftimespec(&io_sync->ts0, &ts_clock, &ts_clock);
if (difftimespec(&ts_clock, &ts_audio, &ts) > 0)
nanosleep(&ts, NULL);
gettimestamp(&io_sync->ts);
return duration;
}
static int snd_pcm_ioplug_drop(snd_pcm_t *pcm)
{
ioplug_priv_t *io = pcm->private_data;
if (io->data->state == SND_PCM_STATE_OPEN)
return -EBADFD;
io->data->callback->stop(io->data);
gettimestamp(&io->trigger_tstamp, pcm->monotonic);
io->data->state = SND_PCM_STATE_SETUP;
return 0;
}
/*
* synchronize hardware pointer (hw_ptr) with ours
*/
static int snd_pcm_dshare_sync_ptr(snd_pcm_t *pcm)
{
snd_pcm_direct_t *dshare = pcm->private_data;
snd_pcm_uframes_t slave_hw_ptr, old_slave_hw_ptr, avail;
snd_pcm_sframes_t diff;
switch (snd_pcm_state(dshare->spcm)) {
case SND_PCM_STATE_DISCONNECTED:
dshare->state = SNDRV_PCM_STATE_DISCONNECTED;
return -ENODEV;
default:
break;
}
if (dshare->slowptr)
snd_pcm_hwsync(dshare->spcm);
old_slave_hw_ptr = dshare->slave_hw_ptr;
slave_hw_ptr = dshare->slave_hw_ptr = *dshare->spcm->hw.ptr;
diff = slave_hw_ptr - old_slave_hw_ptr;
if (diff == 0) /* fast path */
return 0;
if (dshare->state != SND_PCM_STATE_RUNNING &&
dshare->state != SND_PCM_STATE_DRAINING)
/* not really started yet - don't update hw_ptr */
return 0;
if (diff < 0) {
slave_hw_ptr += dshare->slave_boundary;
diff = slave_hw_ptr - old_slave_hw_ptr;
}
dshare->hw_ptr += diff;
dshare->hw_ptr %= pcm->boundary;
// printf("sync ptr diff = %li\n", diff);
if (pcm->stop_threshold >= pcm->boundary) /* don't care */
return 0;
avail = snd_pcm_mmap_playback_avail(pcm);
if (avail > dshare->avail_max)
dshare->avail_max = avail;
if (avail >= pcm->stop_threshold) {
snd_timer_stop(dshare->timer);
gettimestamp(&dshare->trigger_tstamp, pcm->monotonic);
if (dshare->state == SND_PCM_STATE_RUNNING) {
dshare->state = SND_PCM_STATE_XRUN;
return -EPIPE;
}
dshare->state = SND_PCM_STATE_SETUP;
/* clear queue to remove pending poll events */
snd_pcm_direct_clear_timer_queue(dshare);
}
return 0;
}
/* tickcount(&granularity)
* Returns the number of milliseconds since start-up. For a 32-bit cell, this
* count overflows after approximately 24 days of continuous operation.
*/
static cell AMX_NATIVE_CALL n_tickcount(AMX *amx, const cell *params)
{
cell *cptr;
assert(params[0]==(int)sizeof(cell));
INIT_TIMER();
cptr=amx_Address(amx,params[1]);
#if defined __WIN32__ || defined _WIN32 || defined WIN32
*cptr=1000; /* granularity = 1 ms */
#else
*cptr=(cell)CLOCKS_PER_SEC; /* in Unix/Linux, this is often 100 */
#endif
return gettimestamp() & 0x7fffffff;
}
static int snd_pcm_ioplug_start(snd_pcm_t *pcm)
{
ioplug_priv_t *io = pcm->private_data;
int err;
if (io->data->state != SND_PCM_STATE_PREPARED)
return -EBADFD;
err = io->data->callback->start(io->data);
if (err < 0)
return err;
gettimestamp(&io->trigger_tstamp, pcm->monotonic);
io->data->state = SND_PCM_STATE_RUNNING;
return 0;
}
/* stand-alone version - similar like snd_pcm_hw_htimestamp but
* taking the tstamp via gettimestamp().
*/
int snd_pcm_generic_real_htimestamp(snd_pcm_t *pcm, snd_pcm_uframes_t *avail,
snd_htimestamp_t *tstamp)
{
snd_pcm_sframes_t avail1;
int ok = 0;
while (1) {
avail1 = snd_pcm_avail_update(pcm);
if (avail1 < 0)
return avail1;
if (ok && (snd_pcm_uframes_t)avail1 == *avail)
break;
*avail = avail1;
gettimestamp(tstamp, pcm->tstamp_type);
ok = 1;
}
return 0;
}
/*
* synchronize hardware pointer (hw_ptr) with ours
*/
static int snd_pcm_dsnoop_sync_ptr(snd_pcm_t *pcm)
{
snd_pcm_direct_t *dsnoop = pcm->private_data;
snd_pcm_uframes_t slave_hw_ptr, old_slave_hw_ptr, avail;
snd_pcm_sframes_t diff;
switch (snd_pcm_state(dsnoop->spcm)) {
case SND_PCM_STATE_DISCONNECTED:
dsnoop->state = SNDRV_PCM_STATE_DISCONNECTED;
return -ENODEV;
default:
break;
}
if (dsnoop->slowptr)
snd_pcm_hwsync(dsnoop->spcm);
old_slave_hw_ptr = dsnoop->slave_hw_ptr;
snoop_timestamp(pcm);
slave_hw_ptr = dsnoop->slave_hw_ptr;
diff = slave_hw_ptr - old_slave_hw_ptr;
if (diff == 0) /* fast path */
return 0;
if (diff < 0) {
slave_hw_ptr += dsnoop->slave_boundary;
diff = slave_hw_ptr - old_slave_hw_ptr;
}
snd_pcm_dsnoop_sync_area(pcm, old_slave_hw_ptr, diff);
dsnoop->hw_ptr += diff;
dsnoop->hw_ptr %= pcm->boundary;
// printf("sync ptr diff = %li\n", diff);
if (pcm->stop_threshold >= pcm->boundary) /* don't care */
return 0;
if ((avail = snd_pcm_mmap_capture_hw_avail(pcm)) >= pcm->stop_threshold) {
gettimestamp(&dsnoop->trigger_tstamp, pcm->monotonic);
dsnoop->state = SND_PCM_STATE_XRUN;
dsnoop->avail_max = avail;
return -EPIPE;
}
if (avail > dsnoop->avail_max)
dsnoop->avail_max = avail;
return 0;
}
/*
* synchronize hardware pointer (hw_ptr) with ours
*/
static int snd_pcm_dshare_sync_ptr0(snd_pcm_t *pcm, snd_pcm_uframes_t slave_hw_ptr)
{
snd_pcm_direct_t *dshare = pcm->private_data;
snd_pcm_uframes_t old_slave_hw_ptr, avail;
snd_pcm_sframes_t diff;
old_slave_hw_ptr = dshare->slave_hw_ptr;
dshare->slave_hw_ptr = slave_hw_ptr;
diff = slave_hw_ptr - old_slave_hw_ptr;
if (diff == 0) /* fast path */
return 0;
if (dshare->state != SND_PCM_STATE_RUNNING &&
dshare->state != SND_PCM_STATE_DRAINING)
/* not really started yet - don't update hw_ptr */
return 0;
if (diff < 0) {
slave_hw_ptr += dshare->slave_boundary;
diff = slave_hw_ptr - old_slave_hw_ptr;
}
dshare->hw_ptr += diff;
dshare->hw_ptr %= pcm->boundary;
// printf("sync ptr diff = %li\n", diff);
if (pcm->stop_threshold >= pcm->boundary) /* don't care */
return 0;
avail = snd_pcm_mmap_playback_avail(pcm);
if (avail > dshare->avail_max)
dshare->avail_max = avail;
if (avail >= pcm->stop_threshold) {
snd_timer_stop(dshare->timer);
do_silence(pcm);
gettimestamp(&dshare->trigger_tstamp, pcm->tstamp_type);
if (dshare->state == SND_PCM_STATE_RUNNING) {
dshare->state = SND_PCM_STATE_XRUN;
return -EPIPE;
}
dshare->state = SND_PCM_STATE_SETUP;
/* clear queue to remove pending poll events */
snd_pcm_direct_clear_timer_queue(dshare);
}
return 0;
}
static int AMXAPI amx_TimeIdle(AMX *amx, int AMXAPI Exec(AMX *, cell *, int))
{
int err=0;
assert(idxTimer >= 0);
if (PrevIdle != NULL)
PrevIdle(amx, Exec);
if (timelimit>0 && (gettimestamp()-timestamp)>=timelimit) {
if (timerepeat)
timestamp+=timelimit;
else
timelimit=0; /* do not repeat single-shot timer */
err = Exec(amx, NULL, idxTimer);
while (err == AMX_ERR_SLEEP)
err = Exec(amx, NULL, AMX_EXEC_CONT);
} /* if */
return err;
}
static int snd_pcm_dmix_start(snd_pcm_t *pcm)
{
snd_pcm_direct_t *dmix = pcm->private_data;
snd_pcm_sframes_t avail;
int err;
if (dmix->state != SND_PCM_STATE_PREPARED)
return -EBADFD;
avail = snd_pcm_mmap_playback_hw_avail(pcm);
if (avail == 0)
dmix->state = STATE_RUN_PENDING;
else if (avail < 0)
return 0;
else {
if ((err = snd_pcm_dmix_start_timer(pcm, dmix)) < 0)
return err;
snd_pcm_dmix_sync_area(pcm);
}
gettimestamp(&dmix->trigger_tstamp, pcm->tstamp_type);
return 0;
}
void get_ArmPosition (unsigned long *pos, unsigned char *mode)
{
struct timer now;
unsigned long diff;
gettimestamp(&now);
*mode = get_Arm();
diff = timestampdiff(&now, &arm_start);
if (*mode == ARM_DOWN)
{
*pos = arm_pos + diff; // TBD: Overflow?
if (*pos > ARM_STROKE) *pos = ARM_STROKE;
}
else if (*mode == ARM_UP)
{
*pos = (diff > arm_pos) ? 0 : (arm_pos - diff);
}
else
*pos = arm_pos;
}
static int snd_pcm_dmix_status(snd_pcm_t *pcm, snd_pcm_status_t * status)
{
snd_pcm_direct_t *dmix = pcm->private_data;
switch (dmix->state) {
case SNDRV_PCM_STATE_DRAINING:
case SNDRV_PCM_STATE_RUNNING:
snd_pcm_dmix_sync_ptr(pcm);
break;
default:
break;
}
memset(status, 0, sizeof(*status));
status->state = snd_pcm_dmix_state(pcm);
status->trigger_tstamp = dmix->trigger_tstamp;
gettimestamp(&status->tstamp, pcm->monotonic);
status->avail = snd_pcm_mmap_playback_avail(pcm);
status->avail_max = status->avail > dmix->avail_max ? status->avail : dmix->avail_max;
dmix->avail_max = 0;
return 0;
}
void *io_thread_a2dp_sink_sbc(void *arg) {
struct ba_transport *t = (struct ba_transport *)arg;
int16_t *head = (int16_t *)drum_buffer;
int16_t *end = head + drum_buffer_size / sizeof(int16_t);
struct sigaction sigact = { .sa_handler = SIG_IGN };
sigaction(SIGPIPE, &sigact, NULL);
struct io_sync io_sync = {
.sampling = transport_get_sampling(t),
};
for (;;) {
if (io_thread_open_pcm_write(&t->a2dp.pcm) == -1) {
if (errno != ENXIO)
error("Couldn't open FIFO: %s", strerror(errno));
usleep(10000);
continue;
}
fprintf(stderr, ".");
if (io_sync.frames == 0)
gettimestamp(&io_sync.ts0);
if (head == end)
head = (int16_t *)drum_buffer;
size_t samples = head + 512 > end ? end - head : 512;
if (io_thread_write_pcm(&t->a2dp.pcm, head, samples) == -1)
error("FIFO write error: %s", strerror(errno));
head += samples;
io_thread_time_sync(&io_sync, samples / 2);
}
return NULL;
}
static void make_ini(const struct key* key, const struct line* line)
{
const struct timestamp* ts;
struct timestamp now;
pkt_start(&packet, INI1);
pkt_add_u8(&packet, seq_send);
if (line == 0) {
gettimestamp(&now);
ts = &now;
}
else
ts = &line->timestamp;
pkt_add_ts(&packet, ts);
pkt_add_s1c(&packet, sender);
pkt_add_s1c(&packet, service);
pkt_add_s1c(&packet, AUTHENTICATOR_NAME);
pkt_add_s1c(&packet, keyex->name);
pkt_add_s1c(&packet, KEYHASH_NAME);
pkt_add_s1c(&packet, ENCRYPTOR_NAME);
pkt_add_s1c(&packet, "null");
pkt_add_key(&packet, key);
pkt_add_cc(&packet, &ini_authenticator);
}
/*
* the new order transaction
*/
int neword( int t_num,
int w_id_arg, /* warehouse id */
int d_id_arg, /* district id */
int c_id_arg, /* customer id */
int o_ol_cnt_arg, /* number of items */
int o_all_local_arg, /* are all order lines local */
int itemid[], /* ids of items to be ordered */
int supware[], /* warehouses supplying items */
int qty[] /* quantity of each item */
)
{
int w_id = w_id_arg;
int d_id = d_id_arg;
int c_id = c_id_arg;
int o_ol_cnt = o_ol_cnt_arg;
int o_all_local = o_all_local_arg;
float c_discount;
char c_last[17];
char c_credit[3];
float w_tax;
int d_next_o_id;
float d_tax;
char datetime[81];
int o_id;
char i_name[25];
float i_price;
char i_data[51];
int ol_i_id;
int s_quantity;
char s_data[51];
char s_dist_01[25];
char s_dist_02[25];
char s_dist_03[25];
char s_dist_04[25];
char s_dist_05[25];
char s_dist_06[25];
char s_dist_07[25];
char s_dist_08[25];
char s_dist_09[25];
char s_dist_10[25];
char ol_dist_info[25];
int ol_supply_w_id;
float ol_amount;
int ol_number;
int ol_quantity;
char iname[MAX_NUM_ITEMS][MAX_ITEM_LEN];
char bg[MAX_NUM_ITEMS];
float amt[MAX_NUM_ITEMS];
float price[MAX_NUM_ITEMS];
int stock[MAX_NUM_ITEMS];
float total = 0.0;
int min_num;
int i,j,tmp,swp;
int ol_num_seq[MAX_NUM_ITEMS];
int proceed = 0;
MYSQL_STMT* mysql_stmt;
MYSQL_BIND param[9];
MYSQL_BIND column[12];
/* EXEC SQL WHENEVER NOT FOUND GOTO sqlerr;*/
/* EXEC SQL WHENEVER SQLERROR GOTO sqlerr;*/
/*EXEC SQL CONTEXT USE :ctx[t_num];*/
gettimestamp(datetime, STRFTIME_FORMAT, TIMESTAMP_LEN);
proceed = 1;
/*EXEC_SQL SELECT c_discount, c_last, c_credit, w_tax
INTO :c_discount, :c_last, :c_credit, :w_tax
FROM customer, warehouse
WHERE w_id = :w_id
AND c_w_id = w_id
AND c_d_id = :d_id
AND c_id = :c_id;*/
mysql_stmt = stmt[t_num][0];
memset(param, 0, sizeof(MYSQL_BIND) * 3); /* initialize */
param[0].buffer_type = MYSQL_TYPE_LONG;
param[0].buffer = &w_id;
param[1].buffer_type = MYSQL_TYPE_LONG;
param[1].buffer = &d_id;
param[2].buffer_type = MYSQL_TYPE_LONG;
param[2].buffer = &c_id;
if( mysql_stmt_bind_param(mysql_stmt, param) ) goto sqlerr;
if( mysql_stmt_execute(mysql_stmt) ) goto sqlerr;
if( mysql_stmt_store_result(mysql_stmt) ) goto sqlerr;
memset(column, 0, sizeof(MYSQL_BIND) * 4); /* initialize */
column[0].buffer_type = MYSQL_TYPE_FLOAT;
column[0].buffer = &c_discount;
column[1].buffer_type = MYSQL_TYPE_STRING;
column[1].buffer = c_last;
column[1].buffer_length = sizeof(c_last);
column[2].buffer_type = MYSQL_TYPE_STRING;
column[2].buffer = c_credit;
column[2].buffer_length = sizeof(c_credit);
column[3].buffer_type = MYSQL_TYPE_FLOAT;
column[3].buffer = &w_tax;
if( mysql_stmt_bind_result(mysql_stmt, column) ) goto sqlerr;
switch( mysql_stmt_fetch(mysql_stmt) ) {
case 0: //SUCCESS
case MYSQL_DATA_TRUNCATED:
break;
case 1: //ERROR
case MYSQL_NO_DATA: //NO MORE DATA
default:
mysql_stmt_free_result(mysql_stmt);
goto sqlerr;
}
mysql_stmt_free_result(mysql_stmt);
#ifdef DEBUG
printf("n %d\n",proceed);
#endif
proceed = 2;
/*EXEC_SQL SELECT d_next_o_id, d_tax INTO :d_next_o_id, :d_tax
FROM district
WHERE d_id = :d_id
AND d_w_id = :w_id
FOR UPDATE;*/
mysql_stmt = stmt[t_num][1];
memset(param, 0, sizeof(MYSQL_BIND) * 2); /* initialize */
param[0].buffer_type = MYSQL_TYPE_LONG;
param[0].buffer = &d_id;
param[1].buffer_type = MYSQL_TYPE_LONG;
param[1].buffer = &w_id;
if( mysql_stmt_bind_param(mysql_stmt, param) ) goto sqlerr;
if( mysql_stmt_execute(mysql_stmt) ) goto sqlerr;
if( mysql_stmt_store_result(mysql_stmt) ) goto sqlerr;
memset(column, 0, sizeof(MYSQL_BIND) * 2); /* initialize */
column[0].buffer_type = MYSQL_TYPE_LONG;
column[0].buffer = &d_next_o_id;
column[1].buffer_type = MYSQL_TYPE_FLOAT;
column[1].buffer = &d_tax;
if( mysql_stmt_bind_result(mysql_stmt, column) ) goto sqlerr;
switch( mysql_stmt_fetch(mysql_stmt) ) {
case 0: //SUCCESS
case MYSQL_DATA_TRUNCATED:
break;
case 1: //ERROR
case MYSQL_NO_DATA: //NO MORE DATA
default:
mysql_stmt_free_result(mysql_stmt);
goto sqlerr;
}
mysql_stmt_free_result(mysql_stmt);
proceed = 3;
/*EXEC_SQL UPDATE district SET d_next_o_id = :d_next_o_id + 1
WHERE d_id = :d_id
AND d_w_id = :w_id;*/
mysql_stmt = stmt[t_num][2];
memset(param, 0, sizeof(MYSQL_BIND) * 3); /* initialize */
param[0].buffer_type = MYSQL_TYPE_LONG;
param[0].buffer = &d_next_o_id;
param[1].buffer_type = MYSQL_TYPE_LONG;
param[1].buffer = &d_id;
param[2].buffer_type = MYSQL_TYPE_LONG;
param[2].buffer = &w_id;
if( mysql_stmt_bind_param(mysql_stmt, param) ) goto sqlerr;
if( mysql_stmt_execute(mysql_stmt) ) goto sqlerr;
o_id = d_next_o_id;
#ifdef DEBUG
printf("n %d\n",proceed);
#endif
proceed = 4;
/*EXEC_SQL INSERT INTO orders (o_id, o_d_id, o_w_id, o_c_id,
o_entry_d, o_ol_cnt, o_all_local)
VALUES(:o_id, :d_id, :w_id, :c_id,
:datetime,
:o_ol_cnt, :o_all_local);*/
mysql_stmt = stmt[t_num][3];
memset(param, 0, sizeof(MYSQL_BIND) * 7); /* initialize */
param[0].buffer_type = MYSQL_TYPE_LONG;
param[0].buffer = &o_id;
param[1].buffer_type = MYSQL_TYPE_LONG;
param[1].buffer = &d_id;
param[2].buffer_type = MYSQL_TYPE_LONG;
param[2].buffer = &w_id;
param[3].buffer_type = MYSQL_TYPE_LONG;
param[3].buffer = &c_id;
param[4].buffer_type = MYSQL_TYPE_STRING;
param[4].buffer = datetime;
param[4].buffer_length = strlen(datetime);
param[5].buffer_type = MYSQL_TYPE_LONG;
param[5].buffer = &o_ol_cnt;
param[6].buffer_type = MYSQL_TYPE_LONG;
param[6].buffer = &o_all_local;
if( mysql_stmt_bind_param(mysql_stmt, param) ) goto sqlerr;
if( mysql_stmt_execute(mysql_stmt) ) goto sqlerr;
#ifdef DEBUG
printf("n %d\n",proceed);
#endif
proceed = 5;
/* EXEC_SQL INSERT INTO new_orders (no_o_id, no_d_id, no_w_id)
VALUES (:o_id,:d_id,:w_id); */
mysql_stmt = stmt[t_num][4];
memset(param, 0, sizeof(MYSQL_BIND) * 3); /* initialize */
param[0].buffer_type = MYSQL_TYPE_LONG;
param[0].buffer = &o_id;
param[1].buffer_type = MYSQL_TYPE_LONG;
param[1].buffer = &d_id;
param[2].buffer_type = MYSQL_TYPE_LONG;
param[2].buffer = &w_id;
if( mysql_stmt_bind_param(mysql_stmt, param) ) goto sqlerr;
if( mysql_stmt_execute(mysql_stmt) ) goto sqlerr;
/* sort orders to avoid DeadLock */
for (i = 0; i < o_ol_cnt; i++) {
ol_num_seq[i]=i;
}
for (i = 0; i < (o_ol_cnt - 1); i++) {
tmp = (MAXITEMS + 1) * supware[ol_num_seq[i]] + itemid[ol_num_seq[i]];
min_num = i;
for ( j = i+1; j < o_ol_cnt; j++) {
if ( (MAXITEMS + 1) * supware[ol_num_seq[j]] + itemid[ol_num_seq[j]] < tmp ){
tmp = (MAXITEMS + 1) * supware[ol_num_seq[j]] + itemid[ol_num_seq[j]];
min_num = j;
}
}
if ( min_num != i ){
swp = ol_num_seq[min_num];
ol_num_seq[min_num] = ol_num_seq[i];
ol_num_seq[i] = swp;
}
}
for (ol_number = 1; ol_number <= o_ol_cnt; ol_number++) {
ol_supply_w_id = supware[ol_num_seq[ol_number - 1]];
ol_i_id = itemid[ol_num_seq[ol_number - 1]];
ol_quantity = qty[ol_num_seq[ol_number - 1]];
/* EXEC SQL WHENEVER NOT FOUND GOTO invaliditem; */
proceed = 6;
/*EXEC_SQL SELECT i_price, i_name, i_data
INTO :i_price, :i_name, :i_data
FROM item
WHERE i_id = :ol_i_id;*/
mysql_stmt = stmt[t_num][5];
memset(param, 0, sizeof(MYSQL_BIND) * 1); /* initialize */
param[0].buffer_type = MYSQL_TYPE_LONG;
param[0].buffer = &ol_i_id;
if( mysql_stmt_bind_param(mysql_stmt, param) ) goto sqlerr;
if( mysql_stmt_execute(mysql_stmt) ) goto sqlerr;
if( mysql_stmt_store_result(mysql_stmt) ) goto sqlerr;
memset(column, 0, sizeof(MYSQL_BIND) * 3); /* initialize */
column[0].buffer_type = MYSQL_TYPE_FLOAT;
column[0].buffer = &i_price;
column[1].buffer_type = MYSQL_TYPE_STRING;
column[1].buffer = i_name;
column[1].buffer_length = sizeof(i_name);
column[2].buffer_type = MYSQL_TYPE_STRING;
column[2].buffer = i_data;
column[2].buffer_length = sizeof(i_data);
if( mysql_stmt_bind_result(mysql_stmt, column) ) goto sqlerr;
switch( mysql_stmt_fetch(mysql_stmt) ) {
case 0: //SUCCESS
case MYSQL_DATA_TRUNCATED:
break;
case MYSQL_NO_DATA: //NO MORE DATA
mysql_stmt_free_result(mysql_stmt);
goto invaliditem;
case 1: //ERROR
default:
mysql_stmt_free_result(mysql_stmt);
goto sqlerr;
}
mysql_stmt_free_result(mysql_stmt);
price[ol_num_seq[ol_number - 1]] = i_price;
strncpy(iname[ol_num_seq[ol_number - 1]], i_name, 25);
/* EXEC SQL WHENEVER NOT FOUND GOTO sqlerr; */
#ifdef DEBUG
printf("n %d\n",proceed);
#endif
proceed = 7;
/*EXEC_SQL SELECT s_quantity, s_data, s_dist_01, s_dist_02,
s_dist_03, s_dist_04, s_dist_05, s_dist_06,
s_dist_07, s_dist_08, s_dist_09, s_dist_10
INTO :s_quantity, :s_data, :s_dist_01, :s_dist_02,
:s_dist_03, :s_dist_04, :s_dist_05, :s_dist_06,
:s_dist_07, :s_dist_08, :s_dist_09, :s_dist_10
FROM stock
WHERE s_i_id = :ol_i_id
AND s_w_id = :ol_supply_w_id
FOR UPDATE;*/
mysql_stmt = stmt[t_num][6];
memset(param, 0, sizeof(MYSQL_BIND) * 2); /* initialize */
param[0].buffer_type = MYSQL_TYPE_LONG;
param[0].buffer = &ol_i_id;
param[1].buffer_type = MYSQL_TYPE_LONG;
param[1].buffer = &ol_supply_w_id;
if( mysql_stmt_bind_param(mysql_stmt, param) ) goto sqlerr;
if( mysql_stmt_execute(mysql_stmt) ) goto sqlerr;
if( mysql_stmt_store_result(mysql_stmt) ) goto sqlerr;
memset(column, 0, sizeof(MYSQL_BIND) * 12); /* initialize */
column[0].buffer_type = MYSQL_TYPE_LONG;
column[0].buffer = &s_quantity;
column[1].buffer_type = MYSQL_TYPE_STRING;
column[1].buffer = s_data;
column[1].buffer_length = sizeof(s_data);
column[2].buffer_type = MYSQL_TYPE_STRING;
column[2].buffer = s_dist_01;
column[2].buffer_length = sizeof(s_dist_01);
column[3].buffer_type = MYSQL_TYPE_STRING;
column[3].buffer = s_dist_02;
column[3].buffer_length = sizeof(s_dist_02);
column[4].buffer_type = MYSQL_TYPE_STRING;
column[4].buffer = s_dist_03;
column[4].buffer_length = sizeof(s_dist_03);
column[5].buffer_type = MYSQL_TYPE_STRING;
column[5].buffer = s_dist_04;
column[5].buffer_length = sizeof(s_dist_04);
column[6].buffer_type = MYSQL_TYPE_STRING;
column[6].buffer = s_dist_05;
column[6].buffer_length = sizeof(s_dist_05);
column[7].buffer_type = MYSQL_TYPE_STRING;
column[7].buffer = s_dist_06;
column[7].buffer_length = sizeof(s_dist_06);
column[8].buffer_type = MYSQL_TYPE_STRING;
column[8].buffer = s_dist_07;
column[8].buffer_length = sizeof(s_dist_07);
column[9].buffer_type = MYSQL_TYPE_STRING;
column[9].buffer = s_dist_08;
column[9].buffer_length = sizeof(s_dist_08);
column[10].buffer_type = MYSQL_TYPE_STRING;
column[10].buffer = s_dist_09;
column[10].buffer_length = sizeof(s_dist_09);
column[11].buffer_type = MYSQL_TYPE_STRING;
column[11].buffer = s_dist_10;
column[11].buffer_length = sizeof(s_dist_10);
if( mysql_stmt_bind_result(mysql_stmt, column) ) goto sqlerr;
switch( mysql_stmt_fetch(mysql_stmt) ) {
case 0: //SUCCESS
break;
case 1: //ERROR
case MYSQL_NO_DATA: //NO MORE DATA
default:
mysql_stmt_free_result(mysql_stmt);
goto sqlerr;
}
mysql_stmt_free_result(mysql_stmt);
pick_dist_info(ol_dist_info, d_id); /* pick correct
* s_dist_xx */
stock[ol_num_seq[ol_number - 1]] = s_quantity;
if ((strstr(i_data, "original") != NULL) &&
(strstr(s_data, "original") != NULL))
bg[ol_num_seq[ol_number - 1]] = 'B';
else
bg[ol_num_seq[ol_number - 1]] = 'G';
if (s_quantity > ol_quantity)
s_quantity = s_quantity - ol_quantity;
else
s_quantity = s_quantity - ol_quantity + 91;
#ifdef DEBUG
printf("n %d\n",proceed);
#endif
proceed = 8;
/*EXEC_SQL UPDATE stock SET s_quantity = :s_quantity
WHERE s_i_id = :ol_i_id
AND s_w_id = :ol_supply_w_id;*/
mysql_stmt = stmt[t_num][7];
memset(param, 0, sizeof(MYSQL_BIND) * 3); /* initialize */
param[0].buffer_type = MYSQL_TYPE_LONG;
param[0].buffer = &s_quantity;
param[1].buffer_type = MYSQL_TYPE_LONG;
param[1].buffer = &ol_i_id;
param[2].buffer_type = MYSQL_TYPE_LONG;
param[2].buffer = &ol_supply_w_id;
if( mysql_stmt_bind_param(mysql_stmt, param) ) goto sqlerr;
if( mysql_stmt_execute(mysql_stmt) ) goto sqlerr;
ol_amount = ol_quantity * i_price * (1 + w_tax + d_tax) * (1 - c_discount);
amt[ol_num_seq[ol_number - 1]] = ol_amount;
total += ol_amount;
#ifdef DEBUG
printf("n %d\n",proceed);
#endif
proceed = 9;
/*EXEC_SQL INSERT INTO order_line (ol_o_id, ol_d_id, ol_w_id,
ol_number, ol_i_id,
ol_supply_w_id, ol_quantity,
ol_amount, ol_dist_info)
VALUES (:o_id, :d_id, :w_id, :ol_number, :ol_i_id,
:ol_supply_w_id, :ol_quantity, :ol_amount,
:ol_dist_info);*/
mysql_stmt = stmt[t_num][8];
memset(param, 0, sizeof(MYSQL_BIND) * 9); /* initialize */
param[0].buffer_type = MYSQL_TYPE_LONG;
param[0].buffer = &o_id;
param[1].buffer_type = MYSQL_TYPE_LONG;
param[1].buffer = &d_id;
param[2].buffer_type = MYSQL_TYPE_LONG;
param[2].buffer = &w_id;
param[3].buffer_type = MYSQL_TYPE_LONG;
param[3].buffer = &ol_number;
param[4].buffer_type = MYSQL_TYPE_LONG;
param[4].buffer = &ol_i_id;
param[5].buffer_type = MYSQL_TYPE_LONG;
param[5].buffer = &ol_supply_w_id;
param[6].buffer_type = MYSQL_TYPE_LONG;
param[6].buffer = &ol_quantity;
param[7].buffer_type = MYSQL_TYPE_FLOAT;
param[7].buffer = &ol_amount;
param[8].buffer_type = MYSQL_TYPE_STRING;
param[8].buffer = ol_dist_info;
param[8].buffer_length = strlen(ol_dist_info);
if( mysql_stmt_bind_param(mysql_stmt, param) ) goto sqlerr;
if( mysql_stmt_execute(mysql_stmt) ) goto sqlerr;
} /* End Order Lines */
#ifdef DEBUG
printf("insert 3\n");
fflush(stdout);
#endif
/*EXEC_SQL COMMIT WORK;*/
if( mysql_commit(ctx[t_num]) ) goto sqlerr;
return (1);
invaliditem:
/*EXEC_SQL ROLLBACK WORK;*/
mysql_rollback(ctx[t_num]);
/* printf("Item number is not valid\n"); */
return (1); /* OK? */
sqlerr:
fprintf(stderr,"neword %d:%d\n",t_num,proceed);
error(ctx[t_num],mysql_stmt);
/*EXEC SQL WHENEVER SQLERROR GOTO sqlerrerr;*/
/*EXEC_SQL ROLLBACK WORK;*/
mysql_rollback(ctx[t_num]);
sqlerrerr:
return (0);
}
int64_t c_DateTime::t_gettimestamp() {
return gettimestamp();
}
// Launch a command and initiate a startup notification
int runcmd(FXString cmd, FXString cmdname, FXString dir, FXString startdir, FXbool usesn = true, FXString snexcepts = "")
{
int ret;
// Change to current directory
ret = chdir(dir.text());
if (ret < 0)
{
int errcode = errno;
if (errcode)
{
fprintf(stderr, _("Error: Can't enter folder %s: %s"), dir.text(), strerror(errcode));
}
else
{
fprintf(stderr, _("Error: Can't enter folder %s"), dir.text());
}
return(-1);
}
// Get rid of possible command options
cmdname = cmdname.before(' ');
// Check if command is in the startup notification exception list
FXbool startup_notify = true;
if (snexcepts != "")
{
FXString entry;
for (int i = 0; ; i++)
{
entry = snexcepts.section(':', i);
if (streq(entry.text(), ""))
{
break;
}
if (streq(entry.text(), cmdname.text()))
{
startup_notify = false;
break;
}
}
}
// Run command with startup notification
if (usesn && startup_notify)
{
Display* xdisplay;
SnDisplay* display;
SnLauncherContext* context;
Time timestamp;
// Open display
xdisplay = XOpenDisplay(NULL);
if (xdisplay == NULL)
{
fprintf(stderr, _("Error: Can't open display\n"));
ret = chdir(startdir.text());
if (ret < 0)
{
int errcode = errno;
if (errcode)
{
fprintf(stderr, _("Error: Can't enter folder %s: %s"), startdir.text(), strerror(errcode));
}
else
{
fprintf(stderr, _("Error: Can't enter folder %s"), startdir.text());
}
}
return(-1);
}
// Message displayed in the task bar (if any)
FXString message;
message.format(_("Start of %s"), cmdname.text());
// Initiate launcher context
display = sn_display_new(xdisplay, NULL, NULL);
context = sn_launcher_context_new(display, DefaultScreen(xdisplay));
sn_launcher_context_set_name(context, message.text());
sn_launcher_context_set_binary_name(context, cmdname.text());
sn_launcher_context_set_description(context, message.text());
sn_launcher_context_set_icon_name(context, cmdname.text());
timestamp = gettimestamp();
sn_launcher_context_initiate(context, "Xfe", cmd.text(), timestamp);
// Run command in background
cmd += " &";
static pid_t child_pid = 0;
switch ((child_pid = fork()))
{
case -1:
fprintf(stderr, _("Error: Fork failed: %s\n"), strerror(errno));
break;
case 0: // Child
sn_launcher_context_setup_child_process(context);
execl("/bin/sh", "sh", "-c", cmd.text(), (char*)NULL);
_exit(EXIT_SUCCESS);
break;
}
sn_launcher_context_unref(context);
}
// Run command without startup notification
else
{
// Run command in background
cmd += " &";
ret = system(cmd.text());
if (ret < 0)
{
fprintf(stderr, _("Error: Can't execute command %s"), cmd.text());
return(-1);
}
// Just display the wait cursor during a second
sleep(1);
}
// Go back to startup directory
ret = chdir(startdir.text());
if (ret < 0)
{
int errcode = errno;
if (errcode)
{
fprintf(stderr, _("Error: Can't enter folder %s: %s"), startdir.text(), strerror(errcode));
}
else
{
fprintf(stderr, _("Error: Can't enter folder %s"), startdir.text());
}
return(-1);
}
return(0);
}
void *io_thread_a2dp_source_aac(void *arg) {
struct ba_transport *t = (struct ba_transport *)arg;
const a2dp_aac_t *cconfig = (a2dp_aac_t *)t->a2dp.cconfig;
pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
pthread_cleanup_push(CANCEL_ROUTINE(io_thread_release), t);
HANDLE_AACENCODER handle;
AACENC_InfoStruct aacinf;
AACENC_ERROR err;
/* create AAC encoder without the Meta Data module */
const unsigned int channels = transport_get_channels(t);
if ((err = aacEncOpen(&handle, 0x07, channels)) != AACENC_OK) {
error("Couldn't open AAC encoder: %s", aacenc_strerror(err));
goto fail_open;
}
pthread_cleanup_push(CANCEL_ROUTINE(aacEncClose), &handle);
unsigned int aot = AOT_NONE;
unsigned int bitrate = AAC_GET_BITRATE(*cconfig);
unsigned int samplerate = transport_get_sampling(t);
unsigned int channelmode = channels == 1 ? MODE_1 : MODE_2;
switch (cconfig->object_type) {
case AAC_OBJECT_TYPE_MPEG2_AAC_LC:
#if AACENCODER_LIB_VERSION <= 0x03040C00 /* 3.4.12 */
aot = AOT_MP2_AAC_LC;
break;
#endif
case AAC_OBJECT_TYPE_MPEG4_AAC_LC:
aot = AOT_AAC_LC;
break;
case AAC_OBJECT_TYPE_MPEG4_AAC_LTP:
aot = AOT_AAC_LTP;
break;
case AAC_OBJECT_TYPE_MPEG4_AAC_SCA:
aot = AOT_AAC_SCAL;
break;
}
if ((err = aacEncoder_SetParam(handle, AACENC_AOT, aot)) != AACENC_OK) {
error("Couldn't set audio object type: %s", aacenc_strerror(err));
goto fail_init;
}
if ((err = aacEncoder_SetParam(handle, AACENC_BITRATE, bitrate)) != AACENC_OK) {
error("Couldn't set bitrate: %s", aacenc_strerror(err));
goto fail_init;
}
if ((err = aacEncoder_SetParam(handle, AACENC_SAMPLERATE, samplerate)) != AACENC_OK) {
error("Couldn't set sampling rate: %s", aacenc_strerror(err));
goto fail_init;
}
if ((err = aacEncoder_SetParam(handle, AACENC_CHANNELMODE, channelmode)) != AACENC_OK) {
error("Couldn't set channel mode: %s", aacenc_strerror(err));
goto fail_init;
}
if (cconfig->vbr) {
if ((err = aacEncoder_SetParam(handle, AACENC_BITRATEMODE, config.aac_vbr_mode)) != AACENC_OK) {
error("Couldn't set VBR bitrate mode %u: %s", config.aac_vbr_mode, aacenc_strerror(err));
goto fail_init;
}
}
if ((err = aacEncoder_SetParam(handle, AACENC_AFTERBURNER, config.aac_afterburner)) != AACENC_OK) {
error("Couldn't enable afterburner: %s", aacenc_strerror(err));
goto fail_init;
}
if ((err = aacEncoder_SetParam(handle, AACENC_TRANSMUX, TT_MP4_LATM_MCP1)) != AACENC_OK) {
error("Couldn't enable LATM transport type: %s", aacenc_strerror(err));
goto fail_init;
}
if ((err = aacEncoder_SetParam(handle, AACENC_HEADER_PERIOD, 1)) != AACENC_OK) {
error("Couldn't set LATM header period: %s", aacenc_strerror(err));
goto fail_init;
}
if ((err = aacEncEncode(handle, NULL, NULL, NULL, NULL)) != AACENC_OK) {
error("Couldn't initialize AAC encoder: %s", aacenc_strerror(err));
goto fail_init;
}
if ((err = aacEncInfo(handle, &aacinf)) != AACENC_OK) {
error("Couldn't get encoder info: %s", aacenc_strerror(err));
goto fail_init;
}
int in_buffer_identifier = IN_AUDIO_DATA;
int out_buffer_identifier = OUT_BITSTREAM_DATA;
int in_buffer_element_size = sizeof(int16_t);
int out_buffer_element_size = 1;
int16_t *in_buffer, *in_buffer_head;
uint8_t *out_buffer, *out_payload;
int in_buffer_size;
int out_payload_size;
AACENC_BufDesc in_buf = {
.numBufs = 1,
.bufs = (void **)&in_buffer_head,
.bufferIdentifiers = &in_buffer_identifier,
.bufSizes = &in_buffer_size,
.bufElSizes = &in_buffer_element_size,
};
AACENC_BufDesc out_buf = {
.numBufs = 1,
.bufs = (void **)&out_payload,
.bufferIdentifiers = &out_buffer_identifier,
.bufSizes = &out_payload_size,
.bufElSizes = &out_buffer_element_size,
};
AACENC_InArgs in_args = { 0 };
AACENC_OutArgs out_args = { 0 };
in_buffer_size = in_buffer_element_size * aacinf.inputChannels * aacinf.frameLength;
out_payload_size = aacinf.maxOutBufBytes;
in_buffer = malloc(in_buffer_size);
out_buffer = malloc(sizeof(rtp_header_t) + out_payload_size);
pthread_cleanup_push(CANCEL_ROUTINE(free), in_buffer);
pthread_cleanup_push(CANCEL_ROUTINE(free), out_buffer);
if (in_buffer == NULL || out_buffer == NULL) {
error("Couldn't create data buffers: %s", strerror(ENOMEM));
goto fail;
}
uint16_t seq_number = random();
uint32_t timestamp = random();
/* initialize RTP header (the constant part) */
rtp_header_t *rtp_header = (rtp_header_t *)out_buffer;
memset(rtp_header, 0, sizeof(*rtp_header));
rtp_header->version = 2;
rtp_header->paytype = 96;
/* anchor for RTP payload - audioMuxElement (RFC 3016) */
out_payload = (uint8_t *)&rtp_header->csrc[rtp_header->cc];
/* helper variable used during payload fragmentation */
const size_t rtp_header_len = out_payload - out_buffer;
/* initial input buffer head position and the available size */
size_t in_samples = in_buffer_size / in_buffer_element_size;
in_buffer_head = in_buffer;
struct pollfd pfds[] = {
{ t->event_fd, POLLIN, 0 },
{ -1, POLLIN, 0 },
};
struct io_sync io_sync = {
.sampling = samplerate,
};
debug("Starting IO loop: %s",
bluetooth_profile_to_string(t->profile, t->codec));
for (;;) {
pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
ssize_t samples;
/* add PCM socket to the poll if transport is active */
pfds[1].fd = t->state == TRANSPORT_ACTIVE ? t->a2dp.pcm.fd : -1;
if (poll(pfds, sizeof(pfds) / sizeof(*pfds), -1) == -1) {
error("Transport poll error: %s", strerror(errno));
goto fail;
}
if (pfds[0].revents & POLLIN) {
/* dispatch incoming event */
eventfd_t event;
eventfd_read(pfds[0].fd, &event);
io_sync.frames = 0;
continue;
}
/* read data from the FIFO - this function will block */
if ((samples = io_thread_read_pcm(&t->a2dp.pcm, in_buffer_head, in_samples)) <= 0) {
if (samples == -1)
error("FIFO read error: %s", strerror(errno));
goto fail;
}
pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
if (io_sync.frames == 0) {
gettimestamp(&io_sync.ts);
io_sync.ts0 = io_sync.ts;
}
if (!config.a2dp_volume || !t->a2dp.supports_dbus_volume)
/* scale volume or mute audio signal */
io_thread_scale_pcm(t, in_buffer_head, samples, channels);
/* overall input buffer size */
samples += in_buffer_head - in_buffer;
/* in the encoding loop head is used for reading */
in_buffer_head = in_buffer;
while ((in_args.numInSamples = samples) != 0) {
if ((err = aacEncEncode(handle, &in_buf, &out_buf, &in_args, &out_args)) != AACENC_OK)
error("AAC encoding error: %s", aacenc_strerror(err));
if (out_args.numOutBytes > 0) {
size_t payload_len_max = t->mtu_write - rtp_header_len;
size_t payload_len = out_args.numOutBytes;
rtp_header->timestamp = htonl(timestamp);
/* If the size of the RTP packet exceeds writing MTU, the RTP payload
* should be fragmented. According to the RFC 3016, fragmentation of
* the audioMuxElement requires no extra header - the payload should
* be fragmented and spread across multiple RTP packets.
*
* TODO: Confirm that the fragmentation logic is correct.
*
* This code has been tested with Jabra Move headset, however the
* outcome of this test is not positive. Fragmented packets are not
* recognized by the device. */
for (;;) {
ssize_t ret;
size_t len;
len = payload_len > payload_len_max ? payload_len_max : payload_len;
rtp_header->markbit = len < payload_len_max;
rtp_header->seq_number = htons(++seq_number);
if ((ret = write(t->bt_fd, out_buffer, rtp_header_len + len)) == -1) {
if (errno == ECONNRESET || errno == ENOTCONN) {
/* exit the thread upon BT socket disconnection */
debug("BT socket disconnected");
goto fail;
}
error("BT socket write error: %s", strerror(errno));
break;
}
/* break if the last part of the payload has been written */
if ((payload_len -= ret - rtp_header_len) == 0)
break;
/* move rest of data to the beginning of the payload */
debug("Payload fragmentation: extra %zd bytes", payload_len);
memmove(out_payload, out_payload + ret, payload_len);
}
}
/* progress the head position by the number of samples consumed by the
* encoder, also adjust the number of samples in the input buffer */
in_buffer_head += out_args.numInSamples;
samples -= out_args.numInSamples;
/* keep data transfer at a constant bit rate, also
* get a timestamp for the next RTP frame */
timestamp += io_thread_time_sync(&io_sync, out_args.numInSamples / channels);
t->delay = io_sync.delay;
}
/* move leftovers to the beginning */
if (samples > 0 && in_buffer != in_buffer_head)
memmove(in_buffer, in_buffer_head, samples * in_buffer_element_size);
/* reposition input buffer head */
in_buffer_head = in_buffer + samples;
in_samples = in_buffer_size / in_buffer_element_size - samples;
}
fail:
pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
pthread_cleanup_pop(1);
pthread_cleanup_pop(1);
fail_init:
pthread_cleanup_pop(1);
fail_open:
pthread_cleanup_pop(1);
return NULL;
}
#endif
void *io_thread_rfcomm(void *arg) {
struct ba_transport *t = (struct ba_transport *)arg;
pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
pthread_cleanup_push(CANCEL_ROUTINE(io_thread_release), t);
uint8_t mic_gain = t->rfcomm.sco->sco.mic_gain;
uint8_t spk_gain = t->rfcomm.sco->sco.spk_gain;
char buffer[64];
struct at_command at;
int i;
struct pollfd pfds[] = {
{ t->event_fd, POLLIN, 0 },
{ t->bt_fd, POLLIN, 0 },
};
/* HSP only supports CVSD */
if (t->profile == BLUETOOTH_PROFILE_HSP_HS || t->profile == BLUETOOTH_PROFILE_HSP_AG)
t->rfcomm.sco->sco.codec = TRANSPORT_SCO_CODEC_CVSD;
debug("Starting RFCOMM loop: %s",
bluetooth_profile_to_string(t->profile, t->codec));
for (;;) {
const char *response = "OK";
ssize_t ret;
pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
if (poll(pfds, sizeof(pfds) / sizeof(*pfds), -1) == -1) {
error("Transport poll error: %s", strerror(errno));
goto fail;
}
pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
if (pfds[0].revents & POLLIN) {
/* dispatch incoming event */
eventfd_t event;
eventfd_read(pfds[0].fd, &event);
if (mic_gain != t->rfcomm.sco->sco.mic_gain) {
mic_gain = t->rfcomm.sco->sco.mic_gain;
debug("Setting microphone gain: %d", mic_gain);
sprintf(buffer, "+VGM=%d", mic_gain);
io_thread_write_at_response(pfds[1].fd, buffer);
}
if (spk_gain != t->rfcomm.sco->sco.spk_gain) {
spk_gain = t->rfcomm.sco->sco.spk_gain;
debug("Setting speaker gain: %d", spk_gain);
sprintf(buffer, "+VGS=%d", mic_gain);
io_thread_write_at_response(pfds[1].fd, buffer);
}
continue;
}
if ((ret = read(pfds[1].fd, buffer, sizeof(buffer))) == -1) {
switch (errno) {
case ECONNABORTED:
case ECONNRESET:
case ENOTCONN:
case ETIMEDOUT:
/* exit the thread upon socket disconnection */
debug("RFCOMM disconnected: %s", strerror(errno));
transport_set_state(t, TRANSPORT_ABORTED);
goto fail;
default:
error("RFCOMM read error: %s", strerror(errno));
continue;
}
}
/* Parse AT command received from the headset. */
if (at_parse(buffer, &at)) {
warn("Invalid AT command: %s", buffer);
continue;
}
debug("AT command: %s=%s", at.command, at.value);
if (strcmp(at.command, "RING") == 0) {
}
else if (strcmp(at.command, "+CKPD") == 0 && atoi(at.value) == 200) {
}
else if (strcmp(at.command, "+VGM") == 0)
t->rfcomm.sco->sco.mic_gain = mic_gain = atoi(at.value);
else if (strcmp(at.command, "+VGS") == 0)
t->rfcomm.sco->sco.spk_gain = spk_gain = atoi(at.value);
else if (strcmp(at.command, "+IPHONEACCEV") == 0) {
char *ptr = at.value;
size_t count = atoi(strsep(&ptr, ","));
char tmp;
while (count-- && ptr != NULL)
switch (tmp = *strsep(&ptr, ",")) {
case '1':
if (ptr != NULL)
t->device->xapl.accev_battery = atoi(strsep(&ptr, ","));
break;
case '2':
if (ptr != NULL)
t->device->xapl.accev_docked = atoi(strsep(&ptr, ","));
break;
default:
warn("Unsupported IPHONEACCEV key: %c", tmp);
strsep(&ptr, ",");
}
}
else if (strcmp(at.command, "+XAPL") == 0) {
unsigned int vendor, product;
unsigned int version, features;
if (sscanf(at.value, "%x-%x-%u,%u", &vendor, &product, &version, &features) == 4) {
t->device->xapl.vendor_id = vendor;
t->device->xapl.product_id = product;
t->device->xapl.version = version;
t->device->xapl.features = features;
response = "+XAPL=BlueALSA,0";
}
else {
warn("Invalid XAPL value: %s", at.value);
response = "ERROR";
}
}
else if (strcmp(at.command, "+BRSF") == 0) {
uint32_t hf_features = strtoul(at.value, NULL, 10);
debug("Got HFP HF features: 0x%x", hf_features);
uint32_t ag_features = HFP_AG_FEATURES;
#if defined(ENABLE_MSBC)
if (config.enable_msbc) {
if (hf_features & HFP_HF_FEAT_CODEC) {
ag_features |= HFP_AG_FEAT_CODEC;
}
}
#endif
if ((ag_features & HFP_AG_FEAT_CODEC) == 0) {
/* Codec negotiation is not supported,
hence no wideband audio support.
AT+BAC is not sent
*/
t->rfcomm.sco->sco.codec = TRANSPORT_SCO_CODEC_CVSD;
}
t->rfcomm.sco->sco.hf_features = hf_features;
snprintf(buffer, sizeof(buffer), "+BRSF: %u", ag_features);
io_thread_write_at_response(pfds[1].fd, buffer);
}
else if (strcmp(at.command, "+BAC") == 0 && at.type == AT_CMD_TYPE_SET) {
debug("Supported codecs: %s", at.value);
/* In case some headsets send BAC even if we don't
* advertise support for it, just OK and ignore
*/
#if defined(ENABLE_MSBC)
/* Split codecs string */
gchar **codecs = g_strsplit(at.value, ",", 0);
for (i = 0; codecs[i]; i++) {
gchar *codec = codecs[i];
uint32_t codec_value = strtoul(codec, NULL, 10);
if (codec_value == HFP_CODEC_MSBC) {
t->rfcomm.sco->sco.codec = TRANSPORT_SCO_CODEC_MSBC;
}
}
g_strfreev(codecs);
#endif
/* Default to CVSD if no other was found */
if (t->rfcomm.sco->sco.codec == TRANSPORT_SCO_CODEC_UNKNOWN)
t->rfcomm.sco->sco.codec = TRANSPORT_SCO_CODEC_CVSD;
}
else if (strcmp(at.command, "+CIND") == 0) {
if ( at.type == AT_CMD_TYPE_GET) {
io_thread_write_at_response(pfds[1].fd,
"+CIND: 0,0,1,4,0,4,0");
}
else if(at.type == AT_CMD_TYPE_TEST) {
io_thread_write_at_response(pfds[1].fd,
"+CIND: "
"(\"call\",(0,1))"
",(\"callsetup\",(0-3))"
",(\"service\",(0-1))"
",(\"signal\",(0-5))"
",(\"roam\",(0,1))"
",(\"battchg\",(0-5))"
",(\"callheld\",(0-2))"
);
}
}
else if (strcmp(at.command, "+CMER") == 0 && at.type == AT_CMD_TYPE_SET) {
/* +CMER is the last step of the "Service Level
Connection establishment" procedure */
/* Send OK */
io_thread_write_at_response(pfds[1].fd, response);
/* Send codec select if anything besides CVSD was found */
if (t->rfcomm.sco->sco.codec > TRANSPORT_SCO_CODEC_CVSD) {
snprintf(buffer, sizeof(buffer), "+BCS: %u", t->rfcomm.sco->sco.codec);
io_thread_write_at_response(pfds[1].fd, buffer);
}
continue;
}
else if (strcmp(at.command, "+BCS") == 0 && at.type == AT_CMD_TYPE_SET) {
debug("Got codec selected: %d", atoi(at.value));
}
else if (strcmp(at.command, "+BTRH") == 0 && at.type == AT_CMD_TYPE_GET) {
}
else if (strcmp(at.command, "+NREC") == 0 && at.type == AT_CMD_TYPE_SET) {
}
else if (strcmp(at.command, "+CCWA") == 0 && at.type == AT_CMD_TYPE_SET) {
}
else if (strcmp(at.command, "+BIA") == 0 && at.type == AT_CMD_TYPE_SET) {
}
else if (strcmp(at.command, "+CHLD") == 0 && at.type == AT_CMD_TYPE_TEST) {
io_thread_write_at_response(pfds[1].fd, "+CHLD: (0,1,2,3)");
}
else {
warn("Unsupported AT command: %s=%s", at.command, at.value);
response = "ERROR";
}
io_thread_write_at_response(pfds[1].fd, response);
}
fail:
pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
pthread_cleanup_pop(1);
return NULL;
}
void *io_thread_sco(void *arg) {
struct ba_transport *t = (struct ba_transport *)arg;
/* this buffer has to be bigger than SCO MTU */
const size_t buffer_size = 512;
struct sbc_state *sbc = NULL;
int16_t *buffer = malloc(buffer_size);
pthread_cleanup_push(CANCEL_ROUTINE(free), buffer);
pthread_cleanup_push(CANCEL_ROUTINE(free), sbc);
if (buffer == NULL) {
error("Couldn't create data buffers: %s", strerror(ENOMEM));
goto fail;
}
struct pollfd pfds[] = {
{ t->event_fd, POLLIN, 0 },
{ -1, POLLIN, 0 }, //bt
{ -1, 0, 0 }, // shm pcm mic follower by shm pcm spk
{ -1, 0, 0 },
{ -1, 0, 0 },
{ -1, 0, 0 },
};
struct io_sync io_sync = {
.frames = 0,
};
debug("Starting IO loop: %s",
bluetooth_profile_to_string(t->profile, t->codec));
for (;;) {
if (t->sco.codec == TRANSPORT_SCO_CODEC_MSBC) {
pfds[1].fd = t->bt_fd;
} else {
pfds[1].fd = t->sco.mic_pcm.shm != NULL ? t->bt_fd : -1;
}
int shm_mic_nr_pfds = libshm_nr_pollfd(t->sco.mic_pcm.shm);
int shm_spk_nr_pfds = libshm_nr_pollfd(t->sco.spk_pcm.shm);
libshm_populate_pollfd(t->sco.mic_pcm.shm, &pfds[2]);
libshm_populate_pollfd(t->sco.spk_pcm.shm, &pfds[2 + shm_mic_nr_pfds]);
if (poll(pfds, 2 + shm_mic_nr_pfds + shm_spk_nr_pfds, -1) == -1) {
error("Transport poll error: %s", strerror(errno));
goto fail;
}
if (pfds[0].revents & POLLIN) {
/* dispatch incoming event */
eventfd_t event;
eventfd_read(pfds[0].fd, &event);
/* It is required to release SCO if we are not transferring audio,
* because it will free Bluetooth bandwidth - microphone signal is
* transfered even though we are not reading from it! */
if (t->sco.spk_pcm.shm == NULL && t->sco.mic_pcm.shm == NULL) {
transport_release_bt_sco(t);
io_sync.frames = 0;
}
else {
debug("Trying to acquire");
transport_acquire_bt_sco(t);
#if defined(ENABLE_MSBC)
/* This can be called again, make sure it is "reentrant" */
if (t->sco.codec == TRANSPORT_SCO_CODEC_MSBC) {
sbc = iothread_initialize_msbc(sbc);
if (!sbc)
goto fail;
}
#endif
}
io_sync.sampling = transport_get_sampling(t);
continue;
}
if (io_sync.frames == 0) {
gettimestamp(&io_sync.ts);
io_sync.ts0 = io_sync.ts;
}
int poll_mic = libshm_poll(t->sco.mic_pcm.shm, &pfds[2], shm_mic_nr_pfds);
int poll_spk = libshm_poll(t->sco.spk_pcm.shm, &pfds[2 + shm_mic_nr_pfds], shm_spk_nr_pfds);
if (pfds[1].revents & POLLIN) { // bluetooth socket incoming
#if defined(ENABLE_MSBC)
if (t->sco.codec == TRANSPORT_SCO_CODEC_MSBC) {
iothread_handle_incoming_msbc(t, sbc);
}
else
#endif
{
ssize_t len;
if ((len = read(pfds[1].fd, buffer, buffer_size)) == -1) {
debug("SCO read error: %s", strerror(errno));
continue;
}
libshm_write_all(t->sco.mic_pcm.shm, buffer, len);
}
}
if (poll_spk & POLLIN) {
#if defined(ENABLE_MSBC)
if (t->sco.codec == TRANSPORT_SCO_CODEC_MSBC) {
iothread_handle_outgoing_msbc(t, sbc);
}
else
#endif
{
ssize_t samples = t->mtu_write / sizeof(int16_t);
/* read data from the FIFO - this function will block */
if ((samples = io_thread_read_pcm(&t->sco.spk_pcm, buffer, samples)) <= 0) {
if (samples == -1)
error("FIFO read error: %s", strerror(errno));
continue;
}
write(t->bt_fd, buffer, samples * sizeof(int16_t));
}
}
/* mSBC output is synchronized to input, no need for this */
if (t->sco.codec != TRANSPORT_SCO_CODEC_MSBC) {
/* keep data transfer at a constant bit rate */
io_thread_time_sync(&io_sync, 48 / 2);
t->delay = io_sync.delay;
}
}
fail:
pthread_cleanup_pop(1);
pthread_cleanup_pop(1);
return NULL;
}
void *io_thread_a2dp_source_sbc(void *arg) {
struct ba_transport *t = (struct ba_transport *)arg;
pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
pthread_cleanup_push(CANCEL_ROUTINE(io_thread_release), t);
sbc_t sbc;
if ((errno = -sbc_init_a2dp(&sbc, 0, t->a2dp.cconfig, t->a2dp.cconfig_size)) != 0) {
error("Couldn't initialize SBC codec: %s", strerror(errno));
goto fail_init;
}
const size_t sbc_codesize = sbc_get_codesize(&sbc);
const size_t sbc_frame_len = sbc_get_frame_length(&sbc);
const unsigned int channels = transport_get_channels(t);
/* Writing MTU should be big enough to contain RTP header, SBC payload
* header and at least one SBC frame. In general, there is no constraint
* for the MTU value, but the speed might suffer significantly. */
size_t mtu_write = t->mtu_write;
if (mtu_write < sizeof(rtp_header_t) + sizeof(rtp_payload_sbc_t) + sbc_frame_len) {
mtu_write = sizeof(rtp_header_t) + sizeof(rtp_payload_sbc_t) + sbc_frame_len;
warn("Writing MTU too small for one single SBC frame: %zu < %zu", t->mtu_write, mtu_write);
}
const size_t in_buffer_size = sbc_codesize * (mtu_write / sbc_frame_len);
const size_t out_buffer_size = mtu_write;
int16_t *in_buffer = malloc(in_buffer_size);
uint8_t *out_buffer = malloc(out_buffer_size);
pthread_cleanup_push(CANCEL_ROUTINE(sbc_finish), &sbc);
pthread_cleanup_push(CANCEL_ROUTINE(free), in_buffer);
pthread_cleanup_push(CANCEL_ROUTINE(free), out_buffer);
if (in_buffer == NULL || out_buffer == NULL) {
error("Couldn't create data buffers: %s", strerror(ENOMEM));
goto fail;
}
uint16_t seq_number = random();
uint32_t timestamp = random();
/* initialize RTP header (the constant part) */
rtp_header_t *rtp_header = (rtp_header_t *)out_buffer;
memset(rtp_header, 0, sizeof(*rtp_header));
rtp_header->version = 2;
rtp_header->paytype = 96;
rtp_payload_sbc_t *rtp_payload;
rtp_payload = (rtp_payload_sbc_t *)&rtp_header->csrc[rtp_header->cc];
memset(rtp_payload, 0, sizeof(*rtp_payload));
/* reading head position and available read length */
int16_t *in_buffer_head = in_buffer;
size_t in_samples = in_buffer_size / sizeof(int16_t);
struct pollfd pfds[] = {
{ t->event_fd, POLLIN, 0 },
{ -1, 0, 0 },
{ -1, 0, 0 },
};
struct io_sync io_sync = {
.sampling = transport_get_sampling(t),
};
debug("Starting IO loop: %s",
bluetooth_profile_to_string(t->profile, t->codec));
for (;;) {
pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
ssize_t samples;
int nr_shm_fds = libshm_nr_pollfd(t->a2dp.pcm.shm);
libshm_populate_pollfd(t->a2dp.pcm.shm, pfds + 1);
if (poll(pfds, 1 + nr_shm_fds, -1) == -1) {
error("Transport poll error: %s", strerror(errno));
goto fail;
}
if (pfds[0].revents & POLLIN) {
/* dispatch incoming event */
eventfd_t event;
eventfd_read(pfds[0].fd, &event);
io_sync.frames = 0;
continue;
}
if (libshm_poll(t->a2dp.pcm.shm, pfds + 1, nr_shm_fds) < 0) {
error("SHM poll failed");
goto fail;
}
/* read data from the FIFO - this function will block */
if ((samples = io_thread_read_pcm(&t->a2dp.pcm, in_buffer_head, in_samples)) <= 0) {
if (samples == -1)
error("FIFO read error: %s", strerror(errno));
goto fail;
}
pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
/* When the thread is created, there might be no data in the FIFO. In fact
* there might be no data for a long time - until client starts playback.
* In order to correctly calculate time drift, the zero time point has to
* be obtained after the stream has started. */
if (io_sync.frames == 0) {
gettimestamp(&io_sync.ts);
io_sync.ts0 = io_sync.ts;
}
if (!config.a2dp_volume || !t->a2dp.supports_dbus_volume)
/* scale volume or mute audio signal */
io_thread_scale_pcm(t, in_buffer_head, samples, channels);
/* overall input buffer size */
samples += in_buffer_head - in_buffer;
const uint8_t *input = (uint8_t *)in_buffer;
size_t input_len = samples * sizeof(int16_t);
/* encode and transfer obtained data */
while (input_len >= sbc_codesize) {
uint8_t *output = (uint8_t *)(rtp_payload + 1);
size_t output_len = out_buffer_size - (output - out_buffer);
size_t pcm_frames = 0;
size_t sbc_frames = 0;
/* Generate as many SBC frames as possible to fill the output buffer
* without overflowing it. The size of the output buffer is based on
* the socket MTU, so such a transfer should be most efficient. */
while (input_len >= sbc_codesize && output_len >= sbc_frame_len) {
ssize_t len;
ssize_t encoded;
if ((len = sbc_encode(&sbc, input, input_len, output, output_len, &encoded)) < 0) {
error("SBC encoding error: %s", strerror(-len));
break;
}
input += len;
input_len -= len;
output += encoded;
output_len -= encoded;
pcm_frames += len / channels / sizeof(int16_t);
sbc_frames++;
}
rtp_header->seq_number = htons(++seq_number);
rtp_header->timestamp = htonl(timestamp);
rtp_payload->frame_count = sbc_frames;
if (write(t->bt_fd, out_buffer, output - out_buffer) == -1) {
if (errno == ECONNRESET || errno == ENOTCONN) {
/* exit the thread upon BT socket disconnection */
debug("BT socket disconnected");
goto fail;
}
error("BT socket write error: %s", strerror(errno));
}
/* keep data transfer at a constant bit rate, also
* get a timestamp for the next RTP frame */
timestamp += io_thread_time_sync(&io_sync, pcm_frames);
t->delay = io_sync.delay;
}
/* convert bytes length to samples length */
samples = input_len / sizeof(int16_t);
/* If the input buffer was not consumed (due to codesize limit), we
* have to append new data to the existing one. Since we do not use
* ring buffer, we will simply move unprocessed data to the front
* of our linear buffer. */
if (samples > 0 && (uint8_t *)in_buffer != input)
memmove(in_buffer, input, samples * sizeof(int16_t));
/* reposition our reading head */
in_buffer_head = in_buffer + samples;
in_samples = in_buffer_size / sizeof(int16_t) - samples;
}
fail:
pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
pthread_cleanup_pop(1);
pthread_cleanup_pop(1);
pthread_cleanup_pop(1);
fail_init:
pthread_cleanup_pop(1);
return NULL;
}
/*
* the payment transaction
*/
int payment( int t_num,
int w_id_arg, /* warehouse id */
int d_id_arg, /* district id */
int byname, /* select by c_id or c_last? */
int c_w_id_arg,
int c_d_id_arg,
int c_id_arg, /* customer id */
char c_last_arg[], /* customer last name */
float h_amount_arg /* payment amount */
)
{
int w_id = w_id_arg;
int d_id = d_id_arg;
int c_id = c_id_arg;
char w_name[11];
char w_street_1[21];
char w_street_2[21];
char w_city[21];
char w_state[3];
char w_zip[10];
int c_d_id = c_d_id_arg;
int c_w_id = c_w_id_arg;
char c_first[17];
char c_middle[3];
char c_last[17];
char c_street_1[21];
char c_street_2[21];
char c_city[21];
char c_state[3];
char c_zip[10];
char c_phone[17];
char c_since[20];
char c_credit[4];
int c_credit_lim;
float c_discount;
float c_balance;
char c_data[502];
char c_new_data[502];
float h_amount = h_amount_arg;
char h_data[26];
char d_name[11];
char d_street_1[21];
char d_street_2[21];
char d_city[21];
char d_state[3];
char d_zip[10];
int namecnt;
char datetime[81];
int n;
int proceed = 0;
MYSQL_STMT* mysql_stmt;
MYSQL_BIND param[8];
MYSQL_BIND column[14];
/* EXEC SQL WHENEVER NOT FOUND GOTO sqlerr; */
/* EXEC SQL WHENEVER SQLERROR GOTO sqlerr; */
gettimestamp(datetime, STRFTIME_FORMAT, TIMESTAMP_LEN);
proceed = 1;
/*EXEC_SQL UPDATE warehouse SET w_ytd = w_ytd + :h_amount
WHERE w_id =:w_id;*/
mysql_stmt = stmt[t_num][9];
memset(param, 0, sizeof(MYSQL_BIND) * 2); /* initialize */
param[0].buffer_type = MYSQL_TYPE_FLOAT;
param[0].buffer = &h_amount;
param[1].buffer_type = MYSQL_TYPE_LONG;
param[1].buffer = &w_id;
if( mysql_stmt_bind_param(mysql_stmt, param) ) goto sqlerr;
if( mysql_stmt_execute(mysql_stmt) ) goto sqlerr;
proceed = 2;
/*EXEC_SQL SELECT w_street_1, w_street_2, w_city, w_state, w_zip,
w_name
INTO :w_street_1, :w_street_2, :w_city, :w_state,
:w_zip, :w_name
FROM warehouse
WHERE w_id = :w_id;*/
mysql_stmt = stmt[t_num][10];
memset(param, 0, sizeof(MYSQL_BIND) * 1); /* initialize */
param[0].buffer_type = MYSQL_TYPE_LONG;
param[0].buffer = &w_id;
if( mysql_stmt_bind_param(mysql_stmt, param) ) goto sqlerr;
if( mysql_stmt_execute(mysql_stmt) ) goto sqlerr;
if( mysql_stmt_store_result(mysql_stmt) ) goto sqlerr;
memset(column, 0, sizeof(MYSQL_BIND) * 6); /* initialize */
column[0].buffer_type = MYSQL_TYPE_STRING;
column[0].buffer = w_street_1;
column[0].buffer_length = sizeof(w_street_1);
column[1].buffer_type = MYSQL_TYPE_STRING;
column[1].buffer = w_street_2;
column[1].buffer_length = sizeof(w_street_2);
column[2].buffer_type = MYSQL_TYPE_STRING;
column[2].buffer = w_city;
column[2].buffer_length = sizeof(w_city);
column[3].buffer_type = MYSQL_TYPE_STRING;
column[3].buffer = w_state;
column[3].buffer_length = sizeof(w_state);
column[4].buffer_type = MYSQL_TYPE_STRING;
column[4].buffer = w_zip;
column[4].buffer_length = sizeof(w_zip);
column[5].buffer_type = MYSQL_TYPE_STRING;
column[5].buffer = w_name;
column[5].buffer_length = sizeof(w_name);
if( mysql_stmt_bind_result(mysql_stmt, column) ) goto sqlerr;
switch( mysql_stmt_fetch(mysql_stmt) ) {
case 0: //SUCCESS
break;
case 1: //ERROR
case MYSQL_NO_DATA: //NO MORE DATA
default:
mysql_stmt_free_result(mysql_stmt);
goto sqlerr;
}
mysql_stmt_free_result(mysql_stmt);
proceed = 3;
/*EXEC_SQL UPDATE district SET d_ytd = d_ytd + :h_amount
WHERE d_w_id = :w_id
AND d_id = :d_id;*/
mysql_stmt = stmt[t_num][11];
memset(param, 0, sizeof(MYSQL_BIND) * 3); /* initialize */
param[0].buffer_type = MYSQL_TYPE_FLOAT;
param[0].buffer = &h_amount;
param[1].buffer_type = MYSQL_TYPE_LONG;
param[1].buffer = &w_id;
param[2].buffer_type = MYSQL_TYPE_LONG;
param[2].buffer = &d_id;
if( mysql_stmt_bind_param(mysql_stmt, param) ) goto sqlerr;
if( mysql_stmt_execute(mysql_stmt) ) goto sqlerr;
proceed = 4;
/*EXEC_SQL SELECT d_street_1, d_street_2, d_city, d_state, d_zip,
d_name
INTO :d_street_1, :d_street_2, :d_city, :d_state,
:d_zip, :d_name
FROM district
WHERE d_w_id = :w_id
AND d_id = :d_id;*/
mysql_stmt = stmt[t_num][12];
memset(param, 0, sizeof(MYSQL_BIND) * 2); /* initialize */
param[0].buffer_type = MYSQL_TYPE_LONG;
param[0].buffer = &w_id;
param[1].buffer_type = MYSQL_TYPE_LONG;
param[1].buffer = &d_id;
if( mysql_stmt_bind_param(mysql_stmt, param) ) goto sqlerr;
if( mysql_stmt_execute(mysql_stmt) ) goto sqlerr;
if( mysql_stmt_store_result(mysql_stmt) ) goto sqlerr;
memset(column, 0, sizeof(MYSQL_BIND) * 6); /* initialize */
column[0].buffer_type = MYSQL_TYPE_STRING;
column[0].buffer = d_street_1;
column[0].buffer_length = sizeof(d_street_1);
column[1].buffer_type = MYSQL_TYPE_STRING;
column[1].buffer = d_street_2;
column[1].buffer_length = sizeof(d_street_2);
column[2].buffer_type = MYSQL_TYPE_STRING;
column[2].buffer = d_city;
column[2].buffer_length = sizeof(d_city);
column[3].buffer_type = MYSQL_TYPE_STRING;
column[3].buffer = d_state;
column[3].buffer_length = sizeof(d_state);
column[4].buffer_type = MYSQL_TYPE_STRING;
column[4].buffer = d_zip;
column[4].buffer_length = sizeof(d_zip);
column[5].buffer_type = MYSQL_TYPE_STRING;
column[5].buffer = d_name;
column[5].buffer_length = sizeof(d_name);
if( mysql_stmt_bind_result(mysql_stmt, column) ) goto sqlerr;
switch( mysql_stmt_fetch(mysql_stmt) ) {
case 0: //SUCCESS
break;
case 1: //ERROR
case MYSQL_NO_DATA: //NO MORE DATA
default:
mysql_stmt_free_result(mysql_stmt);
goto sqlerr;
}
mysql_stmt_free_result(mysql_stmt);
if (byname) {
strcpy(c_last, c_last_arg);
proceed = 5;
/*EXEC_SQL SELECT count(c_id)
INTO :namecnt
FROM customer
WHERE c_w_id = :c_w_id
AND c_d_id = :c_d_id
AND c_last = :c_last;*/
mysql_stmt = stmt[t_num][13];
memset(param, 0, sizeof(MYSQL_BIND) * 3); /* initialize */
param[0].buffer_type = MYSQL_TYPE_LONG;
param[0].buffer = &c_w_id;
param[1].buffer_type = MYSQL_TYPE_LONG;
param[1].buffer = &c_d_id;
param[2].buffer_type = MYSQL_TYPE_STRING;
param[2].buffer = c_last;
param[2].buffer_length = strlen(c_last);
if( mysql_stmt_bind_param(mysql_stmt, param) ) goto sqlerr;
if( mysql_stmt_execute(mysql_stmt) ) goto sqlerr;
if( mysql_stmt_store_result(mysql_stmt) ) goto sqlerr;
memset(column, 0, sizeof(MYSQL_BIND) * 1); /* initialize */
column[0].buffer_type = MYSQL_TYPE_LONG;
column[0].buffer = &namecnt;
if( mysql_stmt_bind_result(mysql_stmt, column) ) goto sqlerr;
switch( mysql_stmt_fetch(mysql_stmt) ) {
case 0: //SUCCESS
break;
case 1: //ERROR
case MYSQL_NO_DATA: //NO MORE DATA
default:
mysql_stmt_free_result(mysql_stmt);
goto sqlerr;
}
mysql_stmt_free_result(mysql_stmt);
/*EXEC_SQL DECLARE c_byname_p CURSOR FOR
SELECT c_id
FROM customer
WHERE c_w_id = :c_w_id
AND c_d_id = :c_d_id
AND c_last = :c_last
ORDER BY c_first;
EXEC_SQL OPEN c_byname_p;*/
mysql_stmt = stmt[t_num][14];
memset(param, 0, sizeof(MYSQL_BIND) * 3); /* initialize */
param[0].buffer_type = MYSQL_TYPE_LONG;
param[0].buffer = &c_w_id;
param[1].buffer_type = MYSQL_TYPE_LONG;
param[1].buffer = &c_d_id;
param[2].buffer_type = MYSQL_TYPE_STRING;
param[2].buffer = c_last;
param[2].buffer_length = strlen(c_last);
if( mysql_stmt_bind_param(mysql_stmt, param) ) goto sqlerr;
if( mysql_stmt_execute(mysql_stmt) ) goto sqlerr;
if( mysql_stmt_store_result(mysql_stmt) ) goto sqlerr;
memset(column, 0, sizeof(MYSQL_BIND) * 1); /* initialize */
column[0].buffer_type = MYSQL_TYPE_LONG;
column[0].buffer = &c_id;
if( mysql_stmt_bind_result(mysql_stmt, column) ) goto sqlerr;
if (namecnt % 2)
namecnt++; /* Locate midpoint customer; */
for (n = 0; n < namecnt / 2; n++) {
/*EXEC_SQL FETCH c_byname_p
INTO :c_id;*/
switch( mysql_stmt_fetch(mysql_stmt) ) {
case 0: //SUCCESS
break;
case 1: //ERROR
case MYSQL_NO_DATA: //NO MORE DATA
default:
mysql_stmt_free_result(mysql_stmt);
goto sqlerr;
}
}
/*EXEC_SQL CLOSE c_byname_p; */
mysql_stmt_free_result(mysql_stmt);
}
proceed = 6;
/*EXEC_SQL SELECT c_first, c_middle, c_last, c_street_1,
c_street_2, c_city, c_state, c_zip, c_phone,
c_credit, c_credit_lim, c_discount, c_balance,
c_since
INTO :c_first, :c_middle, :c_last, :c_street_1,
:c_street_2, :c_city, :c_state, :c_zip, :c_phone,
:c_credit, :c_credit_lim, :c_discount, :c_balance,
:c_since
FROM customer
WHERE c_w_id = :c_w_id
AND c_d_id = :c_d_id
AND c_id = :c_id
FOR UPDATE;*/
mysql_stmt = stmt[t_num][15];
memset(param, 0, sizeof(MYSQL_BIND) * 3); /* initialize */
param[0].buffer_type = MYSQL_TYPE_LONG;
param[0].buffer = &c_w_id;
param[1].buffer_type = MYSQL_TYPE_LONG;
param[1].buffer = &c_d_id;
param[2].buffer_type = MYSQL_TYPE_LONG;
param[2].buffer = &c_id;
if( mysql_stmt_bind_param(mysql_stmt, param) ) goto sqlerr;
if( mysql_stmt_execute(mysql_stmt) ) goto sqlerr;
if( mysql_stmt_store_result(mysql_stmt) ) goto sqlerr;
memset(column, 0, sizeof(MYSQL_BIND) * 14); /* initialize */
column[0].buffer_type = MYSQL_TYPE_STRING;
column[0].buffer = c_first;
column[0].buffer_length = sizeof(c_first);
column[1].buffer_type = MYSQL_TYPE_STRING;
column[1].buffer = c_middle;
column[1].buffer_length = sizeof(c_middle);
column[2].buffer_type = MYSQL_TYPE_STRING;
column[2].buffer = c_last;
column[2].buffer_length = sizeof(c_last);
column[3].buffer_type = MYSQL_TYPE_STRING;
column[3].buffer = c_street_1;
column[3].buffer_length = sizeof(c_street_1);
column[4].buffer_type = MYSQL_TYPE_STRING;
column[4].buffer = c_street_2;
column[4].buffer_length = sizeof(c_street_2);
column[5].buffer_type = MYSQL_TYPE_STRING;
column[5].buffer = c_city;
column[5].buffer_length = sizeof(c_city);
column[6].buffer_type = MYSQL_TYPE_STRING;
column[6].buffer = c_state;
column[6].buffer_length = sizeof(c_state);
column[7].buffer_type = MYSQL_TYPE_STRING;
column[7].buffer = c_zip;
column[7].buffer_length = sizeof(c_zip);
column[8].buffer_type = MYSQL_TYPE_STRING;
column[8].buffer = c_phone;
column[8].buffer_length = sizeof(c_phone);
column[9].buffer_type = MYSQL_TYPE_STRING;
column[9].buffer = c_credit;
column[9].buffer_length = sizeof(c_credit);
column[10].buffer_type = MYSQL_TYPE_LONG;
column[10].buffer = &c_credit_lim;
column[11].buffer_type = MYSQL_TYPE_FLOAT;
column[11].buffer = &c_discount;
column[12].buffer_type = MYSQL_TYPE_FLOAT;
column[12].buffer = &c_balance;
column[13].buffer_type = MYSQL_TYPE_STRING;
column[13].buffer = c_since;
column[13].buffer_length = sizeof(c_since);
if( mysql_stmt_bind_result(mysql_stmt, column) ) goto sqlerr;
switch( mysql_stmt_fetch(mysql_stmt) ) {
case 0: //SUCCESS
case MYSQL_DATA_TRUNCATED:
break;
case 1: //ERROR
case MYSQL_NO_DATA: //NO MORE DATA
default:
mysql_stmt_free_result(mysql_stmt);
goto sqlerr;
}
mysql_stmt_free_result(mysql_stmt);
c_balance += h_amount;
c_credit[2] = '\0';
if (strstr(c_credit, "BC")) {
proceed = 7;
/*EXEC_SQL SELECT c_data
INTO :c_data
FROM customer
WHERE c_w_id = :c_w_id
AND c_d_id = :c_d_id
AND c_id = :c_id; */
mysql_stmt = stmt[t_num][16];
memset(param, 0, sizeof(MYSQL_BIND) * 3); /* initialize */
param[0].buffer_type = MYSQL_TYPE_LONG;
param[0].buffer = &c_w_id;
param[1].buffer_type = MYSQL_TYPE_LONG;
param[1].buffer = &c_d_id;
param[2].buffer_type = MYSQL_TYPE_LONG;
param[2].buffer = &c_id;
if( mysql_stmt_bind_param(mysql_stmt, param) ) goto sqlerr;
if( mysql_stmt_execute(mysql_stmt) ) goto sqlerr;
if( mysql_stmt_store_result(mysql_stmt) ) goto sqlerr;
memset(column, 0, sizeof(MYSQL_BIND) * 1); /* initialize */
column[0].buffer_type = MYSQL_TYPE_STRING;
column[0].buffer = c_data;
column[0].buffer_length = sizeof(c_data);
if( mysql_stmt_bind_result(mysql_stmt, column) ) goto sqlerr;
switch( mysql_stmt_fetch(mysql_stmt) ) {
case 0: //SUCCESS
break;
case 1: //ERROR
case MYSQL_NO_DATA: //NO MORE DATA
default:
mysql_stmt_free_result(mysql_stmt);
goto sqlerr;
}
mysql_stmt_free_result(mysql_stmt);
sprintf(c_new_data,
"| %4d %2d %4d %2d %4d $%7.2f %12c %24c",
c_id, c_d_id, c_w_id, d_id,
w_id, h_amount,
datetime, c_data);
strncat(c_new_data, c_data,
500 - strlen(c_new_data));
c_new_data[500] = '\0';
proceed = 8;
/*EXEC_SQL UPDATE customer
SET c_balance = :c_balance, c_data = :c_new_data
WHERE c_w_id = :c_w_id
AND c_d_id = :c_d_id
AND c_id = :c_id;*/
mysql_stmt = stmt[t_num][17];
memset(param, 0, sizeof(MYSQL_BIND) * 5); /* initialize */
param[0].buffer_type = MYSQL_TYPE_FLOAT;
param[0].buffer = &c_balance;
param[1].buffer_type = MYSQL_TYPE_STRING;
param[1].buffer = c_data;
param[1].buffer_length = strlen(c_data);
param[2].buffer_type = MYSQL_TYPE_LONG;
param[2].buffer = &c_w_id;
param[3].buffer_type = MYSQL_TYPE_LONG;
param[3].buffer = &c_d_id;
param[4].buffer_type = MYSQL_TYPE_LONG;
param[4].buffer = &c_id;
if( mysql_stmt_bind_param(mysql_stmt, param) ) goto sqlerr;
if( mysql_stmt_execute(mysql_stmt) ) goto sqlerr;
} else {
proceed = 9;
/*EXEC_SQL UPDATE customer
SET c_balance = :c_balance
WHERE c_w_id = :c_w_id
AND c_d_id = :c_d_id
AND c_id = :c_id;*/
mysql_stmt = stmt[t_num][18];
memset(param, 0, sizeof(MYSQL_BIND) * 4); /* initialize */
param[0].buffer_type = MYSQL_TYPE_FLOAT;
param[0].buffer = &c_balance;
param[1].buffer_type = MYSQL_TYPE_LONG;
param[1].buffer = &c_w_id;
param[2].buffer_type = MYSQL_TYPE_LONG;
param[2].buffer = &c_d_id;
param[3].buffer_type = MYSQL_TYPE_LONG;
param[3].buffer = &c_id;
if( mysql_stmt_bind_param(mysql_stmt, param) ) goto sqlerr;
if( mysql_stmt_execute(mysql_stmt) ) goto sqlerr;
}
strncpy(h_data, w_name, 10);
h_data[10] = '\0';
strncat(h_data, d_name, 10);
h_data[20] = ' ';
h_data[21] = ' ';
h_data[22] = ' ';
h_data[23] = ' ';
h_data[24] = '\0';
proceed = 10;
/*EXEC_SQL INSERT INTO history(h_c_d_id, h_c_w_id, h_c_id, h_d_id,
h_w_id, h_date, h_amount, h_data)
VALUES(:c_d_id, :c_w_id, :c_id, :d_id,
:w_id,
:datetime,
:h_amount, :h_data);*/
mysql_stmt = stmt[t_num][19];
memset(param, 0, sizeof(MYSQL_BIND) * 8); /* initialize */
param[0].buffer_type = MYSQL_TYPE_LONG;
param[0].buffer = &c_d_id;
param[1].buffer_type = MYSQL_TYPE_LONG;
param[1].buffer = &c_w_id;
param[2].buffer_type = MYSQL_TYPE_LONG;
param[2].buffer = &c_id;
param[3].buffer_type = MYSQL_TYPE_LONG;
param[3].buffer = &d_id;
param[4].buffer_type = MYSQL_TYPE_LONG;
param[4].buffer = &w_id;
param[5].buffer_type = MYSQL_TYPE_STRING;
param[5].buffer = datetime;
param[5].buffer_length = strlen(datetime);
param[6].buffer_type = MYSQL_TYPE_FLOAT;
param[6].buffer = &h_amount;
param[7].buffer_type = MYSQL_TYPE_STRING;
param[7].buffer = h_data;
param[7].buffer_length = strlen(h_data);
if( mysql_stmt_bind_param(mysql_stmt, param) ) goto sqlerr;
if( mysql_stmt_execute(mysql_stmt) ) goto sqlerr;
/*EXEC_SQL COMMIT WORK;*/
if( mysql_commit(ctx[t_num]) ) goto sqlerr;
return (1);
sqlerr:
printf("payment %d:%d\n",t_num,proceed);
error(ctx[t_num],mysql_stmt);
/*EXEC SQL WHENEVER SQLERROR GOTO sqlerrerr;*/
/*EXEC_SQL ROLLBACK WORK;*/
mysql_rollback(ctx[t_num]);
sqlerrerr:
return (0);
}
int main(int argc, char *argv[])
{
struct option long_option[] =
{
{"help", 0, NULL, 'h'},
{"pdevice", 1, NULL, 'P'},
{"cdevice", 1, NULL, 'C'},
{"min", 1, NULL, 'm'},
{"max", 1, NULL, 'M'},
{"frames", 1, NULL, 'F'},
{"format", 1, NULL, 'f'},
{"channels", 1, NULL, 'c'},
{"rate", 1, NULL, 'r'},
{"seconds", 1, NULL, 's'},
{"block", 0, NULL, 'b'},
{"time", 1, NULL, 't'},
{"poll", 0, NULL, 'p'},
{"effect", 0, NULL, 'e'},
{NULL, 0, NULL, 0},
};
snd_pcm_t *phandle, *chandle;
char *buffer;
int err, latency, morehelp;
int ok;
snd_timestamp_t p_tstamp, c_tstamp;
ssize_t r;
size_t frames_in, frames_out, in_max;
int effect = 0;
morehelp = 0;
while (1) {
int c;
if ((c = getopt_long(argc, argv, "hP:C:m:M:F:f:c:r:s:bt:pe", long_option, NULL)) < 0)
break;
switch (c) {
case 'h':
morehelp++;
break;
case 'P':
pdevice = strdup(optarg);
break;
case 'C':
cdevice = strdup(optarg);
break;
case 'm':
err = atoi(optarg) / 2;
latency_min = err >= 4 ? err : 4;
if (latency_max < latency_min)
latency_max = latency_min;
break;
case 'M':
err = atoi(optarg) / 2;
latency_max = latency_min > err ? latency_min : err;
break;
case 'f':
format = snd_pcm_format_value(optarg);
if (format == SND_PCM_FORMAT_UNKNOWN) {
printf("Unknown format, setting to default S16_LE\n");
format = SND_PCM_FORMAT_S16_LE;
}
break;
case 'c':
err = atoi(optarg);
channels = err >= 1 && err < 1024 ? err : 1;
break;
case 'r':
err = atoi(optarg);
rate = err >= 4000 && err < 200000 ? err : 44100;
break;
case 's':
err = atoi(optarg);
loop_sec = err >= 1 && err <= 100000 ? err : 30;
break;
case 'b':
block = 1;
break;
case 't':
tick_time = atoi(optarg);
tick_time = tick_time < 0 ? 0 : tick_time;
break;
case 'p':
use_poll = 1;
break;
case 'e':
effect = 1;
break;
}
}
if (morehelp) {
help();
return 0;
}
err = snd_output_stdio_attach(&output, stdout, 0);
if (err < 0) {
printf("Output failed: %s\n", snd_strerror(err));
return 0;
}
loop_limit = loop_sec * rate;
latency = latency_min - 4;
buffer = malloc((latency_max * snd_pcm_format_width(format) / 8) * 2);
setscheduler();
printf("Playback device is %s\n", pdevice);
printf("Capture device is %s\n", cdevice);
printf("Parameters are %iHz, %s, %i channels, %s mode\n", rate, snd_pcm_format_name(format), channels, block ? "blocking" : "non-blocking");
printf("Wanted tick time: %ius, poll mode: %s\n", tick_time, use_poll ? "yes" : "no");
printf("Loop limit is %li frames, minimum latency = %i, maximum latency = %i\n", loop_limit, latency_min * 2, latency_max * 2);
if ((err = snd_pcm_open(&phandle, pdevice, SND_PCM_STREAM_PLAYBACK, block ? 0 : SND_PCM_NONBLOCK)) < 0) {
printf("Playback open error: %s\n", snd_strerror(err));
return 0;
}
if ((err = snd_pcm_open(&chandle, cdevice, SND_PCM_STREAM_CAPTURE, block ? 0 : SND_PCM_NONBLOCK)) < 0) {
printf("Record open error: %s\n", snd_strerror(err));
return 0;
}
/* initialize the filter sweep variables */
if (effect) {
fs = (float) rate;
BW = FILTER_BANDWIDTH;
lfo = 0;
dlfo = 2.*M_PI*FILTERSWEEP_LFO_FREQ/fs;
x[0] = (float*) malloc(channels*sizeof(float));
x[1] = (float*) malloc(channels*sizeof(float));
x[2] = (float*) malloc(channels*sizeof(float));
y[0] = (float*) malloc(channels*sizeof(float));
y[1] = (float*) malloc(channels*sizeof(float));
y[2] = (float*) malloc(channels*sizeof(float));
}
while (1) {
frames_in = frames_out = 0;
if (setparams(phandle, chandle, &latency) < 0)
break;
showlatency(latency);
if (tick_time_ok)
printf("Using tick time %ius\n", tick_time_ok);
if ((err = snd_pcm_link(chandle, phandle)) < 0) {
printf("Streams link error: %s\n", snd_strerror(err));
exit(0);
}
if (snd_pcm_format_set_silence(format, buffer, latency*channels) < 0) {
fprintf(stderr, "silence error\n");
break;
}
if (writebuf(phandle, buffer, latency, &frames_out) < 0) {
fprintf(stderr, "write error\n");
break;
}
if (writebuf(phandle, buffer, latency, &frames_out) < 0) {
fprintf(stderr, "write error\n");
break;
}
if ((err = snd_pcm_start(chandle)) < 0) {
printf("Go error: %s\n", snd_strerror(err));
exit(0);
}
gettimestamp(phandle, &p_tstamp);
gettimestamp(chandle, &c_tstamp);
#if 0
printf("Playback:\n");
showstat(phandle, frames_out);
printf("Capture:\n");
showstat(chandle, frames_in);
#endif
ok = 1;
in_max = 0;
while (ok && frames_in < loop_limit) {
if (use_poll) {
/* use poll to wait for next event */
snd_pcm_wait(chandle, 1000);
}
if ((r = readbuf(chandle, buffer, latency, &frames_in, &in_max)) < 0)
ok = 0;
else {
if (effect)
applyeffect(buffer,r);
if (writebuf(phandle, buffer, r, &frames_out) < 0)
ok = 0;
}
}
if (ok)
printf("Success\n");
else
printf("Failure\n");
printf("Playback:\n");
showstat(phandle, frames_out);
printf("Capture:\n");
showstat(chandle, frames_in);
showinmax(in_max);
if (p_tstamp.tv_sec == p_tstamp.tv_sec &&
p_tstamp.tv_usec == c_tstamp.tv_usec)
printf("Hardware sync\n");
snd_pcm_drop(chandle);
snd_pcm_nonblock(phandle, 0);
snd_pcm_drain(phandle);
snd_pcm_nonblock(phandle, !block ? 1 : 0);
if (ok) {
#if 1
printf("Playback time = %li.%i, Record time = %li.%i, diff = %li\n",
p_tstamp.tv_sec,
(int)p_tstamp.tv_usec,
c_tstamp.tv_sec,
(int)c_tstamp.tv_usec,
timediff(p_tstamp, c_tstamp));
#endif
break;
}
snd_pcm_unlink(chandle);
snd_pcm_hw_free(phandle);
snd_pcm_hw_free(chandle);
}
snd_pcm_close(phandle);
snd_pcm_close(chandle);
return 0;
}
