Funkwhale/strawberry-audio-player-windows-mac-linux
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
strawberry-audio-player-win.../src/engine/xineengine.cpp

1049 lines
30 KiB
C++
Raw Blame History

/***************************************************************************
* Copyright (C) 2017-2018 Jonas Kvinge <jonas@jkvinge.net> *
* Copyright (C) 2005 Christophe Thommeret <hftom@free.fr> *
* (C) 2005 Ian Monroe <ian@monroe.nu> *
* (C) 2005-2006 Mark Kretschmann <markey@web.de> *
* (C) 2004-2005 Max Howell <max.howell@methylblue.com> *
* (C) 2003-2004 J. Kofler <kaffeine@gmx.net> *
* *
* 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 "config.h"
#include <stdbool.h>
#include <stdint.h>
#include <sys/types.h>
#include <time.h>
#include <unistd.h>
#include <xine.h>
#include <memory>
#include <cstdlib>
#include <algorithm>
#include <climits>
#include <vector>
#include <QtGlobal>
#include <QApplication>
#include <QThread>
#include <QMutex>
#include <QByteArray>
#include <QChar>
#include <QDir>
#include <QFile>
#include <QFileInfo>
#include <QDateTime>
#include <QLocale>
#include <QVariant>
#include <QString>
#include <QStringBuilder>
#include <QStringList>
#include <QUrl>
#include <QTimer>
#include <QtDebug>
#include <QSettings>
#include "core/logging.h"
#include <core/timeconstants.h>
#include "engine_fwd.h"
#include "enginebase.h"
#include "enginetype.h"
#include "xineengine.h"
#include "xinescope.h"
#include "settings/backendsettingspage.h"
using std::shared_ptr;
#ifndef LLONG_MAX
#define LLONG_MAX 9223372036854775807LL
#endif
// Define this to use xine in a more standard way
//#define XINE_SAFE_MODE
const char *XineEngine::kAutoOutput = "auto";
int XineEngine::last_error_ = XINE_MSG_NO_ERROR;
time_t XineEngine::last_error_time_ = 0; // Hysteresis on xine errors
XineEngine::XineEngine(TaskManager *task_manager)
: EngineBase(),
xine_(nullptr),
stream_(nullptr),
audioport_(nullptr),
eventqueue_(nullptr),
post_(nullptr),
preamp_(1.0),
prune_(nullptr) {
type_ = Engine::Xine;
ReloadSettings();
}
XineEngine::~XineEngine() {
Cleanup();
}
bool XineEngine::Init() {
Cleanup();
SetEnvironment();
QMutexLocker l(&init_mutex_);
xine_ = xine_new();
if (!xine_) {
emit Error("Could not initialize xine.");
return false;
}
#ifdef XINE_SAFE_MODE
xine_engine_set_param(xine_, XINE_ENGINE_PARAM_VERBOSITY, 99);
#endif
xine_init(xine_);
#ifndef XINE_SAFE_MODE
prune_.reset(new PruneScopeThread(this));
prune_->start();
#endif
SetDevice();
if (!ValidOutput(output_)) {
qLog(Error) << "Invalid output detected:" << output_ << " - Resetting to default.";
output_ = DefaultOutput();
}
audioport_ = xine_open_audio_driver(xine_, (output_.isEmpty() || output_ == kAutoOutput ? nullptr : output_.toUtf8().constData()), nullptr);
if (!audioport_) {
emit Error("Xine was unable to initialize any audio drivers.");
return false;
}
return true;
}
void XineEngine::Cleanup() {
// Wait until the prune scope thread is done
if (prune_) {
prune_->exit();
prune_->wait();
}
prune_.reset();
if (stream_)
xine_close(stream_);
if (eventqueue_) {
xine_event_dispose_queue(eventqueue_);
eventqueue_ = nullptr;
}
if (stream_) {
xine_dispose(stream_);
stream_ = nullptr;
}
if (audioport_) {
xine_close_audio_driver(xine_, audioport_);
audioport_ = nullptr;
}
if (post_) {
xine_post_dispose(xine_, post_);
post_ = nullptr;
}
if (xine_) xine_exit(xine_);
xine_ = nullptr;
//qLog(Debug) << "xine closed";
//qLog(Debug) << "Scope statistics:";
//qLog(Debug) << "Average list size: " << log_buffer_count_ / log_scope_call_count_;
//qLog(Debug) << "Buffer failure: " << double(log_no_suitable_buffer_*100) / log_scope_call_count_ << "%";
}
Engine::State XineEngine::state() const {
if (!stream_) return Engine::Empty;
switch(xine_get_status(stream_)) {
case XINE_STATUS_PLAY:
return xine_get_param(stream_, XINE_PARAM_SPEED) != XINE_SPEED_PAUSE ? Engine::Playing : Engine::Paused;
case XINE_STATUS_IDLE:
return Engine::Empty;
case XINE_STATUS_STOP:
default:
return url_.isEmpty() ? Engine::Empty : Engine::Idle;
}
}
bool XineEngine::Load(const QUrl &url, Engine::TrackChangeFlags change, bool force_stop_at_end, quint64 beginning_nanosec, qint64 end_nanosec) {
if (!EnsureStream()) return false;
Engine::Base::Load(url, change, force_stop_at_end, beginning_nanosec, end_nanosec);
xine_close(stream_);
//int result = xine_open(stream_, url.path().toUtf8());
int result = xine_open(stream_, url.toString().toUtf8());
if (result) {
#ifndef XINE_SAFE_MODE
xine_post_out_t *source = xine_get_audio_source(stream_);
xine_post_in_t *target = (xine_post_in_t*)xine_post_input(post_, const_cast<char*>("audio in"));
xine_post_wire(source, target);
#endif
return true;
}
else {
qLog(Error) << "Failed to play";
}
DetermineAndShowErrorMessage();
return false;
}
bool XineEngine::Play(quint64 offset_nanosec) {
if (!EnsureStream()) return false;
int offset = (offset_nanosec / kNsecPerMsec);
const bool has_audio = xine_get_stream_info(stream_, XINE_STREAM_INFO_HAS_AUDIO);
const bool audio_handled = xine_get_stream_info(stream_, XINE_STREAM_INFO_AUDIO_HANDLED);
if (has_audio && audio_handled && xine_play(stream_, 0, offset)) {
emit StateChanged(Engine::Playing);
return true;
}
emit StateChanged(Engine::Empty);
DetermineAndShowErrorMessage();
xine_close(stream_);
return false;
}
void XineEngine::Stop(bool stop_after) {
if (!stream_) return;
xine_stop(stream_);
xine_close(stream_);
xine_set_param(stream_, XINE_PARAM_AUDIO_CLOSE_DEVICE, 1);
emit StateChanged(Engine::Empty);
}
void XineEngine::Pause() {
if (!stream_) return;
if (xine_get_param(stream_, XINE_PARAM_SPEED) != XINE_SPEED_PAUSE) {
xine_set_param(stream_, XINE_PARAM_SPEED, XINE_SPEED_PAUSE);
xine_set_param(stream_, XINE_PARAM_AUDIO_CLOSE_DEVICE, 1);
emit StateChanged(Engine::Paused);
}
}
void XineEngine::Unpause() {
if (!stream_) return;
if (xine_get_param(stream_, XINE_PARAM_SPEED) == XINE_SPEED_PAUSE) {
xine_set_param(stream_, XINE_PARAM_SPEED, XINE_SPEED_NORMAL);
emit StateChanged(Engine::Playing);
}
}
void XineEngine::Seek(quint64 offset_nanosec) {
if (!EnsureStream()) return;
int offset = (offset_nanosec / kNsecPerMsec);
if (xine_get_param(stream_, XINE_PARAM_SPEED) == XINE_SPEED_PAUSE) {
xine_play(stream_, 0, offset);
xine_set_param(stream_, XINE_PARAM_SPEED, XINE_SPEED_PAUSE);
}
else xine_play(stream_, 0, offset);
}
void XineEngine::SetVolumeSW(uint vol) {
if (!stream_) return;
xine_set_param(stream_, XINE_PARAM_AUDIO_AMP_LEVEL, static_cast<uint>(vol * preamp_));
}
qint64 XineEngine::position_nanosec() const {
if (state() == Engine::Empty) return 0;
const qint64 result = (position() * kNsecPerMsec);
return qint64(qMax(0ll, result));
}
qint64 XineEngine::length_nanosec() const {
if (state() == Engine::Empty) return 0;
const qint64 result = end_nanosec_ - beginning_nanosec_;
if (result > 0) {
return result;
}
else {
// Get the length from the pipeline if we don't know.
return (length() * kNsecPerMsec);
}
}
EngineBase::OutputDetailsList XineEngine::GetOutputsList() const {
OutputDetailsList ret;
PluginDetailsList plugins = GetPluginList();
for (const PluginDetails &plugin : plugins) {
OutputDetails output;
output.name = plugin.name;
output.description = plugin.description;
if (plugin.name == "auto") output.iconname = "soundcard";
else if ((plugin.name == "alsa")||(plugin.name == "oss")) output.iconname = "alsa";
else if (plugin.name== "jack") output.iconname = "jack";
else if (plugin.name == "pulseaudio") output.iconname = "pulseaudio";
else if (plugin.name == "bluetooth") output.iconname = "bluetooth";
else if (plugin.name == "file") output.iconname = "document-new";
else output.iconname = "soundcard";
ret.append(output);
}
return ret;
}
bool XineEngine::ValidOutput(const QString &output) {
PluginDetailsList plugins = GetPluginList();
for (const PluginDetails &plugin : plugins) {
if (plugin.name == output) return(true);
}
return(false);
}
bool XineEngine::CustomDeviceSupport(const QString &output) {
return (output == "alsa" || output == "oss" || output == "jack" || output == "pulseaudio");
}
void XineEngine::ReloadSettings() {
Engine::Base::ReloadSettings();
if (output_ == "") output_ = DefaultOutput();
}
void XineEngine::SetEnvironment() {
#ifdef Q_OS_WIN
putenv(QString("XINE_PLUGIN_PATH=" + QCoreApplication::applicationDirPath() + "/xine-plugins").toLatin1().constData());
#endif
#ifdef Q_OS_MACOS
setenv("XINE_PLUGIN_PATH", QString(QCoreApplication::applicationDirPath() + "/../PlugIns/xine").toLatin1().constData(), 1);
#endif
}
uint XineEngine::length() const {
if (!stream_) return 0;
// Xine often delivers nonsense values for VBR files and such, so we only use the length for remote files
if (url_.scheme().toLower() == "file") return 0;
else {
int pos = 0, time = 0, length = 0;
xine_get_pos_length(stream_, &pos, &time, &length);
if (length < 0) length=0;
return length;
}
}
uint XineEngine::position() const {
if (state() == Engine::Empty) return 0;
int pos = 0, time = 0, length = 0;
// Workaround for problems when you seek too quickly, see BUG 99808
int tmp = 0, i = 0;
while (++i < 4) {
xine_get_pos_length(stream_, &pos, &time, &length);
if (time > tmp) break;
usleep(100000);
}
// Here we check for new metadata periodically, because xine does not emit an event in all cases (e.g. with ogg streams). See BUG 122505
if (state() != Engine::Idle && state() != Engine::Empty) {
const Engine::SimpleMetaBundle bundle = fetchMetaData();
if (bundle.title != current_bundle_.title || bundle.artist != current_bundle_.artist) {
qLog(Debug) << "Metadata received.";
current_bundle_ = bundle;
XineEngine *p = const_cast<XineEngine*>(this);
p->emit MetaData(bundle);
}
}
return time;
}
bool XineEngine::CanDecode(const QUrl &url) {
static QStringList list;
if (list.isEmpty()) {
QMutexLocker l(&const_cast<XineEngine*>(this)->init_mutex_);
if (list.isEmpty()) {
char* exts = xine_get_file_extensions(xine_);
list = QString(exts).split(' ');
free(exts);
exts = nullptr;
// Images
list.removeAll("png");
list.removeAll("jpg");
list.removeAll("jpeg");
list.removeAll("gif");
list.removeAll("ilbm");
list.removeAll("iff");
// Subtitles
list.removeAll("asc");
list.removeAll("txt");
list.removeAll("sub");
list.removeAll("srt");
list.removeAll("smi");
list.removeAll("ssa");
// HACK: we also check for m4a because xine plays them but for some reason doesn't return the extension
if (!list.contains("m4a"))
list << "m4a";
}
}
if (url.scheme() == "cdda") return true;
QString path = url.path();
// Partial downloads from Konqi and other browsers tend to have a .part extension
if (path.endsWith(".part")) path = path.left(path.length() - 5);
const QString ext = path.mid(path.lastIndexOf('.') + 1).toLower();
return list.contains(ext);
}
bool XineEngine::MetaDataForUrl(const QUrl &url, Engine::SimpleMetaBundle &b) {
bool result = false;
xine_stream_t *tmpstream = xine_stream_new(xine_, nullptr, nullptr);
if (xine_open(tmpstream, QFile::encodeName(url.toString()))) {
QString audioCodec = QString::fromUtf8(xine_get_meta_info(tmpstream, XINE_META_INFO_SYSTEMLAYER));
if (audioCodec == "CDDA") {
QString title = QString::fromUtf8(xine_get_meta_info(tmpstream, XINE_META_INFO_TITLE));
if ((!title.isNull()) && (!title.isEmpty())) { //no meta info
b.title = title;
b.artist = QString::fromUtf8(xine_get_meta_info(tmpstream, XINE_META_INFO_ARTIST));
b.album = QString::fromUtf8(xine_get_meta_info(tmpstream, XINE_META_INFO_ALBUM));
b.genre = QString::fromUtf8(xine_get_meta_info(tmpstream, XINE_META_INFO_GENRE));
b.year = QString::fromUtf8(xine_get_meta_info(tmpstream, XINE_META_INFO_YEAR));
b.tracknr = QString::fromUtf8(xine_get_meta_info(tmpstream, XINE_META_INFO_TRACK_NUMBER));
if (b.tracknr.isEmpty())
b.tracknr = QFileInfo(url.path()).fileName();
}
else {
b.title = QString("Track %1").arg(QFileInfo(url.path()).fileName());
b.album = "AudioCD";
}
}
if (audioCodec == "CDDA" || audioCodec == "WAV") {
result = true;
int samplerate = xine_get_stream_info(tmpstream, XINE_STREAM_INFO_AUDIO_SAMPLERATE);
// Xine would provide a XINE_STREAM_INFO_AUDIO_BITRATE, but unfortunately not for CDDA or WAV so we calculate the bitrate by our own
int bitsPerSample = xine_get_stream_info(tmpstream, XINE_STREAM_INFO_AUDIO_BITS);
int nbrChannels = xine_get_stream_info(tmpstream, XINE_STREAM_INFO_AUDIO_CHANNELS);
int bitrate = (samplerate * bitsPerSample * nbrChannels) / 1000;
b.bitrate = QString::number(bitrate);
b.samplerate = QString::number(samplerate);
int pos, time, length = 0;
xine_get_pos_length(tmpstream, &pos, &time, &length);
b.length = QString::number(length / 1000);
}
xine_close(tmpstream);
}
xine_dispose(tmpstream);
return result;
}
bool XineEngine::GetAudioCDContents(const QString &device, QList<QUrl> &urls) {
const char * const *xine_urls = nullptr;
int num;
int i = 0;
if (!device.isNull()) {
qLog(Debug) << "xine-engine setting CD Device to: " << device;
xine_cfg_entry_t config;
if (!xine_config_lookup_entry(xine_, "input.cdda_device", &config)) {
emit StatusText("Failed CD device lookup in xine engine");
return false;
}
config.str_value = (char *)device.toLatin1().constData();
xine_config_update_entry(xine_, &config);
}
emit StatusText("Getting AudioCD contents...");
xine_urls = xine_get_autoplay_mrls(xine_, "CD", &num);
if (xine_urls) {
while (xine_urls[i]) {
urls << QUrl(xine_urls[i]);
++i;
}
}
else emit StatusText("Could not read AudioCD");
return true;
}
bool XineEngine::FlushBuffer() {
return false;
}
void XineEngine::SetEqualizerEnabled(bool enabled) {
if (!stream_) return;
equalizer_enabled_ = enabled;
if (!enabled) {
QList<int> gains;
for (uint x = 0; x < 10; x++)
gains << -101; // sets eq gains to zero.
SetEqualizerParameters(0, gains);
}
}
/*
Sets the eq params for xine engine - have to rescale eq params to fitting range (adapted from kaffeine and xfmedia)
preamp:
pre: (-100..100)
post: (0.1..1.9) - this is not really a preamp but we use the xine preamp parameter for our normal volume. so we make a postamp.
gains:
pre: (-100..100)
post: (1..200) - (1 = down, 100 = middle, 200 = up, 0 = off)
*/
void XineEngine::SetEqualizerParameters(int preamp, const QList<int> &gains) {
if (!stream_) return;
equalizer_gains_ = gains;
int_preamp_ = preamp;
QList<int>::ConstIterator it = gains.begin();
xine_set_param(stream_, XINE_PARAM_EQ_30HZ, int((*it)*0.995 + 100));
xine_set_param(stream_, XINE_PARAM_EQ_60HZ, int((*++it)*0.995 + 100));
xine_set_param(stream_, XINE_PARAM_EQ_125HZ, int((*++it)*0.995 + 100));
xine_set_param(stream_, XINE_PARAM_EQ_250HZ, int((*++it)*0.995 + 100));
xine_set_param(stream_, XINE_PARAM_EQ_500HZ, int((*++it)*0.995 + 100));
xine_set_param(stream_, XINE_PARAM_EQ_1000HZ, int((*++it)*0.995 + 100));
xine_set_param(stream_, XINE_PARAM_EQ_2000HZ, int((*++it)*0.995 + 100));
xine_set_param(stream_, XINE_PARAM_EQ_4000HZ, int((*++it)*0.995 + 100));
xine_set_param(stream_, XINE_PARAM_EQ_8000HZ, int((*++it)*0.995 + 100));
xine_set_param(stream_, XINE_PARAM_EQ_16000HZ, int((*++it)*0.995 + 100));
preamp_ = (preamp - 0.1 * preamp + 100) / 100.0;
SetVolume(volume_);
}
void XineEngine::XineEventListener(void *p, const xine_event_t *xineEvent) {
time_t current;
if (!p) return;
#define xe static_cast<XineEngine*>(p)
switch(xineEvent->type) {
case XINE_EVENT_UI_SET_TITLE:
qLog(Debug) << "XINE_EVENT_UI_SET_TITLE";
QApplication::postEvent(xe, new XineEvent(XineEvent::MetaInfoChanged));
break;
case XINE_EVENT_UI_PLAYBACK_FINISHED:
qLog(Debug) << "XINE_EVENT_UI_PLAYBACK_FINISHED";
//emit signal from GUI thread
QApplication::postEvent(xe, new XineEvent(XineEvent::PlaybackFinished));
break;
case XINE_EVENT_PROGRESS: {
xine_progress_data_t* pd = (xine_progress_data_t*)xineEvent->data;
QString msg = "%1 %2%";
msg = msg.arg(QString::fromUtf8(pd->description)).arg(QString::number(pd->percent) + QLocale::system().percent());
XineEvent *e = new XineEvent(XineEvent::StatusMessage);
e->setData(new QString(msg));
QApplication::postEvent(xe, e);
}
break;
case XINE_EVENT_MRL_REFERENCE_EXT: {
// xine has read the stream and found it actually links to something else so we need to play that instead
QString message = QString::fromUtf8(static_cast<xine_mrl_reference_data_ext_t*>(xineEvent->data)->mrl);
XineEvent *e = new XineEvent(XineEvent::Redirecting);
e->setData(new QString(message));
QApplication::postEvent(xe, e);
}
break;
case XINE_EVENT_UI_MESSAGE: {
qLog(Debug) << "message received from xine";
xine_ui_message_data_t *data = (xine_ui_message_data_t *)xineEvent->data;
QString message;
switch (data->type) {
case XINE_MSG_NO_ERROR: {
//series of \0 separated strings, terminated with a \0\0
char str[2000];
char *p = str;
for (char *msg = data->messages; !(*msg == '\0' && *(msg+1) == '\0'); ++msg, ++p)
*p = *msg == '\0' ? '\n' : *msg;
*p = '\0';
qLog(Debug) << str;
break;
}
case XINE_MSG_ENCRYPTED_SOURCE:
break;
case XINE_MSG_UNKNOWN_HOST:
message = "The host is unknown for the URL: <i>%1</i>"; goto param;
case XINE_MSG_UNKNOWN_DEVICE:
message = "The device name you specified seems invalid."; goto param;
case XINE_MSG_NETWORK_UNREACHABLE:
message = "The network appears unreachable."; goto param;
case XINE_MSG_AUDIO_OUT_UNAVAILABLE:
message = "Audio output unavailable; the device is busy."; goto param;
case XINE_MSG_CONNECTION_REFUSED:
message = "The connection was refused for the URL: <i>%1</i>"; goto param;
case XINE_MSG_FILE_NOT_FOUND:
message = "xine could not find the URL: <i>%1</i>"; goto param;
case XINE_MSG_PERMISSION_ERROR:
message = "Access was denied for the URL: <i>%1</i>"; goto param;
case XINE_MSG_READ_ERROR:
message = "The source cannot be read for the URL: <i>%1</i>"; goto param;
case XINE_MSG_LIBRARY_LOAD_ERROR:
message = "A problem occurred while loading a library or decoder."; goto param;
case XINE_MSG_GENERAL_WARNING:
message = "General Warning"; goto explain;
case XINE_MSG_SECURITY:
message = "Security Warning"; goto explain;
default:
message = "Unknown Error"; goto explain;
explain:
// Don't flood the user with error messages
if ((last_error_time_ + 10) > time(&current) && data->type == last_error_) {
last_error_time_ = current;
return;
}
last_error_time_ = current;
last_error_ = data->type;
if (data->explanation) {
message.prepend("<b>");
message += "</b>:<p>";
message += QString::fromUtf8((char*)data + data->explanation);
}
else break; //if no explanation then why bother!
//FALL THROUGH
param:
// Don't flood the user with error messages
if ((last_error_time_ + 10) > time(&current) && data->type == last_error_) {
last_error_time_ = current;
return;
}
last_error_time_ = current;
last_error_ = data->type;
message.prepend("<p>");
message += "<p>";
if (data->explanation) {
message += "xine parameters: <i>";
message += QString::fromUtf8((char*)data + data->parameters);
message += "</i>";
}
else message += "Sorry, no additional information is available.";
QApplication::postEvent(xe, new XineEvent(XineEvent::InfoMessage, new QString(message)));
}
} //case
} //switch
#undef xe
}
bool XineEngine::event(QEvent *e) {
#define message static_cast<QString*>(static_cast<XineEvent*>(e)->data())
switch(e->type()) {
case XineEvent::PlaybackFinished: //XINE_EVENT_UI_PLAYBACK_FINISHED
emit TrackEnded();
return true;
case XineEvent::InfoMessage:
emit InfoMessage((*message).arg(url_.toString()));
delete message;
return true;
case XineEvent::StatusMessage:
emit StatusText(*message);
delete message;
return true;
case XineEvent::MetaInfoChanged: { //meta info has changed
qLog(Debug) << "Metadata received.";
const Engine::SimpleMetaBundle bundle = fetchMetaData();
if (bundle.title != current_bundle_.title || bundle.artist != current_bundle_.artist) {
current_bundle_ = bundle;
emit MetaData(bundle);
}
return true;
}
case XineEvent::Redirecting:
emit StatusText(QString("Redirecting to: ").arg(*message));
Load(QUrl(*message), Engine::Auto, false, 0, 0);
Play(0);
delete message;
return true;
default:
break;
}
#undef message
return false;
}
Engine::SimpleMetaBundle XineEngine::fetchMetaData() const {
Engine::SimpleMetaBundle bundle;
bundle.title = QString::fromUtf8(xine_get_meta_info(stream_, XINE_META_INFO_TITLE));
bundle.artist = QString::fromUtf8(xine_get_meta_info(stream_, XINE_META_INFO_ARTIST));
bundle.album = QString::fromUtf8(xine_get_meta_info(stream_, XINE_META_INFO_ALBUM));
bundle.comment = QString::fromUtf8(xine_get_meta_info(stream_, XINE_META_INFO_COMMENT));
bundle.genre = QString::fromUtf8(xine_get_meta_info(stream_, XINE_META_INFO_GENRE));
bundle.bitrate = QString::number(xine_get_stream_info(stream_, XINE_STREAM_INFO_AUDIO_BITRATE) / 1000);
bundle.samplerate = QString::number(xine_get_stream_info(stream_, XINE_STREAM_INFO_AUDIO_SAMPLERATE));
bundle.year = QString::fromUtf8(xine_get_meta_info(stream_, XINE_META_INFO_YEAR));
bundle.tracknr = QString::fromUtf8(xine_get_meta_info(stream_, XINE_META_INFO_TRACK_NUMBER));
return bundle;
}
void XineEngine::SetDevice() {
if (device_.isValid()) {
bool valid(false);
xine_cfg_entry_t entry;
switch (device_.type()) {
case QVariant::String:
if (device_.toString().isEmpty()) break;
valid = true;
xine_config_register_string(xine_, "audio.device.alsa_front_device", device_.toString().toUtf8().data(), "", "", 10, nullptr, nullptr);
break;
case QVariant::ByteArray:
valid = true;
xine_config_register_string(xine_, "audio.device.alsa_front_device", device_.toByteArray().data(), "", "", 10, nullptr, nullptr);
break;
default:
qLog(Error) << "Unknown device type" << device_;
break;
}
if (valid) {
xine_config_lookup_entry(xine_, "audio.device.alsa_front_device", &entry);
xine_config_update_entry(xine_, &entry);
}
}
current_device_ = device_;
}
bool XineEngine::CreateStream() {
stream_ = xine_stream_new(xine_, audioport_, nullptr);
if (!stream_) {
xine_close_audio_driver(xine_, audioport_);
audioport_ = nullptr;
emit Error("Could not create a new xine stream");
return false;
}
if (eventqueue_) xine_event_dispose_queue(eventqueue_);
eventqueue_ = xine_event_new_queue(stream_);
xine_event_create_listener_thread(eventqueue_, &XineEngine::XineEventListener, (void*)this);
#ifndef XINE_SAFE_MODE
// Implemented in xinescope.h
post_ = scope_plugin_new(xine_, audioport_);
xine_set_param(stream_, XINE_PARAM_METRONOM_PREBUFFER, 6000);
xine_set_param(stream_, XINE_PARAM_IGNORE_VIDEO, 1);
#endif
#ifdef XINE_PARAM_EARLY_FINISHED_EVENT
// Enable gapless playback
qLog(Debug) << "gapless playback enabled.";
xine_set_param(stream_, XINE_PARAM_EARLY_FINISHED_EVENT, 1);
#endif
return true;
}
bool XineEngine::EnsureStream() {
if (!stream_) return CreateStream();
return true;
}
void XineEngine::DetermineAndShowErrorMessage() {
QString body;
switch (xine_get_error(stream_)) {
case XINE_ERROR_NO_INPUT_PLUGIN:
body = "No suitable input plugin. This often means that the url's protocol is not supported. Network failures are other possible causes.";
break;
case XINE_ERROR_NO_DEMUX_PLUGIN:
body = "No suitable demux plugin. This often means that the file format is not supported.";
break;
case XINE_ERROR_DEMUX_FAILED:
body = "Demuxing failed.";
break;
case XINE_ERROR_INPUT_FAILED:
body = "Could not open file.";
break;
case XINE_ERROR_MALFORMED_MRL:
body = "The location is malformed.";
break;
case XINE_ERROR_NONE:
// Xine is thick. Xine doesn't think there is an error but there may be! We check for other errors below.
default:
if (!xine_get_stream_info(stream_, XINE_STREAM_INFO_AUDIO_HANDLED)) {
// xine can read the plugin but it didn't find any codec
// THUS xine=daft for telling us it could handle the format in canDecode!
body = "There is no available decoder.";
QString const ext = QFileInfo(url_.path()).completeSuffix();
// TODO:
// if (ext == "mp3" && EngineController::installDistroCodec("xine-engine"))
// return;
}
else if (!xine_get_stream_info(stream_, XINE_STREAM_INFO_HAS_AUDIO))
body = "There is no audio channel!";
break;
}
// TODO:
qWarning() << body;
}
const Engine::Scope &XineEngine::scope(int chunk_length) {
if (!post_ || !stream_ || xine_get_status(stream_) != XINE_STATUS_PLAY)
return scope_;
MyNode *const myList = scope_plugin_list(post_);
metronom_t *const myMetronom = scope_plugin_metronom(post_);
const int myChannels = scope_plugin_channels(post_);
int scopeidx = 0;
if (myChannels > 2) return scope_;
for (int n, frame = 0; frame < 512;) {
MyNode *best_node = 0;
for (MyNode *node = myList->next; node != myList; node = node->next, log_buffer_count_++)
if (node->vpts <= current_vpts_ && (!best_node || node->vpts > best_node->vpts))
best_node = node;
if (!best_node || best_node->vpts_end < current_vpts_) {
log_no_suitable_buffer_++;
break;
}
int64_t diff = current_vpts_;
diff -= best_node->vpts;
diff *= 1<<16;
diff /= myMetronom->pts_per_smpls;
const int16_t *data16 = best_node->mem;
data16 += diff;
diff += diff % myChannels; // Important correction to ensure we don't overflow the buffer
diff /= myChannels; // Use units of frames, not samples
// Calculate the number of available samples in this buffer
n = best_node->num_frames;
n -= diff;
n += frame; //clipping for # of frames we need
if (n > 512)
n = 512; // We don't want more than 512 frames
for (int c; frame < n; ++frame, data16 += myChannels) {
for (c = 0; c < myChannels; ++c) {
// We now give interleaved pcm to the scope
scope_[scopeidx++] = data16[c];
if (myChannels == 1) // Duplicate mono samples
scope_[scopeidx++] = data16[c];
}
}
current_vpts_ = best_node->vpts_end;
current_vpts_++; // FIXME: Needs to be done for some reason, or you get situations where it uses same buffer again and again
}
log_scope_call_count_++;
return scope_;
}
void XineEngine::PruneScope() {
if (!stream_) return;
// Here we prune the buffer list regularly
MyNode *myList = scope_plugin_list(post_);
if (!myList) return;
// We operate on a subset of the list for thread-safety
MyNode * const first_node = myList->next;
MyNode const * const list_end = myList;
current_vpts_ = (xine_get_status(stream_) == XINE_STATUS_PLAY) ? xine_get_current_vpts(stream_)
: LLONG_MAX; //if state is not playing OR paused, empty the list
//: std::numeric_limits<int64_t>::max(); //TODO Don't support crappy gcc 2.95
for (MyNode *prev = first_node, *node = first_node->next; node != list_end; node = node->next) {
//we never delete first_node this maintains thread-safety
if (node->vpts_end < current_vpts_) {
prev->next = node->next;
free(node->mem);
free(node);
node = prev;
}
prev = node;
}
}
PruneScopeThread::PruneScopeThread(XineEngine *parent) : engine_(parent) {}
void PruneScopeThread::run() {
QTimer timer;
connect(&timer, SIGNAL(timeout()), engine_, SLOT(PruneScope()), Qt::DirectConnection);
timer.start(1000);
exec();
}
EngineBase::PluginDetailsList XineEngine::GetPluginList() const {
PluginDetailsList ret;
const char *const *plugins = xine_list_audio_output_plugins(xine_);
{
PluginDetails details;
details.name = "auto";
details.description = "Automatically detected";
ret << details;
}
for (int i =0 ; plugins[i] ; ++i) {
PluginDetails details;
details.name = QString::fromUtf8(plugins[i]);
if (details.name == "alsa") details.description = "ALSA audio output";
else if (details.name == "oss") details.description = "OSS audio output";
else if (details.name == "pulseaudio") details.description = "PulseAudio audio output";
else if (details.name == "file") details.description = "File audio output";
else if (details.name == "none") details.description = "None";
else details.description = QString::fromUtf8(plugins[i]);
ret << details;
}
return ret;
}
Reference in New Issue View Git Blame Copy Permalink