From 00bb99ac80741fc50ef8a289719373032f2391eb Mon Sep 17 00:00:00 2001 From: toma Date: Wed, 25 Nov 2009 17:56:58 +0000 Subject: Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features. BUG:215923 git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdeaccessibility@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da --- kttsd/players/Makefile.am | 27 + kttsd/players/akodeplayer/Makefile.am | 28 + kttsd/players/akodeplayer/README | 19 + kttsd/players/akodeplayer/akodeplayer.cpp | 179 ++ kttsd/players/akodeplayer/akodeplayer.h | 67 + kttsd/players/akodeplayer/akodeplugin.cpp | 29 + .../players/akodeplayer/kttsd_akodeplugin.desktop | 89 + kttsd/players/alsaplayer/Makefile.am | 30 + kttsd/players/alsaplayer/alsaplayer.cpp | 1729 ++++++++++++++++++++ kttsd/players/alsaplayer/alsaplayer.h | 187 +++ kttsd/players/alsaplayer/alsaplugin.cpp | 29 + kttsd/players/alsaplayer/formats.h | 110 ++ kttsd/players/alsaplayer/kttsd_alsaplugin.desktop | 89 + kttsd/players/artsplayer/Makefile.am | 30 + kttsd/players/artsplayer/artsplayer.cpp | 296 ++++ kttsd/players/artsplayer/artsplayer.h | 95 ++ kttsd/players/artsplayer/artsplugin.cpp | 29 + kttsd/players/artsplayer/kttsd_artsplugin.desktop | 91 ++ kttsd/players/gstplayer/Makefile.am | 30 + kttsd/players/gstplayer/gstplugin.cpp | 29 + kttsd/players/gstplayer/gstreamerplayer.cpp | 258 +++ kttsd/players/gstplayer/gstreamerplayer.h | 76 + kttsd/players/gstplayer/kttsd_gstplugin.desktop | 92 ++ kttsd/players/kttsd_audioplugin.desktop | 47 + 24 files changed, 3685 insertions(+) create mode 100644 kttsd/players/Makefile.am create mode 100644 kttsd/players/akodeplayer/Makefile.am create mode 100644 kttsd/players/akodeplayer/README create mode 100644 kttsd/players/akodeplayer/akodeplayer.cpp create mode 100644 kttsd/players/akodeplayer/akodeplayer.h create mode 100644 kttsd/players/akodeplayer/akodeplugin.cpp create mode 100644 kttsd/players/akodeplayer/kttsd_akodeplugin.desktop create mode 100644 kttsd/players/alsaplayer/Makefile.am create mode 100644 kttsd/players/alsaplayer/alsaplayer.cpp create mode 100644 kttsd/players/alsaplayer/alsaplayer.h create mode 100644 kttsd/players/alsaplayer/alsaplugin.cpp create mode 100644 kttsd/players/alsaplayer/formats.h create mode 100644 kttsd/players/alsaplayer/kttsd_alsaplugin.desktop create mode 100644 kttsd/players/artsplayer/Makefile.am create mode 100644 kttsd/players/artsplayer/artsplayer.cpp create mode 100644 kttsd/players/artsplayer/artsplayer.h create mode 100644 kttsd/players/artsplayer/artsplugin.cpp create mode 100644 kttsd/players/artsplayer/kttsd_artsplugin.desktop create mode 100644 kttsd/players/gstplayer/Makefile.am create mode 100644 kttsd/players/gstplayer/gstplugin.cpp create mode 100644 kttsd/players/gstplayer/gstreamerplayer.cpp create mode 100644 kttsd/players/gstplayer/gstreamerplayer.h create mode 100644 kttsd/players/gstplayer/kttsd_gstplugin.desktop create mode 100644 kttsd/players/kttsd_audioplugin.desktop (limited to 'kttsd/players') diff --git a/kttsd/players/Makefile.am b/kttsd/players/Makefile.am new file mode 100644 index 0000000..f400d82 --- /dev/null +++ b/kttsd/players/Makefile.am @@ -0,0 +1,27 @@ +#kdevelop: artsplayer_DIR = artsplayer +if include_kttsd_artsplayer + artsplayer_DIR = artsplayer +endif + +#kdevelop: gstplayer_DIR = gstplayer +if include_kttsd_gstplayer + gstplayer_DIR = gstplayer +endif + +#kdevelop: alsaplayer_DIR = alsaplayer +if include_kttsd_alsaplayer + alsaplayer_DIR = alsaplayer +endif + +#kdevelop: akodeplayer_DIR = akodeplayer +if include_kttsd_akodeplayer + akodeplayer_DIR = akodeplayer +endif + +SUBDIRS = \ + $(artsplayer_DIR) \ + $(alsaplayer_DIR) \ + $(gstplayer_DIR) \ + $(akodeplayer_DIR) + +kde_servicetypes_DATA = kttsd_audioplugin.desktop diff --git a/kttsd/players/akodeplayer/Makefile.am b/kttsd/players/akodeplayer/Makefile.am new file mode 100644 index 0000000..f5039f6 --- /dev/null +++ b/kttsd/players/akodeplayer/Makefile.am @@ -0,0 +1,28 @@ +INCLUDES = \ + -I$(top_srcdir)/kttsd/libkttsd -I$(top_builddir)/kttsd/libkttsd \ + $(akode_includes) \ + $(all_includes) + +# Let automoc handle all of the metsource files (moc). +METASOURCES = AUTO + +######################################################################### +# LIBRARY SECTION +######################################################################### +# This is the library that gets installed. It's name is used for all +# of the other Makefile.am variables. +kde_module_LTLIBRARIES = libkttsd_akodeplugin.la + +libkttsd_akodeplugin_la_SOURCES = \ + akodeplugin.cpp \ + akodeplayer.cpp +libkttsd_akodeplugin_la_LDFLAGS = $(KDE_PLUGIN) $(all_libraries) -no-undefined +libkttsd_akodeplugin_la_LIBADD = $(top_builddir)/kttsd/libkttsd/libkttsd.la $(akode_libs) + +# Header files that should not be installed. +noinst_HEADERS = \ + akodeplayer.h + +# This library is installed as a plugin. +services_DATA = kttsd_akodeplugin.desktop +servicesdir = $(kde_servicesdir) diff --git a/kttsd/players/akodeplayer/README b/kttsd/players/akodeplayer/README new file mode 100644 index 0000000..a45864f --- /dev/null +++ b/kttsd/players/akodeplayer/README @@ -0,0 +1,19 @@ +This is an aKode audio plugin for KTTS. + +There are two problems right now (19 Jun 2005) that prevent this from being usable +for KTTS: + +1. There was a bug in aKode that prevents it from playing .wav files. Carewolf + applied a patch on 13 Jun 2005 to decoderpluginhandler.cpp for this, + so you may need to update your kdemultimedia modules. + +2. aKode doesn't instantly stop when calling pause() or stop(). + See bug:107135. + +If you want to try this plugin, add --enable-kttsd-akode to ./configure command. + +If the problems above aren't addressed, this plugin should probably be removed +from KTTS. + +-- Gary Cramblitt (PhantomsDad) + diff --git a/kttsd/players/akodeplayer/akodeplayer.cpp b/kttsd/players/akodeplayer/akodeplayer.cpp new file mode 100644 index 0000000..de88773 --- /dev/null +++ b/kttsd/players/akodeplayer/akodeplayer.cpp @@ -0,0 +1,179 @@ +/*************************************************************************** + copyright : (C) 2004 by Allan Sandfeld Jensen + email : kde@carewolf.com +***************************************************************************/ + +/*************************************************************************** + * * + * 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. * + * * + ***************************************************************************/ + +#include + +#include + +#include + +#include "akode/player.h" +#include "akode/decoder.h" + +#include "akodeplayer.h" + +using namespace aKode; + +//////////////////////////////////////////////////////////////////////////////// +// public methods +//////////////////////////////////////////////////////////////////////////////// + +aKodePlayer::aKodePlayer(QObject* parent, const char* name, const QStringList& args) : + Player(parent, name, args), + m_player(0) +{} + +aKodePlayer::~aKodePlayer() +{ + delete m_player; +} + +//void aKodePlayer::play(const FileHandle &file) +void aKodePlayer::startPlay(const QString &file) +{ + kdDebug() << k_funcinfo << endl; + + if (file.isNull()) { // null FileHandle file means unpause + if (paused()) + // m_player->resume(); + m_player->play(); + else + stop(); + return; + } + + // QString filename = file.absFilePath(); + + kdDebug() << "Opening: " << file << endl; + + if (m_player) + m_player->stop(); + else { + m_player = new aKode::Player(); + if (!m_player->open(m_sinkName.ascii())) { + kdDebug() << k_funcinfo << "Unable to open aKode " << m_sinkName << " sink. " + << "Falling back to auto." << endl; + m_player->open("auto"); + } + } + + if (m_player->load(QFile::encodeName(file))) + m_player->play(); + +} + +void aKodePlayer::pause() +{ + if (m_player) + m_player->pause(); +} + +void aKodePlayer::stop() +{ + if (m_player) { + m_player->stop(); + m_player->unload(); + } +} + +void aKodePlayer::setVolume(float volume) +{ + if (m_player) + m_player->setVolume(volume); +} + +float aKodePlayer::volume() const +{ + if (m_player) + return m_player->volume(); + // 1.0 is full volume + return 1.0; +} + +///////////////////////////////////////////////////////////////////////////////// +// m_player status functions +///////////////////////////////////////////////////////////////////////////////// + +bool aKodePlayer::playing() const +{ + if (m_player && m_player->decoder()) + return !m_player->decoder()->eof(); + else + return false; +} + +bool aKodePlayer::paused() const +{ + return m_player && (m_player->state() == aKode::Player::Paused); +} + +int aKodePlayer::totalTime() const +{ + if (m_player) { + Decoder *d = m_player->decoder(); + if (d) + return d->length() / 1000; + } + return -1; +} + +int aKodePlayer::currentTime() const +{ + if (m_player) { + Decoder *d = m_player->decoder(); + if (d) + return d->position() / 1000; + } + return -1; +} + +int aKodePlayer::position() const +{ + if (m_player) { + Decoder *d = m_player->decoder(); + if (d && d->length()) + return (d->position()*1000)/(d->length()); + else + return -1; + } + else + return -1; +} + +///////////////////////////////////////////////////////////////////////////////// +// m_player seek functions +///////////////////////////////////////////////////////////////////////////////// + +void aKodePlayer::seek(int seekTime) +{ + // seek time in seconds? + if (m_player) + m_player->decoder()->seek(seekTime*1000); +} + +void aKodePlayer::seekPosition(int position) +{ + // position unit is 1/1000th + if (m_player) + m_player->decoder()->seek((position * m_player->decoder()->length())/1000); +} + +QStringList aKodePlayer::getPluginList( const QCString& /*classname*/ ) +{ + return QStringList::split("|", "auto|polyp|alsa|jack|oss"); +} + +void aKodePlayer::setSinkName(const QString& sinkName) { m_sinkName = sinkName; } + +#include "akodeplayer.moc" diff --git a/kttsd/players/akodeplayer/akodeplayer.h b/kttsd/players/akodeplayer/akodeplayer.h new file mode 100644 index 0000000..bbfb3ea --- /dev/null +++ b/kttsd/players/akodeplayer/akodeplayer.h @@ -0,0 +1,67 @@ +/*************************************************************************** + copyright : (C) 2004 by Allan Sandfeld Jensen + email : kde@carewolf.com +***************************************************************************/ + +/*************************************************************************** + * * + * 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 AKODEPLAYER_H +#define AKODEPLAYER_H + +#include +#include "kdeexportfix.h" + +#include + +#include "player.h" +#include +namespace aKode { + class File; + class Player; +} + +class KDE_EXPORT aKodePlayer : public Player +{ + Q_OBJECT + +public: + aKodePlayer(QObject* parent = 0, const char* name = 0, const QStringList& args=QStringList()); + virtual ~aKodePlayer(); + + // virtual void play(const FileHandle &file = FileHandle::null()); + virtual void startPlay(const QString &file); + + virtual void setVolume(float volume = 1.0); + virtual float volume() const; + + virtual bool playing() const; + virtual bool paused() const; + + virtual int totalTime() const; + virtual int currentTime() const; + virtual int position() const; + + virtual void seek(int seekTime); + virtual void seekPosition(int position); + + virtual QStringList getPluginList( const QCString& classname ); + virtual void setSinkName(const QString &sinkName); + +public slots: + void pause(); + void stop(); + +private: + aKode::Player *m_player; + QString m_sinkName; +}; + +#endif diff --git a/kttsd/players/akodeplayer/akodeplugin.cpp b/kttsd/players/akodeplayer/akodeplugin.cpp new file mode 100644 index 0000000..9ef0deb --- /dev/null +++ b/kttsd/players/akodeplayer/akodeplugin.cpp @@ -0,0 +1,29 @@ +/***************************************************** vim:set ts=4 sw=4 sts=4: + Generating the factories so aKode can be used as an audio plug in. + ------------------- + Copyright: + (C) 2005 by Gary Cramblitt + ------------------- + Original author: Gary Cramblitt + + 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. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + ******************************************************************************/ + +#include + +#include "akodeplayer.h" + +K_EXPORT_COMPONENT_FACTORY( libkttsd_akodeplugin, KGenericFactory("kttsd_akode") ); + diff --git a/kttsd/players/akodeplayer/kttsd_akodeplugin.desktop b/kttsd/players/akodeplayer/kttsd_akodeplugin.desktop new file mode 100644 index 0000000..cc2c4bf --- /dev/null +++ b/kttsd/players/akodeplayer/kttsd_akodeplugin.desktop @@ -0,0 +1,89 @@ +[Desktop Entry] +Name=KTTSD aKode Plugin +Name[br]=Lugent aKode evit KTTSD +Name[bs]=KTTSD aKode dodatak +Name[ca]=Connector aKode pel KTTSD +Name[cs]=KTTSD aKode modul +Name[da]=KTTSD aKode-plugin +Name[de]=KTTSD aKode-Modul +Name[el]=KTTSD πρόσθετο aKode +Name[es]=Complemento aKode de KTTSD +Name[et]=KTTSD aKode plugin +Name[eu]=KTTSD-ren aKode plugina +Name[fa]=وصلۀ KTTSD aKode +Name[fi]=KTTSD aKode -liitännäinen +Name[fr]=Module aKode pour KTTSD +Name[ga]=Breiseán KTTSD aKode +Name[gl]=Plugin aKode de KTTSD +Name[he]=תוסף aKode עבור KTTSD +Name[hu]=KTTSD aKode hangmodul +Name[is]=KTTSD aKode íforrit +Name[it]=Plugin per aKode di KTTSD +Name[ja]=KTTSD aKode プラグイン +Name[ka]=KTTSD aKode მოდული +Name[km]= កម្មវិធី​ជំនួយ​ aKode សម្រាប់ KTTSD +Name[mk]=aKode-приклучок за KTTSD +Name[nb]=Programtillegg for KTTSD aKode +Name[nds]=aKode-Moduul för KTTSD +Name[ne]=KTTSD aKode प्लगइन +Name[nl]=KTTSD aKode-plugin +Name[pa]=KTTSD aKode ਪਲੱਗਿੰਨ +Name[pl]=Wtyczka aKode KTTSD +Name[pt]='Plugin' aKode do KTTSD +Name[pt_BR]=Plug-in aKode para o KTTSD +Name[ru]=Модуль aKode для KTTSD +Name[sk]=Modul KTTSD aKode +Name[sl]=Vstavek KTTSD za aKode +Name[sr]=aKode прикључак за KTTSD +Name[sr@Latn]=aKode priključak za KTTSD +Name[sv]=KTTSD-insticksprogram för aKode +Name[tg]=Модули KTTSD aKode +Name[tr]=KTTSD aKode Eklentisi +Name[uk]=Втулок aKode для KTTSD +Name[vi]=Trình bổ sung KTTSD aKode +Name[zh_TW]=KTTSD aKode 外掛程式 +Comment=KTTSD aKode audio plugin +Comment[bg]=Аудио приставка на KTTSD за aKode +Comment[br]=Lugent klevet aKode evit KTTSD +Comment[ca]=Connector d'àudio aKode pel KTTSD +Comment[cs]=KTTSD aKode zvukový modul +Comment[da]=KTTSD aKode lyd-plugin +Comment[de]=KTTSD aKode-Audio-Modul +Comment[el]=KTTSD πρόσθετο ήχου aKode +Comment[es]=Complemento de audio aKode de KTTSD +Comment[et]=KTTSD aKode audioplugin +Comment[eu]=KTTSD-ren aKode audio-plugina +Comment[fa]=وصلۀ صوتی KTTSD aKode +Comment[fi]=KTTSD aKode ääniliitännäinen +Comment[fr]=Module audio aKode pour KTTSD +Comment[ga]=Breiseán fuaime KTTSD aKode +Comment[gl]=Plugin de áudio aKode para KTTSD +Comment[hu]=KTTSD aKode hangmodul +Comment[is]=KTTSD aKode hljóð íforrit +Comment[it]=Plugin audio per aKode di KTTSD +Comment[ja]=KTTSD aKode オーディオプラグイン +Comment[ka]=KTTSD aKode აუდიო მოდული +Comment[km]=កម្មវិធី​ជំនួយ​អូឌីយ៉ូ aKode សម្រាប់ KTTSD +Comment[mk]=aKode-аудиоприклучок за KTTSD +Comment[nb]=aKodes lyd-programtillegg for KTTSD +Comment[nds]=aKode-Audiomoduul för KTTSD +Comment[ne]=KTTSD aKode अडियो प्लगइन +Comment[nl]=KTTSD aKode geluidsplugin +Comment[pa]=KTTSD aKode ਆਡੀਓ ਪਲੱਗਿੰਨ +Comment[pl]=Wtyczka dźwięku aKode dla KTTSD +Comment[pt]='Plugin' de áudio aKode do KTTSD +Comment[pt_BR]=Plug-in de áudio KTTSD aKode +Comment[ru]=Модуль вывода звука KTTSD через aKode +Comment[sk]=Modul KTTSD aKode audio +Comment[sl]=Vstavek KTTSD za zvok v aKode +Comment[sr]=aKode аудио прикључак за KTTSD +Comment[sr@Latn]=aKode audio priključak za KTTSD +Comment[sv]=KTTSD-ljudinsticksprogram för aKode +Comment[tg]=Модули KTTSD aKode барои аудио +Comment[tr]=KTTSD aRts ses eklentisi +Comment[uk]=Втулок аудіо aKode для KTTSD +Comment[vi]=Trình bổ sung âm thanh KTTSD aKode +Comment[zh_TW]=KTTSd aKode 語音外掛程式 +Type=Service +ServiceTypes=KTTSD/AudioPlugin +X-KDE-Library=libkttsd_akodeplugin diff --git a/kttsd/players/alsaplayer/Makefile.am b/kttsd/players/alsaplayer/Makefile.am new file mode 100644 index 0000000..9653629 --- /dev/null +++ b/kttsd/players/alsaplayer/Makefile.am @@ -0,0 +1,30 @@ +# Include paths. +INCLUDES = \ + -I$(top_srcdir)/kttsd/libkttsd -I$(top_builddir)/kttsd/libkttsd \ + $(all_includes) +KDE_CXXFLAGS = -D_LARGEFILE64_SOURCE -D_GNU_SOURCE + +# Let automoc handle all of the metsource files (moc). +METASOURCES = AUTO + +######################################################################### +# LIBRARY SECTION +######################################################################### +# This is the library that gets installed. It's name is used for all +# of the other Makefile.am variables. +kde_module_LTLIBRARIES = libkttsd_alsaplugin.la + +libkttsd_alsaplugin_la_SOURCES = \ + alsaplugin.cpp \ + alsaplayer.cpp +libkttsd_alsaplugin_la_LDFLAGS = $(KDE_PLUGIN) $(all_libraries) $(LIBASOUND) -no-undefined +libkttsd_alsaplugin_la_LIBADD = $(top_builddir)/kttsd/libkttsd/libkttsd.la + +# Header files that should not be installed. +noinst_HEADERS = \ + alsaplayer.h \ + formats.h + +# This library is installed as a plugin. +services_DATA = kttsd_alsaplugin.desktop +servicesdir = $(kde_servicesdir) diff --git a/kttsd/players/alsaplayer/alsaplayer.cpp b/kttsd/players/alsaplayer/alsaplayer.cpp new file mode 100644 index 0000000..d3eabe8 --- /dev/null +++ b/kttsd/players/alsaplayer/alsaplayer.cpp @@ -0,0 +1,1729 @@ +/***************************************************** vim:set ts=4 sw=4 sts=4: + ALSA player. + ------------------- + Copyright: + (C) 2005 by Gary Cramblitt + Portions based on aplay.c in alsa-utils + Copyright (c) by Jaroslav Kysela + Based on vplay program by Michael Beck + ------------------- + Original author: Gary Cramblitt + + 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. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + ******************************************************************************/ + +// #include +// System includes. +#include +#if TIME_WITH_SYS_TIME +# include +# include +#else +# if HAVE_SYS_TIME_H +# include +# else +# include +# endif +#endif + +// Qt includes. +#include +#include +#include + +// KDE includes. +#include +#include +#include +#include +#include + +// AlsaPlayer includes. +#include "alsaplayer.h" + +#if !defined(__GNUC__) || __GNUC__ >= 3 +#define ERR(...) do {\ + QString dbgStr;\ + QString s = dbgStr.sprintf( "%s:%d: ERROR ", __FUNCTION__, __LINE__); \ + s += dbgStr.sprintf( __VA_ARGS__); \ + kdDebug() << timestamp() << "AlsaPlayer::" << s << endl; \ +} while (0) +#else +#define ERR(args...) do {\ + QString dbgStr;\ + QString s = dbgStr.sprintf( "%s:%d: ERROR ", __FUNCTION__, __LINE__); \ + s += dbgStr.sprintf( ##args ); \ + kdDebug() << timestamp() << "AlsaPlayer::" << s << endl; \ +} while (0) +#endif + +#if !defined(__GNUC__) || __GNUC__ >= 3 +#define MSG(...) do {\ + if (m_debugLevel >= 1) {\ + QString dbgStr; \ + QString s = dbgStr.sprintf( "%s:%d: ", __FUNCTION__, __LINE__); \ + s += dbgStr.sprintf( __VA_ARGS__); \ + kdDebug() << timestamp() << "AlsaPlayer::" << s << endl; \ + }; \ +} while (0) +#else +#define MSG(args...) do {\ + if (m_debugLevel >= 1) {\ + QString dbgStr; \ + QString s = dbgStr.sprintf( "%s:%d: ", __FUNCTION__, __LINE__); \ + s += dbgStr.sprintf( ##args ); \ + kdDebug() << timestamp() << "AlsaPlayer::" << s << endl; \ + }; \ +} while (0) +#endif + +#if !defined(__GNUC__) || __GNUC__ >= 3 +#define DBG(...) do {\ + if (m_debugLevel >= 2) {\ + QString dbgStr; \ + QString s = dbgStr.sprintf( "%s:%d: ", __FUNCTION__, __LINE__); \ + s += dbgStr.sprintf( __VA_ARGS__); \ + kdDebug() << timestamp() << "AlsaPlayer::" << s << endl; \ + }; \ +} while (0) +#else +#define DBG(args...) do {\ + if (m_debugLevel >= 2) {\ + QString dbgStr; \ + QString s = dbgStr.sprintf( "%s:%d: ", __FUNCTION__, __LINE__); \ + s += dbgStr.sprintf( ##args ); \ + kdDebug() << timestamp() << "AlsaPlayer::" << s << endl; \ + }; \ +} while (0) +#endif + +QString AlsaPlayer::timestamp() const +{ + time_t t; + struct timeval tv; + char *tstr; + t = time(NULL); + tstr = strdup(ctime(&t)); + tstr[strlen(tstr)-1] = 0; + gettimeofday(&tv,NULL); + QString ts; + ts.sprintf(" %s [%d] ",tstr, (int) tv.tv_usec); + free(tstr); + return ts; +} + +//////////////////////////////////////////////////////////////////////////////// +// public methods +//////////////////////////////////////////////////////////////////////////////// + +AlsaPlayer::AlsaPlayer(QObject* parent, const char* name, const QStringList& args) : + Player(parent, name, args), + m_currentVolume(1.0), + m_pcmName("default"), + m_defPeriodSize(128), + m_defPeriods(8), + m_debugLevel(1), + m_simulatedPause(false) +{ + init(); +} + +AlsaPlayer::~AlsaPlayer() +{ + if (running()) { + stop(); + wait(); + } +} + +//void AlsaPlayer::play(const FileHandle &file) +void AlsaPlayer::startPlay(const QString &file) +{ + if (running()) { + if (paused()) { + if (canPause) + snd_pcm_pause(handle, false); + else + m_simulatedPause = false; + } + return; + } + audiofile.setName(file); + audiofile.open(IO_ReadOnly); + fd = audiofile.handle(); + // Start thread running. + start(); +} + +/*virtual*/ void AlsaPlayer::run() +{ + QString pName = m_pcmName.section(" ", 0, 0); + DBG("pName = %s", pName.ascii()); + pcm_name = qstrdup(pName.ascii()); + int err; + snd_pcm_info_t *info; + + m_simulatedPause = false; + + snd_pcm_info_alloca(&info); + + err = snd_output_stdio_attach(&log, stderr, 0); + assert(err >= 0); + + rhwdata.format = DEFAULT_FORMAT; + rhwdata.rate = DEFAULT_SPEED; + rhwdata.channels = 1; + + err = snd_pcm_open(&handle, pcm_name, stream, open_mode); + if (err < 0) { + ERR("audio open error on pcm device %s: %s", pcm_name, snd_strerror(err)); + return; + } + + if ((err = snd_pcm_info(handle, info)) < 0) { + ERR("info error: %s", snd_strerror(err)); + return; + } + + chunk_size = 1024; + hwdata = rhwdata; + + audioBuffer.resize(1024); + // audiobuf = (char *)malloc(1024); + audiobuf = audioBuffer.data(); + if (audiobuf == NULL) { + ERR("not enough memory"); + return; + } + + if (mmap_flag) { + writei_func = snd_pcm_mmap_writei; + readi_func = snd_pcm_mmap_readi; + writen_func = snd_pcm_mmap_writen; + readn_func = snd_pcm_mmap_readn; + } else { + writei_func = snd_pcm_writei; + readi_func = snd_pcm_readi; + writen_func = snd_pcm_writen; + readn_func = snd_pcm_readn; + } + + playback(fd); + cleanup(); + return; +} + +void AlsaPlayer::pause() +{ + if (running()) { + DBG("Pause requested"); + m_mutex.lock(); + if (handle) { + // Some hardware can pause; some can't. canPause is set in set_params. + if (canPause) { + m_simulatedPause = false; + snd_pcm_pause(handle, true); + m_mutex.unlock(); + } else { + // Set a flag and cause wait_for_poll to sleep. When resumed, will get + // an underrun. + m_simulatedPause = true; + m_mutex.unlock(); + } + } + } +} + +void AlsaPlayer::stop() +{ + if (running()) { + DBG("STOP! Locking mutex"); + m_mutex.lock(); + m_simulatedPause = false; + if (handle) { + /* This constant is arbitrary */ + char buf = 42; + DBG("Request for stop, device state is %s", + snd_pcm_state_name(snd_pcm_state(handle))); + write(alsa_stop_pipe[1], &buf, 1); + } + DBG("unlocking mutex"); + m_mutex.unlock(); + /* Wait for thread to exit */ + DBG("waiting for thread to exit"); + wait(); + DBG("cleaning up"); + } + cleanup(); +} + +/* + * Stop playback, cleanup and exit thread. + */ +void AlsaPlayer::stopAndExit() +{ + // if (handle) snd_pcm_drop(handle); + cleanup(); + exit(); +} + +void AlsaPlayer::setVolume(float volume) +{ + m_currentVolume = volume; +} + +float AlsaPlayer::volume() const +{ + return m_currentVolume; +} + +///////////////////////////////////////////////////////////////////////////////// +// player status functions +///////////////////////////////////////////////////////////////////////////////// + +bool AlsaPlayer::playing() const +{ + bool result = false; + if (running()) { + m_mutex.lock(); + if (handle) { + if (canPause) { + snd_pcm_status_t *status; + snd_pcm_status_alloca(&status); + int res; + if ((res = snd_pcm_status(handle, status)) < 0) + ERR("status error: %s", snd_strerror(res)); + else { + result = (SND_PCM_STATE_RUNNING == snd_pcm_status_get_state(status)) + || (SND_PCM_STATE_DRAINING == snd_pcm_status_get_state(status)); + DBG("state = %s", snd_pcm_state_name(snd_pcm_status_get_state(status))); + } + } else + result = !m_simulatedPause; + } + m_mutex.unlock(); + } + return result; +} + +bool AlsaPlayer::paused() const +{ + bool result = false; + if (running()) { + m_mutex.lock(); + if (handle) { + if (canPause) { + snd_pcm_status_t *status; + snd_pcm_status_alloca(&status); + int res; + if ((res = snd_pcm_status(handle, status)) < 0) + ERR("status error: %s", snd_strerror(res)); + else { + result = (SND_PCM_STATE_PAUSED == snd_pcm_status_get_state(status)); + DBG("state = %s", snd_pcm_state_name(snd_pcm_status_get_state(status))); + } + } else + result = m_simulatedPause; + } + m_mutex.unlock(); + } + return result; +} + +int AlsaPlayer::totalTime() const +{ + int total = 0; + int rate = hwdata.rate; + int channels = hwdata.channels; + if (rate > 0 && channels > 0) { + total = int((double(pbrec_count) / rate) / channels); + // DBG("pbrec_count = %i rate =%i channels = %i", pbrec_count, rate, channels); + // DBG("totalTime = %i", total); + } + return total; +} + +int AlsaPlayer::currentTime() const +{ + int current = 0; + int rate = hwdata.rate; + int channels = hwdata.channels; + if (rate > 0 && channels > 0) { + current = int((double(fdcount) / rate) / channels); + // DBG("fdcount = %i rate = %i channels = %i", fdcount, rate, channels); + // DBG("currentTime = %i", current); + } + return current; +} + +int AlsaPlayer::position() const +{ + // TODO: Make this more accurate by adding frames that have been so-far + // played within the Alsa ring buffer. + return pbrec_count > 0 ? int(double(fdcount) * 1000 / pbrec_count + .5) : 0; +} + +///////////////////////////////////////////////////////////////////////////////// +// player seek functions +///////////////////////////////////////////////////////////////////////////////// + +void AlsaPlayer::seek(int /*seekTime*/) +{ + // TODO: +} + +void AlsaPlayer::seekPosition(int /*position*/) +{ + // TODO: +} + +/* + * Returns a list of PCM devices. + * This function fills the specified list with ALSA hardware soundcards found on the system. + * It uses plughw:xx instead of hw:xx for specifiers, because hw:xx are not practical to + * use (e.g. they require a resampler/channel mixer in the application). + */ +QStringList AlsaPlayer::getPluginList( const QCString& /*classname*/ ) +{ + int err = 0; + int card = -1, device = -1; + snd_ctl_t *handle; + snd_ctl_card_info_t *info; + snd_pcm_info_t *pcminfo; + snd_ctl_card_info_alloca(&info); + snd_pcm_info_alloca(&pcminfo); + QStringList result; + + result.append("default"); + for (;;) { + err = snd_card_next(&card); + if (err < 0 || card < 0) break; + if (card >= 0) { + char name[32]; + sprintf(name, "hw:%i", card); + if ((err = snd_ctl_open(&handle, name, 0)) < 0) continue; + if ((err = snd_ctl_card_info(handle, info)) < 0) { + snd_ctl_close(handle); + continue; + } + for (int devCnt=0;;++devCnt) { + err = snd_ctl_pcm_next_device(handle, &device); + if (err < 0 || device < 0) break; + + snd_pcm_info_set_device(pcminfo, device); + snd_pcm_info_set_subdevice(pcminfo, 0); + snd_pcm_info_set_stream(pcminfo, SND_PCM_STREAM_PLAYBACK); + if ((err = snd_ctl_pcm_info(handle, pcminfo)) < 0) continue; + QString infoName = " "; + infoName += snd_ctl_card_info_get_name(info); + infoName += " ("; + infoName += snd_pcm_info_get_name(pcminfo); + infoName += ")"; + if (0 == devCnt) { + QString pcmName = QString("default:%1").arg(card); + result.append(pcmName + infoName); + } + QString pcmName = QString("plughw:%1,%2").arg(card).arg(device); + result.append(pcmName + infoName); + } + snd_ctl_close(handle); + } + } + return result; +} + +// QStringList AlsaPlayer::getPluginList( const QCString& /*classname*/ ) +// { +// QStringList assumed("default"); +// snd_config_t *conf; +// int err = snd_config_update(); +// if (err < 0) { +// ERR("snd_config_update: %s", snd_strerror(err)); +// return assumed; +// } +// err = snd_config_search(snd_config, "pcm", &conf); +// if (err < 0) return QStringList(); +// snd_config_iterator_t it = snd_config_iterator_first(conf); +// snd_config_iterator_t itEnd = snd_config_iterator_end(conf); +// const char* id; +// snd_config_t *entry; +// QStringList result; +// snd_ctl_card_info_t *info; +// snd_ctl_card_info_alloca(&info); +// snd_pcm_info_t *pcminfo; +// snd_pcm_info_alloca(&pcminfo); +// while (it != itEnd) { +// entry = snd_config_iterator_entry(it); +// err = snd_config_get_id(entry, &id); +// if (err >= 0) { +// if (QString(id) != "default") +// { +// int card = -1; +// while (snd_card_next(&card) >= 0 && card >= 0) { +// char name[32]; +// sprintf(name, "%s:%d", id, card); +// DBG("Checking %s", name); +// snd_ctl_t *handle; +// if ((err = snd_ctl_open(&handle, name, SND_CTL_NONBLOCK)) >= 0) { +// if ((err = snd_ctl_card_info(handle, info)) >= 0) { +// int dev = -1; +// snd_pcm_stream_t stream = SND_PCM_STREAM_PLAYBACK; +// while (snd_ctl_pcm_next_device(handle, &dev) >= 0 && dev >= 0) { +// snd_pcm_info_set_device(pcminfo, dev); +// snd_pcm_info_set_subdevice(pcminfo, 0); +// snd_pcm_info_set_stream(pcminfo, stream); +// if ((err = snd_ctl_pcm_info(handle, pcminfo)) >= 0) { +// QString pluginName = name; +// pluginName += ","; +// pluginName += QString::number(dev); +// pluginName += " "; +// pluginName += snd_ctl_card_info_get_name(info); +// pluginName += ","; +// pluginName += snd_pcm_info_get_name(pcminfo); +// result.append(pluginName); +// // DBG(pluginName); +// } +// } +// } +// snd_ctl_close(handle); +// } +// } +// if (card == -1) result.append(id); +// } else result.append(id); +// } +// it = snd_config_iterator_next(it); +// } +// snd_config_update_free_global(); +// return result; +// } + +void AlsaPlayer::setSinkName(const QString& sinkName) { m_pcmName = sinkName; } + +///////////////////////////////////////////////////////////////////////////////// +// private +///////////////////////////////////////////////////////////////////////////////// + +void AlsaPlayer::init() +{ + pcm_name = 0; + handle = 0; + canPause = false; + timelimit = 0; + file_type = FORMAT_DEFAULT; + sleep_min = 0; + // open_mode = 0; + open_mode = SND_PCM_NONBLOCK; + stream = SND_PCM_STREAM_PLAYBACK; + mmap_flag = 0; + interleaved = 1; + audiobuf = NULL; + chunk_size = 0; + period_time = 0; + buffer_time = 0; + avail_min = -1; + start_delay = 0; + stop_delay = 0; + buffer_pos = 0; + log = 0; + fd = -1; + pbrec_count = LLONG_MAX; + alsa_stop_pipe[0] = 0; + alsa_stop_pipe[1] = 0; + alsa_poll_fds = 0; + m_simulatedPause = false; +} + +void AlsaPlayer::cleanup() +{ + DBG("cleaning up"); + m_mutex.lock(); + if (pcm_name) free(pcm_name); + if (fd >= 0) audiofile.close(); + if (handle) { + snd_pcm_drop(handle); + snd_pcm_close(handle); + } + if (alsa_stop_pipe[0]) close(alsa_stop_pipe[0]); + if (alsa_stop_pipe[1]) close(alsa_stop_pipe[1]); + if (audiobuf) audioBuffer.resize(0); + if (alsa_poll_fds) alsa_poll_fds_barray.resize(0); + if (log) snd_output_close(log); + snd_config_update_free_global(); + init(); + m_mutex.unlock(); +} + +/* + * Safe read (for pipes) + */ + +ssize_t AlsaPlayer::safe_read(int fd, void *buf, size_t count) +{ + ssize_t result = 0; + ssize_t res; + + while (count > 0) { + if ((res = read(fd, buf, count)) == 0) + break; + if (res < 0) + return result > 0 ? result : res; + count -= res; + result += res; + buf = (char *)buf + res; + } + return result; +} + +/* + * Test, if it is a .VOC file and return >=0 if ok (this is the length of rest) + * < 0 if not + */ +int AlsaPlayer::test_vocfile(void *buffer) +{ + VocHeader *vp = (VocHeader*)buffer; + + if (!memcmp(vp->magic, VOC_MAGIC_STRING, 20)) { + vocminor = LE_SHORT(vp->version) & 0xFF; + vocmajor = LE_SHORT(vp->version) / 256; + if (LE_SHORT(vp->version) != (0x1233 - LE_SHORT(vp->coded_ver))) + return -2; /* coded version mismatch */ + return LE_SHORT(vp->headerlen) - sizeof(VocHeader); /* 0 mostly */ + } + return -1; /* magic string fail */ +} + +/* + * helper for test_wavefile + */ + +size_t AlsaPlayer::test_wavefile_read(int fd, char *buffer, size_t *size, size_t reqsize, int line) +{ + if (*size >= reqsize) + return *size; + if ((size_t)safe_read(fd, buffer + *size, reqsize - *size) != reqsize - *size) { + ERR("read error (called from line %i)", line); + stopAndExit(); + } + return *size = reqsize; +} + +#define check_wavefile_space(buffer, len, blimit) \ + if (len > blimit) { \ + blimit = len; \ + if ((buffer = (char*)realloc(buffer, blimit)) == NULL) { \ + ERR("not enough memory"); \ + stopAndExit(); \ + } \ + } + +/* + * test, if it's a .WAV file, > 0 if ok (and set the speed, stereo etc.) + * == 0 if not + * Value returned is bytes to be discarded. + */ +ssize_t AlsaPlayer::test_wavefile(int fd, char *_buffer, size_t size) +{ + WaveHeader *h = (WaveHeader *)_buffer; + char *buffer = NULL; + size_t blimit = 0; + WaveFmtBody *f; + WaveChunkHeader *c; + u_int type; + u_int len; + + if (size < sizeof(WaveHeader)) + return -1; + if (h->magic != WAV_RIFF || h->type != WAV_WAVE) + return -1; + if (size > sizeof(WaveHeader)) { + check_wavefile_space(buffer, size - sizeof(WaveHeader), blimit); + memcpy(buffer, _buffer + sizeof(WaveHeader), size - sizeof(WaveHeader)); + } + size -= sizeof(WaveHeader); + while (1) { + check_wavefile_space(buffer, sizeof(WaveChunkHeader), blimit); + test_wavefile_read(fd, buffer, &size, sizeof(WaveChunkHeader), __LINE__); + c = (WaveChunkHeader*)buffer; + type = c->type; + len = LE_INT(c->length); + len += len % 2; + if (size > sizeof(WaveChunkHeader)) + memmove(buffer, buffer + sizeof(WaveChunkHeader), size - sizeof(WaveChunkHeader)); + size -= sizeof(WaveChunkHeader); + if (type == WAV_FMT) + break; + check_wavefile_space(buffer, len, blimit); + test_wavefile_read(fd, buffer, &size, len, __LINE__); + if (size > len) + memmove(buffer, buffer + len, size - len); + size -= len; + } + + if (len < sizeof(WaveFmtBody)) { + ERR("unknown length of 'fmt ' chunk (read %u, should be %u at least)", len, (u_int)sizeof(WaveFmtBody)); + stopAndExit(); + } + check_wavefile_space(buffer, len, blimit); + test_wavefile_read(fd, buffer, &size, len, __LINE__); + f = (WaveFmtBody*) buffer; + if (LE_SHORT(f->format) != WAV_PCM_CODE) { + ERR("can't play not PCM-coded WAVE-files"); + stopAndExit(); + } + if (LE_SHORT(f->modus) < 1) { + ERR("can't play WAVE-files with %d tracks", LE_SHORT(f->modus)); + stopAndExit(); + } + hwdata.channels = LE_SHORT(f->modus); + switch (LE_SHORT(f->bit_p_spl)) { + case 8: + if (hwdata.format != DEFAULT_FORMAT && + hwdata.format != SND_PCM_FORMAT_U8) + MSG("Warning: format is changed to U8"); + hwdata.format = SND_PCM_FORMAT_U8; + break; + case 16: + if (hwdata.format != DEFAULT_FORMAT && + hwdata.format != SND_PCM_FORMAT_S16_LE) + MSG("Warning: format is changed to S16_LE"); + hwdata.format = SND_PCM_FORMAT_S16_LE; + break; + case 24: + switch (LE_SHORT(f->byte_p_spl) / hwdata.channels) { + case 3: + if (hwdata.format != DEFAULT_FORMAT && + hwdata.format != SND_PCM_FORMAT_S24_3LE) + MSG("Warning: format is changed to S24_3LE"); + hwdata.format = SND_PCM_FORMAT_S24_3LE; + break; + case 4: + if (hwdata.format != DEFAULT_FORMAT && + hwdata.format != SND_PCM_FORMAT_S24_LE) + MSG("Warning: format is changed to S24_LE"); + hwdata.format = SND_PCM_FORMAT_S24_LE; + break; + default: + ERR("can't play WAVE-files with sample %d bits in %d bytes wide (%d channels)", LE_SHORT(f->bit_p_spl), LE_SHORT(f->byte_p_spl), hwdata.channels); + stopAndExit(); + } + break; + case 32: + hwdata.format = SND_PCM_FORMAT_S32_LE; + break; + default: + ERR("can't play WAVE-files with sample %d bits wide", LE_SHORT(f->bit_p_spl)); + stopAndExit(); + } + hwdata.rate = LE_INT(f->sample_fq); + + if (size > len) + memmove(buffer, buffer + len, size - len); + size -= len; + + while (1) { + u_int type, len; + + check_wavefile_space(buffer, sizeof(WaveChunkHeader), blimit); + test_wavefile_read(fd, buffer, &size, sizeof(WaveChunkHeader), __LINE__); + c = (WaveChunkHeader*)buffer; + type = c->type; + len = LE_INT(c->length); + if (size > sizeof(WaveChunkHeader)) + memmove(buffer, buffer + sizeof(WaveChunkHeader), size - sizeof(WaveChunkHeader)); + size -= sizeof(WaveChunkHeader); + if (type == WAV_DATA) { + if (len < pbrec_count && len < 0x7ffffffe) + pbrec_count = len; + if (size > 0) + memcpy(_buffer, buffer, size); + free(buffer); + return size; + } + len += len % 2; + check_wavefile_space(buffer, len, blimit); + test_wavefile_read(fd, buffer, &size, len, __LINE__); + if (size > len) + memmove(buffer, buffer + len, size - len); + size -= len; + } + + /* shouldn't be reached */ + return -1; +} + +/* + * Test for AU file. + */ + +int AlsaPlayer::test_au(int fd, char *buffer) +{ + AuHeader *ap = (AuHeader*)buffer; + + if (ap->magic != AU_MAGIC) + return -1; + if (BE_INT(ap->hdr_size) > 128 || BE_INT(ap->hdr_size) < 24) + return -1; + pbrec_count = BE_INT(ap->data_size); + switch (BE_INT(ap->encoding)) { + case AU_FMT_ULAW: + if (hwdata.format != DEFAULT_FORMAT && + hwdata.format != SND_PCM_FORMAT_MU_LAW) + MSG("Warning: format is changed to MU_LAW"); + hwdata.format = SND_PCM_FORMAT_MU_LAW; + break; + case AU_FMT_LIN8: + if (hwdata.format != DEFAULT_FORMAT && + hwdata.format != SND_PCM_FORMAT_U8) + MSG("Warning: format is changed to U8"); + hwdata.format = SND_PCM_FORMAT_U8; + break; + case AU_FMT_LIN16: + if (hwdata.format != DEFAULT_FORMAT && + hwdata.format != SND_PCM_FORMAT_S16_BE) + MSG("Warning: format is changed to S16_BE"); + hwdata.format = SND_PCM_FORMAT_S16_BE; + break; + default: + return -1; + } + hwdata.rate = BE_INT(ap->sample_rate); + if (hwdata.rate < 2000 || hwdata.rate > 256000) + return -1; + hwdata.channels = BE_INT(ap->channels); + if (hwdata.channels < 1 || hwdata.channels > 128) + return -1; + if ((size_t)safe_read(fd, buffer + sizeof(AuHeader), BE_INT(ap->hdr_size) - sizeof(AuHeader)) != BE_INT(ap->hdr_size) - sizeof(AuHeader)) { + ERR("read error"); + stopAndExit(); + } + return 0; +} + +void AlsaPlayer::set_params(void) +{ + snd_pcm_hw_params_t *hwparams; + snd_pcm_uframes_t period_size; + int err; + int dir; + unsigned int rate; + unsigned int periods; + + snd_pcm_hw_params_alloca(&hwparams); + err = snd_pcm_hw_params_any(handle, hwparams); + if (err < 0) { + ERR("Broken configuration for this PCM: no configurations available"); + stopAndExit(); + } + + /* Create the pipe for communication about stop requests. */ + if (pipe(alsa_stop_pipe)) { + ERR("Stop pipe creation failed (%s)", strerror(errno)); + stopAndExit(); + } + + /* Find how many descriptors we will get for poll(). */ + alsa_fd_count = snd_pcm_poll_descriptors_count(handle); + if (alsa_fd_count <= 0){ + ERR("Invalid poll descriptors count returned from ALSA."); + stopAndExit(); + } + + /* Create and fill in struct pollfd *alsa_poll_fds with ALSA descriptors. */ + // alsa_poll_fds = (pollfd *)malloc ((alsa_fd_count + 1) * sizeof(struct pollfd)); + alsa_poll_fds_barray.resize((alsa_fd_count + 1) * sizeof(struct pollfd)); + alsa_poll_fds = (pollfd *)alsa_poll_fds_barray.data(); + assert(alsa_poll_fds); + if ((err = snd_pcm_poll_descriptors(handle, alsa_poll_fds, alsa_fd_count)) < 0) { + ERR("Unable to obtain poll descriptors for playback: %s", snd_strerror(err)); + stopAndExit(); + } + + /* Create a new pollfd structure for requests by alsa_stop(). */ + struct pollfd alsa_stop_pipe_pfd; + alsa_stop_pipe_pfd.fd = alsa_stop_pipe[0]; + alsa_stop_pipe_pfd.events = POLLIN; + alsa_stop_pipe_pfd.revents = 0; + + /* Join this our own pollfd to the ALSAs ones. */ + alsa_poll_fds[alsa_fd_count] = alsa_stop_pipe_pfd; + ++alsa_fd_count; + + if (mmap_flag) { + snd_pcm_access_mask_t *mask = (snd_pcm_access_mask_t *)alloca(snd_pcm_access_mask_sizeof()); + snd_pcm_access_mask_none(mask); + snd_pcm_access_mask_set(mask, SND_PCM_ACCESS_MMAP_INTERLEAVED); + snd_pcm_access_mask_set(mask, SND_PCM_ACCESS_MMAP_NONINTERLEAVED); + snd_pcm_access_mask_set(mask, SND_PCM_ACCESS_MMAP_COMPLEX); + err = snd_pcm_hw_params_set_access_mask(handle, hwparams, mask); + } else if (interleaved) + err = snd_pcm_hw_params_set_access(handle, hwparams, + SND_PCM_ACCESS_RW_INTERLEAVED); + else + err = snd_pcm_hw_params_set_access(handle, hwparams, + SND_PCM_ACCESS_RW_NONINTERLEAVED); + if (err < 0) { + ERR("Error setting access type: %s", snd_strerror(err)); + stopAndExit(); + } + err = snd_pcm_hw_params_set_format(handle, hwparams, hwdata.format); + if (err < 0) { + ERR("Error setting sample format to %i: %s", hwdata.format, snd_strerror(err)); + stopAndExit(); + } + err = snd_pcm_hw_params_set_channels(handle, hwparams, hwdata.channels); + if (err < 0) { + ERR("Error setting channel count to %i: %s", hwdata.channels, snd_strerror(err)); + stopAndExit(); + } + +#if 0 + err = snd_pcm_hw_params_set_periods_min(handle, hwparams, 2); + assert(err >= 0); +#endif + rate = hwdata.rate; +#if SND_LIB_MAJOR >= 1 + err = snd_pcm_hw_params_set_rate_near(handle, hwparams, &hwdata.rate, 0); +#else + err = snd_pcm_hw_params_set_rate_near(handle, hwparams, hwdata.rate, 0); +#endif + assert(err >= 0); + if ((float)rate * 1.05 < hwdata.rate || (float)rate * 0.95 > hwdata.rate) { + MSG("Warning: rate is not accurate (requested = %iHz, got = %iHz)", rate, hwdata.rate); + MSG(" please, try the plug plugin (-Dplug:%s)", snd_pcm_name(handle)); + } + + period_size = m_defPeriodSize; + dir = 1; +#if SND_LIB_MAJOR >= 1 + err = snd_pcm_hw_params_set_period_size_near(handle, hwparams, &period_size, &dir); +#else + err = snd_pcm_hw_params_set_period_size_near(handle, hwparams, period_size, &dir); +#endif + if (err < 0) { + MSG("Setting period_size to %lu failed, but continuing: %s", period_size, snd_strerror(err)); + } + + periods = m_defPeriods; + dir = 1; +#if SND_LIB_MAJOR >= 1 + err = snd_pcm_hw_params_set_periods_near(handle, hwparams, &periods, &dir); +#else + err = snd_pcm_hw_params_set_periods_near(handle, hwparams, periods, &dir); +#endif + if (err < 0) + MSG("Unable to set number of periods to %i, but continuing: %s", periods, snd_strerror(err)); + + /* Install hw parameters. */ + err = snd_pcm_hw_params(handle, hwparams); + if (err < 0) { + MSG("Unable to install hw params: %s", snd_strerror(err)); + snd_pcm_hw_params_dump(hwparams, log); + stopAndExit(); + } + + /* Determine if device can pause. */ + canPause = (1 == snd_pcm_hw_params_can_pause(hwparams)); + + /* Get final buffer size and calculate the chunk size we will pass to device. */ +#if SND_LIB_MAJOR >= 1 + snd_pcm_hw_params_get_buffer_size(hwparams, &buffer_size); +#else + buffer_size = snd_pcm_hw_params_get_buffer_size(hwparams); +#endif + chunk_size = periods * period_size; + + if (0 == chunk_size) { + ERR("Invalid periods or period_size. Cannot continue."); + stopAndExit(); + } + + if (chunk_size == buffer_size) + MSG("WARNING: Shouldn't use chunk_size equal to buffer_size (%lu). Continuing anyway.", chunk_size); + + DBG("Final buffer_size = %lu, chunk_size = %lu, periods = %i, period_size = %lu, canPause = %i", + buffer_size, chunk_size, periods, period_size, canPause); + + if (m_debugLevel >= 2) + snd_pcm_dump(handle, log); + + bits_per_sample = snd_pcm_format_physical_width(hwdata.format); + bits_per_frame = bits_per_sample * hwdata.channels; + chunk_bytes = chunk_size * bits_per_frame / 8; + audioBuffer.resize(chunk_bytes); + audiobuf = audioBuffer.data(); + if (audiobuf == NULL) { + ERR("not enough memory"); + stopAndExit(); + } +} + +#ifndef timersub +#define timersub(a, b, result) \ +do { \ + (result)->tv_sec = (a)->tv_sec - (b)->tv_sec; \ + (result)->tv_usec = (a)->tv_usec - (b)->tv_usec; \ + if ((result)->tv_usec < 0) { \ + --(result)->tv_sec; \ + (result)->tv_usec += 1000000; \ + } \ +} while (0) +#endif + +/* I/O error handler */ +void AlsaPlayer::xrun() +{ + snd_pcm_status_t *status; + int res; + + snd_pcm_status_alloca(&status); + if ((res = snd_pcm_status(handle, status))<0) { + ERR("status error: %s", snd_strerror(res)); + stopAndExit(); + } + if (SND_PCM_STATE_XRUN == snd_pcm_status_get_state(status)) { + struct timeval now, diff, tstamp; + gettimeofday(&now, 0); + snd_pcm_status_get_trigger_tstamp(status, &tstamp); + timersub(&now, &tstamp, &diff); + MSG("%s!!! (at least %.3f ms long)", + stream == SND_PCM_STREAM_PLAYBACK ? "underrun" : "overrun", + diff.tv_sec * 1000 + diff.tv_usec / 1000.0); + if (m_debugLevel >= 2) { + DBG("Status:"); + snd_pcm_status_dump(status, log); + } + if ((res = snd_pcm_prepare(handle))<0) { + ERR("xrun: prepare error: %s", snd_strerror(res)); + stopAndExit(); + } + return; /* ok, data should be accepted again */ + } if (SND_PCM_STATE_DRAINING == snd_pcm_status_get_state(status)) { + if (m_debugLevel >= 2) { + DBG("Status(DRAINING):"); + snd_pcm_status_dump(status, log); + } + if (stream == SND_PCM_STREAM_CAPTURE) { + MSG("capture stream format change? attempting recover..."); + if ((res = snd_pcm_prepare(handle))<0) { + ERR("xrun(DRAINING): prepare error: %s", snd_strerror(res)); + stopAndExit(); + } + return; + } + } + if (m_debugLevel >= 2) { + DBG("Status(R/W):"); + snd_pcm_status_dump(status, log); + } + ERR("read/write error, state = %s", snd_pcm_state_name(snd_pcm_status_get_state(status))); + stopAndExit(); +} + +/* I/O suspend handler */ +void AlsaPlayer::suspend(void) +{ + int res; + + MSG("Suspended. Trying resume. "); + while ((res = snd_pcm_resume(handle)) == -EAGAIN) + sleep(1); /* wait until suspend flag is released */ + if (res < 0) { + MSG("Failed. Restarting stream. "); + if ((res = snd_pcm_prepare(handle)) < 0) { + ERR("suspend: prepare error: %s", snd_strerror(res)); + stopAndExit(); + } + } + MSG("Suspend done."); +} + +/* peak handler */ +void AlsaPlayer::compute_max_peak(char *data, size_t count) +{ + signed int val, max, max_peak = 0, perc; + size_t ocount = count; + + switch (bits_per_sample) { + case 8: { + signed char *valp = (signed char *)data; + signed char mask = snd_pcm_format_silence(hwdata.format); + while (count-- > 0) { + val = *valp++ ^ mask; + val = abs(val); + if (max_peak < val) + max_peak = val; + } + break; + } + case 16: { + signed short *valp = (signed short *)data; + signed short mask = snd_pcm_format_silence_16(hwdata.format); + count /= 2; + while (count-- > 0) { + val = *valp++ ^ mask; + val = abs(val); + if (max_peak < val) + max_peak = val; + } + break; + } + case 32: { + signed int *valp = (signed int *)data; + signed int mask = snd_pcm_format_silence_32(hwdata.format); + count /= 4; + while (count-- > 0) { + val = *valp++ ^ mask; + val = abs(val); + if (max_peak < val) + max_peak = val; + } + break; + } + default: + break; + } + max = 1 << (bits_per_sample-1); + if (max <= 0) + max = 0x7fffffff; + DBG("Max peak (%li samples): %05i (0x%04x) ", (long)ocount, max_peak, max_peak); + if (bits_per_sample > 16) + perc = max_peak / (max / 100); + else + perc = max_peak * 100 / max; + for (val = 0; val < 20; val++) + if (val <= perc / 5) + kdDebug() << '#'; + else + kdDebug() << ' '; + DBG(" %i%%", perc); +} + +/* + * Write to the ALSA pcm. + */ + +ssize_t AlsaPlayer::pcm_write(char *data, size_t count) +{ + ssize_t r; + ssize_t result = 0; + + if (sleep_min == 0 && count < chunk_size) { + DBG("calling snd_pcm_format_set_silence"); + snd_pcm_format_set_silence(hwdata.format, data + count * bits_per_frame / 8, (chunk_size - count) * hwdata.channels); + count = chunk_size; + } + while (count > 0) { + DBG("calling writei_func, count = %i", count); + r = writei_func(handle, data, count); + DBG("writei_func returned %i", r); + if (-EAGAIN == r || (r >= 0 && (size_t)r < count)) { + DBG("r = %i calling snd_pcm_wait", r); + snd_pcm_wait(handle, 100); + } else if (-EPIPE == r) { + xrun(); + } else if (-ESTRPIPE == r) { + suspend(); + } else if (-EBUSY == r){ + MSG("WARNING: sleeping while PCM BUSY"); + usleep(1000); + continue; + } else if (r < 0) { + ERR("write error: %s", snd_strerror(r)); + stopAndExit(); + } + if (r > 0) { + if (m_debugLevel >= 1) + compute_max_peak(data, r * hwdata.channels); + result += r; + count -= r; + data += r * bits_per_frame / 8; + } + /* Report current state */ + DBG("PCM state before polling: %s", + snd_pcm_state_name(snd_pcm_state(handle))); + + int err = wait_for_poll(0); + if (err < 0) { + ERR("Wait for poll() failed"); + return -1; + } + else if (err == 1){ + MSG("Playback stopped"); + /* Drop the playback on the sound device (probably + still in progress up till now) */ + err = snd_pcm_drop(handle); + if (err < 0) { + ERR("snd_pcm_drop() failed: %s", snd_strerror(err)); + return -1; + } + return -1; + } + } + return result; +} + +/* + * ok, let's play a .voc file + */ + +ssize_t AlsaPlayer::voc_pcm_write(u_char *data, size_t count) +{ + ssize_t result = count, r; + size_t size; + + while (count > 0) { + size = count; + if (size > chunk_bytes - buffer_pos) + size = chunk_bytes - buffer_pos; + memcpy(audiobuf + buffer_pos, data, size); + data += size; + count -= size; + buffer_pos += size; + if ((size_t)buffer_pos == chunk_bytes) { + if ((size_t)(r = pcm_write(audiobuf, chunk_size)) != chunk_size) + return r; + buffer_pos = 0; + } + } + return result; +} + +void AlsaPlayer::voc_write_silence(unsigned x) +{ + unsigned l; + char *buf; + + QByteArray buffer(chunk_bytes); + // buf = (char *) malloc(chunk_bytes); + buf = buffer.data(); + if (buf == NULL) { + ERR("can't allocate buffer for silence"); + return; /* not fatal error */ + } + snd_pcm_format_set_silence(hwdata.format, buf, chunk_size * hwdata.channels); + while (x > 0) { + l = x; + if (l > chunk_size) + l = chunk_size; + if (voc_pcm_write((u_char*)buf, l) != (ssize_t)l) { + ERR("write error"); + stopAndExit(); + } + x -= l; + } + // free(buf); +} + +void AlsaPlayer::voc_pcm_flush(void) +{ + if (buffer_pos > 0) { + size_t b; + if (sleep_min == 0) { + if (snd_pcm_format_set_silence(hwdata.format, audiobuf + buffer_pos, chunk_bytes - buffer_pos * 8 / bits_per_sample) < 0) + MSG("voc_pcm_flush - silence error"); + b = chunk_size; + } else { + b = buffer_pos * 8 / bits_per_frame; + } + if (pcm_write(audiobuf, b) != (ssize_t)b) + ERR("voc_pcm_flush error"); + } + snd_pcm_drain(handle); +} + +void AlsaPlayer::voc_play(int fd, int ofs, const char* name) +{ + int l; + VocBlockType *bp; + VocVoiceData *vd; + VocExtBlock *eb; + size_t nextblock, in_buffer; + u_char *data, *buf; + char was_extended = 0, output = 0; + u_short *sp, repeat = 0; + size_t silence; + off64_t filepos = 0; + +#define COUNT(x) nextblock -= x; in_buffer -= x; data += x +#define COUNT1(x) in_buffer -= x; data += x + + QByteArray buffer(64 * 1024); + // data = buf = (u_char *)malloc(64 * 1024); + data = buf = (u_char*)buffer.data(); + buffer_pos = 0; + if (data == NULL) { + ERR("malloc error"); + stopAndExit(); + } + MSG("Playing Creative Labs Channel file '%s'...", name); + /* first we waste the rest of header, ugly but we don't need seek */ + while (ofs > (ssize_t)chunk_bytes) { + if ((size_t)safe_read(fd, buf, chunk_bytes) != chunk_bytes) { + ERR("read error"); + stopAndExit(); + } + ofs -= chunk_bytes; + } + if (ofs) { + if (safe_read(fd, buf, ofs) != ofs) { + ERR("read error"); + stopAndExit(); + } + } + hwdata.format = DEFAULT_FORMAT; + hwdata.channels = 1; + hwdata.rate = DEFAULT_SPEED; + set_params(); + + in_buffer = nextblock = 0; + while (1) { + Fill_the_buffer: /* need this for repeat */ + if (in_buffer < 32) { + /* move the rest of buffer to pos 0 and fill the buf up */ + if (in_buffer) + memcpy(buf, data, in_buffer); + data = buf; + if ((l = safe_read(fd, buf + in_buffer, chunk_bytes - in_buffer)) > 0) + in_buffer += l; + else if (!in_buffer) { + /* the file is truncated, so simulate 'Terminator' + and reduce the datablock for safe landing */ + nextblock = buf[0] = 0; + if (l == -1) { +// perror(name); + stopAndExit(); + } + } + } + while (!nextblock) { /* this is a new block */ + if (in_buffer < sizeof(VocBlockType)) + goto __end; + bp = (VocBlockType *) data; + COUNT1(sizeof(VocBlockType)); + nextblock = VOC_DATALEN(bp); + if (output) + MSG(" "); /* write /n after ASCII-out */ + output = 0; + switch (bp->type) { + case 0: +#if 0 + MSG("Terminator"); +#endif + return; /* VOC-file stop */ + case 1: + vd = (VocVoiceData *) data; + COUNT1(sizeof(VocVoiceData)); + /* we need a SYNC, before we can set new SPEED, STEREO ... */ + + if (!was_extended) { + hwdata.rate = (int) (vd->tc); + hwdata.rate = 1000000 / (256 - hwdata.rate); +#if 0 + MSG("Channel data %d Hz", dsp_speed); +#endif + if (vd->pack) { /* /dev/dsp can't it */ + ERR("can't play packed .voc files"); + return; + } + if (hwdata.channels == 2) /* if we are in Stereo-Mode, switch back */ + hwdata.channels = 1; + } else { /* there was extended block */ + hwdata.channels = 2; + was_extended = 0; + } + set_params(); + break; + case 2: /* nothing to do, pure data */ +#if 0 + MSG("Channel continuation"); +#endif + break; + case 3: /* a silence block, no data, only a count */ + sp = (u_short *) data; + COUNT1(sizeof(u_short)); + hwdata.rate = (int) (*data); + COUNT1(1); + hwdata.rate = 1000000 / (256 - hwdata.rate); + set_params(); + silence = (((size_t) * sp) * 1000) / hwdata.rate; +#if 0 + MSG("Silence for %d ms", (int) silence); +#endif + voc_write_silence(*sp); + break; + case 4: /* a marker for syncronisation, no effect */ + sp = (u_short *) data; + COUNT1(sizeof(u_short)); +#if 0 + MSG("Marker %d", *sp); +#endif + break; + case 5: /* ASCII text, we copy to stderr */ + output = 1; +#if 0 + MSG("ASCII - text :"); +#endif + break; + case 6: /* repeat marker, says repeatcount */ + /* my specs don't say it: maybe this can be recursive, but + I don't think somebody use it */ + repeat = *(u_short *) data; + COUNT1(sizeof(u_short)); +#if 0 + MSG("Repeat loop %d times", repeat); +#endif + if (filepos >= 0) { /* if < 0, one seek fails, why test another */ + if ((filepos = lseek64(fd, 0, 1)) < 0) { + ERR("can't play loops; %s isn't seekable", name); + repeat = 0; + } else { + filepos -= in_buffer; /* set filepos after repeat */ + } + } else { + repeat = 0; + } + break; + case 7: /* ok, lets repeat that be rewinding tape */ + if (repeat) { + if (repeat != 0xFFFF) { +#if 0 + MSG("Repeat loop %d", repeat); +#endif + --repeat; + } +#if 0 + else + MSG("Neverending loop"); +#endif + lseek64(fd, filepos, 0); + in_buffer = 0; /* clear the buffer */ + goto Fill_the_buffer; + } +#if 0 + else + MSG("End repeat loop"); +#endif + break; + case 8: /* the extension to play Stereo, I have SB 1.0 :-( */ + was_extended = 1; + eb = (VocExtBlock *) data; + COUNT1(sizeof(VocExtBlock)); + hwdata.rate = (int) (eb->tc); + hwdata.rate = 256000000L / (65536 - hwdata.rate); + hwdata.channels = eb->mode == VOC_MODE_STEREO ? 2 : 1; + if (hwdata.channels == 2) + hwdata.rate = hwdata.rate >> 1; + if (eb->pack) { /* /dev/dsp can't it */ + ERR("can't play packed .voc files"); + return; + } +#if 0 + MSG("Extended block %s %d Hz", + (eb->mode ? "Stereo" : "Mono"), dsp_speed); +#endif + break; + default: + ERR("unknown blocktype %d. terminate.", bp->type); + return; + } /* switch (bp->type) */ + } /* while (! nextblock) */ + /* put nextblock data bytes to dsp */ + l = in_buffer; + if (nextblock < (size_t)l) + l = nextblock; + if (l) { + if (output) { + if (write(2, data, l) != l) { /* to stderr */ + ERR("write error"); + stopAndExit(); + } + } else { + if (voc_pcm_write(data, l) != l) { + ERR("write error"); + stopAndExit(); + } + } + COUNT(l); + } + } /* while(1) */ + __end: + voc_pcm_flush(); + // free(buf); +} +/* that was a big one, perhaps somebody split it :-) */ + +/* setting the globals for playing raw data */ +void AlsaPlayer::init_raw_data(void) +{ + hwdata = rhwdata; +} + +/* calculate the data count to read from/to dsp */ +off64_t AlsaPlayer::calc_count(void) +{ + off64_t count; + + if (timelimit == 0) { + count = pbrec_count; + } else { + count = snd_pcm_format_size(hwdata.format, hwdata.rate * hwdata.channels); + count *= (off64_t)timelimit; + } + return count < pbrec_count ? count : pbrec_count; +} + +void AlsaPlayer::header(int /*rtype*/, const char* /*name*/) +{ +// fprintf(stderr, "%s %s '%s' : ", +// (stream == SND_PCM_STREAM_PLAYBACK) ? "Playing" : "Recording", +// fmt_rec_table[rtype].what, +// name); + QString channels; + if (hwdata.channels == 1) + channels = "Mono"; + else if (hwdata.channels == 2) + channels = "Stereo"; + else + channels = QString("Channels %1").arg(hwdata.channels); + DBG("Format: %s, Rate %d Hz, %s", + snd_pcm_format_description(hwdata.format), + hwdata.rate, + channels.ascii()); +} + +/* playing raw data */ + +void AlsaPlayer::playback_go(int fd, size_t loaded, off64_t count, int rtype, const char *name) +{ + int l, r; + off64_t written = 0; + off64_t c; + + if (m_debugLevel >= 1) header(rtype, name); + set_params(); + + while (loaded > chunk_bytes && written < count) { + if (pcm_write(audiobuf + written, chunk_size) <= 0) + return; + written += chunk_bytes; + loaded -= chunk_bytes; + } + if (written > 0 && loaded > 0) + memmove(audiobuf, audiobuf + written, loaded); + + l = loaded; + while (written < count) { + do { + c = count - written; + if (c > chunk_bytes) + c = chunk_bytes; + c -= l; + + if (c == 0) + break; + r = safe_read(fd, audiobuf + l, c); + if (r < 0) { +// perror(name); + stopAndExit(); + } + fdcount += r; + if (r == 0) + break; + l += r; + } while (sleep_min == 0 && (size_t)l < chunk_bytes); + l = l * 8 / bits_per_frame; + DBG("calling pcm_write with %i frames.", l); + r = pcm_write(audiobuf, l); + DBG("pcm_write returned r = %i", r); + if (r < 0) return; + if (r != l) + break; + r = r * bits_per_frame / 8; + written += r; + l = 0; + } + + DBG("Draining..."); + + /* We want the next "device ready" notification only when the buffer is completely empty. */ + /* Do this by setting the avail_min to the buffer size. */ + int err; + DBG("Getting swparams"); + snd_pcm_sw_params_t *swparams; + snd_pcm_sw_params_alloca(&swparams); + err = snd_pcm_sw_params_current(handle, swparams); + if (err < 0) { + ERR("Unable to get current swparams: %s", snd_strerror(err)); + return; + } + DBG("Setting avail min to %lu", buffer_size); + err = snd_pcm_sw_params_set_avail_min(handle, swparams, buffer_size); + if (err < 0) { + ERR("Unable to set avail min for playback: %s", snd_strerror(err)); + return; + } + /* write the parameters to the playback device */ + DBG("Writing swparams"); + err = snd_pcm_sw_params(handle, swparams); + if (err < 0) { + ERR("Unable to set sw params for playback: %s", snd_strerror(err)); + return; + } + + DBG("Waiting for poll"); + err = wait_for_poll(1); + if (err < 0) { + ERR("Wait for poll() failed"); + return; + } else if (err == 1){ + MSG("Playback stopped while draining"); + + /* Drop the playback on the sound device (probably + still in progress up till now) */ + err = snd_pcm_drop(handle); + if (err < 0) { + ERR("snd_pcm_drop() failed: %s", snd_strerror(err)); + return; + } + } + DBG("Draining completed"); +} + +/* + * let's play or capture it (capture_type says VOC/WAVE/raw) + */ + +void AlsaPlayer::playback(int fd) +{ + int ofs; + size_t dta; + ssize_t dtawave; + + pbrec_count = LLONG_MAX; + fdcount = 0; + + /* read the file header */ + dta = sizeof(AuHeader); + if ((size_t)safe_read(fd, audiobuf, dta) != dta) { + ERR("read error"); + stopAndExit(); + } + if (test_au(fd, audiobuf) >= 0) { + rhwdata.format = hwdata.format; + pbrec_count = calc_count(); + playback_go(fd, 0, pbrec_count, FORMAT_AU, name.ascii()); + goto __end; + } + dta = sizeof(VocHeader); + if ((size_t)safe_read(fd, audiobuf + sizeof(AuHeader), + dta - sizeof(AuHeader)) != dta - sizeof(AuHeader)) { + ERR("read error"); + stopAndExit(); + } + if ((ofs = test_vocfile(audiobuf)) >= 0) { + pbrec_count = calc_count(); + voc_play(fd, ofs, name.ascii()); + goto __end; + } + /* read bytes for WAVE-header */ + if ((dtawave = test_wavefile(fd, audiobuf, dta)) >= 0) { + pbrec_count = calc_count(); + playback_go(fd, dtawave, pbrec_count, FORMAT_WAVE, name.ascii()); + } else { + /* should be raw data */ + init_raw_data(); + pbrec_count = calc_count(); + playback_go(fd, dta, pbrec_count, FORMAT_RAW, name.ascii()); + } +__end: + return; +} + +/* Wait until ALSA is ready for more samples or stop() was called. + @return 0 if ALSA is ready for more input, +1 if a request to stop + the sound output was received and a negative value on error. */ +int AlsaPlayer::wait_for_poll(int draining) +{ + unsigned short revents; + snd_pcm_state_t state; + int ret; + + DBG("Waiting for poll"); + + /* Wait for certain events */ + while (1) { + /* Simulated pause by not writing to alsa device, which will lead to an XRUN + when resumed. */ + if (m_simulatedPause) + msleep(500); + else { + + ret = poll(alsa_poll_fds, alsa_fd_count, -1); + DBG("activity on %d descriptors", ret); + + /* Check for stop request from alsa_stop on the last file descriptors. */ + if ((revents = alsa_poll_fds[alsa_fd_count-1].revents)) { + if (revents & POLLIN){ + DBG("stop requested"); + return 1; + } + } + + /* Check the first count-1 descriptors for ALSA events */ + snd_pcm_poll_descriptors_revents(handle, alsa_poll_fds, alsa_fd_count-1, &revents); + + /* Ensure we are in the right state */ + state = snd_pcm_state(handle); + DBG("State after poll returned is %s", snd_pcm_state_name(state)); + + if (SND_PCM_STATE_XRUN == state){ + if (!draining){ + MSG("WARNING: Buffer underrun detected!"); + xrun(); + return 0; + }else{ + DBG("Playback terminated"); + return 0; + } + } + + if (SND_PCM_STATE_SUSPENDED == state){ + DBG("WARNING: Suspend detected!"); + suspend(); + return 0; + } + + /* Check for errors */ + if (revents & POLLERR) { + DBG("poll revents says POLLERR"); + return -EIO; + } + + /* Is ALSA ready for more input? */ + if ((revents & POLLOUT)){ + DBG("Ready for more input"); + return 0; + } + } + } +} + +#include "alsaplayer.moc" + +#undef DBG +#undef MSG +#undef ERR + +// vim: sw=4 ts=8 et diff --git a/kttsd/players/alsaplayer/alsaplayer.h b/kttsd/players/alsaplayer/alsaplayer.h new file mode 100644 index 0000000..acd465c --- /dev/null +++ b/kttsd/players/alsaplayer/alsaplayer.h @@ -0,0 +1,187 @@ +/***************************************************** vim:set ts=4 sw=4 sts=4: + ALSA player. + ------------------- + Copyright: + (C) 2005 by Gary Cramblitt + ------------------- + Original author: Gary Cramblitt + + 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. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + ******************************************************************************/ + +#ifndef ALSAPLAYER_H +#define ALSAPLAYER_H + +// System includes. +#include +#include + +// Qt includes. +#include +#include +#include +#include +#include + +// KDE includes. +#include +#include +#include "kdeexportfix.h" +#include + +// AlsaPlayer includes. +#include "formats.h" +#include "player.h" + +#ifndef LLONG_MAX +#define LLONG_MAX 9223372036854775807LL +#endif + +#define DEFAULT_FORMAT SND_PCM_FORMAT_U8 +#define DEFAULT_SPEED 8000 + +#define FORMAT_DEFAULT -1 +#define FORMAT_RAW 0 +#define FORMAT_VOC 1 +#define FORMAT_WAVE 2 +#define FORMAT_AU 3 + +static snd_pcm_sframes_t (*readi_func)(snd_pcm_t *handle, void *buffer, snd_pcm_uframes_t size); +static snd_pcm_sframes_t (*writei_func)(snd_pcm_t *handle, const void *buffer, snd_pcm_uframes_t size); +static snd_pcm_sframes_t (*readn_func)(snd_pcm_t *handle, void **bufs, snd_pcm_uframes_t size); +static snd_pcm_sframes_t (*writen_func)(snd_pcm_t *handle, void **bufs, snd_pcm_uframes_t size); + +class KDE_EXPORT AlsaPlayer : public Player, QThread +{ + Q_OBJECT + +public: + AlsaPlayer(QObject* parent = 0, const char* name = 0, const QStringList& args=QStringList()); + ~AlsaPlayer(); + + virtual void startPlay(const QString& file); + virtual void pause(); + virtual void stop(); + + virtual void setVolume(float volume = 1.0); + virtual float volume() const; + + virtual bool playing() const; + virtual bool paused() const; + + virtual int totalTime() const; + virtual int currentTime() const; + virtual int position() const; // in this case not really the percent + + virtual void seek(int seekTime); + virtual void seekPosition(int position); + + virtual QStringList getPluginList( const QCString& classname ); + virtual void setSinkName(const QString &sinkName); + + virtual void setDebugLevel(uint level) { m_debugLevel = level; } + virtual void setPeriodSize(uint periodSize) { m_defPeriodSize = periodSize; } + virtual void setPeriods(uint periods) { m_defPeriods = periods; } + +protected: + virtual void run(); + +private slots: + +private: + void init(); + void cleanup(); + void stopAndExit(); + int wait_for_poll(int draining); + + QString timestamp() const; + + ssize_t safe_read(int fd, void *buf, size_t count); + int test_vocfile(void *buffer); + size_t test_wavefile_read(int fd, char *buffer, size_t *size, size_t reqsize, int line); + ssize_t test_wavefile(int fd, char *_buffer, size_t size); + int test_au(int fd, char *buffer); + void set_params(void); + void xrun(); + void suspend(void); + void compute_max_peak(char *data, size_t count); + ssize_t pcm_write(char *data, size_t count); + ssize_t voc_pcm_write(u_char *data, size_t count); + void voc_write_silence(unsigned x); + void voc_pcm_flush(void); + void voc_play(int fd, int ofs, const char *name); + void init_raw_data(void); + off64_t calc_count(void); + void header(int rtype, const char *name); + void playback_go(int fd, size_t loaded, off64_t count, int rtype, const char *name); + void playback(int fd); + + KURL m_currentURL; + float m_currentVolume; + QString m_pcmName; + char* pcm_name; + mutable QMutex m_mutex; + + QFile audiofile; + QString name; + bool canPause; + + snd_pcm_t *handle; + struct { + snd_pcm_format_t format; + unsigned int channels; + unsigned int rate; + } hwdata, rhwdata; + int timelimit; + int file_type; + unsigned int sleep_min; + int open_mode; + snd_pcm_stream_t stream; + int mmap_flag; + int interleaved; + QByteArray audioBuffer; + char *audiobuf; + snd_pcm_uframes_t chunk_size; + snd_pcm_uframes_t period_frames; + unsigned period_time; + unsigned buffer_time; + snd_pcm_uframes_t buffer_size; + int avail_min; + int start_delay; + int stop_delay; + int buffer_pos; + size_t bits_per_sample; + size_t bits_per_frame; + size_t chunk_bytes; + snd_output_t *log; + int fd; + off64_t pbrec_count; + off64_t fdcount; + int vocmajor; + int vocminor; + + int alsa_stop_pipe[2]; /* Pipe for communication about stop requests*/ + int alsa_fd_count; /* Counter of descriptors to poll */ + QByteArray alsa_poll_fds_barray; + struct pollfd *alsa_poll_fds; /* Descriptors to poll */ + unsigned int m_defPeriodSize; + unsigned int m_defPeriods; + unsigned int m_debugLevel; + bool m_simulatedPause; +}; + +#endif // ALSAPLAYER_H + +// vim: sw=4 ts=8 et diff --git a/kttsd/players/alsaplayer/alsaplugin.cpp b/kttsd/players/alsaplayer/alsaplugin.cpp new file mode 100644 index 0000000..4bd700d --- /dev/null +++ b/kttsd/players/alsaplayer/alsaplugin.cpp @@ -0,0 +1,29 @@ +/***************************************************** vim:set ts=4 sw=4 sts=4: + Generating the factories so ALSA can be used as an audio plug in. + ------------------- + Copyright: + (C) 2005 by Gary Cramblitt + ------------------- + Original author: Gary Cramblitt + + 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. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + ******************************************************************************/ + +#include + +#include "alsaplayer.h" + +K_EXPORT_COMPONENT_FACTORY( libkttsd_alsaplugin, KGenericFactory("kttsd_alsa") ) + diff --git a/kttsd/players/alsaplayer/formats.h b/kttsd/players/alsaplayer/formats.h new file mode 100644 index 0000000..2c4f724 --- /dev/null +++ b/kttsd/players/alsaplayer/formats.h @@ -0,0 +1,110 @@ +#ifndef FORMATS_H +#define FORMATS_H 1 + +#include +#include + +/* Definitions for .VOC files */ + +#define VOC_MAGIC_STRING "Creative Voice File\x1A" +#define VOC_ACTUAL_VERSION 0x010A +#define VOC_SAMPLESIZE 8 + +#define VOC_MODE_MONO 0 +#define VOC_MODE_STEREO 1 + +#define VOC_DATALEN(bp) ((u_long)(bp->datalen) | \ + ((u_long)(bp->datalen_m) << 8) | \ + ((u_long)(bp->datalen_h) << 16) ) + +typedef struct voc_header { + u_char magic[20]; /* must be MAGIC_STRING */ + u_short headerlen; /* Headerlength, should be 0x1A */ + u_short version; /* VOC-file version */ + u_short coded_ver; /* 0x1233-version */ +} VocHeader; + +typedef struct voc_blocktype { + u_char type; + u_char datalen; /* low-byte */ + u_char datalen_m; /* medium-byte */ + u_char datalen_h; /* high-byte */ +} VocBlockType; + +typedef struct voc_voice_data { + u_char tc; + u_char pack; +} VocVoiceData; + +typedef struct voc_ext_block { + u_short tc; + u_char pack; + u_char mode; +} VocExtBlock; + +/* Definitions for Microsoft WAVE format */ + +#if __BYTE_ORDER == __LITTLE_ENDIAN +#define COMPOSE_ID(a,b,c,d) ((a) | ((b)<<8) | ((c)<<16) | ((d)<<24)) +#define LE_SHORT(v) (v) +#define LE_INT(v) (v) +#define BE_SHORT(v) bswap_16(v) +#define BE_INT(v) bswap_32(v) +#elif __BYTE_ORDER == __BIG_ENDIAN +#define COMPOSE_ID(a,b,c,d) ((d) | ((c)<<8) | ((b)<<16) | ((a)<<24)) +#define LE_SHORT(v) bswap_16(v) +#define LE_INT(v) bswap_32(v) +#define BE_SHORT(v) (v) +#define BE_INT(v) (v) +#else +#error "Wrong endian" +#endif + +#define WAV_RIFF COMPOSE_ID('R','I','F','F') +#define WAV_WAVE COMPOSE_ID('W','A','V','E') +#define WAV_FMT COMPOSE_ID('f','m','t',' ') +#define WAV_DATA COMPOSE_ID('d','a','t','a') +#define WAV_PCM_CODE 1 + +/* it's in chunks like .voc and AMIGA iff, but my source say there + are in only in this combination, so I combined them in one header; + it works on all WAVE-file I have + */ +typedef struct { + u_int magic; /* 'RIFF' */ + u_int length; /* filelen */ + u_int type; /* 'WAVE' */ +} WaveHeader; + +typedef struct { + u_short format; /* should be 1 for PCM-code */ + u_short modus; /* 1 Mono, 2 Stereo */ + u_int sample_fq; /* frequence of sample */ + u_int byte_p_sec; + u_short byte_p_spl; /* samplesize; 1 or 2 bytes */ + u_short bit_p_spl; /* 8, 12 or 16 bit */ +} WaveFmtBody; + +typedef struct { + u_int type; /* 'data' */ + u_int length; /* samplecount */ +} WaveChunkHeader; + +/* Definitions for Sparc .au header */ + +#define AU_MAGIC COMPOSE_ID('.','s','n','d') + +#define AU_FMT_ULAW 1 +#define AU_FMT_LIN8 2 +#define AU_FMT_LIN16 3 + +typedef struct au_header { + u_int magic; /* '.snd' */ + u_int hdr_size; /* size of header (min 24) */ + u_int data_size; /* size of data */ + u_int encoding; /* see to AU_FMT_XXXX */ + u_int sample_rate; /* sample rate */ + u_int channels; /* number of channels (voices) */ +} AuHeader; + +#endif /* FORMATS */ diff --git a/kttsd/players/alsaplayer/kttsd_alsaplugin.desktop b/kttsd/players/alsaplayer/kttsd_alsaplugin.desktop new file mode 100644 index 0000000..36eec0b --- /dev/null +++ b/kttsd/players/alsaplayer/kttsd_alsaplugin.desktop @@ -0,0 +1,89 @@ +[Desktop Entry] +Name=KTTSD ALSA Plugin +Name[br]=Lugent ALSA evit KTTSD +Name[bs]=KTTSD ALSA dodatak +Name[ca]=Connector ALSA pel KTTSD +Name[cs]=KTTSD ALSA modul +Name[da]=KTTSD ALSA plugin +Name[de]=KTTSD ALSA-Modul +Name[el]=KTTSD πρόσθετο ALSA +Name[es]=Complemento ALSA de KTTSD +Name[et]=KTTSD ALSA plugin +Name[eu]=KTTSD-ren ALSA plugina +Name[fa]=وصلۀ KTTSD ALSA +Name[fi]=KTTSD ALSA -liitännäinen +Name[fr]=Module ALSA pour KTTSD +Name[ga]=Breiseán KTTSD ALSA +Name[gl]=Plugin ALSA de KTTSD +Name[hu]=KTTSD ALSA hangmodul +Name[is]=KTTSD ALSA íforrit +Name[it]=Plugin per ALSA di KTTSD +Name[ja]=KTTSD ALSA プラグイン +Name[ka]=KTTSD ALSA მოდული +Name[km]= កម្មវិធី​ជំនួយ​ ALSA សម្រាប់ KTTSD +Name[mk]=ALSA-приклучок за KTTSD +Name[nb]=Alsas programtillegg for KTTSD +Name[nds]=ALSA-Moduul för KTTSD +Name[ne]=KTTSD ALSA प्लगइन +Name[nl]=KTTSD ALSA-plugin +Name[pa]=KTTSD ALSA ਪਲੱਗਿੰਨ +Name[pl]=Wtyczka ALSA dla KTTSD +Name[pt]='Plugin' ALSA do KTTSD +Name[pt_BR]=Plug-in ALSA para o KTTSD +Name[ru]=Модуль alsa для KTTSD +Name[sk]=Modul KTTSD ALSA +Name[sl]=Vstavek KTTSD za ALSA +Name[sr]=ALSA прикључак за KTTSD +Name[sr@Latn]=ALSA priključak za KTTSD +Name[sv]=KTTSD-insticksprogram för ALSA +Name[tg]=Модули KTTSD ALSA +Name[tr]=KTTSD ALSA Eklentisi +Name[uk]=Втулок ALSA для KTTSD +Name[vi]=Trình bổ sung KTTSD ALSA +Name[zh_TW]=KTTSd ALSA 外掛程式 +Comment=KTTSD ALSA audio plugin +Comment[bg]=Аудио приставка на KTTSD за ALSA +Comment[br]=Lugent klevet ALSA evit KTTSD +Comment[bs]=KTTSD ALSA audio dodatak +Comment[ca]=Connector d'àudio ALSA pel KTTSD +Comment[cs]=KTTSD ALSA zvukový modul +Comment[da]=KTTSD ALSA lyd-plugin +Comment[de]=KTTSD ALSA-Audio-Modul +Comment[el]=KTTSD πρόσθετο ήχου ALSA +Comment[es]=Complemento de audio ALSA de KTTSD +Comment[et]=KTTSD ALSA audioplugin +Comment[eu]=KTTSD-ren ALSA audio-plugina +Comment[fa]=وصلۀ صوتی KTTSD ALSA +Comment[fi]=KTTSD ALSA ääniliitännäinen +Comment[fr]=Module audio ALSA pour KTTSD +Comment[ga]=Breiseán fuaime KTTSD ALSA +Comment[gl]=Plugin de áudio ALSA para KTTSD +Comment[hu]=KTTSD ALSA hangmodul +Comment[is]=KTTSD ALSA hljóð íforrit +Comment[it]=Plugin audio per ALSA di KTTSD +Comment[ja]=KTTSD ALSA オーディオプラグイン +Comment[ka]=KTTSD ALSA აუდიო მოდული +Comment[km]= កម្មវិធី​ជំនួយអូឌីយ៉ូ​ ALSA សម្រាប់ KTTSD +Comment[mk]=ALSA-аудиоприклучок за KTTSD +Comment[nb]=Alsas lyd-programtillegg for KTTSD +Comment[nds]=ALSA-Audiomoduul för KTTSD +Comment[ne]=KTTSD ALSA अडियो प्लगइन +Comment[nl]=KTTSD ALSA geluidsplugin +Comment[pa]=KTTSD ALSA ਆਡੀਓ ਪਲੱਗਿੰਨ +Comment[pl]=Wtyczka dźwięku ALSA dla KTTSD +Comment[pt]='Plugin' de áudio ALSA do KTTSD +Comment[pt_BR]=Plug-in de áudio ALSA para o KTTSD +Comment[ru]=Модуль вывода звука KTTSD через alsa +Comment[sk]=Modul KTTSD ALSA audio +Comment[sl]=Vstavek KTTSD za zvok v ALSA +Comment[sr]=ALSA аудио прикључак за KTTSD +Comment[sr@Latn]=ALSA audio priključak za KTTSD +Comment[sv]=KTTSD-ljudinsticksprogram för ALSA +Comment[tg]=Модули KTTSD ALSA барои аудио +Comment[tr]=KTTSD ALSA ses eklentisi +Comment[uk]=Втулок аудіо ALSA для KTTSD +Comment[vi]=Trình bổ sung âm thanh KTTSD ALSA +Comment[zh_TW]=KTTSd ALSA 語音外掛程式 +Type=Service +ServiceTypes=KTTSD/AudioPlugin +X-KDE-Library=libkttsd_alsaplugin diff --git a/kttsd/players/artsplayer/Makefile.am b/kttsd/players/artsplayer/Makefile.am new file mode 100644 index 0000000..d5c6012 --- /dev/null +++ b/kttsd/players/artsplayer/Makefile.am @@ -0,0 +1,30 @@ +# Include paths. INCLUDES is maintained by KDevelop, AM_CPPFLAGS is the preferred variable, +# so keep them synchronized. +INCLUDES = \ + -I$(kde_includes)/arts \ + -I$(top_srcdir)/kttsd/libkttsd -I$(top_builddir)/kttsd/libkttsd \ + $(all_includes) + +# Let automoc handle all of the metsource files (moc). +METASOURCES = AUTO + +######################################################################### +# LIBRARY SECTION +######################################################################### +# This is the library that gets installed. It's name is used for all +# of the other Makefile.am variables. +kde_module_LTLIBRARIES = libkttsd_artsplugin.la + +libkttsd_artsplugin_la_SOURCES = \ + artsplugin.cpp \ + artsplayer.cpp +libkttsd_artsplugin_la_LDFLAGS = $(KDE_PLUGIN) $(all_libraries) -no-undefined +libkttsd_artsplugin_la_LIBADD = $(top_builddir)/kttsd/libkttsd/libkttsd.la -lartskde + +# Header files that should not be installed. +noinst_HEADERS = \ + artsplayer.h + +# This library is installed as a plugin. +services_DATA = kttsd_artsplugin.desktop +servicesdir = $(kde_servicesdir) diff --git a/kttsd/players/artsplayer/artsplayer.cpp b/kttsd/players/artsplayer/artsplayer.cpp new file mode 100644 index 0000000..512765a --- /dev/null +++ b/kttsd/players/artsplayer/artsplayer.cpp @@ -0,0 +1,296 @@ +/*************************************************************************** + begin : Sun Feb 17 2002 + copyright : (C) 2002 - 2004 by Scott Wheeler + email : wheeler@kde.org + + copyright : (C) 2003 by Matthias Kretz + email : kretz@kde.org +***************************************************************************/ + +/*************************************************************************** + * * + * 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. * + * * + ***************************************************************************/ + +#include "artsplayer.h" + +#include +#include +#include + +#include +#include + +#include +#include +#include +#include + +#include + +#include +#include +#include + +//////////////////////////////////////////////////////////////////////////////// +// public methods +//////////////////////////////////////////////////////////////////////////////// + +ArtsPlayer::ArtsPlayer(QObject* parent, const char* name, const QStringList& args) : + Player(parent, name, args), + m_dispatcher(0), + m_server(0), + m_factory(0), + m_playobject(0), + m_amanPlay(0), + m_volumeControl(Arts::StereoVolumeControl::null()), + m_currentVolume(1.0) +{ +} + +ArtsPlayer::~ArtsPlayer() +{ + delete m_playobject; + delete m_factory; + delete m_amanPlay; + delete m_server; + delete m_dispatcher; +} + +//void ArtsPlayer::play(const FileHandle &file) +void ArtsPlayer::startPlay(const QString &file) +{ + if (!m_dispatcher) + setupPlayer(); + + // kdDebug(65432) << k_funcinfo << endl; + // Make sure that the server still exists, if it doesn't a new one should + // be started automatically and the factory and amanPlay are created again. + + if(!file.isNull()) +// m_currentURL.setPath(file.absFilePath()); + m_currentURL.setPath(file); + + if(m_server->server().isNull()) { + KMessageBox::error(0, i18n("Cannot find the aRts soundserver.")); + return; + } + + if(!m_playobject || !file.isNull()) { + stop(); + + delete m_playobject; + m_playobject = m_factory->createPlayObject(m_currentURL, false); + + if(m_playobject->object().isNull()) + connect(m_playobject, SIGNAL(playObjectCreated()), SLOT(playObjectCreated())); + else + playObjectCreated(); + } + + m_playobject->play(); +} + +void ArtsPlayer::pause() +{ + // kdDebug(65432) << k_funcinfo << endl; + if(m_playobject) + m_playobject->pause(); +} + +void ArtsPlayer::stop() +{ + // kdDebug(65432) << k_funcinfo << endl; + if(m_playobject) { + m_playobject->halt(); + delete m_playobject; + m_playobject = 0; + } + if(!m_volumeControl.isNull()) { + m_volumeControl.stop(); + m_volumeControl = Arts::StereoVolumeControl::null(); + } +} + +void ArtsPlayer::setVolume(float volume) +{ + // kdDebug( 65432 ) << k_funcinfo << endl; + + m_currentVolume = volume; + + if(serverRunning() && m_playobject && !m_playobject->isNull()) { + if(m_volumeControl.isNull()) + setupVolumeControl(); + if(!m_volumeControl.isNull()) { + m_volumeControl.scaleFactor(volume); + // kdDebug( 65432 ) << "set volume to " << volume << endl; + } + } +} + +float ArtsPlayer::volume() const +{ + return m_currentVolume; +} + +///////////////////////////////////////////////////////////////////////////////// +// player status functions +///////////////////////////////////////////////////////////////////////////////// + +bool ArtsPlayer::playing() const +{ + if(serverRunning() && m_playobject && m_playobject->state() == Arts::posPlaying) + return true; + else + return false; +} + +bool ArtsPlayer::paused() const +{ + if(serverRunning() && m_playobject && m_playobject->state() == Arts::posPaused) + return true; + else + return false; +} + +int ArtsPlayer::totalTime() const +{ + if(serverRunning() && m_playobject) + return m_playobject->overallTime().seconds; + else + return -1; +} + +int ArtsPlayer::currentTime() const +{ + if(serverRunning() && m_playobject && + (m_playobject->state() == Arts::posPlaying || + m_playobject->state() == Arts::posPaused)) + { + return m_playobject->currentTime().seconds; + } + else + return -1; +} + +int ArtsPlayer::position() const +{ + if(serverRunning() && m_playobject && m_playobject->state() == Arts::posPlaying) { + long total = m_playobject->overallTime().seconds * 1000 + m_playobject->overallTime().ms; + long current = m_playobject->currentTime().seconds * 1000 + m_playobject->currentTime().ms; + + // add .5 to make rounding happen properly + + return int(double(current) * 1000 / total + .5); + } + else + return -1; +} + +///////////////////////////////////////////////////////////////////////////////// +// player seek functions +///////////////////////////////////////////////////////////////////////////////// + +void ArtsPlayer::seek(int seekTime) +{ + if(serverRunning() && m_playobject) { + Arts::poTime poSeekTime; + poSeekTime.custom = 0; + poSeekTime.ms = 0; + poSeekTime.seconds = seekTime; + m_playobject->object().seek(poSeekTime); + } +} + +void ArtsPlayer::seekPosition(int position) +{ + if(serverRunning() && m_playobject) { + Arts::poTime poSeekTime; + long total = m_playobject->overallTime().seconds; + poSeekTime.custom = 0; + poSeekTime.ms = 0; + poSeekTime.seconds = long(double(total) * position / 1000 + .5); + m_playobject->object().seek(poSeekTime); + } +} + +///////////////////////////////////////////////////////////////////////////////// +// private +///////////////////////////////////////////////////////////////////////////////// + +void ArtsPlayer::setupArtsObjects() +{ + // kdDebug( 65432 ) << k_funcinfo << endl; + delete m_factory; + delete m_amanPlay; + m_volumeControl = Arts::StereoVolumeControl::null(); + m_factory = new KDE::PlayObjectFactory(m_server); + m_amanPlay = new KAudioManagerPlay(m_server); + + if(m_amanPlay->isNull() || !m_factory) { + KMessageBox::error(0, i18n("Connecting/starting aRts soundserver failed. " + "Make sure that artsd is configured properly.")); + qApp->exit(1); + } + + m_amanPlay->setTitle(i18n("kttsd")); + m_amanPlay->setAutoRestoreID("kttsdAmanPlay"); + + m_factory->setAudioManagerPlay(m_amanPlay); +} + +void ArtsPlayer::playObjectCreated() +{ + // kdDebug(65432) << k_funcinfo << endl; + setVolume(m_currentVolume); +} + +void ArtsPlayer::setupPlayer() +{ + m_dispatcher = new KArtsDispatcher; + m_server = new KArtsServer; + setupArtsObjects(); + connect(m_server, SIGNAL(restartedServer()), SLOT(setupArtsObjects())); +} + +void ArtsPlayer::setupVolumeControl() +{ + // kdDebug( 65432 ) << k_funcinfo << endl; + m_volumeControl = Arts::DynamicCast(m_server->server().createObject("Arts::StereoVolumeControl")); + if(!m_volumeControl.isNull() && !m_playobject->isNull() && !m_playobject->object().isNull()) { + Arts::Synth_AMAN_PLAY ap = m_amanPlay->amanPlay(); + Arts::PlayObject po = m_playobject->object(); + ap.stop(); + Arts::disconnect(po, "left" , ap, "left" ); + Arts::disconnect(po, "right", ap, "right"); + + m_volumeControl.start(); + ap.start(); + + Arts::connect(po, "left" , m_volumeControl, "inleft" ); + Arts::connect(po, "right", m_volumeControl, "inright"); + Arts::connect(m_volumeControl, "outleft" , ap, "left" ); + Arts::connect(m_volumeControl, "outright", ap, "right"); + // kdDebug( 65432 ) << "connected volume control" << endl; + } + else { + m_volumeControl = Arts::StereoVolumeControl::null(); + kdDebug(65432) << "Could not initialize volume control!" << endl; + } +} + +bool ArtsPlayer::serverRunning() const +{ + if(m_server) + return !(m_server->server().isNull()); + else + return false; +} + +#include "artsplayer.moc" + +// vim: sw=4 ts=8 et diff --git a/kttsd/players/artsplayer/artsplayer.h b/kttsd/players/artsplayer/artsplayer.h new file mode 100644 index 0000000..96d62f6 --- /dev/null +++ b/kttsd/players/artsplayer/artsplayer.h @@ -0,0 +1,95 @@ +/*************************************************************************** + begin : Sun Feb 17 2002 + copyright : (C) 2002 - 2004 by Scott Wheeler + email : wheeler@kde.org + + copyright : (C) 2003 by Matthias Kretz + email : kretz@kde.org +***************************************************************************/ + +/*************************************************************************** + * * + * 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 ARTSPLAYER_H +#define ARTSPLAYER_H + +#include +#include +#include "kdeexportfix.h" + +#include "player.h" + +#include + +#include +#include +#include + +class KArtsDispatcher; +class KArtsServer; +class KAudioManagerPlay; + +namespace KDE { + class PlayObjectFactory; + class PlayObject; +} + +class KDE_EXPORT ArtsPlayer : public Player +{ + Q_OBJECT + +public: + ArtsPlayer(QObject* parent = 0, const char* name = 0, const QStringList& args=QStringList()); + ~ArtsPlayer(); + +// virtual void play(const FileHandle &file = FileHandle::null()); + virtual void startPlay(const QString& file); + virtual void pause(); + virtual void stop(); + + virtual void setVolume(float volume = 1.0); + virtual float volume() const; + + virtual bool playing() const; + virtual bool paused() const; + + virtual int totalTime() const; + virtual int currentTime() const; + virtual int position() const; // in this case not really the percent + + virtual void seek(int seekTime); + virtual void seekPosition(int position); + +private slots: + void setupArtsObjects(); + void playObjectCreated(); + +private: + void setupPlayer(); + void setupVolumeControl(); + bool serverRunning() const; + + KArtsDispatcher *m_dispatcher; + KArtsServer *m_server; + KDE::PlayObjectFactory *m_factory; + KDE::PlayObject *m_playobject; + KAudioManagerPlay *m_amanPlay; + + // This is a pretty heavy module for the needs that JuK has, it would probably + // be good to use two Synth_MUL instead or the one from Noatun. + + Arts::StereoVolumeControl m_volumeControl; + + KURL m_currentURL; + float m_currentVolume; +}; + +#endif + +// vim: sw=4 ts=8 et diff --git a/kttsd/players/artsplayer/artsplugin.cpp b/kttsd/players/artsplayer/artsplugin.cpp new file mode 100644 index 0000000..36f4517 --- /dev/null +++ b/kttsd/players/artsplayer/artsplugin.cpp @@ -0,0 +1,29 @@ +/***************************************************** vim:set ts=4 sw=4 sts=4: + Generating the factories so aRts can be used as an audio plug in. + ------------------- + Copyright: + (C) 2004 by Gary Cramblitt + ------------------- + Original author: Gary Cramblitt + + 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. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + ******************************************************************************/ + +#include + +#include "artsplayer.h" + +K_EXPORT_COMPONENT_FACTORY( libkttsd_artsplugin, KGenericFactory("kttsd_arts") ) + diff --git a/kttsd/players/artsplayer/kttsd_artsplugin.desktop b/kttsd/players/artsplayer/kttsd_artsplugin.desktop new file mode 100644 index 0000000..9eef151 --- /dev/null +++ b/kttsd/players/artsplayer/kttsd_artsplugin.desktop @@ -0,0 +1,91 @@ +[Desktop Entry] +Name=KTTSD Arts Plugin +Name[br]=Lugent Arts evit KTTSD +Name[bs]=KTTSD Arts dodatak +Name[ca]=Connector Arts pel KTTSD +Name[cs]=KTTSD Arts modul +Name[da]=KTTSD aRts-plugin +Name[de]=KTTSD Arts-Modul +Name[el]=KTTSD πρόσθετο Arts +Name[es]=Complemento KTTSD Arts +Name[et]=KTTSD Artsi plugin +Name[eu]=KTTSD-ren Arts-plugina +Name[fa]=وصلۀ KTTSD Arts +Name[fi]=KTTSD Arts -liitännäinen +Name[fr]=Module Arts pour KTTSD +Name[ga]=Breiseán KTTSD Arts +Name[gl]=Plugin Arts de KTTSD +Name[hu]=KTTSD aRts hangmodul +Name[is]=KTTSD Arts íforrit +Name[it]=Plugin per Arts di KTTSD +Name[ja]=KTTSD aRts プラグイン +Name[ka]=KTTSD Arts მოდული +Name[km]=កម្មវិធី​ជំនួយ Arts សម្រាប់ KTTSD +Name[mk]=aRts-приклучок за KTTSD +Name[nb]=Arts programtillegg for KTTSD +Name[nds]=aRts-Moduul för KTTSD +Name[ne]=KTTSD कला प्लगइन +Name[nl]=KTTSD Arts-plugin +Name[pa]=KTTSD Arts ਪਲੱਗਿੰਨ +Name[pl]=Wtyczka aRts KTTSD +Name[pt]='Plugin' Arts do KTTSD +Name[pt_BR]=Plug-in do Arts para o KTTSD +Name[ru]=Модуль Arts для KTTSD +Name[sk]=Modul KTTSD Arts +Name[sl]=Vstavek KTTSD za aRts +Name[sr]=Arts као прикључак за KTTSD +Name[sr@Latn]=Arts kao priključak za KTTSD +Name[sv]=KTTSD-insticksprogram för aRts +Name[ta]=KTTSD ஆர்ட்ஸ் சொருகுப்பொருள் +Name[tg]=Модули Arts барои KTTSD +Name[tr]=KTTSD Arts Eklentisi +Name[uk]=Втулок Arts для KTTSD +Name[vi]=Trình bổ sung KTTSD Arts +Name[zh_TW]=KTTSd Arts 外掛程式 +Comment=KTTSD aRts audio plugin +Comment[bg]=Аудио приставка на KTTSD за aRts +Comment[br]=Lugent klevet Arts evit KTTSD +Comment[ca]=Connector d'àudio aRts pel KTTSD +Comment[cs]=KTTSD aRts zvukový modul +Comment[da]=KTTSD aRts lyd-plugin +Comment[de]=KTTSD aRts Audio-Modul +Comment[el]=KTTSD πρόσθετο ήχου aRts +Comment[es]=Complemento de audio KTTSD aRts +Comment[et]=KTTSD aRts'i audioplugin +Comment[eu]=KTTSD-ren aRts audio-plugina +Comment[fa]=وصلۀ صوتی KTTSD aRts +Comment[fi]=KTTSD aRts ääniliitännäinen +Comment[fr]=Module audio Arts pour KTTSD +Comment[ga]=Breiseán fuaime KTTSD aRts +Comment[gl]=Plugin de áudio aRts para KTTSD +Comment[hu]=KTTSD hangmodul az aRts hangrendszerhez +Comment[is]=KTTSD aRts hljóð íforrit +Comment[it]=Plugin audio per aRts di KTTSD +Comment[ja]=KTTSD aRts オーディオプラグイン +Comment[ka]=KTTSD aRts აუდიო მოდული +Comment[km]=កម្មវិធី​ជំនួយ​អូឌីយ៉ូ aRts សម្រាប់ KTTSD +Comment[mk]=aRts-аудиоприклучок за KTTSD +Comment[ms]=Plugin audio aRts KTTSD +Comment[nb]=aRts lyd-programtillegg for KTTSD +Comment[nds]=aRts-Audiomoduul för KTTSD +Comment[ne]=KTTSD कला अडियो प्लगइन +Comment[nl]=KTTSD aRts-audioplugin +Comment[pa]=KTTSD aRts ਆਡੀਓ ਪਲੱਗਿੰਨ +Comment[pl]=Wtyczka dźwięku aRts dla KTTSD +Comment[pt]='Plugin' áudio aRts do KTTSD +Comment[pt_BR]=Plug-in de áudio do Arts para o KTTSD +Comment[ru]=Модуль вывода звука KTTSD через aRts +Comment[sk]=Modul KTTSD aRts audio +Comment[sl]=Vstavek KTTSD za zvok v aRts +Comment[sr]=Arts као аудио прикључак за KTTSD +Comment[sr@Latn]=Arts kao audio priključak za KTTSD +Comment[sv]=KTTSD-ljudinsticksprogram för aRts +Comment[ta]=KTTSD aRts கேட்பொலி சொருகுப்பொருள் +Comment[tg]=Модули барориши овози KTTSD ба воситаи aRts +Comment[tr]=KTTSD aRts ses eklentisi +Comment[uk]=Звуковий втулок aRts для KTTSD +Comment[vi]=Trình bổ sung âm thanh KTTSD aRts +Comment[zh_TW]=KTTSd aRts 語音外掛程式 +Type=Service +ServiceTypes=KTTSD/AudioPlugin +X-KDE-Library=libkttsd_artsplugin diff --git a/kttsd/players/gstplayer/Makefile.am b/kttsd/players/gstplayer/Makefile.am new file mode 100644 index 0000000..df00c55 --- /dev/null +++ b/kttsd/players/gstplayer/Makefile.am @@ -0,0 +1,30 @@ +# Include paths. INCLUDES is maintained by KDevelop, AM_CPPFLAGS is the preferred variable, +# so keep them synchronized. +INCLUDES = \ + $(GST_CFLAGS) \ + -I$(top_srcdir)/kttsd/libkttsd -I$(top_builddir)/kttsd/libkttsd \ + $(all_includes) + +# Let automoc handle all of the metsource files (moc). +METASOURCES = AUTO + +######################################################################### +# LIBRARY SECTION +######################################################################### +# This is the library that gets installed. It's name is used for all +# of the other Makefile.am variables. +kde_module_LTLIBRARIES = libkttsd_gstplugin.la + +libkttsd_gstplugin_la_SOURCES = \ + gstplugin.cpp \ + gstreamerplayer.cpp +libkttsd_gstplugin_la_LDFLAGS = $(KDE_PLUGIN) $(all_libraries) $(LDFLAGS_GST) -no-undefined +libkttsd_gstplugin_la_LIBADD = $(top_builddir)/kttsd/libkttsd/libkttsd.la $(LDADD_GST) + +# Header files that should not be installed. +noinst_HEADERS = \ + gstreamerplayer.h + +# This library is installed as a plugin. +services_DATA = kttsd_gstplugin.desktop +servicesdir = $(kde_servicesdir) diff --git a/kttsd/players/gstplayer/gstplugin.cpp b/kttsd/players/gstplayer/gstplugin.cpp new file mode 100644 index 0000000..633bff9 --- /dev/null +++ b/kttsd/players/gstplayer/gstplugin.cpp @@ -0,0 +1,29 @@ +/***************************************************** vim:set ts=4 sw=4 sts=4: + Generating the factories so that GStreamer can be used as and audio plug in. + ------------------- + Copyright: + (C) 2004 by Gary Cramblitt + ------------------- + Original author: Gary Cramblitt + + 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. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + ******************************************************************************/ + +#include + +#include "gstreamerplayer.h" + +K_EXPORT_COMPONENT_FACTORY( libkttsd_gstplugin, KGenericFactory("kttsd_gst") ); + diff --git a/kttsd/players/gstplayer/gstreamerplayer.cpp b/kttsd/players/gstplayer/gstreamerplayer.cpp new file mode 100644 index 0000000..64aa1c4 --- /dev/null +++ b/kttsd/players/gstplayer/gstreamerplayer.cpp @@ -0,0 +1,258 @@ +/*************************************************************************** + copyright : (C) 2004 Scott Wheeler + email : wheeler@kde.org +***************************************************************************/ + +/*************************************************************************** + * * + * 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. * + * * + ***************************************************************************/ + +// Qt includes. +#include + +// KDE includes. +#include +#include +#include +#include + +// GStreamerPlayer includes. +#include "gstreamerplayer.h" +#include "gstreamerplayer.moc" + +//////////////////////////////////////////////////////////////////////////////// +// public methods +//////////////////////////////////////////////////////////////////////////////// + +GStreamerPlayer::GStreamerPlayer(QObject* parent, const char* name, const QStringList& args) : + Player(parent, name, args), + m_initialized(false), + m_pipeline(0), + m_source(0), + m_decoder(0), + m_volume(0), + m_sink(0) +{ + // readConfig(); + setupPipeline(); +} + +GStreamerPlayer::~GStreamerPlayer() +{ + stop(); + gst_object_unref(GST_OBJECT(m_pipeline)); +} + +//void GStreamerPlayer::play(const FileHandle &file) +void GStreamerPlayer::startPlay(const QString &file) +{ + if(!file.isNull()) { + stop(); + // g_object_set(G_OBJECT(m_source), "location", file.absFilePath().local8Bit().data(), 0); + g_object_set(G_OBJECT(m_source),"location",file.local8Bit().data(),NULL); + } + + gst_element_set_state(m_pipeline, GST_STATE_PLAYING); +} + +void GStreamerPlayer::pause() +{ + gst_element_set_state(m_pipeline, GST_STATE_PAUSED); +} + +void GStreamerPlayer::stop() +{ + gst_element_set_state(m_pipeline, GST_STATE_NULL); +} + +void GStreamerPlayer::setVolume(float volume) +{ + g_object_set(G_OBJECT(m_volume), "volume", volume, NULL); +} + +float GStreamerPlayer::volume() const +{ + gfloat value; + g_object_get(G_OBJECT(m_volume), "volume", &value, NULL); + return value; +} + +bool GStreamerPlayer::playing() const +{ + return gst_element_get_state(m_pipeline) == GST_STATE_PLAYING; +} + +bool GStreamerPlayer::paused() const +{ + return gst_element_get_state(m_pipeline) == GST_STATE_PAUSED; +} + +int GStreamerPlayer::totalTime() const +{ + return time(GST_QUERY_TOTAL) / GST_SECOND; +} + +int GStreamerPlayer::currentTime() const +{ + return time(GST_QUERY_POSITION) / GST_SECOND; +} + +int GStreamerPlayer::position() const +{ + long long total = time(GST_QUERY_TOTAL); + long long current = time(GST_QUERY_POSITION); + return total > 0 ? int((double(current) / double(total)) * double(1000) + 0.5) : 0; +} + +void GStreamerPlayer::seek(int seekTime) +{ + int type = (GST_FORMAT_TIME | GST_SEEK_METHOD_SET | GST_SEEK_FLAG_FLUSH); + gst_element_seek(m_sink, GstSeekType(type), seekTime * GST_SECOND); +} + +void GStreamerPlayer::seekPosition(int position) +{ + long long total = time(GST_QUERY_TOTAL); + if(total > 0) + seek(int(double(position) / double(1000) * double(totalTime()) + 0.5)); +} + +/** + * Returns a list of GStreamer plugins of the specified class. + * @param classname Desired class. Use "Sink/Audio" for sinks. + * @return List of plugin names. + */ +QStringList GStreamerPlayer::getPluginList( const QCString& classname ) +{ + GList * pool_registries = NULL; + GList* registries = NULL; + GList* plugins = NULL; + GList* features = NULL; + QString name; + QStringList results; + + if(!m_initialized) { + int argc = kapp->argc(); + char **argv = kapp->argv(); + gst_init(&argc, &argv); + m_initialized = true; + } + + pool_registries = gst_registry_pool_list (); + registries = pool_registries; + + while ( registries ) { + GstRegistry * registry = GST_REGISTRY ( registries->data ); + plugins = registry->plugins; + + while ( plugins ) { + GstPlugin * plugin = GST_PLUGIN ( plugins->data ); + features = gst_plugin_get_feature_list ( plugin ); + + while ( features ) { + GstPluginFeature * feature = GST_PLUGIN_FEATURE ( features->data ); + + if ( GST_IS_ELEMENT_FACTORY ( feature ) ) { + GstElementFactory * factory = GST_ELEMENT_FACTORY ( feature ); + + if ( g_strrstr ( factory->details.klass, classname ) ) { + name = g_strdup ( GST_OBJECT_NAME ( factory ) ); + if ( name != "artsdsink" ) results << name; + } + } + features = g_list_next ( features ); + } + plugins = g_list_next ( plugins ); + } + registries = g_list_next ( registries ); + } + g_list_free ( pool_registries ); + pool_registries = NULL; + + return results; +} + +bool GStreamerPlayer::requireVersion(uint major, uint minor, uint micro) +{ + guint gmajor, gminor, gmicro; + + if(!m_initialized) { + int argc = kapp->argc(); + char **argv = kapp->argv(); + gst_init(&argc, &argv); + m_initialized = true; + } + + gst_version(&gmajor, &gminor, &gmicro); + // kdDebug() << QString("GStreamerPlayer::requireVersion: You have gstreamer %1.%2.%3 installed.").arg(gmajor).arg(gminor).arg(gmicro) << endl; + if (gmajor > major) return true; + if (gminor > minor) return true; + if (gmicro >= micro) return true; + kdDebug() << QString("GStreamerPlayer::requireVersion: You have gstreamer %1.%2.%3 installed.").arg(gmajor).arg(gminor).arg(gmicro) << endl; + kdDebug() << QString("GStreamerPlayer::requireVersion: This application requires %1.%2.%3 or greater.").arg(major).arg(minor).arg(micro) << endl; + return false; +} + +void GStreamerPlayer::setSinkName(const QString &sinkName) { m_sinkName = sinkName; } + +//////////////////////////////////////////////////////////////////////////////// +// private methods +//////////////////////////////////////////////////////////////////////////////// + +void GStreamerPlayer::readConfig() +{ + KConfigGroup config(KGlobal::config(), "GStreamerPlayer"); + m_sinkName = config.readEntry("SinkName", QString::null); +} + +void GStreamerPlayer::setupPipeline() +{ + if(!m_initialized) { + int argc = kapp->argc(); + char **argv = kapp->argv(); + gst_init(&argc, &argv); + m_initialized = true; + } + + m_pipeline = gst_thread_new("pipeline"); + m_source = gst_element_factory_make("filesrc", "source"); + m_decoder = gst_element_factory_make("spider", "decoder"); + m_volume = gst_element_factory_make("volume", "volume"); + + if(!m_sinkName.isNull()) + m_sink = gst_element_factory_make(m_sinkName.utf8().data(), "sink"); + if (!m_sink) + { + // m_sink = gst_element_factory_make("alsasink", "sink"); + // if(!m_sink) + // m_sink = gst_element_factory_make("osssink", "sink"); + + // Reversing order. OSS seems to work. Alsa sink produces ugly echo of last + // couple of words in each wav file. argh! + // kdDebug() << "GStreamerPlayer::setupPipeline: trying oss sink." << endl; + m_sink = gst_element_factory_make("osssink", "sink"); + if(!m_sink) + { + // kdDebug() << "GStreamerPlayer::setupPipeline: reverting to alsa sink." << endl; + m_sink = gst_element_factory_make("alsasink", "sink"); + } + } + + gst_bin_add_many(GST_BIN(m_pipeline), m_source, m_decoder, m_volume, m_sink, 0); + gst_element_link_many(m_source, m_decoder, m_volume, m_sink, 0); +} + +long long GStreamerPlayer::time(GstQueryType type) const +{ + gint64 ns = 0; + GstFormat format = GST_FORMAT_TIME; + gst_element_query(m_sink, type, &format, &ns); + return ns; +} + +// vim: set et sw=4: diff --git a/kttsd/players/gstplayer/gstreamerplayer.h b/kttsd/players/gstplayer/gstreamerplayer.h new file mode 100644 index 0000000..6a7f1d6 --- /dev/null +++ b/kttsd/players/gstplayer/gstreamerplayer.h @@ -0,0 +1,76 @@ +/*************************************************************************** + copyright : (C) 2004 Scott Wheeler + email : wheeler@kde.org +***************************************************************************/ + +/*************************************************************************** + * * + * 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 GSTREAMERPLAYER_H +#define GSTREAMERPLAYER_H + +#include "config.h" + +#include +extern "C" { +#include +} +#include +#include +#include "player.h" + +class GStreamerPlayer : public Player +{ + Q_OBJECT + +public: + GStreamerPlayer(QObject* parent = 0, const char* name = 0, const QStringList& args=QStringList()); + virtual ~GStreamerPlayer(); + + // virtual void play(const FileHandle &file = FileHandle::null()); + virtual void startPlay(const QString& file); + + virtual void setVolume(float volume = 1.0); + virtual float volume() const; + + virtual bool playing() const; + virtual bool paused() const; + + virtual int totalTime() const; + virtual int currentTime() const; + virtual int position() const; // in this case not really the percent + + virtual void seek(int seekTime); + virtual void seekPosition(int position); + + virtual QStringList getPluginList( const QCString& classname ); + virtual void setSinkName(const QString &sinkName); + + virtual bool requireVersion(uint major, uint minor, uint micro); + + void pause(); + void stop(); + +private: + void readConfig(); + void setupPipeline(); + long long time(GstQueryType type) const; + + QString m_sinkName; + // True once gst_init() has been called. + bool m_initialized; + + GstElement *m_pipeline; + GstElement *m_source; + GstElement *m_decoder; + GstElement *m_volume; + GstElement *m_sink; +}; + +#endif diff --git a/kttsd/players/gstplayer/kttsd_gstplugin.desktop b/kttsd/players/gstplayer/kttsd_gstplugin.desktop new file mode 100644 index 0000000..7646cee --- /dev/null +++ b/kttsd/players/gstplayer/kttsd_gstplugin.desktop @@ -0,0 +1,92 @@ +[Desktop Entry] +Name=KTTSD GStreamer Plugin +Name[br]=Lugent KTTSD GStreamer +Name[bs]=KTTSD GStreamer dodatak +Name[ca]=Connector GStreamer pel KTTSD +Name[cs]=KTTSD GStreamer modul +Name[da]=KTTSD GStreamer-plugin +Name[de]=KTTSD GStreamer-Modul +Name[el]=KTTSD πρόσθετο GStreamer +Name[es]=Complemento KTTSD GStreamer +Name[et]=KTTSD GStreameri plugin +Name[eu]=KTTSD-ren GStreamer plugina +Name[fa]=وصلۀ KTTSD GStreamer +Name[fi]=KTTSD GStreamer-liitännäinen +Name[fr]=Module GStreamer pour KTTSD +Name[ga]=Breiseán KTTSD GStreamer +Name[gl]=Plugin GStreamer de KTTSD +Name[hu]=KTTSD GStreamer-modul +Name[is]=KTTSD GStreamer íforrit +Name[it]=Plugin per GStreamer di KTTSD +Name[ja]=KTTSD GStreamer プラグイン +Name[ka]=KTTSD GStreamer მოდული +Name[km]= កម្មវិធី​ជំនួយ GStreamer សម្រាប់ KTTSD +Name[mk]=GStreamer-приклучок за KTTSD +Name[ms]=Plugin KTTSD GStreamer +Name[nb]=GStreamer programtillegg for KTTSD +Name[nds]=GStreamer-Moduul för KTTSD +Name[ne]=KTTSD जि स्ट्रिमर प्लगइन +Name[nl]=KTTSD GStreamer-plugin +Name[pa]=KTTSD ਜੀਸਟਰੀਮਰ ਪਲੱਗਿੰਨ +Name[pl]=Wtyczka GStreamer KTTSD +Name[pt]='Plugin' GStreamer do KTTSD +Name[pt_BR]=Plug-in do GStreamer para o KTTSD +Name[ru]=Модуль GStreamer для KTTSD +Name[sk]=Modul KTTSD GStreamer +Name[sl]=Vstavek KTTSD za GStreamer +Name[sr]=GStreamer као прикључак за KTTSD +Name[sr@Latn]=GStreamer kao priključak za KTTSD +Name[sv]=KTTSD-insticksprogram för Gstreamer +Name[ta]=KTTSD GStreamer சொருகுப்பொருள் +Name[tg]=Модули GStreamer барои KTTSD +Name[tr]=KTTSD GStreamer Eklentisi +Name[uk]=Втулок GStreamer для KTTSD +Name[vi]=Trình bổ sung KTTSD GStreamer +Name[zh_TW]=KTTSd GStreamer 外掛程式 +Comment=KTTSD GStreamer audio plugin +Comment[bg]=Аудио приставка на KTTSD за GStreamer +Comment[br]=Lugent klevet GStreamer evit KTTSD +Comment[ca]=Connector d'àudio GStreamer pel KTTSD +Comment[cs]=KTTSD GStreamer zvukový modul +Comment[da]=KTTSD GStreamer lyd-plugin +Comment[de]=KTTSD GStreamer Audio-Modul +Comment[el]=KTTSD πρόσθετο ήχου GStreamer +Comment[es]=Complemento de audio KTTSD GStreamer +Comment[et]=KTTSD GStreameri audioplugin +Comment[eu]=KTTSD-ren GStreamer audio-plugina +Comment[fa]=وصلۀ صوتی KTTSD GStreamer +Comment[fi]=KTTSD GStreamer ääniliitännäinen +Comment[fr]=Module audio GStreamer pour KTTSD +Comment[ga]=Breiseán fuaime GStreamer KTTSD +Comment[gl]=Plugin de áudio GStreamer para KTTSD +Comment[hu]=KTTSD hangmodul a GStreamerhez +Comment[is]=KTTSD GStreamer hljóð íforrit +Comment[it]=Plugin audio per GStreamer di KTTSD +Comment[ja]=KTTSD GStreamer オーディオプラグイン +Comment[ka]=KTTSD GStreamer აუდიო მოდული +Comment[km]=កម្មវិធី​ជំនួយអូឌីយ៉ូ​ GStreamer សម្រាប់ KTTSD +Comment[mk]=GStreamer-аудиоприклучок за KTTSD +Comment[ms]=Plugin audio KTTSD GStreamer +Comment[nb]=GStreamer lyd-programtillegg for KTTSD +Comment[nds]=GStreamer-Audiomoduul för KTTSD +Comment[ne]=KTTSD जि स्ट्रिमर अडियो प्लगइन +Comment[nl]=KTTSD GStreamer-audioplugin +Comment[pa]=KTTSD ਜੀਸਟਰੀਮਰ ਆਡੀਓ ਪਲੱਗਿੰਨ +Comment[pl]=Wtyczka dźwięku GStreamer dla KTTSD +Comment[pt]='Plugin' áudio GStreamer do KTTSD +Comment[pt_BR]=Plug-in de áudio do GStreamer para o KTTSD +Comment[ru]=Модуль вывода звука KTTSD через GStreamer +Comment[sk]=Modul KTTSD GStreamer audio +Comment[sl]=Vstavek KTTSD za zvok v GStreamer +Comment[sr]=GStreamer као аудио прикључак за KTTSD +Comment[sr@Latn]=GStreamer kao audio priključak za KTTSD +Comment[sv]=KTTSD-ljudinsticksprogram för Gstreamer +Comment[ta]=KTTSD GStreamer கேட்பொலி சொருகுப்பொருள் +Comment[tg]=Модули барориши овози KTTSD ба воситаи GStreamer +Comment[tr]= KTTSD GStreamer ses eklentisi +Comment[uk]=Звуковий втулок GStreamer для KTTSD +Comment[vi]=Trình bổ sung âm thanh KTTSD GStreamer +Comment[zh_TW]=KTTSd GStreamer 語音外掛程式 +Type=Service +ServiceTypes=KTTSD/AudioPlugin +X-KDE-Library=libkttsd_gstplugin diff --git a/kttsd/players/kttsd_audioplugin.desktop b/kttsd/players/kttsd_audioplugin.desktop new file mode 100644 index 0000000..ae39e7c --- /dev/null +++ b/kttsd/players/kttsd_audioplugin.desktop @@ -0,0 +1,47 @@ +[Desktop Entry] +Type=ServiceType +X-KDE-ServiceType=KTTSD/AudioPlugin +Comment=Audio Plugin for KTTSD +Comment[bg]=Аудио приставка на KTTSD +Comment[br]=Lugent klevet evit KTTSD +Comment[ca]=Connector d'àudio pel KTTSD +Comment[cs]=Zvukový modul KTTSD +Comment[da]=Lyd-plugin for KTTSD +Comment[de]=Audio-Modul für KTTSD +Comment[el]=Πρόσθετο ήχου για το KTTSD +Comment[es]=Complemento de audio para KTTSD +Comment[et]=KTTSD audioplugin +Comment[eu]=KTTSD-ren audio plugnka +Comment[fa]=وصلۀ صوتی برای KTTSD +Comment[fi]=Ääniliitännäinen KTTSD-ohjelmalle +Comment[fr]=Module audio pour KTTSD +Comment[ga]=Breiseán fuaime KTTSD +Comment[gl]=Plugin de Áudio para KTTSD +Comment[hu]=Hangmodul a KTTSD szolgáltatáshoz +Comment[is]=Hljóð íforrit fyrir KTTSD +Comment[it]=Plugin audio per KTTSD +Comment[ja]=KTTSD 用オーディオプラグイン +Comment[ka]=აუდიო მოდული KTTSD-თვის +Comment[km]=​កម្មវិធី​ជំនួយ​អូឌីយ៉ូ​សម្រាប់​ KTTSD +Comment[mk]=Аудиоприклучок за KTTSD +Comment[ms]=Plugin Audio bagi KTTSD +Comment[nb]=Lyd-programtillegg for KTTSD +Comment[nds]=Audiomoduul för KTTSD +Comment[ne]=KTTSD का लागि अडियो प्लगइन +Comment[nl]=Audio-plugin voor KTTSD +Comment[pa]=KTTSD ਲਈ ਆਡੀਓ ਪਲੱਗਿੰਨ +Comment[pl]=Wtyczka dźwięku dla KTTSD +Comment[pt]='Plugin' Áudio para o KTTSD +Comment[pt_BR]=Plug-in de áudio para o KTTSD +Comment[ru]=Модуль вывода звука KTTSD +Comment[sk]=Audio modul pre KTTSD +Comment[sl]=Vstavek KTTSD za zvok +Comment[sr]=Аудио прикључак за KTTSD +Comment[sr@Latn]=Audio priključak za KTTSD +Comment[sv]=Ljudinsticksprogram för KTTSD +Comment[ta]= KTTSDக்கான கேட்பொலி சொருகுப்பொருள் +Comment[tg]=Модули барориши овози KTTSD +Comment[tr]=KTTS için Ses Eklentisi +Comment[uk]=Звуковий втулок для KTTSD +Comment[vi]=Trình bổ sung Âm thanh cho KTTSD +Comment[zh_TW]=KTTSd 語音外掛程式 -- cgit v1.2.1