void VlcMediaWidget::updateMetadata()
{
metadata.clear();
libvlc_media_t *media = libvlc_media_player_get_media(vlcMediaPlayer);
if (media != NULL) {
metadata.insert(MediaWidget::Title,
QString::fromUtf8(libvlc_media_get_meta(media, libvlc_meta_Title)));
metadata.insert(MediaWidget::Artist,
QString::fromUtf8(libvlc_media_get_meta(media, libvlc_meta_Artist)));
metadata.insert(MediaWidget::Album,
QString::fromUtf8(libvlc_media_get_meta(media, libvlc_meta_Album)));
metadata.insert(MediaWidget::TrackNumber,
QString::fromUtf8(libvlc_media_get_meta(media, libvlc_meta_TrackNumber)));
}
}
static void
_send_all_meta_info(struct _App *app)
{
const char *meta;
_send_cmd_start(app, EM_RESULT_META_INFO);
/*
* Will send in this order: title, artist, album, year,
* genre, comments, disc id and track count.
*/
meta = libvlc_media_get_meta(app->m, libvlc_meta_Title);
_send_cmd_str(app, meta);
meta = libvlc_media_get_meta(app->m, libvlc_meta_Artist);
_send_cmd_str(app, meta);
meta = libvlc_media_get_meta(app->m, libvlc_meta_Album);
_send_cmd_str(app, meta);
meta = libvlc_media_get_meta(app->m, libvlc_meta_Date);
_send_cmd_str(app, meta);
meta = libvlc_media_get_meta(app->m, libvlc_meta_Genre);
_send_cmd_str(app, meta);
meta = NULL; // sending empty comments
_send_cmd_str(app, meta);
meta = NULL; // sending empty disc id
_send_cmd_str(app, meta);
meta = libvlc_media_get_meta(app->m, libvlc_meta_TrackNumber);
_send_cmd_str(app, meta);
_send_cmd_finish(app);
}
void Audiotheque::GetAllSongsBy(Glib::ustring artist)
{
std::vector<Gtk::Widget*> children = hbox.get_children();
for(std::vector<Gtk::Widget*>::iterator it=children.begin()+2; it!=children.end(); it++)
hbox.remove(**it);
libvlc_instance_t *inst;
inst = libvlc_new (0, NULL);
libvlc_media_t *media;
vbox = Gtk::manage(new Gtk::VBox(false,2));
vbox->set_size_request(300,0);
Gtk::Button* button;
std::string path = dirpath+"/"+artist;
DIR* rep = opendir(path.c_str());
button = Gtk::manage(new Gtk::Button("Tous les titres"));
vbox->pack_start(*button,Gtk::PACK_SHRINK);
if(rep!=NULL) {
struct dirent* ent;
std::string here = ".";
std::string parent = "..";
while((ent=readdir(rep))!=NULL) {
if(here.compare(ent->d_name)!=0 && parent.compare(ent->d_name)!=0) {
std::string subdirpath = path+"/"+ent->d_name;
DIR* subdir = opendir(subdirpath.c_str());
if(subdir!=NULL) {
struct dirent* subent;
while((subent=readdir(subdir))!=NULL) {
if(here.compare(subent->d_name)!=0 && parent.compare(subent->d_name)!=0) {
std::string songpath = subdirpath+"/";
songpath += subent->d_name;
media = libvlc_media_new_path(inst,songpath.c_str());
libvlc_media_parse(media);
char* title = libvlc_media_get_meta(media,libvlc_meta_Title);
button = Gtk::manage(new Gtk::Button(title));
vbox->pack_start(*button,Gtk::PACK_SHRINK);
}
}
closedir(subdir);
}
}
}
closedir(rep);
}
hbox.pack_start(*vbox,Gtk::PACK_SHRINK);
hbox.show_all_children();
}
jstring Java_org_videolan_libvlc_LibVLC_getMeta(JNIEnv *env, jobject thiz, int meta)
{
libvlc_media_player_t *mp = getMediaPlayer(env, thiz);
char *psz_meta;
jstring string = NULL;
if (!mp)
return NULL;
libvlc_media_t *p_mp = libvlc_media_player_get_media(mp);
if (!p_mp)
return NULL;
psz_meta = libvlc_media_get_meta(p_mp, meta);
if (psz_meta) {
string = (*env)->NewStringUTF(env, psz_meta);
free(psz_meta);
}
return string;
}
QString VideoWidget::GetTitle(QString file)
{
libvlc_instance_t * pinst;
libvlc_media_player_t *pmp;
libvlc_media_t *pm;
pinst = libvlc_new (0, NULL);
pm = libvlc_media_new_path (pinst, file.toStdString().c_str());
pmp = libvlc_media_player_new_from_media (pm);
libvlc_media_player_play (pmp);
while (libvlc_media_get_state(pm) != 3)
{
libvlc_media_get_state(pm);
}
char *meta = libvlc_media_get_meta (pm, libvlc_meta_Title);
QString title = QString(meta);
title.detach();
libvlc_media_release (pm);
libvlc_media_player_stop (pmp);
libvlc_media_player_release (pmp);
libvlc_release (pinst);
return title;
}
/* TODO Remove: use MediaPlayer.GetMedia().GetMeta instead */
jstring
Java_org_videolan_libvlc_MediaPlayer_getMeta(JNIEnv *env, jobject thiz,
int meta)
{
char *psz_meta;
jstring string = NULL;
vlcjni_object *p_obj = VLCJniObject_getInstance(env, thiz);
if (!p_obj)
return NULL;
libvlc_media_t *p_mp = libvlc_media_player_get_media(p_obj->u.p_mp);
if (!p_mp)
return NULL;
psz_meta = libvlc_media_get_meta(p_mp, meta);
if (psz_meta) {
string = (*env)->NewStringUTF(env, psz_meta);
free(psz_meta);
}
libvlc_media_release(p_mp);
return string;
}
MediaMeta VLCWrapper::GetItemMeta (int row, const QString& location) const
{
MediaMeta meta;
auto m = libvlc_media_list_item_at_index (List_.get (), row);
if (!m)
return meta;
if (!QUrl (location).scheme ().isEmpty ())
{
meta.Artist_ = tr ("Internet stream");
meta.Title_ = location;
return meta;
}
libvlc_media_parse (m);
meta.Artist_ = QString::fromUtf8 (libvlc_media_get_meta (m, libvlc_meta_Artist));
meta.Album_ = QString::fromUtf8 (libvlc_media_get_meta (m, libvlc_meta_Album));
meta.Title_ = QString::fromUtf8 (libvlc_media_get_meta (m, libvlc_meta_Title));
meta.Genre_ = QString::fromUtf8 (libvlc_media_get_meta (m, libvlc_meta_Genre));
meta.Date_ = libvlc_media_get_meta (m, libvlc_meta_Date);
meta.Length_ = libvlc_media_get_duration (m) / 1000;
if (location.isNull ())
meta.Location_ = QUrl (libvlc_media_get_mrl (m));
else
meta.Location_ = QUrl (location);
libvlc_media_track_info_t *pTrackInfo;
int numOfStream = libvlc_media_get_tracks_info (m, &pTrackInfo);
if (numOfStream >= 1)
meta.Type_ = pTrackInfo->i_type;
meta.TrackNumber_ = QString (libvlc_media_get_meta (m,
libvlc_meta_TrackNumber))
.toInt ();
return meta;
}
jobjectArray read_track_info_internal(JNIEnv *env, jobject thiz, libvlc_media_t* p_m)
{
/* get java class */
jclass cls = (*env)->FindClass( env, "org/videolan/libvlc/TrackInfo" );
if ( !cls )
{
LOGE("Failed to load class (org/videolan/libvlc/TrackInfo)" );
return NULL;
}
/* get java class contructor */
jmethodID clsCtor = (*env)->GetMethodID( env, cls, "<init>", "()V" );
if ( !clsCtor )
{
LOGE("Failed to find class constructor (org/videolan/libvlc/TrackInfo)" );
return NULL;
}
/* Get the tracks information of the media. */
libvlc_media_track_t **p_tracks;
int i_nbTracks = libvlc_media_tracks_get(p_m, &p_tracks);
jobjectArray array = (*env)->NewObjectArray(env, i_nbTracks + 1, cls, NULL);
unsigned i;
if (array != NULL)
{
for (i = 0; i <= i_nbTracks; ++i)
{
jobject item = (*env)->NewObject(env, cls, clsCtor);
if (item == NULL)
continue;
(*env)->SetObjectArrayElement(env, array, i, item);
// use last track for metadata
if (i == i_nbTracks)
{
setInt(env, item, "Type", 3 /* TYPE_META */);
setLong(env, item, "Length", libvlc_media_get_duration(p_m));
setString(env, item, "Title", libvlc_media_get_meta(p_m, libvlc_meta_Title));
setString(env, item, "Artist", libvlc_media_get_meta(p_m, libvlc_meta_Artist));
setString(env, item, "Album", libvlc_media_get_meta(p_m, libvlc_meta_Album));
setString(env, item, "Genre", libvlc_media_get_meta(p_m, libvlc_meta_Genre));
setString(env, item, "ArtworkURL", libvlc_media_get_meta(p_m, libvlc_meta_ArtworkURL));
continue;
}
setInt(env, item, "Id", p_tracks[i]->i_id);
setInt(env, item, "Type", p_tracks[i]->i_type);
setString(env, item, "Codec", (const char*)vlc_fourcc_GetDescription(0,p_tracks[i]->i_codec));
setString(env, item, "Language", p_tracks[i]->psz_language);
setInt(env, item, "Bitrate", p_tracks[i]->i_bitrate);
if (p_tracks[i]->i_type == libvlc_track_video)
{
setInt(env, item, "Height", p_tracks[i]->video->i_height);
setInt(env, item, "Width", p_tracks[i]->video->i_width);
setFloat(env, item, "Framerate", (float)p_tracks[i]->video->i_frame_rate_num / p_tracks[i]->video->i_frame_rate_den);
}
if (p_tracks[i]->i_type == libvlc_track_audio)
{
setInt(env, item, "Channels", p_tracks[i]->audio->i_channels);
setInt(env, item, "Samplerate", p_tracks[i]->audio->i_rate);
}
}
}
libvlc_media_tracks_release(p_tracks, i_nbTracks);
return array;
}
ssize_t vlc_in_read(void *buf, size_t len)
{
if (len == 0) {
return 0;
}
assert(buf);
size_t requested = len;
for (;;) {
pthread_mutex_lock(&buffer_lock);
if (vlc_buffer_totalsize(head_buffer) >= len) {
while (len >= head_buffer->size) {
if (head_buffer->buf && head_buffer->size) {
// Get all the data from this list element
memcpy(buf, head_buffer->buf, head_buffer->size);
buf += head_buffer->size;
len -= head_buffer->size;
}
if (head_buffer->next) {
struct vlc_buffer *next_head = head_buffer->next;
vlc_buffer_free(head_buffer);
head_buffer = next_head;
}
else {
vlc_buffer_free(head_buffer);
head_buffer = vlc_buffer_new();
break;
}
}
if (len > 0) {
assert(len < head_buffer->size);
assert(head_buffer->buf);
memcpy(buf, head_buffer->buf, len);
// split the current head into two parts
size_t remaining = head_buffer->size - len;
uint8_t *newbuf = malloc(remaining);
memcpy(newbuf, head_buffer->buf + len, remaining);
free(head_buffer->buf);
head_buffer->buf = newbuf;
head_buffer->size = remaining;
}
pthread_mutex_unlock(&buffer_lock);
return requested;
}
pthread_mutex_unlock(&buffer_lock);
usleep(100);
libvlc_media_t *media = libvlc_media_player_get_media(m_mp);
libvlc_state_t st = libvlc_media_get_state(media);
if (!(st == libvlc_Opening ||
st == libvlc_Buffering ||
st == libvlc_Playing) ) {
return -1;
}
char* nowplaying_sz = libvlc_media_get_meta(media, libvlc_meta_NowPlaying);
if (nowplaying_sz) {
snprintf(vlc_nowplaying, NOWPLAYING_LEN, "%s", nowplaying_sz);
free(nowplaying_sz);
}
}
abort();
}
QString qtVlc::getNowPlaying()
{
return QString(libvlc_media_get_meta(m, libvlc_meta_NowPlaying));
}
QString qtVlc::getArtist()
{
return QString(libvlc_media_get_meta(m, libvlc_meta_Artist));
}
QString qtVlc::getTitle()
{
return QString(libvlc_media_get_meta(m, libvlc_meta_Title));
}
Omm::AvStream::Meta*
VlcTagger::tag(const std::string& uri)
{
LOGNS(Omm::Av, upnpav, debug, "vlc tagger tagging: " + uri);
VlcMeta* pMeta = new VlcMeta;
#if LIBVLC_VERSION_INT < 0x110
_pVlcMedia = libvlc_media_new(_pVlcInstance, uri.c_str(), _pException);
#else
_pVlcMedia = libvlc_media_new_location(_pVlcInstance, uri.c_str());
#endif
handleException();
#if LIBVLC_VERSION_INT < 0x110
#else
libvlc_media_parse(_pVlcMedia);
#endif
#if LIBVLC_VERSION_INT < 0x110
char* pTitle = libvlc_media_get_meta(_pVlcMedia, libvlc_meta_Title, _pException);
#else
char* pTitle = libvlc_media_get_meta(_pVlcMedia, libvlc_meta_Title);
#endif
handleException();
if (pTitle) {
pMeta->setTag("title", std::string(pTitle));
}
#if LIBVLC_VERSION_INT < 0x110
char* pArtist = libvlc_media_get_meta(_pVlcMedia, libvlc_meta_Artist, _pException);
#else
char* pArtist = libvlc_media_get_meta(_pVlcMedia, libvlc_meta_Artist);
#endif
handleException();
if (pArtist) {
pMeta->setTag("artist", std::string(pArtist));
}
#if LIBVLC_VERSION_INT < 0x110
char* pAlbum = libvlc_media_get_meta(_pVlcMedia, libvlc_meta_Album, _pException);
#else
char* pAlbum = libvlc_media_get_meta(_pVlcMedia, libvlc_meta_Album);
#endif
handleException();
if (pAlbum) {
pMeta->setTag("album", std::string(pAlbum));
}
#if LIBVLC_VERSION_INT < 0x110
char* pTrack = libvlc_media_get_meta(_pVlcMedia, libvlc_meta_TrackNumber, _pException);
#else
char* pTrack = libvlc_media_get_meta(_pVlcMedia, libvlc_meta_TrackNumber);
#endif
handleException();
if (pTrack) {
pMeta->setTag("track", std::string(pTrack));
}
#if LIBVLC_VERSION_INT < 0x110
libvlc_time_t duration = libvlc_media_get_duration(_pVlcMedia, _pException);
#else
libvlc_time_t duration = libvlc_media_get_duration(_pVlcMedia);
#endif
handleException();
if (duration) {
pMeta->setTag("duration", Poco::NumberFormatter::format(duration));
}
libvlc_media_release(_pVlcMedia);
// vlc libs need to play the data in order to analyse the streams
// thus we make a simple filename based media type detection
Poco::Path path(uri);
// try to get a filename extension for type of media
std::string extension = Poco::toLower(path.getExtension());
// LOGNS(Omm::Av, upnpav, debug, "vlc tagger extension: " + extension);
Omm::AvStream::Meta::ContainerFormat containerFormat = Omm::AvStream::Meta::CF_UNKNOWN;
if (extension == "mp3") {
pMeta->_mime = Omm::Av::Mime::AUDIO_MPEG;
containerFormat = Omm::AvStream::Meta::CF_AUDIO;
}
else if (extension == "wma" || extension == "ogg" || extension == "wav") {
pMeta->_mime = Omm::Av::Mime::TYPE_AUDIO;
containerFormat = Omm::AvStream::Meta::CF_AUDIO;
}
else if (extension == "mp4" || extension == "mpeg" || extension == "mpg") {
pMeta->_mime = Omm::Av::Mime::VIDEO_MPEG;
containerFormat = Omm::AvStream::Meta::CF_VIDEO;
}
else if (extension == "avi" || extension == "wmv" || extension == "flv") {
pMeta->_mime = Omm::Av::Mime::TYPE_VIDEO;
containerFormat = Omm::AvStream::Meta::CF_VIDEO;
}
else if (extension == "jpg" || extension == "png" || extension == "gif") {
pMeta->_mime = Omm::Av::Mime::TYPE_IMAGE;
containerFormat = Omm::AvStream::Meta::CF_IMAGE;
}
else if (extension == "m3u") {
pMeta->_mime = Omm::Av::Mime::PLAYLIST;
containerFormat = Omm::AvStream::Meta::CF_PLAYLIST;
}
if (containerFormat == Omm::AvStream::Meta::CF_AUDIO) {
pMeta->_isStillImage = false;
VlcStreamInfo* pStreamInfo = new VlcStreamInfo;
pStreamInfo->_isAudio = true;
pStreamInfo->_isVideo = false;
pMeta->addStream(pStreamInfo);
}
else if (containerFormat == Omm::AvStream::Meta::CF_VIDEO) {
pMeta->_isStillImage = false;
VlcStreamInfo* pStreamInfo = new VlcStreamInfo;
pStreamInfo->_isAudio = false;
pStreamInfo->_isVideo = true;
pMeta->addStream(pStreamInfo);
}
else if (containerFormat == Omm::AvStream::Meta::CF_IMAGE) {
pMeta->_isStillImage = true;
VlcStreamInfo* pStreamInfo = new VlcStreamInfo;
pStreamInfo->_isAudio = false;
pStreamInfo->_isVideo = false;
pMeta->addStream(pStreamInfo);
}
else if (containerFormat == Omm::AvStream::Meta::CF_PLAYLIST) {
pMeta->setIsPlaylist(true);
}
return pMeta;
}
