Merge lp:~mixxxdevelopers/mixxx/features_trackbeats into lp:~mixxxdevelopers/mixxx/trunk

[Phillip Whelan]

This branch adds the TrackBeats data type for tracking beats as sample offsets. This version uses SoundTouch to derive the beats. A future version will work with aubio, possibly only in the Analyse pane.

[lp:~mixxxdevelopers/mixxx/features_trackbeats]

2536. By RJ Skerry-Ryan on 2011-02-12

Add Beats abstract interface with a BeatGrid implementation.

2537. By RJ Skerry-Ryan on 2011-02-12

Tighten up the Beats/BeatGrid interface a little bit. Add a reimplementation of TrackBeats as BeatMatrix

2538. By RJ Skerry-Ryan on 2011-02-13

Remove TrackBeats. Change TIO, Analyser, and Waveform to use Beats generic interface instead. Add versioned serialization to TrackDAO. Move creation/destruction of the Beats variants into a BeatFactory class. Most awesome class name, ever.

2539. By RJ Skerry-Ryan on 2011-02-13

Fix lack of deletion of RenderObjects in WaveformRenderer

2540. By RJ Skerry-Ryan on 2011-02-13

Add destructor traces for TIO. Delete the WaveformRenderer.

2541. By RJ Skerry-Ryan on 2011-02-13

Tracks are no longer being deleted. Turning on deletion print in TrackDAO. Clear the track cache when TrackDAO is destroyed.

[RJ Skerry-Ryan (rryan)]

Hey Phil,

Nice work. I went ahead and started hacking on it. Here's the rough outline of what I did:

1) Serialized beats had no version associated with them, so we have no way to deprecate a given way of generating them. I added a beats_version column in the schema to go along w/ the beats blob.

2) I wrote an abstract interface I called "Beats" which is the core of the methods behind TrackBeats, except without all the Seconds variants of the methods. I think it's best just to support one and make the caller deal w/ it. It makes the interface simpler.

3) I expanded the interface to cover measuring the average BPM, scaling the entire range, also finding the beat closest to a given sample.

4) I added a capabilities enum to the Beats so that a Beats implementation can express whether it supports mutation, translation, scaling, add/removing beats, and moving beats.

5) I made two Beats subclasses -- BeatGrid and BeatMatrix. A BeatGrid is a mathematically-backed beatgrid from an average BPM and a sample location of the first beat. A BeatMatrix is just TrackBeats renamed, it stores a BeatList of beat sample locations. I didn't really think it made sense to use a BeatMatrix for the transition, since it would waste a lot of database space from something that could be mathematically generated for free. A BeatGrid is serialized to the database as just those two doubles.

6) I updated the WaveformRenderBeat and AnalyserBpm to use the track's Beats instance.

7) I created a BeatFactory class to handle the creation and deletion of Beats instances.

8) Fixed some merge issues with trunk, some parameters in SQL statements were dropped.

I think you mentioned you saw the Beats were not getting destroyed. I see a bigger problem now which is that the Track's are not getting destroyed either. I think that this is a bug in Mixxx trunk right now too, so hopefully it gets fixed when it's fixed there. There are a lot of random parts of Mixxx that are not getting deleted correctly, so we just have to find all these.

Since I'm hacking on this too, I think Albert should be the branch reviewer.

review: Approve

[lp:~mixxxdevelopers/mixxx/features_trackbeats]

2542. By RJ Skerry-Ryan on 2011-02-13

Fix SQL statement that got munged by a merge.

[RJ Skerry-Ryan (rryan)]

Oops, accidentally approved. Ignore that.

[lp:~mixxxdevelopers/mixxx/features_trackbeats]

2543. By RJ Skerry-Ryan on 2011-02-13

Rephrase :wavesummaryhex binding to match :beats

2544. By RJ Skerry-Ryan on 2011-02-13

Doh. Forgot to add BeatFactory files

2545. By Phillip Whelan on 2011-02-15

FIX: error in ternary syntax.

2546. By Phillip Whelan on 2011-02-15

FIX: generate BeatGrid if we do not have a beatgrid but we have detected the BPM of the song already.

2547. By Phillip Whelan on 2011-02-15

Various changes will bring the new Beats classes into feature parity with the
old trackbeats code.

  * beatfactory.cpp: include beatgrid.h and beatmatrix.h because forward
                     declaration proved to not be enough.
  * beats.h, beatgrid.h, beatmatrix.h: adding findNthBeat method.
  * beatgrid.cpp: many changes and fixes, including adding findNthBeat.
      - implement findNthBeat. calculate the beat using m_dFirstBeat.
      - reimplement findPrevBeat and findNextBeat using findNthBeat.
      - replace all other beat calculations with calls to findNextBeat.
  * beatmatrix.cpp:
      - implement findNthBeat.
      - reimplement findPrevBeat and findNextBeat using findNthBeat.

2548. By RJ Skerry-Ryan on 2011-02-15

Add language to beats.h that makes clear the behavior of findNextBeat and findPrevBeat when dSamples refers to the location of a beat.

2549. By RJ Skerry-Ryan on 2011-02-15

BeatMatrix::findNthBeat fixes for going in the negative direction. Changed variable from offset to n and updated comments to reflect that.

2550. By RJ Skerry-Ryan on 2011-02-15

Fixup BeatGrid::findNextBeat a little bit. It wasn't doing the previous direction correctly.

2551. By RJ Skerry-Ryan on 2011-02-15

Add some parameter checks to BeatGrid.

2552. By RJ Skerry-Ryan on 2011-02-15

Move BeatGrid legacy check from AnalyserBpm to TrackDAO so that any track loaded from DB will get a BeatGrid if it does not have one already and already has a BPM (or if the file metadata has a stored BPM)

2553. By Phillip Whelan on 2011-02-23

Merging from trunk.

2554. By RJ Skerry-Ryan on 2011-02-26

Move beat-related classes to track/

[Albert Santoni (gamegod)]

- Fix the commented pointer leak in TrackDAO::bindTrackToLibraryInsert()

- What was the final verdict on how adding these large blobs to the database will impact subsequent query performance? It would be good to document this since it likely won't be the last time we have to store blobs in the database. (eg. cover art)

- Probably wouldn't hurt to make those version strings in BeatFactory constants defined in the header.

- For the BeatGrid byte array, would it make sense to pack/unpack the blob as a C-style struct? You've got code like this:
+ pBuffer[0] = m_dBpm;
+ pBuffer[1] = m_dFirstBeat;
... and your schema for the format of this buffer is spread out all over the place. For example, BeatGrid::toByteArray() has a hardcoded sizeof(double) * 2 here:

+ QByteArray* pByteArray = new QByteArray((char*)pBuffer, sizeof(double) * 2);

and similarly, readByteArray() has an assert with the same hardcoded length. Using a C-style struct will probably make that code less fragile (eg. sizeof(MyBeatsStruct)).

- void BeatGrid::readByteArray(QByteArray* pByteArray) ---> Did you mean a const QByteArray* ?
:)

- BeatGrid::findNthBeat(...) might lead to unintended behaviour if dSamples is negative. (???)

- The naming of these classes is very confusing. Matrix and grid are synonyms, so I'm barring you from using those words to describe different classes. Names that may be more clear could be "ExtrapolatedBeatGrid" and "CustomBeatGrid".

Otherwise, code looks pretty good. I hope it works. :)

I'll do some testing next time I have a chance and take another pass at the code.

Thanks guys!
Albert

review: Needs Fixing

[lp:~mixxxdevelopers/mixxx/features_trackbeats]

2555. By Phillip Whelan on 2011-02-27

Merging from Repository.

2556. By Phillip Whelan on 2011-03-02

Use a struct for (de)serializing the beat, for beatgrid, from the database.

2557. By Phillip Whelan on 2011-03-02

Undo application of SSE3 patch (not the time nor the place for it).

[Phillip Whelan (pwhelan)]

> - BeatGrid::findNthBeat(...) might lead to unintended behaviour if dSamples is negative. (???)

With the extrapolated beat grid (currently called 'BeatGrid') this will simply return a negative sample offset. Caller beware.

As for the custom beat grid (currently called 'BeatMatrix'), it should just return a simple 0.

[lp:~mixxxdevelopers/mixxx/features_trackbeats]

2558. By Phillip Whelan on 2011-03-03

Make the QByteArray argument to readByteArray and both Beat classes a const.

2559. By Albert Santoni on 2011-03-07

Rename struct to BeatGridData and fixed QByteArray pointer leak in TrackDAO.

2560. By Albert Santoni on 2011-03-07

Merge from trunk

