Exemplo n.º 1
0
        /// <summary>
        /// Initializes default audio endpoint and attaches sound listener into it
        /// </summary>
        protected static void Init()
        {
            if (isInitted)
            {
                return;
            }

            lock (lockObj)
            {
                //Double checked locking
                if (isInitted)
                {
                    return;
                }

                //Get default audio endpoint and attach sound listener
                var audioEndpoint = NAudioHelper.GetDefaultAudioEndpoint();
                if (audioEndpoint != null)
                {
                    NAudioHelper.AttachSoundLevelListener(audioEndpoint);
                }

                //Set isInitted to true to make sure the logic executes only once
                isInitted = true;
            }
        }
Exemplo n.º 2
0
        public async Task <double> GetMediaDurationInMinUsingMediaElement(string mediaFile)
        {
            tb1.Text = Title = $"{System.IO.Path.GetFileName(mediaFile)} ";

            var ttlMin = await getDurnUsingMediaElnt(mediaFile);

            for (int j = 20; j > 0 && ttlMin == ConstHelper.Unknown4004Duration; j--)
            {
                await Task.Delay(3000);

                await Application.Current.Dispatcher.BeginInvoke(new Action(async() => { ttlMin = await getDurnUsingMediaElnt(mediaFile); }));

                tb1.Text = Title += $"{j} ";
            }

            if (ttlMin == ConstHelper.Unknown4004Duration || ttlMin > 300)
            {
                ttlMin = NAudioHelper.GetDuration(mediaFile).TotalMinutes;
            }

            tb1.Text = Title += $" => {ttlMin:N1}min.";

            tb1.Foreground = new SolidColorBrush((ttlMin == ConstHelper.Unknown4004Duration || ttlMin > 300) ? Colors.Red : Colors.Green);

            return(ttlMin);
        }
Exemplo n.º 3
0
        private MemoryStream GetResolutionNoDO(string doNoteName, ResolutionType resolutionType)
        {
            double   bpm = double.Parse(ConfigurationManager.AppSettings["BPM"]);
            double   quarterNotemillis   = (60 / bpm) * 1000;
            TimeSpan quarterNoteDuration = TimeSpan.FromMilliseconds(quarterNotemillis);
            TimeSpan halfNoteDuration    = quarterNoteDuration.Add(quarterNoteDuration);
            TimeSpan wholeNoteDuration   = halfNoteDuration.Add(halfNoteDuration);

            string doFileName = NAudioHelper.GetFileNameFromNoteName(doNoteName);

            doFileName = Path.GetFileName(doFileName);
            int doNoteNumber = int.Parse(doFileName.Split('.')[0]);

            ISampleProvider note1;
            ISampleProvider note2;

            switch (resolutionType)
            {
            case ResolutionType.DoDoReDo:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor2nd, halfNoteDuration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber, wholeNoteDuration);
                break;

            case ResolutionType.DoDoFaMi:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfect4th, halfNoteDuration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor3rd, wholeNoteDuration);
                break;

            case ResolutionType.DoDoLaSo:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor6th, halfNoteDuration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfect5th, wholeNoteDuration);
                break;

            case ResolutionType.DoDoTiHighDo:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor7th, halfNoteDuration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber + 12, wholeNoteDuration);
                break;

            case ResolutionType.DoDoLowTiDo:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.DownMinor2nd, halfNoteDuration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber, wholeNoteDuration);
                break;

            default:
                throw new NotSupportedException($"ResolutionType '{resolutionType}' is not supported.");
            }

            ISampleProvider phrase = note1
                                     .FollowedBy(note2);

            SampleToWaveProvider stwp = new SampleToWaveProvider(phrase);

            MemoryStream wavStream = new MemoryStream();

            WaveFileWriter.WriteWavFileToStream(wavStream, stwp);
            wavStream.Position = 0;
            return(wavStream);
        }
Exemplo n.º 4
0
        private MixingSampleProvider CreateMajorTriad(string doNoteName, string chordAndInversion, string movement)
        {
            _log.Debug($"doNoteName: {doNoteName}, chordAndInversion: {chordAndInversion}, movement: {movement ?? "null"}");
            double   bpm = double.Parse(ConfigurationManager.AppSettings["BPM"]);
            double   quarterNoteMillis = (60 / bpm) * 1000;
            double   halfNoteMillis    = quarterNoteMillis * 2;
            TimeSpan noteDuration      = TimeSpan.FromMilliseconds(halfNoteMillis);

            string doNoteRegisterString = Regex.Replace(doNoteName, "[A-G#b]", "");
            int    doNoteRegister       = int.Parse(doNoteRegisterString);

            string[] parts = chordAndInversion.Trim().Split(' ');
            string   chord = parts[0].Trim();

            string        inversion = parts[1].Trim();
            InversionType inversionType;

            switch (inversion)
            {
            case "(root)":
                inversionType = InversionType.Root;
                break;

            case "(1st)":
                inversionType = InversionType.LowFirst;
                break;

            case "(2nd)":
                inversionType = InversionType.LowSecond;
                break;

            default:
                inversionType = InversionType.Root;
                break;
            }

            string thisChordRootNote = GetClosestNote(doNoteName, chord);

            //thisChordRootNote = chord + doNoteRegister.ToString();
            _log.Debug($"doNoteName: {doNoteName}, thisChordRootNote: {thisChordRootNote}");
            string doFileName = NAudioHelper.GetFileNameFromNoteName(thisChordRootNote);

            doFileName = Path.GetFileName(doFileName);
            int doNoteNumber = int.Parse(doFileName.Split('.')[0]);

            ISampleProvider[] samples;
            samples = Inversion.CreateTriadInversionEx(inversionType, noteDuration, doNoteNumber, doNoteNumber + Interval.UpMajor3rd, doNoteNumber + Interval.UpPerfect5th, doNoteNumber.BassNoteNumber());

            MixingSampleProvider msp = new MixingSampleProvider(samples[0].WaveFormat);

            msp.AddMixerInput(samples[0]);
            msp.AddMixerInput(samples[1]);
            msp.AddMixerInput(samples[2]);
            msp.AddMixerInput(samples[3]);

            return(msp);
        }
Exemplo n.º 5
0
        private MemoryStream GetHarmonicDrill(string doNoteName, L1C7HarmonicDrillType drillType)
        {
            TimeSpan duration = TimeSpan.FromSeconds(3);

            string doFileName = NAudioHelper.GetFileNameFromNoteName(doNoteName);

            doFileName = Path.GetFileName(doFileName);
            int doNoteNumber = int.Parse(doFileName.Split('.')[0]);

            ISampleProvider note1, note2;

            switch (drillType)
            {
            // Minor 2nds.
            case L1C7HarmonicDrillType.MiFa2nd:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor3rd, duration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfect4th, duration);
                break;

            case L1C7HarmonicDrillType.TiDo2nd:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor7th, duration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfectOctave, duration);
                break;

            // Major 7ths.
            case L1C7HarmonicDrillType.DoTi7th:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber, duration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor7th, duration);
                break;

            case L1C7HarmonicDrillType.FaMi7th:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfect4th, duration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor10th, duration);
                break;

            default:
                throw new NotSupportedException($"L1C7HarmonicDrillType '{drillType}' is not supported.");
            }

            MixingSampleProvider msp = new MixingSampleProvider(note1.WaveFormat);

            msp.AddMixerInput(note1);
            msp.AddMixerInput(note2);

            var stwp = new SampleToWaveProvider(msp);

            MemoryStream wavStream = new MemoryStream();

            WaveFileWriter.WriteWavFileToStream(wavStream, stwp);
            wavStream.Position = 0;
            return(wavStream);
        }
Exemplo n.º 6
0
        public ActionResult GetNoteEx(string doNoteName, int type)
        {
            int             doNoteNumber   = NoteHelper.NoteNumberFromNoteName(doNoteName);
            int             thisNoteNumber = doNoteNumber + type;
            ISampleProvider note           = NAudioHelper.GetSampleProvider(thisNoteNumber, TimeSpan.FromSeconds(3));

            var          stwp      = new SampleToWaveProvider(note);
            MemoryStream wavStream = new MemoryStream();

            WaveFileWriter.WriteWavFileToStream(wavStream, stwp);
            wavStream.Position = 0;

            wavStream.WavToMp3File(out string fileName);
            return(Redirect($"~/Temp/{fileName}"));
        }
Exemplo n.º 7
0
        public ActionResult GetDOEx(string doNoteName)
        {
            _log.Info("Entered. Getting the note...");
            ISampleProvider note = NAudioHelper.GetSampleProvider(doNoteName, TimeSpan.FromSeconds(2));

            _log.Info("Got the note");
            var          stwp      = new SampleToWaveProvider(note);
            MemoryStream wavStream = new MemoryStream();

            WaveFileWriter.WriteWavFileToStream(wavStream, stwp);
            wavStream.Position = 0;

            wavStream.WavToMp3File(out string fileName);
            return(Redirect($"~/Temp/{fileName}"));
        }
        public ActionResult GetPitchEx(string doNoteName, int type)
        {
            string doFileName = NAudioHelper.GetFileNameFromNoteName(doNoteName);

            doFileName = Path.GetFileName(doFileName);
            int doNoteNumber = int.Parse(doFileName.Split('.')[0]);

            int noteNumber = doNoteNumber + type;

            TimeSpan noteDuration = TimeSpan.FromSeconds(3);

            var note = NAudioHelper.GetSampleProvider(noteNumber, noteDuration);

            var stwp = new SampleToWaveProvider(note);

            MemoryStream wavStream = new MemoryStream();

            WaveFileWriter.WriteWavFileToStream(wavStream, stwp);
            wavStream.Position = 0;

            wavStream.WavToMp3File(out string fileName);
            return(Redirect($"~/Temp/{fileName}"));
        }
Exemplo n.º 9
0
        public ActionResult DecreaseVolume(int level)
        {
            //Get default endpoint
            var audioEndpoint = NAudioHelper.GetDefaultAudioEndpoint();

            if (audioEndpoint == null)
            {
                return(Json("No devices found to record"));
            }

            try
            {
                if (audioEndpoint.AudioEndpointVolume.MasterVolumeLevelScalar == 0)
                {
                    return(Json("Device is already muted"));
                }

                //Set new volume and mute flag
                float newVolume = 0;
                if (level != 0)
                {
                    newVolume = audioEndpoint.AudioEndpointVolume.MasterVolumeLevelScalar - (float)0.1;
                }
                if (newVolume < 0)
                {
                    newVolume = 0;
                }
                audioEndpoint.AudioEndpointVolume.MasterVolumeLevelScalar = newVolume;
                audioEndpoint.AudioEndpointVolume.Mute = newVolume == 0;
            }
            catch
            {
                //Swallow and return
                return(Json("An error has occured. WHAT DID YOU DO YOU????"));
            }
            return(Json(new { }));
        }
Exemplo n.º 10
0
        private MemoryStream GetMelodicInterval(string doNoteName, L1C7MelodicDrillType drillType)
        {
            double   bpm = double.Parse(ConfigurationManager.AppSettings["BPM"]);
            double   quarterNoteMillis = (60 / bpm) * 1000;
            TimeSpan halfNoteDuration  = TimeSpan.FromMilliseconds(quarterNoteMillis * 2);

            string doFileName = NAudioHelper.GetFileNameFromNoteName(doNoteName);

            doFileName = Path.GetFileName(doFileName);
            int doNoteNumber = int.Parse(doFileName.Split('.')[0]);

            ISampleProvider note1, note2;

            switch (drillType)
            {
                #region Minor 2nds / minor 7ths

            // Minor 2nd intervals.
            case L1C7MelodicDrillType.MiFa2Asc:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor3rd, halfNoteDuration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfect4th, halfNoteDuration);
                break;

            case L1C7MelodicDrillType.TiDo2Asc:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor7th, halfNoteDuration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfectOctave, halfNoteDuration);
                break;

            case L1C7MelodicDrillType.FaMi2Desc:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfect4th, halfNoteDuration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor3rd, halfNoteDuration);
                break;

            case L1C7MelodicDrillType.DoTi2Desc:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfectOctave, halfNoteDuration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor7th, halfNoteDuration);
                break;

            // Major 7th intervals.
            case L1C7MelodicDrillType.DoTi7Asc:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber, halfNoteDuration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor7th, halfNoteDuration);
                break;

            case L1C7MelodicDrillType.FaMi7Asc:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfect4th, halfNoteDuration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor10th, halfNoteDuration);
                break;

            case L1C7MelodicDrillType.TiDo7Desc:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor7th, halfNoteDuration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber, halfNoteDuration);
                break;

            case L1C7MelodicDrillType.MiFa7Desc:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor10th, halfNoteDuration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfect4th, halfNoteDuration);
                break;

                #endregion Major 2nds / min 7ths

            default:
                throw new NotSupportedException($"L1C6MelodicDrillType '{drillType}' is not supported.");
            }

            var phrase = note1
                         .FollowedBy(note2);

            var stwp = new SampleToWaveProvider(phrase);

            MemoryStream wavStream = new MemoryStream();
            WaveFileWriter.WriteWavFileToStream(wavStream, stwp);
            wavStream.Position = 0;
            return(wavStream);
        }
