#include <PlayBackPlugin.h>

Inheritance diagram for Kwave::PlayBackPlugin:

Collaboration diagram for Kwave::PlayBackPlugin:

Public Slots
void	testPlayBack ()

Public Slots inherited from Kwave::Plugin
virtual void	setProgressDialogEnabled (bool enable)

virtual void	updateProgress (qreal progress)

virtual void	cancel ()

virtual void	close ()

void	release ()

Signals
void	sigTestProgress (int percent)

Signals inherited from Kwave::Plugin
void	sigRunning (Kwave::Plugin *plugin)

void	sigDone (Kwave::Plugin *plugin)

void	sigClosed (Kwave::Plugin *p)

void	sigCommand (const QString &command)

void	setProgressText (const QString &text)

Public Member Functions
	PlayBackPlugin (QObject *parent, const QVariantList &args)

virtual	~PlayBackPlugin () Q_DECL_OVERRIDE

virtual void	load (QStringList &params) Q_DECL_OVERRIDE

virtual void	unload () Q_DECL_OVERRIDE

virtual QStringList *	setup (QStringList &previous_params) Q_DECL_OVERRIDE

virtual void	run (QStringList params) Q_DECL_OVERRIDE

Public Member Functions inherited from Kwave::Plugin
	Plugin (QObject *parent, const QVariantList &args)

virtual	~Plugin () Q_DECL_OVERRIDE

virtual QString	name () const

virtual QString	description () const

virtual QString	progressText ()

virtual bool	canClose () const

bool	isRunning () const

bool	shouldStop () const

virtual int	start (QStringList &params)

virtual int	stop ()

Kwave::PluginManager &	manager () const

Kwave::SignalManager &	signalManager ()

QWidget *	parentWidget () const

QString	signalName ()

virtual sample_index_t	signalLength ()

virtual double	signalRate ()

virtual const QList< unsigned int >	selectedTracks ()

virtual sample_index_t	selection (QList< unsigned int > tracks=Q_NULLPTR, sample_index_t left=Q_NULLPTR, sample_index_t *right=Q_NULLPTR, bool expand_if_empty=false)

virtual void	selectRange (sample_index_t offset, sample_index_t length)

virtual void	migrateToActiveContext ()

Public Member Functions inherited from Kwave::Runnable
virtual	~Runnable ()

Public Member Functions inherited from Kwave::PlaybackDeviceFactory
virtual	~PlaybackDeviceFactory ()

Protected Member Functions
Kwave::PlayBackParam	interpreteParameters (QStringList &params)

virtual Kwave::PlayBackDevice *	createDevice (Kwave::playback_method_t method) Q_DECL_OVERRIDE

virtual QList< Kwave::playback_method_t >	supportedMethods () Q_DECL_OVERRIDE

Protected Member Functions inherited from Kwave::Plugin
int	execute (QStringList &params)

void	emitCommand (const QString &command)

void	use ()

void	setPluginManager (Kwave::PluginManager *new_plugin_manager)

virtual void	run_wrapper (const QVariant &params) Q_DECL_OVERRIDE

Private Attributes
Kwave::PlayBackDialog *	m_dialog

Kwave::PlaybackController &	m_playback_controller

Kwave::SampleSink *	m_playback_sink

Detailed Description

Definition at line 41 of file PlayBackPlugin.h.

Constructor & Destructor Documentation

◆ PlayBackPlugin()

Kwave::PlayBackPlugin::PlayBackPlugin	(	QObject *	parent,
		const QVariantList &	args
	)

Constructor

Parameters

parent	reference to our plugin manager
args	argument list [unused]

Definition at line 74 of file PlayBackPlugin.cpp.

     :Kwave::Plugin(parent, args),
      m_dialog(Q_NULLPTR),
      m_playback_controller(manager().playbackController()),
      m_playback_sink(Q_NULLPTR)
 {
 }

◆ ~PlayBackPlugin()

Kwave::PlayBackPlugin::~PlayBackPlugin ( )

virtual

Destructor

