cdc82364e4
See http://music.stackexchange.com/questions/42722/notehead-or-note-head (also correct "fo" to "for" in comment)
8459 lines
235 KiB
C++
8459 lines
235 KiB
C++
//=============================================================================
|
|
// MusE Score
|
|
// Linux Music Score Editor
|
|
// $Id: importove.cpp 4287 2011-05-17 14:50:09Z vanferry $
|
|
//
|
|
// Copyright (C) 2002-2009 Werner Schweer and others
|
|
//
|
|
// This program is free software; you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License version 2.
|
|
//
|
|
// 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., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
//=============================================================================
|
|
|
|
#include "ove.h"
|
|
|
|
namespace OVE {
|
|
|
|
/*template <class T>
|
|
inline void deleteVector(QList<T*>& vec) {
|
|
for (int i=0; i<vec.size(); ++i)
|
|
delete vec[i];
|
|
}
|
|
//vec.clear();
|
|
}*/
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
TickElement::TickElement() {
|
|
tick_ = 0;
|
|
}
|
|
|
|
void TickElement::setTick(int tick) {
|
|
tick_ = tick;
|
|
}
|
|
|
|
int TickElement::getTick(void) const {
|
|
return tick_;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
MeasurePos::MeasurePos() {
|
|
measure_ = 0;
|
|
offset_ = 0;
|
|
}
|
|
|
|
void MeasurePos::setMeasure(int measure) {
|
|
measure_ = measure;
|
|
}
|
|
|
|
int MeasurePos::getMeasure() const {
|
|
return measure_;
|
|
}
|
|
|
|
void MeasurePos::setOffset(int offset) {
|
|
offset_ = offset;
|
|
}
|
|
|
|
int MeasurePos::getOffset() const {
|
|
return offset_;
|
|
}
|
|
|
|
MeasurePos MeasurePos::shiftMeasure(int measure) const {
|
|
MeasurePos mp;
|
|
mp.setMeasure(getMeasure() + measure);
|
|
mp.setOffset(getOffset());
|
|
|
|
return mp;
|
|
}
|
|
|
|
MeasurePos MeasurePos::shiftOffset(int offset) const {
|
|
MeasurePos mp;
|
|
mp.setMeasure(getMeasure());
|
|
mp.setOffset(getOffset() + offset);
|
|
|
|
return mp;
|
|
}
|
|
|
|
bool MeasurePos::operator ==(const MeasurePos& mp) const {
|
|
return getMeasure() == mp.getMeasure() && getOffset() == mp.getOffset();
|
|
}
|
|
|
|
bool MeasurePos::operator !=(const MeasurePos& mp) const {
|
|
return !(*this == mp);
|
|
}
|
|
|
|
bool MeasurePos::operator <(const MeasurePos& mp) const {
|
|
if (getMeasure() != mp.getMeasure()) {
|
|
return getMeasure() < mp.getMeasure();
|
|
}
|
|
|
|
return getOffset() < mp.getOffset();
|
|
}
|
|
|
|
bool MeasurePos::operator <=(const MeasurePos& mp) const {
|
|
if (getMeasure() != mp.getMeasure()) {
|
|
return getMeasure() <= mp.getMeasure();
|
|
}
|
|
|
|
return getOffset() <= mp.getOffset();
|
|
}
|
|
|
|
bool MeasurePos::operator >(const MeasurePos& mp) const {
|
|
return !(*this <= mp);
|
|
}
|
|
|
|
bool MeasurePos::operator >=(const MeasurePos& mp) const {
|
|
return !(*this < mp);
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
PairElement::PairElement() {
|
|
start_ = new MeasurePos();
|
|
stop_ = new MeasurePos();
|
|
}
|
|
|
|
PairElement::~PairElement(){
|
|
delete start_;
|
|
delete stop_;
|
|
}
|
|
|
|
MeasurePos* PairElement::start() const {
|
|
return start_;
|
|
}
|
|
|
|
MeasurePos* PairElement::stop() const {
|
|
return stop_;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
PairEnds::PairEnds() {
|
|
leftLine_ = new LineElement();
|
|
rightLine_ = new LineElement();
|
|
leftShoulder_ = new OffsetElement();
|
|
rightShoulder_ = new OffsetElement();
|
|
}
|
|
|
|
PairEnds::~PairEnds(){
|
|
delete leftLine_;
|
|
delete rightLine_;
|
|
delete leftShoulder_;
|
|
delete rightShoulder_;
|
|
}
|
|
|
|
LineElement* PairEnds::getLeftLine() const {
|
|
return leftLine_;
|
|
}
|
|
|
|
LineElement* PairEnds::getRightLine() const {
|
|
return rightLine_;
|
|
}
|
|
|
|
OffsetElement* PairEnds::getLeftShoulder() const {
|
|
return leftShoulder_;
|
|
}
|
|
|
|
OffsetElement* PairEnds::getRightShoulder() const {
|
|
return rightShoulder_;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
LineElement::LineElement() {
|
|
line_ = 0;
|
|
}
|
|
|
|
void LineElement::setLine(int line) {
|
|
line_ = line;
|
|
}
|
|
|
|
int LineElement::getLine(void) const {
|
|
return line_;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
OffsetElement::OffsetElement() {
|
|
xOffset_ = 0;
|
|
yOffset_ = 0;
|
|
}
|
|
|
|
void OffsetElement::setXOffset(int offset) {
|
|
xOffset_ = offset;
|
|
}
|
|
|
|
int OffsetElement::getXOffset() const {
|
|
return xOffset_;
|
|
}
|
|
|
|
void OffsetElement::setYOffset(int offset) {
|
|
yOffset_ = offset;
|
|
}
|
|
|
|
int OffsetElement::getYOffset() const {
|
|
return yOffset_;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
LengthElement::LengthElement() {
|
|
length_ = 0;
|
|
}
|
|
|
|
void LengthElement::setLength(int length) {
|
|
length_ = length;
|
|
}
|
|
|
|
int LengthElement::getLength() const {
|
|
return length_;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
MusicData::MusicData() {
|
|
musicDataType_ = MusicDataType::None;
|
|
show_ = true;
|
|
color_ = 0;
|
|
voice_ = 0;
|
|
}
|
|
|
|
MusicDataType MusicData::getMusicDataType() const {
|
|
return musicDataType_;
|
|
}
|
|
|
|
MusicData::XmlDataType MusicData::getXmlDataType(MusicDataType type) {
|
|
XmlDataType xmlType = XmlDataType::None;
|
|
|
|
switch (type) {
|
|
case MusicDataType::Measure_Repeat: {
|
|
xmlType = XmlDataType::Attributes;
|
|
break;
|
|
}
|
|
case MusicDataType::Beam: {
|
|
xmlType = XmlDataType::NoteBeam;
|
|
break;
|
|
}
|
|
case MusicDataType::Slur:
|
|
case MusicDataType::Glissando:
|
|
case MusicDataType::Tuplet:
|
|
case MusicDataType::Tie: {
|
|
xmlType = XmlDataType::Notations;
|
|
break;
|
|
}
|
|
case MusicDataType::Text:
|
|
case MusicDataType::Repeat:
|
|
case MusicDataType::Wedge:
|
|
case MusicDataType::Dynamics:
|
|
case MusicDataType::Pedal:
|
|
case MusicDataType::OctaveShift_EndPoint: {
|
|
xmlType = XmlDataType::Direction;
|
|
break;
|
|
}
|
|
default: {
|
|
xmlType = XmlDataType::None;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return xmlType;
|
|
}
|
|
|
|
/*bool MusicData::get_is_pair_element(MusicDataType type)
|
|
{
|
|
bool pair = false;
|
|
|
|
switch ( type )
|
|
{
|
|
case MusicDataType::Numeric_Ending :
|
|
case MusicDataType::Measure_Repeat :
|
|
case MusicDataType::Wedge :
|
|
case MusicDataType::OctaveShift :
|
|
//case MusicDataType::OctaveShift_EndPoint :
|
|
case MusicDataType::Pedal :
|
|
case MusicDataType::Beam :
|
|
case MusicDataType::Glissando :
|
|
case MusicDataType::Slur :
|
|
case MusicDataType::Tie :
|
|
case MusicDataType::Tuplet :
|
|
{
|
|
pair = true;
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return pair;
|
|
}*/
|
|
|
|
void MusicData::setShow(bool show) {
|
|
show_ = show;
|
|
}
|
|
|
|
bool MusicData::getShow() const {
|
|
return show_;
|
|
}
|
|
|
|
void MusicData::setColor(unsigned int color) {
|
|
color_ = color;
|
|
}
|
|
|
|
unsigned int MusicData::getColor() const {
|
|
return color_;
|
|
}
|
|
|
|
void MusicData::setVoice(unsigned int voice) {
|
|
voice_ = voice;
|
|
}
|
|
|
|
unsigned int MusicData::getVoice() const {
|
|
return voice_;
|
|
}
|
|
|
|
void MusicData::copyCommonBlock(const MusicData& source) {
|
|
setTick(source.getTick());
|
|
start()->setOffset(source.start()->getOffset());
|
|
setColor(source.getColor());
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
MidiData::MidiData() {
|
|
midiType_ = MidiType::None;
|
|
}
|
|
|
|
MidiType MidiData::getMidiType() const {
|
|
return midiType_;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
OveSong::OveSong() :
|
|
codec_(0) {
|
|
clear();
|
|
}
|
|
|
|
OveSong::~OveSong() {
|
|
clear();
|
|
}
|
|
|
|
void OveSong::setIsVersion4(bool version4){
|
|
version4_ = version4;
|
|
}
|
|
|
|
bool OveSong::getIsVersion4() const {
|
|
return version4_;
|
|
}
|
|
|
|
void OveSong::setQuarter(int tick) {
|
|
quarter_ = tick;
|
|
}
|
|
|
|
int OveSong::getQuarter(void) const {
|
|
return quarter_;
|
|
}
|
|
|
|
void OveSong::setShowPageMargin(bool show){
|
|
showPageMargin_ = show;
|
|
}
|
|
|
|
bool OveSong::getShowPageMargin() const {
|
|
return showPageMargin_;
|
|
}
|
|
|
|
void OveSong::setShowTransposeTrack(bool show) {
|
|
showTransposeTrack = show;
|
|
}
|
|
|
|
bool OveSong::getShowTransposeTrack() const {
|
|
return showTransposeTrack;
|
|
}
|
|
|
|
void OveSong::setShowLineBreak(bool show) {
|
|
showLineBreak_ = show;
|
|
}
|
|
|
|
bool OveSong::getShowLineBreak() const {
|
|
return showLineBreak_;
|
|
}
|
|
|
|
void OveSong::setShowRuler(bool show) {
|
|
showRuler_ = show;
|
|
}
|
|
|
|
bool OveSong::getShowRuler() const {
|
|
return showRuler_;
|
|
}
|
|
|
|
void OveSong::setShowColor(bool show) {
|
|
showColor_ = show;
|
|
}
|
|
|
|
bool OveSong::getShowColor() const {
|
|
return showColor_;
|
|
}
|
|
|
|
void OveSong::setPlayRepeat(bool play) {
|
|
playRepeat_ = play;
|
|
}
|
|
|
|
bool OveSong::getPlayRepeat() const {
|
|
return playRepeat_;
|
|
}
|
|
|
|
void OveSong::setPlayStyle(PlayStyle style) {
|
|
playStyle_ = style;
|
|
}
|
|
|
|
OveSong::PlayStyle OveSong::getPlayStyle() const {
|
|
return playStyle_;
|
|
}
|
|
|
|
void OveSong::addTitle(const QString& str) {
|
|
titles_.push_back(str);
|
|
}
|
|
|
|
QList<QString> OveSong::getTitles(void) const {
|
|
return titles_;
|
|
}
|
|
|
|
void OveSong::addAnnotate(const QString& str) {
|
|
annotates_.push_back(str);
|
|
}
|
|
|
|
QList<QString> OveSong::getAnnotates(void) const {
|
|
return annotates_;
|
|
}
|
|
|
|
void OveSong::addWriter(const QString& str) {
|
|
writers_.push_back(str);
|
|
}
|
|
|
|
QList<QString> OveSong::getWriters(void) const {
|
|
return writers_;
|
|
}
|
|
|
|
void OveSong::addCopyright(const QString& str) {
|
|
copyrights_.push_back(str);
|
|
}
|
|
|
|
QList<QString> OveSong::getCopyrights(void) const {
|
|
return copyrights_;
|
|
}
|
|
|
|
void OveSong::addHeader(const QString& str) {
|
|
headers_.push_back(str);
|
|
}
|
|
|
|
QList<QString> OveSong::getHeaders(void) const {
|
|
return headers_;
|
|
}
|
|
|
|
void OveSong::addFooter(const QString& str) {
|
|
footers_.push_back(str);
|
|
}
|
|
|
|
QList<QString> OveSong::getFooters(void) const {
|
|
return footers_;
|
|
}
|
|
|
|
void OveSong::addTrack(Track* ptr) {
|
|
tracks_.push_back(ptr);
|
|
}
|
|
|
|
int OveSong::getTrackCount(void) const {
|
|
return tracks_.size();
|
|
}
|
|
|
|
QList<Track*> OveSong::getTracks() const {
|
|
return tracks_;
|
|
}
|
|
|
|
void OveSong::setTrackBarCount(int count) {
|
|
trackBarCount_ = count;
|
|
}
|
|
|
|
int OveSong::getTrackBarCount() const {
|
|
return trackBarCount_;
|
|
}
|
|
|
|
Track* OveSong::getTrack(int part, int staff) const {
|
|
int trackId = partStaffToTrack(part, staff);
|
|
|
|
if( trackId >=0 && trackId < (int)tracks_.size() ) {
|
|
return tracks_[trackId];
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
bool OveSong::addPage(Page* page) {
|
|
pages_.push_back(page);
|
|
return true;
|
|
}
|
|
|
|
int OveSong::getPageCount() const {
|
|
return pages_.size();
|
|
}
|
|
|
|
Page* OveSong::getPage(int idx) {
|
|
if( idx>=0 && idx<(int)pages_.size() ) {
|
|
return pages_[idx];
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
void OveSong::addLine(Line* ptr) {
|
|
lines_.push_back(ptr);
|
|
}
|
|
|
|
int OveSong::getLineCount() const {
|
|
return lines_.size();
|
|
}
|
|
|
|
Line* OveSong::getLine(int idx) const {
|
|
if( idx >=0 && idx<(int)lines_.size() ) {
|
|
return lines_[idx];
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
void OveSong::addMeasure(Measure* ptr) {
|
|
measures_.push_back(ptr);
|
|
}
|
|
|
|
int OveSong::getMeasureCount(void) const {
|
|
return measures_.size();
|
|
}
|
|
|
|
Measure* OveSong::getMeasure(int bar) const {
|
|
if( bar >= 0 && bar < (int)measures_.size() ) {
|
|
return measures_[bar];
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
void OveSong::addMeasureData(MeasureData* ptr) {
|
|
measureDatas_.push_back(ptr);
|
|
}
|
|
|
|
int OveSong::getMeasureDataCount(void) const {
|
|
return measureDatas_.size();
|
|
}
|
|
|
|
MeasureData* OveSong::getMeasureData(int part, int staff/*=0*/, int bar) const {
|
|
int trackId = partStaffToTrack(part, staff);
|
|
int trackBarCount = getTrackBarCount();
|
|
|
|
if( bar >= 0 && bar < trackBarCount ) {
|
|
int measureId = trackBarCount * trackId + bar;
|
|
|
|
if( measureId >=0 && measureId < (int)measureDatas_.size() ) {
|
|
return measureDatas_[measureId];
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
MeasureData* OveSong::getMeasureData(int track, int bar) const {
|
|
int id = trackBarCount_*track + bar;
|
|
|
|
if( id >=0 && id < (int)measureDatas_.size() ) {
|
|
return measureDatas_[id];
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
void OveSong::setPartStaffCounts(const QList<int>& partStaffCounts) {
|
|
//partStaffCounts_.assign(partStaffCounts.begin(), partStaffCounts.end());
|
|
for(int i=0; i<partStaffCounts.size(); ++i) {
|
|
partStaffCounts_.push_back(partStaffCounts[i]);
|
|
}
|
|
}
|
|
|
|
int OveSong::getPartCount() const {
|
|
return partStaffCounts_.size();
|
|
}
|
|
|
|
int OveSong::getStaffCount(int part) const {
|
|
if( part>=0 && part<(int)partStaffCounts_.size() ) {
|
|
return partStaffCounts_[part];
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int OveSong::getPartBarCount() const {
|
|
return measureDatas_.size() / tracks_.size();
|
|
}
|
|
|
|
QPair<int, int> OveSong::trackToPartStaff(int track) const {
|
|
QPair<int, int> partStaff;
|
|
int i;
|
|
int staffCount = 0;
|
|
|
|
for( i=0; i<partStaffCounts_.size(); ++i ) {
|
|
if( staffCount + partStaffCounts_[i] > track ) {
|
|
return qMakePair((int)i, track-staffCount);
|
|
}
|
|
|
|
staffCount += partStaffCounts_[i];
|
|
}
|
|
|
|
return qMakePair((int)partStaffCounts_.size(), 0);
|
|
}
|
|
|
|
int OveSong::partStaffToTrack(int part, int staff) const {
|
|
int i;
|
|
unsigned int staffCount = 0;
|
|
|
|
for( i=0; i<partStaffCounts_.size(); ++i ) {
|
|
if( part == (int)i && staff>=0 && staff<(int)partStaffCounts_[i] ) {
|
|
int trackId = staffCount + staff;
|
|
|
|
if( trackId >=0 && trackId < (int)tracks_.size() ) {
|
|
return trackId;
|
|
}
|
|
}
|
|
|
|
staffCount += partStaffCounts_[i];
|
|
}
|
|
|
|
return tracks_.size();
|
|
}
|
|
|
|
void OveSong::setTextCodecName(const QString& codecName) {
|
|
codec_ = QTextCodec::codecForName(codecName.toLatin1());
|
|
}
|
|
|
|
QString OveSong::getCodecString(const QByteArray& text) {
|
|
QString s;
|
|
if (codec_ == NULL)
|
|
s = QString(text);
|
|
else
|
|
s = codec_->toUnicode(text);
|
|
|
|
s = s.trimmed();
|
|
return s;
|
|
}
|
|
|
|
void OveSong::clear(void)
|
|
{
|
|
version4_ = true;
|
|
quarter_ = 480;
|
|
showPageMargin_ = false;
|
|
showTransposeTrack = false;
|
|
showLineBreak_ = false;
|
|
showRuler_ = false;
|
|
showColor_ = true;
|
|
playRepeat_ = true;
|
|
playStyle_ = PlayStyle::Record;
|
|
|
|
annotates_.clear();
|
|
copyrights_.clear();
|
|
footers_.clear();
|
|
headers_.clear();
|
|
titles_.clear();
|
|
writers_.clear();
|
|
|
|
// deleteVector(tracks_);
|
|
for(int i=0; i<tracks_.size(); ++i){
|
|
delete tracks_[i];
|
|
}
|
|
for(int i=0; i<pages_.size(); ++i){
|
|
delete pages_[i];
|
|
}
|
|
for(int i=0; i<lines_.size(); ++i){
|
|
delete lines_[i];
|
|
}
|
|
for(int i=0; i<measures_.size(); ++i){
|
|
delete measures_[i];
|
|
}
|
|
for(int i=0; i<measureDatas_.size(); ++i){
|
|
delete measureDatas_[i];
|
|
}
|
|
tracks_.clear();
|
|
pages_.clear();
|
|
lines_.clear();
|
|
measures_.clear();
|
|
measureDatas_.clear();
|
|
trackBarCount_ = 0;
|
|
partStaffCounts_.clear();
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
Voice::Voice() {
|
|
channel_ = 0;
|
|
volume_ = -1;
|
|
pitchShift_ = 0;
|
|
pan_ = 0;
|
|
patch_ = 0;
|
|
stemType_ = 0;
|
|
}
|
|
|
|
void Voice::setChannel(int channel) {
|
|
channel_ = channel;
|
|
}
|
|
|
|
int Voice::getChannel() const {
|
|
return channel_;
|
|
}
|
|
|
|
void Voice::setVolume(int volume) {
|
|
volume_ = volume;
|
|
}
|
|
|
|
int Voice::getVolume() const {
|
|
return volume_;
|
|
}
|
|
|
|
void Voice::setPitchShift(int pitchShift) {
|
|
pitchShift_ = pitchShift;
|
|
}
|
|
|
|
int Voice::getPitchShift() const {
|
|
return pitchShift_;
|
|
}
|
|
|
|
void Voice::setPan(int pan) {
|
|
pan_ = pan;
|
|
}
|
|
|
|
int Voice::getPan() const {
|
|
return pan_;
|
|
}
|
|
|
|
void Voice::setPatch(int patch) {
|
|
patch_ = patch;
|
|
}
|
|
|
|
int Voice::getPatch() const {
|
|
return patch_;
|
|
}
|
|
|
|
void Voice::setStemType(int stemType) {
|
|
stemType_ = stemType;
|
|
}
|
|
|
|
int Voice::getStemType() const {
|
|
return stemType_;
|
|
}
|
|
|
|
int Voice::getDefaultPatch() {
|
|
return -1;
|
|
}
|
|
|
|
int Voice::getDefaultVolume() {
|
|
return -1;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
Track::Track() {
|
|
clear();
|
|
}
|
|
|
|
Track::~Track() {
|
|
clear();
|
|
}
|
|
|
|
void Track::setName(const QString& str) {
|
|
name_ = str;
|
|
}
|
|
|
|
QString Track::getName(void) const {
|
|
return name_;
|
|
}
|
|
|
|
void Track::setBriefName(const QString& str) {
|
|
briefName_ = str;
|
|
}
|
|
|
|
QString Track::getBriefName(void) const {
|
|
return briefName_;
|
|
}
|
|
|
|
void Track::setPatch(unsigned int patch) {
|
|
patch_ = patch;
|
|
}
|
|
|
|
unsigned int Track::getPatch() const {
|
|
return patch_;
|
|
}
|
|
|
|
void Track::setChannel(int channel) {
|
|
channel_ = channel;
|
|
}
|
|
|
|
int Track::getChannel() const {
|
|
return channel_;
|
|
}
|
|
|
|
void Track::setShowName(bool show) {
|
|
showName_ = show;
|
|
}
|
|
|
|
bool Track::getShowName() const {
|
|
return showName_;
|
|
}
|
|
|
|
void Track::setShowBriefName(bool show) {
|
|
showBriefName_ = show;
|
|
}
|
|
|
|
bool Track::getShowBriefName() const {
|
|
return showBriefName_;
|
|
}
|
|
|
|
void Track::setMute(bool mute) {
|
|
mute_ = mute;
|
|
}
|
|
|
|
bool Track::getMute() const {
|
|
return mute_;
|
|
}
|
|
|
|
void Track::setSolo(bool solo) {
|
|
solo_ = solo;
|
|
}
|
|
|
|
bool Track::getSolo() const {
|
|
return solo_;
|
|
}
|
|
|
|
void Track::setShowKeyEachLine(bool show) {
|
|
showKeyEachLine_ = show;
|
|
}
|
|
|
|
bool Track::getShowKeyEachLine() const {
|
|
return showKeyEachLine_;
|
|
}
|
|
|
|
void Track::setVoiceCount(int voices) {
|
|
voiceCount_ = voices;
|
|
}
|
|
|
|
int Track::getVoiceCount() const {
|
|
return voiceCount_;
|
|
}
|
|
|
|
void Track::addVoice(Voice* voice) {
|
|
voices_.push_back(voice);
|
|
}
|
|
|
|
QList<Voice*> Track::getVoices() const {
|
|
return voices_;
|
|
}
|
|
|
|
void Track::setShowTranspose(bool show) {
|
|
showTranspose_ = show;
|
|
}
|
|
|
|
bool Track::getShowTranspose() const {
|
|
return showTranspose_;
|
|
}
|
|
|
|
void Track::setTranspose(int transpose) {
|
|
transpose_ = transpose;
|
|
}
|
|
|
|
int Track::getTranspose() const {
|
|
return transpose_;
|
|
}
|
|
|
|
void Track::setNoteShift(int shift) {
|
|
noteShift_ = shift;
|
|
}
|
|
|
|
int Track::getNoteShift() const {
|
|
return noteShift_;
|
|
}
|
|
|
|
void Track::setStartClef(int clef/*in Clef*/) {
|
|
startClef_ = ClefType(clef);
|
|
}
|
|
|
|
ClefType Track::getStartClef() const {
|
|
return startClef_;
|
|
}
|
|
|
|
void Track::setTransposeClef(int clef) {
|
|
transposeClef_ = ClefType(clef);
|
|
}
|
|
|
|
ClefType Track::getTansposeClef() const {
|
|
return transposeClef_;
|
|
}
|
|
|
|
void Track::setStartKey(int key) {
|
|
startKey_ = key;
|
|
}
|
|
|
|
int Track::getStartKey() const {
|
|
return startKey_;
|
|
}
|
|
|
|
void Track::setDisplayPercent(unsigned int percent/*25~100?*/) {
|
|
displayPercent_ = percent;
|
|
}
|
|
|
|
unsigned int Track::getDisplayPercent() const {
|
|
return displayPercent_;
|
|
}
|
|
|
|
void Track::setShowLegerLine(bool show) {
|
|
showLegerLine_ = show;
|
|
}
|
|
|
|
bool Track::getShowLegerLine() const {
|
|
return showLegerLine_;
|
|
}
|
|
|
|
void Track::setShowClef(bool show) {
|
|
showClef_ = show;
|
|
}
|
|
|
|
bool Track::getShowClef() const {
|
|
return showClef_;
|
|
}
|
|
|
|
void Track::setShowTimeSignature(bool show) {
|
|
showTimeSignature_ = show;
|
|
}
|
|
|
|
bool Track::getShowTimeSignature() const {
|
|
return showTimeSignature_;
|
|
}
|
|
|
|
void Track::setShowKeySignature(bool show) {
|
|
showKeySignature_ = show;
|
|
}
|
|
|
|
bool Track::getShowKeySignature() const {
|
|
return showKeySignature_;
|
|
}
|
|
|
|
void Track::setShowBarline(bool show) {
|
|
showBarline_ = show;
|
|
}
|
|
|
|
bool Track::getShowBarline() const {
|
|
return showBarline_;
|
|
}
|
|
|
|
void Track::setFillWithRest(bool fill) {
|
|
fillWithRest_ = fill;
|
|
}
|
|
|
|
bool Track::getFillWithRest() const {
|
|
return fillWithRest_;
|
|
}
|
|
|
|
void Track::setFlatTail(bool flat) {
|
|
flatTail_ = flat;
|
|
}
|
|
|
|
bool Track::getFlatTail() const {
|
|
return flatTail_;
|
|
}
|
|
|
|
void Track::setShowClefEachLine(bool show) {
|
|
showClefEachLine_ = show;
|
|
}
|
|
|
|
bool Track::getShowClefEachLine() const {
|
|
return showClefEachLine_;
|
|
}
|
|
|
|
void Track::addDrum(const DrumNode& node) {
|
|
/*DrumNode node;
|
|
node.line_ = line;
|
|
node.headType_ = headType;
|
|
node.pitch_ = pitch;
|
|
node.voice_ = voice;*/
|
|
drumKit_.push_back(node);
|
|
}
|
|
|
|
QList<Track::DrumNode> Track::getDrumKit() const {
|
|
return drumKit_;
|
|
}
|
|
|
|
void Track::setPart(int part) {
|
|
part_ = part;
|
|
}
|
|
|
|
int Track::getPart() const {
|
|
return part_;
|
|
}
|
|
|
|
void Track::clear(void) {
|
|
number_ = 0;
|
|
|
|
name_ = QString();
|
|
|
|
patch_ = 0;
|
|
channel_ = 0;
|
|
transpose_ = 0;
|
|
showTranspose_ = false;
|
|
noteShift_ = 0;
|
|
startClef_ = ClefType::Treble;
|
|
transposeClef_ = ClefType::Treble;
|
|
displayPercent_ = 100;
|
|
startKey_ = 0;
|
|
voiceCount_ = 8;
|
|
|
|
showName_ = true;
|
|
showBriefName_ = false;
|
|
showKeyEachLine_ = false;
|
|
showLegerLine_ = true;
|
|
showClef_ = true;
|
|
showTimeSignature_ = true;
|
|
showKeySignature_ = true;
|
|
showBarline_ = true;
|
|
showClefEachLine_ = false;
|
|
|
|
fillWithRest_ = true;
|
|
flatTail_ = false;
|
|
|
|
mute_ = false;
|
|
solo_ = false;
|
|
|
|
drumKit_.clear();
|
|
|
|
part_ = 0;
|
|
|
|
for(int i=0; i<voices_.size(); ++i){
|
|
delete voices_[i];
|
|
}
|
|
voices_.clear();
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
Page::Page() {
|
|
beginLine_ = 0;
|
|
lineCount_ = 0;
|
|
|
|
lineInterval_ = 9;
|
|
staffInterval_ = 7;
|
|
staffInlineInterval_ = 6;
|
|
|
|
lineBarCount_ = 4;
|
|
pageLineCount_ = 5;
|
|
|
|
leftMargin_ = 0xA8;
|
|
topMargin_ = 0xA8;
|
|
rightMargin_ = 0xA8;
|
|
bottomMargin_ = 0xA8;
|
|
|
|
pageWidth_ = 0x0B40;
|
|
pageHeight_ = 0x0E90;
|
|
}
|
|
|
|
void Page::setBeginLine(int line) {
|
|
beginLine_ = line;
|
|
}
|
|
|
|
int Page::getBeginLine() const {
|
|
return beginLine_;
|
|
}
|
|
|
|
void Page::setLineCount(int count) {
|
|
lineCount_ = count;
|
|
}
|
|
|
|
int Page::getLineCount() const {
|
|
return lineCount_;
|
|
}
|
|
|
|
void Page::setLineInterval(int interval) {
|
|
lineInterval_ = interval;
|
|
}
|
|
|
|
int Page::getLineInterval() const {
|
|
return lineInterval_;
|
|
}
|
|
|
|
void Page::setStaffInterval(int interval) {
|
|
staffInterval_ = interval;
|
|
}
|
|
|
|
int Page::getStaffInterval() const {
|
|
return staffInterval_;
|
|
}
|
|
|
|
void Page::setStaffInlineInterval(int interval) {
|
|
staffInlineInterval_ = interval;
|
|
}
|
|
|
|
int Page::getStaffInlineInterval() const {
|
|
return staffInlineInterval_;
|
|
}
|
|
|
|
void Page::setLineBarCount(int count) {
|
|
lineBarCount_ = count;
|
|
}
|
|
|
|
int Page::getLineBarCount() const {
|
|
return lineBarCount_;
|
|
}
|
|
|
|
void Page::setPageLineCount(int count) {
|
|
pageLineCount_ = count;
|
|
}
|
|
|
|
int Page::getPageLineCount() const {
|
|
return pageLineCount_;
|
|
}
|
|
|
|
void Page::setLeftMargin(int margin) {
|
|
leftMargin_ = margin;
|
|
}
|
|
|
|
int Page::getLeftMargin() const {
|
|
return leftMargin_;
|
|
}
|
|
|
|
void Page::setTopMargin(int margin) {
|
|
topMargin_ = margin;
|
|
}
|
|
|
|
int Page::getTopMargin() const {
|
|
return topMargin_;
|
|
}
|
|
|
|
void Page::setRightMargin(int margin) {
|
|
rightMargin_ = margin;
|
|
}
|
|
|
|
int Page::getRightMargin() const {
|
|
return rightMargin_;
|
|
}
|
|
|
|
void Page::setBottomMargin(int margin) {
|
|
bottomMargin_ = margin;
|
|
}
|
|
|
|
int Page::getBottomMargin() const {
|
|
return bottomMargin_;
|
|
}
|
|
|
|
void Page::setPageWidth(int width) {
|
|
pageWidth_ = width;
|
|
}
|
|
|
|
int Page::getPageWidth() const {
|
|
return pageWidth_;
|
|
}
|
|
|
|
void Page::setPageHeight(int height) {
|
|
pageHeight_ = height;
|
|
}
|
|
|
|
int Page::getPageHeight() const {
|
|
return pageHeight_;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
Line::Line() {
|
|
beginBar_ = 0;
|
|
barCount_ = 0;
|
|
yOffset_ = 0;
|
|
leftXOffset_ = 0;
|
|
rightXOffset_ = 0;
|
|
}
|
|
|
|
Line::~Line() {
|
|
for(int i=0; i<staffs_.size(); ++i){
|
|
delete staffs_[i];
|
|
}
|
|
staffs_.clear();
|
|
}
|
|
|
|
void Line::addStaff(Staff* staff) {
|
|
staffs_.push_back(staff);
|
|
}
|
|
|
|
int Line::getStaffCount() const {
|
|
return staffs_.size();
|
|
}
|
|
|
|
Staff* Line::getStaff(int idx) const {
|
|
if (idx >= 0 && idx < (int) staffs_.size()) {
|
|
return staffs_[idx];
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
void Line::setBeginBar(unsigned int bar) {
|
|
beginBar_ = bar;
|
|
}
|
|
|
|
unsigned int Line::getBeginBar() const {
|
|
return beginBar_;
|
|
}
|
|
|
|
void Line::setBarCount(unsigned int count) {
|
|
barCount_ = count;
|
|
}
|
|
|
|
unsigned int Line::getBarCount() const {
|
|
return barCount_;
|
|
}
|
|
|
|
void Line::setYOffset(int offset) {
|
|
yOffset_ = offset;
|
|
}
|
|
|
|
int Line::getYOffset() const {
|
|
return yOffset_;
|
|
}
|
|
|
|
void Line::setLeftXOffset(int offset) {
|
|
leftXOffset_ = offset;
|
|
}
|
|
|
|
int Line::getLeftXOffset() const {
|
|
return leftXOffset_;
|
|
}
|
|
|
|
void Line::setRightXOffset(int offset) {
|
|
rightXOffset_ = offset;
|
|
}
|
|
|
|
int Line::getRightXOffset() const {
|
|
return rightXOffset_;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
Staff::Staff() {
|
|
clef_ = ClefType::Treble;
|
|
key_ = 0;
|
|
visible_ = true;
|
|
groupType_ = GroupType::None;
|
|
groupStaffCount_ = 0;
|
|
}
|
|
|
|
void Staff::setClefType(int clef) {
|
|
clef_ = (ClefType) clef;
|
|
}
|
|
|
|
ClefType Staff::getClefType() const {
|
|
return clef_;
|
|
}
|
|
|
|
void Staff::setKeyType(int key) {
|
|
key_ = key;
|
|
}
|
|
|
|
int Staff::getKeyType() const {
|
|
return key_;
|
|
}
|
|
|
|
void Staff::setVisible(bool visible) {
|
|
visible_ = visible;
|
|
}
|
|
|
|
bool Staff::setVisible() const {
|
|
return visible_;
|
|
}
|
|
|
|
void Staff::setGroupType(GroupType type){
|
|
groupType_ = type;
|
|
}
|
|
|
|
GroupType Staff::getGroupType() const {
|
|
return groupType_;
|
|
}
|
|
|
|
void Staff::setGroupStaffCount(int count) {
|
|
groupStaffCount_ = count;
|
|
}
|
|
|
|
int Staff::getGroupStaffCount() const {
|
|
return groupStaffCount_;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
Note::Note() {
|
|
rest_ = false;
|
|
note_ = 60;
|
|
accidental_ = AccidentalType::Normal;
|
|
showAccidental_ = false;
|
|
offVelocity_ = 0x40;
|
|
onVelocity_ = 0x50;
|
|
headType_ = NoteHeadType::Standard;
|
|
tiePos_ = TiePos::None;
|
|
offsetStaff_ = 0;
|
|
show_ = true;
|
|
offsetTick_ = 0;
|
|
}
|
|
|
|
void Note::setIsRest(bool rest) {
|
|
rest_ = rest;
|
|
}
|
|
|
|
bool Note::getIsRest() const {
|
|
return rest_;
|
|
}
|
|
|
|
void Note::setNote(unsigned int note) {
|
|
note_ = note;
|
|
}
|
|
|
|
unsigned int Note::getNote() const {
|
|
return note_;
|
|
}
|
|
|
|
void Note::setAccidental(int type) {
|
|
accidental_ = (AccidentalType) type;
|
|
}
|
|
|
|
AccidentalType Note::getAccidental() const {
|
|
return accidental_;
|
|
}
|
|
|
|
void Note::setShowAccidental(bool show) {
|
|
showAccidental_ = show;
|
|
}
|
|
|
|
bool Note::getShowAccidental() const {
|
|
return showAccidental_;
|
|
}
|
|
|
|
void Note::setOnVelocity(unsigned int velocity) {
|
|
onVelocity_ = velocity;
|
|
}
|
|
|
|
unsigned int Note::getOnVelocity() const {
|
|
return onVelocity_;
|
|
}
|
|
|
|
void Note::setOffVelocity(unsigned int velocity) {
|
|
offVelocity_ = velocity;
|
|
}
|
|
|
|
unsigned int Note::getOffVelocity() const {
|
|
return offVelocity_;
|
|
}
|
|
|
|
void Note::setHeadType(int type) {
|
|
headType_ = (NoteHeadType) type;
|
|
}
|
|
|
|
NoteHeadType Note::getHeadType() const {
|
|
return headType_;
|
|
}
|
|
|
|
void Note::setTiePos(int tiePos) {
|
|
tiePos_ = (TiePos) tiePos;
|
|
}
|
|
|
|
TiePos Note::getTiePos() const {
|
|
return tiePos_;
|
|
}
|
|
|
|
void Note::setOffsetStaff(int offset) {
|
|
offsetStaff_ = offset;
|
|
}
|
|
|
|
int Note::getOffsetStaff() const {
|
|
return offsetStaff_;
|
|
}
|
|
|
|
void Note::setShow(bool show) {
|
|
show_ = show;
|
|
}
|
|
|
|
bool Note::getShow() const {
|
|
return show_;
|
|
}
|
|
|
|
void Note::setOffsetTick(int offset) {
|
|
offsetTick_ = offset;
|
|
}
|
|
|
|
int Note::getOffsetTick() const {
|
|
return offsetTick_;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
Articulation::Articulation() {
|
|
type_ = ArticulationType::Marcato;
|
|
above_ = true;
|
|
|
|
changeSoundEffect_ = false;
|
|
changeLength_ = false;
|
|
changeVelocity_ = false;
|
|
changeExtraLength_ = false;
|
|
|
|
soundEffect_ = qMakePair(0, 0);
|
|
lengthPercentage_ = 100;
|
|
velocityType_ = VelocityType::Offset;
|
|
velocityValue_ = 0;
|
|
extraLength_ = 0;
|
|
|
|
trillNoteLength_ = 60;
|
|
trillRate_ = NoteType::Note_Sixteen;
|
|
accelerateType_ = AccelerateType::None;
|
|
auxiliaryFirst_ = false;
|
|
trillInterval_ = TrillInterval::Chromatic;
|
|
}
|
|
|
|
void Articulation::setArtType(int type) {
|
|
type_ = (ArticulationType) type;
|
|
}
|
|
|
|
ArticulationType Articulation::getArtType() const {
|
|
return type_;
|
|
}
|
|
|
|
void Articulation::setPlacementAbove(bool above) {
|
|
above_ = above;
|
|
}
|
|
|
|
bool Articulation::getPlacementAbove() const {
|
|
return above_;
|
|
}
|
|
|
|
bool Articulation::getChangeSoundEffect() const {
|
|
return changeSoundEffect_;
|
|
}
|
|
|
|
void Articulation::setSoundEffect(int soundFrom, int soundTo) {
|
|
soundEffect_ = qMakePair(soundFrom, soundTo);
|
|
changeSoundEffect_ = true;
|
|
}
|
|
|
|
QPair<int, int> Articulation::getSoundEffect() const {
|
|
return soundEffect_;
|
|
}
|
|
|
|
bool Articulation::getChangeLength() const {
|
|
return changeLength_;
|
|
}
|
|
|
|
void Articulation::setLengthPercentage(int percentage) {
|
|
lengthPercentage_ = percentage;
|
|
changeLength_ = true;
|
|
}
|
|
|
|
int Articulation::getLengthPercentage() const {
|
|
return lengthPercentage_;
|
|
}
|
|
|
|
bool Articulation::getChangeVelocity() const {
|
|
return changeVelocity_;
|
|
}
|
|
|
|
void Articulation::setVelocityType(VelocityType type) {
|
|
velocityType_ = type;
|
|
changeVelocity_ = true;
|
|
}
|
|
|
|
Articulation::VelocityType Articulation::getVelocityType() const {
|
|
return velocityType_;
|
|
}
|
|
|
|
void Articulation::setVelocityValue(int value) {
|
|
velocityValue_ = value;
|
|
}
|
|
|
|
int Articulation::getVelocityValue() const {
|
|
return velocityValue_;
|
|
}
|
|
|
|
bool Articulation::getChangeExtraLength() const {
|
|
return changeExtraLength_;
|
|
}
|
|
|
|
void Articulation::setExtraLength(int length) {
|
|
extraLength_ = length;
|
|
changeExtraLength_ = true;
|
|
}
|
|
|
|
int Articulation::getExtraLength() const {
|
|
return extraLength_;
|
|
}
|
|
|
|
void Articulation::setTrillNoteLength(int length) {
|
|
trillNoteLength_ = length;
|
|
}
|
|
|
|
int Articulation::getTrillNoteLength() const {
|
|
return trillNoteLength_;
|
|
}
|
|
|
|
void Articulation::setTrillRate(NoteType rate) {
|
|
trillRate_ = rate;
|
|
}
|
|
|
|
NoteType Articulation::getTrillRate() const {
|
|
return trillRate_;
|
|
}
|
|
|
|
void Articulation::setAccelerateType(int type) {
|
|
accelerateType_ = (AccelerateType) type;
|
|
}
|
|
|
|
Articulation::AccelerateType Articulation::getAccelerateType() const {
|
|
return accelerateType_;
|
|
}
|
|
|
|
void Articulation::setAuxiliaryFirst(bool first) {
|
|
auxiliaryFirst_ = first;
|
|
}
|
|
|
|
bool Articulation::getAuxiliaryFirst() const {
|
|
return auxiliaryFirst_;
|
|
}
|
|
|
|
void Articulation::setTrillInterval(int interval) {
|
|
trillInterval_ = (TrillInterval) interval;
|
|
}
|
|
|
|
Articulation::TrillInterval Articulation::getTrillInterval() const {
|
|
return trillInterval_;
|
|
}
|
|
|
|
bool Articulation::willAffectNotes() const {
|
|
bool affect = false;
|
|
|
|
switch (getArtType()) {
|
|
case ArticulationType::Major_Trill:
|
|
case ArticulationType::Minor_Trill:
|
|
case ArticulationType::Trill_Section:
|
|
case ArticulationType::Inverted_Short_Mordent:
|
|
case ArticulationType::Inverted_Long_Mordent:
|
|
case ArticulationType::Short_Mordent:
|
|
case ArticulationType::Turn:
|
|
|
|
case ArticulationType::Arpeggio:
|
|
case ArticulationType::Tremolo_Eighth:
|
|
case ArticulationType::Tremolo_Sixteenth:
|
|
case ArticulationType::Tremolo_Thirty_Second:
|
|
case ArticulationType::Tremolo_Sixty_Fourth: {
|
|
affect = true;
|
|
break;
|
|
}
|
|
case ArticulationType::Finger_1:
|
|
case ArticulationType::Finger_2:
|
|
case ArticulationType::Finger_3:
|
|
case ArticulationType::Finger_4:
|
|
case ArticulationType::Finger_5:
|
|
case ArticulationType::Flat_Accidental_For_Trill:
|
|
case ArticulationType::Sharp_Accidental_For_Trill:
|
|
case ArticulationType::Natural_Accidental_For_Trill:
|
|
case ArticulationType::Marcato:
|
|
case ArticulationType::Marcato_Dot:
|
|
case ArticulationType::Heavy_Attack:
|
|
case ArticulationType::SForzando:
|
|
case ArticulationType::SForzando_Dot:
|
|
case ArticulationType::Heavier_Attack:
|
|
case ArticulationType::SForzando_Inverted:
|
|
case ArticulationType::SForzando_Dot_Inverted:
|
|
case ArticulationType::Staccatissimo:
|
|
case ArticulationType::Staccato:
|
|
case ArticulationType::Tenuto:
|
|
case ArticulationType::Up_Bow:
|
|
case ArticulationType::Down_Bow:
|
|
case ArticulationType::Up_Bow_Inverted:
|
|
case ArticulationType::Down_Bow_Inverted:
|
|
case ArticulationType::Natural_Harmonic:
|
|
case ArticulationType::Artificial_Harmonic:
|
|
case ArticulationType::Plus_Sign:
|
|
case ArticulationType::Fermata:
|
|
case ArticulationType::Fermata_Inverted:
|
|
case ArticulationType::Pedal_Down:
|
|
case ArticulationType::Pedal_Up:
|
|
case ArticulationType::Pause:
|
|
case ArticulationType::Grand_Pause:
|
|
case ArticulationType::Toe_Pedal:
|
|
case ArticulationType::Heel_Pedal:
|
|
case ArticulationType::Toe_To_Heel_Pedal:
|
|
case ArticulationType::Heel_To_Toe_Pedal:
|
|
case ArticulationType::Open_String:
|
|
case ArticulationType::Guitar_Lift:
|
|
case ArticulationType::Guitar_Slide_Up:
|
|
case ArticulationType::Guitar_Rip:
|
|
case ArticulationType::Guitar_Fall_Off:
|
|
case ArticulationType::Guitar_Slide_Down:
|
|
case ArticulationType::Guitar_Spill:
|
|
case ArticulationType::Guitar_Flip:
|
|
case ArticulationType::Guitar_Smear:
|
|
case ArticulationType::Guitar_Bend:
|
|
case ArticulationType::Guitar_Doit:
|
|
case ArticulationType::Guitar_Plop:
|
|
case ArticulationType::Guitar_Wow_Wow:
|
|
case ArticulationType::Guitar_Thumb:
|
|
case ArticulationType::Guitar_Index_Finger:
|
|
case ArticulationType::Guitar_Middle_Finger:
|
|
case ArticulationType::Guitar_Ring_Finger:
|
|
case ArticulationType::Guitar_Pinky_Finger:
|
|
case ArticulationType::Guitar_Tap:
|
|
case ArticulationType::Guitar_Hammer:
|
|
case ArticulationType::Guitar_Pluck: {
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return affect;
|
|
}
|
|
|
|
bool Articulation::isTrill(ArticulationType type) {
|
|
bool isTrill = false;
|
|
|
|
switch (type) {
|
|
case ArticulationType::Major_Trill:
|
|
case ArticulationType::Minor_Trill:
|
|
case ArticulationType::Trill_Section: {
|
|
isTrill = true;
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return isTrill;
|
|
}
|
|
|
|
Articulation::XmlType Articulation::getXmlType() const {
|
|
XmlType xmlType = XmlType::Unknown;
|
|
|
|
switch (type_) {
|
|
case ArticulationType::Major_Trill:
|
|
case ArticulationType::Minor_Trill:
|
|
case ArticulationType::Trill_Section:
|
|
case ArticulationType::Inverted_Short_Mordent:
|
|
case ArticulationType::Inverted_Long_Mordent:
|
|
case ArticulationType::Short_Mordent:
|
|
case ArticulationType::Turn:
|
|
// case ArticulationType::Flat_Accidental_For_Trill :
|
|
// case ArticulationType::Sharp_Accidental_For_Trill :
|
|
// case ArticulationType::Natural_Accidental_For_Trill :
|
|
case ArticulationType::Tremolo_Eighth:
|
|
case ArticulationType::Tremolo_Sixteenth:
|
|
case ArticulationType::Tremolo_Thirty_Second:
|
|
case ArticulationType::Tremolo_Sixty_Fourth: {
|
|
xmlType = XmlType::Ornament;
|
|
break;
|
|
}
|
|
case ArticulationType::Marcato:
|
|
case ArticulationType::Marcato_Dot:
|
|
case ArticulationType::Heavy_Attack:
|
|
case ArticulationType::SForzando:
|
|
case ArticulationType::SForzando_Inverted:
|
|
case ArticulationType::SForzando_Dot:
|
|
case ArticulationType::SForzando_Dot_Inverted:
|
|
case ArticulationType::Heavier_Attack:
|
|
case ArticulationType::Staccatissimo:
|
|
case ArticulationType::Staccato:
|
|
case ArticulationType::Tenuto:
|
|
case ArticulationType::Pause:
|
|
case ArticulationType::Grand_Pause: {
|
|
xmlType = XmlType::Articulation;
|
|
break;
|
|
}
|
|
case ArticulationType::Up_Bow:
|
|
case ArticulationType::Down_Bow:
|
|
case ArticulationType::Up_Bow_Inverted:
|
|
case ArticulationType::Down_Bow_Inverted:
|
|
case ArticulationType::Natural_Harmonic:
|
|
case ArticulationType::Artificial_Harmonic:
|
|
case ArticulationType::Finger_1:
|
|
case ArticulationType::Finger_2:
|
|
case ArticulationType::Finger_3:
|
|
case ArticulationType::Finger_4:
|
|
case ArticulationType::Finger_5:
|
|
case ArticulationType::Plus_Sign: {
|
|
xmlType = XmlType::Technical;
|
|
break;
|
|
}
|
|
case ArticulationType::Arpeggio: {
|
|
xmlType = XmlType::Arpeggiate;
|
|
break;
|
|
}
|
|
case ArticulationType::Fermata:
|
|
case ArticulationType::Fermata_Inverted: {
|
|
xmlType = XmlType::Fermata;
|
|
break;
|
|
}
|
|
case ArticulationType::Pedal_Down:
|
|
case ArticulationType::Pedal_Up: {
|
|
xmlType = XmlType::Direction;
|
|
break;
|
|
}
|
|
// case ArticulationType::Toe_Pedal :
|
|
// case ArticulationType::Heel_Pedal :
|
|
// case ArticulationType::Toe_To_Heel_Pedal :
|
|
// case ArticulationType::Heel_To_Toe_Pedal :
|
|
// case ArticulationType::Open_String :
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return xmlType;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
NoteContainer::NoteContainer() {
|
|
musicDataType_ = MusicDataType::Note_Container;
|
|
|
|
grace_ = false;
|
|
cue_ = false;
|
|
rest_ = false;
|
|
raw_ = false;
|
|
noteType_ = NoteType::Note_Quarter;
|
|
dot_ = 0;
|
|
graceNoteType_ = NoteType::Note_Eight;
|
|
stemUp_ = true;
|
|
showStem_ = true;
|
|
stemLength_ = 7;
|
|
inBeam_ = false;
|
|
tuplet_ = 0;
|
|
space_ = 2;//div by 0
|
|
noteShift_ = 0;
|
|
}
|
|
|
|
NoteContainer::~NoteContainer(){
|
|
for(int i=0; i<notes_.size(); ++i){
|
|
delete notes_[i];
|
|
}
|
|
for(int i=0; i<articulations_.size(); ++i){
|
|
delete articulations_[i];
|
|
}
|
|
notes_.clear();
|
|
articulations_.clear();
|
|
}
|
|
|
|
void NoteContainer::setIsGrace(bool grace) {
|
|
grace_ = grace;
|
|
}
|
|
|
|
bool NoteContainer::getIsGrace() const {
|
|
return grace_;
|
|
}
|
|
|
|
void NoteContainer::setIsCue(bool cue) {
|
|
cue_ = cue;
|
|
}
|
|
|
|
bool NoteContainer::getIsCue() const {
|
|
return cue_;
|
|
}
|
|
|
|
void NoteContainer::setIsRest(bool rest) {
|
|
rest_ = rest;
|
|
}
|
|
|
|
bool NoteContainer::getIsRest() const {
|
|
return rest_;
|
|
}
|
|
|
|
void NoteContainer::setIsRaw(bool raw) {
|
|
raw_ = raw;
|
|
}
|
|
|
|
bool NoteContainer::getIsRaw() const {
|
|
return raw_;
|
|
}
|
|
|
|
void NoteContainer::setNoteType(NoteType type) {
|
|
noteType_ = NoteType::Note_Quarter;
|
|
|
|
switch (type) {
|
|
case NoteType::Note_DoubleWhole:
|
|
case NoteType::Note_Whole:
|
|
case NoteType::Note_Half:
|
|
case NoteType::Note_Quarter:
|
|
case NoteType::Note_Eight:
|
|
case NoteType::Note_Sixteen:
|
|
case NoteType::Note_32:
|
|
case NoteType::Note_64:
|
|
case NoteType::Note_128:
|
|
case NoteType::Note_256: {
|
|
noteType_ = type;
|
|
break;
|
|
}
|
|
default: {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
NoteType NoteContainer::getNoteType() const {
|
|
return noteType_;
|
|
}
|
|
|
|
void NoteContainer::setDot(int dot) {
|
|
dot_ = dot;
|
|
}
|
|
|
|
int NoteContainer::getDot() const {
|
|
return dot_;
|
|
}
|
|
|
|
void NoteContainer::setGraceNoteType(NoteType type) {
|
|
graceNoteType_ = type;
|
|
}
|
|
|
|
NoteType NoteContainer::getGraceNoteType() const {
|
|
return graceNoteType_;
|
|
}
|
|
|
|
void NoteContainer::setInBeam(bool in) {
|
|
inBeam_ = in;
|
|
}
|
|
|
|
bool NoteContainer::getInBeam() const {
|
|
return inBeam_;
|
|
}
|
|
|
|
void NoteContainer::setStemUp(bool up) {
|
|
stemUp_ = up;
|
|
}
|
|
|
|
bool NoteContainer::getStemUp(void) const {
|
|
return stemUp_;
|
|
}
|
|
|
|
void NoteContainer::setShowStem(bool show) {
|
|
showStem_ = show;
|
|
}
|
|
|
|
bool NoteContainer::getShowStem() const {
|
|
return showStem_;
|
|
}
|
|
|
|
void NoteContainer::setStemLength(int line) {
|
|
stemLength_ = line;
|
|
}
|
|
|
|
int NoteContainer::getStemLength() const {
|
|
return stemLength_;
|
|
}
|
|
|
|
void NoteContainer::setTuplet(int tuplet) {
|
|
tuplet_ = tuplet;
|
|
}
|
|
|
|
int NoteContainer::getTuplet() const {
|
|
return tuplet_;
|
|
}
|
|
|
|
void NoteContainer::setSpace(int space) {
|
|
space_ = space;
|
|
}
|
|
|
|
int NoteContainer::getSpace() const {
|
|
return space_;
|
|
}
|
|
|
|
void NoteContainer::addNoteRest(Note* note) {
|
|
notes_.push_back(note);
|
|
}
|
|
|
|
QList<Note*> NoteContainer::getNotesRests() const {
|
|
return notes_;
|
|
}
|
|
|
|
void NoteContainer::addArticulation(Articulation* art) {
|
|
articulations_.push_back(art);
|
|
}
|
|
|
|
QList<Articulation*> NoteContainer::getArticulations() const {
|
|
return articulations_;
|
|
}
|
|
|
|
void NoteContainer::setNoteShift(int octave) {
|
|
noteShift_ = octave;
|
|
}
|
|
|
|
int NoteContainer::getNoteShift() const {
|
|
return noteShift_;
|
|
}
|
|
|
|
int NoteContainer::getOffsetStaff() const {
|
|
if(getIsRest())
|
|
return 0;
|
|
|
|
int staffMove = 0;
|
|
QList<OVE::Note*> notes = getNotesRests();
|
|
for (int i = 0; i < notes.size(); ++i) {
|
|
OVE::Note* notePtr = notes[i];
|
|
staffMove = notePtr->getOffsetStaff();
|
|
}
|
|
|
|
return staffMove;
|
|
}
|
|
|
|
int NoteContainer::getDuration() const {
|
|
int duration = (int) NoteDuration::D_4;
|
|
|
|
switch (noteType_) {
|
|
case NoteType::Note_DoubleWhole: {
|
|
duration = (int) NoteDuration::D_Double_Whole;
|
|
break;
|
|
}
|
|
case NoteType::Note_Whole: {
|
|
duration = (int) NoteDuration::D_Whole;
|
|
break;
|
|
}
|
|
case NoteType::Note_Half: {
|
|
duration = (int) NoteDuration::D_2;
|
|
break;
|
|
}
|
|
case NoteType::Note_Quarter: {
|
|
duration = (int) NoteDuration::D_4;
|
|
break;
|
|
}
|
|
case NoteType::Note_Eight: {
|
|
duration = (int) NoteDuration::D_8;
|
|
break;
|
|
}
|
|
case NoteType::Note_Sixteen: {
|
|
duration = (int) NoteDuration::D_16;
|
|
break;
|
|
}
|
|
case NoteType::Note_32: {
|
|
duration = (int) NoteDuration::D_32;
|
|
break;
|
|
}
|
|
case NoteType::Note_64: {
|
|
duration = (int) NoteDuration::D_64;
|
|
break;
|
|
}
|
|
case NoteType::Note_128: {
|
|
duration = (int) NoteDuration::D_128;
|
|
break;
|
|
}
|
|
case NoteType::Note_256: {
|
|
duration = (int) NoteDuration::D_256;
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
|
|
int dotLength = duration;
|
|
|
|
for (int i = 0; i < dot_; ++i) {
|
|
dotLength /= 2;
|
|
}
|
|
|
|
dotLength = duration - dotLength;
|
|
|
|
duration += dotLength;
|
|
|
|
return duration;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
Beam::Beam() {
|
|
musicDataType_ = MusicDataType::Beam;
|
|
grace_ = false;
|
|
}
|
|
|
|
void Beam::setIsGrace(bool grace) {
|
|
grace_ = grace;
|
|
}
|
|
|
|
bool Beam::getIsGrace() const {
|
|
return grace_;
|
|
}
|
|
|
|
void Beam::addLine(const MeasurePos& startMp, const MeasurePos& endMp) {
|
|
lines_.push_back(qMakePair(startMp, endMp));
|
|
}
|
|
|
|
const QList<QPair<MeasurePos, MeasurePos> > Beam::getLines() const {
|
|
return lines_;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
Tie::Tie() {
|
|
musicDataType_ = MusicDataType::Tie;
|
|
|
|
showOnTop_ = true;
|
|
note_ = 72;
|
|
height_ = 24;
|
|
}
|
|
|
|
void Tie::setShowOnTop(bool top) {
|
|
showOnTop_ = top;
|
|
}
|
|
|
|
bool Tie::getShowOnTop() const {
|
|
return showOnTop_;
|
|
}
|
|
|
|
void Tie::setNote(int note) {
|
|
note_ = note;
|
|
}
|
|
|
|
int Tie::getNote() const {
|
|
return note_;
|
|
}
|
|
|
|
void Tie::setHeight(int height) {
|
|
height_ = height;
|
|
}
|
|
|
|
int Tie::getHeight() const {
|
|
return height_;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
Glissando::Glissando() {
|
|
musicDataType_ = MusicDataType::Glissando;
|
|
|
|
straight_ = true;
|
|
text_ = "gliss.";
|
|
lineThick_ = 8;
|
|
}
|
|
|
|
void Glissando::setStraightWavy(bool straight) {
|
|
straight_ = straight;
|
|
}
|
|
|
|
bool Glissando::getStraightWavy() const {
|
|
return straight_;
|
|
}
|
|
|
|
void Glissando::setText(const QString& text) {
|
|
text_ = text;
|
|
}
|
|
|
|
QString Glissando::getText() const {
|
|
return text_;
|
|
}
|
|
|
|
void Glissando::setLineThick(int thick) {
|
|
lineThick_ = thick;
|
|
}
|
|
|
|
int Glissando::getLineThick() const {
|
|
return lineThick_;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
Decorator::Decorator() :
|
|
decoratorType_(Type::Articulation),
|
|
artType_(ArticulationType::Marcato) {
|
|
musicDataType_ = MusicDataType::Decorator;
|
|
}
|
|
|
|
void Decorator::setDecoratorType(Type type) {
|
|
decoratorType_ = type;
|
|
}
|
|
|
|
Decorator::Type Decorator::getDecoratorType() const {
|
|
return decoratorType_;
|
|
}
|
|
|
|
void Decorator::setArticulationType(ArticulationType type) {
|
|
artType_ = type;
|
|
}
|
|
|
|
ArticulationType Decorator::getArticulationType() const {
|
|
return artType_;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
MeasureRepeat::MeasureRepeat() {
|
|
musicDataType_ = MusicDataType::Measure_Repeat;
|
|
singleRepeat_ = true;
|
|
}
|
|
|
|
void MeasureRepeat::setSingleRepeat(bool single) {
|
|
singleRepeat_ = single;
|
|
|
|
start()->setMeasure(0);
|
|
start()->setOffset(0);
|
|
stop()->setMeasure(single ? 1 : 2);
|
|
stop()->setOffset(0);
|
|
}
|
|
|
|
bool MeasureRepeat::getSingleRepeat() const {
|
|
return singleRepeat_;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
Tuplet::Tuplet() :
|
|
tuplet_(3), space_(2), height_(0), noteType_(NoteType::Note_Quarter){
|
|
musicDataType_ = MusicDataType::Tuplet;
|
|
mark_ = new OffsetElement();
|
|
}
|
|
|
|
Tuplet::~Tuplet(){
|
|
delete mark_;
|
|
}
|
|
|
|
void Tuplet::setTuplet(int tuplet) {
|
|
tuplet_ = tuplet;
|
|
}
|
|
|
|
int Tuplet::getTuplet() const {
|
|
return tuplet_;
|
|
}
|
|
|
|
void Tuplet::setSpace(int space) {
|
|
space_ = space;
|
|
}
|
|
|
|
int Tuplet::getSpace() const {
|
|
return space_;
|
|
}
|
|
|
|
OffsetElement* Tuplet::getMarkHandle() const {
|
|
return mark_;
|
|
}
|
|
|
|
void Tuplet::setHeight(int height) {
|
|
height_ = height;
|
|
}
|
|
|
|
int Tuplet::getHeight() const {
|
|
return height_;
|
|
}
|
|
|
|
void Tuplet::setNoteType(NoteType type) {
|
|
noteType_ = type;
|
|
}
|
|
|
|
NoteType Tuplet::getNoteType() const {
|
|
return noteType_;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
Harmony::Harmony() {
|
|
musicDataType_ = MusicDataType::Harmony;
|
|
|
|
harmonyType_ = HarmonyType::H_maj;
|
|
root_ = 0;
|
|
bass_ = -1; //0xff
|
|
bassOnBottom_ = false;
|
|
angle_ = 0;
|
|
}
|
|
|
|
void Harmony::setHarmonyType(HarmonyType type) {
|
|
harmonyType_ = type;
|
|
}
|
|
|
|
HarmonyType Harmony::getHarmonyType() const {
|
|
return harmonyType_;
|
|
}
|
|
|
|
void Harmony::setRoot(int root) {
|
|
root_ = root;
|
|
}
|
|
|
|
int Harmony::getRoot() const {
|
|
return root_;
|
|
}
|
|
|
|
void Harmony::setBass(int bass) {
|
|
bass_ = bass;
|
|
}
|
|
|
|
int Harmony::getBass() const {
|
|
return bass_;
|
|
}
|
|
|
|
void Harmony::setBassOnBottom(bool on) {
|
|
bassOnBottom_ = on;
|
|
}
|
|
|
|
bool Harmony::getBassOnBottom() const {
|
|
return bassOnBottom_;
|
|
}
|
|
|
|
void Harmony::setAngle(int angle) {
|
|
angle_ = angle;
|
|
}
|
|
|
|
int Harmony::getAngle() const {
|
|
return angle_;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
Clef::Clef() {
|
|
musicDataType_ = MusicDataType::Clef;
|
|
|
|
clefType_ = ClefType::Treble;
|
|
}
|
|
|
|
void Clef::setClefType(int type) {
|
|
clefType_ = (ClefType) type;
|
|
}
|
|
|
|
ClefType Clef::getClefType() const {
|
|
return clefType_;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
Lyric::Lyric() {
|
|
musicDataType_ = MusicDataType::Lyric;
|
|
|
|
lyric_ = QString();
|
|
verse_ = 0;
|
|
}
|
|
|
|
void Lyric::setLyric(const QString& lyricText) {
|
|
lyric_ = lyricText;
|
|
}
|
|
|
|
QString Lyric::getLyric() const {
|
|
return lyric_;
|
|
}
|
|
|
|
void Lyric::setVerse(int verse) {
|
|
verse_ = verse;
|
|
}
|
|
|
|
int Lyric::getVerse() const {
|
|
return verse_;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
Slur::Slur() {
|
|
musicDataType_ = MusicDataType::Slur;
|
|
|
|
containerCount_ = 1;
|
|
showOnTop_ = true;
|
|
noteTimePercent_ = 100;
|
|
|
|
handle_2_ = new OffsetElement();
|
|
handle_3_ = new OffsetElement();
|
|
}
|
|
|
|
Slur::~Slur() {
|
|
delete handle_2_;
|
|
delete handle_3_;
|
|
}
|
|
|
|
void Slur::setContainerCount(int count) {
|
|
containerCount_ = count;
|
|
}
|
|
|
|
int Slur::getContainerCount() const {
|
|
return containerCount_;
|
|
}
|
|
|
|
void Slur::setShowOnTop(bool top) {
|
|
showOnTop_ = top;
|
|
}
|
|
|
|
bool Slur::getShowOnTop() const {
|
|
return showOnTop_;
|
|
}
|
|
|
|
OffsetElement* Slur::getHandle2() const {
|
|
return handle_2_;
|
|
}
|
|
|
|
OffsetElement* Slur::getHandle3() const {
|
|
return handle_3_;
|
|
}
|
|
|
|
void Slur::setNoteTimePercent(int percent) {
|
|
noteTimePercent_ = percent;
|
|
}
|
|
|
|
int Slur::getNoteTimePercent() const {
|
|
return noteTimePercent_;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
Dynamics::Dynamics() {
|
|
musicDataType_ = MusicDataType::Dynamics;
|
|
|
|
dynamicsType_ = DynamicsType::PPPP;
|
|
playback_ = true;
|
|
velocity_ = 30;
|
|
}
|
|
|
|
void Dynamics::setDynamicsType(int type) {
|
|
dynamicsType_ = DynamicsType(type);
|
|
}
|
|
|
|
DynamicsType Dynamics::getDynamicsType() const {
|
|
return dynamicsType_;
|
|
}
|
|
|
|
void Dynamics::setIsPlayback(bool play) {
|
|
playback_ = play;
|
|
}
|
|
|
|
bool Dynamics::getIsPlayback() const {
|
|
return playback_;
|
|
}
|
|
|
|
void Dynamics::setVelocity(int vel) {
|
|
velocity_ = vel;
|
|
}
|
|
|
|
int Dynamics::getVelocity() const {
|
|
return velocity_;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
WedgeEndPoint::WedgeEndPoint() {
|
|
musicDataType_ = MusicDataType::Wedge_EndPoint;
|
|
|
|
wedgeType_ = WedgeType::Cres;
|
|
height_ = 24;
|
|
wedgeStart_ = true;
|
|
}
|
|
|
|
void WedgeEndPoint::setWedgeType(WedgeType type) {
|
|
wedgeType_ = type;
|
|
}
|
|
|
|
WedgeType WedgeEndPoint::getWedgeType() const {
|
|
return wedgeType_;
|
|
}
|
|
|
|
void WedgeEndPoint::setHeight(int height) {
|
|
height_ = height;
|
|
}
|
|
|
|
int WedgeEndPoint::getHeight() const {
|
|
return height_;
|
|
}
|
|
|
|
void WedgeEndPoint::setWedgeStart(bool wedgeStart) {
|
|
wedgeStart_ = wedgeStart;
|
|
}
|
|
|
|
bool WedgeEndPoint::getWedgeStart() const {
|
|
return wedgeStart_;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
Wedge::Wedge() {
|
|
musicDataType_ = MusicDataType::Wedge;
|
|
|
|
wedgeType_ = WedgeType::Cres;
|
|
height_ = 24;
|
|
}
|
|
|
|
void Wedge::setWedgeType(WedgeType type) {
|
|
wedgeType_ = type;
|
|
}
|
|
|
|
WedgeType Wedge::getWedgeType() const {
|
|
return wedgeType_;
|
|
}
|
|
|
|
void Wedge::setHeight(int height) {
|
|
height_ = height;
|
|
}
|
|
|
|
int Wedge::getHeight() const {
|
|
return height_;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
Pedal::Pedal() {
|
|
musicDataType_ = MusicDataType::Pedal;
|
|
|
|
half_ = false;
|
|
playback_ = false;
|
|
playOffset_ = 0;
|
|
|
|
pedalHandle_ = new OffsetElement();
|
|
}
|
|
|
|
Pedal::~Pedal() {
|
|
delete pedalHandle_;
|
|
}
|
|
|
|
void Pedal::setHalf(bool half) {
|
|
half_ = half;
|
|
}
|
|
|
|
bool Pedal::getHalf() const {
|
|
return half_;
|
|
}
|
|
|
|
OffsetElement* Pedal::getPedalHandle() const {
|
|
return pedalHandle_;
|
|
}
|
|
|
|
void Pedal::setIsPlayback(bool playback) {
|
|
playback_ = playback;
|
|
}
|
|
|
|
bool Pedal::getIsPlayback() const {
|
|
return playback_;
|
|
}
|
|
|
|
void Pedal::setPlayOffset(int offset) {
|
|
playOffset_ = offset;
|
|
}
|
|
|
|
int Pedal::getPlayOffset() const {
|
|
return playOffset_;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
KuoHao::KuoHao() {
|
|
musicDataType_ = MusicDataType::KuoHao;
|
|
|
|
kuohaoType_ = KuoHaoType::Parentheses;
|
|
height_ = 0;
|
|
}
|
|
|
|
void KuoHao::setHeight(int height) {
|
|
height_ = height;
|
|
}
|
|
|
|
int KuoHao::getHeight() const {
|
|
return height_;
|
|
}
|
|
|
|
void KuoHao::setKuohaoType(int type) {
|
|
kuohaoType_ = (KuoHaoType) type;
|
|
}
|
|
|
|
KuoHaoType KuoHao::getKuohaoType() const {
|
|
return kuohaoType_;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
Expressions::Expressions() {
|
|
musicDataType_ = MusicDataType::Expressions;
|
|
|
|
text_ = QString();
|
|
}
|
|
|
|
void Expressions::setText(const QString& str) {
|
|
text_ = str;
|
|
}
|
|
|
|
QString Expressions::getText() const {
|
|
return text_;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
HarpPedal::HarpPedal() :
|
|
showType_(0),
|
|
showCharFlag_(0) {
|
|
musicDataType_ = MusicDataType::Harp_Pedal;
|
|
}
|
|
|
|
void HarpPedal::setShowType(int type) {
|
|
showType_ = type;
|
|
}
|
|
|
|
int HarpPedal::getShowType() const {
|
|
return showType_;
|
|
}
|
|
|
|
void HarpPedal::setShowCharFlag(int flag) {
|
|
showCharFlag_ = flag;
|
|
}
|
|
|
|
int HarpPedal::getShowCharFlag() const {
|
|
return showCharFlag_;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
OctaveShift::OctaveShift() :
|
|
octaveShiftType_(OctaveShiftType::OS_8),
|
|
octaveShiftPosition_(OctaveShiftPosition::Start),
|
|
endTick_(0) {
|
|
musicDataType_ = MusicDataType::OctaveShift;
|
|
}
|
|
|
|
void OctaveShift::setOctaveShiftType(OctaveShiftType type) {
|
|
octaveShiftType_ = type;
|
|
}
|
|
|
|
OctaveShiftType OctaveShift::getOctaveShiftType() const {
|
|
return octaveShiftType_;
|
|
}
|
|
|
|
int OctaveShift::getNoteShift() const {
|
|
int shift = 12;
|
|
|
|
switch (getOctaveShiftType()) {
|
|
case OctaveShiftType::OS_8: {
|
|
shift = 12;
|
|
break;
|
|
}
|
|
case OctaveShiftType::OS_Minus_8: {
|
|
shift = -12;
|
|
break;
|
|
}
|
|
case OctaveShiftType::OS_15: {
|
|
shift = 24;
|
|
break;
|
|
}
|
|
case OctaveShiftType::OS_Minus_15: {
|
|
shift = -24;
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return shift;
|
|
}
|
|
|
|
void OctaveShift::setEndTick(int tick) {
|
|
endTick_ = tick;
|
|
}
|
|
|
|
int OctaveShift::getEndTick() const {
|
|
return endTick_;
|
|
}
|
|
|
|
void OctaveShift::setOctaveShiftPosition(OctaveShiftPosition position) {
|
|
octaveShiftPosition_ = position;
|
|
}
|
|
|
|
OctaveShiftPosition OctaveShift::getOctaveShiftPosition() const {
|
|
return octaveShiftPosition_;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
OctaveShiftEndPoint::OctaveShiftEndPoint() {
|
|
musicDataType_ = MusicDataType::OctaveShift_EndPoint;
|
|
|
|
octaveShiftType_ = OctaveShiftType::OS_8;
|
|
octaveShiftPosition_ = OctaveShiftPosition::Start;
|
|
endTick_ = 0;
|
|
}
|
|
|
|
void OctaveShiftEndPoint::setOctaveShiftType(OctaveShiftType type) {
|
|
octaveShiftType_ = type;
|
|
}
|
|
|
|
OctaveShiftType OctaveShiftEndPoint::getOctaveShiftType() const {
|
|
return octaveShiftType_;
|
|
}
|
|
|
|
void OctaveShiftEndPoint::setOctaveShiftPosition(OctaveShiftPosition position) {
|
|
octaveShiftPosition_ = position;
|
|
}
|
|
|
|
OctaveShiftPosition OctaveShiftEndPoint::getOctaveShiftPosition() const {
|
|
return octaveShiftPosition_;
|
|
}
|
|
|
|
void OctaveShiftEndPoint::setEndTick(int tick) {
|
|
endTick_ = tick;
|
|
}
|
|
|
|
int OctaveShiftEndPoint::getEndTick() const {
|
|
return endTick_;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
MultiMeasureRest::MultiMeasureRest() {
|
|
musicDataType_ = MusicDataType::Multi_Measure_Rest;
|
|
measureCount_ = 0;
|
|
}
|
|
|
|
void MultiMeasureRest::setMeasureCount(int count) {
|
|
measureCount_ = count;
|
|
}
|
|
|
|
int MultiMeasureRest::getMeasureCount() const {
|
|
return measureCount_;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
Tempo::Tempo() {
|
|
musicDataType_ = MusicDataType::Tempo;
|
|
|
|
leftNoteType_ = 3;
|
|
showMark_ = false;
|
|
showText_ = false;
|
|
showParenthesis_ = false;
|
|
typeTempo_ = 96;
|
|
leftText_ = QString();
|
|
rightText_ = QString();
|
|
swingEighth_ = false;
|
|
rightNoteType_ = 3;
|
|
leftNoteDot_ = false;
|
|
rightNoteDot_ = false;
|
|
rightSideType_ = 0;
|
|
}
|
|
|
|
void Tempo::setLeftNoteType(int type) {
|
|
leftNoteType_ = type;
|
|
}
|
|
|
|
NoteType Tempo::getLeftNoteType() const {
|
|
return (NoteType) leftNoteType_;
|
|
}
|
|
|
|
void Tempo::setShowMark(bool show) {
|
|
showMark_ = show;
|
|
}
|
|
|
|
bool Tempo::getShowMark() const {
|
|
return showMark_;
|
|
}
|
|
|
|
void Tempo::setShowBeforeText(bool show) {
|
|
showText_ = show;
|
|
}
|
|
|
|
bool Tempo::getShowBeforeText() const {
|
|
return showText_;
|
|
}
|
|
|
|
void Tempo::setShowParenthesis(bool show) {
|
|
showParenthesis_ = show;
|
|
}
|
|
|
|
bool Tempo::getShowParenthesis() const {
|
|
return showParenthesis_;
|
|
}
|
|
|
|
void Tempo::setTypeTempo(double tempo) {
|
|
typeTempo_ = tempo;
|
|
}
|
|
|
|
double Tempo::getTypeTempo() const {
|
|
return typeTempo_;
|
|
}
|
|
|
|
double Tempo::getQuarterTempo() const {
|
|
double factor = pow(2.0, int(NoteType::Note_Quarter) - int(getLeftNoteType()));
|
|
if (getLeftNoteDot())
|
|
factor *= 3.0/2.0;
|
|
double tempo = getTypeTempo() * factor;
|
|
|
|
return tempo;
|
|
}
|
|
|
|
void Tempo::setLeftText(const QString& str) {
|
|
leftText_ = str;
|
|
}
|
|
|
|
QString Tempo::getLeftText() const {
|
|
return leftText_;
|
|
}
|
|
|
|
void Tempo::setRightText(const QString& str) {
|
|
rightText_ = str;
|
|
}
|
|
|
|
QString Tempo::getRightText() const {
|
|
return rightText_;
|
|
}
|
|
|
|
void Tempo::setSwingEighth(bool swing) {
|
|
swingEighth_ = swing;
|
|
}
|
|
|
|
bool Tempo::getSwingEighth() const {
|
|
return swingEighth_;
|
|
}
|
|
|
|
void Tempo::setRightNoteType(int type) {
|
|
rightNoteType_ = type;
|
|
}
|
|
|
|
NoteType Tempo::getRightNoteType() const {
|
|
return (NoteType) rightNoteType_;
|
|
}
|
|
|
|
void Tempo::setLeftNoteDot(bool showDot) {
|
|
leftNoteDot_ = showDot;
|
|
}
|
|
|
|
bool Tempo::getLeftNoteDot() const {
|
|
return leftNoteDot_;
|
|
}
|
|
|
|
void Tempo::setRightNoteDot(bool showDot) {
|
|
rightNoteDot_ = showDot;
|
|
}
|
|
|
|
bool Tempo::getRightNoteDot() const {
|
|
return rightNoteDot_;
|
|
}
|
|
|
|
void Tempo::setRightSideType(int type) {
|
|
rightSideType_ = type;
|
|
}
|
|
|
|
int Tempo::getRightSideType() const {
|
|
return rightSideType_;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
Text::Text() {
|
|
musicDataType_ = MusicDataType::Text;
|
|
|
|
textType_ = Type::Rehearsal;
|
|
horiMargin_ = 8;
|
|
vertMargin_ = 8;
|
|
lineThick_ = 4;
|
|
text_ = QString();
|
|
width_ = 0;
|
|
height_ = 0;
|
|
}
|
|
|
|
void Text::setTextType(Type type) {
|
|
textType_ = type;
|
|
}
|
|
|
|
Text::Type Text::getTextType() const {
|
|
return textType_;
|
|
}
|
|
|
|
void Text::setHorizontalMargin(int margin) {
|
|
horiMargin_ = margin;
|
|
}
|
|
|
|
int Text::getHorizontalMargin() const {
|
|
return horiMargin_;
|
|
}
|
|
|
|
void Text::setVerticalMargin(int margin) {
|
|
vertMargin_ = margin;
|
|
}
|
|
|
|
int Text::getVerticalMargin() const {
|
|
return vertMargin_;
|
|
}
|
|
|
|
void Text::setLineThick(int thick) {
|
|
lineThick_ = thick;
|
|
}
|
|
|
|
int Text::getLineThick() const {
|
|
return lineThick_;
|
|
}
|
|
|
|
void Text::setText(const QString& text) {
|
|
text_ = text;
|
|
}
|
|
|
|
QString Text::getText() const {
|
|
return text_;
|
|
}
|
|
|
|
void Text::setWidth(int width) {
|
|
width_ = width;
|
|
}
|
|
|
|
int Text::getWidth() const {
|
|
return width_;
|
|
}
|
|
|
|
void Text::setHeight(int height) {
|
|
height_ = height;
|
|
}
|
|
|
|
int Text::getHeight() const {
|
|
return height_;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
TimeSignature::TimeSignature() {
|
|
numerator_ = 4;
|
|
denominator_ = 4;
|
|
isSymbol_ = false;
|
|
beatLength_ = 480;
|
|
barLength_ = 1920;
|
|
barLengthUnits_ = 0x400;
|
|
replaceFont_ = false;
|
|
showBeatGroup_ = false;
|
|
|
|
groupNumerator1_ = 0;
|
|
groupNumerator2_ = 0;
|
|
groupNumerator3_ = 0;
|
|
groupDenominator1_ = 4;
|
|
groupDenominator2_ = 4;
|
|
groupDenominator3_ = 4;
|
|
|
|
beamGroup1_ = 4;
|
|
beamGroup2_ = 0;
|
|
beamGroup3_ = 0;
|
|
beamGroup4_ = 0;
|
|
|
|
beamCount16th_ = 4;
|
|
beamCount32th_ = 1;
|
|
}
|
|
|
|
void TimeSignature::setNumerator(int numerator) {
|
|
numerator_ = numerator;
|
|
}
|
|
|
|
int TimeSignature::getNumerator() const {
|
|
return numerator_;
|
|
}
|
|
|
|
void TimeSignature::setDenominator(int denominator) {
|
|
denominator_ = denominator;
|
|
}
|
|
|
|
int TimeSignature::getDenominator() const {
|
|
return denominator_;
|
|
}
|
|
|
|
void TimeSignature::setIsSymbol(bool symbol) {
|
|
isSymbol_ = symbol;
|
|
}
|
|
|
|
bool TimeSignature::getIsSymbol() const {
|
|
if (numerator_ == 2 && denominator_ == 2) {
|
|
return true;
|
|
}
|
|
|
|
return isSymbol_;
|
|
}
|
|
|
|
void TimeSignature::setBeatLength(int length) {
|
|
beatLength_ = length;
|
|
}
|
|
|
|
int TimeSignature::getBeatLength() const {
|
|
return beatLength_;
|
|
}
|
|
|
|
void TimeSignature::setBarLength(int length) {
|
|
barLength_ = length;
|
|
}
|
|
|
|
int TimeSignature::getBarLength() const {
|
|
return barLength_;
|
|
}
|
|
|
|
void TimeSignature::addBeat(int startUnit, int lengthUnit, int startTick) {
|
|
BeatNode node;
|
|
node.startUnit_ = startUnit;
|
|
node.lengthUnit_ = lengthUnit;
|
|
node.startTick_ = startTick;
|
|
beats_.push_back(node);
|
|
}
|
|
|
|
void TimeSignature::endAddBeat() {
|
|
int i;
|
|
barLengthUnits_ = 0;
|
|
|
|
for (i = 0; i < beats_.size(); ++i) {
|
|
barLengthUnits_ += beats_[i].lengthUnit_;
|
|
}
|
|
}
|
|
|
|
int TimeSignature::getUnits() const {
|
|
return barLengthUnits_;
|
|
}
|
|
|
|
void TimeSignature::setReplaceFont(bool replace) {
|
|
replaceFont_ = replace;
|
|
}
|
|
|
|
bool TimeSignature::getReplaceFont() const {
|
|
return replaceFont_;
|
|
}
|
|
|
|
void TimeSignature::setShowBeatGroup(bool show) {
|
|
showBeatGroup_ = show;
|
|
}
|
|
|
|
bool TimeSignature::getShowBeatGroup() const {
|
|
return showBeatGroup_;
|
|
}
|
|
|
|
void TimeSignature::setGroupNumerator1(int numerator) {
|
|
groupNumerator1_ = numerator;
|
|
}
|
|
|
|
void TimeSignature::setGroupNumerator2(int numerator) {
|
|
groupNumerator2_ = numerator;
|
|
}
|
|
|
|
void TimeSignature::setGroupNumerator3(int numerator) {
|
|
groupNumerator3_ = numerator;
|
|
}
|
|
|
|
void TimeSignature::setGroupDenominator1(int denominator) {
|
|
groupDenominator1_ = denominator;
|
|
}
|
|
|
|
void TimeSignature::setGroupDenominator2(int denominator) {
|
|
groupDenominator2_ = denominator;
|
|
}
|
|
|
|
void TimeSignature::setGroupDenominator3(int denominator) {
|
|
groupDenominator3_ = denominator;
|
|
}
|
|
|
|
void TimeSignature::setBeamGroup1(int count) {
|
|
beamGroup1_ = count;
|
|
}
|
|
|
|
void TimeSignature::setBeamGroup2(int count) {
|
|
beamGroup2_ = count;
|
|
}
|
|
|
|
void TimeSignature::setBeamGroup3(int count) {
|
|
beamGroup3_ = count;
|
|
}
|
|
|
|
void TimeSignature::setBeamGroup4(int count) {
|
|
beamGroup4_ = count;
|
|
}
|
|
|
|
void TimeSignature::set16thBeamCount(int count) {
|
|
beamCount16th_ = count;
|
|
}
|
|
|
|
void TimeSignature::set32thBeamCount(int count) {
|
|
beamCount32th_ = count;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
Key::Key() {
|
|
key_ = 0;
|
|
set_ = false;
|
|
previousKey_ = 0;
|
|
symbolCount_ = 0;
|
|
}
|
|
|
|
void Key::setKey(int key) {
|
|
key_ = key;
|
|
set_ = true;
|
|
}
|
|
|
|
int Key::getKey() const {
|
|
return key_;
|
|
}
|
|
|
|
bool Key::getSetKey() const {
|
|
return set_;
|
|
}
|
|
|
|
void Key::setPreviousKey(int key) {
|
|
previousKey_ = key;
|
|
}
|
|
|
|
int Key::getPreviousKey() const {
|
|
return previousKey_;
|
|
}
|
|
|
|
void Key::setSymbolCount(int count) {
|
|
symbolCount_ = count;
|
|
}
|
|
|
|
int Key::getSymbolCount() const {
|
|
return symbolCount_;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
RepeatSymbol::RepeatSymbol() :
|
|
text_("#1"), repeatType_(RepeatType::Segno) {
|
|
musicDataType_ = MusicDataType::Repeat;
|
|
}
|
|
|
|
void RepeatSymbol::setText(const QString& text) {
|
|
text_ = text;
|
|
}
|
|
|
|
QString RepeatSymbol::getText() const {
|
|
return text_;
|
|
}
|
|
|
|
void RepeatSymbol::setRepeatType(int repeatType) {
|
|
repeatType_ = (RepeatType) repeatType;
|
|
}
|
|
|
|
RepeatType RepeatSymbol::getRepeatType() const {
|
|
return repeatType_;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
NumericEnding::NumericEnding() {
|
|
musicDataType_ = MusicDataType::Numeric_Ending;
|
|
|
|
height_ = 0;
|
|
text_ = QString();
|
|
numericHandle_ = new OffsetElement();
|
|
}
|
|
|
|
NumericEnding::~NumericEnding() {
|
|
delete numericHandle_;
|
|
}
|
|
|
|
OffsetElement* NumericEnding::getNumericHandle() const {
|
|
return numericHandle_;
|
|
}
|
|
|
|
void NumericEnding::setHeight(int height) {
|
|
height_ = height;
|
|
}
|
|
|
|
int NumericEnding::getHeight() const {
|
|
return height_;
|
|
}
|
|
|
|
void NumericEnding::setText(const QString& text) {
|
|
text_ = text;
|
|
}
|
|
|
|
QString NumericEnding::getText() const {
|
|
return text_;
|
|
}
|
|
|
|
QList<int> NumericEnding::getNumbers() const {
|
|
int i;
|
|
QStringList strs = text_.split(",", QString::SkipEmptyParts);
|
|
QList<int> endings;
|
|
|
|
for (i = 0; i < strs.size(); ++i) {
|
|
bool ok;
|
|
int num = strs[i].toInt(&ok);
|
|
endings.push_back(num);
|
|
}
|
|
|
|
return endings;
|
|
}
|
|
|
|
int NumericEnding::getJumpCount() const {
|
|
QList<int> numbers = getNumbers();
|
|
int count = 0;
|
|
|
|
for (int i = 0; i < numbers.size(); ++i) {
|
|
if ((int)i + 1 != numbers[i]) {
|
|
break;
|
|
}
|
|
|
|
count = i + 1;
|
|
}
|
|
|
|
return count;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
BarNumber::BarNumber() {
|
|
index_ = 0;
|
|
showOnParagraphStart_ = false;
|
|
align_ = 0;
|
|
showFlag_ = 1; // staff
|
|
barRange_ = 1; // can't be 0
|
|
prefix_ = QString();
|
|
}
|
|
|
|
void BarNumber::setIndex(int index) {
|
|
index_ = index;
|
|
}
|
|
|
|
int BarNumber::getIndex() const {
|
|
return index_;
|
|
}
|
|
|
|
void BarNumber::setShowOnParagraphStart(bool show) {
|
|
showOnParagraphStart_ = show;
|
|
}
|
|
|
|
bool BarNumber::getShowOnParagraphStart() const {
|
|
return showOnParagraphStart_;
|
|
}
|
|
|
|
void BarNumber::setAlign(int align)// 0:left, 1:center, 2:right
|
|
{
|
|
align_ = align;
|
|
}
|
|
|
|
int BarNumber::getAlign() const {
|
|
return align_;
|
|
}
|
|
|
|
void BarNumber::setShowFlag(int flag) {
|
|
showFlag_ = flag;
|
|
}
|
|
|
|
int BarNumber::getShowFlag() const {
|
|
return showFlag_;
|
|
}
|
|
|
|
void BarNumber::setShowEveryBarCount(int count) {
|
|
barRange_ = count;
|
|
}
|
|
|
|
int BarNumber::getShowEveryBarCount() const {
|
|
return barRange_;
|
|
}
|
|
|
|
void BarNumber::setPrefix(const QString& str) {
|
|
prefix_ = str;
|
|
}
|
|
|
|
QString BarNumber::getPrefix() const {
|
|
return prefix_;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
MidiController::MidiController() {
|
|
midiType_ = MidiType::Controller;
|
|
controller_ = 64; // pedal
|
|
value_ = 0;
|
|
}
|
|
|
|
void MidiController::setController(int number) {
|
|
controller_ = number;
|
|
}
|
|
|
|
int MidiController::getController() const {
|
|
return controller_;
|
|
}
|
|
|
|
void MidiController::setValue(int value) {
|
|
value_ = value;
|
|
}
|
|
|
|
int MidiController::getValue() const {
|
|
return value_;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
MidiProgramChange::MidiProgramChange() {
|
|
midiType_ = MidiType::Program_Change;
|
|
patch_ = 0; // grand piano
|
|
}
|
|
|
|
void MidiProgramChange::setPatch(int patch) {
|
|
patch_ = patch;
|
|
}
|
|
|
|
int MidiProgramChange::getPatch() const {
|
|
return patch_;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
MidiChannelPressure::MidiChannelPressure() :
|
|
pressure_(0) {
|
|
midiType_ = MidiType::Channel_Pressure;
|
|
}
|
|
|
|
void MidiChannelPressure::setPressure(int pressure) {
|
|
pressure_ = pressure;
|
|
}
|
|
|
|
int MidiChannelPressure::getPressure() const {
|
|
return pressure_;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
MidiPitchWheel::MidiPitchWheel() {
|
|
midiType_ = MidiType::Pitch_Wheel;
|
|
value_ = 0;
|
|
}
|
|
|
|
void MidiPitchWheel::setValue(int value) {
|
|
value_ = value;
|
|
}
|
|
|
|
int MidiPitchWheel::getValue() const {
|
|
return value_;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
Measure::Measure(int index) {
|
|
barNumber_ = new BarNumber();
|
|
barNumber_->setIndex(index);
|
|
time_ = new TimeSignature();
|
|
|
|
clear();
|
|
}
|
|
|
|
Measure::~Measure(){
|
|
clear();
|
|
|
|
delete barNumber_;
|
|
delete time_;
|
|
}
|
|
|
|
BarNumber* Measure::getBarNumber() const {
|
|
return barNumber_;
|
|
}
|
|
|
|
TimeSignature* Measure::getTime() const {
|
|
return time_;
|
|
}
|
|
|
|
void Measure::setLeftBarline(int barline) {
|
|
leftBarline_ = (BarLineType) barline;
|
|
}
|
|
|
|
BarLineType Measure::getLeftBarline() const {
|
|
return leftBarline_;
|
|
}
|
|
|
|
void Measure::setRightBarline(int barline) {
|
|
rightBarline_ = (BarLineType) barline;
|
|
}
|
|
|
|
BarLineType Measure::getRightBarline() const {
|
|
return rightBarline_;
|
|
}
|
|
|
|
void Measure::setBackwardRepeatCount(int repeatCount) {
|
|
repeatCount_ = repeatCount;
|
|
}
|
|
|
|
int Measure::getBackwardRepeatCount() const {
|
|
return repeatCount_;
|
|
}
|
|
|
|
void Measure::setTypeTempo(double tempo) {
|
|
typeTempo_ = tempo;
|
|
}
|
|
|
|
double Measure::getTypeTempo() const {
|
|
return typeTempo_;
|
|
}
|
|
|
|
void Measure::setIsPickup(bool pickup) {
|
|
pickup_ = pickup;
|
|
}
|
|
|
|
bool Measure::getIsPickup() const {
|
|
return pickup_;
|
|
}
|
|
|
|
void Measure::setIsMultiMeasureRest(bool rest) {
|
|
multiMeasureRest_ = rest;
|
|
}
|
|
|
|
bool Measure::getIsMultiMeasureRest() const {
|
|
return multiMeasureRest_;
|
|
}
|
|
|
|
void Measure::setMultiMeasureRestCount(int count) {
|
|
multiMeasureRestCount_ = count;
|
|
}
|
|
|
|
int Measure::getMultiMeasureRestCount() const {
|
|
return multiMeasureRestCount_;
|
|
}
|
|
|
|
void Measure::clear() {
|
|
leftBarline_ = BarLineType::Default;
|
|
rightBarline_ = BarLineType::Default;
|
|
repeatCount_ = 1;
|
|
typeTempo_ = 96.00;
|
|
setLength(0x780); //time = 4/4
|
|
pickup_ = false;
|
|
multiMeasureRest_ = false;
|
|
multiMeasureRestCount_ = 0;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
MeasureData::MeasureData() {
|
|
key_ = new Key();
|
|
clef_ = new Clef();
|
|
}
|
|
|
|
MeasureData::~MeasureData(){
|
|
int i;
|
|
for(i=0; i<musicDatas_.size(); ++i){
|
|
delete musicDatas_[i];
|
|
}
|
|
musicDatas_.clear();
|
|
|
|
// noteContainers_ also in musicDatas_, no need to destory
|
|
noteContainers_.clear();
|
|
|
|
// only delete at element start
|
|
for(i=0; i<crossMeasureElements_.size(); ++i){
|
|
if(crossMeasureElements_[i].second){
|
|
delete crossMeasureElements_[i].first;
|
|
}
|
|
}
|
|
crossMeasureElements_.clear();
|
|
|
|
for(i=0; i<midiDatas_.size(); ++i){
|
|
delete midiDatas_[i];
|
|
}
|
|
midiDatas_.clear();
|
|
|
|
delete key_;
|
|
delete clef_;
|
|
}
|
|
|
|
Key* MeasureData::getKey() const {
|
|
return key_;
|
|
}
|
|
|
|
Clef* MeasureData::getClef() const {
|
|
return clef_;
|
|
}
|
|
|
|
void MeasureData::addNoteContainer(NoteContainer* ptr) {
|
|
noteContainers_.push_back(ptr);
|
|
}
|
|
|
|
QList<NoteContainer*> MeasureData::getNoteContainers() const {
|
|
return noteContainers_;
|
|
}
|
|
|
|
void MeasureData::addMusicData(MusicData* ptr) {
|
|
musicDatas_.push_back(ptr);
|
|
}
|
|
|
|
QList<MusicData*> MeasureData::getMusicDatas(MusicDataType type) {
|
|
int i;
|
|
QList<MusicData*> notations;
|
|
|
|
for (i = 0; i < musicDatas_.size(); ++i) {
|
|
if (type == MusicDataType::None || musicDatas_[i]->getMusicDataType() == type) {
|
|
notations.push_back(musicDatas_[i]);
|
|
}
|
|
}
|
|
|
|
return notations;
|
|
}
|
|
|
|
void MeasureData::addCrossMeasureElement(MusicData* ptr, bool start) {
|
|
crossMeasureElements_.push_back(qMakePair(ptr, start));
|
|
}
|
|
|
|
QList<MusicData*> MeasureData::getCrossMeasureElements(
|
|
MusicDataType type, PairType pairType)
|
|
{
|
|
int i;
|
|
QList<MusicData*> pairs;
|
|
|
|
for (i = 0; i < crossMeasureElements_.size(); ++i) {
|
|
if ((type == MusicDataType::None || crossMeasureElements_[i].first->getMusicDataType() == type)
|
|
&& (pairType == PairType::All || ((crossMeasureElements_[i].second && pairType == PairType::Start)
|
|
|| (!crossMeasureElements_[i].second && pairType == PairType::Stop)))) {
|
|
pairs.push_back(crossMeasureElements_[i].first);
|
|
}
|
|
}
|
|
|
|
return pairs;
|
|
}
|
|
|
|
void MeasureData::addMidiData(MidiData* ptr) {
|
|
midiDatas_.push_back(ptr);
|
|
}
|
|
|
|
QList<MidiData*> MeasureData::getMidiDatas(MidiType type) {
|
|
int i;
|
|
QList<MidiData*> datas;
|
|
|
|
for (i = 0; i < midiDatas_.size(); ++i) {
|
|
if (type == MidiType::None || midiDatas_[i]->getMidiType() == type) {
|
|
datas.push_back(midiDatas_[i]);
|
|
}
|
|
}
|
|
|
|
return datas;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////
|
|
//////////////////////////////////////////////////////////////////////////////////////
|
|
StreamHandle::StreamHandle() :
|
|
size_(0), curPos_(0), point_(NULL) {
|
|
}
|
|
|
|
StreamHandle::StreamHandle(unsigned char* p, int size) :
|
|
size_(size), curPos_(0), point_(p) {
|
|
}
|
|
|
|
StreamHandle::~StreamHandle() {
|
|
point_ = NULL;
|
|
}
|
|
|
|
bool StreamHandle::read(char* buff, int size) {
|
|
if (point_ != NULL && curPos_ + size <= size_) {
|
|
memcpy(buff, point_ + curPos_, size);
|
|
curPos_ += size;
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool StreamHandle::write(char* /*buff*/, int /*size*/) {
|
|
return true;
|
|
}
|
|
|
|
// Block.cpp
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
Block::Block() {
|
|
doResize(0);
|
|
}
|
|
|
|
Block::Block(unsigned int count) {
|
|
doResize(count);
|
|
}
|
|
|
|
void Block::resize(unsigned int count) {
|
|
doResize(count);
|
|
}
|
|
|
|
void Block::doResize(unsigned int count) {
|
|
data_.clear();
|
|
for(unsigned int i=0; i<count; ++i) {
|
|
data_.push_back('\0');
|
|
}
|
|
//data_.resize(count);
|
|
}
|
|
|
|
const unsigned char* Block::data() const {
|
|
//return const_cast<unsigned char*>(&data_.front());
|
|
return &data_.front();
|
|
}
|
|
|
|
unsigned char* Block::data() {
|
|
return &data_.front();
|
|
}
|
|
|
|
int Block::size() const {
|
|
return data_.size();
|
|
}
|
|
|
|
bool Block::toBoolean() const {
|
|
if (data() == NULL) {
|
|
return false;
|
|
}
|
|
|
|
return size() == 1 && data()[0] == 0x01;
|
|
}
|
|
|
|
unsigned int Block::toUnsignedInt() const {
|
|
if (data() == NULL) {
|
|
return 0;
|
|
}
|
|
|
|
int num = 0;
|
|
|
|
for (int i = 0; i < (int)sizeof(int) && i < size(); ++i) {
|
|
num = (num << 8) + *(data() + i);
|
|
}
|
|
|
|
return num;
|
|
}
|
|
|
|
int Block::toInt() const {
|
|
if (data() == NULL) {
|
|
return 0;
|
|
}
|
|
|
|
int i;
|
|
int num = 0;
|
|
|
|
for (i = 0; i < (int)sizeof(int) && i < size(); ++i) {
|
|
num = (num << 8) + (int) *(data() + i);
|
|
}
|
|
|
|
std::size_t minSize = sizeof(int);
|
|
if (size() < (int)minSize) {
|
|
minSize = size();
|
|
}
|
|
|
|
if ((*(data()) & 0x80) == 0x80) {
|
|
int maxNum = int(pow(2.0, (int) minSize * 8));
|
|
num -= maxNum;
|
|
//num *= -1;
|
|
}
|
|
|
|
return num;
|
|
}
|
|
|
|
QByteArray Block::toStrByteArray() const {
|
|
if (data() == NULL) {
|
|
return QByteArray();
|
|
}
|
|
|
|
QByteArray arr((char*) data(), size());
|
|
|
|
return arr;
|
|
}
|
|
|
|
QByteArray Block::fixedSizeBufferToStrByteArray() const {
|
|
QByteArray str;
|
|
|
|
for (int i = 0; i < size(); ++i) {
|
|
if (*(data() + i) == '\0') {
|
|
break;
|
|
}
|
|
|
|
str += (char) *(data() + i);
|
|
}
|
|
|
|
return str;
|
|
}
|
|
|
|
bool Block::operator ==(const Block& block) const {
|
|
if (size() != block.size()) {
|
|
return false;
|
|
}
|
|
|
|
for (int i = 0; i < size() && i < block.size(); ++i) {
|
|
if (*(data() + i) != *(block.data() + i)) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool Block::operator !=(const Block& block) const {
|
|
return !(*this == block);
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
FixedBlock::FixedBlock() :
|
|
Block() {
|
|
}
|
|
|
|
FixedBlock::FixedBlock(unsigned int count) :
|
|
Block(count) {
|
|
}
|
|
|
|
void FixedBlock::resize(unsigned int /*count*/) {
|
|
// Block::resize(size);
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
SizeBlock::SizeBlock() :
|
|
FixedBlock(4) {
|
|
}
|
|
|
|
unsigned int SizeBlock::toSize() const {
|
|
unsigned int i;
|
|
unsigned int num(0);
|
|
const unsigned int SIZE = 4;
|
|
|
|
for (i = 0; i < SIZE; ++i) {
|
|
num = (num << 8) + *(data() + i);
|
|
}
|
|
|
|
return num;
|
|
}
|
|
|
|
/*void SizeBlock::fromUnsignedInt(unsigned int count)
|
|
{
|
|
unsigned_int_to_char_buffer(count, data());
|
|
}*/
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
NameBlock::NameBlock() :
|
|
FixedBlock(4) {
|
|
}
|
|
|
|
/*void NameBlock::setValue(const char* const name)
|
|
{
|
|
unsigned int i;
|
|
|
|
for( i=0; i<size() && *(name+i)!='\0'; ++i )
|
|
{
|
|
*(data()+i) = *(name+i);
|
|
}
|
|
}*/
|
|
|
|
bool NameBlock::isEqual(const QString& name) const {
|
|
int nsize = name.size();
|
|
|
|
if (nsize != size()) {
|
|
return false;
|
|
}
|
|
|
|
for (int i = 0; i < size() && nsize; ++i) {
|
|
if (data()[i] != name[i]) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
CountBlock::CountBlock() :
|
|
FixedBlock(2) {
|
|
}
|
|
|
|
/*void CountBlock::setValue(unsigned short count)
|
|
{
|
|
unsigned int i;
|
|
unsigned int SIZE = sizeof(unsigned short);
|
|
|
|
for( i=0; i<SIZE; ++i )
|
|
{
|
|
data()[SIZE-1-i] = count % 256;
|
|
count /= 256;
|
|
}
|
|
}*/
|
|
|
|
unsigned short CountBlock::toCount() const {
|
|
unsigned short num = 0;
|
|
|
|
for (int i = 0; i < size() && i < (int)sizeof(unsigned short); ++i) {
|
|
num = (num << 8) + *(data() + i);
|
|
}
|
|
|
|
return num;
|
|
}
|
|
|
|
// Chunk.cpp
|
|
const QString Chunk::TrackName = "TRAK";
|
|
const QString Chunk::PageName = "PAGE";
|
|
const QString Chunk::LineName = "LINE";
|
|
const QString Chunk::StaffName = "STAF";
|
|
const QString Chunk::MeasureName = "MEAS";
|
|
const QString Chunk::ConductName = "COND";
|
|
const QString Chunk::BdatName = "BDAT";
|
|
|
|
Chunk::Chunk() {
|
|
}
|
|
|
|
NameBlock Chunk::getName() const {
|
|
return nameBlock_;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
const unsigned int SizeChunk::version3TrackSize = 0x13a;
|
|
|
|
SizeChunk::SizeChunk() :
|
|
Chunk() {
|
|
sizeBlock_ = new SizeBlock();
|
|
dataBlock_ = new Block();
|
|
}
|
|
|
|
SizeChunk::~SizeChunk() {
|
|
delete sizeBlock_;
|
|
delete dataBlock_;
|
|
}
|
|
|
|
SizeBlock* SizeChunk::getSizeBlock() const {
|
|
return sizeBlock_;
|
|
}
|
|
|
|
Block* SizeChunk::getDataBlock() const {
|
|
return dataBlock_;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////
|
|
GroupChunk::GroupChunk() : Chunk() {
|
|
childCount_ = new CountBlock();
|
|
}
|
|
|
|
GroupChunk::~GroupChunk() {
|
|
delete childCount_;
|
|
}
|
|
|
|
CountBlock* GroupChunk::getCountBlock() const {
|
|
return childCount_;
|
|
}
|
|
|
|
// ChunkParse.cpp
|
|
unsigned int getHighNibble(unsigned int byte) {
|
|
return byte / 16;
|
|
}
|
|
|
|
unsigned int getLowNibble(unsigned int byte) {
|
|
return byte % 16;
|
|
}
|
|
|
|
int oveKeyToKey(int oveKey) {
|
|
int key = 0;
|
|
|
|
if( oveKey == 0 ) {
|
|
key = 0;
|
|
}
|
|
else if( oveKey > 7 ) {
|
|
key = oveKey - 7;
|
|
}
|
|
else if( oveKey <= 7 ) {
|
|
key = oveKey * (-1);
|
|
}
|
|
|
|
return key;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
BasicParse::BasicParse(OveSong* ove) :
|
|
ove_(ove), handle_(NULL), notify_(NULL) {
|
|
}
|
|
|
|
BasicParse::BasicParse() :
|
|
ove_(NULL), handle_(NULL), notify_(NULL) {
|
|
}
|
|
|
|
BasicParse::~BasicParse() {
|
|
ove_ = NULL;
|
|
handle_ = NULL;
|
|
notify_ = NULL;
|
|
}
|
|
|
|
void BasicParse::setNotify(IOveNotify* notify) {
|
|
notify_ = notify;
|
|
}
|
|
|
|
bool BasicParse::parse() {
|
|
return false;
|
|
}
|
|
|
|
bool BasicParse::readBuffer(Block& placeHolder, int size) {
|
|
if (handle_ == NULL) {
|
|
return false;
|
|
}
|
|
if (placeHolder.size() != size) {
|
|
placeHolder.resize(size);
|
|
}
|
|
|
|
if (size > 0) {
|
|
return handle_->read((char*) placeHolder.data(), placeHolder.size());
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool BasicParse::jump(int offset) {
|
|
if (handle_ == NULL || offset < 0) {
|
|
return false;
|
|
}
|
|
|
|
if (offset > 0) {
|
|
Block placeHolder(offset);
|
|
return handle_->read((char*) placeHolder.data(), placeHolder.size());
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void BasicParse::messageOut(const QString& str) {
|
|
if (notify_ != NULL) {
|
|
notify_->loadInfo(str);
|
|
}
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
OvscParse::OvscParse(OveSong* ove) :
|
|
BasicParse(ove), chunk_(NULL) {
|
|
}
|
|
|
|
OvscParse::~OvscParse() {
|
|
chunk_ = NULL;
|
|
}
|
|
|
|
void OvscParse::setOvsc(SizeChunk* chunk) {
|
|
chunk_ = chunk;
|
|
}
|
|
|
|
bool OvscParse::parse() {
|
|
Block* dataBlock = chunk_->getDataBlock();
|
|
unsigned int blockSize = chunk_->getSizeBlock()->toSize();
|
|
StreamHandle handle(dataBlock->data(), blockSize);
|
|
Block placeHolder;
|
|
|
|
handle_ = &handle;
|
|
|
|
// version
|
|
if (!readBuffer(placeHolder, 1)) { return false; }
|
|
bool version4 = placeHolder.toUnsignedInt() == 4;
|
|
ove_->setIsVersion4(version4);
|
|
|
|
QString str = QString("This file is created by Overture ") + (version4 ? "4" : "3") + "\n";
|
|
messageOut(str);
|
|
|
|
if( !jump(6) ) { return false; }
|
|
|
|
// show page margin
|
|
if (!readBuffer(placeHolder, 1)) { return false; }
|
|
ove_->setShowPageMargin(placeHolder.toBoolean());
|
|
|
|
if( !jump(1) ) { return false; }
|
|
|
|
// transpose track
|
|
if (!readBuffer(placeHolder, 1)) { return false; }
|
|
ove_->setShowTransposeTrack(placeHolder.toBoolean());
|
|
|
|
// play repeat
|
|
if (!readBuffer(placeHolder, 1)) { return false; }
|
|
ove_->setPlayRepeat(placeHolder.toBoolean());
|
|
|
|
// play style
|
|
if (!readBuffer(placeHolder, 1)) { return false; }
|
|
OveSong::PlayStyle style = OveSong::PlayStyle::Record;
|
|
if(placeHolder.toUnsignedInt() == 1){
|
|
style = OveSong::PlayStyle::Swing;
|
|
}
|
|
else if(placeHolder.toUnsignedInt() == 2){
|
|
style = OveSong::PlayStyle::Notation;
|
|
}
|
|
ove_->setPlayStyle(style);
|
|
|
|
// show line break
|
|
if (!readBuffer(placeHolder, 1)) { return false; }
|
|
ove_->setShowLineBreak(placeHolder.toBoolean());
|
|
|
|
// show ruler
|
|
if (!readBuffer(placeHolder, 1)) { return false; }
|
|
ove_->setShowRuler(placeHolder.toBoolean());
|
|
|
|
// show color
|
|
if (!readBuffer(placeHolder, 1)) { return false; }
|
|
ove_->setShowColor(placeHolder.toBoolean());
|
|
|
|
return true;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
TrackParse::TrackParse(OveSong* ove)
|
|
:BasicParse(ove) {
|
|
}
|
|
|
|
TrackParse::~TrackParse() {
|
|
}
|
|
|
|
void TrackParse::setTrack(SizeChunk* chunk) {
|
|
chunk_ = chunk;
|
|
}
|
|
|
|
bool TrackParse::parse() {
|
|
Block* dataBlock = chunk_->getDataBlock();
|
|
unsigned int blockSize = ove_->getIsVersion4() ? chunk_->getSizeBlock()->toSize() : SizeChunk::version3TrackSize;
|
|
StreamHandle handle(dataBlock->data(), blockSize);
|
|
Block placeHolder;
|
|
|
|
handle_ = &handle;
|
|
|
|
Track* oveTrack = new Track();
|
|
ove_->addTrack(oveTrack);
|
|
|
|
// 2 32bytes long track name buffer
|
|
if( !readBuffer(placeHolder, 32) ) { return false; }
|
|
oveTrack->setName(ove_->getCodecString(placeHolder.fixedSizeBufferToStrByteArray()));
|
|
|
|
if( !readBuffer(placeHolder, 32) ) { return false; }
|
|
oveTrack->setBriefName(ove_->getCodecString(placeHolder.fixedSizeBufferToStrByteArray()));
|
|
|
|
if( !jump(8) ) { return false; } //0x fffa0012 fffa0012
|
|
if( !jump(1) ) { return false; }
|
|
|
|
// patch
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
unsigned int thisByte = placeHolder.toInt();
|
|
oveTrack->setPatch(thisByte&0x7f);
|
|
|
|
// show name
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
oveTrack->setShowName(placeHolder.toBoolean());
|
|
|
|
// show brief name
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
oveTrack->setShowBriefName(placeHolder.toBoolean());
|
|
|
|
if( !jump(1) ) { return false; }
|
|
|
|
// show transpose
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
oveTrack->setShowTranspose(placeHolder.toBoolean());
|
|
|
|
if( !jump(1) ) { return false; }
|
|
|
|
// mute
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
oveTrack->setMute(placeHolder.toBoolean());
|
|
|
|
// solo
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
oveTrack->setSolo(placeHolder.toBoolean());
|
|
|
|
if( !jump(1) ) { return false; }
|
|
|
|
// show key each line
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
oveTrack->setShowKeyEachLine(placeHolder.toBoolean());
|
|
|
|
// voice count
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
oveTrack->setVoiceCount(placeHolder.toUnsignedInt());
|
|
|
|
if( !jump(3) ) { return false; }
|
|
|
|
// transpose value [-127, 127]
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
oveTrack->setTranspose(placeHolder.toInt());
|
|
|
|
if( !jump(2) ) { return false; }
|
|
|
|
// start clef
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
oveTrack->setStartClef(placeHolder.toUnsignedInt());
|
|
|
|
// transpose celf
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
oveTrack->setTransposeClef(placeHolder.toUnsignedInt());
|
|
|
|
// start key
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
oveTrack->setStartKey(placeHolder.toUnsignedInt());
|
|
|
|
// display percent
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
oveTrack->setDisplayPercent(placeHolder.toUnsignedInt());
|
|
|
|
// show leger line
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
oveTrack->setShowLegerLine(placeHolder.toBoolean());
|
|
|
|
// show clef
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
oveTrack->setShowClef(placeHolder.toBoolean());
|
|
|
|
// show time signature
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
oveTrack->setShowTimeSignature(placeHolder.toBoolean());
|
|
|
|
// show key signature
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
oveTrack->setShowKeySignature(placeHolder.toBoolean());
|
|
|
|
// show barline
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
oveTrack->setShowBarline(placeHolder.toBoolean());
|
|
|
|
// fill with rest
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
oveTrack->setFillWithRest(placeHolder.toBoolean());
|
|
|
|
// flat tail
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
oveTrack->setFlatTail(placeHolder.toBoolean());
|
|
|
|
// show clef each line
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
oveTrack->setShowClefEachLine(placeHolder.toBoolean());
|
|
|
|
if( !jump(12) ) { return false; }
|
|
|
|
// 8 voices
|
|
int i;
|
|
QList<Voice*> voices;
|
|
for( i=0; i<8; ++i ) {
|
|
Voice* voicePtr = new Voice();
|
|
|
|
if( !jump(5) ) { return false; }
|
|
|
|
// channel
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
voicePtr->setChannel(placeHolder.toUnsignedInt());
|
|
|
|
// volume
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
voicePtr->setVolume(placeHolder.toInt());
|
|
|
|
// pitch shift
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
voicePtr->setPitchShift(placeHolder.toInt());
|
|
|
|
// pan
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
voicePtr->setPan(placeHolder.toInt());
|
|
|
|
if( !jump(6) ) { return false; }
|
|
|
|
// patch
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
voicePtr->setPatch(placeHolder.toInt());
|
|
|
|
voices.push_back(voicePtr);
|
|
}
|
|
|
|
// stem type
|
|
for( i=0; i<8; ++i ) {
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
voices[i]->setStemType(placeHolder.toUnsignedInt());
|
|
|
|
oveTrack->addVoice(voices[i]);
|
|
}
|
|
|
|
// percussion define
|
|
QList<Track::DrumNode> nodes;
|
|
for(i=0; i<16; ++i) {
|
|
nodes.push_back(Track::DrumNode());
|
|
}
|
|
|
|
// line
|
|
for( i=0; i<16; ++i ) {
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
nodes[i].line_ = placeHolder.toInt();
|
|
}
|
|
|
|
// head type
|
|
for( i=0; i<16; ++i ) {
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
nodes[i].headType_ = placeHolder.toUnsignedInt();
|
|
}
|
|
|
|
// pitch
|
|
for( i=0; i<16; ++i ) {
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
nodes[i].pitch_ = placeHolder.toUnsignedInt();
|
|
}
|
|
|
|
// voice
|
|
for( i=0; i<16; ++i ) {
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
nodes[i].voice_ = placeHolder.toUnsignedInt();
|
|
}
|
|
|
|
for( i=0; i<nodes.size(); ++i ) {
|
|
oveTrack->addDrum(nodes[i]);
|
|
}
|
|
|
|
/* if( !Jump(17) ) { return false; }
|
|
|
|
// voice 0 channel
|
|
if( !ReadBuffer(placeHolder, 1) ) { return false; }
|
|
oveTrack->setChannel(placeHolder.toUnsignedInt());
|
|
|
|
// to be continued. if anything important...*/
|
|
|
|
return true;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
GroupParse::GroupParse(OveSong* ove)
|
|
:BasicParse(ove) {
|
|
}
|
|
|
|
GroupParse::~GroupParse(){
|
|
sizeChunks_.clear();
|
|
}
|
|
|
|
void GroupParse::addSizeChunk(SizeChunk* sizeChunk) {
|
|
sizeChunks_.push_back(sizeChunk);
|
|
}
|
|
|
|
bool GroupParse::parse() {
|
|
return false;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
PageGroupParse::PageGroupParse(OveSong* ove)
|
|
:BasicParse(ove) {
|
|
}
|
|
|
|
PageGroupParse::~PageGroupParse(){
|
|
pageChunks_.clear();
|
|
}
|
|
|
|
void PageGroupParse::addPage(SizeChunk* chunk) {
|
|
pageChunks_.push_back(chunk);
|
|
}
|
|
|
|
bool PageGroupParse::parse() {
|
|
if( pageChunks_.isEmpty() ) {
|
|
return false;
|
|
}
|
|
|
|
int i;
|
|
for( i=0; i<pageChunks_.size(); ++i ) {
|
|
Page* page = new Page();
|
|
ove_->addPage(page);
|
|
|
|
if( !parsePage(pageChunks_[i], page) ) { return false; }
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool PageGroupParse::parsePage(SizeChunk* chunk, Page* page) {
|
|
Block placeHolder(2);
|
|
StreamHandle handle(chunk->getDataBlock()->data(), chunk->getSizeBlock()->toSize());
|
|
|
|
handle_ = &handle;
|
|
|
|
// begin line
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
page->setBeginLine(placeHolder.toUnsignedInt());
|
|
|
|
// line count
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
page->setLineCount(placeHolder.toUnsignedInt());
|
|
|
|
if( !jump(4) ) { return false; }
|
|
|
|
// staff interval
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
page->setStaffInterval(placeHolder.toUnsignedInt());
|
|
|
|
// line interval
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
page->setLineInterval(placeHolder.toUnsignedInt());
|
|
|
|
// staff inline interval
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
page->setStaffInlineInterval(placeHolder.toUnsignedInt());
|
|
|
|
// line bar count
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
page->setLineBarCount(placeHolder.toUnsignedInt());
|
|
|
|
// page line count
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
page->setPageLineCount(placeHolder.toUnsignedInt());
|
|
|
|
// left margin
|
|
if( !readBuffer(placeHolder, 4) ) { return false; }
|
|
page->setLeftMargin(placeHolder.toUnsignedInt());
|
|
|
|
// top margin
|
|
if( !readBuffer(placeHolder, 4) ) { return false; }
|
|
page->setTopMargin(placeHolder.toUnsignedInt());
|
|
|
|
// right margin
|
|
if( !readBuffer(placeHolder, 4) ) { return false; }
|
|
page->setRightMargin(placeHolder.toUnsignedInt());
|
|
|
|
// bottom margin
|
|
if( !readBuffer(placeHolder, 4) ) { return false; }
|
|
page->setBottomMargin(placeHolder.toUnsignedInt());
|
|
|
|
// page width
|
|
if( !readBuffer(placeHolder, 4) ) { return false; }
|
|
page->setPageWidth(placeHolder.toUnsignedInt());
|
|
|
|
// page height
|
|
if( !readBuffer(placeHolder, 4) ) { return false; }
|
|
page->setPageHeight(placeHolder.toUnsignedInt());
|
|
|
|
handle_ = NULL;
|
|
|
|
return true;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
StaffCountGetter::StaffCountGetter(OveSong* ove)
|
|
:BasicParse(ove) {
|
|
}
|
|
|
|
unsigned int StaffCountGetter::getStaffCount(SizeChunk* chunk) {
|
|
StreamHandle handle(chunk->getDataBlock()->data(), chunk->getSizeBlock()->toSize());
|
|
Block placeHolder;
|
|
|
|
handle_ = &handle;
|
|
|
|
if( !jump(6) ) { return false; }
|
|
|
|
// staff count
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
return placeHolder.toUnsignedInt();
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
LineGroupParse::LineGroupParse(OveSong* ove) :
|
|
BasicParse(ove), chunk_(NULL) {
|
|
}
|
|
|
|
LineGroupParse::~LineGroupParse(){
|
|
chunk_ = NULL;
|
|
lineChunks_.clear();
|
|
staffChunks_.clear();
|
|
}
|
|
|
|
void LineGroupParse::setLineGroup(GroupChunk* chunk) {
|
|
chunk_ = chunk;
|
|
}
|
|
|
|
void LineGroupParse::addLine(SizeChunk* chunk) {
|
|
lineChunks_.push_back(chunk);
|
|
}
|
|
|
|
void LineGroupParse::addStaff(SizeChunk* chunk) {
|
|
staffChunks_.push_back(chunk);
|
|
}
|
|
|
|
bool LineGroupParse::parse() {
|
|
if( lineChunks_.isEmpty() || staffChunks_.size() % lineChunks_.size() != 0 ) { return false; }
|
|
|
|
int i;
|
|
unsigned int j;
|
|
unsigned int lineStaffCount = staffChunks_.size() / lineChunks_.size();
|
|
|
|
for( i=0; i<lineChunks_.size(); ++i ) {
|
|
Line* linePtr = new Line();
|
|
|
|
ove_->addLine(linePtr);
|
|
|
|
if( !parseLine(lineChunks_[i], linePtr) ) { return false; }
|
|
|
|
for( j=lineStaffCount*i; j<lineStaffCount*(i+1); ++j ) {
|
|
Staff* staffPtr = new Staff();
|
|
|
|
linePtr->addStaff(staffPtr);
|
|
|
|
if( !parseStaff(staffChunks_[j], staffPtr) ) { return false; }
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool LineGroupParse::parseLine(SizeChunk* chunk, Line* line) {
|
|
Block placeHolder;
|
|
|
|
StreamHandle handle(chunk->getDataBlock()->data(), chunk->getSizeBlock()->toSize());
|
|
|
|
handle_ = &handle;
|
|
|
|
if( !jump(2) ) { return false; }
|
|
|
|
// begin bar
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
line->setBeginBar(placeHolder.toUnsignedInt());
|
|
|
|
// bar count
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
line->setBarCount(placeHolder.toUnsignedInt());
|
|
|
|
if( !jump(6) ) { return false; }
|
|
|
|
// y offset
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
line->setYOffset(placeHolder.toInt());
|
|
|
|
// left x offset
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
line->setLeftXOffset(placeHolder.toInt());
|
|
|
|
// right x offset
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
line->setRightXOffset(placeHolder.toInt());
|
|
|
|
if( !jump(4) ) { return false; }
|
|
|
|
handle_ = NULL;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool LineGroupParse::parseStaff(SizeChunk* chunk, Staff* staff) {
|
|
Block placeHolder;
|
|
|
|
StreamHandle handle(chunk->getDataBlock()->data(), chunk->getSizeBlock()->toSize());
|
|
|
|
handle_ = &handle;
|
|
|
|
if( !jump(7) ) { return false; }
|
|
|
|
// clef
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
staff->setClefType(placeHolder.toUnsignedInt());
|
|
|
|
// key
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
staff->setKeyType(oveKeyToKey(placeHolder.toUnsignedInt()));
|
|
|
|
if( !jump(2) ) { return false; }
|
|
|
|
// visible
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
staff->setVisible(placeHolder.toBoolean());
|
|
|
|
if( !jump(12) ) { return false; }
|
|
|
|
// y offset
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
staff->setYOffset(placeHolder.toInt());
|
|
|
|
int jumpAmount = ove_->getIsVersion4() ? 26 : 18;
|
|
if( !jump(jumpAmount) ) { return false; }
|
|
|
|
// group type
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
GroupType groupType = GroupType::None;
|
|
if(placeHolder.toUnsignedInt() == 1) {
|
|
groupType = GroupType::Brace;
|
|
} else if(placeHolder.toUnsignedInt() == 2) {
|
|
groupType = GroupType::Bracket;
|
|
}
|
|
staff->setGroupType(groupType);
|
|
|
|
// group staff count
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
staff->setGroupStaffCount(placeHolder.toUnsignedInt());
|
|
|
|
handle_ = NULL;
|
|
|
|
return true;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
BarsParse::BarsParse(OveSong* ove) :
|
|
BasicParse(ove) {
|
|
}
|
|
|
|
BarsParse::~BarsParse(){
|
|
measureChunks_.clear();
|
|
conductChunks_.clear();
|
|
bdatChunks_.clear();
|
|
}
|
|
|
|
void BarsParse::addMeasure(SizeChunk* chunk) {
|
|
measureChunks_.push_back(chunk);
|
|
}
|
|
|
|
void BarsParse::addConduct(SizeChunk* chunk) {
|
|
conductChunks_.push_back(chunk);
|
|
}
|
|
|
|
void BarsParse::addBdat(SizeChunk* chunk) {
|
|
bdatChunks_.push_back(chunk);
|
|
}
|
|
|
|
bool BarsParse::parse() {
|
|
int i;
|
|
int trackMeasureCount = ove_->getTrackBarCount();
|
|
int trackCount = ove_->getTrackCount();
|
|
int measureDataCount = trackCount * measureChunks_.size();
|
|
QList<Measure*> measures;
|
|
QList<MeasureData*> measureDatas;
|
|
|
|
if( measureChunks_.isEmpty() ||
|
|
measureChunks_.size() != conductChunks_.size() ||
|
|
(int)bdatChunks_.size() != measureDataCount ) {
|
|
return false;
|
|
}
|
|
|
|
// add to ove
|
|
for ( i=0; i<(int)measureChunks_.size(); ++i ) {
|
|
Measure* measure = new Measure(i);
|
|
|
|
measures.push_back(measure);
|
|
ove_->addMeasure(measure);
|
|
}
|
|
|
|
for ( i=0; i<measureDataCount; ++i ) {
|
|
MeasureData* oveMeasureData = new MeasureData();
|
|
|
|
measureDatas.push_back(oveMeasureData);
|
|
ove_->addMeasureData(oveMeasureData);
|
|
}
|
|
|
|
for( i=0; i<(int)measureChunks_.size(); ++i ) {
|
|
Measure* measure = measures[i];
|
|
|
|
// MEAS
|
|
if( !parseMeas(measure, measureChunks_[i]) ) {
|
|
QString ss = QString("failed in parse MEAS %1\n").arg(i);
|
|
messageOut(ss);
|
|
|
|
return false;
|
|
}
|
|
}
|
|
|
|
for( i=0; i<(int)conductChunks_.size(); ++i ) {
|
|
// COND
|
|
if( !parseCond(measures[i], measureDatas[i], conductChunks_[i]) ) {
|
|
QString ss = QString("failed in parse COND %1\n").arg(i);
|
|
messageOut(ss);
|
|
|
|
return false;
|
|
}
|
|
}
|
|
|
|
for( i=0; i<(int)bdatChunks_.size(); ++i ) {
|
|
int measId = i % trackMeasureCount;
|
|
|
|
// BDAT
|
|
if( !parseBdat(measures[measId], measureDatas[i], bdatChunks_[i]) ) {
|
|
QString ss = QString("failed in parse BDAT %1\n").arg(i);
|
|
messageOut(ss);
|
|
|
|
return false;
|
|
}
|
|
|
|
if( notify_ != NULL ) {
|
|
int measureID = i % trackMeasureCount;
|
|
int trackID = i / trackMeasureCount;
|
|
|
|
//msg.msg_ = OVE_IMPORT_POS;
|
|
//msg.param1_ = (measureID<<16) + trackMeasureCount;
|
|
//msg.param2_ = (trackID<<16) + trackCount;
|
|
|
|
notify_->loadPosition(measureID, trackMeasureCount, trackID, trackCount);
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool BarsParse::parseMeas(Measure* measure, SizeChunk* chunk) {
|
|
Block placeHolder;
|
|
|
|
StreamHandle measureHandle(chunk->getDataBlock()->data(), chunk->getSizeBlock()->toSize());
|
|
|
|
handle_ = &measureHandle;
|
|
|
|
if( !jump(2) ) { return false; }
|
|
|
|
// multi-measure rest
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
measure->setIsMultiMeasureRest(placeHolder.toBoolean());
|
|
|
|
// pickup
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
measure->setIsPickup(placeHolder.toBoolean());
|
|
|
|
if( !jump(4) ) { return false; }
|
|
|
|
// left barline
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
measure->setLeftBarline(placeHolder.toUnsignedInt());
|
|
|
|
// right barline
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
measure->setRightBarline(placeHolder.toUnsignedInt());
|
|
|
|
// tempo
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
double tempo = ((double)placeHolder.toUnsignedInt());
|
|
if( ove_->getIsVersion4() ) {
|
|
tempo /= 100.0;
|
|
}
|
|
measure->setTypeTempo(tempo);
|
|
|
|
// bar length(tick)
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
measure->setLength(placeHolder.toUnsignedInt());
|
|
|
|
if( !jump(6) ) { return false; }
|
|
|
|
// bar number offset
|
|
if( !parseOffsetElement(measure->getBarNumber()) ) { return false; }
|
|
|
|
if( !jump(2) ) { return false; }
|
|
|
|
// multi-measure rest count
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
measure->setMultiMeasureRestCount(placeHolder.toUnsignedInt());
|
|
|
|
handle_ = NULL;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool BarsParse::parseCond(Measure* measure, MeasureData* measureData, SizeChunk* chunk) {
|
|
Block placeHolder;
|
|
|
|
StreamHandle handle(chunk->getDataBlock()->data(), chunk->getSizeBlock()->toSize());
|
|
|
|
handle_ = &handle;
|
|
|
|
// item count
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
unsigned int cnt = placeHolder.toUnsignedInt();
|
|
|
|
if( !parseTimeSignature(measure, 36) ) { return false; }
|
|
|
|
for( unsigned int i=0; i<cnt; ++i ) {
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
unsigned int twoByte = placeHolder.toUnsignedInt();
|
|
unsigned int oldBlockSize = twoByte - 11;
|
|
unsigned int newBlockSize = twoByte - 7;
|
|
|
|
// type id
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
unsigned int thisByte = placeHolder.toUnsignedInt();
|
|
CondType type;
|
|
|
|
if( !getCondElementType(thisByte, type) ) { return false; }
|
|
|
|
switch (type) {
|
|
case CondType::Bar_Number: {
|
|
if (!parseBarNumber(measure, twoByte - 1)) {
|
|
return false;
|
|
}
|
|
break;
|
|
}
|
|
case CondType::Repeat: {
|
|
if (!parseRepeatSymbol(measureData, oldBlockSize)) {
|
|
return false;
|
|
}
|
|
break;
|
|
}
|
|
case CondType::Numeric_Ending: {
|
|
if (!parseNumericEndings(measureData, oldBlockSize)) {
|
|
return false;
|
|
}
|
|
break;
|
|
}
|
|
case CondType::Decorator: {
|
|
if (!parseDecorators(measureData, newBlockSize)) {
|
|
return false;
|
|
}
|
|
break;
|
|
}
|
|
case CondType::Tempo: {
|
|
if (!parseTempo(measureData, newBlockSize)) {
|
|
return false;
|
|
}
|
|
break;
|
|
}
|
|
case CondType::Text: {
|
|
if (!parseText(measureData, newBlockSize)) {
|
|
return false;
|
|
}
|
|
break;
|
|
}
|
|
case CondType::Expression: {
|
|
if (!parseExpressions(measureData, newBlockSize)) {
|
|
return false;
|
|
}
|
|
break;
|
|
}
|
|
case CondType::Time_Parameters: {
|
|
if (!parseTimeSignatureParameters(measure, newBlockSize)) {
|
|
return false;
|
|
}
|
|
break;
|
|
}
|
|
case CondType::Barline_Parameters: {
|
|
if (!parseBarlineParameters(measure, newBlockSize)) {
|
|
return false;
|
|
}
|
|
break;
|
|
}
|
|
default: {
|
|
if (!jump(newBlockSize)) {
|
|
return false;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
handle_ = NULL;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool BarsParse::parseTimeSignature(Measure* measure, int /*length*/) {
|
|
Block placeHolder;
|
|
|
|
TimeSignature* timeSignature = measure->getTime();
|
|
|
|
// numerator
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
timeSignature->setNumerator(placeHolder.toUnsignedInt());
|
|
|
|
// denominator
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
timeSignature->setDenominator(placeHolder.toUnsignedInt());
|
|
|
|
if( !jump(2) ) { return false; }
|
|
|
|
// beat length
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
timeSignature->setBeatLength(placeHolder.toUnsignedInt());
|
|
|
|
// bar length
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
timeSignature->setBarLength(placeHolder.toUnsignedInt());
|
|
|
|
if( !jump(4) ) { return false; }
|
|
|
|
// is symbol
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
timeSignature->setIsSymbol(placeHolder.toBoolean());
|
|
|
|
if( !jump(1) ) { return false; }
|
|
|
|
// replace font
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
timeSignature->setReplaceFont(placeHolder.toBoolean());
|
|
|
|
// color
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
timeSignature->setColor(placeHolder.toUnsignedInt());
|
|
|
|
// show
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
timeSignature->setShow(placeHolder.toBoolean());
|
|
|
|
// show beat group
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
timeSignature->setShowBeatGroup(placeHolder.toBoolean());
|
|
|
|
if( !jump(6) ) { return false; }
|
|
|
|
// numerator 1, 2, 3
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
timeSignature->setGroupNumerator1(placeHolder.toUnsignedInt());
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
timeSignature->setGroupNumerator2(placeHolder.toUnsignedInt());
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
timeSignature->setGroupNumerator3(placeHolder.toUnsignedInt());
|
|
|
|
// denominator
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
timeSignature->setGroupDenominator1(placeHolder.toUnsignedInt());
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
timeSignature->setGroupDenominator2(placeHolder.toUnsignedInt());
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
timeSignature->setGroupDenominator3(placeHolder.toUnsignedInt());
|
|
|
|
// beam group 1~4
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
timeSignature->setBeamGroup1(placeHolder.toUnsignedInt());
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
timeSignature->setBeamGroup2(placeHolder.toUnsignedInt());
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
timeSignature->setBeamGroup3(placeHolder.toUnsignedInt());
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
timeSignature->setBeamGroup4(placeHolder.toUnsignedInt());
|
|
|
|
// beam 16th
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
timeSignature->set16thBeamCount(placeHolder.toUnsignedInt());
|
|
|
|
// beam 32th
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
timeSignature->set32thBeamCount(placeHolder.toUnsignedInt());
|
|
|
|
return true;
|
|
}
|
|
|
|
bool BarsParse::parseTimeSignatureParameters(Measure* measure, int length) {
|
|
Block placeHolder;
|
|
TimeSignature* ts = measure->getTime();
|
|
|
|
int cursor = ove_->getIsVersion4() ? 10 : 8;
|
|
if( !jump(cursor) ) { return false; }
|
|
|
|
// numerator
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
unsigned int numerator = placeHolder.toUnsignedInt();
|
|
|
|
cursor = ove_->getIsVersion4() ? 11 : 9;
|
|
if( ( length - cursor ) % 8 != 0 || (length - cursor) / 8 != (int)numerator ) {
|
|
return false;
|
|
}
|
|
|
|
for( unsigned int i =0; i<numerator; ++i ) {
|
|
// beat start unit
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
int beatStart = placeHolder.toUnsignedInt();
|
|
|
|
// beat length unit
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
int beatLength = placeHolder.toUnsignedInt();
|
|
|
|
if( !jump(2) ) { return false; }
|
|
|
|
// beat start tick
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
int beatStartTick = placeHolder.toUnsignedInt();
|
|
|
|
ts->addBeat(beatStart, beatLength, beatStartTick);
|
|
}
|
|
|
|
ts->endAddBeat();
|
|
|
|
return true;
|
|
}
|
|
|
|
bool BarsParse::parseBarlineParameters(Measure* measure, int /*length*/) {
|
|
Block placeHolder;
|
|
|
|
int cursor = ove_->getIsVersion4() ? 12 : 10;
|
|
if( !jump(cursor) ) { return false; }
|
|
|
|
// repeat count
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
int repeatCount = placeHolder.toUnsignedInt();
|
|
|
|
measure->setBackwardRepeatCount(repeatCount);
|
|
|
|
if( !jump(6) ) { return false; }
|
|
|
|
return true;
|
|
}
|
|
|
|
bool BarsParse::parseNumericEndings(MeasureData* measureData, int /*length*/) {
|
|
Block placeHolder;
|
|
|
|
NumericEnding* numeric = new NumericEnding();
|
|
measureData->addCrossMeasureElement(numeric, true);
|
|
|
|
if( !jump(3) ) { return false; }
|
|
|
|
// common
|
|
if( !parseCommonBlock(numeric) ) { return false; }
|
|
|
|
if( !jump(6) ) { return false; }
|
|
|
|
// measure count
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
//int offsetMeasure = placeHolder.toUnsignedInt() - 1;
|
|
int offsetMeasure = placeHolder.toUnsignedInt();
|
|
numeric->stop()->setMeasure(offsetMeasure);
|
|
|
|
if( !jump(2) ) { return false; }
|
|
|
|
// left x offset
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
numeric->getLeftShoulder()->setXOffset(placeHolder.toInt());
|
|
|
|
// height
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
numeric->setHeight(placeHolder.toUnsignedInt());
|
|
|
|
// left x offset
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
numeric->getRightShoulder()->setXOffset(placeHolder.toInt());
|
|
|
|
if( !jump(2) ) { return false; }
|
|
|
|
// y offset
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
numeric->getLeftShoulder()->setYOffset(placeHolder.toInt());
|
|
numeric->getRightShoulder()->setYOffset(placeHolder.toInt());
|
|
|
|
// number offset
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
numeric->getNumericHandle()->setXOffset(placeHolder.toInt());
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
numeric->getNumericHandle()->setYOffset(placeHolder.toInt());
|
|
|
|
if( !jump(6) ) { return false; }
|
|
|
|
// text size
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
unsigned int size = placeHolder.toUnsignedInt();
|
|
|
|
// text : size maybe a huge value
|
|
if( !readBuffer(placeHolder, size) ) { return false; }
|
|
numeric->setText(ove_->getCodecString(placeHolder.fixedSizeBufferToStrByteArray()));
|
|
|
|
// fix for wedding march.ove
|
|
if( size % 2 == 0 ) {
|
|
if( !jump(1) ) { return false; }
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool BarsParse::parseTempo(MeasureData* measureData, int /*length*/) {
|
|
Block placeHolder;
|
|
unsigned int thisByte;
|
|
|
|
Tempo* tempo = new Tempo();
|
|
measureData->addMusicData(tempo);
|
|
if( !jump(3) )
|
|
return false;
|
|
// common
|
|
if( !parseCommonBlock(tempo) )
|
|
return false;
|
|
if( !readBuffer(placeHolder, 1) )
|
|
return false;
|
|
thisByte = placeHolder.toUnsignedInt();
|
|
// show tempo
|
|
tempo->setShowMark( (getHighNibble(thisByte) & 0x4) == 0x4 );
|
|
// show before text
|
|
tempo->setShowBeforeText( (getHighNibble(thisByte) & 0x8 ) == 0x8 ) ;
|
|
// show parenthesis
|
|
tempo->setShowParenthesis( (getHighNibble(thisByte) & 0x1 ) == 0x1 );
|
|
// left note type
|
|
tempo->setLeftNoteType( getLowNibble(thisByte) );
|
|
// left note dot
|
|
tempo->setLeftNoteDot((getHighNibble(thisByte) & 0x2 ) == 0x2 );
|
|
if( !jump(1) ) // dimension of the note symbol
|
|
return false;
|
|
if( ove_->getIsVersion4() ) {
|
|
if( !jump(2) )
|
|
return false;
|
|
// tempo
|
|
if( !readBuffer(placeHolder, 2) )
|
|
return false;
|
|
tempo->setTypeTempo(((double)placeHolder.toUnsignedInt())/100.0);
|
|
}
|
|
else {
|
|
// tempo
|
|
if( !readBuffer(placeHolder, 2) )
|
|
return false;
|
|
tempo->setTypeTempo((double)placeHolder.toUnsignedInt());
|
|
if( !jump(2) )
|
|
return false;
|
|
}
|
|
// offset
|
|
if( !parseOffsetElement(tempo) )
|
|
return false;
|
|
if( !jump(16) )
|
|
return false;
|
|
// 31 bytes left text
|
|
if( !readBuffer(placeHolder, 31) )
|
|
return false;
|
|
tempo->setLeftText(ove_->getCodecString(placeHolder.fixedSizeBufferToStrByteArray()));
|
|
|
|
if( !readBuffer(placeHolder, 1) )
|
|
return false;
|
|
thisByte = placeHolder.toUnsignedInt();
|
|
// swing eighth
|
|
tempo->setSwingEighth((getHighNibble(thisByte) & 0x4 ) == 0x4 );
|
|
// right note dot
|
|
tempo->setRightNoteDot((getHighNibble(thisByte) & 0x1 ) == 0x1 );
|
|
// compatibility with v3 files ?
|
|
tempo->setRightSideType((int)(getHighNibble(thisByte) & 0x2));
|
|
// right note type
|
|
tempo->setRightNoteType(getLowNibble(thisByte));
|
|
// right text
|
|
if( ove_->getIsVersion4() ) {
|
|
if( !readBuffer(placeHolder, 31) )
|
|
return false;
|
|
tempo->setRightText(ove_->getCodecString(placeHolder.fixedSizeBufferToStrByteArray()));
|
|
if( !readBuffer(placeHolder, 1) )
|
|
return false;
|
|
// 00 -> float 03 -> integer(floor) 01 -> notetype 02 -> text
|
|
tempo->setRightSideType(placeHolder.toInt());
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool BarsParse::parseBarNumber(Measure* measure, int /*length*/) {
|
|
Block placeHolder;
|
|
|
|
BarNumber* barNumber = measure->getBarNumber();
|
|
|
|
if( !jump(2) ) { return false; }
|
|
|
|
// show on paragraph start
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
barNumber->setShowOnParagraphStart(getLowNibble(placeHolder.toUnsignedInt())==8);
|
|
|
|
unsigned int blankSize = ove_->getIsVersion4() ? 9 : 7;
|
|
if( !jump(blankSize) ) { return false; }
|
|
|
|
// text align
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
barNumber->setAlign(placeHolder.toUnsignedInt());
|
|
|
|
if( !jump(4) ) { return false; }
|
|
|
|
// show flag
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
barNumber->setShowFlag(placeHolder.toUnsignedInt());
|
|
|
|
if( !jump(10) ) { return false; }
|
|
|
|
// bar range
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
barNumber->setShowEveryBarCount(placeHolder.toUnsignedInt());
|
|
|
|
// prefix
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
barNumber->setPrefix(ove_->getCodecString(placeHolder.fixedSizeBufferToStrByteArray()));
|
|
|
|
if( !jump(18) ) { return false; }
|
|
|
|
return true;
|
|
}
|
|
|
|
bool BarsParse::parseText(MeasureData* measureData, int length) {
|
|
Block placeHolder;
|
|
|
|
Text* text = new Text();
|
|
measureData->addMusicData(text);
|
|
|
|
if( !jump(3) ) { return false; }
|
|
|
|
// common
|
|
if( !parseCommonBlock(text) ) { return false; }
|
|
|
|
// type
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
unsigned int thisByte = placeHolder.toUnsignedInt();
|
|
bool includeLineBreak = ( (getHighNibble(thisByte)&0x2) != 0x2 );
|
|
unsigned int id = getLowNibble(thisByte);
|
|
Text::Type textType = Text::Type::Rehearsal;
|
|
|
|
if (id == 0) {
|
|
textType = Text::Type::MeasureText;
|
|
} else if (id == 1) {
|
|
textType = Text::Type::SystemText;
|
|
} else // id ==2
|
|
{
|
|
textType = Text::Type::Rehearsal;
|
|
}
|
|
|
|
text->setTextType(textType);
|
|
|
|
if( !jump(1) ) { return false; }
|
|
|
|
// x offset
|
|
if( !readBuffer(placeHolder, 4) ) { return false; }
|
|
text->setXOffset(placeHolder.toInt());
|
|
|
|
// y offset
|
|
if( !readBuffer(placeHolder, 4) ) { return false; }
|
|
text->setYOffset(placeHolder.toInt());
|
|
|
|
// width
|
|
if( !readBuffer(placeHolder, 4) ) { return false; }
|
|
text->setWidth(placeHolder.toUnsignedInt());
|
|
|
|
// height
|
|
if( !readBuffer(placeHolder, 4) ) { return false; }
|
|
text->setHeight(placeHolder.toUnsignedInt());
|
|
|
|
if( !jump(7) ) { return false; }
|
|
|
|
// horizontal margin
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
text->setHorizontalMargin(placeHolder.toUnsignedInt());
|
|
|
|
if( !jump(1) ) { return false; }
|
|
|
|
// vertical margin
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
text->setVerticalMargin(placeHolder.toUnsignedInt());
|
|
|
|
if( !jump(1) ) { return false; }
|
|
|
|
// line thick
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
text->setLineThick(placeHolder.toUnsignedInt());
|
|
|
|
if( !jump(2) ) { return false; }
|
|
|
|
// text size
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
unsigned int size = placeHolder.toUnsignedInt();
|
|
|
|
// text string, maybe huge
|
|
if( !readBuffer(placeHolder, size) ) { return false; }
|
|
text->setText(ove_->getCodecString(placeHolder.fixedSizeBufferToStrByteArray()));
|
|
|
|
if( !includeLineBreak ) {
|
|
if( !jump(6) ) { return false; }
|
|
} else {
|
|
unsigned int cursor = ove_->getIsVersion4() ? 43 : 41;
|
|
cursor += size;
|
|
|
|
// multi lines of text
|
|
for( unsigned int i=0; i<2; ++i ) {
|
|
if( (int)cursor < length ) {
|
|
// line parameters count
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
unsigned int lineCount = placeHolder.toUnsignedInt();
|
|
|
|
if( i==0 && int(cursor + 2 + 8*lineCount) > length ) {
|
|
return false;
|
|
}
|
|
|
|
if( i==1 && int(cursor + 2 + 8*lineCount) != length ) {
|
|
return false;
|
|
}
|
|
|
|
if( !jump(8*lineCount) ) { return false; }
|
|
|
|
cursor += 2 + 8*lineCount;
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool BarsParse::parseRepeatSymbol(MeasureData* measureData, int /*length*/) {
|
|
Block placeHolder;
|
|
|
|
RepeatSymbol* repeat = new RepeatSymbol();
|
|
measureData->addMusicData(repeat);
|
|
|
|
if( !jump(3) ) { return false; }
|
|
|
|
// common
|
|
if( !parseCommonBlock(repeat) ) { return false; }
|
|
|
|
// RepeatType
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
repeat->setRepeatType(placeHolder.toUnsignedInt());
|
|
|
|
if( !jump(13) ) { return false; }
|
|
|
|
// offset
|
|
if( !parseOffsetElement(repeat) ) { return false; }
|
|
|
|
if( !jump(15) ) { return false; }
|
|
|
|
// size
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
unsigned int size = placeHolder.toUnsignedInt();
|
|
|
|
// text, maybe huge
|
|
if( !readBuffer(placeHolder, size) ) { return false; }
|
|
repeat->setText(ove_->getCodecString(placeHolder.fixedSizeBufferToStrByteArray()));
|
|
|
|
// last 0
|
|
if( size % 2 == 0 ) {
|
|
if( !jump(1) ) { return false; }
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool BarsParse::parseBdat(Measure* /*measure*/, MeasureData* measureData, SizeChunk* chunk) {
|
|
Block placeHolder;
|
|
StreamHandle handle(chunk->getDataBlock()->data(), chunk->getSizeBlock()->toSize());
|
|
|
|
handle_ = &handle;
|
|
|
|
// parse here
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
unsigned int cnt = placeHolder.toUnsignedInt();
|
|
|
|
for( unsigned int i=0; i<cnt; ++i ) {
|
|
// 0x0028 or 0x0016 or 0x002C
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
unsigned int count = placeHolder.toUnsignedInt() - 7;
|
|
|
|
// type id
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
unsigned int thisByte = placeHolder.toUnsignedInt();
|
|
BdatType type;
|
|
|
|
if( !getBdatElementType(thisByte, type) ) { return false; }
|
|
|
|
switch( type ) {
|
|
case BdatType::Raw_Note :
|
|
case BdatType::Rest :
|
|
case BdatType::Note : {
|
|
if( !parseNoteRest(measureData, count, type) ) { return false; }
|
|
break;
|
|
}
|
|
case BdatType::Beam : {
|
|
if( !parseBeam(measureData, count) ) { return false; }
|
|
break;
|
|
}
|
|
case BdatType::Harmony : {
|
|
if( !parseHarmony(measureData, count) ) { return false; }
|
|
break;
|
|
}
|
|
case BdatType::Clef : {
|
|
if( !parseClef(measureData, count) ) { return false; }
|
|
break;
|
|
}
|
|
case BdatType::Dynamics : {
|
|
if( !parseDynamics(measureData, count) ) { return false; }
|
|
break;
|
|
}
|
|
case BdatType::Wedge : {
|
|
if( !parseWedge(measureData, count) ) { return false; }
|
|
break;
|
|
}
|
|
case BdatType::Glissando : {
|
|
if( !parseGlissando(measureData, count) ) { return false; }
|
|
break;
|
|
}
|
|
case BdatType::Decorator : {
|
|
if( !parseDecorators(measureData, count) ) { return false; }
|
|
break;
|
|
}
|
|
case BdatType::Key : {
|
|
if( !parseKey(measureData, count) ) { return false; }
|
|
break;
|
|
}
|
|
case BdatType::Lyric : {
|
|
if( !parseLyric(measureData, count) ) { return false; }
|
|
break;
|
|
}
|
|
case BdatType::Octave_Shift: {
|
|
if( !parseOctaveShift(measureData, count) ) { return false; }
|
|
break;
|
|
}
|
|
case BdatType::Slur : {
|
|
if( !parseSlur(measureData, count) ) { return false; }
|
|
break;
|
|
}
|
|
case BdatType::Text : {
|
|
if( !parseText(measureData, count) ) { return false; }
|
|
break;
|
|
}
|
|
case BdatType::Tie : {
|
|
if( !parseTie(measureData, count) ) { return false; }
|
|
break;
|
|
}
|
|
case BdatType::Tuplet : {
|
|
if( !parseTuplet(measureData, count) ) { return false; }
|
|
break;
|
|
}
|
|
case BdatType::Guitar_Bend :
|
|
case BdatType::Guitar_Barre : {
|
|
if( !parseSizeBlock(count) ) { return false; }
|
|
break;
|
|
}
|
|
case BdatType::Pedal: {
|
|
if( !parsePedal(measureData, count) ) { return false; }
|
|
break;
|
|
}
|
|
case BdatType::KuoHao: {
|
|
if( !parseKuohao(measureData, count) ) { return false; }
|
|
break;
|
|
}
|
|
case BdatType::Expressions: {
|
|
if( !parseExpressions(measureData, count) ) { return false; }
|
|
break;
|
|
}
|
|
case BdatType::Harp_Pedal: {
|
|
if( !parseHarpPedal(measureData, count) ) { return false; }
|
|
break;
|
|
}
|
|
case BdatType::Multi_Measure_Rest: {
|
|
if( !parseMultiMeasureRest(measureData, count) ) { return false; }
|
|
break;
|
|
}
|
|
case BdatType::Harmony_GuitarFrame: {
|
|
if( !parseHarmonyGuitarFrame(measureData, count) ) { return false; }
|
|
break;
|
|
}
|
|
case BdatType::Graphics_40:
|
|
case BdatType::Graphics_RoundRect:
|
|
case BdatType::Graphics_Rect:
|
|
case BdatType::Graphics_Round:
|
|
case BdatType::Graphics_Line:
|
|
case BdatType::Graphics_Curve:
|
|
case BdatType::Graphics_WedgeSymbol: {
|
|
if( !parseSizeBlock(count) ) { return false; }
|
|
break;
|
|
}
|
|
case BdatType::Midi_Controller : {
|
|
if( !parseMidiController(measureData, count) ) { return false; }
|
|
break;
|
|
}
|
|
case BdatType::Midi_Program_Change : {
|
|
if( !parseMidiProgramChange(measureData, count) ) { return false; }
|
|
break;
|
|
}
|
|
case BdatType::Midi_Channel_Pressure : {
|
|
if( !parseMidiChannelPressure(measureData, count) ) { return false; }
|
|
break;
|
|
}
|
|
case BdatType::Midi_Pitch_Wheel : {
|
|
if( !parseMidiPitchWheel(measureData, count) ) { return false; }
|
|
break;
|
|
}
|
|
default: {
|
|
if( !jump(count) ) { return false; }
|
|
break;
|
|
}
|
|
}
|
|
|
|
// if i==count-1 then is bar end place holder
|
|
}
|
|
|
|
handle_ = NULL;
|
|
|
|
return true;
|
|
}
|
|
|
|
int getInt(int byte, int bits) {
|
|
int num = 0;
|
|
|
|
if( bits > 0 ) {
|
|
int factor = int(pow(2.0, bits-1));
|
|
num = (byte % (factor*2));
|
|
|
|
if ( (byte & factor) == factor ) {
|
|
num -= factor*2;
|
|
}
|
|
}
|
|
|
|
return num;
|
|
}
|
|
|
|
bool BarsParse::parseNoteRest(MeasureData* measureData, int length, BdatType type) {
|
|
NoteContainer* container = new NoteContainer();
|
|
Block placeHolder;
|
|
unsigned int thisByte;
|
|
|
|
measureData->addNoteContainer(container);
|
|
measureData->addMusicData(container);
|
|
|
|
// note|rest & grace
|
|
container->setIsRest(type==BdatType::Rest);
|
|
container->setIsRaw(type==BdatType::Raw_Note);
|
|
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
thisByte = placeHolder.toUnsignedInt();
|
|
container->setIsGrace( thisByte == 0x3C00 );
|
|
container->setIsCue( thisByte == 0x4B40 || thisByte == 0x3240 );
|
|
|
|
// show / hide
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
thisByte = placeHolder.toUnsignedInt();
|
|
container->setShow(getLowNibble(thisByte)!=0x8);
|
|
|
|
// voice
|
|
container->setVoice(getLowNibble(thisByte)&0x7);
|
|
|
|
// common
|
|
if( !parseCommonBlock(container) ) { return false; }
|
|
|
|
// tuplet
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
container->setTuplet(placeHolder.toUnsignedInt());
|
|
|
|
// space
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
container->setSpace(placeHolder.toUnsignedInt());
|
|
|
|
// in beam
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
thisByte = placeHolder.toUnsignedInt();
|
|
bool inBeam = ( getHighNibble(thisByte) & 0x1 ) == 0x1;
|
|
container->setInBeam(inBeam);
|
|
|
|
// grace NoteType
|
|
container->setGraceNoteType((NoteType)getHighNibble(thisByte));
|
|
|
|
// dot
|
|
container->setDot(getLowNibble(thisByte)&0x03);
|
|
|
|
// NoteType
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
thisByte = placeHolder.toUnsignedInt();
|
|
container->setNoteType((NoteType)getLowNibble(thisByte));
|
|
|
|
int cursor = 0;
|
|
|
|
if( type == BdatType::Rest ) {
|
|
Note* restPtr = new Note();
|
|
container->addNoteRest(restPtr);
|
|
restPtr->setIsRest(true);
|
|
|
|
// line
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
restPtr->setLine(placeHolder.toInt());
|
|
|
|
if( !jump(1) ) { return false; }
|
|
|
|
cursor = ove_->getIsVersion4() ? 16 : 14;
|
|
} else // type == Bdat_Note || type == Bdat_Raw_Note
|
|
{
|
|
// stem up 0x80, stem down 0x00
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
thisByte = placeHolder.toUnsignedInt();
|
|
container->setStemUp((getHighNibble(thisByte)&0x8)==0x8);
|
|
|
|
// stem length
|
|
int stemOffset = thisByte%0x80;
|
|
container->setStemLength(getInt(stemOffset, 7)+7/*3.5 line span*/);
|
|
|
|
// show stem 0x00, hide stem 0x40
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
bool hideStem = getHighNibble(thisByte)==0x4;
|
|
container->setShowStem(!hideStem);
|
|
|
|
if( !jump(1) ) { return false; }
|
|
|
|
// note count
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
unsigned int noteCount = placeHolder.toUnsignedInt();
|
|
unsigned int i;
|
|
|
|
// each note 16 bytes
|
|
for( i=0; i<noteCount; ++i ) {
|
|
Note* notePtr = new Note();
|
|
notePtr->setIsRest(false);
|
|
|
|
container->addNoteRest(notePtr);
|
|
|
|
// note show / hide
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
thisByte = placeHolder.toUnsignedInt();
|
|
notePtr->setShow((thisByte&0x80) != 0x80);
|
|
|
|
// notehead type
|
|
notePtr->setHeadType(thisByte&0x7f);
|
|
|
|
// tie pos
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
thisByte = placeHolder.toUnsignedInt();
|
|
notePtr->setTiePos(getHighNibble(thisByte));
|
|
|
|
// offset staff, in {-1, 0, 1}
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
thisByte = getLowNibble(placeHolder.toUnsignedInt());
|
|
int offsetStaff = 0;
|
|
if( thisByte == 1 ) { offsetStaff = 1; }
|
|
if( thisByte == 7 ) { offsetStaff = -1; }
|
|
notePtr->setOffsetStaff(offsetStaff);
|
|
|
|
// accidental
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
thisByte = placeHolder.toUnsignedInt();
|
|
notePtr->setAccidental(getLowNibble(thisByte));
|
|
// accidental 0: influenced by key, 4: influenced by previous accidental in measure
|
|
//bool notShow = ( getHighNibble(thisByte) == 0 ) || ( getHighNibble(thisByte) == 4 );
|
|
bool notShow = !(getHighNibble(thisByte)&0x1);
|
|
notePtr->setShowAccidental(!notShow);
|
|
|
|
if( !jump(1) ) { return false; }
|
|
|
|
// line
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
notePtr->setLine(placeHolder.toInt());
|
|
|
|
if( !jump(1) ) { return false; }
|
|
|
|
// note
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
unsigned int note = placeHolder.toUnsignedInt();
|
|
notePtr->setNote(note);
|
|
|
|
// note on velocity
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
unsigned int onVelocity = placeHolder.toUnsignedInt();
|
|
notePtr->setOnVelocity(onVelocity);
|
|
|
|
// note off velocity
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
unsigned int offVelocity = placeHolder.toUnsignedInt();
|
|
notePtr->setOffVelocity(offVelocity);
|
|
|
|
if( !jump(2) ) { return false; }
|
|
|
|
// length (tick)
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
container->setLength(placeHolder.toUnsignedInt());
|
|
|
|
// offset tick
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
notePtr->setOffsetTick(placeHolder.toInt());
|
|
}
|
|
|
|
cursor = ove_->getIsVersion4() ? 18 : 16;
|
|
cursor += noteCount * 16/*note size*/;
|
|
}
|
|
|
|
// articulation
|
|
while ( cursor < length + 1/* 0x70 || 0x80 || 0x90 */ ) {
|
|
Articulation* art = new Articulation();
|
|
container->addArticulation(art);
|
|
|
|
// block size
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
int blockSize = placeHolder.toUnsignedInt();
|
|
|
|
// articulation type
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
art->setArtType(placeHolder.toUnsignedInt());
|
|
|
|
// placement
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
art->setPlacementAbove(placeHolder.toUnsignedInt()!=0x00); //0x00:below, 0x30:above
|
|
|
|
// offset
|
|
if( !parseOffsetElement(art) ) { return false; }
|
|
|
|
if( !ove_->getIsVersion4() ) {
|
|
if( blockSize - 8 > 0 ) {
|
|
if( !jump(blockSize-8) ) { return false; }
|
|
}
|
|
} else {
|
|
// setting
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
thisByte = placeHolder.toUnsignedInt();
|
|
const bool changeSoundEffect = ( ( thisByte & 0x1 ) == 0x1 );
|
|
const bool changeLength = ( ( thisByte & 0x2 ) == 0x2 );
|
|
const bool changeVelocity = ( ( thisByte & 0x4 ) == 0x4 );
|
|
//const bool changeExtraLength = ( ( thisByte & 0x20 ) == 0x20 );
|
|
|
|
if( !jump(8) ) { return false; }
|
|
|
|
// velocity type
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
thisByte = placeHolder.toUnsignedInt();
|
|
if( changeVelocity ) {
|
|
art->setVelocityType((Articulation::VelocityType)thisByte);
|
|
}
|
|
|
|
if( !jump(14) ) { return false; }
|
|
|
|
// sound effect
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
int from = placeHolder.toInt();
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
int to = placeHolder.toInt();
|
|
if( changeSoundEffect ) {
|
|
art->setSoundEffect(from, to);
|
|
}
|
|
|
|
if( !jump(1) ) { return false; }
|
|
|
|
// length percentage
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
if( changeLength ) {
|
|
art->setLengthPercentage(placeHolder.toUnsignedInt());
|
|
}
|
|
|
|
// velocity
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
if( changeVelocity ) {
|
|
art->setVelocityValue(placeHolder.toInt());
|
|
}
|
|
|
|
if( Articulation::isTrill(art->getArtType()) ) {
|
|
if( !jump(8) ) { return false; }
|
|
|
|
// trill note length
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
art->setTrillNoteLength(placeHolder.toUnsignedInt());
|
|
|
|
// trill rate
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
thisByte = placeHolder.toUnsignedInt();
|
|
NoteType trillNoteType = NoteType::Note_Sixteen;
|
|
switch ( getHighNibble(thisByte) ) {
|
|
case 0:
|
|
trillNoteType = NoteType::Note_None;
|
|
break;
|
|
case 1:
|
|
trillNoteType = NoteType::Note_Sixteen;
|
|
break;
|
|
case 2:
|
|
trillNoteType = NoteType::Note_32;
|
|
break;
|
|
case 3:
|
|
trillNoteType = NoteType::Note_64;
|
|
break;
|
|
case 4:
|
|
trillNoteType = NoteType::Note_128;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
art->setTrillRate(trillNoteType);
|
|
|
|
// accelerate type
|
|
art->setAccelerateType(thisByte&0xf);
|
|
|
|
if( !jump(1) ) { return false; }
|
|
|
|
// auxiliary first
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
art->setAuxiliaryFirst(placeHolder.toBoolean());
|
|
|
|
if( !jump(1) ) { return false; }
|
|
|
|
// trill interval
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
art->setTrillInterval(placeHolder.toUnsignedInt());
|
|
} else {
|
|
if( blockSize > 40 ) {
|
|
if( !jump( blockSize - 40 ) ) { return false; }
|
|
}
|
|
}
|
|
}
|
|
|
|
cursor += blockSize;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
int tupletToSpace(int tuplet) {
|
|
int a(1);
|
|
|
|
while( a*2 < tuplet ) {
|
|
a *= 2;
|
|
}
|
|
|
|
return a;
|
|
}
|
|
|
|
bool BarsParse::parseBeam(MeasureData* measureData, int length) {
|
|
int i;
|
|
Block placeHolder;
|
|
|
|
Beam* beam = new Beam();
|
|
measureData->addCrossMeasureElement(beam, true);
|
|
|
|
// maybe create tuplet, for < quarter & tool 3(
|
|
bool createTuplet = false;
|
|
int maxEndUnit = 0;
|
|
Tuplet* tuplet = new Tuplet();
|
|
|
|
// is grace
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
beam->setIsGrace(placeHolder.toBoolean());
|
|
|
|
if( !jump(1) ) { return false; }
|
|
|
|
// voice
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
beam->setVoice(getLowNibble(placeHolder.toUnsignedInt())&0x7);
|
|
|
|
// common
|
|
if( !parseCommonBlock(beam) ) { return false; }
|
|
|
|
if( !jump(2) ) { return false; }
|
|
|
|
// beam count
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
int beamCount = placeHolder.toUnsignedInt();
|
|
|
|
if( !jump(1) ) { return false; }
|
|
|
|
// left line
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
beam->getLeftLine()->setLine(placeHolder.toInt());
|
|
|
|
// right line
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
beam->getRightLine()->setLine(placeHolder.toInt());
|
|
|
|
if( ove_->getIsVersion4() ) {
|
|
if( !jump(8) ) { return false; }
|
|
}
|
|
|
|
int currentCursor = ove_->getIsVersion4() ? 23 : 13;
|
|
int count = (length - currentCursor)/16;
|
|
|
|
if( count != beamCount ) { return false; }
|
|
|
|
for( i=0; i<count; ++i ) {
|
|
if( !jump(1) ) { return false; }
|
|
|
|
// tuplet
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
int tupletCount = placeHolder.toUnsignedInt();
|
|
if( tupletCount > 0 ) {
|
|
createTuplet = true;
|
|
tuplet->setTuplet(tupletCount);
|
|
tuplet->setSpace(tupletToSpace(tupletCount));
|
|
}
|
|
|
|
// start / stop measure
|
|
// line i start end position
|
|
MeasurePos startMp;
|
|
MeasurePos stopMp;
|
|
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
startMp.setMeasure(placeHolder.toUnsignedInt());
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
stopMp.setMeasure(placeHolder.toUnsignedInt());
|
|
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
startMp.setOffset(placeHolder.toInt());
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
stopMp.setOffset(placeHolder.toInt());
|
|
|
|
beam->addLine(startMp, stopMp);
|
|
|
|
if( stopMp.getOffset() > maxEndUnit ) {
|
|
maxEndUnit = stopMp.getOffset();
|
|
}
|
|
|
|
if( i == 0 ) {
|
|
if( !jump(4) ) { return false; }
|
|
|
|
// left offset up+4, down-4
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
beam->getLeftShoulder()->setYOffset(placeHolder.toInt());
|
|
|
|
// right offset up+4, down-4
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
beam->getRightShoulder()->setYOffset(placeHolder.toInt());
|
|
} else {
|
|
if( !jump(8) ) { return false; }
|
|
}
|
|
}
|
|
|
|
const QList<QPair<MeasurePos, MeasurePos> > lines = beam->getLines();
|
|
MeasurePos offsetMp;
|
|
|
|
for( i=0; i<lines.size(); ++i ) {
|
|
if( lines[i].second > offsetMp ) {
|
|
offsetMp = lines[i].second;
|
|
}
|
|
}
|
|
|
|
beam->stop()->setMeasure(offsetMp.getMeasure());
|
|
beam->stop()->setOffset(offsetMp.getOffset());
|
|
|
|
// a case that Tuplet block don't exist, and hide inside beam
|
|
if( createTuplet ) {
|
|
tuplet->copyCommonBlock(*beam);
|
|
tuplet->getLeftLine()->setLine(beam->getLeftLine()->getLine());
|
|
tuplet->getRightLine()->setLine(beam->getRightLine()->getLine());
|
|
tuplet->stop()->setMeasure(beam->stop()->getMeasure());
|
|
tuplet->stop()->setOffset(maxEndUnit);
|
|
|
|
measureData->addCrossMeasureElement(tuplet, true);
|
|
} else {
|
|
delete tuplet;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool BarsParse::parseTie(MeasureData* measureData, int /*length*/) {
|
|
Block placeHolder;
|
|
|
|
Tie* tie = new Tie();
|
|
measureData->addCrossMeasureElement(tie, true);
|
|
|
|
if( !jump(3) ) { return false; }
|
|
|
|
// start common
|
|
if( !parseCommonBlock(tie) ) { return false; }
|
|
|
|
if( !jump(1) ) { return false; }
|
|
|
|
// note
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
tie->setNote(placeHolder.toUnsignedInt());
|
|
|
|
// pair lines
|
|
if( !parsePairLinesBlock(tie) ) { return false; }
|
|
|
|
// offset common
|
|
if( !parseOffsetCommonBlock(tie) ) { return false; }
|
|
|
|
// left shoulder offset
|
|
if( !parseOffsetElement(tie->getLeftShoulder()) ) { return false; }
|
|
|
|
// right shoulder offset
|
|
if( !parseOffsetElement(tie->getRightShoulder()) ) { return false; }
|
|
|
|
// height
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
tie->setHeight(placeHolder.toUnsignedInt());
|
|
|
|
return true;
|
|
}
|
|
|
|
bool BarsParse::parseTuplet(MeasureData* measureData, int /*length*/) {
|
|
Block placeHolder;
|
|
|
|
Tuplet* tuplet = new Tuplet();
|
|
measureData->addCrossMeasureElement(tuplet, true);
|
|
|
|
if( !jump(3) ) { return false; }
|
|
|
|
// common
|
|
if( !parseCommonBlock(tuplet) ) { return false; }
|
|
|
|
if( !jump(2) ) { return false; }
|
|
|
|
// pair lines
|
|
if( !parsePairLinesBlock(tuplet) ) { return false; }
|
|
|
|
// offset common
|
|
if( !parseOffsetCommonBlock(tuplet) ) { return false; }
|
|
|
|
// left shoulder offset
|
|
if( !parseOffsetElement(tuplet->getLeftShoulder()) ) { return false; }
|
|
|
|
// right shoulder offset
|
|
if( !parseOffsetElement(tuplet->getRightShoulder()) ) { return false; }
|
|
|
|
if( !jump(2) ) { return false; }
|
|
|
|
// height
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
tuplet->setHeight(placeHolder.toUnsignedInt());
|
|
|
|
// tuplet
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
tuplet->setTuplet(placeHolder.toUnsignedInt());
|
|
|
|
// space
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
tuplet->setSpace(placeHolder.toUnsignedInt());
|
|
|
|
// mark offset
|
|
if( !parseOffsetElement(tuplet->getMarkHandle()) ) { return false; }
|
|
|
|
return true;
|
|
}
|
|
|
|
HarmonyType binaryToHarmonyType(int bin) {
|
|
HarmonyType type = HarmonyType::H_maj;
|
|
if( bin == 0x0091 ) {
|
|
type = HarmonyType::H_maj;
|
|
} else if( bin == 0x0089 ) {
|
|
type = HarmonyType::H_min;
|
|
} else if( bin == 0x0489 ) {
|
|
type = HarmonyType::H_min7;
|
|
} else if( bin == 0x0491 ) {
|
|
type = HarmonyType::H_7;
|
|
} else if( bin == 0x0495 ) {
|
|
type = HarmonyType::H_9;
|
|
} else if( bin == 0x0449 ) {
|
|
type = HarmonyType::H_min7b5;
|
|
} else if( bin == 0x04A1 ) {
|
|
type = HarmonyType::H_7sus4;
|
|
} else if( bin == 0x00A1 ) {
|
|
type = HarmonyType::H_sus4;
|
|
} else if( bin == 0x0049 ) {
|
|
type = HarmonyType::H_dim;
|
|
} else if( bin == 0x0249 ) {
|
|
type = HarmonyType::H_dim7;
|
|
} else if( bin == 0x0111 ) {
|
|
type = HarmonyType::H_aug;
|
|
} else if( bin == 0x0511 ) {
|
|
type = HarmonyType::H_aug7;
|
|
} else if( bin == 0x044D ) {
|
|
type = HarmonyType::H_min9_b5;
|
|
} else if( bin == 0x0499 ) {
|
|
type = HarmonyType::H_7s9;
|
|
} else if( bin == 0x0615 ) {
|
|
type = HarmonyType::H_13;
|
|
} else if( bin == 0x0289 ) {
|
|
type = HarmonyType::H_min6;
|
|
} else if( bin == 0x0291 ) {
|
|
type = HarmonyType::H_6;
|
|
} else if( bin == 0x0295 ) {
|
|
type = HarmonyType::H_6; //6add9
|
|
} else if( bin == 0x0095 ) {
|
|
type = HarmonyType::H_min; //minor add9
|
|
} else if( bin == 0x008D ) {
|
|
type = HarmonyType::H_maj7;
|
|
} else if( bin == 0x0891 ) {
|
|
type = HarmonyType::H_maj7;
|
|
} else if( bin == 0x0881 ) {
|
|
type = HarmonyType::H_maj7_s5; //maj7#5
|
|
} else if( bin == 0x0911 ) {
|
|
type = HarmonyType::H_maj7_s5; //maj7#5
|
|
} else if( bin == 0x0991 ) {
|
|
type = HarmonyType::H_maj7_s11; //maj7#11
|
|
} else if( bin == 0x0851 ) {
|
|
type = HarmonyType::H_maj7_s11; //maj7#11
|
|
} else if( bin == 0x08D1 ) {
|
|
type = HarmonyType::H_maj9;
|
|
} else if( bin == 0x0895 ) {
|
|
type = HarmonyType::H_maj9_s5; //maj9#5
|
|
} else if( bin == 0x0995 ) {
|
|
type = HarmonyType::H_maj13_s11; //maj9#11
|
|
} else if( bin == 0x0855 ) {
|
|
type = HarmonyType::H_maj9_s11; //maj9#11
|
|
} else if( bin == 0x08D5 ) {
|
|
type = HarmonyType::H_maj13;
|
|
} else if( bin == 0x0A95 ) {
|
|
type = HarmonyType::H_maj13_s11; //maj13#11
|
|
} else if( bin == 0x0A55 ) {
|
|
type = HarmonyType::H_maj13; //maj13(no3)
|
|
} else if( bin == 0x0A85 ) {
|
|
type = HarmonyType::H_maj9_s5; //maj13#5#11(no4)
|
|
} else if( bin == 0x0B45 ) {
|
|
type = HarmonyType::H_7b9;
|
|
} else if( bin == 0x0493 ) {
|
|
type = HarmonyType::H_7b5;
|
|
} else if( bin == 0x0451 ) {
|
|
type = HarmonyType::H_9b5;
|
|
} else if( bin == 0x0455 ) {
|
|
type = HarmonyType::H_7s9; //7#5#9
|
|
} else if( bin == 0x0519 ) {
|
|
type = HarmonyType::H_7b9; //7#5b9
|
|
} else if( bin == 0x0513 ) {
|
|
type = HarmonyType::H_aug7; //aug9
|
|
} else if( bin == 0x0515 ) {
|
|
type = HarmonyType::H_sus4; //sus9
|
|
} else if( bin == 0x04A5 ) {
|
|
type = HarmonyType::H_13b9;
|
|
} else if( bin == 0x0613 ) {
|
|
type = HarmonyType::H_13b9; //13b9#11
|
|
} else if( bin == 0x0611 ) {
|
|
type = HarmonyType::H_13;
|
|
} else if( bin == 0x0653 ) {
|
|
type = HarmonyType::H_min; //m(natural7)
|
|
} else if( bin == 0x0889 ) {
|
|
type = HarmonyType::H_min9; //m9(natural7)
|
|
} else if( bin == 0x088D ) {
|
|
type = HarmonyType::H_min11;
|
|
} else if( bin == 0x04AD ) {
|
|
type = HarmonyType::H_9s11;
|
|
} else if( bin == 0x04D5 ) {
|
|
type = HarmonyType::H_7sus4; //sus7
|
|
} else if( bin == 0x0421 ) {
|
|
type = HarmonyType::H_min11;
|
|
} else if( bin == 0x04A9 ) {
|
|
type = HarmonyType::H_min9;
|
|
} else if( bin == 0x048D ) {
|
|
type = HarmonyType::H_7b5b9;
|
|
} else if( bin == 0x0453 ) {
|
|
type = HarmonyType::H_maj; //(no5)
|
|
} else if( bin == 0x0011 ) {
|
|
type = HarmonyType::H_maj7; //(no3)
|
|
} else if( bin == 0x0081 ) {
|
|
type = HarmonyType::H_7; //7(no3)
|
|
} else if( bin == 0x0481 ) {
|
|
type = HarmonyType::H_7; //7(no5)
|
|
} else if( bin == 0x0411 ) {
|
|
type = HarmonyType::H_6;
|
|
} else if( bin == 0x0291 ) {
|
|
type = HarmonyType::H_sus4; //sus(add9)
|
|
} else if( bin == 0x00A5 ) {
|
|
type = HarmonyType::H_13s9; //13#9b5
|
|
} else if( bin == 0x0659 ) {
|
|
type = HarmonyType::H_sus4; //sus(no5)
|
|
} else if( bin == 0x0021 ) {
|
|
type = HarmonyType::H_7b5b9; //7b5b9#9
|
|
} else if( bin == 0x045B ) {
|
|
type = HarmonyType::H_13b5; //13b5b9#9
|
|
} else if( bin == 0x065B ) {
|
|
type = HarmonyType::H_13b9; //13b9#9
|
|
} else if( bin == 0x061B ) {
|
|
type = HarmonyType::H_7b9s9; //7b9#9
|
|
} else if( bin == 0x04B5 ) {
|
|
type = HarmonyType::H_7;
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
bool BarsParse::parseHarmony(MeasureData* measureData, int /*length*/) {
|
|
Block placeHolder;
|
|
|
|
Harmony* harmony = new Harmony();
|
|
measureData->addMusicData(harmony);
|
|
|
|
if( !jump(3) ) { return false; }
|
|
|
|
// common
|
|
if( !parseCommonBlock(harmony) ) { return false; }
|
|
|
|
// bass on bottom
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
harmony->setBassOnBottom((getHighNibble(placeHolder.toUnsignedInt())==0x4));
|
|
|
|
if( !jump(1) ) { return false; }
|
|
|
|
// y offset
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
harmony->setYOffset(placeHolder.toInt());
|
|
|
|
// harmony type
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
harmony->setHarmonyType(binaryToHarmonyType(placeHolder.toUnsignedInt()));
|
|
|
|
// root
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
harmony->setRoot(placeHolder.toInt());
|
|
|
|
// bass
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
harmony->setBass(placeHolder.toInt());
|
|
|
|
// angle
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
harmony->setAngle(placeHolder.toInt());
|
|
|
|
if( ove_->getIsVersion4() ) {
|
|
// length (tick)
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
harmony->setLength(placeHolder.toUnsignedInt());
|
|
|
|
if( !jump(4) ) { return false; }
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool BarsParse::parseClef(MeasureData* measureData, int /*length*/) {
|
|
Block placeHolder;
|
|
|
|
Clef* clef = new Clef();
|
|
measureData->addMusicData(clef);
|
|
|
|
if( !jump(3) ) { return false; }
|
|
|
|
// common
|
|
if( !parseCommonBlock(clef) ) { return false; }
|
|
|
|
// clef type
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
clef->setClefType(placeHolder.toUnsignedInt());
|
|
|
|
// line
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
clef->setLine(placeHolder.toInt());
|
|
|
|
if( !jump(2) ) { return false; }
|
|
|
|
return true;
|
|
}
|
|
|
|
bool BarsParse::parseLyric(MeasureData* measureData, int length) {
|
|
Block placeHolder;
|
|
|
|
Lyric* lyric = new Lyric();
|
|
measureData->addMusicData(lyric);
|
|
|
|
if( !jump(3) ) { return false; }
|
|
|
|
// common
|
|
if( !parseCommonBlock(lyric) ) { return false; }
|
|
|
|
if( !jump(2) ) { return false; }
|
|
|
|
// offset
|
|
if( !parseOffsetElement(lyric) ) { return false; }
|
|
|
|
if( !jump(7) ) { return false; }
|
|
|
|
// verse
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
lyric->setVerse(placeHolder.toUnsignedInt());
|
|
|
|
if( ove_->getIsVersion4() ) {
|
|
if( !jump(6) ) { return false; }
|
|
|
|
// lyric
|
|
if( length > 29 ) {
|
|
if( !readBuffer(placeHolder, length-29) ) { return false; }
|
|
lyric->setLyric(ove_->getCodecString(placeHolder.fixedSizeBufferToStrByteArray()));
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool BarsParse::parseSlur(MeasureData* measureData, int /*length*/) {
|
|
Block placeHolder;
|
|
|
|
Slur* slur = new Slur();
|
|
measureData->addCrossMeasureElement(slur, true);
|
|
|
|
if( !jump(2) ) { return false; }
|
|
|
|
// voice
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
slur->setVoice(getLowNibble(placeHolder.toUnsignedInt())&0x7);
|
|
|
|
// common
|
|
if( !parseCommonBlock(slur) ) { return false; }
|
|
|
|
// show on top
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
slur->setShowOnTop(getHighNibble(placeHolder.toUnsignedInt())==0x8);
|
|
|
|
if( !jump(1) ) { return false; }
|
|
|
|
// pair lines
|
|
if( !parsePairLinesBlock(slur) ) { return false; }
|
|
|
|
// offset common
|
|
if( !parseOffsetCommonBlock(slur) ) { return false; }
|
|
|
|
// handle 1
|
|
if( !parseOffsetElement(slur->getLeftShoulder()) ) { return false; }
|
|
|
|
// handle 4
|
|
if( !parseOffsetElement(slur->getRightShoulder()) ) { return false; }
|
|
|
|
// handle 2
|
|
if( !parseOffsetElement(slur->getHandle2()) ) { return false; }
|
|
|
|
// handle 3
|
|
if( !parseOffsetElement(slur->getHandle3()) ) { return false; }
|
|
|
|
if( ove_->getIsVersion4() ) {
|
|
if( !jump(3) ) { return false; }
|
|
|
|
// note time percent
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
slur->setNoteTimePercent(placeHolder.toUnsignedInt());
|
|
|
|
if( !jump(36) ) { return false; }
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool BarsParse::parseGlissando(MeasureData* measureData, int /*length*/) {
|
|
Block placeHolder;
|
|
|
|
Glissando* glissando = new Glissando();
|
|
measureData->addCrossMeasureElement(glissando, true);
|
|
|
|
if( !jump(3) ) { return false; }
|
|
|
|
// common
|
|
if( !parseCommonBlock(glissando) ) { return false; }
|
|
|
|
// straight or wavy
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
unsigned int thisByte = placeHolder.toUnsignedInt();
|
|
glissando->setStraightWavy(getHighNibble(thisByte)==4);
|
|
|
|
if( !jump(1) ) { return false; }
|
|
|
|
// pair lines
|
|
if( !parsePairLinesBlock(glissando) ) { return false; }
|
|
|
|
// offset common
|
|
if( !parseOffsetCommonBlock(glissando) ) { return false; }
|
|
|
|
// left shoulder
|
|
if( !parseOffsetElement(glissando->getLeftShoulder()) ) { return false; }
|
|
|
|
// right shoulder
|
|
if( !parseOffsetElement(glissando->getRightShoulder()) ) { return false; }
|
|
|
|
if( ove_->getIsVersion4() ) {
|
|
if( !jump(1) ) { return false; }
|
|
|
|
// line thick
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
glissando->setLineThick(placeHolder.toUnsignedInt());
|
|
|
|
if( !jump(12) ) { return false; }
|
|
|
|
// text 32 bytes
|
|
if( !readBuffer(placeHolder, 32) ) { return false; }
|
|
glissando->setText(ove_->getCodecString(placeHolder.fixedSizeBufferToStrByteArray()));
|
|
|
|
if( !jump(6) ) { return false; }
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool getDecoratorType(
|
|
unsigned int thisByte,
|
|
bool& measureRepeat,
|
|
Decorator::Type& decoratorType,
|
|
bool& singleRepeat,
|
|
ArticulationType& artType) {
|
|
measureRepeat = false;
|
|
decoratorType = Decorator::Type::Articulation;
|
|
singleRepeat = true;
|
|
artType = ArticulationType::None;
|
|
|
|
switch (thisByte) {
|
|
case 0x00: {
|
|
decoratorType = Decorator::Type::Dotted_Barline;
|
|
break;
|
|
}
|
|
case 0x30: {
|
|
artType = ArticulationType::Open_String;
|
|
break;
|
|
}
|
|
case 0x31: {
|
|
artType = ArticulationType::Finger_1;
|
|
break;
|
|
}
|
|
case 0x32: {
|
|
artType = ArticulationType::Finger_2;
|
|
break;
|
|
}
|
|
case 0x33: {
|
|
artType = ArticulationType::Finger_3;
|
|
break;
|
|
}
|
|
case 0x34: {
|
|
artType = ArticulationType::Finger_4;
|
|
break;
|
|
}
|
|
case 0x35: {
|
|
artType = ArticulationType::Finger_5;
|
|
break;
|
|
}
|
|
case 0x6B: {
|
|
artType = ArticulationType::Flat_Accidental_For_Trill;
|
|
break;
|
|
}
|
|
case 0x6C: {
|
|
artType = ArticulationType::Sharp_Accidental_For_Trill;
|
|
break;
|
|
}
|
|
case 0x6D: {
|
|
artType = ArticulationType::Natural_Accidental_For_Trill;
|
|
break;
|
|
}
|
|
case 0x8d: {
|
|
measureRepeat = true;
|
|
singleRepeat = true;
|
|
break;
|
|
}
|
|
case 0x8e: {
|
|
measureRepeat = true;
|
|
singleRepeat = false;
|
|
break;
|
|
}
|
|
case 0xA0: {
|
|
artType = ArticulationType::Minor_Trill;
|
|
break;
|
|
}
|
|
case 0xA1: {
|
|
artType = ArticulationType::Major_Trill;
|
|
break;
|
|
}
|
|
case 0xA2: {
|
|
artType = ArticulationType::Trill_Section;
|
|
break;
|
|
}
|
|
case 0xA6: {
|
|
artType = ArticulationType::Turn;
|
|
break;
|
|
}
|
|
case 0xA8: {
|
|
artType = ArticulationType::Tremolo_Eighth;
|
|
break;
|
|
}
|
|
case 0xA9: {
|
|
artType = ArticulationType::Tremolo_Sixteenth;
|
|
break;
|
|
}
|
|
case 0xAA: {
|
|
artType = ArticulationType::Tremolo_Thirty_Second;
|
|
break;
|
|
}
|
|
case 0xAB: {
|
|
artType = ArticulationType::Tremolo_Sixty_Fourth;
|
|
break;
|
|
}
|
|
case 0xB2: {
|
|
artType = ArticulationType::Fermata;
|
|
break;
|
|
}
|
|
case 0xB3: {
|
|
artType = ArticulationType::Fermata_Inverted;
|
|
break;
|
|
}
|
|
case 0xB9: {
|
|
artType = ArticulationType::Pause;
|
|
break;
|
|
}
|
|
case 0xBA: {
|
|
artType = ArticulationType::Grand_Pause;
|
|
break;
|
|
}
|
|
case 0xC0: {
|
|
artType = ArticulationType::Marcato;
|
|
break;
|
|
}
|
|
case 0xC1: {
|
|
artType = ArticulationType::Marcato_Dot;
|
|
break;
|
|
}
|
|
case 0xC2: {
|
|
artType = ArticulationType::SForzando;
|
|
break;
|
|
}
|
|
case 0xC3: {
|
|
artType = ArticulationType::SForzando_Dot;
|
|
break;
|
|
}
|
|
case 0xC4: {
|
|
artType = ArticulationType::SForzando_Inverted;
|
|
break;
|
|
}
|
|
case 0xC5: {
|
|
artType = ArticulationType::SForzando_Dot_Inverted;
|
|
break;
|
|
}
|
|
case 0xC6: {
|
|
artType = ArticulationType::Staccatissimo;
|
|
break;
|
|
}
|
|
case 0xC7: {
|
|
artType = ArticulationType::Staccato;
|
|
break;
|
|
}
|
|
case 0xC8: {
|
|
artType = ArticulationType::Tenuto;
|
|
break;
|
|
}
|
|
case 0xC9: {
|
|
artType = ArticulationType::Natural_Harmonic;
|
|
break;
|
|
}
|
|
case 0xCA: {
|
|
artType = ArticulationType::Artificial_Harmonic;
|
|
break;
|
|
}
|
|
case 0xCB: {
|
|
artType = ArticulationType::Plus_Sign;
|
|
break;
|
|
}
|
|
case 0xCC: {
|
|
artType = ArticulationType::Up_Bow;
|
|
break;
|
|
}
|
|
case 0xCD: {
|
|
artType = ArticulationType::Down_Bow;
|
|
break;
|
|
}
|
|
case 0xCE: {
|
|
artType = ArticulationType::Up_Bow_Inverted;
|
|
break;
|
|
}
|
|
case 0xCF: {
|
|
artType = ArticulationType::Down_Bow_Inverted;
|
|
break;
|
|
}
|
|
case 0xD0: {
|
|
artType = ArticulationType::Pedal_Down;
|
|
break;
|
|
}
|
|
case 0xD1: {
|
|
artType = ArticulationType::Pedal_Up;
|
|
break;
|
|
}
|
|
case 0xD6: {
|
|
artType = ArticulationType::Heavy_Attack;
|
|
break;
|
|
}
|
|
case 0xD7: {
|
|
artType = ArticulationType::Heavier_Attack;
|
|
break;
|
|
}
|
|
default:
|
|
return false;
|
|
break;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool BarsParse::parseDecorators(MeasureData* measureData, int length) {
|
|
Block placeHolder;
|
|
MusicData* musicData = new MusicData();
|
|
|
|
if( !jump(3) ) { return false; }
|
|
|
|
// common
|
|
if( !parseCommonBlock(musicData) ) { return false; }
|
|
|
|
if( !jump(2) ) { return false; }
|
|
|
|
// y offset
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
musicData->setYOffset(placeHolder.toInt());
|
|
|
|
if( !jump(2) ) { return false; }
|
|
|
|
// measure repeat | piano pedal | dotted barline | articulation
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
unsigned int thisByte = placeHolder.toUnsignedInt();
|
|
|
|
Decorator::Type decoratorType;
|
|
bool isMeasureRepeat;
|
|
bool isSingleRepeat = true;
|
|
ArticulationType artType = ArticulationType::None;
|
|
|
|
getDecoratorType(thisByte, isMeasureRepeat, decoratorType, isSingleRepeat, artType);
|
|
|
|
if( isMeasureRepeat ) {
|
|
MeasureRepeat* measureRepeat = new MeasureRepeat();
|
|
measureData->addCrossMeasureElement(measureRepeat, true);
|
|
|
|
measureRepeat->copyCommonBlock(*musicData);
|
|
measureRepeat->setYOffset(musicData->getYOffset());
|
|
|
|
measureRepeat->setSingleRepeat(isSingleRepeat);
|
|
} else {
|
|
Decorator* decorator = new Decorator();
|
|
measureData->addMusicData(decorator);
|
|
|
|
decorator->copyCommonBlock(*musicData);
|
|
decorator->setYOffset(musicData->getYOffset());
|
|
|
|
decorator->setDecoratorType(decoratorType);
|
|
decorator->setArticulationType(artType);
|
|
}
|
|
|
|
int cursor = ove_->getIsVersion4() ? 16 : 14;
|
|
if( !jump(length-cursor) ) { return false; }
|
|
|
|
return true;
|
|
}
|
|
|
|
bool BarsParse::parseWedge(MeasureData* measureData, int length) {
|
|
Block placeHolder;
|
|
Wedge* wedge = new Wedge();
|
|
|
|
if( !jump(3) ) { return false; }
|
|
|
|
// common
|
|
if( !parseCommonBlock(wedge) ) { return false; }
|
|
|
|
// wedge type
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
WedgeType wedgeType = WedgeType::Cres_Line;
|
|
bool wedgeOrExpression = true;
|
|
unsigned int highHalfByte = getHighNibble(placeHolder.toUnsignedInt());
|
|
unsigned int lowHalfByte = getLowNibble(placeHolder.toUnsignedInt());
|
|
|
|
switch (highHalfByte) {
|
|
case 0x0: {
|
|
wedgeType = WedgeType::Cres_Line;
|
|
wedgeOrExpression = true;
|
|
break;
|
|
}
|
|
case 0x4: {
|
|
wedgeType = WedgeType::Decresc_Line;
|
|
wedgeOrExpression = true;
|
|
break;
|
|
}
|
|
case 0x6: {
|
|
wedgeType = WedgeType::Decresc;
|
|
wedgeOrExpression = false;
|
|
break;
|
|
}
|
|
case 0x2: {
|
|
wedgeType = WedgeType::Cres;
|
|
wedgeOrExpression = false;
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
|
|
// 0xb | 0x8(ove3) , else 3, 0(ove3)
|
|
if( (lowHalfByte & 0x8) == 0x8 ) {
|
|
wedgeType = WedgeType::Double_Line;
|
|
wedgeOrExpression = true;
|
|
}
|
|
|
|
if( !jump(1) ) { return false; }
|
|
|
|
// y offset
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
wedge->setYOffset(placeHolder.toInt());
|
|
|
|
// wedge
|
|
if( wedgeOrExpression ) {
|
|
measureData->addCrossMeasureElement(wedge, true);
|
|
wedge->setWedgeType(wedgeType);
|
|
|
|
if( !jump(2) ) { return false; }
|
|
|
|
// height
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
wedge->setHeight(placeHolder.toUnsignedInt());
|
|
|
|
// offset common
|
|
if( !parseOffsetCommonBlock(wedge) ) { return false; }
|
|
|
|
int cursor = ove_->getIsVersion4() ? 21 : 19;
|
|
if( !jump(length-cursor) ) { return false; }
|
|
}
|
|
// expression : cresc, decresc
|
|
else {
|
|
Expressions* express = new Expressions();
|
|
measureData->addMusicData(express);
|
|
|
|
express->copyCommonBlock(*wedge);
|
|
express->setYOffset(wedge->getYOffset());
|
|
|
|
if( !jump(4) ) { return false; }
|
|
|
|
// offset common
|
|
if( !parseOffsetCommonBlock(express) ) { return false; }
|
|
|
|
if( ove_->getIsVersion4() ) {
|
|
if( !jump(18) ) { return false; }
|
|
|
|
// words
|
|
if( length > 39 ) {
|
|
if( !readBuffer(placeHolder, length-39) ) { return false; }
|
|
express->setText(ove_->getCodecString(placeHolder.fixedSizeBufferToStrByteArray()));
|
|
}
|
|
} else {
|
|
QString str = wedgeType==WedgeType::Cres ? "cresc" : "decresc";
|
|
express->setText(str);
|
|
|
|
if( !jump(8) ) { return false; }
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool BarsParse::parseDynamics(MeasureData* measureData, int /*length*/) {
|
|
Block placeHolder;
|
|
|
|
Dynamics* dynamics = new Dynamics();
|
|
measureData->addMusicData(dynamics);
|
|
|
|
if( !jump(1) ) { return false; }
|
|
|
|
// is playback
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
dynamics->setIsPlayback(getHighNibble(placeHolder.toUnsignedInt())!=0x4);
|
|
|
|
if( !jump(1) ) { return false; }
|
|
|
|
// common
|
|
if( !parseCommonBlock(dynamics) ) { return false; }
|
|
|
|
// y offset
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
dynamics->setYOffset(placeHolder.toInt());
|
|
|
|
// dynamics type
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
dynamics->setDynamicsType(getLowNibble(placeHolder.toUnsignedInt()));
|
|
|
|
// velocity
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
dynamics->setVelocity(placeHolder.toUnsignedInt());
|
|
|
|
int cursor = ove_->getIsVersion4() ? 4 : 2;
|
|
|
|
if( !jump(cursor) ) { return false; }
|
|
|
|
return true;
|
|
}
|
|
|
|
bool BarsParse::parseKey(MeasureData* measureData, int /*length*/) {
|
|
Block placeHolder;
|
|
Key* key = measureData->getKey();
|
|
int cursor = ove_->getIsVersion4() ? 9 : 7;
|
|
|
|
if( !jump(cursor) ) { return false; }
|
|
|
|
// key
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
key->setKey(oveKeyToKey(placeHolder.toUnsignedInt()));
|
|
|
|
// previous key
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
key->setPreviousKey(oveKeyToKey(placeHolder.toUnsignedInt()));
|
|
|
|
if( !jump(3) ) { return false; }
|
|
|
|
// symbol count
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
key->setSymbolCount(placeHolder.toUnsignedInt());
|
|
|
|
if( !jump(4) ) { return false; }
|
|
|
|
return true;
|
|
}
|
|
|
|
bool BarsParse::parsePedal(MeasureData* measureData, int length) {
|
|
Block placeHolder;
|
|
|
|
Pedal* pedal = new Pedal();
|
|
//measureData->addMusicData(pedal); //can't remember why
|
|
measureData->addCrossMeasureElement(pedal, true);
|
|
|
|
if( !jump(1) ) { return false; }
|
|
|
|
// is playback
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
pedal->setIsPlayback(getHighNibble(placeHolder.toUnsignedInt())!=4);
|
|
|
|
if( !jump(1) ) { return false; }
|
|
|
|
// common
|
|
if( !parseCommonBlock(pedal) ) { return false; }
|
|
|
|
if( !jump(2) ) { return false; }
|
|
|
|
// pair lines
|
|
if( !parsePairLinesBlock(pedal) ) { return false; }
|
|
|
|
// offset common
|
|
if( !parseOffsetCommonBlock(pedal) ) { return false; }
|
|
|
|
// left shoulder
|
|
if( !parseOffsetElement(pedal->getLeftShoulder()) ) { return false; }
|
|
|
|
// right shoulder
|
|
if( !parseOffsetElement(pedal->getRightShoulder()) ) { return false; }
|
|
|
|
int cursor = ove_->getIsVersion4() ? 0x45 : 0x23;
|
|
int blankCount = ove_->getIsVersion4() ? 42 : 10;
|
|
|
|
pedal->setHalf( length > cursor );
|
|
|
|
if( !jump(blankCount) ) { return false; }
|
|
|
|
if( length > cursor ) {
|
|
if( !jump(2) ) { return false; }
|
|
|
|
// handle x offset
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
pedal->getPedalHandle()->setXOffset(placeHolder.toInt());
|
|
|
|
if( !jump(6) ) { return false; }
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool BarsParse::parseKuohao(MeasureData* measureData, int /*length*/) {
|
|
Block placeHolder;
|
|
|
|
KuoHao* kuoHao = new KuoHao();
|
|
measureData->addMusicData(kuoHao);
|
|
|
|
if( !jump(3) ) { return false; }
|
|
|
|
// common
|
|
if( !parseCommonBlock(kuoHao) ) { return false; }
|
|
|
|
if( !jump(2) ) { return false; }
|
|
|
|
// pair lines
|
|
if( !parsePairLinesBlock(kuoHao) ) { return false; }
|
|
|
|
if( !jump(4) ) { return false; }
|
|
|
|
// left shoulder
|
|
if( !parseOffsetElement(kuoHao->getLeftShoulder()) ) { return false; }
|
|
|
|
// right shoulder
|
|
if( !parseOffsetElement(kuoHao->getRightShoulder()) ) { return false; }
|
|
|
|
// kuohao type
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
kuoHao->setKuohaoType(placeHolder.toUnsignedInt());
|
|
|
|
// height
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
kuoHao->setHeight(placeHolder.toUnsignedInt());
|
|
|
|
int jumpAmount = ove_->getIsVersion4() ? 40 : 8;
|
|
if( !jump(jumpAmount) ) { return false; }
|
|
|
|
return true;
|
|
}
|
|
|
|
bool BarsParse::parseExpressions(MeasureData* measureData, int length) {
|
|
Block placeHolder;
|
|
|
|
Expressions* expressions = new Expressions();
|
|
measureData->addMusicData(expressions);
|
|
|
|
if( !jump(3) ) { return false; }
|
|
|
|
// common00
|
|
if( !parseCommonBlock(expressions) ) { return false; }
|
|
|
|
if( !jump(2) ) { return false; }
|
|
|
|
// y offset
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
expressions->setYOffset(placeHolder.toInt());
|
|
|
|
// range bar offset
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
//int barOffset = placeHolder.toUnsignedInt();
|
|
|
|
if( !jump(10) ) { return false; }
|
|
|
|
// tempo 1
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
//double tempo1 = ((double)placeHolder.toUnsignedInt()) / 100.0;
|
|
|
|
// tempo 2
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
//double tempo2 = ((double)placeHolder.toUnsignedInt()) / 100.0;
|
|
|
|
if( !jump(6) ) { return false; }
|
|
|
|
// text
|
|
int cursor = ove_->getIsVersion4() ? 35 : 33;
|
|
if( length > cursor ) {
|
|
if( !readBuffer(placeHolder, length-cursor) ) { return false; }
|
|
expressions->setText(ove_->getCodecString(placeHolder.fixedSizeBufferToStrByteArray()));
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool BarsParse::parseHarpPedal(MeasureData* measureData, int /*length*/) {
|
|
Block placeHolder;
|
|
|
|
HarpPedal* harpPedal = new HarpPedal();
|
|
measureData->addMusicData(harpPedal);
|
|
|
|
if( !jump(3) ) { return false; }
|
|
|
|
// common
|
|
if( !parseCommonBlock(harpPedal) ) { return false; }
|
|
|
|
if( !jump(2) ) { return false; }
|
|
|
|
// y offset
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
harpPedal->setYOffset(placeHolder.toInt());
|
|
|
|
// show type
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
harpPedal->setShowType(placeHolder.toUnsignedInt());
|
|
|
|
// show char flag
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
harpPedal->setShowCharFlag(placeHolder.toUnsignedInt());
|
|
|
|
if( !jump(8) ) { return false; }
|
|
|
|
return true;
|
|
}
|
|
|
|
bool BarsParse::parseMultiMeasureRest(MeasureData* measureData, int /*length*/) {
|
|
Block placeHolder(2);
|
|
MultiMeasureRest* measureRest = new MultiMeasureRest();
|
|
measureData->addMusicData(measureRest);
|
|
|
|
if( !jump(3) ) { return false; }
|
|
|
|
// common
|
|
if( !parseCommonBlock(measureRest) ) { return false; }
|
|
|
|
if( !jump(6) ) { return false; }
|
|
|
|
return true;
|
|
}
|
|
|
|
bool BarsParse::parseHarmonyGuitarFrame(MeasureData* measureData, int length) {
|
|
Block placeHolder;
|
|
|
|
Harmony* harmony = new Harmony();
|
|
measureData->addMusicData(harmony);
|
|
|
|
if( !jump(3) ) { return false; }
|
|
|
|
// common
|
|
if( !parseCommonBlock(harmony) ) { return false; }
|
|
|
|
// root
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
harmony->setRoot(placeHolder.toUnsignedInt());
|
|
|
|
// type
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
harmony->setHarmonyType((HarmonyType)placeHolder.toUnsignedInt());
|
|
|
|
// bass
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
harmony->setBass(placeHolder.toUnsignedInt());
|
|
|
|
int jumpAmount = ove_->getIsVersion4() ? length - 12 : length - 10;
|
|
if( !jump(jumpAmount) ) { return false; }
|
|
|
|
return true;
|
|
}
|
|
|
|
void extractOctave(unsigned int Bits, OctaveShiftType& octaveShiftType, QList<OctaveShiftPosition>& positions) {
|
|
octaveShiftType = OctaveShiftType::OS_8;
|
|
positions.clear();
|
|
|
|
switch (Bits) {
|
|
case 0x0: {
|
|
octaveShiftType = OctaveShiftType::OS_8;
|
|
positions.push_back(OctaveShiftPosition::Continue);
|
|
break;
|
|
}
|
|
case 0x1: {
|
|
octaveShiftType = OctaveShiftType::OS_Minus_8;
|
|
positions.push_back(OctaveShiftPosition::Continue);
|
|
break;
|
|
}
|
|
case 0x2: {
|
|
octaveShiftType = OctaveShiftType::OS_15;
|
|
positions.push_back(OctaveShiftPosition::Continue);
|
|
break;
|
|
}
|
|
case 0x3: {
|
|
octaveShiftType = OctaveShiftType::OS_Minus_15;
|
|
positions.push_back(OctaveShiftPosition::Continue);
|
|
break;
|
|
}
|
|
case 0x4: {
|
|
octaveShiftType = OctaveShiftType::OS_8;
|
|
positions.push_back(OctaveShiftPosition::Stop);
|
|
break;
|
|
}
|
|
case 0x5: {
|
|
octaveShiftType = OctaveShiftType::OS_Minus_8;
|
|
positions.push_back(OctaveShiftPosition::Stop);
|
|
break;
|
|
}
|
|
case 0x6: {
|
|
octaveShiftType = OctaveShiftType::OS_15;
|
|
positions.push_back(OctaveShiftPosition::Stop);
|
|
break;
|
|
}
|
|
case 0x7: {
|
|
octaveShiftType = OctaveShiftType::OS_Minus_15;
|
|
positions.push_back(OctaveShiftPosition::Stop);
|
|
break;
|
|
}
|
|
case 0x8: {
|
|
octaveShiftType = OctaveShiftType::OS_8;
|
|
positions.push_back(OctaveShiftPosition::Start);
|
|
break;
|
|
}
|
|
case 0x9: {
|
|
octaveShiftType = OctaveShiftType::OS_Minus_8;
|
|
positions.push_back(OctaveShiftPosition::Start);
|
|
break;
|
|
}
|
|
case 0xA: {
|
|
octaveShiftType = OctaveShiftType::OS_15;
|
|
positions.push_back(OctaveShiftPosition::Start);
|
|
break;
|
|
}
|
|
case 0xB: {
|
|
octaveShiftType = OctaveShiftType::OS_Minus_15;
|
|
positions.push_back(OctaveShiftPosition::Start);
|
|
;
|
|
break;
|
|
}
|
|
case 0xC: {
|
|
octaveShiftType = OctaveShiftType::OS_8;
|
|
positions.push_back(OctaveShiftPosition::Start);
|
|
positions.push_back(OctaveShiftPosition::Stop);
|
|
break;
|
|
}
|
|
case 0xD: {
|
|
octaveShiftType = OctaveShiftType::OS_Minus_8;
|
|
positions.push_back(OctaveShiftPosition::Start);
|
|
positions.push_back(OctaveShiftPosition::Stop);
|
|
break;
|
|
}
|
|
case 0xE: {
|
|
octaveShiftType = OctaveShiftType::OS_15;
|
|
positions.push_back(OctaveShiftPosition::Start);
|
|
positions.push_back(OctaveShiftPosition::Stop);
|
|
break;
|
|
}
|
|
case 0xF: {
|
|
octaveShiftType = OctaveShiftType::OS_Minus_15;
|
|
positions.push_back(OctaveShiftPosition::Start);
|
|
positions.push_back(OctaveShiftPosition::Stop);
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
bool BarsParse::parseOctaveShift(MeasureData* measureData, int /*length*/) {
|
|
Block placeHolder;
|
|
|
|
OctaveShift* octave = new OctaveShift();
|
|
measureData->addCrossMeasureElement(octave, true);
|
|
|
|
if( !jump(3) ) { return false; }
|
|
|
|
// common
|
|
if( !parseCommonBlock(octave) ) { return false; }
|
|
|
|
// octave
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
unsigned int type = getLowNibble(placeHolder.toUnsignedInt());
|
|
OctaveShiftType octaveShiftType = OctaveShiftType::OS_8;
|
|
QList<OctaveShiftPosition> positions;
|
|
extractOctave(type, octaveShiftType, positions);
|
|
|
|
octave->setOctaveShiftType(octaveShiftType);
|
|
|
|
if( !jump(1) ) { return false; }
|
|
|
|
// y offset
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
octave->setYOffset(placeHolder.toInt());
|
|
|
|
if( !jump(4) ) { return false; }
|
|
|
|
// length
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
octave->setLength(placeHolder.toUnsignedInt());
|
|
|
|
// end tick
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
octave->setEndTick(placeHolder.toUnsignedInt());
|
|
|
|
// start & stop maybe appear in same measure
|
|
for (int i=0; i<positions.size(); ++i) {
|
|
OctaveShiftPosition position = positions[i];
|
|
OctaveShiftEndPoint* octavePoint = new OctaveShiftEndPoint();
|
|
measureData->addMusicData(octavePoint);
|
|
|
|
octavePoint->copyCommonBlock(*octave);
|
|
octavePoint->setOctaveShiftType(octaveShiftType);
|
|
octavePoint->setOctaveShiftPosition(position);
|
|
octavePoint->setEndTick(octave->getEndTick());
|
|
|
|
// stop
|
|
if( i==0 && position == OctaveShiftPosition::Stop ) {
|
|
octavePoint->start()->setOffset(octave->start()->getOffset()+octave->getLength());
|
|
}
|
|
|
|
// end point
|
|
if( i>0 ) {
|
|
octavePoint->start()->setOffset(octave->start()->getOffset()+octave->getLength());
|
|
octavePoint->setTick(octave->getEndTick());
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool BarsParse::parseMidiController(MeasureData* measureData, int /*length*/) {
|
|
Block placeHolder;
|
|
MidiController* controller = new MidiController();
|
|
measureData->addMidiData(controller);
|
|
|
|
parseMidiCommon(controller);
|
|
|
|
// value [0, 128)
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
controller->setValue(placeHolder.toUnsignedInt());
|
|
|
|
// controller number
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
controller->setController(placeHolder.toUnsignedInt());
|
|
|
|
if( ove_->getIsVersion4() ) {
|
|
if( !jump(2) ) { return false; }
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool BarsParse::parseMidiProgramChange(MeasureData* measureData, int /*length*/) {
|
|
Block placeHolder;
|
|
MidiProgramChange* program = new MidiProgramChange();
|
|
measureData->addMidiData(program);
|
|
|
|
parseMidiCommon(program);
|
|
|
|
if( !jump(1) ) { return false; }
|
|
|
|
// patch
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
program->setPatch(placeHolder.toUnsignedInt());
|
|
|
|
if( ove_->getIsVersion4() ) {
|
|
if( !jump(2) ) { return false; }
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool BarsParse::parseMidiChannelPressure(MeasureData* measureData, int /*length*/) {
|
|
Block placeHolder;
|
|
MidiChannelPressure* pressure = new MidiChannelPressure();
|
|
measureData->addMidiData(pressure);
|
|
|
|
parseMidiCommon(pressure);
|
|
|
|
if( !jump(1) ) { return false; }
|
|
|
|
// pressure
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
pressure->setPressure(placeHolder.toUnsignedInt());
|
|
|
|
if( ove_->getIsVersion4() )
|
|
{
|
|
if( !jump(2) ) { return false; }
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool BarsParse::parseMidiPitchWheel(MeasureData* measureData, int /*length*/) {
|
|
Block placeHolder;
|
|
MidiPitchWheel* wheel = new MidiPitchWheel();
|
|
measureData->addMidiData(wheel);
|
|
|
|
parseMidiCommon(wheel);
|
|
|
|
// pitch wheel
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
int value = placeHolder.toUnsignedInt();
|
|
wheel->setValue(value);
|
|
|
|
if( ove_->getIsVersion4() ) {
|
|
if( !jump(2) ) { return false; }
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool BarsParse::parseSizeBlock(int length) {
|
|
if( !jump(length) ) { return false; }
|
|
|
|
return true;
|
|
}
|
|
|
|
bool BarsParse::parseMidiCommon(MidiData* ptr) {
|
|
Block placeHolder;
|
|
|
|
if( !jump(3) ) { return false; }
|
|
|
|
// start position
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
ptr->setTick(placeHolder.toUnsignedInt());
|
|
|
|
return true;
|
|
}
|
|
|
|
bool BarsParse::parseCommonBlock(MusicData* ptr) {
|
|
Block placeHolder;
|
|
|
|
// start tick
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
ptr->setTick(placeHolder.toInt());
|
|
|
|
// start unit
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
ptr->start()->setOffset(placeHolder.toInt());
|
|
|
|
if( ove_->getIsVersion4() ) {
|
|
// color
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
ptr->setColor(placeHolder.toUnsignedInt());
|
|
|
|
if( !jump(1) ) { return false; }
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool BarsParse::parseOffsetCommonBlock(MusicData* ptr) {
|
|
Block placeHolder;
|
|
|
|
// offset measure
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
ptr->stop()->setMeasure(placeHolder.toUnsignedInt());
|
|
|
|
// end unit
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
ptr->stop()->setOffset(placeHolder.toInt());
|
|
|
|
return true;
|
|
}
|
|
|
|
bool BarsParse::parsePairLinesBlock(PairEnds* ptr) {
|
|
Block placeHolder;
|
|
|
|
// left line
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
ptr->getLeftLine()->setLine(placeHolder.toInt());
|
|
|
|
// right line
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
ptr->getRightLine()->setLine(placeHolder.toInt());
|
|
|
|
return true;
|
|
}
|
|
|
|
bool BarsParse::parseOffsetElement(OffsetElement* ptr) {
|
|
Block placeHolder;
|
|
|
|
// x offset
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
ptr->setXOffset(placeHolder.toInt());
|
|
|
|
// y offset
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
ptr->setYOffset(placeHolder.toInt());
|
|
|
|
return true;
|
|
}
|
|
|
|
bool BarsParse::getCondElementType(unsigned int byteData, CondType& type) {
|
|
if( byteData == 0x09 ) {
|
|
type = CondType::Time_Parameters;
|
|
} else if (byteData == 0x0A) {
|
|
type = CondType::Bar_Number;
|
|
} else if (byteData == 0x16) {
|
|
type = CondType::Decorator;
|
|
} else if (byteData == 0x1C) {
|
|
type = CondType::Tempo;
|
|
} else if (byteData == 0x1D) {
|
|
type = CondType::Text;
|
|
} else if (byteData == 0x25) {
|
|
type = CondType::Expression;
|
|
} else if (byteData == 0x30) {
|
|
type = CondType::Barline_Parameters;
|
|
} else if (byteData == 0x31) {
|
|
type = CondType::Repeat;
|
|
} else if (byteData == 0x32) {
|
|
type = CondType::Numeric_Ending;
|
|
} else {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool BarsParse::getBdatElementType(unsigned int byteData, BdatType& type) {
|
|
if (byteData == 0x70) {
|
|
type = BdatType::Raw_Note;
|
|
} else if (byteData == 0x80) {
|
|
type = BdatType::Rest;
|
|
} else if (byteData == 0x90) {
|
|
type = BdatType::Note;
|
|
} else if (byteData == 0x10) {
|
|
type = BdatType::Beam;
|
|
} else if (byteData == 0x11) {
|
|
type = BdatType::Harmony;
|
|
} else if (byteData == 0x12) {
|
|
type = BdatType::Clef;
|
|
} else if (byteData == 0x13) {
|
|
type = BdatType::Wedge;
|
|
} else if (byteData == 0x14) {
|
|
type = BdatType::Dynamics;
|
|
} else if (byteData == 0x15) {
|
|
type = BdatType::Glissando;
|
|
} else if (byteData == 0x16) {
|
|
type = BdatType::Decorator;
|
|
} else if (byteData == 0x17) {
|
|
type = BdatType::Key;
|
|
} else if (byteData == 0x18) {
|
|
type = BdatType::Lyric;
|
|
} else if (byteData == 0x19) {
|
|
type = BdatType::Octave_Shift;
|
|
} else if (byteData == 0x1B) {
|
|
type = BdatType::Slur;
|
|
} else if (byteData == 0x1D) {
|
|
type = BdatType::Text;
|
|
} else if (byteData == 0x1E) {
|
|
type = BdatType::Tie;
|
|
} else if (byteData == 0x1F) {
|
|
type = BdatType::Tuplet;
|
|
} else if (byteData == 0x21) {
|
|
type = BdatType::Guitar_Bend;
|
|
} else if (byteData == 0x22) {
|
|
type = BdatType::Guitar_Barre;
|
|
} else if (byteData == 0x23) {
|
|
type = BdatType::Pedal;
|
|
} else if (byteData == 0x24) {
|
|
type = BdatType::KuoHao;
|
|
} else if (byteData == 0x25) {
|
|
type = BdatType::Expressions;
|
|
} else if (byteData == 0x26) {
|
|
type = BdatType::Harp_Pedal;
|
|
} else if (byteData == 0x27) {
|
|
type = BdatType::Multi_Measure_Rest;
|
|
} else if (byteData == 0x28) {
|
|
type = BdatType::Harmony_GuitarFrame;
|
|
} else if (byteData == 0x40) {
|
|
type = BdatType::Graphics_40;
|
|
} else if (byteData == 0x41) {
|
|
type = BdatType::Graphics_RoundRect;
|
|
} else if (byteData == 0x42) {
|
|
type = BdatType::Graphics_Rect;
|
|
} else if (byteData == 0x43) {
|
|
type = BdatType::Graphics_Round;
|
|
} else if (byteData == 0x44) {
|
|
type = BdatType::Graphics_Line;
|
|
} else if (byteData == 0x45) {
|
|
type = BdatType::Graphics_Curve;
|
|
} else if (byteData == 0x46) {
|
|
type = BdatType::Graphics_WedgeSymbol;
|
|
} else if (byteData == 0xAB) {
|
|
type = BdatType::Midi_Controller;
|
|
} else if (byteData == 0xAC) {
|
|
type = BdatType::Midi_Program_Change;
|
|
} else if (byteData == 0xAD) {
|
|
type = BdatType::Midi_Channel_Pressure;
|
|
} else if (byteData == 0xAE) {
|
|
type = BdatType::Midi_Pitch_Wheel;
|
|
} else if (byteData == 0xFF) {
|
|
type = BdatType::Bar_End;
|
|
} else {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
LyricChunkParse::LyricChunkParse(OveSong* ove) :
|
|
BasicParse(ove) {
|
|
}
|
|
|
|
void LyricChunkParse::setLyricChunk(SizeChunk* chunk) {
|
|
chunk_ = chunk;
|
|
}
|
|
|
|
// only ove3 has this chunk
|
|
bool LyricChunkParse::parse() {
|
|
unsigned int i;
|
|
Block* dataBlock = chunk_->getDataBlock();
|
|
unsigned int blockSize = chunk_->getSizeBlock()->toSize();
|
|
StreamHandle handle(dataBlock->data(), blockSize);
|
|
Block placeHolder;
|
|
|
|
handle_ = &handle;
|
|
|
|
if( !jump(4) ) { return false; }
|
|
|
|
// Lyric count
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
unsigned int count = placeHolder.toUnsignedInt();
|
|
|
|
for( i=0; i<count; ++i ) {
|
|
LyricInfo info;
|
|
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
//unsigned int size = placeHolder.toUnsignedInt();
|
|
|
|
// 0x0D00
|
|
if( !jump(2) ) { return false; }
|
|
|
|
// voice
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
info.voice_ = placeHolder.toUnsignedInt();
|
|
|
|
// verse
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
info.verse_ = placeHolder.toUnsignedInt();
|
|
|
|
// track
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
info.track_ = placeHolder.toUnsignedInt();
|
|
|
|
if( !jump(1) ) { return false; }
|
|
|
|
// measure
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
info.measure_ = placeHolder.toUnsignedInt();
|
|
|
|
// word count
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
info.wordCount_ = placeHolder.toUnsignedInt();
|
|
|
|
// lyric size
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
info.lyricSize_ = placeHolder.toUnsignedInt();
|
|
|
|
if( !jump(6) ) { return false; }
|
|
|
|
// name
|
|
if( !readBuffer(placeHolder, 32) ) { return false; }
|
|
info.name_ = ove_->getCodecString(placeHolder.fixedSizeBufferToStrByteArray());
|
|
|
|
if( info.lyricSize_ > 0 ) {
|
|
// lyric
|
|
if( info.lyricSize_ > 0 ) {
|
|
if( !readBuffer(placeHolder, info.lyricSize_) ) { return false; }
|
|
info.lyric_ = ove_->getCodecString(placeHolder.fixedSizeBufferToStrByteArray());
|
|
}
|
|
|
|
if( !jump(4) ) { return false; }
|
|
|
|
// font
|
|
if( !readBuffer(placeHolder, 2) ) { return false; }
|
|
info.font_ = placeHolder.toUnsignedInt();
|
|
|
|
if( !jump(1) ) { return false; }
|
|
|
|
// font size
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
info.fontSize_ = placeHolder.toUnsignedInt();
|
|
|
|
// font style
|
|
if( !readBuffer(placeHolder, 1) ) { return false; }
|
|
info.fontStyle_ = placeHolder.toUnsignedInt();
|
|
|
|
if( !jump(1) ) { return false; }
|
|
|
|
for( int j=0; j<info.wordCount_; ++j ) {
|
|
if( !jump(8) ) { return false; }
|
|
}
|
|
}
|
|
|
|
processLyricInfo(info);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool isSpace(char c) {
|
|
return c == ' ' || c == '\n';
|
|
}
|
|
|
|
void LyricChunkParse::processLyricInfo(const LyricInfo& info) {
|
|
int i;
|
|
int j;
|
|
int index = 0; //words
|
|
|
|
int measureId = info.measure_-1;
|
|
bool changeMeasure = true;
|
|
MeasureData* measureData = 0;
|
|
int trackMeasureCount = ove_->getTrackBarCount();
|
|
QStringList words = info.lyric_.split(" ", QString::SkipEmptyParts);
|
|
|
|
while ( index < words.size() && measureId+1 < trackMeasureCount ) {
|
|
if( changeMeasure ) {
|
|
++measureId;
|
|
measureData = ove_->getMeasureData(info.track_, measureId);
|
|
changeMeasure = false;
|
|
}
|
|
|
|
if( measureData == 0 ) { return; }
|
|
QList<NoteContainer*> containers = measureData->getNoteContainers();
|
|
QList<MusicData*> lyrics = measureData->getMusicDatas(MusicDataType::Lyric);
|
|
|
|
for( i=0; i<containers.size() && index<words.size(); ++i ) {
|
|
if( containers[i]->getIsRest() ) {
|
|
continue;
|
|
}
|
|
|
|
for( j=0; j<lyrics.size(); ++j ) {
|
|
Lyric* lyric = dynamic_cast<Lyric*>(lyrics[j]);
|
|
|
|
if( containers[i]->start()->getOffset() == lyric->start()->getOffset() &&
|
|
(int)containers[i]->getVoice() == info.voice_ &&
|
|
lyric->getVerse() == info.verse_ ) {
|
|
if(index<words.size()) {
|
|
QString l = words[index].trimmed();
|
|
if(!l.isEmpty()) {
|
|
lyric->setLyric(l);
|
|
lyric->setVoice(info.voice_);
|
|
}
|
|
}
|
|
|
|
++index;
|
|
}
|
|
}
|
|
}
|
|
|
|
changeMeasure = true;
|
|
}
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
TitleChunkParse::TitleChunkParse(OveSong* ove) :
|
|
BasicParse(ove) {
|
|
titleType_ = 0x00000001;
|
|
annotateType_ = 0x00010000;
|
|
writerType_ = 0x00020002;
|
|
copyrightType_ = 0x00030001;
|
|
headerType_ = 0x00040000;
|
|
footerType_ = 0x00050002;
|
|
}
|
|
|
|
void TitleChunkParse::setTitleChunk(SizeChunk* chunk) {
|
|
chunk_ = chunk;
|
|
}
|
|
|
|
QByteArray getByteArray(const Block& block) {
|
|
QByteArray array((char*)block.data(), block.size());
|
|
int index0 = array.indexOf('\0');
|
|
array = array.left(index0);
|
|
|
|
return array;
|
|
}
|
|
|
|
bool TitleChunkParse::parse() {
|
|
Block* dataBlock = chunk_->getDataBlock();
|
|
unsigned int blockSize = chunk_->getSizeBlock()->toSize();
|
|
StreamHandle handle(dataBlock->data(), blockSize);
|
|
Block typeBlock;
|
|
unsigned int titleType;
|
|
|
|
handle_ = &handle;
|
|
|
|
if( !readBuffer(typeBlock, 4) ) { return false; }
|
|
|
|
titleType = typeBlock.toUnsignedInt();
|
|
|
|
if( titleType == titleType_ || titleType == annotateType_ || titleType == writerType_ || titleType == copyrightType_ ) {
|
|
Block offsetBlock;
|
|
|
|
if( !readBuffer(offsetBlock, 4) ) { return false; }
|
|
|
|
const unsigned int itemCount = 4;
|
|
unsigned int i;
|
|
|
|
for( i=0; i<itemCount; ++i ) {
|
|
if( i>0 ) {
|
|
//0x 00 AB 00 0C 00 00
|
|
if( !jump(6) ) { return false; }
|
|
}
|
|
|
|
Block countBlock;
|
|
if( !readBuffer(countBlock, 2) ) { return false; }
|
|
unsigned int titleSize = countBlock.toUnsignedInt();
|
|
|
|
Block dataBlock;
|
|
if( !readBuffer(dataBlock, titleSize) ) { return false; }
|
|
|
|
QByteArray array = getByteArray(dataBlock);
|
|
if(!array.isEmpty()) {
|
|
addToOve(ove_->getCodecString(array), titleType);
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
if( titleType == headerType_ || titleType == footerType_ ) {
|
|
if( !jump(10) ) { return false; }
|
|
|
|
Block countBlock;
|
|
if( !readBuffer(countBlock, 2) ) { return false; }
|
|
unsigned int titleSize = countBlock.toUnsignedInt();
|
|
|
|
Block dataBlock;
|
|
if( !readBuffer(dataBlock, titleSize) ) { return false; }
|
|
|
|
QByteArray array = getByteArray(dataBlock);
|
|
addToOve(ove_->getCodecString(array), titleType);
|
|
|
|
//0x 00 AB 00 0C 00 00
|
|
if( !jump(6) ) { return false; }
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void TitleChunkParse::addToOve(const QString& str, unsigned int titleType) {
|
|
if( str.isEmpty() ) { return; }
|
|
|
|
if (titleType == titleType_) {
|
|
ove_->addTitle(str);
|
|
}
|
|
|
|
if (titleType == annotateType_) {
|
|
ove_->addAnnotate(str);
|
|
}
|
|
|
|
if (titleType == writerType_) {
|
|
ove_->addWriter(str);
|
|
}
|
|
|
|
if (titleType == copyrightType_) {
|
|
ove_->addCopyright(str);
|
|
}
|
|
|
|
if (titleType == headerType_) {
|
|
ove_->addHeader(str);
|
|
}
|
|
|
|
if (titleType == footerType_) {
|
|
ove_->addFooter(str);
|
|
}
|
|
}
|
|
|
|
// OveOrganize.cpp
|
|
OveOrganizer::OveOrganizer(OveSong* ove) {
|
|
ove_ = ove;
|
|
}
|
|
|
|
void OveOrganizer::organize() {
|
|
if(ove_ == NULL) {
|
|
return;
|
|
}
|
|
|
|
organizeTracks();
|
|
organizeAttributes();
|
|
organizeMeasures();
|
|
}
|
|
|
|
void OveOrganizer::organizeAttributes() {
|
|
int i;
|
|
int j;
|
|
int k;
|
|
|
|
// key
|
|
if(ove_->getLineCount() > 0) {
|
|
Line* line = ove_->getLine(0);
|
|
int partBarCount = ove_->getPartBarCount();
|
|
int lastKey = 0;
|
|
|
|
if(line != 0){
|
|
for(i=0; i<line->getStaffCount(); ++i) {
|
|
QPair<int, int> partStaff = ove_->trackToPartStaff(i);
|
|
Staff* staff = line->getStaff(i);
|
|
lastKey = staff->getKeyType();
|
|
|
|
for(j=0; j<partBarCount; ++j) {
|
|
MeasureData* measureData = ove_->getMeasureData(partStaff.first, partStaff.second, j);
|
|
|
|
if(measureData != 0) {
|
|
Key* key = measureData->getKey();
|
|
|
|
if( j==0 ) {
|
|
key->setKey(lastKey);
|
|
key->setPreviousKey(lastKey);
|
|
}
|
|
|
|
if( !key->getSetKey() ) {
|
|
key->setKey(lastKey);
|
|
key->setPreviousKey(lastKey);
|
|
}
|
|
else {
|
|
if( key->getKey() != lastKey ) {
|
|
lastKey = key->getKey();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// clef
|
|
if( ove_->getLineCount() > 0 ) {
|
|
Line* line = ove_->getLine(0);
|
|
int partBarCount = ove_->getPartBarCount();
|
|
ClefType lastClefType = ClefType::Treble;
|
|
|
|
if(line != 0){
|
|
for( i=0; i<line->getStaffCount(); ++i ) {
|
|
QPair<int, int> partStaff = ove_->trackToPartStaff(i);
|
|
Staff* staff = line->getStaff(i);
|
|
lastClefType = staff->getClefType();
|
|
|
|
for( j=0; j<partBarCount; ++j ) {
|
|
MeasureData* measureData = ove_->getMeasureData(partStaff.first, partStaff.second, j);
|
|
|
|
if(measureData != 0) {
|
|
Clef* clefPtr = measureData->getClef();
|
|
clefPtr->setClefType((int)lastClefType);
|
|
|
|
const QList<MusicData*>& clefs = measureData->getMusicDatas(MusicDataType::Clef);
|
|
|
|
for( k=0; k<clefs.size(); ++k ) {
|
|
Clef* clef = dynamic_cast<Clef*>(clefs[k]);
|
|
lastClefType = clef->getClefType();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
Staff* getStaff(OveSong* ove, int track) {
|
|
if (ove->getLineCount() > 0) {
|
|
Line* line = ove->getLine(0);
|
|
if(line != 0 && line->getStaffCount() > 0) {
|
|
Staff* staff = line->getStaff(track);
|
|
return staff;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
void OveOrganizer::organizeTracks() {
|
|
int i;
|
|
//QList<QPair<ClefType, int> > trackChannels;
|
|
QList<Track*> tracks = ove_->getTracks();
|
|
QList<bool> comboStaveStarts;
|
|
|
|
for( i=0; i<tracks.size(); ++i ) {
|
|
comboStaveStarts.push_back(false);
|
|
}
|
|
|
|
for( i=0; i<tracks.size(); ++i ) {
|
|
Staff* staff = getStaff(ove_, i);
|
|
if(staff != 0) {
|
|
if(staff->getGroupType() == GroupType::Brace && staff->getGroupStaffCount() == 1 ) {
|
|
comboStaveStarts[i] = true;
|
|
}
|
|
}
|
|
|
|
/*if( i < tracks.size() - 1 ) {
|
|
if( tracks[i]->getStartClef() == ClefType::Treble &&
|
|
tracks[i+1]->getStartClef() == ClefType::Bass &&
|
|
tracks[i]->getChannel() == tracks[i+1]->get_channel() ) {
|
|
}
|
|
}*/
|
|
}
|
|
|
|
int trackId = 0;
|
|
QList<int> partStaffCounts;
|
|
|
|
while( trackId < (int)tracks.size() ) {
|
|
int partTrackCount = 1;
|
|
|
|
if( comboStaveStarts[trackId] ) {
|
|
partTrackCount = 2;
|
|
}
|
|
|
|
partStaffCounts.push_back(partTrackCount);
|
|
trackId += partTrackCount;
|
|
}
|
|
|
|
ove_->setPartStaffCounts(partStaffCounts);
|
|
}
|
|
|
|
void OveOrganizer::organizeMeasures() {
|
|
int trackBarCount = ove_->getTrackBarCount();
|
|
|
|
for( int i=0; i<ove_->getPartCount(); ++i ) {
|
|
int partStaffCount = ove_->getStaffCount(i);
|
|
|
|
for( int j=0; j<partStaffCount; ++j ) {
|
|
for( int k=0; k<trackBarCount; ++k ) {
|
|
Measure* measure = ove_->getMeasure(k);
|
|
MeasureData* measureData = ove_->getMeasureData(i, j, k);
|
|
|
|
organizeMeasure(i, j, measure, measureData);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void OveOrganizer::organizeMeasure(int part, int track, Measure* measure, MeasureData* measureData) {
|
|
// note containers
|
|
organizeContainers(part, track, measure, measureData);
|
|
|
|
// single end data
|
|
organizeMusicDatas(part, track, measure, measureData);
|
|
|
|
// cross measure elements
|
|
organizeCrossMeasureElements(part, track, measure, measureData);
|
|
}
|
|
|
|
void addToList(QList<int>& list, int number) {
|
|
for(int i=0; i<list.size(); ++i){
|
|
if(list[i] == number){
|
|
return;
|
|
}
|
|
}
|
|
|
|
list.push_back(number);
|
|
}
|
|
|
|
void OveOrganizer::organizeContainers(int /*part*/, int /*track*/,
|
|
Measure* measure, MeasureData* measureData) {
|
|
int i;
|
|
QList<NoteContainer*> containers = measureData->getNoteContainers();
|
|
int barUnits = measure->getTime()->getUnits();
|
|
QList<int> voices;
|
|
|
|
for(i=0; i<containers.size(); ++i){
|
|
int endUnit = barUnits;
|
|
if( i < containers.size() - 1 ) {
|
|
endUnit = containers[i+1]->start()->getOffset();
|
|
}
|
|
|
|
containers[i]->stop()->setOffset(endUnit);
|
|
addToList(voices, containers[i]->getVoice());
|
|
}
|
|
|
|
// shift voices
|
|
qSort(voices.begin(), voices.end());
|
|
|
|
for (i = 0; i < voices.size(); ++i) {
|
|
int voice = voices[i];
|
|
// voice -> i
|
|
for(int j=0; j<(int)containers.size(); ++j) {
|
|
int avoice = containers[j]->getVoice();
|
|
if ( avoice == voice && avoice != i ) {
|
|
containers[j]->setVoice(i);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void OveOrganizer::organizeMusicDatas(int /*part*/, int /*track*/, Measure* measure, MeasureData* measureData) {
|
|
int i;
|
|
int barIndex = measure->getBarNumber()->getIndex();
|
|
QList<MusicData*> datas = measureData->getMusicDatas(MusicDataType::None);
|
|
|
|
for(i=0; i<datas.size(); ++i) {
|
|
datas[i]->start()->setMeasure(barIndex);
|
|
}
|
|
}
|
|
|
|
void OveOrganizer::organizeCrossMeasureElements(int part, int track, Measure* measure, MeasureData* measureData) {
|
|
int i;
|
|
QList<MusicData*> pairs = measureData->getCrossMeasureElements(MusicDataType::None, MeasureData::PairType::Start);
|
|
|
|
for(i=0; i<pairs.size(); ++i) {
|
|
MusicData* pair = pairs[i];
|
|
|
|
switch ( pair->getMusicDataType() ) {
|
|
case MusicDataType::Beam :
|
|
case MusicDataType::Glissando :
|
|
case MusicDataType::Slur :
|
|
case MusicDataType::Tie :
|
|
case MusicDataType::Tuplet :
|
|
case MusicDataType::Pedal :
|
|
case MusicDataType::Numeric_Ending :
|
|
//case MusicDataType::OctaveShift_EndPoint :
|
|
case MusicDataType::Measure_Repeat : {
|
|
organizePairElement(pair, part, track, measure, measureData);
|
|
break;
|
|
}
|
|
case MusicDataType::OctaveShift : {
|
|
OctaveShift* octave = dynamic_cast<OctaveShift*>(pair);
|
|
organizeOctaveShift(octave, measure, measureData);
|
|
break;
|
|
}
|
|
case MusicDataType::Wedge : {
|
|
Wedge* wedge = dynamic_cast<Wedge*>(pair);
|
|
organizeWedge(wedge, part, track, measure, measureData);
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void OveOrganizer::organizePairElement(
|
|
MusicData* data,
|
|
int part,
|
|
int track,
|
|
Measure* measure,
|
|
MeasureData* measureData) {
|
|
int bar1Index = measure->getBarNumber()->getIndex();
|
|
int bar2Index = bar1Index + data->stop()->getMeasure();
|
|
MeasureData* measureData2 = ove_->getMeasureData(part, track, bar2Index);
|
|
|
|
data->start()->setMeasure(bar1Index);
|
|
|
|
if(measureData2 != 0 && measureData != measureData2) {
|
|
measureData2->addCrossMeasureElement(data, false);
|
|
}
|
|
|
|
if( data->getMusicDataType() == MusicDataType::Tuplet ){
|
|
Tuplet* tuplet = dynamic_cast<Tuplet*>(data);
|
|
const QList<NoteContainer*> containers = measureData->getNoteContainers();
|
|
|
|
for(int i=0; i<containers.size(); ++i){
|
|
if(containers[i]->getTick() > tuplet->getTick()){
|
|
break;
|
|
}
|
|
|
|
if(containers[i]->getTick() == tuplet->getTick()){
|
|
tuplet->setNoteType(containers[i]->getNoteType());
|
|
}
|
|
}
|
|
|
|
int tupletTick = NoteTypeToTick(tuplet->getNoteType(), ove_->getQuarter())*tuplet->getSpace();
|
|
if( tuplet->getTick() % tupletTick != 0 ) {
|
|
int newStartTick = (tuplet->getTick() / tupletTick) * tupletTick;
|
|
|
|
for(int i=0; i<containers.size(); ++i){
|
|
if( containers[i]->getTick() == newStartTick &&
|
|
containers[i]->getTuplet() == tuplet->getTuplet()) {
|
|
tuplet->setTick(containers[i]->getTick());
|
|
tuplet->start()->setOffset(containers[i]->start()->getOffset());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void OveOrganizer::organizeOctaveShift(
|
|
OctaveShift* octave,
|
|
Measure* measure,
|
|
MeasureData* measureData) {
|
|
// octave shift
|
|
int i;
|
|
const QList<NoteContainer*> containers = measureData->getNoteContainers();
|
|
int barIndex = measure->getBarNumber()->getIndex();
|
|
|
|
octave->start()->setMeasure(barIndex);
|
|
|
|
for(i=0; i<containers.size(); ++i) {
|
|
int noteShift = octave->getNoteShift();
|
|
int containerTick = containers[i]->getTick();
|
|
|
|
if( octave->getTick() <= containerTick && octave->getEndTick() > containerTick ) {
|
|
containers[i]->setNoteShift(noteShift);
|
|
}
|
|
}
|
|
}
|
|
|
|
bool getMiddleUnit(
|
|
OveSong* ove, int /*part*/, int /*track*/,
|
|
Measure* measure1, Measure* measure2, int unit1, int /*unit2*/,
|
|
Measure* middleMeasure, int& middleUnit) {
|
|
Q_UNUSED(middleMeasure); // avoid (bogus?) warning to show up
|
|
QList<int> barUnits;
|
|
int i;
|
|
int bar1Index = measure1->getBarNumber()->getIndex();
|
|
int bar2Index = measure2->getBarNumber()->getIndex();
|
|
int sumUnit = 0;
|
|
|
|
for( int j=bar1Index; j<=bar2Index; ++j ) {
|
|
Measure* measure = ove->getMeasure(j);
|
|
barUnits.push_back(measure->getTime()->getUnits());
|
|
sumUnit += measure->getTime()->getUnits();
|
|
}
|
|
|
|
int currentSumUnit = 0;
|
|
for( i=0; i<barUnits.size(); ++i ) {
|
|
int barUnit = barUnits[i];
|
|
|
|
if( i==0 ) {
|
|
barUnit = barUnits[i] - unit1;
|
|
}
|
|
|
|
if( currentSumUnit + barUnit < sumUnit/2 ) {
|
|
currentSumUnit += barUnit;
|
|
}
|
|
else {
|
|
break;
|
|
}
|
|
}
|
|
|
|
if( i < barUnits.size() ) {
|
|
int barMiddleIndex = bar1Index + i;
|
|
middleMeasure = ove->getMeasure(barMiddleIndex);
|
|
middleUnit = sumUnit/2 - currentSumUnit;
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void OveOrganizer::organizeWedge(Wedge* wedge, int part, int track, Measure* measure, MeasureData* measureData) {
|
|
int bar1Index = measure->getBarNumber()->getIndex();
|
|
int bar2Index = bar1Index + wedge->stop()->getMeasure();
|
|
MeasureData* measureData2 = ove_->getMeasureData(part, track, bar2Index);
|
|
WedgeType wedgeType = wedge->getWedgeType();
|
|
|
|
if( wedge->getWedgeType() == WedgeType::Double_Line ) {
|
|
wedgeType = WedgeType::Cres_Line;
|
|
}
|
|
|
|
wedge->start()->setMeasure(bar1Index);
|
|
|
|
WedgeEndPoint* startPoint = new WedgeEndPoint();
|
|
measureData->addMusicData(startPoint);
|
|
|
|
startPoint->setTick(wedge->getTick());
|
|
startPoint->start()->setOffset(wedge->start()->getOffset());
|
|
startPoint->setWedgeStart(true);
|
|
startPoint->setWedgeType(wedgeType);
|
|
startPoint->setHeight(wedge->getHeight());
|
|
|
|
WedgeEndPoint* stopPoint = new WedgeEndPoint();
|
|
|
|
stopPoint->setTick(wedge->getTick());
|
|
stopPoint->start()->setOffset(wedge->stop()->getOffset());
|
|
stopPoint->setWedgeStart(false);
|
|
stopPoint->setWedgeType(wedgeType);
|
|
stopPoint->setHeight(wedge->getHeight());
|
|
|
|
if(measureData2 != 0) {
|
|
measureData2->addMusicData(stopPoint);
|
|
}
|
|
|
|
if( wedge->getWedgeType() == WedgeType::Double_Line ) {
|
|
Measure* middleMeasure = NULL;
|
|
int middleUnit = 0;
|
|
|
|
getMiddleUnit(
|
|
ove_, part, track,
|
|
measure, ove_->getMeasure(bar2Index),
|
|
wedge->start()->getOffset(), wedge->stop()->getOffset(),
|
|
middleMeasure, middleUnit);
|
|
|
|
if( middleMeasure != 0 ) {
|
|
WedgeEndPoint* midStopPoint = new WedgeEndPoint();
|
|
measureData->addMusicData(midStopPoint);
|
|
|
|
midStopPoint->setTick(wedge->getTick());
|
|
midStopPoint->start()->setOffset(middleUnit);
|
|
midStopPoint->setWedgeStart(false);
|
|
midStopPoint->setWedgeType(WedgeType::Cres_Line);
|
|
midStopPoint->setHeight(wedge->getHeight());
|
|
|
|
WedgeEndPoint* midStartPoint = new WedgeEndPoint();
|
|
measureData->addMusicData(midStartPoint);
|
|
|
|
midStartPoint->setTick(wedge->getTick());
|
|
midStartPoint->start()->setOffset(middleUnit);
|
|
midStartPoint->setWedgeStart(true);
|
|
midStartPoint->setWedgeType(WedgeType::Decresc_Line);
|
|
midStartPoint->setHeight(wedge->getHeight());
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// OveSerialize.cpp
|
|
enum class ChunkType : char {
|
|
OVSC = 00 ,
|
|
TRKL,
|
|
TRAK,
|
|
PAGL,
|
|
PAGE,
|
|
LINL,
|
|
LINE,
|
|
STAF,
|
|
BARL,
|
|
MEAS,
|
|
COND,
|
|
BDAT,
|
|
PACH,
|
|
FNTS,
|
|
ODEV,
|
|
TITL,
|
|
ALOT,
|
|
ENGR,
|
|
FMAP,
|
|
PCPR,
|
|
|
|
// Overture 3.6
|
|
LYRC,
|
|
|
|
NONE
|
|
};
|
|
|
|
ChunkType nameToChunkType(const NameBlock& name) {
|
|
ChunkType type = ChunkType::NONE;
|
|
|
|
if (name.isEqual("OVSC")) {
|
|
type = ChunkType::OVSC;
|
|
} else if (name.isEqual("TRKL")) {
|
|
type = ChunkType::TRKL;
|
|
} else if (name.isEqual("TRAK")) {
|
|
type = ChunkType::TRAK;
|
|
} else if (name.isEqual("PAGL")) {
|
|
type = ChunkType::PAGL;
|
|
} else if (name.isEqual("PAGE")) {
|
|
type = ChunkType::PAGE;
|
|
} else if (name.isEqual("LINL")) {
|
|
type = ChunkType::LINL;
|
|
} else if (name.isEqual("LINE")) {
|
|
type = ChunkType::LINE;
|
|
} else if (name.isEqual("STAF")) {
|
|
type = ChunkType::STAF;
|
|
} else if (name.isEqual("BARL")) {
|
|
type = ChunkType::BARL;
|
|
} else if (name.isEqual("MEAS")) {
|
|
type = ChunkType::MEAS;
|
|
} else if (name.isEqual("COND")) {
|
|
type = ChunkType::COND;
|
|
} else if (name.isEqual("BDAT")) {
|
|
type = ChunkType::BDAT;
|
|
} else if (name.isEqual("PACH")) {
|
|
type = ChunkType::PACH;
|
|
} else if (name.isEqual("FNTS")) {
|
|
type = ChunkType::FNTS;
|
|
} else if (name.isEqual("ODEV")) {
|
|
type = ChunkType::ODEV;
|
|
} else if (name.isEqual("TITL")) {
|
|
type = ChunkType::TITL;
|
|
} else if (name.isEqual("ALOT")) {
|
|
type = ChunkType::ALOT;
|
|
} else if (name.isEqual("ENGR")) {
|
|
type = ChunkType::ENGR;
|
|
} else if (name.isEqual("FMAP")) {
|
|
type = ChunkType::FMAP;
|
|
} else if (name.isEqual("PCPR")) {
|
|
type = ChunkType::PCPR;
|
|
} else if (name.isEqual("LYRC")) {
|
|
type = ChunkType::LYRC;
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
int chunkTypeToMaxTimes(ChunkType type) {
|
|
int maxTimes = -1; // no limit
|
|
|
|
switch (type) {
|
|
case ChunkType::OVSC: {
|
|
maxTimes = 1;
|
|
break;
|
|
}
|
|
case ChunkType::TRKL: {// case ChunkType::TRAK :
|
|
maxTimes = 1;
|
|
break;
|
|
}
|
|
case ChunkType::PAGL: {// case ChunkType::PAGE :
|
|
maxTimes = 1;
|
|
break;
|
|
}
|
|
// case ChunkType::LINE :
|
|
// case ChunkType::STAF :
|
|
case ChunkType::LINL: {
|
|
maxTimes = 1;
|
|
break;
|
|
}
|
|
// case ChunkType::MEAS :
|
|
// case ChunkType::COND :
|
|
// case ChunkType::BDAT :
|
|
case ChunkType::BARL: {
|
|
maxTimes = 1;
|
|
break;
|
|
}
|
|
case ChunkType::PACH:
|
|
case ChunkType::FNTS:
|
|
case ChunkType::ODEV:
|
|
case ChunkType::ALOT:
|
|
case ChunkType::ENGR:
|
|
case ChunkType::FMAP:
|
|
case ChunkType::PCPR: {
|
|
maxTimes = 1;
|
|
break;
|
|
}
|
|
case ChunkType::TITL: {
|
|
maxTimes = 8;
|
|
break;
|
|
}
|
|
case ChunkType::LYRC: {
|
|
maxTimes = 1;
|
|
break;
|
|
}
|
|
// case ChunkType::NONE :
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return maxTimes;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
OveSerialize::OveSerialize() :
|
|
ove_(0),
|
|
streamHandle_(0),
|
|
notify_(0) {
|
|
}
|
|
|
|
OveSerialize::~OveSerialize() {
|
|
if(streamHandle_ != 0) {
|
|
delete streamHandle_;
|
|
streamHandle_ = 0;
|
|
}
|
|
}
|
|
|
|
void OveSerialize::setOve(OveSong* ove) {
|
|
ove_ = ove;
|
|
}
|
|
|
|
void OveSerialize::setFileStream(unsigned char* buffer, unsigned int size) {
|
|
streamHandle_ = new StreamHandle(buffer, size);
|
|
}
|
|
|
|
void OveSerialize::setNotify(IOveNotify* notify) {
|
|
notify_ = notify;
|
|
}
|
|
|
|
void OveSerialize::messageOutError() {
|
|
if (notify_ != NULL) {
|
|
notify_->loadError();
|
|
}
|
|
}
|
|
|
|
void OveSerialize::messageOut(const QString& str) {
|
|
if (notify_ != NULL) {
|
|
notify_->loadInfo(str);
|
|
}
|
|
}
|
|
|
|
bool OveSerialize::load(void) {
|
|
if(streamHandle_ == 0)
|
|
return false;
|
|
|
|
if( !readHeader() ) {
|
|
messageOutError();
|
|
return false;
|
|
}
|
|
|
|
unsigned int i;
|
|
QMap<ChunkType, int> chunkTimes;
|
|
//bool firstEnter = true;
|
|
|
|
for( i=(int)ChunkType::OVSC; i<(int)ChunkType::NONE; ++i ) {
|
|
chunkTimes[(ChunkType)i] = 0;
|
|
}
|
|
|
|
ChunkType chunkType = ChunkType::NONE;
|
|
|
|
do {
|
|
NameBlock nameBlock;
|
|
SizeChunk sizeChunk;
|
|
|
|
if( !readNameBlock(nameBlock) ) { return false; }
|
|
|
|
chunkType = nameToChunkType(nameBlock);
|
|
++chunkTimes[chunkType];
|
|
int maxTime = chunkTypeToMaxTimes(chunkType);
|
|
|
|
if( maxTime > 0 && chunkTimes[chunkType] > maxTime ) {
|
|
messageOut("format not support, chunk appear more than accept.\n");
|
|
return false;
|
|
}
|
|
|
|
switch (chunkType) {
|
|
/*case ChunkType::OVSC :
|
|
{
|
|
if( !readHeadData(&sizeChunk) )
|
|
{
|
|
messageOut_error();
|
|
return false;
|
|
}
|
|
|
|
break;
|
|
}*/
|
|
case ChunkType::TRKL: {
|
|
if (!readTracksData()) {
|
|
messageOutError();
|
|
return false;
|
|
}
|
|
|
|
break;
|
|
}
|
|
case ChunkType::PAGL: {
|
|
if (!readPagesData()) {
|
|
messageOutError();
|
|
return false;
|
|
}
|
|
|
|
break;
|
|
}
|
|
case ChunkType::LINL: {
|
|
if (!readLinesData()) {
|
|
messageOutError();
|
|
return false;
|
|
}
|
|
|
|
break;
|
|
}
|
|
case ChunkType::BARL: {
|
|
if (!readBarsData()) {
|
|
messageOutError();
|
|
return false;
|
|
}
|
|
|
|
break;
|
|
}
|
|
case ChunkType::TRAK:
|
|
case ChunkType::PAGE:
|
|
case ChunkType::LINE:
|
|
case ChunkType::STAF:
|
|
case ChunkType::MEAS:
|
|
case ChunkType::COND:
|
|
case ChunkType::BDAT: {
|
|
return false;
|
|
break;
|
|
}
|
|
case ChunkType::LYRC: {
|
|
SizeChunk lyricChunk;
|
|
if (!readSizeChunk(&lyricChunk)) {
|
|
messageOutError();
|
|
return false;
|
|
}
|
|
|
|
LyricChunkParse parse(ove_);
|
|
|
|
parse.setLyricChunk(&lyricChunk);
|
|
parse.parse();
|
|
|
|
break;
|
|
}
|
|
case ChunkType::TITL: {
|
|
SizeChunk titleChunk;
|
|
if (!readSizeChunk(&titleChunk)) {
|
|
messageOutError();
|
|
return false;
|
|
}
|
|
|
|
TitleChunkParse titleChunkParse(ove_);
|
|
|
|
titleChunkParse.setTitleChunk(&titleChunk);
|
|
titleChunkParse.parse();
|
|
|
|
break;
|
|
}
|
|
case ChunkType::PACH:
|
|
case ChunkType::FNTS:
|
|
case ChunkType::ODEV:
|
|
case ChunkType::ALOT:
|
|
case ChunkType::ENGR:
|
|
case ChunkType::FMAP:
|
|
case ChunkType::PCPR: {
|
|
if (!readSizeChunk(&sizeChunk)) {
|
|
messageOutError();
|
|
return false;
|
|
}
|
|
|
|
break;
|
|
}
|
|
default:
|
|
/*if( firstEnter )
|
|
{
|
|
QString info = "Not compatible file, try to load and save with newer version, Overture 4 is recommended.\n";
|
|
messageOut(info);
|
|
messageOutError();
|
|
|
|
return false;
|
|
}*/
|
|
|
|
break;
|
|
}
|
|
|
|
//firstEnter = false;
|
|
}
|
|
while ( chunkType != ChunkType::NONE );
|
|
|
|
// if( !readOveEnd() ) { return false; }
|
|
|
|
// organize OveData
|
|
OVE::OveOrganizer organizer(ove_);
|
|
organizer.organize();
|
|
|
|
return true;
|
|
}
|
|
|
|
void OveSerialize::release() {
|
|
delete this;
|
|
}
|
|
|
|
bool OveSerialize::readHeader() {
|
|
ChunkType chunkType = ChunkType::NONE;
|
|
NameBlock nameBlock;
|
|
SizeChunk sizeChunk;
|
|
|
|
if (!readNameBlock(nameBlock)) {
|
|
return false;
|
|
}
|
|
|
|
chunkType = nameToChunkType(nameBlock);
|
|
//int maxTime = chunkTypeToMaxTimes(chunkType);
|
|
|
|
if (chunkType == ChunkType::OVSC) {
|
|
if (readHeadData(&sizeChunk)) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
QString info = "Not compatible file, try to load and save with newer version, Overture 4 is recommended.\n";
|
|
messageOut(info);
|
|
|
|
return false;
|
|
}
|
|
|
|
bool OveSerialize::readHeadData(SizeChunk* ovscChunk) {
|
|
if (!readSizeChunk(ovscChunk))
|
|
return false;
|
|
|
|
OvscParse ovscParse(ove_);
|
|
|
|
ovscParse.setNotify(notify_);
|
|
ovscParse.setOvsc(ovscChunk);
|
|
|
|
return ovscParse.parse();
|
|
}
|
|
|
|
bool OveSerialize::readTracksData() {
|
|
GroupChunk trackGroupChunk;
|
|
|
|
if (!readGroupChunk(&trackGroupChunk))
|
|
return false;
|
|
|
|
unsigned int i;
|
|
unsigned short trackCount = trackGroupChunk.getCountBlock()->toCount();
|
|
|
|
for (i = 0; i < trackCount; ++i) {
|
|
SizeChunk* trackChunk = new SizeChunk();
|
|
|
|
if (ove_->getIsVersion4()) {
|
|
if (!readChunkName(trackChunk, Chunk::TrackName)) {
|
|
return false;
|
|
}
|
|
if (!readSizeChunk(trackChunk)) {
|
|
return false;
|
|
}
|
|
} else {
|
|
if (!readDataChunk(trackChunk->getDataBlock(),
|
|
SizeChunk::version3TrackSize)) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
TrackParse trackParse(ove_);
|
|
|
|
trackParse.setTrack(trackChunk);
|
|
trackParse.parse();
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool OveSerialize::readPagesData() {
|
|
GroupChunk pageGroupChunk;
|
|
|
|
if (!readGroupChunk(&pageGroupChunk))
|
|
return false;
|
|
|
|
unsigned short pageCount = pageGroupChunk.getCountBlock()->toCount();
|
|
unsigned int i;
|
|
PageGroupParse parse(ove_);
|
|
|
|
for (i = 0; i < pageCount; ++i) {
|
|
SizeChunk* pageChunk = new SizeChunk();
|
|
|
|
if (!readChunkName(pageChunk, Chunk::PageName)) {
|
|
return false;
|
|
}
|
|
if (!readSizeChunk(pageChunk)) {
|
|
return false;
|
|
}
|
|
|
|
parse.addPage(pageChunk);
|
|
}
|
|
|
|
if (!parse.parse()) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool OveSerialize::readLinesData() {
|
|
GroupChunk lineGroupChunk;
|
|
if (!readGroupChunk(&lineGroupChunk))
|
|
return false;
|
|
|
|
unsigned short lineCount = lineGroupChunk.getCountBlock()->toCount();
|
|
int i;
|
|
unsigned int j;
|
|
QList<SizeChunk*> lineChunks;
|
|
QList<SizeChunk*> staffChunks;
|
|
|
|
for (i = 0; i < lineCount; ++i) {
|
|
SizeChunk* lineChunk = new SizeChunk();
|
|
|
|
if (!readChunkName(lineChunk, Chunk::LineName)) {
|
|
return false;
|
|
}
|
|
if (!readSizeChunk(lineChunk)) {
|
|
return false;
|
|
}
|
|
|
|
lineChunks.push_back(lineChunk);
|
|
|
|
StaffCountGetter getter(ove_);
|
|
unsigned int staffCount = getter.getStaffCount(lineChunk);
|
|
|
|
for (j = 0; j < staffCount; ++j) {
|
|
SizeChunk* staffChunk = new SizeChunk();
|
|
|
|
if (!readChunkName(staffChunk, Chunk::StaffName)) {
|
|
return false;
|
|
}
|
|
if (!readSizeChunk(staffChunk)) {
|
|
return false;
|
|
}
|
|
|
|
staffChunks.push_back(staffChunk);
|
|
}
|
|
}
|
|
|
|
LineGroupParse parse(ove_);
|
|
|
|
parse.setLineGroup(&lineGroupChunk);
|
|
|
|
for (i = 0; i < lineChunks.size(); ++i) {
|
|
parse.addLine(lineChunks[i]);
|
|
}
|
|
|
|
for (i = 0; i < staffChunks.size(); ++i) {
|
|
parse.addStaff(staffChunks[i]);
|
|
}
|
|
|
|
if (!parse.parse()) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool OveSerialize::readBarsData() {
|
|
GroupChunk barGroupChunk;
|
|
if (!readGroupChunk(&barGroupChunk))
|
|
return false;
|
|
|
|
unsigned short measCount = barGroupChunk.getCountBlock()->toCount();
|
|
int i;
|
|
|
|
QList<SizeChunk*> measureChunks;
|
|
QList<SizeChunk*> conductChunks;
|
|
QList<SizeChunk*> bdatChunks;
|
|
|
|
ove_->setTrackBarCount(measCount);
|
|
|
|
// read chunks
|
|
for (i = 0; i < measCount; ++i) {
|
|
SizeChunk* measureChunkPtr = new SizeChunk();
|
|
|
|
if (!readChunkName(measureChunkPtr, Chunk::MeasureName)) {
|
|
return false;
|
|
}
|
|
if (!readSizeChunk(measureChunkPtr)) {
|
|
return false;
|
|
}
|
|
|
|
measureChunks.push_back(measureChunkPtr);
|
|
}
|
|
|
|
for (i = 0; i < measCount; ++i) {
|
|
SizeChunk* conductChunkPtr = new SizeChunk();
|
|
|
|
if (!readChunkName(conductChunkPtr, Chunk::ConductName))
|
|
return false;
|
|
|
|
if (!readSizeChunk(conductChunkPtr))
|
|
return false;
|
|
|
|
conductChunks.push_back(conductChunkPtr);
|
|
}
|
|
|
|
int bdatCount = ove_->getTrackCount() * measCount;
|
|
for (i = 0; i < bdatCount; ++i) {
|
|
SizeChunk* batChunkPtr = new SizeChunk();
|
|
|
|
if (!readChunkName(batChunkPtr, Chunk::BdatName)) {
|
|
return false;
|
|
}
|
|
if (!readSizeChunk(batChunkPtr)) {
|
|
return false;
|
|
}
|
|
|
|
bdatChunks.push_back(batChunkPtr);
|
|
}
|
|
|
|
// parse bars
|
|
BarsParse barsParse(ove_);
|
|
|
|
for (i = 0; i < (int) measureChunks.size(); ++i) {
|
|
barsParse.addMeasure(measureChunks[i]);
|
|
}
|
|
|
|
for (i = 0; i < (int) conductChunks.size(); ++i) {
|
|
barsParse.addConduct(conductChunks[i]);
|
|
}
|
|
|
|
for (i = 0; i < (int) bdatChunks.size(); ++i) {
|
|
barsParse.addBdat(bdatChunks[i]);
|
|
}
|
|
|
|
barsParse.setNotify(notify_);
|
|
if (!barsParse.parse()) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool OveSerialize::readOveEnd() {
|
|
if (streamHandle_ == 0)
|
|
return false;
|
|
|
|
const unsigned int END_OVE1 = 0xffffffff;
|
|
const unsigned int END_OVE2 = 0x00000000;
|
|
unsigned int buffer;
|
|
|
|
if (!streamHandle_->read((char*) &buffer, sizeof(unsigned int)))
|
|
return false;
|
|
|
|
if (buffer != END_OVE1)
|
|
return false;
|
|
|
|
if (!streamHandle_->read((char*) &buffer, sizeof(unsigned int)))
|
|
return false;
|
|
|
|
if (buffer != END_OVE2)
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////
|
|
bool OveSerialize::readNameBlock(NameBlock& nameBlock) {
|
|
if (streamHandle_ == 0)
|
|
return false;
|
|
|
|
if (!streamHandle_->read((char*) nameBlock.data(), nameBlock.size()))
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool OveSerialize::readChunkName(Chunk* /*chunk*/, const QString& name) {
|
|
if (streamHandle_ == 0)
|
|
return false;
|
|
|
|
NameBlock nameBlock;
|
|
|
|
if (!streamHandle_->read((char*) nameBlock.data(), nameBlock.size()))
|
|
return false;
|
|
|
|
if (!(nameBlock.toStrByteArray() == name))
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool OveSerialize::readSizeChunk(SizeChunk* sizeChunk) {
|
|
if (streamHandle_ == 0)
|
|
return false;
|
|
|
|
SizeBlock* sizeBlock = sizeChunk->getSizeBlock();
|
|
|
|
if (!streamHandle_->read((char*) sizeBlock->data(), sizeBlock->size()))
|
|
return false;
|
|
|
|
unsigned int blockSize = sizeBlock->toSize();
|
|
|
|
sizeChunk->getDataBlock()->resize(blockSize);
|
|
|
|
Block* dataBlock = sizeChunk->getDataBlock();
|
|
|
|
if (!streamHandle_->read((char*) dataBlock->data(), blockSize))
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool OveSerialize::readDataChunk(Block* block, unsigned int size) {
|
|
if (streamHandle_ == 0)
|
|
return false;
|
|
|
|
block->resize(size);
|
|
|
|
if (!streamHandle_->read((char*) block->data(), size))
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool OveSerialize::readGroupChunk(GroupChunk* groupChunk) {
|
|
if (streamHandle_ == 0)
|
|
return false;
|
|
|
|
CountBlock* countBlock = groupChunk->getCountBlock();
|
|
|
|
if (!streamHandle_->read((char*) countBlock->data(), countBlock->size()))
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
IOVEStreamLoader* createOveStreamLoader() {
|
|
return new OveSerialize;
|
|
}
|
|
|
|
}
|