You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
527 lines
17 KiB
527 lines
17 KiB
/***************************************************************************
|
|
streaming.cpp - description
|
|
-------------------
|
|
begin : Sun Sept 3 2006
|
|
copyright : (C) 2006 by Martin Witte
|
|
email : witte@kawo1.rwth-aachen.de
|
|
***************************************************************************/
|
|
|
|
/***************************************************************************
|
|
* *
|
|
* This program is free software; you can redistribute it and/or modify *
|
|
* it under the terms of the GNU General Public License as published by *
|
|
* the Free Software Foundation; either version 2 of the License, or *
|
|
* (at your option) any later version. *
|
|
* *
|
|
***************************************************************************/
|
|
|
|
#include "streaming.h"
|
|
|
|
#include "../../src/include/aboutwidget.h"
|
|
#include "../../src/include/utils.h"
|
|
#include <klocale.h>
|
|
#include <kaboutdata.h>
|
|
#include <kurl.h>
|
|
#include <klocale.h>
|
|
|
|
#include "streaming-job.h"
|
|
#include "streaming-configuration.h"
|
|
|
|
///////////////////////////////////////////////////////////////////////
|
|
//// plugin library functions
|
|
|
|
PLUGIN_LIBRARY_FUNCTIONS(StreamingDevice, "kradio-streaming", i18n("Streaming Support"));
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
|
|
|
|
StreamingDevice::StreamingDevice(const TQString &name)
|
|
: TQObject(NULL, NULL),
|
|
PluginBase(name, i18n("KRadio Streaming Plugin"))
|
|
{
|
|
m_CaptureChannels.setAutoDelete(true);
|
|
m_PlaybackChannels.setAutoDelete(true);
|
|
}
|
|
|
|
|
|
StreamingDevice::~StreamingDevice()
|
|
{
|
|
resetPlaybackStreams();
|
|
resetCaptureStreams();
|
|
}
|
|
|
|
|
|
bool StreamingDevice::connectI(Interface *i)
|
|
{
|
|
bool a = PluginBase::connectI(i);
|
|
bool b = ISoundStreamClient::connectI(i);
|
|
return a || b;
|
|
}
|
|
|
|
|
|
bool StreamingDevice::disconnectI(Interface *i)
|
|
{
|
|
bool a = PluginBase::disconnectI(i);
|
|
bool b = ISoundStreamClient::disconnectI(i);
|
|
return a || b;
|
|
}
|
|
|
|
void StreamingDevice::noticeConnectedI (ISoundStreamServer *s, bool pointer_valid)
|
|
{
|
|
ISoundStreamClient::noticeConnectedI(s, pointer_valid);
|
|
if (s && pointer_valid) {
|
|
s->register4_sendReleasePlayback(this);
|
|
s->register4_sendReleaseCapture(this);
|
|
s->register4_sendStartPlayback(this);
|
|
s->register4_sendPausePlayback(this);
|
|
s->register4_sendStopPlayback(this);
|
|
s->register4_queryIsPlaybackRunning(this);
|
|
s->register4_sendStartCaptureWithFormat(this);
|
|
s->register4_sendStopCapture(this);
|
|
s->register4_queryIsCaptureRunning(this);
|
|
s->register4_notifySoundStreamClosed(this);
|
|
s->register4_notifySoundStreamRedirected(this);
|
|
s->register4_notifySoundStreamData(this);
|
|
s->register4_notifyReadyForPlaybackData(this);
|
|
}
|
|
}
|
|
|
|
// PluginBase
|
|
|
|
void StreamingDevice::saveState (KConfig *c) const
|
|
{
|
|
c->setGroup(TQString("streaming-") + PluginBase::name());
|
|
c->writeEntry("soundstreamclient-id", m_SoundStreamClientID);
|
|
|
|
c->writeEntry("playback-channels", m_PlaybackChannelList.size());
|
|
for (unsigned int i = 0; i < m_PlaybackChannelList.size(); ++i) {
|
|
TQString s = m_PlaybackChannelList[i];
|
|
const StreamingJob *j = m_PlaybackChannels[s];
|
|
|
|
const SoundFormat &sf = j->getSoundFormat();
|
|
KURL url = j->getURL();
|
|
size_t buffer_size = j->getBufferSize();
|
|
|
|
sf.saveConfig("playback-channel-" + TQString::number(i), c);
|
|
c->writeEntry("playback-channel-" + TQString::number(i) + "-url", url.url());
|
|
c->writeEntry("playback-channel-" + TQString::number(i) + "-buffer-size", buffer_size);
|
|
}
|
|
|
|
c->writeEntry("capture-channels", m_CaptureChannelList.size());
|
|
for (unsigned int i = 0; i < m_CaptureChannelList.size(); ++i) {
|
|
TQString s = m_CaptureChannelList[i];
|
|
const StreamingJob *j = m_CaptureChannels[s];
|
|
|
|
const SoundFormat &sf = j->getSoundFormat();
|
|
KURL url = j->getURL();
|
|
size_t buffer_size = j->getBufferSize();
|
|
|
|
sf.saveConfig("capture-channel-" + TQString::number(i), c);
|
|
c->writeEntry("capture-channel-" + TQString::number(i) + "-url", url.url());
|
|
c->writeEntry("capture-channel-" + TQString::number(i) + "-buffer-size", buffer_size);
|
|
}
|
|
}
|
|
|
|
void StreamingDevice::restoreState (KConfig *c)
|
|
{
|
|
c->setGroup(TQString("streaming-") + PluginBase::name());
|
|
setSoundStreamClientID(c->readEntry("soundstreamclient-id", getSoundStreamClientID()));
|
|
|
|
resetPlaybackStreams(false);
|
|
resetCaptureStreams(false);
|
|
|
|
int n = c->readNumEntry("playback-channels", 0);
|
|
for (int i = 0; i < n; ++i) {
|
|
SoundFormat sf;
|
|
sf.restoreConfig("playback-channel-" + TQString::number(i), c);
|
|
TQString url = c->readEntry("playback-channel-" + TQString::number(i) + "-url", TQString());
|
|
size_t buffer_size = c->readNum64Entry("playback-channel-" + TQString::number(i) + "-buffer-size", 32*1024);
|
|
|
|
if (!url.isNull()) {
|
|
addPlaybackStream(url, sf, buffer_size, i == n-1);
|
|
}
|
|
}
|
|
|
|
n = c->readNumEntry("capture-channels", 0);
|
|
for (int i = 0; i < n; ++i) {
|
|
SoundFormat sf;
|
|
sf.restoreConfig("capture-channel-" + TQString::number(i), c);
|
|
TQString url = c->readEntry("capture-channel-" + TQString::number(i) + "-url", TQString());
|
|
size_t buffer_size = c->readNum64Entry("capture-channel-" + TQString::number(i) + "-buffer-size", 32*1024);
|
|
|
|
if (!url.isNull()) {
|
|
addCaptureStream(url, sf, buffer_size, i == n-1);
|
|
}
|
|
}
|
|
|
|
if (!m_CaptureChannelList.size()) {
|
|
addCaptureStream("/dev/video24", SoundFormat(48000, 2, 16, true, BYTE_ORDER, "raw"), 65536);
|
|
}
|
|
|
|
emit sigUpdateConfig();
|
|
}
|
|
|
|
|
|
ConfigPageInfo StreamingDevice::createConfigurationPage()
|
|
{
|
|
StreamingConfiguration *conf = new StreamingConfiguration(NULL, this);
|
|
TQObject::connect(this, TQT_SIGNAL(sigUpdateConfig()), conf, TQT_SLOT(slotUpdateConfig()));
|
|
return ConfigPageInfo (conf,
|
|
i18n("Streaming"),
|
|
i18n("Streaming Device Options"),
|
|
"kradio_streaming");
|
|
}
|
|
|
|
|
|
AboutPageInfo StreamingDevice::createAboutPage()
|
|
{
|
|
return AboutPageInfo();
|
|
}
|
|
|
|
|
|
|
|
bool StreamingDevice::preparePlayback(SoundStreamID id, const TQString &channel, bool /*active_mode*/, bool start_immediately)
|
|
{
|
|
if (id.isValid() && m_PlaybackChannels.find(channel)) {
|
|
m_AllPlaybackStreams.insert(id, channel);
|
|
if (start_immediately)
|
|
startPlayback(id);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
bool StreamingDevice::prepareCapture(SoundStreamID id, const TQString &channel)
|
|
{
|
|
logDebug("StreamingDevice::prepareCapture");
|
|
if (id.isValid() && m_CaptureChannels.find(channel)) {
|
|
m_AllCaptureStreams.insert(id, channel);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool StreamingDevice::releasePlayback(SoundStreamID id)
|
|
{
|
|
if (id.isValid() && m_AllPlaybackStreams.contains(id)) {
|
|
stopPlayback(id);
|
|
if (!m_EnabledPlaybackStreams.contains(id))
|
|
m_AllPlaybackStreams.remove(id);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool StreamingDevice::releaseCapture(SoundStreamID id)
|
|
{
|
|
logDebug("StreamingDevice::releaseCapture");
|
|
if (id.isValid() && m_AllCaptureStreams.contains(id)) {
|
|
stopCapture(id);
|
|
if (!m_EnabledCaptureStreams.contains(id))
|
|
m_AllCaptureStreams.remove(id);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool StreamingDevice::supportsPlayback() const
|
|
{
|
|
return m_PlaybackChannels.size() > 0;
|
|
}
|
|
|
|
|
|
bool StreamingDevice::supportsCapture() const
|
|
{
|
|
return m_CaptureChannels.size() > 0;
|
|
}
|
|
|
|
|
|
bool StreamingDevice::startPlayback(SoundStreamID id)
|
|
{
|
|
if (id.isValid() && m_AllPlaybackStreams.contains(id)) {
|
|
m_EnabledPlaybackStreams.insert(id, m_AllPlaybackStreams[id]);
|
|
StreamingJob &x = *m_PlaybackChannels.find(m_AllPlaybackStreams[id]);
|
|
x.startPlayback();
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
bool StreamingDevice::pausePlayback(SoundStreamID /*id*/)
|
|
{
|
|
//return stopPlayback(id);
|
|
return false;
|
|
}
|
|
|
|
|
|
bool StreamingDevice::stopPlayback(SoundStreamID id)
|
|
{
|
|
if (id.isValid() && m_EnabledPlaybackStreams.contains(id)) {
|
|
StreamingJob &x = *m_PlaybackChannels.find(m_AllPlaybackStreams[id]);
|
|
if (x.stopPlayback()) {
|
|
m_EnabledPlaybackStreams.remove(id);
|
|
}
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
bool StreamingDevice::isPlaybackRunning(SoundStreamID id, bool &b) const
|
|
{
|
|
if (id.isValid() && m_EnabledPlaybackStreams.contains(id)) {
|
|
b = true;
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool StreamingDevice::startCaptureWithFormat(SoundStreamID id,
|
|
const SoundFormat &proposed_format,
|
|
SoundFormat &real_format,
|
|
bool force_format)
|
|
{
|
|
logDebug("StreamingDevice::startCaptureWithFormat");
|
|
if (id.isValid() && m_AllCaptureStreams.contains(id)) {
|
|
m_EnabledCaptureStreams.insert(id, m_AllCaptureStreams[id]);
|
|
StreamingJob &x = *m_CaptureChannels.find(m_AllCaptureStreams[id]);
|
|
x.startCapture(proposed_format, real_format, force_format);
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
bool StreamingDevice::stopCapture(SoundStreamID id)
|
|
{
|
|
if (id.isValid() && m_EnabledCaptureStreams.contains(id)) {
|
|
StreamingJob &x = *m_CaptureChannels.find(m_AllCaptureStreams[id]);
|
|
if (x.stopCapture()) {
|
|
m_EnabledCaptureStreams.remove(id);
|
|
}
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
bool StreamingDevice::isCaptureRunning(SoundStreamID id, bool &b, SoundFormat &sf) const
|
|
{
|
|
if (id.isValid() && m_EnabledCaptureStreams.contains(id)) {
|
|
StreamingJob &x = *m_CaptureChannels.find(m_AllCaptureStreams[id]);
|
|
sf = x.getSoundFormat();
|
|
b = true;
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
bool StreamingDevice::noticeSoundStreamClosed(SoundStreamID id)
|
|
{
|
|
bool found = (stopCapture(id) && releaseCapture(id)) ||
|
|
(stopPlayback(id) && releasePlayback(id));
|
|
return found;
|
|
}
|
|
|
|
|
|
bool StreamingDevice::noticeSoundStreamRedirected(SoundStreamID oldID, SoundStreamID newID)
|
|
{
|
|
bool found = false;
|
|
if (newID != oldID) {
|
|
if (m_AllPlaybackStreams.contains(oldID)) {
|
|
m_AllPlaybackStreams.insert(newID, m_AllPlaybackStreams[oldID]);
|
|
m_AllPlaybackStreams.remove(oldID);
|
|
found = true;
|
|
}
|
|
if (m_EnabledPlaybackStreams.contains(oldID)) {
|
|
m_EnabledPlaybackStreams.insert(newID, m_EnabledPlaybackStreams[oldID]);
|
|
m_EnabledPlaybackStreams.remove(oldID);
|
|
found = true;
|
|
}
|
|
if (m_AllCaptureStreams.contains(oldID)) {
|
|
m_AllCaptureStreams.insert(newID, m_AllCaptureStreams[oldID]);
|
|
m_AllCaptureStreams.remove(oldID);
|
|
found = true;
|
|
}
|
|
if (m_EnabledCaptureStreams.contains(oldID)) {
|
|
m_EnabledCaptureStreams.insert(newID, m_EnabledCaptureStreams[oldID]);
|
|
m_EnabledCaptureStreams.remove(oldID);
|
|
found = true;
|
|
}
|
|
}
|
|
return found;
|
|
}
|
|
|
|
|
|
bool StreamingDevice::noticeSoundStreamData(SoundStreamID id,
|
|
const SoundFormat &/*format*/,
|
|
const char *data, size_t size, size_t &consumed_size,
|
|
const SoundMetaData &/*md*/
|
|
)
|
|
{
|
|
if (id.isValid() && m_EnabledPlaybackStreams.contains(id)) {
|
|
StreamingJob &x = *m_CaptureChannels.find(m_AllCaptureStreams[id]);
|
|
x.playData(data, size, consumed_size);
|
|
return true;
|
|
}
|
|
else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool StreamingDevice::noticeReadyForPlaybackData(SoundStreamID id, size_t free_size)
|
|
{
|
|
if (!id.isValid() || !m_AllCaptureStreams.contains(id))
|
|
return false;
|
|
StreamingJob &x = *m_CaptureChannels.find(m_AllCaptureStreams[id]);
|
|
|
|
while (x.hasRecordedData() && free_size > 0) {
|
|
const char *buffer = NULL;
|
|
size_t size = SIZE_T_DONT_CARE;
|
|
size_t consumed_size = SIZE_T_DONT_CARE;
|
|
SoundMetaData meta_data(0,0,0, i18n("internal stream, not stored (%1)").arg(m_AllCaptureStreams[id]));
|
|
x.lockData(buffer, size, meta_data); // get pointer to data and meta-data content
|
|
if (size > free_size)
|
|
size = free_size;
|
|
notifySoundStreamData(id, x.getSoundFormat(), buffer, size, consumed_size, meta_data);
|
|
if (consumed_size == SIZE_T_DONT_CARE)
|
|
consumed_size = size;
|
|
x.removeData(consumed_size);
|
|
free_size -= consumed_size;
|
|
if (consumed_size < size) {
|
|
logWarning(i18n("StreamingDevice %1::notifySoundStreamData: Playback Clients skipped %2 bytes").arg(name()).arg(size-consumed_size));
|
|
break;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
const TQStringList &StreamingDevice::getPlaybackChannels() const
|
|
{
|
|
return m_PlaybackChannelList;
|
|
}
|
|
|
|
|
|
const TQStringList &StreamingDevice::getCaptureChannels() const
|
|
{
|
|
return m_CaptureChannelList;
|
|
}
|
|
|
|
|
|
TQString StreamingDevice::getSoundStreamClientDescription() const
|
|
{
|
|
return i18n("Streaming Device %1").arg(PluginBase::name());
|
|
}
|
|
|
|
|
|
void StreamingDevice::logStreamError(const KURL &url, const TQString &s)
|
|
{
|
|
logError(i18n("Streaming Device %1, %2: %3").arg(name()).arg(url.url()).arg(s));
|
|
}
|
|
|
|
void StreamingDevice::logStreamWarning(const KURL &url, const TQString &s)
|
|
{
|
|
logWarning(i18n("Streaming Device %1, %2: %3").arg(name()).arg(url.url()).arg(s));
|
|
}
|
|
|
|
|
|
bool StreamingDevice::getPlaybackStreamOptions(const TQString &channel, TQString &url, SoundFormat &sf, size_t &buffer_size) const
|
|
{
|
|
if (m_PlaybackChannels.find(channel)) {
|
|
const StreamingJob *j = m_PlaybackChannels[channel];
|
|
url = j->getURL();
|
|
sf = j->getSoundFormat();
|
|
buffer_size = j->getBufferSize();
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
bool StreamingDevice::getCaptureStreamOptions(const TQString &channel, TQString &url, SoundFormat &sf, size_t &buffer_size) const
|
|
{
|
|
if (m_CaptureChannels.find(channel)) {
|
|
const StreamingJob *j = m_CaptureChannels[channel];
|
|
url = j->getURL();
|
|
sf = j->getSoundFormat();
|
|
buffer_size = j->getBufferSize();
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void StreamingDevice::resetPlaybackStreams(bool notification_enabled)
|
|
{
|
|
while (m_EnabledPlaybackStreams.begin() != m_EnabledPlaybackStreams.end()) {
|
|
sendStopPlayback(m_EnabledPlaybackStreams.begin().key());
|
|
}
|
|
while (m_AllPlaybackStreams.begin() != m_AllPlaybackStreams.end()) {
|
|
releasePlayback(m_AllPlaybackStreams.begin().key());
|
|
}
|
|
m_PlaybackChannelList.clear();
|
|
m_PlaybackChannels.clear();
|
|
if (notification_enabled) {
|
|
notifyPlaybackChannelsChanged(m_SoundStreamClientID, m_PlaybackChannelList);
|
|
}
|
|
}
|
|
|
|
|
|
void StreamingDevice::resetCaptureStreams(bool notification_enabled)
|
|
{
|
|
while (m_EnabledCaptureStreams.begin() != m_EnabledCaptureStreams.end()) {
|
|
sendStopCapture(m_EnabledCaptureStreams.begin().key());
|
|
}
|
|
while (m_AllCaptureStreams.begin() != m_AllCaptureStreams.end()) {
|
|
releaseCapture(m_AllCaptureStreams.begin().key());
|
|
}
|
|
m_CaptureChannelList.clear();
|
|
m_CaptureChannels.clear();
|
|
if (notification_enabled) {
|
|
notifyCaptureChannelsChanged(m_SoundStreamClientID, m_CaptureChannelList);
|
|
}
|
|
}
|
|
|
|
|
|
void StreamingDevice::addPlaybackStream(const TQString &url, const SoundFormat &sf, size_t buffer_size, bool notification_enabled)
|
|
{
|
|
StreamingJob *x = new StreamingJob(url, sf, buffer_size);
|
|
connect(x, TQT_SIGNAL(logStreamError(const KURL &, const TQString &)),
|
|
this, TQT_SLOT (logStreamError(const KURL &, const TQString &)));
|
|
|
|
m_PlaybackChannelList.append(url);
|
|
m_PlaybackChannels.insert(url, x);
|
|
if (notification_enabled) {
|
|
notifyPlaybackChannelsChanged(m_SoundStreamClientID, m_PlaybackChannelList);
|
|
}
|
|
}
|
|
|
|
|
|
void StreamingDevice::addCaptureStream (const TQString &url, const SoundFormat &sf, size_t buffer_size, bool notification_enabled)
|
|
{
|
|
StreamingJob *x = new StreamingJob(url, sf, buffer_size);
|
|
connect(x, TQT_SIGNAL(logStreamError(const KURL &, const TQString &)),
|
|
this, TQT_SLOT (logStreamError(const KURL &, const TQString &)));
|
|
|
|
m_CaptureChannelList.append(url);
|
|
m_CaptureChannels.insert(url, x);
|
|
if (notification_enabled) {
|
|
notifyCaptureChannelsChanged(m_SoundStreamClientID, m_CaptureChannelList);
|
|
}
|
|
}
|
|
|
|
|
|
#include "streaming.moc"
|