+int eServiceMP3::getInfo(int w)
+{
+ gchar *tag = 0;
+
+ switch (w)
+ {
+ case sTitle:
+ case sArtist:
+ case sAlbum:
+ case sComment:
+ case sTracknumber:
+ case sGenre:
+ case sVideoType:
+ return resIsString;
+ case sCurrentTitle:
+ tag = GST_TAG_TRACK_NUMBER;
+ break;
+ case sTotalTitles:
+ tag = GST_TAG_TRACK_COUNT;
+ break;
+ default:
+ return resNA;
+ }
+
+ if (!m_stream_tags || !tag)
+ return 0;
+
+ guint value;
+ if (gst_tag_list_get_uint(m_stream_tags, tag, &value))
+ return (int) value;
+
+ return 0;
+
+}
+
+std::string eServiceMP3::getInfoString(int w)
+{
+ gchar *tag = 0;
+ switch (w)
+ {
+ case sTitle:
+ tag = GST_TAG_TITLE;
+ break;
+ case sArtist:
+ tag = GST_TAG_ARTIST;
+ break;
+ case sAlbum:
+ tag = GST_TAG_ALBUM;
+ break;
+ case sComment:
+ tag = GST_TAG_COMMENT;
+ break;
+ case sTracknumber:
+ tag = GST_TAG_TRACK_NUMBER;
+ break;
+ case sGenre:
+ tag = GST_TAG_GENRE;
+ break;
+ case sVideoType:
+ tag = GST_TAG_VIDEO_CODEC;
+ break;
+ default:
+ return "";
+ }
+
+ if (!m_stream_tags || !tag)
+ return "";
+
+ gchar *value;
+
+ if (gst_tag_list_get_string(m_stream_tags, tag, &value))
+ {
+ std::string res = value;
+ g_free(value);
+ return res;
+ }
+
+ return "";
+}
+
+RESULT eServiceMP3::audioChannel(ePtr<iAudioChannelSelection> &ptr)
+{
+ ptr = this;
+ return 0;
+}
+
+RESULT eServiceMP3::audioTracks(ePtr<iAudioTrackSelection> &ptr)
+{
+ ptr = this;
+ return 0;
+}
+
+RESULT eServiceMP3::subtitle(ePtr<iSubtitleOutput> &ptr)
+{
+ ptr = this;
+ return 0;
+}
+
+int eServiceMP3::getNumberOfTracks()
+{
+ return m_audioStreams.size();
+}
+
+int eServiceMP3::getCurrentTrack()
+{
+ return m_currentAudioStream;
+}
+
+RESULT eServiceMP3::selectTrack(unsigned int i)
+{
+ int ret = selectAudioStream(i);
+ /* flush */
+ pts_t ppos;
+ getPlayPosition(ppos);
+ seekTo(ppos);
+
+ return ret;
+}
+
+int eServiceMP3::selectAudioStream(int i)
+{
+ gint nb_sources;
+ GstPad *active_pad;
+ GstElement *switch_audio = gst_bin_get_by_name(GST_BIN(m_gst_pipeline),"switch_audio");
+ if ( !switch_audio )
+ {
+ eDebug("can't switch audio tracks! gst-plugin-selector needed");
+ return -1;
+ }
+ g_object_get (G_OBJECT (switch_audio), "n-pads", &nb_sources, NULL);
+ if ( (unsigned int)i >= m_audioStreams.size() || i >= nb_sources || (unsigned int)m_currentAudioStream >= m_audioStreams.size() )
+ return -2;
+ char sinkpad[8];
+ sprintf(sinkpad, "sink%d", i);
+ g_object_set (G_OBJECT (switch_audio), "active-pad", gst_element_get_pad (switch_audio, sinkpad), NULL);
+ g_object_get (G_OBJECT (switch_audio), "active-pad", &active_pad, NULL);
+ gchar *name;
+ name = gst_pad_get_name (active_pad);
+ eDebug ("switched audio to (%s)", name);
+ g_free(name);
+ m_currentAudioStream = i;
+ return 0;
+}
+
+int eServiceMP3::getCurrentChannel()
+{
+ return STEREO;
+}
+
+RESULT eServiceMP3::selectChannel(int i)
+{
+ eDebug("eServiceMP3::selectChannel(%i)",i);
+ return 0;
+}
+
+RESULT eServiceMP3::getTrackInfo(struct iAudioTrackInfo &info, unsigned int i)
+{
+// eDebug("eServiceMP3::getTrackInfo(&info, %i)",i);
+ if (i >= m_audioStreams.size())
+ return -2;
+ if (m_audioStreams[i].type == audioStream::atMPEG)
+ info.m_description = "MPEG";
+ else if (m_audioStreams[i].type == audioStream::atMP3)
+ info.m_description = "MP3";
+ else if (m_audioStreams[i].type == audioStream::atAC3)
+ info.m_description = "AC3";
+ else if (m_audioStreams[i].type == audioStream::atAAC)
+ info.m_description = "AAC";
+ else if (m_audioStreams[i].type == audioStream::atDTS)
+ info.m_description = "DTS";
+ else if (m_audioStreams[i].type == audioStream::atPCM)
+ info.m_description = "PCM";
+ else if (m_audioStreams[i].type == audioStream::atOGG)
+ info.m_description = "OGG";
+ else
+ info.m_description = "???";
+ if (info.m_language.empty())
+ info.m_language = m_audioStreams[i].language_code;
+ return 0;
+}
+
+void eServiceMP3::gstBusCall(GstBus *bus, GstMessage *msg)
+{
+ if (!msg)
+ return;
+ gchar *sourceName;
+ GstObject *source;
+
+ source = GST_MESSAGE_SRC(msg);
+ sourceName = gst_object_get_name(source);
+
+ if (gst_message_get_structure(msg))
+ {
+ gchar *string = gst_structure_to_string(gst_message_get_structure(msg));
+ eDebug("gst_message from %s: %s", sourceName, string);
+ g_free(string);
+ }
+ else
+ eDebug("gst_message from %s: %s (without structure)", sourceName, GST_MESSAGE_TYPE_NAME(msg));
+
+ switch (GST_MESSAGE_TYPE (msg))
+ {
+ case GST_MESSAGE_EOS:
+ m_event((iPlayableService*)this, evEOF);
+ break;
+ case GST_MESSAGE_ERROR:
+ {
+ gchar *debug;
+ GError *err;
+
+ gst_message_parse_error (msg, &err, &debug);
+ g_free (debug);
+ eWarning("Gstreamer error: %s (%i)", err->message, err->code );
+ if ( err->domain == GST_STREAM_ERROR && err->code == GST_STREAM_ERROR_DECODE )
+ {
+ if ( g_strrstr(sourceName, "videosink") )
+ m_event((iPlayableService*)this, evUser+11);
+ }
+ g_error_free(err);
+ /* TODO: signal error condition to user */
+ break;
+ }
+ case GST_MESSAGE_TAG:
+ {
+ GstTagList *tags, *result;
+ gst_message_parse_tag(msg, &tags);
+
+ result = gst_tag_list_merge(m_stream_tags, tags, GST_TAG_MERGE_PREPEND);
+ if (result)
+ {
+ if (m_stream_tags)
+ gst_tag_list_free(m_stream_tags);
+ m_stream_tags = result;
+ }
+
+ gchar *g_audiocodec;
+ if ( gst_tag_list_get_string(tags, GST_TAG_AUDIO_CODEC, &g_audiocodec) && m_audioStreams.size() == 0 )
+ {
+ GstPad* pad = gst_element_get_pad (GST_ELEMENT(source), "src");
+ GstCaps* caps = gst_pad_get_caps(pad);
+ GstStructure* str = gst_caps_get_structure(caps, 0);
+ if ( !str )
+ break;
+ audioStream audio;
+ audio.type = gstCheckAudioPad(str);
+ m_audioStreams.push_back(audio);
+ }
+ break;
+ }
+ case GST_MESSAGE_ASYNC_DONE:
+ {
+ GstTagList *tags;
+ for (std::vector<audioStream>::iterator IterAudioStream(m_audioStreams.begin()); IterAudioStream != m_audioStreams.end(); ++IterAudioStream)
+ {
+ if ( IterAudioStream->pad )
+ {
+ g_object_get(IterAudioStream->pad, "tags", &tags, NULL);
+ gchar *g_language;
+ if ( gst_is_tag_list(tags) && gst_tag_list_get_string(tags, GST_TAG_LANGUAGE_CODE, &g_language) )
+ {
+ eDebug("found audio language %s",g_language);
+ IterAudioStream->language_code = std::string(g_language);
+ g_free (g_language);
+ }
+ }
+ }
+ for (std::vector<subtitleStream>::iterator IterSubtitleStream(m_subtitleStreams.begin()); IterSubtitleStream != m_subtitleStreams.end(); ++IterSubtitleStream)
+ {
+ if ( IterSubtitleStream->pad )
+ {
+ g_object_get(IterSubtitleStream->pad, "tags", &tags, NULL);
+ gchar *g_language;
+ if ( gst_is_tag_list(tags) && gst_tag_list_get_string(tags, GST_TAG_LANGUAGE_CODE, &g_language) )
+ {
+ eDebug("found subtitle language %s",g_language);
+ IterSubtitleStream->language_code = std::string(g_language);
+ g_free (g_language);
+ }
+ }
+ }
+ }
+ default:
+ break;
+ }
+ g_free (sourceName);
+}
+
+GstBusSyncReply eServiceMP3::gstBusSyncHandler(GstBus *bus, GstMessage *message, gpointer user_data)
+{
+ eServiceMP3 *_this = (eServiceMP3*)user_data;
+ _this->m_pump.send(1);
+ /* wake */
+ return GST_BUS_PASS;
+}
+
+int eServiceMP3::gstCheckAudioPad(GstStructure* structure)
+{
+ const gchar* type;
+ type = gst_structure_get_name(structure);
+
+ if (!strcmp(type, "audio/mpeg")) {
+ gint mpegversion, layer = 0;
+ gst_structure_get_int (structure, "mpegversion", &mpegversion);
+ gst_structure_get_int (structure, "layer", &layer);
+ eDebug("mime audio/mpeg version %d layer %d", mpegversion, layer);
+ switch (mpegversion) {
+ case 1:
+ {
+ if ( layer == 3 )
+ return audioStream::atMP3;
+ else
+ return audioStream::atMPEG;
+ }
+ case 2:
+ return audioStream::atMPEG;
+ case 4:
+ return audioStream::atAAC;
+ default:
+ return audioStream::atUnknown;
+ }
+ }
+ else
+ {
+ eDebug("mime %s", type);
+ if (!strcmp(type, "audio/x-ac3") || !strcmp(type, "audio/ac3"))
+ return audioStream::atAC3;
+ else if (!strcmp(type, "audio/x-dts") || !strcmp(type, "audio/dts"))
+ return audioStream::atDTS;
+ else if (!strcmp(type, "audio/x-raw-int"))
+ return audioStream::atPCM;
+ }
+ return audioStream::atUnknown;
+}
+
+void eServiceMP3::gstCBpadAdded(GstElement *decodebin, GstPad *pad, gpointer user_data)
+{
+ const gchar* type;
+ GstCaps* caps;
+ GstStructure* str;
+ caps = gst_pad_get_caps(pad);
+ str = gst_caps_get_structure(caps, 0);
+ type = gst_structure_get_name(str);
+
+ eDebug("A new pad %s:%s was created", GST_OBJECT_NAME (decodebin), GST_OBJECT_NAME (pad));
+
+ eServiceMP3 *_this = (eServiceMP3*)user_data;
+ GstBin *pipeline = GST_BIN(_this->m_gst_pipeline);
+ if (g_strrstr(type,"audio"))
+ {
+ audioStream audio;
+ audio.type = _this->gstCheckAudioPad(str);
+ GstElement *switch_audio = gst_bin_get_by_name(pipeline , "switch_audio");
+ if ( switch_audio )
+ {
+ GstPad *sinkpad = gst_element_get_request_pad (switch_audio, "sink%d");
+ gst_pad_link(pad, sinkpad);
+ audio.pad = sinkpad;
+ _this->m_audioStreams.push_back(audio);
+
+ if ( _this->m_audioStreams.size() == 1 )
+ {
+ _this->selectAudioStream(0);
+ gst_element_set_state (_this->m_gst_pipeline, GST_STATE_PLAYING);
+ }
+ else
+ g_object_set (G_OBJECT (switch_audio), "select-all", FALSE, NULL);
+ }
+ else
+ {
+ gst_pad_link(pad, gst_element_get_static_pad(gst_bin_get_by_name(pipeline,"queue_audio"), "sink"));
+ _this->m_audioStreams.push_back(audio);
+ }
+ }
+ if (g_strrstr(type,"video"))
+ {
+ gst_pad_link(pad, gst_element_get_static_pad(gst_bin_get_by_name(pipeline,"queue_video"), "sink"));
+ }
+ if (g_strrstr(type,"application/x-ssa") || g_strrstr(type,"application/x-ass"))
+ {
+ GstElement *switch_subtitles = gst_bin_get_by_name(pipeline,"switch_subtitles");
+ if ( !switch_subtitles )
+ {
+ switch_subtitles = gst_element_factory_make ("input-selector", "switch_subtitles");
+ if ( !switch_subtitles )
+ return;
+ GstElement *parser = gst_element_factory_make("ssaparse", "parse_subtitles");
+ GstElement *sink = gst_element_factory_make("fakesink", "sink_subtitles");
+ gst_bin_add_many(pipeline, switch_subtitles, parser, sink, NULL);
+ gst_element_link(switch_subtitles, parser);
+ gst_element_link(parser, sink);
+ g_object_set (G_OBJECT(sink), "signal-handoffs", TRUE, NULL);
+ g_signal_connect(sink, "handoff", G_CALLBACK(gstCBsubtitleAvail), _this);
+ }
+ GstPad *sinkpad = gst_element_get_request_pad (switch_subtitles, "sink%d");
+ gst_pad_link(pad, sinkpad);
+ subtitleStream subs;
+ subs.pad = sinkpad;
+ _this->m_subtitleStreams.push_back(subs);
+ }
+}
+
+void eServiceMP3::gstCBfilterPadAdded(GstElement *filter, GstPad *pad, gpointer user_data)
+{
+ eServiceMP3 *_this = (eServiceMP3*)user_data;
+ GstElement *decoder = gst_bin_get_by_name(GST_BIN(_this->m_gst_pipeline),"decoder");
+ gst_pad_link(pad, gst_element_get_static_pad (decoder, "sink"));
+}
+
+void eServiceMP3::gstCBnewPad(GstElement *decodebin, GstPad *pad, gboolean last, gpointer user_data)
+{
+ eServiceMP3 *_this = (eServiceMP3*)user_data;
+ GstCaps *caps;
+ GstStructure *str;
+ GstPad *audiopad;
+
+ /* only link once */
+ GstElement *audiobin = gst_bin_get_by_name(GST_BIN(_this->m_gst_pipeline),"audiobin");
+ audiopad = gst_element_get_static_pad (audiobin, "sink");
+ if ( !audiopad || GST_PAD_IS_LINKED (audiopad)) {
+ eDebug("audio already linked!");
+ g_object_unref (audiopad);
+ return;
+ }
+
+ /* check media type */
+ caps = gst_pad_get_caps (pad);
+ str = gst_caps_get_structure (caps, 0);
+ eDebug("gst new pad! %s", gst_structure_get_name (str));
+
+ if (!g_strrstr (gst_structure_get_name (str), "audio")) {
+ gst_caps_unref (caps);
+ gst_object_unref (audiopad);
+ return;
+ }
+
+ gst_caps_unref (caps);
+ gst_pad_link (pad, audiopad);
+}
+
+void eServiceMP3::gstCBunknownType(GstElement *decodebin, GstPad *pad, GstCaps *caps, gpointer user_data)
+{
+ GstStructure *str;
+
+ /* check media type */
+ caps = gst_pad_get_caps (pad);
+ str = gst_caps_get_structure (caps, 0);
+ eDebug("unknown type: %s - this can't be decoded.", gst_structure_get_name (str));
+ gst_caps_unref (caps);
+}
+
+void eServiceMP3::gstPoll(const int&)
+{
+ /* ok, we have a serious problem here. gstBusSyncHandler sends
+ us the wakup signal, but likely before it was posted.
+ the usleep, an EVIL HACK (DON'T DO THAT!!!) works around this.
+
+ I need to understand the API a bit more to make this work
+ proplerly. */
+ usleep(1);
+
+ GstBus *bus = gst_pipeline_get_bus (GST_PIPELINE (m_gst_pipeline));
+ GstMessage *message;
+ while ((message = gst_bus_pop (bus)))
+ {
+ gstBusCall(bus, message);
+ gst_message_unref (message);
+ }
+}
+