Compare commits
6
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
b7ad00a4c5 | ||
|
|
fbbd77bfbf | ||
|
|
be06ca656d | ||
|
|
665cd0bb1c | ||
|
|
1c0321a705 | ||
|
|
5b9e16a708 |
No files matched your search
+1
-1
@@ -1,5 +1,5 @@
|
||||
---
|
||||
Checks: 'clang-diagnostic-*,clang-analyzer-*,cppcoreguidelines-*,-cppcoreguidelines-pro-bounds-array-to-pointer-decay,-cppcoreguidelines-pro-bounds-pointer-arithmetic'
|
||||
Checks: 'clang-diagnostic-*,clang-analyzer-*,cppcoreguidelines-*,-cppcoreguidelines-pro-bounds-array-to-pointer-decay,-cppcoreguidelines-pro-bounds-pointer-arithmetic,-cppcoreguidelines-non-private-member-variables-in-classes'
|
||||
WarningsAsErrors: ''
|
||||
HeaderFilterRegex: ''
|
||||
AnalyzeTemporaryDtors: false
|
||||
|
||||
@@ -56,6 +56,8 @@ SET(Calyp_App_SRCS
|
||||
ResourceHandle.cpp
|
||||
VideoHandle.cpp
|
||||
VideoSubWindow.cpp
|
||||
VideoStreamSubWindow.cpp
|
||||
ModuleSubWindow.cpp
|
||||
ViewArea.cpp
|
||||
GridManager.cpp
|
||||
# Module Quality
|
||||
|
||||
+21
-15
@@ -29,6 +29,7 @@
|
||||
#include <QDockWidget>
|
||||
|
||||
#include "ModuleHandleDock.h"
|
||||
#include "ModuleSubWindow.h"
|
||||
#include "VideoSubWindow.h"
|
||||
#include "lib/CalypFrame.h"
|
||||
#include "lib/CalypStream.h"
|
||||
@@ -55,16 +56,19 @@ CalypAppModuleIf::~CalypAppModuleIf()
|
||||
auto* ptr = m_pcModuleDock;
|
||||
m_pcModuleDock = NULL;
|
||||
ptr->close();
|
||||
delete ptr;
|
||||
}
|
||||
if( m_pcDisplaySubWindow )
|
||||
{
|
||||
auto* ptr = m_pcDisplaySubWindow;
|
||||
m_pcDisplaySubWindow = NULL;
|
||||
ptr->closeSubWindow();
|
||||
delete ptr;
|
||||
}
|
||||
if( m_pcDockWidget )
|
||||
{
|
||||
m_pcDockWidget->close();
|
||||
delete m_pcDockWidget;
|
||||
}
|
||||
if( m_pcModule )
|
||||
{
|
||||
@@ -77,7 +81,7 @@ void CalypAppModuleIf::update( bool isPlaying )
|
||||
{
|
||||
if( m_pcDisplaySubWindow )
|
||||
{
|
||||
m_pcDisplaySubWindow->refreshFrame();
|
||||
m_pcDisplaySubWindow->refreshSubWindow();
|
||||
}
|
||||
else
|
||||
{
|
||||
@@ -85,13 +89,13 @@ void CalypAppModuleIf::update( bool isPlaying )
|
||||
}
|
||||
}
|
||||
|
||||
void CalypAppModuleIf::setPlaying( bool isPlaying )
|
||||
{
|
||||
if( m_pcDisplaySubWindow )
|
||||
{
|
||||
m_pcDisplaySubWindow->setPlaying( isPlaying );
|
||||
}
|
||||
}
|
||||
// void CalypAppModuleIf::setPlaying( bool isPlaying )
|
||||
// {
|
||||
// if( m_pcDisplaySubWindow )
|
||||
// {
|
||||
// m_pcDisplaySubWindow->setPlaying( isPlaying );
|
||||
// }
|
||||
// }
|
||||
|
||||
bool CalypAppModuleIf::isRunning()
|
||||
{
|
||||
@@ -154,7 +158,6 @@ bool CalypAppModuleIf::apply( bool isPlaying, bool disableThreads )
|
||||
show();
|
||||
}
|
||||
}
|
||||
|
||||
return moduleExecuted;
|
||||
}
|
||||
|
||||
@@ -210,22 +213,25 @@ bool CalypAppModuleIf::process()
|
||||
|
||||
void CalypAppModuleIf::show()
|
||||
{
|
||||
if( m_canceling )
|
||||
return;
|
||||
switch( m_pcModule->m_iModuleType )
|
||||
{
|
||||
case CLP_FRAME_PROCESSING_MODULE: {
|
||||
auto displayWindow = m_pcDisplaySubWindow;
|
||||
auto displayWindow = qobject_cast<VideoSubWindow*>( m_pcDisplaySubWindow );
|
||||
if( displayWindow == nullptr )
|
||||
displayWindow = m_pcSubWindow[0];
|
||||
#ifdef CALYP_THREADED_MODULES
|
||||
if( m_Mutex.try_lock() )
|
||||
{
|
||||
m_pcDisplaySubWindow->setFillWindow( false );
|
||||
m_pcDisplaySubWindow->setCurrFrame( m_pcProcessedFrame );
|
||||
displayWindow->setFillWindow( false );
|
||||
displayWindow->setCurrFrame( m_pcProcessedFrame );
|
||||
m_Mutex.unlock();
|
||||
}
|
||||
#else
|
||||
displayWindow->setFillWindow( false );
|
||||
displayWindow->setCurrFrame( m_pcProcessedFrame );
|
||||
#endif
|
||||
m_pcDisplaySubWindow->setFillWindow( false );
|
||||
m_pcDisplaySubWindow->setCurrFrame( m_pcProcessedFrame );
|
||||
break;
|
||||
}
|
||||
case CLP_FRAME_MEASUREMENT_MODULE:
|
||||
@@ -238,7 +244,7 @@ void CalypAppModuleIf::disable()
|
||||
{
|
||||
QApplication::setOverrideCursor( Qt::WaitCursor );
|
||||
#ifdef CALYP_THREADED_MODULES
|
||||
QMutexLocker locker( &m_Mutex );
|
||||
m_canceling = true;
|
||||
m_Mutex.lock();
|
||||
m_Mutex.unlock();
|
||||
#endif
|
||||
|
||||
@@ -52,6 +52,7 @@ class CalypFrame;
|
||||
#define CLP_MODULE_MAX_NUM_FRAMES 5
|
||||
|
||||
class VideoSubWindow;
|
||||
class ModuleSubWindow;
|
||||
|
||||
class CalypAppModuleIf : std::enable_shared_from_this<CalypAppModuleIf>,
|
||||
#ifdef CALYP_THREADED_MODULES
|
||||
@@ -88,7 +89,7 @@ public:
|
||||
void update( bool isPlaying );
|
||||
bool apply( bool isPlaying = false, bool disableThreads = false );
|
||||
bool process();
|
||||
void setPlaying( bool isPlaying );
|
||||
// void setPlaying( bool isPlaying );
|
||||
bool isRunning();
|
||||
void show();
|
||||
void disable();
|
||||
@@ -105,7 +106,7 @@ private:
|
||||
std::vector<VideoSubWindow*> m_pcSubWindow;
|
||||
|
||||
// The module owns the related widgets
|
||||
VideoSubWindow* m_pcDisplaySubWindow{ nullptr };
|
||||
ModuleSubWindow* m_pcDisplaySubWindow{ nullptr };
|
||||
QDockWidget* m_pcDockWidget{ nullptr };
|
||||
ModuleHandleDock* m_pcModuleDock{ nullptr };
|
||||
|
||||
@@ -119,6 +120,7 @@ private:
|
||||
|
||||
#ifdef CALYP_THREADED_MODULES
|
||||
QMutex m_Mutex;
|
||||
std::atomic<bool> m_canceling{ false };
|
||||
#endif
|
||||
};
|
||||
|
||||
|
||||
+10
-12
@@ -192,13 +192,13 @@ void MainWindow::loadFile( QString fileName, CalypFileInfo* pStreamInfo )
|
||||
printMessage( "File " + fileName + " do not exist!", CLP_LOG_ERROR );
|
||||
return;
|
||||
}
|
||||
VideoSubWindow* videoSubWindow = MainWindow::findVideoStreamSubWindow( m_pcWindowHandle, fileName );
|
||||
auto* videoSubWindow = MainWindow::findVideoStreamSubWindow( m_pcWindowHandle, fileName );
|
||||
if( videoSubWindow )
|
||||
{
|
||||
m_pcWindowHandle->setActiveSubWindow( videoSubWindow );
|
||||
return;
|
||||
}
|
||||
videoSubWindow = new VideoSubWindow( VideoSubWindow::VIDEO_STREAM_SUBWINDOW ); // createSubWindow();
|
||||
videoSubWindow = new VideoStreamSubWindow(); // createSubWindow();
|
||||
videoSubWindow->setResourceManaget( m_appResourceHandle.get() );
|
||||
|
||||
if( !pStreamInfo )
|
||||
@@ -380,9 +380,8 @@ void MainWindow::saveStream()
|
||||
|
||||
void MainWindow::format()
|
||||
{
|
||||
if( m_pcCurrentVideoSubWindow )
|
||||
if( auto* pcVideoSubWindow = qobject_cast<VideoStreamSubWindow*>( m_pcCurrentVideoSubWindow ) )
|
||||
{
|
||||
VideoSubWindow* pcVideoSubWindow = m_pcCurrentVideoSubWindow;
|
||||
try
|
||||
{
|
||||
if( pcVideoSubWindow->loadFile( pcVideoSubWindow->getCurrentFileName(), true ) )
|
||||
@@ -436,10 +435,10 @@ void MainWindow::reloadAll()
|
||||
|
||||
void MainWindow::loadAll()
|
||||
{
|
||||
if( m_pcCurrentVideoSubWindow )
|
||||
if( auto* pcVideoSubWindow = qobject_cast<VideoStreamSubWindow*>( m_pcCurrentVideoSubWindow ) )
|
||||
{
|
||||
printMessage( "Loading file into memory...", CLP_LOG_INFO );
|
||||
m_pcCurrentVideoSubWindow->loadAll();
|
||||
pcVideoSubWindow->loadAll();
|
||||
printMessage( "File loaded", CLP_LOG_INFO );
|
||||
}
|
||||
}
|
||||
@@ -529,19 +528,18 @@ void MainWindow::dropEvent( QDropEvent* event )
|
||||
|
||||
// ----------------------- Sub Window Functions -----------------------
|
||||
|
||||
VideoSubWindow* MainWindow::findVideoStreamSubWindow( const SubWindowHandle* windowManager,
|
||||
const QString& fileName )
|
||||
VideoStreamSubWindow* MainWindow::findVideoStreamSubWindow( const SubWindowHandle* windowManager,
|
||||
const QString& fileName )
|
||||
{
|
||||
QString canonicalFilePath = QFileInfo( fileName ).canonicalFilePath();
|
||||
VideoSubWindow* pcSubWindow;
|
||||
QList<SubWindowAbstract*> subWindowList = windowManager->findSubWindow( SubWindowAbstract::VIDEO_STREAM_SUBWINDOW );
|
||||
for( int i = 0; i < subWindowList.size(); i++ )
|
||||
{
|
||||
pcSubWindow = qobject_cast<VideoSubWindow*>( subWindowList.at( i ) );
|
||||
auto* pcSubWindow = qobject_cast<VideoStreamSubWindow*>( subWindowList.at( i ) );
|
||||
if( pcSubWindow->getCurrentFileName() == canonicalFilePath )
|
||||
return qobject_cast<VideoSubWindow*>( pcSubWindow );
|
||||
return pcSubWindow;
|
||||
}
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
// ----------------------- Update Functions -----------------------
|
||||
|
||||
+4
-2
@@ -41,6 +41,7 @@
|
||||
#include <QVector>
|
||||
|
||||
#include "CommonDefs.h"
|
||||
#include "VideoStreamSubWindow.h"
|
||||
#include "VideoSubWindow.h"
|
||||
#include "config.h"
|
||||
#ifdef USE_QTDBUS
|
||||
@@ -59,6 +60,7 @@ class QSignalMapper;
|
||||
class CalypOptions;
|
||||
class CalypStream;
|
||||
class SubWindowHandle;
|
||||
class VideoStreamSubWindow;
|
||||
class VideoHandle;
|
||||
class QualityHandle;
|
||||
class ModulesHandle;
|
||||
@@ -130,8 +132,8 @@ private:
|
||||
QString m_cLastOpenPath;
|
||||
QStringList showFileDialog( bool bRead );
|
||||
|
||||
static VideoSubWindow* findVideoStreamSubWindow( const SubWindowHandle* windowManager,
|
||||
const QString& fileName );
|
||||
static VideoStreamSubWindow* findVideoStreamSubWindow( const SubWindowHandle* windowManager,
|
||||
const QString& fileName );
|
||||
|
||||
void updateMenus();
|
||||
|
||||
|
||||
@@ -0,0 +1,114 @@
|
||||
/* This file is a part of Calyp project
|
||||
* Copyright (C) 2014-2021 by Joao Carreira (jfmcarreira@gmail.com)
|
||||
* Luis Lucas (luisfrlucas@gmail.com)
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License along
|
||||
* with this program; if not, write to the Free Software Foundation, Inc.,
|
||||
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
||||
*/
|
||||
|
||||
/**
|
||||
* \file ModuleSubWindow.cpp
|
||||
* \brief Video Sub windows handling
|
||||
*/
|
||||
|
||||
#include "ModuleSubWindow.h"
|
||||
|
||||
#include <QSettings>
|
||||
#include <QStaticText>
|
||||
#include <cassert>
|
||||
|
||||
#include "ModulesHandle.h"
|
||||
|
||||
ModuleSubWindow::ModuleSubWindow( CalypAppModuleIf* module, QWidget* parent )
|
||||
: VideoSubWindow( VideoSubWindow::MODULE_SUBWINDOW, parent )
|
||||
{
|
||||
m_pcDisplayModule = module;
|
||||
}
|
||||
|
||||
ModuleSubWindow::~ModuleSubWindow()
|
||||
{
|
||||
}
|
||||
|
||||
void ModuleSubWindow::resetWindowName()
|
||||
{
|
||||
QString windowName{ "Module" };
|
||||
if( auto module_ptr = m_pcDisplayModule )
|
||||
{
|
||||
windowName.append( " " ).append( module_ptr->getModule()->m_pchModuleLongName );
|
||||
}
|
||||
setWindowName( windowName );
|
||||
}
|
||||
|
||||
void ModuleSubWindow::updateVideoWindowInfo()
|
||||
{
|
||||
m_cStreamInformation = "";
|
||||
|
||||
m_cStreamInformation = "Module";
|
||||
if( auto module_ptr = m_pcDisplayModule )
|
||||
{
|
||||
const auto& arraySubWindows = module_ptr->getSubWindowList();
|
||||
QStringList windowInfoList;
|
||||
if( arraySubWindows.size() > 0 )
|
||||
{
|
||||
for( std::size_t i = 0; i < arraySubWindows.size(); i++ )
|
||||
{
|
||||
if( arraySubWindows[i]->getWindowName() != getWindowName() )
|
||||
{
|
||||
windowInfoList.append( QString( "Input %1 - " + arraySubWindows[i]->getWindowName() ).arg( i + 1 ) );
|
||||
}
|
||||
}
|
||||
}
|
||||
if( module_ptr->getModuleRequirements() & CLP_MODULES_HAS_INFO )
|
||||
{
|
||||
QStringList list = QString::fromStdString( module_ptr->moduleInfo() ).split( '\n' );
|
||||
windowInfoList.append( list );
|
||||
}
|
||||
if( windowInfoList.size() > 0 )
|
||||
{
|
||||
m_pcVideoInfo->setInformationTopLeft( windowInfoList );
|
||||
}
|
||||
}
|
||||
if( m_pcCurrFrameAsset )
|
||||
{
|
||||
QString m_cPelFmtName = QString::fromStdString( m_pcCurrFrameAsset->getPelFmtName() );
|
||||
m_cStreamInformation += " | " + m_cPelFmtName;
|
||||
}
|
||||
if( m_cStreamInformation.isEmpty() )
|
||||
{
|
||||
m_cStreamInformation = " ";
|
||||
}
|
||||
}
|
||||
|
||||
bool ModuleSubWindow::isPlaying()
|
||||
{
|
||||
if( auto module_ptr = m_pcDisplayModule )
|
||||
{
|
||||
for( auto window : module_ptr->getSubWindowList() )
|
||||
{
|
||||
if( window->isPlaying() )
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
void ModuleSubWindow::refreshSubWindow()
|
||||
{
|
||||
if( auto module_ptr = m_pcDisplayModule )
|
||||
{
|
||||
setFillWindow( true );
|
||||
updateVideoWindowInfo();
|
||||
module_ptr->apply( isPlaying(), false );
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,64 @@
|
||||
/* This file is a part of Calyp project
|
||||
* Copyright (C) 2014-2021 by Joao Carreira (jfmcarreira@gmail.com)
|
||||
* Luis Lucas (luisfrlucas@gmail.com)
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License along
|
||||
* with this program; if not, write to the Free Software Foundation, Inc.,
|
||||
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
||||
*/
|
||||
|
||||
/**
|
||||
* \file ModuleSubWindow.h
|
||||
* \brief Video Sub windows handling
|
||||
*/
|
||||
|
||||
#ifndef __MODULESUBWINDOW_H__
|
||||
#define __MODULESUBWINDOW_H__
|
||||
|
||||
#include <QDataStream>
|
||||
#include <QFuture>
|
||||
#include <QRect>
|
||||
#include <QString>
|
||||
#include <QVector>
|
||||
|
||||
#include "CalypAppModuleIf.h"
|
||||
#include "CommonDefs.h"
|
||||
#include "VideoSubWindow.h"
|
||||
#include "config.h"
|
||||
#include "lib/CalypStream.h"
|
||||
|
||||
class VideoInformation;
|
||||
|
||||
class ModuleSubWindow : public VideoSubWindow
|
||||
{
|
||||
Q_OBJECT
|
||||
|
||||
public:
|
||||
ModuleSubWindow( CalypAppModuleIf* module, QWidget* parent = 0 );
|
||||
~ModuleSubWindow();
|
||||
|
||||
void resetWindowName();
|
||||
|
||||
void updateVideoWindowInfo();
|
||||
|
||||
bool isPlaying();
|
||||
void stop(){};
|
||||
void advanceOneFrame(){};
|
||||
auto getFrameNum() -> std::uint64_t { return 1; };
|
||||
|
||||
void refreshSubWindow();
|
||||
|
||||
void setCurrFrame( std::shared_ptr<CalypFrame> pcCurrFrame );
|
||||
};
|
||||
|
||||
#endif // __MODULESUBWINDOW_H__
|
||||
+18
-23
@@ -27,6 +27,7 @@
|
||||
#include <cstdio>
|
||||
|
||||
#include "MainWindow.h"
|
||||
#include "ModuleSubWindow.h"
|
||||
#include "ModulesHandleOptDialog.h"
|
||||
#include "SubWindowHandle.h"
|
||||
#include "SubWindowSelectorDialog.h"
|
||||
@@ -184,18 +185,17 @@ void ModulesHandle::updateMenus()
|
||||
|
||||
if( pcSubWindow )
|
||||
{
|
||||
auto apcCurrentModule = pcSubWindow->getModuleArray();
|
||||
m_arrayActions[DISABLE_ACT]->setEnabled( apcCurrentModule.size() > 0 );
|
||||
m_arrayActions[DISABLE_ACT]->setEnabled( pcSubWindow->hasModules() );
|
||||
if( pcSubWindow->getDisplayModule() )
|
||||
{
|
||||
m_arrayActions[APPLY_ALL_ACT]->setEnabled( true );
|
||||
m_arrayActions[SWAP_FRAMES_ACT]->setEnabled( true );
|
||||
}
|
||||
for( int i = 0; i < apcCurrentModule.size(); i++ )
|
||||
{
|
||||
currModuleAction = apcCurrentModule.at( i )->m_pcModuleAction;
|
||||
currModuleAction->setChecked( true );
|
||||
}
|
||||
// for( int i = 0; i < apcCurrentModule.size(); i++ )
|
||||
// {
|
||||
// currModuleAction = apcCurrentModule.at( i )->m_pcModuleAction;
|
||||
// currModuleAction->setChecked( true );
|
||||
// }
|
||||
}
|
||||
}
|
||||
|
||||
@@ -219,16 +219,15 @@ void ModulesHandle::processOpt( int index )
|
||||
CalypAppModuleIf* pcCurrentModule = pcSubWindow->getDisplayModule();
|
||||
if( pcCurrentModule )
|
||||
{
|
||||
CalypAppModuleIf* pcCurrModule = pcCurrentModule;
|
||||
switch( index )
|
||||
{
|
||||
case INVALID_OPT:
|
||||
break;
|
||||
case SWAP_FRAMES_ACT:
|
||||
swapModulesWindowsIf( pcCurrModule );
|
||||
swapModulesWindowsIf( pcCurrentModule );
|
||||
break;
|
||||
case APPLY_ALL_ACT:
|
||||
applyAllModuleIf( pcCurrModule );
|
||||
applyAllModuleIf( pcCurrentModule );
|
||||
break;
|
||||
default:
|
||||
Q_ASSERT( 0 );
|
||||
@@ -376,14 +375,12 @@ void ModulesHandle::activateModule()
|
||||
|
||||
QString windowName;
|
||||
|
||||
VideoSubWindow* pcModuleSubWindow = NULL;
|
||||
if( pcCurrAppModuleIf->m_pcModule->m_iModuleType == CLP_FRAME_PROCESSING_MODULE )
|
||||
{
|
||||
if( ( pcCurrAppModuleIf->m_pcModule->m_uiModuleRequirements & CLP_MODULE_REQUIRES_NEW_WINDOW ) || bShowModulesNewWindow )
|
||||
{
|
||||
pcModuleSubWindow = new VideoSubWindow( VideoSubWindow::MODULE_SUBWINDOW, pcCurrAppModuleIf.get() );
|
||||
windowName.append( QStringLiteral( "Module " ) );
|
||||
windowName.append( pcCurrAppModuleIf->m_pcModule->m_pchModuleLongName );
|
||||
auto pcModuleSubWindow = new ModuleSubWindow( pcCurrAppModuleIf.get() );
|
||||
pcModuleSubWindow->resetWindowName();
|
||||
pcCurrAppModuleIf->m_pcDisplaySubWindow = pcModuleSubWindow;
|
||||
// connect( pcModuleSubWindow->getViewArea(), SIGNAL( selectionChanged( QRect ) ), m_appModuleVideo,
|
||||
// SLOT( updateSelectionArea( QRect ) ) );
|
||||
@@ -445,12 +442,11 @@ void ModulesHandle::activateModule()
|
||||
|
||||
QCoreApplication::processEvents();
|
||||
|
||||
if( pcModuleSubWindow )
|
||||
if( pcCurrAppModuleIf->m_pcDisplaySubWindow )
|
||||
{
|
||||
pcModuleSubWindow->setWindowName( windowName );
|
||||
m_pcMainWindowManager->addSubWindow( pcModuleSubWindow );
|
||||
pcModuleSubWindow->show();
|
||||
m_appModuleVideo->addSubWindow( pcModuleSubWindow );
|
||||
m_pcMainWindowManager->addSubWindow( pcCurrAppModuleIf->m_pcDisplaySubWindow );
|
||||
pcCurrAppModuleIf->m_pcDisplaySubWindow->show();
|
||||
m_appModuleVideo->addSubWindow( pcCurrAppModuleIf->m_pcDisplaySubWindow );
|
||||
}
|
||||
else
|
||||
{
|
||||
@@ -540,7 +536,7 @@ void ModulesHandle::applyAllModuleIf( CalypAppModuleIf* pcCurrModuleIf )
|
||||
Height = pcCurrModuleIf->m_pcProcessedFrame->getHeight();
|
||||
InputFormat = pcCurrModuleIf->m_pcProcessedFrame->getPelFormat();
|
||||
BitsPixel = pcCurrModuleIf->m_pcProcessedFrame->getBitsPel();
|
||||
FrameRate = pcCurrModuleIf->m_pcSubWindow[0]->getInputStream()->getFrameRate();
|
||||
FrameRate = 30;
|
||||
|
||||
pcCurrModuleIf->m_pcModuleStream = std::unique_ptr<CalypStream>();
|
||||
if( !pcCurrModuleIf->m_pcModuleStream->open( fileName.toStdString(), Width, Height, InputFormat, BitsPixel,
|
||||
@@ -558,7 +554,7 @@ void ModulesHandle::applyAllModuleIf( CalypAppModuleIf* pcCurrModuleIf )
|
||||
std::uint64_t numberOfFrames = -1;
|
||||
for( unsigned int i = 0; i < numberOfWindows; i++ )
|
||||
{
|
||||
currFrames = pcCurrModuleIf->m_pcSubWindow[i]->getInputStream()->getFrameNum();
|
||||
currFrames = pcCurrModuleIf->m_pcSubWindow[i]->getFrameNum();
|
||||
if( currFrames < numberOfFrames )
|
||||
numberOfFrames = currFrames;
|
||||
pcCurrModuleIf->m_pcSubWindow[i]->stop();
|
||||
@@ -571,8 +567,7 @@ void ModulesHandle::applyAllModuleIf( CalypAppModuleIf* pcCurrModuleIf )
|
||||
pcCurrModuleIf->m_pcModuleStream->writeFrame( *pcCurrModuleIf->m_pcProcessedFrame );
|
||||
for( unsigned int i = 0; i < numberOfWindows; i++ )
|
||||
{
|
||||
pcCurrModuleIf->m_pcSubWindow[i]->play();
|
||||
pcCurrModuleIf->m_pcSubWindow[i]->playEvent();
|
||||
pcCurrModuleIf->m_pcSubWindow[i]->advanceOneFrame();
|
||||
}
|
||||
}
|
||||
for( unsigned int i = 0; i < numberOfWindows; i++ )
|
||||
|
||||
@@ -169,10 +169,10 @@ void QualityHandle::measureQuality( QVector<VideoSubWindow*> apcWindowList )
|
||||
}
|
||||
VideoSubWindow* pcReferenceWindow = apcWindowList.at( 0 )->getRefSubWindow();
|
||||
|
||||
numberOfFrames = pcReferenceWindow->getInputStream()->getFrameNum();
|
||||
numberOfFrames = pcReferenceWindow->getFrameNum();
|
||||
for( unsigned i = 0; i < numberOfWindows; i++ )
|
||||
{
|
||||
currFrames = apcWindowList.at( i )->getInputStream()->getFrameNum();
|
||||
currFrames = apcWindowList.at( i )->getFrameNum();
|
||||
if( currFrames < numberOfFrames )
|
||||
numberOfFrames = currFrames;
|
||||
apcWindowList.at( i )->stop();
|
||||
@@ -183,7 +183,6 @@ void QualityHandle::measureQuality( QVector<VideoSubWindow*> apcWindowList )
|
||||
|
||||
QVector<double>* padQualityValues = new QVector<double>[numberOfWindows + 1];
|
||||
double* padAverageQuality = new double[numberOfWindows + 1];
|
||||
double dCurrentQuality;
|
||||
|
||||
for( unsigned i = 0; i < numberOfWindows + 1; i++ )
|
||||
{
|
||||
@@ -199,12 +198,12 @@ void QualityHandle::measureQuality( QVector<VideoSubWindow*> apcWindowList )
|
||||
for( unsigned int i = 0; i < numberOfWindows; i++ )
|
||||
{
|
||||
pcCurrFrame = apcWindowList.at( i )->getCurrFrame();
|
||||
dCurrentQuality = pcCurrFrame->getQuality( m_iQualityMetricIdx, pcReferenceFrame, CLP_LUMA );
|
||||
double dCurrentQuality = pcCurrFrame->getQuality( m_iQualityMetricIdx, pcReferenceFrame, CLP_LUMA );
|
||||
padAverageQuality[i + 1] = ( padAverageQuality[i + 1] * double( f ) + dCurrentQuality ) / double( f + 1 );
|
||||
padQualityValues[i + 1].append( dCurrentQuality );
|
||||
apcWindowList.at( i )->seekRelativeEvent( true );
|
||||
apcWindowList.at( i )->advanceOneFrame();
|
||||
}
|
||||
pcReferenceWindow->seekRelativeEvent( true );
|
||||
pcReferenceWindow->advanceOneFrame();
|
||||
pcProgressBar->incrementProgress( 1 );
|
||||
}
|
||||
for( unsigned int i = 0; i < numberOfWindows; i++ )
|
||||
|
||||
@@ -26,8 +26,10 @@
|
||||
|
||||
#include <QCloseEvent>
|
||||
#include <QFocusEvent>
|
||||
#include <QGuiApplication>
|
||||
#include <QHBoxLayout>
|
||||
#include <QIcon>
|
||||
#include <QScreen>
|
||||
#include <QScrollBar>
|
||||
|
||||
#include "MdiSubWindow.h"
|
||||
@@ -87,10 +89,20 @@ bool SubWindowAbstract::mayClose()
|
||||
|
||||
QSize SubWindowAbstract::sizeHint() const
|
||||
{
|
||||
return QSize();
|
||||
QSize maxSize;
|
||||
QWidget* p = parentWidget();
|
||||
if( p )
|
||||
{
|
||||
maxSize = p->size();
|
||||
}
|
||||
else
|
||||
{
|
||||
maxSize = QGuiApplication::screens()[0]->availableGeometry().size();
|
||||
}
|
||||
return sizeHint( maxSize );
|
||||
}
|
||||
|
||||
QSize SubWindowAbstract::sizeHint( const QSize& ) const
|
||||
QSize SubWindowAbstract::sizeHint( const QSize& maxSize ) const
|
||||
{
|
||||
return QSize();
|
||||
}
|
||||
|
||||
@@ -107,7 +107,7 @@ public:
|
||||
* Size related functions
|
||||
*/
|
||||
virtual QSize sizeHint() const;
|
||||
virtual QSize sizeHint( const QSize& ) const;
|
||||
virtual QSize sizeHint( const QSize& maxSize ) const;
|
||||
|
||||
/**
|
||||
* Window name
|
||||
|
||||
+53
-53
@@ -40,6 +40,7 @@
|
||||
#include "SeekStreamDialog.h"
|
||||
#include "SubWindowHandle.h"
|
||||
#include "SubWindowSelectorDialog.h"
|
||||
#include "VideoStreamSubWindow.h"
|
||||
#include "VideoSubWindow.h"
|
||||
|
||||
VideoHandle::VideoHandle( QWidget* parent, SubWindowHandle* windowManager )
|
||||
@@ -325,10 +326,16 @@ void VideoHandle::update()
|
||||
{
|
||||
if( m_pcCurrentVideoSubWindow )
|
||||
{
|
||||
const CalypStream* pcStream = m_pcCurrentVideoSubWindow->getInputStream();
|
||||
const CalypFrame* pcFrame = m_pcCurrentVideoSubWindow->getCurrFrame();
|
||||
bool isPlaying{ false };
|
||||
const CalypStream* pcStream{ nullptr };
|
||||
if( auto* videoStreamSubWindow = qobject_cast<VideoStreamSubWindow*>( m_pcCurrentVideoSubWindow ) )
|
||||
{
|
||||
pcStream = videoStreamSubWindow->getInputStream();
|
||||
isPlaying = videoStreamSubWindow->isPlaying();
|
||||
}
|
||||
auto pcFrame = m_pcCurrentVideoSubWindow->getCurrFrameAsset();
|
||||
|
||||
m_pcVideoFormatLabel->setText( m_pcCurrentVideoSubWindow->getStreamInformation() );
|
||||
m_pcVideoFormatLabel->setText( m_pcCurrentVideoSubWindow->getVideoInformation() );
|
||||
|
||||
QString resolution;
|
||||
if( pcFrame )
|
||||
@@ -362,7 +369,7 @@ void VideoHandle::update()
|
||||
}
|
||||
}
|
||||
m_pcResolutionLabel->setText( resolution );
|
||||
m_pcFramePropertiesSideBar->setFrame( m_pcCurrentVideoSubWindow->getCurrFrameAsset(), m_pcCurrentVideoSubWindow->isPlaying() );
|
||||
m_pcFramePropertiesSideBar->setFrame( pcFrame, isPlaying );
|
||||
|
||||
m_pcFrameNumInfo->setTotalFrameNum( total_frame_num );
|
||||
m_pcFrameNumInfo->setCurrFrameNum( frame_num );
|
||||
@@ -433,12 +440,11 @@ void VideoHandle::addSubWindow( VideoSubWindow* window )
|
||||
|
||||
void VideoHandle::closeSubWindow( SubWindowAbstract* subWindow )
|
||||
{
|
||||
VideoSubWindow* videoSubWindow = qobject_cast<VideoSubWindow*>( subWindow );
|
||||
auto* videoStreamSubWindow = qobject_cast<VideoStreamSubWindow*>( subWindow );
|
||||
|
||||
if( m_acPlayingSubWindows.contains( videoSubWindow ) )
|
||||
if( m_acPlayingSubWindows.contains( videoStreamSubWindow ) )
|
||||
{
|
||||
int pos = m_acPlayingSubWindows.indexOf( videoSubWindow );
|
||||
// m_acPlayingSubWindows.at( pos )->stop();
|
||||
int pos = m_acPlayingSubWindows.indexOf( videoStreamSubWindow );
|
||||
m_acPlayingSubWindows.remove( pos );
|
||||
if( m_acPlayingSubWindows.size() < 2 )
|
||||
{
|
||||
@@ -541,18 +547,18 @@ unsigned long VideoHandle::getMaxFrameNumber()
|
||||
unsigned long maxFrames = INT_MAX;
|
||||
if( m_pcCurrentVideoSubWindow )
|
||||
{
|
||||
if( m_acPlayingSubWindows.contains( m_pcCurrentVideoSubWindow ) )
|
||||
if( m_acPlayingSubWindows.contains( qobject_cast<VideoStreamSubWindow*>( m_pcCurrentVideoSubWindow ) ) )
|
||||
{
|
||||
for( int i = 0; i < m_acPlayingSubWindows.size(); i++ )
|
||||
{
|
||||
currFrames = m_acPlayingSubWindows.at( i )->getInputStream()->getFrameNum();
|
||||
currFrames = m_acPlayingSubWindows.at( i )->getFrameNum();
|
||||
if( currFrames < maxFrames )
|
||||
maxFrames = currFrames;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
maxFrames = m_pcCurrentVideoSubWindow->getInputStream()->getFrameNum();
|
||||
maxFrames = m_pcCurrentVideoSubWindow->getFrameNum();
|
||||
}
|
||||
}
|
||||
return maxFrames;
|
||||
@@ -565,9 +571,9 @@ void VideoHandle::setTimerStatus()
|
||||
{
|
||||
status |= m_acPlayingSubWindows.at( i )->isPlaying();
|
||||
}
|
||||
if( m_pcCurrentVideoSubWindow )
|
||||
if( auto* videoStreamSubWindow = qobject_cast<VideoStreamSubWindow*>( m_pcCurrentVideoSubWindow ) )
|
||||
{
|
||||
status |= m_pcCurrentVideoSubWindow->isPlaying();
|
||||
status |= videoStreamSubWindow->isPlaying();
|
||||
}
|
||||
if( status )
|
||||
{
|
||||
@@ -596,13 +602,12 @@ void VideoHandle::configureFrameRateTimer()
|
||||
|
||||
void VideoHandle::play()
|
||||
{
|
||||
if( !m_pcCurrentVideoSubWindow )
|
||||
auto* videoStreamSubWindow = qobject_cast<VideoStreamSubWindow*>( m_pcCurrentVideoSubWindow );
|
||||
|
||||
if( videoStreamSubWindow == nullptr )
|
||||
return;
|
||||
|
||||
if( !m_pcCurrentVideoSubWindow->getInputStream() )
|
||||
return;
|
||||
|
||||
if( !m_pcCurrentVideoSubWindow->isPlaying() ) // Not playing
|
||||
if( !videoStreamSubWindow->isPlaying() ) // Not playing
|
||||
{
|
||||
if( m_acPlayingSubWindows.size() < 2 )
|
||||
{
|
||||
@@ -611,9 +616,9 @@ void VideoHandle::play()
|
||||
m_acPlayingSubWindows.at( i )->pause();
|
||||
}
|
||||
m_acPlayingSubWindows.clear();
|
||||
m_acPlayingSubWindows.append( m_pcCurrentVideoSubWindow );
|
||||
m_acPlayingSubWindows.append( videoStreamSubWindow );
|
||||
}
|
||||
if( m_acPlayingSubWindows.contains( m_pcCurrentVideoSubWindow ) )
|
||||
if( m_acPlayingSubWindows.contains( videoStreamSubWindow ) )
|
||||
{
|
||||
for( int i = 0; i < m_acPlayingSubWindows.size(); i++ )
|
||||
{
|
||||
@@ -624,7 +629,7 @@ void VideoHandle::play()
|
||||
}
|
||||
else
|
||||
{
|
||||
if( m_acPlayingSubWindows.contains( m_pcCurrentVideoSubWindow ) )
|
||||
if( m_acPlayingSubWindows.contains( videoStreamSubWindow ) )
|
||||
{
|
||||
for( int i = 0; i < m_acPlayingSubWindows.size(); i++ )
|
||||
{
|
||||
@@ -633,12 +638,11 @@ void VideoHandle::play()
|
||||
}
|
||||
else
|
||||
{
|
||||
m_pcCurrentVideoSubWindow->pause();
|
||||
videoStreamSubWindow->pause();
|
||||
}
|
||||
}
|
||||
setTimerStatus();
|
||||
emit changed();
|
||||
// update();
|
||||
}
|
||||
|
||||
void VideoHandle::stop()
|
||||
@@ -711,9 +715,7 @@ void VideoHandle::playEvent()
|
||||
}
|
||||
catch( const char* msg )
|
||||
{
|
||||
QString warningMsg = "Error while playing " +
|
||||
QFileInfo( m_pcCurrentVideoSubWindow->getCurrentFileName() ).fileName() +
|
||||
" with the following error: \n" + msg;
|
||||
QString warningMsg = "Error while playing " + m_pcCurrentVideoSubWindow->getWindowName() + " with the following error: \n" + msg;
|
||||
QMessageBox::warning( m_pcParet, QApplication::applicationName(), warningMsg );
|
||||
qDebug() << warningMsg;
|
||||
stop();
|
||||
@@ -730,11 +732,11 @@ void VideoHandle::playEvent()
|
||||
|
||||
void VideoHandle::seekEvent( int direction )
|
||||
{
|
||||
if( m_pcCurrentVideoSubWindow )
|
||||
if( auto* videoStreamSubWindow = qobject_cast<VideoStreamSubWindow*>( m_pcCurrentVideoSubWindow ) )
|
||||
{
|
||||
if( m_acPlayingSubWindows.contains( m_pcCurrentVideoSubWindow ) )
|
||||
if( m_acPlayingSubWindows.contains( videoStreamSubWindow ) )
|
||||
{
|
||||
if( !( (unsigned int)( m_pcCurrentVideoSubWindow->getInputStream()->getCurrFrameNum() + 1 ) >= getMaxFrameNumber() &&
|
||||
if( !( (unsigned int)( videoStreamSubWindow->getInputStream()->getCurrFrameNum() + 1 ) >= getMaxFrameNumber() &&
|
||||
direction > 0 ) )
|
||||
{
|
||||
for( auto playingSubWindow : m_acPlayingSubWindows )
|
||||
@@ -745,7 +747,7 @@ void VideoHandle::seekEvent( int direction )
|
||||
}
|
||||
else
|
||||
{
|
||||
m_pcCurrentVideoSubWindow->seekRelativeEvent( direction > 0 ? true : false );
|
||||
videoStreamSubWindow->seekRelativeEvent( direction > 0 ? true : false );
|
||||
}
|
||||
emit changed();
|
||||
}
|
||||
@@ -753,37 +755,37 @@ void VideoHandle::seekEvent( int direction )
|
||||
|
||||
void VideoHandle::seekVideo()
|
||||
{
|
||||
if( m_pcCurrentVideoSubWindow )
|
||||
if( auto* videoStreamSubWindow = qobject_cast<VideoStreamSubWindow*>( m_pcCurrentVideoSubWindow ) )
|
||||
{
|
||||
if( m_pcCurrentVideoSubWindow->getInputStream() )
|
||||
SeekStreamDialog* dialogSeekVideo = new SeekStreamDialog( videoStreamSubWindow->getInputStream(), m_pcParet );
|
||||
int newFrameNum = dialogSeekVideo->runDialog();
|
||||
if( newFrameNum >= 0 )
|
||||
{
|
||||
SeekStreamDialog* dialogSeekVideo =
|
||||
new SeekStreamDialog( m_pcCurrentVideoSubWindow->getInputStream(), m_pcParet );
|
||||
int newFrameNum = dialogSeekVideo->runDialog();
|
||||
if( newFrameNum >= 0 )
|
||||
if( m_acPlayingSubWindows.contains( videoStreamSubWindow ) )
|
||||
{
|
||||
if( m_acPlayingSubWindows.contains( m_pcCurrentVideoSubWindow ) )
|
||||
for( auto playingSubWindow : m_acPlayingSubWindows )
|
||||
{
|
||||
for( auto playingSubWindow : m_acPlayingSubWindows )
|
||||
{
|
||||
playingSubWindow->seekAbsoluteEvent( (unsigned int)newFrameNum );
|
||||
}
|
||||
playingSubWindow->seekAbsoluteEvent( (unsigned int)newFrameNum );
|
||||
}
|
||||
else
|
||||
{
|
||||
m_pcCurrentVideoSubWindow->seekAbsoluteEvent( (unsigned int)newFrameNum );
|
||||
}
|
||||
emit changed();
|
||||
}
|
||||
else
|
||||
{
|
||||
videoStreamSubWindow->seekAbsoluteEvent( (unsigned int)newFrameNum );
|
||||
}
|
||||
emit changed();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void VideoHandle::seekSliderEvent( int new_frame_num )
|
||||
{
|
||||
if( m_pcCurrentVideoSubWindow && !m_bIsPlaying ) // TODO: Fix this slot
|
||||
// TODO: Fix this slot
|
||||
if( m_bIsPlaying )
|
||||
return;
|
||||
|
||||
if( auto* videoStreamSubWindow = qobject_cast<VideoStreamSubWindow*>( m_pcCurrentVideoSubWindow ) )
|
||||
{
|
||||
if( m_acPlayingSubWindows.contains( m_pcCurrentVideoSubWindow ) )
|
||||
if( m_acPlayingSubWindows.contains( videoStreamSubWindow ) )
|
||||
{
|
||||
for( auto playingSubWindow : m_acPlayingSubWindows )
|
||||
{
|
||||
@@ -792,7 +794,7 @@ void VideoHandle::seekSliderEvent( int new_frame_num )
|
||||
}
|
||||
else
|
||||
{
|
||||
m_pcCurrentVideoSubWindow->seekAbsoluteEvent( (unsigned int)new_frame_num );
|
||||
videoStreamSubWindow->seekAbsoluteEvent( (unsigned int)new_frame_num );
|
||||
}
|
||||
emit changed();
|
||||
}
|
||||
@@ -800,8 +802,6 @@ void VideoHandle::seekSliderEvent( int new_frame_num )
|
||||
|
||||
void VideoHandle::videoSelectionButtonEvent()
|
||||
{
|
||||
VideoSubWindow* videoSubWindow;
|
||||
|
||||
Qt::KeyboardModifiers keyModifiers = QApplication::keyboardModifiers();
|
||||
if( keyModifiers & Qt::ControlModifier )
|
||||
{
|
||||
@@ -809,7 +809,7 @@ void VideoHandle::videoSelectionButtonEvent()
|
||||
m_pcMainWindowManager->findSubWindow( SubWindowAbstract::VIDEO_STREAM_SUBWINDOW );
|
||||
for( auto subWindow : subWindowList )
|
||||
{
|
||||
videoSubWindow = qobject_cast<VideoSubWindow*>( subWindow );
|
||||
auto* videoSubWindow = qobject_cast<VideoStreamSubWindow*>( subWindow );
|
||||
m_acPlayingSubWindows.append( videoSubWindow );
|
||||
}
|
||||
}
|
||||
@@ -829,7 +829,7 @@ void VideoHandle::videoSelectionButtonEvent()
|
||||
QList<SubWindowAbstract*> selectedSubWindowList = dialogWindowsSelection.getSelectedWindows();
|
||||
for( auto window : selectedSubWindowList )
|
||||
{
|
||||
videoSubWindow = qobject_cast<VideoSubWindow*>( window );
|
||||
auto* videoSubWindow = qobject_cast<VideoStreamSubWindow*>( window );
|
||||
m_acPlayingSubWindows.append( videoSubWindow );
|
||||
}
|
||||
}
|
||||
|
||||
+4
-3
@@ -33,6 +33,7 @@
|
||||
#include <QWidget>
|
||||
|
||||
#include "CommonDefs.h"
|
||||
#include "VideoSubWindow.h"
|
||||
#include "config.h"
|
||||
|
||||
class QToolBar;
|
||||
@@ -43,7 +44,7 @@ class QSlider;
|
||||
|
||||
class SubWindowHandle;
|
||||
class SubWindowAbstract;
|
||||
class VideoSubWindow;
|
||||
class VideoStreamSubWindow;
|
||||
class FramePropertiesDock;
|
||||
class FrameNumberWidget;
|
||||
class QTimer;
|
||||
@@ -116,8 +117,8 @@ private:
|
||||
QLabel* m_pcVideoFormatLabel;
|
||||
QLabel* m_pcResolutionLabel;
|
||||
|
||||
VideoSubWindow* m_pcCurrentVideoSubWindow;
|
||||
QVector<VideoSubWindow*> m_acPlayingSubWindows;
|
||||
QPointer<VideoSubWindow> m_pcCurrentVideoSubWindow;
|
||||
QVector<VideoStreamSubWindow*> m_acPlayingSubWindows;
|
||||
|
||||
QTimer* m_pcPlayingTimer;
|
||||
bool m_bIsPlaying;
|
||||
|
||||
@@ -0,0 +1,595 @@
|
||||
/* This file is a part of Calyp project
|
||||
* Copyright (C) 2014-2021 by Joao Carreira (jfmcarreira@gmail.com)
|
||||
* Luis Lucas (luisfrlucas@gmail.com)
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License along
|
||||
* with this program; if not, write to the Free Software Foundation, Inc.,
|
||||
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
||||
*/
|
||||
|
||||
/**
|
||||
* \file VideoStreamSubWindow.cpp
|
||||
* \brief Video Sub windows handling
|
||||
*/
|
||||
|
||||
#include "VideoStreamSubWindow.h"
|
||||
|
||||
#include <QScrollArea>
|
||||
#include <QSettings>
|
||||
#include <QStaticText>
|
||||
#include <cassert>
|
||||
|
||||
#include "ConfigureFormatDialog.h"
|
||||
#include "ModulesHandle.h"
|
||||
#include "QtConcurrent/qtconcurrentrun.h"
|
||||
#include "ResourceHandle.h"
|
||||
#include "SubWindowAbstract.h"
|
||||
|
||||
#define QT_NO_CONCURRENT
|
||||
|
||||
/**
|
||||
* \brief Functions to control data stream from stream information
|
||||
*/
|
||||
|
||||
QDataStream& operator<<( QDataStream& out, const CalypFileInfoVector& array )
|
||||
{
|
||||
CalypFileInfo d;
|
||||
out << array.size();
|
||||
for( int i = 0; i < array.size(); i++ )
|
||||
{
|
||||
d = array.at( i );
|
||||
out << d.m_cFilename << d.m_uiWidth << d.m_uiHeight << d.m_iPelFormat << d.m_uiBitsPelPixel << d.m_iEndianness
|
||||
<< d.m_uiFrameRate << d.m_uiFileSize;
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
QDataStream& operator>>( QDataStream& in, CalypFileInfoVector& array )
|
||||
{
|
||||
CalypFileInfo d;
|
||||
int array_size{ 0 };
|
||||
in >> array_size;
|
||||
for( int i = 0; i < array_size; i++ )
|
||||
{
|
||||
in >> d.m_cFilename;
|
||||
in >> d.m_uiWidth;
|
||||
in >> d.m_uiHeight;
|
||||
in >> d.m_iPelFormat;
|
||||
in >> d.m_uiBitsPelPixel;
|
||||
in >> d.m_iEndianness;
|
||||
in >> d.m_uiFrameRate;
|
||||
in >> d.m_uiFileSize;
|
||||
array.append( d );
|
||||
}
|
||||
return in;
|
||||
}
|
||||
|
||||
int findCalypStreamInfo( CalypFileInfoVector array, QString filename )
|
||||
{
|
||||
for( int i = 0; i < array.size(); i++ )
|
||||
if( array.at( i ).m_cFilename == filename )
|
||||
return i;
|
||||
return -1;
|
||||
}
|
||||
|
||||
VideoStreamSubWindow::VideoStreamSubWindow( QWidget* parent )
|
||||
: VideoSubWindow( VideoSubWindow::VIDEO_STREAM_SUBWINDOW, parent )
|
||||
, m_pcResourceManager( nullptr )
|
||||
, m_pCurrStream( NULL )
|
||||
, m_bIsPlaying( false )
|
||||
|
||||
{
|
||||
}
|
||||
|
||||
VideoStreamSubWindow::~VideoStreamSubWindow()
|
||||
{
|
||||
if( m_pcResourceManager )
|
||||
m_pcResourceManager->removeResource( m_uiResourceId );
|
||||
}
|
||||
|
||||
void VideoStreamSubWindow::resetWindowName()
|
||||
{
|
||||
setWindowName( QFileInfo( m_cFilename ).fileName() );
|
||||
}
|
||||
|
||||
void VideoStreamSubWindow::updateVideoWindowInfo()
|
||||
{
|
||||
m_cStreamInformation = "";
|
||||
if( m_pcDisplayModule )
|
||||
{
|
||||
m_cStreamInformation = "Module";
|
||||
const auto& arraySubWindows = m_pcDisplayModule->getSubWindowList();
|
||||
QStringList windowInfoList;
|
||||
if( arraySubWindows.size() > 0 )
|
||||
{
|
||||
for( std::size_t i = 0; i < arraySubWindows.size(); i++ )
|
||||
{
|
||||
if( arraySubWindows[i]->getWindowName() != getWindowName() )
|
||||
{
|
||||
windowInfoList.append( QString( "Input %1 - " + arraySubWindows[i]->getWindowName() ).arg( i + 1 ) );
|
||||
}
|
||||
}
|
||||
}
|
||||
if( m_pcDisplayModule->getModuleRequirements() & CLP_MODULES_HAS_INFO )
|
||||
{
|
||||
QStringList list = QString::fromStdString( m_pcDisplayModule->moduleInfo() ).split( '\n' );
|
||||
windowInfoList.append( list );
|
||||
}
|
||||
if( windowInfoList.size() > 0 )
|
||||
{
|
||||
m_pcVideoInfo->setInformationTopLeft( windowInfoList );
|
||||
}
|
||||
}
|
||||
else if( m_pCurrStream )
|
||||
{
|
||||
QString m_cFormatName = QString::fromStdString( m_pCurrStream->getFormatName() );
|
||||
QString m_cCodedName = QString::fromStdString( m_pCurrStream->getCodecName() );
|
||||
m_cStreamInformation = m_cFormatName + " | " + m_cCodedName;
|
||||
}
|
||||
if( m_pcCurrFrameAsset )
|
||||
{
|
||||
QString m_cPelFmtName = QString::fromStdString( m_pcCurrFrameAsset->getPelFmtName() );
|
||||
if( m_pCurrStream )
|
||||
if( !m_pCurrStream->isNative() )
|
||||
m_cPelFmtName += "*";
|
||||
m_cStreamInformation += " | " + m_cPelFmtName;
|
||||
}
|
||||
if( m_cStreamInformation.isEmpty() )
|
||||
{
|
||||
m_cStreamInformation = " ";
|
||||
}
|
||||
}
|
||||
|
||||
void VideoStreamSubWindow::loadAll()
|
||||
{
|
||||
QApplication::setOverrideCursor( Qt::WaitCursor );
|
||||
m_pCurrStream->loadAll();
|
||||
refreshFrame();
|
||||
QApplication::restoreOverrideCursor();
|
||||
}
|
||||
|
||||
bool VideoStreamSubWindow::loadFile( QString cFilename, bool bForceDialog )
|
||||
{
|
||||
assert( m_pcResourceManager != nullptr );
|
||||
|
||||
ConfigureFormatDialog formatDialog( this );
|
||||
unsigned int Width = 0, Height = 0, BitsPel = 8, FrameRate = 30;
|
||||
int Endianness = CLP_LITTLE_ENDIAN;
|
||||
int InputFormat = CLP_YUV420P;
|
||||
QSettings appSettings;
|
||||
|
||||
if( m_pCurrStream )
|
||||
m_pCurrStream->getFormat( Width, Height, InputFormat, BitsPel, Endianness, FrameRate );
|
||||
else
|
||||
m_uiResourceId = m_pcResourceManager->getResource( nullptr );
|
||||
|
||||
m_pCurrStream = m_pcResourceManager->getResourceAsset( m_uiResourceId );
|
||||
|
||||
bool bConfig = true;
|
||||
if( !bForceDialog )
|
||||
{
|
||||
bConfig = guessFormat( cFilename, Width, Height, InputFormat, BitsPel, Endianness, FrameRate );
|
||||
if( bConfig )
|
||||
{
|
||||
// Pre-load values with last opened file
|
||||
Width = appSettings.value( "VideoStreamSubWindow/LastWidth" ).value<unsigned int>();
|
||||
Height = appSettings.value( "VideoStreamSubWindow/LastHeight" ).value<unsigned int>();
|
||||
BitsPel = appSettings.value( "VideoStreamSubWindow/LastBitsPerPixel" ).value<unsigned int>();
|
||||
}
|
||||
}
|
||||
bool bRet = false;
|
||||
for( int iPass = 0; iPass < 2 && !bRet; iPass++ )
|
||||
{
|
||||
if( iPass || bConfig )
|
||||
{
|
||||
if( formatDialog.runConfigureFormatDialog( QFileInfo( cFilename ).fileName(), Width, Height, InputFormat, BitsPel,
|
||||
Endianness, FrameRate ) == QDialog::Rejected )
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
try
|
||||
{
|
||||
bRet = m_pCurrStream->open( cFilename.toStdString(), Width, Height, InputFormat, BitsPel, Endianness, FrameRate, true );
|
||||
}
|
||||
catch( CalypFailure& e )
|
||||
{
|
||||
if( iPass == 1 )
|
||||
throw( e );
|
||||
}
|
||||
}
|
||||
|
||||
m_sStreamInfo.m_cFilename = cFilename;
|
||||
m_sStreamInfo.m_uiWidth = Width;
|
||||
m_sStreamInfo.m_uiHeight = Height;
|
||||
m_sStreamInfo.m_iPelFormat = InputFormat;
|
||||
m_sStreamInfo.m_uiBitsPelPixel = BitsPel;
|
||||
m_sStreamInfo.m_iEndianness = Endianness;
|
||||
m_sStreamInfo.m_uiFrameRate = FrameRate;
|
||||
m_sStreamInfo.m_uiFileSize = QFileInfo( cFilename ).size();
|
||||
|
||||
QVariant var;
|
||||
var.setValue<unsigned int>( Width );
|
||||
appSettings.setValue( "VideoStreamSubWindow/LastWidth", var );
|
||||
var.setValue<unsigned int>( Height );
|
||||
appSettings.setValue( "VideoStreamSubWindow/LastHeight", var );
|
||||
var.setValue<unsigned int>( BitsPel );
|
||||
appSettings.setValue( "VideoStreamSubWindow/LastBitsPerPixel", var );
|
||||
|
||||
#ifdef CALYP_MANAGED_RESOURCES
|
||||
m_pcResourceManager->startResourceWorker( m_uiResourceId );
|
||||
#endif
|
||||
|
||||
QApplication::restoreOverrideCursor();
|
||||
|
||||
refreshFrame();
|
||||
|
||||
m_cFilename = cFilename;
|
||||
|
||||
updateVideoWindowInfo();
|
||||
setWindowName( QFileInfo( m_cFilename ).fileName() );
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool VideoStreamSubWindow::loadFile( CalypFileInfo* streamInfo )
|
||||
{
|
||||
assert( m_pcResourceManager != nullptr );
|
||||
|
||||
m_uiResourceId = m_pcResourceManager->getResource( m_pCurrStream );
|
||||
m_pCurrStream = m_pcResourceManager->getResourceAsset( m_uiResourceId );
|
||||
|
||||
if( !m_pCurrStream->open( streamInfo->m_cFilename.toStdString(), streamInfo->m_uiWidth, streamInfo->m_uiHeight,
|
||||
streamInfo->m_iPelFormat, streamInfo->m_uiBitsPelPixel, streamInfo->m_iEndianness,
|
||||
streamInfo->m_uiFrameRate, true ) )
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
m_sStreamInfo = *streamInfo;
|
||||
|
||||
#ifdef CALYP_MANAGED_RESOURCES
|
||||
m_pcResourceManager->startResourceWorker( m_uiResourceId );
|
||||
#endif
|
||||
|
||||
QApplication::restoreOverrideCursor();
|
||||
|
||||
refreshFrame();
|
||||
|
||||
m_cFilename = streamInfo->m_cFilename;
|
||||
updateVideoWindowInfo();
|
||||
setWindowName( QFileInfo( m_cFilename ).fileName() );
|
||||
return true;
|
||||
}
|
||||
|
||||
bool VideoStreamSubWindow::guessFormat( QString filename, unsigned int& rWidth, unsigned int& rHeight, int& rInputFormat, unsigned int& rBitsPerPixel,
|
||||
int& rEndianness, unsigned int& rFrameRate )
|
||||
{
|
||||
std::vector<CalypStandardResolution> stdResList = CalypStream::stdResolutionSizes();
|
||||
bool bGuessed = true;
|
||||
bool bGuessedByFilesize = false;
|
||||
QString FilenameShort = QFileInfo( filename ).fileName();
|
||||
QString fileExtension = QFileInfo( filename ).suffix();
|
||||
|
||||
if( filename.startsWith( "/dev/" ) )
|
||||
{
|
||||
return false;
|
||||
}
|
||||
if( !fileExtension.compare( "yuv", Qt::CaseInsensitive ) || !fileExtension.compare( "rgb", Qt::CaseInsensitive ) ||
|
||||
!fileExtension.compare( "gray", Qt::CaseInsensitive ) )
|
||||
{
|
||||
bGuessed = false;
|
||||
// Guess pixel format
|
||||
auto formats_list = CalypFrame::supportedPixelFormatListNames();
|
||||
for( std::size_t i = 0; i < formats_list.size(); i++ )
|
||||
{
|
||||
if( FilenameShort.contains( formats_list[i].c_str(), Qt::CaseInsensitive ) )
|
||||
{
|
||||
rInputFormat = i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if( rWidth == 0 || rHeight == 0 )
|
||||
{
|
||||
// Guess resolution - match resolution name
|
||||
int iMatch = -1;
|
||||
for( unsigned int i = 0; i < stdResList.size(); i++ )
|
||||
{
|
||||
if( FilenameShort.contains( QString::fromStdString( stdResList[i].shortName ) ) )
|
||||
{
|
||||
iMatch = i;
|
||||
}
|
||||
}
|
||||
if( iMatch >= 0 )
|
||||
{
|
||||
rWidth = stdResList[iMatch].uiWidth;
|
||||
rHeight = stdResList[iMatch].uiHeight;
|
||||
}
|
||||
|
||||
// Guess resolution - match %dx%d
|
||||
//QRegularExpressionMatch resolutionMatch = QRegularExpression( "_\\d*x\\d*" ).match( FilenameShort );
|
||||
QRegularExpressionMatch resolutionMatch = QRegularExpression( "_[0-9]+x[0-9]+" ).match( FilenameShort );
|
||||
if( resolutionMatch.hasMatch() )
|
||||
{
|
||||
QString resolutionString = resolutionMatch.captured( resolutionMatch.lastCapturedIndex() );
|
||||
if( resolutionString.startsWith( "_" ) || resolutionString.endsWith( "_" ) )
|
||||
{
|
||||
resolutionString.remove( "_" );
|
||||
QStringList resolutionArgs = resolutionString.split( "x" );
|
||||
if( resolutionArgs.size() == 2 )
|
||||
{
|
||||
rWidth = resolutionArgs.at( 0 ).toUInt();
|
||||
rHeight = resolutionArgs.at( 1 ).toUInt();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Guess resolution by file size
|
||||
if( rWidth == 0 && rHeight == 0 )
|
||||
{
|
||||
FILE* pF = fopen( filename.toStdString().c_str(), "rb" );
|
||||
if( pF )
|
||||
{
|
||||
fseek( pF, 0, SEEK_END );
|
||||
unsigned long long int uiFileSize = ftell( pF );
|
||||
fclose( pF );
|
||||
|
||||
int count = 0, module, frame_bytes, match;
|
||||
for( unsigned int i = 0; i < stdResList.size(); i++ )
|
||||
{
|
||||
frame_bytes =
|
||||
CalypFrame::getBytesPerFrame( stdResList[i].uiWidth, stdResList[i].uiHeight, rInputFormat, 8 );
|
||||
module = uiFileSize % frame_bytes;
|
||||
if( module == 0 )
|
||||
{
|
||||
match = i;
|
||||
count++;
|
||||
}
|
||||
}
|
||||
if( count == 1 )
|
||||
{
|
||||
rWidth = stdResList[match].uiWidth;
|
||||
rHeight = stdResList[match].uiHeight;
|
||||
bGuessedByFilesize = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// [.|_]
|
||||
// Guess bits per pixel - match %dbpp
|
||||
QRegularExpressionMatch BppMatch = QRegularExpression( "_[0-9]+bpp" ).match( FilenameShort );
|
||||
if( BppMatch.hasMatch() )
|
||||
{
|
||||
QString matchString = BppMatch.captured( BppMatch.lastCapturedIndex() );
|
||||
matchString.remove( "_" );
|
||||
matchString.remove( "bpp" );
|
||||
rBitsPerPixel = matchString.toUInt();
|
||||
if( !( rBitsPerPixel > 0 && rBitsPerPixel < 16 ) )
|
||||
{
|
||||
rBitsPerPixel = -1;
|
||||
}
|
||||
}
|
||||
QRegularExpressionMatch BppOnlybMatch = QRegularExpression( "_[0-9]+b" ).match( FilenameShort );
|
||||
if( BppOnlybMatch.hasMatch() )
|
||||
{
|
||||
QString matchString = BppOnlybMatch.captured( BppOnlybMatch.lastCapturedIndex() );
|
||||
matchString.remove( "_" );
|
||||
matchString.remove( "b" );
|
||||
rBitsPerPixel = matchString.toUInt();
|
||||
if( !( rBitsPerPixel > 0 && rBitsPerPixel < 16 ) )
|
||||
{
|
||||
rBitsPerPixel = -1;
|
||||
}
|
||||
}
|
||||
|
||||
// Guess frame rate - match %dbpp
|
||||
QRegularExpressionMatch FpsMatch = QRegularExpression( "_[0-9]+fps" ).match( FilenameShort );
|
||||
if( FpsMatch.hasMatch() )
|
||||
{
|
||||
QString matchString = FpsMatch.captured( FpsMatch.lastCapturedIndex() );
|
||||
matchString.remove( "_" );
|
||||
matchString.remove( "fps" );
|
||||
rFrameRate = matchString.toUInt();
|
||||
if( rFrameRate < 0 )
|
||||
{
|
||||
rFrameRate = 30;
|
||||
}
|
||||
}
|
||||
|
||||
// Guess Endianness
|
||||
if( FilenameShort.contains( QStringLiteral( "be" ), Qt::CaseInsensitive ) )
|
||||
{
|
||||
rEndianness = CLP_BIG_ENDIAN;
|
||||
}
|
||||
if( FilenameShort.contains( QStringLiteral( "le" ), Qt::CaseInsensitive ) )
|
||||
{
|
||||
rEndianness = CLP_LITTLE_ENDIAN;
|
||||
}
|
||||
|
||||
if( rWidth > 0 && rHeight > 0 && rInputFormat >= 0 )
|
||||
bGuessed = true && !bGuessedByFilesize;
|
||||
}
|
||||
return !bGuessed;
|
||||
}
|
||||
|
||||
void VideoStreamSubWindow::refreshSubWindow()
|
||||
{
|
||||
#ifdef CALYP_MANAGED_RESOURCES
|
||||
m_pcResourceManager->stopResourceWorker( m_uiResourceId );
|
||||
#endif
|
||||
if( !m_pCurrStream->reload() )
|
||||
{
|
||||
close();
|
||||
return;
|
||||
}
|
||||
#ifdef CALYP_MANAGED_RESOURCES
|
||||
m_pcResourceManager->startResourceWorker( m_uiResourceId );
|
||||
#endif
|
||||
|
||||
updateVideoWindowInfo();
|
||||
refreshFrame();
|
||||
}
|
||||
|
||||
void VideoStreamSubWindow::refreshFrame()
|
||||
{
|
||||
bool bSetFrame = true;
|
||||
m_pcCurrFrameAsset = m_pCurrStream->getCurrFrameAsset();
|
||||
|
||||
if( m_pcDisplayModule )
|
||||
{
|
||||
//bool disableThreads = !m_bIsPlaying && hasAssociatedModule();
|
||||
m_pcDisplayModule->apply( m_bIsPlaying, true );
|
||||
bSetFrame = false;
|
||||
}
|
||||
if( bSetFrame )
|
||||
VideoSubWindow::refreshFrame();
|
||||
}
|
||||
|
||||
void VideoStreamSubWindow::refreshFrame( bool bThreaded )
|
||||
{
|
||||
#ifndef QT_NO_CONCURRENT
|
||||
m_cRefreshResult.waitForFinished();
|
||||
if( bThreaded )
|
||||
{
|
||||
m_cRefreshResult = QtConcurrent::run( this, &VideoSubWindow::refreshFrame );
|
||||
}
|
||||
else
|
||||
#endif
|
||||
{
|
||||
refreshFrame();
|
||||
}
|
||||
}
|
||||
|
||||
bool VideoStreamSubWindow::goToNextFrame( bool bThreaded )
|
||||
{
|
||||
#ifndef QT_NO_CONCURRENT
|
||||
m_cRefreshResult.waitForFinished();
|
||||
m_cReadResult.waitForFinished();
|
||||
#endif
|
||||
#ifdef CALYP_MANAGED_RESOURCES
|
||||
while( !m_pCurrStream->hasNextFrame() && !m_pCurrStream->isEof() )
|
||||
{
|
||||
}
|
||||
#endif
|
||||
bool bEndOfSeq = m_pCurrStream->setNextFrame();
|
||||
#ifdef CALYP_MANAGED_RESOURCES
|
||||
bThreaded = false;
|
||||
m_pcResourceManager->wakeResourceWorker( m_uiResourceId );
|
||||
#endif
|
||||
if( !bEndOfSeq )
|
||||
{
|
||||
#ifndef QT_NO_CONCURRENT
|
||||
m_cRefreshResult.waitForFinished();
|
||||
if( bThreaded )
|
||||
{
|
||||
m_cReadResult = QtConcurrent::run( m_pCurrStream, &CalypStream::readNextFrameFillRGBBuffer );
|
||||
refreshFrame( bThreaded );
|
||||
}
|
||||
else
|
||||
#endif
|
||||
{
|
||||
refreshFrame( bThreaded );
|
||||
#ifndef CALYP_MANAGED_RESOURCES
|
||||
m_pCurrStream->readNextFrameFillRGBBuffer();
|
||||
#endif
|
||||
}
|
||||
}
|
||||
return bEndOfSeq;
|
||||
}
|
||||
|
||||
bool VideoStreamSubWindow::saveStream( QString filename )
|
||||
{
|
||||
bool iRet = false;
|
||||
QApplication::setOverrideCursor( Qt::WaitCursor );
|
||||
|
||||
// TODO: implement this
|
||||
QApplication::restoreOverrideCursor();
|
||||
return iRet;
|
||||
}
|
||||
|
||||
bool VideoStreamSubWindow::isPlaying()
|
||||
{
|
||||
return m_bIsPlaying;
|
||||
}
|
||||
|
||||
bool VideoStreamSubWindow::play()
|
||||
{
|
||||
bool isPlaying = false;
|
||||
if( m_pCurrStream && m_pCurrStream->getFrameNum() > 1 )
|
||||
{
|
||||
isPlaying = true;
|
||||
}
|
||||
m_bIsPlaying = isPlaying;
|
||||
return m_bIsPlaying;
|
||||
}
|
||||
|
||||
bool VideoStreamSubWindow::playEvent()
|
||||
{
|
||||
bool bEndOfSeq = false;
|
||||
if( m_pCurrStream && m_bIsPlaying )
|
||||
{
|
||||
bEndOfSeq = goToNextFrame( true );
|
||||
}
|
||||
return bEndOfSeq;
|
||||
}
|
||||
|
||||
void VideoStreamSubWindow::pause()
|
||||
{
|
||||
m_bIsPlaying = false;
|
||||
refreshFrame();
|
||||
}
|
||||
|
||||
void VideoStreamSubWindow::seekAbsoluteEvent( unsigned int new_frame_num )
|
||||
{
|
||||
if( m_pCurrStream )
|
||||
{
|
||||
if( m_pCurrStream->seekInput( new_frame_num ) )
|
||||
refreshFrame();
|
||||
|
||||
#ifdef CALYP_MANAGED_RESOURCES
|
||||
m_pcResourceManager->wakeResourceWorker( m_uiResourceId );
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
void VideoStreamSubWindow::seekRelativeEvent( bool bIsFoward )
|
||||
{
|
||||
if( m_pCurrStream )
|
||||
{
|
||||
if( bIsFoward )
|
||||
{
|
||||
goToNextFrame( true );
|
||||
}
|
||||
else
|
||||
{
|
||||
m_pCurrStream->seekInputRelative( bIsFoward );
|
||||
#ifdef CALYP_MANAGED_RESOURCES
|
||||
m_pcResourceManager->wakeResourceWorker( m_uiResourceId );
|
||||
#endif
|
||||
refreshFrame();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void VideoStreamSubWindow::stop()
|
||||
{
|
||||
#ifndef QT_NO_CONCURRENT
|
||||
m_cRefreshResult.waitForFinished();
|
||||
m_cReadResult.waitForFinished();
|
||||
#endif
|
||||
m_bIsPlaying = false;
|
||||
seekAbsoluteEvent( 0 );
|
||||
return;
|
||||
}
|
||||
@@ -0,0 +1,132 @@
|
||||
/* This file is a part of Calyp project
|
||||
* Copyright (C) 2014-2021 by Joao Carreira (jfmcarreira@gmail.com)
|
||||
* Luis Lucas (luisfrlucas@gmail.com)
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License along
|
||||
* with this program; if not, write to the Free Software Foundation, Inc.,
|
||||
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
||||
*/
|
||||
|
||||
/**
|
||||
* \file VideoStreamSubWindow.h
|
||||
* \brief Video Sub windows handling
|
||||
*/
|
||||
|
||||
#ifndef __VIDEOSTREAMSUBWINDOW_H__
|
||||
#define __VIDEOSTREAMSUBWINDOW_H__
|
||||
|
||||
#include <QDataStream>
|
||||
#include <QFuture>
|
||||
#include <QRect>
|
||||
#include <QString>
|
||||
#include <QVector>
|
||||
#include <cstdint>
|
||||
|
||||
#include "CommonDefs.h"
|
||||
#include "VideoSubWindow.h"
|
||||
#include "config.h"
|
||||
#include "lib/CalypStream.h"
|
||||
|
||||
class QScrollArea;
|
||||
|
||||
class VideoInformation;
|
||||
class VideoStreamSubWindow;
|
||||
class ResourceHandle;
|
||||
class CalypAppModuleIf;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
QString m_cFilename;
|
||||
unsigned int m_uiWidth;
|
||||
unsigned int m_uiHeight;
|
||||
int m_iPelFormat;
|
||||
unsigned int m_uiBitsPelPixel;
|
||||
unsigned int m_iEndianness;
|
||||
unsigned int m_uiFrameRate;
|
||||
unsigned long long int m_uiFileSize;
|
||||
} CalypFileInfo;
|
||||
typedef QVector<CalypFileInfo> CalypFileInfoVector;
|
||||
|
||||
QDataStream& operator<<( QDataStream& out, const CalypFileInfoVector& d );
|
||||
QDataStream& operator>>( QDataStream& in, CalypFileInfoVector& d );
|
||||
int findCalypStreamInfo( CalypFileInfoVector array, QString filename );
|
||||
|
||||
class VideoStreamSubWindow : public VideoSubWindow
|
||||
{
|
||||
Q_OBJECT
|
||||
|
||||
public:
|
||||
VideoStreamSubWindow( QWidget* parent = 0 );
|
||||
~VideoStreamSubWindow();
|
||||
|
||||
void resetWindowName() override;
|
||||
void updateVideoWindowInfo() override;
|
||||
|
||||
bool isPlaying() override;
|
||||
void stop() override;
|
||||
void advanceOneFrame() override { goToNextFrame( true ); }
|
||||
auto getFrameNum() -> std::uint64_t override { return m_pCurrStream->getFrameNum(); }
|
||||
|
||||
void setResourceManaget( ResourceHandle* resourceManager ) { m_pcResourceManager = resourceManager; }
|
||||
|
||||
bool loadFile( QString cFilename, bool bForceDialog = false );
|
||||
bool loadFile( CalypFileInfo* streamInfo );
|
||||
void loadAll();
|
||||
bool saveStream( QString filename );
|
||||
|
||||
bool play();
|
||||
void pause();
|
||||
bool playEvent();
|
||||
void seekAbsoluteEvent( unsigned int new_frame_num );
|
||||
void seekRelativeEvent( bool bIsFoward );
|
||||
|
||||
CalypFileInfo getStreamInfo() { return m_sStreamInfo; }
|
||||
|
||||
const CalypStream* getInputStream() { return m_pCurrStream; }
|
||||
const CalypStream* getCurrStream() { return m_pCurrStream; }
|
||||
|
||||
QString getCurrentFileName() { return m_cFilename; }
|
||||
|
||||
void refreshSubWindow() override;
|
||||
void refreshFrame();
|
||||
void refreshFrame( bool bThreaded );
|
||||
|
||||
private:
|
||||
bool goToNextFrame( bool bThreaded );
|
||||
|
||||
static bool guessFormat( QString filename, unsigned int& rWidth, unsigned int& rHeight, int& rInputFormat, unsigned int& rBitsPerPixel,
|
||||
int& rEndianness, unsigned int& rFrameRate );
|
||||
|
||||
private: // NO_LINT
|
||||
ResourceHandle* m_pcResourceManager;
|
||||
|
||||
QString m_cFilename;
|
||||
CalypFileInfo m_sStreamInfo;
|
||||
std::size_t m_uiResourceId;
|
||||
CalypStream* m_pCurrStream;
|
||||
QString m_cCurrFileName;
|
||||
|
||||
bool m_bIsPlaying;
|
||||
|
||||
/**
|
||||
* Threads variables
|
||||
* QtConcurrent
|
||||
*/
|
||||
QFuture<void> m_cRefreshResult;
|
||||
QFuture<void> m_cReadResult;
|
||||
};
|
||||
|
||||
Q_DECLARE_METATYPE( CalypFileInfo ) // NOLINT
|
||||
Q_DECLARE_METATYPE( CalypFileInfoVector ) // NOLINT
|
||||
|
||||
#endif // __VIDEOSTREAMSUBWINDOW_H__
|
||||
+79
-706
@@ -31,127 +31,59 @@
|
||||
|
||||
#include "ConfigureFormatDialog.h"
|
||||
#include "ModulesHandle.h"
|
||||
#include "QtConcurrent/qtconcurrentrun.h"
|
||||
#include "ResourceHandle.h"
|
||||
#include "SubWindowAbstract.h"
|
||||
|
||||
#define QT_NO_CONCURRENT
|
||||
|
||||
/**
|
||||
* \brief Functions to control data stream from stream information
|
||||
*/
|
||||
|
||||
QDataStream& operator<<( QDataStream& out, const CalypFileInfoVector& array )
|
||||
VideoInformation::VideoInformation( QWidget* parent )
|
||||
: QWidget( parent ), m_bBusyWindow( false )
|
||||
{
|
||||
CalypFileInfo d;
|
||||
out << array.size();
|
||||
for( int i = 0; i < array.size(); i++ )
|
||||
{
|
||||
d = array.at( i );
|
||||
out << d.m_cFilename << d.m_uiWidth << d.m_uiHeight << d.m_iPelFormat << d.m_uiBitsPelPixel << d.m_iEndianness
|
||||
<< d.m_uiFrameRate << d.m_uiFileSize;
|
||||
}
|
||||
return out;
|
||||
setPalette( Qt::transparent );
|
||||
setAttribute( Qt::WA_TransparentForMouseEvents );
|
||||
m_cTopLeftTextFont.setPointSize( 8 );
|
||||
m_cCenterTextFont.setPointSize( 12 );
|
||||
m_pcRefreshTimer = new QTimer;
|
||||
m_pcRefreshTimer->setSingleShot( true );
|
||||
}
|
||||
|
||||
QDataStream& operator>>( QDataStream& in, CalypFileInfoVector& array )
|
||||
void VideoInformation::setInformationTopLeft( const QStringList& textLines )
|
||||
{
|
||||
CalypFileInfo d;
|
||||
int array_size{ 0 };
|
||||
in >> array_size;
|
||||
for( int i = 0; i < array_size; i++ )
|
||||
m_cTopLeftTextList.clear();
|
||||
for( int i = 0; i < textLines.size(); i++ )
|
||||
{
|
||||
in >> d.m_cFilename;
|
||||
in >> d.m_uiWidth;
|
||||
in >> d.m_uiHeight;
|
||||
in >> d.m_iPelFormat;
|
||||
in >> d.m_uiBitsPelPixel;
|
||||
in >> d.m_iEndianness;
|
||||
in >> d.m_uiFrameRate;
|
||||
in >> d.m_uiFileSize;
|
||||
array.append( d );
|
||||
m_cTopLeftTextList.append( QStaticText( textLines.at( i ) ) );
|
||||
}
|
||||
return in;
|
||||
}
|
||||
|
||||
int findCalypStreamInfo( CalypFileInfoVector array, QString filename )
|
||||
void VideoInformation::setBusyWindow( bool bFlag )
|
||||
{
|
||||
for( int i = 0; i < array.size(); i++ )
|
||||
if( array.at( i ).m_cFilename == filename )
|
||||
return i;
|
||||
return -1;
|
||||
m_bBusyWindow = bFlag;
|
||||
// Do not show the refresh screen if it takes less than 500 ms
|
||||
m_pcRefreshTimer->start( 500 );
|
||||
}
|
||||
|
||||
/**
|
||||
* \class VideoInformation
|
||||
* \brief Shows information about video sub window
|
||||
*/
|
||||
|
||||
class VideoInformation : public QWidget
|
||||
void VideoInformation::paintEvent( QPaintEvent* event )
|
||||
{
|
||||
private:
|
||||
QTimer* m_pcRefreshTimer;
|
||||
QList<QStaticText> m_cTopLeftTextList;
|
||||
QFont m_cTopLeftTextFont;
|
||||
QFont m_cCenterTextFont;
|
||||
bool m_bBusyWindow;
|
||||
|
||||
public:
|
||||
VideoInformation( QWidget* parent )
|
||||
: QWidget( parent ), m_bBusyWindow( false )
|
||||
QPainter painter( this );
|
||||
painter.setFont( m_cTopLeftTextFont );
|
||||
if( !m_cTopLeftTextList.isEmpty() && size().width() > 300 )
|
||||
{
|
||||
setPalette( Qt::transparent );
|
||||
setAttribute( Qt::WA_TransparentForMouseEvents );
|
||||
m_cTopLeftTextFont.setPointSize( 8 );
|
||||
m_cCenterTextFont.setPointSize( 12 );
|
||||
m_pcRefreshTimer = new QTimer;
|
||||
m_pcRefreshTimer->setSingleShot( true );
|
||||
}
|
||||
void setInformationTopLeft( const QStringList& textLines )
|
||||
{
|
||||
m_cTopLeftTextList.clear();
|
||||
for( int i = 0; i < textLines.size(); i++ )
|
||||
QPoint topLeftCorner( 10, 10 );
|
||||
for( int i = 0; i < m_cTopLeftTextList.size(); i++ )
|
||||
{
|
||||
m_cTopLeftTextList.append( QStaticText( textLines.at( i ) ) );
|
||||
painter.drawStaticText( topLeftCorner, m_cTopLeftTextList.at( i ) );
|
||||
topLeftCorner += QPoint( 0, 15 );
|
||||
}
|
||||
}
|
||||
void setBusyWindow( bool bFlag )
|
||||
if( m_bBusyWindow && !m_pcRefreshTimer->isActive() )
|
||||
{
|
||||
m_bBusyWindow = bFlag;
|
||||
// Do not show the refresh screen if it takes less than 500 ms
|
||||
m_pcRefreshTimer->start( 500 );
|
||||
painter.setFont( m_cCenterTextFont );
|
||||
painter.drawText( rect(), Qt::AlignHCenter | Qt::AlignVCenter, QStringLiteral( "Refreshing..." ) );
|
||||
painter.fillRect( rect(), QBrush( QColor::fromRgb( 255, 255, 255, 50 ), Qt::SolidPattern ) );
|
||||
}
|
||||
|
||||
protected:
|
||||
void paintEvent( QPaintEvent* event )
|
||||
{
|
||||
QPainter painter( this );
|
||||
painter.setFont( m_cTopLeftTextFont );
|
||||
if( !m_cTopLeftTextList.isEmpty() && size().width() > 300 )
|
||||
{
|
||||
QPoint topLeftCorner( 10, 10 );
|
||||
for( int i = 0; i < m_cTopLeftTextList.size(); i++ )
|
||||
{
|
||||
painter.drawStaticText( topLeftCorner, m_cTopLeftTextList.at( i ) );
|
||||
topLeftCorner += QPoint( 0, 15 );
|
||||
}
|
||||
}
|
||||
if( m_bBusyWindow && !m_pcRefreshTimer->isActive() )
|
||||
{
|
||||
painter.setFont( m_cCenterTextFont );
|
||||
painter.drawText( rect(), Qt::AlignHCenter | Qt::AlignVCenter, QStringLiteral( "Refreshing..." ) );
|
||||
painter.fillRect( rect(), QBrush( QColor::fromRgb( 255, 255, 255, 50 ), Qt::SolidPattern ) );
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
VideoSubWindow::VideoSubWindow( enum VideoSubWindowCategories category, QWidget* parent )
|
||||
: SubWindowAbstract( parent, SubWindowAbstract::VIDEO_SUBWINDOW | category )
|
||||
, m_pcResourceManager( nullptr )
|
||||
, m_bWindowBusy( false )
|
||||
, m_pCurrStream( NULL )
|
||||
, m_pcReferenceSubWindow( NULL )
|
||||
, m_bIsPlaying( false )
|
||||
, m_pcUpdateTimer( NULL )
|
||||
{
|
||||
// Create a new scroll area inside the sub-window
|
||||
@@ -194,17 +126,16 @@ VideoSubWindow::VideoSubWindow( enum VideoSubWindowCategories category, QWidget*
|
||||
m_pcVideoInfo = new VideoInformation( this );
|
||||
}
|
||||
|
||||
VideoSubWindow::VideoSubWindow( enum VideoSubWindowCategories category, CalypAppModuleIf* displayModule, QWidget* parent )
|
||||
: VideoSubWindow( category, parent )
|
||||
{
|
||||
m_pcCurrentDisplayModule = displayModule;
|
||||
}
|
||||
|
||||
VideoSubWindow::~VideoSubWindow()
|
||||
{
|
||||
auto tmpModules = m_associatedModules;
|
||||
m_associatedModules.clear();
|
||||
for( auto module : tmpModules )
|
||||
{
|
||||
module->disable();
|
||||
}
|
||||
|
||||
m_pcCurrFrameAsset = nullptr;
|
||||
if( m_pcResourceManager )
|
||||
m_pcResourceManager->removeResource( m_uiResourceId );
|
||||
delete m_pcUpdateTimer;
|
||||
}
|
||||
|
||||
@@ -214,16 +145,9 @@ VideoSubWindow::~VideoSubWindow()
|
||||
|
||||
void VideoSubWindow::closeEvent( QCloseEvent* event )
|
||||
{
|
||||
//stop();
|
||||
auto tmpModules = m_associatedModules;
|
||||
m_associatedModules.clear();
|
||||
for( auto module : tmpModules )
|
||||
if( m_pcDisplayModule )
|
||||
{
|
||||
module->disable();
|
||||
}
|
||||
if( m_pcCurrentDisplayModule )
|
||||
{
|
||||
m_pcCurrentDisplayModule->disable();
|
||||
m_pcDisplayModule->disable();
|
||||
event->ignore();
|
||||
return;
|
||||
}
|
||||
@@ -232,24 +156,24 @@ void VideoSubWindow::closeEvent( QCloseEvent* event )
|
||||
|
||||
void VideoSubWindow::keyPressEvent( QKeyEvent* event )
|
||||
{
|
||||
if( m_pcCurrentDisplayModule )
|
||||
if( m_pcDisplayModule )
|
||||
{
|
||||
if( m_pcCurrentDisplayModule->getModuleRequirements() & CLP_MODULE_USES_KEYS )
|
||||
if( m_pcDisplayModule->getModuleRequirements() & CLP_MODULE_USES_KEYS )
|
||||
{
|
||||
bool bRet = false;
|
||||
switch( event->key() )
|
||||
{
|
||||
case Qt::Key_A:
|
||||
bRet = m_pcCurrentDisplayModule->getModule()->keyPressed( MODULE_KEY_LEFT );
|
||||
bRet = m_pcDisplayModule->getModule()->keyPressed( MODULE_KEY_LEFT );
|
||||
break;
|
||||
case Qt::Key_D:
|
||||
bRet = m_pcCurrentDisplayModule->getModule()->keyPressed( MODULE_KEY_RIGHT );
|
||||
bRet = m_pcDisplayModule->getModule()->keyPressed( MODULE_KEY_RIGHT );
|
||||
break;
|
||||
case Qt::Key_W:
|
||||
bRet = m_pcCurrentDisplayModule->getModule()->keyPressed( MODULE_KEY_UP );
|
||||
bRet = m_pcDisplayModule->getModule()->keyPressed( MODULE_KEY_UP );
|
||||
break;
|
||||
case Qt::Key_S:
|
||||
bRet = m_pcCurrentDisplayModule->getModule()->keyPressed( MODULE_KEY_DOWN );
|
||||
bRet = m_pcDisplayModule->getModule()->keyPressed( MODULE_KEY_DOWN );
|
||||
break;
|
||||
}
|
||||
if( bRet )
|
||||
@@ -271,36 +195,18 @@ void VideoSubWindow::resizeEvent( QResizeEvent* event )
|
||||
/**
|
||||
* Size related handlers
|
||||
*/
|
||||
|
||||
QSize VideoSubWindow::sizeHint() const
|
||||
{
|
||||
QSize maxSize;
|
||||
|
||||
QWidget* p = parentWidget();
|
||||
if( p )
|
||||
{
|
||||
maxSize = p->size();
|
||||
}
|
||||
else
|
||||
{
|
||||
maxSize = QGuiApplication::screens()[0]->availableGeometry().size();
|
||||
}
|
||||
return sizeHint( maxSize );
|
||||
}
|
||||
|
||||
QSize VideoSubWindow::sizeHint( const QSize& maxSize ) const
|
||||
{
|
||||
QSize isize;
|
||||
if( m_pcCurrFrameAsset )
|
||||
isize = QSize( m_pcCurrFrameAsset->getWidth() + 50, m_pcCurrFrameAsset->getHeight() + 50 );
|
||||
else if( m_pCurrStream )
|
||||
isize = QSize( m_pCurrStream->getWidth() + 50, m_pCurrStream->getHeight() + 50 );
|
||||
|
||||
// If the VideoSubWindow needs more space that the avaiable, we'll give
|
||||
// to the subwindow a reasonable size preserving the image aspect ratio.
|
||||
if( !( isize.width() < maxSize.width() && isize.height() < maxSize.height() ) )
|
||||
{
|
||||
isize.scale( maxSize, Qt::KeepAspectRatio );
|
||||
isize = QSize( m_pcCurrFrameAsset->getWidth() + 50, m_pcCurrFrameAsset->getHeight() + 50 );
|
||||
// If the VideoSubWindow needs more space that the avaiable, we'll give
|
||||
// to the subwindow a reasonable size preserving the image aspect ratio.
|
||||
if( !( isize.width() < maxSize.width() && isize.height() < maxSize.height() ) )
|
||||
{
|
||||
isize.scale( maxSize, Qt::KeepAspectRatio );
|
||||
}
|
||||
}
|
||||
return isize;
|
||||
}
|
||||
@@ -310,348 +216,6 @@ void VideoSubWindow::updateWindowOnTimeout()
|
||||
m_pcVideoInfo->update();
|
||||
}
|
||||
|
||||
void VideoSubWindow::loadAll()
|
||||
{
|
||||
QApplication::setOverrideCursor( Qt::WaitCursor );
|
||||
m_pCurrStream->loadAll();
|
||||
refreshFrame();
|
||||
QApplication::restoreOverrideCursor();
|
||||
}
|
||||
|
||||
void VideoSubWindow::refreshSubWindow()
|
||||
{
|
||||
if( getCategory() & SubWindowAbstract::VIDEO_STREAM_SUBWINDOW )
|
||||
{
|
||||
#ifdef CALYP_MANAGED_RESOURCES
|
||||
m_pcResourceManager->stopResourceWorker( m_uiResourceId );
|
||||
#endif
|
||||
if( !m_pCurrStream->reload() )
|
||||
{
|
||||
close();
|
||||
return;
|
||||
}
|
||||
#ifdef CALYP_MANAGED_RESOURCES
|
||||
m_pcResourceManager->startResourceWorker( m_uiResourceId );
|
||||
#endif
|
||||
}
|
||||
updateVideoWindowInfo();
|
||||
refreshFrame();
|
||||
}
|
||||
|
||||
bool VideoSubWindow::loadFile( QString cFilename, bool bForceDialog )
|
||||
{
|
||||
assert( m_pcResourceManager != nullptr );
|
||||
|
||||
ConfigureFormatDialog formatDialog( this );
|
||||
unsigned int Width = 0, Height = 0, BitsPel = 8, FrameRate = 30;
|
||||
int Endianness = CLP_LITTLE_ENDIAN;
|
||||
int InputFormat = CLP_YUV420P;
|
||||
QSettings appSettings;
|
||||
|
||||
if( m_pCurrStream )
|
||||
m_pCurrStream->getFormat( Width, Height, InputFormat, BitsPel, Endianness, FrameRate );
|
||||
else
|
||||
m_uiResourceId = m_pcResourceManager->getResource( nullptr );
|
||||
|
||||
m_pCurrStream = m_pcResourceManager->getResourceAsset( m_uiResourceId );
|
||||
|
||||
bool bConfig = true;
|
||||
if( !bForceDialog )
|
||||
{
|
||||
bConfig = guessFormat( cFilename, Width, Height, InputFormat, BitsPel, Endianness, FrameRate );
|
||||
if( bConfig )
|
||||
{
|
||||
// Pre-load values with last opened file
|
||||
Width = appSettings.value( "VideoSubWindow/LastWidth" ).value<unsigned int>();
|
||||
Height = appSettings.value( "VideoSubWindow/LastHeight" ).value<unsigned int>();
|
||||
BitsPel = appSettings.value( "VideoSubWindow/LastBitsPerPixel" ).value<unsigned int>();
|
||||
}
|
||||
}
|
||||
bool bRet = false;
|
||||
for( int iPass = 0; iPass < 2 && !bRet; iPass++ )
|
||||
{
|
||||
if( iPass || bConfig )
|
||||
{
|
||||
if( formatDialog.runConfigureFormatDialog( QFileInfo( cFilename ).fileName(), Width, Height, InputFormat, BitsPel,
|
||||
Endianness, FrameRate ) == QDialog::Rejected )
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
try
|
||||
{
|
||||
bRet = m_pCurrStream->open( cFilename.toStdString(), Width, Height, InputFormat, BitsPel, Endianness, FrameRate, true );
|
||||
}
|
||||
catch( CalypFailure& e )
|
||||
{
|
||||
if( iPass == 1 )
|
||||
throw( e );
|
||||
}
|
||||
}
|
||||
|
||||
m_sStreamInfo.m_cFilename = cFilename;
|
||||
m_sStreamInfo.m_uiWidth = Width;
|
||||
m_sStreamInfo.m_uiHeight = Height;
|
||||
m_sStreamInfo.m_iPelFormat = InputFormat;
|
||||
m_sStreamInfo.m_uiBitsPelPixel = BitsPel;
|
||||
m_sStreamInfo.m_iEndianness = Endianness;
|
||||
m_sStreamInfo.m_uiFrameRate = FrameRate;
|
||||
m_sStreamInfo.m_uiFileSize = QFileInfo( cFilename ).size();
|
||||
|
||||
QVariant var;
|
||||
var.setValue<unsigned int>( Width );
|
||||
appSettings.setValue( "VideoSubWindow/LastWidth", var );
|
||||
var.setValue<unsigned int>( Height );
|
||||
appSettings.setValue( "VideoSubWindow/LastHeight", var );
|
||||
var.setValue<unsigned int>( BitsPel );
|
||||
appSettings.setValue( "VideoSubWindow/LastBitsPerPixel", var );
|
||||
|
||||
#ifdef CALYP_MANAGED_RESOURCES
|
||||
m_pcResourceManager->startResourceWorker( m_uiResourceId );
|
||||
#endif
|
||||
|
||||
QApplication::restoreOverrideCursor();
|
||||
|
||||
refreshFrame();
|
||||
|
||||
m_cFilename = cFilename;
|
||||
|
||||
updateVideoWindowInfo();
|
||||
setWindowName( QFileInfo( m_cFilename ).fileName() );
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool VideoSubWindow::loadFile( CalypFileInfo* streamInfo )
|
||||
{
|
||||
assert( m_pcResourceManager != nullptr );
|
||||
|
||||
m_uiResourceId = m_pcResourceManager->getResource( m_pCurrStream );
|
||||
m_pCurrStream = m_pcResourceManager->getResourceAsset( m_uiResourceId );
|
||||
|
||||
if( !m_pCurrStream->open( streamInfo->m_cFilename.toStdString(), streamInfo->m_uiWidth, streamInfo->m_uiHeight,
|
||||
streamInfo->m_iPelFormat, streamInfo->m_uiBitsPelPixel, streamInfo->m_iEndianness,
|
||||
streamInfo->m_uiFrameRate, true ) )
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
m_sStreamInfo = *streamInfo;
|
||||
|
||||
#ifdef CALYP_MANAGED_RESOURCES
|
||||
m_pcResourceManager->startResourceWorker( m_uiResourceId );
|
||||
#endif
|
||||
|
||||
QApplication::restoreOverrideCursor();
|
||||
|
||||
refreshFrame();
|
||||
|
||||
m_cFilename = streamInfo->m_cFilename;
|
||||
updateVideoWindowInfo();
|
||||
setWindowName( QFileInfo( m_cFilename ).fileName() );
|
||||
return true;
|
||||
}
|
||||
|
||||
void VideoSubWindow::updateVideoWindowInfo()
|
||||
{
|
||||
m_cStreamInformation = "";
|
||||
if( m_pcCurrentDisplayModule )
|
||||
{
|
||||
m_cStreamInformation = "Module";
|
||||
const auto& arraySubWindows = m_pcCurrentDisplayModule->getSubWindowList();
|
||||
QStringList windowInfoList;
|
||||
if( arraySubWindows.size() > 0 )
|
||||
{
|
||||
for( std::size_t i = 0; i < arraySubWindows.size(); i++ )
|
||||
{
|
||||
if( arraySubWindows[i]->getWindowName() != getWindowName() )
|
||||
{
|
||||
windowInfoList.append( QString( "Input %1 - " + arraySubWindows[i]->getWindowName() ).arg( i + 1 ) );
|
||||
}
|
||||
}
|
||||
}
|
||||
if( m_pcCurrentDisplayModule->getModuleRequirements() & CLP_MODULES_HAS_INFO )
|
||||
{
|
||||
QStringList list = QString::fromStdString( m_pcCurrentDisplayModule->moduleInfo() ).split( '\n' );
|
||||
windowInfoList.append( list );
|
||||
}
|
||||
if( windowInfoList.size() > 0 )
|
||||
{
|
||||
m_pcVideoInfo->setInformationTopLeft( windowInfoList );
|
||||
}
|
||||
}
|
||||
else if( m_pCurrStream )
|
||||
{
|
||||
QString m_cFormatName = QString::fromStdString( m_pCurrStream->getFormatName() );
|
||||
QString m_cCodedName = QString::fromStdString( m_pCurrStream->getCodecName() );
|
||||
m_cStreamInformation = m_cFormatName + " | " + m_cCodedName;
|
||||
}
|
||||
if( m_pcCurrFrameAsset )
|
||||
{
|
||||
QString m_cPelFmtName = QString::fromStdString( m_pcCurrFrameAsset->getPelFmtName() );
|
||||
if( m_pCurrStream )
|
||||
if( !m_pCurrStream->isNative() )
|
||||
m_cPelFmtName += "*";
|
||||
m_cStreamInformation += " | " + m_cPelFmtName;
|
||||
}
|
||||
if( m_cStreamInformation.isEmpty() )
|
||||
{
|
||||
m_cStreamInformation = " ";
|
||||
}
|
||||
}
|
||||
|
||||
bool VideoSubWindow::guessFormat( QString filename, unsigned int& rWidth, unsigned int& rHeight, int& rInputFormat, unsigned int& rBitsPerPixel,
|
||||
int& rEndianness, unsigned int& rFrameRate )
|
||||
{
|
||||
std::vector<CalypStandardResolution> stdResList = CalypStream::stdResolutionSizes();
|
||||
bool bGuessed = true;
|
||||
bool bGuessedByFilesize = false;
|
||||
QString FilenameShort = QFileInfo( filename ).fileName();
|
||||
QString fileExtension = QFileInfo( filename ).suffix();
|
||||
|
||||
if( filename.startsWith( "/dev/" ) )
|
||||
{
|
||||
return false;
|
||||
}
|
||||
if( !fileExtension.compare( "yuv", Qt::CaseInsensitive ) || !fileExtension.compare( "rgb", Qt::CaseInsensitive ) ||
|
||||
!fileExtension.compare( "gray", Qt::CaseInsensitive ) )
|
||||
{
|
||||
bGuessed = false;
|
||||
// Guess pixel format
|
||||
auto formats_list = CalypFrame::supportedPixelFormatListNames();
|
||||
for( std::size_t i = 0; i < formats_list.size(); i++ )
|
||||
{
|
||||
if( FilenameShort.contains( formats_list[i].c_str(), Qt::CaseInsensitive ) )
|
||||
{
|
||||
rInputFormat = i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if( rWidth == 0 || rHeight == 0 )
|
||||
{
|
||||
// Guess resolution - match resolution name
|
||||
int iMatch = -1;
|
||||
for( unsigned int i = 0; i < stdResList.size(); i++ )
|
||||
{
|
||||
if( FilenameShort.contains( QString::fromStdString( stdResList[i].shortName ) ) )
|
||||
{
|
||||
iMatch = i;
|
||||
}
|
||||
}
|
||||
if( iMatch >= 0 )
|
||||
{
|
||||
rWidth = stdResList[iMatch].uiWidth;
|
||||
rHeight = stdResList[iMatch].uiHeight;
|
||||
}
|
||||
|
||||
// Guess resolution - match %dx%d
|
||||
//QRegularExpressionMatch resolutionMatch = QRegularExpression( "_\\d*x\\d*" ).match( FilenameShort );
|
||||
QRegularExpressionMatch resolutionMatch = QRegularExpression( "_[0-9]+x[0-9]+" ).match( FilenameShort );
|
||||
if( resolutionMatch.hasMatch() )
|
||||
{
|
||||
QString resolutionString = resolutionMatch.captured( resolutionMatch.lastCapturedIndex() );
|
||||
if( resolutionString.startsWith( "_" ) || resolutionString.endsWith( "_" ) )
|
||||
{
|
||||
resolutionString.remove( "_" );
|
||||
QStringList resolutionArgs = resolutionString.split( "x" );
|
||||
if( resolutionArgs.size() == 2 )
|
||||
{
|
||||
rWidth = resolutionArgs.at( 0 ).toUInt();
|
||||
rHeight = resolutionArgs.at( 1 ).toUInt();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Guess resolution by file size
|
||||
if( rWidth == 0 && rHeight == 0 )
|
||||
{
|
||||
FILE* pF = fopen( filename.toStdString().c_str(), "rb" );
|
||||
if( pF )
|
||||
{
|
||||
fseek( pF, 0, SEEK_END );
|
||||
unsigned long long int uiFileSize = ftell( pF );
|
||||
fclose( pF );
|
||||
|
||||
int count = 0, module, frame_bytes, match;
|
||||
for( unsigned int i = 0; i < stdResList.size(); i++ )
|
||||
{
|
||||
frame_bytes =
|
||||
CalypFrame::getBytesPerFrame( stdResList[i].uiWidth, stdResList[i].uiHeight, rInputFormat, 8 );
|
||||
module = uiFileSize % frame_bytes;
|
||||
if( module == 0 )
|
||||
{
|
||||
match = i;
|
||||
count++;
|
||||
}
|
||||
}
|
||||
if( count == 1 )
|
||||
{
|
||||
rWidth = stdResList[match].uiWidth;
|
||||
rHeight = stdResList[match].uiHeight;
|
||||
bGuessedByFilesize = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// [.|_]
|
||||
// Guess bits per pixel - match %dbpp
|
||||
QRegularExpressionMatch BppMatch = QRegularExpression( "_[0-9]+bpp" ).match( FilenameShort );
|
||||
if( BppMatch.hasMatch() )
|
||||
{
|
||||
QString matchString = BppMatch.captured( BppMatch.lastCapturedIndex() );
|
||||
matchString.remove( "_" );
|
||||
matchString.remove( "bpp" );
|
||||
rBitsPerPixel = matchString.toUInt();
|
||||
if( !( rBitsPerPixel > 0 && rBitsPerPixel < 16 ) )
|
||||
{
|
||||
rBitsPerPixel = -1;
|
||||
}
|
||||
}
|
||||
QRegularExpressionMatch BppOnlybMatch = QRegularExpression( "_[0-9]+b" ).match( FilenameShort );
|
||||
if( BppOnlybMatch.hasMatch() )
|
||||
{
|
||||
QString matchString = BppOnlybMatch.captured( BppOnlybMatch.lastCapturedIndex() );
|
||||
matchString.remove( "_" );
|
||||
matchString.remove( "b" );
|
||||
rBitsPerPixel = matchString.toUInt();
|
||||
if( !( rBitsPerPixel > 0 && rBitsPerPixel < 16 ) )
|
||||
{
|
||||
rBitsPerPixel = -1;
|
||||
}
|
||||
}
|
||||
|
||||
// Guess frame rate - match %dbpp
|
||||
QRegularExpressionMatch FpsMatch = QRegularExpression( "_[0-9]+fps" ).match( FilenameShort );
|
||||
if( FpsMatch.hasMatch() )
|
||||
{
|
||||
QString matchString = FpsMatch.captured( FpsMatch.lastCapturedIndex() );
|
||||
matchString.remove( "_" );
|
||||
matchString.remove( "fps" );
|
||||
rFrameRate = matchString.toUInt();
|
||||
if( rFrameRate < 0 )
|
||||
{
|
||||
rFrameRate = 30;
|
||||
}
|
||||
}
|
||||
|
||||
// Guess Endianness
|
||||
if( FilenameShort.contains( QStringLiteral( "be" ), Qt::CaseInsensitive ) )
|
||||
{
|
||||
rEndianness = CLP_BIG_ENDIAN;
|
||||
}
|
||||
if( FilenameShort.contains( QStringLiteral( "le" ), Qt::CaseInsensitive ) )
|
||||
{
|
||||
rEndianness = CLP_LITTLE_ENDIAN;
|
||||
}
|
||||
|
||||
if( rWidth > 0 && rHeight > 0 && rInputFormat >= 0 )
|
||||
bGuessed = true && !bGuessedByFilesize;
|
||||
}
|
||||
return !bGuessed;
|
||||
}
|
||||
|
||||
void VideoSubWindow::updateSelectedArea( QRect area )
|
||||
{
|
||||
m_cSelectedArea = area;
|
||||
@@ -669,24 +233,24 @@ void VideoSubWindow::updateSelectedArea( QRect area )
|
||||
// {
|
||||
// m_associatedModules.erase( it );
|
||||
// }
|
||||
// m_pcCurrentDisplayModule = std::move( pcModule );
|
||||
// m_pcDisplayModule = std::move( pcModule );
|
||||
// updateVideoWindowInfo();
|
||||
// }
|
||||
|
||||
bool VideoSubWindow::hasAssociatedModule()
|
||||
{
|
||||
if( m_pcCurrentDisplayModule == nullptr )
|
||||
if( m_pcDisplayModule == nullptr )
|
||||
return !m_associatedModules.empty();
|
||||
return m_associatedModules.size() > 1;
|
||||
}
|
||||
|
||||
void VideoSubWindow::setDisplayModule( CalypAppModuleIf* pcModule )
|
||||
{
|
||||
if( m_pcCurrentDisplayModule != nullptr )
|
||||
if( m_pcDisplayModule != nullptr )
|
||||
{
|
||||
m_pcCurrentDisplayModule->disable();
|
||||
m_pcDisplayModule->disable();
|
||||
}
|
||||
m_pcCurrentDisplayModule = pcModule;
|
||||
m_pcDisplayModule = pcModule;
|
||||
updateVideoWindowInfo();
|
||||
}
|
||||
|
||||
@@ -712,15 +276,15 @@ void VideoSubWindow::disableModule( CalypAppModuleIf* pcModule )
|
||||
{
|
||||
m_associatedModules.erase( it );
|
||||
}
|
||||
if( pcModule == m_pcCurrentDisplayModule )
|
||||
if( pcModule == m_pcDisplayModule )
|
||||
{
|
||||
bRefresh |= true;
|
||||
m_pcCurrentDisplayModule = nullptr;
|
||||
setWindowName( QFileInfo( m_cFilename ).fileName() );
|
||||
m_pcDisplayModule = nullptr;
|
||||
resetWindowName();
|
||||
}
|
||||
if( bRefresh )
|
||||
{
|
||||
refreshFrame();
|
||||
refreshSubWindow();
|
||||
updateVideoWindowInfo();
|
||||
}
|
||||
// if( pcModule )
|
||||
@@ -732,10 +296,10 @@ void VideoSubWindow::disableModule( CalypAppModuleIf* pcModule )
|
||||
// ModulesHandle::destroyModuleIf( pcModule );
|
||||
// bRefresh |= true;
|
||||
// }
|
||||
// if( pcModule == m_pcCurrentDisplayModule )
|
||||
// if( pcModule == m_pcDisplayModule )
|
||||
// {
|
||||
// pcModule = m_pcCurrentDisplayModule;
|
||||
// m_pcCurrentDisplayModule = 0;
|
||||
// pcModule = m_pcDisplayModule;
|
||||
// m_pcDisplayModule = 0;
|
||||
// ModulesHandle::destroyModuleIf( pcModule );
|
||||
// setWindowName( QFileInfo( m_cFilename ).fileName() );
|
||||
// bRefresh |= true;
|
||||
@@ -751,10 +315,10 @@ void VideoSubWindow::disableModule( CalypAppModuleIf* pcModule )
|
||||
// bRefresh |= true;
|
||||
// }
|
||||
// assert( m_apcCurrentModule.size() == 0 );
|
||||
// if( m_pcCurrentDisplayModule )
|
||||
// if( m_pcDisplayModule )
|
||||
// {
|
||||
// pcModule = m_pcCurrentDisplayModule;
|
||||
// m_pcCurrentDisplayModule = NULL;
|
||||
// pcModule = m_pcDisplayModule;
|
||||
// m_pcDisplayModule = NULL;
|
||||
// ModulesHandle::destroyModuleIf( pcModule );
|
||||
// setWindowName( QFileInfo( m_cFilename ).fileName() );
|
||||
// bRefresh |= true;
|
||||
@@ -791,114 +355,34 @@ void VideoSubWindow::setFillWindow( bool bFlag )
|
||||
m_pcVideoInfo->setBusyWindow( bFlag );
|
||||
}
|
||||
|
||||
std::shared_ptr<CalypFrame> VideoSubWindow::getCurrFrameAsset()
|
||||
{
|
||||
if( m_pcCurrFrameAsset == nullptr && m_pCurrStream != nullptr )
|
||||
{
|
||||
m_pcCurrFrameAsset = m_pCurrStream->getCurrFrameAsset();
|
||||
}
|
||||
return m_pcCurrFrameAsset;
|
||||
};
|
||||
|
||||
void VideoSubWindow::setCurrFrame( std::shared_ptr<CalypFrame> pcCurrFrame )
|
||||
{
|
||||
m_pcCurrFrameAsset = std::move( pcCurrFrame );
|
||||
refreshFrame();
|
||||
}
|
||||
|
||||
void VideoSubWindow::refreshFrame()
|
||||
{
|
||||
m_cViewArea->setImage( m_pcCurrFrameAsset );
|
||||
for( auto& module : m_associatedModules )
|
||||
{
|
||||
if( module.get() != m_pcCurrentDisplayModule )
|
||||
module->update( m_bIsPlaying );
|
||||
if( module.get() != m_pcDisplayModule )
|
||||
module->update( isPlaying() );
|
||||
}
|
||||
}
|
||||
|
||||
void VideoSubWindow::refreshFrameOperation()
|
||||
{
|
||||
bool bSetFrame = false;
|
||||
if( m_pCurrStream )
|
||||
{
|
||||
m_pcCurrFrameAsset = m_pCurrStream->getCurrFrameAsset();
|
||||
bSetFrame |= true;
|
||||
}
|
||||
|
||||
if( m_pcCurrentDisplayModule )
|
||||
{
|
||||
m_bWindowBusy = true;
|
||||
bool disableThreads = !m_bIsPlaying && hasAssociatedModule();
|
||||
m_pcCurrentDisplayModule->apply( m_bIsPlaying, disableThreads );
|
||||
bSetFrame = false;
|
||||
}
|
||||
if( bSetFrame )
|
||||
{
|
||||
m_cViewArea->setImage( m_pcCurrFrameAsset );
|
||||
for( auto& module : m_associatedModules )
|
||||
{
|
||||
if( module.get() != m_pcCurrentDisplayModule )
|
||||
module->update( m_bIsPlaying );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void VideoSubWindow::refreshFrame( bool bThreaded )
|
||||
{
|
||||
#ifndef QT_NO_CONCURRENT
|
||||
m_cRefreshResult.waitForFinished();
|
||||
if( bThreaded )
|
||||
{
|
||||
m_cRefreshResult = QtConcurrent::run( this, &VideoSubWindow::refreshFrameOperation );
|
||||
}
|
||||
else
|
||||
#endif
|
||||
{
|
||||
refreshFrameOperation();
|
||||
}
|
||||
}
|
||||
|
||||
bool VideoSubWindow::goToNextFrame( bool bThreaded )
|
||||
{
|
||||
#ifndef QT_NO_CONCURRENT
|
||||
m_cRefreshResult.waitForFinished();
|
||||
m_cReadResult.waitForFinished();
|
||||
#endif
|
||||
#ifdef CALYP_MANAGED_RESOURCES
|
||||
while( !m_pCurrStream->hasNextFrame() && !m_pCurrStream->isEof() )
|
||||
;
|
||||
#endif
|
||||
bool bEndOfSeq = m_pCurrStream->setNextFrame();
|
||||
#ifdef CALYP_MANAGED_RESOURCES
|
||||
bThreaded = false;
|
||||
m_pcResourceManager->wakeResourceWorker( m_uiResourceId );
|
||||
#endif
|
||||
if( !bEndOfSeq )
|
||||
{
|
||||
#ifndef QT_NO_CONCURRENT
|
||||
m_cRefreshResult.waitForFinished();
|
||||
if( bThreaded )
|
||||
{
|
||||
m_cReadResult = QtConcurrent::run( m_pCurrStream, &CalypStream::readNextFrameFillRGBBuffer );
|
||||
refreshFrame( bThreaded );
|
||||
}
|
||||
else
|
||||
#endif
|
||||
{
|
||||
refreshFrame( bThreaded );
|
||||
#ifndef CALYP_MANAGED_RESOURCES
|
||||
m_pCurrStream->readNextFrameFillRGBBuffer();
|
||||
#endif
|
||||
}
|
||||
}
|
||||
return bEndOfSeq;
|
||||
}
|
||||
|
||||
bool VideoSubWindow::save( QString filename )
|
||||
{
|
||||
bool iRet = false;
|
||||
QApplication::setOverrideCursor( Qt::WaitCursor );
|
||||
|
||||
std::unique_ptr<CalypFrame> new_frame{ nullptr };
|
||||
CalypFrame* saveFrame = m_pcCurrFrameAsset.get();
|
||||
if( m_cSelectedArea.isValid() )
|
||||
{
|
||||
saveFrame = new CalypFrame( m_pcCurrFrameAsset.get(), m_cSelectedArea.x(), m_cSelectedArea.y(), m_cSelectedArea.width(),
|
||||
m_cSelectedArea.height() );
|
||||
new_frame = std::make_unique<CalypFrame>( m_pcCurrFrameAsset.get(), m_cSelectedArea.x(), m_cSelectedArea.y(), m_cSelectedArea.width(),
|
||||
m_cSelectedArea.height() );
|
||||
saveFrame = new_frame.get();
|
||||
}
|
||||
if( !saveFrame )
|
||||
{
|
||||
@@ -909,109 +393,6 @@ bool VideoSubWindow::save( QString filename )
|
||||
return iRet;
|
||||
}
|
||||
|
||||
bool VideoSubWindow::saveStream( QString filename )
|
||||
{
|
||||
bool iRet = false;
|
||||
QApplication::setOverrideCursor( Qt::WaitCursor );
|
||||
|
||||
// TODO: implement this
|
||||
QApplication::restoreOverrideCursor();
|
||||
return iRet;
|
||||
}
|
||||
|
||||
void VideoSubWindow::setPlaying( bool isPlaying )
|
||||
{
|
||||
m_bIsPlaying = isPlaying;
|
||||
for( auto module : m_associatedModules )
|
||||
{
|
||||
module->setPlaying( isPlaying );
|
||||
}
|
||||
}
|
||||
|
||||
bool VideoSubWindow::isPlaying()
|
||||
{
|
||||
if( getCategory() & SubWindowCategory::MODULE_SUBWINDOW )
|
||||
{
|
||||
for( auto window : m_pcCurrentDisplayModule->getSubWindowList() )
|
||||
{
|
||||
if( window->isPlaying() )
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
return m_bIsPlaying;
|
||||
}
|
||||
|
||||
bool VideoSubWindow::play()
|
||||
{
|
||||
bool isPlaying = false;
|
||||
if( m_pCurrStream && m_pCurrStream->getFrameNum() > 1 )
|
||||
{
|
||||
isPlaying = true;
|
||||
}
|
||||
setPlaying( isPlaying );
|
||||
return m_bIsPlaying;
|
||||
}
|
||||
|
||||
bool VideoSubWindow::playEvent()
|
||||
{
|
||||
bool bEndOfSeq = false;
|
||||
if( m_pCurrStream && m_bIsPlaying )
|
||||
{
|
||||
bEndOfSeq = goToNextFrame( true );
|
||||
}
|
||||
return bEndOfSeq;
|
||||
}
|
||||
|
||||
void VideoSubWindow::pause()
|
||||
{
|
||||
setPlaying( false );
|
||||
refreshFrame();
|
||||
}
|
||||
|
||||
void VideoSubWindow::seekAbsoluteEvent( unsigned int new_frame_num )
|
||||
{
|
||||
if( m_pCurrStream )
|
||||
{
|
||||
if( m_pCurrStream->seekInput( new_frame_num ) )
|
||||
refreshFrame();
|
||||
|
||||
#ifdef CALYP_MANAGED_RESOURCES
|
||||
m_pcResourceManager->wakeResourceWorker( m_uiResourceId );
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
void VideoSubWindow::seekRelativeEvent( bool bIsFoward )
|
||||
{
|
||||
if( m_pCurrStream )
|
||||
{
|
||||
if( bIsFoward )
|
||||
{
|
||||
goToNextFrame( true );
|
||||
}
|
||||
else
|
||||
{
|
||||
m_pCurrStream->seekInputRelative( bIsFoward );
|
||||
#ifdef CALYP_MANAGED_RESOURCES
|
||||
m_pcResourceManager->wakeResourceWorker( m_uiResourceId );
|
||||
#endif
|
||||
refreshFrame();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void VideoSubWindow::stop()
|
||||
{
|
||||
#ifndef QT_NO_CONCURRENT
|
||||
m_cRefreshResult.waitForFinished();
|
||||
m_cReadResult.waitForFinished();
|
||||
#endif
|
||||
setPlaying( false );
|
||||
seekAbsoluteEvent( 0 );
|
||||
return;
|
||||
}
|
||||
|
||||
QSize VideoSubWindow::getScrollSize()
|
||||
{
|
||||
return QSize( m_pcScrollArea->viewport()->size().width() - 5, m_pcScrollArea->viewport()->size().height() - 5 );
|
||||
@@ -1095,14 +476,6 @@ void VideoSubWindow::updateScrollValues()
|
||||
m_dVerScroll = yPos / double( m_pcScrollArea->verticalScrollBar()->maximum() );
|
||||
}
|
||||
|
||||
//void VideoSubWindow::setCurScrollValues()
|
||||
//{
|
||||
// QScrollBar* scrollBar = m_pcScrollArea->horizontalScrollBar();
|
||||
// scrollBar->setValue( m_cCurrScroll.x() );
|
||||
// scrollBar = m_pcScrollArea->verticalScrollBar();
|
||||
// scrollBar->setValue( m_cCurrScroll.y() );
|
||||
//}
|
||||
|
||||
void VideoSubWindow::normalSize()
|
||||
{
|
||||
double factor = 1.0;
|
||||
@@ -1149,8 +522,8 @@ void VideoSubWindow::scaleView( const QSize& size, QPoint center )
|
||||
QSize imgViewSize;
|
||||
if( m_pcCurrFrameAsset )
|
||||
imgViewSize = QSize( m_pcCurrFrameAsset->getWidth(), m_pcCurrFrameAsset->getHeight() );
|
||||
else
|
||||
imgViewSize = QSize( m_pCurrStream->getWidth(), m_pCurrStream->getHeight() );
|
||||
//else
|
||||
// imgViewSize = QSize( m_pCurrStream->getWidth(), m_pCurrStream->getHeight() );
|
||||
QSize newSize = imgViewSize;
|
||||
newSize.scale( size, Qt::KeepAspectRatio );
|
||||
|
||||
|
||||
+63
-116
@@ -28,6 +28,7 @@
|
||||
#include <QDataStream>
|
||||
#include <QFuture>
|
||||
#include <QRect>
|
||||
#include <QStaticText>
|
||||
#include <QString>
|
||||
#include <QVector>
|
||||
|
||||
@@ -45,69 +46,32 @@ class VideoSubWindow;
|
||||
class ResourceHandle;
|
||||
class CalypAppModuleIf;
|
||||
|
||||
typedef struct
|
||||
/**
|
||||
* \class VideoInformation
|
||||
* \brief Shows information about video sub window
|
||||
*/
|
||||
class VideoInformation : public QWidget
|
||||
{
|
||||
QString m_cFilename;
|
||||
unsigned int m_uiWidth;
|
||||
unsigned int m_uiHeight;
|
||||
int m_iPelFormat;
|
||||
unsigned int m_uiBitsPelPixel;
|
||||
unsigned int m_iEndianness;
|
||||
unsigned int m_uiFrameRate;
|
||||
unsigned long long int m_uiFileSize;
|
||||
} CalypFileInfo;
|
||||
typedef QVector<CalypFileInfo> CalypFileInfoVector;
|
||||
public:
|
||||
VideoInformation( QWidget* parent );
|
||||
void setInformationTopLeft( const QStringList& textLines );
|
||||
void setBusyWindow( bool bFlag );
|
||||
|
||||
QDataStream& operator<<( QDataStream& out, const CalypFileInfoVector& d );
|
||||
QDataStream& operator>>( QDataStream& in, CalypFileInfoVector& d );
|
||||
int findCalypStreamInfo( CalypFileInfoVector array, QString filename );
|
||||
protected:
|
||||
void paintEvent( QPaintEvent* event );
|
||||
|
||||
private:
|
||||
QTimer* m_pcRefreshTimer;
|
||||
QList<QStaticText> m_cTopLeftTextList;
|
||||
QFont m_cTopLeftTextFont;
|
||||
QFont m_cCenterTextFont;
|
||||
bool m_bBusyWindow;
|
||||
};
|
||||
|
||||
class VideoSubWindow : public SubWindowAbstract
|
||||
{
|
||||
Q_OBJECT
|
||||
|
||||
private:
|
||||
ResourceHandle* m_pcResourceManager;
|
||||
|
||||
bool m_bWindowBusy;
|
||||
|
||||
QScrollArea* m_pcScrollArea;
|
||||
QPoint m_cCurrScroll;
|
||||
double m_dHorScroll;
|
||||
double m_dVerScroll;
|
||||
|
||||
ViewArea* m_cViewArea;
|
||||
|
||||
VideoInformation* m_pcVideoInfo;
|
||||
|
||||
QString m_cFilename;
|
||||
QString m_cStreamInformation;
|
||||
CalypFileInfo m_sStreamInfo;
|
||||
std::size_t m_uiResourceId;
|
||||
CalypStream* m_pCurrStream;
|
||||
std::shared_ptr<CalypFrame> m_pcCurrFrameAsset;
|
||||
//CalypFrame* m_pcCurrFrame;
|
||||
QRect m_cSelectedArea;
|
||||
|
||||
CalypAppModuleIf* m_pcCurrentDisplayModule{ nullptr };
|
||||
std::vector<std::shared_ptr<CalypAppModuleIf>> m_associatedModules;
|
||||
bool m_hasAssociatedModules;
|
||||
|
||||
VideoSubWindow* m_pcReferenceSubWindow;
|
||||
|
||||
// QString m_cWindowShortName;
|
||||
QString m_cCurrFileName;
|
||||
|
||||
bool m_bIsPlaying;
|
||||
|
||||
QTimer* m_pcUpdateTimer;
|
||||
/**
|
||||
* Threads variables
|
||||
* QtConcurrent
|
||||
*/
|
||||
QFuture<void> m_cRefreshResult;
|
||||
QFuture<void> m_cReadResult;
|
||||
|
||||
public:
|
||||
enum VideoSubWindowCategories
|
||||
{
|
||||
@@ -115,41 +79,26 @@ public:
|
||||
MODULE_SUBWINDOW = SubWindowAbstract::MODULE_SUBWINDOW,
|
||||
};
|
||||
VideoSubWindow( enum VideoSubWindowCategories category, QWidget* parent = 0 );
|
||||
VideoSubWindow( enum VideoSubWindowCategories category, CalypAppModuleIf* displayModule, QWidget* parent = 0 );
|
||||
~VideoSubWindow();
|
||||
|
||||
void setResourceManaget( ResourceHandle* resourceManager ) { m_pcResourceManager = resourceManager; }
|
||||
virtual void resetWindowName() = 0;
|
||||
virtual void updateVideoWindowInfo() = 0;
|
||||
|
||||
void updateVideoWindowInfo();
|
||||
virtual bool isPlaying() = 0;
|
||||
virtual void stop() = 0;
|
||||
virtual void advanceOneFrame() = 0;
|
||||
virtual auto getFrameNum() -> std::uint64_t { return 1; };
|
||||
|
||||
bool loadFile( QString cFilename, bool bForceDialog = false );
|
||||
bool loadFile( CalypFileInfo* streamInfo );
|
||||
void loadAll();
|
||||
QString getVideoInformation() { return m_cStreamInformation; }
|
||||
bool save( QString filename );
|
||||
bool saveStream( QString filename );
|
||||
|
||||
void refreshSubWindow();
|
||||
void refreshFrame( bool bThreaded = false );
|
||||
|
||||
bool play();
|
||||
void pause();
|
||||
bool playEvent();
|
||||
void stop();
|
||||
|
||||
void setPlaying( bool isPlaying );
|
||||
bool isPlaying();
|
||||
void seekAbsoluteEvent( unsigned int new_frame_num );
|
||||
void seekRelativeEvent( bool bIsFoward );
|
||||
|
||||
void setCurrFrame( std::shared_ptr<CalypFrame> pcCurrFrame );
|
||||
|
||||
CalypFileInfo getStreamInfo() { return m_sStreamInfo; }
|
||||
QString getStreamInformation() { return m_cStreamInformation; }
|
||||
const CalypStream* getInputStream() { return m_pCurrStream; }
|
||||
const CalypStream* getCurrStream() { return m_pCurrStream; }
|
||||
CalypFrame* getCurrFrame() { return m_pcCurrFrameAsset.get(); }
|
||||
std::shared_ptr<CalypFrame> getCurrFrameAsset();
|
||||
ViewArea* getViewArea() { return m_cViewArea; }
|
||||
auto getCurrFrame() -> CalypFrame* { return m_pcCurrFrameAsset.get(); }
|
||||
auto getCurrFrameAsset() -> std::shared_ptr<CalypFrame> { return m_pcCurrFrameAsset; };
|
||||
auto getViewArea() -> ViewArea* { return m_cViewArea; }
|
||||
|
||||
VideoSubWindow* getRefSubWindow() { return m_pcReferenceSubWindow; }
|
||||
void setRefSubWindow( VideoSubWindow* subWindow )
|
||||
{
|
||||
m_pcReferenceSubWindow = NULL;
|
||||
@@ -158,59 +107,37 @@ public:
|
||||
m_pcReferenceSubWindow = subWindow;
|
||||
}
|
||||
|
||||
VideoSubWindow* getRefSubWindow() { return m_pcReferenceSubWindow; }
|
||||
/**
|
||||
* Functions to enable a module in the
|
||||
* current SubWindow
|
||||
*/
|
||||
//void enableModule( std::shared_ptr<CalypAppModuleIf> pcModule );
|
||||
auto hasModules() -> bool { return m_associatedModules.size() > 0; }
|
||||
bool hasAssociatedModule();
|
||||
void setDisplayModule( CalypAppModuleIf* pcModule );
|
||||
void associateModule( std::shared_ptr<CalypAppModuleIf> pcModule );
|
||||
void disableModule( CalypAppModuleIf* pcModule );
|
||||
bool disableAllModules();
|
||||
|
||||
CalypAppModuleIf* getDisplayModule() { return m_pcCurrentDisplayModule; }
|
||||
QVector<CalypAppModuleIf*> getModuleArray()
|
||||
{
|
||||
QVector<CalypAppModuleIf*> apcModulesArray;
|
||||
if( m_pcCurrentDisplayModule )
|
||||
apcModulesArray.append( m_pcCurrentDisplayModule );
|
||||
for( const auto& module : m_associatedModules )
|
||||
{
|
||||
apcModulesArray.append( module.get() );
|
||||
}
|
||||
return apcModulesArray;
|
||||
}
|
||||
CalypAppModuleIf* getDisplayModule() { return m_pcDisplayModule; }
|
||||
|
||||
/**
|
||||
* Virtual functions from SubWindowAbstract
|
||||
*/
|
||||
void normalSize();
|
||||
void zoomToFit();
|
||||
void scaleView( double scale, QPoint center = QPoint() );
|
||||
void zoomToFactor( double factor, QPoint center = QPoint() );
|
||||
void normalSize() override;
|
||||
void zoomToFit() override;
|
||||
void scaleView( double scale, QPoint center = QPoint() ) override;
|
||||
void zoomToFactor( double factor, QPoint center = QPoint() ) override;
|
||||
|
||||
double getScaleFactor() { return m_cViewArea->getZoomFactor(); }
|
||||
double getScaleFactor() override { return m_cViewArea->getZoomFactor(); }
|
||||
/**
|
||||
* Size related functions
|
||||
*/
|
||||
QSize sizeHint() const;
|
||||
QSize sizeHint( const QSize& ) const;
|
||||
QSize sizeHint( const QSize& ) const override;
|
||||
|
||||
QString getCurrentFileName() { return m_cFilename; }
|
||||
void clearWindowBusy() { m_bWindowBusy = false; }
|
||||
void setFillWindow( bool bFlag );
|
||||
|
||||
void adjustScrollBarToRatio( const double& horRatio, const double& verRatio );
|
||||
|
||||
private:
|
||||
void refreshFrameOperation();
|
||||
bool goToNextFrame( bool bThreaded = false );
|
||||
|
||||
static bool guessFormat( QString filename, unsigned int& rWidth, unsigned int& rHeight, int& rInputFormat, unsigned int& rBitsPerPixel,
|
||||
int& rEndianness, unsigned int& rFrameRate );
|
||||
|
||||
bool hasRunningModule();
|
||||
|
||||
/**
|
||||
@@ -222,6 +149,8 @@ private:
|
||||
QSize getScrollSize();
|
||||
|
||||
protected:
|
||||
void refreshFrame();
|
||||
|
||||
void keyPressEvent( QKeyEvent* event ) override;
|
||||
void resizeEvent( QResizeEvent* event ) override;
|
||||
void closeEvent( QCloseEvent* event ) override;
|
||||
@@ -233,9 +162,27 @@ public Q_SLOTS:
|
||||
void updateScrollValues();
|
||||
void updateSelectedArea( QRect area );
|
||||
void updatePixelValueStatusBar( const QPoint& pos );
|
||||
|
||||
protected:
|
||||
VideoInformation* m_pcVideoInfo;
|
||||
QString m_cStreamInformation;
|
||||
std::shared_ptr<CalypFrame> m_pcCurrFrameAsset;
|
||||
//bool m_bWindowBusy;
|
||||
//bool m_bIsPlaying;
|
||||
|
||||
std::vector<std::shared_ptr<CalypAppModuleIf>> m_associatedModules;
|
||||
CalypAppModuleIf* m_pcDisplayModule{ nullptr };
|
||||
//bool m_hasAssociatedModules;
|
||||
|
||||
private:
|
||||
QScrollArea* m_pcScrollArea;
|
||||
QPoint m_cCurrScroll;
|
||||
double m_dHorScroll;
|
||||
double m_dVerScroll;
|
||||
ViewArea* m_cViewArea;
|
||||
QRect m_cSelectedArea;
|
||||
VideoSubWindow* m_pcReferenceSubWindow;
|
||||
QTimer* m_pcUpdateTimer;
|
||||
};
|
||||
|
||||
Q_DECLARE_METATYPE( CalypFileInfo ) // NOLINT
|
||||
Q_DECLARE_METATYPE( CalypFileInfoVector ) // NOLINT
|
||||
|
||||
#endif // __VIDEOSUBWINDOW_H__
|
||||
@@ -41,7 +41,7 @@ class HistogramWorker : public QThread
|
||||
{
|
||||
private:
|
||||
QObject* m_parent;
|
||||
std::shared_ptr<CalypFrame> m_pcFrame;
|
||||
std::shared_ptr<CalypFrame> m_pcFrame{ nullptr };
|
||||
|
||||
public:
|
||||
HistogramWorker( QObject* parent )
|
||||
@@ -52,27 +52,28 @@ public:
|
||||
void setup( std::shared_ptr<CalypFrame> frame )
|
||||
{
|
||||
m_pcFrame = std::move( frame );
|
||||
EventData* eventData = new EventData( m_pcFrame.get() ); // NOLINT
|
||||
EventData* eventData = new EventData(); // NOLINT
|
||||
eventData->starting = true;
|
||||
// QCoreApplication::postEvent( m_parent, eventData );
|
||||
start();
|
||||
QCoreApplication::postEvent( m_parent, eventData );
|
||||
}
|
||||
void run() override
|
||||
{
|
||||
if( m_pcFrame != nullptr && m_parent != nullptr )
|
||||
EventData* eventData = new EventData(); // NOLINT
|
||||
if( m_pcFrame != nullptr )
|
||||
{
|
||||
EventData* eventData = new EventData( m_pcFrame.get() ); // NOLINT
|
||||
m_pcFrame->calcHistogram();
|
||||
eventData->success = true;
|
||||
QCoreApplication::postEvent( m_parent, eventData );
|
||||
eventData->frame = m_pcFrame.get();
|
||||
}
|
||||
eventData->success = true;
|
||||
QCoreApplication::postEvent( m_parent, eventData );
|
||||
}
|
||||
|
||||
class EventData : public QEvent
|
||||
{
|
||||
public:
|
||||
EventData( CalypFrame* f )
|
||||
: QEvent( QEvent::User ), frame{ f } {}
|
||||
EventData()
|
||||
: QEvent( QEvent::User ), frame{ nullptr } {}
|
||||
CalypFrame* frame{ nullptr };
|
||||
bool starting{ false };
|
||||
bool success{ false };
|
||||
|
||||
+3
-3
@@ -569,7 +569,7 @@ CalypPixel CalypFrame::getPixel( unsigned int xPos, unsigned int yPos ) const
|
||||
return PixelValue;
|
||||
}
|
||||
|
||||
CalypPixel CalypFrame::getPixel( unsigned int xPos, unsigned int yPos, CalypColorSpace eColorSpace )
|
||||
CalypPixel CalypFrame::getPixel( unsigned int xPos, unsigned int yPos, CalypColorSpace eColorSpace ) const
|
||||
{
|
||||
return getPixel( xPos, yPos ).convertPixel( eColorSpace );
|
||||
}
|
||||
@@ -1262,12 +1262,12 @@ bool CalypFrame::toMat( cv::Mat& cvMat, bool convertToGray, bool scale, unsigned
|
||||
cv::Mat tmpMat( imgHeight, imgWidth, CV_MAKETYPE( cvPrecision, numChannels ) );
|
||||
|
||||
unsigned char* cv_data = tmpMat.data;
|
||||
CalypPixel currPel;
|
||||
for( unsigned y = 0; y < imgHeight; y++ )
|
||||
{
|
||||
for( unsigned x = 0; x < imgWidth; x++ )
|
||||
{
|
||||
currPel = getPixel( x, y ) * scaleFactor;
|
||||
CalypPixel currPel = getPixel( x, y );
|
||||
currPel *= scaleFactor;
|
||||
for( unsigned int ch = 0; ch < numChannels; ch++ )
|
||||
for( unsigned b = 0; b < numBytes; b++ )
|
||||
{
|
||||
|
||||
+31
-22
@@ -93,6 +93,7 @@ enum CLP_RGB_Components
|
||||
|
||||
enum CLP_Endianness
|
||||
{
|
||||
CLP_INVALID_ENDIANESS = -1,
|
||||
CLP_BIG_ENDIAN = 0,
|
||||
CLP_LITTLE_ENDIAN = 1,
|
||||
};
|
||||
@@ -106,27 +107,39 @@ enum CLP_Endianness
|
||||
*/
|
||||
class CalypPixel
|
||||
{
|
||||
private:
|
||||
static constexpr std::size_t kMaxNumberOfComponents{ 4 };
|
||||
int m_colorSpace{ CLP_COLOR_INVALID };
|
||||
std::array<ClpPel, kMaxNumberOfComponents> m_pelComp{ 0, 0, 0, 0 };
|
||||
|
||||
public:
|
||||
static int getMaxNumberOfComponents();
|
||||
static std::size_t getMaxNumberOfComponents() { return kMaxNumberOfComponents; }
|
||||
|
||||
CalypPixel( const int& CalypColorSpace = CLP_COLOR_INVALID );
|
||||
CalypPixel( const int& CalypColorSpace, const ClpPel& c0 );
|
||||
CalypPixel( const int& CalypColorSpace, const ClpPel& c0, const ClpPel& c1, const ClpPel& c2 );
|
||||
CalypPixel( const int& CalypColorSpace, const ClpPel& c0, const ClpPel& c1, const ClpPel& c2, const ClpPel& c3 );
|
||||
CalypPixel( const CalypPixel& other );
|
||||
~CalypPixel();
|
||||
CalypPixel() = default;
|
||||
CalypPixel( const int CalypColorSpace, const ClpPel c0 = 0 );
|
||||
CalypPixel( const int CalypColorSpace, const ClpPel c0, const ClpPel c1, const ClpPel c2 );
|
||||
CalypPixel( const int CalypColorSpace, const ClpPel c0, const ClpPel c1, const ClpPel c2, const ClpPel c3 );
|
||||
CalypPixel( const CalypPixel& other ) noexcept = default;
|
||||
CalypPixel( CalypPixel&& other ) noexcept = default;
|
||||
auto operator=( const CalypPixel& other ) -> CalypPixel& = default;
|
||||
auto operator=( CalypPixel&& other ) noexcept -> CalypPixel& = default;
|
||||
~CalypPixel() = default;
|
||||
|
||||
int colorSpace() const;
|
||||
int colorSpace() const { return m_colorSpace; };
|
||||
|
||||
ClpPel operator[]( const int& channel ) const;
|
||||
ClpPel& operator[]( const int& channel );
|
||||
auto components() const -> const std::array<ClpPel, kMaxNumberOfComponents>& { return m_pelComp; };
|
||||
auto components() -> std::array<ClpPel, kMaxNumberOfComponents>& { return m_pelComp; };
|
||||
|
||||
CalypPixel operator=( const CalypPixel& );
|
||||
CalypPixel operator+( const CalypPixel& );
|
||||
CalypPixel operator+=( const CalypPixel& );
|
||||
CalypPixel operator-( const CalypPixel& );
|
||||
CalypPixel operator-=( const CalypPixel& );
|
||||
CalypPixel operator*( const double& );
|
||||
ClpPel operator[]( const int& channel ) const { return m_pelComp[channel]; }
|
||||
ClpPel& operator[]( const int& channel ) { return m_pelComp[channel]; }
|
||||
|
||||
CalypPixel& operator+=( const CalypPixel& );
|
||||
CalypPixel& operator-=( const CalypPixel& );
|
||||
CalypPixel& operator*=( const double& );
|
||||
|
||||
CalypPixel operator+( const CalypPixel& ) const;
|
||||
CalypPixel operator-( const CalypPixel& ) const;
|
||||
CalypPixel operator*( const double& ) const;
|
||||
|
||||
/**
|
||||
* Convert a Pixel to a new color space
|
||||
@@ -134,11 +147,7 @@ public:
|
||||
* @param eOutputSpace output color space
|
||||
* @return converted pixel
|
||||
*/
|
||||
CalypPixel convertPixel( CalypColorSpace eOutputSpace );
|
||||
|
||||
private:
|
||||
class CalypPixelPrivate;
|
||||
std::unique_ptr<CalypPixelPrivate> d;
|
||||
CalypPixel convertPixel( CalypColorSpace eOutputSpace ) const;
|
||||
};
|
||||
|
||||
/**
|
||||
@@ -434,7 +443,7 @@ public:
|
||||
* @param eColorSpace desired color space
|
||||
* @return pixel value
|
||||
*/
|
||||
CalypPixel getPixel( unsigned int xPos, unsigned int yPos, CalypColorSpace eColorSpace );
|
||||
CalypPixel getPixel( unsigned int xPos, unsigned int yPos, CalypColorSpace eColorSpace ) const;
|
||||
|
||||
/**
|
||||
* Set pixel value at coordinates to a given value
|
||||
|
||||
+6
-3
@@ -127,7 +127,7 @@ public:
|
||||
const char* m_pchModuleCategory{ "" };
|
||||
const char* m_pchModuleName{ "" };
|
||||
const char* m_pchModuleTooltip{ "" };
|
||||
const char* m_pchModuleLongName{ "" };
|
||||
const char* m_pchModuleLongName{ nullptr };
|
||||
|
||||
//! Number of frames
|
||||
unsigned int m_uiNumberOfFrames{ 1 };
|
||||
@@ -135,12 +135,15 @@ public:
|
||||
unsigned int m_uiModuleRequirements{ CLP_MODULE_REQUIRES_NOTHING };
|
||||
|
||||
unsigned int m_iFrameBufferCount{ 0 };
|
||||
//CalypFrame* m_pcOutputFrame;
|
||||
|
||||
CalypOptions m_cModuleOptions;
|
||||
|
||||
CalypModuleIf() = default;
|
||||
virtual ~CalypModuleIf() {}
|
||||
CalypModuleIf( const CalypModuleIf& other ) noexcept = delete;
|
||||
CalypModuleIf( CalypModuleIf&& other ) noexcept = delete;
|
||||
auto operator=( const CalypModuleIf& other ) -> CalypModuleIf& = delete;
|
||||
auto operator=( CalypModuleIf&& other ) noexcept -> CalypModuleIf& = delete;
|
||||
virtual ~CalypModuleIf() = default;
|
||||
virtual void destroy() = 0;
|
||||
|
||||
const char* getModuleLongName()
|
||||
|
||||
+89
-132
@@ -22,204 +22,161 @@
|
||||
* \brief Video Frame handling
|
||||
*/
|
||||
|
||||
#include <algorithm>
|
||||
#include <cassert>
|
||||
#include <memory>
|
||||
#include <numeric>
|
||||
|
||||
#include "CalypFrame.h"
|
||||
#include "PixelFormats.h"
|
||||
#include "config.h"
|
||||
|
||||
#define MAX_NUMBER_COMPONENTS 4
|
||||
|
||||
class CalypPixel::CalypPixelPrivate
|
||||
{
|
||||
public:
|
||||
CalypPixelPrivate( const int& ColorSpace )
|
||||
{
|
||||
iColorSpace = ColorSpace == CLP_COLOR_GRAY ?
|
||||
CLP_COLOR_YUV :
|
||||
ColorSpace;
|
||||
for( int i = 0; i < MAX_NUMBER_COMPONENTS; i++ )
|
||||
{
|
||||
PelComp[i] = 0;
|
||||
}
|
||||
}
|
||||
|
||||
int iColorSpace;
|
||||
ClpPel PelComp[MAX_NUMBER_COMPONENTS];
|
||||
};
|
||||
constexpr auto kMinPixelValue{ 0 };
|
||||
constexpr auto kMaxPixelValue{ 255 };
|
||||
|
||||
static inline void yuvToRgb( const int& iY, const int& iU, const int& iV, int& iR, int& iG, int& iB )
|
||||
{
|
||||
iR = iY + ( ( 1436 * ( iV - 128 ) ) >> 10 );
|
||||
iG = iY - ( ( 352 * ( iU - 128 ) + 731 * ( iV - 128 ) ) >> 10 );
|
||||
iB = iY + ( ( 1812 * ( iU - 128 ) ) >> 10 );
|
||||
iR = iR < 0 ? 0 : iR > 255 ? 255 :
|
||||
iR;
|
||||
iG = iG < 0 ? 0 : iG > 255 ? 255 :
|
||||
iG;
|
||||
iB = iB < 0 ? 0 : iB > 255 ? 255 :
|
||||
iB;
|
||||
iR = std::clamp( iY + ( ( 1436 * ( iV - 128 ) ) >> 10 ), kMinPixelValue, kMaxPixelValue ); //NOLINT
|
||||
iG = std::clamp( iY - ( ( 352 * ( iU - 128 ) + 731 * ( iV - 128 ) ) >> 10 ), kMinPixelValue, kMaxPixelValue ); //NOLINT
|
||||
iB = std::clamp( iY + ( ( 1812 * ( iU - 128 ) ) >> 10 ), kMinPixelValue, kMaxPixelValue ); //NOLINT
|
||||
}
|
||||
|
||||
static inline void rgbToYuv( const int& iR, const int& iG, const int& iB, int& iY, int& iU, int& iV )
|
||||
{
|
||||
iY = ( 299 * iR + 587 * iG + 114 * iB + 500 ) / 1000;
|
||||
iU = ( 1000 * ( iB - iY ) + 226816 ) / 1772;
|
||||
iV = ( 1000 * ( iR - iY ) + 179456 ) / 1402;
|
||||
iY = ( 299 * iR + 587 * iG + 114 * iB + 500 ) / 1000; //NOLINT
|
||||
iU = ( 1000 * ( iB - iY ) + 226816 ) / 1772; //NOLINT
|
||||
iV = ( 1000 * ( iR - iY ) + 179456 ) / 1402; //NOLINT
|
||||
}
|
||||
|
||||
int CalypPixel::getMaxNumberOfComponents()
|
||||
CalypPixel::CalypPixel( const int ColorSpace, const ClpPel c0 )
|
||||
{
|
||||
return MAX_NUMBER_COMPONENTS;
|
||||
m_colorSpace = ColorSpace;
|
||||
m_pelComp[0] = c0;
|
||||
}
|
||||
|
||||
CalypPixel::CalypPixel( const int& ColorSpace )
|
||||
: d{ std::make_unique<CalypPixelPrivate>( ColorSpace ) }
|
||||
CalypPixel::CalypPixel( const int ColorSpace, const ClpPel c0, const ClpPel c1, const ClpPel c2 )
|
||||
{
|
||||
m_colorSpace = ColorSpace;
|
||||
m_pelComp[0] = c0;
|
||||
m_pelComp[1] = c1;
|
||||
m_pelComp[2] = c2;
|
||||
}
|
||||
|
||||
CalypPixel::CalypPixel( const int& ColorSpace, const ClpPel& c0 )
|
||||
: d{ std::make_unique<CalypPixelPrivate>( ColorSpace ) }
|
||||
CalypPixel::CalypPixel( const int ColorSpace, const ClpPel c0, const ClpPel c1, const ClpPel c2, const ClpPel c3 )
|
||||
{
|
||||
d->PelComp[0] = c0;
|
||||
m_colorSpace = ColorSpace;
|
||||
m_pelComp[0] = c0;
|
||||
m_pelComp[1] = c1;
|
||||
m_pelComp[2] = c2;
|
||||
m_pelComp[3] = c3;
|
||||
}
|
||||
|
||||
CalypPixel::CalypPixel( const int& ColorSpace, const ClpPel& c0, const ClpPel& c1, const ClpPel& c2 )
|
||||
: d{ std::make_unique<CalypPixelPrivate>( ColorSpace ) }
|
||||
CalypPixel& CalypPixel::operator+=( const CalypPixel& in )
|
||||
{
|
||||
d->PelComp[0] = c0;
|
||||
d->PelComp[1] = c1;
|
||||
d->PelComp[2] = c2;
|
||||
}
|
||||
|
||||
CalypPixel::CalypPixel( const int& ColorSpace, const ClpPel& c0, const ClpPel& c1, const ClpPel& c2, const ClpPel& c3 )
|
||||
: d{ std::make_unique<CalypPixelPrivate>( ColorSpace ) }
|
||||
{
|
||||
d->PelComp[0] = c0;
|
||||
d->PelComp[1] = c1;
|
||||
d->PelComp[2] = c2;
|
||||
d->PelComp[3] = c3;
|
||||
}
|
||||
|
||||
CalypPixel::CalypPixel( const CalypPixel& other )
|
||||
: d{ std::make_unique<CalypPixelPrivate>( other.colorSpace() ) }
|
||||
|
||||
{
|
||||
for( int i = 0; i < MAX_NUMBER_COMPONENTS; i++ )
|
||||
{
|
||||
d->PelComp[i] = other[i];
|
||||
}
|
||||
}
|
||||
|
||||
CalypPixel::~CalypPixel() = default;
|
||||
|
||||
int CalypPixel::colorSpace() const
|
||||
{
|
||||
return d->iColorSpace;
|
||||
}
|
||||
|
||||
ClpPel CalypPixel::operator[]( const int& channel ) const
|
||||
{
|
||||
return d->PelComp[channel];
|
||||
}
|
||||
ClpPel& CalypPixel::operator[]( const int& channel )
|
||||
{
|
||||
return d->PelComp[channel];
|
||||
}
|
||||
|
||||
CalypPixel CalypPixel::operator=( const CalypPixel& other )
|
||||
{
|
||||
for( int i = 0; i < MAX_NUMBER_COMPONENTS; i++ )
|
||||
{
|
||||
d->PelComp[i] = other[i];
|
||||
}
|
||||
assert( in.colorSpace() == m_colorSpace );
|
||||
const auto& other_comp = in.components();
|
||||
std::transform( other_comp.begin(),
|
||||
other_comp.end(),
|
||||
m_pelComp.begin(),
|
||||
m_pelComp.begin(),
|
||||
[]( auto& p1, auto& p2 ) { return p1 + p2; } );
|
||||
return *this;
|
||||
}
|
||||
|
||||
CalypPixel CalypPixel::operator+( const CalypPixel& in )
|
||||
CalypPixel& CalypPixel::operator-=( const CalypPixel& in )
|
||||
{
|
||||
CalypPixel result;
|
||||
for( int i = 0; i < MAX_NUMBER_COMPONENTS; i++ )
|
||||
{
|
||||
result[i] = d->PelComp[i] + in[i];
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
CalypPixel CalypPixel::operator+=( const CalypPixel& in )
|
||||
{
|
||||
for( int i = 0; i < MAX_NUMBER_COMPONENTS; i++ )
|
||||
{
|
||||
d->PelComp[i] += in[i];
|
||||
}
|
||||
assert( in.colorSpace() == m_colorSpace );
|
||||
const auto& other_comp = in.components();
|
||||
std::transform( other_comp.begin(),
|
||||
other_comp.end(),
|
||||
m_pelComp.begin(),
|
||||
m_pelComp.begin(),
|
||||
[]( auto& p1, auto& p2 ) { return p1 - p2; } );
|
||||
return *this;
|
||||
}
|
||||
|
||||
CalypPixel CalypPixel::operator-( const CalypPixel& in )
|
||||
CalypPixel& CalypPixel::operator*=( const double& op )
|
||||
{
|
||||
CalypPixel result;
|
||||
for( int i = 0; i < MAX_NUMBER_COMPONENTS; i++ )
|
||||
{
|
||||
result[i] = d->PelComp[i] - in[i];
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
CalypPixel CalypPixel::operator-=( const CalypPixel& in )
|
||||
{
|
||||
for( int i = 0; i < MAX_NUMBER_COMPONENTS; i++ )
|
||||
{
|
||||
d->PelComp[i] -= in[i];
|
||||
}
|
||||
std::transform( m_pelComp.begin(),
|
||||
m_pelComp.end(),
|
||||
m_pelComp.begin(),
|
||||
[&op]( auto& p1 ) { return p1 * op; } );
|
||||
return *this;
|
||||
}
|
||||
|
||||
CalypPixel CalypPixel::operator*( const double& op )
|
||||
CalypPixel CalypPixel::operator+( const CalypPixel& in ) const
|
||||
{
|
||||
CalypPixel result;
|
||||
for( int i = 0; i < MAX_NUMBER_COMPONENTS; i++ )
|
||||
{
|
||||
result[i] = d->PelComp[i] * op;
|
||||
}
|
||||
assert( in.colorSpace() == m_colorSpace );
|
||||
const auto& other_comp = in.components();
|
||||
CalypPixel result{ m_colorSpace };
|
||||
std::transform( other_comp.begin(),
|
||||
other_comp.end(),
|
||||
m_pelComp.begin(),
|
||||
result.components().begin(),
|
||||
[]( auto& p1, auto& p2 ) { return p1 + p2; } );
|
||||
return result;
|
||||
}
|
||||
|
||||
CalypPixel CalypPixel::convertPixel( CalypColorSpace eOutputSpace )
|
||||
CalypPixel CalypPixel::operator-( const CalypPixel& in ) const
|
||||
{
|
||||
if( d->iColorSpace == eOutputSpace )
|
||||
assert( in.colorSpace() == m_colorSpace );
|
||||
const auto& other_comp = in.components();
|
||||
CalypPixel result{ m_colorSpace };
|
||||
std::transform( other_comp.begin(),
|
||||
other_comp.end(),
|
||||
m_pelComp.begin(),
|
||||
result.components().begin(),
|
||||
[]( auto& p1, auto& p2 ) { return p1 - p2; } );
|
||||
return result;
|
||||
}
|
||||
|
||||
CalypPixel CalypPixel::operator*( const double& op ) const
|
||||
{
|
||||
CalypPixel result{ m_colorSpace };
|
||||
auto& comp = result.components();
|
||||
std::transform( comp.begin(),
|
||||
comp.end(),
|
||||
comp.begin(),
|
||||
[&op]( auto& p1 ) { return p1 * op; } );
|
||||
return result;
|
||||
}
|
||||
|
||||
CalypPixel CalypPixel::convertPixel( CalypColorSpace eOutputSpace ) const
|
||||
{
|
||||
if( m_colorSpace == eOutputSpace )
|
||||
return *this;
|
||||
|
||||
int outA = 0;
|
||||
int outB = 0;
|
||||
int outC = 0;
|
||||
int outD = 0;
|
||||
if( d->iColorSpace == CLP_COLOR_YUV )
|
||||
if( m_colorSpace == CLP_COLOR_YUV )
|
||||
{
|
||||
switch( eOutputSpace )
|
||||
{
|
||||
case CLP_COLOR_GRAY:
|
||||
outA = d->PelComp[0];
|
||||
outA = m_pelComp[0];
|
||||
break;
|
||||
case CLP_COLOR_RGBA:
|
||||
outD = 255;
|
||||
outD = kMaxPixelValue;
|
||||
case CLP_COLOR_RGB:
|
||||
yuvToRgb( d->PelComp[0], d->PelComp[1], d->PelComp[2], outA, outB, outC );
|
||||
yuvToRgb( m_pelComp[0], m_pelComp[1], m_pelComp[2], outA, outB, outC );
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
if( d->iColorSpace == CLP_COLOR_RGB )
|
||||
if( m_colorSpace == CLP_COLOR_RGB )
|
||||
{
|
||||
switch( eOutputSpace )
|
||||
{
|
||||
case CLP_COLOR_GRAY:
|
||||
rgbToYuv( d->PelComp[0], d->PelComp[1], d->PelComp[2], outA, outB, outC );
|
||||
rgbToYuv( m_pelComp[0], m_pelComp[1], m_pelComp[2], outA, outB, outC );
|
||||
case CLP_COLOR_YUV:
|
||||
rgbToYuv( d->PelComp[0], d->PelComp[1], d->PelComp[2], outA, outB, outC );
|
||||
rgbToYuv( m_pelComp[0], m_pelComp[1], m_pelComp[2], outA, outB, outC );
|
||||
break;
|
||||
case CLP_COLOR_RGBA:
|
||||
outD = 255;
|
||||
outD = kMaxPixelValue;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
|
||||
+50
-44
@@ -48,6 +48,8 @@
|
||||
constexpr auto kDefaultBitsPerPixel = 8;
|
||||
constexpr auto kDefaultFrameRate = 30;
|
||||
|
||||
auto find_stream_handler( std::string strFilename, bool bRead ) -> CalypStreamFormat::CreateStreamHandlerFn;
|
||||
|
||||
std::vector<CalypStreamFormat> CalypStream::supportedReadFormats()
|
||||
{
|
||||
INI_REGIST_CALYP_SUPPORTED_FMT;
|
||||
@@ -166,8 +168,7 @@ public:
|
||||
bool isInit;
|
||||
bool isInput;
|
||||
|
||||
CalypStreamHandlerIf* handler;
|
||||
CreateStreamHandlerFn pfctCreateHandler;
|
||||
std::unique_ptr<CalypStreamHandlerIf> handler;
|
||||
|
||||
std::shared_ptr<CalypStreamFrameBuffer> frameBuffer;
|
||||
std::deque<std::shared_ptr<CalypFrame>> frameFifo;
|
||||
@@ -187,7 +188,6 @@ public:
|
||||
CalypStreamPrivate()
|
||||
{
|
||||
handler = nullptr;
|
||||
pfctCreateHandler = nullptr;
|
||||
isInput = true;
|
||||
isInit = false;
|
||||
bLoadAll = false;
|
||||
@@ -205,7 +205,6 @@ public:
|
||||
if( handler )
|
||||
{
|
||||
handler->closeHandler();
|
||||
handler->Delete();
|
||||
}
|
||||
|
||||
bLoadAll = false;
|
||||
@@ -253,43 +252,6 @@ std::vector<std::string> CalypStreamFormat::getExts()
|
||||
return arrayExt;
|
||||
}
|
||||
|
||||
CreateStreamHandlerFn CalypStream::findStreamHandler( std::string strFilename, bool bRead )
|
||||
{
|
||||
std::string currExt = strFilename.substr( strFilename.find_last_of( "." ) + 1 );
|
||||
currExt = clpLowercase( currExt );
|
||||
|
||||
std::vector<CalypStreamFormat> supportedFmts;
|
||||
if( bRead )
|
||||
{
|
||||
supportedFmts = CalypStream::supportedReadFormats();
|
||||
}
|
||||
else
|
||||
{
|
||||
supportedFmts = CalypStream::supportedWriteFormats();
|
||||
}
|
||||
for( unsigned int i = 0; i < supportedFmts.size(); i++ )
|
||||
{
|
||||
std::vector<std::string> arrayExt = supportedFmts[i].getExts();
|
||||
for( std::vector<std::string>::iterator e = arrayExt.begin(); e != arrayExt.end(); ++e )
|
||||
{
|
||||
if( currExt != "" && currExt == *e )
|
||||
{
|
||||
return supportedFmts[i].formatFct;
|
||||
}
|
||||
else if( strFilename.find( *e ) != std::string::npos )
|
||||
{
|
||||
return supportedFmts[i].formatFct;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef USE_FFMPEG
|
||||
return &StreamHandlerLibav::Create;
|
||||
#else
|
||||
return &StreamHandlerRaw::Create;
|
||||
#endif
|
||||
}
|
||||
|
||||
CalypStream::CalypStream()
|
||||
: d{ std::make_unique<CalypStreamPrivate>() }
|
||||
{
|
||||
@@ -348,13 +310,13 @@ bool CalypStream::open( std::string filename, unsigned int width, unsigned int h
|
||||
d->isInit = false;
|
||||
d->isInput = bInput;
|
||||
|
||||
d->pfctCreateHandler = CalypStream::findStreamHandler( filename, d->isInput );
|
||||
if( !d->pfctCreateHandler )
|
||||
auto createHandlerFct = find_stream_handler( filename, d->isInput );
|
||||
if( !createHandlerFct )
|
||||
{
|
||||
throw CalypFailure( "CalypStream", "Invalid handler" );
|
||||
}
|
||||
|
||||
d->handler = d->pfctCreateHandler();
|
||||
d->handler = createHandlerFct();
|
||||
|
||||
if( !d->handler )
|
||||
{
|
||||
@@ -434,6 +396,13 @@ bool CalypStream::open( std::string filename, unsigned int width, unsigned int h
|
||||
return d->isInit;
|
||||
}
|
||||
|
||||
bool CalypStream::supportsFormating()
|
||||
{
|
||||
if( d->handler != nullptr )
|
||||
return false;
|
||||
return d->handler->m_bSupportsFormat;
|
||||
}
|
||||
|
||||
bool CalypStream::reload()
|
||||
{
|
||||
d->frameFifo.clear();
|
||||
@@ -695,3 +664,40 @@ bool CalypStream::seekInput( unsigned long new_frame_num )
|
||||
d->readNextFrame();
|
||||
return true;
|
||||
}
|
||||
|
||||
auto find_stream_handler( std::string strFilename, bool bRead ) -> CalypStreamFormat::CreateStreamHandlerFn
|
||||
{
|
||||
std::string currExt = strFilename.substr( strFilename.find_last_of( "." ) + 1 );
|
||||
currExt = clpLowercase( currExt );
|
||||
|
||||
std::vector<CalypStreamFormat> supportedFmts;
|
||||
if( bRead )
|
||||
{
|
||||
supportedFmts = CalypStream::supportedReadFormats();
|
||||
}
|
||||
else
|
||||
{
|
||||
supportedFmts = CalypStream::supportedWriteFormats();
|
||||
}
|
||||
for( unsigned int i = 0; i < supportedFmts.size(); i++ )
|
||||
{
|
||||
std::vector<std::string> arrayExt = supportedFmts[i].getExts();
|
||||
for( std::vector<std::string>::iterator e = arrayExt.begin(); e != arrayExt.end(); ++e )
|
||||
{
|
||||
if( currExt != "" && currExt == *e )
|
||||
{
|
||||
return supportedFmts[i].formatFct;
|
||||
}
|
||||
else if( strFilename.find( *e ) != std::string::npos )
|
||||
{
|
||||
return supportedFmts[i].formatFct;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef USE_FFMPEG
|
||||
return &StreamHandlerLibav::Create;
|
||||
#else
|
||||
return &StreamHandlerRaw::Create;
|
||||
#endif
|
||||
}
|
||||
+21
-14
@@ -34,17 +34,6 @@
|
||||
|
||||
class CalypStreamHandlerIf;
|
||||
|
||||
typedef CalypStreamHandlerIf* ( *CreateStreamHandlerFn )( void );
|
||||
|
||||
struct CalypStreamFormat
|
||||
{
|
||||
std::string formatName;
|
||||
std::string formatExt;
|
||||
std::vector<std::string> getExts();
|
||||
std::string formatPattern;
|
||||
CreateStreamHandlerFn formatFct;
|
||||
};
|
||||
|
||||
struct CalypStandardResolution
|
||||
{
|
||||
std::string shortName;
|
||||
@@ -52,6 +41,26 @@ struct CalypStandardResolution
|
||||
unsigned int uiHeight;
|
||||
};
|
||||
|
||||
/**
|
||||
* \class CalypStreamFormat
|
||||
* \ingroup CalypLibGrp CalypStreamGrp
|
||||
* \brief Stream format handling class
|
||||
*/
|
||||
|
||||
class CalypStreamFormat
|
||||
{
|
||||
public:
|
||||
using CreateStreamHandlerFn = auto ( * )( void ) -> std::unique_ptr<CalypStreamHandlerIf>;
|
||||
|
||||
CalypStreamFormat() = default;
|
||||
std::vector<std::string> getExts();
|
||||
|
||||
std::string formatName;
|
||||
std::string formatExt;
|
||||
std::string formatPattern;
|
||||
CreateStreamHandlerFn formatFct;
|
||||
};
|
||||
|
||||
/**
|
||||
* \class CalypStream
|
||||
* \ingroup CalypLibGrp CalypStreamGrp
|
||||
@@ -62,9 +71,6 @@ class CalypStream
|
||||
public:
|
||||
static std::vector<CalypStreamFormat> supportedReadFormats();
|
||||
static std::vector<CalypStreamFormat> supportedWriteFormats();
|
||||
|
||||
static CreateStreamHandlerFn findStreamHandler( std::string strFilename, bool bRead );
|
||||
|
||||
static std::vector<CalypStandardResolution> stdResolutionSizes();
|
||||
|
||||
CalypStream();
|
||||
@@ -84,6 +90,7 @@ public:
|
||||
bool open( std::string filename, unsigned int width, unsigned int height, int input_format, unsigned int bitsPel, int endianness, bool hasNegative, unsigned int frame_rate,
|
||||
bool bInput );
|
||||
|
||||
bool supportsFormating();
|
||||
bool reload();
|
||||
|
||||
bool isNative() const;
|
||||
|
||||
+33
-37
@@ -51,12 +51,11 @@
|
||||
formatsList.insert( formatsList.end(), new_fmts.begin(), new_fmts.end() ); \
|
||||
}
|
||||
|
||||
#define REGISTER_CALYP_STREAM_HANDLER( X ) \
|
||||
public: \
|
||||
static CalypStreamHandlerIf* Create() { return new X(); } \
|
||||
void Delete() { delete this; } \
|
||||
static std::vector<CalypStreamFormat> supportedReadFormats(); \
|
||||
static std::vector<CalypStreamFormat> supportedWriteFormats(); \
|
||||
#define REGISTER_CALYP_STREAM_HANDLER( X ) \
|
||||
public: \
|
||||
static std::unique_ptr<CalypStreamHandlerIf> Create() { return std::make_unique<X>(); } \
|
||||
static std::vector<CalypStreamFormat> supportedReadFormats(); \
|
||||
static std::vector<CalypStreamFormat> supportedWriteFormats(); \
|
||||
// static int checkforSupportedFile( String, bool );
|
||||
|
||||
/**
|
||||
@@ -69,23 +68,7 @@ class CalypStreamHandlerIf
|
||||
friend class CalypStream;
|
||||
|
||||
public:
|
||||
CalypStreamHandlerIf()
|
||||
: m_bIsInput( true )
|
||||
, m_bNative( true )
|
||||
, m_uiWidth( 0 )
|
||||
, m_uiHeight( 0 )
|
||||
, m_iPixelFormat( -1 )
|
||||
, m_uiBitsPerPixel( 8 )
|
||||
, m_iEndianness( -1 )
|
||||
, m_dFrameRate( 30 )
|
||||
, m_uiCurrFrameFileIdx( 0 )
|
||||
, m_uiTotalNumberFrames( 0 )
|
||||
, m_uiNBytesPerFrame( 0 )
|
||||
, m_isEOF( false )
|
||||
{
|
||||
}
|
||||
virtual ~CalypStreamHandlerIf() {}
|
||||
virtual void Delete() = 0;
|
||||
|
||||
virtual bool openHandler( std::string strFilename, bool bInput ) = 0;
|
||||
virtual void closeHandler() = 0;
|
||||
@@ -96,28 +79,41 @@ public:
|
||||
|
||||
virtual void calculateFrameNumber(){};
|
||||
|
||||
std::string getFormatName() { return m_strFormatName; }
|
||||
std::string getCodecName() { return m_strCodecName; }
|
||||
std::string getFormatName()
|
||||
{
|
||||
return m_strFormatName;
|
||||
}
|
||||
std::string getCodecName()
|
||||
{
|
||||
return m_strCodecName;
|
||||
}
|
||||
|
||||
protected:
|
||||
const char* m_pchHandlerName;
|
||||
CalypStreamHandlerIf() = default;
|
||||
CalypStreamHandlerIf( bool supportsFormats )
|
||||
: m_bSupportsFormat{ supportsFormats }
|
||||
{
|
||||
}
|
||||
|
||||
const char* m_pchHandlerName{ "" };
|
||||
const bool m_bSupportsFormat{ false };
|
||||
|
||||
std::string m_strFormatName;
|
||||
std::string m_strCodecName;
|
||||
bool m_bIsInput;
|
||||
bool m_bNative;
|
||||
bool m_bIsInput{ true };
|
||||
bool m_bNative{ true };
|
||||
std::string m_cFilename;
|
||||
unsigned int m_uiWidth;
|
||||
unsigned int m_uiHeight;
|
||||
int m_iPixelFormat;
|
||||
unsigned int m_uiBitsPerPixel;
|
||||
int m_iEndianness;
|
||||
double m_dFrameRate;
|
||||
std::uint64_t m_uiCurrFrameFileIdx;
|
||||
std::uint64_t m_uiTotalNumberFrames;
|
||||
unsigned int m_uiWidth{ 0 };
|
||||
unsigned int m_uiHeight{ 0 };
|
||||
int m_iPixelFormat{ -1 };
|
||||
unsigned int m_uiBitsPerPixel{ 8 };
|
||||
int m_iEndianness{ CLP_INVALID_ENDIANESS };
|
||||
double m_dFrameRate{ 30 };
|
||||
std::uint64_t m_uiCurrFrameFileIdx{ 0 };
|
||||
std::uint64_t m_uiTotalNumberFrames{ 0 };
|
||||
std::vector<ClpByte> m_pStreamBuffer;
|
||||
std::uint64_t m_uiNBytesPerFrame;
|
||||
bool m_isEOF;
|
||||
std::uint64_t m_uiNBytesPerFrame{ 0 };
|
||||
bool m_isEOF{ false };
|
||||
};
|
||||
|
||||
#endif // __CALYPSTREAMHANDLERIF_H__
|
||||
@@ -44,6 +44,12 @@ std::vector<CalypStreamFormat> StreamHandlerRaw::supportedWriteFormats()
|
||||
END_REGIST_CALYP_SUPPORTED_FMT;
|
||||
}
|
||||
|
||||
StreamHandlerRaw::StreamHandlerRaw()
|
||||
: CalypStreamHandlerIf{ true }
|
||||
{
|
||||
m_pchHandlerName = "RawVideo";
|
||||
}
|
||||
|
||||
bool StreamHandlerRaw::openHandler( std::string strFilename, bool bInput )
|
||||
{
|
||||
m_bIsInput = bInput;
|
||||
|
||||
@@ -40,7 +40,7 @@ private:
|
||||
FILE* m_pFile; /**< The input file pointer >*/
|
||||
|
||||
public:
|
||||
StreamHandlerRaw() { m_pchHandlerName = "RawVideo"; }
|
||||
StreamHandlerRaw();
|
||||
~StreamHandlerRaw() {}
|
||||
bool openHandler( std::string strFilename, bool bInput );
|
||||
void closeHandler();
|
||||
|
||||
@@ -32,7 +32,7 @@ DisparityStereoSGBM::DisparityStereoSGBM()
|
||||
m_iModuleType = CLP_FRAME_PROCESSING_MODULE;
|
||||
m_pchModuleCategory = "Stereo";
|
||||
m_pchModuleName = "Disparity-SGBM";
|
||||
m_pchModuleName = "SGBM based disparity";
|
||||
m_pchModuleLongName = "SGBM based disparity";
|
||||
m_pchModuleTooltip = "Measure the disparity between two images using the "
|
||||
"Stereo SGBM method (OpenCV)";
|
||||
m_uiNumberOfFrames = 2;
|
||||
|
||||
@@ -36,6 +36,7 @@ SaliencyBasedFiltering::SaliencyBasedFiltering()
|
||||
m_iModuleType = CLP_FRAME_PROCESSING_MODULE;
|
||||
m_pchModuleCategory = "Quality";
|
||||
m_pchModuleName = "SaliencyBasedFiltering";
|
||||
m_pchModuleLongName = "Saliency Based Filtering";
|
||||
m_pchModuleTooltip = "Image filter based on a map";
|
||||
m_uiModuleRequirements = CLP_MODULE_REQUIRES_NOTHING;
|
||||
m_uiNumberOfFrames = 2;
|
||||
|
||||
Reference in new issue
Block a user