Ejemplo n.º 1
0
        /** The MidiFile and/or SheetMusic has changed. Stop any playback sound,
         *  and store the current midifile and sheet music.
         */
        public void SetMidiFile(MidiFile file, MidiOptions opt, SheetMusic s)
        {
            /* If we're paused, and using the same midi file, redraw the
             * highlighted notes.
             */
            if ((file == midifile && midifile != null && playstate == paused))
            {
                options = opt;
                sheet   = s;
                sheet.ShadeNotes((int)currentPulseTime, (int)-10, false);

                /* We have to wait some time (200 msec) for the sheet music
                 * to scroll and redraw, before we can re-shade.
                 */
                Timer redrawTimer = new Timer();
                redrawTimer.Interval = 200;
                redrawTimer.Tick    += new EventHandler(ReShade);
                redrawTimer.Enabled  = true;
                redrawTimer.Start();
            }
            else
            {
                this.Stop(null, null);
                midifile = file;
                options  = opt;
                sheet    = s;
            }
            this.DeleteSoundFile();
        }
Ejemplo n.º 2
0
        CreateStaffs(List <MusicSymbol>[] allsymbols, KeySignature key,
                     MidiOptions options, int measurelen)
        {
            List <Staff>[] trackstaffs = new List <Staff> [allsymbols.Length];
            int            totaltracks = trackstaffs.Length;

            for (int track = 0; track < totaltracks; track++)
            {
                List <MusicSymbol> symbols = allsymbols[track];
                trackstaffs[track] = CreateStaffsForTrack(symbols, measurelen, key, options, track, totaltracks);
            }

            /* Update the EndTime of each Staff. EndTime is used for playback */
            foreach (List <Staff> list in trackstaffs)
            {
                for (int i = 0; i < list.Count - 1; i++)
                {
                    list[i].EndTime = list[i + 1].StartTime;
                }
            }

            /* Interleave the staffs of each track into the result array. */
            int maxstaffs = 0;

            for (int i = 0; i < trackstaffs.Length; i++)
            {
                if (maxstaffs < trackstaffs[i].Count)
                {
                    maxstaffs = trackstaffs[i].Count;
                }
            }
            List <Staff> result = new List <Staff>(maxstaffs * trackstaffs.Length);

            for (int i = 0; i < maxstaffs; i++)
            {
                foreach (List <Staff> list in trackstaffs)
                {
                    if (i < list.Count)
                    {
                        result.Add(list[i]);
                    }
                }
            }
            return(result);
        }
Ejemplo n.º 3
0
        private int measureLength;          /** The time (in pulses) of a measure */

        /** Create a new staff with the given list of music symbols,
         * and the given key signature.  The clef is determined by
         * the clef of the first chord symbol. The track number is used
         * to determine whether to join this left/right vertical sides
         * with the staffs above and below. The SheetMusicOptions are used
         * to check whether to display measure numbers or not.
         */
        public Staff(List <MusicSymbol> symbols, KeySignature key,
                     MidiOptions options,
                     int tracknum, int totaltracks)
        {
            keysigWidth      = SheetMusic.KeySignatureWidth(key);
            this.tracknum    = tracknum;
            this.totaltracks = totaltracks;
            showMeasures     = (options.showMeasures && tracknum == 0);
            measureLength    = options.time.Measure;
            Clef clef = FindClef(symbols);

            clefsym      = new ClefSymbol(clef, 0, false);
            keys         = key.GetSymbols(clef);
            this.symbols = symbols;
            CalculateWidth(options.scrollVert);
            CalculateHeight();
            CalculateStartEndTime();
            FullJustify();
        }