Definition at line 84 of file PlayBackPlugin.cpp.

References m_dialog, and m_playback_sink.

 {
     // make sure the dialog is gone
     if (m_dialog) delete m_dialog;
     m_dialog = Q_NULLPTR;
 
     Q_ASSERT(!m_playback_sink);
 }

Member Function Documentation

◆ createDevice()

Kwave::PlayBackDevice * Kwave::PlayBackPlugin::createDevice ( Kwave::playback_method_t method )

protectedvirtual

Create a playback device matching the given playback method.

Parameters

method a playback_method_t (aRts, ALSA, OSS...)

Returns: a new PlayBackDevice or 0 if failed

Implements Kwave::PlaybackDeviceFactory.

Definition at line 253 of file PlayBackPlugin.cpp.

References DBG, Kwave::TypesMap< IDX, DATA >::findFromData(), Kwave::TypesMap< IDX, DATA >::name(), Kwave::PLAYBACK_ALSA, Kwave::PLAYBACK_OSS, Kwave::PLAYBACK_PULSEAUDIO, Kwave::PLAYBACK_QT_AUDIO, and Kwave::Plugin::signalManager().

 {
     Kwave::PlayBackTypesMap methods;
     qDebug("PlayBackPlugin::createDevice('%s' [%d])",
            DBG(methods.name(methods.findFromData(method))),
            static_cast<int>(method) );
 
     switch (method) {
 #ifdef HAVE_QT_AUDIO_SUPPORT
         case Kwave::PLAYBACK_QT_AUDIO:
             return new Kwave::PlayBackQt();
 #endif /* HAVE_QT_AUDIO_SUPPORT */
 
 #ifdef HAVE_PULSEAUDIO_SUPPORT
         case Kwave::PLAYBACK_PULSEAUDIO:
             return new Kwave::PlayBackPulseAudio(
                 Kwave::FileInfo(signalManager().metaData()));
 #endif /* HAVE_PULSEAUDIO_SUPPORT */
 
 #ifdef HAVE_ALSA_SUPPORT
         case Kwave::PLAYBACK_ALSA:
             return new Kwave::PlayBackALSA();
 #endif /* HAVE_ALSA_SUPPORT */
 
 #ifdef HAVE_OSS_SUPPORT
         case Kwave::PLAYBACK_OSS:
             return new Kwave::PlayBackOSS();
 #endif /* HAVE_OSS_SUPPORT */
 
         default:
             break;
     }
 
     return Q_NULLPTR; // nothing found :-(
 }

Here is the call graph for this function:

◆ interpreteParameters()

Kwave::PlayBackParam Kwave::PlayBackPlugin::interpreteParameters ( QStringList & params )

protected

Interpretes a given parameter list and sets up internal parameters accordingly.

Parameters

params reference to a QStringList with parameters

Returns: the detected playback parameters

Definition at line 94 of file PlayBackPlugin.cpp.

References Kwave::PlayBackParam::bits_per_sample, Kwave::PlayBackParam::bufbase, Kwave::PlayBackParam::channels, Kwave::PlayBackParam::device, Kwave::PlayBackParam::method, Kwave::PLAYBACK_INVALID, and Kwave::PLAYBACK_NONE.

Referenced by load(), and setup().

 {
     Kwave::PlayBackParam playback_params;
     Kwave::PlayBackParam default_params;
     bool ok;
     QString param;
 
     // evaluate the parameter list
     if (params.count() != 5) return default_params;
 
     // parameter #0: playback method
     param = params[0];
     unsigned int method = param.toUInt(&ok);
     Q_ASSERT(ok);
     if (!ok) return default_params;
     if (method >= Kwave::PLAYBACK_INVALID) method = Kwave::PLAYBACK_NONE;
     playback_params.method = static_cast<Kwave::playback_method_t>(method);
 
     // parameter #1: playback device [/dev/dsp , ... ]
     param = params[1];
     playback_params.device = param;
 
     // parameter #2: number of channels [1 | 2]
     param = params[2];
     playback_params.channels = param.toUInt(&ok);
     Q_ASSERT(ok);
     if (!ok) return default_params;
 
     // parameter #3: bits per sample [8 | 16 ]
     param = params[3];
     playback_params.bits_per_sample = param.toUInt(&ok);
     Q_ASSERT(ok);
     if (!ok) return default_params;
 
     // parameter #4: base of buffer size [4...16]
     param = params[4];
     playback_params.bufbase = param.toUInt(&ok);
     Q_ASSERT(ok);
     if (!ok) return default_params;
 
     return playback_params;
 }

