/*!
Use \a playlist as the source of images to be displayed in the viewer.
*/
void QMediaImageViewer::setPlaylist(QMediaPlaylist *playlist)
{
Q_D(QMediaImageViewer);
if (d->playlist) {
disconnect(d->playlist, SIGNAL(currentMediaChanged(QMediaContent)),
this, SLOT(_q_playlistMediaChanged(QMediaContent)));
disconnect(d->playlist, SIGNAL(destroyed()), this, SLOT(_q_playlistDestroyed()));
QMediaObject::unbind(d->playlist);
}
d->playlist = playlist;
if (d->playlist) {
connect(d->playlist, SIGNAL(currentMediaChanged(QMediaContent)),
this, SLOT(_q_playlistMediaChanged(QMediaContent)));
connect(d->playlist, SIGNAL(destroyed()), this, SLOT(_q_playlistDestroyed()));
QMediaObject::bind(d->playlist);
setMedia(d->playlist->currentMedia());
} else {
setMedia(QMediaContent());
}
}
void TimelineContainer::setTimeline(const std::shared_ptr<Timeline>& timeline)
{
if (mTimeline)
mTimeline->disconnect(this);
mTimeline = timeline;
// clear existing timeline layer widgets
while (mLayerLayout->count())
mLayerLayout->takeAt(0)->widget()->deleteLater();
if (mTimeline) {
QObject::connect(mTimeline.get(), &Timeline::layerAdded,
this, &TimelineContainer::insertLayerWidget);
QObject::connect(mTimeline.get(), &Timeline::layerRemoved,
this, &TimelineContainer::removeLayerWidget);
QObject::connect(mTimeline.get(), SIGNAL(backingTrackChanged(QString)),
mPlaybackWidget, SLOT(setMedia(QString)));
for (int i = 0; i < mTimeline->layers().size(); i++) {
insertLayerWidget(i, mTimeline->layer(i));
}
mPlaybackWidget->setMedia(mTimeline->backingTrack());
if (ui->playback_widget->snapSteps() != 0)
emit snapIntervalChanged(snapInterval(mTimeline->bpm(), ui->playback_widget->snapSteps()));
}
}
// Update RTP/SDP data from parameters
// Return true if media changed
bool SDPSession::updateRtpSDP(const NamedList& params)
{
DDebug(m_parser,DebugAll,"SDPSession::updateRtpSDP(%s) [%p]",params.c_str(),this);
String addr;
ObjList* tmp = updateRtpSDP(params,addr,m_rtpMedia);
if (tmp) {
bool chg = (m_rtpLocalAddr != addr);
m_rtpLocalAddr = addr;
return setMedia(tmp) || chg;
}
return false;
}
void DirectShowPlayerControl::pause()
{
if (m_status == QMediaPlayer::NoMedia)
return;
if (m_status == QMediaPlayer::InvalidMedia) {
setMedia(m_media, m_stream);
if (m_error != QMediaPlayer::NoError)
return;
}
m_service->pause();
emit stateChanged(m_state = QMediaPlayer::PausedState);
}
void PlanetC_VideoPlayer::openFile(const QString& filename)
{
//Set default options
posX = 0;
posY = 0;
sizeW = 0.64;
sizeH = 0.48;
rotationAngle = 0;
//Load file into QMediaPlayer and pause
//video->setVisible(false);
setMedia(QUrl::fromLocalFile(filename));
pause();
}
HistoryMessage::HistoryMessage(
not_null<History*> history,
const MTPDmessage &data)
: HistoryItem(
history,
data.vid.v,
data.vflags.v,
data.vdate.v,
data.has_from_id() ? data.vfrom_id.v : UserId(0)) {
CreateConfig config;
if (data.has_fwd_from() && data.vfwd_from.type() == mtpc_messageFwdHeader) {
auto &f = data.vfwd_from.c_messageFwdHeader();
config.originalDate = f.vdate.v;
if (f.has_from_id() || f.has_channel_id()) {
config.senderOriginal = f.has_channel_id()
? peerFromChannel(f.vchannel_id)
: peerFromUser(f.vfrom_id);
if (f.has_channel_post()) config.originalId = f.vchannel_post.v;
if (f.has_post_author()) config.authorOriginal = qs(f.vpost_author);
if (f.has_saved_from_peer() && f.has_saved_from_msg_id()) {
config.savedFromPeer = peerFromMTP(f.vsaved_from_peer);
config.savedFromMsgId = f.vsaved_from_msg_id.v;
}
}
}
if (data.has_reply_to_msg_id()) config.replyTo = data.vreply_to_msg_id.v;
if (data.has_via_bot_id()) config.viaBotId = data.vvia_bot_id.v;
if (data.has_views()) config.viewsCount = data.vviews.v;
if (data.has_reply_markup()) config.mtpMarkup = &data.vreply_markup;
if (data.has_edit_date()) config.editDate = data.vedit_date.v;
if (data.has_post_author()) config.author = qs(data.vpost_author);
createComponents(config);
if (data.has_media()) {
setMedia(data.vmedia);
}
auto text = TextUtilities::Clean(qs(data.vmessage));
auto entities = data.has_entities()
? TextUtilities::EntitiesFromMTP(data.ventities.v)
: EntitiesInText();
setText({ text, entities });
if (data.has_grouped_id()) {
setGroupId(MessageGroupId::FromRaw(data.vgrouped_id.v));
}
}
void QAndroidMediaPlayerControl::play()
{
if (!mMediaPlayerReady) {
mPendingState = QMediaPlayer::PlayingState;
if (mCurrentState == QMediaPlayer::StoppedState
&& !mMediaContent.isNull()
&& mCurrentMediaStatus != QMediaPlayer::LoadingMedia) {
setMedia(mMediaContent, 0);
}
return;
}
mMediaPlayer->play();
setState(QMediaPlayer::PlayingState);
}
void kClip::setClip ( shared_ptr<Clip> _clip ) {
clip = _clip;
name = _clip->getName();
aspectRatio = _clip -> getAspectRatio();
string imgPath = _clip -> getFilename();
string thumbPath = imgPath.substr(0, imgPath.find(".") )+".png";
img.setUseTexture(true);
img.loadImage(thumbPath);
setMedia(_clip);
}
void QAndroidMediaPlayerControl::flushPendingStates()
{
if (mPendingSetMedia) {
setMedia(mMediaContent, 0);
mPendingSetMedia = false;
return;
}
switch (mPendingState) {
case QMediaPlayer::PlayingState:
if (mPendingPosition > -1)
setPosition(mPendingPosition);
play();
break;
case QMediaPlayer::PausedState:
pause();
break;
case QMediaPlayer::StoppedState:
stop();
break;
}
}
void QMediaPlayerPrivate::_q_playlistDestroyed()
{
playlist = 0;
setMedia(QMediaContent(), 0);
}
void QMediaPlayerPrivate::_q_updateMedia(const QMediaContent &media)
{
Q_Q(QMediaPlayer);
if (!control)
return;
// check if the current playlist is a top-level playlist
Q_ASSERT(playlist);
if (media.isNull() && playlist != rootMedia.playlist()) {
// switch back to parent playlist
QMediaPlaylist *pls = parentPlaylist(playlist);
Q_ASSERT(pls);
disconnectPlaylist();
playlist = pls;
connectPlaylist();
Q_ASSERT(!pendingPlaylist.playlist());
nestedPlaylists--;
Q_ASSERT(nestedPlaylists >= 0);
playlist->next();
return;
}
if (media.playlist()) {
if (nestedPlaylists < MAX_NESTED_PLAYLISTS) {
nestedPlaylists++;
Q_ASSERT(!pendingPlaylist.playlist());
// disconnect current playlist
disconnectPlaylist();
// new playlist signals are connected
// in the call to setPlaylist() in _q_handlePlaylistLoaded()
playlist = media.playlist();
emit q->currentMediaChanged(media);
_q_handlePlaylistLoaded();
return;
} else if (playlist) {
playlist->next();
}
return;
}
const QMediaPlayer::State currentState = state;
setMedia(media, 0);
if (!media.isNull()) {
switch (currentState) {
case QMediaPlayer::PlayingState:
control->play();
break;
case QMediaPlayer::PausedState:
control->pause();
break;
default:
break;
}
}
_q_stateChanged(control->state());
}
void HistoryMessage::refreshMedia(const MTPMessageMedia *media) {
_media = nullptr;
if (media) {
setMedia(*media);
}
}
void PlanetC_VideoPlayer::close()
{
stop();
setMedia(QMediaContent());
}
void kSample::setSample ( shared_ptr<Sample> _sample ) {
sample = _sample;
sampleRate = _sample -> getSampleRate();
setMedia(_sample);
}
void QGstreamerPlayerControl::playOrPause(QMediaPlayer::State newState)
{
if (m_mediaStatus == QMediaPlayer::NoMedia)
return;
pushState();
if (m_setMediaPending) {
m_mediaStatus = QMediaPlayer::LoadingMedia;
setMedia(m_currentResource, m_stream);
}
#ifdef Q_WS_MAEMO_6
//this is a work around for the gstreamer bug,
//should be remove once it get fixed
if (newState == QMediaPlayer::PlayingState && m_mediaStatus == QMediaPlayer::InvalidMedia) {
setMedia(m_currentResource, m_stream);
}
#endif
if (m_mediaStatus == QMediaPlayer::EndOfMedia && m_pendingSeekPosition == -1) {
m_pendingSeekPosition = 0;
}
if (!m_resources->isGranted())
m_resources->acquire();
if (m_resources->isGranted()) {
// show prerolled frame if switching from stopped state
if (m_pendingSeekPosition == -1) {
m_session->showPrerollFrames(true);
} else if (m_session->state() == QMediaPlayer::StoppedState) {
// Don't evaluate the next two conditions.
} else if (m_session->isSeekable()) {
m_session->pause();
m_session->showPrerollFrames(true);
m_session->seek(m_pendingSeekPosition);
m_pendingSeekPosition = -1;
} else {
m_pendingSeekPosition = -1;
}
bool ok = false;
//To prevent displaying the first video frame when playback is resumed
//the pipeline is paused instead of playing, seeked to requested position,
//and after seeking is finished (position updated) playback is restarted
//with show-preroll-frame enabled.
if (newState == QMediaPlayer::PlayingState && m_pendingSeekPosition == -1)
ok = m_session->play();
else
ok = m_session->pause();
if (!ok)
newState = QMediaPlayer::StoppedState;
}
if (m_mediaStatus == QMediaPlayer::InvalidMedia)
m_mediaStatus = QMediaPlayer::LoadingMedia;
m_currentState = newState;
if (m_mediaStatus == QMediaPlayer::EndOfMedia || m_mediaStatus == QMediaPlayer::LoadedMedia) {
if (m_bufferProgress == -1 || m_bufferProgress == 100)
m_mediaStatus = QMediaPlayer::BufferedMedia;
else
m_mediaStatus = QMediaPlayer::BufferingMedia;
}
popAndNotifyState();
emit positionChanged(position());
}
void PlaybackWidget::setMedia(const QString &str)
{
setMedia(QMediaContent(QUrl(str)));
}
// Update from parameters. Build a default SDP if no media is found in params
bool SDPSession::updateSDP(const NamedList& params)
{
DDebug(m_parser,DebugAll,"SDPSession::updateSdp('%s') [%p]",params.c_str(),this);
bool defaults = true;
const char* sdpPrefix = params.getValue("osdp-prefix","osdp");
ObjList* lst = 0;
unsigned int n = params.length();
String defFormats;
m_parser->getAudioFormats(defFormats);
for (unsigned int i = 0; i < n; i++) {
const NamedString* p = params.getParam(i);
if (!p)
continue;
// search for rtp_port or rtp_port_MEDIANAME parameters
String tmp(p->name());
if (!tmp.startSkip("media",false))
continue;
if (tmp && (tmp[0] != '_'))
continue;
// since we found at least one media declaration disable defaults
defaults = false;
// now tmp holds the suffix for the media, null for audio
bool audio = tmp.null();
// check if media is supported, default only for audio
if (!p->toBoolean(audio))
continue;
String fmts = params.getValue("formats" + tmp);
if (audio && fmts.null())
fmts = defFormats;
if (fmts.null())
continue;
String trans = params.getValue("transport" + tmp,"RTP/AVP");
String crypto;
if (m_secure)
crypto = params.getValue("crypto" + tmp);
if (audio)
tmp = "audio";
else
tmp >> "_";
SDPMedia* rtp = 0;
// try to take the media descriptor from the old list
if (m_rtpMedia) {
ObjList* om = m_rtpMedia->find(tmp);
if (om)
rtp = static_cast<SDPMedia*>(om->remove(false));
}
bool append = false;
if (rtp)
rtp->update(fmts);
else {
rtp = new SDPMedia(tmp,trans,fmts);
append = true;
}
rtp->crypto(crypto,false);
if (sdpPrefix) {
for (unsigned int j = 0; j < n; j++) {
const NamedString* param = params.getParam(j);
if (!param)
continue;
tmp = param->name();
if (tmp.startSkip(sdpPrefix + rtp->suffix() + "_",false) && (tmp.find('_') < 0))
rtp->parameter(tmp,*param,append);
}
}
if (!lst)
lst = new ObjList;
lst->append(rtp);
}
if (defaults && !lst) {
lst = new ObjList;
lst->append(new SDPMedia("audio","RTP/AVP",params.getValue("formats",defFormats)));
}
return setMedia(lst);
}
