FCL/sf/mw/qt: comparison src/3rdparty/phonon/gstreamer/mediaobject.cpp

equal deleted inserted replaced

-:b72c6db6890b
+:5dc02b23752f
 You should have received a copy of the GNU Lesser General Public License
 along with this library.  If not, see <http://www.gnu.org/licenses/>.
 */
 #include <cmath>
 #include <gst/interfaces/propertyprobe.h>
+#include <gst/pbutils/install-plugins.h>
 #include "common.h"
 #include "mediaobject.h"
 #include "videowidget.h"
 #include "message.h"
 #include "backend.h"
 , m_state(Phonon::LoadingState)
 , m_pendingState(Phonon::LoadingState)
 , m_tickTimer(new QTimer(this))
 , m_prefinishMark(0)
 , m_transitionTime(0)
+, m_isStream(false)
 , m_posAtSeek(-1)
 , m_prefinishMarkReachedNotEmitted(true)
 , m_aboutToFinishEmitted(false)
 , m_loading(false)
 , m_capsHandler(0)
 , m_previousTickTime(-1)
 , m_resetNeeded(false)
 , m_autoplayTitles(true)
 , m_availableTitles(0)
 , m_currentTitle(1)
+, m_pendingTitle(1)
 {
 qRegisterMetaType<GstCaps*>("GstCaps*");
 qRegisterMetaType<State>("State");
 static int count = 0;
 m_root = this;
 createPipeline();
 m_backend->addBusWatcher(this);
 connect(m_tickTimer, SIGNAL(timeout()), SLOT(emitTick()));
 }
-connect(this, SIGNAL(stateChanged(Phonon::State,Phonon::State)),
+connect(this, SIGNAL(stateChanged(Phonon::State, Phonon::State)),
-this, SLOT(notifyStateChange(Phonon::State,Phonon::State)));
+this, SLOT(notifyStateChange(Phonon::State, Phonon::State)));
 }
 MediaObject::~MediaObject()
 {
 return QString("ErrorState");
 }
 return QString();
 }
+void
+pluginInstallationDone( GstInstallPluginsReturn res, gpointer userData )
+{
+// Nothing inside yet
+Q_UNUSED(res);
+Q_UNUSED(userData);
+}
 void MediaObject::saveState()
 {
 //Only first resumeState is respected
 if (m_resumeState)
 return;
 void MediaObject::noMorePadsAvailable ()
 {
 if (m_missingCodecs.size() > 0) {
 bool canPlay = (m_hasAudio || m_videoStreamFound);
 Phonon::ErrorType error = canPlay ? Phonon::NormalError : Phonon::FatalError;
+#ifdef PLUGIN_INSTALL_API
+GstInstallPluginsContext *ctx = gst_install_plugins_context_new ();
+gchar *details[2];
+details[0] = m_missingCodecs[0].toLocal8Bit().data();
+details[1] = NULL;
+GstInstallPluginsReturn status;
+status = gst_install_plugins_async( details, ctx, pluginInstallationDone, NULL );
+gst_install_plugins_context_free ( ctx );
+if ( status != GST_INSTALL_PLUGINS_STARTED_OK )
+{
+if( status == GST_INSTALL_PLUGINS_HELPER_MISSING )
+setError(QString(tr("Missing codec helper script assistant.")), Phonon::FatalError );
+else
+setError(QString(tr("Plugin codec installation failed for codec: %0"))
+.arg(m_missingCodecs[0].split("|")[3]), error);
+}
+m_missingCodecs.clear();
+#else
+QString codecs = m_missingCodecs.join(", ");
 if (error == Phonon::NormalError && m_hasVideo && !m_videoStreamFound) {
 m_hasVideo = false;
 emit hasVideoChanged(false);
 }
-QString codecs = m_missingCodecs.join(", ");
 setError(QString(tr("A required codec is missing. You need to install the following codec(s) to play this content: %0")).arg(codecs), error);
 m_missingCodecs.clear();
+#endif
 }
 }
 void MediaObject::cb_no_more_pads (GstElement * decodebin, gpointer data)
 {
 // For GStreamer versions < 0.10.12
 GstStructure *str = gst_caps_get_structure (caps, 0);
 value = QString::fromUtf8(gst_structure_get_name (str));
 }
-media->addMissingCodecName(value);
+#ifdef PLUGIN_INSTALL_API
+QString plugins = QString("gstreamer|0.10|%0|%1|decoder-%2")
+.arg( qApp->applicationName() )
+.arg( value )
+.arg( QString::fromUtf8(gst_caps_to_string (caps) ) );
+media->addMissingCodecName( plugins );
+#else
+media->addMissingCodecName( value );
+#endif
 }
 static void notifyVideoCaps(GObject *obj, GParamSpec *, gpointer data)
 {
 GstPad *pad = GST_PAD(obj);
 gst_element_set_state(m_videoGraph, currentState == GST_STATE_PLAYING ? GST_STATE_PLAYING : GST_STATE_PAUSED);
 m_videoStreamFound = true;
 m_backend->logMessage("Video track connected", Backend::Info, this);
 // Note that the notify::caps _must_ be installed after linking to work with Dapper
 m_capsHandler = g_signal_connect(pad, "notify::caps", G_CALLBACK(notifyVideoCaps), this);
 if (!m_loading && !m_hasVideo) {
 m_hasVideo = m_videoStreamFound;
 emit hasVideoChanged(m_hasVideo);
 }
 }
 m_backend->logMessage(QString("%1 is not a valid URI").arg(url.toString()));
 return false;
 }
 // Create a new datasource based on the input URL
