SampleReader.h

Go to the documentation of this file.

/***************************************************************************
         SampleReader.h  -  stream for reading samples from a track
                             -------------------
    begin                : Apr 25 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 SAMPLE_READER_H
#define SAMPLE_READER_H

#include "config.h"

#include <QtGlobal>
#include <QList>
#include <QObject>
#include <QTime>

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

namespace Kwave
{

    class Q_DECL_EXPORT SampleReader: public Kwave::SampleSource
    {
        Q_OBJECT
    public:

        SampleReader(Kwave::ReaderMode mode, Kwave::Stripe::List stripes);

        virtual ~SampleReader() Q_DECL_OVERRIDE;

        void reset();

        virtual void goOn() Q_DECL_OVERRIDE;

        inline bool eof() const {
            return (pos() > m_last);
        }

        virtual bool done() const Q_DECL_OVERRIDE { return eof(); }

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

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

        void skip(sample_index_t count);

        void seek(sample_index_t pos);

        inline sample_index_t pos() const {
            return (m_src_position + m_buffer_position - m_buffer_used);
        }

        inline sample_index_t first() const {
            return m_first;
        }

        inline sample_index_t last() const {
            return m_last;
        }

        SampleReader& operator >> (sample_t &sample);

        SampleReader& operator >> (Kwave::SampleArray &sample);

    signals:

        void proceeded();

        void output(Kwave::SampleArray data);

    protected:

        void fillBuffer();

        unsigned int readSamples(sample_index_t offset,
                                 Kwave::SampleArray &buffer,
                                 unsigned int buf_offset,
                                 unsigned int length);

    private:

        Kwave::ReaderMode m_mode;

        QList<Kwave::Stripe> m_stripes;

        sample_index_t m_src_position;

        sample_index_t m_first;

        sample_index_t m_last;

        Kwave::SampleArray m_buffer;

        unsigned int m_buffer_used;

        unsigned int m_buffer_position;

        QTime m_progress_time;

        sample_index_t m_last_seek_pos;

    };
}

#endif /* SAMPLE_READER_H */

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