Stripe.h

Go to the documentation of this file.

/***************************************************************************
               Stripe.h  -  continuous block of samples
                             -------------------
    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 STRIPE_H
#define STRIPE_H

#include "config.h"

#include <QtGlobal>
#include <QExplicitlySharedDataPointer>
#include <QMutex>
#include <QSharedData>

#include "libkwave/MemoryManager.h"
#include "libkwave/Sample.h"
#include "libkwave/SampleArray.h"

//***************************************************************************
namespace Kwave
{
    class Q_DECL_EXPORT Stripe
    {
    public:

        Stripe();

        Stripe(const Stripe &other);

        Stripe(sample_index_t start);

        Stripe(sample_index_t start, const Kwave::SampleArray& samples);

        Stripe(sample_index_t start, Stripe& stripe, unsigned int offset);

        virtual ~Stripe();

        sample_index_t start() const;

        void setStart(sample_index_t start);

        unsigned int length() const;

        sample_index_t end() const;

        unsigned int resize(unsigned int length, bool initialize = true);

        unsigned int append(const Kwave::SampleArray &samples,
                            unsigned int offset,
                            unsigned int count);

        void deleteRange(unsigned int offset, unsigned int length);

        void overwrite(unsigned int offset, const Kwave::SampleArray &source,
                       unsigned int srcoff, unsigned int srclen);

        bool combine(unsigned int offset, Kwave::Stripe &other);

        unsigned int read(Kwave::SampleArray &buffer, unsigned int dstoff,
                          unsigned int offset, unsigned int length);

        void minMax(unsigned int first, unsigned int last,
                    sample_t &min, sample_t &max);

        Stripe &operator << (const Kwave::SampleArray &samples);

        bool operator == (const Stripe &other) const;

        Stripe &operator = (const Stripe &other);

        class List: public QList<Kwave::Stripe>
        {
        public:

            List()
                :QList<Kwave::Stripe>(), m_left(0), m_right(0)
            {
            }

            List(sample_index_t left, sample_index_t right)
                :QList<Kwave::Stripe>(), m_left(left), m_right(right)
            {
            }

            virtual ~List()
            {
            }

            inline sample_index_t left() const { return m_left; }

            inline sample_index_t right() const { return m_right; }

        private:
            sample_index_t m_left;

            sample_index_t m_right;
        };

    private:

        unsigned int resizeStorage(unsigned int length);

    private:

        class MappedArray: public Kwave::SampleArray
        {
        public:
            explicit MappedArray(Stripe &stripe);

            virtual ~MappedArray();

            unsigned int copy(unsigned int dst, unsigned int src,
                              unsigned int cnt);

            unsigned int read(Kwave::SampleArray &buffer, unsigned int dstoff,
                              unsigned int offset, unsigned int length);

        private:

            Stripe &m_stripe;

            sample_t *m_storage;

            unsigned int m_length;
        };

    private:

        sample_t *mapStorage();

        void unmapStorage();

    private:

        class StripeStorage: public QSharedData
        {
        public:
            StripeStorage();

            StripeStorage(const StripeStorage &other);

            virtual ~StripeStorage();

            sample_t *map();

            void unmap();

            inline int mapCount() const { return m_map_count; }

        public:

            sample_index_t m_start;

            unsigned int m_length;

            Kwave::Handle m_storage;

        private:

            QMutex m_lock;

            int m_map_count;

            sample_t *m_mapped_storage;
        };

    private:

        QMutex m_lock;

        QExplicitlySharedDataPointer<StripeStorage> m_data;

    };
}

#endif /* STRIPE_H */

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