Exemplo n.º 11
0
        private MemoryStream GetMelodicDrill(string doNoteName, L1C7MelodicDrillType drillType)
        {
            double bpm = double.Parse(ConfigurationManager.AppSettings["BPM"]);
            double quarterNoteMillis = (60 / bpm) * 1000;

            TimeSpan eighthNoteDuration            = TimeSpan.FromMilliseconds(quarterNoteMillis / 2);
            TimeSpan quarterNoteDuration           = TimeSpan.FromMilliseconds(quarterNoteMillis);
            TimeSpan dottedQuarterNoteDuration     = TimeSpan.FromMilliseconds(quarterNoteMillis).Add(eighthNoteDuration);
            TimeSpan halfNoteDuration              = TimeSpan.FromMilliseconds(quarterNoteMillis * 2);
            TimeSpan halfNoteAndEighthNoteDuration = halfNoteDuration.Add(eighthNoteDuration);
            TimeSpan wholeNoteDuration             = TimeSpan.FromMilliseconds(quarterNoteMillis * 4);

            string doFileName = NAudioHelper.GetFileNameFromNoteName(doNoteName);

            doFileName = Path.GetFileName(doFileName);
            int doNoteNumber = int.Parse(doFileName.Split('.')[0]);

            ISampleProvider note1, note2, note3, note4 = null;

            switch (drillType)
            {
            // Minor 2nd intervals.
            case L1C7MelodicDrillType.MiMiFaMiMin2nd:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor3rd, quarterNoteDuration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor3rd, eighthNoteDuration);
                note3 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfect4th, halfNoteAndEighthNoteDuration);
                note4 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor3rd, wholeNoteDuration);
                break;

            case L1C7MelodicDrillType.TiDoDoMin2nd:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.DownMinor2nd, dottedQuarterNoteDuration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber, halfNoteAndEighthNoteDuration);
                note3 = NAudioHelper.GetSampleProvider(doNoteNumber, wholeNoteDuration);
                break;

            case L1C7MelodicDrillType.FaFaMiMiMin2nd:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfect4th, quarterNoteDuration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfect4th, eighthNoteDuration);
                note3 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor3rd, halfNoteAndEighthNoteDuration);
                note4 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor3rd, wholeNoteDuration);
                break;

            case L1C7MelodicDrillType.DoTiDoMin2nd:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber, dottedQuarterNoteDuration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.DownMinor2nd, halfNoteAndEighthNoteDuration);
                note3 = NAudioHelper.GetSampleProvider(doNoteNumber, wholeNoteDuration);
                break;

            // Major 7th intervals.
            case L1C7MelodicDrillType.DoDoTiDoMaj7th:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber, quarterNoteDuration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber, eighthNoteDuration);
                note3 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor7th, halfNoteAndEighthNoteDuration);
                note4 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfectOctave, wholeNoteDuration);
                break;

            case L1C7MelodicDrillType.FaMiMiMaj7th:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfect4th, dottedQuarterNoteDuration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor10th, halfNoteAndEighthNoteDuration);
                note3 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor10th, wholeNoteDuration);
                break;

            case L1C7MelodicDrillType.TiTiDoDoMaj7th:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor7th, quarterNoteDuration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor7th, eighthNoteDuration);
                note3 = NAudioHelper.GetSampleProvider(doNoteNumber, halfNoteAndEighthNoteDuration);
                note4 = NAudioHelper.GetSampleProvider(doNoteNumber, wholeNoteDuration);
                break;

            case L1C7MelodicDrillType.MiFaMiMaj7th:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor10th, dottedQuarterNoteDuration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfect4th, halfNoteAndEighthNoteDuration);
                note3 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor3rd, wholeNoteDuration);
                break;

            default:
                throw new NotSupportedException($"L1C7MelodicDrillType '{drillType}' is not supported.");
            }

            var phrase = note1
                         .FollowedBy(note2)
                         .FollowedBy(note3);

            if (note4 != null)
            {
                phrase = phrase.FollowedBy(note4);
            }

            var stwp = new SampleToWaveProvider(phrase);

            MemoryStream wavStream = new MemoryStream();

            WaveFileWriter.WriteWavFileToStream(wavStream, stwp);
            wavStream.Position = 0;
            return(wavStream);
        }
Exemplo n.º 12
0
        public ActionResult Get4ChordProgression(string doNoteName, string progression)
        {
            TimeSpan noteDuration = TimeSpan.FromSeconds(2);

            string doFileName = NAudioHelper.GetFileNameFromNoteName(doNoteName);

            doFileName = Path.GetFileName(doFileName);
            int doNoteNumber = int.Parse(doFileName.Split('.')[0]);

            string[]          chords = progression.Split('-');
            ISampleProvider[] samples1, samples2, samples3, samples4;

            // First chord.
            string[] chordParts      = chords[0].Split(' ');
            int      degree          = int.Parse(chordParts[0]);
            int      newDoNoteNumber = GetDoNoteNumber(doNoteNumber, degree);

            samples1 = CreateTriad(newDoNoteNumber, degree, noteDuration);

            // Second chord.
            chordParts      = chords[1].Split(' ');
            degree          = int.Parse(chordParts[0]);
            newDoNoteNumber = GetDoNoteNumber(doNoteNumber, degree);
            samples2        = CreateTriad(newDoNoteNumber, degree, noteDuration);

            // Third chord.
            chordParts      = chords[2].Split(' ');
            degree          = int.Parse(chordParts[0]);
            newDoNoteNumber = GetDoNoteNumber(doNoteNumber, degree);
            samples3        = CreateTriad(newDoNoteNumber, degree, noteDuration);

            // Fourth chord.
            chordParts      = chords[3].Split(' ');
            degree          = int.Parse(chordParts[0]);
            newDoNoteNumber = GetDoNoteNumber(doNoteNumber, degree);
            samples4        = CreateTriad(newDoNoteNumber, degree, noteDuration);

            MixingSampleProvider msp1 = new MixingSampleProvider(samples1[0].WaveFormat);

            msp1.AddMixerInput(samples1[0]);
            msp1.AddMixerInput(samples1[1]);
            msp1.AddMixerInput(samples1[2]);

            MixingSampleProvider msp2 = new MixingSampleProvider(samples2[0].WaveFormat);

            msp2.AddMixerInput(samples2[0]);
            msp2.AddMixerInput(samples2[1]);
            msp2.AddMixerInput(samples2[2]);

            MixingSampleProvider msp3 = new MixingSampleProvider(samples3[0].WaveFormat);

            msp3.AddMixerInput(samples3[0]);
            msp3.AddMixerInput(samples3[1]);
            msp3.AddMixerInput(samples3[2]);

            MixingSampleProvider msp4 = new MixingSampleProvider(samples4[0].WaveFormat);

            msp4.AddMixerInput(samples4[0]);
            msp4.AddMixerInput(samples4[1]);
            msp4.AddMixerInput(samples4[2]);

            var phrase = msp1
                         .FollowedBy(msp2)
                         .FollowedBy(msp3)
                         .FollowedBy(msp4);

            var stwp = new SampleToWaveProvider(phrase);

            MemoryStream wavStream = new MemoryStream();

            WaveFileWriter.WriteWavFileToStream(wavStream, stwp);
            wavStream.Position = 0;

            wavStream.WavToMp3File(out string fileName);
            return(Redirect($"~/Temp/{fileName}"));
        }
Exemplo n.º 13
0
        public ActionResult Get3ChordProgressionEx(string doNoteName, int progressiontype)
        {
            var progressionType = (ProgressionType3)progressiontype;

            TimeSpan duration = TimeSpan.FromSeconds(2);

            string doFileName = NAudioHelper.GetFileNameFromNoteName(doNoteName);

            doFileName = Path.GetFileName(doFileName);
            int doNoteNumber = int.Parse(doFileName.Split('.')[0]);

            ISampleProvider[] samples1;
            ISampleProvider[] samples2;
            ISampleProvider[] samples3;

            switch (progressionType)
            {
            case ProgressionType3.One2ndTwoMin1stThreeMin1st:
                samples1 = Inversion.CreateTriadInversionEx(doNoteNumber, TriadType.OneMajor, InversionType.HighSecond, duration, true);
                samples2 = Inversion.CreateTriadInversionEx(doNoteNumber, TriadType.TwoMinor, InversionType.HighFirst, duration, true);
                samples3 = Inversion.CreateTriadInversionEx(doNoteNumber, TriadType.ThreeMinor, InversionType.HighFirst, duration, true);
                break;

            case ProgressionType3.One1stFive2ndSixMin2nd:
                samples1 = Inversion.CreateTriadInversionEx(doNoteNumber, TriadType.OneMajor, InversionType.HighFirst, duration, true);
                samples2 = Inversion.CreateTriadInversionEx(doNoteNumber, TriadType.FiveMajor, InversionType.LowSecond, duration, true);
                samples3 = Inversion.CreateTriadInversionEx(doNoteNumber, TriadType.SixMinor, InversionType.LowSecond, duration, true);
                break;

            case ProgressionType3.Four2ndFive1stSixMin1st:
                samples1 = Inversion.CreateTriadInversionEx(doNoteNumber, TriadType.FourMajor, InversionType.LowSecond, duration, true);
                samples2 = Inversion.CreateTriadInversionEx(doNoteNumber, TriadType.FiveMajor, InversionType.LowFirst, duration, true);
                samples3 = Inversion.CreateTriadInversionEx(doNoteNumber, TriadType.SixMinor, InversionType.LowFirst, duration, true);
                break;

            case ProgressionType3.ThreeMin1stOne2ndTwoMin1st:
                samples1 = Inversion.CreateTriadInversionEx(doNoteNumber, TriadType.ThreeMinor, InversionType.HighFirst, duration, true);
                samples2 = Inversion.CreateTriadInversionEx(doNoteNumber, TriadType.OneMajor, InversionType.HighSecond, duration, true);
                samples3 = Inversion.CreateTriadInversionEx(doNoteNumber, TriadType.TwoMinor, InversionType.HighFirst, duration, true);
                break;

            case ProgressionType3.FourRootFive2ndThreeMinRoot:
                samples1 = Inversion.CreateTriadInversionEx(doNoteNumber, TriadType.FourMajor, InversionType.Root, duration, true);
                samples2 = Inversion.CreateTriadInversionEx(doNoteNumber, TriadType.FiveMajor, InversionType.LowSecond, duration, true);
                samples3 = Inversion.CreateTriadInversionEx(doNoteNumber, TriadType.ThreeMinor, InversionType.Root, duration, true);
                break;

            case ProgressionType3.OneRootTwoMin2ndFour1st:
                samples1 = Inversion.CreateTriadInversionEx(doNoteNumber, TriadType.OneMajor, InversionType.Root, duration, true);
                samples2 = Inversion.CreateTriadInversionEx(doNoteNumber, TriadType.TwoMinor, InversionType.LowSecond, duration, true);
                samples3 = Inversion.CreateTriadInversionEx(doNoteNumber, TriadType.FourMajor, InversionType.LowFirst, duration, true);
                break;

            case ProgressionType3.One1stThreeMinRootTwoMinFirst:
                samples1 = Inversion.CreateTriadInversionEx(doNoteNumber, TriadType.OneMajor, InversionType.HighFirst, duration, true);
                samples2 = Inversion.CreateTriadInversionEx(doNoteNumber, TriadType.ThreeMinor, InversionType.Root, duration, true);
                samples3 = Inversion.CreateTriadInversionEx(doNoteNumber, TriadType.TwoMinor, InversionType.HighFirst, duration, true);
                break;

            case ProgressionType3.Four2ndOneRootFive1st:
                samples1 = Inversion.CreateTriadInversionEx(doNoteNumber, TriadType.FourMajor, InversionType.LowSecond, duration, true);
                samples2 = Inversion.CreateTriadInversionEx(doNoteNumber, TriadType.OneMajor, InversionType.Root, duration, true);
                samples3 = Inversion.CreateTriadInversionEx(doNoteNumber, TriadType.FiveMajor, InversionType.LowFirst, duration, true);
                break;

            case ProgressionType3.SixMinRootFour1stOne2nd:
                samples1 = Inversion.CreateTriadInversionEx(doNoteNumber, TriadType.SixMinor, InversionType.Root, duration, true);
                samples2 = Inversion.CreateTriadInversionEx(doNoteNumber, TriadType.FourMajor, InversionType.HighFirst, duration, true);
                samples3 = Inversion.CreateTriadInversionEx(doNoteNumber, TriadType.OneMajor, InversionType.HighSecond, duration, true);
                break;

            case ProgressionType3.Five2ndOneRootTwoRoot:
                samples1 = Inversion.CreateTriadInversionEx(doNoteNumber, TriadType.FiveMajor, InversionType.LowSecond, duration, true);
                samples2 = Inversion.CreateTriadInversionEx(doNoteNumber, TriadType.OneMajor, InversionType.Root, duration, true);
                samples3 = Inversion.CreateTriadInversionEx(doNoteNumber, TriadType.TwoMinor, InversionType.Root, duration, true);
                break;

            case ProgressionType3.One1stFive2ndFourRoot:
                samples1 = Inversion.CreateTriadInversionEx(doNoteNumber, TriadType.OneMajor, InversionType.HighFirst, duration, true);
                samples2 = Inversion.CreateTriadInversionEx(doNoteNumber, TriadType.FiveMajor, InversionType.LowSecond, duration, true);
                samples3 = Inversion.CreateTriadInversionEx(doNoteNumber, TriadType.FourMajor, InversionType.Root, duration, true);
                break;

            default:
                throw new NotSupportedException($"ProgressionType {progressionType} is not supported.");
            }

            MixingSampleProvider msp1 = new MixingSampleProvider(samples1[0].WaveFormat);

            msp1.AddMixerInput(samples1[0]);
            msp1.AddMixerInput(samples1[1]);
            msp1.AddMixerInput(samples1[2]);
            if (samples1[3] != null)  // Bass note.
            {
                msp1.AddMixerInput(samples1[3]);
            }

            MixingSampleProvider msp2 = new MixingSampleProvider(samples2[0].WaveFormat);

            msp2.AddMixerInput(samples2[0]);
            msp2.AddMixerInput(samples2[1]);
            msp2.AddMixerInput(samples2[2]);
            if (samples2[3] != null)  // Bass note.
            {
                msp2.AddMixerInput(samples2[3]);
            }

            MixingSampleProvider msp3 = new MixingSampleProvider(samples3[0].WaveFormat);

            msp3.AddMixerInput(samples3[0]);
            msp3.AddMixerInput(samples3[1]);
            msp3.AddMixerInput(samples3[2]);
            if (samples3[3] != null)  // Bass note.
            {
                msp3.AddMixerInput(samples3[3]);
            }

            var phrase = msp1
                         .FollowedBy(msp2)
                         .FollowedBy(msp3);

            var stwp = new SampleToWaveProvider(phrase);

            MemoryStream wavStream = new MemoryStream();

            WaveFileWriter.WriteWavFileToStream(wavStream, stwp);
            wavStream.Position = 0;

            wavStream.WavToMp3File(out string fileName);
            return(Redirect($"~/Temp/{fileName}"));
        }
