/home/maxime/Projets/Mixxx/1.10/mixxx/src/trackinfoobject.h

Go to the documentation of this file.

/***************************************************************************
                          trackinfoobject.h  -  description
                             -------------------
    begin                : 10 02 2003
    copyright            : (C) 2003 by Tue & Ken Haste Andersen
    email                : haste@diku.dk
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

#ifndef TRACKINFOOBJECT_H
#define TRACKINFOOBJECT_H

#include <QList>
#include <QDateTime>
#include <QObject>
#include <QFileInfo>
#include <QMutex>
#include <QVector>
#include <QSharedPointer>
#include <QWeakPointer>

#include "defs.h"
#include "track/beats.h"
#include "library/dao/cue.h"

class QString;
class QDomElement;
class QDomDocument;
class QDomNode;
class ControlObject;
class TrackPlaylist;
class Cue;

class TrackInfoObject;

typedef QSharedPointer<TrackInfoObject> TrackPointer;
typedef QWeakPointer<TrackInfoObject> TrackWeakPointer;

#include "segmentation.h"

class TrackInfoObject : public QObject
{
    Q_OBJECT
public:
    TrackInfoObject(const QString sLocation="", bool parseHeader=true);
    // Initialize track with a QFileInfo class
    TrackInfoObject(QFileInfo& fileInfo, bool parseHeader=true);
    TrackInfoObject(const QDomNode &);
    virtual ~TrackInfoObject();

    bool isValid() const;
    int parse();
    void writeToXML( QDomDocument &, QDomElement & );

    int getDuration() const;
    void setDuration(int);
    QString getDurationStr() const;

    // Accessors for various stats of the file on disk. These are auto-populated
    // when the TIO is constructed, or when setLocation() is called.

    Q_PROPERTY(QString artist READ getArtist WRITE setArtist)
    Q_PROPERTY(QString title READ getTitle WRITE setTitle)
    Q_PROPERTY(QString album READ getAlbum WRITE setAlbum)
    Q_PROPERTY(QString genre READ getGenre WRITE setGenre)
    Q_PROPERTY(QString year READ getYear WRITE setYear)
    Q_PROPERTY(QString track_number READ getTrackNumber WRITE setTrackNumber)
    Q_PROPERTY(int times_played READ getTimesPlayed)
    Q_PROPERTY(QString comment READ getComment WRITE setComment)
    Q_PROPERTY(float bpm READ getBpm WRITE setBpm)
    Q_PROPERTY(QString bpmFormatted READ getBpmStr STORED false)
    Q_PROPERTY(int duration READ getDuration WRITE setDuration)
    Q_PROPERTY(QString durationFormatted READ getDurationStr STORED false)


    // Returns absolute path to the file, including the filename.
    QString getLocation() const;
    // Returns the absolute path to the directory containing the file
    QString getDirectory() const;
    // Returns the filename of the file.
    QString getFilename() const;
    // Returns file creation date
    QDateTime getCreateDate() const;
    // Returns the length of the file in bytes
    int getLength() const;
    // Returns whether the file exists on disk or not. Updated as of the time
    // the TrackInfoObject is created, or when setLocation() is called.
    bool exists() const;



    float getReplayGain() const;
    void setReplayGain(float);
    float getBpm() const;
    void setBpm(float);
    QString getBpmStr() const;
    bool getBpmConfirm() const;
    void setBpmConfirm(bool confirm=true);
    bool getHeaderParsed() const;
    void setHeaderParsed(bool parsed = true);
    QString getComment() const;
    void setComment(QString);
    QString getType() const;
    void setType(QString);
    int getBitrate() const;
    QString getBitrateStr() const;
    void setBitrate(int);
    void setBeatFirst(float);
    float getBeatFirst() const;
    void setSampleRate(int iSampleRate);
    int getSampleRate() const;
    void setChannels(int iChannels);
    int getChannels() const;
    QString getInfo() const;

    QDateTime getDateAdded() const;
    void setDateAdded(QDateTime dateAdded);

    QString getTitle() const;
    void setTitle(QString);
    QString getArtist() const;
    void setArtist(QString);
    QString getAlbum() const;
    void setAlbum(QString);
    QString getYear() const;
    void setYear(QString);
    QString getGenre() const;
    void setGenre(QString);
    QString getTrackNumber() const;
    void setTrackNumber(QString);
    int getTimesPlayed() const;
    void setTimesPlayed(int t);
    void incTimesPlayed();
    bool getPlayed() const;
    void setPlayed(bool);

    int getId() const;

    int getRating() const;
    void setRating(int);

    QString getKey() const;
    void setKey(QString);

    QString getURL();
    void setURL(QString url);
    void setVisualWaveform(QVector<float> *pWave);
    QVector<float> * getVisualWaveform();

    void setVisualResampleRate(double dVisualResampleRate);
    double getVisualResampleRate();

    void setWaveSummary(const QByteArray* pWave, bool updateUI = true);

    const QByteArray* getWaveSummary();

    void setBpmControlObject(ControlObject *p);

    void setCuePoint(float cue);
    float getCuePoint();

    // Calls for managing the track's cue points
    Cue* addCue();
    void removeCue(Cue* cue);
    const QList<Cue*>& getCuePoints();
    void setCuePoints(QList<Cue*> cuePoints);

    bool isDirty();

    // Signals to the creator of this TrackInfoObject to save the Track as it
    // may be deleted.
    void doSave();

    // Returns true if the track location has changed
    bool locationChanged();

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

  public slots:
    void slotCueUpdated();

  signals:
    void wavesummaryUpdated(TrackInfoObject*);
    void bpmUpdated(double bpm);
    void beatsUpdated();
    void ReplayGainUpdated(double replaygain);
    void cuesUpdated();
    void changed(TrackInfoObject* pTrack);
    void dirty(TrackInfoObject* pTrack);
    void clean(TrackInfoObject* pTrack);
    void save(TrackInfoObject* pTrack);

  private slots:
    void slotBeatsUpdated();

  private:

    // Common initialization function between all TIO constructors.
    void initialize(bool parseHeader);

    // Initialize all the location variables.
    void populateLocation(QFileInfo& fileInfo);

    // Method for parsing information from knowing only the file name.  It
    // assumes that the filename is written like: "artist - trackname.xxx"
    void parseFilename();

    // Set whether the TIO is dirty not. This should never be called except by
    // TIO local methods or the TrackDAO.
    void setDirty(bool bDirty);

    // Set a unique identifier for the track. Only used by services like
    // TrackDAO
    void setId(int iId);

    // Flag that indicates whether or not the TIO has changed. This is used by
    // TrackDAO to determine whether or not to write the Track back.
    bool m_bDirty;

    // Special flag for telling if the track location was changed.
    bool m_bLocationChanged;

    // The filename
    QString m_sFilename;
    // The full path to the file, including the filename.
    QString m_sLocation;
    // The full path to the directory containing the file.
    QString m_sDirectory;
    // Length of track in bytes
    int m_iLength;
    // Flag which indicates whether the file exists or not.
    bool m_bExists;

    QString m_sAlbum;
    QString m_sArtist;
    QString m_sTitle;
    QString m_sGenre;
    QString m_sYear;
    QString m_sTrackNumber;

    QString m_sType;
    QString m_sComment;
    QString m_sURL;
    int m_iDuration;
    int m_iSampleRate;
    int m_iChannels;
    int m_Rating;;
    int m_iBitrate;
    int m_iTimesPlayed;
    float m_fReplayGain;
    bool m_bPlayed;
    float m_fBpm;
    float m_fMinBpm;
    float m_fMaxBpm;
    bool m_bBpmConfirm;
    bool m_bHeaderParsed;
    float m_fBeatFirst;
    int m_iId;
    float m_fCuePoint;
    QDateTime m_dCreateDate;
    // Date the track was added to the library
    QDateTime m_dateAdded;

    QString m_key;

    // The list of cue points for the track
    QList<Cue*> m_cuePoints;

    QVector<float> *m_pVisualWave;
    QByteArray m_waveSummary;

    mutable QMutex m_qMutex;

    bool m_bIsValid;

    double m_dVisualResampleRate;
    Segmentation<QString> m_chordData;

    // Storage for the track's beats
    BeatsPointer m_pBeats;

    friend class TrackDAO;
};

#endif