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]

2532. By Phillip Whelan on 2011-02-05

Cleaning up the order of TrackBeats and creating the few remaining Seconds equivalent functions.

2533. By Phillip Whelan on 2011-02-09

Commenting of functions and addition of the last seconds equivalent functions. Also adding removeBeatSample function and it's seconds equivalent.

2534. By Phillip Whelan on 2011-02-09

Removing unecessary white space.

2535. By Phillip Whelan on 2011-02-11

Tweaks to adding and removing samples.

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.

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

Fix SQL statement that got munged by a merge.

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/

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).

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

2561. By Albert Santoni on 2011-03-07

Merge from trunk

2562. By Phillip Whelan on 2011-03-07

FIX: change track beats code to use sample offsets instead of frame offsets. this way the code fits in with the rest of the codebase.

2563. By Phillip Whelan on 2011-03-09

Comments for beatgrid units, contributed by Albert Santoni.

2564. By Phillip Whelan on 2011-03-09

Change beatgrid to serialize in frame offsets but use sample offsets at runtime.

2565. By Phillip Whelan on 2011-03-10

Cleaning up some cruft left over from earlier shift to using sample offsets at runtime.

Unmerged revisions

=== modified file 'mixxx/build/depends.py'
--- mixxx/build/depends.py	2011-02-09 18:34:37 +0000
+++ mixxx/build/depends.py	2011-02-11 04:42:13 +0000
@@ -529,6 +529,7 @@
 
                    "sampleutil.cpp",
                    "trackinfoobject.cpp",
+                   "trackbeats.cpp",
                    "baseplayer.cpp",
                    "basetrackplayer.cpp",
                    "deck.cpp",

=== modified file 'mixxx/res/schema.xml'
--- mixxx/res/schema.xml	2011-01-06 13:53:48 +0000
+++ mixxx/res/schema.xml	2011-02-11 04:42:13 +0000
@@ -228,4 +228,12 @@
         );
     </sql>
   </revision>
+  <revision version="10" min_compatible="3">
+    <description>
+      Add beats column to library table.
+    </description>
+    <sql>
+      ALTER TABLE Library ADD COLUMN beats BLOB;
+    </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-02-11 04:42:13 +0000
@@ -3,6 +3,7 @@
 
 #include "BPMDetect.h"
 #include "trackinfoobject.h"
+#include "trackbeats.h"
 #include "analyserbpm.h"
 
 
@@ -29,6 +30,13 @@
         //                                    defaultrange ? MIN_BPM : m_iMinBpm,
         //                                    defaultrange ? MAX_BPM : m_iMaxBpm);
     }
+    else if ( tio->getBpm() != 0. )
+    {
+        // Make sure we have the track beats loaded or generate them.
+        TrackBeatsPointer pTrackBeats = tio->getTrackBeats();
+        if ( pTrackBeats == NULL )
+            doBeats(tio);
+    }
 }
 
 
@@ -58,6 +66,21 @@
     return BPM;
 }
 