Exemplo n.º 14
0
        /// <summary>
        /// 截取音频后,对每个小音频获语音转文字,一个音频对应一段文字
        /// </summary>
        /// <param name="startMilliSecond"></param>
        /// <param name="endMilliSecond"></param>
        /// <param name="reader"></param>
        /// <param name="sound_path"></param>
        /// <param name="_name"></param>
        /// <param name="language"></param>
        /// <param name="splitTime"></param>
        private void GetBaiduSpeech(TimeSpan startMilliSecond, TimeSpan endMilliSecond, string sound_path, int i, string language, double splitTime)
        {
            string newFile     = "";
            string _newFile    = "";
            string pcm_newFile = "";
            bool   need_delete = true;
            //将文件保存到新的文件夹(sound_path是原音频路径,newFolder是新的小音频路径,使用完成后将上传到服务器成功的音频删除)
            string newFolder = System.AppDomain.CurrentDomain.BaseDirectory + "NewSoundFiles/" + Path.GetFileNameWithoutExtension(sound_path) + "/";

            newFolder = newFolder.Replace("/", "\\");
            AudioFileReader reader  = new AudioFileReader(sound_path);
            AudioFileReader _reader = null;//超过60s音频截取小音频

            try
            {
                #region 为截取音频做准备
                //开始时间往前取startMilliSecond一半的偏移,结束时间往后取间隔时间的一半的偏移
                if (i == 0)
                {
                    startMilliSecond = startMilliSecond - TimeSpan.FromMilliseconds(startMilliSecond.TotalMilliseconds / 2);
                }
                else
                {
                    startMilliSecond = startMilliSecond - TimeSpan.FromMilliseconds(splitTime / 2);
                }
                if (endMilliSecond < reader.TotalTime)//最后一次不用取偏移
                {
                    endMilliSecond = endMilliSecond + TimeSpan.FromMilliseconds(splitTime / 2);
                }
                TimeSpan span = endMilliSecond - startMilliSecond;
                if (span.TotalSeconds > 60)//超过60s,只取50秒
                {
                    span = TimeSpan.FromSeconds(50);
                }
                var trimed = reader.Skip(startMilliSecond).Take(endMilliSecond - startMilliSecond);
                #endregion
                string fileName = Path.GetFileNameWithoutExtension(sound_path) + "_" + i + Path.GetExtension(sound_path);//重命名文件

                //重新存储到一个新的文件目录
                if (!System.IO.Directory.Exists(newFolder))
                {
                    System.IO.Directory.CreateDirectory(newFolder);
                }
                //拼接后的文件路径
                newFile = newFolder + fileName;
                //截取小音频文件
                WaveFileWriter.CreateWaveFile16(newFile, trimed);
                //上传到文件服务器
                string server_path = UploadFile.PostFile(newFile);
                if (Util.isNotNull(server_path))
                {
                    //上传成功
                    voiceFiles.Add(server_path);
                }
                else
                {
                    need_delete = false;
                    //上传失败,在服务器上的路径
                    voiceFiles.Add(Util.getServerPath() + "/NewSoundFiles/" + Path.GetFileNameWithoutExtension(sound_path) + "/" + fileName);
                }
                //大于60s的需要再处理
                if (span == TimeSpan.FromSeconds(50))//音频大于60s,只截取50s
                {
                    //小音频
                    _reader = new AudioFileReader(sound_path);
                    var _trimed = _reader.Skip(startMilliSecond).Take(span);
                    //保存新的音频文件
                    string _fileName = "_" + Path.GetFileNameWithoutExtension(sound_path) + "_" + i + ".pcm";//重命名文件
                    _newFile = newFolder + _fileName;
                    WaveFileWriter.CreateWaveFile16(_newFile, _trimed);
                    //将音频转换为文字
                    //baidu_text.Add(BaiduSpeech.BaiduTranslateToText(_newFile, language, _trimed.WaveFormat.SampleRate.ToString()));
                    baidu_text.Add(Rays.Utility.BadiAI.BaiduAI.BaiduTranslateToText(_newFile, language, trimed.WaveFormat.SampleRate.ToString()));
                }
                else
                {
                    //将wav转换成pcm可以提高识别速度
                    pcm_newFile = NAudioHelper.GetPcmPath(newFile);
                    //将音频转换为文字
                    //baidu_text.Add(BaiduSpeech.BaiduTranslateToText(pcm_newFile, language, trimed.WaveFormat.SampleRate.ToString()));
                    baidu_text.Add(Rays.Utility.BadiAI.BaiduAI.BaiduTranslateToText(pcm_newFile, language, trimed.WaveFormat.SampleRate.ToString()));
                }
            }
            catch (Exception ex)
            {
                LogHelper.Error("GetBaiduSpeech:" + ex.Message);
            }
            finally
            {
                reader.Close();
                reader.Dispose();
                if (_reader != null)
                {
                    _reader.Close();
                    _reader.Dispose();
                }
                //删除文件
                //if (File.Exists(_newFile))
                //{
                //    File.Delete(_newFile);
                //}
                //if (need_delete)
                //{
                //    if (File.Exists(newFile))
                //    {
                //        File.Delete(newFile);
                //    }
                //}
                ////删除目录
                //if (Directory.Exists(newFolder) && Directory.GetFiles(newFolder).Length == 0)
                //{
                //    Directory.Delete(newFolder);
                //}

                //if (File.Exists(pcm_newFile))
                //{
                //    File.Delete(pcm_newFile);
                //    string pcm_folder = Path.GetDirectoryName(pcm_newFile);
                //    //删除目录
                //    if (Directory.Exists(pcm_folder) && Directory.GetFiles(pcm_folder).Length == 0)
                //    {
                //        Directory.Delete(pcm_folder);
                //    }
                //}
            }
        }
Exemplo n.º 15
0
        /// <summary>
        /// 解析音频文件,获取时间戳,截取音频,语音转文字
        /// </summary>
        /// <param name="sound_path"></param>
        /// <param name="word_path"></param>
        /// <param name="language"></param>
        /// <param name="splitTime"></param>
        public void GetTimeSpan(string sound_path, string word_path, string language, double splitTime = 1.5)
        {
            //通过NAudio读取音频文件流
            AudioFileReader inputStream    = null;
            string          sound_path_mp3 = "";

            try
            {
                if (sound_path.ToLower().EndsWith(".mp3"))
                {
                    sound_path_mp3 = sound_path;
                    //通过NAudio将文件转换为WAV格式,返回新的文件路径
                    sound_path = NAudioHelper.GetWavPath(sound_path);
                }
                inputStream = new AudioFileReader(sound_path);

                //WAV文件读取
                WAVReader reader = new WAVReader();
                reader.GetTimeSpan(sound_path, out voicePoint, out voiceMilliSecond, splitTime);
                //voicePoint是为了截取小音频
                //voicePoint是双数的原因是有开始时间就有一个结束时间
                //最后一次的时间要加上(结束时,没有停顿时间)
                if (voicePoint.Count % 2 != 0)
                {
                    voicePoint.Add(inputStream.TotalTime);
                }
                LogHelper.Info("时间戳获取:成功");
                //string totalTime=FfmpegHelper.getMediaDuration(sound_path);
                int _name = 1;//命名
                //一个时间点对应一段音频对应一段文字
                LogHelper.Info("语音转文字:开始");
                for (int i = 0; i < voicePoint.Count; i += 2)
                {
                    GetBaiduSpeech(voicePoint[i], voicePoint[i + 1], sound_path, _name, language, splitTime);
                    ++_name;
                }
                //word原文
                if (Path.GetExtension(word_path).Contains("doc") || Path.GetExtension(word_path).Contains("docx"))
                {
                    originalText = NPOIHelper.ExcuteWordText(word_path);
                    //word原文的集合
                    results = GetTextContrast(voiceFiles.ToArray(), voiceMilliSecond.ToArray(), baidu_text.ToArray(), originalText, language);
                }
                else if (Path.GetExtension(word_path).Contains("txt") || Path.GetExtension(word_path).Contains("lrc"))
                {
                    string _originalText = Util.ReadTxt(word_path);
                    originalText = string.Join("", _originalText.Split('|'));
                    //word原文的集合
                    results = GetTextContrast(voiceFiles.ToArray(), voiceMilliSecond.ToArray(), baidu_text.ToArray(), _originalText, language);
                }
            }
            catch (Exception ex)
            {
                LogHelper.Error(ex.Message);
            }
            finally
            {
                inputStream.Close();
                inputStream.Dispose();
                isFinish = true;
                ////删除MP3文件
                //if (Util.isNotNull(sound_path_mp3) && File.Exists(sound_path_mp3))
                //{
                //    File.Delete(sound_path_mp3);
                //    string mp3_folder = Path.GetDirectoryName(sound_path_mp3);
                //    if (Directory.Exists(mp3_folder) && Directory.GetFiles(mp3_folder).Length == 0)
                //    {
                //        Directory.Delete(mp3_folder);
                //    }
                //}
                ////删除word文件
                //if (File.Exists(word_path))
                //{
                //    File.Delete(word_path);
                //    //删除word文件目录
                //    string word_folder = Path.GetDirectoryName(word_path);
                //    if (Directory.Exists(word_folder) && Directory.GetFiles(word_folder).Length == 0)
                //    {
                //        Directory.Delete(word_folder);
                //    }
                //}

                ////删除文件夹,删除原音频文件
                //if (File.Exists(sound_path))
                //{
                //    File.Delete(sound_path);
                //    //删除原音频目录
                //    string sound_folder = Path.GetDirectoryName(sound_path);
                //    if (Directory.Exists(sound_folder) && Directory.GetFiles(sound_folder).Length == 0)
                //    {
                //        Directory.Delete(sound_folder);
                //    }
                //}
            }
        }
Exemplo n.º 16
0
        public ActionResult GetTriad(string doNoteName, int triadtype)
        {
            var           triadType     = (L2C5TriadType)triadtype;
            InversionType inversionType = GetRandomInversion();

            TimeSpan noteDuration = TimeSpan.FromSeconds(3);

            string doFileName = NAudioHelper.GetFileNameFromNoteName(doNoteName);

            doFileName = Path.GetFileName(doFileName);
            int doNoteNumber = int.Parse(doFileName.Split('.')[0]);

            ISampleProvider[] samples;
            int newDoNoteNumber;  // Used for other chords besides the I.

            switch (triadType)
            {
            case L2C5TriadType.OneMajor:
                samples = Inversion.CreateTriadInversionEx(inversionType, noteDuration, doNoteNumber, doNoteNumber + Interval.UpMajor3rd, doNoteNumber + Interval.UpPerfect5th);
                break;

            case L2C5TriadType.TwoMinor:
                newDoNoteNumber = doNoteNumber + Interval.UpMajor2nd;
                samples         = Inversion.CreateTriadInversionEx(inversionType, noteDuration, newDoNoteNumber, newDoNoteNumber + Interval.UpMinor3rd, newDoNoteNumber + Interval.UpPerfect5th);
                break;

            case L2C5TriadType.ThreeMinor:
                newDoNoteNumber = doNoteNumber + Interval.UpMajor3rd;
                samples         = Inversion.CreateTriadInversionEx(inversionType, noteDuration, newDoNoteNumber, newDoNoteNumber + Interval.UpMinor3rd, newDoNoteNumber + Interval.UpPerfect5th);
                break;

            case L2C5TriadType.FourMajor:
                newDoNoteNumber = doNoteNumber + Interval.UpPerfect4th;
                samples         = Inversion.CreateTriadInversionEx(inversionType, noteDuration, newDoNoteNumber, newDoNoteNumber + Interval.UpMajor3rd, newDoNoteNumber + Interval.UpPerfect5th);
                break;

            case L2C5TriadType.FiveMajor:
                newDoNoteNumber = doNoteNumber + Interval.UpPerfect5th;
                samples         = Inversion.CreateTriadInversionEx(inversionType, noteDuration, newDoNoteNumber, newDoNoteNumber + Interval.UpMajor3rd, newDoNoteNumber + Interval.UpPerfect5th);
                break;

            case L2C5TriadType.SixMinor:
                newDoNoteNumber = doNoteNumber + Interval.UpMajor6th;
                samples         = Inversion.CreateTriadInversionEx(inversionType, noteDuration, newDoNoteNumber, newDoNoteNumber + Interval.UpMinor3rd, newDoNoteNumber + Interval.UpPerfect5th);
                break;

            case L2C5TriadType.SevenDiminished:
                newDoNoteNumber = doNoteNumber + Interval.UpMajor7th;
                samples         = Inversion.CreateTriadInversionEx(inversionType, noteDuration, newDoNoteNumber, newDoNoteNumber + Interval.UpMinor3rd, newDoNoteNumber + Interval.UpDiminished5th);
                break;

            default:
                throw new NotSupportedException($"L2C5TriadType {triadType} is not supported.");
            }

            MixingSampleProvider msp = new MixingSampleProvider(samples[0].WaveFormat);

            msp.AddMixerInput(samples[0]);
            msp.AddMixerInput(samples[1]);
            msp.AddMixerInput(samples[2]);

            IWaveProvider wp        = msp.ToWaveProvider();
            MemoryStream  wavStream = new MemoryStream();

            WaveFileWriter.WriteWavFileToStream(wavStream, wp);
            wavStream.Position = 0;

            wavStream.WavToMp3File(out string fileName);
            return(Redirect($"~/Temp/{fileName}"));
        }