Ejemplo n.º 4
0
        /** Set the MidiFile to use.
         *  Save the list of midi notes. Each midi note includes the note Number
         *  and StartTime (in pulses), so we know which notes to shade given the
         *  current pulse time.
         */
        public void SetMidiFile(MidiFile midifile, MidiOptions options)
        {
            if (midifile == null)
            {
                notes        = null;
                useTwoColors = false;
                return;
            }

            List <MidiTrack> tracks = midifile.ChangeMidiNotes(options);
            MidiTrack        track  = MidiFile.CombineToSingleTrack(tracks);

            notes = track.Notes;

            maxShadeDuration = midifile.Time.Quarter * 2;

            /* We want to know which track the note came from.
             * Use the 'channel' field to store the track.
             */
            for (int tracknum = 0; tracknum < tracks.Count; tracknum++)
            {
                foreach (MidiNote note in tracks[tracknum].Notes)
                {
                    note.Channel = tracknum;
                }
            }

            /* When we have exactly two tracks, we assume this is a piano song,
             * and we use different colors for highlighting the left hand and
             * right hand notes.
             */
            useTwoColors = false;
            if (tracks.Count == 2)
            {
                useTwoColors = true;
            }

            showNoteLetters = options.showNoteLetters;
            this.Invalidate();
        }
Ejemplo n.º 5
0
        /** Create a new SheetMusic control, using the given midi filename.
         *  The options can be null.
         */
        public SheetMusic(string filename, MidiOptions options)
        {
            MidiFile file = new MidiFile(filename);

            init(file, options);
        }
Ejemplo n.º 6
0
 /** Create a new SheetMusic control, using the given parsed MidiFile.
  *  The options can be null.
  */
 public SheetMusic(MidiFile file, MidiOptions options)
 {
     init(file, options);
 }
Ejemplo n.º 7
0
        CreateStaffsForTrack(List <MusicSymbol> symbols, int measurelen,
                             KeySignature key, MidiOptions options,
                             int track, int totaltracks)
        {
            int          keysigWidth = KeySignatureWidth(key);
            int          startindex  = 0;
            List <Staff> thestaffs   = new List <Staff>(symbols.Count / 50);

            while (startindex < symbols.Count)
            {
                /* startindex is the index of the first symbol in the staff.
                 * endindex is the index of the last symbol in the staff.
                 */
                int endindex = startindex;
                int width    = keysigWidth;
                int maxwidth;

                /* If we're scrolling vertically, the maximum width is PageWidth. */
                if (scrollVert)
                {
                    maxwidth = SheetMusic.PageWidth;
                }
                else
                {
                    maxwidth = 2000000;
                }

                while (endindex < symbols.Count &&
                       width + symbols[endindex].Width < maxwidth)
                {
                    width += symbols[endindex].Width;
                    endindex++;
                }
                endindex--;

                /* There's 3 possibilities at this point:
                 * 1. We have all the symbols in the track.
                 *    The endindex stays the same.
                 *
                 * 2. We have symbols for less than one measure.
                 *    The endindex stays the same.
                 *
                 * 3. We have symbols for 1 or more measures.
                 *    Since measures cannot span multiple staffs, we must
                 *    make sure endindex does not occur in the middle of a
                 *    measure.  We count backwards until we come to the end
                 *    of a measure.
                 */

                if (endindex == symbols.Count - 1)
                {
                    /* endindex stays the same */
                }
                else if (symbols[startindex].StartTime / measurelen ==
                         symbols[endindex].StartTime / measurelen)
                {
                    /* endindex stays the same */
                }
                else
                {
                    int endmeasure = symbols[endindex + 1].StartTime / measurelen;
                    while (symbols[endindex].StartTime / measurelen ==
                           endmeasure)
                    {
                        endindex--;
                    }
                }
                int range = endindex + 1 - startindex;
                if (scrollVert)
                {
                    width = SheetMusic.PageWidth;
                }
                Staff staff = new Staff(symbols.GetRange(startindex, range),
                                        key, options, track, totaltracks);
                thestaffs.Add(staff);
                startindex = endindex + 1;
            }
            return(thestaffs);
        }