+void AnalyserBPM::doBeats(TrackPointer tio)
+{
+    TrackBeats *pTrackBeats = new TrackBeats(tio);
+    float seconds;
+    float duration = (float)tio->getDuration();
+    float inc = 60. / tio->getBpm();
+
+    for (seconds = 0; seconds < duration; seconds += inc)
+    {
+        pTrackBeats->addBeatSeconds(seconds);
+    }
+
+    tio->setTrackBeats(TrackBeatsPointer(pTrackBeats, &QObject::deleteLater), TRUE);
+}
+
 void AnalyserBPM::finalise(TrackPointer tio) {
     // Check if BPM detection is enabled
     if(m_pDetector == NULL) {
@@ -71,6 +94,8 @@
 
         tio->setBpm(newbpm);
         tio->setBpmConfirm();
+
+        doBeats(tio);
         //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-02-11 04:42:13 +0000
@@ -17,6 +17,7 @@
 
   private:
     float correctBPM(float BPM, int min, int max, int aboveRange);
+    void doBeats(TrackPointer tio);
 
     ConfigObject<ConfigValue> *m_pConfig;
     soundtouch::BPMDetect *m_pDetector;

=== 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-02-11 04:42:13 +0000
@@ -3,6 +3,7 @@
 #include <QtCore>
 #include <QtSql>
 #include "trackinfoobject.h"
+#include "trackbeats.h"
 #include "library/dao/trackdao.h"
 #include "audiotagger.h"
 
@@ -215,16 +216,16 @@
 
 void TrackDAO::prepareLibraryInsert(QSqlQuery& query) {
     query.prepare("INSERT INTO library (artist, title, album, year, genre, tracknumber, "
-                  "filetype, location, comment, url, duration, rating, key, "
+                  "filetype, location, comment, url, duration, "
                   "bitrate, samplerate, cuepoint, bpm, replaygain, wavesummaryhex, "
                   "timesplayed, "
-                  "channels, mixxx_deleted, header_parsed) "
+                  "channels, mixxx_deleted, header_parsed, beats) "
                   "VALUES (:artist, "
                   ":title, :album, :year, :genre, :tracknumber, "
-                  ":filetype, :location, :comment, :url, :duration, :rating, :key,"
+                  ":filetype, :location, :comment, :url, :duration, "
                   ":bitrate, :samplerate, :cuepoint, :bpm, :replaygain, :wavesummaryhex, "
                   ":timesplayed, "
-                  ":channels, :mixxx_deleted, :header_parsed)");
+                  ":channels, :mixxx_deleted, :header_parsed, :beats)");
 }
 
 void TrackDAO::bindTrackToLibraryInsert(QSqlQuery& query, TrackInfoObject* pTrack, int trackLocationId) {
@@ -249,11 +250,23 @@
     const QByteArray* pWaveSummary = pTrack->getWaveSummary();
     if (pWaveSummary) //Avoid null pointer deref
         query.bindValue(":wavesummaryhex", *pWaveSummary);
+    else
+        query.bindValue(":wavesummaryhex", 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;
+    TrackBeatsPointer pBeats = pTrack->getTrackBeats();
+    if ( pBeats )
+        pBeatsBlob = pBeats->serializeToBlob();
+
+    if ( pBeatsBlob )
+        query.bindValue(":beats", *pBeatsBlob);
+    else
+        query.bindValue(":beats", QVariant(QVariant::ByteArray));
+
 }
 
 void TrackDAO::addTracks(QList<TrackInfoObject*> tracksToAdd) {
@@ -306,7 +319,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;
@@ -550,6 +564,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 +590,19 @@
         track->setReplayGain(replaygain.toFloat());
         track->setWaveSummary(wavesummaryhex, false);
         delete wavesummaryhex;
+
+        // TrackBeats needs the samplerate for it's constructor
+        // so we do it all right here.
+        QByteArray* beatsblob = new QByteArray(
+            query.value(query.record().indexOf("beats")).toByteArray());
+        if ( beatsblob->size() > 1 )
+        {
+            TrackBeats* pTrackBeats = new TrackBeats(pTrack);
+            pTrackBeats->unserializeFromBlob(beatsblob);
+            track->setTrackBeats(TrackBeatsPointer(pTrackBeats, &QObject::deleteLater), false);
+        }
+        delete beatsblob;
+
         track->setTimesPlayed(timesplayed);
         track->setPlayed(played);
         track->setChannels(channels);
@@ -593,8 +621,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));
@@ -647,7 +673,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 "
+        "FROM Library "
+        "INNER JOIN track_locations "
+            "ON library.location = track_locations.id "
+        "WHERE library.id=" + QString("%1").arg(id)
+    );
 
     TrackPointer pTrack;
 
@@ -686,7 +722,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=:beats "
                   "WHERE id="+QString("%1").arg(trackId));
     query.bindValue(":artist", pTrack->getArtist());
     query.bindValue(":title", pTrack->getTitle());
@@ -713,6 +750,13 @@
     query.bindValue(":channels", pTrack->getChannels());
     query.bindValue(":header_parsed", pTrack->getHeaderParsed() ? 1 : 0);
     //query.bindValue(":location", pTrack->getLocation());
