Example #1
0
        public static KeySignature Create(
            DiatonicToneClass key,
            PitchTransform transform,
            Mode mode
            )
        {
            var modesteps = new PitchTransform[] {
                PitchTransform.DoubleSharp,
                PitchTransform.DoubleSharp,
                PitchTransform.Sharp,
                PitchTransform.DoubleSharp,
                PitchTransform.DoubleSharp,
                PitchTransform.DoubleSharp,
                PitchTransform.Sharp
            };

            var keysteps = new PitchTransform[] {
                PitchTransform.DoubleSharp,
                PitchTransform.DoubleSharp,
                PitchTransform.Sharp,
                PitchTransform.DoubleSharp,
                PitchTransform.DoubleSharp,
                PitchTransform.DoubleSharp,
                PitchTransform.Sharp
            };

            var mode_copy = mode;

            while (mode_copy != Mode.Major)
            {
                // rotate L one step
                var step0 = modesteps[0];
                for (int i = 1; i < modesteps.Length; i++)
                {
                    modesteps[i - 1] = modesteps[i];
                }
                modesteps[modesteps.Length - 1] = step0;

                mode_copy = (Mode)((int)mode_copy - 1);
            }

            var key_copy = key;

            while (key_copy != DiatonicToneClass.C)
            {
                // rotate L one step
                var step0 = keysteps[0];
                for (int i = 1; i < keysteps.Length; i++)
                {
                    keysteps[i - 1] = keysteps[i];
                }
                keysteps[keysteps.Length - 1] = step0;

                key_copy = (DiatonicToneClass)((int)key_copy - 1);
            }

            var signature =
                new KeySignature();

            var pitch = key.GetPitchClass();

            for (int i = 0; i < 7; i++)
            {
                signature[key] = transform;

                transform += modesteps[i];
                transform -= keysteps[i];

                //TODO: should modesteps[i] or transform be used here
                pitch = modesteps[i].Transform(pitch);
                key   = key.ToRight();
            }

            return(signature);
        }
Example #2
0
        public AdornmentTrack(
            StorageObjectID storageobjectID,
            EditorFile file
            ) :
            base(
                storageobjectID,
                file
                )
        {
            obj = this.Object();

            binder_staffs =
                Staffs.Bind(
                    obj.GetOrMake("staffs").ID,
                    File
                    );

            binder_staffs.Deserializer = staff_obj => {
                using (var stream = staff_obj.OpenRead()) {
                    using (var br = new BinaryReader(stream)) {
                        var staff = new Staff();

                        staff.Lines          = br.ReadInt32();
                        staff.MiddleHalfLine = br.ReadInt32();
                        staff.Shift          = br.ReadInt32();
                        staff.Clef.BottomKey = new DiatonicTone(br.ReadInt32());
                        staff.Clef.Symbol    = (ClefSymbol)br.ReadInt32();

                        return(staff);
                    }
                }
            };

            binder_staffs.Serializer = (staff_obj, staff) => {
                using (var stream = staff_obj.OpenWrite()) {
                    using (var bw = new BinaryWriter(stream)) {
                        bw.Write(staff.Lines);
                        bw.Write(staff.MiddleHalfLine);
                        bw.Write(staff.Shift);
                        bw.Write(staff.Clef.BottomKey.Tones);
                        bw.Write((int)staff.Clef.Symbol);
                    }
                }
            };

            binder_keysigs =
                KeySignatures.Bind(
                    obj.GetOrMake("key-signatures").ID,
                    File
                    );

            binder_keysigs.Deserializer = keysig_obj => {
                using (var stream = keysig_obj.OpenRead()) {
                    using (var br = new BinaryReader(stream)) {
                        var transform_a = new PitchTransform(br.ReadInt32());
                        var transform_b = new PitchTransform(br.ReadInt32());
                        var transform_c = new PitchTransform(br.ReadInt32());
                        var transform_d = new PitchTransform(br.ReadInt32());
                        var transform_e = new PitchTransform(br.ReadInt32());
                        var transform_f = new PitchTransform(br.ReadInt32());
                        var transform_g = new PitchTransform(br.ReadInt32());

                        var keysig =
                            new KeySignature(
                                transform_c,
                                transform_d,
                                transform_e,
                                transform_f,
                                transform_g,
                                transform_a,
                                transform_b
                                );

                        return(keysig);
                    }
                }
            };

            binder_keysigs.Serializer = (keysig_obj, keysig) => {
                using (var stream = keysig_obj.OpenWrite()) {
                    using (var bw = new BinaryWriter(stream)) {
                        bw.Write(keysig[DiatonicToneClass.A].Steps);
                        bw.Write(keysig[DiatonicToneClass.B].Steps);
                        bw.Write(keysig[DiatonicToneClass.C].Steps);
                        bw.Write(keysig[DiatonicToneClass.D].Steps);
                        bw.Write(keysig[DiatonicToneClass.E].Steps);
                        bw.Write(keysig[DiatonicToneClass.F].Steps);
                        bw.Write(keysig[DiatonicToneClass.G].Steps);
                    }
                }
            };
        }
