示例#1
0
void MainWindow::buttonSixPressed() {
    m_currentNote = 5;
    Note * note = m_sequencerController->getSequencer()->getNotes().at( 5 );
    Oscillator * oscillator = note->getOscillator();

    float frequency = oscillator->getFrequency();
    float amplitude = note->getAmplitude();

    blockSignals( true );
    if( note->getWavetype() == FM ) {
        FmOscillator * fm = static_cast<FmOscillator *>( oscillator );
        ui->harmonicitySpinner->setEnabled( true );
        ui->modIndexSpinner->setEnabled( true );
        ui->harmonicitySpinner->setValue( fm->getHarmonicity() );
        ui->modIndexSpinner->setValue( fm->getModulationIndex() );
    } else {
        ui->harmonicitySpinner->setEnabled( false );
        ui->modIndexSpinner->setEnabled( false );
    }

    ui->frequencySpinner->setValue( frequency );
    ui->amplitudeSlider->setValue( amplitude * 100.0f );
    ui->bpmBox->setValue( m_sequencerController->getBpm() );

    setComboBox( note->getWavetype() );
    blockSignals( false );
}
示例#2
0
文件: main.cpp 项目: eriser/noisebox
int main() {
	printf("Noisebox!\n");
	

	osc.setOscType(kOSC_TYPE_SAW , SAMPLERATE);
	osc.frequency = 440;
	
	lfo.setOscType(kOSC_TYPE_SAW, SAMPLERATE);
	lfo.frequency = 0.1;
	




	if(startMidi()!=0) {
		
		return 1;
	}
	
	if(startAudio()!=0) {
		return 1;
	}

	

	cout << "\nPlaying ... press any to quit.\n";
	while ( cin.peek() == EOF ) {
         usleep(100*1000);
	}

	printf("Bye!\n");
}
// ---------------------------------------------------------------------------
//      accum_samples
// ---------------------------------------------------------------------------
//      helper
//
static void accum_samples( CSOUND * csound,
                           Oscillator & oscil, Breakpoint & bp,
                           double * bufbegin )
{
  if( bp.amplitude() > 0 || oscil.amplitude() > 0 )
    {
      double radfreq = radianFreq( csound, bp.frequency() );
      double amp = bp.amplitude();
      double bw = bp.bandwidth();

      //        initialize the oscillator if it is changing from zero
      //        to non-zero amplitude in this  control block:
      if ( oscil.amplitude() == 0. )
        {
          //    don't initialize with bogus values, Oscillator
          //    only guards against out-of-range target values
          //    in generateSamples(), parameter mutators are
          //    dangerous:

          if ( radfreq > PI )   //      don't alias
            amp = 0.;

          if ( bw > 1. )        //      clamp bandwidth
            bw = 1.;
          else if ( bw < 0. )
            bw = 0.;

#ifdef DEBUG_LORISGENS
        /*
          std::cerr << "initializing oscillator " << std::endl;
          std::cerr << "parameters: " << bp.frequency() << "  ";
          std::cerr << amp << "  " << bw << std::endl;
        */
#endif

          //    initialize frequency, amplitude, and bandwidth to
          //    their target values:
          /*
            oscil.setRadianFreq( radfreq );
            oscil.setAmplitude( amp );
            oscil.setBandwidth( bw );
          */
          oscil.resetEnvelopes( bp, (double) csound->esr );

          //    roll back the phase:
          oscil.resetPhase( bp.phase() - ( radfreq * (double) csound->ksmps ) );
        }

      //        accumulate samples into buffer:
      // oscil.generateSamples( bufbegin, bufbegin + nsamps, radfreq, amp, bw );
      oscil.oscillate( bufbegin, bufbegin + csound->ksmps,
                       bp, (double) csound->esr );
    }
}
示例#4
0
文件: main.cpp 项目: eriser/noisebox
//////////////////////////////////////////
// the magic
int audioCallback( void *outputBuffer, void *inputBuffer, unsigned int length,
         double streamTime, RtAudioStreamStatus status, void *userData )
{

	float *buffer = (float *) outputBuffer;

	if ( status )
		std::cout << "Stream underflow detected!" << std::endl;
	float out = 0;
	for(int i = 0; i < length; i++) {
	
		float of = oscFreq.get();
		lfo.frequency = lfoFreq.get();
		
		
		if(modType==MOD_PITCH) {
			osc.frequency = of - modAmount.get()*map(lfo.getSample(), -1, 1, 0, of);
		} else {
			osc.frequency = of;
		}
		
		
		float filtFreq = filterFreq.get();
		
		if(modType==MOD_CUTOFF) {
			filtFreq = filtFreq - modAmount.get()*map(lfo.getSample(), -1, 1, 40, filtFreq);
		}
		
		float s = osc.getSample();
		
		out = filter.lores(s, filtFreq, filterRes.get());
		out = distort(out*distVolume);
		
		if(out!=out) { // NaN prevention
			out = s;
		}
		out *= 0.7f;
		
		if(mute) out = 0;
		buffer[i*2] = out;
		buffer[i*2+1] = out;
	}
	
  return 0;
}
示例#5
0
//This function shows a part of how the modules work internally, based on a sample-by-sample model.
void modularSynthInternals(void) {
	//Here we create an Oscillator
	Oscillator osc;
	osc.frequency = 1; //We'll set the frequency to 1 Hz
	osc.setGeneratorFunction(Oscillator::sine); //Set the waveform to a sine wave.

	//We are going to manually tell the oscillator that the sample rate is 40 samples per second
	ModuleControlData_t controlData;
	controlData.sampleRate = 40;
	osc.setData(controlData);

	//If the frequency is 1 Hz (1 cycle per second) and there are 40 samples per second, if we take 40 samples,
	//we should expect to see a whole sine wave (0 to 1 to 0 to -1 and back to 0). So, we call getNextSample()
	//40 times to advance 40 samples through the process of generating the waveform and print the result.
	for (int i = 0; i < 40; i++) {
		cout << osc.getNextSample() << endl;
	}
}
示例#6
0
文件: main.cpp 项目: eriser/noisebox
//////////////////////////////////////////
// The main midi callback
void midiCallback( double deltatime, std::vector< unsigned char > *message, void *userData )
{

  unsigned int nBytes = message->size();
  for ( unsigned int i=0; i<nBytes; i++ )
    std::cout << "Byte " << i << " = " << (int)message->at(i) << ", ";
  if ( nBytes > 0 )
    std::cout << "stamp = " << deltatime << std::endl;


    if(message->at(0)==144) {
    	// note on
    	mute = false;
    	int oscType = message->at(1) - 36;
    	oscType %= 4;
    	osc.setOscType(oscType, SAMPLERATE);
    } else if(message->at(0)==128) {
    	// note off
    	if(message->at(1)<=39) {
    		mute = true;
    	}
    } else if(message->at(0)==176) {
    	int val = message->at(2);
		switch(message->at(1)) {
			case 1:
				oscFreq.set(logMap(val, 0, 127, 20, 8000));
				break; 
			case 2:
				lfoFreq.set(logMap(val, 0, 127, 0.01, 100));
				break;
			case 3:
				modAmount.set(map(val, 0, 127, 0, 1));
			 	break;
			 case 4:
				if(val>63) {
					modType = MOD_PITCH;
				} else {
					modType = MOD_CUTOFF;
				}
			 	break;
			 	
			 case 5:
				filterFreq.set(map(val, 0, 127, 50, 4000));
			 	break;
			 case 6:
			 	filterRes.set(map(val, 0, 127, 1, 10));
				break;
			case 7:
				distVolume = logMap(val, 0, 127, 0, 10);
			 	break;
			 case 8:
			 	distGain = logMap(val, 0, 127, 0, 10);
				break;
		}
	}
}
示例#7
0
  void processAudio(AudioBuffer &buffer) {
    FloatArray left = buffer.getSamples(LEFT_CHANNEL);
    FloatArray right = buffer.getSamples(RIGHT_CHANNEL);
    for(int i = 0; i<buffer.getSize(); i++){
      if(abs(last-target) < 0.001){
	last = target;
	target = noise->getNextSample()*range;
      }
      left[i] = last;
      last += getIncrement();
      right[i] = hz.voltsToSample(quantize(hz.sampleToVolts(right[i])));
    }
  }