+    TrackBeatsPointer pBeats = pTrack->getTrackBeats();
+    if ( pBeats )
+    {
+        const QByteArray *pBeatsBlob = pBeats->serializeToBlob();
+        if ( pBeatsBlob )
+            query.bindValue(":beats", *pBeatsBlob);
+    }
 
     if (!query.exec()) {
         qDebug() << query.lastError();

=== modified file 'mixxx/src/library/trackcollection.cpp'
--- mixxx/src/library/trackcollection.cpp	2010-12-22 21:23:09 +0000
+++ mixxx/src/library/trackcollection.cpp	2011-02-11 04:42:13 +0000
@@ -68,7 +68,7 @@
         return false;
     }
 
-    int requiredSchemaVersion = 9;
+    int requiredSchemaVersion = 10;
     if (!SchemaManager::upgradeToSchemaVersion(m_pConfig, m_db,
                                                requiredSchemaVersion)) {
         QMessageBox::warning(0, tr("Cannot upgrade database schema"),

=== added file 'mixxx/src/trackbeats.cpp'
--- mixxx/src/trackbeats.cpp	1970-01-01 00:00:00 +0000
+++ mixxx/src/trackbeats.cpp	2011-02-11 04:42:13 +0000
@@ -0,0 +1,349 @@
+#include <QtDebug>
+
+#include "defs.h"
+#include "trackinfoobject.h"
+#include "trackbeats.h"
+
+#define TRACKBEATS_INDEX_RANGE 20
+
+
+TrackBeats::TrackBeats(TrackPointer tio) : m_qMutex(QMutex::Recursive)
+{
+    m_iSampleRate = tio->getSampleRate();
+}
+
+TrackBeats::~TrackBeats()
+{
+}
+
+/**
+ * Private function that returns the sample index. This is an index into 
+ * m_beatIndex which holds the first sample offset that holds a beat for a 
+ * certain range of sample offsets.
+ */
+int TrackBeats::sampleIndex(int sample) const
+{
+    QMutexLocker lock(&m_qMutex);
+    return (int) round(sample / (m_iSampleRate * TRACKBEATS_INDEX_RANGE));
+}
+
+/**
+ * Get the count of beats stored.
+ */
+int TrackBeats::getBeatCount() const
+{
+    QMutexLocker lock(&m_qMutex);
+    return m_beats.size();
+}
+
+/**
+ * Add a beat at 'sample' sample.
+ */
+void TrackBeats::addBeatSample(int sample)
+{
+    QMutexLocker lock(&m_qMutex);
+    int index = sampleIndex(sample);
+    int i;
+
+
+    if ((m_beatIndex.size()-1) < index ) 
+    {
+        for (i = m_beatIndex.size() - 1; i <= index; i++ )
+            m_beatIndex.append(sample);
+    }
+    else
+    {
+        for (i = index; m_beatIndex.at(i) >= sample && i >= 0; i-- ) {
+            m_beatIndex[index] = sample;
+        }
+    }
+
+    m_beats[sample] = sample;
+}
+
+/**
+ * Remove the beat with the sample offset specified.
+ */
+void TrackBeats::removeBeatSample(int sample)
+{
+    QMutexLocker lock(&m_qMutex);
+    int index = sampleIndex(sample);
+    int i;
+    int newSample = -1;
+
+
+    m_beats.remove(sample);
+
+    if ( ! m_beatIndex.contains(sample))
+        return;
+
+    if ((index+1) < m_beatIndex.size()) {
+        newSample = m_beatIndex.at(index+1);
+
+        for (i = index; i >= 0 && m_beatIndex.at(i) >= sample; i--) {
+            if ( m_beatIndex.at(i) == sample )
+                m_beatIndex[i] = newSample;
+        }
+    }
+    else {
+        for (i = index; i >= 0 && m_beatIndex.at(i) >= sample; i--) {
+            if ( m_beatIndex.at(i) == sample )
+                m_beatIndex.removeAt(i);
+        }
+    }
+
+    if ( m_beatIndex.contains(sample) )
+        qDebug() << "Dangling Indexes:" << m_beatIndex.count(sample);
+}
+
+/**
+ * Add a beat at 'beat' seconds.
+ */
+void TrackBeats::addBeatSeconds(double beat)
+{
+    QMutexLocker lock(&m_qMutex);
+    addBeatSample((int)round(beat * m_iSampleRate));
+}
+
+
+/**
+ * Remove a beat at 'beat' seconds.
+ */
+void TrackBeats::removeBeatSeconds(double beat)
+{
+    QMutexLocker lock(&m_qMutex);
+    removeBeatSample((int)round(beat * m_iSampleRate));
+}
+
+/**
+ * Find the Next beat starting from offset sample.
+ */
+int TrackBeats::findNextBeatSample(int sample) const
+{
+    QMutexLocker lock(&m_qMutex);
+    QMapIterator<int, int> iter(m_beats);
+    int index = sampleIndex(sample);
+
+
+    if (m_beatIndex.size() > index)
+    {
+        iter.findNext(m_beatIndex.value(index));
+        do {
+            iter.next();
+        } while((iter.hasNext()) && (iter.value() <= sample));
+
+        return iter.value();
+    }
+
+    return -1;
+}
+
+/**
+ * Find the Previous beat starting from offset sample.
+ */
+int TrackBeats::findPrevBeatSample(int sample) const
+{
+    QMutexLocker lock(&m_qMutex);
+    QMapIterator<int, int> iter(m_beats);
+    int index = sampleIndex(sample);
+
+    if (m_beatIndex.size() > index)
+    {
+        iter.findNext(m_beatIndex.value(index));
+        do {
+            iter.previous();
+        } while((iter.hasPrevious()) && (iter.value() >= sample));
+
+        return iter.value();
+    }
+
+    return -1;
+}
+
+/**
+ * Find the Nth beat (offset) from sample .
+ */
+int TrackBeats::findBeatOffsetSamples(int sample, int offset) const
+{
+    QMutexLocker lock(&m_qMutex);
+    QMapIterator<int, int> iter(m_beats);
+    int index = sampleIndex(sample);
+    int i;
+
+
+    if (m_beatIndex.size() < index)
+        return -1;
+
+
+    iter.findNext(m_beatIndex.value(index));
+    do {
+        iter.next();
+    } while((iter.hasNext()) && (iter.value() <= sample));
+
+    // Backup one just to be before the marker
+    if ((iter.hasPrevious()) && (iter.value() > sample))
+        iter.previous();
+
+    // Find the offset from the current beat
+    if ( offset > 0 )
+    {
+        for (i = 0; i < offset && iter.hasNext(); i++)
+            iter.next();
+    }
+    else if ( offset < 0 )
+    {
+        for (i = offset * -1; i > 0 && iter.hasPrevious(); i--)
+            iter.previous();
+    }
+
+    return iter.value();
+}
+
+/**
+ * Return TRUE if there is any beats between start and stop (in samples)
+ */
+bool TrackBeats::hasBeatsSamples(double start, double stop) const
+{
+    QMutexLocker lock(&m_qMutex);
+    QMapIterator<int, int> iter(m_beats);
+    int index = sampleIndex(start);
+
+
+    if (iter.findNext(m_beatIndex.value(index)))
+    {
+        do {
+            if ((iter.value() >= start) && (iter.value() <= stop))
+                 return true;
+
+            iter.next();
+        } while((iter.hasNext()) && (iter.value() <= stop));
+    }
+
+    return false;
+}
+
+/**
+ * Find and return a list of all beats between sample offset start and stop.
+ */
+QList<int>* TrackBeats::findBeatsSamples(int start, int stop) const
+{
+    QMutexLocker lock(&m_qMutex);
+    QList<int> *ret = new QList<int>;
+    QMapIterator<int, int> iter(m_beats);
+    int index = sampleIndex(start);
+
+
+    if (iter.findNext(m_beatIndex.value(index)))
+    {
+        do {
+            if ((iter.value() >= start) && (iter.value() <= stop))
+                 ret->append(iter.value());
+
+            iter.next();
+        } while((iter.hasNext()) && (iter.value() <= stop));
+    }
+
+    return ret;
+}
+
+/**
+ * Find the Next beat starting from an offset in seconds.
+ */
+double TrackBeats::findNextBeatSeconds(double beat) const
+{
+    QMutexLocker lock(&m_qMutex);
+    int sample = (int) round(beat * m_iSampleRate);
+    return findNextBeatSample(sample) / m_iSampleRate;
+}
+
+/**
+ * Find the Previous beat starting from an offset in seconds.
+ */
+double TrackBeats::findPrevBeatSeconds(double beat) const
+{
+    QMutexLocker lock(&m_qMutex);
+    int sample = (int) round(beat * m_iSampleRate);
+    return findPrevBeatSample(sample) / m_iSampleRate;
+}
+
+/**
+ * Find the Nth beat (offset) from offset seconds in seconds.
+ */
+double TrackBeats::findBeatOffsetSeconds(double seconds, int offset) const
+{
+    QMutexLocker lock(&m_qMutex);
+    int bgn = round(seconds * m_iSampleRate);
+    return ((double)findBeatOffsetSamples(bgn, offset) / m_iSampleRate);
+}
+
+/**
+ * Return TRUE if there is any beats between start and stop (in seconds)
+ */
+bool TrackBeats::hasBeatsSeconds(double start, double stop) const
+{
+    QMutexLocker lock(&m_qMutex);
+    int bgn = round(start * m_iSampleRate);
+    int end = round(stop * m_iSampleRate);
+
+    return hasBeatsSamples(bgn, end);
+}
+
+/**
+ * Find and return a list of all beats between seconds start and stop.
+ */
+QList<double>* TrackBeats::findBeatsSeconds(double start, double stop) const
+{
+    QMutexLocker lock(&m_qMutex);
+    QList<double> *ret = new QList<double>;
+    QList<int>* samples;
+    int begin = round(start * m_iSampleRate);
+    int end = round(stop * m_iSampleRate);
+    int i;
+
+
+    samples = findBeatsSamples(begin, end);
+    for (i = 0; i < samples->size(); i++)
+    {
+        ret->append((double)samples->at(i) / (double)m_iSampleRate);
+    }
+
+    delete samples;
+    return ret;
+}
+
+QByteArray *TrackBeats::serializeToBlob()
+{
+    QMutexLocker lock(&m_qMutex);
+    QByteArray *blob;
+    int *buffer = new int[getBeatCount()];
+    int *ptr = buffer;
+    QMapIterator<int, int> iter(m_beats);
+
+
+    iter.next();
+
+    while ( iter.hasNext())
+    {
+        *ptr++ = iter.value();
+        iter.next();
+    }
+
+    blob = new QByteArray((char *)buffer, getBeatCount() * sizeof(int));
+    delete []buffer;
+
+    return blob;
+}
+
+void TrackBeats::unserializeFromBlob(QByteArray *blob)
+{
+    QMutexLocker lock(&m_qMutex);
+    int *ptr = (int *)blob->constData();
+    int i;
+
+
+    for (i = blob->size() / sizeof(int); --i; ptr++)
+    {
+        addBeatSample(*ptr);
+    }
+}
+

=== added file 'mixxx/src/trackbeats.h'
--- mixxx/src/trackbeats.h	1970-01-01 00:00:00 +0000
+++ mixxx/src/trackbeats.h	2011-02-11 04:42:13 +0000
@@ -0,0 +1,59 @@
+#include <QtDebug>
+#include <QList>
+#include <QSharedPointer>
+#include "trackinfoobject.h"
+
+
+#ifndef __TRACK_BEATS_H__
+#define __TRACK_BEATS_H__
+
+class TrackBeats;
+typedef QSharedPointer<TrackBeats> TrackBeatsPointer;
+
+class TrackBeats : public QObject
+{
+    Q_OBJECT;
+public:
+    TrackBeats(TrackPointer);
+    virtual ~TrackBeats();
+
+
+    int getBeatCount() const;
+
+    void addBeatSample(int);
+    void addBeatSeconds(double);
+    void removeBeatSample(int);
+    void removeBeatSeconds(double);
+    void nudgeSamples(int);
+
+    int findPrevBeatSample(int) const;
+    int findNextBeatSample(int) const;
+    int findBeatOffsetSamples(int, int) const;
+    bool hasBeatsSamples(double, double) const;
+    bool hasBeatsSeconds(double, double) const;
+    double findNextBeatSeconds(double) const;
+    double findPrevBeatSeconds(double) const;
+    QList<int>* findBeatsSamples(int, int) const;
+    double findBeatOffsetSeconds(double, int) const;
+    QList<double>* findBeatsSeconds(double, double) const;
+    QByteArray *serializeToBlob();
+    void unserializeFromBlob(QByteArray *blob);
+
+private:
+    /** Find the Samples Index */
+    int sampleIndex(int) const;
+    /** Sample Rate for this song */
+    int m_iSampleRate;
+    /** Duration of the entire song in seconds */
+    double m_dDuration;
+    /** 10 second index (in samples) */
+    QList<int> m_beatIndex;
+    /** Map of all the beats in samples */
+    QMap<int, int> m_beats;
+    /** Pointer to the related Track */
+    TrackPointer m_track;
+    /** Mutex protecting access to object */
+    mutable QMutex m_qMutex;
+};
+
+#endif

=== modified file 'mixxx/src/trackinfoobject.cpp'
--- mixxx/src/trackinfoobject.cpp	2010-11-24 15:20:09 +0000
+++ mixxx/src/trackinfoobject.cpp	2011-02-11 04:42:13 +0000
@@ -341,6 +341,22 @@
     m_bBpmConfirm = confirm;
 }
 
+void TrackInfoObject::setTrackBeats(TrackBeatsPointer beats, bool isDirty)
+{
+    QMutexLocker lock(&m_qMutex);
+    m_pTrackBeatsPointer = beats;
+    if ( isDirty )
+        setDirty(true);
+
+    emit(trackBeatsUpdated(1));
+}
+
+TrackBeatsPointer TrackInfoObject::getTrackBeats() const
+{
+    QMutexLocker lock(&m_qMutex);
+    return m_pTrackBeatsPointer;
+}
+
 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-02-11 04:42:13 +0000
@@ -40,9 +40,11 @@
 class Cue;
 
 class TrackInfoObject;
+class TrackBeats;
 
 typedef QSharedPointer<TrackInfoObject> TrackPointer;
 typedef QWeakPointer<TrackInfoObject> TrackWeakPointer;
+typedef QSharedPointer<TrackBeats> TrackBeatsPointer;
 
 #include "segmentation.h"
 
@@ -242,6 +244,12 @@
     /** Set the track's full file path */
     void setLocation(QString location);
 
+    /** Get the Track's Beats list */
+    TrackBeatsPointer getTrackBeats() const;
+
+    /** Set the Track's Beats */
+    void setTrackBeats(TrackBeatsPointer beats, bool isDirty);
+
     const Segmentation<QString>* getChordData();
     void setChordData(Segmentation<QString> cd);
 
@@ -251,6 +259,7 @@
   signals:
     void wavesummaryUpdated(TrackInfoObject*);
     void bpmUpdated(double bpm);
+    void trackBeatsUpdated(int);
     void ReplayGainUpdated(double replaygain);
     void cuesUpdated();
     void changed();
@@ -370,6 +379,9 @@
     double m_dVisualResampleRate;
     Segmentation<QString> m_chordData;
 
+    // Storage for the Track's detected beats
+    TrackBeatsPointer m_pTrackBeatsPointer;
+
     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-02-11 04:42:13 +0000
@@ -14,6 +14,8 @@
 #include "widget/wskincolor.h"
 #include "widget/wwidget.h"
 #include "trackinfoobject.h"
+#include "trackbeats.h"
+
 
 WaveformRenderBeat::WaveformRenderBeat(const char* group, WaveformRenderer *parent)
         : m_pParent(parent),
@@ -21,6 +23,7 @@
           m_pBeatFirst(NULL),
           m_pTrackSamples(NULL),
           m_pTrack(),
+          m_pTrackBeats(NULL),
           m_iWidth(0),
           m_iHeight(0),
           m_dBpm(-1),
@@ -38,6 +41,7 @@
 
     m_pTrackSamples = new ControlObjectThreadMain(ControlObject::getControl(ConfigKey(group,"track_samples")));
     slotUpdateTrackSamples(m_pTrackSamples->get());
+
     connect(m_pTrackSamples, SIGNAL(valueChanged(double)),
             this, SLOT(slotUpdateTrackSamples(double)));
 }
