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