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; } }