示例#8
0
int main( int argc, char ** argv ) {
	if( argc <= 2 ) {
		std::cout << "please provide valid command line arguments. Syntax is '/wav_writer <filename.wav> <oscillatortype>'" << std::endl;
		return -1;
	}

	std::string filename;
	filename = "res/";
	filename += argv[1];

	Oscillator * oscillator;
	Oscillator * oscillatorTwo = 0;

	if( strcmp( argv[2], "triangle" ) == 0 ) {
		oscillator = new TriangleOscillator();
	} else if( strcmp( argv[2], "rsaw" ) == 0 ) {
		oscillator = new RisingSawtoothOscillator();
	} else if( strcmp( argv[2], "additive" ) == 0 ) {
		oscillator = new SineOscillator();
		oscillatorTwo = new SineOscillator( 523.0f );
	} else {
		oscillator = new SineOscillator();
	}

	WavWriter wavWriter( filename );

	wavWriter.setBitsPerSample( 16 );
	wavWriter.setStereo( false );
	
	int dataSize = 5 * oscillator->getSampleRate() * 2; // duration in seconds * sample rate * bytes per sample
	char * data = new char[dataSize];
	
	if( oscillatorTwo != 0 ) {
		for( int i = 0; i < dataSize - 1; i+=2 ) {
			ByteConverter::shortToBytes( oscillator->nextSample() / 2 + oscillatorTwo->nextSample() / 2, data, i );
		}
	} else {
		for( int i = 0; i < dataSize - 1; i+=2 ) {
			ByteConverter::shortToBytes( oscillator->nextSample(), data, i );
		}
	}

	if( wavWriter.writeWav( data, dataSize ) ) {
		std::cout << "hooray! it worked!" << std::endl;
	} else {
		std::cout << "aww, no worky." << std::endl;
	}

	delete oscillator;
	if( oscillatorTwo != 0 ) {
		delete oscillatorTwo;
	}

	return 0;
}
  float getNextSample(){
    float vca1 = sine->getNextSample();
    vca1 += chirp->getNextSample();
    vca1 *= env1->getNextSample();

    float vca2 = 0.0f;
    vca2 += impulse->getNextSample();
    // vca2 += filter->process(noise->getNextSample());
    // vca2 *= env2->getNextSample();
    vca2 += noise->getNextSample();
    vca2 = filter->process(vca2);
    vca2 *= env2->getNextSample();
    
    float sample = vca1*(1.0-balance) + vca2*balance;
    return sample;
  }