Exemplo n.º 17
0
        /// <summary>
        /// 解析音频文件,获取时间戳,截取音频,语音转文字
        /// </summary>
        /// <param name="sound_path"></param>
        /// <param name="word_path"></param>
        /// <param name="language"></param>
        /// <param name="splitTime"></param>
        public void GetTimeSpanLrc(string sound_path, string word_path, string language, double splitTime = 1.5)
        {
            string        sound_path_mp3  = "";                   //音频格式转换后的文件
            List <string> cut_sound_files = new List <string> (); //切分后的音频文件
            string        folder          = Path.GetDirectoryName(sound_path);

            try
            {
                if (sound_path.ToLower().EndsWith(".mp3"))
                {
                    sound_path_mp3 = sound_path;
                    //通过NAudio将文件转换为WAV格式,返回新的文件路径
                    sound_path = NAudioHelper.GetWavPath(sound_path);
                }
                //音频处理,通过lrc的时间戳来截取音频与内容
                //1.先从lrc里面获取时间戳与内容
                if (Path.GetExtension(word_path).Contains("lrc"))
                {
                    Dictionary <TimeSpan, string> lrcs = Util.ReadLrc(word_path);
                    List <TimeSpan> times = lrcs.Keys.ToList();
                    for (int i = 0; i < times.Count; i++)
                    {
                        TextContrastResult _result = new TextContrastResult();
                        //2.通过时间戳,截取音频
                        string   cut_sound_file = folder + "\\" + i + "_" + sys.getRandomStr() + Path.GetExtension(sound_path);
                        TimeSpan _start         = new TimeSpan();
                        TimeSpan _end           = new TimeSpan();
                        if (i == times.Count - 1)
                        {
                            _end = TimeSpan.Parse(FfmpegHelper.getMediaDuration(sound_path));
                        }
                        else
                        {
                            _end = times[i + 1];
                        }
                        _start               = times[i];
                        _result.timespan     = times[i].TotalSeconds;
                        _result.contractText = lrcs[times[i]];
                        _result.baiduText    = lrcs[times[i]];
                        _result.precent      = "100%";
                        bool is_success = FfmpegHelper.CutAudioFile(sound_path, cut_sound_file, _start, _end - _start);
                        if (is_success)
                        {
                            cut_sound_files.Add(cut_sound_file);
                        }
                        //上传到服务器
                        if (File.Exists(cut_sound_file))
                        {
                            string server_path = UploadFile.PostFile(cut_sound_file);
                            _result.file_url = server_path;
                        }
                        results.Add(_result);
                    }
                }
                //原文
                string _originalText = Util.ReadTxt(word_path);
                originalText = string.Join("", _originalText.Split('|'));
            }
            catch (Exception ex)
            {
                LogHelper.Error(ex.Message);
            }
            finally
            {
                isFinish = true;
                //删除切分的文件
                foreach (string cut_sound_file in cut_sound_files)
                {
                    if (Util.isNotNull(cut_sound_file) && File.Exists(cut_sound_file))
                    {
                        File.Delete(cut_sound_file);
                    }
                }
                //删除MP3文件
                if (Util.isNotNull(sound_path_mp3) && File.Exists(sound_path_mp3))
                {
                    File.Delete(sound_path_mp3);
                    string mp3_folder = Path.GetDirectoryName(sound_path_mp3);
                    if (Directory.Exists(mp3_folder) && Directory.GetFiles(mp3_folder).Length == 0)
                    {
                        Directory.Delete(mp3_folder);
                    }
                }
                //删除word文件
                if (File.Exists(word_path))
                {
                    File.Delete(word_path);
                    //删除word文件目录
                    string word_folder = Path.GetDirectoryName(word_path);
                    if (Directory.Exists(word_folder) && Directory.GetFiles(word_folder).Length == 0)
                    {
                        Directory.Delete(word_folder);
                    }
                }

                //删除文件夹,删除原音频文件
                if (File.Exists(sound_path))
                {
                    File.Delete(sound_path);
                    //删除原音频目录
                    string sound_folder = Path.GetDirectoryName(sound_path);
                    if (Directory.Exists(sound_folder) && Directory.GetFiles(sound_folder).Length == 0)
                    {
                        Directory.Delete(sound_folder);
                    }
                }
            }
        }
Exemplo n.º 18
0
        public ActionResult Get2ChordProgression(string doNoteName, int progressiontype)
        {
            var progressionType = (L2C4ProgressionType)progressiontype;

            TimeSpan noteDuration = TimeSpan.FromSeconds(2);

            string doFileName = NAudioHelper.GetFileNameFromNoteName(doNoteName);

            doFileName = Path.GetFileName(doFileName);
            int doNoteNumber = int.Parse(doFileName.Split('.')[0]);

            ISampleProvider[] samples1;
            ISampleProvider[] samples2;

            switch (progressionType)
            {
            case L2C4ProgressionType.Five2ndToOne1st:
                samples1 = Inversion.CreateTriadInversionEx(InversionType.LowSecond, noteDuration, doNoteNumber + Interval.UpPerfect5th, doNoteNumber + Interval.UpMajor7th, doNoteNumber + Interval.UpMajor9th);
                samples2 = Inversion.CreateTriadInversionEx(InversionType.HighFirst, noteDuration.Add(noteDuration), doNoteNumber, doNoteNumber + Interval.UpMajor3rd, doNoteNumber + Interval.UpPerfect5th);
                break;

            case L2C4ProgressionType.Five1stToOneRoot:
                samples1 = Inversion.CreateTriadInversionEx(InversionType.LowFirst, noteDuration, doNoteNumber + Interval.UpPerfect5th, doNoteNumber + Interval.UpMajor7th, doNoteNumber + Interval.UpMajor9th);
                samples2 = Inversion.CreateTriadInversionEx(InversionType.Root, noteDuration.Add(noteDuration), doNoteNumber, doNoteNumber + Interval.UpMajor3rd, doNoteNumber + Interval.UpPerfect5th);
                break;

            case L2C4ProgressionType.FiveRootToOne2nd:
                samples1 = Inversion.CreateTriadInversionEx(InversionType.Root, noteDuration, doNoteNumber + Interval.UpPerfect5th, doNoteNumber + Interval.UpMajor7th, doNoteNumber + Interval.UpMajor9th);
                samples2 = Inversion.CreateTriadInversionEx(InversionType.HighSecond, noteDuration.Add(noteDuration), doNoteNumber, doNoteNumber + Interval.UpMajor3rd, doNoteNumber + Interval.UpPerfect5th);
                break;

            case L2C4ProgressionType.Four1stToOne2nd:
                samples1 = Inversion.CreateTriadInversionEx(InversionType.LowFirst, noteDuration, doNoteNumber + Interval.UpPerfect4th, doNoteNumber + Interval.UpMajor6th, doNoteNumber + Interval.UpPerfectOctave);
                samples2 = Inversion.CreateTriadInversionEx(InversionType.LowSecond, noteDuration.Add(noteDuration), doNoteNumber, doNoteNumber + Interval.UpMajor3rd, doNoteNumber + Interval.UpPerfect5th);
                break;

            case L2C4ProgressionType.FourRootToOne1st:
                samples1 = Inversion.CreateTriadInversionEx(InversionType.Root, noteDuration, doNoteNumber + Interval.UpPerfect4th, doNoteNumber + Interval.UpMajor6th, doNoteNumber + Interval.UpPerfectOctave);
                samples2 = Inversion.CreateTriadInversionEx(InversionType.HighFirst, noteDuration.Add(noteDuration), doNoteNumber, doNoteNumber + Interval.UpMajor3rd, doNoteNumber + Interval.UpPerfect5th);
                break;

            case L2C4ProgressionType.Four2ndToOneRoot:
                samples1 = Inversion.CreateTriadInversionEx(InversionType.LowSecond, noteDuration, doNoteNumber + Interval.UpPerfect4th, doNoteNumber + Interval.UpMajor6th, doNoteNumber + Interval.UpPerfectOctave);
                samples2 = Inversion.CreateTriadInversionEx(InversionType.Root, noteDuration.Add(noteDuration), doNoteNumber, doNoteNumber + Interval.UpMajor3rd, doNoteNumber + Interval.UpPerfect5th);
                break;

            case L2C4ProgressionType.OneRootToFlatTwoRoot:
                samples1 = Inversion.CreateTriadInversionEx(InversionType.Root, noteDuration, doNoteNumber, doNoteNumber + Interval.UpMajor3rd, doNoteNumber + Interval.UpPerfect5th);
                samples2 = Inversion.CreateTriadInversionEx(InversionType.Root, noteDuration.Add(noteDuration), doNoteNumber + Interval.UpMinor2nd, doNoteNumber + Interval.UpPerfect4th, doNoteNumber + Interval.UpAugmented5th);
                break;

            case L2C4ProgressionType.OneRootToFlatTwo2nd:
                samples1 = Inversion.CreateTriadInversionEx(InversionType.Root, noteDuration, doNoteNumber, doNoteNumber + Interval.UpMajor3rd, doNoteNumber + Interval.UpPerfect5th);
                samples2 = Inversion.CreateTriadInversionEx(InversionType.LowSecond, noteDuration.Add(noteDuration), doNoteNumber + Interval.UpMinor2nd, doNoteNumber + Interval.UpPerfect4th, doNoteNumber + Interval.UpAugmented5th);
                break;

            case L2C4ProgressionType.OneRootToSevenRoot:
                samples1 = Inversion.CreateTriadInversionEx(InversionType.Root, noteDuration, doNoteNumber, doNoteNumber + Interval.UpMajor3rd, doNoteNumber + Interval.UpPerfect5th);
                samples2 = Inversion.CreateTriadInversionEx(InversionType.Root, noteDuration.Add(noteDuration), doNoteNumber + Interval.DownMinor2nd, doNoteNumber + Interval.UpMinor3rd, doNoteNumber + Interval.UpDiminished5th);
                break;

            case L2C4ProgressionType.OneRootToSeven1st:
                samples1 = Inversion.CreateTriadInversionEx(InversionType.Root, noteDuration, doNoteNumber, doNoteNumber + Interval.UpMajor3rd, doNoteNumber + Interval.UpPerfect5th);
                samples2 = Inversion.CreateTriadInversionEx(InversionType.HighFirst, noteDuration.Add(noteDuration), doNoteNumber + Interval.DownMinor2nd, doNoteNumber + Interval.UpMinor3rd, doNoteNumber + Interval.UpDiminished5th);
                break;

            default:
                throw new NotSupportedException($"ProgressionType {progressionType} is not supported.");
            }

            MixingSampleProvider msp1 = new MixingSampleProvider(samples1[0].WaveFormat);

            msp1.AddMixerInput(samples1[0]);
            msp1.AddMixerInput(samples1[1]);
            msp1.AddMixerInput(samples1[2]);

            MixingSampleProvider msp2 = new MixingSampleProvider(samples2[0].WaveFormat);

            msp2.AddMixerInput(samples2[0]);
            msp2.AddMixerInput(samples2[1]);
            msp2.AddMixerInput(samples2[2]);

            var phrase = msp1
                         .FollowedBy(msp2);

            var stwp = new SampleToWaveProvider(phrase);

            MemoryStream wavStream = new MemoryStream();

            WaveFileWriter.WriteWavFileToStream(wavStream, stwp);
            wavStream.Position = 0;

            wavStream.WavToMp3File(out string fileName);
            return(Redirect($"~/Temp/{fileName}"));
        }
