Exemple #1
0
        static void Main(string[] args)
        {
            WaveFormat waveFormat = new WaveFormat(44100, 16, 1);

            Oscillator freqOsc      = new Oscillator(Oscillator.WaveType.SineWave, waveFormat.SampleRate, new ConstantScalar(0.1f), new ConstantScalar(80.0f), new ConstantScalar(0), new ConstantScalar(100.0f));
            Oscillator ampOscVel    = new Oscillator(Oscillator.WaveType.SineWave, waveFormat.SampleRate, new ConstantScalar(0.05f), new ConstantScalar(8.0f), new ConstantScalar(0.5f), new ConstantScalar(8.0f));
            Oscillator ampOsc       = new Oscillator(Oscillator.WaveType.SawtoothWave, waveFormat.SampleRate, ampOscVel, new ConstantScalar(0.5f), new ConstantScalar(0), new ConstantScalar(1.1f));
            Oscillator variableFreq = new Oscillator(Oscillator.WaveType.SineWave, waveFormat.SampleRate, freqOsc, ampOsc, new ConstantScalar(0), new ConstantScalar(0));

            ScalarPassthrough scalarPassthru = new ScalarPassthrough(waveFormat, variableFreq);

            NoiseGenerator noiseGen  = new NoiseGenerator(waveFormat, NoiseGenerator.NoiseType.WhiteNoise);
            Oscillator     freqsweep = new Oscillator(Oscillator.WaveType.SineWave, waveFormat.SampleRate, new ConstantScalar(0.1f), new ConstantScalar(200), new ConstantScalar(0), new ConstantScalar(440));
            Oscillator     qsweep    = new Oscillator(Oscillator.WaveType.SineWave, waveFormat.SampleRate, new ConstantScalar(1.0f), new ConstantScalar(0.9f), new ConstantScalar(0), new ConstantScalar(1.0f)); //new ConstantScalar((float)(1.0 / Math.Sqrt(2)));
            //Oscillator gainSweep = new Oscillator(Oscillator.WaveType.TriangleWave, waveFormat.SampleRate, new ConstantScalar(0.025f), new ConstantScalar(2), new ConstantScalar(0), new ConstantScalar(6));
            ConstantScalar gainSweep = new ConstantScalar(6);

            SampleProcessor.SampleProcessor filter = new SampleProcessor.NotchFilter(waveFormat, freqsweep, qsweep, gainSweep, scalarPassthru);


            // distortion "pedal" on a minimally modified hard body electric guitar signal
            Oscillator     gainOsc     = new Oscillator(Oscillator.WaveType.SineWave, waveFormat.SampleRate, new ConstantScalar(0.5f), new ConstantScalar(2), new ConstantScalar(0), new ConstantScalar(5));
            Oscillator     cutoffOsc   = new Oscillator(Oscillator.WaveType.SineWave, waveFormat.SampleRate, new ConstantScalar(0.95f), new ConstantScalar(3), new ConstantScalar(0), new ConstantScalar(4));
            ConstantScalar cutoff      = new ConstantScalar(0.2f);
            IWaveSource    cleanguitar = CodecFactory.Instance.GetCodec(@"..\..\sampledata\guitar-sample.mp3"); // sample signal from single-pickup electric guitar. Recorded 8/14/20.
            IReadableAudioSource <float> convertedguitar = cleanguitar.ToMono().ToSampleSource();

            SampleProcessor.DistortionEffect distortion   = new SampleProcessor.DistortionEffect(waveFormat, gainOsc, cutoff, convertedguitar);
            SampleProcessor.SampleProcessor  reverbEffect = new SampleProcessor.ReverbEffect(waveFormat, new ConstantScalar(0.4f), new ConstantScalar(0.5f), waveFormat.SampleRate, distortion);

            BasicAudioController basicAudioController = new BasicAudioController(GetSoundOut(), 1, 44100);

            basicAudioController.addSource((ISampleSource)reverbEffect);
            basicAudioController.startPlaying();

            Console.ReadKey();
            basicAudioController.stopPlaying();
            return;

            MIDI.MIDIData data = MIDI.MIDIFileReader.readFile(@"..\..\sampledata\MIDI_sample.mid");

            MIDI.MIDIData testdata = new MIDI.MIDIData();
            testdata.format       = 0;
            testdata.timing       = MIDI.TimingScheme.TimeCode;
            testdata.timecode_fps = 24;
            testdata.timecode_sfr = 4;
            testdata.ntracks      = 1;
            testdata.tracks.Add(new MIDI.MIDITrack());
            MIDI.MIDIEvent event0 = new MIDI.MIDIEvent();
            MIDI.MIDIEvent event1 = new MIDI.MIDIEvent();

            event0.delta = 4 * 24 * 5; // wait 5 seconds from start
            event1.delta = 4 * 24 * 2; // 2 seconds

            //event0.type = MIDI.EventType.MIDIEvent;
            //event0.midieventtype = MIDI.MIDIEventType.NoteOn;
            //event0.val1 = 0; // channel 0
            //event0.val2 = 60; // middle C
            //event0.val3 = 1;

            //event1.type = MIDI.EventType.MIDIEvent;
            //event1.midieventtype = MIDI.MIDIEventType.NoteOff;
            //event1.val1 = 0; // channel 0
            //event1.val2 = 60; // middle C
            //event1.val3 = 1;

            //testdata.tracks[0].events.Add(event0);
            //testdata.tracks[0].events.Add(event1);


            MIDI.MIDIPlayer player = new MIDI.MIDIPlayer(data);
            Console.WriteLine("Track 1 events:");
            player.playTrack(1);

            Console.ReadKey();
            return;

            MIDIAudioController audioController = new MIDIAudioController(GetSoundOut());

            ChromaticScale.ChromaticScale scale = new ChromaticScale.ChromaticScale();
            audioController.startPlaying();
            SampleSource.WaveGenerator.WaveType wavetype = WaveGenerator.WaveType.SineWave;

            Console.ReadKey(); // wait for input
            for (int i = 0; i < scale.notes.Count(); i++)
            {
                float freq = scale.notes[i].base_freq / 2;
                Console.WriteLine(scale.notes[i].identifier[0] + " - " + freq + " - " + wavetype);
                audioController.updatePlaying(freq, wavetype);
                Console.ReadKey(); // wait for input

                wavetype = Next(wavetype);
            }
            for (int i = 0; i < scale.notes.Count(); i++)
            {
                Console.WriteLine(scale.notes[i].identifier[0] + " - " + scale.notes[i].base_freq.ToString() + " - " + wavetype);
                audioController.updatePlaying(scale.notes[i].base_freq, wavetype);
                Console.ReadKey(); // wait for input
                wavetype = Next(wavetype);
            }
            for (int i = 0; i < scale.notes.Count(); i++)
            {
                float freq = scale.notes[i].base_freq * 2;
                Console.WriteLine(scale.notes[i].identifier[0] + " - " + freq + " - " + wavetype);
                audioController.updatePlaying(freq, wavetype);
                Console.ReadKey(); // wait for input
                wavetype = Next(wavetype);
            }

            audioController.stopPlaying();
            audioController.Dispose();
        }
        public void playTrack(int trackIndex)
        {
            if (trackIndex >= data.tracks.Count)
            {
                throw new Exception(String.Format("Invalid track index {0} specified. Highest available track index is {1}", trackIndex, data.tracks.Count - 1));
            }

            // determine timing increments
            UInt64 time_inc_us    = 1;
            UInt64 time_offset_us = 0; // start time offset

            if (data.timing == TimingScheme.MetricalTiming)
            {
                // locate tempo event in track 0 (format 0 or 1) or playing track for format 2
                UInt64 us_per_quarternote = 500000; // 120 bpm default (I think)
                switch (data.format)
                {
                case 0:
                    for (int i = 0; i < data.tracks[trackIndex].events.Count; i++)
                    {
                        if (data.tracks[trackIndex].events[i].type == EventType.MetaEvent && data.tracks[trackIndex].events[i].metaeventtype == MetaEventType.Tempo)
                        {
                            Console.WriteLine("Tempo event with value {0} ({0:X2})", data.tracks[trackIndex].events[i].val1);
                            us_per_quarternote = data.tracks[trackIndex].events[i].val1;
                            time_inc_us        = us_per_quarternote / data.tickdiv;
                            break;
                        }
                    }
                    break;

                case 1:
                    for (int i = 0; i < data.tracks[0].events.Count; i++)
                    {
                        if (data.tracks[0].events[i].type == EventType.MetaEvent && data.tracks[0].events[i].metaeventtype == MetaEventType.Tempo)
                        {
                            Console.WriteLine("Tempo event with value {0} ({0:X2})", data.tracks[0].events[i].val1);
                            us_per_quarternote = data.tracks[0].events[i].val1;
                            time_inc_us        = us_per_quarternote / data.tickdiv; // should give us/p
                            break;
                        }
                        else if (data.tracks[0].events[i].type == EventType.MetaEvent && data.tracks[0].events[i].metaeventtype == MetaEventType.TimeSignature)
                        {
                            Console.WriteLine("TimeSignature event with value {0} {1} {2} {3} ({0:X2} {1:X2} {2:X2} {3:X2})", data.tracks[0].events[i].val1, data.tracks[0].events[i].val2, data.tracks[0].events[i].val3, data.tracks[0].events[i].val4);
                            break;
                        }
                    }
                    break;

                case 2:
                    for (int i = 0; i < data.tracks[trackIndex].events.Count; i++)
                    {
                        if (data.tracks[trackIndex].events[i].type == EventType.MetaEvent && data.tracks[trackIndex].events[i].metaeventtype == MetaEventType.Tempo)
                        {
                            Console.WriteLine("Tempo event with value {0} ({0:X2})", data.tracks[trackIndex].events[i].val1);
                            us_per_quarternote = data.tracks[trackIndex].events[i].val1;
                            time_inc_us        = us_per_quarternote / data.tickdiv;
                            break;
                        }
                    }
                    break;

                default:
                    break;
                }
            }
            else
            {
                // 1 tick is the sub-frame resolution
                time_inc_us = (UInt64)(1000000 / (data.timecode_fps * data.timecode_sfr));
            }

            UInt64 ticks       = 0; // ticks are in microseconds
            int    event_index = 0;
            UInt64 curr_ticks  = data.tracks[trackIndex].events[0].delta;
            MIDIAudioController audioController = new MIDIAudioController(GetSoundOut());

            audioController.startPlayingMidi();
            while (event_index < data.tracks[trackIndex].events.Count)
            {
                while (curr_ticks == 0 && event_index < data.tracks[trackIndex].events.Count)
                {
                    if (data.tracks[trackIndex].events[event_index].type == EventType.MIDIEvent)
                    {
                        MIDIEvent the_event = data.tracks[trackIndex].events[event_index];
                        if (the_event.val1 == 0) // channel 0 for note events
                        {
                            switch (the_event.midieventtype)
                            {
                            case MIDIEventType.NoteOn:
                                audioController.startPlayingMIDIKey((int)the_event.val2, (float)the_event.val3 * 0.0001f);
                                Console.WriteLine("NoteOn {0} {1}", the_event.val2, the_event.val3);
                                break;

                            case MIDIEventType.NoteOff:
                                audioController.stopPlayingMIDIKey((int)the_event.val2, (float)the_event.val3 * 0.0001f);
                                Console.WriteLine("NoteOff {0} {1}", the_event.val2, the_event.val3);
                                break;

                            default:
                                break;
                            }
                        }
                    }
                    event_index += 1;
                    if (event_index >= data.tracks[trackIndex].events.Count)
                    {
                        break;
                    }
                    curr_ticks = data.tracks[trackIndex].events[event_index].delta;
                }
                audioController.updateMidiKeys(1.0f); // 1 increment
                Thread.Sleep((int)time_inc_us / 1000);
                ticks += time_inc_us;
                curr_ticks--;

                if (event_index >= data.tracks[trackIndex].events.Count)
                {
                    break;
                }
                //Console.WriteLine("ticks {0} event_index {1} ({2}) curr_ticks {3}", ticks, event_index, data.tracks[trackIndex].events[event_index].delta, curr_ticks);
            }
        }