@@ -58,6 +62,15 @@
     m_iNumSamples = (int)samples;
 }
 
+void WaveformRenderBeat::slotUpdateTrackBeats(int)
+{
+    m_pTrackBeats = m_pTrack->getTrackBeats();
+    if ( m_pTrackBeats )
+        qDebug() << "WaveformRenderBeat :: beats = " << m_pTrackBeats->getBeatCount();
+    else
+        qDebug() << "No WaveformRenderBeat beats list";
+}
+
 void WaveformRenderBeat::resize(int w, int h) {
     m_iWidth = w;
     m_iHeight = h;
@@ -91,7 +104,10 @@
     m_dSamplesPerDownsample = n;
     m_dSamplesPerPixel = double(f)/z;
 
-    //qDebug() << "WaveformRenderBeat sampleRate  " << sampleRate << " samplesPerPixel " << m_dSamplesPerPixel;
+    // Reset the tracker beats for each new song
+    m_pTrackBeats = pTrack->getTrackBeats();
+    connect(pTrack.data(), SIGNAL(trackBeatsUpdated(int)), this, 
+                SLOT(slotUpdateTrackBeats(int)));
 
 }
 
@@ -108,9 +124,18 @@
     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)
+void WaveformRenderBeat::draw(QPainter *pPainter, QPaintEvent *event, QVector<float> *buffer, double dPlayPos, double rateAdjust)
+{
+    drawTrackBeat(pPainter, event, buffer, dPlayPos, rateAdjust);
+}
+
+void WaveformRenderBeat::drawTrackBeat(QPainter *pPainter, QPaintEvent *event, QVector<float> *buffer, double dPlayPos, double rateAdjust)
+{
+    QList<int>* beatSamples;
+    int i;
+
+
+    if ( m_pTrackBeats == NULL )
         return;
 
     slotUpdateTrackSamples(m_pTrackSamples->get());
@@ -137,11 +162,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;
 
@@ -163,10 +183,18 @@
 
     // snap to the first beat
     double curPos = ceilf(basePos/m_dBeatLength)*m_dBeatLength;
-
     bool reset = false;
-    for(;curPos <= endPos; curPos+=m_dBeatLength) {
-        if(curPos < 0)
+    int curSample = (int)round(curPos);
+    int endSample = (int)round(endPos);
+
+
+    beatSamples = m_pTrackBeats->findBeatsSamples(curSample, endSample);
+
+    for(i = 0; i < beatSamples->size(); i++) {
+        curPos = beatSamples->at(i);
+
+
+        if (curPos < 0)
             continue;
 
         // i relative to the current play position in subpixels
@@ -174,7 +202,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;
         }
 
@@ -189,6 +217,7 @@
         }
     }
 