Here is the caller graph for this function:

◆ load()

void Kwave::PlayBackPlugin::load ( QStringList & params )

virtual

Gets called when the plugin is first loaded and connects itself to the playback controller and the current signal.

Reimplemented from Kwave::Plugin.

Definition at line 139 of file PlayBackPlugin.cpp.

References interpreteParameters(), m_playback_controller, Kwave::PlaybackController::registerPlaybackDeviceFactory(), Kwave::PlaybackController::setDefaultParams(), and Kwave::Plugin::use().

 {
     use(); // stay loaded
 
     // register as a factory for playback devices
     m_playback_controller.registerPlaybackDeviceFactory(this);
     m_playback_controller.setDefaultParams(interpreteParameters(params));
 }

Here is the call graph for this function:

◆ run()

void Kwave::PlayBackPlugin::run ( QStringList params )

virtual

Starts a playback test sequence

Parameters

params list of strings with parameters (unused)

Reimplemented from Kwave::Plugin.

Definition at line 291 of file PlayBackPlugin.cpp.

References Kwave::StreamObject::blockSize(), Kwave::PlayBackParam::channels, Kwave::connect(), Kwave::Osc::goOn(), Kwave::CurveStreamAdapter::goOn(), Kwave::MultiTrackSource< SOURCE, INITIALIZE >::goOn(), Kwave::Curve::insert(), m_dialog, m_playback_sink, Kwave::PlayBackDialog::params(), PLAYBACK_TEST_FREQUENCY, Kwave::PlayBackParam::rate, Kwave::StreamObject::setAttribute(), Kwave::Plugin::shouldStop(), sigTestProgress(), Kwave::toInt(), and Kwave::toUint().

 {
     const double       t_sweep =   1.0; /* seconds per speaker */
     const unsigned int periods =     3; /* number of periods to play */
 
     qDebug("PlayBackPlugin::run()");
 
     Q_UNUSED(params);
 
     Q_ASSERT(m_dialog);
     Q_ASSERT(m_playback_sink);
     if (!m_dialog || !m_playback_sink) return;
     Kwave::PlayBackParam playback_params = m_dialog->params();
 
     unsigned int channels = playback_params.channels;
     double rate           = playback_params.rate;
     Q_ASSERT(channels);
     Q_ASSERT(rate > 1.0);
     if (!channels || (rate <= 1.0)) return;
 
     // settings are valid -> take them
 
     double t_period = t_sweep * channels;
     unsigned int curve_length = Kwave::toUint(t_period * rate);
 
     // create all objects
     Kwave::Curve curve;
     curve.insert(0.0, 0.0);
     if (channels < 2) {
         // mono
         curve.insert(0.5, 1.0);
     } else {
         // all above
         curve.insert(0.5 / static_cast<double>(channels), 1.0);
         curve.insert(1.0 / static_cast<double>(channels), 0.0);
     }
     curve.insert(1.0, 0.0);
 
     Kwave::CurveStreamAdapter curve_adapter(curve, curve_length);
 
     Kwave::MultiTrackSource<Kwave::Delay, true> delay(channels);
     for (unsigned int i = 0; i < channels; i++) {
         Q_ASSERT(delay[i]);
         if (!delay[i]) break;
         delay[i]->setAttribute(SLOT(setDelay(QVariant)),
             QVariant(i * t_sweep * rate));
     }
 
     Kwave::Osc osc;
     osc.setAttribute(SLOT(setFrequency(QVariant)),
                      QVariant(rate / PLAYBACK_TEST_FREQUENCY));
 
     Kwave::MultiTrackSource<Kwave::Mul, true> mul(channels);
 
     // connect everything together...
     //
     // curve -> delay --.
     //                  |
     //                  v
     //                 mul -> sink
     //                  ^
     //                  |
     //            osc --'
 
     Kwave::connect(
         curve_adapter,    SIGNAL(output(Kwave::SampleArray)),
         delay,            SLOT(input(Kwave::SampleArray)));
     Kwave::connect(
         delay,            SIGNAL(output(Kwave::SampleArray)),
         mul,              SLOT(input_a(Kwave::SampleArray)));
     Kwave::connect(
         osc,              SIGNAL(output(Kwave::SampleArray)),
         mul,              SLOT(input_b(Kwave::SampleArray)));
     Kwave::connect(
         mul,              SIGNAL(output(Kwave::SampleArray)),
         *m_playback_sink, SLOT(input(Kwave::SampleArray)));
 
     // show a progress dialog
 
     // transport the samples
     sample_index_t samples_max     = static_cast<sample_index_t>(
                                      periods * t_period * rate);
     sample_index_t samples_written = 0;
     while (!shouldStop() && (samples_written <= samples_max)) {
         osc.goOn();
         curve_adapter.goOn();
         delay.goOn();
         mul.goOn();
 
         samples_written += osc.blockSize();
 
         double percent = (static_cast<double>(samples_written) * 100.0) /
                           static_cast<double>(samples_max);
         emit sigTestProgress(Kwave::toInt(percent));
     }
 }