[Albert Santoni (gamegod)]

Phil and I fixed the remaining stuff from my review. Approve and merged into trunk tonight.

review: Approve

=== modified file 'mixxx/build/depends.py'
--- mixxx/build/depends.py	2011-03-04 09:09:44 +0000
+++ mixxx/build/depends.py	2011-03-07 05:53:37 +0000
@@ -540,6 +540,10 @@
 
                    "sampleutil.cpp",
                    "trackinfoobject.cpp",
+                   "track/beatgrid.cpp",
+                   "track/beatmatrix.cpp",
+                   "track/beatfactory.cpp",
+
                    "baseplayer.cpp",
                    "basetrackplayer.cpp",
                    "deck.cpp",
 
=== modified file 'mixxx/res/schema.xml'
--- mixxx/res/schema.xml	2011-02-21 07:01:11 +0000
+++ mixxx/res/schema.xml	2011-03-07 05:53:37 +0000
@@ -266,4 +266,13 @@
         );
     </sql>
   </revision>
+  <revision version="12" min_compatible="3">
+    <description>
+      Add beats column to library table.
+    </description>
+    <sql>
+      ALTER TABLE Library ADD COLUMN beats BLOB;
+      ALTER TABLE Library ADD COLUMN beats_version TEXT;
+    </sql>
+  </revision>
 </schema>
 
=== modified file 'mixxx/src/analyserbpm.cpp'
--- mixxx/src/analyserbpm.cpp	2010-10-19 01:35:26 +0000
+++ mixxx/src/analyserbpm.cpp	2011-03-07 05:53:37 +0000
@@ -3,6 +3,8 @@
 
 #include "BPMDetect.h"
 #include "trackinfoobject.h"
+#include "track/beatgrid.h"
+#include "track/beatfactory.h"
 #include "analyserbpm.h"
 
 
@@ -20,9 +22,9 @@
     // int defaultrange = m_pConfig->getValueString(ConfigKey("[BPM]","BPMAboveRangeEnabled")).toInt();
     bool bpmEnabled = (bool)m_pConfig->getValueString(ConfigKey("[BPM]","BPMDetectionEnabled")).toInt();
 
-    // If BPM detection is not enabled, or the track already has BPM detection done.
-    if(bpmEnabled &&
-       tio->getBpm() == 0.) {
+    // If BPM detection is enabled and the track does not have a BPM already,
+    // create a detector.
+    if(bpmEnabled && tio->getBpm() == 0.) {
         // All SoundSource's return stereo data, no matter the real file's type
         m_pDetector = new soundtouch::BPMDetect(2, sampleRate);
         //m_pDetector = new BPMDetect(tio->getChannels(), sampleRate);
@@ -31,10 +33,7 @@
     }
 }
 