+    delete beatSamples;
     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-02-11 04:42:13 +0000
@@ -7,6 +7,7 @@
 #include <QVector>
 
 #include "renderobject.h"
+#include "trackbeats.h"
 
 class QDomNode;
 class QPainter;
@@ -17,18 +18,21 @@
 class WaveformRenderer;
 class SoundSourceProxy;
 
+
 class WaveformRenderBeat : public RenderObject {
     Q_OBJECT
 public:
     WaveformRenderBeat(const char *group, WaveformRenderer *parent);
     void resize(int w, int h);
     void setup(QDomNode node);
+    void drawTrackBeat(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);
+    void slotUpdateTrackBeats(int);
     void slotUpdateTrackSamples(double samples);
 private:
     WaveformRenderer *m_pParent;
@@ -36,6 +40,7 @@
     ControlObjectThreadMain *m_pBeatFirst;
     ControlObjectThreadMain *m_pTrackSamples;
     TrackPointer m_pTrack;
+    TrackBeatsPointer m_pTrackBeats;
     int m_iWidth, m_iHeight;
     double m_dBpm;
     double m_dBeatFirst;
@@ -46,6 +51,7 @@
     double m_dBeatLength;
     int m_iNumSamples;
     int m_iSampleRate;
+
 };
 
 #endif