Exemplo n.º 19
0
        private MemoryStream GetMelodicInterval(string doNoteName, L1C5MelodicDrillType drillType)
        {
            double   bpm = double.Parse(ConfigurationManager.AppSettings["BPM"]);
            double   quarterNoteMillis = (60 / bpm) * 1000;
            TimeSpan halfNoteDuration  = TimeSpan.FromMilliseconds(quarterNoteMillis * 2);

            string doFileName = NAudioHelper.GetFileNameFromNoteName(doNoteName);

            doFileName = Path.GetFileName(doFileName);
            int doNoteNumber = int.Parse(doFileName.Split('.')[0]);

            ISampleProvider note1, note2;

            switch (drillType)
            {
                #region 4ths.

            case L1C5MelodicDrillType.DoFa4Asc:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber, halfNoteDuration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfect4th, halfNoteDuration);
                break;

            case L1C5MelodicDrillType.ReSo4Asc:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor2nd, halfNoteDuration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfect5th, halfNoteDuration);
                break;

            case L1C5MelodicDrillType.MiLa4Asc:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor3rd, halfNoteDuration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor6th, halfNoteDuration);
                break;

            case L1C5MelodicDrillType.FaTi4Asc:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfect4th, halfNoteDuration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor7th, halfNoteDuration);
                break;

            case L1C5MelodicDrillType.SoDo4Asc:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfect5th, halfNoteDuration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfectOctave, halfNoteDuration);
                break;

            case L1C5MelodicDrillType.LaRe4Asc:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor6th, halfNoteDuration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor9th, halfNoteDuration);
                break;

            case L1C5MelodicDrillType.TiMi4Asc:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor7th, halfNoteDuration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor10th, halfNoteDuration);
                break;

            case L1C5MelodicDrillType.FaDo4Desc:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfect4th, halfNoteDuration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber, halfNoteDuration);
                break;

            case L1C5MelodicDrillType.SoRe4Desc:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfect5th, halfNoteDuration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor2nd, halfNoteDuration);
                break;

            case L1C5MelodicDrillType.LaMi4Desc:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor6th, halfNoteDuration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor3rd, halfNoteDuration);
                break;

            case L1C5MelodicDrillType.TiFa4Desc:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor7th, halfNoteDuration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfect4th, halfNoteDuration);
                break;

            case L1C5MelodicDrillType.DoSo4Desc:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfectOctave, halfNoteDuration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfect5th, halfNoteDuration);
                break;

            case L1C5MelodicDrillType.ReLa4Desc:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor9th, halfNoteDuration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor6th, halfNoteDuration);
                break;

            case L1C5MelodicDrillType.MiTi4Desc:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor10th, halfNoteDuration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor7th, halfNoteDuration);
                break;

                #endregion 4ths.

                #region 5ths.

            case L1C5MelodicDrillType.DoSo5Asc:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber, halfNoteDuration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfect5th, halfNoteDuration);
                break;

            case L1C5MelodicDrillType.ReLa5Asc:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor2nd, halfNoteDuration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor6th, halfNoteDuration);
                break;

            case L1C5MelodicDrillType.MiTi5Asc:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor3rd, halfNoteDuration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor7th, halfNoteDuration);
                break;

            case L1C5MelodicDrillType.FaDo5Asc:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfect4th, halfNoteDuration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfectOctave, halfNoteDuration);
                break;

            case L1C5MelodicDrillType.SoRe5Asc:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfect5th, halfNoteDuration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor9th, halfNoteDuration);
                break;

            case L1C5MelodicDrillType.LaMi5Asc:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor6th, halfNoteDuration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor10th, halfNoteDuration);
                break;

            case L1C5MelodicDrillType.TiFa5Asc:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor7th, halfNoteDuration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfect11th, halfNoteDuration);
                break;

            case L1C5MelodicDrillType.SoDo5Desc:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfect5th, halfNoteDuration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber, halfNoteDuration);
                break;

            case L1C5MelodicDrillType.LaRe5Desc:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor6th, halfNoteDuration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor2nd, halfNoteDuration);
                break;

            case L1C5MelodicDrillType.TiMi5Desc:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor7th, halfNoteDuration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor3rd, halfNoteDuration);
                break;

            case L1C5MelodicDrillType.DoFa5Desc:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfectOctave, halfNoteDuration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfect4th, halfNoteDuration);
                break;

            case L1C5MelodicDrillType.ReSo5Desc:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor9th, halfNoteDuration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfect5th, halfNoteDuration);
                break;

            case L1C5MelodicDrillType.MiLa5Desc:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor10th, halfNoteDuration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor6th, halfNoteDuration);
                break;

            case L1C5MelodicDrillType.FaTi5Desc:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfect11th, halfNoteDuration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor7th, halfNoteDuration);
                break;

                #endregion 5ths.

            default:
                throw new NotSupportedException($"L1C5MelodicDrillType '{drillType}' is not supported.");
            }

            var phrase = note1
                         .FollowedBy(note2);

            var stwp = new SampleToWaveProvider(phrase);

            MemoryStream wavStream = new MemoryStream();
            WaveFileWriter.WriteWavFileToStream(wavStream, stwp);
            wavStream.Position = 0;
            return(wavStream);
        }
Exemplo n.º 20
0
        private MemoryStream GetHarmonicDrillEx(string doNoteName, L1C5HarmonicDrillType drillType)
        {
            TimeSpan duration = TimeSpan.FromSeconds(3);

            string doFileName = NAudioHelper.GetFileNameFromNoteName(doNoteName);

            doFileName = Path.GetFileName(doFileName);
            int doNoteNumber = int.Parse(doFileName.Split('.')[0]);

            ISampleProvider note1, note2;

            switch (drillType)
            {
                #region 4ths.

            case L1C5HarmonicDrillType.DoFa4:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber, duration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfect4th, duration);
                break;

            case L1C5HarmonicDrillType.ReSo4:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor2nd, duration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfect5th, duration);
                break;

            case L1C5HarmonicDrillType.MiLa4:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor3rd, duration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor6th, duration);
                break;

            case L1C5HarmonicDrillType.FaTi4:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfect4th, duration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor7th, duration);
                break;

            case L1C5HarmonicDrillType.SoDo4:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfect5th, duration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfectOctave, duration);
                break;

            case L1C5HarmonicDrillType.LaRe4:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor6th, duration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor9th, duration);
                break;

            case L1C5HarmonicDrillType.TiMi4:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor7th, duration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor10th, duration);
                break;

                #endregion 4ths.

                #region 5ths.

            case L1C5HarmonicDrillType.DoSo5:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber, duration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfect5th, duration);
                break;

            case L1C5HarmonicDrillType.ReLa5:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor2nd, duration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor6th, duration);
                break;

            case L1C5HarmonicDrillType.MiTi5:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor3rd, duration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor7th, duration);
                break;

            case L1C5HarmonicDrillType.FaDo5:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfect4th, duration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfectOctave, duration);
                break;

            case L1C5HarmonicDrillType.SoRe5:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfect5th, duration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor9th, duration);
                break;

            case L1C5HarmonicDrillType.LaMi5:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor6th, duration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor10th, duration);
                break;

            case L1C5HarmonicDrillType.TiFa5:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor7th, duration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfect11th, duration);
                break;

                #endregion 5ths.

            default:
                throw new NotSupportedException($"L1C5HarmonicDrillType '{drillType}' is not supported.");
            }

            MixingSampleProvider msp = new MixingSampleProvider(note1.WaveFormat);
            msp.AddMixerInput(note1);
            msp.AddMixerInput(note2);

            var stwp = new SampleToWaveProvider(msp);

            MemoryStream wavStream = new MemoryStream();
            WaveFileWriter.WriteWavFileToStream(wavStream, stwp);
            wavStream.Position = 0;
            return(wavStream);
        }
Exemplo n.º 21
0
        /// <summary>
        /// 解析音频文件,获取时间戳,截取音频,语音转文字
        /// </summary>
        /// <param name="sound_path"></param>
        /// <param name="word_path"></param>
        /// <param name="language"></param>
        /// <param name="splitTime"></param>
        public void GetTimeSpan(string sound_path, string word_path, string language, double splitTime = 1.5)
        {
            //通过NAudio读取音频文件流
            AudioFileReader inputStream    = null;
            string          sound_path_mp3 = "";

            try
            {
                if (sound_path.ToLower().EndsWith(".mp3"))
                {
                    sound_path_mp3 = sound_path;
                    //通过NAudio将文件转换为WAV格式,返回新的文件路径
                    sound_path = NAudioHelper.GetWavPath(sound_path);
                }
                inputStream = new AudioFileReader(sound_path);
                //WAV文件读取
                WAVReader reader = new WAVReader();
                //reader.GetTimeSpan(sound_path, out voicePoint, out voiceMilliSecond, splitTime);
                reader.GetTimeSpan(sound_path, out voicePoint, out musicContents, splitTime);
                //voicePoint是为了截取小音频
                //voicePoint是双数的原因是有开始时间就有一个结束时间
                //最后一次的时间要加上(结束时,没有停顿时间)
                if (voicePoint.Count % 2 != 0)
                {
                    voicePoint.Add(inputStream.TotalTime);
                }
                LogHelper.Info("时间戳获取:成功");
                //string totalTime=FfmpegHelper.getMediaDuration(sound_path);
                int _name = 1;//命名
                //一个时间点对应一段音频对应一段文字
                LogHelper.Info("语音转文字:开始");
                for (int i = 0; i < voicePoint.Count; i += 2)
                {
                    var para = new BaiduRead()
                    {
                        voice_time = musicContents.Select(o => o.voiceMilliSecond).ToList()[i / 2],
                        start      = voicePoint[i],
                        end        = voicePoint[i + 1],
                        sound_path = sound_path,
                        file_name  = _name,
                        language   = language,
                        splitTime  = splitTime
                    };
                    Task task_max = Task.Factory.StartNew(() => {
                        GetBaiduSpeech(para);
                    });
                    Task.WaitAll(task_max);

                    //GetBaiduSpeech(para);
                    ++_name;
                }
                //word原文
                originalText = NPOIHelper.ExcuteWordText(word_path);
                //word原文的集合
                results = GetTextContrast(musicContents, originalText, language);
            }
            catch (Exception ex)
            {
                LogHelper.Error(ex.Message);
            }
            #region  除文件
            finally
            {
                inputStream.Close();
                inputStream.Dispose();
                isFinish = true;
                //删除MP3文件
                if (Util.isNotNull(sound_path_mp3) && File.Exists(sound_path_mp3))
                {
                    File.Delete(sound_path_mp3);
                    string mp3_folder = Path.GetDirectoryName(sound_path_mp3);
                    if (Directory.Exists(mp3_folder) && Directory.GetFiles(mp3_folder).Length == 0)
                    {
                        Directory.Delete(mp3_folder);
                    }
                }
                //删除word文件
                if (File.Exists(word_path))
                {
                    File.Delete(word_path);
                    //删除word文件目录
                    string word_folder = Path.GetDirectoryName(word_path);
                    if (Directory.Exists(word_folder) && Directory.GetFiles(word_folder).Length == 0)
                    {
                        Directory.Delete(word_folder);
                    }
                }

                //删除文件夹,删除原音频文件
                if (File.Exists(sound_path))
                {
                    File.Delete(sound_path);
                    //删除原音频目录
                    string sound_folder = Path.GetDirectoryName(sound_path);
                    if (Directory.Exists(sound_folder) && Directory.GetFiles(sound_folder).Length == 0)
                    {
                        Directory.Delete(sound_folder);
                    }
                }
            }
            #endregion
        }
