C++ (Cpp) rove_file_is_active Examples

Example #1

File: rove_group.c Project: killerisation/rove

void rove_group_activate_file(rove_file_t *file) {
	if( file->group->active_loop )
		if( file->group->active_loop != file )
			if( rove_file_is_active(file->group->active_loop) )
				rove_file_deactivate(file->group->active_loop);

	file->group->active_loop = file;
}

Example #2

File: jack.c Project: rknLA/rove

static int process(jack_nframes_t nframes, void *arg) {
	static int quantize_frames = 0;

#define on_quantize_boundary() (!quantize_frames)

	jack_default_audio_sample_t *out_l;
	jack_default_audio_sample_t *out_r;
	jack_default_audio_sample_t *in_l;
	jack_default_audio_sample_t *in_r;

	jack_nframes_t until_quantize, rate, nframes_left, nframes_offset, i;
	int j, group_count, next_bit;
	uint16_t qfield;

	jack_default_audio_sample_t *buffers[2];

	rove_group_t *g;
	rove_file_t *f;

	group_count = state.group_count;

	rate = jack_get_sample_rate(state.client);

	/* initialize each group's output buffers and zero them */
	for( i = 0; i < group_count; i++ ) {
		g = &state.groups[i];
		
		g->output_buffer_l = out_l = jack_port_get_buffer(g->outport_l, nframes);
		g->output_buffer_r = out_r = jack_port_get_buffer(g->outport_r, nframes);
		
		for( j = 0; j < nframes; j++ )
			out_l[j] = out_r[j] = 0;
	}

	for( nframes_offset = 0; nframes > 0; nframes -= nframes_left ) {
		if( on_quantize_boundary() ) {
			for( j = 0; j < group_count; j++ ) {
				g = &state.groups[j];
				f = g->active_loop;

				process_file(f);
			}

			qfield = state.monome->quantize_field >> 1;

			for( j = 0; qfield; qfield >>= next_bit ) {
				next_bit = ffs(qfield);
				j += next_bit;

				f = (rove_file_t *) state.monome->callbacks[j].data;
				process_file(f);
			}
		}

		until_quantize   = (state.snap_delay - quantize_frames);
		nframes_left     = MIN(until_quantize, nframes);
		quantize_frames += nframes_left;

		if( quantize_frames >= state.snap_delay - 1 )
			quantize_frames = 0;

		for( j = 0; j < group_count; j++ ) {
			g = &state.groups[j];

			if( !(f = g->active_loop) )
				continue;

			if( !rove_file_is_active(f) )
				continue;

			/* will eventually become an array of arbitrary size for better multichannel support */
			buffers[0] = g->output_buffer_l + nframes_offset;
			buffers[1] = g->output_buffer_r + nframes_offset;

			if( f->process_cb )
				f->process_cb(f, buffers, 2, nframes_left, rate);
		}

		nframes_offset += nframes_left;
	}

	out_l = jack_port_get_buffer(outport_l, nframes_offset);
	out_r = jack_port_get_buffer(outport_r, nframes_offset);
	in_l = jack_port_get_buffer(group_mix_inport_l, nframes_offset);
	in_r = jack_port_get_buffer(group_mix_inport_r, nframes_offset);

	memcpy(out_l, in_l, sizeof(jack_default_audio_sample_t) * nframes_offset);
	memcpy(out_r, in_r, sizeof(jack_default_audio_sample_t) * nframes_offset);

	return 0;
}