Ejemplo n.º 8
0
        /** Create a new SheetMusic control.
         * MidiFile is the parsed midi file to display.
         * SheetMusic Options are the menu options that were selected.
         *
         * - Apply all the Menu Options to the MidiFile tracks.
         * - Calculate the key signature
         * - For each track, create a list of MusicSymbols (notes, rests, bars, etc)
         * - Vertically align the music symbols in all the tracks
         * - Partition the music notes into horizontal staffs
         */
        public void init(MidiFile file, MidiOptions options)
        {
            if (options == null)
            {
                options = new MidiOptions(file);
            }
            zoom     = 1.0f;
            filename = file.FileName;

            SetColors(options.colors, options.shadeColor, options.shade2Color);
            pen = new Pen(Color.Black, 1);

            List <MidiTrack> tracks = file.ChangeMidiNotes(options);

            SetNoteSize(options.largeNoteSize);
            scrollVert      = options.scrollVert;
            showNoteLetters = options.showNoteLetters;
            TimeSignature time = file.Time;

            if (options.time != null)
            {
                time = options.time;
            }
            if (options.key == -1)
            {
                mainkey = GetKeySignature(tracks);
            }
            else
            {
                mainkey = new KeySignature(options.key);
            }

            numtracks = tracks.Count;

            int lastStart = file.EndTime() + options.shifttime;

            /* Create all the music symbols (notes, rests, vertical bars, and
             * clef changes).  The symbols variable contains a list of music
             * symbols for each track.  The list does not include the left-side
             * Clef and key signature symbols.  Those can only be calculated
             * when we create the staffs.
             */
            List <MusicSymbol>[] symbols = new List <MusicSymbol> [numtracks];
            for (int tracknum = 0; tracknum < numtracks; tracknum++)
            {
                MidiTrack          track  = tracks[tracknum];
                ClefMeasures       clefs  = new ClefMeasures(track.Notes, time.Measure);
                List <ChordSymbol> chords = CreateChords(track.Notes, mainkey, time, clefs);
                symbols[tracknum] = CreateSymbols(chords, clefs, time, lastStart);
            }

            List <LyricSymbol>[] lyrics = null;
            if (options.showLyrics)
            {
                lyrics = GetLyrics(tracks);
            }

            /* Vertically align the music symbols */
            SymbolWidths widths = new SymbolWidths(symbols, lyrics);

            // SymbolWidths widths = new SymbolWidths(symbols);
            AlignSymbols(symbols, widths);

            staffs = CreateStaffs(symbols, mainkey, options, time.Measure);
            CreateAllBeamedChords(symbols, time);
            if (lyrics != null)
            {
                AddLyricsToStaffs(staffs, lyrics);
            }

            /* After making chord pairs, the stem directions can change,
             * which affects the staff height.  Re-calculate the staff height.
             */
            foreach (Staff staff in staffs)
            {
                staff.CalculateHeight();
            }

            BackColor = Color.White;

            SetZoom(1.0f);
        }
Ejemplo n.º 9
0
        /** Create a new SheetMusic control, using the given raw midi byte[] data.
         *  The options can be null.
         */
        public SheetMusic(byte[] data, string title, MidiOptions options)
        {
            MidiFile file = new MidiFile(data, title);

            init(file, options);
        }