Exemplo n.º 22
0
        public ActionResult AudioAndDictation(int resolutionType, string keySignature, double bpm, int numberOfMeasures)
        {
            // We'll add stuff to the Dictionary and return as JSON.
            var dict = new Dictionary <string, string>();

            #region Audio

            //double bpm = double.Parse(ConfigurationManager.AppSettings["BPM"]);
            double   quarterNoteMillis      = (60 / bpm) * 1000;
            TimeSpan quarterNoteDuration    = TimeSpan.FromMilliseconds(quarterNoteMillis);
            TimeSpan halfNoteDuration       = TimeSpan.FromMilliseconds(quarterNoteMillis * 2);
            TimeSpan dottedHalfNoteDuration = TimeSpan.FromMilliseconds(quarterNoteMillis * 3);
            TimeSpan wholeNoteDuration      = TimeSpan.FromMilliseconds(quarterNoteMillis * 4);

            // Setup the scale note numbers.
            int[] scaleNoteNumbers = new int[] { 38, 39, 41, 43, 44, 46, 48, 50, 51 };  // C Major, with a low TI.
            scaleNoteNumbers = NoteHelper.TransposeScaleNoteNumbers(scaleNoteNumbers, keySignature);

            // The initial DO.
            ISampleProvider wholeDoNote = NAudioHelper.GetSampleProvider(scaleNoteNumbers[1], wholeNoteDuration);

            // Four metronome ticks before the transcription part plays.
            ISampleProvider[] ticks    = new ISampleProvider[4];
            string            tickFile = HostingEnvironment.MapPath($"~/Samples/Woodblock.wav");
            for (int i = 0; i < ticks.Length; i++)
            {
                ticks[i] = NAudioHelper.GetSampleProviderFromFile(tickFile, quarterNoteDuration);
            }

            List <string> measureRhythms = GetNoteRhythms();

            int    randomInt      = NoteHelper.GetRandomInt(0, measureRhythms.Count);
            string measureRhythm1 = measureRhythms[randomInt];
            randomInt = NoteHelper.GetRandomInt(0, measureRhythms.Count);
            string measureRhythm2 = measureRhythms[randomInt];
            if (numberOfMeasures == 2)
            {
                while ((measureRhythm1.Split(',').Count() + measureRhythm2.Split(',').Count()) % 2 == 1)  // Ensure an even number of notes, so there's always a (reverse) resolution.
                {
                    randomInt      = NoteHelper.GetRandomInt(0, measureRhythms.Count);
                    measureRhythm2 = measureRhythms[randomInt];
                }
            }
            randomInt = NoteHelper.GetRandomInt(0, measureRhythms.Count);
            string measureRhythm3 = measureRhythms[randomInt];
            randomInt = NoteHelper.GetRandomInt(0, measureRhythms.Count);
            string measureRhythm4 = measureRhythms[randomInt];
            if (numberOfMeasures == 4)
            {
                while ((measureRhythm1.Split(',').Count() + measureRhythm2.Split(',').Count() + measureRhythm3.Split(',').Count() + measureRhythm4.Split(',').Count()) % 2 == 1)
                {
                    randomInt      = NoteHelper.GetRandomInt(0, measureRhythms.Count);
                    measureRhythm4 = measureRhythms[randomInt];
                }
            }

            string[] measureRhythmSplit1 = measureRhythm1.Split(',');
            int      numberOfNotes1      = measureRhythmSplit1.Length;
            string[] measureRhythmSplit2 = measureRhythm2.Split(',');
            int      numberOfNotes2      = measureRhythmSplit2.Length;
            string[] measureRhythmSplit3 = measureRhythm3.Split(',');
            int      numberOfNotes3      = measureRhythmSplit3.Length;
            string[] measureRhythmSplit4 = measureRhythm4.Split(',');
            int      numberOfNotes4      = measureRhythmSplit4.Length;

            ISampleProvider[] notes1 = new ISampleProvider[numberOfNotes1];
            ISampleProvider[] notes2 = new ISampleProvider[numberOfNotes2];
            ISampleProvider[] notes3 = new ISampleProvider[numberOfNotes3];
            ISampleProvider[] notes4 = new ISampleProvider[numberOfNotes4];

            Queue <int> noteNumberQueue;
            switch (resolutionType)
            {
            case 1:
                noteNumberQueue = GetResolutionIntQueue(scaleNoteNumbers, 16, 1);      // 16 notes max.
                break;

            case 2:
                noteNumberQueue = GetResolutionIntQueue(scaleNoteNumbers, 16, 2);
                break;

            case 3:
                noteNumberQueue = GetResolutionIntQueue(scaleNoteNumbers, 16, 3);
                break;

            default:
                throw new NotSupportedException($"ResolutionType '{resolutionType}' is not supported.");
            }

            int[] measureNoteNumbers1 = NoteHelper.PopulateNoteNumbersFromQueue(numberOfNotes1, noteNumberQueue);
            int[] measureNoteNumbers2 = NoteHelper.PopulateNoteNumbersFromQueue(numberOfNotes2, noteNumberQueue);
            int[] measureNoteNumbers3 = NoteHelper.PopulateNoteNumbersFromQueue(numberOfNotes3, noteNumberQueue);
            int[] measureNoteNumbers4 = NoteHelper.PopulateNoteNumbersFromQueue(numberOfNotes4, noteNumberQueue);

            NoteHelper.CreateSamplesFromRhythmsAndNoteNames(new TimeSpan(), quarterNoteDuration, halfNoteDuration, dottedHalfNoteDuration, wholeNoteDuration, measureRhythmSplit1, notes1, measureNoteNumbers1);
            NoteHelper.CreateSamplesFromRhythmsAndNoteNames(new TimeSpan(), quarterNoteDuration, halfNoteDuration, dottedHalfNoteDuration, wholeNoteDuration, measureRhythmSplit2, notes2, measureNoteNumbers2);
            NoteHelper.CreateSamplesFromRhythmsAndNoteNames(new TimeSpan(), quarterNoteDuration, halfNoteDuration, dottedHalfNoteDuration, wholeNoteDuration, measureRhythmSplit3, notes3, measureNoteNumbers3);
            NoteHelper.CreateSamplesFromRhythmsAndNoteNames(new TimeSpan(), quarterNoteDuration, halfNoteDuration, dottedHalfNoteDuration, wholeNoteDuration, measureRhythmSplit4, notes4, measureNoteNumbers4);

            ISampleProvider phrase =
                wholeDoNote;

            foreach (var tick in ticks)
            {
                phrase = phrase.FollowedBy(tick);
            }

            foreach (var note1 in notes1)
            {
                phrase = phrase.FollowedBy(note1);
            }
            foreach (var note2 in notes2)
            {
                phrase = phrase.FollowedBy(note2);
            }
            if (numberOfMeasures == 4)
            {
                foreach (var note3 in notes3)
                {
                    phrase = phrase.FollowedBy(note3);
                }
                foreach (var note4 in notes4)
                {
                    phrase = phrase.FollowedBy(note4);
                }
            }

            // HACK: Use an empty note because without it, the audio gets cut short.
            ISampleProvider emptyNote = NAudioHelper.GetSampleProvider(0, 0, SignalGeneratorType.White, halfNoteDuration);
            phrase = phrase.FollowedBy(emptyNote);

            SampleToWaveProvider stwp = new SampleToWaveProvider(phrase);
            MixingSampleProvider msp  = new MixingSampleProvider(stwp.WaveFormat);
            msp.AddMixerInput(stwp);

            int totalTicks = 8 + (4 * numberOfMeasures);
            ISampleProvider[] metronomeTicks = new ISampleProvider[totalTicks];

            // The first two measures have zero gain, as this is the initial DO whole note and metronome ticks.
            for (int i = 0; i < 8; i++)
            {
                metronomeTicks[i] = NAudioHelper.GetSampleProvider(0, 0, SignalGeneratorType.White, quarterNoteDuration);
            }
            for (int i = 8; i < totalTicks; i++)
            {
                metronomeTicks[i] = NAudioHelper.GetSampleProviderFromFile(tickFile, quarterNoteDuration);
            }

            ISampleProvider metronomePhrase = metronomeTicks[0];
            for (int i = 0; i < metronomeTicks.Length; i++)
            {
                metronomePhrase = metronomePhrase.FollowedBy(metronomeTicks[i]);
            }

            msp.AddMixerInput(metronomePhrase);

            IWaveProvider wp = msp.ToWaveProvider();

            MemoryStream wavStream = new MemoryStream();
            //WaveFileWriter.WriteWavFileToStream(wavStream, stwp);
            WaveFileWriter.WriteWavFileToStream(wavStream, wp);
            wavStream.Position = 0;
            wavStream.WavToMp3File(out string fileName);
            dict.Add("src", fileName);

            #endregion Audio

            #region Notation

            string[] noteNames1 = new string[numberOfNotes1];
            NoteHelper.AdjustNoteNamesForKey(keySignature, measureNoteNumbers1, noteNames1);

            string[] noteNames2 = new string[numberOfNotes2];
            NoteHelper.AdjustNoteNamesForKey(keySignature, measureNoteNumbers2, noteNames2);

            string[] noteNames3 = new string[numberOfNotes3];
            NoteHelper.AdjustNoteNamesForKey(keySignature, measureNoteNumbers3, noteNames3);

            string[] noteNames4 = new string[numberOfNotes4];
            NoteHelper.AdjustNoteNamesForKey(keySignature, measureNoteNumbers4, noteNames4);

            string script1 = NoteHelper.GetEasyScoreScript("transcription1", noteNames1, measureRhythmSplit1, keySignature, true);
            dict.Add("theScript1", script1);
            string script2 = NoteHelper.GetEasyScoreScript("transcription2", noteNames2, measureRhythmSplit2, keySignature, false);
            dict.Add("theScript2", script2);
            if (numberOfMeasures == 4)
            {
                string script3 = NoteHelper.GetEasyScoreScript("transcription3", noteNames3, measureRhythmSplit3, keySignature, false);
                dict.Add("theScript3", script3);
                string script4 = NoteHelper.GetEasyScoreScript("transcription4", noteNames4, measureRhythmSplit4, keySignature, false);
                dict.Add("theScript4", script4);
            }

            #endregion Notation

            var json = Json(dict, JsonRequestBehavior.AllowGet);
            return(json);
        }
Exemplo n.º 23
0
        public ActionResult Get3ChordProgressionEx(string doNoteName, int progressiontype)
        {
            var progressionType = (ProgressionType)progressiontype;

            TimeSpan noteDuration = TimeSpan.FromSeconds(2);

            string doFileName = NAudioHelper.GetFileNameFromNoteName(doNoteName);

            doFileName = Path.GetFileName(doFileName);
            int doNoteNumber = int.Parse(doFileName.Split('.')[0]);

            ISampleProvider[] samples1;
            ISampleProvider[] samples2;
            ISampleProvider[] samples3;

            switch (progressionType)
            {
            case ProgressionType.Four2ndFive1stOneRoot:
                samples1 = Inversion.CreateTriadInversionEx(InversionType.LowSecond, noteDuration, doNoteNumber + Interval.UpPerfect4th, doNoteNumber + Interval.UpMajor6th, doNoteNumber + Interval.UpPerfectOctave, (doNoteNumber + Interval.UpPerfect4th).BassNoteNumber());
                samples2 = Inversion.CreateTriadInversionEx(InversionType.LowFirst, noteDuration, doNoteNumber + Interval.UpPerfect5th, doNoteNumber + Interval.UpMajor7th, doNoteNumber + Interval.UpMajor9th, (doNoteNumber + Interval.UpPerfect5th).BassNoteNumber());
                samples3 = Inversion.CreateTriadInversionEx(InversionType.Root, noteDuration.Add(noteDuration), doNoteNumber, doNoteNumber + Interval.UpMajor3rd, doNoteNumber + Interval.UpPerfect5th, doNoteNumber.BassNoteNumber());
                break;

            case ProgressionType.OneRootFour2ndFive1st:
                samples1 = Inversion.CreateTriadInversionEx(InversionType.Root, noteDuration, doNoteNumber, doNoteNumber + Interval.UpMajor3rd, doNoteNumber + Interval.UpPerfect5th, doNoteNumber.BassNoteNumber());
                samples2 = Inversion.CreateTriadInversionEx(InversionType.LowSecond, noteDuration, doNoteNumber + Interval.UpPerfect4th, doNoteNumber + Interval.UpMajor6th, doNoteNumber + Interval.UpPerfectOctave, (doNoteNumber + Interval.UpPerfect4th).BassNoteNumber());
                samples3 = Inversion.CreateTriadInversionEx(InversionType.LowFirst, noteDuration.Add(noteDuration), doNoteNumber + Interval.UpPerfect5th, doNoteNumber + Interval.UpMajor7th, doNoteNumber + Interval.UpMajor9th, (doNoteNumber + Interval.UpPerfect5th).BassNoteNumber());
                break;


            case ProgressionType.Four2ndOneRootFive1st:
                samples1 = Inversion.CreateTriadInversionEx(InversionType.LowSecond, noteDuration, doNoteNumber + Interval.UpPerfect4th, doNoteNumber + Interval.UpMajor6th, doNoteNumber + Interval.UpPerfectOctave, (doNoteNumber + Interval.UpPerfect4th).BassNoteNumber());
                samples2 = Inversion.CreateTriadInversionEx(InversionType.Root, noteDuration, doNoteNumber, doNoteNumber + Interval.UpMajor3rd, doNoteNumber + Interval.UpPerfect5th, doNoteNumber.BassNoteNumber());
                samples3 = Inversion.CreateTriadInversionEx(InversionType.LowFirst, noteDuration.Add(noteDuration), doNoteNumber + Interval.UpPerfect5th, doNoteNumber + Interval.UpMajor7th, doNoteNumber + Interval.UpMajor9th, (doNoteNumber + Interval.UpPerfect5th).BassNoteNumber());
                break;

            case ProgressionType.OneRootFive1stSixMin1st:
                samples1 = Inversion.CreateTriadInversionEx(InversionType.Root, noteDuration, doNoteNumber, doNoteNumber + Interval.UpMajor3rd, doNoteNumber + Interval.UpPerfect5th, doNoteNumber.BassNoteNumber());
                samples2 = Inversion.CreateTriadInversionEx(InversionType.LowFirst, noteDuration, doNoteNumber + Interval.UpPerfect5th, doNoteNumber + Interval.UpMajor7th, doNoteNumber + Interval.UpMajor9th, (doNoteNumber + Interval.UpPerfect5th).BassNoteNumber());
                samples3 = Inversion.CreateTriadInversionEx(InversionType.LowFirst, noteDuration.Add(noteDuration), doNoteNumber + Interval.UpMajor6th, doNoteNumber + Interval.UpPerfectOctave, doNoteNumber + Interval.UpMajor10th, (doNoteNumber + Interval.UpMajor6th).BassNoteNumber());
                break;

            case ProgressionType.SixMin2ndFourRootOne1st:
                samples1 = Inversion.CreateTriadInversionEx(InversionType.LowSecond, noteDuration, doNoteNumber + Interval.UpMajor6th, doNoteNumber + Interval.UpPerfectOctave, doNoteNumber + Interval.UpMajor10th, (doNoteNumber + Interval.UpMajor6th).BassNoteNumber());
                samples2 = Inversion.CreateTriadInversionEx(InversionType.Root, noteDuration, doNoteNumber + Interval.UpPerfect4th, doNoteNumber + Interval.UpMajor6th, doNoteNumber + Interval.UpPerfectOctave, (doNoteNumber + Interval.UpPerfect4th).BassNoteNumber());
                samples3 = Inversion.CreateTriadInversionEx(InversionType.HighFirst, noteDuration.Add(noteDuration), doNoteNumber, doNoteNumber + Interval.UpMajor3rd, doNoteNumber + Interval.UpPerfect5th, doNoteNumber.BassNoteNumber());
                break;

            case ProgressionType.OneRootSixMin1stFive1st:
                samples1 = Inversion.CreateTriadInversionEx(InversionType.Root, noteDuration, doNoteNumber, doNoteNumber + Interval.UpMajor3rd, doNoteNumber + Interval.UpPerfect5th, doNoteNumber.BassNoteNumber());
                samples2 = Inversion.CreateTriadInversionEx(InversionType.LowFirst, noteDuration, doNoteNumber + Interval.UpMajor6th, doNoteNumber + Interval.UpPerfectOctave, doNoteNumber + Interval.UpMajor10th, (doNoteNumber + Interval.UpMajor6th).BassNoteNumber());
                samples3 = Inversion.CreateTriadInversionEx(InversionType.LowFirst, noteDuration.Add(noteDuration), doNoteNumber + Interval.UpPerfect5th, doNoteNumber + Interval.UpMajor7th, doNoteNumber + Interval.UpMajor9th, (doNoteNumber + Interval.UpPerfect5th).BassNoteNumber());
                break;

            case ProgressionType.FiveRootFourRootSixMin2nd:
                samples1 = Inversion.CreateTriadInversionEx(InversionType.Root, noteDuration, doNoteNumber + Interval.UpPerfect5th, doNoteNumber + Interval.UpMajor7th, doNoteNumber + Interval.UpMajor9th, (doNoteNumber + Interval.UpPerfect5th).BassNoteNumber());
                samples2 = Inversion.CreateTriadInversionEx(InversionType.Root, noteDuration, doNoteNumber + Interval.UpPerfect4th, doNoteNumber + Interval.UpMajor6th, doNoteNumber + Interval.UpPerfectOctave, (doNoteNumber + Interval.UpPerfect4th).BassNoteNumber());
                samples3 = Inversion.CreateTriadInversionEx(InversionType.LowSecond, noteDuration.Add(noteDuration), doNoteNumber + Interval.UpMajor6th, doNoteNumber + Interval.UpPerfectOctave, doNoteNumber + Interval.UpMajor10th, (doNoteNumber + Interval.UpMajor6th).BassNoteNumber());
                break;

            case ProgressionType.FourRootFiveRootSixMinRoot:
                samples1 = Inversion.CreateTriadInversionEx(InversionType.Root, noteDuration, doNoteNumber + Interval.UpPerfect4th, doNoteNumber + Interval.UpMajor6th, doNoteNumber + Interval.UpPerfectOctave, (doNoteNumber + Interval.UpPerfect4th).BassNoteNumber());
                samples2 = Inversion.CreateTriadInversionEx(InversionType.Root, noteDuration, doNoteNumber + Interval.UpPerfect5th, doNoteNumber + Interval.UpMajor7th, doNoteNumber + Interval.UpMajor9th, (doNoteNumber + Interval.UpPerfect5th).BassNoteNumber());
                samples3 = Inversion.CreateTriadInversionEx(InversionType.Root, noteDuration.Add(noteDuration), doNoteNumber + Interval.UpMajor6th, doNoteNumber + Interval.UpPerfectOctave, doNoteNumber + Interval.UpMajor10th, (doNoteNumber + Interval.UpMajor6th).BassNoteNumber());
                break;

            case ProgressionType.SixMin1stOne2ndFour1st:
                samples1 = Inversion.CreateTriadInversionEx(InversionType.LowFirst, noteDuration, doNoteNumber + Interval.UpMajor6th, doNoteNumber + Interval.UpPerfectOctave, doNoteNumber + Interval.UpMajor10th, (doNoteNumber + Interval.UpMajor6th).BassNoteNumber());
                samples2 = Inversion.CreateTriadInversionEx(InversionType.LowSecond, noteDuration, doNoteNumber, doNoteNumber + Interval.UpMajor3rd, doNoteNumber + Interval.UpPerfect5th, doNoteNumber.BassNoteNumber());
                samples3 = Inversion.CreateTriadInversionEx(InversionType.LowFirst, noteDuration.Add(noteDuration), doNoteNumber + Interval.UpPerfect4th, doNoteNumber + Interval.UpMajor6th, doNoteNumber + Interval.UpPerfectOctave, (doNoteNumber + Interval.UpPerfect4th).BassNoteNumber());
                break;

            case ProgressionType.Five2ndSixMin2ndOneRoot:
                samples1 = Inversion.CreateTriadInversionEx(InversionType.LowSecond, noteDuration, doNoteNumber + Interval.UpPerfect5th, doNoteNumber + Interval.UpMajor7th, doNoteNumber + Interval.UpMajor9th, (doNoteNumber + Interval.UpPerfect5th).BassNoteNumber());
                samples2 = Inversion.CreateTriadInversionEx(InversionType.LowSecond, noteDuration, doNoteNumber + Interval.UpMajor6th, doNoteNumber + Interval.UpPerfectOctave, doNoteNumber + Interval.UpMajor10th, (doNoteNumber + Interval.UpMajor6th).BassNoteNumber());
                samples3 = Inversion.CreateTriadInversionEx(InversionType.Root, noteDuration.Add(noteDuration), doNoteNumber, doNoteNumber + Interval.UpMajor3rd, doNoteNumber + Interval.UpPerfect5th, doNoteNumber.BassNoteNumber());
                break;

            default:
                throw new NotSupportedException($"ProgressionType {progressionType} is not supported.");
            }

            // First chord.
            MixingSampleProvider msp1 = new MixingSampleProvider(samples1[0].WaveFormat);

            msp1.AddMixerInput(samples1[0]);
            msp1.AddMixerInput(samples1[1]);
            msp1.AddMixerInput(samples1[2]);
            if (samples1[3] != null)  // Bass note.
            {
                msp1.AddMixerInput(samples1[3]);
            }

            // Second chord.
            MixingSampleProvider msp2 = new MixingSampleProvider(samples2[0].WaveFormat);

            msp2.AddMixerInput(samples2[0]);
            msp2.AddMixerInput(samples2[1]);
            msp2.AddMixerInput(samples2[2]);
            if (samples2[3] != null)  // Bass note.
            {
                msp2.AddMixerInput(samples2[3]);
            }

            // Third chord.
            MixingSampleProvider msp3 = new MixingSampleProvider(samples3[0].WaveFormat);

            msp3.AddMixerInput(samples3[0]);
            msp3.AddMixerInput(samples3[1]);
            msp3.AddMixerInput(samples3[2]);
            if (samples3[3] != null)  // Bass note.
            {
                msp3.AddMixerInput(samples3[3]);
            }

            var phrase = msp1
                         .FollowedBy(msp2)
                         .FollowedBy(msp3);

            var stwp = new SampleToWaveProvider(phrase);

            MemoryStream wavStream = new MemoryStream();

            WaveFileWriter.WriteWavFileToStream(wavStream, stwp);
            wavStream.Position = 0;

            wavStream.WavToMp3File(out string fileName);
            return(Redirect($"~/Temp/{fileName}"));
        }