Here is the call graph for this function:

◆ setup()

QStringList * Kwave::PlayBackPlugin::setup ( QStringList & previous_params )

virtual

See also: Kwave::Plugin::setup()

Reimplemented from Kwave::Plugin.

Definition at line 157 of file PlayBackPlugin.cpp.

References _, Kwave::PlayBackParam::bits_per_sample, Kwave::PlayBackParam::bufbase, Kwave::PlayBackParam::channels, Kwave::connect(), DBG, Kwave::PlayBackParam::device, interpreteParameters(), m_dialog, Kwave::Plugin::manager(), Kwave::PlayBackParam::method, Kwave::PlayBackDialog::params(), Kwave::SignalManager::playbackController(), Kwave::PlaybackController::setDefaultParams(), Kwave::PlayBackDialog::setMethod(), Kwave::Plugin::signalManager(), and testPlayBack().

 {
     QStringList *result = Q_NULLPTR;
 
     // try to interpret the list of previous parameters, ignore errors
     Kwave::PlayBackParam playback_params =
         interpreteParameters(previous_params);
 
     Q_ASSERT(!m_dialog);
     if (m_dialog) delete m_dialog;
 
     m_dialog = new Kwave::PlayBackDialog(
         *this,
         manager().playbackController(),
         playback_params
     );
     Q_ASSERT(m_dialog);
     if (!m_dialog) return Q_NULLPTR;
 
     connect(m_dialog, SIGNAL(sigTestPlayback()),
             this, SLOT(testPlayBack()));
 
     // activate the playback method
     m_dialog->setMethod(playback_params.method);
 
     if (m_dialog->exec() == QDialog::Accepted) {
         // get the new parameters and let them take effect
         result = new QStringList();
         Q_ASSERT(result);
         if (result) {
             QString param;
 
             playback_params = m_dialog->params();
 
             // parameter #0: playback method
             param = param.setNum(
                 static_cast<unsigned int>(playback_params.method));
             result->append(param);
 
             // parameter #1: playback device [/dev/dsp , ... ]
             param = playback_params.device;
             result->append(param);
 
             // parameter #2: number of channels [1, 2, ... n]
             param = param.setNum(playback_params.channels);
             result->append(param);
 
             // parameter #3: bits per sample [8, 16, 24, ...]
             param = param.setNum(playback_params.bits_per_sample);
             result->append(param);
 
             // parameter #4: base of buffer size [8 ... 16]
             param = param.setNum(playback_params.bufbase);
             result->append(param);
 
             qDebug("new playback params: '%s",
                    DBG(result->join(_("','")) + _("'")));
 
             // take over the new playback parameters
             signalManager().playbackController().setDefaultParams(
                 playback_params
             );
         }
     }
 
     delete m_dialog;
     m_dialog = Q_NULLPTR;
 
     return result;
 }

