2442 lines
80 KiB
C++
2442 lines
80 KiB
C++
#include "rm_frame_video_base.h"
|
|
#include "../fm_dimensions.h"
|
|
#include "fm_logo_widget.h"
|
|
|
|
#include "../data/rm_video_item_2ch.h"
|
|
#include "../core/rm_player.h"
|
|
#include "../core/rm_play_process.h"
|
|
#include "fm_button.h"
|
|
#include "../core/fm_strings.h"
|
|
#include "fav/OpenGLVideo.h"
|
|
#include "../core/rm_math.h"
|
|
#include "rm_frame_list.h"
|
|
#include <QButtonGroup>
|
|
|
|
#if (USE_360_POSITION_VIEW)
|
|
#include <QStackedLayout>
|
|
#endif // USE_360_POSITION_VIEW
|
|
|
|
#if (RM_MODEL == RM_MODEL_TYPE_TB4000)
|
|
#include <QDialog>
|
|
#include <QLibrary>
|
|
#endif // PLAYER_ONLY_LIBRARY_MODE
|
|
|
|
#if (USE_DRAG_ZOOM)
|
|
#include "fm_drag_zoom_widget.h"
|
|
#endif
|
|
|
|
#if (USE_360_POSITION_VIEW)
|
|
#include "fm_360_position_view.h"
|
|
#endif // #if (USE_360_POSITION_VIEW)
|
|
|
|
#if (RM_MODEL == RM_MODEL_TYPE_TB4000)
|
|
#include "window_main.h"
|
|
#endif
|
|
|
|
#if (PLAYER_ONLY_LIBRARY_MODE)
|
|
#include <QStandardPaths>
|
|
#include <QFileDialog>
|
|
#endif
|
|
|
|
#include <QStyle>
|
|
|
|
#if (TOP_DOWN_360)
|
|
#include <QSettings>
|
|
#define USER_SETTINGS "HKEY_CURRENT_USER\\SOFTWARE\\TBD_VIEWER"
|
|
#endif
|
|
|
|
#if (RM_MODEL == RM_MODEL_TYPE_TB4000 && !PLAYER_ONLY_LIBRARY_MODE)
|
|
static RMVideoItem* lastPlayItem = NULL;
|
|
#endif
|
|
|
|
RMFrameVideoBase::RMFrameVideoBase(QWidget *parent,bool bMain, bool bEvent) : RMWidgetBase(parent,bEvent)
|
|
{
|
|
#if (CLICK_PAUSE_PLAY)
|
|
clickTimer = NULL;
|
|
#endif // CLICK_PAUSE_PLAY
|
|
|
|
_bIsMainVideo = _bIsFrontVideo = bMain;
|
|
|
|
layout = new QVBoxLayout(this);
|
|
ZERO_LAYOUT(layout);
|
|
//layout->setAlignment(Qt::AlignLeft | Qt::AlignTop);
|
|
|
|
_createTitleBar();
|
|
|
|
logoWidget = new FMLogoWidget(bMain,this);
|
|
#if (DUAL_VIEWER)
|
|
logoWidget->setObjectName("video_main_logo");
|
|
if(bMain == false)
|
|
{
|
|
logoWidget->setProperty("rear",true);
|
|
logoWidget->style()->unpolish(logoWidget);
|
|
logoWidget->style()->polish(logoWidget);
|
|
logoWidget->update();
|
|
}
|
|
_zoom3D = false;
|
|
#else
|
|
//logoWidget->setObjectName(bMain ? "video_main_logo" : "video_sub_logo");
|
|
#endif
|
|
logoWidget->setSizePolicy(QSizePolicy::Expanding,QSizePolicy::Expanding);
|
|
layout->addWidget(logoWidget);
|
|
|
|
#if (DUAL_VIDEO_WIDGET || TOPDOWN_360_QUAD_MODE)
|
|
// 가로 2개 채널 영상 표시
|
|
_videoBaseWidget = new QWidget(this);
|
|
layout->addWidget(_videoBaseWidget);
|
|
#if (TOPDOWN_360_QUAD_MODE) // 상하단 구분
|
|
_videoWidgetVLayout = new QVBoxLayout(_videoBaseWidget);
|
|
ZERO_LAYOUT(_videoWidgetVLayout)
|
|
_videoBaseTopWidget = new QWidget(_videoBaseWidget);
|
|
_videoBaseDownWidget = new QWidget(_videoBaseWidget);
|
|
_videoWidgetVLayout->addWidget(_videoBaseTopWidget);
|
|
_videoWidgetVLayout->addWidget(_videoBaseDownWidget);
|
|
|
|
_videoWidgetLayout = new QHBoxLayout(_videoBaseTopWidget);
|
|
ZERO_LAYOUT(_videoWidgetLayout);
|
|
_videoWidgetLayout2 = new QHBoxLayout(_videoBaseDownWidget);
|
|
ZERO_LAYOUT(_videoWidgetLayout2);
|
|
|
|
_videoWidget2 = NULL;
|
|
_videoWidget3 = NULL;
|
|
_videoWidget4 = NULL;
|
|
|
|
#else // TOPDOWN_360_QUAD_MODE
|
|
_videoWidgetLayout = new QHBoxLayout(_videoBaseWidget);
|
|
ZERO_LAYOUT(_videoWidgetLayout);
|
|
#endif // TOPDOWN_360_QUAD_MODE
|
|
#endif // #if (DUAL_VIDEO_WIDGET)
|
|
|
|
_videoWidget = NULL;
|
|
|
|
connect(RMPlayer::instance(),SIGNAL(playEvent(PLAY_EVENT, RMVideoItem*)),SLOT(onPlayEvent(PLAY_EVENT, RMVideoItem*)));
|
|
|
|
#if (LIVE_LANGUAGE_CHANGE && MODEL_STANDARD)
|
|
connect(RMLanguage::instance(),SIGNAL(languageChange(RMLanguage::LANGUAGE_TYPE)),SLOT(onLanguageChange(RMLanguage::LANGUAGE_TYPE)));
|
|
#endif
|
|
|
|
#if !(DO_NOT_USE_ZOOM)
|
|
|
|
#if !(REMOVE_ALL_SHORT_CUTS)
|
|
connect(RMApp::instance()->pipPositionShortcut,SIGNAL(activated()),SLOT(onTogglePIPLocation()));
|
|
connect(RMApp::instance()->pipToggleShortcut,SIGNAL(activated()),SLOT(onToggleShowHidePIP()));
|
|
#endif
|
|
|
|
connect(RMApp::instance(),SIGNAL(hidePIPForCapture(bool)),SLOT(onHidePIPForCapture(bool)));
|
|
// PIP
|
|
bIsFullScreen = false;
|
|
bZoomStarted = false;
|
|
#if !(ZOOM_SHADER)
|
|
bPIPRight = true;
|
|
_zoomTimer = NULL;
|
|
zoomWidget = NULL;
|
|
#endif // #if !(ZOOM_SHADER)
|
|
#endif // DO_NOT_USE_ZOOM
|
|
|
|
#if (USE_DRAG_ZOOM)
|
|
dragWidget = NULL;
|
|
#endif //
|
|
|
|
#if (!DO_NOT_USE_ZOOM || MODEL_360 || TOP_DOWN_360)
|
|
_dragStart = false;
|
|
#endif
|
|
#if (MODEL_360)
|
|
_dualMode = 0;
|
|
_offByDualMode = false;
|
|
#endif
|
|
|
|
//#if (MODEL_BBVIEWER)
|
|
// _bNoVideoData = false;
|
|
//#endif
|
|
#if (TOP_DOWN_360)
|
|
#if (RM_MODEL == RM_MODEL_TYPE_TB4000 && !PLAYER_ONLY_LIBRARY_MODE)
|
|
QSettings settings(USER_SETTINGS,QSettings::NativeFormat);
|
|
mode360 = (MODE_360)settings.value("mode_360",0).toInt();
|
|
#else // !PLAYER_ONLY_LIBRARY_MODE
|
|
mode360 = MODE_360_ROUND;
|
|
#endif // PLAYER_ONLY_LIBRARY_MODE
|
|
#if (SINGLE_CH_VIEWER)
|
|
_pVR = RMPlayer::instance()->_videoOutputF;
|
|
#else // SINGLE_CH_VIEWER
|
|
_pVR = bMain ? RMPlayer::instance()->_videoOutputF : RMPlayer::instance()->_videoOutputR;
|
|
#endif // SINGLE_CH_VIEWER
|
|
_accelerationTimer = NULL;
|
|
|
|
#if (USE_360_POSITION_VIEW)
|
|
_posView = NULL;
|
|
_posStaticView = NULL;
|
|
#endif // #if (USE_360_POSITION_VIEW)
|
|
|
|
#if (RM_MODEL_360)
|
|
#if (!USE_POINT_ZOOM || USE_HYBRID_ZOOM)
|
|
_bZoomMode = false;
|
|
QPixmap pixmapZoom;
|
|
pixmapZoom.load(":/image/vt_zoom.png");
|
|
_magnifyZoom = new QCursor(pixmapZoom);
|
|
#endif // ZOOM
|
|
|
|
refreshMode360();
|
|
#if (RM_MODEL == RM_MODEL_TYPE_TB4000)
|
|
_refresh360UI();
|
|
#endif // #if (RM_MODEL == RM_MODEL_TYPE_TB4000)
|
|
#endif // RM_MODEL_360
|
|
#endif // TOP_DOWN_360
|
|
|
|
#if (PENTA_CHANNEL)
|
|
for(int i=0;i<7;i++) {
|
|
selectButtons[i]->setHidden(true);
|
|
}
|
|
#endif // #if (PENTA_CHANNEL)
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
void RMFrameVideoBase::_createTitleBar()
|
|
{
|
|
_titleBar = new QWidget(this);
|
|
_titleBar->setObjectName("video_title");
|
|
#if (RM_MODEL == RM_MODEL_TYPE_EMT_KR)
|
|
_titleBar->setStyleSheet("QWidget#video_title{background-color: #323232;}"); //
|
|
#else
|
|
_titleBar->setStyleSheet("QWidget#video_title{background-color: #595959;}"); //
|
|
#endif
|
|
layout->addWidget(_titleBar);
|
|
|
|
QHBoxLayout* titleLayout = new QHBoxLayout(_titleBar);
|
|
titleLayout->setAlignment(Qt::AlignVCenter | Qt::AlignLeft);
|
|
ZERO_LAYOUT(titleLayout);
|
|
#if !(NO_CAMERA_TITLE)
|
|
titleLabel = new QLabel(_titleBar);
|
|
titleLabel->setAccessibleName("fm_video_title_label");
|
|
|
|
#if(REMOVE_OLD_C)
|
|
QString iconPath = _bIsMainVideo ? ":/image/title_video_front" + RMLanguage::languageTag() + ".png" : ":/image/title_video_rear" + RMLanguage::languageTag() + ".png";
|
|
#else // REMOVE_OLD_C
|
|
#if (SUB_MODEL_KEIYO_360)
|
|
QString iconPath = _bIsMainVideo ? ":/image/title_video_360.png" : ":/image/title_video_wide.png";
|
|
#else // SUB_MODEL_KEIYO_360
|
|
QString iconPath = _bIsMainVideo ? ":/image/title_video_front.png" : ":/image/title_video_rear.png";
|
|
#endif // SUB_MODEL_KEIYO_360
|
|
#if (LIVE_LANGUAGE_CHANGE)
|
|
if(RMLanguage::isJP() == false)
|
|
{
|
|
iconPath = _bIsMainVideo ? ":/image/title_video_front_en.png" : ":/image/title_video_rear_en.png";
|
|
}
|
|
#endif
|
|
#endif // #if(REMOVE_OLD_C)
|
|
|
|
titleLabel->setPixmap( QPixmap(iconPath) );
|
|
titleLabel->setSizePolicy(QSizePolicy::Fixed,QSizePolicy::Fixed);
|
|
titleLabel->setFixedHeight(VIDEO_TITLE_HEIGHT);
|
|
titleLayout->addWidget(titleLabel);
|
|
|
|
#if (RM_MODEL == RM_MODEL_TYPE_TB4000 && !PLAYER_ONLY_LIBRARY_MODE)
|
|
if(_bIsMainVideo){
|
|
btnTB5000 = FMButton::btn(_titleBar,titleLayout,"vt_detail_c","",QSize(130,26));
|
|
btnTB5000->setVisible(false);
|
|
connect(btnTB5000,SIGNAL(clicked()),SLOT(onTB5000()));
|
|
} else {
|
|
btnTB5000 = NULL;
|
|
}
|
|
#endif // TB4000
|
|
|
|
#endif // #if !(NO_CAMERA_TITLE)
|
|
|
|
#if (RM_MODEL == RM_MODEL_TYPE_KEIYO1 || RM_MODEL == RM_MODEL_TYPE_MBJ5010) // || RM_MODEL == RM_MODEL_TYPE_FC_DR232W
|
|
if(_bIsMainVideo) {
|
|
LAYOUT_SPACE(titleLayout,12,0);
|
|
QLabel* speedWarning = new QLabel(_titleBar);
|
|
speedWarning->setText(FMS::txt("speed_warning"));
|
|
speedWarning->setStyleSheet("font-family: Arial; font-size: 12px; color : #E9EC31");
|
|
titleLayout->addWidget(speedWarning);
|
|
}
|
|
#endif
|
|
|
|
#if (RM_MODEL == RM_MODEL_TYPE_AN6000)
|
|
titleLabel->setHidden(true);
|
|
#endif // RM_MODEL_TYPE_AN6000
|
|
|
|
|
|
titleTools = new QWidget(_titleBar);
|
|
titleTools->setSizePolicy(QSizePolicy::Expanding,QSizePolicy::Preferred);
|
|
|
|
titleLayout->addWidget(titleTools);
|
|
titleToolLayout = new QHBoxLayout(titleTools);
|
|
titleToolLayout->setAlignment(Qt::AlignVCenter | Qt::AlignRight);
|
|
ZERO_LAYOUT(titleToolLayout);
|
|
|
|
#if (PENTA_CHANNEL)
|
|
_createCHTool(titleTools, titleToolLayout);
|
|
#endif // PENTA_CHANNEL
|
|
|
|
#if (RM_MODEL == RM_MODEL_TYPE_TB4000)
|
|
#if (TOP_DOWN_360)
|
|
|
|
LAYOUT_SPACE(titleToolLayout,40,0);
|
|
|
|
QSize s2 = QSize(50,24);
|
|
btnMode360_2D = FMButton::btnType0(titleTools,titleToolLayout,"m360_2d","",s2,g_type_button_colors2);
|
|
btnMode360_2D->setCheckable(true);
|
|
btnMode360_3D = FMButton::btnType0(titleTools,titleToolLayout,"m360_3d","",s2,g_type_button_colors2);
|
|
btnMode360_3D->setCheckable(true);
|
|
btnMode360_4CH = FMButton::btnType0(titleTools,titleToolLayout,"m360_4ch","",s2,g_type_button_colors2);
|
|
btnMode360_4CH->setCheckable(true);
|
|
btnMode360_5CH = FMButton::btnType0(titleTools,titleToolLayout,"m360_5ch","",s2,g_type_button_colors2);
|
|
btnMode360_5CH->setCheckable(true);
|
|
connect(btnMode360_2D,SIGNAL(clicked()),SLOT(onMode360()));
|
|
connect(btnMode360_3D,SIGNAL(clicked()),SLOT(onMode360()));
|
|
connect(btnMode360_4CH,SIGNAL(clicked()),SLOT(onMode360()));
|
|
connect(btnMode360_5CH,SIGNAL(clicked()),SLOT(onMode360()));
|
|
|
|
|
|
LAYOUT_SPACE(titleToolLayout,10,0);
|
|
|
|
btnReset360 = FMButton::btnType0(titleTools,titleToolLayout,"m360_reset",FMS::txt("reset_360"),QSize(52,26),g_type_button_colors2);
|
|
connect(btnReset360,SIGNAL(clicked()),SLOT(onReset360()));
|
|
|
|
#if (PLAYER_ONLY_LIBRARY_MODE)
|
|
btnSave360 = FMButton::btnType0(titleTools,titleToolLayout,"m360_save",FMS::txt("save_360"),QSize(80,26),g_type_button_colors2);
|
|
connect(btnSave360,SIGNAL(clicked()),SLOT(onSave360()));
|
|
|
|
QSpacerItem* sp0 = new QSpacerItem(10,0,QSizePolicy::Fixed,QSizePolicy::Fixed);
|
|
titleToolLayout->addSpacerItem(sp0);
|
|
_fileNameLabel = new QLabel(titleTools);
|
|
_fileNameLabel->setStyleSheet("font-family: Arial;font-size: 12px;color : white;");
|
|
titleToolLayout->addWidget(_fileNameLabel);
|
|
#endif // PLAYER_ONLY_LIBRARY_MODE
|
|
_refresh360UI();
|
|
|
|
|
|
QSpacerItem* sp = new QSpacerItem(0,0,QSizePolicy::Expanding,QSizePolicy::Fixed);
|
|
titleToolLayout->addSpacerItem(sp);
|
|
|
|
seperator = new QLabel(titleTools);
|
|
seperator->setPixmap(QPixmap(":/image/vt_seperator.png"));
|
|
titleToolLayout->addWidget(seperator);
|
|
|
|
#endif // TOP_DOWN_360
|
|
|
|
QSize btnSize = QSize(36,36);
|
|
btnFullScreen = FMButton::btnCheck(titleTools,titleToolLayout,"title_maximize",FMS::txt("fullscreen"),btnSize);
|
|
const int space = 6;
|
|
LAYOUT_SPACE(titleToolLayout,space,0);
|
|
if(_bIsMainVideo) {
|
|
connect(btnFullScreen,SIGNAL(clicked()),RMApp::instance()->pMainWindow,SLOT(onFullScreen()));
|
|
}
|
|
else {
|
|
connect(btnFullScreen,SIGNAL(clicked()),RMApp::instance()->pMainWindow,SLOT(onFullScreenSub()));
|
|
}
|
|
#if (PLAYER_ONLY_LIBRARY_MODE)
|
|
btnFullScreen->setVisible(false);
|
|
btnClose = FMButton::btn(titleTools,titleToolLayout,"title_close",FM_WSTR(L"닫기"),QSize(36,36));
|
|
#endif //!PLAYER_ONLY_LIBRARY_MODE
|
|
|
|
#else // TB4000
|
|
QSize btnSize = QSize(30,26);
|
|
|
|
#if (TOP_DOWN_360)
|
|
btnMode360 = FMButton::btn(titleTools,titleToolLayout,"vt_360_mode",FMS::txt("mode_360"),btnSize);
|
|
LAYOUT_SPACE(titleToolLayout,2,0);
|
|
connect(btnMode360,SIGNAL(clicked()),SLOT(onMode360()));
|
|
|
|
btnReset360 = FMButton::btn(titleTools,titleToolLayout,"vt_reset",FMS::txt("reset_360"),btnSize);
|
|
LAYOUT_SPACE(titleToolLayout,2,0);
|
|
connect(btnReset360,SIGNAL(clicked()),SLOT(onReset360()));
|
|
|
|
btnZoom360 = FMButton::btn(titleTools,titleToolLayout,"vt_zoom",FMS::txt("zoom_360"),btnSize);
|
|
LAYOUT_SPACE(titleToolLayout,2,0);
|
|
connect(btnZoom360,SIGNAL(clicked()),SLOT(onZoom360()));
|
|
btnZoom360->setHidden(true);
|
|
|
|
|
|
seperator = new QLabel(titleTools);
|
|
seperator->setPixmap(QPixmap(":/image/vt_seperator.png"));
|
|
titleToolLayout->addWidget(seperator);
|
|
_refresh360UI();
|
|
const int space = 4;
|
|
#else
|
|
const int space = 6;
|
|
#endif // TOP_DOWN_360
|
|
|
|
// 2-23/07/25 180 모드의 2CH 영상에는 적용
|
|
#if (LIVE_LANGUAGE2)
|
|
btnFlipH = FMButton::btn2(titleTools,titleToolLayout,"vt_flip_h","flip_h",btnSize);
|
|
LAYOUT_SPACE(titleToolLayout,space,0);
|
|
#else // LIVE_LANGUAGE2
|
|
btnFlipH = FMButton::btn(titleTools,titleToolLayout,"vt_flip_h",FMS::txt("flip_h"),btnSize);
|
|
LAYOUT_SPACE(titleToolLayout,space,0);
|
|
#endif // LIVE_LANGUAGE2
|
|
|
|
#if (TOP_DOWN_360)
|
|
btnFlipH->setVisible(!_bIsFrontVideo);
|
|
#endif
|
|
|
|
#if !(TOP_DOWN_360)
|
|
#if (LIVE_LANGUAGE2)
|
|
//btnFlipH = FMButton::btn2(titleTools,titleToolLayout,"vt_flip_h","flip_h",btnSize);
|
|
//LAYOUT_SPACE(titleToolLayout,space,0);
|
|
btnFlipV = FMButton::btn2(titleTools,titleToolLayout,"vt_flip_v","flip_v",btnSize);
|
|
LAYOUT_SPACE(titleToolLayout,space,0);
|
|
|
|
#if !(PENTA_CHANNEL)
|
|
btnSwap = FMButton::btn2(titleTools,titleToolLayout,"vt_swap","swap",btnSize);
|
|
LAYOUT_SPACE(titleToolLayout,space,0);
|
|
#endif // PENTA_CHANNEL
|
|
|
|
#else // LIVE_LANGUAGE2
|
|
//btnFlipH = FMButton::btn(titleTools,titleToolLayout,"vt_flip_h",FMS::txt("flip_h"),btnSize);
|
|
//LAYOUT_SPACE(titleToolLayout,space,0);
|
|
btnFlipV = FMButton::btn(titleTools,titleToolLayout,"vt_flip_v",FMS::txt("flip_v"),btnSize);
|
|
LAYOUT_SPACE(titleToolLayout,space,0);
|
|
#if !(SINGLE_CH_VIEWER)
|
|
btnSwap = FMButton::btn(titleTools,titleToolLayout,"vt_swap",FMS::txt("swap"),btnSize);
|
|
LAYOUT_SPACE(titleToolLayout,space,0);
|
|
#endif // #if !(SINGLE_CH_VIEWER)
|
|
|
|
#endif // LIVE_LANGUAGE2
|
|
#else // TOP_DOWN_360
|
|
#if (LIVE_LANGUAGE2)
|
|
btnSwap = FMButton::btn2(titleTools,titleToolLayout,"vt_swap","swap",btnSize);
|
|
LAYOUT_SPACE(titleToolLayout,space,0);
|
|
#else // LIVE_LANGUAGE2
|
|
btnSwap = FMButton::btn(titleTools,titleToolLayout,"vt_swap",FMS::txt("swap"),btnSize);
|
|
LAYOUT_SPACE(titleToolLayout,space,0);
|
|
#endif // LIVE_LANGUAGE2
|
|
#endif // #if !(TOP_DOWN_360)
|
|
|
|
|
|
#if (TRI_CHANNEL || TRI_CHANNEL2)
|
|
#if (LIVE_LANGUAGE2)
|
|
#if (RM_MODEL_EMT_KR)
|
|
// 3CH 페달과 3CH INDOOR(360X) 모델이 존재함
|
|
// static FMButton* btnCheck2(QWidget* parent, QLayout* layout, const char* iconName, const char* toolTip, QSize size);
|
|
btnIndoor = FMButton::btnProperty(titleTools,titleToolLayout,"vt_ch3","ch3","wide",btnSize);
|
|
|
|
#else // RM_MODEL_EMT_KR
|
|
btnIndoor = FMButton::btn2(titleTools,titleToolLayout,"vt_reset","indoor",btnSize);
|
|
#endif
|
|
#else // LIVE_LANGUAGE2
|
|
btnIndoor = FMButton::btn(titleTools,titleToolLayout,"vt_indoor",FMS::txt("indoor"),btnSize);
|
|
#endif // LIVE_LANGUAGE2
|
|
btnIndoor->setHidden(_bIsMainVideo);
|
|
#endif // TRI_CHANNEL
|
|
|
|
#if (RM_MODEL_EMT_KR)
|
|
btn360Wide = FMButton::btnCheck2(titleTools,titleToolLayout,"vt_360","360normal",btnSize);
|
|
btn360Wide->setHidden(_bIsMainVideo);
|
|
btn360Wide->setEnabled(false);
|
|
connect(btn360Wide,SIGNAL(clicked()),this,SLOT(onToggleWideMode()));
|
|
#endif // RM_MODEL_EMT_KR
|
|
|
|
#if (LIVE_LANGUAGE2)
|
|
btnFullScreen = FMButton::btnCheck2(titleTools,titleToolLayout,"vt_fullscreen","fullscreen",btnSize);
|
|
#else // LIVE_LANGUAGE2
|
|
btnFullScreen = FMButton::btnCheck(titleTools,titleToolLayout,"vt_fullscreen",FMS::txt("fullscreen"),btnSize);
|
|
#endif // LIVE_LANGUAGE2
|
|
|
|
#if (TRI_CHANNEL2)
|
|
btnIndoor->setEnabled(false);
|
|
#endif //
|
|
|
|
LAYOUT_SPACE(titleToolLayout,space,0);
|
|
|
|
#if (TRI_CHANNEL || TRI_CHANNEL2)
|
|
connect(btnIndoor,SIGNAL(clicked()),RMPlayer::instance(),SLOT(toggleIndoor()));
|
|
#endif // TRI_CHANNEL
|
|
|
|
#if !(SINGLE_CH_VIEWER || PENTA_CHANNEL)
|
|
connect(btnSwap,SIGNAL(clicked()),RMPlayer::instance(),SLOT(toggleSwap()));
|
|
#endif // SINGLE_CH_VIEWER
|
|
|
|
if(_bIsMainVideo) {
|
|
connect(btnFlipH,SIGNAL(clicked()),RMPlayer::instance(),SLOT(onToggleHFlipMain()));
|
|
}
|
|
else {
|
|
connect(btnFlipH,SIGNAL(clicked()),RMPlayer::instance(),SLOT(onToggleHFlipSub()));
|
|
}
|
|
|
|
#if !(TOP_DOWN_360)
|
|
if(_bIsMainVideo) {
|
|
//connect(btnFlipH,SIGNAL(clicked()),RMPlayer::instance(),SLOT(onToggleHFlipMain()));
|
|
connect(btnFlipV,SIGNAL(clicked()),RMPlayer::instance(),SLOT(onToggleVFlipMain()));
|
|
}
|
|
else {
|
|
//connect(btnFlipH,SIGNAL(clicked()),RMPlayer::instance(),SLOT(onToggleHFlipSub()));
|
|
connect(btnFlipV,SIGNAL(clicked()),RMPlayer::instance(),SLOT(onToggleVFlipSub()));
|
|
}
|
|
#endif // #if !(TOP_DOWN_360)
|
|
|
|
if(_bIsMainVideo) {
|
|
connect(btnFullScreen,SIGNAL(clicked()),RMApp::instance()->pMainWindow,SLOT(onFullScreen()));
|
|
}
|
|
else {
|
|
connect(btnFullScreen,SIGNAL(clicked()),RMApp::instance()->pMainWindow,SLOT(onFullScreenSub()));
|
|
}
|
|
#endif // #if !(RM_MODEL == RM_MODEL_TYPE_TB4000)
|
|
}
|
|
#if (PENTA_CHANNEL)
|
|
void RMFrameVideoBase::_createCHTool(QWidget* parent, QHBoxLayout* layout)
|
|
{
|
|
QWidget* chWidget = new QWidget(parent);
|
|
layout->addWidget(chWidget);
|
|
QHBoxLayout* chLayout = new QHBoxLayout(chWidget);
|
|
ZERO_LAYOUT(chLayout);
|
|
chLayout->setSpacing(3);
|
|
|
|
//const char* tag = RMLanguage::instance()->languageTag().toLatin1().data();
|
|
//qInfo() << tag << __FUNCTION__;
|
|
selectButtons[0] = FMButton::btnPressCheck2(chWidget,chLayout,"select_fr","select_fr");
|
|
selectButtons[0]->valueTag = RMApp::ChannelModeFR;
|
|
|
|
selectButtons[1] = FMButton::btnPressCheck2(chWidget,chLayout,"select_lr","select_lr");
|
|
selectButtons[1]->valueTag = RMApp::ChannelModeLR;
|
|
|
|
selectButtons[2] = FMButton::btnPressCheck2(chWidget,chLayout,"select_front","select_front");
|
|
selectButtons[2]->valueTag = RMApp::ChannelModeFront;
|
|
|
|
selectButtons[3] = FMButton::btnPressCheck2(chWidget,chLayout,"select_rear","select_rear");
|
|
selectButtons[3]->valueTag = RMApp::ChannelModeRear;
|
|
|
|
selectButtons[4] = FMButton::btnPressCheck2(chWidget,chLayout,"select_left","select_left");
|
|
selectButtons[4]->valueTag = RMApp::ChannelModeLeft;
|
|
|
|
selectButtons[5] = FMButton::btnPressCheck2(chWidget,chLayout,"select_right","select_right");
|
|
selectButtons[5]->valueTag = RMApp::ChannelModeRight;
|
|
#if (USE_INDOOR_CAMERA_NAME)
|
|
selectButtons[6] = FMButton::btnPressCheck2(chWidget,chLayout,"select_indoor","select_indoor");
|
|
#else
|
|
selectButtons[6] = FMButton::btnPressCheck2(chWidget,chLayout,"select_asst","select_asst");
|
|
#endif
|
|
selectButtons[6]->valueTag = RMApp::ChannelModeSub;
|
|
selectButtons[6]->setHidden(true);
|
|
|
|
selectButtons[0]->setChecked(true);
|
|
|
|
for(int i=0;i<7;i++) {
|
|
connect(selectButtons[i],SIGNAL(clicked()),this,SLOT(onSelectVideo()));
|
|
}
|
|
layout->addSpacerItem(new QSpacerItem(1,0,QSizePolicy::Expanding,QSizePolicy::Fixed));
|
|
connect(RMLanguage::instance(),SIGNAL(languageChange(RMLanguage::LANGUAGE_TYPE)),SLOT(onLanguageChange(RMLanguage::LANGUAGE_TYPE)));
|
|
|
|
_refreshCHTool();
|
|
}
|
|
void RMFrameVideoBase::_refreshCHTool()
|
|
{
|
|
const int height = 21;
|
|
const int widthENKO = 48;
|
|
QList<int> widthJP = QList<int>() << 91 << 91 << 55 << 55 << 55 << 55 << 55;
|
|
|
|
bool isJP = RMLanguage::instance()->language() == RMLanguage::LANGUAGE_JP;
|
|
QString tag = RMLanguage::instance()->languageTag();
|
|
for(int i=0;i<7;i++) {
|
|
QString name = selectButtons[i]->objectName();
|
|
selectButtons[i]->_setPressCheckStyleSheet((name + tag).toLatin1().data());
|
|
selectButtons[i]->setFixedSize(isJP ? widthJP.at(i): widthENKO,height);
|
|
}
|
|
//_createCHTool(titleTools,titleToolLayout);
|
|
}
|
|
void RMFrameVideoBase::onSelectVideo()
|
|
{
|
|
/*
|
|
RMApp::ChannelMode mode;
|
|
FMButton* btn = qobject_cast<FMButton*>(sender());
|
|
for(int i=0;i<7;i++) {
|
|
bool selected = selectButtons[i] == btn;
|
|
selectButtons[i]->setChecked(selected);
|
|
if(selected) {
|
|
mode = (RMApp::ChannelMode)selectButtons[i]->valueTag;
|
|
}
|
|
//qInfo() << i << selectButtons[i]->isChecked() << __FUNCTION__;
|
|
}
|
|
_videoWidget2->setHidden(!(mode == RMApp::ChannelModeFR || mode == RMApp::ChannelModeLR));
|
|
RMPlayer::instance()->changeCHMode(mode); // 채널변경
|
|
//RMApp::instance()->appEvent();
|
|
*/
|
|
FMButton* btn = qobject_cast<FMButton*>(sender());
|
|
selectMode(btn->valueTag);
|
|
}
|
|
void RMFrameVideoBase::selectMode(int mode)
|
|
{
|
|
for(int i=0;i<7;i++) {
|
|
bool selected = (mode == selectButtons[i]->valueTag);
|
|
selectButtons[i]->setChecked(selected);
|
|
//qInfo() << i << selectButtons[i]->isChecked() << __FUNCTION__;
|
|
}
|
|
_videoWidget2->setHidden(!(mode == RMApp::ChannelModeFR || mode == RMApp::ChannelModeLR));
|
|
RMPlayer::instance()->changeCHMode((RMApp::ChannelMode)mode); // 채널변경
|
|
}
|
|
|
|
#endif // PENTA_CHANNEL
|
|
#if(TOPDOWN_360_QUAD_MODE)
|
|
void RMFrameVideoBase::setOtherVideoWidgets(QWidget* widget2,QWidget* widget3,QWidget* widget4)
|
|
{
|
|
_videoWidget2 = widget2;
|
|
_videoWidgetLayout->addWidget(_videoWidget2); // 우상단
|
|
_videoWidget2->setParent(_videoBaseTopWidget);
|
|
|
|
// video widget 처리 후 PIP 설정
|
|
// 처리해 두지 않으면 zoomWidget 사이즈 오류발생
|
|
_videoWidget2->setMinimumSize(160,90);
|
|
_videoWidget2->setSizePolicy(QSizePolicy::Expanding,QSizePolicy::Expanding);
|
|
|
|
_videoWidget3 = widget3;
|
|
_videoWidgetLayout2->addWidget(_videoWidget3); // 좌하단
|
|
_videoWidget3->setParent(_videoBaseDownWidget);
|
|
_videoWidget3->setMinimumSize(160,90);
|
|
_videoWidget3->setSizePolicy(QSizePolicy::Expanding,QSizePolicy::Expanding);
|
|
|
|
_videoWidget4 = widget4;
|
|
_videoWidgetLayout2->addWidget(_videoWidget4); // 좌우단
|
|
_videoWidget4->setParent(_videoBaseDownWidget);
|
|
_videoWidget4->setMinimumSize(160,90);
|
|
_videoWidget4->setSizePolicy(QSizePolicy::Expanding,QSizePolicy::Expanding);
|
|
|
|
refreshMode360();
|
|
}
|
|
#endif // TOPDOWN_360_QUAD_MODE
|
|
#if (DUAL_VIDEO_WIDGET)
|
|
void RMFrameVideoBase::setVideoWidget2(QWidget* widget)
|
|
{
|
|
_videoWidget2 = widget;
|
|
_videoWidgetLayout->addWidget(_videoWidget2);
|
|
_videoWidget2->setParent(_videoBaseWidget);
|
|
|
|
// video widget 처리 후 PIP 설정
|
|
// 처리해 두지 않으면 zoomWidget 사이즈 오류발생
|
|
_videoWidget2->setMinimumSize(160,90);
|
|
_videoWidget2->setSizePolicy(QSizePolicy::Expanding,QSizePolicy::Expanding);
|
|
}
|
|
#endif // DUAL_VIDEO_WIDGET
|
|
void RMFrameVideoBase::setVideoWidget(QWidget* widget)
|
|
{
|
|
_videoWidget = widget;
|
|
|
|
#if (DUAL_VIDEO_WIDGET)
|
|
_videoBaseWidget->setHidden(true);
|
|
_videoWidgetLayout->addWidget(_videoWidget);
|
|
_videoWidget->setParent(_videoBaseWidget);
|
|
#elif (TOPDOWN_360_QUAD_MODE)
|
|
_videoBaseWidget->setHidden(true);
|
|
_videoWidgetLayout->addWidget(_videoWidget);
|
|
_videoWidget->setParent(_videoBaseTopWidget);
|
|
#else // DUAL_VIDEO_WIDGET
|
|
_videoWidget->setHidden(true);
|
|
_videoWidget->setParent(this);
|
|
layout->addWidget(_videoWidget);
|
|
#endif // DUAL_VIDEO_WIDGET
|
|
|
|
// video widget 처리 후 PIP 설정
|
|
// 처리해 두지 않으면 zoomWidget 사이즈 오류발생
|
|
_videoWidget->setMinimumSize(160,90);
|
|
|
|
if(_bIsMainVideo) {
|
|
_videoWidget->setSizePolicy(QSizePolicy::Expanding,QSizePolicy::Expanding);
|
|
}
|
|
else {
|
|
// 339,188
|
|
_videoWidget->setSizePolicy(QSizePolicy::Expanding,QSizePolicy::Expanding);
|
|
#if (DUAL_VIEWER)
|
|
FAV::VideoRenderer* vr = RMPlayer::instance()->_videoOutputR;
|
|
vr->opengl()->setAngle(0.0);
|
|
vr->opengl()->setDualFront(_bIsMainVideo);
|
|
#endif
|
|
}
|
|
|
|
#if !(DO_NOT_USE_ZOOM || ZOOM_SHADER)
|
|
// ZOOM WIDGET
|
|
videoLayout = new QHBoxLayout(_videoWidget);
|
|
|
|
zoomWidget = new QWidget(_videoWidget);
|
|
zoomWidget->setObjectName("test_widget");
|
|
zoomWidget->setSizePolicy(QSizePolicy::Fixed,QSizePolicy::Fixed);
|
|
|
|
// video widet 에서 가져옴
|
|
videoLayout->addWidget(zoomWidget);
|
|
|
|
// zoom layout 에 새로운 video target 이 추가됨
|
|
zoomLayout = new QHBoxLayout(zoomWidget);
|
|
zoomLayout->setContentsMargins(1,1,1,1);
|
|
zoomLayout->setSpacing(0);
|
|
|
|
zoomPos = NULL;
|
|
zoomVideoWidget = NULL;
|
|
|
|
refreshPIP();
|
|
zoomWidget->setHidden(true);
|
|
#endif // @DO_NOT_USE_ZOOM || @ZOOM_SHADER
|
|
|
|
#if (USE_DRAG_ZOOM)
|
|
QHBoxLayout* drawRectLayout = new QHBoxLayout(_videoWidget);
|
|
ZERO_LAYOUT(drawRectLayout);
|
|
dragWidget = new FMDragZoomWidget(_videoWidget);
|
|
drawRectLayout->addWidget(dragWidget);
|
|
if(_bIsMainVideo) {
|
|
RMPlayer::instance()->setROIWidget(dragWidget);
|
|
} else {
|
|
RMPlayer::instance()->setROIWidgetRear(dragWidget);
|
|
}
|
|
#if (CLICK_PAUSE_PLAY)
|
|
connect(dragWidget,SIGNAL(clicked()),this,SLOT(onClicked()));
|
|
#endif // CLICK_PAUSE_PLAY
|
|
|
|
#if (TOP_DOWN_360)
|
|
dragWidget->_disabled = !(mode360 == MODE_360_ROUND);
|
|
#endif // TOP_DOWN_360
|
|
#endif // USE_DRAG_ZOOM
|
|
|
|
#if (USE_360_POSITION_VIEW)
|
|
videoLayout = new QStackedLayout(dragWidget);
|
|
ZERO_LAYOUT(videoLayout);
|
|
//videoLayout->setContentsMargins(10,10,10,10);
|
|
//videoLayout->setAlignment(Qt::AlignTop|Qt::AlignRight);
|
|
|
|
_posStaticView = new FM360StaticPositionView(dragWidget);
|
|
_posStaticView->setMode(mode360);
|
|
videoLayout->addWidget(_posStaticView);
|
|
|
|
_posView = new FM360PositionView(dragWidget);
|
|
_posView->setObjectName("test_widget");
|
|
//_posView->setSizePolicy(QSizePolicy::Fixed,QSizePolicy::Fixed);
|
|
_posView->setStyleSheet("FM360PositionView{background-color: #FF0000;}");
|
|
// video widet 에서 가져옴
|
|
videoLayout->addWidget(_posView);
|
|
_posView->setHidden(mode360 != MODE_360_VR);
|
|
connect(_posView,SIGNAL(angleUpdated(double,double)),this,SLOT(onAngleUpdated(double,double)));
|
|
videoLayout->setCurrentIndex(0);
|
|
|
|
if(mode360 == MODE_360_VR) {
|
|
double ax, ay;
|
|
_pVR->opengl()->angle(&ax,&ay);
|
|
_posView->setAngle(ax,ay);
|
|
}
|
|
#endif // #if (USE_360_POSITION_VIEW)
|
|
}
|
|
#if (USE_360_POSITION_VIEW)
|
|
void RMFrameVideoBase::onAngleUpdated(double yaw,double pitch)
|
|
{
|
|
_pVR->opengl()->setAngle(yaw,pitch);
|
|
_pVR->widget()->update();
|
|
}
|
|
#endif
|
|
void RMFrameVideoBase::onAppEvent(RMApp::Event event,int param)
|
|
{
|
|
Q_UNUSED(param)
|
|
#if (RM_MODEL == RM_MODEL_TYPE_TB4000)
|
|
if(event == RMApp::WillFullScreen || event == RMApp::WillNormalScreen)
|
|
{
|
|
#if (RM_MODEL == RM_MODEL_TYPE_TB4000 && !PLAYER_ONLY_LIBRARY_MODE)
|
|
WindowMain* pw = (WindowMain*)RMApp::instance()->pMainWindow;
|
|
if(btnTB5000 != NULL) {
|
|
// 2CH 전체화면 전환일 경우
|
|
if(event == RMApp::WillFullScreen && pw->bSubFullScreen) {
|
|
btnTB5000->setVisible(false);
|
|
}
|
|
else if (event == RMApp::WillNormalScreen) {
|
|
// 2CH 에서 복귀시에는 2CH 영상이 전방 영상으로 지정되어 있어
|
|
// 해상도 비율로 확인 불가... -> isContain360Frame 으로 둘다 확인
|
|
btnTB5000->setVisible(RMPlayer::instance()->isContain360Frame());
|
|
}
|
|
}
|
|
#if (DRAG_ZOOM_BY_RATIO)
|
|
// 후방 전체화면/복귀시 비율 조절 (MAIN VIDEO FRAME 에서만 발생하게 되므로, _bIsMainVideo 만 적용)
|
|
if(_bIsMainVideo) {
|
|
QSize fs = pw->bSubFullScreen ? RMPlayer::instance()->rearFrameSize() : RMPlayer::instance()->frameSize();
|
|
if (fs.height() > 0) {
|
|
qreal wr = (qreal)fs.width() / (qreal)fs.height();
|
|
dragWidget->ratio = (wr < 1.1) ? QSize(1,1) : QSize(16000,9000);
|
|
}
|
|
}
|
|
#endif // DRAG_ZOOM_BY_RATIO
|
|
|
|
#endif // TB4000 360 자세히 감추기, 보이기
|
|
|
|
// 최대화의 경우 제거
|
|
if(RMApp::mMAXIMIZE) {
|
|
btnFullScreen->setToolTip(FMS::txt("fullscreen"));
|
|
btnFullScreen->setChecked(false);
|
|
} else {
|
|
btnFullScreen->setToolTip(event == RMApp::WillFullScreen ? FMS::txt("restore_window") : FMS::txt("fullscreen"));
|
|
btnFullScreen->setChecked(event == RMApp::WillFullScreen);
|
|
}
|
|
}
|
|
#else // !RM_MODEL_TYPE_TB4000
|
|
if(event == RMApp::WillFullScreen || event == RMApp::WillNormalScreen)
|
|
{
|
|
// WindowMain* pw = RMApp::instance()->pMainWindow;
|
|
// // 최대화의 경우 제거
|
|
// btnFullScreen->setHidden(pw->mMAXIMIZE);
|
|
|
|
btnFullScreen->setToolTip(event == RMApp::WillFullScreen ? FMS::txt("restore_window") : FMS::txt("fullscreen"));
|
|
btnFullScreen->setChecked(event == RMApp::WillFullScreen);
|
|
#if (USE_MAXIMIZE)
|
|
btnFullScreen->setHidden(event == RMApp::WillFullScreen && param == 1);
|
|
#endif
|
|
btnFullScreen->setToolTip(event == RMApp::WillFullScreen ? FMS::txt("restore_window") : FMS::txt("fullscreen"));
|
|
#if (RM_MODEL == RM_MODEL_TYPE_XLDR_88 || RM_MODEL == RM_MODEL_TYPE_BV2000)
|
|
btnFullScreen->setChecked(event == RMApp::WillFullScreen);
|
|
#endif
|
|
#if !(DO_NOT_USE_ZOOM)
|
|
if(bZoomStarted) {
|
|
onToggleZoom();
|
|
}
|
|
#endif
|
|
|
|
#if (MODEL_WATEX)
|
|
if(_bIsMainVideo)
|
|
{
|
|
bool isFullScreen = event == RMApp::WillFullScreen;
|
|
logoWidget->setObjectName(isFullScreen ? "video_main_logo_max" : "video_main_logo");
|
|
logoWidget->setProperty("rear",_bIsFront ? false : true);
|
|
logoWidget->style()->unpolish(logoWidget);
|
|
logoWidget->style()->polish(logoWidget);
|
|
logoWidget->update();
|
|
}
|
|
#endif
|
|
|
|
#if (DUAL_VIEWER) // Base 에서 처리함
|
|
bIsFullScreen = event == RMApp::WillFullScreen;
|
|
#if (MODEL_STANDARD)
|
|
titleLabel->setHidden(bIsFullScreen);
|
|
#endif
|
|
this->setFixedHeight(bIsFullScreen ? QWIDGETSIZE_MAX : MAIN_VIDEO_CONTROL_HEIGHT);
|
|
this->setSizePolicy(QSizePolicy::Expanding,bIsFullScreen ? QSizePolicy::Preferred : QSizePolicy::Fixed);
|
|
#if !(DO_NOT_USE_ZOOM)
|
|
refreshPIP();
|
|
#endif
|
|
#endif // DUAL_VIEWER
|
|
|
|
}
|
|
#endif // #if !(RM_MODEL == RM_MODEL_TYPE_TB4000)
|
|
}
|
|
// 영상 존재하지 않을 경우 끄기
|
|
void RMFrameVideoBase::_videoOnOff(bool on)
|
|
{
|
|
bool bLoaded = on;//(event == PLAY_DID_FIRST_FRAME);
|
|
#if (DUAL_VIDEO_WIDGET || TOPDOWN_360_QUAD_MODE)
|
|
QWidget* vw = _videoBaseWidget;
|
|
#else // DUAL_VIDEO_WIDGET
|
|
QWidget* vw = _videoWidget;
|
|
#endif // DUAL_VIDEO_WIDGET
|
|
if (bLoaded)
|
|
{
|
|
if(vw != NULL && vw->isHidden() == true)
|
|
{
|
|
layout->removeWidget(logoWidget);
|
|
logoWidget->setHidden(true);
|
|
vw->setHidden(false);
|
|
vw->setParent(this);
|
|
|
|
layout->insertWidget(layout->indexOf(_titleBar)+1,vw);
|
|
|
|
|
|
// 화면 표시 시간
|
|
LOG_VLOAD << QString(_bIsMainVideo ? "PLAYER (main) DID SHOW" : "PLAYER (Sub) DID SHOW") << LOG_VLOAD_T;
|
|
}
|
|
|
|
// 파일 변경시 해상도가 다른 경우가 있어 ZOOM 을 다시 설정해야함
|
|
#if !(DO_NOT_USE_ZOOM || ZOOM_SHADER)
|
|
if(bZoomStarted) {
|
|
QTimer::singleShot(10,this,SLOT(onForceUpdateZoom()));
|
|
}
|
|
#endif
|
|
|
|
}
|
|
else {
|
|
|
|
setHidden(true);
|
|
layout->removeWidget(vw);
|
|
if(vw != NULL)
|
|
{
|
|
vw->setHidden(true);
|
|
}
|
|
logoWidget->setHidden(false);
|
|
logoWidget->setParent(this);
|
|
#if (MODEL_STANDARD)
|
|
layout->insertWidget(layout->indexOf(_titleBar)+1,logoWidget);
|
|
#else // MODEL_STANDARD
|
|
layout->insertWidget(1,logoWidget);
|
|
#endif // MODEL_STANDARD
|
|
|
|
#if (MODEL_360)
|
|
if(_bIsMainVideo || _offByDualMode == false)
|
|
{
|
|
setHidden(false);
|
|
}
|
|
#else // MODEL_360
|
|
setHidden(false);
|
|
#endif // MODEL_360
|
|
}
|
|
}
|
|
#if (MODEL_360)
|
|
void RMFrameVideoBase::dualOff(bool off)
|
|
{
|
|
_offByDualMode = off;
|
|
setHidden(off);
|
|
}
|
|
void RMFrameVideoBase::setDualMode(bool dual)
|
|
{
|
|
_dualMode = dual;
|
|
FAV::VideoRenderer* vr = _bIsMainVideo ? RMPlayer::instance()->_videoOutputF : RMPlayer::instance()->_videoOutputR;
|
|
vr->opengl()->setDualMode(dual ? 1 : 0);
|
|
|
|
if(dual == 0) {
|
|
vr->opengl()->setAngle(_bIsMainVideo ? 0.5 : 0.0);
|
|
//vr->setOutAspectRatioMode(FAV::VideoRenderer::VideoAspectRatio);
|
|
vr->setOutAspectRatioMode(FAV::VideoRenderer::RendererAspectRatio);
|
|
}
|
|
else
|
|
{
|
|
vr->setOutAspectRatioMode(FAV::VideoRenderer::CustomAspectRation); // ?CustomAspectRation
|
|
vr->setOutAspectRatio(_resolution.width() / (_resolution.height() / 2.0)); // top down dual
|
|
}
|
|
}
|
|
|
|
#endif // MODEL_360
|
|
void RMFrameVideoBase::onPlayEvent(PLAY_EVENT event, RMVideoItem* item)
|
|
{
|
|
if(event == PLAY_DID_SWAPPED || event == PLAY_DID_UNSWAPPED)
|
|
{
|
|
_bIsFrontVideo = (_bIsMainVideo == (event == PLAY_DID_UNSWAPPED));
|
|
refreshLanguage();
|
|
|
|
logoWidget->setStyle(_bIsFrontVideo);
|
|
refreshVideoOff();
|
|
|
|
#if (TOP_DOWN_360)
|
|
_refresh360UI();
|
|
#endif
|
|
|
|
#if (RM_MODEL_EMT_KR)
|
|
btn360Wide->setHidden(_bIsFrontVideo);
|
|
if(item != NULL) {
|
|
btn360Wide->setEnabled(item->isWideMode());
|
|
btn360Wide->setChecked(RMPlayer::instance()->isWideMode());
|
|
}
|
|
btn360Wide->setToolTip(btn360Wide->isChecked() ? FMS::txt("360wide") : FMS::txt("360normal"));
|
|
|
|
#endif // RM_MODEL_EMT_KR
|
|
|
|
#if (TRI_CHANNEL || TRI_CHANNEL2)
|
|
// 후방만 실내 버튼 표시
|
|
btnIndoor->setHidden(_bIsFrontVideo);
|
|
#if (TRI_CHANNEL2)
|
|
if(item != NULL) {
|
|
// 영상 파일의 채널이 2이상일 경우
|
|
btnIndoor->setEnabled(item->realCHCount() > 2);
|
|
// 영상이 WIDE 지원 영상일 경우 (실내 아이콘으로 표시)
|
|
btnIndoor->updateProperty("wide",item->isWideMode());
|
|
btnIndoor->setToolTip(FMS::txt("ch3_wide"));
|
|
} else {
|
|
btnIndoor->setEnabled(false);
|
|
btnIndoor->setToolTip(FMS::txt("ch3"));
|
|
}
|
|
#endif //
|
|
|
|
#endif // TRI_CHANNEL
|
|
|
|
#if (TOP_DOWN_360 && !(RM_MODEL == RM_MODEL_TYPE_TB4000))
|
|
btnFlipH->setVisible(!_bIsFrontVideo);
|
|
#endif
|
|
|
|
// 화면 해상도 비율로 업데이트
|
|
#if (USE_ZOOM_WH_RATIO)
|
|
refreshZoomWidgetWH();
|
|
#endif
|
|
|
|
#if !(DO_NOT_USE_ZOOM || ZOOM_SHADER)
|
|
if(bZoomStarted) {
|
|
zoomVideoWidget->update(); // 다시 PAINT
|
|
}
|
|
#endif
|
|
}
|
|
#if (TRI_CHANNEL || TRI_CHANNEL2)
|
|
else if(event == PLAY_DID_INDOOR_CH || event == PLAY_DID_OUTDOOR_CH)
|
|
{
|
|
refreshTitle(false);
|
|
#if (TRI_CHANNEL2)
|
|
// CH3 일때만 처리 가능
|
|
btn360Wide->setEnabled(RMPlayer::instance()->isIndoor() && RMPlayer::instance()->itemIsWideMode());
|
|
#endif //
|
|
}
|
|
#endif
|
|
// LOGO 처리
|
|
else if (event == PLAY_DID_FIRST_FRAME || event == PLAY_DID_CLEARED) {
|
|
|
|
#if (RM_MODEL == RM_MODEL_TYPE_TB4000 && !PLAYER_ONLY_LIBRARY_MODE)
|
|
if(_bIsMainVideo) {
|
|
btnTB5000->setVisible(false);
|
|
if(event == PLAY_DID_FIRST_FRAME) {
|
|
// 여기서는 pw->bSubFullScreen 라고 하더라도 이미 전후방 전환되어 있으므로 frameSize() 만 확인하면 됨
|
|
QSize fs = RMPlayer::instance()->frameSize();
|
|
if (fs.height() > 0) {
|
|
WindowMain* pw = (WindowMain*)RMApp::instance()->pMainWindow;
|
|
qreal wr = (qreal)fs.width() / (qreal)fs.height();
|
|
// 후방 전체화면일 경우는 무조건 감추기
|
|
btnTB5000->setVisible(wr < 1.1 && !pw->bSubFullScreen);
|
|
#if (DRAG_ZOOM_BY_RATIO)
|
|
dragWidget->ratio = (wr < 1.1) ? QSize(1,1) : QSize(16000,9000);
|
|
#endif //
|
|
}
|
|
}
|
|
}
|
|
#endif // #if (RM_MODEL == RM_MODEL_TYPE_TB4000 && !PLAYER_ONLY_LIBRARY_MODE)
|
|
|
|
#if (PLAY_CONTINUE_EVENT)
|
|
// 로딩...등 다음파일 플레이시 변화 없도록 처리
|
|
if(event == PLAY_DID_CLEARED && (item != NULL || RMPlayProcess::instance()->isLoadingNextFile()))
|
|
{
|
|
return;
|
|
}
|
|
#endif // PLAY_CONTINUE_EVENT
|
|
if(event == PLAY_DID_CLEARED || item == NULL)
|
|
{
|
|
#if (PLAYER_ONLY_LIBRARY_MODE)
|
|
_fileNameLabel->setText("");
|
|
#endif // LIBRARY_MODE
|
|
//_bIsForceToggle = false;
|
|
_videoOnOff(false);
|
|
#if (PENTA_CHANNEL)
|
|
for(int i=0;i<7;i++) {
|
|
selectButtons[i]->setHidden(true);
|
|
}
|
|
#endif // #if (PENTA_CHANNEL)
|
|
|
|
#if (RM_MODEL_EMT_KR)
|
|
btnIndoor->setEnabled(false);
|
|
btn360Wide->setEnabled(false);
|
|
#endif //
|
|
|
|
#if !(NO_CAMERA_TITLE)
|
|
refreshTitle(false); // 전후방 강제 전환
|
|
#endif // #if !(NO_CAMERA_TITLE)
|
|
}
|
|
else
|
|
{
|
|
#if (PLAYER_ONLY_LIBRARY_MODE)
|
|
_fileNameLabel->setText(item->title());
|
|
#endif // LIBRARY_MODE
|
|
|
|
refreshVideoOff();
|
|
}
|
|
}
|
|
else if (event == PLAY_DID_LOADED && item != NULL)
|
|
{
|
|
//qInfo() << this->size() << __FUNCTION__;
|
|
//_bIsForceToggle = item->forceSwap; // 후방파일만 존재하여 강제 토글
|
|
#if (PENTA_CHANNEL)
|
|
// 각 항목별 시나리오 적용
|
|
bool bStatus[7] = {false,};
|
|
if(item != NULL) {
|
|
bStatus[2] = !item->filePath.isEmpty(); // 전
|
|
bStatus[3] = !item->filePathCH2.isEmpty(); // 후
|
|
bStatus[4] = !item->filePathCH3.isEmpty(); // 좌
|
|
bStatus[5] = !item->filePathCH4.isEmpty(); // 우
|
|
bStatus[6] = !item->filePathCH5.isEmpty(); // 보조
|
|
bStatus[0] = bStatus[2] && bStatus[3]; // 전+후
|
|
bStatus[1] = bStatus[4] && bStatus[5]; // 좌+우
|
|
}
|
|
for(int i=0;i<7;i++) {
|
|
selectButtons[i]->setHidden(!bStatus[i]);
|
|
}
|
|
// 현재 모드가 지원하는 모드인지 확인
|
|
bool bCurrentModeIsOK = true;
|
|
switch(RMApp::instance()->chMode) {
|
|
case RMApp::ChannelModeFR: // 전후
|
|
bCurrentModeIsOK = bStatus[0];
|
|
break;
|
|
case RMApp::ChannelModeLR: // 좌우
|
|
bCurrentModeIsOK = bStatus[1];
|
|
break;
|
|
case RMApp::ChannelModeFront: // 전
|
|
bCurrentModeIsOK = bStatus[2];
|
|
break;
|
|
case RMApp::ChannelModeRear: // 후
|
|
bCurrentModeIsOK = bStatus[3];
|
|
break;
|
|
case RMApp::ChannelModeLeft: // 좌
|
|
bCurrentModeIsOK = bStatus[4];
|
|
break;
|
|
case RMApp::ChannelModeRight: //우
|
|
bCurrentModeIsOK = bStatus[5];
|
|
break;
|
|
case RMApp::ChannelModeSub: // 보조
|
|
bCurrentModeIsOK = bStatus[6];
|
|
break;
|
|
}
|
|
|
|
// 현재 모드 사용 불가능 할 경우
|
|
if(!bCurrentModeIsOK) {
|
|
for(int i=0;i<7;i++){
|
|
if(bStatus[i]){ // 처음부터 사용가능한 모드 확인후 전환
|
|
selectMode(selectButtons[i]->valueTag);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
#endif // PENTA_CHANNEL
|
|
|
|
// 화면 해상도 비율로 업데이트
|
|
#if (USE_ZOOM_WH_RATIO)
|
|
refreshZoomWidgetWH();
|
|
#endif
|
|
|
|
#if !(DO_NOT_USE_ZOOM || ZOOM_SHADER)
|
|
if(bZoomStarted) {
|
|
#if (USE_ZOOM_WH_RATIO)
|
|
// 파일 다시 로딩시 해상도가 변경될 경우 setOutAspectRatioMode 다시 변경 해야함.
|
|
RMPlayer::instance()->updateZoomAspectRatio();
|
|
#endif
|
|
zoomVideoWidget->update(); // 다시 PAINT
|
|
}
|
|
#endif // DO_NOT_USE_ZOOM
|
|
|
|
#if (TRI_CHANNEL2)
|
|
btnIndoor->setEnabled(!_bIsFrontVideo && item->realCHCount() == 3);
|
|
btnIndoor->updateProperty("wide",item->isWideMode());
|
|
btnIndoor->setToolTip(item->isWideMode() ? FMS::txt("ch3_wide") : FMS::txt("ch3"));
|
|
|
|
#endif //
|
|
#if (RM_MODEL_EMT_KR)
|
|
btn360Wide->setEnabled(!_bIsFrontVideo && RMPlayer::instance()->isIndoor() && RMPlayer::instance()->itemIsWideMode());
|
|
#endif // RM_MODEL_EMT_KR
|
|
|
|
_resolution = RMPlayer::instance()->playerF()->videoResolution();
|
|
//qInfo() << item->isSingleChannel() << __FUNCTION__;
|
|
refreshButtons(!item->isSingleChannel());
|
|
#if (TOGGLE_PLAYER)
|
|
bool forceSwap = (item->isRearOnly() && !RMPlayer::instance()->isSwapped()) ||
|
|
(item->isFrontOnly() && RMPlayer::instance()->isSwapped());
|
|
#else
|
|
bool forceSwap = item->isRearOnly();
|
|
#endif
|
|
|
|
//qInfo() << "forceSwap:" << forceSwap << "item->isRearOnly():" << item->isRearOnly() << LOG_FL;
|
|
#if !(NO_CAMERA_TITLE)
|
|
refreshTitle(forceSwap); // 전후방 강제 전환
|
|
#endif // #if !(NO_CAMERA_TITLE)
|
|
#if !(TOGGLE_PLAYER)
|
|
if(item->isSingleChannel()) {
|
|
bool frontLogo = _bIsFrontVideo;
|
|
if(forceSwap) {
|
|
frontLogo = !frontLogo;
|
|
}
|
|
logoWidget->setStyle(frontLogo);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
}
|
|
void RMFrameVideoBase::refreshButtons(bool bSingle)
|
|
{
|
|
#if !(RM_MODEL == RM_MODEL_TYPE_TB4000)
|
|
#if !(SINGLE_CH_VIEWER || PENTA_CHANNEL)
|
|
btnSwap->setEnabled(bSingle);
|
|
#endif // #if !(SINGLE_CH_VIEWER)
|
|
#endif // RM_MODEL_TYPE_TB4000
|
|
|
|
}
|
|
|
|
#if (RM_MODEL == RM_MODEL_TYPE_TB4000 && !PLAYER_ONLY_LIBRARY_MODE)
|
|
// 함수 포인터 타입 정의
|
|
//typedef QMainWindow* (*createTB5000WindowFunc)(QWidget*,RMSettings*,RMVideoItem*,RMVideoFileList*);
|
|
void onTB5000CallBack(int code) {
|
|
qInfo() << code << __FUNCTION__;
|
|
WindowMain* p = qobject_cast<WindowMain*>(RMApp::instance()->pMainWindow);
|
|
switch(code) {
|
|
case 0:
|
|
RMApp::isTB5000 = false;
|
|
if(lastPlayItem != NULL) {
|
|
emit RMApp::instance()->tb5000Close(lastPlayItem);
|
|
}
|
|
break;
|
|
case 1:
|
|
p->onPrevious();
|
|
break;
|
|
case 2:
|
|
p->onNext();
|
|
break;
|
|
}
|
|
}
|
|
|
|
void RMFrameVideoBase::onTB5000()
|
|
{
|
|
// WindowMain* pw = qobject_cast<WindowMain*>(RMApp::instance()->pMainWindow);
|
|
// pw->onFullScreen();
|
|
|
|
lastPlayItem = RMPlayer::instance()->getCurrentItem();
|
|
RMPlayer::instance()->prepareForCapture();
|
|
QMainWindow* p5 = createTB5000Window(RMApp::instance()->pMainWindow,
|
|
RMSettings::instance(),
|
|
lastPlayItem,
|
|
RMVideoFileList::instance(),
|
|
onTB5000CallBack);
|
|
|
|
p5->setWindowModality(Qt::ApplicationModal);
|
|
p5->show();
|
|
RMApp::isTB5000 = true;
|
|
}
|
|
#endif // RM_MODEL
|
|
|
|
|
|
void RMFrameVideoBase::refreshVideoOff()
|
|
{
|
|
bool videoOn = true;
|
|
if(_bIsFrontVideo == true && RMPlayer::instance()->playerF()->isLoaded() == false)
|
|
{
|
|
videoOn = false;
|
|
}
|
|
#if !(SINGLE_CH_VIEWER)
|
|
if(_bIsFrontVideo == false && RMPlayer::instance()->playerR()->isLoaded() == false)
|
|
{
|
|
videoOn = false;
|
|
}
|
|
#endif // SINGLE_CH_VIEWER
|
|
|
|
_videoOnOff(videoOn);
|
|
}
|
|
|
|
#if (ZOOM_SHADER)
|
|
void RMFrameVideoBase::onToggleZoom()
|
|
{
|
|
|
|
}
|
|
void RMFrameVideoBase::mousePressEvent(QMouseEvent* event)
|
|
{
|
|
_dragStart = true;
|
|
_dragPos = event->pos();
|
|
}
|
|
void RMFrameVideoBase::mouseMoveEvent(QMouseEvent* event)
|
|
{
|
|
if(bZoomStarted == false) {
|
|
return;
|
|
}
|
|
//_updateZoomProcess(event->pos());
|
|
}
|
|
void RMFrameVideoBase::mouseReleaseEvent(QMouseEvent* event)
|
|
{
|
|
if(bZoomStarted == false) {
|
|
return;
|
|
}
|
|
_dragStart = false;
|
|
//_updateZoomProcess(event->pos());
|
|
}
|
|
void RMFrameVideoBase::mouseDoubleClickEvent(QMouseEvent* e)
|
|
{
|
|
#if (MODEL_STANDARD)
|
|
// 타이틀 클릭 방지
|
|
if(e->pos().y() < titleLabel->size().height() ||
|
|
RMPlayer::instance()->playerF()->isLoaded() == false ) {
|
|
return;
|
|
}
|
|
#else
|
|
Q_UNUSED(e)
|
|
#endif
|
|
onToggleZoom();
|
|
}
|
|
void RMFrameVideoBase::onHidePIPForCapture(bool hide)
|
|
{
|
|
|
|
}
|
|
void RMFrameVideoBase::onToggleShowHidePIP()
|
|
{
|
|
if(bZoomStarted) {
|
|
}
|
|
}
|
|
void RMFrameVideoBase::onTogglePIPLocation()
|
|
{
|
|
}
|
|
|
|
#endif // ZOOM_SHADER
|
|
|
|
#if !(DO_NOT_USE_ZOOM || ZOOM_SHADER)
|
|
// ----------------------------------------------------------------------------
|
|
void RMFrameVideoBase::refreshPIP()
|
|
{
|
|
if(_videoWidget == NULL) {
|
|
return;
|
|
}
|
|
|
|
// int top_margin = bIsFullScreen ? 44 : 17;
|
|
// int lr_margin = bIsFullScreen ? 50 : 18;
|
|
// QSize zoomSize = bIsFullScreen ? QSize(480,270) : QSize(166,93);
|
|
|
|
int top_margin = bIsFullScreen ? 44 : pipRect.top();
|
|
int lr_margin = bIsFullScreen ? 50 : pipRect.left();
|
|
QSize zoomSize = bIsFullScreen ? QSize(480,270) :pipRect.size();
|
|
|
|
zoomWidget->setFixedSize(zoomSize);
|
|
|
|
if (bPIPRight) {
|
|
videoLayout->setAlignment(Qt::AlignTop | Qt::AlignRight);
|
|
videoLayout->setContentsMargins(0,top_margin,lr_margin,0);
|
|
}
|
|
else {
|
|
videoLayout->setAlignment(Qt::AlignTop | Qt::AlignLeft);
|
|
videoLayout->setContentsMargins(lr_margin,top_margin,0,0);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
void RMFrameVideoBase::_updateZoomProcess(QPoint pos)
|
|
{
|
|
_zoomPos = pos;
|
|
if(_zoomTimer != NULL) {
|
|
return;
|
|
}
|
|
_zoomTimer = new QTimer();
|
|
_zoomTimer->setSingleShot(true);
|
|
_zoomTimer->setInterval(50);
|
|
connect(_zoomTimer,SIGNAL(timeout()),SLOT(onUpdateZoom()));
|
|
_zoomTimer->start();
|
|
}
|
|
#if (RM_MODEL_EMT_KR)
|
|
void RMFrameVideoBase::onToggleWideMode()
|
|
{
|
|
bool bWide = btn360Wide->isChecked();
|
|
btn360Wide->setToolTip(bWide ? FMS::txt("360wide") : FMS::txt("360normal"));
|
|
RMPlayer::instance()->toggleWide();
|
|
}
|
|
#endif // RM_MODEL_EMT_KR
|
|
void RMFrameVideoBase::onUpdateZoom()
|
|
{
|
|
//qInfo() << __FUNCTION__;
|
|
|
|
if(_zoomTimer != NULL) {
|
|
delete _zoomTimer;
|
|
_zoomTimer = NULL;
|
|
}
|
|
|
|
if(_dragStart == false) {
|
|
return;
|
|
}
|
|
// 누적 되지 않도록
|
|
float x = (float)(_dragPos.x() - _zoomPos.x()) / ((float) size().width());
|
|
float y = (float)(_dragPos.y() - _zoomPos.y()) / ((float) size().height());
|
|
|
|
// 2배 확대된 상태이니 화면의 절반으로 처리
|
|
x *= 0.5;
|
|
y *= 0.5;
|
|
if(zoomPos != NULL) {
|
|
|
|
zoomPos->setPos(x,y);
|
|
RMPlayer::instance()->updateZoom(zoomPos->_x,zoomPos->_y,_bIsMainVideo);
|
|
}
|
|
}
|
|
void RMFrameVideoBase::onForceUpdateZoom()
|
|
{
|
|
// 실패할 경우 재시도
|
|
// Seamless Play 시 이전 영상의 프레임이 남아 있어서 updateZoom fail 이 발생하지 않음 TT
|
|
if(RMPlayer::instance()->updateZoom(zoomPos->_x,zoomPos->_y,_bIsMainVideo) == false)
|
|
{
|
|
QTimer::singleShot(10,this,SLOT(onForceUpdateZoom()));
|
|
#if (USE_ZOOM_WH_RATIO)
|
|
refreshZoomWidgetWH();
|
|
#endif
|
|
}
|
|
}
|
|
#if !(DUAL_VIEWER) // 같이 구현되어 있음
|
|
void RMFrameVideoBase::mousePressEvent(QMouseEvent* event)
|
|
{
|
|
if(zoomPos == NULL || bZoomStarted == false) {
|
|
return;
|
|
}
|
|
_dragStart = true;
|
|
_dragPos = event->pos();
|
|
zoomPos->start();
|
|
}
|
|
void RMFrameVideoBase::mouseMoveEvent(QMouseEvent* event)
|
|
{
|
|
if(zoomPos == NULL || bZoomStarted == false) {
|
|
return;
|
|
}
|
|
|
|
_updateZoomProcess(event->pos());
|
|
}
|
|
void RMFrameVideoBase::mouseReleaseEvent(QMouseEvent* event)
|
|
{
|
|
if(zoomPos == NULL || bZoomStarted == false) {
|
|
return;
|
|
}
|
|
_dragStart = false;
|
|
_updateZoomProcess(event->pos());
|
|
}
|
|
void RMFrameVideoBase::mouseDoubleClickEvent(QMouseEvent* e)
|
|
{
|
|
#if (RM_MODEL == RM_MODEL_TYPE_TB4000) // 전체화면 전환
|
|
if(e->button() == Qt::LeftButton) {
|
|
if(_bIsFrontVideo) {
|
|
QTimer::singleShot(0,Qt::PreciseTimer,RMApp::instance()->pMainWindow,SLOT(onFullScreen()));
|
|
}
|
|
else {
|
|
QTimer::singleShot(0,Qt::PreciseTimer,RMApp::instance()->pMainWindow,SLOT(onFullScreenSub()));
|
|
}
|
|
}
|
|
#else // RM_MODEL_TYPE_TB4000
|
|
#if (MODEL_STANDARD)
|
|
// 타이틀 클릭 방지
|
|
#if !(NO_CAMERA_TITLE)
|
|
if(e->pos().y() < titleLabel->size().height() ||
|
|
RMPlayer::instance()->playerF()->isLoaded() == false ) {
|
|
return;
|
|
}
|
|
#endif // #if !(NO_CAMERA_TITLE)
|
|
#else // MODEL_STANDARD
|
|
Q_UNUSED(e)
|
|
#endif // MODEL_STANDARD
|
|
onToggleZoom();
|
|
#endif // RM_MODEL_TYPE_TB4000
|
|
}
|
|
#endif // #if !(DUAL_VIEWER)
|
|
|
|
#if (USE_ZOOM_WH_RATIO)
|
|
void RMFrameVideoBase::refreshZoomWidgetWH()
|
|
{
|
|
if(zoomWidget == NULL, zoomPos == NULL) {
|
|
return;
|
|
}
|
|
#if (SINGLE_CH_VIEWER)
|
|
//FAV::AVPlayer* player = RMPlayer::instance()->playerF();
|
|
#else
|
|
// Renderer 가 변경되나 frame draw 되지 않아 처리가 안됨..
|
|
FAV::AVPlayer* player = _bIsMainVideo ? RMPlayer::instance()->mainScreenPlayer() : RMPlayer::instance()->subScreenPlayer();
|
|
#endif
|
|
QSize wh = player->videoResolution();
|
|
#if (MODEL_360)
|
|
zoomPos->_whr = ((double)wh.width()) / ((double)wh.height() / 2);
|
|
#else
|
|
zoomPos->_whr = ((double)wh.width()) / ((double)wh.height());
|
|
#endif
|
|
}
|
|
#endif // USE_ZOOM_WH_RATIO
|
|
void RMFrameVideoBase::onToggleZoom()
|
|
{
|
|
|
|
if(zoomWidget == NULL) {
|
|
return;
|
|
}
|
|
bZoomStarted = !bZoomStarted;
|
|
zoomWidget->setHidden(!bZoomStarted);
|
|
if(bZoomStarted) {
|
|
zoomVideoWidget = RMPlayer::instance()->startZoom(_bIsMainVideo);
|
|
zoomLayout->addWidget(zoomVideoWidget);
|
|
|
|
// ZOOM 비디오 위에 추가됨
|
|
zoomPosLayout = new QHBoxLayout(zoomVideoWidget);
|
|
zoomPosLayout->setMargin(0);
|
|
zoomPosLayout->setSpacing(0);
|
|
|
|
|
|
zoomPos = new RMWidgetZoomPos(zoomVideoWidget);
|
|
zoomPosLayout->addWidget(zoomPos);
|
|
#if (USE_ZOOM_WH_RATIO)
|
|
refreshZoomWidgetWH();
|
|
#endif
|
|
}
|
|
else {
|
|
|
|
if(_zoomTimer != NULL) {
|
|
delete _zoomTimer;
|
|
_zoomTimer = NULL;
|
|
}
|
|
zoomPosLayout->removeWidget(zoomPos);
|
|
delete zoomPos;
|
|
zoomPos = NULL;
|
|
delete zoomPosLayout;
|
|
zoomPosLayout = NULL;
|
|
|
|
zoomLayout->removeWidget(zoomVideoWidget);
|
|
RMPlayer::instance()->stopZoom(_bIsMainVideo);
|
|
zoomVideoWidget = NULL;
|
|
}
|
|
}
|
|
|
|
|
|
void RMFrameVideoBase::onTogglePIPLocation()
|
|
{
|
|
bPIPRight = !bPIPRight;
|
|
refreshPIP();
|
|
}
|
|
void RMFrameVideoBase::onToggleShowHidePIP()
|
|
{
|
|
if(bZoomStarted) {
|
|
zoomWidget->setHidden(!zoomWidget->isHidden());
|
|
}
|
|
}
|
|
|
|
void RMFrameVideoBase::onHidePIPForCapture(bool hide)
|
|
{
|
|
if(bZoomStarted && zoomWidget != NULL) {
|
|
|
|
if(hide == false) {
|
|
if(_wasPIPHidden == false) {
|
|
zoomWidget->setHidden(false);
|
|
}
|
|
}
|
|
else {
|
|
// 기존 상태 확인해서 처리
|
|
_wasPIPHidden = zoomWidget->isHidden();
|
|
zoomWidget->setHidden(true);
|
|
|
|
if(bZoomStarted)
|
|
{
|
|
onToggleZoom();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#endif // #if !(DO_NOT_USE_ZOOM)
|
|
#if (RM_MODEL == RM_MODEL_TYPE_TB4000)
|
|
void RMFrameVideoBase::mouseDoubleClickEvent(QMouseEvent* e)
|
|
{
|
|
#if (CLICK_PAUSE_PLAY)
|
|
cancelClickTimer();
|
|
#endif // CLICK_PAUSE_PLAY
|
|
|
|
#if !(PLAYER_ONLY_LIBRARY_MODE)
|
|
if(e->button() == Qt::LeftButton) {
|
|
if(_bIsFrontVideo) {
|
|
QTimer::singleShot(0,Qt::PreciseTimer,RMApp::instance()->pMainWindow,SLOT(onFullScreen()));
|
|
}
|
|
else {
|
|
QTimer::singleShot(0,Qt::PreciseTimer,RMApp::instance()->pMainWindow,SLOT(onFullScreenSub()));
|
|
}
|
|
}
|
|
#endif // #if (PLAYER_ONLY_LIBRARY_MODE)
|
|
RMWidgetBase::mouseDoubleClickEvent(e);
|
|
}
|
|
#endif // TB4000
|
|
#if !(NO_CAMERA_TITLE)
|
|
void RMFrameVideoBase::refreshTitle(bool bForceFlip)
|
|
{
|
|
bool isFront = _bIsFrontVideo;
|
|
if(bForceFlip) {
|
|
isFront = !isFront;
|
|
}
|
|
#if (TRI_CHANNEL || TRI_CHANNEL2)
|
|
// 현재 후방 실내 모드일 경우
|
|
bool isIndoor = RMPlayer::instance()->isIndoor();
|
|
#endif //
|
|
|
|
//qInfo() << "_bIsFrontVideo:" << _bIsFrontVideo << "bForceFlip" << bForceFlip << LOG_FL;
|
|
QString iconPath;
|
|
|
|
#if(REMOVE_OLD_C)
|
|
QString tag_png = RMLanguage::languageTag() + ".png";
|
|
#if (TRI_CHANNEL)
|
|
QString rearName = isIndoor ? ":/image/title_video_indoor" + tag_png : ":/image/title_video_rear" + tag_png;
|
|
iconPath = isFront ? ":/image/title_video_front" + tag_png : rearName;
|
|
#elif (TRI_CHANNEL2)
|
|
QString rearName = isIndoor ? (RMPlayer::instance()->itemIsWideMode() ? ":/image/title_video_indoor.png" : ":/image/title_video_pedal.png") : ":/image/title_video_rear.png";
|
|
iconPath = isFront ? ":/image/title_video_front.png" : rearName;
|
|
//qInfo() << "wide:" << RMPlayer::instance()->isWideMode() << "iconPath:" << iconPath << LOG_FL;
|
|
#else // TRI_CHANNEL
|
|
iconPath = isFront ? ":/image/title_video_front" + tag_png : ":/image/title_video_rear" + tag_png;
|
|
#endif // TRI_CHANNEL
|
|
#else // #if(REMOVE_OLD_C)
|
|
if(RMLanguage::isJP())
|
|
{
|
|
#if (TRI_CHANNEL)
|
|
QString rearName = isIndoor ? ":/image/title_video_indoor.png" : ":/image/title_video_rear.png";
|
|
iconPath = isFront ? ":/image/title_video_front.png" : rearName;
|
|
#else
|
|
#if (SUB_MODEL_KEIYO_360)
|
|
iconPath = isFront ? ":/image/title_video_360.png" : ":/image/title_video_wide.png";
|
|
#else // SUB_MODEL_KEIYO_360
|
|
iconPath = isFront ? ":/image/title_video_front.png" : ":/image/title_video_rear.png";
|
|
#endif // SUB_MODEL_KEIYO_360
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
#if (TRI_CHANNEL)
|
|
QString rearName = isIndoor ? ":/image/title_video_indoor_en.png" : ":/image/title_video_rear_en.png";
|
|
iconPath = isFront ? ":/image/title_video_front_en.png" : rearName;
|
|
#else
|
|
iconPath = isFront ? ":/image/title_video_front_en.png" : ":/image/title_video_rear_en.png";
|
|
#endif
|
|
}
|
|
#endif // REMOVE_OLD_C
|
|
|
|
titleLabel->setPixmap( QPixmap(iconPath) );
|
|
}
|
|
#endif // #if !(NO_CAMERA_TITLE)
|
|
#if (LIVE_LANGUAGE_CHANGE && MODEL_STANDARD)
|
|
void RMFrameVideoBase::refreshLanguage()
|
|
{
|
|
#if !(NO_CAMERA_TITLE)
|
|
refreshTitle(false);
|
|
#endif // #if !(NO_CAMERA_TITLE)
|
|
refreshLanguageSub();
|
|
#if (PENTA_CHANNEL)
|
|
_refreshCHTool();
|
|
#endif
|
|
}
|
|
#if (CLICK_PAUSE_PLAY)
|
|
void RMFrameVideoBase::onPlayOrPause()
|
|
{
|
|
RMPlayer::instance()->onPlayOrPause();
|
|
}
|
|
void RMFrameVideoBase::startClickTimer()
|
|
{
|
|
cancelClickTimer();
|
|
clickTimer = new QTimer(this);
|
|
clickTimer->setSingleShot(true);
|
|
clickTimer->setInterval(100);
|
|
connect(clickTimer,SIGNAL(timeout()),SLOT(onPlayOrPause()));
|
|
clickTimer->start();
|
|
}
|
|
void RMFrameVideoBase::cancelClickTimer()
|
|
{
|
|
if(clickTimer != NULL) {
|
|
delete clickTimer;
|
|
clickTimer = NULL;
|
|
}
|
|
}
|
|
void RMFrameVideoBase::onClicked()
|
|
{
|
|
startClickTimer();
|
|
}
|
|
#endif // CLICK_PAUSE_PLAY
|
|
void RMFrameVideoBase::onLanguageChange(RMLanguage::LANGUAGE_TYPE language)
|
|
{
|
|
Q_UNUSED(language);
|
|
refreshLanguage();
|
|
}
|
|
#endif // (LIVE_LANGUAGE_CHANGE && MODEL_STANDARD)
|
|
#if (RESIZE_FILTER && !DO_NOT_USE_ZOOM)
|
|
void RMFrameVideoBase::resizeEvent(QResizeEvent *event)
|
|
{
|
|
if(_videoWidget != NULL) {
|
|
int h = (event->size().width() * 9) / 16;
|
|
QSize s = QSize(event->size().width(),h);
|
|
if(event->size().width() > 1080) {
|
|
s = QSize(-1,-1);
|
|
}
|
|
RMPlayer::instance()->resizeFilter(s,_bIsMainVideo);
|
|
}
|
|
}
|
|
#endif // RESIZE_FILTER
|
|
|
|
#if (MODEL_360)
|
|
void RMFrameVideoBase::mouseMoveEvent(QMouseEvent* event)
|
|
{
|
|
#if (!DO_NOT_USE_ZOOM)
|
|
if(zoomPos == NULL || bZoomStarted == false) {
|
|
#endif
|
|
if(_dragStart == false) {
|
|
return;
|
|
}
|
|
double offset = (_dragPos.x() - event->pos().x()) / (double)this->size().width();
|
|
offset *= 0.5;
|
|
FAV::VideoRenderer* vr = _bIsMainVideo ? RMPlayer::instance()->_videoOutputF : RMPlayer::instance()->_videoOutputR;
|
|
vr->opengl()->setAngle(_startAngle + offset);
|
|
if(1)//_zoom3D)
|
|
{
|
|
double op = (event->pos().y() - _dragPos.y()) / (double)this->size().height();
|
|
//op *= 0.5;
|
|
vr->opengl()->setPitch(_startPitch + op);
|
|
}
|
|
// Pause 시 OpenGL Update 처리
|
|
vr->widget()->update();
|
|
return;
|
|
#if (!DO_NOT_USE_ZOOM)
|
|
}
|
|
_updateZoomProcess(event->pos());
|
|
#endif
|
|
}
|
|
void RMFrameVideoBase::mousePressEvent(QMouseEvent* event)
|
|
{
|
|
#if (!DO_NOT_USE_ZOOM)
|
|
if(zoomPos == NULL || bZoomStarted == false) {
|
|
#endif
|
|
if(_dualMode) {
|
|
_dragStart = false;
|
|
return;
|
|
}
|
|
|
|
_dragStart = true;
|
|
FAV::VideoRenderer* vr = _bIsMainVideo ? RMPlayer::instance()->_videoOutputF : RMPlayer::instance()->_videoOutputR;
|
|
_startAngle = vr->opengl()->angle();
|
|
_startPitch = vr->opengl()->pitch();
|
|
//qInfo() << "_startAngle:" << _startAngle;
|
|
_dragPos = event->pos();
|
|
return;
|
|
#if (!DO_NOT_USE_ZOOM)
|
|
}
|
|
_dragStart = true;
|
|
_dragPos = event->pos();
|
|
zoomPos->start();
|
|
#endif
|
|
}
|
|
|
|
void RMFrameVideoBase::mouseReleaseEvent(QMouseEvent* event)
|
|
{
|
|
#if (!DO_NOT_USE_ZOOM)
|
|
_updateZoomProcess(event->pos());
|
|
#else
|
|
Q_UNUSED(event);
|
|
#endif
|
|
_dragStart = false;
|
|
}
|
|
void RMFrameVideoBase::mouseDoubleClickEvent(QMouseEvent* e)
|
|
{
|
|
if(_dualMode)
|
|
{
|
|
onToggleZoom();
|
|
return;
|
|
}
|
|
|
|
// 타이틀 클릭 방지
|
|
if(e->pos().y() < titleLabel->size().height() ||
|
|
RMPlayer::instance()->playerF()->isLoaded() == false ) {
|
|
return;
|
|
}
|
|
_zoom3D = !_zoom3D;
|
|
FAV::VideoRenderer* vr = _bIsMainVideo ? RMPlayer::instance()->_videoOutputF : RMPlayer::instance()->_videoOutputR;
|
|
vr->opengl()->setZoom(_zoom3D);
|
|
vr->widget()->update();
|
|
}
|
|
#elif (TOP_DOWN_360)
|
|
void RMFrameVideoBase::wheelEvent(QWheelEvent *e)
|
|
{
|
|
if(_pVR->opengl()->mode() == MODE_360_VR) {
|
|
// zoom-in, out
|
|
int z = e->angleDelta().y() > 0 ? 1 : -1;
|
|
//FAV::VideoRenderer* vr = RMPlayer::GetInstance()->playerF()->renderer();
|
|
_pVR->opengl()->setZoom(_pVR->opengl()->zoom() + z);
|
|
_pVR->widget()->update();
|
|
//RMPlayer::GetInstance()->playWidgetF()->update();
|
|
}
|
|
}
|
|
void RMFrameVideoBase::mouseMoveEvent(QMouseEvent* event)
|
|
{
|
|
if(_mousePressed == true)
|
|
{
|
|
//qInfo() << "mode:" << _pVR->opengl()->mode() << LOG_FL;
|
|
if(_pVR->opengl()->mode() == MODE_360_VR)
|
|
{
|
|
#if (MOUSE_DRAG_ACCELERATION)
|
|
// 이동거리
|
|
int time = _dragTimer.elapsed();
|
|
// time == 0 무한대 발생
|
|
if (time >= 1) {
|
|
double ldx = (event->pos().x() - _lastSpeedPos.x()) * 100;
|
|
double ldy = (event->pos().y() - _lastSpeedPos.y()) * 100;
|
|
double ts = ((double)time);
|
|
ldx = ldx / ts;
|
|
ldy = ldy / ts;
|
|
_lastSpeed = QPointF((_lastSpeed.x() + ldx) / 2.0,(_lastSpeed.y() + ldy) / 2.0);
|
|
//qInfo() << "_lastSpeed:" << _lastSpeed << ldx << ldy << "time:" << time;
|
|
//_lastSpeed = QPointF(qMin((_lastSpeed.x() + ldx) / 2.0,10.0),qMin((_lastSpeed.y() + ldy) / 2.0,10.0));
|
|
|
|
_lastSpeedPos = event->pos();
|
|
//qInfo() << _lastSpeed << cs;
|
|
}
|
|
#endif // MOUSE_DRAG_ACCELERATION
|
|
double rx = (event->pos().x() - _dragPos.x()) / (double)this->size().width();
|
|
double ry = (event->pos().y() - _dragPos.y()) / (double)this->size().height();
|
|
|
|
_pVR->opengl()->drag(rx,ry);
|
|
// Pause 시 OpenGL Update 처리
|
|
_pVR->widget()->update();
|
|
#if (USE_360_POSITION_VIEW)
|
|
double ax, ay;
|
|
_pVR->opengl()->angle(&ax,&ay);
|
|
//qInfo() << ax << ay << __FUNCTION__;
|
|
_posView->setAngle(ax,ay);
|
|
#endif // #if (USE_360_POSITION_VIEW)
|
|
}
|
|
// 포인트 + 영역 확대 중에는 영역확대 불가...
|
|
else if(_bIsMainVideo == true &&
|
|
RMPlayer::instance()->playerF()->isLoaded() == true &&
|
|
_bZoomMode == true &&
|
|
_pVR->opengl()->zoomLevel2D == 0 &&
|
|
_pVR->opengl()->bROI == false)
|
|
{
|
|
#if (!USE_POINT_ZOOM || USE_HYBRID_ZOOM)
|
|
// 360 은 필터하지 않는다
|
|
_rect.setBottomRight(event->pos());
|
|
update();
|
|
#endif // USE_POINT_ZOOM
|
|
}
|
|
//qInfo() << _pVR->opengl()->bROI;
|
|
//qInfo() << "isSubVideo:" << isSubVideo << "_ROIEnabled:" << _ROIEnabled << "_bZoomMode:" << _bZoomMode << "LV2:" << _pVR->opengl()->zoomLevel2D << __FUNCTION__ << __LINE__;
|
|
}
|
|
QWidget::mouseMoveEvent(event);
|
|
}
|
|
void RMFrameVideoBase::mousePressEvent(QMouseEvent* event)
|
|
{
|
|
//qInfo() << "mode:" << _pVR->opengl()->mode() << "_bIsMainVideo:" << _bIsMainVideo << LOG_FL;
|
|
if(RMPlayer::instance()->playerF()->isLoaded() == true && event->button() == Qt::LeftButton)
|
|
{
|
|
#if(TOPDOWN_360_QUAD_MODE)
|
|
if(mode360 == MODE_360_QUAD) {
|
|
return;
|
|
}
|
|
#endif
|
|
_mousePressed = true;
|
|
_dragPos = event->pos();
|
|
if(_pVR->opengl()->mode() == MODE_360_VR) {
|
|
// 초기 각도 저장
|
|
setCursor(Qt::PointingHandCursor);
|
|
|
|
RMPlayer::instance()->renderer360()->opengl()->startDrag();
|
|
#if (MOUSE_DRAG_ACCELERATION)
|
|
stopAccelerationTimer();
|
|
_dragTimer.start();
|
|
_lastSpeedPos = _dragPos;
|
|
_lastSpeed = QPointF(0.0,0.0);
|
|
#endif
|
|
}
|
|
else if(_bIsMainVideo == false) // 확대하지 않는다.
|
|
{
|
|
#if (!USE_POINT_ZOOM || USE_HYBRID_ZOOM)
|
|
// 360 은 16:9 필터하지 않는다.
|
|
_rect.setTopLeft(event->pos());
|
|
_rect.setBottomRight(event->pos());
|
|
#endif
|
|
}
|
|
}
|
|
QWidget::mousePressEvent(event);
|
|
}
|
|
void RMFrameVideoBase::mouseReleaseEvent(QMouseEvent* event)
|
|
{
|
|
#if (CLICK_PAUSE_PLAY)
|
|
//qInfo() << __FUNCTION__;
|
|
if(_pVR->opengl()->mode() != MODE_360_ROUND &&
|
|
_mousePressed &&
|
|
abs(_dragPos.x() - event->pos().x()) < 2 &&
|
|
abs(_dragPos.y() - event->pos().y()) < 2)
|
|
{
|
|
startClickTimer();;
|
|
}
|
|
#else
|
|
Q_UNUSED(event);
|
|
#endif
|
|
|
|
if(_pVR->opengl()->mode() != MODE_360_VR && _bIsMainVideo) { // 2D 모드 + main video
|
|
|
|
bool ROI = false;
|
|
// 현재 영역 확대중일 경우 확대 취소
|
|
if(RMPlayer::instance()->playerF()->isLoaded() == true &&
|
|
_bZoomMode == true &&
|
|
_pVR->opengl()->bROI == false)
|
|
{
|
|
// 현재 POINT 확대중일 경우 DRAG 하더라도 최초 POINT 만 사용
|
|
if(_pVR->opengl()->zoomLevel2D != 0)
|
|
{
|
|
_rect.setCoords(0,0,0,0);
|
|
}
|
|
//qInfo() << _rect << __FUNCTION__ << __LINE__;
|
|
_rect = _rect.normalized();
|
|
//qInfo() << _rect << __FUNCTION__ << __LINE__;
|
|
|
|
// POINT ZOOM
|
|
if(_rect.width() < 5 || _rect.height() < 5)
|
|
{
|
|
ROI = true;
|
|
sendSelectedSignal();
|
|
}
|
|
else // DRAG ZOOM
|
|
{
|
|
if(_drawStarted == true)
|
|
{
|
|
sendSelectedSignal();
|
|
ROI = true;
|
|
_rect.setRect(0,0,0,0); // 삭제
|
|
update();
|
|
_drawStarted = false;
|
|
}
|
|
}
|
|
}
|
|
if(ROI == false)
|
|
{
|
|
_pVR->opengl()->clearROI();
|
|
_pVR->widget()->update();
|
|
if(_pVR->opengl()->mode() == MODE_360_ROUND) {
|
|
_pVR->setOutAspectRatioMode(FAV::VideoRenderer::VideoAspectRatio);
|
|
}
|
|
}
|
|
}
|
|
else { // MODE 2 (360)
|
|
#if (MOUSE_DRAG_ACCELERATION)
|
|
#if (USE_POINT_ZOOM)
|
|
if (_bZoomMode && _bIsMainVideo == true)
|
|
{
|
|
setCursor(*_magnifyZoom);
|
|
}
|
|
else
|
|
#endif // USE_POINT_ZOOM
|
|
{
|
|
unsetCursor();
|
|
}
|
|
#if (USE_POINT_ZOOM)
|
|
if (_bZoomMode &&
|
|
abs(_dragPos.x() - event->pos().x()) < 5 &&
|
|
abs(_dragPos.y() - event->pos().y()) < 5)
|
|
{
|
|
|
|
double rx = ((double)event->pos().x()) / ((double)size().width());
|
|
double ry = ((double)event->pos().y()) / ((double)size().height());
|
|
|
|
// ZOOM
|
|
//FAV::VideoRenderer* vr = RMPlayer::GetInstance()->mainRenderer();// playerF()->renderer();
|
|
_pVR->opengl()->zoomPos(rx,ry);
|
|
_pVR->widget()->update();
|
|
//RMPlayer::GetInstance()->playWidgetF()->update();
|
|
}
|
|
else if (fabs(_lastSpeed.x()) > 5.0 || fabs(_lastSpeed.y()) > 5.0) {
|
|
#else
|
|
if (fabs(_lastSpeed.x()) > 5.0 || fabs(_lastSpeed.y()) > 5.0) {
|
|
#endif // USE_POINT_ZOOM
|
|
|
|
// 가속 최대 150
|
|
double x = _lastSpeed.x();
|
|
double y = _lastSpeed.y();
|
|
|
|
double fx = fabs(x);
|
|
double fy = fabs(y);
|
|
x = qMin(fx,150.0) * ((x > 0) - (x < 0));
|
|
y = qMin(fy,150.0) * ((y > 0) - (y < 0));
|
|
|
|
// 전체 scroll 개수
|
|
_scrollStartCount = _scrollCount = (int)qMax(fx,fy);
|
|
|
|
// scroll 변환값
|
|
_lastSpeed = QPointF(x/((double)_scrollCount * 10),y/((double)_scrollCount* 10));
|
|
|
|
// 타이머 시작
|
|
_accelerationTimer = new QTimer(this);
|
|
_accelerationTimer->setSingleShot(false);
|
|
connect(_accelerationTimer,SIGNAL(timeout()),SLOT(onScroll()));
|
|
_accelerationTimer->start(5);
|
|
}
|
|
|
|
//qInfo() << "LAST SPEED:" << _lastSpeed;
|
|
#endif // MOUSE_DRAG_ACCELERATION
|
|
}
|
|
|
|
_mousePressed = false;
|
|
#if (!USE_POINT_ZOOM || USE_HYBRID_ZOOM)
|
|
_drawStarted = false;
|
|
#endif
|
|
|
|
QWidget::mouseReleaseEvent(event);
|
|
}
|
|
//void RMFrameVideoBase::mouseDoubleClickEvent(QMouseEvent* event)
|
|
//{
|
|
|
|
//}
|
|
#if (USE_POINT_ZOOM)
|
|
void RMFrameVideoBase::sendSelectedSignal()
|
|
{
|
|
//_rect = _rect.normalized();
|
|
// 지점 확대
|
|
if(_rect.width() < 5 || _rect.height() < 5)
|
|
{
|
|
float x = ((float)_dragPos.x()) / ((float)rect().width());
|
|
float y = ((float)_dragPos.y()) / ((float)rect().height());
|
|
|
|
_pVR->opengl()->zoomPos(x,y);
|
|
_pVR->widget()->update();
|
|
if(_pVR->opengl()->mode() == MODE_360_ROUND && _pVR->opengl()->zoomLevel2D == 0)
|
|
{
|
|
_pVR->setOutAspectRatioMode(FAV::VideoRenderer::VideoAspectRatio);
|
|
}
|
|
else
|
|
{
|
|
_pVR->setOutAspectRatioMode(FAV::VideoRenderer::RendererAspectRatio);
|
|
}
|
|
|
|
}
|
|
else // 영역 확대 (2020/09/01)
|
|
{
|
|
// 사용자 설정 영역을 화면 영역 비율로 조정
|
|
QRect bound = rect();
|
|
|
|
// 화면에 확대할 영역은 화면 비율로 조정한다.
|
|
_rect = QRectAspectFillRect(QSize(bound.width(),bound.height()),_rect);
|
|
//qInfo() << "RR:" << _rect;
|
|
|
|
int xmin = MIN(_rect.left(), _rect.right());
|
|
int ymin = MIN(_rect.top(), _rect.bottom());
|
|
|
|
float x = (float)(xmin - bound.left()) / (float)bound.width();
|
|
float y = (float)(ymin - bound.top()) / (float)bound.height();
|
|
|
|
float width = (float)_rect.width() / (float)bound.width();
|
|
float height = (float)_rect.height() / (float)bound.height();
|
|
|
|
// 상하 여백 발생시 영역 조정
|
|
if (_pVR->opengl()->mode() == MODE_360_ROUND)
|
|
{
|
|
QSize fs = _pVR->opengl()->frameSize(); // 2880x2880
|
|
|
|
double sw = bound.width(); // 화면크기 1351
|
|
double sh = bound.height(); // " 516
|
|
double sr = sw/sh; // 화면비 2.618
|
|
|
|
double fw = fs.width(); // 2880
|
|
double fh = fs.height(); // 2880
|
|
double fr = fw/fh; // 영상비 1:1
|
|
|
|
// 영상 좌우 여백
|
|
if(fr < sr)
|
|
{
|
|
// S(1542 x 622), F(1920 x 1080)
|
|
// 영상H/화면H * 영상W = 622/1080*1920 = 1105.778 (화면대비 영상 W[fsw])
|
|
double fsw = (sh/fh) * fw;
|
|
|
|
// X 비율[sx] = 화면W/(화면대비 영상 W) = 1.3944
|
|
double sx = sw / fsw;
|
|
width *= sx; // 선택된 영역을 확장
|
|
|
|
// 좌측 여백 = 화면W - 화면대비영상W / 화면W * 0.5
|
|
double xoffset = ((sw - fsw) / sw) * 0.5;
|
|
|
|
// X 좌표는 X - 옵셋 * SCALE
|
|
x = (x - xoffset) * sx;
|
|
}
|
|
else // 영상 상하 여백
|
|
{
|
|
double fsh = (sw/fw) * fh;
|
|
|
|
// Y 비율[sy] = 화면H/(화면대비 영상 H)
|
|
double sy = sh / fsh;
|
|
height *= sy; // 선택된 영역을 확장
|
|
|
|
// 좌측 여백 = 화면W - 화면대비영상W / 화면W * 0.5
|
|
double yoffset = ((sh - fsh) / sh) * 0.5;
|
|
|
|
// Y 좌표는 Y - 옵셋 * SCALE
|
|
y = (y - yoffset) * sy;
|
|
}
|
|
}
|
|
else if (_pVR->opengl()->mode() == MODE_360_PANORAMA_2CH || _pVR->opengl()->mode() == MODE_360_PENTA) // 2020/12/06 파노라마 모드 16:9
|
|
{
|
|
QSize fs = _pVR->opengl()->frameSize();
|
|
|
|
double sw = bound.width();
|
|
double sh = bound.height();
|
|
double sr = sw/sh; // 화면비
|
|
|
|
double fw = fs.width();
|
|
double fh = fw / 16.0 * 9.0;
|
|
double fr = fw/fh; // 영상비
|
|
|
|
// 영상 좌우 여백
|
|
if(fr < sr)
|
|
{
|
|
// S(1542 x 622), F(1920 x 1080)
|
|
// 영상H/화면H * 영상W = 622/1080*1920 = 1105.778 (화면대비 영상 W[fsw])
|
|
double fsw = (sh/fh) * fw;
|
|
|
|
// X 비율[sx] = 화면W/(화면대비 영상 W) = 1.3944
|
|
double sx = sw / fsw;
|
|
width *= sx; // 선택된 영역을 확장
|
|
|
|
// 좌측 여백 = 화면W - 화면대비영상W / 화면W * 0.5
|
|
double xoffset = ((sw - fsw) / sw) * 0.5;
|
|
|
|
// X 좌표는 X - 옵셋 * SCALE
|
|
x = (x - xoffset) * sx;
|
|
}
|
|
else // 영상 상하 여백
|
|
{
|
|
double fsh = (sw/fw) * fh;
|
|
|
|
// Y 비율[sy] = 화면H/(화면대비 영상 H)
|
|
double sy = sh / fsh;
|
|
height *= sy; // 선택된 영역을 확장
|
|
|
|
// 좌측 여백 = 화면W - 화면대비영상W / 화면W * 0.5
|
|
double yoffset = ((sh - fsh) / sh) * 0.5;
|
|
|
|
// Y 좌표는 Y - 옵셋 * SCALE
|
|
y = (y - yoffset) * sy;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// 상하+좌우 반전 반영
|
|
if (_pVR->opengl()->isVFlip()) {
|
|
y = 1.0 - y - height;
|
|
}
|
|
|
|
if (_pVR->opengl()->isHFlip()) {
|
|
x = 1.0 - x - width;
|
|
}
|
|
|
|
x = qMin(qMax(x,0.0f),1.0f);
|
|
y = qMin(qMax(y,0.0f),1.0f);
|
|
|
|
width = qMin(qMax(width,0.0f),1.0f);
|
|
height = qMin(qMax(height,0.0f),1.0f);
|
|
|
|
_pVR->opengl()->setROI(x,y,width,height);
|
|
_pVR->widget()->update();
|
|
_pVR->setOutAspectRatioMode(FAV::VideoRenderer::RendererAspectRatio);
|
|
}
|
|
}
|
|
#endif // #if (USE_POINT_ZOOM)
|
|
void RMFrameVideoBase::refreshMode360()
|
|
{
|
|
int mode = mode360;
|
|
// 2D 모드 확대 제거
|
|
btnReset360->setEnabled(mode360 == MODE_360_VR);
|
|
#if (TOPDOWN_360_QUAD_MODE)
|
|
if(mode360 == MODE_360_QUAD) {
|
|
//qInfo() << "4CH" << __FUNCTION__;
|
|
mode = MODE_360_VR;
|
|
_videoBaseDownWidget->setHidden(false);
|
|
if(_videoWidget2 != NULL) {
|
|
_videoWidget2->setHidden(false);
|
|
}
|
|
RMPlayer::instance()->setQuadMode(true);
|
|
|
|
|
|
QList<FAV::VideoRenderer*> ll = QList<FAV::VideoRenderer*>() << RMPlayer::instance()->_videoOutput2 << RMPlayer::instance()->_videoOutput3 << RMPlayer::instance()->_videoOutput4;
|
|
QList<double> angles = QList<double>() << 90 << 180 << 270;
|
|
for(int i=0;i<ll.size();i++) {
|
|
FAV::VideoRenderer* vr = ll.at(i);
|
|
vr->opengl()->clearROI();
|
|
vr->widget()->update();
|
|
vr->opengl()->setMode(mode);
|
|
vr->widget()->update();
|
|
vr->opengl()->setAngle(angles.at(i),330);
|
|
vr->setOutAspectRatioMode(mode == 0 ? FAV::VideoRenderer::VideoAspectRatio : FAV::VideoRenderer::RendererAspectRatio);
|
|
}
|
|
|
|
} else {
|
|
//qInfo() << "1CH" << __FUNCTION__;
|
|
if(_videoWidget2 != NULL) {
|
|
_videoWidget2->setHidden(true);
|
|
}
|
|
_videoBaseDownWidget->setHidden(true);
|
|
RMPlayer::instance()->setQuadMode(false);
|
|
}
|
|
#endif // #if (TOPDOWN_360_QUAD_MODE)
|
|
|
|
FAV::VideoRenderer* vr = RMPlayer::instance()->renderer360();
|
|
vr->opengl()->clearROI();
|
|
vr->widget()->update();
|
|
vr->opengl()->setMode(mode);
|
|
vr->widget()->update();
|
|
emit mode360Change(mode); // 현재 사용하는곳 없음???
|
|
vr->setOutAspectRatioMode((mode == 0) ? FAV::VideoRenderer::VideoAspectRatio : FAV::VideoRenderer::RendererAspectRatio);
|
|
|
|
#if (USE_DRAG_ZOOM)
|
|
// ROI WIDGET 제거
|
|
//RMPlayer::instance()->EnableROIWidget(mode360 != MODE_360_VR);
|
|
if(dragWidget != NULL) {
|
|
dragWidget->_disabled = !(mode360 == MODE_360_ROUND);
|
|
}
|
|
#endif // USE_DRAG_ZOOM
|
|
#if (USE_360_POSITION_VIEW)
|
|
|
|
if(_posStaticView != NULL) {
|
|
_posStaticView->setMode(mode360);
|
|
}
|
|
|
|
if(_posView != NULL) {
|
|
|
|
if(mode360 == MODE_360_VR) {
|
|
videoLayout->setCurrentIndex(1);
|
|
} else {
|
|
videoLayout->setCurrentIndex(0);
|
|
}
|
|
//_posView->setHidden(mode360 != MODE_360_VR);
|
|
|
|
if(mode360 == MODE_360_VR) {
|
|
double ax, ay;
|
|
_pVR->opengl()->angle(&ax,&ay);
|
|
_posView->setAngle(ax,ay);
|
|
}
|
|
}
|
|
#endif // USE_360_POSITION_VIEW
|
|
}
|
|
#if (MOUSE_DRAG_ACCELERATION)
|
|
void RMFrameVideoBase::stopAccelerationTimer()
|
|
{
|
|
if (_accelerationTimer != NULL) {
|
|
_accelerationTimer->stop();
|
|
delete _accelerationTimer;
|
|
_accelerationTimer = NULL;
|
|
}
|
|
}
|
|
void RMFrameVideoBase::onScroll()
|
|
{
|
|
// 종료처리 + 감속비율 계산
|
|
_scrollCount--;
|
|
|
|
// 현재 감속 비율 (linear)
|
|
double r = ((double)_scrollCount)/((double)_scrollStartCount);
|
|
#if (TOP_DOWN_2D_360)
|
|
r *= 0.5;
|
|
#endif
|
|
// 감속 변환
|
|
double sx = _lastSpeed.x() * r;
|
|
double sy = _lastSpeed.y() * r;
|
|
//FAV::VideoRenderer* vr = RMPlayer::GetInstance()->playerF()->renderer();
|
|
_pVR->opengl()->scroll(sx,sy);
|
|
|
|
// Pause 시 OpenGL Update 처리
|
|
_pVR->widget()->update();
|
|
//RMPlayer::GetInstance()->playWidgetF()->update();
|
|
|
|
if (_scrollCount <= 0) {
|
|
stopAccelerationTimer();
|
|
}
|
|
|
|
}
|
|
#if (USE_POINT_ZOOM)
|
|
void RMFrameVideoBase::onZoomChange(bool bZoom)
|
|
{
|
|
//qInfo() << "onZoomChange:" << bZoom;
|
|
_bZoomMode = bZoom;
|
|
if (_bZoomMode && _bIsMainVideo == true) {
|
|
setCursor(*_magnifyZoom);
|
|
} else {
|
|
unsetCursor();
|
|
RMPlayer::instance()->onClearROI();
|
|
}
|
|
|
|
}
|
|
#endif // USE_POINT_ZOOM
|
|
#endif // MOUSE_DRAG_ACCELERATION
|
|
|
|
void RMFrameVideoBase::onMode360()
|
|
{
|
|
#if (RM_MODEL == RM_MODEL_TYPE_TB4000)
|
|
int mode = 0;
|
|
FMButton* btn = qobject_cast<FMButton*>(sender());
|
|
|
|
if(btn == btnMode360_2D) {
|
|
mode = MODE_360_ROUND;
|
|
} else if (btn == btnMode360_3D) {
|
|
mode = MODE_360_VR;
|
|
}else if (btn == btnMode360_4CH) {
|
|
mode = MODE_360_PANORAMA_2CH;
|
|
}else if (btn == btnMode360_5CH) {
|
|
mode = MODE_360_PENTA;
|
|
}
|
|
mode360 = (MODE_360)mode;
|
|
_refresh360UI();
|
|
#else // #if (RM_MODEL == RM_MODEL_TYPE_TB4000)
|
|
FAV::VideoRenderer* vr = RMPlayer::instance()->renderer360();
|
|
|
|
// MODE_360_QUAD
|
|
// 0: fish
|
|
// 1: 상하단 변환
|
|
// 2: 3D
|
|
#if (TOPDOWN_360_QUAD_MODE)
|
|
int mode = (mode360 + 1) % 4;
|
|
#else // TOPDOWN_360_QUAD_MODE
|
|
int mode = vr->opengl()->mode();
|
|
#if (REMOVE_360_WIDE_SINGLE)
|
|
mode = (1 + mode) % 3;
|
|
#else
|
|
mode = (1 + mode) % 4;
|
|
#endif
|
|
#endif // TOPDOWN_360_QUAD_MODE
|
|
#endif // #if (RM_MODEL == RM_MODEL_TYPE_TB4000)
|
|
|
|
mode360 = (MODE_360)mode;
|
|
//qInfo() << "mode" << mode << __FUNCTION__;
|
|
|
|
refreshMode360();
|
|
|
|
#if (RM_MODEL == RM_MODEL_TYPE_TB4000 && !PLAYER_ONLY_LIBRARY_MODE)
|
|
// MODE 저장, 로드 없음
|
|
QSettings settings(USER_SETTINGS,QSettings::NativeFormat);
|
|
settings.setValue("mode_360",mode360);
|
|
#endif // PLAYER_ONLY_LIBRARY_MODE
|
|
}
|
|
void RMFrameVideoBase::onZoom360()
|
|
{
|
|
modeZoom = !modeZoom;
|
|
// modeZoomButton->setProperty("selected", modeZoom);
|
|
// modeZoomButton->style()->unpolish(modeZoomButton);
|
|
// modeZoomButton->style()->polish(modeZoomButton);
|
|
// modeZoomButton->update();
|
|
emit modeZoomChange(modeZoom);
|
|
}
|
|
void RMFrameVideoBase::onReset360()
|
|
{
|
|
FAV::VideoRenderer* vr = RMPlayer::instance()->playerF()->renderer();
|
|
vr->opengl()->resetAngle();// setAngle(0,0);
|
|
vr->widget()->update();
|
|
#if (USE_360_POSITION_VIEW)
|
|
if(mode360 == MODE_360_VR) {
|
|
double ax, ay;
|
|
_pVR->opengl()->angle(&ax,&ay);
|
|
_posView->setAngle(ax,ay);
|
|
}
|
|
#endif // #if (USE_360_POSITION_VIEW)
|
|
}
|
|
void RMFrameVideoBase::_refresh360UI()
|
|
{
|
|
#if !(RM_MODEL == RM_MODEL_TYPE_TB4000)
|
|
seperator->setHidden(!_bIsFrontVideo);
|
|
btnMode360->setHidden(!_bIsFrontVideo);
|
|
btnReset360->setHidden(!_bIsFrontVideo);
|
|
#else // !RM_MODEL_TYPE_TB4000
|
|
btnMode360_2D->setChecked(mode360 == MODE_360_ROUND);
|
|
btnMode360_3D->setChecked(mode360 == MODE_360_VR);
|
|
btnMode360_4CH->setChecked(mode360 == MODE_360_PANORAMA_2CH);
|
|
btnMode360_5CH->setChecked(mode360 == MODE_360_PENTA);
|
|
btnReset360->setEnabled(mode360 == MODE_360_VR);
|
|
btnReset360->setHidden(mode360 != MODE_360_VR);
|
|
|
|
#if (PLAYER_ONLY_LIBRARY_MODE)
|
|
btnSave360->setEnabled(mode360 == MODE_360_PANORAMA_2CH || mode360 == MODE_360_PENTA);
|
|
btnSave360->setHidden(mode360 != MODE_360_PANORAMA_2CH && mode360 != MODE_360_PENTA);
|
|
#endif // #if (PLAYER_ONLY_LIBRARY_MODE)
|
|
|
|
#endif // RM_MODEL_TYPE_TB4000
|
|
//btnZoom360->setHidden(!_bIsFrontVideo);
|
|
}
|
|
#if (PLAYER_ONLY_LIBRARY_MODE)
|
|
void RMFrameVideoBase::onSave360()
|
|
{
|
|
RMPlayer::instance()->prepareForCapture();
|
|
|
|
// 파일 저장 먼저 확인
|
|
QString documentPath = "";
|
|
QStringList list = QStandardPaths::standardLocations(QStandardPaths::DocumentsLocation);
|
|
if(list.count() > 0)
|
|
{
|
|
documentPath = list.first();
|
|
}
|
|
RMVideoItem* item = RMPlayer::instance()->getCurrentItem();
|
|
if(item == NULL) {
|
|
return;
|
|
}
|
|
|
|
QString filter = "JPEG file (*.jpg)";
|
|
QString destPath = QFileDialog::getSaveFileName(0,
|
|
FM_WSTR(L"파일 저장"),
|
|
documentPath + QDir::separator() + item->title() + ".jpg",
|
|
"JPEG file (*.jpg)",
|
|
&filter,
|
|
QFileDialog::DontConfirmOverwrite);
|
|
if(destPath.isEmpty() || destPath.isNull())
|
|
{
|
|
QApplication::restoreOverrideCursor();
|
|
setEnabled(true);
|
|
return;
|
|
}
|
|
|
|
// 기존 파일 삭제
|
|
QFileInfo finfo(destPath);
|
|
|
|
QString folder = finfo.dir().absolutePath();
|
|
QString name = finfo.baseName();
|
|
|
|
QPixmap pixmap = _videoWidget->grab();
|
|
QImage image = pixmap.toImage();
|
|
if(mode360 == MODE_360_PANORAMA_2CH) {
|
|
// 1. 이미지 크기 정보 가져오기
|
|
int w = image.width();
|
|
int h = image.height();
|
|
|
|
// 각 사분면의 너비와 높이
|
|
// 정수 나누기이므로, 홀수 크기의 경우 우하단 부분이 1픽셀 더 커질 수 있습니다.
|
|
int halfW = w / 2;
|
|
int halfH = h / 2;
|
|
|
|
// 2. 네 개의 사분면 영역 (QRect) 정의
|
|
// QRect(x, y, width, height)
|
|
|
|
// 2-1. 좌상단 (Top-Left)
|
|
QRect topLeftRect(0, 0, halfW, halfH);
|
|
QImage topLeftImage = image.copy(topLeftRect);
|
|
QString path1 = folder + QDir::separator() + name + "_1.jpg";
|
|
topLeftImage.save(path1);
|
|
|
|
// 2-2. 우상단 (Top-Right)
|
|
// 시작 x 좌표는 이미지 너비의 절반(halfW)부터 시작합니다.
|
|
QRect topRightRect(halfW, 0, w - halfW, halfH);
|
|
QImage topRightImage = image.copy(topRightRect);
|
|
QString path2 = folder + QDir::separator() + name + "_2.jpg";
|
|
topRightImage.save(path2);
|
|
|
|
// 2-3. 좌하단 (Bottom-Left)
|
|
// 시작 y 좌표는 이미지 높이의 절반(halfH)부터 시작합니다.
|
|
QRect bottomLeftRect(0, halfH, halfW, h - halfH);
|
|
QImage bottomLeftImage = image.copy(bottomLeftRect);
|
|
QString path3 = folder + QDir::separator() + name + "_3.jpg";
|
|
bottomLeftImage.save(path3);
|
|
|
|
// 2-4. 우하단 (Bottom-Right)
|
|
// 시작 x, y 좌표 모두 절반부터 시작합니다.
|
|
// 너비와 높이는 전체 크기에서 halfW/halfH를 뺀 나머지입니다. (홀수 크기 처리)
|
|
QRect bottomRightRect(halfW, halfH, w - halfW, h - halfH);
|
|
QImage bottomRightImage = image.copy(bottomRightRect);
|
|
QString path4 = folder + QDir::separator() + name + "_4.jpg";
|
|
bottomRightImage.save(path4);
|
|
} else { // 5CH
|
|
|
|
// 1. 이미지 크기 정보 가져오기
|
|
int w = image.width();
|
|
int h = image.height();
|
|
|
|
|
|
// 좌측 영역
|
|
const float leftArea = 0.5;
|
|
const int left = (int)(leftArea * ((float)w));
|
|
QRect leftRect(0, 0, left, h);
|
|
QImage leftImage = image.copy(leftRect);
|
|
QString path5 = folder + QDir::separator() + name + "_5.jpg";
|
|
leftImage.save(path5);
|
|
|
|
|
|
// 각 사분면의 너비와 높이
|
|
// 정수 나누기이므로, 홀수 크기의 경우 우하단 부분이 1픽셀 더 커질 수 있습니다.
|
|
int halfW = (w - left) / 2;
|
|
int halfH = h / 2;
|
|
|
|
// 2. 네 개의 사분면 영역 (QRect) 정의
|
|
|
|
// 2-1. 좌상단 (Top-Left)
|
|
QRect topLeftRect(left, 0, halfW, halfH);
|
|
QImage topLeftImage = image.copy(topLeftRect);
|
|
QString path1 = folder + QDir::separator() + name + "_1.jpg";
|
|
topLeftImage.save(path1);
|
|
|
|
// 2-2. 우상단 (Top-Right)
|
|
// 시작 x 좌표는 이미지 너비의 절반(halfW)부터 시작합니다.
|
|
QRect topRightRect(left+halfW, 0, halfW, halfH);
|
|
QImage topRightImage = image.copy(topRightRect);
|
|
QString path2 = folder + QDir::separator() + name + "_2.jpg";
|
|
topRightImage.save(path2);
|
|
|
|
// 2-3. 좌하단 (Bottom-Left)
|
|
// 시작 y 좌표는 이미지 높이의 절반(halfH)부터 시작합니다.
|
|
QRect bottomLeftRect(left, halfH, halfW, halfH);
|
|
QImage bottomLeftImage = image.copy(bottomLeftRect);
|
|
QString path3 = folder + QDir::separator() + name + "_3.jpg";
|
|
bottomLeftImage.save(path3);
|
|
|
|
// 2-4. 우하단 (Bottom-Right)
|
|
// 시작 x, y 좌표 모두 절반부터 시작합니다.
|
|
// 너비와 높이는 전체 크기에서 halfW/halfH를 뺀 나머지입니다. (홀수 크기 처리)
|
|
QRect bottomRightRect(left+halfW, halfH, halfW, halfH);
|
|
QImage bottomRightImage = image.copy(bottomRightRect);
|
|
QString path4 = folder + QDir::separator() + name + "_4.jpg";
|
|
bottomRightImage.save(path4);
|
|
|
|
}
|
|
//qInfo() << "folder:" << folder << "name:" << name << __FUNCTION__;
|
|
}
|
|
#endif // LIBRARY_MODE
|
|
|
|
#endif // TOP_DOWN_360
|
|
|