musicutil.h

Go to the documentation of this file.

/*
 * musicutil.h, Author: Andrea Rizzi <[email protected]>
 *
 * Copyright (C) 2001-2013 Atomic Blue ([email protected], http://www.atomicblue.org) 
 *
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation (version 2 of the License)
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 *
 */

#ifndef MUSIC_UTIL_H
#define MUSIC_UTIL_H


//====================================================================================
// Crystal Space Includes
//====================================================================================
#include <cssysdef.h>
#include <csutil/refarr.h>
#include <csutil/csstring.h>
#include <iutil/document.h>

struct ScoreStatistics
{
    ScoreStatistics()
    {
        Reset();
    }

    ScoreStatistics(const ScoreStatistics &copy)
    {
        nNotes = copy.nNotes;
        nChords = copy.nChords;
        nBb = copy.nBb;
        nGb = copy.nGb;
        nEb = copy.nEb;
        nDb = copy.nDb;
        nAb = copy.nAb;

        totalLength = copy.totalLength;
        totalLengthNoRests = copy.totalLengthNoRests;

        minimumDuration = copy.minimumDuration;
        maximumPolyphony = copy.maximumPolyphony;
        averageDuration =copy.averageDuration;
        averagePolyphony = copy.averagePolyphony;

        tempo = copy.tempo;
        fifths = copy.fifths;
        beatType = copy.beatType;
    }

    ScoreStatistics &operator+=(const ScoreStatistics &addend)
    {
        nNotes += addend.nNotes;
        nChords += addend.nChords;
        nBb += addend.nBb;
        nGb += addend.nGb;
        nEb += addend.nEb;
        nDb += addend.nDb;
        nAb += addend.nAb;

        totalLength += addend.totalLength;
        totalLengthNoRests += addend.totalLengthNoRests;

        return *this;
    }

    ScoreStatistics &operator-=(const ScoreStatistics &subtrahend)
    {
        nNotes -= subtrahend.nNotes;
        nChords -= subtrahend.nChords;
        nBb -= subtrahend.nBb;
        nGb -= subtrahend.nGb;
        nEb -= subtrahend.nEb;
        nDb -= subtrahend.nDb;
        nAb -= subtrahend.nAb;

        totalLength -= subtrahend.totalLength;
        totalLengthNoRests -= subtrahend.totalLengthNoRests;

        return *this;
    }

    ScoreStatistics &operator*=(const int scalar)
    {
        nNotes *= scalar;
        nChords *= scalar;
        nBb *= scalar;
        nGb *= scalar;
        nEb *= scalar;
        nDb *= scalar;
        nAb *= scalar;

        totalLength *= scalar;
        totalLengthNoRests *= scalar;

        return *this;
    }

    const ScoreStatistics operator*(const int scalar)
    {
        ScoreStatistics result(*this);
        result *= scalar;
        return result;
    }

    void Reset()
    {
        nNotes = 0;
        nChords = 0;
        nBb = 0;
        nGb = 0;
        nEb = 0;
        nDb = 0;
        nAb = 0;

        totalLength = 0.0;
        totalLengthNoRests = 0.0;

        minimumDuration = 0;
        maximumPolyphony = 0;
        averageDuration = 0.0;
        averagePolyphony = 0.0;

        tempo = 0;
        fifths = 0;
        beatType = 0;
    }

    int nNotes;                 
    int nChords;                
    int nBb;                    
    int nGb;                    
    int nEb;                    
    int nDb;                    
    int nAb;                    

    float totalLength;          
    float totalLengthNoRests;   

    int minimumDuration;        
    int maximumPolyphony;       
    float averageDuration;      
    float averagePolyphony;     

    int tempo;                  
    int fifths;                 
    int beatType;               
};


namespace psMusic
{

enum Accidental
{
    NO_ACCIDENTAL,
    DOUBLE_FLAT,
    FLAT,
    NATURAL,
    SHARP,
    DOUBLE_SHARP
};


// Unit of measure is a sixteenth. If you change this constant you must change the values
// in the enum Duration and the method CheckDuration() too.
#define DURATION_QUARTER_DIVISIONS 16

enum Duration
{
    SIXTEENTH_DURATION      = 1,
    EIGHTH_DURATION         = 2,
    DOTTED_EIGHTH_DURATION  = 3,
    QUARTER_DURATION        = 4,
    DOTTED_QUARTER_DURATION = 6,
    HALF_DURATION           = 8,
    DOTTED_HALF_DURATION    = 12,
    WHOLE_DURATION          = 16,
    DOTTED_WHOLE_DURATION   = 24
};


bool CheckDuration(int duration);

Duration GetBiggestDuration(int duration);

void NextPitch(char &pitch, uint &octave);

void PreviousPitch(char &pitch, uint &octave);

void EnharmonicPitch(char &pitch, int &accidental);

bool GetMeasures(iDocument* score, csRefArray<iDocumentNode> &measures);

bool GetStatistics(iDocument* musicalScore, ScoreStatistics &stats);

bool GetAttributes(iDocument* musicalScore, int &quarterDivisions,
                   int &fifths, int &beats, int &beatType, int &tempo);

bool ZCompressSong(const csString &inputScore, csString &outputScore);

bool ZDecompressSong(const csString &inputScore, csString &outputScore);

bool CheckValidity(iDocument* musicalScore, csRef<iDocumentNode> &partNode);

}

#endif // MUSIC_UTIL_H