Here is the call graph for this function:

◆ sigTestProgress

void Kwave::PlayBackPlugin::sigTestProgress ( int percent )

signal

emits the progress of the playback test, from thread context

Referenced by run(), and testPlayBack().

Here is the caller graph for this function:

◆ supportedMethods()

QList< Kwave::playback_method_t > Kwave::PlayBackPlugin::supportedMethods ( )

protectedvirtual

Returns a list of supported playback methods.

Returns: list of all supported playback methods, should not contain "any" or "invalid"

Implements Kwave::PlaybackDeviceFactory.

Definition at line 229 of file PlayBackPlugin.cpp.

References Kwave::PLAYBACK_ALSA, Kwave::PLAYBACK_OSS, Kwave::PLAYBACK_PULSEAUDIO, and Kwave::PLAYBACK_QT_AUDIO.

 {
     QList<Kwave::playback_method_t> methods;
 
 #ifdef HAVE_QT_AUDIO_SUPPORT
     methods.append(Kwave::PLAYBACK_QT_AUDIO);
 #endif /* HAVE_QT_AUDIO_SUPPORT */
 
 #ifdef HAVE_PULSEAUDIO_SUPPORT
     methods.append(Kwave::PLAYBACK_PULSEAUDIO);
 #endif /* HAVE_PULSEAUDIO_SUPPORT */
 
 #ifdef HAVE_ALSA_SUPPORT
     methods.append(Kwave::PLAYBACK_ALSA);
 #endif /* HAVE_ALSA_SUPPORT */
 
 #ifdef HAVE_OSS_SUPPORT
     methods.append(Kwave::PLAYBACK_OSS);
 #endif /* HAVE_OSS_SUPPORT */
 
     return methods;
 }

◆ testPlayBack

void Kwave::PlayBackPlugin::testPlayBack ( )

slot

Plays a sample sound for testing the playback

Definition at line 389 of file PlayBackPlugin.cpp.

References _, Kwave::Plugin::cancel(), Kwave::PlayBackParam::channels, Kwave::Plugin::close(), Kwave::connect(), Kwave::PlayBackParam::device, Kwave::Plugin::execute(), Kwave::Plugin::isRunning(), m_dialog, m_playback_sink, Kwave::Plugin::manager(), Kwave::PluginManager::openMultiTrackPlayback(), Kwave::PlayBackDialog::params(), PLAYBACK_TEST_FREQUENCY, Kwave::PlayBackParam::rate, Kwave::StreamObject::setInteractive(), Kwave::Plugin::sigDone(), sigTestProgress(), Kwave::MessageBox::sorry(), Kwave::Plugin::stop(), and Kwave::toInt().

