#include <msp/strings/format.h>
#include "client.h"
#include "xinema.h"
-#include "xinestream.h"
using namespace std;
using namespace Msp;
socket->signal_end_of_file.connect(sigc::mem_fun(this, &Client::end_of_stream));
xinema.signal_stream_created.connect(sigc::mem_fun(this, &Client::stream_created));
+ xinema.signal_stream_destroyed.connect(sigc::mem_fun(this, &Client::stream_destroyed));
+ XineStream *stream = xinema.get_stream();
+ if(stream)
+ stream_created(*stream);
}
void Client::data_available()
{
char rbuf[1024];
- unsigned len = socket->read(rbuf, sizeof(rbuf));
+ unsigned len;
+ try
+ {
+ len = socket->read(rbuf, sizeof(rbuf));
+ }
+ catch(const std::exception &)
+ {
+ stale = true;
+ return;
+ }
+
buffer.append(rbuf, len);
string::size_type start = 0;
catch(const exception &e)
{
send_reply(string("error ")+e.what());
- return;
}
start = newline+1;
stale = true;
}
+XineStream &Client::get_stream() const
+{
+ XineStream *stream = xinema.get_stream();
+ if(stream)
+ return *stream;
+
+ throw runtime_error("No stream");
+}
+
+int Client::convert_channel(const string &arg)
+{
+ if(arg=="off")
+ return XineStream::OFF;
+ else
+ return lexical_cast<unsigned>(arg);
+}
+
void Client::process_command(const string &cmd)
{
string::size_type space = cmd.find(' ');
string args;
if(space!=string::npos)
args = cmd.substr(space+1);
+
if(keyword=="list_directory")
list_directory(args);
else if(keyword=="play_file")
xinema.play_file(args);
+ else if(keyword=="play")
+ get_stream().play();
+ else if(keyword=="seek")
+ get_stream().seek(lexical_cast<float>(args)*Time::sec);
+ else if(keyword=="pause")
+ get_stream().pause();
+ else if(keyword=="stop")
+ get_stream().stop();
+ else if(keyword=="select_audio")
+ get_stream().select_audio_channel(convert_channel(args));
+ else if(keyword=="select_spu")
+ get_stream().select_spu_channel(convert_channel(args));
else
- send_reply("error Invalid command");
+ throw runtime_error("Invalid command");
}
void Client::send_reply(const string &reply)
{
- socket->write(reply);
- socket->put('\n');
+ Msp::MutexLock lock(mutex);
+ try
+ {
+ socket->write(reply);
+ socket->put('\n');
+ }
+ catch(const std::exception &)
+ {
+ stale = true;
+ }
}
void Client::list_directory(const FS::Path &dn)
else
send_reply("file "+*i);
}
+
}
void Client::stream_created(XineStream &stream)
{
+ stream.signal_state_changed.connect(sigc::mem_fun(this, &Client::stream_state_changed));
+ stream.signal_title_changed.connect(sigc::mem_fun(this, &Client::stream_title_changed));
stream.signal_duration_changed.connect(sigc::mem_fun(this, &Client::stream_duration_changed));
stream.signal_position_changed.connect(sigc::mem_fun(this, &Client::stream_position_changed));
+ stream.signal_channels_changed.connect(sigc::mem_fun(this, &Client::stream_channels_changed));
+ stream.signal_current_audio_channel_changed.connect(sigc::mem_fun(this, &Client::stream_audio_channel_changed));
+ stream.signal_current_spu_channel_changed.connect(sigc::mem_fun(this, &Client::stream_spu_channel_changed));
+
+ MutexLock lock(stream.get_mutex());
+ stream_state_changed(stream.get_state());
+
string title = stream.get_title();
if(!title.empty())
send_reply("title "+title);
+
+ if(const Time::TimeDelta &dur = stream.get_duration())
+ stream_duration_changed(dur);
+
+ stream_channels_changed();
+ stream_audio_channel_changed(stream.get_current_audio_channel());
+ stream_spu_channel_changed(stream.get_current_spu_channel());
+}
+
+void Client::stream_destroyed()
+{
+ send_reply("ejected");
+}
+
+void Client::stream_state_changed(XineStream::State state)
+{
+ send_reply(format("state %s", state));
+}
+
+void Client::stream_title_changed(const string &title)
+{
+ send_reply("title "+title);
}
void Client::stream_duration_changed(const Time::TimeDelta &dur)
last_position = pos;
}
}
+
+void Client::stream_channels_changed()
+{
+ XineStream &stream = get_stream();
+
+ const vector<string> &audio_channels = stream.get_audio_channels();
+ send_reply(format("audio_count %d", audio_channels.size()));
+ for(unsigned i=0; i<audio_channels.size(); ++i)
+ send_reply(format("audio %d %s", i, audio_channels[i]));
+
+ const vector<string> &spu_channels = stream.get_spu_channels();
+ send_reply(format("spu_count %d", spu_channels.size()));
+ for(unsigned i=0; i<spu_channels.size(); ++i)
+ send_reply(format("spu %d %s", i, spu_channels[i]));
+
+ send_reply("channels_end");
+}
+
+void Client::stream_audio_channel_changed(int chan)
+{
+ if(chan==XineStream::OFF)
+ send_reply("current_audio off");
+ else
+ send_reply(format("current_audio %d", chan));
+}
+
+void Client::stream_spu_channel_changed(int chan)
+{
+ if(chan==XineStream::OFF)
+ send_reply("current_spu off");
+ else
+ send_reply(format("current_spu %d", chan));
+}