Exemplo n.º 24
0
 private void InitRequest()
 {
     //Fill the viewbag values
     ViewBag.Volume            = NAudioHelper.GetCurrentSoundLevel();
     ViewBag.AudioDeviceExists = NAudioHelper.GetDefaultAudioEndpoint() != null;
 }
Exemplo n.º 25
0
        private MemoryStream GetMelodicDrillEx(string doNoteName, L1C5MelodicDrillType drillType)
        {
            double bpm = double.Parse(ConfigurationManager.AppSettings["BPM"]);
            double quarterNoteMillis = (60 / bpm) * 1000;
            double eighthNoteMillis  = quarterNoteMillis / 2;

            TimeSpan eighthNoteDuration  = TimeSpan.FromMilliseconds(eighthNoteMillis);
            TimeSpan quarterNoteDuration = eighthNoteDuration.Add(eighthNoteDuration);
            TimeSpan wholeNoteDuration   = quarterNoteDuration.Add(quarterNoteDuration).Add(quarterNoteDuration).Add(quarterNoteDuration);

            string doFileName = NAudioHelper.GetFileNameFromNoteName(doNoteName);

            doFileName = Path.GetFileName(doFileName);
            int doNoteNumber = int.Parse(doFileName.Split('.')[0]);

            ISampleProvider note1, note2, note3, note4, note5, note6;

            switch (drillType)
            {
                #region 4ths.

            case L1C5MelodicDrillType.DoDoDoFaFaMi4:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber, quarterNoteDuration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber, eighthNoteDuration);
                note3 = NAudioHelper.GetSampleProvider(doNoteNumber, eighthNoteDuration);
                note4 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfect4th, quarterNoteDuration);
                note5 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfect4th, quarterNoteDuration);
                note6 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor3rd, wholeNoteDuration);
                break;

            case L1C5MelodicDrillType.ReReSoSoSoSo4:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor2nd, quarterNoteDuration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor2nd, quarterNoteDuration);
                note3 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfect5th, quarterNoteDuration);
                note4 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfect5th, eighthNoteDuration);
                note5 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfect5th, eighthNoteDuration);
                note6 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfect5th, wholeNoteDuration);
                break;

            case L1C5MelodicDrillType.MiMiMiLaLaSo4:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor3rd, quarterNoteDuration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor3rd, eighthNoteDuration);
                note3 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor3rd, eighthNoteDuration);
                note4 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor6th, quarterNoteDuration);
                note5 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor6th, quarterNoteDuration);
                note6 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfect5th, wholeNoteDuration);
                break;

            case L1C5MelodicDrillType.FaFaTiTiTiDo4:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfect4th, quarterNoteDuration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfect4th, quarterNoteDuration);
                note3 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor7th, quarterNoteDuration);
                note4 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor7th, eighthNoteDuration);
                note5 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor7th, eighthNoteDuration);
                note6 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfectOctave, wholeNoteDuration);
                break;

            case L1C5MelodicDrillType.SoSoSoDoDoDo4:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfect5th, quarterNoteDuration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfect5th, eighthNoteDuration);
                note3 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfect5th, eighthNoteDuration);
                note4 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfectOctave, quarterNoteDuration);
                note5 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfectOctave, quarterNoteDuration);
                note6 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfectOctave, wholeNoteDuration);
                break;

            case L1C5MelodicDrillType.LaLaReReReDo4:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor6th, quarterNoteDuration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor6th, quarterNoteDuration);
                note3 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor9th, quarterNoteDuration);
                note4 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor9th, eighthNoteDuration);
                note5 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor9th, eighthNoteDuration);
                note6 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfectOctave, wholeNoteDuration);
                break;

            case L1C5MelodicDrillType.TiTiTiMiMiMi4:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor7th, quarterNoteDuration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor7th, eighthNoteDuration);
                note3 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor7th, eighthNoteDuration);
                note4 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor10th, quarterNoteDuration);
                note5 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor10th, quarterNoteDuration);
                note6 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor10th, wholeNoteDuration);
                break;

                #endregion 4ths.

                #region 5ths.

            case L1C5MelodicDrillType.DoDoDoSoSoSo5:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber, quarterNoteDuration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber, eighthNoteDuration);
                note3 = NAudioHelper.GetSampleProvider(doNoteNumber, eighthNoteDuration);
                note4 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfect5th, quarterNoteDuration);
                note5 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfect5th, quarterNoteDuration);
                note6 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfect5th, wholeNoteDuration);
                break;

            case L1C5MelodicDrillType.ReReLaLaLaSo5:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor2nd, quarterNoteDuration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor2nd, quarterNoteDuration);
                note3 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor6th, quarterNoteDuration);
                note4 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor6th, eighthNoteDuration);
                note5 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor6th, eighthNoteDuration);
                note6 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfect5th, wholeNoteDuration);
                break;

            case L1C5MelodicDrillType.MiMiMiTiTiDo5:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor3rd, quarterNoteDuration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor3rd, eighthNoteDuration);
                note3 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor3rd, eighthNoteDuration);
                note4 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor7th, quarterNoteDuration);
                note5 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor7th, quarterNoteDuration);
                note6 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfectOctave, wholeNoteDuration);
                break;

            case L1C5MelodicDrillType.FaFaDoDoDoDo5:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfect4th, quarterNoteDuration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfect4th, quarterNoteDuration);
                note3 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfectOctave, quarterNoteDuration);
                note4 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfectOctave, eighthNoteDuration);
                note5 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfectOctave, eighthNoteDuration);
                note6 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfectOctave, wholeNoteDuration);
                break;

            case L1C5MelodicDrillType.SoSoSoReReDo5:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfect5th, quarterNoteDuration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfect5th, eighthNoteDuration);
                note3 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfect5th, eighthNoteDuration);
                note4 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor9th, quarterNoteDuration);
                note5 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor9th, quarterNoteDuration);
                note6 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfectOctave, wholeNoteDuration);
                break;

            case L1C5MelodicDrillType.LaLaMiMiMiMi5:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor6th, quarterNoteDuration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor6th, quarterNoteDuration);
                note3 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor10th, quarterNoteDuration);
                note4 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor10th, eighthNoteDuration);
                note5 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor10th, eighthNoteDuration);
                note6 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor10th, wholeNoteDuration);
                break;

            case L1C5MelodicDrillType.FaFaFaTiTiDo5:
                note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfect4th, quarterNoteDuration);
                note2 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfect4th, eighthNoteDuration);
                note3 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfect4th, eighthNoteDuration);
                note4 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.DownMinor2nd, quarterNoteDuration);
                note5 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.DownMinor2nd, quarterNoteDuration);
                note6 = NAudioHelper.GetSampleProvider(doNoteNumber, wholeNoteDuration);
                break;

                #endregion 5ths.

            default:
                throw new NotSupportedException($"L1C5MelodicDrillType '{drillType}' is not supported.");
            }

            var phrase = note1
                         .FollowedBy(note2)
                         .FollowedBy(note3)
                         .FollowedBy(note4)
                         .FollowedBy(note5)
                         .FollowedBy(note6);

            var stwp = new SampleToWaveProvider(phrase);

            MemoryStream wavStream = new MemoryStream();
            WaveFileWriter.WriteWavFileToStream(wavStream, stwp);
            wavStream.Position = 0;
            return(wavStream);
        }
