static void fz_process_mesh_type5(fz_context *ctx, fz_shade *shade, const fz_matrix *ctm, fz_mesh_processor *painter) { fz_stream *stream = fz_open_compressed_buffer(ctx, shade->buffer); fz_vertex *buf = NULL; fz_vertex *ref = NULL; int first; int ncomp = painter->ncomp; int i, k; int vprow = shade->u.m.vprow; int bpcoord = shade->u.m.bpcoord; int bpcomp = shade->u.m.bpcomp; float x0 = shade->u.m.x0; float x1 = shade->u.m.x1; float y0 = shade->u.m.y0; float y1 = shade->u.m.y1; float *c0 = shade->u.m.c0; float *c1 = shade->u.m.c1; float x, y, c[FZ_MAX_COLORS]; fz_var(buf); fz_var(ref); fz_try(ctx) { ref = fz_malloc_array(ctx, vprow, sizeof(fz_vertex)); buf = fz_malloc_array(ctx, vprow, sizeof(fz_vertex)); first = 1; while (!fz_is_eof_bits(ctx, stream)) { for (i = 0; i < vprow; i++) { x = read_sample(ctx, stream, bpcoord, x0, x1); y = read_sample(ctx, stream, bpcoord, y0, y1); for (k = 0; k < ncomp; k++) c[k] = read_sample(ctx, stream, bpcomp, c0[k], c1[k]); fz_prepare_vertex(ctx, painter, &buf[i], ctm, x, y, c); } if (!first) for (i = 0; i < vprow - 1; i++) paint_quad(ctx, painter, &ref[i], &ref[i+1], &buf[i+1], &buf[i]); SWAP(ref,buf); first = 0; } } fz_always(ctx) { fz_free(ctx, ref); fz_free(ctx, buf); fz_drop_stream(ctx, stream); } fz_catch(ctx) { fz_rethrow(ctx); } }
static void fz_mesh_type5_process(fz_context *ctx, fz_shade *shade, const fz_matrix *ctm, fz_mesh_processor *painter) { fz_stream *stream = fz_open_compressed_buffer(ctx, shade->buffer); fz_vertex *buf = NULL; fz_vertex *ref = NULL; int first; int ncomp; int i, k; int vprow = shade->u.m.vprow; int bpcoord = shade->u.m.bpcoord; int bpcomp = shade->u.m.bpcomp; float x0 = shade->u.m.x0; float x1 = shade->u.m.x1; float y0 = shade->u.m.y0; float y1 = shade->u.m.y1; float *c0 = shade->u.m.c0; float *c1 = shade->u.m.c1; fz_var(buf); fz_var(ref); fz_try(ctx) { ref = fz_malloc_array(ctx, vprow, sizeof(fz_vertex)); buf = fz_malloc_array(ctx, vprow, sizeof(fz_vertex)); first = 1; ncomp = (shade->use_function > 0 ? 1 : shade->colorspace->n); while (!fz_is_eof_bits(stream)) { for (i = 0; i < vprow; i++) { buf[i].p.x = read_sample(stream, bpcoord, x0, x1); buf[i].p.y = read_sample(stream, bpcoord, y0, y1); fz_transform_point(&buf[i].p, ctm); for (k = 0; k < ncomp; k++) buf[i].c[k] = read_sample(stream, bpcomp, c0[k], c1[k]); } if (!first) for (i = 0; i < vprow - 1; i++) paint_quad(painter, &ref[i], &ref[i+1], &buf[i+1], &buf[i]); SWAP(ref,buf); first = 0; } } fz_always(ctx) { fz_free(ctx, ref); fz_free(ctx, buf); fz_close(stream); } fz_catch(ctx) { fz_rethrow(ctx); } }
static void pdf_load_type5_shade(fz_shade *shade, pdf_document *xref, pdf_obj *dict, int funcs, pdf_function **func) { fz_context *ctx = xref->ctx; struct mesh_params p; struct vertex *buf, *ref; int first; int ncomp; int i, k; fz_stream *stream; pdf_load_mesh_params(xref, dict, &p); if (funcs > 0) { ncomp = 1; pdf_sample_shade_function(ctx, shade, funcs, func, p.c0[0], p.c1[0]); } else ncomp = shade->colorspace->n; ref = fz_malloc_array(ctx, p.vprow, sizeof(struct vertex)); buf = fz_malloc_array(ctx, p.vprow, sizeof(struct vertex)); first = 1; stream = pdf_open_stream(xref, pdf_to_num(dict), pdf_to_gen(dict)); while (!fz_is_eof_bits(stream)) { for (i = 0; i < p.vprow; i++) { buf[i].x = read_sample(stream, p.bpcoord, p.x0, p.x1); buf[i].y = read_sample(stream, p.bpcoord, p.y0, p.y1); for (k = 0; k < ncomp; k++) buf[i].c[k] = read_sample(stream, p.bpcomp, p.c0[k], p.c1[k]); } if (!first) for (i = 0; i < p.vprow - 1; i++) pdf_add_quad(ctx, shade, &ref[i], &ref[i+1], &buf[i+1], &buf[i]); memcpy(ref, buf, p.vprow * sizeof(struct vertex)); first = 0; } fz_free(ctx, ref); fz_free(ctx, buf); fz_close(stream); }
int main () { int bitn = 7; char c = 0; int i; int llp = 0; while (!feof (stdin)) { if (lp > 3 * SAMPLES_PER_TRAME) { bitn = 7; c = 0; lp = 0; llp++; } if (llp == FLUSH_TIMEOUT) fflush (stdout); if (f2 > FREQ_SEP_MIN && f2 < FREQ_SEP_MAX && f1 > FREQ_DATA_MIN && f1 < FREQ_DATA_MAX) { #if DEBUG printf ("%d %d %d @%d\n", f1, f2, FREQ_DATA_THRESHOLD, ftell (stdin) - sizeof (trame)); #endif if (f1 < FREQ_DATA_THRESHOLD) c |= (1 << bitn); bitn--; if (bitn < 0) { #if DEBUG printf ("<%c, %x>", c, c); #else printf ("%c", c); #endif bitn = 7; c = 0; } lp = 0; llp = 0; for (i = 0; i < SAMPLES_PER_TRAME; i++) read_sample (); continue; } read_sample (); } return 0; }
std::shared_ptr< Surface > flat::PdmFileReader< Surface >::operator() ( ) { # if defined DBG_FLAT_PDM_FILE_READER std::clog << "flat::PdmFileReader< Surface >::PdmFileReader\t|" << " path \"" << path << '\"' << std::endl; # endif size_t index = 0; std::ifstream stream; stream.exceptions( std::ifstream::failbit | std::ifstream::badbit ); stream.open( path.c_str() ); read_file_header( stream ); const size_t num_vertices = get<0>( vertex_field_size ) * get<1>( vertex_field_size ); std::shared_ptr< Surface > surface = Surface::create_with_size( num_vertices ); do { read_sample( stream, surface, index ); } while( ++index < num_vertices ); stream.close(); flat::SimpleRectlinearTriangulator triangulator( vertex_field_size ); triangulator( surface ); return surface; }
static void pdf_load_type5_shade(fz_shade *shade, pdf_xref *xref, fz_obj *dict, int funcs, pdf_function **func, fz_stream *stream) { struct mesh_params p; struct vertex *buf, *ref; int first; int ncomp; int i, k; pdf_load_mesh_params(xref, dict, &p); if (funcs > 0) { ncomp = 1; pdf_sample_shade_function(shade, funcs, func, p.c0[0], p.c1[0]); } else ncomp = shade->colorspace->n; ref = fz_calloc(p.vprow, sizeof(struct vertex)); buf = fz_calloc(p.vprow, sizeof(struct vertex)); first = 1; while (!fz_is_eof_bits(stream)) { for (i = 0; i < p.vprow; i++) { buf[i].x = read_sample(stream, p.bpcoord, p.x0, p.x1); buf[i].y = read_sample(stream, p.bpcoord, p.y0, p.y1); for (k = 0; k < ncomp; k++) buf[i].c[k] = read_sample(stream, p.bpcomp, p.c0[k], p.c1[k]); } if (!first) for (i = 0; i < p.vprow - 1; i++) pdf_add_quad(shade, &ref[i], &ref[i+1], &buf[i+1], &buf[i]); memcpy(ref, buf, p.vprow * sizeof(struct vertex)); first = 0; } free(ref); free(buf); }
/* Decode a single block of data from 'data', storing 'n_samples' decoded 16 bit samples in 'samples'. All buffer lengths have been verified by the caller */ static gboolean adpcmdec_decode_ms_block (ADPCMDec * dec, int n_samples, const guint8 * data, gint16 * samples) { gint16 pred[2]; gint16 idelta[2]; int idx; /* Current byte offset in 'data' */ int i; /* Current sample index in 'samples' */ /* Read the block header, verify for sanity */ if (dec->channels == 1) { pred[0] = data[0]; idelta[0] = read_sample (data + 1); samples[1] = read_sample (data + 3); samples[0] = read_sample (data + 5); idx = 7; i = 2; if (pred[0] < 0 || pred[0] > 6) { GST_WARNING_OBJECT (dec, "Invalid block predictor"); return FALSE; } } else { pred[0] = data[0]; pred[1] = data[1]; idelta[0] = read_sample (data + 2); idelta[1] = read_sample (data + 4); samples[2] = read_sample (data + 6); samples[3] = read_sample (data + 8); samples[0] = read_sample (data + 10); samples[1] = read_sample (data + 12); idx = 14; i = 4; if (pred[0] < 0 || pred[0] > 6 || pred[1] < 0 || pred[1] > 6) { GST_WARNING_OBJECT (dec, "Invalid block predictor"); return FALSE; } } for (; i < n_samples; i++) { int chan = i % dec->channels; int bytecode; int delta; int current; int predict; if (i % 2 == 0) { bytecode = (data[idx] >> 4) & 0x0F; } else {
int read_adc(int serial, sample_data_t *sd, size_t ndev) { printf("Acquiring data...\n"); cbm_send_broadcast(serial, BCMD_ACQUIRE, NULL, 0); usleep(SAMPLE_DELAY_US); printf("Getting data...\n"); tcflush(serial, TCIFLUSH); cbm_send_broadcast(serial, BCMD_GET_DATA, NULL, 0); printf("Reading data...\n"); for (size_t i=0; i<ndev; i++) { if (read_sample(serial, sd+i) < 0) return -1; } return 0; }
void qsound_device::sound_stream_update(sound_stream &stream, stream_sample_t **inputs, stream_sample_t **outputs, int samples) { // Clear the buffers memset(outputs[0], 0, samples * sizeof(*outputs[0])); memset(outputs[1], 0, samples * sizeof(*outputs[1])); for (auto & elem : m_channel) { if (elem.enabled) { stream_sample_t *lmix=outputs[0]; stream_sample_t *rmix=outputs[1]; // Go through the buffer and add voice contributions for (int i = 0; i < samples; i++) { elem.address += (elem.step_ptr >> 12); elem.step_ptr &= 0xfff; elem.step_ptr += elem.freq; if (elem.address >= elem.end) { if (elem.loop) { // Reached the end, restart the loop elem.address -= elem.loop; // Make sure we don't overflow (what does the real chip do in this case?) if (elem.address >= elem.end) elem.address = elem.end - elem.loop; elem.address &= 0xffff; } else { // Reached the end of a non-looped sample elem.enabled = false; break; } } int8_t sample = read_sample(elem.bank | elem.address); *lmix++ += ((sample * elem.lvol * elem.vol) >> 14); *rmix++ += ((sample * elem.rvol * elem.vol) >> 14); } } }
void qsound_device::sound_stream_update(sound_stream &stream, stream_sample_t **inputs, stream_sample_t **outputs, int samples) { // Clear the buffers memset(outputs[0], 0, samples * sizeof(*outputs[0])); memset(outputs[1], 0, samples * sizeof(*outputs[1])); for (int ch = 0; ch < 16; ch++) { if (m_channel[ch].enabled) { stream_sample_t *lmix=outputs[0]; stream_sample_t *rmix=outputs[1]; // Go through the buffer and add voice contributions for (int i = 0; i < samples; i++) { m_channel[ch].address += (m_channel[ch].step_ptr >> 12); m_channel[ch].step_ptr &= 0xfff; m_channel[ch].step_ptr += m_channel[ch].freq; if (m_channel[ch].address >= m_channel[ch].end) { if (m_channel[ch].loop) { // Reached the end, restart the loop m_channel[ch].address -= m_channel[ch].loop; // Make sure we don't overflow (what does the real chip do in this case?) if (m_channel[ch].address >= m_channel[ch].end) m_channel[ch].address = m_channel[ch].end - m_channel[ch].loop; m_channel[ch].address &= 0xffff; } else { // Reached the end of a non-looped sample m_channel[ch].enabled = false; break; } } INT8 sample = read_sample(m_channel[ch].bank | m_channel[ch].address); *lmix++ += ((sample * m_channel[ch].lvol * m_channel[ch].vol) >> 14); *rmix++ += ((sample * m_channel[ch].rvol * m_channel[ch].vol) >> 14); } } }
void main(void) { double xin; double yout; Tremolo_init(4000,1); while(1) { if (new_sample_flag()) { /*When there's new sample at your ADC or CODEC input*/ /*Read the sample*/ xin = read_sample(); /*Apply the Tremolo_process function to the sample*/ yout = Tremolo_process(0.7*temp); /*Send the output value to your DAC or codec output*/ write_output(yout); /*Makes LFO vary*/ Tremolo_sweep(); } } }
void *maintask(void *arg) { struct sched_param sp; sp.sched_priority = 99; pthread_setschedparam(pthread_self(), SCHED_RR, &sp); mlockall(MCL_CURRENT | MCL_FUTURE); int channel = 0; struct timespec current; int i; int samplectr = 0; current = firsttime; for(i=0; i < MAX_ITERATIONS; i++){ clock_nanosleep(CLOCK_MONOTONIC, TIMER_ABSTIME, ¤t, NULL); sample_buffer[current_buffer][samplectr] = read_sample(channel); samplectr++; if(samplectr == PROCESSING_INTERVAL){ samplectr = 0; current_buffer = !current_buffer; sem_post(&sampling_done); } // Increment current time point current.tv_nsec += DELAY; if(current.tv_nsec >= 1000000000){ current.tv_nsec -= 1000000000; current.tv_sec++; } } return NULL; }
int read_bits_fsk(FILE *fp, int *bit, int *len) { int n, sample; float l; n = 0; do{ sample = read_sample(fp); // unsigned sample; if (sample == EOF) return EOF; // usample >= 0 par_alt = par; par = sign(sample); sample_count++; n++; } while (par*par_alt > 0); l = (float)n / samples_per_bit; // abw = n % samples_per_bit; *len = (int)(l+0.5); *bit = (1-par_alt)/2; // unten 1, oben -1 // inverse: *bit = (1+par_alt)/2; /* Y-offset ? */ return 0; }
/** * @brief read returns value in volts * @return value read from the input, softcalibrated and converted to physical value. */ double read() { return comedi_to_phys(read_sample(), range, maxdata); }
static int op_jack_write(const char *buffer, int count) { if (fail) { op_jack_exit(); return -OP_ERROR_INTERNAL; } if (!drop_done) { return 0; } int frame_size = sf_get_frame_size(sample_format); int channels = sf_get_channels(sample_format); size_t frames = count / frame_size; /* since this is the only place where the ringbuffers get * written, available space will only grow, therefore frames_min * is safe. */ size_t frames_min = SIZE_MAX; for (int c = 0; c < CHANNELS; c++) { size_t frames_available = jack_ringbuffer_write_space(ringbuffer[c]) / sizeof(jack_default_audio_sample_t); if (frames_available < frames_min) { frames_min = frames_available; } } if (frames > frames_min) { frames = frames_min; } jack_default_audio_sample_t buf[CHANNELS][buffer_size]; /* demux and convert to float */ for (int pos = 0; pos < count; ) { int frame = pos / frame_size; for (int c = 0; c < channels; c++) { int idx = pos + c * sample_bytes; /* for now, only 2 channels and mono are supported */ if (channel_map[c] == CHANNEL_POSITION_LEFT || channel_map[c] == CHANNEL_POSITION_MONO) { buf[0][frame] = read_sample(&buffer[idx]); } else if (channel_map[c] == CHANNEL_POSITION_RIGHT || channel_map[c] == CHANNEL_POSITION_MONO) { buf[1][frame] = read_sample(&buffer[idx]); } } pos += frame_size; } #ifdef HAVE_SAMPLERATE if (resample_ratio > 1.01f || resample_ratio < 0.99) { jack_default_audio_sample_t converted[buffer_size]; SRC_DATA src_data; for (int c = 0; c < CHANNELS; c++) { src_data.data_in = buf[c]; src_data.data_out = converted; src_data.input_frames = frames; src_data.output_frames = frames_min; src_data.src_ratio = resample_ratio; src_data.end_of_input = 0; int err = src_process(src_state[c], &src_data); if (err) { d_print("libsamplerate err %s\n", src_strerror(err)); } int byte_length = src_data.output_frames_gen * sizeof(jack_default_audio_sample_t); jack_ringbuffer_write(ringbuffer[c], (const char*) converted, byte_length); } return src_data.input_frames_used * frame_size; } else { #endif int byte_length = frames * sizeof(jack_default_audio_sample_t); for (int c = 0; c < CHANNELS; c++) { jack_ringbuffer_write(ringbuffer[c], (const char*) buf[c], byte_length); } return frames * frame_size; #ifdef HAVE_SAMPLERATE } #endif }
static void fz_process_mesh_type4(fz_context *ctx, fz_shade *shade, const fz_matrix *ctm, fz_mesh_processor *painter) { fz_stream *stream = fz_open_compressed_buffer(ctx, shade->buffer); fz_vertex v[4]; fz_vertex *va = &v[0]; fz_vertex *vb = &v[1]; fz_vertex *vc = &v[2]; fz_vertex *vd = &v[3]; int flag, i, ncomp = painter->ncomp; int bpflag = shade->u.m.bpflag; int bpcoord = shade->u.m.bpcoord; int bpcomp = shade->u.m.bpcomp; float x0 = shade->u.m.x0; float x1 = shade->u.m.x1; float y0 = shade->u.m.y0; float y1 = shade->u.m.y1; float *c0 = shade->u.m.c0; float *c1 = shade->u.m.c1; float x, y, c[FZ_MAX_COLORS]; fz_try(ctx) { while (!fz_is_eof_bits(ctx, stream)) { flag = fz_read_bits(ctx, stream, bpflag); x = read_sample(ctx, stream, bpcoord, x0, x1); y = read_sample(ctx, stream, bpcoord, y0, y1); for (i = 0; i < ncomp; i++) c[i] = read_sample(ctx, stream, bpcomp, c0[i], c1[i]); fz_prepare_vertex(ctx, painter, vd, ctm, x, y, c); switch (flag) { case 0: /* start new triangle */ SWAP(va, vd); fz_read_bits(ctx, stream, bpflag); x = read_sample(ctx, stream, bpcoord, x0, x1); y = read_sample(ctx, stream, bpcoord, y0, y1); for (i = 0; i < ncomp; i++) c[i] = read_sample(ctx, stream, bpcomp, c0[i], c1[i]); fz_prepare_vertex(ctx, painter, vb, ctm, x, y, c); fz_read_bits(ctx, stream, bpflag); x = read_sample(ctx, stream, bpcoord, x0, x1); y = read_sample(ctx, stream, bpcoord, y0, y1); for (i = 0; i < ncomp; i++) c[i] = read_sample(ctx, stream, bpcomp, c0[i], c1[i]); fz_prepare_vertex(ctx, painter, vc, ctm, x, y, c); paint_tri(ctx, painter, va, vb, vc); break; case 1: /* Vb, Vc, Vd */ SWAP(va, vb); SWAP(vb, vc); SWAP(vc, vd); paint_tri(ctx, painter, va, vb, vc); break; case 2: /* Va, Vc, Vd */ SWAP(vb, vc); SWAP(vc, vd); paint_tri(ctx, painter, va, vb, vc); break; } } } fz_always(ctx) { fz_drop_stream(ctx, stream); } fz_catch(ctx) { fz_rethrow(ctx); } }
static void pdf_load_type7_shade(fz_shade *shade, pdf_document *xref, pdf_obj *dict, int funcs, pdf_function **func) { fz_context *ctx = xref->ctx; struct mesh_params p; int haspatch, hasprevpatch; float prevc[4][FZ_MAX_COLORS]; fz_point prevp[16]; int ncomp; int i, k; fz_stream *stream; pdf_load_mesh_params(xref, dict, &p); if (funcs > 0) { ncomp = 1; pdf_sample_shade_function(ctx, shade, funcs, func, p.c0[0], p.c1[0]); } else ncomp = shade->colorspace->n; hasprevpatch = 0; stream = pdf_open_stream(xref, pdf_to_num(dict), pdf_to_gen(dict)); while (!fz_is_eof_bits(stream)) { float c[4][FZ_MAX_COLORS]; fz_point v[16]; int startcolor; int startpt; int flag; flag = fz_read_bits(stream, p.bpflag); if (flag == 0) { startpt = 0; startcolor = 0; } else { startpt = 4; startcolor = 2; } for (i = startpt; i < 16; i++) { v[i].x = read_sample(stream, p.bpcoord, p.x0, p.x1); v[i].y = read_sample(stream, p.bpcoord, p.y0, p.y1); } for (i = startcolor; i < 4; i++) { for (k = 0; k < ncomp; k++) c[i][k] = read_sample(stream, p.bpcomp, p.c0[k], p.c1[k]); } haspatch = 0; if (flag == 0) { haspatch = 1; } else if (flag == 1 && hasprevpatch) { v[0] = prevp[3]; v[1] = prevp[4]; v[2] = prevp[5]; v[3] = prevp[6]; memcpy(c[0], prevc[1], ncomp * sizeof(float)); memcpy(c[1], prevc[2], ncomp * sizeof(float)); haspatch = 1; } else if (flag == 2 && hasprevpatch) { v[0] = prevp[6]; v[1] = prevp[7]; v[2] = prevp[8]; v[3] = prevp[9]; memcpy(c[0], prevc[2], ncomp * sizeof(float)); memcpy(c[1], prevc[3], ncomp * sizeof(float)); haspatch = 1; } else if (flag == 3 && hasprevpatch) { v[0] = prevp[ 9]; v[1] = prevp[10]; v[2] = prevp[11]; v[3] = prevp[ 0]; memcpy(c[0], prevc[3], ncomp * sizeof(float)); memcpy(c[1], prevc[0], ncomp * sizeof(float)); haspatch = 1; } if (haspatch) { pdf_tensor_patch patch; pdf_make_tensor_patch(&patch, 7, v); for (i = 0; i < 4; i++) memcpy(patch.color[i], c[i], ncomp * sizeof(float)); draw_patch(ctx, shade, &patch, SUBDIV, SUBDIV); for (i = 0; i < 16; i++) prevp[i] = v[i]; for (i = 0; i < 4; i++) memcpy(prevc[i], c[i], FZ_MAX_COLORS * sizeof(float)); hasprevpatch = 1; } } fz_close(stream); }
static void pdf_load_type4_shade(fz_shade *shade, pdf_document *xref, pdf_obj *dict, int funcs, pdf_function **func) { fz_context *ctx = xref->ctx; struct mesh_params p; struct vertex va, vb, vc, vd; int ncomp; int flag; int i; fz_stream *stream; pdf_load_mesh_params(xref, dict, &p); if (funcs > 0) { ncomp = 1; pdf_sample_shade_function(ctx, shade, funcs, func, p.c0[0], p.c1[0]); } else ncomp = shade->colorspace->n; stream = pdf_open_stream(xref, pdf_to_num(dict), pdf_to_gen(dict)); while (!fz_is_eof_bits(stream)) { flag = fz_read_bits(stream, p.bpflag); vd.x = read_sample(stream, p.bpcoord, p.x0, p.x1); vd.y = read_sample(stream, p.bpcoord, p.y0, p.y1); for (i = 0; i < ncomp; i++) vd.c[i] = read_sample(stream, p.bpcomp, p.c0[i], p.c1[i]); switch (flag) { case 0: /* start new triangle */ va = vd; fz_read_bits(stream, p.bpflag); vb.x = read_sample(stream, p.bpcoord, p.x0, p.x1); vb.y = read_sample(stream, p.bpcoord, p.y0, p.y1); for (i = 0; i < ncomp; i++) vb.c[i] = read_sample(stream, p.bpcomp, p.c0[i], p.c1[i]); fz_read_bits(stream, p.bpflag); vc.x = read_sample(stream, p.bpcoord, p.x0, p.x1); vc.y = read_sample(stream, p.bpcoord, p.y0, p.y1); for (i = 0; i < ncomp; i++) vc.c[i] = read_sample(stream, p.bpcomp, p.c0[i], p.c1[i]); pdf_add_triangle(ctx, shade, &va, &vb, &vc); break; case 1: /* Vb, Vc, Vd */ va = vb; vb = vc; vc = vd; pdf_add_triangle(ctx, shade, &va, &vb, &vc); break; case 2: /* Va, Vc, Vd */ vb = vc; vc = vd; pdf_add_triangle(ctx, shade, &va, &vb, &vc); break; } } fz_close(stream); }
static void fz_process_mesh_type7(fz_context *ctx, fz_shade *shade, const fz_matrix *ctm, fz_mesh_processor *painter) { fz_stream *stream = fz_open_compressed_buffer(ctx, shade->buffer); int bpflag = shade->u.m.bpflag; int bpcoord = shade->u.m.bpcoord; int bpcomp = shade->u.m.bpcomp; float x0 = shade->u.m.x0; float x1 = shade->u.m.x1; float y0 = shade->u.m.y0; float y1 = shade->u.m.y1; float *c0 = shade->u.m.c0; float *c1 = shade->u.m.c1; float color_storage[2][4][FZ_MAX_COLORS]; fz_point point_storage[2][16]; int store = 0; int ncomp = painter->ncomp; int i, k; float (*prevc)[FZ_MAX_COLORS] = NULL; fz_point (*prevp) = NULL; fz_try(ctx) { while (!fz_is_eof_bits(ctx, stream)) { float (*c)[FZ_MAX_COLORS] = color_storage[store]; fz_point *v = point_storage[store]; int startcolor; int startpt; int flag; tensor_patch patch; flag = fz_read_bits(ctx, stream, bpflag); if (flag == 0) { startpt = 0; startcolor = 0; } else { startpt = 4; startcolor = 2; } for (i = startpt; i < 16; i++) { v[i].x = read_sample(ctx, stream, bpcoord, x0, x1); v[i].y = read_sample(ctx, stream, bpcoord, y0, y1); fz_transform_point(&v[i], ctm); } for (i = startcolor; i < 4; i++) { for (k = 0; k < ncomp; k++) c[i][k] = read_sample(ctx, stream, bpcomp, c0[k], c1[k]); } if (flag == 0) { } else if (flag == 1 && prevc) { v[0] = prevp[3]; v[1] = prevp[4]; v[2] = prevp[5]; v[3] = prevp[6]; memcpy(c[0], prevc[1], ncomp * sizeof(float)); memcpy(c[1], prevc[2], ncomp * sizeof(float)); } else if (flag == 2 && prevc) { v[0] = prevp[6]; v[1] = prevp[7]; v[2] = prevp[8]; v[3] = prevp[9]; memcpy(c[0], prevc[2], ncomp * sizeof(float)); memcpy(c[1], prevc[3], ncomp * sizeof(float)); } else if (flag == 3 && prevc) { v[0] = prevp[ 9]; v[1] = prevp[10]; v[2] = prevp[11]; v[3] = prevp[ 0]; memcpy(c[0], prevc[3], ncomp * sizeof(float)); memcpy(c[1], prevc[0], ncomp * sizeof(float)); } else continue; /* We have no patch! */ make_tensor_patch(&patch, 7, v); for (i = 0; i < 4; i++) memcpy(patch.color[i], c[i], ncomp * sizeof(float)); draw_patch(ctx, painter, &patch, SUBDIV, SUBDIV); prevp = v; prevc = c; store ^= 1; } } fz_always(ctx) { fz_drop_stream(ctx, stream); } fz_catch(ctx) { fz_rethrow(ctx); } }
SR_PRIV int bl_acme_receive_data(int fd, int revents, void *cb_data) { uint32_t cur_time, elapsed_time; uint64_t nrexpiration; struct sr_datafeed_packet packet, framep; struct sr_datafeed_analog analog; struct sr_dev_inst *sdi; struct sr_channel *ch; struct channel_priv *chp; struct dev_context *devc; GSList *chl, chonly; unsigned i; (void)fd; (void)revents; sdi = cb_data; if (!sdi) return TRUE; devc = sdi->priv; if (!devc) return TRUE; packet.type = SR_DF_ANALOG; packet.payload = &analog; memset(&analog, 0, sizeof(struct sr_datafeed_analog)); if (read(devc->timer_fd, &nrexpiration, sizeof(nrexpiration)) < 0) { sr_warn("Failed to read timer information"); return TRUE; } /* * We were not able to process the previous timer expiration, we are * overloaded. */ if (nrexpiration > 1) devc->samples_missed += nrexpiration - 1; /* * XXX This is a nasty workaround... * * At high sampling rates and maximum channels we are not able to * acquire samples fast enough, even though frontends still think * that samples arrive on time. This causes shifts in frontend * plots. * * To compensate for the delay we check if any clock events were * missed and - if so - don't really read the next value, but send * the same sample as fast as possible. We do it until we are back * on schedule. * * At high sampling rate this doesn't seem to visibly reduce the * accuracy. */ for (i = 0; i < nrexpiration; i++) { framep.type = SR_DF_FRAME_BEGIN; sr_session_send(cb_data, &framep); /* * Due to different units used in each channel we're sending * samples one-by-one. */ for (chl = sdi->channels; chl; chl = chl->next) { ch = chl->data; chp = ch->priv; if (!ch->enabled) continue; chonly.next = NULL; chonly.data = ch; analog.channels = &chonly; analog.num_samples = 1; analog.mq = channel_to_mq(chl->data); analog.unit = channel_to_unit(ch); if (i < 1) chp->val = read_sample(ch); analog.data = &chp->val; sr_session_send(cb_data, &packet); } framep.type = SR_DF_FRAME_END; sr_session_send(cb_data, &framep); } devc->samples_read++; if (devc->limit_samples > 0 && devc->samples_read >= devc->limit_samples) { sr_info("Requested number of samples reached."); sdi->driver->dev_acquisition_stop(sdi, cb_data); devc->last_sample_fin = g_get_monotonic_time(); return TRUE; } else if (devc->limit_msec > 0) { cur_time = g_get_monotonic_time(); elapsed_time = cur_time - devc->start_time; if (elapsed_time >= devc->limit_msec) { sr_info("Sampling time limit reached."); sdi->driver->dev_acquisition_stop(sdi, cb_data); devc->last_sample_fin = g_get_monotonic_time(); return TRUE; } } devc->last_sample_fin = g_get_monotonic_time(); return TRUE; }
static void fz_mesh_type7_process(fz_context *ctx, fz_shade *shade, const fz_matrix *ctm, fz_mesh_processor *painter) { fz_stream *stream = fz_open_compressed_buffer(ctx, shade->buffer); int bpflag = shade->u.m.bpflag; int bpcoord = shade->u.m.bpcoord; int bpcomp = shade->u.m.bpcomp; float x0 = shade->u.m.x0; float x1 = shade->u.m.x1; float y0 = shade->u.m.y0; float y1 = shade->u.m.y1; float *c0 = shade->u.m.c0; float *c1 = shade->u.m.c1; float prevc[4][FZ_MAX_COLORS]; fz_point prevp[16]; int ncomp; int i, k; int haspatch, hasprevpatch; fz_try(ctx) { hasprevpatch = 0; ncomp = (shade->use_function > 0 ? 1 : shade->colorspace->n); while (!fz_is_eof_bits(stream)) { float c[4][FZ_MAX_COLORS]; fz_point v[16]; int startcolor; int startpt; int flag; flag = fz_read_bits(stream, bpflag); if (flag == 0) { startpt = 0; startcolor = 0; } else { startpt = 4; startcolor = 2; } for (i = startpt; i < 16; i++) { v[i].x = read_sample(stream, bpcoord, x0, x1); v[i].y = read_sample(stream, bpcoord, y0, y1); fz_transform_point(&v[i], ctm); } for (i = startcolor; i < 4; i++) { for (k = 0; k < ncomp; k++) c[i][k] = read_sample(stream, bpcomp, c0[k], c1[k]); } haspatch = 0; if (flag == 0) { haspatch = 1; } else if (flag == 1 && hasprevpatch) { v[0] = prevp[3]; v[1] = prevp[4]; v[2] = prevp[5]; v[3] = prevp[6]; memcpy(c[0], prevc[1], ncomp * sizeof(float)); memcpy(c[1], prevc[2], ncomp * sizeof(float)); haspatch = 1; } else if (flag == 2 && hasprevpatch) { v[0] = prevp[6]; v[1] = prevp[7]; v[2] = prevp[8]; v[3] = prevp[9]; memcpy(c[0], prevc[2], ncomp * sizeof(float)); memcpy(c[1], prevc[3], ncomp * sizeof(float)); haspatch = 1; } else if (flag == 3 && hasprevpatch) { v[0] = prevp[ 9]; v[1] = prevp[10]; v[2] = prevp[11]; v[3] = prevp[ 0]; memcpy(c[0], prevc[3], ncomp * sizeof(float)); memcpy(c[1], prevc[0], ncomp * sizeof(float)); haspatch = 1; } if (haspatch) { tensor_patch patch; make_tensor_patch(&patch, 7, v); for (i = 0; i < 4; i++) memcpy(patch.color[i], c[i], ncomp * sizeof(float)); draw_patch(painter, &patch, SUBDIV, SUBDIV); for (i = 0; i < 16; i++) prevp[i] = v[i]; for (i = 0; i < 4; i++) memcpy(prevc[i], c[i], FZ_MAX_COLORS * sizeof(float)); hasprevpatch = 1; } } } fz_always(ctx) { fz_close(stream); } fz_catch(ctx) { fz_rethrow(ctx); } }
static void fz_mesh_type4_process(fz_context *ctx, fz_shade *shade, const fz_matrix *ctm, fz_mesh_processor *painter) { fz_stream *stream = fz_open_compressed_buffer(ctx, shade->buffer); fz_vertex v[4]; fz_vertex *va = &v[0]; fz_vertex *vb = &v[1]; fz_vertex *vc = &v[2]; fz_vertex *vd = &v[3]; int flag, i, ncomp; int bpflag = shade->u.m.bpflag; int bpcoord = shade->u.m.bpcoord; int bpcomp = shade->u.m.bpcomp; float x0 = shade->u.m.x0; float x1 = shade->u.m.x1; float y0 = shade->u.m.y0; float y1 = shade->u.m.y1; float *c0 = shade->u.m.c0; float *c1 = shade->u.m.c1; fz_try(ctx) { ncomp = (shade->use_function > 0 ? 1 : shade->colorspace->n); while (!fz_is_eof_bits(stream)) { flag = fz_read_bits(stream, bpflag); vd->p.x = read_sample(stream, bpcoord, x0, x1); vd->p.y = read_sample(stream, bpcoord, y0, y1); fz_transform_point(&vd->p, ctm); for (i = 0; i < ncomp; i++) vd->c[i] = read_sample(stream, bpcomp, c0[i], c1[i]); switch (flag) { case 0: /* start new triangle */ SWAP(va, vd); fz_read_bits(stream, bpflag); vb->p.x = read_sample(stream, bpcoord, x0, x1); vb->p.y = read_sample(stream, bpcoord, y0, y1); fz_transform_point(&vb->p, ctm); for (i = 0; i < ncomp; i++) vb->c[i] = read_sample(stream, bpcomp, c0[i], c1[i]); fz_read_bits(stream, bpflag); vc->p.x = read_sample(stream, bpcoord, x0, x1); vc->p.y = read_sample(stream, bpcoord, y0, y1); fz_transform_point(&vc->p, ctm); for (i = 0; i < ncomp; i++) vc->c[i] = read_sample(stream, bpcomp, c0[i], c1[i]); paint_tri(painter, va, vb, vc); break; case 1: /* Vb, Vc, Vd */ SWAP(va, vb); SWAP(vb, vc); SWAP(vc, vd); paint_tri(painter, va, vb, vc); break; case 2: /* Va, Vc, Vd */ SWAP(vb, vc); SWAP(vc, vd); paint_tri(painter, va, vb, vc); break; } } } fz_always(ctx) { fz_close(stream); } fz_catch(ctx) { fz_rethrow(ctx); } }