Referenced by setup().

 {
     qDebug("PlayBackPlugin::testPlayBack()");
 
     Q_ASSERT(m_dialog);
     if (!m_dialog) return;
     Kwave::PlayBackParam playback_params = m_dialog->params();
 
     // check if we really have selected a playback device
     if (!playback_params.device.length()) {
         Kwave::MessageBox::sorry(m_dialog, i18n(
             "Please select a playback device first"));
         return;
     }
 
     unsigned int channels = playback_params.channels;
     double rate           = playback_params.rate;
     Q_ASSERT(channels);
     Q_ASSERT(rate > 1.0);
     if (!channels || (rate <= 1.0)) return;
 
     // settings are valid -> take them
 
     // create the multi track playback sink
     // NOTE: this must be done in main thread context!
     Q_ASSERT(!m_playback_sink);
     if (m_playback_sink) return;
     m_playback_sink = manager().openMultiTrackPlayback(
         channels,
         &playback_params
     );
     if (!m_playback_sink) return;
     m_playback_sink->setInteractive(true);
 
     // show a progress dialog
     QProgressDialog *progress = Q_NULLPTR;
     progress = new QProgressDialog(m_dialog);
     Q_ASSERT(progress);
     if (progress) {
         progress->setWindowTitle(i18n("Playback Test"));
         progress->setModal(true);
         progress->setMinimumDuration(0);
         progress->setMinimum(0);
         progress->setMaximum(100);
         progress->setAutoClose(false);
         progress->setValue(0);
         progress->setLabelText(
             _("<html><p><br>") +
             i18n("You should now hear a %1 Hz test tone.<br/><br/>"
                     "(If you hear clicks or dropouts, please increase<br/>"
                     "the buffer size and try again)",
                     Kwave::toInt(PLAYBACK_TEST_FREQUENCY)) +
             _("</p></html>")
         );
         connect(progress, SIGNAL(canceled()), this, SLOT(cancel()),
                 Qt::QueuedConnection);
         connect(this, SIGNAL(sigDone(Kwave::Plugin*)), progress, SLOT(close()),
                 Qt::QueuedConnection);
         connect(this, SIGNAL(sigTestProgress(int)), progress, SLOT(setValue(int)),
                 Qt::QueuedConnection);
 
         QStringList params;
         execute(params);
         progress->exec();
         cancel();
     }
 
     // set hourglass cursor, waiting for shutdown could take some time...
     QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
 
     // wait through manual polling here, no timeout
     qDebug("waiting...");
     while (isRunning()) {
         cancel();
         sleep(1);
         qDebug(".");
     }
     qDebug("done.");
 
     // close the playback sink again (here in main thread context)
     m_playback_sink->setInteractive(false);
     delete m_playback_sink;
     m_playback_sink = Q_NULLPTR;
 
     // free the progress dialog
     delete progress;
 
     // stop the worker thread through the Runnable API
     stop();
 
     // remove hourglass
     QApplication::restoreOverrideCursor();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ unload()

void Kwave::PlayBackPlugin::unload ( )

virtual

Gets called before the plugin is unloaded.

Reimplemented from Kwave::Plugin.

Definition at line 149 of file PlayBackPlugin.cpp.

References m_playback_controller, Kwave::Plugin::release(), and Kwave::PlaybackController::unregisterPlaybackDeviceFactory().

 {
     // unregister from the list playback factories
     m_playback_controller.unregisterPlaybackDeviceFactory(this);
     release();
 }

Here is the call graph for this function:

Member Data Documentation

◆ m_dialog

Kwave::PlayBackDialog* Kwave::PlayBackPlugin::m_dialog

private

dialog for the playback setup

Definition at line 118 of file PlayBackPlugin.h.

Referenced by run(), setup(), testPlayBack(), and ~PlayBackPlugin().

◆ m_playback_controller

Kwave::PlaybackController& Kwave::PlayBackPlugin::m_playback_controller

private

reference to the playback controller

Definition at line 121 of file PlayBackPlugin.h.

Referenced by load(), and unload().

◆ m_playback_sink

Kwave::SampleSink* Kwave::PlayBackPlugin::m_playback_sink

private

sample sink, for playback test

Definition at line 124 of file PlayBackPlugin.h.

Referenced by run(), testPlayBack(), and ~PlayBackPlugin().

The documentation for this class was generated from the following files:

plugins/playback/PlayBackPlugin.h
plugins/playback/PlayBackPlugin.cpp

Public Slots

Signals

Public Member Functions

Protected Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ PlayBackPlugin()

◆ ~PlayBackPlugin()

Member Function Documentation

◆ createDevice()

◆ interpreteParameters()

◆ load()

◆ run()

◆ setup()

◆ sigTestProgress

◆ supportedMethods()

◆ testPlayBack

◆ unload()

Member Data Documentation

◆ m_dialog

◆ m_playback_controller

◆ m_playback_sink