static void do_store()
{
input_stop();
conf_store();
input_start();
OK();
}
static void do_load()
{
input_stop();
conf_load();
OK();
input_calibrate(CHANNELS);
input_start();
}
static void do_conf()
{
char c = 0;
char line[64];
int args, id, num, gain, min, max;
struct chan *channel;
gets(line);
args = sscanf(line, "%c %u %u %i %i", &c, &num, &gain, &min, &max);
if (args > 0) {
id = CHANNEL_ID(c);
if (id >= CHANNELS)
NOK();
else if (args == 1) {
channel = conf_get(id);
printf("%c %u %u %i %i\n", c, channel->num, channel->gain, channel->min, channel->max);
}
else {
int tmp;
input_stop();
channel = conf_get(id);
tmp = channel->gain;
channel->num = limit(num, 0, AD_CHANNELS);
if (args >= 3) {
channel->gain = limit(gain, AD_GAIN_MIN, AD_GAIN_MAX);
if (tmp != channel->gain)
input_calibrate(id);
}
if (args == 4) {
max = limit(min, 0, AD_VMAX);
min = limit(-min, AD_VMIN, 0);
channel->min = min;
channel->max = max;
}
else if (args >= 5) {
channel->min = limit(min, AD_VMIN, AD_VMAX);
channel->max = limit(max, channel->min, AD_VMAX);
}
printf("ok %c %u %u %i %i\n", c, channel->num, channel->gain, channel->min, channel->max);
input_start();
}
}
else NOK();
}
// Wait for some event
static bool poll_uv_loop(int32_t ms)
{
bool timed_out;
uv_run_mode run_mode = UV_RUN_ONCE;
if (input_ready()) {
// If there's a pending input event to be consumed, do it now
return true;
}
input_start();
timed_out = false;
if (ms > 0) {
// Timeout passed as argument to the timer
timer.data = &timed_out;
// We only start the timer after the loop is running, for that we
// use an prepare handle(pass the interval as data to it)
timer_prepare.data = &ms;
uv_prepare_start(&timer_prepare, timer_prepare_cb);
} else if (ms == 0) {
// For ms == 0, we need to do a non-blocking event poll by
// setting the run mode to UV_RUN_NOWAIT.
run_mode = UV_RUN_NOWAIT;
}
do {
// Run one event loop iteration, blocking for events if run_mode is
// UV_RUN_ONCE
uv_run(uv_default_loop(), run_mode);
} while (
// Continue running if ...
!input_ready() && // we have no input
!has_pending_events() && // no events are waiting to be processed
run_mode != UV_RUN_NOWAIT && // ms != 0
!timed_out // we didn't get a timeout
);
input_stop();
if (ms > 0) {
// Stop the timer
uv_timer_stop(&timer);
}
return input_ready() || has_pending_events();
}
static void do_info()
{
char c;
int i, tmp;
struct chan *channel;
input_stop();
if ((c = getchar()) == 'V') {
tmp = AD7793_voltmon();
printf("%u.%uV\n", tmp/1000000, tmp%1000000);
}
else if (c == 'T') {
tmp = AD7793_temperature();
printf("%u.%uC\n", tmp/10000, tmp%10000);
}
else {
if ((i = CHANNEL_ID(c)) < CHANNELS) // print only one channel
tmp = i+1;
else { // print all channels and state information
i = 0;
tmp = CHANNELS;
printf("%s\n", STATE_NAME(state_getState()));
}
while (i < tmp) {
channel = conf_get(i);
printf("%c %s ch%u %ux %i ... %i %iuV\n",
CHANNEL_NAME(i), ERROR_NAME(state_getError(i)),
channel->num, 1<<channel->gain,
channel->min, channel->max,
input_latest(i));
i++;
}
}
input_start();
}
RawImage Rw2Decoder::decodeRawInternal() {
vector<TiffIFD*> data = mRootIFD->getIFDsWithTag(PANASONIC_STRIPOFFSET);
bool isOldPanasonic = FALSE;
if (data.empty()) {
if (!mRootIFD->hasEntryRecursive(STRIPOFFSETS))
ThrowRDE("RW2 Decoder: No image data found");
isOldPanasonic = TRUE;
data = mRootIFD->getIFDsWithTag(STRIPOFFSETS);
}
TiffIFD* raw = data[0];
uint32 height = raw->getEntry((TiffTag)3)->getShort();
uint32 width = raw->getEntry((TiffTag)2)->getShort();
if (isOldPanasonic) {
ThrowRDE("Cannot decode old-style Panasonic RAW files");
TiffEntry *offsets = raw->getEntry(STRIPOFFSETS);
TiffEntry *counts = raw->getEntry(STRIPBYTECOUNTS);
if (offsets->count != 1) {
ThrowRDE("RW2 Decoder: Multiple Strips found: %u", offsets->count);
}
int off = offsets->getInt();
if (!mFile->isValid(off))
ThrowRDE("Panasonic RAW Decoder: Invalid image data offset, cannot decode.");
int count = counts->getInt();
if (count != (int)(width*height*2))
ThrowRDE("Panasonic RAW Decoder: Byte count is wrong.");
if (!mFile->isValid(off+count))
ThrowRDE("Panasonic RAW Decoder: Invalid image data offset, cannot decode.");
mRaw->dim = iPoint2D(width, height);
mRaw->createData();
ByteStream input_start(mFile->getData(off), mFile->getSize() - off);
iPoint2D pos(0, 0);
readUncompressedRaw(input_start, mRaw->dim,pos, width*2, 16, BitOrder_Plain);
} else {
mRaw->dim = iPoint2D(width, height);
mRaw->createData();
TiffEntry *offsets = raw->getEntry(PANASONIC_STRIPOFFSET);
if (offsets->count != 1) {
ThrowRDE("RW2 Decoder: Multiple Strips found: %u", offsets->count);
}
load_flags = 0x2008;
int off = offsets->getInt();
if (!mFile->isValid(off))
ThrowRDE("RW2 Decoder: Invalid image data offset, cannot decode.");
input_start = new ByteStream(mFile->getData(off), mFile->getSize() - off);
DecodeRw2();
}
// Read blacklevels
if (raw->hasEntry((TiffTag)0x1c) && raw->hasEntry((TiffTag)0x1d) && raw->hasEntry((TiffTag)0x1e)) {
mRaw->blackLevelSeparate[0] = raw->getEntry((TiffTag)0x1c)->getInt() + 15;
mRaw->blackLevelSeparate[1] = mRaw->blackLevelSeparate[2] = raw->getEntry((TiffTag)0x1d)->getInt() + 15;
mRaw->blackLevelSeparate[3] = raw->getEntry((TiffTag)0x1e)->getInt() + 15;
}
return mRaw;
}
// Wait for some event
bool event_poll(int32_t ms)
{
uv_run_mode run_mode = UV_RUN_ONCE;
if (input_ready()) {
// If there's a pending input event to be consumed, do it now
return true;
}
static int recursive = 0;
if (!(recursive++)) {
// Only needs to start the libuv handle the first time we enter here
input_start();
}
uv_timer_t timer;
uv_prepare_t timer_prepare;
TimerData timer_data = {.ms = ms, .timed_out = false, .timer = &timer};
if (ms > 0) {
uv_timer_init(uv_default_loop(), &timer);
// This prepare handle that actually starts the timer
uv_prepare_init(uv_default_loop(), &timer_prepare);
// Timeout passed as argument to the timer
timer.data = &timer_data;
// We only start the timer after the loop is running, for that we
// use a prepare handle(pass the interval as data to it)
timer_prepare.data = &timer_data;
uv_prepare_start(&timer_prepare, timer_prepare_cb);
} else if (ms == 0) {
// For ms == 0, we need to do a non-blocking event poll by
// setting the run mode to UV_RUN_NOWAIT.
run_mode = UV_RUN_NOWAIT;
}
do {
// Run one event loop iteration, blocking for events if run_mode is
// UV_RUN_ONCE
uv_run(uv_default_loop(), run_mode);
// Process immediate events outside uv_run since libuv event loop not
// support recursion(processing events may cause a recursive event_poll
// call)
event_process(false);
} while (
// Continue running if ...
!input_ready() && // we have no input
!event_has_deferred() && // no events are waiting to be processed
run_mode != UV_RUN_NOWAIT && // ms != 0
!timer_data.timed_out); // we didn't get a timeout
if (!(--recursive)) {
// Again, only stop when we leave the top-level invocation
input_stop();
}
if (ms > 0) {
// Ensure the timer-related handles are closed and run the event loop
// once more to let libuv perform it's cleanup
uv_close((uv_handle_t *)&timer, NULL);
uv_close((uv_handle_t *)&timer_prepare, NULL);
uv_run(uv_default_loop(), UV_RUN_NOWAIT);
event_process(false);
}
return input_ready() || event_has_deferred();
}
bool event_has_deferred()
{
return !kl_empty(get_queue(true));
}
// Push an event to the queue
void event_push(Event event, bool deferred)
{
*kl_pushp(Event, get_queue(deferred)) = event;
}
int main(int argc, char **argv)
{
int c, port = 2222, samplefreq = SAMPLEFREQ, chans = 2;
int fmt_bits = 16;
char *dev = "/dev/dsp";
while((c = getopt(argc, argv, "+b:B:c:dhp:s:D:")) != EOF) {
switch(c) {
case 'b':
buffer_size = atoi(optarg) * 1024;
if(buffer_size < 16) {
fprintf(stderr, "ERROR: buffer_size < 16\n");
exit(1);
}
break;
case 'c':
chans = atoi(optarg);
break;
case 'd':
debug++;
break;
case 'B':
fmt_bits = atoi(optarg);
if(fmt_bits != 16 && fmt_bits != 32) usage(1);
break;
case 'h':
usage(0);
case 'p':
port = atoi(optarg);
break;
case 's':
samplefreq = atoi(optarg);
break;
case 'D':
dev = optarg;
break;
default:
usage(1);
}
}
buffer_init();
input_start();
output_init(dev, samplefreq, fmt_bits, chans);
signals_init();
socket_init(port);
/* lock memory (limits for non-root can be raised in /etc/security/limits.conf) */
if(mlockall(MCL_CURRENT | MCL_FUTURE) == -1) {
struct rlimit rl;
if(getrlimit(RLIMIT_MEMLOCK, &rl) == 0) {
rl.rlim_cur = rl.rlim_max;
if(setrlimit(RLIMIT_MEMLOCK, &rl) == -1) {
perror("setrlimit RLIMIT_MEMLOCK");
}
}
if(mlockall(MCL_CURRENT | MCL_FUTURE) == -1) {
perror("warning: mlockall");
}
}
/* realtime priority (limits for non-root can be raised in /etc/security/limits.conf) */
struct sched_param sp;
sp.sched_priority = 1;
if(sched_setscheduler(getpid(), SCHED_FIFO, &sp) < 0)
perror("sched_setscheduler");
output_start();
mainloop();
return 0;
}
void pad(const T* arg0,
const T* arg1,
T* out,
const Shape& arg0_shape,
const Shape& out_shape,
const Shape& padding_below,
const Shape& padding_above,
const Shape& padding_interior)
{
Coordinate input_start(arg0_shape.size(), 0); // start at (0,0,...,0)
Coordinate input_end =
out_shape; // end at (d'0,d'1,...,d'n), the outer corner of the post-padding shape
Strides input_strides(arg0_shape.size(), 1);
AxisVector input_axis_order(arg0_shape.size());
for (size_t i = 0; i < arg0_shape.size(); i++)
{
input_axis_order[i] = i;
}
Strides input_dilation(arg0_shape.size());
for (size_t i = 0; i < arg0_shape.size(); i++)
{
input_dilation[i] = padding_interior[i] + 1;
}
// Need to cast these to CoordinateDiff in order to make CoordinateTransform happy.
CoordinateDiff padding_below_signed;
CoordinateDiff padding_above_signed;
for (size_t i = 0; i < padding_below.size(); i++)
{
padding_below_signed.push_back(padding_below[i]);
padding_above_signed.push_back(padding_above[i]);
}
CoordinateTransform input_transform(arg0_shape,
input_start,
input_end,
input_strides,
input_axis_order,
padding_below_signed,
padding_above_signed,
input_dilation);
CoordinateTransform output_transform(out_shape);
CoordinateTransform::Iterator output_it = output_transform.begin();
for (const Coordinate& in_coord : input_transform)
{
const Coordinate& out_coord = *output_it;
T v = input_transform.has_source_coordinate(in_coord)
? arg0[input_transform.index(in_coord)]
: *arg1;
out[output_transform.index(out_coord)] = v;
++output_it;
}
}
