void
AlbumItem::setShowArtist( const bool showArtist )
{
if( showArtist != m_showArtist )
{
m_showArtist = showArtist;
metadataChanged( m_album );
}
}
void MprisPlayer::setMetadata(const QVariantMap &metadata)
{
if (m_metadata == metadata) {
return;
}
m_metadata = metadata;
m_typedMetadata = typeMetadata(metadata);
emit metadataChanged();
}
void
TrackItem::setTrack( Meta::TrackPtr trackPtr )
{
if( m_track )
unsubscribeFrom( m_track );
m_track = trackPtr;
subscribeTo( m_track );
metadataChanged( m_track );
}
void ImportMusicDialog::showEditMetadataDialog()
{
if (m_tracks->size() == 0)
return;
Metadata *editMeta = m_tracks->at(m_currentTrack)->metadata;
MythScreenStack *mainStack = GetMythMainWindow()->GetMainStack();
EditMetadataDialog *editDialog = new EditMetadataDialog(mainStack, editMeta);
editDialog->setSaveMetadataOnly();
if (!editDialog->Create())
{
delete editDialog;
return;
}
connect(editDialog, SIGNAL(metadataChanged()), this, SLOT(metadataChanged()));
mainStack->AddScreen(editDialog);
}
/*------------------------------------------------------------------------------
| OMX_VideoProcessor::cleanup
+-----------------------------------------------------------------------------*/
void OMX_MediaProcessor::cleanup()
{
LOG_INFORMATION(LOG_TAG, "Cleaning up...");
#if 0
if (m_refresh)
{
m_BcmHost.vc_tv_hdmi_power_on_best(
tv_state.width,
tv_state.height,
tv_state.frame_rate,
HDMI_NONINTERLACED,
(EDID_MODE_MATCH_FLAG_T)(HDMI_MODE_MATCH_FRAMERATE|
HDMI_MODE_MATCH_RESOLUTION|HDMI_MODE_MATCH_SCANMODE)
);
}
#endif
LOG_VERBOSE(LOG_TAG, "Closing players...");
#ifdef ENABLE_SUBTITLES
m_player_subtitles->Close();
#endif
m_player_video->Close();
m_player_audio->Close();
if (m_omx_pkt) {
m_omx_reader->FreePacket(m_omx_pkt);
m_omx_pkt = NULL;
}
LOG_VERBOSE(LOG_TAG, "Closing players...");
m_omx_reader->Close();
m_metadata.clear();
emit metadataChanged(m_metadata);
vc_tv_show_info(0);
// lcarlon: free the texture. Invoke freeTexture so that it is the user
// of the class to do it cause it is commonly required to do it in the
// current OpenGL and EGL context. Do it here, after the stop command is
// considered finished: this is needed to avoid hardlock in case the
// used wants to free the texture in his own thread, which would still
// be blocked waiting for the stop command to finish.
LOG_VERBOSE(LOG_TAG, "Freeing texture...");
m_provider->freeTexture(m_textureData);
m_textureData = NULL;
emit textureInvalidated();
LOG_INFORMATION(LOG_TAG, "Cleanup done.");
}
void BrushPresetManager::setPreset(const QString &path)
{
if (path.isEmpty())
return;
auto preset = Json::readFromFile(path).toMap();
if (preset.isEmpty())
return;
_preset = preset;
emit presetChanged(preset, path);
emit metadataChanged(metadata());
emit strokerChanged(stroker());
emit settingsChanged(settings());
}
NowPlaying::NowPlaying(QObject *parent, const QVariantList &args)
: Plasma::Applet(parent, args),
m_controller(0),
m_state(NoPlayer),
m_currentLayout(NoLayout),
m_volume(0),
m_length(0),
m_textPanel(new InfoPanel)
{
resize(300, 200); // ideal planar size
connect(this, SIGNAL(metadataChanged(QMap<QString,QString>)),
m_textPanel, SLOT(updateMetadata(QMap<QString,QString>)));
connect(this, SIGNAL(coverChanged(QPixmap)),
m_textPanel, SLOT(updateArtwork(QPixmap)));
}
PlayerStatus *PlayerStatus::setMetadata(
QString songTitle,
QString songArtist,
QString songAlbum,
QString songArt,
qlonglong songProgressMax,
qlonglong songProgressMin
) {
if (title != songTitle) {
title = songTitle;
artist = songArtist;
album = songAlbum;
art = songArt;
progressMax = songProgressMax;
progressMin = songProgressMin;
emit metadataChanged();
}
return this;
}
QT_BEGIN_NAMESPACE
/*------------------------------------------------------------------------------
| OpenMAXILPlayerControl::OpenMAXILPlayerControl
+-----------------------------------------------------------------------------*/
OpenMAXILPlayerControl::OpenMAXILPlayerControl(QObject *parent)
: QMediaPlayerControl(parent)
, m_ownStream(false)
, m_seekToStartPending(false)
, m_pendingSeekPosition(-1)
, m_mediaProcessor(new OMX_MediaProcessor(make_shared<OMX_EGLBufferProvider>()))
, m_textureData(NULL)
, m_sceneGraphInitialized(false)
, m_quickItem(NULL)
{
log_debug_func;
connect(m_mediaProcessor, SIGNAL(stateChanged(OMX_MediaProcessor::OMX_MediaProcessorState)),
this, SLOT(onStateChanged(OMX_MediaProcessor::OMX_MediaProcessorState)));
connect(m_mediaProcessor, SIGNAL(metadataChanged(QVariantMap)),
this, SIGNAL(metaDataChanged(QVariantMap)));
}
void PEMetadataView::familyEntry() {
if (m_familyEdit->isModified()) {
emit metadataChanged("family", m_familyEdit->text());
m_familyEdit->setModified(false);
}
}
void EditMetadataCommon::saveToMetadata()
{
*m_sourceMetadata = *m_metadata;
emit metadataChanged();
cleanupAndClose();
}
/*------------------------------------------------------------------------------
| OMX_MediaProcessor::setFilenameInt
+-----------------------------------------------------------------------------*/
inline
bool OMX_MediaProcessor::setFilenameInt(QString filename, OMX_TextureData*& textureData)
{
switch (m_state) {
case STATE_INACTIVE:
break;
case STATE_STOPPED:
cleanup();
break;
case STATE_PAUSED:
case STATE_PLAYING:
return false; // TODO: Reimplement.
}
LOG_VERBOSE(LOG_TAG, "Opening %s...", qPrintable(filename));
// It seems that omxplayer expects path and not local URIs.
QUrl url(filename);
if (url.isLocalFile() && filename.startsWith("file://"))
filename = url.path();
if (!m_omx_reader->Open(filename.toStdString(), true)) {
LOG_ERROR(LOG_TAG, "Failed to open source.");
return false;
}
// Emit a signal transmitting the matadata. Anyway, I'm not sure where to check for
// metadata actually changed or not... I emit the signal anyway, then the receiver
// decides.
LOG_VERBOSE(LOG_TAG, "Copy metatada...");
convertMetaData();
emit metadataChanged(m_metadata);
m_filename = filename;
m_has_video = m_omx_reader->VideoStreamCount();
m_has_audio = m_omx_reader->AudioStreamCount();
#ifdef ENABLE_SUBTITLES
m_has_subtitle = m_omx_reader->SubtitleStreamCount();
#endif
m_loop = m_loop && m_omx_reader->CanSeek();
LOG_VERBOSE(LOG_TAG, "Initializing OMX clock...");
if (!m_av_clock->OMXInitialize())
return false;
if (ENABLE_HDMI_CLOCK_SYNC && !m_av_clock->HDMIClockSync())
return false;
m_av_clock->OMXStateIdle();
m_av_clock->OMXStop();
m_av_clock->OMXPause();
m_omx_reader->GetHints(OMXSTREAM_AUDIO, *m_hints_audio);
m_omx_reader->GetHints(OMXSTREAM_VIDEO, *m_hints_video);
if (m_fps > 0.0f)
m_hints_video->fpsrate = m_fps * DVD_TIME_BASE, m_hints_video->fpsscale = DVD_TIME_BASE;
// Set audio stream to use.
// TODO: Implement a way to change it runtime.
#if 0
m_omx_reader->SetActiveStream(OMXSTREAM_AUDIO, m_audio_index_use);
#endif
// Seek on start?
#if 0
if (m_seek_pos !=0 && m_omx_reader->CanSeek()) {
printf("Seeking start of video to %i seconds\n", m_seek_pos);
m_omx_reader->SeekTime(m_seek_pos * 1000.0f, false, &startpts); // from seconds to DVD_TIME_BASE
}
#endif
if (m_has_video) {
LOG_VERBOSE(LOG_TAG, "Opening video using OMX...");
if (!m_player_video->Open(
*m_hints_video,
m_av_clock,
textureData,
VS_DEINTERLACEMODE_OFF, /* deinterlace */
OMX_ImageFilterAnaglyphNone,
ENABLE_HDMI_CLOCK_SYNC,
true, /* threaded */
1.0, /* display aspect, unused */
0, /* display */
0, /* layer */
m_video_queue_size, m_video_fifo_size
))
return false;
}
#ifdef ENABLE_SUBTITLES
LOG_VERBOSE(LOG_TAG, "Opening subtitles using OMX...");
if(m_has_subtitle &&
!m_player_subtitles.Open(m_omx_reader.SubtitleStreamCount(),
std::move(external_subtitles),
m_font_path,
m_italic_font_path,
m_font_size,
m_centered,
m_subtitle_lines,
m_av_clock))
return false;
// This is an upper bound check on the subtitle limits. When we pulled the subtitle
// index from the user we check to make sure that the value is larger than zero, but
// we couldn't know without scanning the file if it was too high. If this is the case
// then we replace the subtitle index with the maximum value possible.
if (m_has_subtitle && m_subtitle_index > (m_omx_reader->SubtitleStreamCount() - 1))
m_subtitle_index = m_omx_reader->SubtitleStreamCount() - 1;
#endif
m_omx_reader->GetHints(OMXSTREAM_AUDIO, *m_hints_audio);
#if 0
if ((m_hints_audio.codec == CODEC_ID_AC3 || m_hints_audio.codec == CODEC_ID_EAC3) &&
m_BcmHost.vc_tv_hdmi_audio_supported(EDID_AudioFormat_eAC3, 2, EDID_AudioSampleRate_e44KHz, EDID_AudioSampleSize_16bit ) != 0)
m_passthrough = false;
if (m_hints_audio.codec == CODEC_ID_DTS &&
m_BcmHost.vc_tv_hdmi_audio_supported(EDID_AudioFormat_eDTS, 2, EDID_AudioSampleRate_e44KHz, EDID_AudioSampleSize_16bit ) != 0)
m_passthrough = false;
#endif
LOG_VERBOSE(LOG_TAG, "Opening audio using OMX...");
if (m_has_audio) {
if (!m_player_audio->Open(
*m_hints_audio,
m_av_clock,
m_omx_reader,
"omx:hdmi", /* TODO: implement way to change */
false, /* TODO: passthrough */
false, /* TODO: hw decode */
false, /* TODO: downmix boost */
true, /* threaded */
false, /* is_live */
PCM_LAYOUT_2_0,
m_audio_queue_size, m_audio_fifo_size
))
return false;
if (m_has_audio)
m_player_audio->SetVolume(pow(10, 0 / 2000.0));
}
setState(STATE_STOPPED);
return true;
}
void PEMetadataView::variantEntry() {
if (m_variantEdit->isModified()) {
emit metadataChanged("variant", m_variantEdit->text());
m_variantEdit->setModified(false);
}
}
void PEMetadataView::titleEntry() {
if (m_titleEdit->isModified()) {
emit metadataChanged("title", m_titleEdit->text());
m_titleEdit->setModified(false);
}
}
MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow)
{
ui->setupUi(this);
QAction* aRemove = ui->actionRemove_Playlist_Selection;
QAction* aClear = ui->actionClear_Playlist;
connect(aRemove, SIGNAL(triggered()), ui->player->playlist(), SLOT(removeSelection()));
connect(aClear, SIGNAL(triggered()), ui->player->playlist(), SLOT(clear()));
connect(ui->player->inner_player(), SIGNAL(metaDataChanged(QString,QVariant)), SLOT(metadataChanged(QString,QVariant)));
}
void MpvAudioOutput::event_loop() {
while (true) {
auto event = mpv_wait_event(handle_, -1);
// qDebug() << "mpv event " << mpv_event_name(event->event_id);
switch (event->event_id) {
case MPV_EVENT_SHUTDOWN:
return;
case MPV_EVENT_QUEUE_OVERFLOW:
qWarning() << "mpv queue overflow";
break;
case MPV_EVENT_START_FILE:
setState(AudioState::Buffering);
break;
case MPV_EVENT_FILE_LOADED:
setState(AudioState::Playing);
emit currentSourceChanged();
setVolume();
if (seek_offset_ != -1) {
seek(seek_offset_);
seek_offset_ = -1;
}
break;
case MPV_EVENT_END_FILE: {
auto end_ev = reinterpret_cast<mpv_event_end_file *>(event->data);
if (end_ev->reason == MPV_END_FILE_REASON_ERROR)
qWarning() << "Ended file: " << mpv_error_string(end_ev->error);
break;
}
case MPV_EVENT_LOG_MESSAGE: {
auto log = reinterpret_cast<mpv_event_log_message *>(event->data);
qDebug() << "mpv [" << log->prefix << "] " << log->text;
break;
}
case MPV_EVENT_PROPERTY_CHANGE: {
auto prop = reinterpret_cast<mpv_event_property *>(event->data);
if (prop->format != MPV_FORMAT_NONE && prop->data) {
if (std::string(prop->name) == "playback-time") {
std::string pos(*(reinterpret_cast<char **>(prop->data)));
emit tick(pos_to_qint64(pos));
if (volumeNeverSet_)
setVolume();
} else if (std::string(prop->name) == "idle") {
int idle = *reinterpret_cast<int *>(prop->data);
if (idle) {
setState(AudioState::Stopped);
emit finished();
} else
setState(AudioState::Playing);
} else if (std::string(prop->name) == "pause") {
int pause = *reinterpret_cast<int *>(prop->data);
if (pause)
setState(AudioState::Paused);
else if (state_ == AudioState::Paused)
setState(AudioState::Playing);
} else if (std::string(prop->name) == "duration") {
double v = *reinterpret_cast<double *>(prop->data);
emit durationChanged(v);
} else if (std::string(prop->name) == "metadata") {
emit metadataChanged(get_property("media-title").toString(),
get_property("audio-format").toString(),
get_property("audio-params/samplerate").toInt());
}
}
break;
}
default:
break;
}
}
}
void BrushPresetManager::setMetadata(const BrushPresetMetadata &metadata)
{
_preset["metadata"] = metadata.toVariantMap();
emit metadataChanged(metadata);
}
void PEMetadataView::labelEntry() {
if (m_labelEdit->isModified()) {
emit metadataChanged("label", m_labelEdit->text());
m_labelEdit->setModified(false);
}
}
void PEMetadataView::descriptionEntry() {
if (m_descriptionEdit->document()->isModified()) {
emit metadataChanged("description", m_descriptionEdit->toHtml());
m_descriptionEdit->document()->setModified(false);
}
}
void PEMetadataView::authorEntry() {
if (m_authorEdit->isModified()) {
emit metadataChanged("author", m_authorEdit->text());
m_authorEdit->setModified(false);
}
}
void NowPlaying::dataUpdated(const QString &name,
const Plasma::DataEngine::Data &data)
{
//i18n("No media player found")
//i18nc("The state of a music player", "Stopped")
if (name != m_watchingPlayer) {
kDebug() << "Wasn't expecting an update from" << name << " but watching " << m_watchingPlayer;
return;
}
if (data.isEmpty()) {
kDebug() << "Got no data";
findPlayer();
return;
}
State newstate;
if (data["State"].toString() == "playing") {
newstate = Playing;
} else if (data["State"].toString() == "paused") {
newstate = Paused;
} else {
newstate = Stopped;
}
if (newstate != m_state) {
emit stateChanged(newstate);
m_state = newstate;
}
QString timeText;
int length = data["Length"].toInt();
if (length != m_length) {
m_length = length;
}
if (length != 0) {
int pos = data["Position"].toInt();
timeText = QString::number(pos / 60) + ':' +
QString::number(pos % 60).rightJustified(2, '0') + " / " +
QString::number(length / 60) + ':' +
QString::number(length % 60).rightJustified(2, '0');
}
QMap<QString,QString> metadata;
metadata["Artist"] = data["Artist"].toString();
metadata["Album"] = data["Album"].toString();
metadata["Title"] = data["Title"].toString();
metadata["Time"] = timeText;
metadata["Track number"] = QString::number(data["Track number"].toInt());
metadata["Comment"] = data["Comment"].toString();
metadata["Genre"] = data["Genre"].toString();
// the time should usually have changed
emit metadataChanged(metadata);
// used for seeing when the track has changed
if ((metadata["Title"] != m_title) || (metadata["Artist"] != m_artist))
{
m_title = metadata["Title"];
m_artist = metadata["Artist"];
m_artwork = data["Artwork"].value<QPixmap>();
emit coverChanged(m_artwork);
if(Plasma::ToolTipManager::self()->isVisible(this)) {
toolTipAboutToShow();
}
}
update();
}
void QProtobufModel::setMetadata(const QUrl &_url)
{
m_metadata = _url;
emit metadataChanged(m_metadata);
checkSourceChange();
}