#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