Ejemplo n.º 10
0
        /** Create a new MidiPlayer, displaying the play/stop buttons, the
         *  speed bar, and volume bar.  The midifile and sheetmusic are initially null.
         */
        public MidiPlayer()
        {
            this.Font = new Font("Arial", 10, FontStyle.Bold);
            loadButtonImages();
            int buttonheight = this.Font.Height * 2;

            this.midifile    = null;
            this.options     = null;
            this.sheet       = null;
            playstate        = stopped;
            startTime        = DateTime.Now.TimeOfDay;
            startPulseTime   = 0;
            currentPulseTime = 0;
            prevPulseTime    = -10;
            errormsg         = new StringBuilder(256);
            ToolTip tip;

            /* Create the rewind button */
            rewindButton            = new Button();
            rewindButton.Parent     = this;
            rewindButton.Image      = rewindImage;
            rewindButton.ImageAlign = ContentAlignment.MiddleCenter;
            rewindButton.Size       = new Size(buttonheight, buttonheight);
            rewindButton.Location   = new Point(buttonheight / 2, buttonheight / 2);
            rewindButton.Click     += new EventHandler(Rewind);
            tip = new ToolTip();
            tip.SetToolTip(rewindButton, "Rewind");

            /* Create the play button */
            playButton            = new Button();
            playButton.Parent     = this;
            playButton.Image      = playImage;
            playButton.ImageAlign = ContentAlignment.MiddleCenter;
            playButton.Size       = new Size(buttonheight, buttonheight);
            playButton.Location   = new Point(buttonheight / 2, buttonheight / 2);
            playButton.Location   = new Point(rewindButton.Location.X + rewindButton.Width + buttonheight / 2,
                                              rewindButton.Location.Y);
            playButton.Click += new EventHandler(PlayPause);
            playTip           = new ToolTip();
            playTip.SetToolTip(playButton, "Play");

            /* Create the stop button */
            stopButton            = new Button();
            stopButton.Parent     = this;
            stopButton.Image      = stopImage;
            stopButton.ImageAlign = ContentAlignment.MiddleCenter;
            stopButton.Size       = new Size(buttonheight, buttonheight);
            stopButton.Location   = new Point(playButton.Location.X + playButton.Width + buttonheight / 2,
                                              playButton.Location.Y);
            stopButton.Click += new EventHandler(Stop);
            tip = new ToolTip();
            tip.SetToolTip(stopButton, "Stop");

            /* Create the fastFwd button */
            fastFwdButton            = new Button();
            fastFwdButton.Parent     = this;
            fastFwdButton.Image      = fastFwdImage;
            fastFwdButton.ImageAlign = ContentAlignment.MiddleCenter;
            fastFwdButton.Size       = new Size(buttonheight, buttonheight);
            fastFwdButton.Location   = new Point(stopButton.Location.X + stopButton.Width + buttonheight / 2,
                                                 stopButton.Location.Y);
            fastFwdButton.Click += new EventHandler(FastForward);
            tip = new ToolTip();
            tip.SetToolTip(fastFwdButton, "Fast Forward");



            /* Create the Speed bar */
            Label speedLabel = new Label();

            speedLabel.Parent    = this;
            speedLabel.Text      = "Speed: ";
            speedLabel.TextAlign = ContentAlignment.MiddleRight;
            speedLabel.Height    = buttonheight;
            speedLabel.Width     = buttonheight * 2;
            speedLabel.Location  = new Point(fastFwdButton.Location.X + fastFwdButton.Width + buttonheight / 2,
                                             fastFwdButton.Location.Y);

            speedBar               = new TrackBar();
            speedBar.Parent        = this;
            speedBar.Minimum       = 1;
            speedBar.Maximum       = 100;
            speedBar.TickFrequency = 10;
            speedBar.TickStyle     = TickStyle.BottomRight;
            speedBar.LargeChange   = 10;
            speedBar.Value         = 100;
            speedBar.Width         = buttonheight * 5;
            speedBar.Location      = new Point(speedLabel.Location.X + speedLabel.Width + 2,
                                               speedLabel.Location.Y);
            tip = new ToolTip();
            tip.SetToolTip(speedBar, "Adjust the speed");

            /* Create the Volume bar */
            Label volumeLabel = new Label();

            volumeLabel.Parent     = this;
            volumeLabel.Image      = volumeImage;
            volumeLabel.ImageAlign = ContentAlignment.MiddleRight;
            volumeLabel.Height     = buttonheight;
            volumeLabel.Width      = buttonheight * 2;
            volumeLabel.Location   = new Point(speedBar.Location.X + speedBar.Width + buttonheight / 2,
                                               speedBar.Location.Y);

            volumeBar               = new TrackBar();
            volumeBar.Parent        = this;
            volumeBar.Minimum       = 1;
            volumeBar.Maximum       = 100;
            volumeBar.TickFrequency = 10;
            volumeBar.TickStyle     = TickStyle.BottomRight;
            volumeBar.LargeChange   = 10;
            volumeBar.Value         = 100;
            volumeBar.Width         = buttonheight * 5;
            volumeBar.Location      = new Point(volumeLabel.Location.X + volumeLabel.Width + 2,
                                                volumeLabel.Location.Y);
            volumeBar.Scroll += new EventHandler(ChangeVolume);
            tip = new ToolTip();
            tip.SetToolTip(volumeBar, "Adjust the volume");

            Height = buttonheight * 2;

            /* Initialize the timer used for playback, but don't start
             * the timer yet (enabled = false).
             */
            timer          = new Timer();
            timer.Enabled  = false;
            timer.Interval = 100;  /* 100 millisec */
            timer.Tick    += new EventHandler(TimerCallback);

            tempSoundFile = "";
        }