示例#10
0
//--------------------------------------------------------------
void testApp::mousePressed(int x, int y, int button){
    Oscillator newOsc;
    newOsc.setup(50);
    osc.push_back(newOsc);

}
示例#11
0
void runExperiment(void) {

	Input.setup(true, true);

	StreamOutput output; //StreamOutput is one of the ways to get sound out of a modular synth. 
		//It requires a CX_SoundStream to play the sounds, which is configured below.

	//Configure the sound stream. See the soundBuffer example for more information about these values. 
	//Also see the documentation for CX_SoundStream::Configuration.
	CX_SoundStream::Configuration ssConfig;
	ssConfig.api = RtAudio::Api::WINDOWS_DS;
	ssConfig.outputChannels = 2;
	ssConfig.sampleRate = 48000;
	ssConfig.bufferSize = 4096;
	ssConfig.streamOptions.numberOfBuffers = 2;

	CX_SoundStream ss;
	ss.setup(ssConfig);
	ss.start();

	output.setup(&ss); //Set the CX_SoundStream ss as the sound stream for the StreamOutput.


	//Now that we have an output, we can make a really basic synthesizer:
	Oscillator osc;
	osc.setGeneratorFunction(Oscillator::saw); //We'll generate a saw wave.
	osc.frequency = 440; //At 440 Hz (A4)

	Multiplier gain;
	gain.setGain(-20); //Make the output quieter by 20 decibels

	osc >> gain >> output; //operator>> means that osc feeds into gain which then feeds into output.

	cout << "Let's listen to a saw wave for 3 seconds" << endl;
	Clock.sleep(CX_Seconds(3));
	

	//Lets add a low pass filter to the chain.
	Filter lpf;
	lpf.setType(Filter::LOW_PASS);
	lpf.cutoff = 600; //Set the cutoff frequency of the filter to 600 Hz, so frequencies past there get attentuated.

	osc >> lpf >> gain >> output; //Reconnect things so that the osc goes through the filter.

	cout << "Now a filtered saw" << endl;
	Clock.sleep(CX_Seconds(3));

	//Lets add an envelope
	Envelope env;
	env.a = 0.5; //Set the attack time to .5 seconds (i.e. 500 ms). This is the length of time needed to go from 0 to 1.
	env.d = 0.5; //Decay time, to go from 1 to the sustain level
	env.s = 0.4; //Sustain at .4 times the full amplitude, which is reached at the end of the attack
	env.r = 1.0; //Release time, time to go from the sustain level to 0

	osc >> lpf >> env >> gain >> output;

	cout << "Now an amp envelope on the sound will give it a slow onset on offset." << endl;
	env.attack();
	Clock.sleep(CX_Seconds(3));
	env.release();
	Clock.sleep(CX_Seconds(2));


	/* You can route the output from a modular synth into a SoundBufferOutput,
	which allows you to use the sounds you make in that same way that you would
	use a sound buffer, including saving them to a file. */
	SoundBufferOutput sbOut;

	gain >> sbOut; //Without changing the other connections, route gain into sbOut, disconnecting it from output.
	sbOut.setup(44100); //Use the same sample rate as the sound stream

	env.attack(); //Start by priming the evelope so that sound comes out of it.
	sbOut.sampleData(CX_Seconds(2)); //Sample 1 second worth of data at the given sample rate.

	env.release(); //Now relase the evelope (go from the sustain phase to the release phase
	sbOut.sampleData(CX_Seconds(1)); //And sample an additional 1/2 second of data.

	//Now that you're done sampling, you can use the sound buffer that you made!
	sbOut.sb; // <-- This is the sound buffer. See the soundBuffer example for to see how to use it in detail.
	sbOut.sb.normalize(); //Its a good idea to normalize before saving to a file to get the levels up.
	sbOut.sb.writeToFile("Envelope sample.wav"); //You can save it to file, like in this example, or play it using a CX_SoundBufferPlayer.



	//Now we make a relatively complex synthesizer, with two oscillators, an LFO
	//modifying the frequency of one of the oscillators, an envelope modifying the cutoff frequency
	//of the filter, and a mixer to combine together the oscillators.
	Mixer oscMix;

	osc >> gain >> oscMix; //Run the main oscillator into the mixer.

	//This oscillator doubles the main oscillator, except that its frequency is modified by an LFO.
	Oscillator doublingOsc;
	doublingOsc.setGeneratorFunction(Oscillator::saw);

	Oscillator lfo;
	lfo.setGeneratorFunction(Oscillator::sine);
	lfo.frequency = 5;

	Multiplier lfoGain;
	lfoGain.amount = 2;

	Adder lfoOffset;
	lfoOffset.amount = osc.frequency;

	//Feed to lfo signal (which goes from -1 to 1) into a multiplier to make its range a little bigger, then add an offset to put
	//it into a good frequency range. This offset will be changed along with the mainOsc frequency.
	lfo >> lfoGain >> lfoOffset >> doublingOsc.frequency;
	
	Multiplier doublingOscGain;

	doublingOsc >> doublingOscGain >> oscMix; //Now run the doubliing oscillator into the mixer.


	//Run a mod envelope into the filter cutoff frequency.
	Envelope modEnv;
	modEnv.a = .1;
	modEnv.d = .1;
	modEnv.s = .5;
	modEnv.r = .2;

	Multiplier modMult;
	modMult.amount = 1000;

	Adder modOffset;
	modOffset.amount = 400;

	modEnv >> modMult >> modOffset >> lpf.cutoff;

	//Change the amp envelope settings a little
	env.a = .3;
	env.d = .2;
	env.s = .6;
	env.r = .2;

	//After the mixer, filter to mixed data, attach the amp envelope, and route into the output.
	oscMix >> lpf >> env >> output;

	drawInformation();

	while (true) {
		if (Input.pollEvents()) {
			while (Input.Mouse.availableEvents()) {
				CX_Mouse::Event ev = Input.Mouse.getNextEvent();
				if (ev.type == CX_Mouse::MOVED || ev.type == CX_Mouse::DRAGGED) {
					osc.frequency = pow(ev.x, 1.3);
					lfoOffset.amount = osc.frequency; //We don't set the frequency of the doubling osc directly,
						//instead we set the offset for the lfo that feeds into the frequency of the doubling osc.

					double g = -ev.y / 20;
					gain.setGain(g);
					doublingOscGain.setGain(g);

					cout << "Frequency = " << osc.frequency.getValue() << endl;
					cout << "Gain = " << g << endl;
				}

				if (ev.type == CX_Mouse::PRESSED) {
					env.attack();
					modEnv.attack();
				}

				if (ev.type == CX_Mouse::RELEASED) {
					env.release();
					modEnv.release();
				}
			}

			while (Input.Keyboard.availableEvents()) {
				CX_Keyboard::Event ev = Input.Keyboard.getNextEvent();

				ss.hasSwappedSinceLastCheck();
				while (!ss.hasSwappedSinceLastCheck())
					;

				switch (ev.key) {
				case 'T': 
					osc.setGeneratorFunction(Oscillator::triangle);
					doublingOsc.setGeneratorFunction(Oscillator::triangle);
					break;
				case 'Q': 
					osc.setGeneratorFunction(Oscillator::square);
					doublingOsc.setGeneratorFunction(Oscillator::square);
					break;
				case 'I': 
					osc.setGeneratorFunction(Oscillator::sine);
					doublingOsc.setGeneratorFunction(Oscillator::sine);
					break;
				case 'A': 
					osc.setGeneratorFunction(Oscillator::saw);
					doublingOsc.setGeneratorFunction(Oscillator::saw);
					break;
				case 'W': 
					osc.setGeneratorFunction(Oscillator::whiteNoise);
					doublingOsc.setGeneratorFunction(Oscillator::whiteNoise);
					break;
				}
			}

			drawInformation();
		}
	}
}
示例#12
0
文件: main.cpp 项目: flit/bass.slab
void init_audio_synth()
{
    AudioOutput::Buffer buf;
    buf.dataSize = BUFFER_SIZE * CHANNEL_NUM * sizeof(int16_t);
    buf.data = (uint8_t *)&g_outBuf[0][0];
    g_audioOut.add_buffer(&buf);
    buf.data = (uint8_t *)&g_outBuf[1][0];
    g_audioOut.add_buffer(&buf);

    g_audioOut.set_source(&g_audioOutConverter);
    AudioBuffer audioBuf(&g_audioBuf[0], BUFFER_SIZE);
    g_audioOutConverter.set_buffer(audioBuf);
    g_audioOutConverter.set_source(&g_mixer);

    g_kickSeq.set_sample_rate(kSampleRate);
    g_kickSeq.set_tempo(100.0f);
//     g_kickSeq.set_sequence("x---x---x---x-x-x---x---x---x---xx--x--x--xxx-x-");
    g_kickSeq.set_sequence("x---------x---------"); //x-x----xx---");
    g_kickSeq.init();

    g_kickGen.set_sample_rate(kSampleRate);
    g_kickGen.set_sequence(&g_kickSeq);
    g_kickGen.set_freq(50.0f);
    g_kickGen.enable_sustain(false);
    g_kickGen.init();
    g_kickGen.set_attack(0.01f);
    g_kickGen.set_release(0.6f);

    g_bassSeq.set_sample_rate(kSampleRate);
    g_bassSeq.set_tempo(100.0f);
    g_bassSeq.set_sequence("--s>>>>p--------"); //"--s>>>p-----s>>>>>>p----");
    g_bassSeq.init();

    g_bassGen.set_sample_rate(kSampleRate);
    g_bassGen.set_sequence(&g_bassSeq);
    g_bassGen.set_freq(80.0f);
    g_bassGen.enable_sustain(true);
    g_bassGen.init();
    g_bassGen.set_attack(0.3f);
    g_bassGen.set_release(3.0f);

    g_filter.set_sample_rate(kSampleRate);
    g_filter.set_frequency(120.0f);
    g_filter.set_q(0.4f);
    g_filter.recompute_coefficients();
    g_filter.set_input(&g_bassGen);

    g_delay.set_sample_rate(kSampleRate);
    g_delay.set_maximum_delay_seconds(0.4f);
    g_delay.set_delay_samples(g_kickSeq.get_samples_per_beat());
    g_delay.set_feedback(0.7f);
    g_delay.set_wet_mix(0.5f);
    g_delay.set_dry_mix(0.8f);
    g_delay.set_input(&g_kickGen);

    AudioBuffer mixBuf(&g_mixBuf[0], BUFFER_SIZE);
    g_mixer.set_buffer(mixBuf);
    g_mixer.set_input_count(2);
    g_mixer.set_input(0, &g_delay, 0.5f);
    g_mixer.set_input(1, &g_bassGen, 0.34f);
//     g_mixer.set_input(2, &g_tickGen, 0.3f);
}