Exemplo n.º 26
0
        public ActionResult AudioAndDictation(int intervalType, string keySignature, double bpm, int numberOfMeasures, string smallestRhythmicUnit, bool includeC2)
        {
            _log.Debug($"intervalType: {intervalType}, keySignature: {keySignature}, bpm: {bpm}, numberOfMeasures: {numberOfMeasures}, smallestRhythmicUnit: {smallestRhythmicUnit}, includeC2: {includeC2}");

            L1C3IntervalType intType = (L1C3IntervalType)intervalType;

            bool includeEighthNoteRhythms = smallestRhythmicUnit.ToUpper() == "EIGHTH";

            // We'll add stuff to the Dictionary and return as JSON.
            var dict = new Dictionary <string, string>();

            #region Audio

            //double bpm = double.Parse(ConfigurationManager.AppSettings["BPM"]);
            double   quarterNoteMillis      = (60 / bpm) * 1000;
            TimeSpan quarterNoteDuration    = TimeSpan.FromMilliseconds(quarterNoteMillis);
            TimeSpan halfNoteDuration       = TimeSpan.FromMilliseconds(quarterNoteMillis * 2);
            TimeSpan dottedHalfNoteDuration = TimeSpan.FromMilliseconds(quarterNoteMillis * 3);
            TimeSpan wholeNoteDuration      = TimeSpan.FromMilliseconds(quarterNoteMillis * 4);
            TimeSpan eighthNoteDuration     = TimeSpan.FromMilliseconds(quarterNoteMillis / 2);

            // Setup the scale note numbers.
            int[] scaleNoteNumbers = new int[] { 38, 39, 41, 43, 44, 46, 48, 50, 51, 53, 55, 56, 58, 60 };  // C Major, low TI to high SO.
            scaleNoteNumbers = NoteHelper.TransposeScaleNoteNumbers(scaleNoteNumbers, keySignature);

            // The initial DO.
            ISampleProvider wholeDoNote = NAudioHelper.GetSampleProvider(scaleNoteNumbers[1], wholeNoteDuration);

            // Four metronome ticks before the transcription part plays.
            ISampleProvider[] ticks    = new ISampleProvider[4];
            string            tickFile = HostingEnvironment.MapPath($"~/Samples/Woodblock.wav");
            for (int i = 0; i < ticks.Length; i++)
            {
                ticks[i] = NAudioHelper.GetSampleProviderFromFile(tickFile, quarterNoteDuration);
            }

            List <string> measureRhythms = GetNoteRhythms(includeEighthNoteRhythms);

            int    randomInt;
            string measureRhythm1;
            string measureRhythm2;
            // Ensure there's at least 4 notes per 2 measures, as we need at least one C1 resolutiona and at least 1 C2 interval.
            // Ensure an even number of notes, so the interval is complete.
            // Ensure there's exactly one pair of eighth notes for each two measure phrase.
            while (true)
            {
                randomInt      = NoteHelper.GetRandomInt(0, measureRhythms.Count);
                measureRhythm1 = measureRhythms[randomInt];
                randomInt      = NoteHelper.GetRandomInt(0, measureRhythms.Count);
                measureRhythm2 = measureRhythms[randomInt];

                int totalNotes       = measureRhythm1.Split(',').Count() + measureRhythm2.Split(',').Count();
                int totalEighthNotes = measureRhythm1.Split(',').Where(w => w == "8").Count() + measureRhythm2.Split(',').Where(w => w == "8").Count();

                // Ensure a minimum number of notes for the 2 measure phrase. This could be 4, or 6 if C2 intervals are included.
                int minimumNumberOfNotes = includeC2 ? 6 : 4;
                if (totalNotes < minimumNumberOfNotes)
                {
                    continue;
                }

                // Ensure an even number of notes.
                if (totalNotes % 2 != 0)
                {
                    continue;
                }

                // If quarter note is smallest rhythmic unit, ensure no eighth notes.
                if (!includeEighthNoteRhythms && totalEighthNotes > 0)
                {
                    continue;
                }

                // If eighth note is smallest rhythic unit, ensure just one pair of eighth notes.
                if (includeEighthNoteRhythms && totalEighthNotes != 2)
                {
                    continue;
                }

                break;
            }

            string measureRhythm3 = string.Empty;
            string measureRhythm4 = string.Empty;

            // TODO: Figure out how to refactor this. Kinda messy, but for now we need to populate measures 3 and 4 even if the user
            // choose just 2 measures.
            randomInt      = NoteHelper.GetRandomInt(0, measureRhythms.Count);
            measureRhythm3 = measureRhythms[randomInt];
            randomInt      = NoteHelper.GetRandomInt(0, measureRhythms.Count);
            measureRhythm4 = measureRhythms[randomInt];

            //if (numberOfMeasures == 4)
            if (true)
            {
                while (true)
                {
                    randomInt      = NoteHelper.GetRandomInt(0, measureRhythms.Count);
                    measureRhythm3 = measureRhythms[randomInt];
                    randomInt      = NoteHelper.GetRandomInt(0, measureRhythms.Count);
                    measureRhythm4 = measureRhythms[randomInt];

                    int totalNotes       = measureRhythm3.Split(',').Count() + measureRhythm4.Split(',').Count();
                    int totalEighthNotes = measureRhythm3.Split(',').Where(w => w == "8").Count() + measureRhythm4.Split(',').Where(w => w == "8").Count();

                    // Ensure a minimum number of notes for the 2 measure phrase. This could be 4, or 6 if C2 intervals are included.
                    int minimumNumberOfNotes = includeC2 ? 6 : 4;
                    if (totalNotes < minimumNumberOfNotes)
                    {
                        continue;
                    }

                    // Ensure an even number of notes.
                    if (totalNotes % 2 != 0)
                    {
                        continue;
                    }

                    // If quarter note is smallest rhythmic unit, ensure no eighth notes.
                    if (!includeEighthNoteRhythms && totalEighthNotes > 0)
                    {
                        continue;
                    }

                    // If eighth note is smallest rhythic unit, ensure just one pair of eighth notes.
                    if (includeEighthNoteRhythms && totalEighthNotes != 2)
                    {
                        continue;
                    }

                    break;
                }
            }

            string[] measureRhythmSplit1 = measureRhythm1.Split(',');
            int      numberOfNotes1      = measureRhythmSplit1.Length;
            string[] measureRhythmSplit2 = measureRhythm2.Split(',');
            int      numberOfNotes2      = measureRhythmSplit2.Length;
            string[] measureRhythmSplit3 = measureRhythm3.Split(',');
            int      numberOfNotes3      = measureRhythmSplit3.Length;
            string[] measureRhythmSplit4 = measureRhythm4.Split(',');
            int      numberOfNotes4      = measureRhythmSplit4.Length;

            ISampleProvider[] notes1 = new ISampleProvider[numberOfNotes1];
            ISampleProvider[] notes2 = new ISampleProvider[numberOfNotes2];
            ISampleProvider[] notes3 = new ISampleProvider[numberOfNotes3];
            ISampleProvider[] notes4 = new ISampleProvider[numberOfNotes4];

            int first2MeasuresNumberOfNotes  = numberOfNotes1 + numberOfNotes2;
            int second2MeasuresNumberOfNotes = numberOfNotes3 + numberOfNotes4;

            Queue <int> noteNumberQueue    = new Queue <int>();
            bool        criteriaSatisfied  = false;
            int         numberOfTries      = 0;
            int         maxNumberOfTries   = 1999;
            var         parametersToString = string.Empty;

            try
            {
                while (!(noteNumberQueue.AllStepsWithinRange(12) && noteNumberQueue.AllNotesWithinRange(12) && criteriaSatisfied))
                {
                    numberOfTries++;

                    //_log.Info($"numberOfTries: {numberOfTries}");
                    //_log.Info($"measureRhythm1: {measureRhythm1}");
                    //_log.Info($"measureRhythm2: {measureRhythm2}");
                    if (numberOfTries > maxNumberOfTries)
                    {
                        throw new PhraseGenerationException($"Aborted phrase generation after {numberOfTries} tries.");
                    }

                    noteNumberQueue = GetIntervalIntQueue(scaleNoteNumbers, first2MeasuresNumberOfNotes, second2MeasuresNumberOfNotes, intType, out criteriaSatisfied, includeC2, out parametersToString);
                }
            }
            catch (PhraseGenerationException pgEx)
            {
                _log.Trace($"{numberOfTries} - {parametersToString}");

                _log.Error(pgEx, $"The maxNumberOfTries ({maxNumberOfTries}) has been exceeded.");
                dict.Add("hasError", "yep");
                dict.Add("numberOfTries", numberOfTries.ToString());
                var jsonEx = Json(dict, JsonRequestBehavior.AllowGet);
                return(jsonEx);
            }

            _log.Trace(numberOfTries);

            int[] measureNoteNumbers1 = NoteHelper.PopulateNoteNumbersFromQueue(numberOfNotes1, noteNumberQueue);
            int[] measureNoteNumbers2 = NoteHelper.PopulateNoteNumbersFromQueue(numberOfNotes2, noteNumberQueue);
            int[] measureNoteNumbers3 = NoteHelper.PopulateNoteNumbersFromQueue(numberOfNotes3, noteNumberQueue);
            int[] measureNoteNumbers4 = NoteHelper.PopulateNoteNumbersFromQueue(numberOfNotes4, noteNumberQueue);

            NoteHelper.CreateSamplesFromRhythmsAndNoteNames(eighthNoteDuration, quarterNoteDuration, halfNoteDuration, dottedHalfNoteDuration, wholeNoteDuration, measureRhythmSplit1, notes1, measureNoteNumbers1);
            NoteHelper.CreateSamplesFromRhythmsAndNoteNames(eighthNoteDuration, quarterNoteDuration, halfNoteDuration, dottedHalfNoteDuration, wholeNoteDuration, measureRhythmSplit2, notes2, measureNoteNumbers2);
            NoteHelper.CreateSamplesFromRhythmsAndNoteNames(eighthNoteDuration, quarterNoteDuration, halfNoteDuration, dottedHalfNoteDuration, wholeNoteDuration, measureRhythmSplit3, notes3, measureNoteNumbers3);
            NoteHelper.CreateSamplesFromRhythmsAndNoteNames(eighthNoteDuration, quarterNoteDuration, halfNoteDuration, dottedHalfNoteDuration, wholeNoteDuration, measureRhythmSplit4, notes4, measureNoteNumbers4);

            ISampleProvider phrase =
                wholeDoNote;

            foreach (var tick in ticks)
            {
                phrase = phrase.FollowedBy(tick);
            }

            foreach (var note1 in notes1)
            {
                phrase = phrase.FollowedBy(note1);
            }
            foreach (var note2 in notes2)
            {
                phrase = phrase.FollowedBy(note2);
            }
            if (numberOfMeasures == 4)
            {
                foreach (var note3 in notes3)
                {
                    phrase = phrase.FollowedBy(note3);
                }
                foreach (var note4 in notes4)
                {
                    phrase = phrase.FollowedBy(note4);
                }
            }

            // HACK: Use an empty note because without it, the audio gets cut short.
            ISampleProvider emptyNote = NAudioHelper.GetSampleProvider(0, 0, SignalGeneratorType.White, halfNoteDuration);
            phrase = phrase.FollowedBy(emptyNote);

            SampleToWaveProvider stwp = new SampleToWaveProvider(phrase);
            MixingSampleProvider msp  = new MixingSampleProvider(stwp.WaveFormat);
            msp.AddMixerInput(stwp);

            int totalTicks = 8 + (4 * numberOfMeasures);
            ISampleProvider[] metronomeTicks = new ISampleProvider[totalTicks];

            // The first two measures have zero gain, as this is the initial DO whole note and metronome ticks.
            for (int i = 0; i < 8; i++)
            {
                metronomeTicks[i] = NAudioHelper.GetSampleProvider(0, 0, SignalGeneratorType.White, quarterNoteDuration);
            }
            for (int i = 8; i < totalTicks; i++)
            {
                metronomeTicks[i] = NAudioHelper.GetSampleProviderFromFile(tickFile, quarterNoteDuration);
            }

            ISampleProvider metronomePhrase = metronomeTicks[0];
            for (int i = 0; i < metronomeTicks.Length; i++)
            {
                metronomePhrase = metronomePhrase.FollowedBy(metronomeTicks[i]);
            }

            msp.AddMixerInput(metronomePhrase);

            IWaveProvider wp = msp.ToWaveProvider();

            MemoryStream wavStream = new MemoryStream();
            //WaveFileWriter.WriteWavFileToStream(wavStream, stwp);
            WaveFileWriter.WriteWavFileToStream(wavStream, wp);
            wavStream.Position = 0;
            wavStream.WavToMp3File(out string fileName);
            dict.Add("src", fileName);
            dict.Add("numberOfTries", numberOfTries.ToString());

            #endregion Audio

            #region Notation

            string[] noteNames1 = new string[numberOfNotes1];
            NoteHelper.AdjustNoteNamesForKey(keySignature, measureNoteNumbers1, noteNames1);

            string[] noteNames2 = new string[numberOfNotes2];
            NoteHelper.AdjustNoteNamesForKey(keySignature, measureNoteNumbers2, noteNames2);

            string[] noteNames3 = new string[numberOfNotes3];
            NoteHelper.AdjustNoteNamesForKey(keySignature, measureNoteNumbers3, noteNames3);

            string[] noteNames4 = new string[numberOfNotes4];
            NoteHelper.AdjustNoteNamesForKey(keySignature, measureNoteNumbers4, noteNames4);

            string script1 = NoteHelper.GetEasyScoreScript3("transcription1", noteNames1, measureRhythmSplit1, keySignature, true);
            //string script1 = NoteHelper.GetMusicXmlScript("transcription1", noteNames1, measureRhythmSplit1, keySignature, false);

            dict.Add("theScript1", script1);
            string script2 = NoteHelper.GetEasyScoreScript3("transcription2", noteNames2, measureRhythmSplit2, keySignature, false);
            dict.Add("theScript2", script2);
            if (numberOfMeasures == 4)
            {
                string script3 = NoteHelper.GetEasyScoreScript3("transcription3", noteNames3, measureRhythmSplit3, keySignature, false);
                dict.Add("theScript3", script3);
                string script4 = NoteHelper.GetEasyScoreScript3("transcription4", noteNames4, measureRhythmSplit4, keySignature, false);
                dict.Add("theScript4", script4);
            }

            #endregion Notation

            var json = Json(dict, JsonRequestBehavior.AllowGet);
            return(json);
        }