private Common.Models.Rest GetRest(Rest rest)
 {
     if (int.TryParse(rest.Value.TrimStart('r'), out var duration))
     {
         return(new Common.Models.Rest(DurationUtils.GetClosestDuration(duration)));
     }
     return(null);
 }
        private IList <MetaSymbolGroup> GetMetadataFromTrack(Track track)
        {
            var             symbolGroups = new List <MetaSymbolGroup>();
            MetaSymbolGroup last         = null;

            foreach (var e in track.Iterator())
            {
                var message = e.MidiMessage;
                if (message.MessageType != MessageType.Meta)
                {
                    continue;
                }
                var metaMessage = message as MetaMessage;

                switch (metaMessage?.MetaType)
                {
                case MetaType.TimeSignature:
                    if (last != null)
                    {
                        last.End = e.AbsoluteTicks;
                    }
                    var timeSignatureBytes = metaMessage.GetBytes();
                    var beat = 1 / Math.Pow(timeSignatureBytes[1], -2);

                    var symbolGroup = new SymbolGroup
                    {
                        Meter = new TimeSignature
                        {
                            Ticks = timeSignatureBytes[0],
                            Beat  = DurationUtils.GetClosestDuration(beat)
                        }
                    };

                    var meta = new MetaSymbolGroup {
                        Start = e.AbsoluteTicks, SymbolGroup = symbolGroup
                    };
                    symbolGroups.Add(meta);
                    last = meta;
                    _currentTimeSignature = symbolGroup.Meter;
                    break;

                case MetaType.Tempo:
                    var tempoBytes = metaMessage.GetBytes();
                    var tempo      = (tempoBytes[0] & 0xff) << 16 | (tempoBytes[1] & 0xff) << 8 |
                                (tempoBytes[2] & 0xff);
                    last.SymbolGroup.Tempo = 60000000 / tempo;     // bpm
                    break;
                }
            }

            return(symbolGroups);
        }
        private void SetTimeSignature(string value)
        {
            var values = value.Split('/');

            if (!int.TryParse(values[0], out var ticks) || !int.TryParse(values[1], out var beat))
            {
                return;
            }

            _lastTimeSignature = new TimeSignature
            {
                Ticks = ticks, Beat = DurationUtils.GetClosestDuration(beat)
            };

            if (_currentGroup.Symbols.Count == 0) // still empty
            {
                _currentGroup.Meter = _lastTimeSignature;
                return;
            }

            CreateNewSymbolGroup();
        }
        private Common.Models.Note GetNote(Note note)
        {
            var name = Regex.Replace(note.Value, @"[\d',.]", string.Empty);

            int.TryParse(Regex.Replace(note.Value, @"[A-Za-z',.]", string.Empty), out var duration);

            AlterOctave(note.Value);

            // set previous to the new note
            _previous = new Common.Models.Note((Names)name[0], _relativeOctave, DurationUtils.GetClosestDuration(duration));

            if (name.EndsWith("es") || name.EndsWith("as"))
            {
                _previous.Modifier = Common.Definitions.Modifiers.Flat;
            }
            else if (name.EndsWith("is"))
            {
                _previous.Modifier = Common.Definitions.Modifiers.Sharp;
            }

            _previous.Dots = note.Value.ToCharArray().Count(dot => dot == '.');
            return(_previous);
        }