-QByteArray encoded_cstr_url = url.toEncoded();
+// add the 'file' scheme if it's missing; the double '/' is needed!
+QByteArray encoded_cstr_url = (url.scheme() == QLatin1String("") ?
+"file://" + url.toEncoded() :
+url.toEncoded());
 m_datasource = gst_element_make_from_uri(GST_URI_SRC, encoded_cstr_url.constData(), (const char*)NULL);
 if (!m_datasource)
 return false;
 // Set the device for MediaSource::Disc
 if (m_source.discType() == Phonon::Cd
 && (g_object_class_find_property (G_OBJECT_GET_CLASS (m_datasource), "read-speed"))) {
 g_object_set (G_OBJECT (m_datasource), "read-speed", 2, (const char*)NULL);
 m_backend->logMessage(QString("new device speed : 2X"), Backend::Info, this);
 }
+}
+/* make HTTP sources send extra headers so we get icecast
+* metadata in case the stream is an icecast stream */
+if (encoded_cstr_url.startsWith("http://")
+&& g_object_class_find_property (G_OBJECT_GET_CLASS (m_datasource), "iradio-mode")) {
+g_object_set (m_datasource, "iradio-mode", TRUE, NULL);
+m_isStream = true;
 }
 // Link data source into pipeline
 gst_bin_add(GST_BIN(m_pipeline), m_datasource);
 if (!gst_element_link(m_datasource, m_decodebin)) {
 {
 m_pipeline = gst_pipeline_new (NULL);
 gst_object_ref (GST_OBJECT (m_pipeline));
 gst_object_sink (GST_OBJECT (m_pipeline));
-m_decodebin = gst_element_factory_make ("decodebin", NULL);
+m_decodebin = gst_element_factory_make ("decodebin2", NULL);
 g_signal_connect (m_decodebin, "new-decoded-pad", G_CALLBACK (&cb_newpad), this);
 g_signal_connect (m_decodebin, "unknown-type", G_CALLBACK (&cb_unknown_type), this);
 g_signal_connect (m_decodebin, "no-more-pads", G_CALLBACK (&cb_no_more_pads), this);
 gst_bin_add(GST_BIN(m_pipeline), m_decodebin);
 m_backend->logMessage("phonon state request: Playing", Backend::Info, this);
 if (m_atEndOfStream) {
 m_backend->logMessage("EOS already reached", Backend::Info, this);
 } else if (currentState == GST_STATE_PLAYING) {
 changeState(Phonon::PlayingState);
-} else if (!m_atEndOfStream && gst_element_set_state(m_pipeline, GST_STATE_PLAYING) != GST_STATE_CHANGE_FAILURE) {
+} else if (gst_element_set_state(m_pipeline, GST_STATE_PLAYING) != GST_STATE_CHANGE_FAILURE) {
 m_pendingState = Phonon::PlayingState;
 } else {
 m_backend->logMessage("phonon state request failed", Backend::Info, this);
 }
 break;
 {
 if (newstate == m_state)
 return;
 Phonon::State oldState = m_state;
 m_state = newstate; // m_state must be set before emitting, since
 // Error state requires that state() will return the new value
 m_pendingState = newstate;
 emit stateChanged(newstate, oldState);
 switch (newstate) {
 m_backend->logMessage("phonon state changed: Playing", Backend::Info, this);
 break;
 case Phonon::StoppedState:
 m_backend->logMessage("phonon state changed: Stopped", Backend::Info, this);
+// We must reset the pipeline when playing again
+m_resetNeeded = true;
 m_tickTimer->stop();
 break;
 case Phonon::ErrorState:
 m_loading = false;
 // We have to reset the state completely here, otherwise
 // remnants of the old pipeline can result in strangenes
 // such as failing duration queries etc
 GstState state;
 gst_element_set_state(m_pipeline, GST_STATE_NULL);
-gst_element_get_state (m_pipeline, &state, NULL, 2000);
+gst_element_get_state(m_pipeline, &state, NULL, 2000);
 m_source = source;
 emit currentSourceChanged(m_source);
 m_previousTickTime = -1;
 m_missingCodecs.clear();
 // Go into to loading state
 changeState(Phonon::LoadingState);
 m_loading = true;
-m_resetNeeded = false;
+// IMPORTANT: Honor the m_resetNeeded flag as it currently stands.
+// See https://qa.mandriva.com/show_bug.cgi?id=56807
+//m_resetNeeded = false;
 m_resumeState = false;
 m_pendingState = Phonon::StoppedState;
 // Make sure we start out unconnected
 if (GST_ELEMENT_PARENT(m_audioGraph))
 gst_bin_remove(GST_BIN(m_pipeline), m_videoGraph);
 // Clear any existing errors
 m_aboutToFinishEmitted = false;
 m_error = NoError;
-m_errorString = QString();
+m_errorString.clear();
 m_bufferPercent = 0;
 m_prefinishMarkReachedNotEmitted = true;
 m_aboutToFinishEmitted = false;
 m_hasAudio = false;
 m_videoStreamFound = false;
 setTotalTime(-1);
 m_atEndOfStream = false;
-// Clear exising meta tags
+m_availableTitles = 0;
+m_pendingTitle = 1;
+m_currentTitle = 1;
+// Clear existing meta tags
 m_metaData.clear();
+m_isStream = false;
 switch (source.type()) {
 case MediaSource::Url: {
-if (createPipefromURL(source.url()))
+if (!createPipefromURL(source.url()))
-m_loading = true;
-else
 setError(tr("Could not open media source."));
 }
 break;
 case MediaSource::LocalFile: {
-if (createPipefromURL(QUrl::fromLocalFile(source.fileName())))
+if (!createPipefromURL(QUrl::fromLocalFile(source.fileName())))
-m_loading = true;
-else
 setError(tr("Could not open media source."));
 }
 break;
 case MediaSource::Invalid:
 case MediaSource::Empty:
 break;
 case MediaSource::Stream:
-if (createPipefromStream(source))
+if (!createPipefromStream(source))
-m_loading = true;
-else
 setError(tr("Could not open media source."));
 break;
 case MediaSource::Disc:
 {
 QString mediaUrl;
 switch (source.discType()) {
 case Phonon::NoDisc:
 qWarning() << "I should never get to see a MediaSource that is a disc but doesn't specify which one";
 return;
 case Phonon::Cd:  // CD tracks can be specified by setting the url in the following way uri=cdda:4
 mediaUrl = QLatin1String("cdda://");
 break;
 break;
 default:
 qWarning() <<  "media " << source.discType() << " not implemented";
 return;
 }
-if (!mediaUrl.isEmpty() && createPipefromURL(QUrl(mediaUrl)))
+if (mediaUrl.isEmpty() || !createPipefromURL(QUrl(mediaUrl)))
-m_loading = true;
-else
 setError(tr("Could not open media source."));
 }
 break;
 default:
 MediaNodeEvent event(MediaNodeEvent::SourceChanged);
 notify(&event);
 // We need to link this node to ensure that fake sinks are connected
 // before loading, otherwise the stream will be blocked
-if (m_loading)
+link();
-link();
 beginLoad();
 }
 void MediaObject::beginLoad()
 {
 if (m_videoStreamFound != m_hasVideo) {
 m_hasVideo = m_videoStreamFound;
 emit hasVideoChanged(m_hasVideo);
 }
-m_availableTitles = 1;
+if (m_source.discType() == Phonon::Cd) {
 gint64 titleCount;
 GstFormat format = gst_format_get_by_nick("track");
 if (gst_element_query_duration (m_pipeline, &format, &titleCount)) {
 //check if returned format is still "track",
 //gstreamer sometimes returns the total time, if tracks information is not available.
 if (qstrcmp(gst_format_get_name(format), "track") == 0)  {
 int oldAvailableTitles = m_availableTitles;
 m_availableTitles = (int)titleCount;
 if (m_availableTitles != oldAvailableTitles) {
 emit availableTitlesChanged(m_availableTitles);
 m_backend->logMessage(QString("Available titles changed: %0").arg(m_availableTitles), Backend::Info, this);
+}
 }
 }
 }
 }
 void MediaObject::setPrefinishMark(qint32 newPrefinishMark)
 {
 m_prefinishMark = newPrefinishMark;
 case Phonon::ErrorState:
 return;
 }
 quint64 current = currentTime();
 quint64 total = totalTime();
 if (current < total - m_prefinishMark)
 m_prefinishMarkReachedNotEmitted = true;
 if (current < total - ABOUT_TO_FINNISH_TIME)
 m_aboutToFinishEmitted = false;
 qint64 currentTime = getPipelinePos();
 qint64 totalTime = m_totalTime;
 if (m_tickInterval > 0 && currentTime != m_previousTickTime) {
 emit tick(currentTime);
 m_previousTickTime = currentTime;
 }
 if (m_state == Phonon::PlayingState) {
 if (currentTime >= totalTime - m_prefinishMark) {
 if (m_prefinishMarkReachedNotEmitted) {
 m_prefinishMarkReachedNotEmitted = false;
 emit prefinishMarkReached(totalTime - currentTime);
 }
 }
 // Prepare load of next source
 if (currentTime >= totalTime - ABOUT_TO_FINNISH_TIME) {
-if (!m_aboutToFinishEmitted) {
+if (m_source.type() == MediaSource::Disc &&
+m_autoplayTitles &&
+m_availableTitles > 1 &&
+m_currentTitle < m_availableTitles) {
+m_aboutToFinishEmitted = false;
+} else if (!m_aboutToFinishEmitted) {
 m_aboutToFinishEmitted = true; // track is about to finish
 emit aboutToFinish();
 }
 }
 }
 m_backend->logMessage(msgString, Backend::Debug, this);
 }
 switch (GST_MESSAGE_TYPE (gstMessage)) {
 case GST_MESSAGE_EOS:
-m_backend->logMessage("EOS recieved", Backend::Info, this);
+m_backend->logMessage("EOS received", Backend::Info, this);
 handleEndOfStream();
 break;
 case GST_MESSAGE_TAG: {
 GstTagList* tag_list = 0;
 gst_message_parse_tag(gstMessage, &tag_list);
 if (tag_list) {
+TagMap newTags;
+gst_tag_list_foreach (tag_list, &foreach_tag_function, &newTags);
+gst_tag_list_free(tag_list);
+// Determine if we should no fake the album/artist tags.
+// This is a little confusing as we want to fake it on initial
+// connection where title, album and artist are all missing.
+// There are however times when we get just other information,
+// e.g. codec, and so we want to only do clever stuff if we
+// have a commonly available tag (ORGANIZATION) or we have a
+// change in title
+bool fake_it =
+(m_isStream
+&& ((!newTags.contains("TITLE")
+&& newTags.contains("ORGANIZATION"))
+|| (newTags.contains("TITLE")
+&& m_metaData.value("TITLE") != newTags.value("TITLE")))
+&& !newTags.contains("ALBUM")
+&& !newTags.contains("ARTIST"));
 TagMap oldMap = m_metaData; // Keep a copy of the old one for reference
-// Append any new meta tags to the existing tag list
-gst_tag_list_foreach (tag_list, &foreach_tag_function, &m_metaData);
+// Now we've checked the new data, append any new meta tags to the existing tag list
+// We cannot use TagMap::iterator as this is a multimap and when streaming data
+// could in theory be lost.
+QList<QString> keys = newTags.keys();
+for (QList<QString>::iterator i = keys.begin(); i != keys.end(); ++i) {
+QString key = *i;
+if (m_isStream) {
+// If we're streaming, we need to remove data in m_metaData
+// in order to stop it filling up indefinitely (as it's a multimap)
+m_metaData.remove(key);
+}
+QList<QString> values = newTags.values(key);
+for (QList<QString>::iterator j = values.begin(); j != values.end(); ++j) {
+QString value = *j;
+QString currVal = m_metaData.value(key);
+if (!m_metaData.contains(key) || currVal != value) {
+m_metaData.insert(key, value);
+}
+}
+}
 m_backend->logMessage("Meta tags found", Backend::Info, this);
-if (oldMap != m_metaData && !m_loading)
+if (oldMap != m_metaData) {
-emit metaDataChanged(m_metaData);
+// This is a bit of a hack to ensure that stream metadata is
-gst_tag_list_free(tag_list);
+// returned. We get as much as we can from the Shoutcast server's
-}
+// StreamTitle= header. If further info is decoded from the stream
+// itself later, then it will overwrite this info.
+if (m_isStream && fake_it) {
+m_metaData.remove("ALBUM");
+m_metaData.remove("ARTIST");
+// Detect whether we want to "fill in the blanks"
+QString str;
+if (m_metaData.contains("TITLE"))
+{
+str = m_metaData.value("TITLE");
+int splitpoint;
+// Check to see if our title matches "%s - %s"
+// Where neither %s are empty...
+if ((splitpoint = str.indexOf(" - ")) > 0
+&& str.size() > (splitpoint+3)) {
+m_metaData.insert("ARTIST", str.left(splitpoint));
+m_metaData.replace("TITLE", str.mid(splitpoint+3));
+}
+} else {
+str = m_metaData.value("GENRE");
+if (!str.isEmpty())
+m_metaData.insert("TITLE", str);
+else
+m_metaData.insert("TITLE", "Streaming Data");
+}
+if (!m_metaData.contains("ARTIST")) {
+str = m_metaData.value("LOCATION");
+if (!str.isEmpty())
+m_metaData.insert("ARTIST", str);
+else
+m_metaData.insert("ARTIST", "Streaming Data");
+}
+str = m_metaData.value("ORGANIZATION");
+if (!str.isEmpty())
+m_metaData.insert("ALBUM", str);
+else
+m_metaData.insert("ALBUM", "Streaming Data");
+}
+// As we manipulate the title, we need to recompare
+// oldMap and m_metaData here...
+if (oldMap != m_metaData && !m_loading)
+emit metaDataChanged(m_metaData);
+}
+			}
 }
 break;
 case GST_MESSAGE_STATE_CHANGED : {
 case GST_STATE_PLAYING :
 m_atStartOfStream = false;
 m_backend->logMessage("gstreamer: pipeline state set to playing", Backend::Info, this);
 m_tickTimer->start();
 changeState(Phonon::PlayingState);
+if ((m_source.type() == MediaSource::Disc) && (m_currentTitle != m_pendingTitle)) {
+setTrack(m_pendingTitle);
+}
 if (m_resumeState && m_oldState == Phonon::PlayingState) {
 seek(m_oldPos);
 m_resumeState = false;
 }
 break;
 case GST_STATE_READY :
 if (!m_loading && m_pendingState == Phonon::StoppedState)
 changeState(Phonon::StoppedState);
 m_backend->logMessage("gstreamer: pipeline state set to ready", Backend::Debug, this);
 m_tickTimer->stop();
+if ((m_source.type() == MediaSource::Disc) && (m_currentTitle != m_pendingTitle)) {
+setTrack(m_pendingTitle);
+}
 break;
 case GST_STATE_VOID_PENDING :
 m_backend->logMessage("gstreamer: pipeline state set to pending (void)", Backend::Debug, this);
 m_tickTimer->stop();
 setError(tr("Could not open audio device. The device is already in use."), Phonon::NormalError);
 else
 setError(err->message, Phonon::FatalError);
 gst_caps_unref (caps);
 gst_object_unref (sinkPad);
 }
 } else {
 setError(QString(err->message), Phonon::FatalError);
 }
 } else if (err->domain == GST_STREAM_ERROR) {
 switch (err->code) {
 //case GST_MESSAGE_CLOCK_PROVIDE:
 //case GST_MESSAGE_NEW_CLOCK:
 //case GST_MESSAGE_STEP_DONE:
 //case GST_MESSAGE_LATENCY: only from 0.10.12
 //case GST_MESSAGE_ASYNC_DONE: only from 0.10.13
 default:
 break;
 }
 }
 void MediaObject::handleEndOfStream()
 {
 return;
 if (!m_seekable)
 m_atEndOfStream = true;
-if (m_autoplayTitles &&
+if (m_source.type() == MediaSource::Disc &&
+m_autoplayTitles &&
 m_availableTitles > 1 &&
 m_currentTitle < m_availableTitles) {
 _iface_setCurrentTitle(m_currentTitle + 1);
 return;
 }
 // Only emit paused if the finished signal
 // did not result in a new state
 if (m_pendingState == Phonon::PausedState)
 setState(m_pendingState);
 }
+}
+}
+void MediaObject::invalidateGraph()
+{
+m_resetNeeded = true;
+if (m_state == Phonon::PlayingState || m_state == Phonon::PausedState) {
+changeState(Phonon::StoppedState);
 }
 }
 // Notifes the pipeline about state changes in the media object
 void MediaObject::notifyStateChange(Phonon::State newstate, Phonon::State oldstate)
 return m_currentTitle;
 }
 void MediaObject::_iface_setCurrentTitle(int title)
 {
+m_backend->logMessage(QString("setCurrentTitle %0").arg(title), Backend::Info, this);
+if ((title == m_currentTitle) || (title == m_pendingTitle))
+return;
+m_pendingTitle = title;
+if (m_state == Phonon::PlayingState || m_state == Phonon::StoppedState) {
+setTrack(m_pendingTitle);
+} else {
+setState(Phonon::StoppedState);
+}
+}
+void MediaObject::setTrack(int title)
+{
+if (((m_state != Phonon::PlayingState) && (m_state != Phonon::StoppedState)) || (title < 1) || (title > m_availableTitles))
+return;
+//let's seek to the beginning of the song
 GstFormat trackFormat = gst_format_get_by_nick("track");
-m_backend->logMessage(QString("setCurrentTitle %0").arg(title), Backend::Info, this);
+m_backend->logMessage(QString("setTrack %0").arg(title), Backend::Info, this);
-if ((title == m_currentTitle) || (title < 1) || (title > m_availableTitles))
+if (gst_element_seek_simple(m_pipeline, trackFormat, GST_SEEK_FLAG_FLUSH, title - 1)) {
-return;
+m_currentTitle = title;
-m_currentTitle = title;
-//let's seek to the beginning of the song
-if (gst_element_seek_simple(m_pipeline, trackFormat, GST_SEEK_FLAG_FLUSH, m_currentTitle - 1)) {
 updateTotalTime();
 m_atEndOfStream = false;
 emit titleChanged(title);
 emit totalTimeChanged(totalTime());
 }

changeset 30	5dc02b23752f
parent 3	41300fa6a67c
child 37	758a864f9613