RecordPlugin.h

Go to the documentation of this file.

/*************************************************************************
         RecordPlugin.h  -  plugin for recording audio data
                             -------------------
    begin                : Wed Jul 09 2003
    copyright            : (C) 2003 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 RECORD_PLUGIN_H
#define RECORD_PLUGIN_H

#include "config.h"

#include <QByteArray>
#include <QList>
#include <QString>
#include <QStringList>
#include <QTimer>
#include <QVector>

#include "libkwave/MultiTrackWriter.h"
#include "libkwave/Plugin.h"
#include "libkwave/Sample.h"
#include "libkwave/SampleArray.h"
#include "libkwave/SampleFIFO.h"
#include "libkwave/SampleFormat.h"

#include "RecordController.h"
#include "RecordParams.h"
#include "RecordState.h"

class QStringList;

namespace Kwave
{

    class RecordDevice;
    class RecordDialog;
    class RecordThread;
    class SampleDecoder;

    class RecordPlugin: public Kwave::Plugin
    {
        Q_OBJECT
    public:

        RecordPlugin(QObject *parent, const QVariantList &args);

        virtual ~RecordPlugin() Q_DECL_OVERRIDE;

        virtual QStringList *setup(QStringList &previous_params) Q_DECL_OVERRIDE;

    signals:

        void sigRecordedSamples(sample_index_t samples_recorded);

    protected:

        class InhibitRecordGuard
        {
        public:
            explicit InhibitRecordGuard(Kwave::RecordPlugin &recorder)
                :m_recorder(recorder)
            {
                m_recorder.enterInhibit();
            }

            virtual ~InhibitRecordGuard()
            {
                m_recorder.leaveInhibit();
            }

        private:
            Kwave::RecordPlugin &m_recorder;
        };

    protected:
        friend class InhibitRecordGuard;

        void enterInhibit();

        void leaveInhibit();

    protected slots:

        void resetRecording(bool &accepted);

        void startRecording();

        void recordStopped(int reason);

        void stateChanged(Kwave::RecordState state);

    private slots:

        // setup functions

        void setMethod(Kwave::record_method_t method);

        void setDevice(const QString &device);

        void changeTracks(unsigned int new_tracks);

        void changeSampleRate(double new_rate);

        void changeCompression(Kwave::Compression::Type new_compression);

        void changeBitsPerSample(unsigned int new_bits);

        void changeSampleFormat(Kwave::SampleFormat::Format new_format);

        void processBuffer();

        void buffersChanged();

        void prerecordingChanged(bool enable);

        void retryOpen();

    private:

        void closeDevice();

        void notice(QString message);

        void setupRecordThread();

        void updateBufferProgressBar();

        bool checkTrigger(unsigned int track, const Kwave::SampleArray &buffer);

        void split(QByteArray &raw_data, QByteArray &dest,
                   unsigned int bytes_per_sample,
                   unsigned int track,
                   unsigned int tracks);

        void enqueuePrerecording(unsigned int track,
                                 const Kwave::SampleArray &decoded);

        void flushPrerecordingQueue();

        bool paramsValid();

    private:

        Kwave::record_method_t m_method;

        QString m_device_name;

        Kwave::RecordController m_controller;

        Kwave::RecordState m_state;

        Kwave::RecordDevice *m_device;

        Kwave::RecordDialog *m_dialog;

        Kwave::RecordThread *m_thread;

        Kwave::SampleDecoder *m_decoder;

        QVector<Kwave::SampleFIFO> m_prerecording_queue;

        Kwave::MultiTrackWriter *m_writers;

        unsigned int m_buffers_recorded;

        unsigned int m_inhibit_count;

        QVector<float> m_trigger_value;

        QTimer m_retry_timer;

    };
}

#endif /* RECORD_PLUGIN_H */

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