Track.h

Go to the documentation of this file.

/***************************************************************************
                 Track.h -  collects one or more stripes in one track
                             -------------------
    begin                : Feb 09 2001
    copyright            : (C) 2001 by Thomas Eschenbacher
    email                : Thomas Eschenbacher <thomas.eschenbacher@gmx.de>
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   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 TRACK_H
#define TRACK_H

#include "config.h"
#include <limits.h>  // for UINT_MAX

#include <QtGlobal>
#include <QList>
#include <QMutex>
#include <QObject>
#include <QReadWriteLock>
#include <QUuid>

#include "libkwave/InsertMode.h"
#include "libkwave/ReaderMode.h"
#include "libkwave/SampleArray.h"
#include "libkwave/Stripe.h"

//***************************************************************************
namespace Kwave
{

    class SampleReader;
    class TrackWriter;
    class Writer;

    class Q_DECL_EXPORT Track: public QObject
    {
        Q_OBJECT
    public:
        Track();

        Track(sample_index_t length, QUuid *uuid);

        virtual ~Track();

        sample_index_t length();

        Kwave::Writer *openWriter(Kwave::InsertMode mode,
                                  sample_index_t left = 0,
                                  sample_index_t right = 0);

        Kwave::SampleReader *openReader(Kwave::ReaderMode mode,
            sample_index_t left = 0,
            sample_index_t right = SAMPLE_INDEX_MAX);

        Kwave::Stripe::List stripes(sample_index_t left,
                                    sample_index_t right);

        bool mergeStripes(const Kwave::Stripe::List &stripes);

        void deleteRange(sample_index_t offset, sample_index_t length,
                         bool make_gap = false);

        bool insertSpace(sample_index_t offset, sample_index_t shift);

        inline bool selected() const { return m_selected; }

        void select(bool select);

        const QUuid &uuid() const { return m_uuid; }

    public slots:

        void toggleSelection();

        void defragment();

    signals:

        void sigSamplesInserted(Kwave::Track *src, sample_index_t offset,
                                sample_index_t length);

        void sigSamplesDeleted(Kwave::Track *src, sample_index_t offset,
                               sample_index_t length);

        void sigSamplesModified(Kwave::Track *src, sample_index_t offset,
                                sample_index_t length);

        void sigSelectionChanged(bool selected);

    private:
        sample_index_t unlockedLength();

        void unlockedDelete(sample_index_t offset, sample_index_t length,
                            bool make_gap = false);

        bool appendAfter(Stripe *stripe, sample_index_t offset,
                         const Kwave::SampleArray &buffer,
                         unsigned int buf_offset, unsigned int length);

        void moveRight(sample_index_t offset, sample_index_t shift);

        void appendStripe(sample_index_t length);

        Stripe splitStripe(Stripe &stripe, unsigned int offset);


        bool mergeStripe(Kwave::Stripe &stripe);

        void dump();

    protected:

        friend class Kwave::TrackWriter;

        bool writeSamples(Kwave::InsertMode mode,
                          sample_index_t offset,
                          const Kwave::SampleArray &buffer,
                          unsigned int buf_offset,
                          unsigned int length);

        void use();

        void release();

    private:

        Stripe *newStripe(sample_index_t start, unsigned int length);

    private:
        QMutex m_lock;

        QReadWriteLock m_lock_usage;

        QList<Stripe> m_stripes;

        bool m_selected;

        QUuid m_uuid;
    };
}

#endif /* TRACK_H */

//***************************************************************************
//***************************************************************************