Record-PulseAudio.h

Go to the documentation of this file.

/*************************************************************************
    Record-PulseAudio.h  -  device for audio recording via PulesAudio
                             -------------------
    begin                : Sun Okt 20 2013
    copyright            : (C) 2014 by Joerg-Christian Boehme
    email                : joerg@chaosdorf.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 KWAVE_RECORD_PULSEAUDIO_H
#define KWAVE_RECORD_PULSEAUDIO_H

#include "config.h"
#ifdef HAVE_PULSEAUDIO_SUPPORT

#include <poll.h>

#include <pulse/context.h>
#include <pulse/error.h>
#include <pulse/introspect.h>
#include <pulse/mainloop.h>
#include <pulse/proplist.h>
#include <pulse/sample.h>
#include <pulse/stream.h>

#include <QList>
#include <QMutex>
#include <QString>
#include <QStringList>
#include <QWaitCondition>

#include "libkwave/Runnable.h"
#include "libkwave/SampleFormat.h"
#include "libkwave/WorkerThread.h"

#include "RecordDevice.h"

namespace Kwave
{

    class RecordPulseAudio: public Kwave::RecordDevice, public Kwave::Runnable
    {
    public:

        RecordPulseAudio();

        virtual ~RecordPulseAudio() Q_DECL_OVERRIDE;

        virtual QString open(const QString& dev) Q_DECL_OVERRIDE;

        virtual Kwave::byte_order_t endianness() Q_DECL_OVERRIDE;

        virtual Kwave::SampleFormat::Format sampleFormat() Q_DECL_OVERRIDE;

        virtual int setSampleFormat(Kwave::SampleFormat::Format new_format)
            Q_DECL_OVERRIDE;

        virtual QList<Kwave::SampleFormat::Format> detectSampleFormats()
            Q_DECL_OVERRIDE;

        virtual int bitsPerSample() Q_DECL_OVERRIDE;

        virtual int setBitsPerSample(unsigned int new_bits) Q_DECL_OVERRIDE;

        virtual QList< unsigned int > supportedBits() Q_DECL_OVERRIDE;

        virtual Kwave::Compression::Type compression() Q_DECL_OVERRIDE;

        virtual int setCompression(Kwave::Compression::Type new_compression)
            Q_DECL_OVERRIDE;

        virtual QList<Kwave::Compression::Type> detectCompressions()
            Q_DECL_OVERRIDE;

        virtual double sampleRate() Q_DECL_OVERRIDE;

        virtual int setSampleRate(double& new_rate) Q_DECL_OVERRIDE;

        virtual QList< double > detectSampleRates() Q_DECL_OVERRIDE;

        virtual int tracks() Q_DECL_OVERRIDE;

        virtual int setTracks(unsigned int& tracks) Q_DECL_OVERRIDE;

        virtual int detectTracks(unsigned int& min, unsigned int& max)
            Q_DECL_OVERRIDE;

        virtual int close() Q_DECL_OVERRIDE;

        virtual int read(QByteArray& buffer, unsigned int offset)
            Q_DECL_OVERRIDE;

        virtual QStringList supportedDevices() Q_DECL_OVERRIDE;

        int mainloopPoll(struct pollfd *ufds, unsigned long int nfds,
                         int timeout);

    protected:

        virtual void run_wrapper(const QVariant &params) Q_DECL_OVERRIDE;

    private:

        void detectSupportedFormats(const QString &device);

        static void pa_context_notify_cb(pa_context *c, void *userdata);

        static void pa_source_info_cb(pa_context *c, const pa_source_info *info,
                                      int eol, void *userdata);

        static void pa_stream_state_cb(pa_stream *p, void *userdata);

        static void pa_read_cb(pa_stream *p, size_t nbytes, void *userdata);

        void notifySourceInfo(pa_context *c, const pa_source_info *info, int eol);

        void notifyContext(pa_context *c);

        void notifyStreamState(pa_stream *stream);

        void notifyRead(pa_stream *stream, size_t nbytes);

        bool connectToServer();

        void disconnectFromServer();

        void scanDevices();

        pa_sample_format_t mode2format(int compression, int bits,
            Kwave::SampleFormat::Format sample_format);

        int initialize(uint32_t buffer_size);

    private:

        typedef struct
        {
            QString m_name;               
            QString m_description;        
            QString m_driver;             
            quint32 m_card;               
            pa_sample_spec m_sample_spec; 
        } source_info_t;

    private:

        Kwave::WorkerThread m_mainloop_thread;

        QMutex m_mainloop_lock;

        QWaitCondition m_mainloop_signal;

        Kwave::SampleFormat::Format m_sample_format;

        quint8 m_tracks;

        double m_rate;

        Kwave::Compression::Type m_compression;

        unsigned int m_bits_per_sample;

        QList<pa_sample_format_t> m_supported_formats;

        bool m_initialized;

        pa_proplist *m_pa_proplist;

        pa_mainloop *m_pa_mainloop;

        pa_context *m_pa_context;

        pa_stream *m_pa_stream;

        QString m_pa_device;

        QString m_name;

        QString m_device;

        QMap<QString, source_info_t> m_device_list;
    };

}

#endif /* HAVE_PULSEAUDIO_SUPPORT */

#endif // KWAVE_RECORD_PULSEAUDIO_H