Example #3
0
        public void Import(
            EditorFile file,
            string filename,
            PorterOptions options
            )
        {
            var midifile = new MidiFile(filename, false);

            var trackcontainer =
                file[TrackControllerContainer.ItemName] as TrackControllerContainer;

            var musictrackfactory =
                trackcontainer
                .Tracks
                .FactorySet
                .Factories
                .FirstOrDefault(_ => _ is MusicTrackFactory)
                .Name;

            for (int track_index = 0; track_index < midifile.Tracks; track_index++)
            {
                var events = midifile.Events.GetTrackEvents(track_index);

                var track =
                    (MusicTrack)trackcontainer.Tracks.Create(musictrackfactory);

                foreach (var e in events)
                {
                    switch (e.CommandCode)
                    {
                    case MidiCommandCode.NoteOn: {
                        var e1 = (NoteOnEvent)e;

                        var start =
                            ImportTime(e1.AbsoluteTime, midifile);

                        var length =
                            ImportTime(e1.NoteLength, midifile);

                        var duration =
                            new Duration {
                            Start  = start,
                            Length = length
                        };

                        track.Melody.AddNote(new SemiTone(e1.NoteNumber - 12), duration);

                        break;
                    }

                    case MidiCommandCode.NoteOff: {
                        var e1 = (NoteEvent)e;

                        break;
                    }

                    case MidiCommandCode.MetaEvent: {
                        var meta = (MetaEvent)e;

                        switch (meta.MetaEventType)
                        {
                        case MetaEventType.Copyright:

                            break;

                        case MetaEventType.CuePoint:

                            break;

                        case MetaEventType.DeviceName:

                            break;

                        case MetaEventType.EndTrack:

                            break;

                        case MetaEventType.KeySignature: {
                            var keysigevent = (KeySignatureEvent)meta;

                            var circle5index = (sbyte)keysigevent.SharpsFlats;

                            Mode mode;

                            switch (keysigevent.MajorMinor)
                            {
                            case 1:
                                mode = Mode.Major;
                                break;

                            case 0:
                                mode = Mode.Minor;
                                break;

                            default:
                                throw new InvalidOperationException();
                            }

                            PitchTransform transform;
                            var            key =
                                CircleOfFifths.Index(circle5index, ChromaticPitchClass.C, out transform);

                            var sig =
                                KeySignature.Create(
                                    key,
                                    transform,
                                    mode
                                    );

                            var start =
                                ImportTime(keysigevent.AbsoluteTime, midifile);

                            track
                            .Adornment
                            .KeySignatures
                            .OverwriteEverythingToRight(
                                sig,
                                start
                                );

                            break;
                        }

                        case MetaEventType.Lyric:

                            break;

                        case MetaEventType.Marker:

                            break;

                        case MetaEventType.MidiChannel:

                            break;

                        case MetaEventType.MidiPort:

                            break;

                        case MetaEventType.ProgramName:

                            break;

                        case MetaEventType.SequencerSpecific:
                            break;

                        case MetaEventType.SequenceTrackName: {
                            var text = (TextEvent)meta;

                            track.Name.Value = text.Text;

                            break;
                        }

                        case MetaEventType.SetTempo:
                            var tempoevent = meta as TempoEvent;
                            // Can midi files have linear varying tempos?
                            // if so, then this code doesn't handle all midis.

                            if (options.PortTempo)
                            {
                                track
                                .Tempo
                                .SetTempo(
                                    ImportTime(tempoevent.AbsoluteTime, midifile),
                                    (float)tempoevent.Tempo / 4
                                    );
                            }

                            break;

                        case MetaEventType.SmpteOffset:

                            break;

                        case MetaEventType.TextEvent:
                            break;

                        case MetaEventType.TimeSignature:
                            var timesigevent = (TimeSignatureEvent)meta;

                            var timesig =
                                new TimeSignature(
                                    new Simple(
                                        timesigevent.Numerator,
                                        timesigevent.Denominator
                                        )
                                    );

                            track
                            .Rhythm
                            .TimeSignatures
                            .OverwriteEverythingToRight(
                                timesig,
                                ImportTime(timesigevent.AbsoluteTime, midifile)
                                );

                            break;

                        case MetaEventType.TrackInstrumentName:

                            break;

                        case MetaEventType.TrackSequenceNumber:

                            break;

                        default:
                            throw new InvalidOperationException();
                        }

                        break;
                    }

                    case MidiCommandCode.PatchChange: {
                        break;
                    }

                    case MidiCommandCode.ControlChange: {
                        break;
                    }

                    default:
                        throw new InvalidOperationException();
                    }
                }
            }
        }