tdesktop/Telegram/SourceFiles/media/view/media_view_pip.cpp

1805 lines
50 KiB
C++

/*
This file is part of Telegram Desktop,
the official desktop application for the Telegram messaging service.
For license and copyright information please follow this link:
https://github.com/telegramdesktop/tdesktop/blob/master/LEGAL
*/
#include "media/view/media_view_pip.h"
#include "media/streaming/media_streaming_player.h"
#include "media/streaming/media_streaming_document.h"
#include "media/streaming/media_streaming_utility.h"
#include "media/view/media_view_playback_progress.h"
#include "media/view/media_view_pip_opengl.h"
#include "media/view/media_view_pip_raster.h"
#include "media/audio/media_audio.h"
#include "data/data_document.h"
#include "data/data_document_media.h"
#include "data/data_file_origin.h"
#include "data/data_session.h"
#include "data/data_media_rotation.h"
#include "main/main_account.h"
#include "main/main_session.h"
#include "core/application.h"
#include "base/platform/base_platform_info.h"
#include "base/power_save_blocker.h"
#include "base/event_filter.h"
#include "ui/platform/ui_platform_utility.h"
#include "ui/platform/ui_platform_window_title.h"
#include "ui/widgets/buttons.h"
#include "ui/wrap/fade_wrap.h"
#include "ui/widgets/shadow.h"
#include "ui/text/format_values.h"
#include "ui/gl/gl_surface.h"
#include "ui/painter.h"
#include "window/window_controller.h"
#include "styles/style_widgets.h"
#include "styles/style_window.h"
#include "styles/style_media_view.h"
#include <QtGui/QWindow>
#include <QtGui/QScreen>
#include <QtWidgets/QApplication>
namespace Media {
namespace View {
namespace {
constexpr auto kPipLoaderPriority = 2;
constexpr auto kMsInSecond = 1000;
[[nodiscard]] QRect ScreenFromPosition(QPoint point) {
const auto screen = QGuiApplication::screenAt(point);
const auto use = screen ? screen : QGuiApplication::primaryScreen();
return use
? use->availableGeometry()
: QRect(0, 0, st::windowDefaultWidth, st::windowDefaultHeight);
}
[[nodiscard]] QSize MaxAllowedSizeForScreen(QSize screenSize) {
// Each side should be less than screen side - 3 * st::pipBorderSkip,
// That way it won't try to snap to both opposite sides of the screen.
const auto skip = 3 * st::pipBorderSkip;
return { screenSize.width() - skip, screenSize.height() - skip };
}
[[nodiscard]] QPoint ClampToEdges(QRect screen, QRect inner) {
const auto skip = st::pipBorderSkip;
const auto area = st::pipBorderSnapArea;
const auto sleft = screen.x() + skip;
const auto stop = screen.y() + skip;
const auto sright = screen.x() + screen.width() - skip;
const auto sbottom = screen.y() + screen.height() - skip;
const auto ileft = inner.x();
const auto itop = inner.y();
const auto iright = inner.x() + inner.width();
const auto ibottom = inner.y() + inner.height();
auto shiftx = 0;
auto shifty = 0;
if (iright + shiftx >= sright - area && iright + shiftx < sright + area) {
shiftx += (sright - iright);
}
if (ileft + shiftx >= sleft - area && ileft + shiftx < sleft + area) {
shiftx += (sleft - ileft);
}
if (ibottom + shifty >= sbottom - area && ibottom + shifty < sbottom + area) {
shifty += (sbottom - ibottom);
}
if (itop + shifty >= stop - area && itop + shifty < stop + area) {
shifty += (stop - itop);
}
return inner.topLeft() + QPoint(shiftx, shifty);
}
[[nodiscard]] QRect Transformed(
QRect original,
QSize minimalSize,
QSize maximalSize,
QPoint delta,
RectPart by) {
const auto width = original.width();
const auto height = original.height();
const auto x1 = width - minimalSize.width();
const auto x2 = maximalSize.width() - width;
const auto y1 = height - minimalSize.height();
const auto y2 = maximalSize.height() - height;
switch (by) {
case RectPart::Center: return original.translated(delta);
case RectPart::TopLeft:
original.setTop(original.y() + std::clamp(delta.y(), -y2, y1));
original.setLeft(original.x() + std::clamp(delta.x(), -x2, x1));
return original;
case RectPart::TopRight:
original.setTop(original.y() + std::clamp(delta.y(), -y2, y1));
original.setWidth(original.width() + std::clamp(delta.x(), -x1, x2));
return original;
case RectPart::BottomRight:
original.setHeight(
original.height() + std::clamp(delta.y(), -y1, y2));
original.setWidth(original.width() + std::clamp(delta.x(), -x1, x2));
return original;
case RectPart::BottomLeft:
original.setHeight(
original.height() + std::clamp(delta.y(), -y1, y2));
original.setLeft(original.x() + std::clamp(delta.x(), -x2, x1));
return original;
case RectPart::Left:
original.setLeft(original.x() + std::clamp(delta.x(), -x2, x1));
return original;
case RectPart::Top:
original.setTop(original.y() + std::clamp(delta.y(), -y2, y1));
return original;
case RectPart::Right:
original.setWidth(original.width() + std::clamp(delta.x(), -x1, x2));
return original;
case RectPart::Bottom:
original.setHeight(
original.height() + std::clamp(delta.y(), -y1, y2));
return original;
}
return original;
Unexpected("RectPart in PiP Transformed.");
}
[[nodiscard]] QRect Constrained(
QRect original,
QSize minimalSize,
QSize maximalSize,
QSize ratio,
RectPart by,
RectParts attached) {
if (by == RectPart::Center) {
return original;
} else if (!original.width() && !original.height()) {
return QRect(original.topLeft(), ratio);
}
const auto widthLarger = (original.width() * ratio.height())
> (original.height() * ratio.width());
const auto desiredSize = ratio.scaled(
original.size(),
(((RectParts(by) & RectPart::AllCorners)
|| ((by == RectPart::Top || by == RectPart::Bottom)
&& widthLarger)
|| ((by == RectPart::Left || by == RectPart::Right)
&& !widthLarger))
? Qt::KeepAspectRatio
: Qt::KeepAspectRatioByExpanding));
const auto newSize = QSize(
std::clamp(
desiredSize.width(),
minimalSize.width(),
maximalSize.width()),
std::clamp(
desiredSize.height(),
minimalSize.height(),
maximalSize.height()));
switch (by) {
case RectPart::TopLeft:
return QRect(
original.topLeft() + QPoint(
original.width() - newSize.width(),
original.height() - newSize.height()),
newSize);
case RectPart::TopRight:
return QRect(
original.topLeft() + QPoint(
0,
original.height() - newSize.height()),
newSize);
case RectPart::BottomRight:
return QRect(original.topLeft(), newSize);
case RectPart::BottomLeft:
return QRect(
original.topLeft() + QPoint(
original.width() - newSize.width(),
0),
newSize);
case RectPart::Left:
return QRect(
original.topLeft() + QPoint(
(original.width() - newSize.width()),
((attached & RectPart::Top)
? 0
: (attached & RectPart::Bottom)
? (original.height() - newSize.height())
: (original.height() - newSize.height()) / 2)),
newSize);
case RectPart::Top:
return QRect(
original.topLeft() + QPoint(
((attached & RectPart::Left)
? 0
: (attached & RectPart::Right)
? (original.width() - newSize.width())
: (original.width() - newSize.width()) / 2),
0),
newSize);
case RectPart::Right:
return QRect(
original.topLeft() + QPoint(
0,
((attached & RectPart::Top)
? 0
: (attached & RectPart::Bottom)
? (original.height() - newSize.height())
: (original.height() - newSize.height()) / 2)),
newSize);
case RectPart::Bottom:
return QRect(
original.topLeft() + QPoint(
((attached & RectPart::Left)
? 0
: (attached & RectPart::Right)
? (original.width() - newSize.width())
: (original.width() - newSize.width()) / 2),
(original.height() - newSize.height())),
newSize);
}
Unexpected("RectPart in PiP Constrained.");
}
[[nodiscard]] QByteArray Serialize(const PipPanel::Position &position) {
auto result = QByteArray();
auto stream = QDataStream(&result, QIODevice::WriteOnly);
stream.setVersion(QDataStream::Qt_5_3);
stream
<< qint32(position.attached.value())
<< qint32(position.snapped.value())
<< position.screen
<< position.geometry;
stream.device()->close();
return result;
}
[[nodiscard]] PipPanel::Position Deserialize(const QByteArray &data) {
auto stream = QDataStream(data);
auto result = PipPanel::Position();
auto attached = qint32(0);
auto snapped = qint32(0);
stream >> attached >> snapped >> result.screen >> result.geometry;
if (stream.status() != QDataStream::Ok) {
return {};
}
result.attached = RectParts::from_raw(attached);
result.snapped = RectParts::from_raw(snapped);
return result;
}
Qt::Edges RectPartToQtEdges(RectPart rectPart) {
switch (rectPart) {
case RectPart::TopLeft:
return Qt::TopEdge | Qt::LeftEdge;
case RectPart::TopRight:
return Qt::TopEdge | Qt::RightEdge;
case RectPart::BottomRight:
return Qt::BottomEdge | Qt::RightEdge;
case RectPart::BottomLeft:
return Qt::BottomEdge | Qt::LeftEdge;
case RectPart::Left:
return Qt::LeftEdge;
case RectPart::Top:
return Qt::TopEdge;
case RectPart::Right:
return Qt::RightEdge;
case RectPart::Bottom:
return Qt::BottomEdge;
}
return Qt::Edges();
}
} // namespace
QRect RotatedRect(QRect rect, int rotation) {
switch (rotation) {
case 0: return rect;
case 90: return QRect(
rect.y(),
-rect.x() - rect.width(),
rect.height(),
rect.width());
case 180: return QRect(
-rect.x() - rect.width(),
-rect.y() - rect.height(),
rect.width(),
rect.height());
case 270: return QRect(
-rect.y() - rect.height(),
rect.x(),
rect.height(),
rect.width());
}
Unexpected("Rotation in RotatedRect.");
}
bool UsePainterRotation(int rotation) {
return !(rotation % 180);
}
QSize FlipSizeByRotation(QSize size, int rotation) {
return (((rotation / 90) % 2) == 1)
? QSize(size.height(), size.width())
: size;
}
QImage RotateFrameImage(QImage image, int rotation) {
auto transform = QTransform();
transform.rotate(rotation);
return image.transformed(transform);
}
PipPanel::PipPanel(
QWidget *parent,
Fn<Ui::GL::ChosenRenderer(Ui::GL::Capabilities)> renderer)
: _content(Ui::GL::CreateSurface(std::move(renderer)))
, _parent(parent) {
}
void PipPanel::init() {
widget()->setWindowFlags(Qt::Tool
| Qt::WindowStaysOnTopHint
| Qt::FramelessWindowHint
| Qt::WindowDoesNotAcceptFocus);
widget()->setAttribute(Qt::WA_ShowWithoutActivating);
widget()->setAttribute(Qt::WA_MacAlwaysShowToolWindow);
widget()->setAttribute(Qt::WA_NoSystemBackground);
widget()->setAttribute(Qt::WA_TranslucentBackground);
Ui::Platform::IgnoreAllActivation(widget());
Ui::Platform::InitOnTopPanel(widget());
widget()->setMouseTracking(true);
widget()->resize(0, 0);
widget()->hide();
widget()->createWinId();
rp()->shownValue(
) | rpl::filter([=](bool shown) {
return shown;
}) | rpl::start_with_next([=] {
// Workaround Qt's forced transient parent.
Ui::Platform::ClearTransientParent(widget());
}, rp()->lifetime());
QObject::connect(
widget()->windowHandle(),
&QWindow::screenChanged,
[=](QScreen *screen) {
handleScreenChanged(screen);
});
if (Platform::IsWayland()) {
rp()->sizeValue(
) | rpl::start_with_next([=](QSize size) {
handleWaylandResize(size);
}, rp()->lifetime());
base::install_event_filter(widget(), [=](not_null<QEvent*> event) {
if (event->type() == QEvent::Resize && _inHandleWaylandResize) {
return base::EventFilterResult::Cancel;
}
return base::EventFilterResult::Continue;
});
base::install_event_filter(widget()->windowHandle(), [=](not_null<QEvent*> event) {
if (event->type() == QEvent::Resize) {
if (_inHandleWaylandResize) {
return base::EventFilterResult::Cancel;
}
const auto newSize = static_cast<QResizeEvent*>(event.get())->size();
if (_suggestedWaylandSize == newSize) {
handleWaylandResize(newSize);
return base::EventFilterResult::Cancel;
}
}
return base::EventFilterResult::Continue;
});
}
}
not_null<QWidget*> PipPanel::widget() const {
return _content->rpWidget();
}
not_null<Ui::RpWidgetWrap*> PipPanel::rp() const {
return _content.get();
}
void PipPanel::setAspectRatio(QSize ratio) {
if (_ratio == ratio) {
return;
}
_ratio = ratio;
if (_ratio.isEmpty()) {
_ratio = QSize(1, 1);
}
Ui::Platform::DisableSystemWindowResize(widget(), _ratio);
if (!widget()->size().isEmpty()) {
setPosition(countPosition());
}
}
void PipPanel::setPosition(Position position) {
if (!position.screen.isEmpty()) {
for (const auto screen : QApplication::screens()) {
if (screen->geometry() == position.screen) {
setPositionOnScreen(position, screen->availableGeometry());
return;
}
}
}
setPositionDefault();
}
QRect PipPanel::inner() const {
return widget()->rect().marginsRemoved(_padding);
}
RectParts PipPanel::attached() const {
return _attached;
}
bool PipPanel::useTransparency() const {
return _useTransparency;
}
void PipPanel::setDragDisabled(bool disabled) {
_dragDisabled = disabled;
if (_dragState) {
_dragState = std::nullopt;
}
}
bool PipPanel::dragging() const {
return _dragState.has_value();
}
rpl::producer<> PipPanel::saveGeometryRequests() const {
return _saveGeometryRequests.events();
}
QScreen *PipPanel::myScreen() const {
return widget()->screen();
}
PipPanel::Position PipPanel::countPosition() const {
const auto screen = myScreen();
if (!screen) {
return Position();
}
auto result = Position();
result.screen = screen->geometry();
result.geometry = widget()->geometry().marginsRemoved(_padding);
const auto available = screen->availableGeometry();
const auto skip = st::pipBorderSkip;
const auto left = result.geometry.x();
const auto right = left + result.geometry.width();
const auto top = result.geometry.y();
const auto bottom = top + result.geometry.height();
if ((!_dragState || *_dragState != RectPart::Center)
&& !Platform::IsWayland()) {
if (left == available.x()) {
result.attached |= RectPart::Left;
} else if (right == available.x() + available.width()) {
result.attached |= RectPart::Right;
} else if (left == available.x() + skip) {
result.snapped |= RectPart::Left;
} else if (right == available.x() + available.width() - skip) {
result.snapped |= RectPart::Right;
}
if (top == available.y()) {
result.attached |= RectPart::Top;
} else if (bottom == available.y() + available.height()) {
result.attached |= RectPart::Bottom;
} else if (top == available.y() + skip) {
result.snapped |= RectPart::Top;
} else if (bottom == available.y() + available.height() - skip) {
result.snapped |= RectPart::Bottom;
}
}
return result;
}
void PipPanel::setPositionDefault() {
const auto widgetScreen = [&](auto &&widget) -> QScreen* {
if (!widget) {
return nullptr;
}
if (!Platform::IsWayland()) {
if (const auto screen = QGuiApplication::screenAt(
widget->geometry().center())) {
return screen;
}
}
return widget->screen();
};
const auto parentScreen = widgetScreen(_parent);
const auto myScreen = widget()->screen();
if (parentScreen && myScreen != parentScreen) {
widget()->windowHandle()->setScreen(parentScreen);
}
auto position = Position();
position.snapped = RectPart::Top | RectPart::Left;
position.screen = parentScreen->geometry();
position.geometry = QRect(0, 0, st::pipDefaultSize, st::pipDefaultSize);
setPositionOnScreen(position, parentScreen->availableGeometry());
}
void PipPanel::setPositionOnScreen(Position position, QRect available) {
const auto screen = available;
const auto requestedSize = position.geometry.size();
const auto max = std::max(requestedSize.width(), requestedSize.height());
// Apply aspect ratio.
const auto scaled = (_ratio.width() > _ratio.height())
? QSize(max, max * _ratio.height() / _ratio.width())
: QSize(max * _ratio.width() / _ratio.height(), max);
// Apply maximum size.
const auto fit = MaxAllowedSizeForScreen(screen.size());
const auto byWidth = (scaled.width() * fit.height())
> (scaled.height() * fit.width());
const auto normalized = (byWidth && scaled.width() > fit.width())
? QSize(fit.width(), fit.width() * scaled.height() / scaled.width())
: (!byWidth && scaled.height() > fit.height())
? QSize(
fit.height() * scaled.width() / scaled.height(),
fit.height())
: scaled;
// Apply minimal size.
const auto min = st::pipMinimalSize;
const auto minimalSize = (_ratio.width() > _ratio.height())
? QSize(min * _ratio.width() / _ratio.height(), min)
: QSize(min, min * _ratio.height() / _ratio.width());
const auto size = QSize(
std::max(normalized.width(), minimalSize.width()),
std::max(normalized.height(), minimalSize.height()));
// Apply maximal size.
const auto maximalSize = byWidth
? QSize(fit.width(), fit.width() * _ratio.height() / _ratio.width())
: QSize(fit.height() * _ratio.width() / _ratio.height(), fit.height());
// Apply left-right screen borders.
const auto skip = st::pipBorderSkip;
const auto inner = screen.marginsRemoved({ skip, skip, skip, skip });
auto geometry = QRect(position.geometry.topLeft(), size);
if ((position.attached & RectPart::Left)
|| (geometry.x() < screen.x())) {
geometry.moveLeft(screen.x());
} else if ((position.attached & RectPart::Right)
|| (geometry.x() + geometry.width() > screen.x() + screen.width())) {
geometry.moveLeft(screen.x() + screen.width() - geometry.width());
} else if (position.snapped & RectPart::Left) {
geometry.moveLeft(inner.x());
} else if (position.snapped & RectPart::Right) {
geometry.moveLeft(inner.x() + inner.width() - geometry.width());
}
// Apply top-bottom screen borders.
if ((position.attached & RectPart::Top) || (geometry.y() < screen.y())) {
geometry.moveTop(screen.y());
} else if ((position.attached & RectPart::Bottom)
|| (geometry.y() + geometry.height()
> screen.y() + screen.height())) {
geometry.moveTop(
screen.y() + screen.height() - geometry.height());
} else if (position.snapped & RectPart::Top) {
geometry.moveTop(inner.y());
} else if (position.snapped & RectPart::Bottom) {
geometry.moveTop(inner.y() + inner.height() - geometry.height());
}
geometry += _padding;
setGeometry(geometry);
widget()->setMinimumSize(minimalSize);
widget()->setMaximumSize(
std::max(minimalSize.width(), maximalSize.width()),
std::max(minimalSize.height(), maximalSize.height()));
updateDecorations();
}
void PipPanel::update() {
widget()->update();
}
void PipPanel::setGeometry(QRect geometry) {
widget()->setGeometry(geometry);
}
void PipPanel::handleWaylandResize(QSize size) {
_inHandleWaylandResize = true;
_suggestedWaylandSize = size;
// Apply aspect ratio.
const auto max = std::max(size.width(), size.height());
const auto scaled = (_ratio.width() > _ratio.height())
? QSize(max, max * _ratio.height() / _ratio.width())
: QSize(max * _ratio.width() / _ratio.height(), max);
// Buffer can't be bigger than the configured
// (suggested by compositor) size.
const auto byWidth = (scaled.width() * size.height())
> (scaled.height() * size.width());
const auto normalized = (byWidth && scaled.width() > size.width())
? QSize(size.width(), size.width() * scaled.height() / scaled.width())
: (!byWidth && scaled.height() > size.height())
? QSize(
size.height() * scaled.width() / scaled.height(),
size.height())
: scaled;
widget()->resize(normalized);
_inHandleWaylandResize = false;
}
void PipPanel::handleScreenChanged(QScreen *screen) {
const auto screenGeometry = screen->availableGeometry();
const auto minimalSize = _ratio.scaled(
st::pipMinimalSize,
st::pipMinimalSize,
Qt::KeepAspectRatioByExpanding);
const auto maximalSize = _ratio.scaled(
MaxAllowedSizeForScreen(screenGeometry.size()),
Qt::KeepAspectRatio);
widget()->setMinimumSize(minimalSize);
widget()->setMaximumSize(
std::max(minimalSize.width(), maximalSize.width()),
std::max(minimalSize.height(), maximalSize.height()));
}
void PipPanel::handleMousePress(QPoint position, Qt::MouseButton button) {
if (button != Qt::LeftButton) {
return;
}
updateOverState(position);
_pressState = _overState;
_pressPoint = QCursor::pos();
}
void PipPanel::handleMouseRelease(QPoint position, Qt::MouseButton button) {
if (button != Qt::LeftButton || !base::take(_pressState)) {
return;
} else if (base::take(_dragState)) {
finishDrag(QCursor::pos());
updateOverState(position);
}
}
void PipPanel::updateOverState(QPoint point) {
const auto size = st::pipResizeArea;
const auto ignore = _attached | _snapped;
const auto count = [&](RectPart side, int padding) {
return (ignore & side) ? 0 : padding ? padding : size;
};
const auto left = count(RectPart::Left, _padding.left());
const auto top = count(RectPart::Top, _padding.top());
const auto right = count(RectPart::Right, _padding.right());
const auto bottom = count(RectPart::Bottom, _padding.bottom());
const auto width = widget()->width();
const auto height = widget()->height();
const auto overState = [&] {
if (point.x() < left) {
if (point.y() < top) {
return RectPart::TopLeft;
} else if (point.y() >= height - bottom) {
return RectPart::BottomLeft;
} else {
return RectPart::Left;
}
} else if (point.x() >= width - right) {
if (point.y() < top) {
return RectPart::TopRight;
} else if (point.y() >= height - bottom) {
return RectPart::BottomRight;
} else {
return RectPart::Right;
}
} else if (point.y() < top) {
return RectPart::Top;
} else if (point.y() >= height - bottom) {
return RectPart::Bottom;
} else {
return RectPart::Center;
}
}();
if (_overState != overState) {
_overState = overState;
widget()->setCursor([&] {
switch (_overState) {
case RectPart::Center:
return style::cur_pointer;
case RectPart::TopLeft:
case RectPart::BottomRight:
return style::cur_sizefdiag;
case RectPart::TopRight:
case RectPart::BottomLeft:
return style::cur_sizebdiag;
case RectPart::Left:
case RectPart::Right:
return style::cur_sizehor;
case RectPart::Top:
case RectPart::Bottom:
return style::cur_sizever;
}
Unexpected("State in PipPanel::updateOverState.");
}());
}
}
void PipPanel::handleMouseMove(QPoint position) {
if (!_pressState) {
updateOverState(position);
return;
}
const auto point = QCursor::pos();
const auto distance = QApplication::startDragDistance();
if (!_dragState
&& (point - _pressPoint).manhattanLength() > distance
&& !_dragDisabled) {
_dragState = _pressState;
updateDecorations();
_dragStartGeometry = widget()->geometry().marginsRemoved(_padding);
}
if (_dragState) {
if (Platform::IsWayland()) {
startSystemDrag();
} else {
processDrag(point);
}
}
}
void PipPanel::startSystemDrag() {
Expects(_dragState.has_value());
const auto stateEdges = RectPartToQtEdges(*_dragState);
if (stateEdges) {
widget()->windowHandle()->startSystemResize(stateEdges);
} else {
widget()->windowHandle()->startSystemMove();
}
Ui::SendSynteticMouseEvent(
widget().get(),
QEvent::MouseButtonRelease,
Qt::LeftButton);
}
void PipPanel::processDrag(QPoint point) {
Expects(_dragState.has_value());
const auto dragPart = *_dragState;
const auto screen = (dragPart == RectPart::Center)
? ScreenFromPosition(point)
: myScreen()
? myScreen()->availableGeometry()
: QRect();
if (screen.isEmpty()) {
return;
}
const auto minimalSize = _ratio.scaled(
st::pipMinimalSize,
st::pipMinimalSize,
Qt::KeepAspectRatioByExpanding);
const auto maximalSize = _ratio.scaled(
MaxAllowedSizeForScreen(screen.size()),
Qt::KeepAspectRatio);
const auto geometry = Transformed(
_dragStartGeometry,
minimalSize,
maximalSize,
point - _pressPoint,
dragPart);
const auto valid = Constrained(
geometry,
minimalSize,
maximalSize,
_ratio,
dragPart,
_attached);
const auto clamped = (dragPart == RectPart::Center)
? ClampToEdges(screen, valid)
: valid.topLeft();
widget()->setMinimumSize(minimalSize);
widget()->setMaximumSize(
std::max(minimalSize.width(), maximalSize.width()),
std::max(minimalSize.height(), maximalSize.height()));
if (clamped != valid.topLeft()) {
moveAnimated(clamped);
} else {
const auto newGeometry = valid.marginsAdded(_padding);
_positionAnimation.stop();
setGeometry(newGeometry);
}
}
void PipPanel::finishDrag(QPoint point) {
const auto screen = ScreenFromPosition(point);
const auto inner = widget()->geometry().marginsRemoved(_padding);
const auto position = widget()->pos();
const auto clamped = [&] {
auto result = position;
if (Platform::IsWayland()) {
return result;
}
if (result.x() > screen.x() + screen.width() - inner.width()) {
result.setX(screen.x() + screen.width() - inner.width());
}
if (result.x() < screen.x()) {
result.setX(screen.x());
}
if (result.y() > screen.y() + screen.height() - inner.height()) {
result.setY(screen.y() + screen.height() - inner.height());
}
if (result.y() < screen.y()) {
result.setY(screen.y());
}
return result;
}();
if (position != clamped) {
moveAnimated(clamped);
} else {
_positionAnimation.stop();
updateDecorations();
}
}
void PipPanel::updatePositionAnimated() {
const auto progress = _positionAnimation.value(1.);
if (!_positionAnimation.animating()) {
widget()->move(_positionAnimationTo
- QPoint(_padding.left(), _padding.top()));
if (!_dragState) {
updateDecorations();
}
return;
}
const auto from = QPointF(_positionAnimationFrom);
const auto to = QPointF(_positionAnimationTo);
widget()->move((from + (to - from) * progress).toPoint()
- QPoint(_padding.left(), _padding.top()));
}
void PipPanel::moveAnimated(QPoint to) {
if (_positionAnimation.animating() && _positionAnimationTo == to) {
return;
}
_positionAnimationTo = to;
_positionAnimationFrom = widget()->pos()
+ QPoint(_padding.left(), _padding.top());
_positionAnimation.stop();
_positionAnimation.start(
[=] { updatePositionAnimated(); },
0.,
1.,
st::slideWrapDuration,
anim::easeOutCirc);
}
void PipPanel::updateDecorations() {
const auto guard = gsl::finally([&] {
if (!_dragState) {
_saveGeometryRequests.fire({});
}
});
const auto position = countPosition();
const auto use = Ui::Platform::TranslucentWindowsSupported();
const auto full = use ? st::callShadow.extend : style::margins();
const auto padding = style::margins(
(position.attached & RectPart::Left) ? 0 : full.left(),
(position.attached & RectPart::Top) ? 0 : full.top(),
(position.attached & RectPart::Right) ? 0 : full.right(),
(position.attached & RectPart::Bottom) ? 0 : full.bottom());
_snapped = position.snapped;
if (_padding == padding && _attached == position.attached) {
return;
}
const auto newGeometry = position.geometry.marginsAdded(padding);
_attached = position.attached;
_padding = padding;
_useTransparency = use;
widget()->setAttribute(Qt::WA_OpaquePaintEvent, !_useTransparency);
setGeometry(newGeometry);
update();
}
Pip::Pip(
not_null<Delegate*> delegate,
not_null<DocumentData*> data,
std::shared_ptr<Streaming::Document> shared,
FnMut<void()> closeAndContinue,
FnMut<void()> destroy)
: _delegate(delegate)
, _data(data)
, _instance(std::move(shared), [=] { waitingAnimationCallback(); })
, _panel(
_delegate->pipParentWidget(),
[=](Ui::GL::Capabilities capabilities) {
return chooseRenderer(capabilities);
})
, _playbackProgress(std::make_unique<PlaybackProgress>())
, _rotation(data->owner().mediaRotation().get(data))
, _lastPositiveVolume((Core::App().settings().videoVolume() > 0.)
? Core::App().settings().videoVolume()
: Core::Settings::kDefaultVolume)
, _closeAndContinue(std::move(closeAndContinue))
, _destroy(std::move(destroy)) {
setupPanel();
setupButtons();
setupStreaming();
_data->session().account().sessionChanges(
) | rpl::start_with_next([=] {
_destroy();
}, _panel.rp()->lifetime());
}
Pip::~Pip() = default;
void Pip::setupPanel() {
_panel.init();
const auto size = [&] {
if (!_instance.info().video.size.isEmpty()) {
return _instance.info().video.size;
}
const auto media = _data->activeMediaView();
if (media) {
media->goodThumbnailWanted();
}
const auto good = media ? media->goodThumbnail() : nullptr;
const auto original = good ? good->size() : _data->dimensions;
return original.isEmpty() ? QSize(1, 1) : original;
}();
_panel.setAspectRatio(FlipSizeByRotation(size, _rotation));
_panel.setPosition(Deserialize(_delegate->pipLoadGeometry()));
_panel.widget()->show();
_panel.saveGeometryRequests(
) | rpl::start_with_next([=] {
saveGeometry();
}, _panel.rp()->lifetime());
_panel.rp()->events(
) | rpl::start_with_next([=](not_null<QEvent*> e) {
const auto mousePosition = [&] {
return static_cast<QMouseEvent*>(e.get())->pos();
};
const auto mouseButton = [&] {
return static_cast<QMouseEvent*>(e.get())->button();
};
switch (e->type()) {
case QEvent::Close: handleClose(); break;
case QEvent::Leave: handleLeave(); break;
case QEvent::MouseMove:
handleMouseMove(mousePosition());
break;
case QEvent::MouseButtonPress:
handleMousePress(mousePosition(), mouseButton());
break;
case QEvent::MouseButtonRelease:
handleMouseRelease(mousePosition(), mouseButton());
break;
case QEvent::MouseButtonDblClick:
handleDoubleClick(mouseButton());
break;
}
}, _panel.rp()->lifetime());
}
void Pip::handleClose() {
crl::on_main(_panel.widget(), [=] {
_destroy();
});
}
void Pip::handleLeave() {
setOverState(OverState::None);
}
void Pip::handleMouseMove(QPoint position) {
const auto weak = Ui::MakeWeak(_panel.widget());
const auto guard = gsl::finally([&] {
if (weak) {
_panel.handleMouseMove(position);
}
});
setOverState(computeState(position));
seekUpdate(position);
volumeControllerUpdate(position);
}
void Pip::setOverState(OverState state) {
if (_over == state) {
return;
}
const auto wasShown = ResolveShownOver(_over);
_over = state;
const auto nowAreShown = (ResolveShownOver(_over) != OverState::None);
if ((wasShown != OverState::None) != nowAreShown) {
_controlsShown.start(
[=] { _panel.update(); },
nowAreShown ? 0. : 1.,
nowAreShown ? 1. : 0.,
st::fadeWrapDuration,
anim::linear);
}
if (!_pressed) {
updateActiveState(wasShown);
}
_panel.update();
}
void Pip::setPressedState(std::optional<OverState> state) {
if (_pressed == state) {
return;
}
const auto wasShown = shownActiveState();
_pressed = state;
updateActiveState(wasShown);
}
Pip::OverState Pip::shownActiveState() const {
return ResolveShownOver(_pressed.value_or(_over));
}
float64 Pip::activeValue(const Button &button) const {
const auto shownState = ResolveShownOver(button.state);
return button.active.value((shownActiveState() == shownState) ? 1. : 0.);
}
void Pip::updateActiveState(OverState wasShown) {
const auto check = [&](Button &button) {
const auto shownState = ResolveShownOver(button.state);
const auto nowIsShown = (shownActiveState() == shownState);
if ((wasShown == shownState) != nowIsShown) {
button.active.start(
[=, &button] { _panel.widget()->update(button.icon); },
nowIsShown ? 0. : 1.,
nowIsShown ? 1. : 0.,
st::fadeWrapDuration,
anim::linear);
}
};
check(_close);
check(_enlarge);
check(_play);
check(_playback);
check(_volumeToggle);
check(_volumeController);
}
Pip::OverState Pip::ResolveShownOver(OverState state) {
return (state == OverState::VolumeController)
? OverState::VolumeToggle
: state;
}
void Pip::handleMousePress(QPoint position, Qt::MouseButton button) {
const auto weak = Ui::MakeWeak(_panel.widget());
const auto guard = gsl::finally([&] {
if (weak) {
_panel.handleMousePress(position, button);
}
});
if (button != Qt::LeftButton) {
return;
}
_pressed = _over;
if (_over == OverState::Playback || _over == OverState::VolumeController) {
_panel.setDragDisabled(true);
}
seekUpdate(position);
volumeControllerUpdate(position);
}
void Pip::handleMouseRelease(QPoint position, Qt::MouseButton button) {
const auto weak = Ui::MakeWeak(_panel.widget());
const auto guard = gsl::finally([&] {
if (weak) {
_panel.handleMouseRelease(position, button);
}
});
if (button != Qt::LeftButton) {
return;
}
seekUpdate(position);
volumeControllerUpdate(position);
const auto pressed = base::take(_pressed);
if (pressed && *pressed == OverState::Playback) {
_panel.setDragDisabled(false);
seekFinish(_playbackProgress->value());
} else if (pressed && *pressed == OverState::VolumeController) {
_panel.setDragDisabled(false);
_panel.update();
} else if (_panel.dragging() || !pressed || *pressed != _over) {
_lastHandledPress = std::nullopt;
} else {
_lastHandledPress = _over;
switch (_over) {
case OverState::Close: _panel.widget()->close(); break;
case OverState::Enlarge: _closeAndContinue(); break;
case OverState::VolumeToggle: volumeToggled(); break;
case OverState::Other: playbackPauseResume(); break;
}
}
}
void Pip::handleDoubleClick(Qt::MouseButton button) {
if (_over != OverState::Other
|| !_lastHandledPress
|| *_lastHandledPress != _over) {
return;
}
playbackPauseResume(); // Un-click the first click.
_closeAndContinue();
}
void Pip::seekUpdate(QPoint position) {
if (!_pressed || *_pressed != OverState::Playback) {
return;
}
const auto unbound = (position.x() - _playback.icon.x())
/ float64(_playback.icon.width());
const auto progress = std::clamp(unbound, 0., 1.);
seekProgress(progress);
}
void Pip::seekProgress(float64 value) {
if (!_lastDurationMs) {
return;
}
_playbackProgress->setValue(value, false);
const auto positionMs = std::clamp(
static_cast<crl::time>(value * _lastDurationMs),
crl::time(0),
_lastDurationMs);
if (_seekPositionMs != positionMs) {
_seekPositionMs = positionMs;
if (!_instance.player().paused()
&& !_instance.player().finished()) {
_pausedBySeek = true;
playbackPauseResume();
}
updatePlaybackTexts(_seekPositionMs, _lastDurationMs, kMsInSecond);
}
}
void Pip::seekFinish(float64 value) {
if (!_lastDurationMs) {
return;
}
const auto positionMs = std::clamp(
static_cast<crl::time>(value * _lastDurationMs),
crl::time(0),
_lastDurationMs);
_seekPositionMs = -1;
_startPaused = !_pausedBySeek && !_instance.player().finished();
restartAtSeekPosition(positionMs);
}
void Pip::volumeChanged(float64 volume) {
if (volume > 0.) {
_lastPositiveVolume = volume;
}
Player::mixer()->setVideoVolume(volume);
Core::App().settings().setVideoVolume(volume);
Core::App().saveSettingsDelayed();
}
void Pip::volumeToggled() {
const auto volume = Core::App().settings().videoVolume();
volumeChanged(volume ? 0. : _lastPositiveVolume);
_panel.update();
}
void Pip::volumeControllerUpdate(QPoint position) {
if (!_pressed || *_pressed != OverState::VolumeController) {
return;
}
const auto unbound = (position.x() - _volumeController.icon.x())
/ float64(_volumeController.icon.width());
const auto value = std::clamp(unbound, 0., 1.);
volumeChanged(value);
_panel.update();
}
void Pip::setupButtons() {
_close.state = OverState::Close;
_enlarge.state = OverState::Enlarge;
_playback.state = OverState::Playback;
_volumeToggle.state = OverState::VolumeToggle;
_volumeController.state = OverState::VolumeController;
_play.state = OverState::Other;
_panel.rp()->sizeValue(
) | rpl::map([=] {
return _panel.inner();
}) | rpl::start_with_next([=](QRect rect) {
const auto skip = st::pipControlSkip;
_close.area = QRect(
rect.x(),
rect.y(),
st::pipCloseIcon.width() + 2 * skip,
st::pipCloseIcon.height() + 2 * skip);
_enlarge.area = QRect(
_close.area.x() + _close.area.width(),
rect.y(),
st::pipEnlargeIcon.width() + 2 * skip,
st::pipEnlargeIcon.height() + 2 * skip);
const auto volumeSkip = st::pipPlaybackSkip;
const auto volumeHeight = 2 * volumeSkip + st::pipPlaybackWide;
const auto volumeToggleWidth = st::pipVolumeIcon0.width()
+ 2 * skip;
const auto volumeToggleHeight = st::pipVolumeIcon0.height()
+ 2 * skip;
const auto volumeWidth = (((st::mediaviewVolumeWidth + 2 * skip)
+ _close.area.width()
+ _enlarge.area.width()
+ volumeToggleWidth) < rect.width())
? st::mediaviewVolumeWidth
: 0;
_volumeController.area = QRect(
rect.x() + rect.width() - volumeWidth - 2 * volumeSkip,
rect.y() + (volumeToggleHeight - volumeHeight) / 2,
volumeWidth,
volumeHeight);
_volumeToggle.area = QRect(
_volumeController.area.x()
- st::pipVolumeIcon0.width()
- skip,
rect.y(),
volumeToggleWidth,
volumeToggleHeight);
if (!Ui::Platform::TitleControlsOnLeft()) {
_close.area.moveLeft(rect.x()
+ rect.width()
- (_close.area.x() - rect.x())
- _close.area.width());
_enlarge.area.moveLeft(rect.x()
+ rect.width()
- (_enlarge.area.x() - rect.x())
- _enlarge.area.width());
_volumeToggle.area.moveLeft(rect.x());
_volumeController.area.moveLeft(_volumeToggle.area.x()
+ _volumeToggle.area.width());
}
_close.icon = _close.area.marginsRemoved({ skip, skip, skip, skip });
_enlarge.icon = _enlarge.area.marginsRemoved(
{ skip, skip, skip, skip });
_volumeToggle.icon = _volumeToggle.area.marginsRemoved(
{ skip, skip, skip, skip });
_play.icon = QRect(
rect.x() + (rect.width() - st::pipPlayIcon.width()) / 2,
rect.y() + (rect.height() - st::pipPlayIcon.height()) / 2,
st::pipPlayIcon.width(),
st::pipPlayIcon.height());
const auto volumeArea = _volumeController.area;
_volumeController.icon = (volumeArea.width() > 2 * volumeSkip
&& volumeArea.height() > 2 * volumeSkip)
? volumeArea.marginsRemoved(
{ volumeSkip, volumeSkip, volumeSkip, volumeSkip })
: QRect();
const auto playbackSkip = st::pipPlaybackSkip;
const auto playbackHeight = 2 * playbackSkip + st::pipPlaybackWide;
_playback.area = QRect(
rect.x(),
rect.y() + rect.height() - playbackHeight,
rect.width(),
playbackHeight);
_playback.icon = _playback.area.marginsRemoved(
{ playbackSkip, playbackSkip, playbackSkip, playbackSkip });
}, _panel.rp()->lifetime());
_playbackProgress->setValueChangedCallback([=](
float64 value,
float64 receivedTill) {
_panel.widget()->update(_playback.area);
});
}
void Pip::saveGeometry() {
_delegate->pipSaveGeometry(Serialize(_panel.countPosition()));
}
void Pip::updatePlayPauseResumeState(const Player::TrackState &state) {
auto showPause = Player::ShowPauseIcon(state.state);
if (showPause != _showPause) {
_showPause = showPause;
_panel.update();
}
}
void Pip::setupStreaming() {
_instance.setPriority(kPipLoaderPriority);
_instance.lockPlayer();
_instance.player().updates(
) | rpl::start_with_next_error([=](Streaming::Update &&update) {
handleStreamingUpdate(std::move(update));
}, [=](Streaming::Error &&error) {
handleStreamingError(std::move(error));
}, _instance.lifetime());
updatePlaybackState();
}
Ui::GL::ChosenRenderer Pip::chooseRenderer(
Ui::GL::Capabilities capabilities) {
const auto use = Platform::IsMac()
? true
: capabilities.transparency;
LOG(("OpenGL: %1 (PipPanel)").arg(Logs::b(use)));
if (use) {
_opengl = true;
return {
.renderer = std::make_unique<RendererGL>(this),
.backend = Ui::GL::Backend::OpenGL,
};
}
return {
.renderer = std::make_unique<RendererSW>(this),
.backend = Ui::GL::Backend::Raster,
};
}
void Pip::paint(not_null<Renderer*> renderer) const {
const auto controlsShown = _controlsShown.value(
(_over != OverState::None) ? 1. : 0.);
auto geometry = ContentGeometry{
.inner = _panel.inner(),
.attached = (_panel.useTransparency()
? _panel.attached()
: RectPart::AllSides),
.fade = controlsShown,
.outer = _panel.widget()->size(),
.rotation = _rotation,
.videoRotation = _instance.info().video.rotation,
.useTransparency = _panel.useTransparency(),
};
if (canUseVideoFrame()) {
renderer->paintTransformedVideoFrame(geometry);
_instance.markFrameShown();
} else {
const auto content = staticContent();
if (_preparedCoverState == ThumbState::Cover) {
geometry.rotation += base::take(geometry.videoRotation);
}
renderer->paintTransformedStaticContent(content, geometry);
}
if (_instance.waitingShown()) {
renderer->paintRadialLoading(countRadialRect(), controlsShown);
}
if (controlsShown > 0) {
paintButtons(renderer, controlsShown);
paintPlayback(renderer, controlsShown);
paintVolumeController(renderer, controlsShown);
}
}
void Pip::paintButtons(not_null<Renderer*> renderer, float64 shown) const {
const auto outer = _panel.widget()->width();
const auto drawOne = [&](
const Button &button,
const style::icon &icon,
const style::icon &iconOver) {
renderer->paintButton(
button,
outer,
shown,
activeValue(button),
icon,
iconOver);
};
renderer->paintButtonsStart();
drawOne(
_play,
_showPause ? st::pipPauseIcon : st::pipPlayIcon,
_showPause ? st::pipPauseIconOver : st::pipPlayIconOver);
drawOne(_close, st::pipCloseIcon, st::pipCloseIconOver);
drawOne(_enlarge, st::pipEnlargeIcon, st::pipEnlargeIconOver);
const auto volume = Core::App().settings().videoVolume();
if (volume <= 0.) {
drawOne(
_volumeToggle,
st::pipVolumeIcon0,
st::pipVolumeIcon0Over);
} else if (volume < 1 / 2.) {
drawOne(
_volumeToggle,
st::pipVolumeIcon1,
st::pipVolumeIcon1Over);
} else {
drawOne(
_volumeToggle,
st::pipVolumeIcon2,
st::pipVolumeIcon2Over);
}
}
void Pip::paintPlayback(not_null<Renderer*> renderer, float64 shown) const {
const auto outer = QRect(
_playback.icon.x(),
_playback.icon.y() - st::pipPlaybackFont->height,
_playback.icon.width(),
st::pipPlaybackFont->height + _playback.icon.height());
renderer->paintPlayback(outer, shown);
}
void Pip::paintPlaybackContent(
QPainter &p,
QRect outer,
float64 shown) const {
p.setOpacity(shown);
paintPlaybackProgress(p, outer);
paintPlaybackTexts(p, outer);
}
void Pip::paintPlaybackProgress(QPainter &p, QRect outer) const {
const auto radius = _playback.icon.height() / 2;
const auto progress = _playbackProgress->value();
const auto active = activeValue(_playback);
const auto height = anim::interpolate(
st::pipPlaybackWidth,
_playback.icon.height(),
active);
const auto rect = QRect(
outer.x(),
(outer.y()
+ st::pipPlaybackFont->height
+ _playback.icon.height()
- height),
outer.width(),
height);
paintProgressBar(p, rect, progress, radius, active);
}
void Pip::paintProgressBar(
QPainter &p,
const QRect &rect,
float64 progress,
int radius,
float64 active) const {
const auto done = int(base::SafeRound(rect.width() * progress));
PainterHighQualityEnabler hq(p);
p.setPen(Qt::NoPen);
if (done > 0) {
p.setBrush(anim::brush(
st::mediaviewPipControlsFg,
st::mediaviewPipPlaybackActive,
active));
p.setClipRect(rect.x(), rect.y(), done, rect.height());
p.drawRoundedRect(
rect.x(),
rect.y(),
std::min(done + radius, rect.width()),
rect.height(),
radius,
radius);
}
if (done < rect.width()) {
const auto from = std::max(rect.x() + done - radius, rect.x());
p.setBrush(st::mediaviewPipPlaybackInactive);
p.setClipRect(
rect.x() + done,
rect.y(),
rect.width() - done,
rect.height());
p.drawRoundedRect(
from,
rect.y(),
rect.x() + rect.width() - from,
rect.height(),
radius,
radius);
}
p.setClipping(false);
}
void Pip::paintPlaybackTexts(QPainter &p, QRect outer) const {
const auto left = outer.x()
- _playback.icon.x()
+ _playback.area.x()
+ st::pipPlaybackTextSkip;
const auto right = outer.x()
- _playback.icon.x()
+ _playback.area.x()
+ _playback.area.width()
- st::pipPlaybackTextSkip;
const auto top = outer.y() + st::pipPlaybackFont->ascent;
p.setFont(st::pipPlaybackFont);
p.setPen(st::mediaviewPipControlsFgOver);
p.drawText(left, top, _timeAlready);
p.drawText(right - _timeLeftWidth, top, _timeLeft);
}
void Pip::paintVolumeController(
not_null<Renderer*> renderer,
float64 shown) const {
if (_volumeController.icon.isEmpty()) {
return;
}
renderer->paintVolumeController(_volumeController.icon, shown);
}
void Pip::paintVolumeControllerContent(
QPainter &p,
QRect outer,
float64 shown) const {
p.setOpacity(shown);
const auto radius = _volumeController.icon.height() / 2;
const auto volume = Core::App().settings().videoVolume();
const auto active = activeValue(_volumeController);
const auto height = anim::interpolate(
st::pipPlaybackWidth,
_volumeController.icon.height(),
active);
const auto rect = QRect(
outer.x(),
outer.y() + radius - height / 2,
outer.width(),
height);
paintProgressBar(p, rect, volume, radius, active);
}
void Pip::handleStreamingUpdate(Streaming::Update &&update) {
using namespace Streaming;
v::match(update.data, [&](Information &update) {
_panel.setAspectRatio(
FlipSizeByRotation(update.video.size, _rotation));
}, [&](const PreloadedVideo &update) {
updatePlaybackState();
}, [&](const UpdateVideo &update) {
_panel.update();
Core::App().updateNonIdle();
updatePlaybackState();
}, [&](const PreloadedAudio &update) {
updatePlaybackState();
}, [&](const UpdateAudio &update) {
updatePlaybackState();
}, [&](WaitingForData) {
}, [&](MutedByOther) {
}, [&](Finished) {
updatePlaybackState();
});
}
void Pip::updatePlaybackState() {
const auto state = _instance.player().prepareLegacyState();
updatePlayPauseResumeState(state);
if (state.position == kTimeUnknown
|| state.length == kTimeUnknown
|| _pausedBySeek) {
return;
}
_playbackProgress->updateState(state);
updatePowerSaveBlocker(state);
qint64 position = 0;
if (Player::IsStoppedAtEnd(state.state)) {
position = state.length;
} else if (!Player::IsStoppedOrStopping(state.state)) {
position = state.position;
} else {
position = 0;
}
const auto playFrequency = state.frequency;
_lastDurationMs = (state.length * crl::time(1000)) / playFrequency;
if (_seekPositionMs < 0) {
updatePlaybackTexts(position, state.length, playFrequency);
}
}
void Pip::updatePowerSaveBlocker(const Player::TrackState &state) {
const auto block = _data->isVideoFile()
&& !IsPausedOrPausing(state.state)
&& !IsStoppedOrStopping(state.state);
base::UpdatePowerSaveBlocker(
_powerSaveBlocker,
block,
base::PowerSaveBlockType::PreventDisplaySleep,
[] { return u"Video playback is active"_q; },
[=] { return _panel.widget()->windowHandle(); });
}
void Pip::updatePlaybackTexts(
int64 position,
int64 length,
int64 frequency) {
const auto playAlready = position / frequency;
const auto playLeft = (length / frequency) - playAlready;
const auto already = Ui::FormatDurationText(playAlready);
const auto minus = QChar(8722);
const auto left = minus + Ui::FormatDurationText(playLeft);
if (_timeAlready == already && _timeLeft == left) {
return;
}
_timeAlready = already;
_timeLeft = left;
_timeLeftWidth = st::pipPlaybackFont->width(_timeLeft);
_panel.widget()->update(QRect(
_playback.area.x(),
_playback.icon.y() - st::pipPlaybackFont->height,
_playback.area.width(),
st::pipPlaybackFont->height));
}
void Pip::handleStreamingError(Streaming::Error &&error) {
_panel.widget()->close();
}
void Pip::playbackPauseResume() {
if (_instance.player().failed()) {
_panel.widget()->close();
} else if (_instance.player().finished()
|| !_instance.player().active()) {
_startPaused = false;
restartAtSeekPosition(0);
} else if (_instance.player().paused()) {
_instance.resume();
updatePlaybackState();
} else {
_instance.pause();
updatePlaybackState();
}
}
void Pip::restartAtSeekPosition(crl::time position) {
if (!_instance.info().video.cover.isNull()) {
_preparedCoverStorage = QImage();
_preparedCoverState = ThumbState::Empty;
_instance.saveFrameToCover();
}
auto options = Streaming::PlaybackOptions();
options.position = position;
options.hwAllowed = Core::App().settings().hardwareAcceleratedVideo();
options.audioId = _instance.player().prepareLegacyState().id;
options.speed = _delegate->pipPlaybackSpeed();
_instance.play(options);
if (_startPaused) {
_instance.pause();
}
_pausedBySeek = false;
updatePlaybackState();
}
bool Pip::canUseVideoFrame() const {
return _instance.player().ready()
&& !_instance.info().video.cover.isNull();
}
QImage Pip::videoFrame(const FrameRequest &request) const {
Expects(canUseVideoFrame());
return _instance.frame(request);
}
Streaming::FrameWithInfo Pip::videoFrameWithInfo() const {
Expects(canUseVideoFrame());
return _instance.frameWithInfo();
}
QImage Pip::staticContent() const {
const auto &cover = _instance.info().video.cover;
const auto media = _data->activeMediaView();
const auto use = media
? media
: _data->inlineThumbnailBytes().isEmpty()
? nullptr
: _data->createMediaView();
if (use) {
use->goodThumbnailWanted();
}
const auto good = use ? use->goodThumbnail() : nullptr;
const auto thumb = use ? use->thumbnail() : nullptr;
const auto blurred = use ? use->thumbnailInline() : nullptr;
const auto state = !cover.isNull()
? ThumbState::Cover
: good
? ThumbState::Good
: thumb
? ThumbState::Thumb
: blurred
? ThumbState::Inline
: ThumbState::Empty;
if (!_preparedCoverStorage.isNull() && _preparedCoverState >= state) {
return _preparedCoverStorage;
}
_preparedCoverState = state;
if (state == ThumbState::Cover) {
_preparedCoverStorage = _instance.info().video.cover;
} else {
_preparedCoverStorage = (good
? good
: thumb
? thumb
: blurred
? blurred
: Image::BlankMedia().get())->original();
if (!good) {
_preparedCoverStorage = Images::Blur(
std::move(_preparedCoverStorage));
}
}
return _preparedCoverStorage;
}
void Pip::paintRadialLoadingContent(
QPainter &p,
const QRect &inner,
QColor fg) const {
const auto arc = inner.marginsRemoved(QMargins(
st::radialLine,
st::radialLine,
st::radialLine,
st::radialLine));
p.setOpacity(_instance.waitingOpacity());
p.setPen(Qt::NoPen);
p.setBrush(st::radialBg);
{
PainterHighQualityEnabler hq(p);
p.drawEllipse(inner);
}
p.setOpacity(1.);
Ui::InfiniteRadialAnimation::Draw(
p,
_instance.waitingState(),
arc.topLeft(),
arc.size(),
_panel.widget()->width(),
fg,
st::radialLine);
}
QRect Pip::countRadialRect() const {
const auto outer = _panel.inner();
return {
outer.x() + (outer.width() - st::radialSize.width()) / 2,
outer.y() + (outer.height() - st::radialSize.height()) / 2,
st::radialSize.width(),
st::radialSize.height()
};
}
Pip::OverState Pip::computeState(QPoint position) const {
if (!_panel.inner().contains(position)) {
return OverState::None;
} else if (_close.area.contains(position)) {
return OverState::Close;
} else if (_enlarge.area.contains(position)) {
return OverState::Enlarge;
} else if (_playback.area.contains(position)) {
return OverState::Playback;
} else if (_volumeToggle.area.contains(position)) {
return OverState::VolumeToggle;
} else if (_volumeController.area.contains(position)) {
return OverState::VolumeController;
} else {
return OverState::Other;
}
}
void Pip::waitingAnimationCallback() {
_panel.widget()->update(countRadialRect());
}
} // namespace View
} // namespace Media