-
-
 void AnalyserBPM::process(const CSAMPLE *pIn, const int iLen) {
-
     // Check if BPM detection is enabled
     if(m_pDetector == NULL) {
         return;
@@ -42,7 +41,6 @@
     //qDebug() << "AnalyserBPM::process() processing " << iLen << " samples";
 
     m_pDetector->inputSamples(pIn, iLen/2);
-
 }
 
 float AnalyserBPM::correctBPM( float BPM, int min, int max, int aboveRange) {
@@ -71,6 +69,13 @@
 
         tio->setBpm(newbpm);
         tio->setBpmConfirm();
+
+        // Currently, the BPM is only analyzed if the track has no BPM. This
+        // means we don't have to worry that the track already has an existing
+        // BeatGrid.
+        BeatsPointer pBeats = BeatFactory::makeBeatGrid(tio, newbpm, 0.0f);
+        tio->setBeats(pBeats);
+
         //if(pBpmReceiver) {
         //pBpmReceiver->setComplete(tio, false, bpm);
         //}
 
=== modified file 'mixxx/src/analyserbpm.h'
--- mixxx/src/analyserbpm.h	2010-07-15 19:07:16 +0000
+++ mixxx/src/analyserbpm.h	2011-03-07 05:53:37 +0000
@@ -8,7 +8,6 @@
 
 
 class AnalyserBPM : public Analyser {
-
   public:
     AnalyserBPM(ConfigObject<ConfigValue> *_config);
     void initialise(TrackPointer tio, int sampleRate, int totalSamples);
@@ -22,7 +21,6 @@
     soundtouch::BPMDetect *m_pDetector;
     int m_iMinBpm, m_iMaxBpm;
     bool m_bProcessEntireSong;
-
 };
 
 #endif
 
=== modified file 'mixxx/src/basetrackplayer.cpp'
--- mixxx/src/basetrackplayer.cpp	2010-11-17 21:02:24 +0000
+++ mixxx/src/basetrackplayer.cpp	2011-03-07 05:53:37 +0000
@@ -98,6 +98,7 @@
     delete m_pPlayPosition;
     delete m_pBPM;
     delete m_pReplayGain;
+    delete m_pWaveformRenderer;
 }
 
 void BaseTrackPlayer::slotLoadTrack(TrackPointer track, bool bStartFromEndPos)
@@ -184,7 +185,7 @@
     // Read the tags if required
     if(!m_pLoadedTrack->getHeaderParsed())
         SoundSourceProxy::ParseHeader(m_pLoadedTrack.data());
-    
+
     m_pLoadedTrack->incTimesPlayed();
 
     // Generate waveform summary
 
=== modified file 'mixxx/src/library/dao/trackdao.cpp'
--- mixxx/src/library/dao/trackdao.cpp	2010-12-02 22:17:33 +0000
+++ mixxx/src/library/dao/trackdao.cpp	2011-03-07 05:53:37 +0000
@@ -2,7 +2,10 @@
 #include <QtDebug>
 #include <QtCore>
 #include <QtSql>
+
 #include "trackinfoobject.h"
+#include "track/beats.h"
+#include "track/beatfactory.h"
 #include "library/dao/trackdao.h"
 #include "audiotagger.h"
 
@@ -35,6 +38,8 @@
 
 TrackDAO::~TrackDAO()
 {
+    qDebug() << "~TrackDAO()";
+    clearCache();
 }
 
 void TrackDAO::initialize()
@@ -218,13 +223,13 @@
                   "filetype, location, comment, url, duration, rating, key, "
                   "bitrate, samplerate, cuepoint, bpm, replaygain, wavesummaryhex, "
                   "timesplayed, "
-                  "channels, mixxx_deleted, header_parsed) "
+                  "channels, mixxx_deleted, header_parsed, beats_version, beats) "
                   "VALUES (:artist, "
                   ":title, :album, :year, :genre, :tracknumber, "
-                  ":filetype, :location, :comment, :url, :duration, :rating, :key,"
+                  ":filetype, :location, :comment, :url, :duration, :rating, :key, "
                   ":bitrate, :samplerate, :cuepoint, :bpm, :replaygain, :wavesummaryhex, "
                   ":timesplayed, "
-                  ":channels, :mixxx_deleted, :header_parsed)");
+                  ":channels, :mixxx_deleted, :header_parsed, :beats_version, :beats)");
 }
 
 void TrackDAO::bindTrackToLibraryInsert(QSqlQuery& query, TrackInfoObject* pTrack, int trackLocationId) {
@@ -243,17 +248,33 @@
     query.bindValue(":bitrate", pTrack->getBitrate());
     query.bindValue(":samplerate", pTrack->getSampleRate());
     query.bindValue(":cuepoint", pTrack->getCuePoint());
-    query.bindValue(":bpm", pTrack->getBpm());
+
     query.bindValue(":replaygain", pTrack->getReplayGain());
     query.bindValue(":key", pTrack->getKey());
     const QByteArray* pWaveSummary = pTrack->getWaveSummary();
-    if (pWaveSummary) //Avoid null pointer deref
-        query.bindValue(":wavesummaryhex", *pWaveSummary);
+    query.bindValue(":wavesummaryhex", pWaveSummary ? *pWaveSummary : QVariant(QVariant::ByteArray));
     query.bindValue(":timesplayed", pTrack->getTimesPlayed());
     //query.bindValue(":datetime_added", pTrack->getDateAdded());
     query.bindValue(":channels", pTrack->getChannels());
     query.bindValue(":mixxx_deleted", 0);
     query.bindValue(":header_parsed", pTrack->getHeaderParsed() ? 1 : 0);
+
+    const QByteArray* pBeatsBlob = NULL;
+    QString blobVersion = "";
+    BeatsPointer pBeats = pTrack->getBeats();
+    // Fall back on cached BPM
+    double dBpm = pTrack->getBpm();
+
+    if (pBeats) {
+        pBeatsBlob = pBeats->toByteArray();
+        blobVersion = pBeats->getVersion();
+        dBpm = pBeats->getBpm();
+    }
+
+    query.bindValue(":bpm", dBpm);
+    query.bindValue(":beats_version", blobVersion);
+    query.bindValue(":beats", pBeatsBlob ? *pBeatsBlob : QVariant(QVariant::ByteArray));
+    delete pBeatsBlob;
 }
 
 void TrackDAO::addTracks(QList<TrackInfoObject*> tracksToAdd) {
@@ -306,7 +327,8 @@
         bindTrackToLibraryInsert(query, pTrack, pTrack->getId());
 
         if (!query.exec()) {
-            qDebug() << "Failed to INSERT new track into library"
+            qDebug() << "Failed to INSERT new track into library:"
+                         << pTrack->getFilename()
                      << __FILE__ << __LINE__ << query.lastError();
             m_database.rollback();
             return;
@@ -495,7 +517,7 @@
 void TrackDAO::deleteTrack(TrackInfoObject* pTrack) {
     Q_ASSERT(pTrack);
 
-    //qDebug() << "Got deletion call for track" << pTrack << "ID" << pTrack->getId() << pTrack->getInfo();
+    qDebug() << "Got deletion call for track" << pTrack << "ID" << pTrack->getId() << pTrack->getInfo();
 
     // Save dirty tracks.
     pTrack->save();
@@ -521,8 +543,8 @@
 
     int locationId = -1;
     while (query.next()) {
+        // Good god! Assign query.record() to a freaking variable!
         int trackId = query.value(query.record().indexOf("id")).toInt();
-
         QString artist = query.value(query.record().indexOf("artist")).toString();
         QString title = query.value(query.record().indexOf("title")).toString();
         QString album = query.value(query.record().indexOf("album")).toString();
@@ -550,6 +572,7 @@
         bool header_parsed = query.value(query.record().indexOf("header_parsed")).toBool();
 
         TrackInfoObject* track = new TrackInfoObject(location, false);
+        TrackPointer pTrack = TrackPointer(track, this->deleteTrack);
 
         // TIO already stats the file to see if it exists, what its length is,
         // etc. So don't bother setting it.
@@ -575,6 +598,14 @@
         track->setReplayGain(replaygain.toFloat());
         track->setWaveSummary(wavesummaryhex, false);
         delete wavesummaryhex;
+
+        QString beatsVersion = query.value(query.record().indexOf("beats_version")).toString();
+        QByteArray beatsBlob = query.value(query.record().indexOf("beats")).toByteArray();
+        BeatsPointer pBeats = BeatFactory::loadBeatsFromByteArray(pTrack, beatsVersion, &beatsBlob);
+        if (pBeats) {
+            pTrack->setBeats(pBeats);
+        }
+
         track->setTimesPlayed(timesplayed);
         track->setPlayed(played);
         track->setChannels(channels);
@@ -593,8 +624,6 @@
         connect(track, SIGNAL(save()),
                 this, SLOT(slotTrackSave()));
 
-        TrackPointer pTrack = TrackPointer(track, this->deleteTrack);
-
         // Automatic conversion to a weak pointer
         m_tracks[trackId] = pTrack;
         m_trackCache.insert(trackId, new TrackPointer(pTrack));
@@ -606,6 +635,15 @@
             pTrack->parse();
         }
 
+        if (!pBeats && pTrack->getBpm() != 0.0f) {
+            // The track has no stored beats but has a previously detected BPM
+            // or a BPM loaded from metadata. Automatically create a beatgrid
+            // for the track. This dirties the track so we have to do it after
+            // all the signal connections, etc. are in place.
+            BeatsPointer pBeats = BeatFactory::makeBeatGrid(pTrack, pTrack->getBpm(), 0.0f);
+            pTrack->setBeats(pBeats);
+        }
+
         return pTrack;
     }
     //query.finish();
@@ -647,7 +685,17 @@
     time.start();
     QSqlQuery query(m_database);
 
-    query.prepare("SELECT library.id, artist, title, album, year, genre, tracknumber, filetype, rating, key, track_locations.location as location, track_locations.filesize as filesize, comment, url, duration, bitrate, samplerate, cuepoint, bpm, replaygain, wavesummaryhex, channels, header_parsed, timesplayed, played FROM Library INNER JOIN track_locations ON library.location = track_locations.id WHERE library.id=" + QString("%1").arg(id));
+    query.prepare(
+        "SELECT library.id, artist, title, album, year, genre, tracknumber, "
+        "filetype, rating, key, track_locations.location as location, "
+        "track_locations.filesize as filesize, comment, url, duration, bitrate, "
+        "samplerate, cuepoint, bpm, replaygain, wavesummaryhex, channels, "
+        "header_parsed, timesplayed, played, beats_version, beats "
+        "FROM Library "
+        "INNER JOIN track_locations "
+            "ON library.location = track_locations.id "
+        "WHERE library.id=" + QString("%1").arg(id)
+    );
 
     TrackPointer pTrack;
 
@@ -686,7 +734,8 @@
                   "bitrate=:bitrate, samplerate=:samplerate, cuepoint=:cuepoint, "
                   "bpm=:bpm, replaygain=:replaygain, wavesummaryhex=:wavesummaryhex, "
                   "timesplayed=:timesplayed, played=:played, "
-                  "channels=:channels, header_parsed=:header_parsed "
+                  "channels=:channels, header_parsed=:header_parsed, "
+                  "beats_version=:beats_version, beats=:beats "
                   "WHERE id="+QString("%1").arg(trackId));
     query.bindValue(":artist", pTrack->getArtist());
     query.bindValue(":title", pTrack->getTitle());
@@ -701,19 +750,33 @@
     query.bindValue(":bitrate", pTrack->getBitrate());
     query.bindValue(":samplerate", pTrack->getSampleRate());
     query.bindValue(":cuepoint", pTrack->getCuePoint());
-    query.bindValue(":bpm", pTrack->getBpm());
+
     query.bindValue(":replaygain", pTrack->getReplayGain());
     query.bindValue(":key", pTrack->getKey());
     query.bindValue(":rating", pTrack->getRating());
     const QByteArray* pWaveSummary = pTrack->getWaveSummary();
-    if (pWaveSummary) //Avoid null pointer deref
-        query.bindValue(":wavesummaryhex", *pWaveSummary);
+    query.bindValue(":wavesummaryhex", pWaveSummary ? *pWaveSummary : QVariant(QVariant::ByteArray));
     query.bindValue(":timesplayed", pTrack->getTimesPlayed());
     query.bindValue(":played", pTrack->getPlayed());
     query.bindValue(":channels", pTrack->getChannels());
     query.bindValue(":header_parsed", pTrack->getHeaderParsed() ? 1 : 0);
     //query.bindValue(":location", pTrack->getLocation());
 
+    BeatsPointer pBeats = pTrack->getBeats();
+    QByteArray* pBeatsBlob = NULL;
+    QString beatsVersion = "";
+    double dBpm = pTrack->getBpm();
+
+    if (pBeats) {
+        pBeatsBlob = pBeats->toByteArray();
+        beatsVersion = pBeats->getVersion();
+        dBpm = pBeats->getBpm();
+    }
+
+    query.bindValue(":beats", pBeatsBlob ? *pBeatsBlob : QVariant(QVariant::ByteArray));
+    query.bindValue(":beats_version", beatsVersion);
+    query.bindValue(":bpm", dBpm);
+
     if (!query.exec()) {
         qDebug() << query.lastError();
         m_database.rollback();
 
=== modified file 'mixxx/src/library/trackcollection.cpp'
--- mixxx/src/library/trackcollection.cpp	2011-02-21 07:01:11 +0000
+++ mixxx/src/library/trackcollection.cpp	2011-03-07 05:53:37 +0000
@@ -68,7 +68,7 @@
         return false;
     }
 
-    int requiredSchemaVersion = 11;
+    int requiredSchemaVersion = 12;
     if (!SchemaManager::upgradeToSchemaVersion(m_pConfig, m_db,
                                                requiredSchemaVersion)) {
         QMessageBox::warning(0, tr("Cannot upgrade database schema"),
 
=== added directory 'mixxx/src/track'
=== added file 'mixxx/src/track/beatfactory.cpp'
--- mixxx/src/track/beatfactory.cpp	1970-01-01 00:00:00 +0000
+++ mixxx/src/track/beatfactory.cpp	2011-03-07 05:53:37 +0000
@@ -0,0 +1,43 @@
+#include <QtDebug>
+
+#include "track/beatgrid.h"
+#include "track/beatmatrix.h"
+#include "track/beatfactory.h"
+
+BeatsPointer BeatFactory::loadBeatsFromByteArray(TrackPointer pTrack, QString beatsVersion,
+                                                 QByteArray* beatsSerialized) {
+    // TODO(XXX) make it so the version strings are not in multiple places
+    if (beatsVersion == "BeatGrid-1.0") {
+        BeatGrid* pGrid = new BeatGrid(pTrack, beatsSerialized);
+        pGrid->moveToThread(pTrack->thread());
+        pGrid->setParent(pTrack.data());
+        qDebug() << "Successfully deserialized BeatGrid";
+        return BeatsPointer(pGrid, &BeatFactory::deleteBeats);
+    } else if (beatsVersion == "BeatMatrix-1.0") {
+        BeatMatrix* pMatrix = new BeatMatrix(pTrack, beatsSerialized);
+        pMatrix->moveToThread(pTrack->thread());
+        pMatrix->setParent(pTrack.data());
+        qDebug() << "Successfully deserialized BeatMatrix";
+        return BeatsPointer(pMatrix, &BeatFactory::deleteBeats);
+    }
+    qDebug() << "BeatFactory::loadBeatsFromByteArray could not parse serialized beats.";
+    return BeatsPointer();
+}
+
+BeatsPointer BeatFactory::makeBeatGrid(TrackPointer pTrack, double dBpm, double dFirstBeatSample) {
+    BeatGrid* pGrid = new BeatGrid(pTrack);
+    pGrid->setGrid(dBpm, dFirstBeatSample);
+    return BeatsPointer(pGrid, &BeatFactory::deleteBeats);
+}
+
+void BeatFactory::deleteBeats(Beats* pBeats) {
+    // This assumes all Beats* variants multiply-inherit from QObject. Kind of ugly. Oh well.
+    QObject* pObject = dynamic_cast<QObject*>(pBeats);
+
+    if (pObject != NULL) {
+        qDebug() << "Deleting QObject instance.";
+        pObject->deleteLater();
+    } else {
+        qDebug() << "Could not delete Beats instance, did not dynamic_cast to QObject";
+    }
+}
 
=== added file 'mixxx/src/track/beatfactory.h'
--- mixxx/src/track/beatfactory.h	1970-01-01 00:00:00 +0000
+++ mixxx/src/track/beatfactory.h	2011-03-07 05:53:37 +0000
@@ -0,0 +1,19 @@
+#ifndef BEATFACTORY_H
+#define BEATFACTORY_H
+
+#include "track/beats.h"
+#include "track/beatgrid.h"
+#include "track/beatmatrix.h"
+
+class BeatFactory {
+  public:
+    static BeatsPointer loadBeatsFromByteArray(TrackPointer pTrack,
+                                               QString beatsVersion,
+                                               QByteArray* beatsSerialized);
+    static BeatsPointer makeBeatGrid(TrackPointer pTrack,
+                                     double dBpm, double dFirstBeatSample);
+  private:
+    static void deleteBeats(Beats* pBeats);
+};
+
+#endif /* BEATFACTORY_H */
 
=== added file 'mixxx/src/track/beatgrid.cpp'
--- mixxx/src/track/beatgrid.cpp	1970-01-01 00:00:00 +0000
+++ mixxx/src/track/beatgrid.cpp	2011-03-07 05:53:37 +0000
@@ -0,0 +1,186 @@
+#include <QMutexLocker>
+#include <QDebug>
+
+#include "track/beatgrid.h"
+
+
+struct BeatGridData {
+	double bpm;
+	double firstBeat;
+};
+
+BeatGrid::BeatGrid(TrackPointer pTrack, const QByteArray* pByteArray)
+        : QObject(),
+          m_mutex(QMutex::Recursive),
+          m_iSampleRate(pTrack->getSampleRate()),
+          m_dBpm(0.0f),
+          m_dFirstBeat(0.0f),
+          m_dBeatLength(0.0f) {
+    connect(pTrack.data(), SIGNAL(bpmUpdated(double)),
+            this, SLOT(slotTrackBpmUpdated(double)));
+
+    qDebug() << "New BeatGrid";
+    if (pByteArray != NULL) {
+        readByteArray(pByteArray);
+    }
+}
+
+BeatGrid::~BeatGrid() {
+	
+}
+
+void BeatGrid::setGrid(double dBpm, double dFirstBeatSample) {
+    QMutexLocker lock(&m_mutex);
+    m_dBpm = dBpm;
+    m_dFirstBeat = dFirstBeatSample;
+    m_dBeatLength = 60.0 * m_iSampleRate / m_dBpm;
+}
+
+QByteArray* BeatGrid::toByteArray() const {
+    QMutexLocker locker(&m_mutex);
+    BeatGridData blob = { m_dBpm, m_dFirstBeat };
+    QByteArray* pByteArray = new QByteArray((char *)&blob, sizeof(blob));
+    return pByteArray;
+}
+
+void BeatGrid::readByteArray(const QByteArray* pByteArray) {
+    if ( pByteArray->size() != sizeof(BeatGridData))
+        return;
+    BeatGridData *blob = (BeatGridData *)pByteArray->data();
+    setGrid(blob->bpm, blob->firstBeat);
+}
+
+QString BeatGrid::getVersion() const {
+    QMutexLocker locker(&m_mutex);
+    return "BeatGrid-1.0";
+}
+
+// internal use only
+bool BeatGrid::isValid() const {
+    return m_iSampleRate > 0 && m_dBpm > 0;
+}
+
+// This could be implemented in the Beats Class itself.
+// If necessary, the child class can redefine it.
+double BeatGrid::findNextBeat(double dSamples) const {
+    return findNthBeat(dSamples, +1);
+}
+
+// This could be implemented in the Beats Class itself.
+// If necessary, the child class can redefine it.
+double BeatGrid::findPrevBeat(double dSamples) const {
+    return findNthBeat(dSamples, -1);
+}
+
+// This is an internal call. This could be implemented in the Beats Class itself.
+double BeatGrid::findClosestBeat(double dSamples) const {
+    QMutexLocker locker(&m_mutex);
+    if (!isValid()) {
+        return -1;
+    }
+    double nextBeat = findNextBeat(dSamples);
+    double prevBeat = findPrevBeat(dSamples);
+    return (nextBeat - dSamples > dSamples - prevBeat) ? prevBeat : nextBeat;
+}
+
+double BeatGrid::findNthBeat(double dSamples, int n) const {
+    QMutexLocker locker(&m_mutex);
+    if (!isValid() || n == 0) {
+        return -1;
+    }
+
+    double dClosestBeat;
+    if (n > 0) {
+        // We're going forward, so use ceilf to round up to the next multiple of
+        // m_dBeatLength
+        dClosestBeat = ceilf(dSamples/m_dBeatLength) * m_dBeatLength + m_dFirstBeat;
+        n = n - 1;
+    } else {
+        // We're going backward, so use floorf to round up to the next multiple
+        // of m_dBeatLength
+        dClosestBeat = floorf(dSamples/m_dBeatLength) * m_dBeatLength + m_dFirstBeat;
+        n = n + 1;
+    }
+
+    return dClosestBeat + n * m_dBeatLength;
+}
+
+void BeatGrid::findBeats(double startSample, double stopSample, QList<double>* pBeatsList) const {
+    QMutexLocker locker(&m_mutex);
+    if (!isValid() || startSample > stopSample) {
+        return;
+    }
+    double curBeat = findNextBeat(startSample);
+    while (curBeat <= stopSample) {
+        pBeatsList->append(curBeat);
+        curBeat += m_dBeatLength;
+    }
+}
+
+bool BeatGrid::hasBeatInRange(double startSample, double stopSample) const {
+    QMutexLocker locker(&m_mutex);
+    if (!isValid() || startSample > stopSample) {
+        return false;
+    }
+    double curBeat = findNextBeat(startSample);
+    if (curBeat <= stopSample) {
+        return true;
+    }
+    return false;
+}
+
+double BeatGrid::getBpm() const {
+    QMutexLocker locker(&m_mutex);
+    if (!isValid()) {
+        return -1;
+    }
+    return m_dBpm;
+}
+
+double BeatGrid::getBpmRange(double startSample, double stopSample) const {
+    QMutexLocker locker(&m_mutex);
+    if (!isValid() || startSample > stopSample) {
+        return -1;
+    }
+    return m_dBpm;
+}
+
+void BeatGrid::addBeat(double dBeatSample) {
+    //QMutexLocker locker(&m_mutex);
+    return;
+}
+
+void BeatGrid::removeBeat(double dBeatSample) {
+    //QMutexLocker locker(&m_mutex);
+    return;
+}
+
+void BeatGrid::moveBeat(double dBeatSample, double dNewBeatSample) {
+    //QMutexLocker locker(&m_mutex);
+    return;
+}
+
+void BeatGrid::translate(double dNumSamples) {
+    QMutexLocker locker(&m_mutex);
+    if (!isValid()) {
+        return;
+    }
+    m_dFirstBeat += dNumSamples;
+    locker.unlock();
+    emit(updated());
+}
+
+void BeatGrid::scale(double dScalePercentage) {
+    QMutexLocker locker(&m_mutex);
+    if (!isValid()) {
+        return;
+    }
+    m_dBpm *= dScalePercentage;
+    locker.unlock();
+    emit(updated());
+}
+
+void BeatGrid::slotTrackBpmUpdated(double dBpm) {
+    QMutexLocker locker(&m_mutex);
+    m_dBpm = dBpm;
+}
 
=== added file 'mixxx/src/track/beatgrid.h'
--- mixxx/src/track/beatgrid.h	1970-01-01 00:00:00 +0000
+++ mixxx/src/track/beatgrid.h	2011-03-07 05:53:37 +0000
@@ -0,0 +1,75 @@
+#ifndef BEATGRID_H
+#define BEATGRID_H
+
+#include <QMutex>
+#include <QObject>
+
+#include "trackinfoobject.h"
+#include "track/beats.h"
+
+// BeatGrid is an implementation of the Beats interface that implements an
+// infinite grid of beats, aligned to a song simply by a starting offset of the
+// first beat and the song's average beats-per-minute.
+class BeatGrid : public QObject, public virtual Beats {
+    Q_OBJECT
+  public:
+    BeatGrid(TrackPointer pTrack, const QByteArray* pByteArray=NULL);
+    virtual ~BeatGrid();
+
+    // Initializes the BeatGrid to have a BPM of dBpm and the first beat offset
+    // of dFirstBeatSample. Does not generate an updated() signal, since it is
+    // meant for initialization.
+    void setGrid(double dBpm, double dFirstBeatSample);
+
+    // The following are all methods from the Beats interface, see method
+    // comments in beats.h
+
+    virtual Beats::CapabilitiesFlags getCapabilities() const {
+        return BEATSCAP_TRANSLATE | BEATSCAP_SCALE;
+    }
+
+    virtual QByteArray* toByteArray() const;
+    virtual QString getVersion() const;
+
+    ////////////////////////////////////////////////////////////////////////////
+    // Beat calculations
+    ////////////////////////////////////////////////////////////////////////////
+
+    virtual double findNextBeat(double dSamples) const;
+    virtual double findPrevBeat(double dSamples) const;
+    virtual double findClosestBeat(double dSamples) const;
+    virtual double findNthBeat(double dSamples, int n) const;
+    virtual void findBeats(double startSample, double stopSample, BeatList* pBeatsList) const;
+    virtual bool hasBeatInRange(double startSample, double stopSample) const;
+    virtual double getBpm() const;
+    virtual double getBpmRange(double startSample, double stopSample) const;
+
+    ////////////////////////////////////////////////////////////////////////////
+    // Beat mutations
+    ////////////////////////////////////////////////////////////////////////////
+
+    virtual void addBeat(double dBeatSample);
+    virtual void removeBeat(double dBeatSample);
+    virtual void moveBeat(double dBeatSample, double dNewBeatSample);
+    virtual void translate(double dNumSamples);
+    virtual void scale(double dScalePercentage);
+
+  signals:
+    void updated();
+
+  private slots:
+    void slotTrackBpmUpdated(double bpm);
+
+  private:
+    void readByteArray(const QByteArray* pByteArray);
+    // For internal use only.
+    bool isValid() const;
+
+    mutable QMutex m_mutex;
+    int m_iSampleRate;
+    double m_dBpm, m_dFirstBeat;
+    double m_dBeatLength;
+};
+
+
+#endif /* BEATGRID_H */
 
=== added file 'mixxx/src/track/beatmatrix.cpp'
--- mixxx/src/track/beatmatrix.cpp	1970-01-01 00:00:00 +0000
+++ mixxx/src/track/beatmatrix.cpp	2011-03-07 05:53:37 +0000
@@ -0,0 +1,271 @@
+#include <QtDebug>
+#include <QMutexLocker>
+
+#include "track/beatmatrix.h"
+
+BeatMatrix::BeatMatrix(TrackPointer pTrack, const QByteArray* pByteArray)
+        : QObject(),
+          m_mutex(QMutex::Recursive),
+          m_iSampleRate(pTrack->getSampleRate()) {
+    if (pByteArray != NULL) {
+        readByteArray(pByteArray);
+    }
+}
+
+BeatMatrix::~BeatMatrix() {
+}
+
+unsigned int BeatMatrix::numBeats() const {
+    return m_beatList.size();
+}
+
+QByteArray* BeatMatrix::toByteArray() const {
+    QMutexLocker locker(&m_mutex);
+    // No guarantees BeatLists are made of a data type which located adjacent
+    // items in adjacent memory locations.
+    double* pBuffer = new double[m_beatList.size()];
+    for (int i = 0; i < m_beatList.size(); ++i) {
+        pBuffer[i] = m_beatList[i];
+    }
+    QByteArray* pByteArray = new QByteArray((char*)pBuffer, sizeof(pBuffer[0]) * m_beatList.size());
+    delete [] pBuffer;
+    return pByteArray;
+}
+
+void BeatMatrix::readByteArray(const QByteArray* pByteArray) {
+    if (pByteArray->size() % sizeof(double) != 0) {
+        qDebug() << "ERROR: Could not parse BeatMatrix from QByteArray of size" << pByteArray->size();
+        return;
+    }
+
+    int numBeats = pByteArray->size() / sizeof(double);
+    double* pBuffer = (double*)pByteArray->data();
+    for (int i = 0; i < numBeats; ++i) {
+        m_beatList.append(pBuffer[i]);
+    }
+}
+
+
+QString BeatMatrix::getVersion() const {
+    QMutexLocker locker(&m_mutex);
+    return "BeatMatrix-1.0";
+}
+
+// internal use only
+bool BeatMatrix::isValid() const {
+    return m_iSampleRate > 0 && m_beatList.size() > 0;
+}
+
+double BeatMatrix::findNextBeat(double dSamples) const {
+    return findNthBeat(dSamples, 1);
+}
+
+double BeatMatrix::findPrevBeat(double dSamples) const {
+    return findNthBeat(dSamples, -1);
+}
+
+double BeatMatrix::findClosestBeat(double dSamples) const {
+    QMutexLocker locker(&m_mutex);
+    if (!isValid()) {
+        return -1;
+    }
+    double nextBeat = findNextBeat(dSamples);
+    double prevBeat = findPrevBeat(dSamples);
+    return (nextBeat - dSamples > dSamples - prevBeat) ? prevBeat : nextBeat;
+}
+
+double BeatMatrix::findNthBeat(double dSamples, int n) const {
+    QMutexLocker locker(&m_mutex);
+    BeatList::const_iterator it;
+    int i;
+
+    if (!isValid() || n == 0) {
+        return -1;
+    }
+
+    if (n > 0) {
+        it = qLowerBound(m_beatList.begin(), m_beatList.end(), dSamples);
+
+        // Count down until n=1
+        while (it != m_beatList.end()) {
+            if (n == 1) {
+                return *it;
+            }
+            it++; n--;
+        }
+    }
+    else if (n < 0) {
+        it = qUpperBound(m_beatList.begin(), m_beatList.end(), dSamples);
+
+        // Count up until n=-1
+        while (it != m_beatList.begin()) {
+            // qUpperBound starts us off at the position just-one-past the last
+            // occurence of dSamples-or-smaller in the list. In order to get the
+            // last instance of dSamples-or-smaller, we decrement it by 1 before
+            // touching it. The guard of this while loop guarantees this does
+            // not put us before the start of the loop.
+            it--;
+            if (n == -1) {
+                return *it;
+            }
+            n++;
+        }
+    }
+
+    return -1;
+}
+
+void BeatMatrix::findBeats(double startSample, double stopSample, QList<double>* pBeatsList) const {
+    QMutexLocker locker(&m_mutex);
+    if (!isValid() || startSample > stopSample) {
+        return;
+    }
+    BeatList::const_iterator curBeat = qLowerBound(m_beatList.begin(),
+                                                   m_beatList.end(),
+                                                   startSample);
+    BeatList::const_iterator stopBeat = qUpperBound(m_beatList.begin(),
+                                                    m_beatList.end(),
+                                                    stopSample);
+
+    for (; curBeat != stopBeat; curBeat++) {
+        pBeatsList->append(*curBeat);
+    }
+}
+
+bool BeatMatrix::hasBeatInRange(double startSample, double stopSample) const {
+    QMutexLocker locker(&m_mutex);
+    if (!isValid() || startSample > stopSample) {
+        return false;
+    }
+    BeatList::const_iterator startBeat = qLowerBound(m_beatList.begin(),
+                                                     m_beatList.end(),
+                                                     startSample);
+    BeatList::const_iterator stopBeat = qUpperBound(m_beatList.begin(),
+                                                    m_beatList.end(),
+                                                    stopSample);
+
+    if (startBeat != stopBeat)
+        return true;
+    return false;
+}
+
+double BeatMatrix::getBpm() const {
+    QMutexLocker locker(&m_mutex);
+    if (!isValid()) {
+        return -1;
+    }
+
+    // TODO(XXX) not actually correct. We need the true song length.
+    double startSample = *m_beatList.begin();
+    double stopSample = *(m_beatList.end()-1);
+    double songDurationMinutes =
+            (stopSample - startSample) / (60.0f * m_iSampleRate);
+    return m_beatList.size() / songDurationMinutes;
+}
+
+double BeatMatrix::getBpmRange(double startSample, double stopSample) const {
+    QMutexLocker locker(&m_mutex);
+    if (!isValid() || startSample > stopSample) {
+        return -1;
+    }
+
+    BeatList::const_iterator startBeat = qLowerBound(m_beatList.begin(),
+                                               m_beatList.end(),
+                                               startSample);
+    BeatList::const_iterator stopBeat = qUpperBound(m_beatList.begin(),
+                                                    m_beatList.end(),
+                                                    stopSample);
+    double rangeDurationMinutes =
+            (stopSample - startSample) / (60.0f * m_iSampleRate);
+    // Subtracting returns the number of beats between the samples referred to
+    // by the start and end.
+    double beatsInRange = stopBeat - startBeat;
+
+    return beatsInRange / rangeDurationMinutes;
+}
+
+void BeatMatrix::addBeat(double dBeatSample) {
+    QMutexLocker locker(&m_mutex);
+
+    BeatList::iterator it = qLowerBound(m_beatList.begin(),
+                                        m_beatList.end(),
+                                        dBeatSample);
+    // Don't insert a duplicate beat. TODO(XXX) determine what epsilon to
+    // consider a beat identical to another.
+    if (*it == dBeatSample)
+        return;
+
+    m_beatList.insert(it, dBeatSample);
+    locker.unlock();
+    emit(updated());
+}
+
+void BeatMatrix::removeBeat(double dBeatSample) {
+    QMutexLocker locker(&m_mutex);
+    BeatList::iterator it = qLowerBound(m_beatList.begin(),
+                                        m_beatList.end(), dBeatSample);
+
+    // In case there are duplicates, remove every instance of dBeatSample
+    // TODO(XXX) add invariant checks against this
+    // TODO(XXX) determine what epsilon to consider a beat identical to another
+    while (*it == dBeatSample) {
+        it = m_beatList.erase(it);
+    }
+    locker.unlock();
+    emit(updated());
+}
+
+void BeatMatrix::moveBeat(double dBeatSample, double dNewBeatSample) {
+    QMutexLocker locker(&m_mutex);
+
+    BeatList::iterator it = qLowerBound(m_beatList.begin(),
+                                        m_beatList.end(), dBeatSample);
+
+    // Remove all beats from dBeatSample
+    while (*it == dBeatSample) {
+        it = m_beatList.erase(it);
+    }
+
+    // Now add a beat to dNewBeatSample
+    it = qLowerBound(m_beatList.begin(),
+                     m_beatList.end(), dNewBeatSample);
+
+    // TODO(XXX) beat epsilon
+    if (*it != dNewBeatSample) {
+        m_beatList.insert(it, dNewBeatSample);
+    }
+    locker.unlock();
+    emit(updated());
+}
+
+void BeatMatrix::translate(double dNumSamples) {
+    QMutexLocker locker(&m_mutex);
+    if (!isValid()) {
+        return;
+    }
+
+    for (BeatList::iterator it = m_beatList.begin();
+         it != m_beatList.end(); ++it) {
+        *it += dNumSamples;
+    }
+    locker.unlock();
+    emit(updated());
+}
+
+void BeatMatrix::scale(double dScalePercentage) {
+    QMutexLocker locker(&m_mutex);
+    if (!isValid()) {
+        return;
+    }
+    for (BeatList::iterator it = m_beatList.begin();
+         it != m_beatList.end(); ++it) {
+        *it *= dScalePercentage;
+    }
+    locker.unlock();
+    emit(updated());
+}
+
+void BeatMatrix::slotTrackBpmUpdated(double dBpm) {
+    //QMutexLocker locker(&m_mutex);
+    // TODO(XXX) How do we handle this?
+}
 
=== added file 'mixxx/src/track/beatmatrix.h'
--- mixxx/src/track/beatmatrix.h	1970-01-01 00:00:00 +0000
+++ mixxx/src/track/beatmatrix.h	2011-03-07 05:53:37 +0000
@@ -0,0 +1,67 @@
+#ifndef BEATMATRIX_H
+#define BEATMATRIX_H
+
+#include <QObject>
+#include <QMutex>
+
+#include "trackinfoobject.h"
+#include "track/beats.h"
+
+// BeatMatrix is an implementation of the Beats interface that implements a list
+// of finite beats that have been extracted or otherwise annotated for a track.
+class BeatMatrix : public QObject, public Beats {
+    Q_OBJECT
+  public:
+    BeatMatrix(TrackPointer pTrack, const QByteArray* pByteArray=NULL);
+    virtual ~BeatMatrix();
+
+    // See method comments in beats.h
+
+    virtual Beats::CapabilitiesFlags getCapabilities() const {
+        return BEATSCAP_TRANSLATE | BEATSCAP_SCALE | BEATSCAP_ADDREMOVE | BEATSCAP_MOVEBEAT;
+    }
+
+    virtual QByteArray* toByteArray() const;
+    virtual QString getVersion() const;
+
+    ////////////////////////////////////////////////////////////////////////////
+    // Beat calculations
+    ////////////////////////////////////////////////////////////////////////////
+
+    virtual double findNextBeat(double dSamples) const;
+    virtual double findPrevBeat(double dSamples) const;
+    virtual double findClosestBeat(double dSamples) const;
+    virtual double findNthBeat(double dSamples, int n) const;
+    virtual void findBeats(double startSample, double stopSample, QList<double>* pBeatsList) const;
+    virtual bool hasBeatInRange(double startSample, double stopSample) const;
+    virtual double getBpm() const;
+    virtual double getBpmRange(double startSample, double stopSample) const;
+
+    ////////////////////////////////////////////////////////////////////////////
+    // Beat mutations
+    ////////////////////////////////////////////////////////////////////////////
+
+    virtual void addBeat(double dBeatSample);
+    virtual void removeBeat(double dBeatSample);
+    virtual void moveBeat(double dBeatSample, double dNewBeatSample);
+    virtual void translate(double dNumSamples);
+    virtual void scale(double dScalePercentage);
+
+  signals:
+    void updated();
+
+  private slots:
+    void slotTrackBpmUpdated(double bpm);
+
+  private:
+    void readByteArray(const QByteArray* pByteArray);
+    // For internal use only.
+    bool isValid() const;
+    unsigned int numBeats() const;
+
+    mutable QMutex m_mutex;
+    int m_iSampleRate;
+    BeatList m_beatList;
+};
+
+#endif /* BEATMATRIX_H */
 
=== added file 'mixxx/src/track/beats.h'
--- mixxx/src/track/beats.h	1970-01-01 00:00:00 +0000
+++ mixxx/src/track/beats.h	2011-03-07 05:53:37 +0000
@@ -0,0 +1,106 @@
+#ifndef BEATS_H
+#define BEATS_H
+
+#include <QString>
+#include <QList>
+#include <QByteArray>
+#include <QSharedPointer>
+
+class Beats;
+typedef QSharedPointer<Beats> BeatsPointer;
+
+// QList's are attractive because they pre-allocate an internal buffer that is
+// not free'd after a clear(). The downside is that they do not necessarily
+// store adjecent items in adjacent memory locations.
+typedef QList<double> BeatList;
+
+// Beats is a pure abstract base class for BPM and beat management classes. It
+// provides a specification of all methods a beat-manager class must provide, as
+// well as a capability model for representing optional features.
+class Beats {
+  public:
+    Beats() { }
+    virtual ~Beats() { }
+
+    enum Capabilities {
+        BEATSCAP_NONE          = 0x0000,
+        BEATSCAP_ADDREMOVE     = 0x0001,
+        BEATSCAP_TRANSLATE     = 0x0002,
+        BEATSCAP_SCALE         = 0x0004,
+        BEATSCAP_MOVEBEAT      = 0x0008
+    };
+    typedef int CapabilitiesFlags; // Allows us to do ORing
+
+    virtual Beats::CapabilitiesFlags getCapabilities() const = 0;
+
+    // Serialization
+    virtual QByteArray* toByteArray() const = 0;
+
+    // A string representing the version of the beat-processing code that
+    // produced this Beats instance. Used by BeatsFactory for associating a
+    // given serialization with the version that produced it.
+    virtual QString getVersion() const = 0;
+
+    ////////////////////////////////////////////////////////////////////////////
+    // Beat calculations
+    ////////////////////////////////////////////////////////////////////////////
+
+    // Starting from sample dSamples, return the sample of the next beat in the
+    // track, or -1 if none exists. If dSamples refers to the location of a
+    // beat, dSamples is returned.
+    virtual double findNextBeat(double dSamples) const = 0;
+
+    // Starting from sample dSamples, return the sample of the previous beat in
+    // the track, or -1 if none exists. If dSamples refers to the location of
+    // beat, dSamples is returned.
+    virtual double findPrevBeat(double dSamples) const = 0;
+
+    // Starting from sample dSamples, return the sample of the closest beat in
+    // the track, or -1 if none exists.
+    virtual double findClosestBeat(double dSamples) const = 0;
+
+    // Find the Nth beat from sample dSamples. Works with both positive and
+    // negative values of n. Calling findNthBeat with n=0 is invalid. Calling
+    // findNthBeat with n=1 or n=-1 is equivalent to calling findNextBeat and
+    // findPrevBeat, respectively. If dSamples refers to the location of a beat,
+    // then dSamples is returned. If no beat can be found, returns -1.<
+    virtual double findNthBeat(double dSamples, int n) const = 0;
+
+    // Adds to pBeatsList the position in samples of every beat occuring between
+    // startPosition and endPosition
+    virtual void findBeats(double startSample, double stopSample, BeatList* pBeatsList) const = 0;
+
+    // Return whether or not a sample lies between startPosition and endPosition
+    virtual bool hasBeatInRange(double startSample, double stopSample) const = 0;
+
+    // Return the average BPM over the entire track if the BPM is
+    // valid, otherwise returns -1
+    virtual double getBpm() const = 0;
+
+    // Return the average BPM over the range from startSample to endSample,
+    // specified in samples if the BPM is valid, otherwise returns -1
+    virtual double getBpmRange(double startSample, double stopSample) const = 0;
+
+    ////////////////////////////////////////////////////////////////////////////
+    // Beat mutations
+    ////////////////////////////////////////////////////////////////////////////
+
+    // Add a beat at location dBeatSample. Beats instance must have the
+    // capability BEATSCAP_ADDREMOVE.
+    virtual void addBeat(double dBeatSample) = 0;
+
+    // Remove a beat at location dBeatSample. Beats instance must have the
+    // capability BEATSCAP_ADDREMOVE.
+    virtual void removeBeat(double dBeatSample) = 0;
+
+    // Translate all beats in the song by dNumSamples samples. Beats that lie
+    // before the start of the track or after the end of the track are not
+    // removed. Beats instance must have the capability BEATSCAP_TRANSLATE.
+    virtual void translate(double dNumSamples) = 0;
+
+    // Scale the position of every beat in the song by dScalePercentage. Beats
+    // class must have the capability BEATSCAP_SCALE.
+    virtual void scale(double dScalePercentage) = 0;
+};
+
+#endif /* BEATS_H */
 
=== modified file 'mixxx/src/trackinfoobject.cpp'
--- mixxx/src/trackinfoobject.cpp	2010-11-24 15:20:09 +0000
+++ mixxx/src/trackinfoobject.cpp	2011-03-07 05:53:37 +0000
@@ -143,6 +143,7 @@
 }
 
 TrackInfoObject::~TrackInfoObject() {
+    qDebug() << "~TrackInfoObject()";
 }
 
 void TrackInfoObject::doSave() {
@@ -341,6 +342,42 @@
     m_bBpmConfirm = confirm;
 }
 
+void TrackInfoObject::setBeats(BeatsPointer pBeats) {
+    QMutexLocker lock(&m_qMutex);
+
+    // This whole method is not so great. The fact that Beats is an ABC is
+    // limiting with respect to QObject and signals/slots.
+
+    QObject* pObject = NULL;
+    if (m_pBeats) {
+        pObject = dynamic_cast<QObject*>(m_pBeats.data());
+        if (pObject)
+            pObject->disconnect(this, SIGNAL(updated()));
+    }
+    m_pBeats = pBeats;
+    pObject = dynamic_cast<QObject*>(m_pBeats.data());
+    Q_ASSERT(pObject);
+    if (pObject) {
+        connect(pObject, SIGNAL(updated()),
+                this, SLOT(slotBeatsUpdated()));
+    }
+    setDirty(true);
+    lock.unlock();
+    emit(beatsUpdated());
+}
+
+BeatsPointer TrackInfoObject::getBeats() const {
+    QMutexLocker lock(&m_qMutex);
+    return m_pBeats;
+}
+
+void TrackInfoObject::slotBeatsUpdated() {
+    QMutexLocker lock(&m_qMutex);
+    setDirty(true);
+    lock.unlock();
+    emit(beatsUpdated());
+}
+
 bool TrackInfoObject::getHeaderParsed()  const
 {
     QMutexLocker lock(&m_qMutex);
 
=== modified file 'mixxx/src/trackinfoobject.h'
--- mixxx/src/trackinfoobject.h	2010-11-17 21:02:24 +0000
+++ mixxx/src/trackinfoobject.h	2011-03-07 05:53:37 +0000
@@ -28,7 +28,7 @@
 #include <QWeakPointer>
 
 #include "defs.h"
-
+#include "track/beats.h"
 #include "library/dao/cue.h"
 
 class QString;
@@ -242,6 +242,12 @@
     /** Set the track's full file path */
     void setLocation(QString location);
 
+    // Get the track's Beats list
+    BeatsPointer getBeats() const;
+
+    // Set the track's Beats
+    void setBeats(BeatsPointer beats);
+
     const Segmentation<QString>* getChordData();
     void setChordData(Segmentation<QString> cd);
 
@@ -251,6 +257,7 @@
   signals:
     void wavesummaryUpdated(TrackInfoObject*);
     void bpmUpdated(double bpm);
+    void beatsUpdated();
     void ReplayGainUpdated(double replaygain);
     void cuesUpdated();
     void changed();
@@ -258,6 +265,9 @@
     void clean();
     void save();
 
+  private slots:
+    void slotBeatsUpdated();
+
   private:
 
     // Common initialization function between all TIO constructors.
@@ -370,6 +380,9 @@
     double m_dVisualResampleRate;
     Segmentation<QString> m_chordData;
 
+    // Storage for the track's beats
+    BeatsPointer m_pBeats;
+
     friend class TrackDAO;
 };
 
 
=== modified file 'mixxx/src/waveform/waveformrenderbeat.cpp'
--- mixxx/src/waveform/waveformrenderbeat.cpp	2010-11-25 01:06:46 +0000
+++ mixxx/src/waveform/waveformrenderbeat.cpp	2011-03-07 05:53:37 +0000
@@ -14,45 +14,26 @@
 #include "widget/wskincolor.h"
 #include "widget/wwidget.h"
 #include "trackinfoobject.h"
+#include "track/beats.h"
+
 
 WaveformRenderBeat::WaveformRenderBeat(const char* group, WaveformRenderer *parent)
         : m_pParent(parent),
-          m_pBpm(NULL),
-          m_pBeatFirst(NULL),
           m_pTrackSamples(NULL),
           m_pTrack(),
           m_iWidth(0),
           m_iHeight(0),
-          m_dBpm(-1),
-          m_dBeatFirst(-1),
           m_dSamplesPerPixel(-1),
           m_dSamplesPerDownsample(-1),
-          m_dBeatLength(-1),
           m_iNumSamples(0),
           m_iSampleRate(-1) {
-    m_pBpm = new ControlObjectThreadMain(ControlObject::getControl(ConfigKey(group, "file_bpm")));
-    connect(m_pBpm, SIGNAL(valueChanged(double)), this, SLOT(slotUpdateBpm(double)));
-
-    //m_pBeatFirst = new ControlObjectThreadMain(ControlObject::getControl(ConfigKey(group, "BeatFirst")));
-    //connect(m_pBeatFirst, SIGNAL(valueChanged(double)), this, SLOT(slotUpdateBeatFirst(double)));
-
-    m_pTrackSamples = new ControlObjectThreadMain(ControlObject::getControl(ConfigKey(group,"track_samples")));
+    m_pTrackSamples = new ControlObjectThreadMain(
+        ControlObject::getControl(ConfigKey(group,"track_samples")));
     slotUpdateTrackSamples(m_pTrackSamples->get());
     connect(m_pTrackSamples, SIGNAL(valueChanged(double)),
             this, SLOT(slotUpdateTrackSamples(double)));
 }
 
-void WaveformRenderBeat::slotUpdateBpm(double v) {
-    //qDebug() << "WaveformRenderBeat :: BPM = " << v;
-    m_dBpm = v;
-    m_dBeatLength = -1;
-}
-
-void WaveformRenderBeat::slotUpdateBeatFirst(double v) {
-    //qDebug() << "WaveformRenderBeat :: beatFirst = " << v;
-    m_dBeatFirst = v;
-}
-
 void WaveformRenderBeat::slotUpdateTrackSamples(double samples) {
     //qDebug() << "WaveformRenderBeat :: samples = " << int(samples);
     m_iNumSamples = (int)samples;
@@ -65,9 +46,7 @@
 
 void WaveformRenderBeat::newTrack(TrackPointer pTrack) {
     m_pTrack = pTrack;
-    m_dBpm = -1;
-    m_dBeatFirst = -1;
-    m_dBeatLength = -1;
+
     m_iNumSamples = 0;
     m_iSampleRate = 0;
     m_dSamplesPerDownsample = -1;
@@ -90,13 +69,9 @@
 
     m_dSamplesPerDownsample = n;
     m_dSamplesPerPixel = double(f)/z;
-
-    //qDebug() << "WaveformRenderBeat sampleRate  " << sampleRate << " samplesPerPixel " << m_dSamplesPerPixel;
-
 }
 
 void WaveformRenderBeat::setup(QDomNode node) {
-
     colorMarks.setNamedColor(WWidget::selectNodeQString(node, "BeatColor"));
     colorMarks = WSkinColor::getCorrectColor(colorMarks);
 
@@ -108,10 +83,9 @@
     colorHighlight = WSkinColor::getCorrectColor(colorHighlight);
 }
 
-
-void WaveformRenderBeat::draw(QPainter *pPainter, QPaintEvent *event, QVector<float> *buffer, double dPlayPos, double rateAdjust) {
-    if(m_dBpm == -1 || m_dBpm == 0)
-        return;
+void WaveformRenderBeat::draw(QPainter *pPainter, QPaintEvent *event,
+                              QVector<float> *buffer, double dPlayPos, double rateAdjust) {
+    int i;
 
     slotUpdateTrackSamples(m_pTrackSamples->get());
 
@@ -121,6 +95,10 @@
     if(buffer == NULL)
         return;
 
+    BeatsPointer pBeats = m_pTrack->getBeats();
+    if (!pBeats)
+        return;
+
     int iCurPos = (int)(dPlayPos * m_iNumSamples);
 
     if(iCurPos % 2 != 0)
@@ -137,11 +115,6 @@
     // Therefore, sample s is a beat if it satisfies  s % 60f/b == 0.
     // where s is a /mono/ sample
 
-    // beat length in samples
-    if(m_dBeatLength <= 0) {
-        m_dBeatLength = 60.0 * m_iSampleRate / m_dBpm;
-    }
-
     double subpixelsPerPixel = m_pParent->getSubpixelsPerPixel()*(1.0+rateAdjust);
     const int oversample = (int)subpixelsPerPixel;
 
@@ -161,12 +134,13 @@
     double basePos = iCurPos - m_dSamplesPerPixel*halfw*(1.0+rateAdjust);
     double endPos = basePos + m_iWidth*m_dSamplesPerPixel*(1.0+rateAdjust);
 
-    // snap to the first beat
-    double curPos = ceilf(basePos/m_dBeatLength)*m_dBeatLength;
+
+    m_beatList.clear();
+    pBeats->findBeats(basePos, endPos, &m_beatList);
 
     bool reset = false;
-    for(;curPos <= endPos; curPos+=m_dBeatLength) {
-        if(curPos < 0)
+    foreach (double curPos, m_beatList) {
+        if (curPos < 0)
             continue;
 
         // i relative to the current play position in subpixels
@@ -174,7 +148,7 @@
 
         // If i is less than 20 subpixels from center, highlight it.
         if(abs(i) < 20) {
-            pPainter->setPen(colorHighlight);
+            pPainter->setPen(QColor(255,255,255));
             reset = true;
         }
 
@@ -190,5 +164,4 @@
     }
 
     pPainter->restore();
-
 }
 
=== modified file 'mixxx/src/waveform/waveformrenderbeat.h'
--- mixxx/src/waveform/waveformrenderbeat.h	2010-07-15 19:07:16 +0000
+++ mixxx/src/waveform/waveformrenderbeat.h	2011-03-07 05:53:37 +0000
@@ -12,40 +12,35 @@
 class QPainter;
 class QPaintEvent;
 
-
 class ControlObjectThreadMain;
 class WaveformRenderer;
 class SoundSourceProxy;
 
 class WaveformRenderBeat : public RenderObject {
     Q_OBJECT
-public:
+  public:
     WaveformRenderBeat(const char *group, WaveformRenderer *parent);
     void resize(int w, int h);
     void setup(QDomNode node);
-    void draw(QPainter *pPainter, QPaintEvent *event, QVector<float> *buffer, double playPos, double rateAdjust);
+    void draw(QPainter *pPainter, QPaintEvent *event, QVector<float> *buffer,
+              double playPos, double rateAdjust);
     void newTrack(TrackPointer pTrack);
 
-public slots:
-    void slotUpdateBpm(double bpm);
-    void slotUpdateBeatFirst(double beatfirst);
+  public slots:
     void slotUpdateTrackSamples(double samples);
-private:
+  private:
     WaveformRenderer *m_pParent;
-    ControlObjectThreadMain *m_pBpm;
-    ControlObjectThreadMain *m_pBeatFirst;
     ControlObjectThreadMain *m_pTrackSamples;
     TrackPointer m_pTrack;
     int m_iWidth, m_iHeight;
-    double m_dBpm;
-    double m_dBeatFirst;
     QColor colorMarks;
     QColor colorHighlight;
     double m_dSamplesPerPixel;
     double m_dSamplesPerDownsample;
-    double m_dBeatLength;
     int m_iNumSamples;
     int m_iSampleRate;
+
+    BeatList m_beatList;
 };
 
 #endif
 
=== modified file 'mixxx/src/waveform/waveformrenderer.cpp'
--- mixxx/src/waveform/waveformrenderer.cpp	2010-08-27 20:10:20 +0000
+++ mixxx/src/waveform/waveformrenderer.cpp	2011-03-07 05:53:37 +0000
@@ -1,9 +1,3 @@
-/**
-
-  A license and other info goes here!
-
- */
-
 #include <QDebug>
 #include <QDomNode>
 #include <QImage>
@@ -126,6 +120,8 @@
 
 
 WaveformRenderer::~WaveformRenderer() {
+    qDebug() << "~WaveformRenderer()";
+
     // Wait for the thread to quit
     m_bQuit = true;
     QThread::wait();
@@ -165,6 +161,13 @@
     if(m_pRenderBeat)
         delete m_pRenderBeat;
     m_pRenderBeat = NULL;
+
+    QMutableListIterator<RenderObject*> iter(m_renderObjects);
+    while (iter.hasNext()) {
+        RenderObject* ro = iter.next();
+        iter.remove();
+        delete ro;
+    }
 }
 
 void WaveformRenderer::slotUpdatePlayPos(double v) {
 
=== modified file 'mixxx/src/waveform/waveformrenderer.h'
--- mixxx/src/waveform/waveformrenderer.h	2010-07-15 19:07:16 +0000
+++ mixxx/src/waveform/waveformrenderer.h	2011-03-07 05:53:37 +0000
@@ -28,7 +28,7 @@
     Q_OBJECT
 public:
     WaveformRenderer(const char* group);
-    ~WaveformRenderer();
+    virtual ~WaveformRenderer();
 
     void resize(int w, int h);
     void draw(QPainter* pPainter, QPaintEvent *pEvent);