OverViewCache.h

Go to the documentation of this file.

/***************************************************************************
        OverViewCache.h  -  fast cache for sample data overview
                             -------------------
    begin                : Mon May 20 2002
    copyright            : (C) 2000 by Thomas Eschenbacher
    email                : 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 OVER_VIEW_CACHE_H
#define OVER_VIEW_CACHE_H

#include "config.h"

#include <QtGlobal>
#include <QHash>
#include <QImage>
#include <QList>
#include <QMutex>
#include <QObject>
#include <QUuid>
#include <QVector>

#include "libkwave/Sample.h"

#include "libgui/SelectionTracker.h"

class QColor;

namespace Kwave
{

    class SignalManager;
    class Track;

    class Q_DECL_EXPORT OverViewCache: public QObject
    {
        Q_OBJECT
    public:

        typedef struct {
            sample_t min;
            sample_t max;
        } MinMax;

        typedef QVector<MinMax> MinMaxArray;

        OverViewCache(Kwave::SignalManager &signal,
                      sample_index_t src_offset,
                      sample_index_t src_length,
                      const QList<unsigned int> *src_tracks);

        virtual ~OverViewCache();

        int getMinMax(int width, MinMaxArray &minmax);

        virtual QImage getOverView(int width, int height,
                                   const QColor &fg, const QColor &bg,
                                   double gain = 1.0);

    signals:

        void changed();

    protected slots:

        void slotTrackInserted(const QUuid &track_id);

        void slotTrackDeleted(const QUuid &track_id);

        void slotLengthChanged(sample_index_t new_length);

        void slotInvalidated(const QUuid *track_id,
                             sample_index_t first,
                             sample_index_t last);

    protected:

        typedef enum {
            Invalid = 0,
            Fuzzy,
            Valid,
            Unused
        } CacheState;

    private:

        void scaleUp();

        void scaleDown();

        void invalidateCache(const QUuid *uuid,
                             unsigned int first,
                             unsigned int last);

    private:

        Kwave::SignalManager &m_signal;

        Kwave::SelectionTracker m_selection;

        QHash<QUuid, QVector <sample_t> > m_min;

        QHash<QUuid, QVector <sample_t> > m_max;

        QHash<QUuid, QVector <CacheState> > m_state;

        MinMaxArray m_minmax;

        quint64 m_scale;

        QMutex m_lock;

    };
}

#endif // _OVER_VIEW_CACHE_H_

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