Disable DEBUG_ASSERT

Add type safe flags
Replace MACRO with templates (WIP)

.appveyor.yml

@@ -1,45 +1,46 @@
-image: Visual Studio 2017
+image: Visual Studio 2019
 configuration: Release
 platform:
   - x64
 environment:
   access_token:
-    secure: WAV5LfCSAtwE1JuZh4HrDlxOOClimLoslYAJlf5KRgc3f7WIkX591PrSSua/Zo2C
-    
+    secure: SMxOWNKN0RkPvICWhIet2FJM5g/zx5mguM/XAPjM2OrC3U2/LAqcBZw0veS9peS4
+
 clone_folder: C:\Projects\calyp
 
 init:
   - ps: Add-Content "$HOME\.git-credentials" "https://$($env:access_token):x-oauth-basic@github.com`n"
   - git config --global credential.helper store
   - git config --global user.email "jfmcarreira@gmail.com"
-  - git config --global user.name "AppVeyor" 
+  - git config --global user.name "AppVeyor"
   - ps: iex ((new-object net.webclient).DownloadString('https://raw.githubusercontent.com/appveyor/ci/master/scripts/enable-rdp.ps1'))
-  
+
 install:
-  - '"C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\VC\Auxiliary\Build\vcvarsall.bat" x64'
-  #- '"C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\vcvarsall.bat" amd64'
+  - '"C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Auxiliary\Build\vcvarsall.bat" x64'
   - choco install nsis
   - choco install opencv
   - 'C:\Tools\opencv\build\setup_vars_opencv4.cmd'
   - cd C:\Projects
-  - ps: Start-FileDownload 'https://ffmpeg.zeranoe.com/builds/win64/dev/ffmpeg-4.1.1-win64-dev.zip'
-  - 7z x ffmpeg-4.1.1-win64-dev.zip -y
+  - ps: Start-FileDownload 'https://www.gyan.dev/ffmpeg/builds/ffmpeg-release-full-shared.7z' ffmpeg.7z
+  - 7z x ffmpeg.7z -y -offmpeg
   - git clone https://github.com/pixlra/calyp-deployment.git
-  
-  
+  - CALL calyp-deployment/scripts/extract_ffmpeg.bat
+  - ps: rm C:\Projects\ffmpeg_libraries\bin\*.exe
+
+
 build_script:
   - mv C:\Projects\calyp C:\Projects\calyp-deployment\cmake-helper\
   - mkdir C:\Projects\calyp-build
   - cd C:\Projects\calyp-build
-  - cmake -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=install -DUSE_DYNLOAD=OFF -DOpenCV_DIR="C:/Tools/opencv/build" -DOpenCV_DLL_DIR="C:/Tools/opencv/build/x64/vc15/bin" -DOpenCV_INSTALL_MODULES="world" -DQT_DIR="C:\Qt\latest\msvc2017_64" -DQt5_DIR="C:\Qt\latest\msvc2017_64\lib\cmake\Qt5" -DUSE_QTDBUS=OFF -DAVFORMAT_LIBRARIES=C:/Projects/ffmpeg-4.1.1-win64-dev/lib/avformat.lib -DAVFORMAT_INCLUDE_DIRS=C:/Projects/ffmpeg-4.1.1-win64-dev/include -DAVCODEC_LIBRARIES=C:/Projects/ffmpeg-4.1.1-win64-dev/lib/avcodec.lib -DAVCODEC_INCLUDE_DIRS=C:/Projects/ffmpeg-4.1.1-win64-dev/include   -DAVUTIL_LIBRARIES=C:/Projects/ffmpeg-4.1.1-win64-dev/lib/avutil.lib -DAVUTIL_INCLUDE_DIRS=C:/Projects/ffmpeg-4.1.1-win64-dev/include -DSWSCALE_LIBRARIES=C:/Projects/ffmpeg-4.1.1-win64-dev/lib/swscale.lib -DSWSCALE_INCLUDE_DIRS=C:/Projects/ffmpeg-4.1.1-win64-dev/include -G "Visual Studio 15 2017 Win64" C:\Projects\calyp-deployment\cmake-helper
-  - cmake --build . --target ALL_BUILD -- /p:Configuration=Release > log_build
-  - cmake --build . --target INSTALL -- /p:Configuration=Release > log_install
-  - cmake --build . --target PACKAGE -- /p:Configuration=Release > log_pkg
+  - cmake -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=install -DUSE_DYNLOAD=OFF -DOpenCV_DIR="C:/Tools/opencv/build" -DOpenCV_DLL_DIR="C:/Tools/opencv/build/x64/vc15/bin" -DOpenCV_INSTALL_MODULES="world" -DQT_DIR="C:\Qt\latest\msvc2019_64" -DQt5_DIR="C:\Qt\latest\msvc2019_64\lib\cmake\Qt5" -DUSE_QTDBUS=OFF -DAVFORMAT_LIBRARIES=C:/Projects/ffmpeg_libraries/lib/avformat.lib -DAVFORMAT_INCLUDE_DIRS=C:/Projects/ffmpeg_libraries/include -DAVCODEC_LIBRARIES=C:/Projects/ffmpeg_libraries/lib/avcodec.lib -DAVCODEC_INCLUDE_DIRS=C:/Projects/ffmpeg_libraries/include -DAVUTIL_LIBRARIES=C:/Projects/ffmpeg_libraries/lib/avutil.lib -DAVUTIL_INCLUDE_DIRS=C:/Projects/ffmpeg_libraries/include -DSWSCALE_LIBRARIES=C:/Projects/ffmpeg_libraries/lib/swscale.lib -DSWSCALE_INCLUDE_DIRS=C:/Projects/ffmpeg_libraries/include -DAVDEVICE_LIBRARIES=C:/Projects/ffmpeg_libraries/lib/avdevice.lib -DAVDEVICE_INCLUDE_DIRS=C:/Projects/ffmpeg_libraries/include -DPOSTPROC_LIBRARIES=C:/Projects/ffmpeg_libraries/lib/postproc.lib -DPOSTPROC_INCLUDE_DIRS=C:/Projects/ffmpeg_libraries/include -DFFMPEG_DIR=C:\Projects\ffmpeg_libraries -DSWRESAMPLE_LIBRARIES=C:/Projects/ffmpeg_libraries/lib/swresample.lib -DSWRESAMPLE_INCLUDE_DIRS=C:/Projects/ffmpeg_libraries/include -G "Visual Studio 16 2019" -A x64 C:\Projects\calyp-deployment\cmake-helper
+  - cmake --build . --target ALL_BUILD -- /p:Configuration=Release
+  - cmake --build . --target INSTALL -- /p:Configuration=Release
+  - cmake --build . --target PACKAGE -- /p:Configuration=Release
 
 after_build:
   - IF "%APPVEYOR_REPO_BRANCH%" == "master" (CALL ..\calyp-deployment\scripts\deploy-to-github.bat)
 
-  
+
 on_failure:
  - ps: $blockRdp = $true; iex ((new-object net.webclient).DownloadString('https://raw.githubusercontent.com/appveyor/ci/master/scripts/enable-rdp.ps1'))
 

.clang-tidy

@@ -0,0 +1,45 @@
+---
+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, -cppcoreguidelines-owning-memory, -cppcoreguidelines-pro-bounds-constant-array-index, -readability-magic-numbers,-cppcoreguidelines-avoid-magic-numbers'
+WarningsAsErrors: ''
+HeaderFilterRegex: ''
+AnalyzeTemporaryDtors: false
+FormatStyle:     none
+CheckOptions:
+  - key:             llvm-else-after-return.WarnOnConditionVariables
+    value:           '0'
+  - key:             modernize-loop-convert.MinConfidence
+    value:           reasonable
+  - key:             modernize-replace-auto-ptr.IncludeStyle
+    value:           llvm
+  - key:             cert-str34-c.DiagnoseSignedUnsignedCharComparisons
+    value:           '0'
+  - key:             google-readability-namespace-comments.ShortNamespaceLines
+    value:           '10'
+  - key:             cert-oop54-cpp.WarnOnlyIfThisHasSuspiciousField
+    value:           '0'
+  - key:             cppcoreguidelines-non-private-member-variables-in-classes.IgnoreClassesWithAllMemberVariablesBeingPublic
+    value:           '1'
+  - key:             cert-dcl16-c.NewSuffixes
+    value:           'L;LL;LU;LLU'
+  - key:             google-readability-braces-around-statements.ShortStatementLines
+    value:           '1'
+  - key:             modernize-pass-by-value.IncludeStyle
+    value:           llvm
+  - key:             google-readability-namespace-comments.SpacesBeforeComments
+    value:           '2'
+  - key:             modernize-loop-convert.MaxCopySize
+    value:           '16'
+  - key:             cppcoreguidelines-explicit-virtual-functions.IgnoreDestructors
+    value:           '1'
+  - key:             modernize-use-nullptr.NullMacros
+    value:           'NULL'
+  - key:             llvm-qualified-auto.AddConstToQualified
+    value:           '0'
+  - key:             modernize-loop-convert.NamingStyle
+    value:           CamelCase
+  - key:             llvm-else-after-return.WarnOnUnfixable
+    value:           '0'
+  - key:             google-readability-function-size.StatementThreshold
+    value:           '800'
+  - key:             readability-magic-numbers.IgnorePowersOf2IntegerValues
+    value:           '1'

.cmake-format.py

@@ -0,0 +1,117 @@
+# ----------------------------------
+# Options affecting listfile parsing
+# ----------------------------------
+with section("parse"):
+
+  # Specify structure for custom cmake functions
+  additional_commands = { 'foo': { 'flags': ['BAR', 'BAZ'],
+             'kwargs': {'DEPENDS': '*', 'HEADERS': '*', 'SOURCES': '*'}}}
+
+  ## Override configurations per-command where available
+  #override_spec = {}
+
+  # Specify variable tags.
+  vartags = []
+
+  # Specify property tags.
+  proptags = []
+
+# -----------------------------
+# Options affecting formatting.
+# -----------------------------
+with section("format"):
+
+  # How wide to allow formatted cmake files
+  line_width = 150
+
+  # How many spaces to tab for indent
+  tab_size = 2
+
+  # If an argument group contains more than this many sub-groups (parg or kwarg
+  # groups) then force it to a vertical layout.
+  max_subgroups_hwrap = 2
+
+  # If a positional argument group contains more than this many arguments, then
+  # force it to a vertical layout.
+  max_pargs_hwrap = 6
+
+  dangle_parens = True
+
+  # Format command names consistently as 'lower' or 'upper' case
+  command_case = 'upper'
+
+  # Format keywords consistently as 'lower' or 'upper' case
+  keyword_case = 'upper'
+
+
+# ----------------------------
+# Options affecting the linter
+# ----------------------------
+with section("lint"):
+
+  # a list of lint codes to disable
+  disabled_codes = ["C0103"]
+
+  # regular expression pattern describing valid function names
+  function_pattern = '[0-9a-z_]+'
+
+  # regular expression pattern describing valid macro names
+  macro_pattern = '[0-9A-Z_]+'
+
+  # regular expression pattern describing valid names for variables with global
+  # (cache) scope
+  global_var_pattern = '[A-Z][0-9A-Z_]+'
+
+  # regular expression pattern describing valid names for variables with global
+  # scope (but internal semantic)
+  internal_var_pattern = '_[A-Z][0-9A-Z_]+'
+
+  # regular expression pattern describing valid names for variables with local
+  # scope
+  local_var_pattern = '[a-z][a-z0-9_]+'
+
+  # regular expression pattern describing valid names for privatedirectory
+  # variables
+  private_var_pattern = '_[0-9a-z_]+'
+
+  # regular expression pattern describing valid names for public directory
+  # variables
+  public_var_pattern = '[A-Z][0-9A-Z_]+'
+
+  # regular expression pattern describing valid names for function/macro
+  # arguments and loop variables.
+  argument_var_pattern = '[a-z][a-z0-9_]+'
+
+  # regular expression pattern describing valid names for keywords used in
+  # functions or macros
+  keyword_pattern = '[A-Z][0-9A-Z_]+'
+
+  # In the heuristic for C0201, how many conditionals to match within a loop in
+  # before considering the loop a parser.
+  max_conditionals_custom_parser = 2
+
+  # Require at least this many newlines between statements
+  min_statement_spacing = 1
+
+  # Require no more than this many newlines between statements
+  max_statement_spacing = 2
+  max_returns = 6
+  max_branches = 12
+  max_arguments = 5
+  max_localvars = 15
+  max_statements = 50
+
+# -------------------------------
+# Options affecting file encoding
+# -------------------------------
+with section("encode"):
+
+  # If true, emit the unicode byte-order mark (BOM) at the start of the file
+  emit_byteorder_mark = False
+
+  # Specify the encoding of the input file. Defaults to utf-8
+  input_encoding = 'utf-8'
+
+  # Specify the encoding of the output file. Defaults to utf-8. Note that cmake
+  # only claims to support utf-8 so be careful when using anything else
+  output_encoding = 'utf-8'

.github/workflows/build.yml

@@ -0,0 +1,61 @@
+name: Build on Linux
+
+on:
+  push:
+    branches:
+      - master
+      - devel
+  pull_request:
+    branches: [ master ]
+
+env:
+  # Customize the CMake build type here (Release, Debug, RelWithDebInfo, etc.)
+  BUILD_TYPE: Release
+
+jobs:
+  check-build:
+    # The CMake configure and build commands are platform agnostic and should work equally
+    # well on Windows or Mac.  You can convert this to a matrix build if you need
+    # cross-platform coverage.
+    # See: https://docs.github.com/en/free-pro-team@latest/actions/learn-github-actions/managing-complex-workflows#using-a-build-matrix
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Install dependencies
+      run: sudo apt-get update &&  sudo apt-get install gcc-10 g++-10 cmake qtbase5-dev libavcodec-dev libavformat-dev libavutil-dev libopencv-dev libopencv-video-dev libopencv-contrib-dev
+
+    - uses: actions/checkout@v2
+
+    - name: Build with default options
+      # Configure CMake in a 'build' subdirectory. `CMAKE_BUILD_TYPE` is only required if you are using a single-configuration generator such as make.
+      # See https://cmake.org/cmake/help/latest/variable/CMAKE_BUILD_TYPE.html?highlight=cmake_build_type
+      run: cmake -B ${{github.workspace}}/build -D CMAKE_C_COMPILER=gcc-10 -D CMAKE_CXX_COMPILER=g++-10 -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} -DUSE_WERROR=ON; cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}}
+
+    - name: Build without threads
+      run: cmake -B ${{github.workspace}}/build -D CMAKE_C_COMPILER=gcc-10 -D CMAKE_CXX_COMPILER=g++-10 -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} -DUSE_WERROR=ON -DCALYP_MANAGED_RESOURCES=OFF -DCALYP_THREADED_MODULES=OFF; cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}}
+
+  check-tests:
+    runs-on: ubuntu-latest
+    steps:
+    - name: Install dependencies
+      run: sudo apt-get update &&  sudo apt-get install gcc-10 g++-10 cmake qtbase5-dev libavcodec-dev libavformat-dev libavutil-dev libopencv-dev libopencv-video-dev libopencv-contrib-dev
+
+    - uses: actions/checkout@v2
+
+    - name: Check out tests data
+      uses: actions/checkout@master
+      with:
+        repository: 'pixlra/calyp-testdata'
+        path: ${{github.workspace}}/tests_data
+
+    - name: Configure CMake
+      # Configure CMake in a 'build' subdirectory. `CMAKE_BUILD_TYPE` is only required if you are using a single-configuration generator such as make.
+      # See https://cmake.org/cmake/help/latest/variable/CMAKE_BUILD_TYPE.html?highlight=cmake_build_type
+      run: cmake -B ${{github.workspace}}/build -D CMAKE_C_COMPILER=gcc-10 -D CMAKE_CXX_COMPILER=g++-10 -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} -DBUILD_TESTS=ON -DCALYP_TEST_DATA_DIR=${{github.workspace}}/tests_data
+
+    - name: Build
+      # Build your program with the given configuration
+      run: cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}}
+
+    - name: CalypLib tests
+      run: cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}} -t test

.gitignore

@@ -1,9 +1,11 @@
 # Created by https://www.gitignore.io/api/c++,clion,linux
 # Edit at https://www.gitignore.io/?templates=c++,clion,linux
-
+deps/**
 ### C++ ###
 # Prerequisites
 *.d
+# Clang
+.cache/
 
 # Compiled Object files
 *.slo
@@ -74,6 +76,7 @@
 # CMake
 bin/
 build/
+build-*
 cmake-build-*/
 
 # Mongo Explorer plugin
@@ -132,4 +135,15 @@ fabric.properties
 # .nfs files are created when an open file is removed but is still being accessed
 .nfs*
 
-# End of https://www.gitignore.io/api/c++,clion,linux
+### vscode ###
+.vscode/*
+*.code-workspace
+
+# Documentation
+doc/
+
+# CLang
+compile_commands.json
+
+# Build dirs
+build*

.idea/calyp.iml

@@ -1,2 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<module classpath="CMake" type="CPP_MODULE" version="4" />

.idea/encodings.xml

@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="Encoding" addBOMForNewFiles="with NO BOM" />
-</project>

.idea/misc.xml

@@ -1,7 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="CMakeWorkspace" PROJECT_DIR="$PROJECT_DIR$" />
-  <component name="JavaScriptSettings">
-    <option name="languageLevel" value="ES6" />
-  </component>
-</project>

.idea/modules.xml

@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="ProjectModuleManager">
-    <modules>
-      <module fileurl="file://$PROJECT_DIR$/.idea/calyp.iml" filepath="$PROJECT_DIR$/.idea/calyp.iml" />
-    </modules>
-  </component>
-</project>

.idea/vcs.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="VcsDirectoryMappings">
-    <mapping directory="$PROJECT_DIR$" vcs="Git" />
-  </component>
-</project>

.pre-commit-config.yaml

@@ -0,0 +1,29 @@
+fail_fast: false
+
+repos:
+  - repo: https://github.com/cheshirekow/cmake-format-precommit
+    rev: v0.6.10
+    hooks:
+    - id: cmake-format
+    - id: cmake-lint
+
+  - repo: https://github.com/pocc/pre-commit-hooks
+    rev: v1.1.1
+    hooks:
+      - id: clang-format
+        args: [--style=file, -i]
+
+  - repo: local
+    hooks:
+    - id: cmake-configure
+      name: Cmake Configure
+      entry: cmake -B build
+      pass_filenames: false
+      language: system
+    - id: cmake-build
+      name: Cmake Build
+      entry: cmake --build build
+      pass_filenames: false
+      language: system
+
+

.travis.yml

@@ -1,7 +1,7 @@
 language: cpp
-dist: xenial
+dist: bionic
 before_install:
   - sudo apt-get -qq update
-  - sudo apt-get install build-essential cmake qtbase5-dev libavcodec-dev libavformat-dev libavutil-dev libopencv-dev libopencv-video-dev libopencv-contrib-dev
+  - sudo apt-get install build-essential cmake qtbase5-dev libavcodec-dev libavformat-dev libavutil-dev libopencv-dev libopencv-video-dev libopencv-contrib-dev libgtest-dev
 script:
   - mkdir -p build && cd build && cmake .. && make && cd ..

CMakeLists.txt

@@ -1,240 +1,325 @@
-###
-### CMakeLists for calyp
-###
+#
+# CMakeLists for calyp
+#
 
-cmake_minimum_required( VERSION 3.2.0 )
+CMAKE_MINIMUM_REQUIRED(VERSION 3.5.0)
 
-######################################################################################
+# ####################################################################################################################################################
+# Project Definition
+# ####################################################################################################################################################
+
+SET(PROJECT_NAME
+    "calyp"
+    CACHE INTERNAL "" FORCE
+)
+SET(PROJECT_LIBRARY
+    "Calyp"
+    CACHE INTERNAL "" FORCE
+)
+
+SET(CALYP_VERSION_MAJOR "2")
+SET(CALYP_VERSION_MINOR "1")
+SET(CALYP_VERSION_PATCH "0")
+SET(CALYP_VERSION
+    "${CALYP_VERSION_MAJOR}.${CALYP_VERSION_MINOR}.${CALYP_VERSION_PATCH}"
+    CACHE INTERNAL "" FORCE
+)
+
+PROJECT(
+  ${PROJECT_NAME}
+  VERSION ${CALYP_VERSION}
+  LANGUAGES "CXX"
+)
+
+# ####################################################################################################################################################
 # CMake  functions
-######################################################################################
-SET(CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake )
-INCLUDE( cmake/ModulesFct.cmake )
+# ####################################################################################################################################################
+SET(CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake)
+INCLUDE(cmake/ModulesFct.cmake)
 INCLUDE(FeatureSummary)
 INCLUDE(GNUInstallDirs)
 
-######################################################################################
-# Project Definition
-######################################################################################
-
-SET( PROJECT_NAME "calyp" CACHE INTERNAL "" FORCE )
-SET( PROJECT_LIBRARY "Calyp" CACHE INTERNAL "" FORCE )
-
-
-PROJECT( ${PROJECT_NAME} )
-SET( CALYP_VERSION_MAJOR "1" )
-SET( CALYP_VERSION_MINOR "1" )
-SET( CALYP_VERSION_PATCH "0" )
-SET( CALYP_VERSION "${CALYP_VERSION_MAJOR}.${CALYP_VERSION_MINOR}.${CALYP_VERSION_PATCH}" CACHE INTERNAL "" FORCE )
-
-######################################################################################
+# ####################################################################################################################################################
 # Variables
-######################################################################################
+# ####################################################################################################################################################
 
-OPTION( BUILD_APP               "Build GUI Application"                 ON  )
-OPTION( BUILD_TOOLS             "Build Command Line Application"        ON  )
-OPTION( BUILD_EXAMPLES          "Build Examples"                        OFF )
-OPTION( BUILD_DOC               "Build Documentation"                   OFF )
-OPTION( BUILD_TESTS             "Build Google Tests"                    OFF )
+OPTION(BUILD_APP "Build GUI Application" ON)
+OPTION(BUILD_TOOLS "Build Command Line Application" ON)
+OPTION(BUILD_EXAMPLES "Build Examples" OFF)
+OPTION(BUILD_DOC "Build Documentation" OFF)
+OPTION(BUILD_TESTS "Build Tests" OFF)
+OPTION(BUILD_WITH_SANITIZERS "Build with sanitizers" OFF)
+OPTION(BUILD_WITH_THREAD_SANITIZER "Build with thread sanitizer" OFF)
 
-OPTION( USE_FERVOR              "Add Fervor support"                    OFF )
+OPTION(USE_FERVOR "Add Fervor support" OFF)
 
-OPTION( USE_DYNLOAD             "Use dynamic load of modules"           ON  )
-OPTION( USE_SSE                 "Build with SSE support"                OFF )
-OPTION( USE_WERROR              "Warnings as errors"                    OFF )
-OPTION( USE_STATIC              "Use static libs"                       OFF )
+OPTION(USE_DYNLOAD "Use dynamic load of modules" ON)
+OPTION(USE_SSE "Build with SSE support" ON)
+OPTION(USE_WERROR "Warnings as errors" OFF)
+OPTION(USE_STATIC "Use static libs" OFF)
+OPTION(USE_IWYU "Use include what you use tool" OFF)
 
-
-######################################################################################
+# ####################################################################################################################################################
 # Release configuration
-######################################################################################
+# ####################################################################################################################################################
 
 # To be switched on when releasing.
 OPTION(RELEASE_BUILD "Remove Git revision from program version (use for stable releases)" ON)
 
 # Get current version.
-set(CALYP_VERSION_STRING "${CALYP_VERSION}")
-if(NOT RELEASE_BUILD AND EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/.git)
+SET(CALYP_VERSION_STRING "${CALYP_VERSION}")
+IF(NOT RELEASE_BUILD AND EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/.git)
   # Probably a Git workspace; determine the revision.
   FIND_PACKAGE(Git QUIET)
-  if(GIT_FOUND)
-    exec_program(${GIT_EXECUTABLE}
-      ${CMAKE_CURRENT_SOURCE_DIR}
+  IF(GIT_FOUND)
+    EXEC_PROGRAM(
+      ${GIT_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}
       ARGS "describe --tags"
       OUTPUT_VARIABLE CALYP_GIT_REVISION
       RETURN_VALUE TAG_RESULT
     )
     # git describe --tags failed; maybe the repository was checked with depth=1.
-    if(NOT ${TAG_RESULT} EQUAL 0)
-      exec_program(${GIT_EXECUTABLE}
-        ${CMAKE_CURRENT_SOURCE_DIR}
+    IF(NOT ${TAG_RESULT} EQUAL 0)
+      EXEC_PROGRAM(
+        ${GIT_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}
         ARGS "describe --always"
         OUTPUT_VARIABLE CALYP_GIT_REVISION
       )
-    endif()
-    message(STATUS "Calyp Git revision: ${CALYP_GIT_REVISION}")
-    set(CALYP_VERSION_STRING "${CALYP_VERSION} (rev. ${CALYP_GIT_REVISION})")
-  else()
-    message(STATUS "Calyp Git revision could not be determined")
-  endif()
-endif()
+    ENDIF()
+    MESSAGE(STATUS "Calyp Git revision: ${CALYP_GIT_REVISION}")
+    SET(CALYP_VERSION_STRING "${CALYP_VERSION} (rev. ${CALYP_GIT_REVISION})")
+  ELSE()
+    MESSAGE(STATUS "Calyp Git revision could not be determined")
+  ENDIF()
+ENDIF()
 
-SET(UPDATE_CHANNEL "stable" CACHE STRING "Update channel" )
+SET(UPDATE_CHANNEL
+    "stable"
+    CACHE STRING "Update channel"
+)
 # CONFIGURE_FILE( ${CMAKE_CURRENT_SOURCE_DIR}/CalypUpdate.xml.in ${CMAKE_CURRENT_BINARY_DIR}/CalypUpdate-${UPDATE_CHANNEL}.xml )
 
-
-######################################################################################
+# ####################################################################################################################################################
 # Dependencies
-######################################################################################
+# ####################################################################################################################################################
+INCLUDE(FetchContent)
 
-IF( BUILD_DOC )
+SET(FETCHCONTENT_BASE_DIR  "${CMAKE_BINARY_DIR}/deps")
+
+# Doxygen
+IF(BUILD_DOC)
   FIND_PACKAGE(Doxygen)
-  SET( BUILD_DOC ${Doxygen_FOUND} )
+  SET(BUILD_DOC ${Doxygen_FOUND})
 ENDIF()
-SET_PACKAGE_PROPERTIES(Doxygen PROPERTIES URL "http://www.doxygen.org/" DESCRIPTION "Doxygen" TYPE OPTIONAL)
+SET_PACKAGE_PROPERTIES(
+  Doxygen PROPERTIES
+  URL "http://www.doxygen.org/"
+  DESCRIPTION "Doxygen"
+  TYPE OPTIONAL
+)
 
+# Type safe
+FETCHCONTENT_DECLARE(
+  type_safe
+  GIT_REPOSITORY https://github.com/foonathan/type_safe
+  GIT_TAG v0.2.2
+  SOURCE_DIR "${CMAKE_BINARY_DIR}/deps/type_safe"
+)
 
-IF( BUILD_TESTS )
-  FIND_PACKAGE(GTest)
-  SET( BUILD_DOC ${GTEST_FOUND} )
-  IF( GTEST_FOUND )
-    ENABLE_TESTING()
-    INCLUDE_DIRECTORIES(${GTEST_INCLUDE_DIRS})
-  ENDIF()
+SET_PACKAGE_PROPERTIES(
+  type_safe PROPERTIES
+  URL "https://github.com/foonathan/type_safe"
+  DESCRIPTION "Zero overhead abstractions that use the C++ type system to prevent bugs."
+  TYPE REQUIRED
+)
+FETCHCONTENT_MAKEAVAILABLE(type_safe)
+INCLUDE_DIRECTORIES(${CMAKE_BINARY_DIR}/deps/type_safe/include/ ${CMAKE_BINARY_DIR}/deps/type_safe/external/debug_assert/)
+ADD_DEFINITIONS(-DTYPE_SAFE_ENABLE_ASSERTIONS=0 -DTYPE_SAFE_ENABLE_PRECONDITION_CHECKS=0 -DDEBUG_ASSERT_DISABLE)
+
+# Catch2 and Google Tests
+IF(BUILD_TESTS)
+  FETCHCONTENT_DECLARE(googletest URL https://github.com/google/googletest/archive/609281088cfefc76f9d0ce82e1ff6c30cc3591e5.zip)
+  # For Windows: Prevent overriding the parent project's compiler/linker settings
+  SET(gtest_force_shared_crt
+      ON
+      CACHE BOOL "" FORCE
+  )
+  FETCHCONTENT_DECLARE(
+    Catch2
+    GIT_REPOSITORY https://github.com/catchorg/Catch2.git
+    GIT_TAG v2.13.1
+  )
+
+  SET_PACKAGE_PROPERTIES(
+    googletest PROPERTIES
+    URL "https://github.com/google/googletest"
+    DESCRIPTION "Google unit tests"
+    TYPE OPTIONAL
+  )
+
+  SET_PACKAGE_PROPERTIES(
+    Catch2 PROPERTIES
+    URL "https://github.com/catchorg/Catch2"
+    DESCRIPTION "Catch2 unit tests"
+    TYPE OPTIONAL
+  )
+  FETCHCONTENT_MAKEAVAILABLE(googletest Catch2)
+
+  INCLUDE(${CMAKE_BINARY_DIR}/deps/catch2-src/contrib/Catch.cmake)
+  INCLUDE(CTest)
+  ENABLE_TESTING()
+
+  SET(CALYP_TEST_DATA_DIR
+      "CALYP_TEST_DATA_DIR"
+      CACHE PATH "Location of video information for testing"
+  )
 ENDIF()
 
-OPTION( USE_OPENCV "Add OpenCV support" ON )
-IF( USE_OPENCV )
 
-  FIND_PACKAGE( OpenCV COMPONENTS core highgui imgproc video )
-  IF( ${OpenCV_FOUND} )
-    SET(USE_OPENCV TRUE )
-    LIST(APPEND OPENCV_MODULES core highgui imgproc video )
-    FIND_PACKAGE( OpenCV COMPONENTS videoio photo )
-    IF( ${OPENCV_VIDEOIO_FOUND} )
-      LIST(APPEND OPENCV_MODULES videoio )
+# OpenCV
+OPTION(USE_OPENCV "Add OpenCV support" ON)
+IF(USE_OPENCV)
+
+  FIND_PACKAGE(OpenCV COMPONENTS core highgui imgproc video)
+  IF(${OpenCV_FOUND})
+    SET(USE_OPENCV TRUE)
+    LIST(APPEND OPENCV_MODULES core highgui imgproc video)
+    FIND_PACKAGE(OpenCV COMPONENTS videoio photo)
+    IF(${OPENCV_VIDEOIO_FOUND})
+      LIST(APPEND OPENCV_MODULES videoio)
     ENDIF()
-    IF( ${OPENCV_PHOTO_FOUND} )
-      LIST(APPEND OPENCV_MODULES photo )
+    IF(${OPENCV_PHOTO_FOUND})
+      LIST(APPEND OPENCV_MODULES photo)
     ENDIF()
   ELSE()
-    SET(USE_OPENCV FALSE )
+    SET(USE_OPENCV FALSE)
   ENDIF()
 ENDIF()
-SET_PACKAGE_PROPERTIES(OpenCV PROPERTIES URL "http://opencv.willowgarage.com" DESCRIPTION "OpenCV library support in CalypFrame" TYPE OPTIONAL)
+SET_PACKAGE_PROPERTIES(
+  OpenCV PROPERTIES
+  URL "http://opencv.willowgarage.com"
+  DESCRIPTION "OpenCV library support in CalypFrame"
+  TYPE OPTIONAL
+)
 
-OPTION( USE_FFMPEG "Add FFMPEG support" ON )
-IF( USE_FFMPEG )
-  FIND_PACKAGE( FFmpeg COMPONENTS AVCODEC AVFORMAT AVUTIL SWSCALE )
-  IF( "${AVCODEC_VERSION}" VERSION_LESS "56.0.0" )
-    SET(FFMPEG_FOUND FALSE )
-    SET(FFmpeg_FOUND FALSE )
-  ENDIF()
+# FFmpeg
+OPTION(USE_FFMPEG "Add FFMPEG support" ON)
+IF(USE_FFMPEG)
+  FIND_PACKAGE(FFmpeg COMPONENTS AVCODEC AVFORMAT AVUTIL SWSCALE)
   SET(USE_FFMPEG ${FFMPEG_FOUND})
 ENDIF()
-SET_PACKAGE_PROPERTIES(FFmpeg PROPERTIES URL "http://ffmpeg.org/" DESCRIPTION "Libav library support in CalypStream" TYPE OPTIONAL)
+SET_PACKAGE_PROPERTIES(
+  FFmpeg PROPERTIES
+  URL "http://ffmpeg.org/"
+  DESCRIPTION "Libav library support in CalypStream"
+  TYPE OPTIONAL
+)
 
-IF( WIN32 )
-  SET( USE_STATIC ON )
-  INCLUDE( cmake/Win32.cmake )
+IF(WIN32)
+  SET(USE_STATIC ON)
+  INCLUDE(cmake/Win32.cmake)
 ENDIF()
 
-
-######################################################################################
+# ####################################################################################################################################################
 # CMake Defin1itions
-######################################################################################
+# ####################################################################################################################################################
 
-SET(CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake )
+SET(CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake)
 INCLUDE(FeatureSummary)
 
 # must go before the project command
-SET(CMAKE_CONFIGURATION_TYPES "Debug;Release" CACHE STRING "Configs" FORCE)
+SET(CMAKE_CONFIGURATION_TYPES
+    "Debug;Release"
+    CACHE STRING "Configs" FORCE
+)
 IF(DEFINED CMAKE_BUILD_TYPE AND CMAKE_VERSION VERSION_GREATER "2.8")
-  SET_PROPERTY( CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS ${CMAKE_CONFIGURATION_TYPES} )
+  SET_PROPERTY(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS ${CMAKE_CONFIGURATION_TYPES})
 ENDIF()
-SET( CMAKE_CXX_FLAGS "" )
+SET(CMAKE_CXX_FLAGS "")
 
-INCLUDE_DIRECTORIES( ${CMAKE_CURRENT_BINARY_DIR} )
+INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR})
 
-######################################################################################
+# ####################################################################################################################################################
 # Compiler options
-######################################################################################
+# ####################################################################################################################################################
 
-SET(CMAKE_CXX_STANDARD 14)
-if(CMAKE_COMPILER_IS_GNUCXX)
-    ADD_DEFINITIONS(-std=gnu++0x)
-endif()
-
-IF (NOT CMAKE_BUILD_TYPE )
-    MESSAGE(STATUS "No build type selected, default to Release")
-    SET(CMAKE_BUILD_TYPE "Release")
+SET(CMAKE_CXX_STANDARD 20)
+SET(CMAKE_CXX_STANDARD_REQUIRED ON)
+IF(MSVC)
+  ADD_COMPILE_OPTIONS(/std:c++20)
+ELSE()
+  IF(CMAKE_COMPILER_IS_GNUCC AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 10.0)
+    ADD_DEFINITIONS(-std=gnu++2a)
+  ELSE()
+    ADD_DEFINITIONS(-std=c++20)
+  ENDIF()
 ENDIF()
 
-SET( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall" )
-
-ADD_DEFINITIONS(-DQT_NO_CAST_TO_ASCII
-                #-DQT_NO_CAST_FROM_ASCII
-                -DQT_NO_URL_CAST_FROM_STRING
-                -DQT_NO_CAST_FROM_BYTEARRAY
-                #-DQT_NO_SIGNALS_SLOTS_KEYWORDS
-                #-DQT_USE_QSTRINGBUILDER
-               )
-
-# if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU" OR CMAKE_CXX_COMPILER_ID MATCHES "Clang")
-#    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pedantic")
-# endif()
-
-if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
-   if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS "5.0.0")
-      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}  -Wlogical-op" )
-   endif()
-   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-deprecated-declarations" )
-endif()
-
-IF( USE_WERROR )
-  SET( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror" )
+IF(NOT CMAKE_BUILD_TYPE)
+  MESSAGE(STATUS "No build type selected, default to Release")
+  SET(CMAKE_BUILD_TYPE "Release")
 ENDIF()
 
-SET( CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -g -O0" )
-SET( CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O2" )
+SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -funroll-loops")
 
+# if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU" OR CMAKE_CXX_COMPILER_ID MATCHES "Clang") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pedantic") endif()
 
-######################################################################################
+IF(USE_WERROR)
+  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror")
+ENDIF()
+
+SET(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -g -O0 -DCLP_DEBUG")
+IF(BUILD_WITH_SANITIZERS)
+  SET(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -fsanitize=address -fsanitize=leak -fsanitize=undefined")
+ENDIF()
+IF(BUILD_WITH_THREAD_SANITIZER)
+  SET(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -fsanitize=thread")
+ENDIF()
+
+IF(USE_IWYU)
+  FIND_PROGRAM(iwyu_path NAMES include-what-you-use iwyu REQUIRED)
+  SET(CXX_INCLUDE_WHAT_YOU_USE ON)
+ENDIF()
+
+# ####################################################################################################################################################
 # Configure targets
-######################################################################################
+# ####################################################################################################################################################
 
-ADD_FEATURE_INFO(CalypApp     BUILD_APP    "Build Graphical interface")
-ADD_FEATURE_INFO(CalypTools   BUILD_TOOLS  "Build Command line tool"  )
-ADD_FEATURE_INFO(DynLoad    USE_DYNLOAD   "Support for dynamic module load" )
-ADD_FEATURE_INFO(SSE        USE_SSE       "SSE instructions support" )
-ADD_FEATURE_INFO(WErrors    USE_WERROR    "Warnings as errors" )
+ADD_FEATURE_INFO(CalypApp BUILD_APP "Build Graphical interface")
+ADD_FEATURE_INFO(CalypTools BUILD_TOOLS "Build Command line tool")
+ADD_FEATURE_INFO(DynLoad USE_DYNLOAD "Support for dynamic module load")
+ADD_FEATURE_INFO(SSE USE_SSE "SSE instructions support")
+ADD_FEATURE_INFO(WErrors USE_WERROR "Warnings as errors")
 
-ADD_SUBDIRECTORY( lib )
-ADD_SUBDIRECTORY( modules )
+ADD_SUBDIRECTORY(lib)
 
-IF( ${BUILD_TOOLS} )
-  ADD_SUBDIRECTORY( tools )
+IF(${BUILD_TOOLS} OR ${BUILD_APP})
+  ADD_SUBDIRECTORY(modules)
 ENDIF()
 
-IF( ${BUILD_APP} )
-  ADD_SUBDIRECTORY( app )
+IF(${BUILD_TOOLS})
+  ADD_SUBDIRECTORY(tools)
 ENDIF()
 
-IF( ${BUILD_EXAMPLES} )
-  ADD_SUBDIRECTORY( examples )
+IF(${BUILD_APP})
+  ADD_SUBDIRECTORY(app)
 ENDIF()
 
+IF(${BUILD_EXAMPLES})
+  ADD_SUBDIRECTORY(examples)
+ENDIF()
 
-CONFIGURE_FILE( ${CMAKE_CURRENT_SOURCE_DIR}/config.h.in ${CMAKE_CURRENT_BINARY_DIR}/config.h )
+CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/config.h.in ${CMAKE_CURRENT_BINARY_DIR}/config.h)
 
-######################################################################################
+# ####################################################################################################################################################
 # Final information dump
-######################################################################################
+# ####################################################################################################################################################
 MESSAGE("")
-MESSAGE( STATUS "${PROJECT_NAME} INFORMATION"                     )
-MESSAGE( STATUS "Version: "                 "${CALYP_VERSION_STRING}" )
-MESSAGE( STATUS "Configuration:"                                  )
-MESSAGE( STATUS "    Static libs: "         "${USE_STATIC}" )
-MESSAGE( STATUS "    Build type: "          "${CMAKE_BUILD_TYPE}" )
-MESSAGE( STATUS "    Build flags: "         "${CMAKE_CXX_FLAGS}"  )
+MESSAGE(STATUS "${PROJECT_NAME} INFORMATION")
+MESSAGE(STATUS "Version: " "${CALYP_VERSION_STRING}")
+MESSAGE(STATUS "Configuration:")
+MESSAGE(STATUS "    Static libs: " "${USE_STATIC}")
+MESSAGE(STATUS "    Build type: " "${CMAKE_BUILD_TYPE}")
+MESSAGE(STATUS "    Build flags: " "${CMAKE_CXX_FLAGS}")
 
 FEATURE_SUMMARY(WHAT ALL INCLUDE_QUIET_PACKAGES FATAL_ON_MISSING_REQUIRED_PACKAGES)

Mainpage.dox

@@ -27,19 +27,21 @@ Modules
 
 Supported Quality Metrics
 ----------------------------------------------------------------
-- PSNR
-- SSIM
-- MSE
+- Peak Signal-to-Noise Ratio (PSNR)
+- Structural SIMilarity (SSIM) 
+- Mean Square Error (MSE)
+- Weighted Spherical PSNR (WS-PSNR)
+
 
 Frame Processing Modules
 ----------------------------------------------------------------
 - Component filtering
-- Frame difference, crop, shift, binarization
+- Frame difference, crop, shift, binarization and rotation
 - Sub-sampling operations
 - Measuring modules
 - Modules based on opencv:
-    * Disparity estimation
-    * Motion estimation
+    - Disparity estimation
+    - Motion estimation
 
 Supported Formats
 ----------------------------------------------------------------
@@ -62,35 +64,9 @@ Supported Formats
 Developers
 ----------------------------------------------------------------
 
-- Joao Carreira     (jfmcarreira@gmail.com)
-- Lui­s Lucas       (luisfrlucas@gmail.com)
-
-Builds
-----------------------------------------------------------------
-Download update build for windows and linux from our <a href="https://sourceforge.net/projects/playuver/">SourceForge project page</a>
-
-
-Build/Install using cmake
-----------------------------------------------------------------
-
-1. The following are required for compilation:
-  - an ordinary C++ development environment (g++, make, C++ libraries and headers, ...)
-  - cmake
-  - a Qt development environment (libraries, headers, qmake, ...): only QtCore, QtGui and QtWidgets are required, at least in version 4
-
-2. Optional Dependencies:
-  - QtDBus
-  - OpenCv
-  - FFmpeg
-
-3. Run the following commands: (this will create an executable named calyp)
-```
-mkdir build
-cd build
-cmake -DUSE_QT4=OFF -DUSE_FFMPEG=ON -DUSE_OPENCV=ON ..  (for FFmpeg and OpenCV support)
-make
-make install
-```
-
+- [**Joao Carreira**](https://github.com/jfmcarreira) (Founder, Main Developer)
+- [**Lui­s Lucas**   ](https://github.com/lfrlucas)    (Founder, Developer)
+- [**Joao Santos**  ](https://github.com/jpataias)    (Contributor)
+- [**JNSFilipe**    ](https://github.com/JNSFilipe)   (Contributor)
 
 */

README.md

@@ -3,9 +3,11 @@
 
 ## Build Status
 
-Master branch | Development branch
------------- | -------------
-[![Linux Status](https://travis-ci.org/pixlra/calyp.svg?branch=master)](https://travis-ci.org/pixlra/calyp.svg?branch=master) [![Windows status](https://ci.appveyor.com/api/projects/status/ea2ktvtg7uqwrika/branch/master?svg=true)](https://ci.appveyor.com/project/jfmcarreira/calyp/branch/master) | Comming soon!
+| Master | Development |
+|--|--|
+| ![master branch](https://github.com/pixlra/calyp/actions/workflows/build.yml/badge.svg?branch=master) | ![devel branch](https://github.com/pixlra/calyp/actions/workflows/build.yml/badge.svg?branch=master) |
+
+[![Windows status](https://ci.appveyor.com/api/projects/status/ea2ktvtg7uqwrika/branch/master?svg=true)](https://ci.appveyor.com/project/jfmcarreira/calyp/branch/master) 
 
 
 ## Features
@@ -20,7 +22,7 @@ Master branch | Development branch
 - Constant growing libs for stream and frame processing (CalypStream and CalypFrame)
 - Advanced API for frame/video processing algorithms
 - Frame level quality measurement API based on the CalypFrame class
-- Powefull command-line tool for quality and frame processing algorithms (uses the referred APIs)
+- Powerful command-line tool for quality and frame processing algorithms (uses the referred APIs)
 
 ## Modules
 - CalypLib: Low level library
@@ -30,7 +32,7 @@ Master branch | Development branch
 
 ##  Supported Quality Metrics
 - Peak Signal-to-Noise Ratio (PSNR)
-- Structural SIMilarity (SSIM) 
+- Structural SIMilarity (SSIM)
 - Mean Square Error (MSE)
 - Weighted Spherical PSNR (WS-PSNR)
 
@@ -73,13 +75,13 @@ Master branch | Development branch
 * **Dependencies**
   1. an ordinary C++ development environment (g++, make, C++ libraries and headers, ...)
   2. cmake
-  3. a Qt development environment: QtCore, QtGui, QtWidgets, QtPrintSupport and QtConcurrent (version 4 or higher)
+  3. a Qt development environment: QtCore, QtGui, QtWidgets, QtPrintSupport and QtConcurrent (version 5 or higher)
   4. Optional: QtDBus, OpenCV, FFmpeg
 * **List of required commands**
 ```
 mkdir build
 cd build
-cmake -DUSE_QT4=OFF -DUSE_FFMPEG=ON -DUSE_OPENCV=ON ..  (for FFmpeg and OpenCV support)
+cmake -DUSE_FFMPEG=ON -DUSE_OPENCV=ON ..  (for FFmpeg and OpenCV support)
 make
 make install
 ```

app/CMakeLists.txt

@@ -1,148 +1,180 @@
-###
-### CMakeLists for calyp app component
-###
+#
+# CMakeLists for calyp app component
+#
 
-INCLUDE_DIRECTORIES( ${CMAKE_CURRENT_SOURCE_DIR}
-                     ${CMAKE_CURRENT_SOURCE_DIR}/external
-                     ${CMAKE_CURRENT_SOURCE_DIR}/dialog
-                     ${CMAKE_CURRENT_SOURCE_DIR}/docks
-                     ${CMAKE_CURRENT_SOURCE_DIR}/widgets )
+INCLUDE_DIRECTORIES(
+  ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/.. ${CMAKE_CURRENT_SOURCE_DIR}/external ${CMAKE_CURRENT_SOURCE_DIR}/dialog
+  ${CMAKE_CURRENT_SOURCE_DIR}/docks ${CMAKE_CURRENT_SOURCE_DIR}/widgets
+)
 
-OPTION( USE_QTDBUS    "Build with QtDBus"         ON  )
-OPTION( USE_FERVOR    "Add Fervor support"        OFF )
+OPTION(USE_QTDBUS "Build with QtDBus" ON)
+OPTION(USE_FERVOR "Add Fervor support" OFF)
+OPTION(CALYP_MANAGED_RESOURCES "Handle streams in separate threads" ON)
+OPTION(CALYP_THREADED_MODULES "Use threads for modules" ON)
 
-ADD_SUBDIRECTORY( external )
+ADD_SUBDIRECTORY(external)
 
-FIND_PACKAGE( Qt5 REQUIRED COMPONENTS Core Gui Widgets Concurrent )
-LIST(APPEND QT_LINKER_LIBS Qt5::Core Qt5::Gui Qt5::Widgets Qt5::Concurrent )
-LIST(APPEND QT_MODULES Core Gui Widgets Concurrent )
+FIND_PACKAGE(Qt5 REQUIRED COMPONENTS Core Gui Widgets Concurrent)
+LIST(APPEND QT_LINKER_LIBS Qt5::Core Qt5::Gui Qt5::Widgets Qt5::Concurrent)
+LIST(APPEND QT_MODULES Core Gui Widgets Concurrent)
 
-IF( USE_QTDBUS )
-  FIND_PACKAGE( Qt5DBus )
-  SET_PACKAGE_PROPERTIES(Qt5DBus PROPERTIES DESCRIPTION "Support for Qt5 DBus messages between instances" TYPE OPTIONAL )
-  IF( ${Qt5DBus_FOUND} )
-    SET( USE_QTDBUS ${Qt5DBus_FOUND} ) # TODO: fix this stupid variable
-    SET( USE_QTDBUS ${Qt5DBus_FOUND} PARENT_SCOPE)
-    LIST(APPEND QT_LINKER_LIBS Qt5::DBus )
-    LIST(APPEND QT_MODULES DBus )
+IF(USE_QTDBUS)
+  FIND_PACKAGE(Qt5DBus)
+  SET_PACKAGE_PROPERTIES(
+    Qt5DBus PROPERTIES
+    DESCRIPTION "Support for Qt5 DBus messages between instances"
+    TYPE OPTIONAL
+  )
+  IF(${Qt5DBus_FOUND})
+    SET(USE_QTDBUS ${Qt5DBus_FOUND}) # TODO: fix this stupid variable
+    SET(USE_QTDBUS
+        ${Qt5DBus_FOUND}
+        PARENT_SCOPE
+    )
+    LIST(APPEND QT_LINKER_LIBS Qt5::DBus)
+    LIST(APPEND QT_MODULES DBus)
   ENDIF()
 ENDIF()
 
-set(Calyp_App_SRCS
-# Main
+ADD_DEFINITIONS(
+  -DQT_NO_CAST_TO_ASCII
+  # -DQT_NO_CAST_FROM_ASCII
+  -DQT_NO_URL_CAST_FROM_STRING
+  -DQT_NO_CAST_FROM_BYTEARRAY
+  # -DQT_NO_SIGNALS_SLOTS_KEYWORDS -DQT_USE_QSTRINGBUILDER
+)
+
+SET(Calyp_App_SRCS
+    # Main
     main.cpp
     MainWindow.cpp
-# Module SubWindow
+    # Module SubWindow
     SubWindowHandle.cpp
     MdiSubWindow.cpp
     SubWindowAbstract.cpp
-# Module Video
+    # Module Video
+    ResourceHandle.cpp
     VideoHandle.cpp
     VideoSubWindow.cpp
+    VideoStreamSubWindow.cpp
+    ModuleSubWindow.cpp
     ViewArea.cpp
     GridManager.cpp
-# Module Quality
+    # Module Quality
     QualityHandle.cpp
     PlotSubWindow.cpp
-    external/qcustomplot/qcustomplot.cpp
-# Module Plugins
+    # Module Plugins
     ModulesHandle.cpp
     CalypAppModuleIf.cpp
-# Dialogs
+    # Dialogs
     dialog/AboutDialog.cpp
     dialog/ConfigureFormatDialog.cpp
     dialog/SubWindowSelectorDialog.cpp
     dialog/ProgressBar.cpp
     dialog/SeekStreamDialog.cpp
     dialog/ModulesHandleOptDialog.cpp
-# Widgets
+    # Widgets
     widgets/HistogramWidget.cpp
     widgets/FrameNumberWidget.cpp
-# Docks
+    # Docks
     docks/FramePropertiesDock.cpp
     docks/ModuleHandleDock.cpp
     docks/QualityMeasurementSidebar.cpp
 )
 
-IF( USE_QTDBUS )
-  LIST( APPEND Calyp_App_SRCS  DBusAppAdaptor.cpp )
+IF(USE_QTDBUS)
+  LIST(APPEND Calyp_App_SRCS DBusAppAdaptor.cpp)
 ENDIF()
 
+SET(Calyp_App_UI "")
 
-set(Calyp_App_UI "" )
+SET(Calyp_App_RCC resources/${PROJECT_NAME}.qrc)
 
-set(Calyp_App_RCC
-  resources/${PROJECT_NAME}.qrc
-)
+IF(USE_FERVOR)
 
+  SET(FERVOR_DIR ${CMAKE_CURRENT_SOURCE_DIR}/external/fervor)
 
-IF( USE_FERVOR )
+  IF(EXISTS ${FERVOR_DIR})
 
-  SET( FERVOR_DIR ${CMAKE_CURRENT_SOURCE_DIR}/external/fervor )
+    SET(FERVOR_APP_NAME ${PROJECT_NAME})
+    SET(FERVOR_APP_VERSION ${CALYP_VERSION_STRING})
 
-  IF(EXISTS ${FERVOR_DIR} )
+    ADD_SUBDIRECTORY(${FERVOR_DIR})
 
-    SET( FERVOR_APP_NAME ${PROJECT_NAME} )
-    SET( FERVOR_APP_VERSION ${CALYP_VERSION_STRING} )
+    INCLUDE_DIRECTORIES(${FERVOR_DIR})
 
-    ADD_SUBDIRECTORY( ${FERVOR_DIR} )
+    LIST(APPEND APP_LINKER_LIBS Fervor)
 
-    INCLUDE_DIRECTORIES( ${FERVOR_DIR} )
+    FIND_PACKAGE(Qt5 REQUIRED Network WebKit WebKitWidgets)
 
-    LIST(APPEND APP_LINKER_LIBS Fervor )
+    LIST(APPEND QT_LINKER_LIBS Qt5::Network Qt5::WebKit Qt5::WebKitWidgets)
+    LIST(APPEND QT_MODULES Network WebKit WebKitWidgets)
 
-    FIND_PACKAGE( Qt5 REQUIRED Network WebKit WebKitWidgets )
-
-    LIST(APPEND QT_LINKER_LIBS Qt5::Network Qt5::WebKit Qt5::WebKitWidgets )
-    LIST(APPEND QT_MODULES Network WebKit WebKitWidgets )
-
-#     LIST(APPEND APP_LINKER_LIBS ${FERVOR_DEPENDENCIES} )
-    INCLUDE_DIRECTORIES( ${FERVOR_INCLUDE_DIRS} )
+    # LIST(APPEND APP_LINKER_LIBS ${FERVOR_DEPENDENCIES} )
+    INCLUDE_DIRECTORIES(${FERVOR_INCLUDE_DIRS})
 
     SET(QT_USE_QTNETWORK true)
     SET(QT_USE_QTWEBKIT true)
 
   ELSE()
-    MESSAGE( "Fervor lib source code is not find in ${FERVOR_DIR}... Disabling it!" )
-    SET( USE_FERVOR False )
+    MESSAGE("Fervor lib source code is not find in ${FERVOR_DIR}... Disabling it!")
+    SET(USE_FERVOR False)
   ENDIF()
 ENDIF()
 
-SET_PACKAGE_PROPERTIES(Fervor PROPERTIES URL "https://github.com/pypt/fervor" DESCRIPTION "Fervor lib includes check for updates feature" TYPE OPTIONAL )
+SET_PACKAGE_PROPERTIES(
+  Fervor PROPERTIES
+  URL "https://github.com/pypt/fervor"
+  DESCRIPTION "Fervor lib includes check for updates feature"
+  TYPE OPTIONAL
+)
 ADD_FEATURE_INFO(Fervor USE_FERVOR "Fervor lib includes check for updates feature.")
 
-QT5_WRAP_UI( Calyp_App_UI_Wrap ${Calyp_App_UI} )
-QT5_ADD_RESOURCES( Calyp_App_RCC ${Calyp_App_RCC} )
+QT5_WRAP_UI(Calyp_App_UI_Wrap ${Calyp_App_UI})
+QT5_ADD_RESOURCES(Calyp_App_RCC ${Calyp_App_RCC})
 
 # Instruct CMake to run moc automatically when needed.
-SET( CMAKE_AUTOMOC ON )
+SET(CMAKE_AUTOMOC ON)
 
-# Windows application icon
-IF( WIN32 )
-  set(WINDOWS_RES_FILE ${CMAKE_CURRENT_BINARY_DIR}/resources.obj)
-  IF( MSVC )
-    add_custom_command(OUTPUT ${WINDOWS_RES_FILE}
-      COMMAND rc.exe /fo ${WINDOWS_RES_FILE} ${PROJECT_NAME}.rc
-      WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/resources
-    )
-  ELSE()
-    add_custom_command(OUTPUT ${WINDOWS_RES_FILE}
-      COMMAND windres.exe ${PROJECT_NAME}.rc ${WINDOWS_RES_FILE}
-      WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/resources
-    )
-  ENDIF()
+IF(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-deprecated-enum-enum-conversion")
 ENDIF()
 
-
-ADD_EXECUTABLE( ${PROJECT_NAME} ${Calyp_App_SRCS} ${HEADERS_MOC_FILES} ${Calyp_App_UI_Wrap} ${Calyp_App_RCC} ${WINDOWS_RES_FILE} )
-TARGET_LINK_LIBRARIES( ${PROJECT_NAME} ${PROJECT_LIBRARY} CalypModules ${APP_LINKER_LIBS} ${QT_LINKER_LIBS} QCustomPlotLib )
+# Windows application icon
+IF(WIN32)
+  SET(WINDOWS_RES_FILE ${CMAKE_CURRENT_BINARY_DIR}/resources.obj)
+  IF(MSVC)
+    ADD_CUSTOM_COMMAND(
+      OUTPUT ${WINDOWS_RES_FILE}
+      COMMAND rc.exe /fo ${WINDOWS_RES_FILE} ${PROJECT_NAME}.rc
+      WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/resources
+      COMMENT "Add icon on windows platform"
+    )
+  ELSE()
+    ADD_CUSTOM_COMMAND(
+      OUTPUT ${WINDOWS_RES_FILE}
+      COMMAND windres.exe ${PROJECT_NAME}.rc ${WINDOWS_RES_FILE}
+      WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/resources
+      COMMENT "Add icon on windows platform"
+    )
+  ENDIF()
+  ADD_EXECUTABLE(${PROJECT_NAME} ${Calyp_App_SRCS} ${HEADERS_MOC_FILES} ${Calyp_App_UI_Wrap} ${Calyp_App_RCC} ${WINDOWS_RES_FILE})
+ELSEIF(CMAKE_HOST_APPLE)
+  SET(CMAKE_MACOSX_BUNDLE ON)
+  SET(MACOSX_BUNDLE_EXECUTABLE_NAME ${PROJECT_NAME})
+  SET(MACOSX_BUNDLE_ICON_FILE Contents/Resources/calyp.icns)
+  SET(MACOSX_BUNDLE_BUNDLE_NAME Calyp)
+  SET(APP_ICON_MACOSX ${CMAKE_CURRENT_SOURCE_DIR}/resources/calyp.icns)
+  SET_SOURCE_FILES_PROPERTIES(${APP_ICON_MACOSX} PROPERTIES MACOSX_PACKAGE_LOCATION "Resources")
+  ADD_EXECUTABLE(${PROJECT_NAME} MACOSX_BUNDLE ${Calyp_App_SRCS} ${HEADERS_MOC_FILES} ${Calyp_App_UI_Wrap} ${Calyp_App_RCC} ${APP_ICON_MACOSX})
+ELSE()
+  ADD_EXECUTABLE(${PROJECT_NAME} ${Calyp_App_SRCS} ${HEADERS_MOC_FILES} ${Calyp_App_UI_Wrap} ${Calyp_App_RCC})
+ENDIF()
+TARGET_LINK_LIBRARIES(${PROJECT_NAME} ${PROJECT_LIBRARY} CalypModules ${APP_LINKER_LIBS} ${QT_LINKER_LIBS} QCustomPlotLib)
 
 # QT5_USE_MODULES( ${PROJECT_NAME} ${QT_MODULES} )
 
-INSTALL(TARGETS ${PROJECT_NAME} DESTINATION bin )
-INSTALL(FILES resources/calyp.desktop DESTINATION share/applications )
-INSTALL(FILES resources/calyp.png DESTINATION share/pixmaps )
-INSTALL(FILES resources/calyp.xml DESTINATION share/mime/packages )
-
-
-
+INSTALL(TARGETS ${PROJECT_NAME} DESTINATION bin)
+INSTALL(FILES resources/calyp.desktop DESTINATION share/applications)
+INSTALL(FILES resources/calyp.png DESTINATION share/pixmaps)
+INSTALL(FILES resources/calyp.xml DESTINATION share/mime/packages)

app/CalypAppModuleIf.cpp

@@ -1,5 +1,5 @@
 /*    This file is a part of Calyp project
- *    Copyright (C) 2014-2019  by Joao Carreira   (jfmcarreira@gmail.com)
+ *    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
@@ -24,43 +24,80 @@
 
 #include "CalypAppModuleIf.h"
 
-#include "VideoSubWindow.h"
-
 #include <QAction>
 #include <QApplication>
 #include <QDockWidget>
 
-CalypAppModuleIf::CalypAppModuleIf( QObject* parent, QAction* action, CalypModuleIf* module )
-    : m_bIsRunning( false )
-    , m_pcModuleAction( action )
-    , m_pcModule( module )
-    , m_pcDisplaySubWindow( NULL )
-    , m_pcDockWidget( NULL )
-    , m_pcModuleDock( NULL )
-    , m_pcModuleStream( NULL )
-    , m_pcProcessedFrame( NULL )
-    , m_dMeasurementResult( 0 )
+#include "ModuleHandleDock.h"
+#include "ModuleSubWindow.h"
+#include "VideoSubWindow.h"
+#include "lib/CalypFrame.h"
+#include "lib/CalypStream.h"
+
+CalypAppModuleIf::CalypAppModuleIf( QObject* parent, QAction* action, CalypModulePtr&& module )
+    : m_pcModuleAction( action ), m_pcModule( std ::move( module ) )
 {
   setParent( parent );
-  for( int i = 0; i < CLP_MODULE_MAX_NUM_FRAMES; i++ )
+#ifdef CALYP_THREADED_MODULES
+  setObjectName( m_pcModule->m_pchModuleName );
+#endif
+  m_frameList.reserve( m_pcModule->m_uiNumberOfFrames );
+  m_frameListPtr.reserve( m_pcModule->m_uiNumberOfFrames );
+  m_pcSubWindow.resize( m_pcModule->m_uiNumberOfFrames, nullptr );
+}
+
+CalypAppModuleIf::~CalypAppModuleIf()
+{
+#ifdef CALYP_THREADED_MODULES
+  wait();
+#endif
+  if( m_pcModuleDock )
   {
-    m_pcSubWindow[i] = NULL;
+    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 )
+  {
+    m_pcModule->destroy();
+    m_pcModule = nullptr;
   }
 }
 
-void CalypAppModuleIf::update()
+void CalypAppModuleIf::update( bool isPlaying )
 {
   if( m_pcDisplaySubWindow )
   {
-    m_pcDisplaySubWindow->refreshFrame();
+    m_pcDisplaySubWindow->refreshSubWindow();
   }
   else
   {
-    apply();
+    apply( isPlaying );
   }
 }
 
-bool CalypAppModuleIf::isRunning()
+// void CalypAppModuleIf::setPlaying( bool isPlaying )
+// {
+//   if( m_pcDisplaySubWindow )
+//   {
+//     m_pcDisplaySubWindow->setPlaying( isPlaying );
+//   }
+// }
+
+bool CalypAppModuleIf::isRunning() const
 {
 #ifdef CALYP_THREADED_MODULES
   return QThread::isRunning();
@@ -69,12 +106,20 @@ bool CalypAppModuleIf::isRunning()
 #endif
 }
 
+void CalypAppModuleIf::run()
+{
+  bool result = process();
+  if( result )
+  {
+    EventData* eventData = new EventData( m_bSuccess, this );
+    QCoreApplication::postEvent( parent(), eventData );
+  }
+}
+
 bool CalypAppModuleIf::apply( bool isPlaying, bool disableThreads )
 {
-  bool bRet = false;
-
-  QApplication::setOverrideCursor( Qt::WaitCursor );
-  if( m_pcModule->m_iModuleType == CLP_FRAME_PROCESSING_MODULE )
+  bool moduleExecuted = false;
+  if( m_pcModule->m_iModuleType == ClpModuleType::FrameProcessing )
   {
     if( m_pcDisplaySubWindow )
     {
@@ -85,8 +130,20 @@ bool CalypAppModuleIf::apply( bool isPlaying, bool disableThreads )
       m_pcSubWindow[0]->setFillWindow( true );
     }
   }
-  if( !( isPlaying && ( m_pcModule->m_uiModuleRequirements & CLP_MODULE_REQUIRES_SKIP_WHILE_PLAY ) ) )
+
+  if( !( isPlaying && m_pcModule->m_uiModuleRequirements.is_set( ClpModuleFeature::SkipWhilePlaying ) ) )
   {
+    m_frameList.clear();
+    for( unsigned int i = 0; i < m_pcModule->m_uiNumberOfFrames; i++ )
+    {
+      m_frameList.push_back( m_pcSubWindow[i]->getCurrFrameAsset() );
+    }
+
+    // Skip module is is already running
+    if( isRunning() )
+      return moduleExecuted;
+
+    moduleExecuted = true;
 #ifdef CALYP_THREADED_MODULES
     if( !disableThreads )
     {
@@ -96,49 +153,51 @@ bool CalypAppModuleIf::apply( bool isPlaying, bool disableThreads )
     else
 #endif
     {
-      run();
+      QApplication::setOverrideCursor( Qt::WaitCursor );
+      process();
+      QApplication::restoreOverrideCursor();
       show();
     }
-
-    if( m_pcDisplaySubWindow || m_pcModule->m_iModuleType == CLP_FRAME_MEASUREMENT_MODULE )
-    {
-      bRet = true;
-    }
   }
-  else
-  {
-    bRet = true;
-  }
-  QApplication::restoreOverrideCursor();
-  return bRet;
+  return moduleExecuted;
 }
 
-void CalypAppModuleIf::run()
+bool CalypAppModuleIf::process()
 {
-  m_bIsRunning = true;
   m_bSuccess = false;
-  std::vector<CalypFrame*> apcFrameList;
-  for( unsigned int i = 0; i < m_pcModule->m_uiNumberOfFrames; i++ )
+
+  if( m_frameList.empty() )
+    return false;
+
+#ifdef CALYP_THREADED_MODULES
+  QMutexLocker locker( &m_Mutex );
+#endif
+
+  m_frameListPtr.clear();
+  for( auto& frame : m_frameList )
   {
-    apcFrameList.push_back( m_pcSubWindow[i]->getCurrFrame() );
+    m_frameListPtr.push_back( frame.get() );
   }
 
-  if( m_pcModule->m_iModuleType == CLP_FRAME_PROCESSING_MODULE )
+  if( m_pcModule->m_iModuleType == ClpModuleType::FrameProcessing )
   {
+    CalypFrame* framePtr{ nullptr };
     if( m_pcModule->m_iModuleAPI >= CLP_MODULE_API_2 )
     {
-      m_pcProcessedFrame = m_pcModule->process( apcFrameList );
+      framePtr = m_pcModule->process( m_frameListPtr );
     }
     else
     {
-      m_pcProcessedFrame = m_pcModule->process( m_pcSubWindow[0]->getCurrFrame() );
+      framePtr = m_pcModule->process( m_pcSubWindow[0]->getCurrFrame() );
     }
+    assert( framePtr != nullptr );
+    m_pcProcessedFrame = std::shared_ptr<CalypFrame>{ framePtr, []( CalypFrame* ptr ) {} };
   }
-  else if( m_pcModule->m_iModuleType == CLP_FRAME_MEASUREMENT_MODULE )
+  else if( m_pcModule->m_iModuleType == ClpModuleType::FrameMeasurement )
   {
     if( m_pcModule->m_iModuleAPI >= CLP_MODULE_API_2 )
     {
-      m_dMeasurementResult = m_pcModule->measure( apcFrameList );
+      m_dMeasurementResult = m_pcModule->measure( m_frameListPtr );
     }
     else
     {
@@ -147,84 +206,61 @@ void CalypAppModuleIf::run()
   }
   else
   {
-    return;
+    return false;
   }
   m_bSuccess = true;
-  m_bIsRunning = false;
-#ifdef CALYP_THREADED_MODULES
-  EventData* eventData = new EventData( m_bSuccess, this );
-  if( parent() )
-    QCoreApplication::postEvent( parent(), eventData );
-#endif
-  return;
+  return true;
 }
 
 void CalypAppModuleIf::show()
 {
+#ifdef CALYP_THREADED_MODULES
+  if( m_canceling )
+    return;
+#endif
   switch( m_pcModule->m_iModuleType )
   {
-  case CLP_FRAME_PROCESSING_MODULE:
-    if( m_pcDisplaySubWindow )
+  case ClpModuleType::FrameProcessing: {
+    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->setCurrFrame( m_pcProcessedFrame );
-      m_pcDisplaySubWindow->setFillWindow( false );
-      m_pcDisplaySubWindow->clearWindowBusy();
-    }
-    else
-    {
-      m_pcSubWindow[0]->setCurrFrame( m_pcProcessedFrame );
-      m_pcSubWindow[0]->setFillWindow( false );
-      m_pcSubWindow[0]->clearWindowBusy();
+      displayWindow->setFillWindow( false );
+      displayWindow->setCurrFrame( m_pcProcessedFrame );
+      m_Mutex.unlock();
     }
+#else
+    displayWindow->setFillWindow( false );
+    displayWindow->setCurrFrame( m_pcProcessedFrame );
+#endif
     break;
-  case CLP_FRAME_MEASUREMENT_MODULE:
-    m_pcModuleDock->setModulueReturnValue( m_dMeasurementResult );
+  }
+  case ClpModuleType::FrameMeasurement:
+    m_pcModuleDock->setModuleReturnValue( m_dMeasurementResult );
     break;
+  default:
+    assert( false );
   }
 }
 
-void CalypAppModuleIf::destroy()
+void CalypAppModuleIf::disable()
 {
-  if( m_bIsRunning )
+  QApplication::setOverrideCursor( Qt::WaitCursor );
+#ifdef CALYP_THREADED_MODULES
+  m_canceling = true;
+  m_Mutex.lock();
+  m_Mutex.unlock();
+#endif
+  m_frameList.clear();
+  m_frameListPtr.clear();
+  while( m_pcSubWindow.size() > 0 )
   {
-    QApplication::setOverrideCursor( Qt::WaitCursor );
-    while( m_bIsRunning )
-    {
-    }
-    QApplication::restoreOverrideCursor();
-  }
-  if( m_pcModuleDock )
-  {
-    m_pcModuleDock->close();
-    m_pcModuleDock = NULL;
-  }
-  if( m_pcDockWidget )
-  {
-    m_pcDockWidget->close();
-    m_pcDockWidget = NULL;
-  }
-  if( m_pcDisplaySubWindow )
-    m_pcDisplaySubWindow->closeSubWindow();
-  m_pcDisplaySubWindow = NULL;
-
-  for( int i = 0; i < CLP_MODULE_MAX_NUM_FRAMES; i++ )
-  {
-    if( m_pcSubWindow[i] )
-    {
-      m_pcSubWindow[i]->disableModule( this );
-      m_pcSubWindow[i] = NULL;
-    }
-  }
-  if( m_pcModuleStream )
-  {
-    m_pcModuleStream->close();
-    delete m_pcModuleStream;
-    m_pcModuleStream = NULL;
-  }
-  if( m_pcModule )
-  {
-    m_pcModule->destroy();
-    m_pcModule->Delete();
-    m_pcModule = NULL;
+    auto window = m_pcSubWindow.back();
+    m_pcSubWindow.erase( m_pcSubWindow.end() - 1 );
+    if( window != nullptr )
+      window->disableModule( this );
   }
+  QApplication::restoreOverrideCursor();
 }

app/CalypAppModuleIf.h

@@ -1,5 +1,5 @@
 /*    This file is a part of Calyp project
- *    Copyright (C) 2014-2019  by Joao Carreira   (jfmcarreira@gmail.com)
+ *    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
@@ -25,90 +25,100 @@
 #ifndef __CALYPAPPMODULESIF_H__
 #define __CALYPAPPMODULESIF_H__
 
-#include "CommonDefs.h"
-#include "ModuleHandleDock.h"
-#include "config.h"
-#include "lib/CalypFrame.h"
-#include "lib/CalypModuleIf.h"
-#include "lib/CalypStream.h"
-
 #include <QEvent>
+#include <QPointer>
 #include <QVector>
 #include <cstdio>
 #include <iostream>
 
+#include "config.h"
+
+#ifdef CALYP_THREADED_MODULES
+#include <QMutex>
+#include <QThread>
+#endif
+
+#include "CommonDefs.h"
+#include "ModuleHandleDock.h"
+// #include "lib/CalypFrame.h"
+#include "lib/CalypModuleIf.h"
+// #include "lib/CalypStream.h"
+
 class QAction;
 class QDockWidget;
-
-#define CLP_MODULE_MAX_NUM_FRAMES 5
+class CalypStream;
+class CalypFrame;
 
 class VideoSubWindow;
+class ModuleSubWindow;
 
-class CalypAppModuleIf
+class CalypAppModuleIf : std::enable_shared_from_this<CalypAppModuleIf>,
 #ifdef CALYP_THREADED_MODULES
-    : public QThread
+                         public QThread
 #else
-    : public QObject
+                         public QObject
 #endif
 {
   friend class ModulesHandle;
   friend class ModuleHandleDock;
   friend class ModulesHandleOptDialog;
 
-private:
-  bool m_bIsRunning;
-  bool m_bSuccess;
-
-  QAction* m_pcModuleAction;
-  CalypModuleIf* m_pcModule;
-
-  VideoSubWindow* m_pcSubWindow[CLP_MODULE_MAX_NUM_FRAMES];
-
-  VideoSubWindow* m_pcDisplaySubWindow;
-
-  QDockWidget* m_pcDockWidget;
-  ModuleHandleDock* m_pcModuleDock;
-
-  CalypStream* m_pcModuleStream;
-  CalypFrame* m_pcProcessedFrame;
-  double m_dMeasurementResult;
-
 public:
   class EventData : public QEvent
   {
   public:
     EventData( bool success, CalypAppModuleIf* module )
-        : QEvent( QEvent::User )
+        : QEvent( QEvent::User ), m_bSuccess{ success }, m_pcModule{ module }
     {
-      m_bSuccess = success;
-      m_pcModule = module;
     }
     bool m_bSuccess;
-    CalypAppModuleIf* m_pcModule;
+    QPointer<CalypAppModuleIf> m_pcModule;
   };
 
-  CalypAppModuleIf( QObject* parent, QAction* action, CalypModuleIf* module );
-  virtual ~CalypAppModuleIf() {}
-  QList<VideoSubWindow*> getSubWindowList()
-  {
-    QList<VideoSubWindow*> arraySubWindows;
-    for( int i = 0; i < CLP_MODULE_MAX_NUM_FRAMES; i++ )
-      if( m_pcSubWindow[i] )
-        arraySubWindows.append( m_pcSubWindow[i] );
-    return arraySubWindows;
-  }
+  CalypAppModuleIf( QObject* parent, QAction* action, CalypModulePtr&& module );
+  ~CalypAppModuleIf();
 
-  CalypModuleIf* getModule() { return m_pcModule; }
-  unsigned int getModuleRequirements() { return m_pcModule->m_uiModuleRequirements; }
-  ClpString moduleInfo() { return m_pcModule->moduleInfo(); }
-  void update();
+  auto getSubWindowList() const -> const std::vector<VideoSubWindow*>& { return m_pcSubWindow; }
+
+  CalypModuleIf* getModule() { return m_pcModule.get(); }
+  auto getModuleRequirements() const -> ClpModuleFeatures { return m_pcModule->m_uiModuleRequirements; }
+  std::string moduleInfo() const { return m_pcModule->moduleInfo(); }
+  void update( bool isPlaying );
   bool apply( bool isPlaying = false, bool disableThreads = false );
-  bool isRunning();
+  bool process();
+  // void setPlaying( bool isPlaying );
+  bool isRunning() const;
   void show();
-  void destroy();
+  void disable();
 
 protected:
   virtual void run();
+
+private:
+  bool m_bSuccess{ false };
+
+  QAction* m_pcModuleAction{ nullptr };
+  CalypModulePtr m_pcModule{ nullptr };
+
+  std::vector<VideoSubWindow*> m_pcSubWindow;
+
+  // The module owns the related widgets
+  ModuleSubWindow* m_pcDisplaySubWindow{ nullptr };
+  QDockWidget* m_pcDockWidget{ nullptr };
+  ModuleHandleDock* m_pcModuleDock{ nullptr };
+
+  std::unique_ptr<CalypStream> m_pcModuleStream{ nullptr };
+
+  std::vector<std::shared_ptr<CalypFrame>> m_frameList;
+  std::vector<CalypFrame*> m_frameListPtr;
+
+  std::shared_ptr<CalypFrame> m_pcProcessedFrame{ nullptr };
+  double m_dMeasurementResult{ 0 };
+
+#ifdef CALYP_THREADED_MODULES
+  QMutex m_Mutex;
+  std::atomic<bool> m_canceling{ false };
+#endif
 };
 
 #endif  // __CALYPAPPMODULESIF_H__

app/CommonDefs.h

@@ -1,5 +1,5 @@
 /*    This file is a part of Calyp project
- *    Copyright (C) 2014-2019  by Joao Carreira   (jfmcarreira@gmail.com)
+ *    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

app/DBusAppAdaptor.cpp

@@ -1,5 +1,5 @@
 /*    This file is a part of Calyp project
- *    Copyright (C) 2014-2019  by Joao Carreira   (jfmcarreira@gmail.com)
+ *    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

app/DBusAppAdaptor.h

@@ -1,5 +1,5 @@
 /*    This file is a part of Calyp project
- *    Copyright (C) 2014-2019  by Joao Carreira   (jfmcarreira@gmail.com)
+ *    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

app/GridManager.cpp

@@ -1,5 +1,5 @@
 /*    This file is a part of Calyp project
- *    Copyright (C) 2014-2019  by Joao Carreira   (jfmcarreira@gmail.com)
+ *    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
@@ -52,7 +52,7 @@ void GridManager::setGridSize( int newsize )
 ////////////////////////////////////////////////////////////////////////////////
 //                              Grid Drawer
 ////////////////////////////////////////////////////////////////////////////////
-void GridManager::drawGrid( QPixmap& image, const QRect& area, QPainter* painter )
+void GridManager::drawGrid( const QImage& image, const QRect& area, QPainter* painter )
 {
   int offsetx = 0;  // Grid offset doesn't applies to SCODE
   int offsety = 0;  // project for now...
@@ -71,8 +71,7 @@ void GridManager::drawGrid( QPixmap& image, const QRect& area, QPainter* painter
   switch( style )
   {
   case intersectionDot:
-  case intersectionCross:
-  {
+  case intersectionCross: {
     painter->setPen( mainPen );
     // Draw crosses or dots on intersections
     for( int x = offsetx; x <= area.right(); x += hSpacing )
@@ -99,8 +98,7 @@ void GridManager::drawGrid( QPixmap& image, const QRect& area, QPainter* painter
     }
     break;
   }
-  case Dashed:
-  {
+  case Dashed: {
     // Change pen to the dashed line
     mainPen.setStyle( Qt::DashLine );
   }

app/GridManager.h

@@ -1,5 +1,5 @@
 /*    This file is a part of Calyp project
- *    Copyright (C) 2014-2019  by Joao Carreira   (jfmcarreira@gmail.com)
+ *    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
@@ -29,6 +29,7 @@
 #include <QColor>
 #include <QPen>
 #include <QRect>
+
 #include "CommonDefs.h"
 #include "config.h"
 
@@ -54,7 +55,7 @@ public:
 
   void setGridSize( int newsize );
 
-  void drawGrid( QPixmap& image, const QRect& area, QPainter* painter );
+  void drawGrid( const QImage& image, const QRect& area, QPainter* painter );
 
   /**
    * @returns a QRect defined by the grid that contains the point (x, y).

app/MainWindow.cpp

@@ -1,5 +1,5 @@
 /*    This file is a part of Calyp project
- *    Copyright (C) 2014-2019  by Joao Carreira   (jfmcarreira@gmail.com)
+ *    Copyright (C) 2014-2021  by Joao Carreira   (jfmcarreira@gmail.com)
  *                                Luis Lucas      (luisfrlucas@gmail.com)
  *                                Joao Santos     (joaompssantos@gmail.com)
  *
@@ -25,6 +25,16 @@
 
 #include "MainWindow.h"
 
+#include <QAction>
+#include <QActionGroup>
+#include <QCloseEvent>
+#include <QDoubleSpinBox>
+#include <QDragEnterEvent>
+#include <QDropEvent>
+#include <QSignalMapper>
+#include <QtDebug>
+#include <memory>
+
 #include "AboutDialog.h"
 #include "ModulesHandle.h"
 #include "QualityHandle.h"
@@ -34,15 +44,6 @@
 #include "VideoHandle.h"
 #include "VideoSubWindow.h"
 #include "lib/CalypOptions.h"
-
-#include <QAction>
-#include <QActionGroup>
-#include <QCloseEvent>
-#include <QDoubleSpinBox>
-#include <QDragEnterEvent>
-#include <QDropEvent>
-#include <QSignalMapper>
-#include <QtDebug>
 #ifdef USE_FERVOR
 #include "fvupdater.h"
 #endif
@@ -58,6 +59,8 @@ MainWindow::MainWindow()
   m_pDBusAdaptor = new DBusAppAdaptor( this );
 #endif
 
+  m_appResourceHandle = std::make_unique<ResourceHandle>();
+
   m_pcWindowHandle = new SubWindowHandle( this );
 
   m_appModuleVideo = new VideoHandle( this, m_pcWindowHandle );
@@ -76,15 +79,15 @@ MainWindow::MainWindow()
   setWindowTitle( QApplication::applicationName() );
   setWindowIcon( QIcon( ":logos/calyp-icon.png" ) );
   setUnifiedTitleAndToolBarOnMac( true );
-  setCentralWidget( m_pcWindowHandle );
+  setCentralWidget( m_pcWindowHandle->getWidget() );
   setAcceptDrops( true );
-  setBackgroundRole( QPalette::Background );
+  setBackgroundRole( QPalette::Window );
 
-  connect( m_pcWindowHandle, SIGNAL( windowActivated() ), this, SLOT( update() ) );
-  connect( m_pcWindowHandle, SIGNAL( changed() ), this, SLOT( update() ) );
-  connect( m_appModuleVideo, SIGNAL( changed() ), this, SLOT( update() ) );
-  connect( m_appModuleQuality, SIGNAL( changed() ), this, SLOT( update() ) );
-  connect( m_appModuleExtensions, SIGNAL( changed() ), this, SLOT( update() ) );
+  connect( m_pcWindowHandle, &SubWindowHandle::windowActivated, this, &MainWindow::updateMainWindow );
+  connect( m_pcWindowHandle, &SubWindowHandle::changed, this, &MainWindow::updateMainWindow, Qt::QueuedConnection );
+  connect( m_appModuleVideo, &VideoHandle::changed, this, &MainWindow::updateMainWindow, Qt::QueuedConnection );
+  connect( m_appModuleQuality, &QualityHandle::changed, this, &MainWindow::updateMainWindow, Qt::QueuedConnection );
+  connect( m_appModuleExtensions, &ModulesHandle::changed, this, &MainWindow::updateMainWindow, Qt::QueuedConnection );
 }
 
 bool MainWindow::parseArgs( int argc, char* argv[] )
@@ -92,16 +95,16 @@ bool MainWindow::parseArgs( int argc, char* argv[] )
   bool bRet = false;
   CalypOptions pcCmdParser;
 
-  std::vector<ClpString> m_apcInputs;
-  ClpString strResolution( "" );
-  ClpString strPelFmt( "" );
+  std::vector<std::string> m_apcInputs;
+  std::string strResolution( "" );
+  std::string strPelFmt( "" );
 
   pcCmdParser.addOptions()                      /**/
       ( "input,i", m_apcInputs, "input file" )  /**/
       ( "size,s", strResolution, "size (WxH)" ) /**/
       ( "pel_fmt", strPelFmt, "pixel format" );
 
-  if( !pcCmdParser.parse( argc, argv ) )
+  if( pcCmdParser.parse( argc, argv ) < 0 )
   {
     bRet |= true;
   }
@@ -182,34 +185,52 @@ void MainWindow::closeAll()
   m_pcWindowHandle->removeAllSubWindow();
 }
 
-void MainWindow::loadFile( QString fileName, CalypFileInfo* pStreamInfo )
+void MainWindow::loadFile( CalypFileInfo pStreamInfo )
+{
+  QString filename{ pStreamInfo.m_cFilename };
+  loadFile( std::move( filename ), std::move( pStreamInfo ) );
+}
+
+void MainWindow::loadFile( QString fileName, std::optional<CalypFileInfo> streamInfo )
 {
   if( !QFileInfo( fileName ).exists() )
   {
     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();
-  if( !pStreamInfo )
+  videoSubWindow = new VideoStreamSubWindow();  // createSubWindow();
+  videoSubWindow->setResourceManaget( m_appResourceHandle.get() );
+
+  if( !streamInfo.has_value() )
   {
-    int idx = findCalypStreamInfo( m_aRecentFileStreamInfo, fileName );
-    pStreamInfo = (CalypFileInfo*)( idx >= 0 ? &m_aRecentFileStreamInfo.at( idx ) : NULL );
+    auto idx = findCalypStreamInfo( m_aRecentFileStreamInfo, fileName );
+    if( idx >= 0 )
+      streamInfo = m_aRecentFileStreamInfo.at( idx );
   }
 
   try
   {
     bool opened = false;
 
-    if( !pStreamInfo )
+    if( streamInfo.has_value() )
+    {
+      try
+      {
+        opened = videoSubWindow->loadFile( std::move( *streamInfo ) );
+      }
+      catch( CalypFailure& e )
+      {
+      }
+    }
+
+    if( !opened )
       opened = videoSubWindow->loadFile( fileName );
-    else
-      opened = videoSubWindow->loadFile( pStreamInfo );
 
     if( opened )
     {
@@ -256,12 +277,12 @@ QStringList MainWindow::showFileDialog( bool bRead )
 
   for( unsigned int i = 0; i < supportedFmts.size(); i++ )
   {
-    std::vector<ClpString> arrayExt = supportedFmts[i].getExts();
+    std::vector<std::string> arrayExt = supportedFmts[i].getExts();
     if( arrayExt.size() > 0 )
     {
       QString currFmt( QString::fromStdString( supportedFmts[i].formatName ) );
       currFmt.append( " (" );
-      for( std::vector<ClpString>::iterator e = arrayExt.begin(); e != arrayExt.end(); ++e )
+      for( std::vector<std::string>::iterator e = arrayExt.begin(); e != arrayExt.end(); ++e )
       {
         supported.append( " *." );
         currFmt.append( "*." );
@@ -299,7 +320,7 @@ void MainWindow::open()
   {
     if( !fileNameList.at( i ).isEmpty() )
     {
-      loadFile( fileNameList.at( i ) );
+      loadFile( std::move( fileNameList.at( i ) ) );
     }
   }
 }
@@ -312,9 +333,10 @@ void MainWindow::open()
 void MainWindow::openRecent()
 {
   QAction* action = qobject_cast<QAction*>( sender() );
-  CalypFileInfo recentFile = action->data().value<CalypFileInfo>();
   if( action )
-    loadFile( recentFile.m_cFilename, &recentFile );
+  {
+    loadFile( action->data().value<CalypFileInfo>() );
+  }
 }
 
 void MainWindow::saveFrame()
@@ -375,9 +397,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 ) )
@@ -395,7 +416,7 @@ void MainWindow::format()
       m_pcCurrentSubWindow->close();
     }
     m_pcCurrentSubWindow = NULL;
-    update();
+    updateMainWindow();
   }
 }
 
@@ -405,7 +426,7 @@ void MainWindow::reload()
   {
     m_pcCurrentSubWindow->refreshSubWindow();
     m_pcCurrentSubWindow = NULL;
-    update();
+    updateMainWindow();
   }
 }
 
@@ -426,15 +447,15 @@ void MainWindow::reloadAll()
     }
   }
   m_pcCurrentSubWindow = NULL;
-  update();
+  updateMainWindow();
 }
 
 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 );
   }
 }
@@ -524,24 +545,23 @@ 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  -----------------------
 
-void MainWindow::update()
+void MainWindow::updateMainWindow()
 {
   SubWindowAbstract* activeSubWindow = m_pcWindowHandle->activeSubWindow();
   QCoreApplication::processEvents();
@@ -595,10 +615,17 @@ void MainWindow::updateMenus()
 {
   bool hasSubWindow = ( m_pcWindowHandle->activeSubWindow() != 0 );
 
-  bool hasVideoStreamSubWindow = false;
-  if( m_pcCurrentSubWindow )
-    if( m_pcCurrentSubWindow->getCategory() & SubWindowAbstract::VIDEO_STREAM_SUBWINDOW )
-      hasVideoStreamSubWindow = true;
+  bool hasVideoStreamSubWindow{ false };
+  bool supportsFormat{ false };
+  if( m_pcCurrentSubWindow && m_pcCurrentSubWindow->getCategory() & SubWindowAbstract::VIDEO_STREAM_SUBWINDOW )
+  {
+    hasVideoStreamSubWindow = true;
+
+    if( auto* pcVideoSubWindow = qobject_cast<VideoStreamSubWindow*>( m_pcCurrentVideoSubWindow ) )
+    {
+      supportsFormat = pcVideoSubWindow->supportsFormatConfiguration();
+    }
+  }
 
   m_arrayMenu[RECENT_MENU]->setEnabled( m_aRecentFileStreamInfo.size() > 0 ? true : false );
 
@@ -608,7 +635,7 @@ void MainWindow::updateMenus()
   m_arrayActions[RELOAD_ACT]->setEnabled( hasSubWindow );
   m_arrayActions[RELOAD_ALL_ACT]->setEnabled( hasSubWindow );
 
-  m_arrayActions[FORMAT_ACT]->setEnabled( hasVideoStreamSubWindow );
+  m_arrayActions[FORMAT_ACT]->setEnabled( supportsFormat );
   m_arrayActions[LOAD_ALL_ACT]->setEnabled( hasVideoStreamSubWindow );
 
   m_arrayActions[ZOOM_IN_ACT]->setEnabled( hasSubWindow );
@@ -802,12 +829,9 @@ void MainWindow::createMenus()
 
   menuBar()->addMenu( m_appModuleVideo->createVideoMenu() );
   menuBar()->addMenu( m_appModuleVideo->createImageMenu() );
-  QMenu* QualityMenu = m_appModuleQuality->createMenu();
-  menuBar()->addMenu( QualityMenu );
-  QMenu* ModuleMenu = m_appModuleExtensions->createMenu();
-  menuBar()->addMenu( ModuleMenu );
-  QMenu* windowMenu = m_pcWindowHandle->createMenu();
-  menuBar()->addMenu( windowMenu );
+  menuBar()->addMenu( m_appModuleQuality->createMenu() );
+  menuBar()->addMenu( m_appModuleExtensions->createMenu() );
+  menuBar()->addMenu( m_pcWindowHandle->createMenu() );
 
   menuBar()->addSeparator();
 

app/MainWindow.h

@@ -1,5 +1,5 @@
 /*    This file is a part of Calyp project
- *    Copyright (C) 2014-2019  by Joao Carreira   (jfmcarreira@gmail.com)
+ *    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
@@ -36,16 +36,19 @@
 #ifndef __MAINWINDOW_H__
 #define __MAINWINDOW_H__
 
+#include <QMainWindow>
+#include <QString>
+#include <QVector>
+#include <optional>
+
 #include "CommonDefs.h"
+#include "VideoStreamSubWindow.h"
 #include "VideoSubWindow.h"
 #include "config.h"
 #ifdef USE_QTDBUS
 #include "DBusAppAdaptor.h"
 #endif
-
-#include <QMainWindow>
-#include <QString>
-#include <QVector>
+#include "ResourceHandle.h"
 
 class QCloseEvent;
 class QDragEnterEvent;
@@ -58,6 +61,7 @@ class QSignalMapper;
 class CalypOptions;
 class CalypStream;
 class SubWindowHandle;
+class VideoStreamSubWindow;
 class VideoHandle;
 class QualityHandle;
 class ModulesHandle;
@@ -73,7 +77,8 @@ class MainWindow : public QMainWindow
 public:
   MainWindow();
   bool parseArgs( int argc, char* argv[] );
-  void loadFile( QString fileName, CalypFileInfo* pStreamInfo = NULL );
+  void loadFile( CalypFileInfo pStreamInfo );
+  void loadFile( QString fileName, std::optional<CalypFileInfo> pStreamInfo = {} );
 
 public Q_SLOTS:
   void printMessage( const QString& msg );
@@ -114,7 +119,7 @@ private Q_SLOTS:
   void dragEnterEvent( QDragEnterEvent* event );
   void dropEvent( QDropEvent* event );
 
-  void update();
+  void updateMainWindow();
   void updateZoomFactorSBox();
 
 private:
@@ -129,8 +134,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();
 
@@ -158,6 +163,7 @@ private:
    * Quality
    * Modules
    */
+  std::unique_ptr<ResourceHandle> m_appResourceHandle;
   VideoHandle* m_appModuleVideo;
   QualityHandle* m_appModuleQuality;
   ModulesHandle* m_appModuleExtensions;

app/MdiSubWindow.cpp

@@ -1,5 +1,5 @@
 /*    This file is a part of Calyp project
- *    Copyright (C) 2014-2019  by Joao Carreira   (jfmcarreira@gmail.com)
+ *    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
@@ -24,15 +24,15 @@
 
 #include "MdiSubWindow.h"
 
-#include "SubWindowAbstract.h"
-
 #include <QCloseEvent>
 
+#include "SubWindowAbstract.h"
+
 MdiSubWindow::MdiSubWindow( QWidget* parent )
     : QMdiSubWindow( parent )
 {
   setAttribute( Qt::WA_DeleteOnClose );
-  setBackgroundRole( QPalette::Background );
+  setBackgroundRole( QPalette::Window );
 }
 
 QSize MdiSubWindow::sizeHint() const

app/MdiSubWindow.h

@@ -1,5 +1,5 @@
 /*    This file is a part of Calyp project
- *    Copyright (C) 2014-2019  by Joao Carreira   (jfmcarreira@gmail.com)
+ *    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
@@ -26,6 +26,7 @@
 #define __MDISUBWINDOW_H_
 
 #include <QMdiSubWindow>
+
 #include "CommonDefs.h"
 #include "config.h"
 

app/ModuleSubWindow.cpp

@@ -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().is_set( ClpModuleFeature::HasInfo ) )
+    {
+      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 );
+  }
+}

app/ModuleSubWindow.h

@@ -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__

app/ModulesHandle.cpp

@@ -1,5 +1,5 @@
 /*    This file is a part of Calyp project
- *    Copyright (C) 2014-2019  by Joao Carreira   (jfmcarreira@gmail.com)
+ *    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
@@ -24,7 +24,10 @@
 
 #include "ModulesHandle.h"
 
+#include <cstdio>
+
 #include "MainWindow.h"
+#include "ModuleSubWindow.h"
 #include "ModulesHandleOptDialog.h"
 #include "SubWindowHandle.h"
 #include "SubWindowSelectorDialog.h"
@@ -32,10 +35,8 @@
 #include "VideoSubWindow.h"
 #include "modules/CalypModulesFactory.h"
 
-#include <cstdio>
-
 ModulesHandle::ModulesHandle( QWidget* parent, SubWindowHandle* windowManager, VideoHandle* moduleVideo )
-    : QWidget( parent ), m_pcParent( parent ), m_pcMainWindowManager( windowManager ), m_appModuleVideo( moduleVideo )
+    : m_pcParent( parent ), m_pcMainWindowManager( windowManager ), m_appModuleVideo( moduleVideo )
 {
   setParent( m_pcParent );
 }
@@ -50,32 +51,32 @@ void ModulesHandle::createActions()
   connect( m_pcActionMapper, SIGNAL( mapped( int ) ), this, SLOT( processOpt( int ) ) );
 
   //  m_arrayActions[FORCE_PLAYING_REFRESH_ACT] = new QAction( "Refresh while
-  //  playing", parent() );
+  //  playing", m_pcParent );
   //  m_arrayActions[FORCE_PLAYING_REFRESH_ACT]->setStatusTip( "Force module
   //  refreshing while playing" );
   //  m_arrayActions[FORCE_PLAYING_REFRESH_ACT]->setCheckable( true );
 
-  m_arrayActions[LOAD_EXTERNAL_ACT] = new QAction( "Load external module", parent() );
+  m_arrayActions[LOAD_EXTERNAL_ACT] = new QAction( "Load external module", m_pcParent );
   m_arrayActions[LOAD_EXTERNAL_ACT]->setStatusTip( "Load an externally build module" );
-  connect( m_arrayActions[LOAD_EXTERNAL_ACT], SIGNAL( triggered() ), this, SLOT( loadExternalModule() ) );
+  connect( m_arrayActions[LOAD_EXTERNAL_ACT], &QAction::triggered, this, &ModulesHandle::loadExternalModule );
 
-  m_arrayActions[APPLY_ALL_ACT] = new QAction( "Apply to All", parent() );
+  m_arrayActions[APPLY_ALL_ACT] = new QAction( "Apply to All", m_pcParent );
   m_arrayActions[APPLY_ALL_ACT]->setStatusTip( "Apply module to all frames and save the result" );
   connect( m_arrayActions[APPLY_ALL_ACT], SIGNAL( triggered() ), m_pcActionMapper, SLOT( map() ) );
   m_pcActionMapper->setMapping( m_arrayActions[APPLY_ALL_ACT], APPLY_ALL_ACT );
 
-  m_arrayActions[SWAP_FRAMES_ACT] = new QAction( "Swap frames", parent() );
+  m_arrayActions[SWAP_FRAMES_ACT] = new QAction( "Swap frames", m_pcParent );
   m_arrayActions[SWAP_FRAMES_ACT]->setStatusTip( "Swap Sub Window order" );
   connect( m_arrayActions[SWAP_FRAMES_ACT], SIGNAL( triggered() ), m_pcActionMapper, SLOT( map() ) );
   m_pcActionMapper->setMapping( m_arrayActions[SWAP_FRAMES_ACT], SWAP_FRAMES_ACT );
 
-  m_arrayActions[DISABLE_ACT] = new QAction( "Disable Modules", parent() );
-  connect( m_arrayActions[DISABLE_ACT], SIGNAL( triggered() ), this, SLOT( destroyWindowModules() ) );
+  m_arrayActions[DISABLE_ACT] = new QAction( "Disable Modules", m_pcParent );
+  connect( m_arrayActions[DISABLE_ACT], &QAction::triggered, this, &ModulesHandle::destroyWindowModules );
 
-  m_arrayActions[DISABLE_ALL_ACT] = new QAction( "Disable All Modules", parent() );
-  connect( m_arrayActions[DISABLE_ALL_ACT], SIGNAL( triggered() ), this, SLOT( destroyAllModulesIf() ) );
+  m_arrayActions[DISABLE_ALL_ACT] = new QAction( "Disable All Modules", m_pcParent );
+  connect( m_arrayActions[DISABLE_ALL_ACT], &QAction::triggered, this, &ModulesHandle::destroyAllModulesIf );
 
-  m_arrayActions[FORCE_NEW_WINDOW_ACT] = new QAction( "Use New Window", parent() );
+  m_arrayActions[FORCE_NEW_WINDOW_ACT] = new QAction( "Use New Window", m_pcParent );
   m_arrayActions[FORCE_NEW_WINDOW_ACT]->setStatusTip(
       "Show module result in a new window. Some modules already force this "
       "feature" );
@@ -84,21 +85,16 @@ void ModulesHandle::createActions()
 
 QMenu* ModulesHandle::createMenu()
 {
-  m_pcModulesMenu = new QMenu( "&Modules", this );
+  m_pcModulesMenu = new QMenu( "&Modules", m_pcParent );
   buildMenu();
   return m_pcModulesMenu;
 }
 
 void ModulesHandle::buildMenu()
 {
-  CalypModuleIf* pcCurrModuleIf;
-  QString ModuleIfinternalName;
-  QAction* currAction;
-  QMenu* currSubMenu;
-
-  for( int i = 0; i < m_arrayModulesActions.size(); i++ )
+  for( auto& action : m_arrayModulesActions )
   {
-    delete m_arrayModulesActions.at( i );
+    delete action;
   }
   m_arrayModulesActions.clear();
   m_pcModulesMenu->clear();
@@ -108,28 +104,31 @@ void ModulesHandle::buildMenu()
   CalypModulesFactoryMap::iterator it = moduleFactoryMap.begin();
   for( ; it != moduleFactoryMap.end(); ++it )
   {
-    pcCurrModuleIf = it->second();
-    ModuleIfinternalName = QString::fromLocal8Bit( it->first );
+    auto pcCurrModuleIf = it->second();
+    QString ModuleIfinternalName = QString::fromLocal8Bit( it->first );
 
-    currSubMenu = NULL;
-    if( pcCurrModuleIf->m_pchModuleCategory )
+    QMenu* currSubMenu{ nullptr };
+    if( pcCurrModuleIf->m_iModuleAPI <= CLP_MODULE_API_2 )
     {
-      for( int j = 0; j < m_pcModulesSubMenuList.size(); j++ )
+      if( pcCurrModuleIf->m_pchModuleCategory )
       {
-        if( m_pcModulesSubMenuList.at( j )->title() == QString( pcCurrModuleIf->m_pchModuleCategory ) )
+        for( int j = 0; j < m_pcModulesSubMenuList.size(); j++ )
         {
-          currSubMenu = m_pcModulesSubMenuList.at( j );
-          break;
+          if( m_pcModulesSubMenuList.at( j )->title() == QString( pcCurrModuleIf->m_pchModuleCategory ) )
+          {
+            currSubMenu = m_pcModulesSubMenuList.at( j );
+            break;
+          }
+        }
+        if( !currSubMenu )
+        {
+          currSubMenu = m_pcModulesMenu->addMenu( pcCurrModuleIf->m_pchModuleCategory );
+          m_pcModulesSubMenuList.append( currSubMenu );
         }
-      }
-      if( !currSubMenu )
-      {
-        currSubMenu = m_pcModulesMenu->addMenu( pcCurrModuleIf->m_pchModuleCategory );
-        m_pcModulesSubMenuList.append( currSubMenu );
       }
     }
 
-    currAction = new QAction( pcCurrModuleIf->getModuleLongName(), parent() );
+    QAction* currAction = new QAction( pcCurrModuleIf->getModuleLongName(), m_pcParent );
     QString moduleTooltip = pcCurrModuleIf->m_pchModuleTooltip;
     if( pcCurrModuleIf->m_uiNumberOfFrames > 1 )
       moduleTooltip += QString( " | Requires %1 frames" ).arg( pcCurrModuleIf->m_uiNumberOfFrames );
@@ -137,15 +136,13 @@ void ModulesHandle::buildMenu()
     currAction->setStatusTip( moduleTooltip );
     currAction->setData( ModuleIfinternalName );
     currAction->setCheckable( false );
-    connect( currAction, SIGNAL( triggered() ), this, SLOT( activateModule() ) );
+    connect( currAction, &QAction::triggered, this, &ModulesHandle::activateModule );
     m_arrayModulesActions.append( currAction );
 
     if( currSubMenu )
       currSubMenu->addAction( currAction );
     else
       m_pcModulesMenu->addAction( currAction );
-
-    pcCurrModuleIf->Delete();
   }
 
   m_pcModulesMenu->addAction( m_arrayActions[LOAD_EXTERNAL_ACT] );
@@ -159,20 +156,20 @@ void ModulesHandle::buildMenu()
 
 void ModulesHandle::updateMenus()
 {
-  VideoSubWindow* pcSubWindow = qobject_cast<VideoSubWindow*>( m_pcMainWindowManager->activeSubWindow() );
-  bool hasSubWindow = pcSubWindow ? true : false;
-  QAction* currModuleAction;
+  VideoSubWindow* pcSubWindow = m_pcMainWindowManager->activeSubWindow<VideoSubWindow>();
+
+  bool hasSubWindow = pcSubWindow != nullptr ? true : false;
 
   for( int i = 0; i < m_arrayModulesActions.size(); i++ )
   {
-    currModuleAction = m_arrayModulesActions.at( i );
-    //currModuleAction->setEnabled( hasSubWindow );
+    auto* currModuleAction = m_arrayModulesActions.at( i );
+    // currModuleAction->setEnabled( hasSubWindow );
     currModuleAction->setChecked( false );
   }
-  //for( int i = 0; i < m_pcModulesSubMenuList.size(); i++ )
+  // for( int i = 0; i < m_pcModulesSubMenuList.size(); i++ )
   //{
   //	m_pcModulesSubMenuList.at( i )->setEnabled( hasSubWindow );
-  //}
+  // }
 
   for( int i = 0; i < m_arrayActions.size(); i++ )
   {
@@ -180,22 +177,21 @@ void ModulesHandle::updateMenus()
   }
   m_arrayActions[LOAD_EXTERNAL_ACT]->setEnabled( true );
   m_arrayActions[FORCE_NEW_WINDOW_ACT]->setEnabled( hasSubWindow );
-  m_arrayActions[DISABLE_ALL_ACT]->setEnabled( m_pcCalypAppModuleIfList.size() > 0 );
+  m_arrayActions[DISABLE_ALL_ACT]->setEnabled( true );
 
   if( pcSubWindow )
   {
-    QList<CalypAppModuleIf*> 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 );
+    // }
   }
 }
 
@@ -213,22 +209,21 @@ void ModulesHandle::writeSettings()
 
 void ModulesHandle::processOpt( int index )
 {
-  VideoSubWindow* pcSubWindow = qobject_cast<VideoSubWindow*>( m_pcMainWindowManager->activeSubWindow() );
+  VideoSubWindow* pcSubWindow = m_pcMainWindowManager->activeSubWindow<VideoSubWindow>();
   if( pcSubWindow )
   {
     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 );
@@ -263,7 +258,7 @@ void ModulesHandle::activateModule()
   Qt::KeyboardModifiers keyModifiers = QApplication::keyboardModifiers();
   bool bTmpForceNewWindow = false;
 
-  VideoSubWindow* pcVideoSubWindow = qobject_cast<VideoSubWindow*>( m_pcMainWindowManager->activeSubWindow() );
+  VideoSubWindow* pcVideoSubWindow = m_pcMainWindowManager->activeSubWindow<VideoSubWindow>();
   if( !pcVideoSubWindow )
   {
     return;
@@ -275,9 +270,12 @@ void ModulesHandle::activateModule()
   }
 
   QString ModuleIfName = pcAction->data().toString();
-  CalypModuleIf* pcCurrModuleIf =
-      CalypModulesFactory::Get()->CreateModule( ModuleIfName.toLocal8Bit().constData() );
-  CalypAppModuleIf* pcCurrAppModuleIf = new CalypAppModuleIf( this, pcAction, pcCurrModuleIf );
+  auto pcCurrModuleIf = CalypModulesFactory::Get()->CreateModule( ModuleIfName.toLocal8Bit().constData() );
+  if( pcCurrModuleIf == nullptr )
+  {
+    return;
+  }
+  auto pcCurrAppModuleIf = std::make_shared<CalypAppModuleIf>( this, pcAction, std::move( pcCurrModuleIf ) );
 
   QList<VideoSubWindow*> videoSubWindowList;
   int numberOfFrames = pcCurrAppModuleIf->m_pcModule->m_uiNumberOfFrames;
@@ -285,7 +283,7 @@ void ModulesHandle::activateModule()
   {
     int minNumFrames = numberOfFrames;
     int maxNumFrames = numberOfFrames;
-    if( pcCurrAppModuleIf->m_pcModule->m_uiModuleRequirements & CLP_MODULES_VARIABLE_NUM_FRAMES )
+    if( pcCurrAppModuleIf->m_pcModule->m_uiModuleRequirements.is_set( ClpModuleFeature::VariableNumOfFrames ) )
     {
       minNumFrames = numberOfFrames;
       maxNumFrames = 255;
@@ -334,7 +332,7 @@ void ModulesHandle::activateModule()
         {
           videoSubWindowList.clear();
           qobject_cast<MainWindow*>( m_pcParent )->printMessage( "Error! Incompatible frames", CLP_LOG_ERROR );
-          destroyModuleIf( pcCurrAppModuleIf );
+          // destroyModuleIf( pcCurrAppModuleIf );
           return;
         }
       }
@@ -349,7 +347,7 @@ void ModulesHandle::activateModule()
   {
     qobject_cast<MainWindow*>( m_pcParent )
         ->printMessage( "Error! There is no windows to apply the module", CLP_LOG_ERROR );
-    destroyModuleIf( pcCurrAppModuleIf );
+    // destroyModuleIf( pcCurrAppModuleIf );
     return;
   }
 
@@ -358,13 +356,13 @@ void ModulesHandle::activateModule()
     pcCurrAppModuleIf->m_pcSubWindow[i] = videoSubWindowList.at( i );
   }
 
-  if( pcCurrAppModuleIf->m_pcModule->m_uiModuleRequirements & CLP_MODULE_REQUIRES_OPTIONS )
+  if( pcCurrAppModuleIf->m_pcModule->m_uiModuleRequirements.is_set( ClpModuleFeature::Options ) )
   {
-    ModulesHandleOptDialog moduleOptDialog( m_pcParent, pcCurrAppModuleIf );
+    ModulesHandleOptDialog moduleOptDialog( m_pcParent, pcCurrAppModuleIf.get() );
     if( moduleOptDialog.runConfiguration() == QDialog::Rejected )
     {
       qobject_cast<MainWindow*>( m_pcParent )->printMessage( "Module canceled by user!", CLP_LOG_WARNINGS );
-      destroyModuleIf( pcCurrAppModuleIf );
+      // destroyModuleIf( pcCurrAppModuleIf );
       return;
     }
   }
@@ -373,14 +371,12 @@ void ModulesHandle::activateModule()
 
   QString windowName;
 
-  VideoSubWindow* pcModuleSubWindow = NULL;
-  if( pcCurrAppModuleIf->m_pcModule->m_iModuleType == CLP_FRAME_PROCESSING_MODULE )
+  if( pcCurrAppModuleIf->m_pcModule->m_iModuleType == ClpModuleType::FrameProcessing )
   {
-    if( ( pcCurrAppModuleIf->m_pcModule->m_uiModuleRequirements & CLP_MODULE_REQUIRES_NEW_WINDOW ) || bShowModulesNewWindow )
+    if( bShowModulesNewWindow || pcCurrAppModuleIf->m_pcModule->m_uiModuleRequirements.is_set( ClpModuleFeature::NewWindow ) )
     {
-      pcModuleSubWindow = new VideoSubWindow( VideoSubWindow::MODULE_SUBWINDOW );
-      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 ) ) );
@@ -389,11 +385,15 @@ void ModulesHandle::activateModule()
       //      connect( pcModuleSubWindow, SIGNAL( scrollBarMoved_SWindow( const QPoint ) ), m_appModuleVideo,
       //               SLOT( moveAllScrollBars( const QPoint ) ) );
     }
+    else
+    {
+      pcCurrAppModuleIf->m_pcSubWindow[0]->setDisplayModule( pcCurrAppModuleIf.get() );
+    }
   }
-  else if( pcCurrAppModuleIf->m_pcModule->m_iModuleType == CLP_FRAME_MEASUREMENT_MODULE )
+  else if( pcCurrAppModuleIf->m_pcModule->m_iModuleType == ClpModuleType::FrameMeasurement )
   {
     pcCurrAppModuleIf->m_pcDisplaySubWindow = NULL;
-    pcCurrAppModuleIf->m_pcModuleDock = new ModuleHandleDock( m_pcParent, pcCurrAppModuleIf );
+    pcCurrAppModuleIf->m_pcModuleDock = new ModuleHandleDock( m_pcParent, pcCurrAppModuleIf.get() );
     QString titleDockWidget;
     titleDockWidget.append( pcCurrAppModuleIf->m_pcModule->m_pchModuleName );
     titleDockWidget.append( " Information" );
@@ -405,19 +405,9 @@ void ModulesHandle::activateModule()
         ->addDockWidget( Qt::RightDockWidgetArea, pcCurrAppModuleIf->m_pcDockWidget );
   }
 
-  // Associate module with subwindows
-  if( !pcCurrAppModuleIf->m_pcDisplaySubWindow && !pcCurrAppModuleIf->m_pcModuleDock )
+  for( int i = 0; i < videoSubWindowList.size(); i++ )
   {
-    pcCurrAppModuleIf->m_pcSubWindow[0]->enableModule( pcCurrAppModuleIf );
-  }
-  else
-  {
-    if( pcCurrAppModuleIf->m_pcDisplaySubWindow )
-      pcCurrAppModuleIf->m_pcDisplaySubWindow->enableModule( pcCurrAppModuleIf );
-    for( int i = 0; i < videoSubWindowList.size(); i++ )
-    {
-      pcCurrAppModuleIf->m_pcSubWindow[i]->associateModule( pcCurrAppModuleIf );
-    }
+    pcCurrAppModuleIf->m_pcSubWindow[i]->associateModule( pcCurrAppModuleIf );
   }
 
   // Create Module
@@ -440,19 +430,19 @@ void ModulesHandle::activateModule()
   if( !moduleCreated )
   {
     qobject_cast<MainWindow*>( m_pcParent )->printMessage( "Error! Module cannot be created", CLP_LOG_ERROR );
-    destroyModuleIf( pcCurrAppModuleIf );
+    // destroyModuleIf( pcCurrAppModuleIf );
     return;
   }
 
   pcCurrAppModuleIf->apply( false, true );
+
   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
   {
@@ -462,44 +452,39 @@ void ModulesHandle::activateModule()
     videoSubWindowList.at( 0 )->setWindowName( windowName );
   }
 
-  m_pcCalypAppModuleIfList.append( pcCurrAppModuleIf );
+  // Change ownership of the module
+  // if( !pcCurrAppModuleIf->m_pcDisplaySubWindow && !pcCurrAppModuleIf->m_pcModuleDock )
+  // {
+  //   pcCurrAppModuleIf->m_pcSubWindow[0]->enableModule( pcCurrAppModuleIf );
+  // }
+  // else if( pcCurrAppModuleIf->m_pcDisplaySubWindow )
+  // {
+  //   pcCurrAppModuleIf->m_pcDisplaySubWindow->enableModule( pcCurrAppModuleIf );
+  // }
 
   emit changed();
 }
 
-void ModulesHandle::destroyModuleIf( CalypAppModuleIf* pcCurrModuleIf )
-{
-  if( pcCurrModuleIf )
-  {
-    pcCurrModuleIf->destroy();
-  }
-}
-
 void ModulesHandle::destroyWindowModules()
 {
-  VideoSubWindow* pcVideoSubWindow = qobject_cast<VideoSubWindow*>( m_pcMainWindowManager->activeSubWindow() );
+  VideoSubWindow* pcVideoSubWindow = m_pcMainWindowManager->activeSubWindow<VideoSubWindow>();
   if( pcVideoSubWindow )
   {
-    pcVideoSubWindow->disableModule();
+    pcVideoSubWindow->disableAllModules();
     emit changed();
   }
 }
 
 void ModulesHandle::destroyAllModulesIf()
 {
-  for( int i = 0; i < m_pcCalypAppModuleIfList.size(); i++ )
+  bool emit_changed = false;
+  QList<SubWindowAbstract*> windowsList = m_pcMainWindowManager->findSubWindow( SubWindowAbstract::VIDEO_SUBWINDOW );
+  for( auto window : windowsList )
   {
-    destroyModuleIf( m_pcCalypAppModuleIfList.at( i ) );
-  }
-  emit changed();
-}
-
-void ModulesHandle::applyModuleIf( QList<CalypAppModuleIf*> pcCurrModuleIfList, bool isPlaying, bool disableThreads )
-{
-  for( int i = 0; i < pcCurrModuleIfList.size() && !isPlaying; i++ )
-  {
-    pcCurrModuleIfList.at( i )->apply( isPlaying, disableThreads );
+    emit_changed |= qobject_cast<VideoSubWindow*>( window )->disableAllModules();
   }
+  if( emit_changed )
+    emit changed();
 }
 
 void ModulesHandle::applyAllModuleIf( CalypAppModuleIf* pcCurrModuleIf )
@@ -508,21 +493,18 @@ void ModulesHandle::applyAllModuleIf( CalypAppModuleIf* pcCurrModuleIf )
   {
     if( !pcCurrModuleIf->m_pcModuleStream )
     {
-      unsigned int Width = 0, Height = 0, FrameRate = 30;
-      int BitsPixel, InputFormat = -1;
-
       QString supported = tr( "Supported Files (" );
       QStringList formatsList;
       std::vector<CalypStreamFormat> supportedFmts = CalypStream::supportedWriteFormats();
 
       for( unsigned int i = 0; i < supportedFmts.size(); i++ )
       {
-        std::vector<ClpString> arrayExt = supportedFmts[i].getExts();
+        std::vector<std::string> arrayExt = supportedFmts[i].getExts();
         if( arrayExt.size() > 0 )
         {
           QString currFmt( QString::fromStdString( supportedFmts[i].formatName ) );
           currFmt.append( " (" );
-          for( std::vector<ClpString>::iterator e = arrayExt.begin(); e != arrayExt.end(); ++e )
+          for( std::vector<std::string>::iterator e = arrayExt.begin(); e != arrayExt.end(); ++e )
           {
             supported.append( " *." );
             currFmt.append( "*." );
@@ -543,18 +525,17 @@ void ModulesHandle::applyAllModuleIf( CalypAppModuleIf* pcCurrModuleIf )
       {
         return;
       }
-      Width = pcCurrModuleIf->m_pcProcessedFrame->getWidth();
-      Height = pcCurrModuleIf->m_pcProcessedFrame->getHeight();
-      InputFormat = pcCurrModuleIf->m_pcProcessedFrame->getPelFormat();
-      BitsPixel = pcCurrModuleIf->m_pcProcessedFrame->getBitsPel();
-      FrameRate = pcCurrModuleIf->m_pcSubWindow[0]->getInputStream()->getFrameRate();
+      auto Width = pcCurrModuleIf->m_pcProcessedFrame->getWidth();
+      auto Height = pcCurrModuleIf->m_pcProcessedFrame->getHeight();
+      auto InputFormat = pcCurrModuleIf->m_pcProcessedFrame->getPelFormat();
+      auto BitsPixel = pcCurrModuleIf->m_pcProcessedFrame->getBitsPel();
+      auto FrameRate = 30;
 
-      pcCurrModuleIf->m_pcModuleStream = new CalypStream;
+      pcCurrModuleIf->m_pcModuleStream = std::unique_ptr<CalypStream>();
       if( !pcCurrModuleIf->m_pcModuleStream->open( fileName.toStdString(), Width, Height, InputFormat, BitsPixel,
-                                                   CLP_LITTLE_ENDIAN, FrameRate, false ) )
+                                                   CLP_LITTLE_ENDIAN, FrameRate, CalypStream::Type::Output ) )
       {
-        delete pcCurrModuleIf->m_pcModuleStream;
-        pcCurrModuleIf->m_pcModuleStream = NULL;
+        pcCurrModuleIf->m_pcModuleStream = nullptr;
         return;
       }
     }
@@ -562,11 +543,11 @@ void ModulesHandle::applyAllModuleIf( CalypAppModuleIf* pcCurrModuleIf )
   if( pcCurrModuleIf->m_pcModuleStream )
   {
     unsigned int numberOfWindows = pcCurrModuleIf->m_pcModule->m_uiNumberOfFrames;
-    ClpULong currFrames = 0;
-    ClpULong numberOfFrames = -1;
+    std::uint64_t currFrames = 0;
+    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();
@@ -576,11 +557,10 @@ void ModulesHandle::applyAllModuleIf( CalypAppModuleIf* pcCurrModuleIf )
     {
       pcCurrModuleIf->apply( false, true );
       QCoreApplication::processEvents();
-      pcCurrModuleIf->m_pcModuleStream->writeFrame( pcCurrModuleIf->m_pcProcessedFrame );
+      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++ )
@@ -606,12 +586,15 @@ void ModulesHandle::swapModulesWindowsIf( CalypAppModuleIf* pcCurrModuleIf )
 void ModulesHandle::customEvent( QEvent* event )
 {
   if( !event )
-  {
     return;
-  }
+
   CalypAppModuleIf::EventData* eventData = (CalypAppModuleIf::EventData*)event;
   if( eventData->m_bSuccess )
   {
+    event->accept();
+    // The module could be freed by the time the event is processed
+    if( eventData->m_pcModule.isNull() )
+      return;
     eventData->m_pcModule->show();
   }
 }

app/ModulesHandle.h

@@ -1,5 +1,5 @@
 /*    This file is a part of Calyp project
- *    Copyright (C) 2014-2019  by Joao Carreira   (jfmcarreira@gmail.com)
+ *    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
@@ -24,15 +24,14 @@
 #ifndef __MODULESHANDLE_H__
 #define __MODULESHANDLE_H__
 
-#include "config.h"
-
+#include <QtCore>
+#include <QtWidgets>
 #include <cstdio>
 #include <iostream>
 
-#include <QtCore>
-#include <QtWidgets>
 #include "CalypAppModuleIf.h"
 #include "CommonDefs.h"
+#include "config.h"
 #include "lib/CalypFrame.h"
 
 class VideoHandle;
@@ -40,7 +39,7 @@ class SubWindowHandle;
 class CalypAppModuleIf;
 class SubWindowHandle;
 
-class ModulesHandle : public QWidget
+class ModulesHandle : public QObject
 {
   Q_OBJECT
 public:
@@ -56,10 +55,6 @@ public:
   void readSettings();
   void writeSettings();
 
-  static void destroyModuleIf( CalypAppModuleIf* pcCurrModuleIf );
-  static void applyModuleIf( QList<CalypAppModuleIf*> pcCurrModuleIfList, bool isPlaying = false,
-                             bool disableThreads = false );
-
 private:
   QWidget* m_pcParent;
   SubWindowHandle* m_pcMainWindowManager;

app/PlotSubWindow.cpp

@@ -1,5 +1,5 @@
 /*    This file is a part of Calyp project
- *    Copyright (C) 2014-2019  by Joao Carreira   (jfmcarreira@gmail.com)
+ *    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
@@ -24,8 +24,11 @@
 
 #include "PlotSubWindow.h"
 
+#include <QGuiApplication>
+#include <QScreen>
+#include <QSize>
+
 #include "qcustomplot.h"
-//#include "external/qcustomplot/qcustomplot.h"
 
 void PlotSubWindow::definePlotColors()
 {
@@ -174,7 +177,7 @@ QSize PlotSubWindow::sizeHint() const
   }
   else
   {
-    maxSize = QApplication::desktop()->availableGeometry().size();
+    maxSize = QGuiApplication::screens()[0]->availableGeometry().size();
   }
   return sizeHint( maxSize );
 }

app/PlotSubWindow.h

@@ -1,5 +1,5 @@
 /*    This file is a part of Calyp project
- *    Copyright (C) 2014-2019  by Joao Carreira   (jfmcarreira@gmail.com)
+ *    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
@@ -25,12 +25,12 @@
 #ifndef __PLOTWINDOWHANDLE_H__
 #define __PLOTWINDOWHANDLE_H__
 
+#include <QtWidgets>
+
 #include "CommonDefs.h"
 #include "SubWindowAbstract.h"
 #include "config.h"
 
-#include <QtWidgets>
-
 class QCustomPlot;
 
 class PlotSubWindow : public SubWindowAbstract

app/QualityHandle.cpp

@@ -1,5 +1,5 @@
 /*    This file is a part of Calyp project
- *    Copyright (C) 2014-2019  by Joao Carreira   (jfmcarreira@gmail.com)
+ *    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
@@ -24,18 +24,17 @@
 
 #include "QualityHandle.h"
 
+#include <QtGui>
+
 #include "PlotSubWindow.h"
 #include "ProgressBar.h"
+#include "QtConcurrent/qtconcurrentrun.h"
 #include "SubWindowHandle.h"
 #include "SubWindowSelectorDialog.h"
 #include "VideoSubWindow.h"
-#include "lib/LibMemory.h"
-
-#include <QtGui>
-#include "QtConcurrent/qtconcurrentrun.h"
 
 QualityHandle::QualityHandle( QWidget* parent, SubWindowHandle* windowManager )
-    : m_pcParet( parent ), m_pcMainWindowManager( windowManager )
+    : m_pcParent( parent ), m_pcMainWindowManager( windowManager )
 {
 }
 
@@ -71,7 +70,7 @@ void QualityHandle::createActions()
 
 QMenu* QualityHandle::createMenu()
 {
-  m_pcMenuQuality = new QMenu( "Quality", this );
+  m_pcMenuQuality = new QMenu( "Quality", m_pcParent );
   m_pcSubMenuQualityMetrics = m_pcMenuQuality->addMenu( "Quality Metrics" );
   m_pcSubMenuQualityMetrics->addActions( m_actionGroupQualityMetric->actions() );
   m_pcMenuQuality->addAction( m_arrayActions[SELECT_CURR_REF_ACT] );
@@ -83,8 +82,8 @@ QMenu* QualityHandle::createMenu()
 
 QDockWidget* QualityHandle::createDock()
 {
-  m_pcQualityHandleSideBar = new QualityMeasurementSidebar( m_pcParet, m_pcMainWindowManager );
-  m_pcQualityHandleDock = new QDockWidget( tr( "Quality Measurement" ), this );
+  m_pcQualityHandleSideBar = new QualityMeasurementSidebar( m_pcParent, m_pcMainWindowManager );
+  m_pcQualityHandleDock = new QDockWidget( tr( "Quality Measurement" ), m_pcParent );
   m_pcQualityHandleDock->setAllowedAreas( Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea );
   m_pcQualityHandleDock->setWidget( m_pcQualityHandleSideBar );
 
@@ -99,7 +98,7 @@ QDockWidget* QualityHandle::createDock()
 
 void QualityHandle::updateMenus()
 {
-  VideoSubWindow* pcCurrentVideoSubWindow = qobject_cast<VideoSubWindow*>( m_pcMainWindowManager->activeSubWindow() );
+  VideoSubWindow* pcCurrentVideoSubWindow = m_pcMainWindowManager->activeSubWindow<VideoSubWindow>();
   bool hasSubWindow = pcCurrentVideoSubWindow ? true : false;
   bool hasReference = false;
   bool isReference = false;
@@ -157,8 +156,8 @@ void QualityHandle::update( VideoSubWindow* currSubWindow )
 void QualityHandle::measureQuality( QVector<VideoSubWindow*> apcWindowList )
 {
   unsigned numberOfWindows = apcWindowList.size();
-  ClpULong currFrames = 0;
-  ClpULong numberOfFrames = -1;
+  std::uint64_t currFrames = 0;
+  std::uint64_t numberOfFrames = -1;
 
   //! Check reference window
   for( unsigned i = 0; i < numberOfWindows; i++ )
@@ -170,21 +169,20 @@ 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();
   }
   pcReferenceWindow->stop();
 
-  ProgressBar* pcProgressBar = new ProgressBar( m_pcParet, numberOfFrames );
+  ProgressBar* pcProgressBar = new ProgressBar( m_pcParent, numberOfFrames );
 
   QVector<double>* padQualityValues = new QVector<double>[numberOfWindows + 1];
   double* padAverageQuality = new double[numberOfWindows + 1];
-  double dCurrentQuality;
 
   for( unsigned i = 0; i < numberOfWindows + 1; i++ )
   {
@@ -200,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++ )
@@ -249,7 +247,7 @@ void QualityHandle::slotQualityMetricChanged( int idx )
 
 void QualityHandle::slotSelectCurrentAsReference()
 {
-  VideoSubWindow* pcRefSubWindow = qobject_cast<VideoSubWindow*>( m_pcMainWindowManager->activeSubWindow() );
+  VideoSubWindow* pcRefSubWindow = m_pcMainWindowManager->activeSubWindow<VideoSubWindow>();
   if( pcRefSubWindow )
   {
     VideoSubWindow* pcVideoSubWindow;
@@ -269,7 +267,7 @@ void QualityHandle::slotSelectCurrentAsReference()
 
 void QualityHandle::slotPlotQualitySingle()
 {
-  VideoSubWindow* pcSubWindow = qobject_cast<VideoSubWindow*>( m_pcMainWindowManager->activeSubWindow() );
+  VideoSubWindow* pcSubWindow = m_pcMainWindowManager->activeSubWindow<VideoSubWindow>();
   if( pcSubWindow )
   {
     if( pcSubWindow->getRefSubWindow() )
@@ -293,7 +291,7 @@ void QualityHandle::slotPlotQualitySingle()
 
 void QualityHandle::slotPlotQualitySeveral()
 {
-  VideoSubWindow* pcSubWindow = qobject_cast<VideoSubWindow*>( m_pcMainWindowManager->activeSubWindow() );
+  VideoSubWindow* pcSubWindow = m_pcMainWindowManager->activeSubWindow<VideoSubWindow>();
   if( pcSubWindow )
   {
     QVector<VideoSubWindow*> apcWindowList;

app/QualityHandle.h

@@ -1,5 +1,5 @@
 /*    This file is a part of Calyp project
- *    Copyright (C) 2014-2019  by Joao Carreira   (jfmcarreira@gmail.com)
+ *    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
@@ -25,17 +25,18 @@
 #ifndef __QUALITYMEASUREMENT_H__
 #define __QUALITYMEASUREMENT_H__
 
+#include <QFuture>
 #include <QtCore>
 #include <QtWidgets>
+
 #include "CommonDefs.h"
-#include "QFuture"
 #include "QualityMeasurementSidebar.h"
 #include "config.h"
 
 class SubWindowHandle;
 class VideoSubWindow;
 
-class QualityHandle : public QWidget
+class QualityHandle : public QObject
 {
   Q_OBJECT
 public:
@@ -53,7 +54,7 @@ public:
   void update( VideoSubWindow* currSubWindow );
 
 private:
-  QWidget* m_pcParet;
+  QWidget* m_pcParent;
   SubWindowHandle* m_pcMainWindowManager;
 
   enum

app/ResourceHandle.cpp

@@ -0,0 +1,167 @@
+/*    This file is a part of Calyp project
+ *    Copyright (C) 2014-2021  by Joao Carreira   (jfmcarreira@gmail.com)
+ *                                Luis Lucas      (luisfrlucas@gmail.com)
+ *                                Joao Santos     (joaompssantos@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     ResourceHandle.cpp
+ * \brief    Handle resources
+ */
+
+#include "ResourceHandle.h"
+
+#include <QCoreApplication>
+#include <QEvent>
+#include <QFileInfo>
+#include <QMutex>
+#include <QThread>
+#include <chrono>
+#include <iostream>
+#include <memory>
+#include <optional>
+
+ResourceWorker::ResourceWorker( std::shared_ptr<CalypStream> stream )
+{
+  m_pcStream = stream;
+}
+
+void ResourceWorker::stop()
+{
+  m_bStop = true;
+  wake();
+  wait();
+}
+
+void ResourceWorker::wake()
+{
+  m_Mutex.lock();
+  m_ResourceIdle.wakeAll();
+  m_Mutex.unlock();
+}
+
+void ResourceWorker::run()
+{
+  m_bStop = false;
+  // Loop forever
+  while( !m_bStop )
+  {
+    //auto start = std::chrono::steady_clock::now();
+    m_pcStream->readNextFrameFillRGBBuffer();
+    // auto end = std::chrono::steady_clock::now();
+    // std::cout << "Elapsed time reading and processing a frame: "
+    //           << std::chrono::duration_cast<std::chrono::milliseconds>( end - start ).count()
+    //           << " ms" << std::endl;
+
+    // if( !m_pcStream->hasWritingSlot() )
+    // {
+    //   m_Mutex.lock();
+    //   m_ResourceIdle.wait( &m_Mutex );
+    //   m_Mutex.unlock();
+    // }
+    while( !m_bStop && !m_pcStream->hasWritingSlot() )
+    {
+      // Wait here
+    }
+  }
+}
+
+ResourceHandle::ResourceHandle()
+{
+}
+
+auto ResourceHandle::addResource() -> std::size_t
+{
+  auto resource_id = unique_id;
+  unique_id++;
+  auto newStreamResource = std::make_shared<CalypStream>();
+  auto newStreamResourceWorker = std::make_unique<ResourceWorker>( newStreamResource );
+  m_apcStreamResourcesList[resource_id] = newStreamResource;
+  m_apcStreamResourcesWorkersList[resource_id] = std::move( newStreamResourceWorker );
+  return resource_id;
+}
+
+auto ResourceHandle::getResource( CalypStream* ptr ) -> std::size_t
+{
+  if( ptr != nullptr )
+  {
+    for( std::size_t i = 0; i < m_apcStreamResourcesList.size(); i++ )
+    {
+      if( m_apcStreamResourcesList[i].get() == ptr )
+        return i;
+    }
+  }
+  return addResource();
+}
+
+auto ResourceHandle::getResourceAsset( std::size_t id ) -> CalypStream*
+{
+  if( m_apcStreamResourcesWorkersList.count( id ) )
+  {
+    return m_apcStreamResourcesList[id].get();
+  }
+  return nullptr;
+}
+
+void ResourceHandle::removeResource( std::size_t id )
+{
+  if( !m_apcStreamResourcesWorkersList.count( id ) )
+  {
+    assert( false );
+    return;
+  }
+
+  // Remove worker first
+  m_apcStreamResourcesWorkersList[id]->stop();
+  m_apcStreamResourcesWorkersList[id] = nullptr;
+
+  // Then the underlying stream
+  m_apcStreamResourcesList[id] = nullptr;
+}
+
+void ResourceHandle::stopResourceWorker( std::size_t id )
+{
+  if( !m_apcStreamResourcesWorkersList.count( id ) )
+  {
+    assert( false );
+    return;
+  }
+  m_apcStreamResourcesWorkersList[id]->stop();
+}
+
+void ResourceHandle::startResourceWorker( std::size_t id )
+{
+  if( !m_apcStreamResourcesWorkersList.count( id ) )
+  {
+    assert( false );
+    return;
+  }
+  m_apcStreamResourcesWorkersList[id]->setObjectName(
+      "RW-" +
+      QFileInfo( QString::fromStdString( m_apcStreamResourcesList[id]->getFileName() ) ).completeBaseName() );
+  m_apcStreamResourcesWorkersList[id]->start();
+}
+
+void ResourceHandle::wakeResourceWorker( std::size_t id )
+{
+  if( !m_apcStreamResourcesWorkersList.count( id ) )
+  {
+    assert( false );
+    return;
+  }
+  m_apcStreamResourcesWorkersList[id]->wake();
+}

app/ResourceHandle.h

@@ -0,0 +1,73 @@
+/*    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     ResourceHandle.h
+ * \brief    Handle multiple sub-windows
+ */
+
+#ifndef __RESOURCEHANDLE_H__
+#define __RESOURCEHANDLE_H__
+
+#include <QMutex>
+#include <QThread>
+#include <QVector>
+#include <QWaitCondition>
+
+#include "CommonDefs.h"
+#include "lib/CalypStream.h"
+
+class ResourceWorker : public QThread
+{
+private:
+  QMutex m_Mutex;
+  QWaitCondition m_ResourceIdle;
+  std::shared_ptr<CalypStream> m_pcStream;
+  bool m_bStop{ false };
+
+public:
+  ResourceWorker( std::shared_ptr<CalypStream> stream );
+  void stop();
+  void wake();
+  void run();
+};
+
+class ResourceHandle
+{
+public:
+  ResourceHandle();
+  ~ResourceHandle() = default;
+
+  auto getResource( CalypStream* ptr ) -> std::size_t;
+  auto getResourceAsset( std::size_t id ) -> CalypStream*;
+  void removeResource( std::size_t id );
+  void stopResourceWorker( std::size_t id );
+  void startResourceWorker( std::size_t id );
+  void wakeResourceWorker( std::size_t id );
+
+private:
+  auto addResource() -> std::size_t;
+
+private:
+  std::size_t unique_id{ 0 };
+  std::map<std::size_t, std::shared_ptr<CalypStream>> m_apcStreamResourcesList;
+  std::map<std::size_t, std::unique_ptr<ResourceWorker>> m_apcStreamResourcesWorkersList;
+};
+
+#endif  // __RESOURCEHANDLE_H__

app/SubWindowAbstract.cpp

@@ -1,5 +1,5 @@
 /*    This file is a part of Calyp project
- *    Copyright (C) 2014-2019  by Joao Carreira   (jfmcarreira@gmail.com)
+ *    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
@@ -24,14 +24,16 @@
 
 #include "SubWindowAbstract.h"
 
-#include "MdiSubWindow.h"
-
 #include <QCloseEvent>
 #include <QFocusEvent>
+#include <QGuiApplication>
 #include <QHBoxLayout>
 #include <QIcon>
+#include <QScreen>
 #include <QScrollBar>
 
+#include "MdiSubWindow.h"
+
 SubWindowAbstract::SubWindowAbstract( QWidget* parent, unsigned int category )
     : QWidget( parent ), m_cSubWindow( NULL )
 {
@@ -40,7 +42,7 @@ SubWindowAbstract::SubWindowAbstract( QWidget* parent, unsigned int category )
   // setFocusPolicy( Qt::WheelFocus );
   setFocusPolicy( Qt::StrongFocus );
   setAttribute( Qt::WA_DeleteOnClose );
-  setBackgroundRole( QPalette::Background );
+  setBackgroundRole( QPalette::Window );
 
   setWindowIcon( QIcon( ":/logos/calyp-icon.png" ) );
 
@@ -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();
 }

app/SubWindowAbstract.h

@@ -1,5 +1,5 @@
 /*    This file is a part of Calyp project
- *    Copyright (C) 2014-2019  by Joao Carreira   (jfmcarreira@gmail.com)
+ *    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
@@ -41,6 +41,7 @@
 #include <QSize>
 #include <QString>
 #include <QWidget>
+
 #include "CommonDefs.h"
 #include "config.h"
 
@@ -106,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

app/SubWindowHandle.cpp

@@ -1,5 +1,5 @@
 /*    This file is a part of Calyp project
- *    Copyright (C) 2014-2019  by Joao Carreira   (jfmcarreira@gmail.com)
+ *    Copyright (C) 2014-2021  by Joao Carreira   (jfmcarreira@gmail.com)
  *                                Luis Lucas      (luisfrlucas@gmail.com)
  *                                Joao Santos     (joaompssantos@gmail.com)
  *
@@ -25,29 +25,31 @@
 
 #include "SubWindowHandle.h"
 
-#include "MainWindow.h"
-#include "MdiSubWindow.h"
-#include "SubWindowAbstract.h"
-
 #include <QAction>
 #include <QActionGroup>
 #include <QApplication>
 #include <QDesktopWidget>
+#include <QGuiApplication>
 #include <QHBoxLayout>
 #include <QMdiArea>
 #include <QMenu>
 #include <QPainter>
+#include <QScreen>
 #include <QSettings>
 #include <QSignalMapper>
 #include <QStyle>
 
+#include "MainWindow.h"
+#include "MdiSubWindow.h"
+#include "SubWindowAbstract.h"
+
 class MdiArea : public QMdiArea
 {
 public:
   MdiArea( QWidget* parent = 0 )
       : QMdiArea( parent ), m_pixmapLogo( ":/logos/calyp-logo.png" )
   {
-    setBackgroundRole( QPalette::Background );
+    setBackgroundRole( QPalette::Window );
   }
 
   void appendLogMessage( const QString& msg )
@@ -83,7 +85,7 @@ private:
 };
 
 SubWindowHandle::SubWindowHandle( QWidget* parent )
-    : QWidget( parent )
+    : m_pcApp( qobject_cast<MainWindow*>( parent ) )
 {
   m_iWindowMode = -1;
   m_pcWindowManagerLayout = NULL;
@@ -92,7 +94,7 @@ SubWindowHandle::SubWindowHandle( QWidget* parent )
   m_apcSubWindowList.clear();
   m_apcMdiSubWindowList.clear();
 
-  m_pcApp = qobject_cast<MainWindow*>( parentWidget() );
+  m_pcCentralWidget = new QWidget;
   // setWindowMode( DETACHEDSUBWINDOWMODE );
   setWindowMode( MDISUBWINDOWMODE );
 }
@@ -150,11 +152,11 @@ void SubWindowHandle::setWindowMode( int iWindowMode )
       m_apcSubWindowList.at( i )->resize( m_apcSubWindowList.at( i )->sizeHint() );
       m_apcSubWindowList.at( i )->show();
     }
-    setVisible( false );
-    parentWidget()->update();
+    m_pcCentralWidget->setVisible( false );
+    m_pcApp->update();
     m_pcApp->showNormal();
     qApp->processEvents();
-    QSize screenSize = QApplication::desktop()->availableGeometry().size();
+    QSize screenSize = QGuiApplication::screens()[0]->availableGeometry().size();
     m_pcApp->move( 0, 0 );
     m_pcApp->resize( screenSize.width(), 5 );
     m_pcApp->setWindowTitle( QApplication::applicationName() );
@@ -162,13 +164,13 @@ void SubWindowHandle::setWindowMode( int iWindowMode )
 
   if( iWindowMode == MDISUBWINDOWMODE )
   {
-    setVisible( true );
+    m_pcCentralWidget->setVisible( true );
     m_pcMdiArea = new MdiArea;
     m_pcMdiArea->setActivationOrder( QMdiArea::ActivationHistoryOrder );
     connect( m_pcMdiArea, SIGNAL( subWindowActivated( QMdiSubWindow* ) ), this, SLOT( updateActiveSubWindow() ) );
-    m_pcWindowManagerLayout = new QHBoxLayout( this );
+    m_pcWindowManagerLayout = new QHBoxLayout( m_pcCentralWidget );
     m_pcWindowManagerLayout->addWidget( m_pcMdiArea );
-    setLayout( m_pcWindowManagerLayout );
+    m_pcCentralWidget->setLayout( m_pcWindowManagerLayout );
     for( int i = 0; i < m_apcSubWindowList.size(); i++ )
     {
       addMdiSubWindow( m_apcSubWindowList.at( i ) );
@@ -180,6 +182,10 @@ void SubWindowHandle::setWindowMode( int iWindowMode )
     {
       m_pcApp->setWindowTitle( QApplication::applicationName() + " :: " + m_pcActiveWindow->getWindowName() );
     }
+    else
+    {
+      m_pcApp->setWindowTitle( QApplication::applicationName() );
+    }
   }
   m_iWindowMode = iWindowMode;
   // tileSubWindows();
@@ -216,6 +222,10 @@ void SubWindowHandle::updateActiveSubWindow( SubWindowAbstract* window )
     {
       m_pcApp->setWindowTitle( QApplication::applicationName() + " :: " + m_pcActiveWindow->getWindowName() );
     }
+    else
+    {
+      m_pcApp->setWindowTitle( QApplication::applicationName() );
+    }
   }
 }
 
@@ -230,12 +240,14 @@ void SubWindowHandle::addMdiSubWindow( SubWindowAbstract* window )
            SLOT( removeMdiSubWindow( MdiSubWindow* ) ) );
 }
 
-void SubWindowHandle::addSubWindow( SubWindowAbstract* window, Qt::WindowFlags flags )
+void SubWindowHandle::addSubWindow( SubWindowAbstract* window )
 {
   if( window )
   {
-    connect( window, SIGNAL( updateStatusBar( const QString& ) ), m_pcApp, SLOT( printMessage( const QString& ) ) );
-    connect( window, SIGNAL( zoomFactorChanged( const double, const QPoint ) ), m_pcApp, SLOT( updateZoomFactorSBox() ) );
+    connect( window, SIGNAL( updateStatusBar( const QString& ) ), m_pcApp,
+             SLOT( printMessage( const QString& ) ) );
+    connect( window, SIGNAL( zoomFactorChanged( const double, const QPoint ) ), m_pcApp,
+             SLOT( updateZoomFactorSBox() ) );
     if( m_iWindowMode == DETACHEDSUBWINDOWMODE )
     {
       connect( window, SIGNAL( aboutToActivate( SubWindowAbstract* ) ), this,
@@ -274,7 +286,12 @@ void SubWindowHandle::removeSubWindow( int windowIdx )
     if( !m_apcSubWindowList.isEmpty() )
       m_apcSubWindowList.front()->setFocus();
     else
-      m_pcActiveWindow = NULL;
+      m_pcActiveWindow = nullptr;
+
+    if( m_pcActiveWindow == nullptr )
+    {
+      m_pcApp->setWindowTitle( QApplication::applicationName() );
+    }
 
     emit changed();
   }
@@ -303,11 +320,6 @@ void SubWindowHandle::removeActiveSubWindow()
   removeSubWindow( m_pcActiveWindow );
 }
 
-SubWindowAbstract* SubWindowHandle::activeSubWindow() const
-{
-  return m_pcActiveWindow;
-}
-
 QList<SubWindowAbstract*> SubWindowHandle::findSubWindow( const unsigned int uiCategory ) const
 {
   QList<SubWindowAbstract*> apcSubWindowList;
@@ -378,7 +390,7 @@ void SubWindowHandle::tileSubWindows()
 
   if( m_iWindowMode == DETACHEDSUBWINDOWMODE )
   {
-    QSize screenSize = QApplication::desktop()->availableGeometry().size();
+    QSize screenSize = QGuiApplication::screens()[0]->availableGeometry().size();
     unsigned int minWindowsInRow = 1;
     while( ( screenSize.width() / minWindowsInRow ) > 500 )
     {
@@ -474,12 +486,12 @@ void SubWindowHandle::createActions()
   m_actionGroupWindowMode->actions().at( m_iWindowMode )->setChecked( true );
 
   m_arrayActions[CLOSE_ACT] = new QAction( tr( "&Close" ), this );
-  m_arrayActions[CLOSE_ACT]->setIcon( style()->standardIcon( QStyle::SP_DialogCloseButton ) );
+  m_arrayActions[CLOSE_ACT]->setIcon( m_pcApp->style()->standardIcon( QStyle::SP_DialogCloseButton ) );
   m_arrayActions[CLOSE_ACT]->setStatusTip( tr( "Close the active window" ) );
   connect( m_arrayActions[CLOSE_ACT], SIGNAL( triggered() ), this, SLOT( removeActiveSubWindow() ) );
 
   m_arrayActions[CLOSE_ACT] = new QAction( tr( "&Close" ), this );
-  m_arrayActions[CLOSE_ACT]->setIcon( style()->standardIcon( QStyle::SP_DialogCloseButton ) );
+  m_arrayActions[CLOSE_ACT]->setIcon( m_pcApp->style()->standardIcon( QStyle::SP_DialogCloseButton ) );
   m_arrayActions[CLOSE_ACT]->setStatusTip( tr( "Close the active window" ) );
   connect( m_arrayActions[CLOSE_ACT], SIGNAL( triggered() ), this, SLOT( removeActiveSubWindow() ) );
 
@@ -502,14 +514,14 @@ void SubWindowHandle::createActions()
 
   m_arrayActions[NEXT_WINDOWS_ACT] = new QAction( tr( "Ne&xt" ), this );
   m_arrayActions[NEXT_WINDOWS_ACT]->setShortcuts( QKeySequence::NextChild );
-  m_arrayActions[NEXT_WINDOWS_ACT]->setIcon( QIcon( style()->standardIcon( QStyle::SP_ArrowRight ) ) );
+  m_arrayActions[NEXT_WINDOWS_ACT]->setIcon( QIcon( m_pcApp->style()->standardIcon( QStyle::SP_ArrowRight ) ) );
   m_arrayActions[NEXT_WINDOWS_ACT]->setStatusTip( tr( "Move the focus to the next window" ) );
   //  connect( m_arrayActions[NEXT_WINDOWS_ACT], SIGNAL( triggered() ), this,
   //  SLOT( activateNextSubWindow() ) );
 
   m_arrayActions[PREVIOUS_WINDOWS_ACT] = new QAction( tr( "Pre&vious" ), this );
   m_arrayActions[PREVIOUS_WINDOWS_ACT]->setShortcuts( QKeySequence::PreviousChild );
-  m_arrayActions[PREVIOUS_WINDOWS_ACT]->setIcon( QIcon( style()->standardIcon( QStyle::SP_ArrowLeft ) ) );
+  m_arrayActions[PREVIOUS_WINDOWS_ACT]->setIcon( QIcon( m_pcApp->style()->standardIcon( QStyle::SP_ArrowLeft ) ) );
   m_arrayActions[PREVIOUS_WINDOWS_ACT]->setStatusTip( tr( "Move the focus to the previous window" ) );
   //  connect( m_arrayActions[PREVIOUS_WINDOWS_ACT], SIGNAL( triggered() ),
   //  this, SLOT( activatePreviousSubWindow() ) );
@@ -520,12 +532,17 @@ void SubWindowHandle::createActions()
 
 QMenu* SubWindowHandle::createMenu()
 {
-  m_pcMenuWindow = new QMenu( "&Window", this );
+  m_pcMenuWindow = new QMenu( "&Window", m_pcApp );
   updateMenu();
   connect( m_pcMenuWindow, SIGNAL( aboutToShow() ), this, SLOT( updateMenu() ) );
   return m_pcMenuWindow;
 }
 
+auto SubWindowHandle::getWidget() -> QWidget*
+{
+  return m_pcCentralWidget;
+}
+
 void SubWindowHandle::updateMenu()
 {
   m_pcMenuWindow->clear();

app/SubWindowHandle.h

@@ -1,5 +1,5 @@
 /*    This file is a part of Calyp project
- *    Copyright (C) 2014-2019  by Joao Carreira   (jfmcarreira@gmail.com)
+ *    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
@@ -25,12 +25,12 @@
 #ifndef __SUBWINDOWHANDLE_H__
 #define __SUBWINDOWHANDLE_H__
 
-#include "CommonDefs.h"
-
 #include <QString>
 #include <QVector>
 #include <QWidget>
 
+#include "CommonDefs.h"
+
 class QAction;
 class QActionGroup;
 class QHBoxLayout;
@@ -42,7 +42,7 @@ class SubWindowAbstract;
 class MdiArea;
 class MdiSubWindow;
 
-class SubWindowHandle : public QWidget
+class SubWindowHandle : public QObject
 {
   Q_OBJECT
 
@@ -51,9 +51,14 @@ public:
 
   void processLogMsg( const QString& msg );
 
-  void addSubWindow( SubWindowAbstract* widget, Qt::WindowFlags flags = 0 );
+  void addSubWindow( SubWindowAbstract* widget );
 
-  SubWindowAbstract* activeSubWindow() const;
+  template <class T = SubWindowAbstract>
+  T* activeSubWindow() const
+  {
+    static_assert( std::is_base_of<SubWindowAbstract, T>::value, "T must inherit from SubWindowAbstract" );
+    return qobject_cast<T*>( m_pcActiveWindow );
+  }
 
   QList<SubWindowAbstract*> findSubWindow( const unsigned int uiCategory = 0 ) const;
   QList<SubWindowAbstract*> findSubWindow( const QString& aName, const unsigned int uiCategory = 0 ) const;
@@ -62,6 +67,8 @@ public:
   void createActions();
   QMenu* createMenu();
 
+  auto getWidget() -> QWidget*;
+
   void readSettings();
   void writeSettings();
 
@@ -76,6 +83,7 @@ private:
   int m_iWindowMode;
   QList<SubWindowAbstract*> m_apcSubWindowList;
 
+  QWidget* m_pcCentralWidget;
   QHBoxLayout* m_pcWindowManagerLayout;
   MdiArea* m_pcMdiArea;
   QList<MdiSubWindow*> m_apcMdiSubWindowList;

app/VideoHandle.cpp

@@ -1,5 +1,5 @@
 /*    This file is a part of Calyp project
- *    Copyright (C) 2014-2019  by Joao Carreira   (jfmcarreira@gmail.com)
+ *    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
@@ -24,50 +24,53 @@
 
 #include "VideoHandle.h"
 
+#include <QDockWidget>
+#include <QElapsedTimer>
+#include <QLabel>
+#include <QSignalMapper>
+#include <QSlider>
+#include <QTimer>
+#include <QToolBar>
+#include <QtGui>
+#include <memory>
+
 #include "FrameNumberWidget.h"
 #include "FramePropertiesDock.h"
 #include "MainWindow.h"
 #include "SeekStreamDialog.h"
 #include "SubWindowHandle.h"
 #include "SubWindowSelectorDialog.h"
+#include "VideoStreamSubWindow.h"
 #include "VideoSubWindow.h"
-
-#include <QDockWidget>
-#include <QElapsedTimer>
-#include <QLabel>
-#include <QSignalMapper>
-#include <QSlider>
-#include <QToolBar>
-#include <QtGui>
-#if( _CONTROL_PLAYING_TIME_ == 1 )
-#include <QElapsedTimer>
-#endif
+#include "lib/CalypFrame.h"
 
 VideoHandle::VideoHandle( QWidget* parent, SubWindowHandle* windowManager )
-    : m_pcParet( parent ), m_pcMainWindowManager( windowManager )
+    : m_pcParent( parent ), m_pcMainWindowManager( windowManager )
 {
   m_pcCurrentVideoSubWindow = NULL;
   m_bIsPlaying = false;
-  m_pcPlayingTimer = new QTimer;
+  m_pcPlayingTimer = new QTimer( this );
+  m_pcFrameRateFeedbackTimer = std::make_unique<QElapsedTimer>();
   m_pcPlayingTimer->setTimerType( Qt::PreciseTimer );
-  connect( m_pcPlayingTimer, SIGNAL( timeout() ), this, SLOT( playEvent() ) );
+  connect( m_pcPlayingTimer, &QTimer::timeout,
+           this, &VideoHandle::playEvent );
   m_acPlayingSubWindows.clear();
 }
 
-VideoHandle::~VideoHandle() {}
+VideoHandle::~VideoHandle() = default;
 
 void VideoHandle::createActions()
 {
   m_arrayActions.resize( TOTAL_ACT );
   m_arrayActions[PLAY_ACT] = new QAction( "Play", this );
   m_arrayActions[PLAY_ACT]->setStatusTip( "Play/Pause" );
-  m_arrayActions[PLAY_ACT]->setIcon( QIcon( m_pcParet->style()->standardIcon( QStyle::SP_MediaPlay ) ) );
+  m_arrayActions[PLAY_ACT]->setIcon( QIcon( m_pcParent->style()->standardIcon( QStyle::SP_MediaPlay ) ) );
   m_arrayActions[PLAY_ACT]->setShortcut( Qt::Key_Space );
   connect( m_arrayActions[PLAY_ACT], SIGNAL( triggered() ), this, SLOT( play() ) );
 
   m_arrayActions[STOP_ACT] = new QAction( "Stop", this );
   m_arrayActions[STOP_ACT]->setStatusTip( "Stop" );
-  m_arrayActions[STOP_ACT]->setIcon( QIcon( m_pcParet->style()->standardIcon( QStyle::SP_MediaStop ) ) );
+  m_arrayActions[STOP_ACT]->setIcon( QIcon( m_pcParent->style()->standardIcon( QStyle::SP_MediaStop ) ) );
   connect( m_arrayActions[STOP_ACT], SIGNAL( triggered() ), this, SLOT( stop() ) );
 
   m_mapperVideoSeek = new QSignalMapper( this );
@@ -76,7 +79,7 @@ void VideoHandle::createActions()
   m_arrayActions[VIDEO_BACKWARD_ACT] = new QAction( "Video Backward", this );
   m_arrayActions[VIDEO_BACKWARD_ACT]->setStatusTip( "Seek backward" );
   m_arrayActions[VIDEO_BACKWARD_ACT]->setIcon(
-      QIcon( m_pcParet->style()->standardIcon( QStyle::SP_MediaSeekBackward ) ) );
+      QIcon( m_pcParent->style()->standardIcon( QStyle::SP_MediaSeekBackward ) ) );
   m_arrayActions[VIDEO_BACKWARD_ACT]->setShortcut( Qt::Key_Left );
   connect( m_arrayActions[VIDEO_BACKWARD_ACT], SIGNAL( triggered() ), m_mapperVideoSeek, SLOT( map() ) );
   m_mapperVideoSeek->setMapping( m_arrayActions[VIDEO_BACKWARD_ACT], 0 );
@@ -84,7 +87,7 @@ void VideoHandle::createActions()
   m_arrayActions[VIDEO_FORWARD_ACT] = new QAction( "Video Forward", this );
   m_arrayActions[VIDEO_FORWARD_ACT]->setStatusTip( "Seek forward" );
   m_arrayActions[VIDEO_FORWARD_ACT]->setIcon(
-      QIcon( m_pcParet->style()->standardIcon( QStyle::SP_MediaSeekForward ) ) );
+      QIcon( m_pcParent->style()->standardIcon( QStyle::SP_MediaSeekForward ) ) );
   m_arrayActions[VIDEO_FORWARD_ACT]->setShortcut( Qt::Key_Right );
   connect( m_arrayActions[VIDEO_FORWARD_ACT], SIGNAL( triggered() ), m_mapperVideoSeek, SLOT( map() ) );
   m_mapperVideoSeek->setMapping( m_arrayActions[VIDEO_FORWARD_ACT], 1 );
@@ -121,6 +124,24 @@ void VideoHandle::createActions()
   connect( m_pcFrameSlider, SIGNAL( valueChanged( int ) ), this, SLOT( seekSliderEvent( int ) ) );
 
   // ------------ Image ------------
+  m_mapperComponent = new QSignalMapper( this );
+  m_actionGroupComponent = new QActionGroup( this );
+  m_actionGroupComponent->setExclusive( true );
+  m_mapperComponent->setMapping( m_actionGroupComponent->addAction( "All" ), -1 );
+  m_mapperComponent->setMapping( m_actionGroupComponent->addAction( "Red" ), 0 );
+  m_mapperComponent->setMapping( m_actionGroupComponent->addAction( "Green" ), 1 );
+  m_mapperComponent->setMapping( m_actionGroupComponent->addAction( "Blue" ), 2 );
+  m_mapperComponent->setMapping( m_actionGroupComponent->addAction( "Alpha" ), 3 );
+  for( int i = 0; i < m_actionGroupComponent->actions().size(); i++ )
+  {
+    m_actionGroupComponent->actions().at( i )->setCheckable( true );
+    m_actionGroupComponent->actions().at( i )->setVisible( false );
+    connect( m_actionGroupComponent->actions().at( i ), SIGNAL( triggered() ), m_mapperComponent, SLOT( map() ) );
+  }
+  m_actionGroupComponent->actions().at( 0 )->setChecked( true );
+  m_actionGroupComponent->actions().at( 0 )->setVisible( true );
+  connect( m_mapperComponent, SIGNAL( mapped( int ) ), this, SLOT( setComponent( int ) ) );
+
   m_actionGroupTools = new QActionGroup( this );
   m_actionGroupTools->setExclusive( true );
 
@@ -156,9 +177,11 @@ void VideoHandle::createActions()
   m_mapperGrid = new QSignalMapper( this );
   m_actionGroupGrid = new QActionGroup( this );
   m_actionGroupGrid->setExclusive( true );
+  m_mapperGrid->setMapping( m_actionGroupGrid->addAction( "4x4" ), 4 );
   m_mapperGrid->setMapping( m_actionGroupGrid->addAction( "8x8" ), 8 );
   m_mapperGrid->setMapping( m_actionGroupGrid->addAction( "16x16" ), 16 );
   m_mapperGrid->setMapping( m_actionGroupGrid->addAction( "64x64" ), 64 );
+  m_mapperGrid->setMapping( m_actionGroupGrid->addAction( "128x128" ), 128 );
 
   for( int i = 0; i < m_actionGroupGrid->actions().size(); i++ )
   {
@@ -176,7 +199,7 @@ void VideoHandle::createActions()
 
 QMenu* VideoHandle::createVideoMenu()
 {
-  m_pcMenuVideo = new QMenu( "Video", m_pcParet );
+  m_pcMenuVideo = new QMenu( "Video", m_pcParent );
   m_pcMenuVideo->addAction( m_arrayActions[PLAY_ACT] );
   m_pcMenuVideo->addAction( m_arrayActions[STOP_ACT] );
   m_pcMenuVideo->addAction( m_arrayActions[VIDEO_BACKWARD_ACT] );
@@ -191,7 +214,9 @@ QMenu* VideoHandle::createVideoMenu()
 
 QMenu* VideoHandle::createImageMenu()
 {
-  m_pcMenuImage = new QMenu( "Image", m_pcParet );
+  m_pcMenuImage = new QMenu( "Image", m_pcParent );
+  m_menuComponent = m_pcMenuImage->addMenu( "Component" );
+  m_menuComponent->addActions( m_actionGroupComponent->actions() );
   m_pcMenuImage->addAction( m_arrayActions[NAVIGATION_TOOL_ACT] );
   m_pcMenuImage->addAction( m_arrayActions[SELECTION_TOOL_ACT] );
   m_pcMenuImage->addAction( m_arrayActions[BLOCK_SELECTION_TOOL_ACT] );
@@ -226,8 +251,8 @@ QToolBar* VideoHandle::createToolBar()
 
 QDockWidget* VideoHandle::createDock()
 {
-  m_pcFramePropertiesSideBar = new FramePropertiesDock( m_pcParet, &m_bIsPlaying );
-  m_pcFramePropertiesDock = new QDockWidget( tr( "Frame Information" ), m_pcParet );
+  m_pcFramePropertiesSideBar = new FramePropertiesDock( m_pcParent, &m_bIsPlaying );
+  m_pcFramePropertiesDock = new QDockWidget( tr( "Frame Information" ), m_pcParent );
   m_pcFramePropertiesDock->setAllowedAreas( Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea );
   m_pcFramePropertiesDock->setWidget( m_pcFramePropertiesSideBar );
   connect( m_pcFramePropertiesDock, SIGNAL( visibilityChanged( bool ) ), this, SLOT( update() ) );
@@ -240,6 +265,12 @@ QWidget* VideoHandle::createStatusBarMessage()
   QWidget* pcStatusBarWidget = new QWidget;
   QHBoxLayout* mainlayout = new QHBoxLayout;
 
+  m_pcPlayingFPSLabel = new QLabel;
+  m_pcPlayingFPSLabel->setText( " " );
+  m_pcPlayingFPSLabel->setSizePolicy( QSizePolicy( QSizePolicy::Fixed, QSizePolicy::Fixed ) );
+  m_pcPlayingFPSLabel->setMinimumWidth( 150 );
+  m_pcPlayingFPSLabel->setAlignment( Qt::AlignCenter );
+
   m_pcVideoFormatLabel = new QLabel;
   m_pcVideoFormatLabel->setText( " " );
   m_pcVideoFormatLabel->setSizePolicy( QSizePolicy( QSizePolicy::Fixed, QSizePolicy::Fixed ) );
@@ -252,6 +283,7 @@ QWidget* VideoHandle::createStatusBarMessage()
   m_pcResolutionLabel->setMinimumWidth( 90 );
   m_pcResolutionLabel->setAlignment( Qt::AlignCenter );
 
+  mainlayout->addWidget( m_pcPlayingFPSLabel );
   mainlayout->addWidget( m_pcVideoFormatLabel );
   mainlayout->addWidget( m_pcResolutionLabel );
   pcStatusBarWidget->setLayout( mainlayout );
@@ -259,9 +291,65 @@ QWidget* VideoHandle::createStatusBarMessage()
   return pcStatusBarWidget;
 }
 
+void VideoHandle::updateComponentMenu()
+{
+  VideoSubWindow* pcSubWindow = m_pcMainWindowManager->activeSubWindow<VideoSubWindow>();
+  if( pcSubWindow == nullptr )
+  {
+    m_menuComponent->setEnabled( false );
+    return;
+  }
+
+  const auto* frame = pcSubWindow->getCurrFrame();
+  if( frame == nullptr )
+  {
+    m_menuComponent->setEnabled( false );
+    return;
+  }
+
+  m_menuComponent->setEnabled( true );
+  for( int i = 1; i < m_actionGroupComponent->actions().size(); i++ )
+  {
+    m_actionGroupComponent->actions()[i]->setChecked( false );
+    m_actionGroupComponent->actions()[i]->setVisible( false );
+  }
+  switch( frame->getColorSpace() )
+  {
+  case CLP_COLOR_GRAY:
+    m_actionGroupComponent->actions().at( 1 )->setText( QStringLiteral( "Gray" ) );
+    m_actionGroupComponent->actions().at( 1 )->setVisible( true );
+    break;
+  case CLP_COLOR_YUV:
+    m_actionGroupComponent->actions().at( 1 )->setText( QStringLiteral( "Luminance" ) );
+    m_actionGroupComponent->actions().at( 1 )->setVisible( true );
+    m_actionGroupComponent->actions().at( 2 )->setText( QStringLiteral( "Chrominance U (Cb)" ) );
+    m_actionGroupComponent->actions().at( 2 )->setVisible( true );
+    m_actionGroupComponent->actions().at( 3 )->setText( QStringLiteral( "Chrominance V (Cr)" ) );
+    m_actionGroupComponent->actions().at( 3 )->setVisible( true );
+    break;
+  case CLP_COLOR_RGBA:
+    m_actionGroupComponent->actions().at( 4 )->setText( QStringLiteral( "Alpha" ) );
+    m_actionGroupComponent->actions().at( 4 )->setVisible( true );
+    [[fallthrough]];
+  case CLP_COLOR_RGB:
+    m_actionGroupComponent->actions().at( 1 )->setText( QStringLiteral( "Red" ) );
+    m_actionGroupComponent->actions().at( 1 )->setVisible( true );
+    m_actionGroupComponent->actions().at( 2 )->setText( QStringLiteral( "Green" ) );
+    m_actionGroupComponent->actions().at( 2 )->setVisible( true );
+    m_actionGroupComponent->actions().at( 3 )->setText( QStringLiteral( "Blue" ) );
+    m_actionGroupComponent->actions().at( 3 )->setVisible( true );
+    break;
+  default:
+    Q_ASSERT( false );
+  }
+  auto component = pcSubWindow->getViewArea()->getFilteredChannel();
+  int idx = component.has_value() ? *component : 0;
+  m_actionGroupComponent->actions().at( idx )->setChecked( true );
+}
+
 void VideoHandle::updateMenus()
 {
-  VideoSubWindow* pcSubWindow = qobject_cast<VideoSubWindow*>( m_pcMainWindowManager->activeSubWindow() );
+  VideoSubWindow* pcSubWindow = m_pcMainWindowManager->activeSubWindow<VideoSubWindow>();
   bool hasSubWindow = pcSubWindow ? true : false;
 
   m_arrayActions[PLAY_ACT]->setEnabled( hasSubWindow );
@@ -287,6 +375,8 @@ void VideoHandle::updateMenus()
   m_arrayActions[SELECTION_TOOL_ACT]->setEnabled( hasSubWindow );
   m_arrayActions[BLOCK_SELECTION_TOOL_ACT]->setEnabled( hasSubWindow );
   m_arrayActions[SHOW_GRID_ACT]->setEnabled( hasSubWindow );
+
+  updateComponentMenu();
 }
 
 void VideoHandle::readSettings()
@@ -317,13 +407,16 @@ void VideoHandle::update()
 {
   if( m_pcCurrentVideoSubWindow )
   {
-    CalypStream* pcStream = m_pcCurrentVideoSubWindow->getInputStream();
-    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();
 
-    unsigned long frame_num = 0;
-    unsigned long total_frame_num = 1;
-
-    m_pcVideoFormatLabel->setText( m_pcCurrentVideoSubWindow->getStreamInformation() );
+    m_pcVideoFormatLabel->setText( m_pcCurrentVideoSubWindow->getVideoInformation() );
 
     QString resolution;
     if( pcFrame )
@@ -331,6 +424,8 @@ void VideoHandle::update()
       resolution.append( QString( "%1x%2" ).arg( pcFrame->getWidth() ).arg( pcFrame->getHeight() ) );
     }
 
+    unsigned long frame_num = 0;
+    unsigned long total_frame_num = 1;
     if( pcStream )
     {
       frame_num = pcStream->getCurrFrameNum();
@@ -355,8 +450,7 @@ void VideoHandle::update()
       }
     }
     m_pcResolutionLabel->setText( resolution );
-
-    m_pcFramePropertiesSideBar->setFrame( pcFrame );
+    m_pcFramePropertiesSideBar->setFrame( pcFrame, isPlaying );
 
     m_pcFrameNumInfo->setTotalFrameNum( total_frame_num );
     m_pcFrameNumInfo->setCurrFrameNum( frame_num );
@@ -366,19 +460,25 @@ void VideoHandle::update()
     m_pcFrameSlider->setValue( frame_num );
     m_pcFrameSlider->blockSignals( false );
 
+    if( m_uiRealAverageFrameRate > 0 )
+    {
+      m_pcPlayingFPSLabel->setText( QString( "%1 fps" ).arg( m_uiRealAverageFrameRate ) );
+    }
+
     if( m_pcCurrentVideoSubWindow->isPlaying() )
     {
       m_arrayActions[PLAY_ACT]->setText( "Pause" );
-      m_arrayActions[PLAY_ACT]->setIcon( m_pcParet->style()->standardIcon( QStyle::SP_MediaPause ) );
+      m_arrayActions[PLAY_ACT]->setIcon( m_pcParent->style()->standardIcon( QStyle::SP_MediaPause ) );
     }
     else
     {
       m_arrayActions[PLAY_ACT]->setText( "Play" );
-      m_arrayActions[PLAY_ACT]->setIcon( m_pcParet->style()->standardIcon( QStyle::SP_MediaPlay ) );
+      m_arrayActions[PLAY_ACT]->setIcon( m_pcParent->style()->standardIcon( QStyle::SP_MediaPlay ) );
     }
   }
   else
   {
+    m_pcPlayingFPSLabel->setText( "" );
     m_pcVideoFormatLabel->setText( "" );
     m_pcResolutionLabel->setText( "" );
     m_pcFramePropertiesSideBar->reset();
@@ -421,18 +521,21 @@ 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 )
     {
       m_arrayActions[VIDEO_LOCK_ACT]->setVisible( false );
     }
   }
+  if( subWindow == m_pcCurrentVideoSubWindow )
+  {
+    m_pcFramePropertiesSideBar->reset();
+  }
 }
 
 void VideoHandle::zoomToFactorAll( const double scale, const QPoint center )
@@ -525,18 +628,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;
@@ -549,9 +652,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 )
   {
@@ -559,42 +662,34 @@ void VideoHandle::setTimerStatus()
     {
       m_pcPlayingTimer->start();
       m_bIsPlaying = true;
-#if( _CONTROL_PLAYING_TIME_ == 1 )
       m_uiNumberPlayedFrames = 0;
-      m_pcPlayControlTimer = new QElapsedTimer;
-      m_pcPlayControlTimer->start();
-      m_dAverageFps = 0;
-#endif
+      m_pcFrameRateFeedbackTimer->start();
+      m_uiRealAverageFrameRate = 0;
     }
   }
   else
   {
-#if( _CONTROL_PLAYING_TIME_ == 1 )
-    if( m_pcPlayControlTimer && m_pcPlayingTimer->interval() > 0 )
-    {
-      qDebug() << "Desired Fps: " << 1000 / m_pcPlayingTimer->interval() << "Real Fps: " << 1000 / m_dAverageFps;
-
-      delete m_pcPlayControlTimer;
-      m_pcPlayControlTimer = NULL;
-    }
-#endif
     m_pcPlayingTimer->stop();
     m_bIsPlaying = false;
   }
 }
 
+void VideoHandle::configureFrameRateTimer()
+{
+  double frame_rate = m_acPlayingSubWindows.at( 0 )->getInputStream()->getFrameRate();
+  unsigned int time_ms = (unsigned int)( 1000.0 / frame_rate + 0.5 );
+  m_pcPlayingTimer->setInterval( time_ms );
+}
+
 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
   {
-    double frameRate;
-    unsigned int timeinterval;
     if( m_acPlayingSubWindows.size() < 2 )
     {
       for( int i = 0; i < m_acPlayingSubWindows.size(); i++ )
@@ -602,22 +697,20 @@ 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++ )
       {
         m_acPlayingSubWindows.at( i )->play();
       }
-      frameRate = m_acPlayingSubWindows.at( 0 )->getInputStream()->getFrameRate();
-      timeinterval = (unsigned int)( 1000.0 / frameRate + 0.5 );
-      m_pcPlayingTimer->setInterval( timeinterval );
+      configureFrameRateTimer();
     }
   }
   else
   {
-    if( m_acPlayingSubWindows.contains( m_pcCurrentVideoSubWindow ) )
+    if( m_acPlayingSubWindows.contains( videoStreamSubWindow ) )
     {
       for( int i = 0; i < m_acPlayingSubWindows.size(); i++ )
       {
@@ -626,21 +719,20 @@ void VideoHandle::play()
     }
     else
     {
-      m_pcCurrentVideoSubWindow->pause();
+      videoStreamSubWindow->pause();
     }
   }
   setTimerStatus();
   emit changed();
-  // update();
 }
 
 void VideoHandle::stop()
 {
   if( m_acPlayingSubWindows.size() > 0 )
   {
-    for( int i = 0; i < m_acPlayingSubWindows.size(); i++ )
+    for( auto playingSubWindow : m_acPlayingSubWindows )
     {
-      m_acPlayingSubWindows.at( i )->stop();
+      playingSubWindow->stop();
     }
     m_acPlayingSubWindows.clear();
     setTimerStatus();
@@ -656,109 +748,134 @@ void VideoHandle::stop()
   m_arrayActions[VIDEO_LOCK_ACT]->setVisible( false );
 }
 
+void VideoHandle::calculateRealFrameRate()
+{
+  double average_time_between_frames_ms = m_uiNumberPlayedFrames > 0 ? 1000.0 / m_uiRealAverageFrameRate : 0;
+  double time_elapsed_since_last_frame_ms = m_pcFrameRateFeedbackTimer->elapsed();
+  average_time_between_frames_ms = double( average_time_between_frames_ms * m_uiNumberPlayedFrames + time_elapsed_since_last_frame_ms ) / double( m_uiNumberPlayedFrames + 1 );
+  m_uiRealAverageFrameRate = 1000.0 / average_time_between_frames_ms;
+  m_uiNumberPlayedFrames++;
+  m_pcFrameRateFeedbackTimer->restart();
+}
+
 void VideoHandle::playEvent()
 {
-  bool bEndOfSequence = false;
-#if( _CONTROL_PLAYING_TIME_ == 1 )
-  m_dAverageFps = double( m_dAverageFps * m_uiNumberPlayedFrames + m_pcPlayControlTimer->elapsed() ) /
-                  double( m_uiNumberPlayedFrames + 1 );
-  m_uiNumberPlayedFrames++;
-  m_pcPlayControlTimer->restart();
-#endif
+  // auto start = std::chrono::steady_clock::now();
+
+  // This value should only be true if it is really needed to refresh the UI after this play event
+  // Lets assume the current window is not playing. Nothing changes in the UI expect the playing windows
+  // So no changed is emmited
+  bool bShouldRefreshUI = false;
+  calculateRealFrameRate();
   try
   {
-    for( int i = 0; i < m_acPlayingSubWindows.size(); i++ )
+    bool bEndOfSequence = false;
+    for( auto playingSubWindow : m_acPlayingSubWindows )
     {
-      bEndOfSequence |= m_acPlayingSubWindows.at( i )->playEvent();
+      bEndOfSequence |= playingSubWindow->playEvent();
+      // If the current selected windows is playing then we need to refresh the UI
+      if( playingSubWindow == m_pcCurrentVideoSubWindow )
+      {
+        bShouldRefreshUI = true;
+      }
     }
     if( bEndOfSequence )
     {
       if( !m_arrayActions[VIDEO_REPEAT_ACT]->isChecked() )
+      {
         stop();
+      }
       else
-        for( int i = 0; i < m_acPlayingSubWindows.size(); i++ )
-          m_acPlayingSubWindows.at( i )->seekAbsoluteEvent( 0 );
+      {
+        for( auto playingSubWindow : m_acPlayingSubWindows )
+        {
+          playingSubWindow->seekAbsoluteEvent( 0 );
+        }
+      }
     }
   }
   catch( const char* msg )
   {
-    QString warningMsg = "Error while playing " +
-                         QFileInfo( m_pcCurrentVideoSubWindow->getCurrentFileName() ).fileName() +
-                         " with the following error: \n" + msg;
-    QMessageBox::warning( m_pcParet, QApplication::applicationName(), warningMsg );
+    QString warningMsg = "Error while playing " + m_pcCurrentVideoSubWindow->getWindowName() + " with the following error: \n" + msg;
+    QMessageBox::warning( m_pcParent, QApplication::applicationName(), warningMsg );
     qDebug() << warningMsg;
     stop();
     m_pcCurrentVideoSubWindow->close();
   }
-  emit changed();
+  if( bShouldRefreshUI )
+    emit changed();
+
+  // auto end = std::chrono::steady_clock::now();
+  // std::cout << "Elapsed time going to next frame: "
+  //           << std::chrono::duration_cast<std::chrono::milliseconds>( end - start ).count()
+  //           << " ms" << std::endl;
 }
 
 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( int i = 0; i < m_acPlayingSubWindows.size(); i++ )
+        for( auto playingSubWindow : m_acPlayingSubWindows )
         {
-          m_acPlayingSubWindows.at( i )->seekRelativeEvent( direction > 0 ? true : false );
+          playingSubWindow->seekRelativeEvent( direction > 0 ? true : false );
         }
       }
     }
     else
     {
-      m_pcCurrentVideoSubWindow->seekRelativeEvent( direction > 0 ? true : false );
+      videoStreamSubWindow->seekRelativeEvent( direction > 0 ? true : false );
     }
     emit changed();
-    // update();
   }
 }
 
 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_pcParent );
+    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( int i = 0; i < m_acPlayingSubWindows.size(); i++ )
-          {
-            m_acPlayingSubWindows.at( i )->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( int i = 0; i < m_acPlayingSubWindows.size(); i++ )
+      for( auto playingSubWindow : m_acPlayingSubWindows )
       {
-        m_acPlayingSubWindows.at( i )->seekAbsoluteEvent( (unsigned int)new_frame_num );
+        playingSubWindow->seekAbsoluteEvent( (unsigned int)new_frame_num );
       }
     }
     else
     {
-      m_pcCurrentVideoSubWindow->seekAbsoluteEvent( (unsigned int)new_frame_num );
+      videoStreamSubWindow->seekAbsoluteEvent( (unsigned int)new_frame_num );
     }
     emit changed();
   }
@@ -766,36 +883,34 @@ void VideoHandle::seekSliderEvent( int new_frame_num )
 
 void VideoHandle::videoSelectionButtonEvent()
 {
-  VideoSubWindow* videoSubWindow;
-
   Qt::KeyboardModifiers keyModifiers = QApplication::keyboardModifiers();
   if( keyModifiers & Qt::ControlModifier )
   {
     QList<SubWindowAbstract*> subWindowList =
         m_pcMainWindowManager->findSubWindow( SubWindowAbstract::VIDEO_STREAM_SUBWINDOW );
-    for( int i = 0; i < subWindowList.size(); i++ )
+    for( auto subWindow : subWindowList )
     {
-      videoSubWindow = qobject_cast<VideoSubWindow*>( subWindowList.at( i ) );
+      auto* videoSubWindow = qobject_cast<VideoStreamSubWindow*>( subWindow );
       m_acPlayingSubWindows.append( videoSubWindow );
     }
   }
   else
   {
-    SubWindowSelectorDialog dialogWindowsSelection( m_pcParet, m_pcMainWindowManager,
+    SubWindowSelectorDialog dialogWindowsSelection( m_pcParent, m_pcMainWindowManager,
                                                     SubWindowAbstract::VIDEO_STREAM_SUBWINDOW );
     QStringList cWindowListNames;
-    for( int i = 0; i < m_acPlayingSubWindows.size(); i++ )
+    for( auto playingSubWindow : m_acPlayingSubWindows )
     {
-      dialogWindowsSelection.selectSubWindow( m_acPlayingSubWindows.at( i ) );
+      dialogWindowsSelection.selectSubWindow( playingSubWindow );
     }
     if( dialogWindowsSelection.exec() == QDialog::Accepted )
     {
       m_acPlayingSubWindows.clear();
 
       QList<SubWindowAbstract*> selectedSubWindowList = dialogWindowsSelection.getSelectedWindows();
-      for( int i = 0; i < selectedSubWindowList.size(); i++ )
+      for( auto window : selectedSubWindowList )
       {
-        videoSubWindow = qobject_cast<VideoSubWindow*>( selectedSubWindowList.at( i ) );
+        auto* videoSubWindow = qobject_cast<VideoStreamSubWindow*>( window );
         m_acPlayingSubWindows.append( videoSubWindow );
       }
     }
@@ -807,7 +922,7 @@ void VideoHandle::videoSelectionButtonEvent()
 
   if( m_acPlayingSubWindows.size() > 0 )
   {
-    m_acPlayingSubWindows.at( 0 )->activateWindow();
+    m_acPlayingSubWindows.front()->activateWindow();
     if( m_acPlayingSubWindows.size() > 1 )
     {
       m_arrayActions[VIDEO_LOCK_ACT]->setVisible( true );
@@ -826,6 +941,20 @@ void VideoHandle::videoSelectionButtonEvent()
   }
 }
 
+void VideoHandle::setComponent( int component )
+{
+  if( m_pcCurrentVideoSubWindow == nullptr )
+    return;
+  if( component < 0 )
+  {
+    m_pcCurrentVideoSubWindow->getViewArea()->clearFilteredChannel();
+  }
+  else
+  {
+    m_pcCurrentVideoSubWindow->getViewArea()->setFilteredChannel( static_cast<std::size_t>( component ) );
+  }
+}
+
 void VideoHandle::setTool( int tool )
 {
   m_uiViewTool = tool;

app/VideoHandle.h

@@ -1,5 +1,5 @@
 /*    This file is a part of Calyp project
- *    Copyright (C) 2014-2019  by Joao Carreira   (jfmcarreira@gmail.com)
+ *    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
@@ -25,29 +25,29 @@
 #ifndef __VIDEOHANDLE_H__
 #define __VIDEOHANDLE_H__
 
-#include "CommonDefs.h"
-#include "config.h"
-
+#include <QElapsedTimer>
 #include <QMenu>
 #include <QPoint>
 #include <QThread>
 #include <QVector>
 #include <QWidget>
 
-//#define _CONTROL_PLAYING_TIME_ 1
+#include "CommonDefs.h"
+#include "VideoSubWindow.h"
+#include "config.h"
 
 class QToolBar;
 class QDockWidget;
 class QSignalMapper;
 class QLabel;
 class QSlider;
-class QElapsedTimer;
 
 class SubWindowHandle;
 class SubWindowAbstract;
-class VideoSubWindow;
+class VideoStreamSubWindow;
 class FramePropertiesDock;
 class FrameNumberWidget;
+class QTimer;
 
 class VideoHandle : public QObject
 {
@@ -72,7 +72,7 @@ public:
   void addSubWindow( VideoSubWindow* subWindow );
 
 private:
-  QWidget* m_pcParet;
+  QWidget* m_pcParent;
   SubWindowHandle* m_pcMainWindowManager;
   enum
   {
@@ -97,6 +97,11 @@ private:
   QSlider* m_pcFrameSlider;
   FrameNumberWidget* m_pcFrameNumInfo;
 
+  // Filter component actions
+  QMenu* m_menuComponent;
+  QActionGroup* m_actionGroupComponent;
+  QSignalMapper* m_mapperComponent;
+
   // Tools Actions
   QActionGroup* m_actionGroupTools;
   QSignalMapper* m_mapperTools;
@@ -113,23 +118,25 @@ private:
   QDockWidget* m_pcFramePropertiesDock;
   FramePropertiesDock* m_pcFramePropertiesSideBar;
 
+  QLabel* m_pcPlayingFPSLabel;
   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;
 
-#if( _CONTROL_PLAYING_TIME_ == 1 )
-  unsigned int m_uiNumberPlayedFrames;
-  double m_dAverageFps;
-  QElapsedTimer* m_pcPlayControlTimer;
-#endif
+  unsigned int m_uiNumberPlayedFrames{ 0 };
+  unsigned int m_uiRealAverageFrameRate{ 0 };
+  std::unique_ptr<QElapsedTimer> m_pcFrameRateFeedbackTimer;
 
+  void configureFrameRateTimer();
+  void calculateRealFrameRate();
   unsigned long getMaxFrameNumber();
   void setTimerStatus();
+  void updateComponentMenu();
 
 Q_SIGNALS:
   void changed();
@@ -140,13 +147,16 @@ private Q_SLOTS:
   void closeSubWindow( SubWindowAbstract* subWindow );
   void zoomToFactorAll( const double factor, const QPoint center = QPoint() );
   void moveAllScrollBars( const double&, const double& );
+
   void play();
   void stop();
+
   void playEvent();
   void seekSliderEvent( int new_frame_num );
   void seekEvent( int direction );
   void seekVideo();
   void videoSelectionButtonEvent();
+  void setComponent( int component );
   void setTool( int tool );
   void toggleGrid( bool checked );
   void setGridSize( int size );

app/VideoStreamSubWindow.cpp

@@ -0,0 +1,604 @@
+/*    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 << d.m_bForceRaw;
+  }
+  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;
+    in >> d.m_bForceRaw;
+    array.append( d );
+  }
+  return in;
+}
+
+auto findCalypStreamInfo( const CalypFileInfoVector& array, const QString& filename ) -> int
+{
+  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() & ClpModuleFeature::HasInfo )
+    {
+      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;
+  auto InputFormat = ClpPixelFormats::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 };
+  bool forceRaw{ 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, iPass == 1, CalypStream::Type::Input );
+      forceRaw = iPass > 0;
+    }
+    catch( CalypFailure& e )
+    {
+      if( iPass > 0 )
+        throw( e );
+    }
+  }
+
+  if( !bRet )
+  {
+    return false;
+  }
+
+  m_sStreamInfo.m_cFilename = cFilename;
+  m_sStreamInfo.m_uiWidth = Width;
+  m_sStreamInfo.m_uiHeight = Height;
+  m_sStreamInfo.m_iPelFormat = static_cast<std::int64_t>( InputFormat );
+  m_sStreamInfo.m_uiBitsPelPixel = BitsPel;
+  m_sStreamInfo.m_iEndianness = Endianness;
+  m_sStreamInfo.m_uiFrameRate = FrameRate;
+  m_sStreamInfo.m_uiFileSize = QFileInfo( cFilename ).size();
+  m_sStreamInfo.m_bForceRaw = forceRaw;
+
+  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,
+                            static_cast<ClpPixelFormats>( streamInfo.m_iPelFormat ), streamInfo.m_uiBitsPelPixel, streamInfo.m_iEndianness,
+                            streamInfo.m_uiFrameRate, streamInfo.m_bForceRaw, CalypStream::Type::Input ) )
+  {
+    return false;
+  }
+
+  m_cFilename = streamInfo.m_cFilename;
+  m_sStreamInfo = std::move( streamInfo );
+
+#ifdef CALYP_MANAGED_RESOURCES
+  m_pcResourceManager->startResourceWorker( m_uiResourceId );
+#endif
+
+  QApplication::restoreOverrideCursor();
+
+  refreshFrame();
+
+  updateVideoWindowInfo();
+  setWindowName( QFileInfo( m_cFilename ).fileName() );
+  return true;
+}
+
+bool VideoStreamSubWindow::guessFormat( const QString& filename, unsigned int& rWidth, unsigned int& rHeight, ClpPixelFormats& 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
+    const auto& formats_list = CalypFrame::supportedPixelFormatListNames();
+    for( const auto& [key, name] : formats_list )
+    {
+      if( FilenameShort.contains( QString::fromStdString( std::string( name ) ), Qt::CaseInsensitive ) )
+      {
+        rInputFormat = key;
+        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 != ClpPixelFormats::Invalid )
+      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( const 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;
+}

app/VideoStreamSubWindow.h

@@ -0,0 +1,135 @@
+/*    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;
+
+struct CalypFileInfo
+{
+  QString m_cFilename;
+  unsigned int m_uiWidth;
+  unsigned int m_uiHeight;
+  int m_iPelFormat;
+  unsigned int m_uiBitsPelPixel;
+  int m_iEndianness;
+  unsigned int m_uiFrameRate;
+  unsigned long long int m_uiFileSize;
+  bool m_bForceRaw{ false };
+};
+using CalypFileInfoVector = QVector<CalypFileInfo>;
+
+QDataStream& operator<<( QDataStream& out, const CalypFileInfoVector& d );
+QDataStream& operator>>( QDataStream& in, CalypFileInfoVector& d );
+auto findCalypStreamInfo( const CalypFileInfoVector& array, const QString& filename ) -> int;
+
+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 supportsFormatConfiguration() const { return m_pCurrStream->supportsFormatConfiguration(); };
+
+  bool loadFile( QString cFilename, bool bForceDialog = false );
+  bool loadFile( CalypFileInfo streamInfo );
+  void loadAll();
+  bool saveStream( const 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( const QString& filename, unsigned int& rWidth, unsigned int& rHeight, ClpPixelFormats& 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__

app/VideoSubWindow.h

@@ -1,5 +1,5 @@
 /*    This file is a part of Calyp project
- *    Copyright (C) 2014-2019  by Joao Carreira   (jfmcarreira@gmail.com)
+ *    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
@@ -28,8 +28,11 @@
 #include <QDataStream>
 #include <QFuture>
 #include <QRect>
+#include <QStaticText>
 #include <QString>
 #include <QVector>
+
+#include "CalypAppModuleIf.h"
 #include "CommonDefs.h"
 #include "SubWindowAbstract.h"
 #include "ViewArea.h"
@@ -40,67 +43,35 @@ class QScrollArea;
 
 class VideoInformation;
 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 ) override;
+
+private:
+  QTimer* m_pcRefreshTimer;
+  QList<QStaticText> m_cTopLeftTextList;
+  QFont m_cTopLeftTextFont;
+  QFont m_cCenterTextFont;
+  bool m_bBusyWindow;
+};
 
 class VideoSubWindow : public SubWindowAbstract
 {
   Q_OBJECT
 
-private:
-  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;
-  CalypStream* m_pCurrStream;
-
-  CalypFrame* m_pcCurrFrame;
-  QRect m_cSelectedArea;
-
-  CalypAppModuleIf* m_pcCurrentDisplayModule;
-  QList<CalypAppModuleIf*> m_apcCurrentModule;
-
-  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
   {
@@ -110,90 +81,63 @@ public:
   VideoSubWindow( enum VideoSubWindowCategories category, QWidget* parent = 0 );
   ~VideoSubWindow();
 
-  void updateVideoWindowInfo();
+  virtual void resetWindowName() = 0;
+  virtual void updateVideoWindowInfo() = 0;
 
-  bool loadFile( QString cFilename, bool bForceDialog = false );
-  bool loadFile( CalypFileInfo* streamInfo );
-  void loadAll();
-  bool save( QString filename );
-  bool saveStream( QString filename );
+  virtual bool isPlaying() = 0;
+  virtual void stop() = 0;
+  virtual void advanceOneFrame() = 0;
+  virtual auto getFrameNum() -> std::uint64_t { return 1; };
 
-  void refreshSubWindow();
-  void refreshFrame( bool bThreaded = false );
+  QString getVideoInformation() { return m_cStreamInformation; }
+  bool save( const QString& filename );
 
-  bool play();
-  void pause();
-  bool playEvent();
-  void stop();
+  void setCurrFrame( std::shared_ptr<CalypFrame> pcCurrFrame );
 
-  bool isPlaying() { return m_bIsPlaying; }
-  void seekAbsoluteEvent( unsigned int new_frame_num );
-  void seekRelativeEvent( bool bIsFoward );
+  auto getCurrFrame() -> CalypFrame* { return m_pcCurrFrameAsset.get(); }
+  auto getCurrFrameAsset() -> std::shared_ptr<CalypFrame> { return m_pcCurrFrameAsset; };
+  auto getViewArea() -> ViewArea* { return m_cViewArea; }
 
-  void setCurrFrame( CalypFrame* pcCurrFrame );
-
-  CalypFileInfo getStreamInfo() { return m_sStreamInfo; }
-  QString getStreamInformation() { return m_cStreamInformation; }
-  CalypStream* getInputStream() { return m_pCurrStream; }
-  CalypStream* getCurrStream() { return m_pCurrStream; }
-  CalypFrame* getCurrFrame() { return m_pcCurrFrame; }
-  ViewArea* getViewArea() { return m_cViewArea; }
+  VideoSubWindow* getRefSubWindow() { return m_pcReferenceSubWindow; }
   void setRefSubWindow( VideoSubWindow* subWindow )
   {
     m_pcReferenceSubWindow = NULL;
     if( subWindow )
-      if( m_pcCurrFrame->haveSameFmt( subWindow->getCurrFrame() ) )
+      if( m_pcCurrFrameAsset->haveSameFmt( subWindow->getCurrFrame() ) )
         m_pcReferenceSubWindow = subWindow;
   }
 
-  VideoSubWindow* getRefSubWindow() { return m_pcReferenceSubWindow; }
   /**
    * Functions to enable a module in the
    * current SubWindow
    */
-  void enableModule( CalypAppModuleIf* pcModule );
-  void disableModule( CalypAppModuleIf* pcModule = NULL );
-  void associateModule( CalypAppModuleIf* pcModule );
-
-  CalypAppModuleIf* getDisplayModule() { return m_pcCurrentDisplayModule; }
-  QList<CalypAppModuleIf*> getModuleArray()
-  {
-    QList<CalypAppModuleIf*> apcModulesArray;
-    if( m_pcCurrentDisplayModule )
-      apcModulesArray.append( m_pcCurrentDisplayModule );
-    apcModulesArray.append( m_apcCurrentModule );
-    return apcModulesArray;
-  }
+  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_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; }
-  bool getIsModule() { return getCategory() | SubWindowAbstract::MODULE_SUBWINDOW; }
-  void clearWindowBusy() { m_bWindowBusy = false; }
   void setFillWindow( bool bFlag );
 
-  void adjustScrollBarToRatio( const double& horRatio, const double& verRatio );
+  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();
 
   /**
@@ -205,9 +149,11 @@ private:
   QSize getScrollSize();
 
 protected:
-  void keyPressEvent( QKeyEvent* event );
-  void resizeEvent( QResizeEvent* event );
-  void closeEvent( QCloseEvent* event );
+  void refreshFrame();
+
+  void keyPressEvent( QKeyEvent* event ) override;
+  void resizeEvent( QResizeEvent* event ) override;
+  void closeEvent( QCloseEvent* event ) override;
 
 public Q_SLOTS:
   void updateWindowOnTimeout();
@@ -216,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{ 0 };
+  double m_dVerScroll{ 0 };
+  ViewArea* m_cViewArea;
+  QRect m_cSelectedArea;
+  VideoSubWindow* m_pcReferenceSubWindow;
+  QTimer* m_pcUpdateTimer;
 };
 
-Q_DECLARE_METATYPE( CalypFileInfo )
-Q_DECLARE_METATYPE( CalypFileInfoVector )
-
 #endif  // __VIDEOSUBWINDOW_H__

app/ViewArea.cpp

@@ -1,5 +1,5 @@
 /*    This file is a part of Calyp project
- *    Copyright (C) 2014-2019  by Joao Carreira   (jfmcarreira@gmail.com)
+ *    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
@@ -25,7 +25,8 @@
 
 #include "ViewArea.h"
 
-#include "GridManager.h"
+#include <qcolor.h>
+#include <qnamespace.h>
 
 #include <QColor>
 #include <QCoreApplication>
@@ -38,68 +39,102 @@
 #include <QRectF>
 #include <QString>
 #include <QWidget>
-
 #include <cmath>
 
-static const QColor selectionColor = Qt::cyan;
-static const QColor imageMaskColor = Qt::green;
-static const QColor eraserColor = Qt::red;
+#include "GridManager.h"
+
+#if QT_VERSION >= QT_VERSION_CHECK( 5, 14, 0 )
+constexpr auto kSelectionColor = QColorConstants::Cyan;
+constexpr auto kImageMaskColor = QColorConstants::Green;
+constexpr auto kEraserColor = QColorConstants::Red;
+#else
+static const QColor kSelectionColor = Qt::cyan;
+static const QColor kImageMaskColor = Qt::green;
+static const QColor kEraserColor = Qt::red;
+#endif
+constexpr double kMaxZoom = 100.0;
+constexpr double kMinZoom = 0.01;
 
 ViewArea::ViewArea( QWidget* parent )
     : QWidget( parent )
 {
   setMouseTracking( true );
-
-  m_pcCurrFrame = NULL;
-  m_pixmap = QPixmap();
   m_grid = GridManager();
   m_mask = QBitmap();
   m_selectedArea = QRect();
-  m_dZoomFactor = 1;
-  m_xOffset = 0;
-  m_yOffset = 0;
-  m_mode = NormalMode;
-  m_eTool = NavigationTool;
-  m_bGridVisible = false;
-  m_snapToGrid = false;
-  m_blockTrackEnable = false;
-  m_visibleZoomRect = true;
 
   m_zoomWinTimer.setSingleShot( true );
   m_zoomWinTimer.setInterval( 2000 );
   connect( &m_zoomWinTimer, SIGNAL( timeout() ), this, SLOT( update() ) );
 }
 
-void ViewArea::setImage( CalypFrame* pcFrame )
+void ViewArea::setImage( std::shared_ptr<CalypFrame> frame )
 {
-  m_pcCurrFrame = pcFrame;
-  m_uiPixelHalfScale = 1 << ( m_pcCurrFrame->getBitsPel() - 1 );
-  m_pcCurrFrame->fillRGBBuffer();
-  QImage qimg = QImage( m_pcCurrFrame->getRGBBuffer(), m_pcCurrFrame->getWidth(), m_pcCurrFrame->getHeight(),
-                        QImage::Format_ARGB32 );
-  setImage( QPixmap::fromImage( qimg ) );
-}
+  m_nextFrame = frame;
+  m_uiPixelHalfScale = 1 << ( m_nextFrame->getBitsPel() - 1 );
+  if( m_filterSingleChannel.has_value() )
+  {
+    m_nextFrame->fillRGBBuffer( m_filterSingleChannel );
+  }
+  else
+  {
+    m_nextFrame->fillRGBBuffer();
+  }
 
-void ViewArea::setImage( const QPixmap& pixmap )
-{
-  m_pixmap = pixmap;
-  m_mask = QBitmap( pixmap.width(), pixmap.height() );
-  m_mask.clear();
+  m_image = QImage( m_nextFrame->getRGBBuffer(),
+                    m_nextFrame->getWidth(),
+                    m_nextFrame->getHeight(),
+                    QImage::Format_ARGB32 );
+
+  // m_mask = QBitmap( pixmap.width(), pixmap.height() );
+  // m_mask.clear();
   updateSize();
   update();
   updateGeometry();
-
   initZoomWinRect();
 }
 
-void ViewArea::clear()
+// void ViewArea::clear()
+// {
+//   m_image = QImage();
+//   m_mask = QBitmap();
+//   m_mode = NormalMode;
+//   updateSize();
+//   update();
+//   updateGeometry();
+// }
+
+auto ViewArea::getFilteredChannel() -> std::optional<std::size_t>
 {
-  m_pixmap = QPixmap();
-  m_mask = QBitmap();
-  m_mode = NormalMode;
-  updateSize();
+  return m_filterSingleChannel;
+}
+
+void ViewArea::setFilteredChannel( std::size_t channel )
+{
+  m_filterSingleChannel = channel;
+  if( m_nextFrame != nullptr )
+  {
+    m_nextFrame->fillRGBBuffer( m_filterSingleChannel );
+    m_image = QImage( m_nextFrame->getRGBBuffer(),
+                      m_nextFrame->getWidth(),
+                      m_nextFrame->getHeight(),
+                      QImage::Format_ARGB32 );
+  }
+  update();
+}
+
+void ViewArea::clearFilteredChannel()
+{
+  m_filterSingleChannel = {};
+  if( m_nextFrame != nullptr )
+  {
+    m_nextFrame->fillRGBBuffer( m_filterSingleChannel );
+    m_image = QImage( m_nextFrame->getRGBBuffer(),
+                      m_nextFrame->getWidth(),
+                      m_nextFrame->getHeight(),
+                      QImage::Format_ARGB32 );
+  }
   update();
-  updateGeometry();
 }
 
 void ViewArea::setTool( unsigned int view )
@@ -167,14 +202,14 @@ void ViewArea::setZoomFactor( double f )
 
 double ViewArea::scaleZoomFactor( double scale, QPoint center, QSize minimumSize )
 {
-  double maxZoom = 100.0;
-  double minZoom = 0.01;  //( 1.0 / m_pixmap.width() );
+  Q_ASSERT( !m_image.isNull() );
+
   double new_scale = 1.0;
 
-  if( ( m_dZoomFactor == minZoom ) && ( scale < 1 ) )
+  if( ( m_dZoomFactor == kMinZoom ) && ( scale < 1 ) )
     return new_scale;
 
-  if( ( m_dZoomFactor == maxZoom ) && ( scale > 1 ) )
+  if( ( m_dZoomFactor == kMaxZoom ) && ( scale > 1 ) )
     return new_scale;
 
   double newZoomFactor = m_dZoomFactor * scale * 100.0;
@@ -184,10 +219,10 @@ double ViewArea::scaleZoomFactor( double scale, QPoint center, QSize minimumSize
 
   if( !minimumSize.isNull() )
   {
-    double cw = m_pixmap.width() * m_dZoomFactor;
-    double ch = m_pixmap.height() * m_dZoomFactor;
-    double fw = m_pixmap.width() * newZoomFactor;
-    double fh = m_pixmap.height() * newZoomFactor;
+    double cw = m_image.width() * m_dZoomFactor;
+    double ch = m_image.height() * m_dZoomFactor;
+    double fw = m_image.width() * newZoomFactor;
+    double fh = m_image.height() * newZoomFactor;
     double mw = minimumSize.width();
     double mh = minimumSize.height();
 
@@ -215,16 +250,16 @@ double ViewArea::scaleZoomFactor( double scale, QPoint center, QSize minimumSize
 
   new_scale = scale;
 
-  if( newZoomFactor < minZoom )
+  if( newZoomFactor < kMinZoom )
   {
-    newZoomFactor = minZoom;
+    newZoomFactor = kMinZoom;
     new_scale = newZoomFactor / m_dZoomFactor;
   }
   else
   {
-    if( newZoomFactor > maxZoom )
+    if( newZoomFactor > kMaxZoom )
     {
-      newZoomFactor = maxZoom;
+      newZoomFactor = kMaxZoom;
       new_scale = newZoomFactor / m_dZoomFactor;
     }
   }
@@ -320,45 +355,45 @@ void ViewArea::setSnapToGrid( bool enable )
 
 void ViewArea::initZoomWinRect()
 {
-  int iMinX = 80;
-  int iMinY = 80;
+  double iMinX = 80;
+  double iMinY = 80;
 
-  int iMaxX = iMinX * 5;
-  int iMaxY = iMinY * 5;
+  double iMaxX = iMinX * 5;
+  double iMaxY = iMinY * 5;
 
   double dSizeRatio, dWinZoomRatio;
 
-  int iHorizontalImg = ( m_pixmap.width() > m_pixmap.height() ) ? 1 : 0;
+  bool iHorizontalImg = m_image.width() > m_image.height();
 
   if( iHorizontalImg )
   {
-    dSizeRatio = (double)m_pixmap.width() / (double)m_pixmap.height();
+    dSizeRatio = (double)m_image.width() / (double)m_image.height();
   }
   else
   {
-    dSizeRatio = (double)m_pixmap.height() / (double)m_pixmap.width();
+    dSizeRatio = (double)m_image.height() / (double)m_image.width();
   }
 
   if( dSizeRatio > 5.0 )
   {
     if( iHorizontalImg )
     {
-      dWinZoomRatio = (double)( m_pixmap.width() * 1024 / iMaxX ) / 1000.0;
+      dWinZoomRatio = static_cast<double>( m_image.width() ) * 1024.0 / iMaxX / 1000.0;
     }
     else
     {
-      dWinZoomRatio = (double)( m_pixmap.height() * 1024 / iMaxY ) / 1000.0;
+      dWinZoomRatio = static_cast<double>( m_image.height() ) * 1024.0 / iMaxY / 1000.0;
     }
   }
   else
   {
     if( iHorizontalImg )
     {
-      dWinZoomRatio = (double)( m_pixmap.height() * 1024 / iMinY ) / 1000.0;
+      dWinZoomRatio = static_cast<double>( m_image.height() ) * 1024.0 / iMinY / 1000.0;
     }
     else
     {
-      dWinZoomRatio = (double)( m_pixmap.width() * 1024 / iMinX ) / 1000.0;
+      dWinZoomRatio = static_cast<double>( m_image.width() ) * 1024.0 / iMinX / 1000.0;
     }
   }
 
@@ -370,8 +405,8 @@ void ViewArea::initZoomWinRect()
 ////////////////////////////////////////////////////////////////////////////////
 void ViewArea::updateSize()
 {
-  int w = m_pixmap.width() * m_dZoomFactor;
-  int h = m_pixmap.height() * m_dZoomFactor;
+  int w = m_image.width() * m_dZoomFactor;
+  int h = m_image.height() * m_dZoomFactor;
   setMinimumSize( w, h );
 
   QWidget* p = parentWidget();
@@ -389,17 +424,17 @@ void ViewArea::updateSize()
 
 void ViewArea::updateOffset()
 {
-  if( width() > m_pixmap.width() * m_dZoomFactor )
+  if( width() > m_image.width() * m_dZoomFactor )
   {
-    m_xOffset = ( width() - m_pixmap.width() * m_dZoomFactor ) / 2;
+    m_xOffset = ( width() - m_image.width() * m_dZoomFactor ) / 2;
   }
   else
   {
     m_xOffset = 0;
   }
-  if( height() > m_pixmap.height() * m_dZoomFactor )
+  if( height() > m_image.height() * m_dZoomFactor )
   {
-    m_yOffset = ( height() - m_pixmap.height() * m_dZoomFactor ) / 2;
+    m_yOffset = ( height() - m_image.height() * m_dZoomFactor ) / 2;
   }
   else
   {
@@ -412,7 +447,7 @@ void ViewArea::updateOffset()
 ////////////////////////////////////////////////////////////////////////////////
 void ViewArea::resizeEvent( QResizeEvent* event )
 {
-  if( size().isEmpty() || m_pixmap.isNull() )
+  if( size().isEmpty() || m_image.isNull() )
     return;
 
   updateOffset();
@@ -425,12 +460,11 @@ void ViewArea::resizeEvent( QResizeEvent* event )
 
 void ViewArea::paintEvent( QPaintEvent* event )
 {
+  m_currFrame = m_nextFrame;
+
   QRect winRect = event->rect();
 
-  if( visibleRegion().isEmpty() )
-    return;
-
-  if( size().isEmpty() || m_pixmap.isNull() )
+  if( visibleRegion().isEmpty() || size().isEmpty() || m_image.isNull() || m_currFrame == nullptr )
     return;
 
   QSize windowSize = parentWidget()->size();
@@ -443,15 +477,14 @@ void ViewArea::paintEvent( QPaintEvent* event )
 
   // This line is for fast paiting. Only visible area of the image is painted.
   // We take the exposed rect from the event (that gives us scroll/expose
-  // optimizations for free – no need
-  // to draw the whole pixmap if your widget is only partially exposed), and
-  // reverse map it with the painter matrix.
+  // optimizations for free – no need to draw the whole pixmap if your widget
+  // is only partially exposed), and reverse map it with the painter matrix.
   // That gives us the part of the pixmap that has actually been exposed.
-  // See:
-  // http://blog.qt.digia.com/blog/2006/05/13/fast-transformed-pixmapimage-drawing/
-  QRect exposedRect = painter.worldTransform().inverted().mapRect( event->rect() ).adjusted( -1, -1, 1, 1 );
+  // See: http://blog.qt.digia.com/blog/2006/05/13/fast-transformed-pixmapimage-drawing/
+  QRect exposedRect = painter.worldTransform().inverted().mapRect( winRect ).adjusted( -1, -1, 1, 1 );
   // Draw the pixmap.
-  painter.drawPixmap( exposedRect, m_pixmap, exposedRect );
+  // painter.drawPixmap( exposedRect, m_pixmap, exposedRect );
+  painter.drawImage( exposedRect, m_image, exposedRect );
 
   // Draw the Grid if it's visible.
   if( m_bGridVisible )
@@ -469,33 +502,33 @@ void ViewArea::paintEvent( QPaintEvent* event )
     // is, is referenced to the not scaled image.
     // To know what image area we need to update, just intersects the
     // rectangle area with the image area.
-    vr &= QRect( 0, 0, m_pixmap.width(), m_pixmap.height() );
+    vr &= QRect( 0, 0, m_image.width(), m_image.height() );
 
     // Set up for the grid drawer.
     painter.setRenderHint( QPainter::Antialiasing );
 
     // Draw grid.
-    m_grid.drawGrid( m_pixmap, vr, &painter );
+    m_grid.drawGrid( m_image, vr, &painter );
   }
 
   painter.restore();
 
   // Draw a border around the image.
   /*  if( m_xOffset || m_yOffset )
-	 {
-	 painter.setPen( Qt::black );
-	 painter.drawRect( m_xOffset - 1, m_yOffset - 1, m_pixmap.width() *
-	 m_dZoomFactor + 1, m_pixmap.height() *
-	 m_dZoomFactor + 1 );
-	 }*/
+   {
+   painter.setPen( Qt::black );
+   painter.drawRect( m_xOffset - 1, m_yOffset - 1, m_image.width() *
+   m_dZoomFactor + 1, m_image.height() *
+   m_dZoomFactor + 1 );
+   }*/
 
-  int frFormat = m_pcCurrFrame->getColorSpace();
+  int frFormat = m_currFrame->getColorSpace();
 
   // Draw pixel values in grid
   if( m_dZoomFactor >= 60.0 || ( frFormat != CLP_COLOR_RGBA && m_dZoomFactor >= 50.0 ) )
   {
-    int imageWidth = m_pixmap.width();
-    int imageHeight = m_pixmap.height();
+    int imageWidth = m_image.width();
+    int imageHeight = m_image.height();
     ;
 
     QFont font( "Helvetica" );
@@ -513,7 +546,7 @@ void ViewArea::paintEvent( QPaintEvent* event )
 
         QRect pixelRect( viewToWindow( pixelTopLeft ), QSize( m_dZoomFactor, m_dZoomFactor ) );
         QString pixelValue;
-        CalypPixel pixel = m_pcCurrFrame->getPixel( pixelTopLeft.x(), pixelTopLeft.y() );
+        CalypPixel pixel = m_currFrame->getPixel( pixelTopLeft.x(), pixelTopLeft.y() );
 
         if( frFormat == CLP_COLOR_YUV || frFormat == CLP_COLOR_GRAY )
         {
@@ -560,33 +593,33 @@ void ViewArea::paintEvent( QPaintEvent* event )
       painter.drawLine( viewToWindow( QPoint( 0, y ) ), viewToWindow( QPoint( imageWidth, y ) ) );
     }
   }
-  bool showZoomRect = m_pixmap.width() * m_dZoomFactor > windowSize.width() ||
-                      m_pixmap.height() * m_dZoomFactor > windowSize.height();
+  bool showZoomRect = m_image.width() * m_dZoomFactor > windowSize.width() ||
+                      m_image.height() * m_dZoomFactor > windowSize.height();
 
   // VISIBLE ZOOM RECT
   if( m_visibleZoomRect && m_zoomWinTimer.isActive() && showZoomRect )
   {
     double dRatio = m_dZoomWinRatio;
 
-    QRect cImg = QRect( 0, 0, m_pixmap.width(), m_pixmap.height() );
+    QRect cImg = QRect( 0, 0, m_image.width(), m_image.height() );
     QPoint cZWinRBpos = QPoint( winRect.bottomRight() ) - QPoint( 15, 15 );
     QRect cImgWinRect( 0, 0, round( (double)cImg.width() / dRatio ), round( (double)cImg.height() / dRatio ) );
     cImgWinRect.moveBottomRight( cZWinRBpos );
 
     QRect vr = windowToView( winRect );
     QRect cVisibleImg = vr & cImg;
-    //cVisibleImg.moveTopLeft(vr.topLeft());
+    // cVisibleImg.moveTopLeft(vr.topLeft());
     QRect cVisibleWinRect;
     cVisibleWinRect.setLeft( floor( (double)cVisibleImg.x() / dRatio ) );
     cVisibleWinRect.setTop( floor( (double)cVisibleImg.y() / dRatio ) );
     cVisibleWinRect.setRight( round( (double)cVisibleImg.right() / dRatio ) );
     cVisibleWinRect.setBottom( round( (double)cVisibleImg.bottom() / dRatio ) );
 
-    //painter.fillRect( cImgWinRect, QBrush( QColor( 128, 128, 128, 128 ) ) );
+    // painter.fillRect( cImgWinRect, QBrush( QColor( 128, 128, 128, 128 ) ) );
     painter.setPen( QColor( 50, 50, 50, 128 ) );
-    //painter.drawRect( cImgWinRect );
+    // painter.drawRect( cImgWinRect );
     painter.setOpacity( 0.7 );
-    painter.drawPixmap( cImgWinRect, m_pixmap );
+    painter.drawImage( cImgWinRect, m_image );
     painter.setOpacity( 1 );
 
     cVisibleWinRect.moveTopLeft( cImgWinRect.topLeft() + cVisibleWinRect.topLeft() );
@@ -607,7 +640,7 @@ void ViewArea::paintEvent( QPaintEvent* event )
     painter.setPen( QColor( 255, 255, 255, 128 ) );
     painter.drawRect( cVisibleWinRect );
 
-    //qDebug() << "Debug VisibleZoomRect: " << winRect << vr << cImgWinRect << cVisibleWinRect << cVisibleImg << dRatio;
+    // qDebug() << "Debug VisibleZoomRect: " << winRect << vr << cImgWinRect << cVisibleWinRect << cVisibleImg << dRatio;
   }
 
   QRect sr = viewToWindow( m_selectedArea );
@@ -618,7 +651,7 @@ void ViewArea::paintEvent( QPaintEvent* event )
     if( m_newShape || m_blockTrackEnable )
     {
       // Set the tool color
-      QColor selectColor = selectionColor;
+      QColor selectColor = kSelectionColor;
 
       selectColor.setAlpha( 120 );
 
@@ -643,7 +676,7 @@ void ViewArea::paintEvent( QPaintEvent* event )
       painter.setBrush( fill );
       painter.setPen( Qt::NoPen );
       QPainterPath myPath;
-      QRect imgr = viewToWindow( QRect( 0, 0, m_pixmap.width(), m_pixmap.height() ) );
+      QRect imgr = viewToWindow( QRect( 0, 0, m_image.width(), m_image.height() ) );
 
       myPath.addRect( imgr );
       myPath.addRect( sr );  // m_selectedArea
@@ -672,7 +705,7 @@ void ViewArea::paintEvent( QPaintEvent* event )
   if( m_maskColor.isValid() )
     color = m_maskColor;
   else
-    color = imageMaskColor;
+    color = kImageMaskColor;
 
   color.setAlpha( 120 );
   painter.setPen( color );
@@ -688,22 +721,20 @@ void ViewArea::paintEvent( QPaintEvent* event )
     {
       switch( tool() )
       {
-      case MaskTool:
-      {
+      case MaskTool: {
         if( m_maskColor.isValid() )
           color = m_maskColor;
         else
-          color = imageMaskColor;
+          color = kImageMaskColor;
 
         break;
       }
-      case EraserTool:
-      {
-        color = eraserColor;
+      case EraserTool: {
+        color = kEraserColor;
         break;
       }
       default:
-        color = selectionColor;  // ?Problems!
+        color = kSelectionColor;  // ?Problems!
       }
 
       color.setAlpha( 120 );
@@ -733,7 +764,7 @@ void ViewArea::wheelEvent( QWheelEvent* event )
 
   if( event->modifiers() & Qt::ControlModifier )
   {
-    scale = 0.001 * event->delta();
+    scale = 0.001 * event->angleDelta().y();
     if( scale > 0 )
       scale = 1.25;
     else
@@ -741,10 +772,16 @@ void ViewArea::wheelEvent( QWheelEvent* event )
 
     QWidget* p = parentWidget();
     QSize minimumSize = QSize( p->size().width() - 5, p->size().height() - 5 );
-    usedScale = scaleZoomFactor( scale, event->pos(), minimumSize );
+
+#if QT_VERSION < QT_VERSION_CHECK( 5, 14, 0 )
+    auto eventPosition = event->pos();
+#else
+    auto eventPosition = event->position().toPoint();
+#endif
+    usedScale = scaleZoomFactor( scale, eventPosition, minimumSize );
     if( usedScale != 1.0 )
     {
-      emit zoomFactorChanged_byWheel( usedScale, event->pos() );
+      emit zoomFactorChanged_byWheel( usedScale, eventPosition );
     }
   }
 }
@@ -755,7 +792,7 @@ void ViewArea::mousePressEvent( QMouseEvent* event )
 
   QPoint vpos = windowToView( event->pos() );
 
-  if( event->button() == Qt::MidButton )
+  if( event->button() == Qt::MiddleButton )
   {
   }
   if( event->button() == Qt::LeftButton )
@@ -902,24 +939,24 @@ void ViewArea::mouseMoveEvent( QMouseEvent* event )
       }
     }
     /*    else // if tool() == BlockSelectionTool || MaskTool || EraserTool
-		 {
-		 m_blockTrackEnable = false;
-		 // If cursor is inside the selected area, we most redraw
-		 // the selection rect because it may be smaller.
-		 if( m_selectedArea.contains( actualPos ) )
-		 {
-		 m_selectedArea = m_grid.rectContains( m_lastPos );
-		 }
+     {
+     m_blockTrackEnable = false;
+     // If cursor is inside the selected area, we most redraw
+     // the selection rect because it may be smaller.
+     if( m_selectedArea.contains( actualPos ) )
+     {
+     m_selectedArea = m_grid.rectContains( m_lastPos );
+     }
 
-		 m_selectedArea = m_selectedArea.united( m_grid.rectContains( actualPos ) );
-		 }
-		 */
+     m_selectedArea = m_selectedArea.united( m_grid.rectContains( actualPos ) );
+     }
+     */
     if( tool() == SelectionTool )
     {
       // intercept the selected area with the image area to limit the
       // selection only to the image area, preventing it to come outside
       // the image.
-      m_selectedArea &= QRect( 0, 0, m_pixmap.width(), m_pixmap.height() );
+      m_selectedArea &= QRect( 0, 0, m_image.width(), m_image.height() );
 
       // Update only the united area
       //      updateRect = updateRect.united( viewToWindow( m_selectedArea ) );
@@ -1003,7 +1040,7 @@ void ViewArea::mouseReleaseEvent( QMouseEvent* event )
 
 bool ViewArea::isPosValid( const QPoint& pos ) const
 {
-  if( pos.x() < 0 || pos.y() < 0 || pos.x() >= m_pixmap.width() || pos.y() >= m_pixmap.height() )
+  if( pos.x() < 0 || pos.y() < 0 || pos.x() >= m_image.width() || pos.y() >= m_image.height() )
     return false;
   else
     return true;
@@ -1075,8 +1112,7 @@ void ViewArea::updateMask( const QRect& rect )
 {
   switch( tool() )
   {
-  case MaskTool:
-  {
+  case MaskTool: {
     // Add rect to the mask
     QPainter painter( &m_mask );
     painter.setBrush( Qt::color1 );
@@ -1085,8 +1121,7 @@ void ViewArea::updateMask( const QRect& rect )
     painter.end();
     break;
   }
-  case EraserTool:
-  {
+  case EraserTool: {
     // Clears rect area in the mask
     QPainter painter( &m_mask );
     painter.setBrush( Qt::color0 );
@@ -1096,6 +1131,6 @@ void ViewArea::updateMask( const QRect& rect )
     break;
   }
   default: /* Do Nothing */
-           ;
+      ;
   }
 }

app/ViewArea.h

@@ -1,5 +1,5 @@
 /*    This file is a part of Calyp project
- *    Copyright (C) 2014-2019  by Joao Carreira   (jfmcarreira@gmail.com)
+ *    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
@@ -26,17 +26,17 @@
 #ifndef __VIEWAREA_H__
 #define __VIEWAREA_H__
 
-#include "CommonDefs.h"
-#include "GridManager.h"
-#include "config.h"
-#include "lib/CalypFrame.h"
-
 #include <QBitmap>
 #include <QColor>
 #include <QPixmap>
 #include <QTimer>
 #include <QWidget>
 
+#include "CommonDefs.h"
+#include "GridManager.h"
+#include "config.h"
+#include "lib/CalypFrame.h"
+
 class CalypStream;
 
 /**
@@ -56,17 +56,15 @@ public:
 
   ViewArea( QWidget* parent = 0 );
 
-  void setImage( CalypFrame* pcFrame );
-  void setImage( const QPixmap& pixmap );
+  void setImage( std::shared_ptr<CalypFrame> frame );
+
+  auto getFilteredChannel() -> std::optional<std::size_t>;
+  void setFilteredChannel( std::size_t channel );
+  void clearFilteredChannel();
 
   void setMode( int mode );
   void setMaskColor( const QColor& color = QColor() );
 
-  /**
-   * Clears any contents.
-   */
-  void clear();
-
   /**
    * Select tool from the menu
    */
@@ -83,8 +81,6 @@ public:
    */
   void clearMask();
 
-  QPixmap image() const { return m_pixmap; }
-  QBitmap mask() const { return m_mask; }
   QRect selectedArea() const { return m_selectedArea; }
   GridManager gridManager() const { return m_grid; }
   QColor maskColor() const { return m_maskColor; }
@@ -110,12 +106,12 @@ public Q_SLOTS:
   //  void setSelectedArea( QRect &rect );
 
 protected:
-  void paintEvent( QPaintEvent* event );
-  void resizeEvent( QResizeEvent* event );
-  void mousePressEvent( QMouseEvent* event );
-  void mouseMoveEvent( QMouseEvent* event );
-  void mouseReleaseEvent( QMouseEvent* event );
-  void wheelEvent( QWheelEvent* event );
+  void paintEvent( QPaintEvent* event ) override;
+  void resizeEvent( QResizeEvent* event ) override;
+  void mousePressEvent( QMouseEvent* event ) override;
+  void mouseMoveEvent( QMouseEvent* event ) override;
+  void mouseReleaseEvent( QMouseEvent* event ) override;
+  void wheelEvent( QWheelEvent* event ) override;
 
   void updateSize();
   void updateOffset();
@@ -150,33 +146,36 @@ private:
   QPoint viewToWindow( const QPoint& pt ) const;
   QRect viewToWindow( const QRect& rc ) const;
 
-  CalypFrame* m_pcCurrFrame;
+  std::shared_ptr<CalypFrame> m_currFrame;
+  QImage m_image;
+  std::shared_ptr<CalypFrame> m_nextFrame;
 
+  std::optional<std::size_t> m_filterSingleChannel;
   ClpPel m_uiPixelHalfScale;
 
-  Tool m_eTool;
-  bool m_bGridVisible;
+  Tool m_eTool{ NavigationTool };
+  bool m_bGridVisible{ false };
 
   QTimer m_zoomWinTimer;
   double m_dZoomWinRatio;
-  double m_dZoomFactor;
+  double m_dZoomFactor{ 1.0 };
 
-  QPixmap m_pixmap;
+  // QPixmap m_pixmap;
   QBitmap m_mask;
   QRect m_selectedArea;
   QPoint m_lastPos;
   QPoint m_lastWindowPos;
   GridManager m_grid;
-  ViewMode m_mode;
+  ViewMode m_mode{ NormalMode };
 
   QColor m_maskColor;
-  int m_xOffset;
-  int m_yOffset;
-  bool m_blockTrackEnable;
+  int m_xOffset{ 0 };
+  int m_yOffset{ 0 };
+  bool m_blockTrackEnable{ false };
   bool m_newShape;
-  bool m_snapToGrid;
+  bool m_snapToGrid{ false };
   bool m_cursorInGrid;
-  bool m_visibleZoomRect;
+  bool m_visibleZoomRect{ true };
 };
 
 #endif  // __VIEWAREA_H__

app/dialog/AboutDialog.cpp

@@ -1,5 +1,5 @@
 /*    This file is a part of Calyp project
- *    Copyright (C) 2014-2019  by Joao Carreira   (jfmcarreira@gmail.com)
+ *    Copyright (C) 2014-2021  by Joao Carreira   (jfmcarreira@gmail.com)
  *                                Luis Lucas      (luisfrlucas@gmail.com)
  *                                Joao Santos     (joaompssantos@gmail.com)
  *
@@ -27,14 +27,14 @@
 
 #include "AboutDialog.h"
 
-#include "config.h"
-
 #include <QApplication>
 #include <QDialogButtonBox>
 #include <QLabel>
 #include <QTextEdit>
 #include <QVBoxLayout>
 
+#include "config.h"
+
 #define TAB_FROM_SPACES "&nbsp;&nbsp;&nbsp;"
 
 AboutDialog::AboutDialog( QWidget* parent )
@@ -49,7 +49,7 @@ AboutDialog::AboutDialog( QWidget* parent )
                                   .arg( QApplication::applicationVersion() ) );
   label->setWordWrap( false );
 
-  QString featuresList = QStringLiteral( "<p><h3><b>Features:</b></h3><ul>" );
+  QString featuresList = QStringLiteral( "<p><h4><b>Features:</b></h4><ul>" );
 
 #ifdef USE_QTDBUS
   featuresList.append( QStringLiteral( "<li>Support for Qt DBus messages" ) );
@@ -63,14 +63,21 @@ AboutDialog::AboutDialog( QWidget* parent )
   featuresList.append( QStringLiteral( "</ul></p>" ) );
   QLabel* labelFeatures = new QLabel( featuresList );
 
-  QLabel* labelCopyright = new QLabel( QStringLiteral( "Copyright © 2014–2018 Joao Carreira and Luis Lucas" ) );
+  QString thanksList = QStringLiteral( "<p><h4><b>Thanks to:</b></h4><ul>" );
+  thanksList.append( QStringLiteral( "<li>Joao Santos" ) );
+  thanksList.append( QStringLiteral( "<li>Jose Filipe" ) );
+  thanksList.append( QStringLiteral( "</ul></p>" ) );
+  QLabel* labelContributors = new QLabel( thanksList );
+
+  QLabel* labelCopyright = new QLabel( QStringLiteral( "Copyright 2014–2021 Joao Carreira and Luis Lucas" ) );
 
   QWidget* topWidget = new QWidget;
   QVBoxLayout* topLayout = new QVBoxLayout;
   topLayout->addWidget( pixmapLabel, 0, Qt::AlignHCenter );
   topLayout->addWidget( label );
-  topLayout->addWidget( labelFeatures );
   topLayout->addWidget( labelCopyright );
+  topLayout->addWidget( labelFeatures );
+  topLayout->addWidget( labelContributors );
   topWidget->setLayout( topLayout );
 
   //	QTextEdit *textEdit = new QTextEdit(tr("<p>This program is free "

app/dialog/AboutDialog.h

@@ -1,5 +1,5 @@
 /*    This file is a part of Calyp project
- *    Copyright (C) 2014-2019  by Joao Carreira   (jfmcarreira@gmail.com)
+ *    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

app/dialog/ConfigureFormatDialog.cpp

@@ -1,5 +1,5 @@
 /*    This file is a part of Calyp project
- *    Copyright (C) 2014-2019  by Joao Carreira   (jfmcarreira@gmail.com)
+ *    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
@@ -24,8 +24,6 @@
 
 #include "ConfigureFormatDialog.h"
 
-#include "lib/CalypFrame.h"
-
 #include <QComboBox>
 #include <QDebug>
 #include <QDialogButtonBox>
@@ -39,6 +37,8 @@
 #include <QString>
 #include <QWidget>
 
+#include "lib/CalypFrame.h"
+
 #define MAX_SUPPORTED_RESOLUTION 99999
 
 QDataStream& operator<<( QDataStream& out, const CalypStandardResolutionVector& array )
@@ -382,8 +382,28 @@ ConfigureFormatDialog::ConfigureFormatDialog( QWidget* parent )
   setFixedSize( MainLayout->sizeHint() );
 }
 
+auto findPelFormatColorSpace( ClpPixelFormats rInputFormat ) -> std::pair<int, std::int64_t>
+{
+  if( rInputFormat != ClpPixelFormats::Invalid )
+  {
+    auto pelFmtName = CalypFrame::pixelFormatName( rInputFormat );
+    for( unsigned int j = 0; j < CalypFrame::supportedColorSpacesListNames().size(); j++ )
+    {
+      const auto& formats_list = CalypFrame::supportedPixelFormatListNames( j );
+      for( const auto& [key, name] : formats_list )
+      {
+        if( pelFmtName == name )
+        {
+          return std::make_pair( j, static_cast<int>( key ) );
+        }
+      }
+    }
+  }
+  return std::make_pair( 0, 0 );
+}
+
 int ConfigureFormatDialog::runConfigureFormatDialog( const QString& Filename, unsigned int& rWidth, unsigned int& rHeight,
-                                                     int& rInputFormat, unsigned int& rBits, int& rEndianess, unsigned int& rFrameRate )
+                                                     ClpPixelFormats& rInputFormat, unsigned int& rBits, int& rEndianess, unsigned int& rFrameRate )
 {
   // Set default values
   // setWindowTitle( "Configure resolution for " + Filename );
@@ -391,24 +411,8 @@ int ConfigureFormatDialog::runConfigureFormatDialog( const QString& Filename, un
   m_spinBoxWidth->setValue( rWidth );
   m_spinBoxheight->setValue( rHeight );
 
-  int colorSpace = 0;
-  int sampling = 0;
-  if( rInputFormat >= 0 )
-  {
-    ClpString pelFmtName = CalypFrame::supportedPixelFormatListNames()[rInputFormat];
-    for( unsigned int j = 0; j < CalypFrame::supportedColorSpacesListNames().size(); j++ )
-    {
-      for( unsigned int i = 0; i < CalypFrame::supportedPixelFormatListNames( j ).size(); i++ )
-      {
-        if( pelFmtName == CalypFrame::supportedPixelFormatListNames( j )[i] )
-        {
-          colorSpace = j;
-          sampling = i;
-          break;
-        }
-      }
-    }
-  }
+  auto [colorSpace, sampling] = findPelFormatColorSpace( rInputFormat );
+
   m_comboBoxColorSpace->setCurrentIndex( colorSpace );
   m_comboBoxPixelFormat->setCurrentIndex( sampling );
   m_spinBoxBits->setValue( rBits );
@@ -441,16 +445,8 @@ int ConfigureFormatDialog::runConfigureFormatDialog( const QString& Filename, un
   rWidth = m_spinBoxWidth->value();
   rHeight = m_spinBoxheight->value();
   colorSpace = m_comboBoxColorSpace->currentIndex();
-  sampling = m_comboBoxPixelFormat->currentIndex();
-  ClpString pelFmtName = CalypFrame::supportedPixelFormatListNames( colorSpace )[sampling];
-  for( unsigned int i = 0; i < CalypFrame::supportedPixelFormatListNames().size(); i++ )
-  {
-    if( pelFmtName == CalypFrame::supportedPixelFormatListNames()[i] )
-    {
-      rInputFormat = i;
-      break;
-    }
-  }
+  sampling = m_comboBoxPixelFormat->currentData().toInt();
+  rInputFormat = static_cast<ClpPixelFormats>( sampling );
   rBits = m_spinBoxBits->value();
   rEndianess = m_comboBoxEndianness->currentIndex();
   rFrameRate = m_spinBoxFrameRate->value();
@@ -512,9 +508,10 @@ void ConfigureFormatDialog::slotColorSpaceChange( int idx )
     return;
 
   m_comboBoxPixelFormat->clear();
-  for( unsigned int i = 0; i < CalypFrame::supportedPixelFormatListNames( idx ).size(); i++ )
+  const auto& formats_list = CalypFrame::supportedPixelFormatListNames( idx );
+  for( const auto& [key, name] : formats_list )
   {
-    m_comboBoxPixelFormat->insertItem( i, CalypFrame::supportedPixelFormatListNames( idx )[i].c_str() );
+    m_comboBoxPixelFormat->addItem( QString::fromStdString( std::string( name ) ), static_cast<int>( key ) );
   }
   m_comboBoxPixelFormat->setCurrentIndex( 0 );
 }

app/dialog/ConfigureFormatDialog.h

@@ -1,5 +1,5 @@
 /*    This file is a part of Calyp project
- *    Copyright (C) 2014-2019  by Joao Carreira   (jfmcarreira@gmail.com)
+ *    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
@@ -38,7 +38,7 @@ class QSpinBox;
 class QString;
 class QWidget;
 
-typedef QVector<CalypStandardResolution> CalypStandardResolutionVector;
+using CalypStandardResolutionVector = QVector<CalypStandardResolution>;
 QDataStream& operator<<( QDataStream& out, const CalypStandardResolutionVector& array );
 QDataStream& operator>>( QDataStream& in, CalypStandardResolutionVector& array );
 
@@ -51,7 +51,7 @@ class ConfigureFormatDialog : public QDialog
 
 public:
   ConfigureFormatDialog( QWidget* parent = 0 );
-  int runConfigureFormatDialog( const QString& Filename, unsigned int& rWidth, unsigned int& rHeight, int& rInputFormat, unsigned int& rBits,
+  int runConfigureFormatDialog( const QString& Filename, unsigned int& rWidth, unsigned int& rHeight, ClpPixelFormats& rInputFormat, unsigned int& rBits,
                                 int& rEndianess, unsigned int& rFrameRate );
 
   void readSettings();

app/dialog/ModulesHandleOptDialog.cpp

@@ -1,5 +1,5 @@
 /*    This file is a part of Calyp project
- *    Copyright (C) 2014-2019  by Joao Carreira   (jfmcarreira@gmail.com)
+ *    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
@@ -24,8 +24,6 @@
 
 #include "ModulesHandleOptDialog.h"
 
-#include "lib/CalypOptions.h"
-
 #include <QCheckBox>
 #include <QDialogButtonBox>
 #include <QLabel>
@@ -34,20 +32,21 @@
 #include <QVector>
 #include <QWidget>
 
+#include "lib/CalypOptions.h"
+
 class QLineEdit;
 
-class OpionConfiguration : public QWidget
+class OptionConfiguration : public QWidget
 {
 public:
-  OpionConfiguration( OptionBase* option )
+  OptionConfiguration( CalypOptions::OptionBase* option )
+      : m_cName{ option->opt_string }
   {
-    m_pcChecked = NULL;
-    m_cName = option->opt_string;
-    m_pcDescription = new QLabel;
+    auto* pcDescription = new QLabel;
     QString desc = QString::fromStdString( option->opt_desc );
-    m_pcDescription->setText( desc );
+    pcDescription->setText( desc );
     QHBoxLayout* layout = new QHBoxLayout;
-    layout->addWidget( m_pcDescription, 0, Qt::AlignLeft );
+    layout->addWidget( pcDescription, 0, Qt::AlignLeft );
     if( !option->isBinary() )
     {
       m_pcValue = new QLineEdit;
@@ -64,7 +63,7 @@ public:
     layout->setContentsMargins( 1, 1, 1, 1 );
     setLayout( layout );
   }
-  const QString getValue() const
+  auto getValue() const -> QString
   {
     if( m_pcChecked )
     {
@@ -72,13 +71,12 @@ public:
     }
     return m_pcValue->text();
   }
-  const ClpString& getName() { return m_cName; }
+  auto getName() const -> std::string { return m_cName; }
 
 private:
-  QLineEdit* m_pcValue;
-  QCheckBox* m_pcChecked;
-  QLabel* m_pcDescription;
-  ClpString m_cName;
+  QLineEdit* m_pcValue{ nullptr };
+  QCheckBox* m_pcChecked{ nullptr };
+  std::string m_cName;
 };
 
 ModulesHandleOptDialog::ModulesHandleOptDialog( QWidget* parent, CalypAppModuleIf* pcCurrModuleIf )
@@ -87,13 +85,12 @@ ModulesHandleOptDialog::ModulesHandleOptDialog( QWidget* parent, CalypAppModuleI
   resize( 400, 10 );
   setWindowTitle( "Select module parameters" );
 
-  const CalypOptions::OptionsList& moduleOptions = m_pcCurrModuleIf->m_pcModule->m_cModuleOptions.getOptionList();
+  auto& moduleOptions = m_pcCurrModuleIf->m_pcModule->m_cModuleOptions.getOptionList();
 
   QVBoxLayout* optionsLayout = new QVBoxLayout;
-  OpionConfiguration* pcOption;
-  for( CalypOptions::OptionsList::const_iterator it = moduleOptions.begin(); it != moduleOptions.end(); ++it )
+  for( auto& option : moduleOptions )
   {
-    pcOption = new OpionConfiguration( ( *it )->opt );
+    auto pcOption = new OptionConfiguration( option->base_opt.get() );
     m_apcOptionList.append( pcOption );
     optionsLayout->addWidget( pcOption );
   }
@@ -121,17 +118,17 @@ int ModulesHandleOptDialog::runConfiguration()
     return QDialog::Rejected;
   }
 
-  std::vector<ClpString> argsArray;
-  ClpString optionString;
+  std::vector<std::string> argsArray;
+  std::string optionString;
   QString valueString( "" );
 
-  for( int i = 0; i < m_apcOptionList.size(); i++ )
+  for( const auto& option : m_apcOptionList )
   {
-    valueString = m_apcOptionList.at( i )->getValue();
+    valueString = option->getValue();
     if( !valueString.isEmpty() )
     {
       optionString.append( "--" );
-      optionString.append( m_apcOptionList.at( i )->getName() );
+      optionString.append( option->getName() );
       if( !( valueString == "true" ) )
       {
         optionString.append( "=" );

app/dialog/ModulesHandleOptDialog.h

@@ -1,5 +1,5 @@
 /*    This file is a part of Calyp project
- *    Copyright (C) 2014-2019  by Joao Carreira   (jfmcarreira@gmail.com)
+ *    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
@@ -25,14 +25,14 @@
 #ifndef __MODULEHANDLEOPTDIALOG_H__
 #define __MODULEHANDLEOPTDIALOG_H__
 
+#include <QDialog>
+#include <QVector>
+
 #include "CalypAppModuleIf.h"
 #include "CommonDefs.h"
 #include "config.h"
 
-#include <QDialog>
-#include <QVector>
-
-class OpionConfiguration;
+class OptionConfiguration;
 
 /**
  *
@@ -47,7 +47,7 @@ public:
 
 private:
   CalypAppModuleIf* m_pcCurrModuleIf;
-  QVector<OpionConfiguration*> m_apcOptionList;
+  QVector<OptionConfiguration*> m_apcOptionList;
 };
 
 #endif  // __MODULEHANDLEOPTDIALOG_H__

app/dialog/ProgressBar.cpp

@@ -1,5 +1,5 @@
 /*    This file is a part of Calyp project
- *    Copyright (C) 2014-2019  by Joao Carreira   (jfmcarreira@gmail.com)
+ *    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

app/dialog/ProgressBar.h

@@ -1,5 +1,5 @@
 /*    This file is a part of Calyp project
- *    Copyright (C) 2014-2019  by Joao Carreira   (jfmcarreira@gmail.com)
+ *    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
@@ -25,11 +25,11 @@
 #ifndef __PROGRESSBAR_H__
 #define __PROGRESSBAR_H__
 
-#include "CommonDefs.h"
-
 #include <QDialog>
 #include <QWidget>
 
+#include "CommonDefs.h"
+
 class QProgressBar;
 
 class ProgressBar : public QWidget

app/dialog/SeekStreamDialog.cpp

@@ -1,5 +1,5 @@
 /*    This file is a part of Calyp project
- *    Copyright (C) 2014-2019  by Joao Carreira   (jfmcarreira@gmail.com)
+ *    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
@@ -24,8 +24,6 @@
 
 #include "SeekStreamDialog.h"
 
-#include "lib/CalypStream.h"
-
 #include <QDialogButtonBox>
 #include <QGridLayout>
 #include <QLabel>
@@ -33,7 +31,9 @@
 #include <QVector>
 #include <QWidget>
 
-SeekStreamDialog::SeekStreamDialog( CalypStream* pcCurrStream, QWidget* parent )
+#include "lib/CalypStream.h"
+
+SeekStreamDialog::SeekStreamDialog( const CalypStream* pcCurrStream, QWidget* parent )
     : QDialog( parent, Qt::Dialog | Qt::WindowTitleHint ), m_iSelectedFrameNum()
 {
   m_iSelectedFrameNum = pcCurrStream->getCurrFrameNum();

app/dialog/SeekStreamDialog.h

@@ -1,5 +1,5 @@
 /*    This file is a part of Calyp project
- *    Copyright (C) 2014-2019  by Joao Carreira   (jfmcarreira@gmail.com)
+ *    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
@@ -25,13 +25,13 @@
 #ifndef __SEEKSTREAMDIALOG_H__
 #define __SEEKSTREAMDIALOG_H__
 
+#include <QDialog>
+#include <QVector>
+
 #include "CalypAppModuleIf.h"
 #include "CommonDefs.h"
 #include "config.h"
 
-#include <QDialog>
-#include <QVector>
-
 class QSpinBox;
 
 /**
@@ -42,7 +42,7 @@ class SeekStreamDialog : public QDialog
   Q_OBJECT
 
 public:
-  SeekStreamDialog( CalypStream* pcCurrStream, QWidget* parent = 0 );
+  SeekStreamDialog( const CalypStream* pcCurrStream, QWidget* parent = 0 );
   int runDialog();
 
 private:

app/dialog/SubWindowSelectorDialog.cpp

@@ -1,5 +1,5 @@
 /*    This file is a part of Calyp project
- *    Copyright (C) 2014-2019  by Joao Carreira   (jfmcarreira@gmail.com)
+ *    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
@@ -24,12 +24,12 @@
 
 #include "SubWindowSelectorDialog.h"
 
-#include "SubWindowHandle.h"
-#include "VideoSubWindow.h"
-
 #include <QCheckBox>
 #include <QGroupBox>
 
+#include "SubWindowHandle.h"
+#include "VideoSubWindow.h"
+
 SubWindowSelectorDialog::SubWindowSelectorDialog( QWidget* parent, SubWindowHandle* windowManager,
                                                   unsigned int uiCategory, int minWindowsSelected, int maxWindowsSelected )
     : QDialog( parent )

app/dialog/SubWindowSelectorDialog.h

@@ -1,5 +1,5 @@
 /*    This file is a part of Calyp project
- *    Copyright (C) 2014-2019  by Joao Carreira   (jfmcarreira@gmail.com)
+ *    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
@@ -25,13 +25,12 @@
 #ifndef __DIALOGSUBWINDOWSELECTOR_H__
 #define __DIALOGSUBWINDOWSELECTOR_H__
 
-#include "CommonDefs.h"
-#include "config.h"
-
+#include <QVector>
 #include <QtCore>
 #include <QtWidgets>
 
-#include <QVector>
+#include "CommonDefs.h"
+#include "config.h"
 
 class QPixmap;
 class QColor;

app/docks/FramePropertiesDock.cpp

@@ -1,5 +1,5 @@
 /*    This file is a part of Calyp project
- *    Copyright (C) 2014-2019  by Joao Carreira   (jfmcarreira@gmail.com)
+ *    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
@@ -28,12 +28,12 @@
 #include <QtGui>
 #include <cmath>
 
+#include "lib/CalypStream.h"
+
 FramePropertiesDock::FramePropertiesDock( QWidget* parent, bool* pbMainPlaySwitch )
-    : QWidget( parent ), m_pbIsPlaying( pbMainPlaySwitch )
+    : QWidget( parent ), m_bIsPlaying( false ), m_bHasFrame( false )
 {
   // -------------- Variables definition --------------
-  m_pcFrame = NULL;
-  m_pcSelectedFrame = NULL;
   m_iLastFrameType = -1;
 
   // Histogram area -----------------------------------------------------
@@ -204,6 +204,11 @@ FramePropertiesDock::FramePropertiesDock( QWidget* parent, bool* pbMainPlaySwitc
   labelMedianValue = new QLabel;
   labelMedianValue->setAlignment( Qt::AlignRight | Qt::AlignVCenter );
 
+  QLabel* entropyLabel = new QLabel( tr( "Entropy:" ) );
+  entropyLabel->setAlignment( Qt::AlignLeft | Qt::AlignVCenter );
+  labelEntropyValue = new QLabel;
+  labelEntropyValue->setAlignment( Qt::AlignRight | Qt::AlignVCenter );
+
   QLabel* percentileLabel = new QLabel( tr( "Percentile:" ) );
   percentileLabel->setAlignment( Qt::AlignLeft | Qt::AlignVCenter );
   labelPercentileValue = new QLabel;
@@ -225,6 +230,10 @@ FramePropertiesDock::FramePropertiesDock( QWidget* parent, bool* pbMainPlaySwitc
   statisticsLayout->addWidget( labelStdDevValue, gridRow++, 1 );
   statisticsLayout->addWidget( medianLabel, gridRow, 0 );
   statisticsLayout->addWidget( labelMedianValue, gridRow++, 1 );
+  statisticsLayout->addWidget( percentileLabel, gridRow, 0 );
+  statisticsLayout->addWidget( labelPercentileValue, gridRow++, 1 );
+  statisticsLayout->addWidget( entropyLabel, gridRow, 0 );
+  statisticsLayout->addWidget( labelEntropyValue, gridRow++, 1 );
 
   QGroupBox* statisticsGroup = new QGroupBox( tr( "Statistics" ) );
   statisticsGroup->setLayout( statisticsLayout );
@@ -271,16 +280,15 @@ QSize FramePropertiesDock::sizeHint() const
 
 void FramePropertiesDock::reset()
 {
-  m_pcFrame = NULL;
+  m_pcFrame = nullptr;
+  m_pcSelectedFrame = nullptr;
+
+  m_bHasFrame = false;
   m_cSelectionArea = QRect();
-  if( m_pcSelectedFrame )
-  {
-    delete m_pcSelectedFrame;
-    m_pcSelectedFrame = NULL;
-  }
 
   m_iLastFrameType = -1;
 
+  labelRangeValue->clear();
   labelNEBinsValue->clear();
   labelMeanValue->clear();
   labelPixelsValue->clear();
@@ -288,6 +296,7 @@ void FramePropertiesDock::reset()
   labelCountValue->clear();
   labelMedianValue->clear();
   labelPercentileValue->clear();
+  labelEntropyValue->clear();
 
   // Remove the histogram data from memory
   histogramWidget->reset();
@@ -295,7 +304,7 @@ void FramePropertiesDock::reset()
   setEnabled( false );
 }
 
-void FramePropertiesDock::setFrame( CalypFrame* pcFrame )
+void FramePropertiesDock::setFrame( std::shared_ptr<CalypFrame> pcFrame, bool isPlaying )
 {
   int colorSpace = pcFrame->getColorSpace();
   if( m_iLastFrameType != colorSpace )
@@ -357,35 +366,40 @@ void FramePropertiesDock::setFrame( CalypFrame* pcFrame )
     }
   }
   setEnabled( true );
-  if( m_pcFrame || !( *m_pbIsPlaying ) )
+  m_bIsPlaying = isPlaying;
+  if( !m_bIsPlaying )
   {
-    m_pcFrame = pcFrame;
-    updateDataHistogram();
+    if( pcFrame )
+    {
+      m_bHasFrame = true;
+      m_pcFrame = pcFrame;
+    }
+    else
+    {
+      m_bHasFrame = false;
+    }
   }
+  updateDataHistogram();
 }
 
 void FramePropertiesDock::setSelection( const QRect& selectionArea )
 {
-  if( m_pcFrame )
+  if( m_bHasFrame )
   {
     bool bSelectionChanged = !( selectionArea.size() == m_cSelectionArea.size() );
-    m_cSelectionArea = selectionArea;
     if( selectionArea.isValid() )
     {
+      m_cSelectionArea = selectionArea;
       histogramWidget->stopHistogramComputation();
-
       /*
-       * Allocate a new image for the selection
-       * or just copy information
+       * Crop selection from frame
        */
       if( bSelectionChanged )
       {
-        if( m_pcSelectedFrame )
-        {
-          delete m_pcSelectedFrame;
-        }
-        m_pcSelectedFrame = new CalypFrame( m_pcFrame, selectionArea.x(), selectionArea.y(), selectionArea.width(),
-                                            selectionArea.height() );
+        m_pcSelectedFrame = std::make_shared<CalypFrame>( *m_pcFrame, selectionArea.x(),
+                                                          selectionArea.y(),
+                                                          selectionArea.width(),
+                                                          selectionArea.height() );
       }
       updateDataHistogram();
       selectionImageButton->click();
@@ -402,13 +416,21 @@ void FramePropertiesDock::setSelection( const QRect& selectionArea )
 
 void FramePropertiesDock::updateDataHistogram()
 {
-  if( m_pcFrame && isVisible() )
+  if( m_bHasFrame && isVisible() )
   {
-    if( !*m_pbIsPlaying )
+    if( m_bIsPlaying )
     {
-      if( m_pcSelectedFrame )
+      histogramWidget->setLoadingSkipped();
+    }
+    else
+    {
+      if( m_cSelectionArea.isValid() )
       {
-        m_pcSelectedFrame->copyFrom( m_pcFrame, m_cSelectionArea.x(), m_cSelectionArea.y() );
+        m_pcSelectedFrame = std::make_shared<CalypFrame>( *m_pcFrame,
+                                                          m_cSelectionArea.x(),
+                                                          m_cSelectionArea.y(),
+                                                          m_cSelectionArea.width(),
+                                                          m_cSelectionArea.height() );
         fullImageButton->show();
         selectionImageButton->show();
       }
@@ -417,12 +439,9 @@ void FramePropertiesDock::updateDataHistogram()
         fullImageButton->hide();
         selectionImageButton->hide();
       }
-      histogramWidget->updateData( m_pcFrame, m_pcSelectedFrame );
-    }
-    else
-    {
-      histogramWidget->setLoadingSkipped();
+      histogramWidget->updateData( m_pcFrame, m_cSelectionArea.isValid() ? m_pcSelectedFrame : nullptr );
     }
+
     histogramWidget->update();
   }
   else
@@ -443,7 +462,7 @@ void FramePropertiesDock::updateStatistiques()
   if( channel == CalypFrame::HIST_ALL_CHANNELS )
     channel = colorsCB->itemData( colorsCB->currentIndex() ).toInt();
 
-  CalypFrame* frame;
+  std::shared_ptr<CalypFrame> frame;
 
   if( histogramWidget->m_renderingType == HistogramWidget::FullImageHistogram )
     frame = histogramWidget->m_fullImage;
@@ -472,7 +491,10 @@ void FramePropertiesDock::updateStatistiques()
     labelCountValue->setText( value.setNum( (float)counts, 'f', 0 ) );
 
     double median = frame->getMedian( channel, min, max );
-    labelMedianValue->setText( value.setNum( median, 'f', 1 ) );
+    labelMedianValue->setText( value.setNum( median, 'f', 0 ) );
+
+    double entropy = frame->getEntropy( channel, min, max );
+    labelEntropyValue->setText( value.setNum( entropy, 'f', 2 ) );
 
     double percentile = ( pixels > 0 ? ( 100.0 * counts / pixels ) : 0.0 );
     labelPercentileValue->setText( value.setNum( percentile, 'f', 1 ) );
@@ -513,7 +535,7 @@ void FramePropertiesDock::slotRefreshOptions( int range )
 
 void FramePropertiesDock::slotHistogramComputationFailed()
 {
-  m_pcFrame = NULL;
+  m_bHasFrame = false;
 }
 
 void FramePropertiesDock::slotChannelChanged( int index )

app/docks/FramePropertiesDock.h

@@ -1,5 +1,5 @@
 /*    This file is a part of Calyp project
- *    Copyright (C) 2014-2019  by Joao Carreira   (jfmcarreira@gmail.com)
+ *    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
@@ -25,13 +25,14 @@
 #ifndef __FRAMEPROPERTIESDOCK_H__
 #define __FRAMEPROPERTIESDOCK_H__
 
+#include <QtWidgets>
+
 #include "CommonDefs.h"
 #include "HistogramWidget.h"
 #include "config.h"
 #include "lib/CalypFrame.h"
-#include "lib/CalypStream.h"
 
-#include <QtWidgets>
+class CalypStream;
 
 class FramePropertiesDock : public QWidget
 {
@@ -42,17 +43,17 @@ public:
 
   QSize sizeHint() const;
 
-  void setFrame( CalypFrame* m_pcFrame );
+  void setFrame( std::shared_ptr<CalypFrame> m_pcFrame, bool isPlaying );
   void setSelection( const QRect& selectionArea );
   void reset();
   void stopHistogram();
 
 private:
-  CalypFrame* m_pcFrame;
-  CalypFrame* m_pcSelectedFrame;
+  std::shared_ptr<CalypFrame> m_pcFrame;
+  std::shared_ptr<CalypFrame> m_pcSelectedFrame;
   int m_iLastFrameType;
-
-  bool* m_pbIsPlaying;
+  bool m_bIsPlaying;
+  bool m_bHasFrame;
 
   QComboBox* channelCB;
   QComboBox* colorsCB;
@@ -76,6 +77,7 @@ private:
   QLabel* labelMeanValue;
   QLabel* labelStdDevValue;
   QLabel* labelMedianValue;
+  QLabel* labelEntropyValue;
   QLabel* labelPercentileValue;
 
   QLabel* colorsLabel;

app/docks/ModuleHandleDock.cpp

@@ -1,5 +1,5 @@
 /*    This file is a part of Calyp project
- *    Copyright (C) 2014-2019  by Joao Carreira   (jfmcarreira@gmail.com)
+ *    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
@@ -24,14 +24,14 @@
 
 #include "ModuleHandleDock.h"
 
-#include "CalypAppModuleIf.h"
-#include "ModulesHandle.h"
-
 #include <QGridLayout>
 #include <QLabel>
 #include <QString>
 #include <QtGui>
 
+#include "CalypAppModuleIf.h"
+#include "ModulesHandle.h"
+
 ModuleHandleDock::ModuleHandleDock( QWidget* parent, CalypAppModuleIf* moduleIf )
     : QWidget( parent ), m_pcCurrModuleIf( moduleIf )
 {
@@ -58,9 +58,9 @@ ModuleHandleDock::ModuleHandleDock( QWidget* parent, CalypAppModuleIf* moduleIf
   setEnabled( true );
 }
 
-ModuleHandleDock::~ModuleHandleDock() {}
+ModuleHandleDock::~ModuleHandleDock() = default;
 
-void ModuleHandleDock::setModulueReturnValue( double value )
+void ModuleHandleDock::setModuleReturnValue( double value )
 {
   labelModulueReturnValue->clear();
   QString strValue = QString( "%1" ).arg( value );
@@ -69,11 +69,9 @@ void ModuleHandleDock::setModulueReturnValue( double value )
 
 void ModuleHandleDock::visibilityChangedSlot( bool visiblity )
 {
-  if( !visiblity && m_pcCurrModuleIf )
+  if( !visiblity )
   {
-    CalypAppModuleIf* pcCurrentModule = m_pcCurrModuleIf;
-    m_pcCurrModuleIf = NULL;
-    ModulesHandle::destroyModuleIf( pcCurrentModule );
+    m_pcCurrModuleIf->disable();
   }
 }
 

app/docks/ModuleHandleDock.h

@@ -1,5 +1,5 @@
 /*    This file is a part of Calyp project
- *    Copyright (C) 2014-2019  by Joao Carreira   (jfmcarreira@gmail.com)
+ *    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
@@ -25,12 +25,12 @@
 #ifndef __MODULEHANDLEDOCK_H__
 #define __MODULEHANDLEDOCK_H__
 
-#include "CommonDefs.h"
-#include "config.h"
-
 #include <QSize>
 #include <QWidget>
 
+#include "CommonDefs.h"
+#include "config.h"
+
 class QLabel;
 
 class CalypAppModuleIf;
@@ -42,7 +42,7 @@ public:
   ModuleHandleDock( QWidget* parent, CalypAppModuleIf* moduleIf );
   ~ModuleHandleDock();
 
-  void setModulueReturnValue( double value );
+  void setModuleReturnValue( double value );
 
   QSize sizeHint() const;
 

app/docks/QualityMeasurementSidebar.cpp

@@ -1,5 +1,5 @@
 /*    This file is a part of Calyp project
- *    Copyright (C) 2014-2019  by Joao Carreira   (jfmcarreira@gmail.com)
+ *    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
@@ -24,11 +24,11 @@
 
 #include "QualityMeasurementSidebar.h"
 
+#include <QtGui>
+
 #include "SubWindowHandle.h"
 #include "VideoSubWindow.h"
 
-#include <QtGui>
-
 QualityMeasurementSidebar::QualityMeasurementSidebar( QWidget* parent, SubWindowHandle* windowManager )
     : QWidget( parent ), m_pcMainWindowManager( windowManager ), m_pcCurrentVideoSubWindow( NULL )
 {

app/docks/QualityMeasurementSidebar.h

@@ -1,5 +1,5 @@
 /*    This file is a part of Calyp project
- *    Copyright (C) 2014-2019  by Joao Carreira   (jfmcarreira@gmail.com)
+ *    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
@@ -25,14 +25,14 @@
 #ifndef __QUALITYMEASUREMENTSIDEBAR_H__
 #define __QUALITYMEASUREMENTSIDEBAR_H__
 
+#include <QtWidgets>
+
 #include "CommonDefs.h"
 #include "HistogramWidget.h"
 #include "config.h"
 #include "lib/CalypFrame.h"
 #include "lib/CalypStream.h"
 
-#include <QtWidgets>
-
 class SubWindowHandle;
 class VideoSubWindow;
 

app/external/CMakeLists.txt

@@ -1,5 +1,5 @@
-###
-### CMakeLists for calyp external components
-###
+#
+# CMakeLists for calyp external components
+#
 
-ADD_SUBDIRECTORY( qcustomplot )
+ADD_SUBDIRECTORY(qcustomplot)

app/external/qcustomplot/CMakeLists.txt

@@ -1,20 +1,17 @@
-###
-### CMakeLists for qcustomplot
-###
+#
+# CMakeLists for qcustomplot
+#
 
-FIND_PACKAGE( Qt5 REQUIRED COMPONENTS Core Gui Widgets PrintSupport )
+FIND_PACKAGE(Qt5 REQUIRED COMPONENTS Core Gui Widgets PrintSupport)
 
-set(qcustomplot_SRCS
-  qcustomplot.cpp
-  qcustomplot.h
-)
+SET(qcustomplot_SRCS qcustomplot.cpp qcustomplot.h)
 
-ADD_LIBRARY( QCustomPlotLib STATIC ${qcustomplot_SRCS} )
-TARGET_LINK_LIBRARIES( QCustomPlotLib
-  Qt5::Core
-  Qt5::Gui
-  Qt5::Widgets
-  Qt5::PrintSupport
-)
+SET(CMAKE_AUTOMOC ON)
 
-TARGET_INCLUDE_DIRECTORIES(QCustomPlotLib PUBLIC . )
+IF(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}  -Wno-deprecated-declarations -Wno-deprecated-enum-enum-conversion")
+ENDIF()
+
+ADD_LIBRARY(QCustomPlotLib STATIC ${qcustomplot_SRCS})
+TARGET_LINK_LIBRARIES(QCustomPlotLib Qt5::Core Qt5::Gui Qt5::Widgets Qt5::PrintSupport)
+TARGET_INCLUDE_DIRECTORIES(QCustomPlotLib PUBLIC .)

app/external/qcustomplot/GPL.txt

@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    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 3 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, see <http://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<http://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<http://www.gnu.org/philosophy/why-not-lgpl.html>.

app/external/qcustomplot/changelog.txt

@@ -1,3 +1,37 @@
+#### Version 2.1.0 released on 29.03.21 ####
+
+Added features:
+  - Compatibility up to Qt 6.0
+  - Tech Preview: Radial Plots (see setupPolarPlotDemo in examples project)
+  - QCPAxisTickerDateTime can now be configured with a QTimeZone for adjusting the label display to arbitrary time zones
+  - QCPColorGradient (and thus also QCPColorMap) now has explicit configurable NaN handling (see QCPColorGradient::setNanHandling)
+  - added timing/benchmarking method QCustomPlot::replotTime(bool average) which returns the milliseconds per replot
+  - QCustomPlot::plottableAt has an optional output parameter dataIndex, providing the index of the data point at the probed position
+  - QCustomPlot::plottableAt<T> template method allows limiting the search to the specified QCPAbstractPlottable subclass T
+  - QCustomPlot::itemAt<T> template method allows limiting the search to the specified QCPAbstractItem subclass T
+  - Added Interaction flag QCP::iSelectPlottablesBeyondAxisRect, allows selection of data points very close to (and beyond of) the axes
+  - QCPAxisTickerDateTime::dateTimeToKey(QDate &) now also takes a TimeSpec to specify the interpretation of the start-of-day
+  - QCPAxisTickerLog now switches to linear ticks if zoomed in beyond where logarithmic ticks are reasonable
+  - Added QCustomPlot::afterLayout signal, for user code that crucially depends on layout sizes/positions, right before the draw step during a replot
+  
+Bugfixes:
+  - Fixed bug where QCPLayer::replot wouldn't issue full replot even though invalidated buffers existed
+  - Fixed QCPCurve bug causing rendering artifacts when using keys/values smaller than about 1e-12 in some constellations
+  - Fixed getValueRange when used with explicit keyRange, now doesn't use key range expanded by one point to each side anymore
+  - Fixed bug of QCPAxis tick label font size change only propagating to the layout after second call to replot
+  - Fixed bug of QCPTextElement not respecting the configured text alignment flag (setTextFlags)
+  - Various documentation typos and improvements
+  
+Other:
+  - QCP Now requires C++11. However, Qt4.6 compatibility is maintained in the QCP 2.x release series
+  - QCPColorScale is now initialized with gpCold gradient preset, which prevents color maps turning black when linking them to a default-created color scale without explicitly setting a gradient
+  - QCPLegend::clearItems is now faster in case of many legend items (>1000)
+  - Modernized expressions and thereby avoided some warnings (e.g. nullptr and casts)
+  - Switched to foreach (Qt macro) where possible (in preparation for switch to range-based for (C++11), soonest at next major release)
+  - Work around Qt bug, drawing lines with pen width 1 as slow as with pen widths > 1 (polyfill instead of line algorithm, also on Normal-DPI), by using pen width 0 in such cases.
+  - Added QCP::Interaction flag iNone=0x000 to allow explicitly specifying no interaction (Avoids QFlags::zero, which was deprecated in Qt5.14)
+  - QCP is now compatible with defines QT_USE_QSTRINGBUILDER, QT_USE_FAST_CONCATENATION (Qt<4.8), QT_USE_FAST_OPERATOR_PLUS (Qt<4.8)
+
 #### Version 2.0.1 released on 25.06.18 ####
 
 Bugfixes:

app/main.cpp

@@ -1,5 +1,5 @@
 /*    This file is a part of Calyp project
- *    Copyright (C) 2014-2019  by Joao Carreira   (jfmcarreira@gmail.com)
+ *    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
@@ -31,6 +31,7 @@
 #include "DBusAppAdaptor.h"
 #endif
 #include <QApplication>
+#include <QStyleFactory>
 #ifdef USE_FERVOR
 #include "fvupdater.h"
 #endif
@@ -51,6 +52,10 @@ int main( int argc, char* argv[] )
   QApplication::setApplicationVersion( QStringLiteral( CALYP_VERSION_STRING ) );
   QApplication::setOrganizationName( QStringLiteral( "PixLRA" ) );
 
+#if _WIN32
+  application.setStyle( QStyleFactory::create( "Fusion" ) );
+#endif
+
 #ifdef USE_QTDBUS
   /**
    * use dbus, if available

app/widgets/FrameNumberWidget.cpp

@@ -1,5 +1,5 @@
 /*    This file is a part of Calyp project
- *    Copyright (C) 2014-2019  by Joao Carreira   (jfmcarreira@gmail.com)
+ *    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

app/widgets/FrameNumberWidget.h

@@ -1,5 +1,5 @@
 /*    This file is a part of Calyp project
- *    Copyright (C) 2014-2019  by Joao Carreira   (jfmcarreira@gmail.com)
+ *    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
@@ -25,11 +25,11 @@
 #ifndef __WIDGETFRAMENUMBER_H__
 #define __WIDGETFRAMENUMBER_H__
 
+#include <QWidget>
+
 #include "CommonDefs.h"
 #include "config.h"
 
-#include <QWidget>
-
 class QLabel;
 
 class FrameNumberWidget : public QWidget

app/widgets/HistogramWidget.cpp

@@ -1,5 +1,5 @@
 /*    This file is a part of Calyp project
- *    Copyright (C) 2014-2019  by Joao Carreira   (jfmcarreira@gmail.com)
+ *    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
@@ -41,60 +41,42 @@ class HistogramWorker : public QThread
 {
 private:
   QObject* m_parent;
-  CalypFrame* m_pcFrame;
+  std::shared_ptr<CalypFrame> m_pcFrame{ nullptr };
 
 public:
   HistogramWorker( QObject* parent )
-  {
-    m_pcFrame = NULL;
-    m_parent = parent;
-  }
+      : m_parent{ parent } {}
 
-  void setup( CalypFrame* frame )
+  void reset() { m_pcFrame = nullptr; }
+
+  void setup( std::shared_ptr<CalypFrame> frame )
   {
-    m_pcFrame = frame;
-    // run();
+    m_pcFrame = std::move( frame );
+    EventData* eventData = new EventData();  // NOLINT
+    eventData->starting = true;
+    // QCoreApplication::postEvent( m_parent, eventData );
     start();
   }
-  void run()
+  void run() override
   {
-    if( m_pcFrame && m_parent )
+    EventData* eventData = new EventData();  // NOLINT
+    if( m_pcFrame != nullptr )
     {
-      EventData* eventData = new EventData();
-      //      eventDm_imageHistogramata->starting = true;
-      //      eventData->success = false;
-      //      eventData->histogram = m_histogram;
-      //      QCoreApplication::postEvent( m_parent, eventData );
-
-      eventData->starting = true;
-
       m_pcFrame->calcHistogram();
-
-      eventData->starting = false;
-      //       eventData->success = m_pcFrame->getHasHistogram();
-      eventData->success = true;
-      eventData->frame = m_pcFrame;
-      QCoreApplication::postEvent( m_parent, eventData );
+      eventData->frame = m_pcFrame.get();
     }
+    eventData->success = true;
+    QCoreApplication::postEvent( m_parent, eventData );
   }
 
-  /**
-	 * Custom Event
-	 */
   class EventData : public QEvent
   {
   public:
     EventData()
-        : QEvent( QEvent::User )
-    {
-      starting = false;
-      success = false;
-      frame = NULL;
-    }
-
-    bool starting;
-    bool success;
-    CalypFrame* frame;
+        : QEvent( QEvent::User ), frame{ nullptr } {}
+    CalypFrame* frame{ nullptr };
+    bool starting{ false };
+    bool success{ false };
   };
 };
 
@@ -239,8 +221,10 @@ void HistogramWidget::reset()
   d->guideVisible = false;
   d->clearFlag = HistogramWidgetPrivate::HistogramNone;
   // Remove histogram data from memory.
-  m_fullImage = NULL;
-  m_selectionImage = NULL;
+  m_fullImage = nullptr;
+  m_selectionImage = nullptr;
+  m_imageWorker->setup( nullptr );
+  m_selectionWorker->setup( nullptr );
   update();
 }
 
@@ -262,7 +246,7 @@ void HistogramWidget::customEvent( QEvent* event )
     return;
   }
 
-  if( ed->frame != m_fullImage && ed->frame != m_selectionImage )
+  if( ed->frame != m_fullImage.get() && ed->frame != m_selectionImage.get() )
   {
     return;
   }
@@ -323,8 +307,6 @@ void HistogramWidget::customEvent( QEvent* event )
       emit signalHistogramComputationFailed();
     }
   }
-
-  // delete ed;
 }
 ////////////////////////////////////////////////////////////////////////////////
 //                          Data Loading Functions
@@ -379,7 +361,7 @@ void HistogramWidget::stopHistogramComputation()
 //                          Update Data Methods
 ////////////////////////////////////////////////////////////////////////////////
 
-void HistogramWidget::updateData( CalypFrame* pcFrame, CalypFrame* pcFrameSelection )
+void HistogramWidget::updateData( std::shared_ptr<CalypFrame> pcFrame, std::shared_ptr<CalypFrame> pcFrameSelection )
 {
   d->imageBits = pcFrame->getBitsPel();
   switch( pcFrame->getColorSpace() )
@@ -497,7 +479,7 @@ void HistogramWidget::paintEvent( QPaintEvent* )
   int wWidth = width() - 1;
   int wHeight = height() - 1;
   double max;
-  CalypFrame* frame;
+  std::shared_ptr<CalypFrame> frame;
 
   if( m_renderingType == ImageSelectionHistogram && m_selectionImage )
     frame = m_selectionImage;
@@ -938,7 +920,11 @@ void HistogramWidget::paintEvent( QPaintEvent* )
 
     tipText += cellBeg + tr( "Median:" ) + cellMid;
     double median = frame->getMedian( m_channelType, 0, frame->getNumHistogramSegment() - 1 );
-    tipText += value.setNum( median, 'f', 1 ) + cellEnd;
+    tipText += value.setNum( median, 'f', 0 ) + cellEnd;
+
+    tipText += cellBeg + tr( "Entropy:" ) + cellMid;
+    double entropy = frame->getEntropy( m_channelType, 0, frame->getNumHistogramSegment() - 1 );
+    tipText += value.setNum( entropy, 'f', 2 ) + cellEnd;
 
     tipText += cellBeg + tr( "Percent:" ) + cellMid;
     double percentile = ( pixels > 0 ? ( 100.0 * counts / pixels ) : 0.0 );

app/widgets/HistogramWidget.h

@@ -1,5 +1,5 @@
 /*    This file is a part of Calyp project
- *    Copyright (C) 2014-2019  by Joao Carreira   (jfmcarreira@gmail.com)
+ *    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
@@ -26,13 +26,13 @@
 #ifndef __HISTOGRAMWIDGET_H__
 #define __HISTOGRAMWIDGET_H__
 
+#include <QColor>
+#include <QWidget>
+
 #include "CommonDefs.h"
 #include "config.h"
 #include "lib/CalypFrame.h"
 
-#include <QColor>
-#include <QWidget>
-
 class QEvent;
 
 class HistogramWorker;
@@ -90,7 +90,7 @@ public:
   void stopHistogramComputation();
 
   /** Update full image histogram data. */
-  void updateData( CalypFrame* pcFrame, CalypFrame* pcFrameSelection );
+  void updateData( std::shared_ptr<CalypFrame> pcFrame, std::shared_ptr<CalypFrame> pcFrameSelection );
 
   /** @see @p HistogramOption */
   void setOptions( HistogramOptions options = AllOptions );
@@ -113,12 +113,10 @@ public:
 
   /** Full image */
   HistogramWorker* m_imageWorker;
-  // CalypFrameStats* m_imageHistogram;
-  CalypFrame* m_fullImage;
+  std::shared_ptr<CalypFrame> m_fullImage;
   /** Histogram area selection */
   HistogramWorker* m_selectionWorker;
-  // CalypFrameStats* m_selectionHistogram;
-  CalypFrame* m_selectionImage;
+  std::shared_ptr<CalypFrame> m_selectionImage;
 
 Q_SIGNALS:
   void signalintervalChanged( int min, int max );

cmake/FindFFmpeg.cmake

@@ -1,147 +1,139 @@
-# - Try to find the required ffmpeg components(default: AVFORMAT, AVUTIL, AVCODEC)
+# * Try to find the required ffmpeg components(default: AVFORMAT, AVUTIL, AVCODEC)
 #
-# Once done this will define
-#  FFMPEG_FOUND         - System has the all required components.
-#  FFMPEG_INCLUDE_DIRS  - Include directory necessary for using the required components headers.
-#  FFMPEG_LIBRARIES     - Link these to use the required ffmpeg components.
-#  FFMPEG_DEFINITIONS   - Compiler switches required for using the required ffmpeg components.
+# Once done this will define FFMPEG_FOUND         - System has the all required components. FFMPEG_INCLUDE_DIRS  - Include directory necessary for
+# using the required components headers. FFMPEG_LIBRARIES     - Link these to use the required ffmpeg components. FFMPEG_DEFINITIONS   - Compiler
+# switches required for using the required ffmpeg components.
 #
-# For each of the components it will additionally set.
-#   - AVCODEC
-#   - AVDEVICE
-#   - AVFORMAT
-#   - AVUTIL
-#   - POSTPROCESS
-#   - SWSCALE
-# the following variables will be defined
-#  <component>_FOUND        - System has <component>
-#  <component>_INCLUDE_DIRS - Include directory necessary for using the <component> headers
-#  <component>_LIBRARIES    - Link these to use <component>
-#  <component>_DEFINITIONS  - Compiler switches required for using <component>
-#  <component>_VERSION      - The components version
+# For each of the components it will additionally set. - AVCODEC - AVDEVICE - AVFORMAT - AVUTIL - POSTPROCESS - SWSCALE the following variables will
+# be defined <component>_FOUND        - System has <component> <component>_INCLUDE_DIRS - Include directory necessary for using the <component>
+# headers <component>_LIBRARIES    - Link these to use <component> <component>_DEFINITIONS  - Compiler switches required for using <component>
+# <component>_VERSION      - The components version
 #
-# Copyright (c) 2006, Matthias Kretz, <kretz@kde.org>
-# Copyright (c) 2008, Alexander Neundorf, <neundorf@kde.org>
-# Copyright (c) 2011, Michael Jansen, <kde@michael-jansen.biz>
+# Copyright (c) 2006, Matthias Kretz, <kretz@kde.org> Copyright (c) 2008, Alexander Neundorf, <neundorf@kde.org> Copyright (c) 2011, Michael Jansen,
+# <kde@michael-jansen.biz>
 #
-# Redistribution and use is allowed according to the terms of the BSD license.
-# For details see the accompanying COPYING-CMAKE-SCRIPTS file.
+# Redistribution and use is allowed according to the terms of the BSD license. For details see the accompanying COPYING-CMAKE-SCRIPTS file.
 
-include(FindPackageHandleStandardArgs)
+INCLUDE(FindPackageHandleStandardArgs)
 
 # The default components were taken from a survey over other FindFFMPEG.cmake files
-if (NOT FFmpeg_FIND_COMPONENTS)
-  set(FFmpeg_FIND_COMPONENTS AVCODEC AVFORMAT AVUTIL)
-endif ()
+IF(NOT FFmpeg_FIND_COMPONENTS)
+  SET(FFmpeg_FIND_COMPONENTS AVCODEC AVFORMAT AVUTIL)
+ENDIF()
 
 #
-### Macro: set_component_found
+# Macro: set_component_found
 #
 # Marks the given component as found if both *_LIBRARIES AND *_INCLUDE_DIRS is present.
 #
-macro(set_component_found _component )
-  if (${_component}_LIBRARIES AND ${_component}_INCLUDE_DIRS)
+MACRO(set_component_found _component)
+  IF(${_component}_LIBRARIES AND ${_component}_INCLUDE_DIRS)
     # message(STATUS "  - ${_component} found.")
-    set(${_component}_FOUND TRUE)
-  else ()
+    SET(${_component}_FOUND TRUE)
+  ELSE()
     # message(STATUS "  - ${_component} not found.")
-  endif ()
-endmacro()
+  ENDIF()
+ENDMACRO()
 
 #
-### Macro: find_component
+# Macro: find_component
 #
-# Checks for the given component by invoking pkgconfig and then looking up the libraries and
-# include directories.
+# Checks for the given component by invoking pkgconfig and then looking up the libraries and include directories.
 #
-macro(find_component _component _pkgconfig _library _header)
+MACRO(find_component _component _pkgconfig _library _header)
 
-  if (NOT WIN32)
-     # use pkg-config to get the directories and then use these values
-     # in the FIND_PATH() and FIND_LIBRARY() calls
-     find_package(PkgConfig)
-     if (PKG_CONFIG_FOUND)
-       pkg_check_modules(PC_${_component} ${_pkgconfig})
-     endif ()
-  endif (NOT WIN32)
+  IF(NOT WIN32)
+    # use pkg-config to get the directories and then use these values in the FIND_PATH() and FIND_LIBRARY() calls
+    FIND_PACKAGE(PkgConfig)
+    IF(PKG_CONFIG_FOUND)
+      PKG_CHECK_MODULES(PC_${_component} ${_pkgconfig})
+    ENDIF()
+  ENDIF(NOT WIN32)
 
-  find_path(${_component}_INCLUDE_DIRS ${_header}
-    HINTS
-      ${PC_LIB${_component}_INCLUDEDIR}
-      ${PC_LIB${_component}_INCLUDE_DIRS}
-    PATH_SUFFIXES
-      ffmpeg
+  FIND_PATH(
+    ${_component}_INCLUDE_DIRS ${_header}
+    HINTS ${PC_LIB${_component}_INCLUDEDIR} ${PC_LIB${_component}_INCLUDE_DIRS}
+    PATH_SUFFIXES ffmpeg
   )
 
-  find_library(${_component}_LIBRARIES NAMES ${_library}
-      HINTS
-      ${PC_LIB${_component}_LIBDIR}
-      ${PC_LIB${_component}_LIBRARY_DIRS}
-  )
-
-  set(${_component}_DEFINITIONS  ${PC_${_component}_CFLAGS_OTHER} CACHE STRING "The ${_component} CFLAGS.")
-  set(${_component}_VERSION      ${PC_${_component}_VERSION}      CACHE STRING "The ${_component} version number.")
-
-  set_component_found(${_component})
-
-  mark_as_advanced(
-    ${_component}_INCLUDE_DIRS
+  FIND_LIBRARY(
     ${_component}_LIBRARIES
-    ${_component}_DEFINITIONS
-    ${_component}_VERSION)
+    NAMES ${_library}
+    HINTS ${PC_LIB${_component}_LIBDIR} ${PC_LIB${_component}_LIBRARY_DIRS}
+  )
 
-endmacro()
+  SET(${_component}_DEFINITIONS
+      ${PC_${_component}_CFLAGS_OTHER}
+      CACHE STRING "The ${_component} CFLAGS."
+  )
+  SET(${_component}_VERSION
+      ${PC_${_component}_VERSION}
+      CACHE STRING "The ${_component} version number."
+  )
 
+  SET_COMPONENT_FOUND(${_component})
+
+  MARK_AS_ADVANCED(${_component}_INCLUDE_DIRS ${_component}_LIBRARIES ${_component}_DEFINITIONS ${_component}_VERSION)
+
+ENDMACRO()
 
 # Check for cached results. If there are skip the costly part.
-if (NOT FFMPEG_LIBRARIES)
+IF(NOT FFMPEG_LIBRARIES)
 
   # Check for all possible component.
-  find_component(AVCODEC  libavcodec  avcodec  libavcodec/avcodec.h)
-  find_component(AVFORMAT libavformat avformat libavformat/avformat.h)
-  find_component(AVDEVICE libavdevice avdevice libavdevice/avdevice.h)
-  find_component(AVUTIL   libavutil   avutil   libavutil/avutil.h)
-  find_component(SWSCALE  libswscale  swscale  libswscale/swscale.h)
-  find_component(POSTPROC libpostproc postproc libpostproc/postprocess.h)
+  FIND_COMPONENT(AVCODEC libavcodec avcodec libavcodec/avcodec.h)
+  FIND_COMPONENT(AVFORMAT libavformat avformat libavformat/avformat.h)
+  FIND_COMPONENT(AVDEVICE libavdevice avdevice libavdevice/avdevice.h)
+  FIND_COMPONENT(AVUTIL libavutil avutil libavutil/avutil.h)
+  FIND_COMPONENT(SWSCALE libswscale swscale libswscale/swscale.h)
+  FIND_COMPONENT(SWRESAMPLE libswresample swresample libswresample/swresample.h)
+  FIND_COMPONENT(POSTPROC libpostproc postproc libpostproc/postprocess.h)
 
   # Check if the required components were found and add their stuff to the FFMPEG_* vars.
-  foreach (_component ${FFmpeg_FIND_COMPONENTS})
-    if (${_component}_FOUND)
+  FOREACH(_component ${FFmpeg_FIND_COMPONENTS})
+    IF(${_component}_FOUND)
       # message(STATUS "Required component ${_component} present.")
-      set(FFMPEG_LIBRARIES   ${FFMPEG_LIBRARIES}   ${${_component}_LIBRARIES})
-      set(FFMPEG_DEFINITIONS ${FFMPEG_DEFINITIONS} ${${_component}_DEFINITIONS})
-      list(APPEND FFMPEG_INCLUDE_DIRS ${${_component}_INCLUDE_DIRS})
-    else ()
+      SET(FFMPEG_LIBRARIES ${FFMPEG_LIBRARIES} ${${_component}_LIBRARIES})
+      SET(FFMPEG_DEFINITIONS ${FFMPEG_DEFINITIONS} ${${_component}_DEFINITIONS})
+      LIST(APPEND FFMPEG_INCLUDE_DIRS ${${_component}_INCLUDE_DIRS})
+    ELSE()
       # message(STATUS "Required component ${_component} missing.")
-    endif ()
-  endforeach ()
+    ENDIF()
+  ENDFOREACH()
 
   # Build the include path with duplicates removed.
-  if (FFMPEG_INCLUDE_DIRS)
-    list(REMOVE_DUPLICATES FFMPEG_INCLUDE_DIRS)
-  endif ()
+  IF(FFMPEG_INCLUDE_DIRS)
+    LIST(REMOVE_DUPLICATES FFMPEG_INCLUDE_DIRS)
+  ENDIF()
 
   # cache the vars.
-  set(FFMPEG_INCLUDE_DIRS ${FFMPEG_INCLUDE_DIRS} CACHE STRING "The FFmpeg include directories." FORCE)
-  set(FFMPEG_LIBRARIES    ${FFMPEG_LIBRARIES}    CACHE STRING "The FFmpeg libraries." FORCE)
-  set(FFMPEG_DEFINITIONS  ${FFMPEG_DEFINITIONS}  CACHE STRING "The FFmpeg cflags." FORCE)
+  SET(FFMPEG_INCLUDE_DIRS
+      ${FFMPEG_INCLUDE_DIRS}
+      CACHE STRING "The FFmpeg include directories." FORCE
+  )
+  SET(FFMPEG_LIBRARIES
+      ${FFMPEG_LIBRARIES}
+      CACHE STRING "The FFmpeg libraries." FORCE
+  )
+  SET(FFMPEG_DEFINITIONS
+      ${FFMPEG_DEFINITIONS}
+      CACHE STRING "The FFmpeg cflags." FORCE
+  )
 
-  mark_as_advanced(FFMPEG_INCLUDE_DIRS
-                   FFMPEG_LIBRARIES
-                   FFMPEG_DEFINITIONS)
+  MARK_AS_ADVANCED(FFMPEG_INCLUDE_DIRS FFMPEG_LIBRARIES FFMPEG_DEFINITIONS)
 
-endif ()
+ENDIF()
 
 # Now set the noncached _FOUND vars for the components.
-foreach (_component AVCODEC AVDEVICE AVFORMAT AVUTIL POSTPROCESS SWSCALE)
-  set_component_found(${_component})
-endforeach ()
+FOREACH(_component AVCODEC AVDEVICE AVFORMAT AVUTIL POSTPROCESS SWSCALE)
+  SET_COMPONENT_FOUND(${_component})
+ENDFOREACH()
 
 # Compile the list of required vars
-set(_FFmpeg_REQUIRED_VARS FFMPEG_LIBRARIES FFMPEG_INCLUDE_DIRS)
-foreach (_component ${FFmpeg_FIND_COMPONENTS})
-  list(APPEND _FFmpeg_REQUIRED_VARS ${_component}_LIBRARIES ${_component}_INCLUDE_DIRS)
-endforeach ()
+SET(_FFmpeg_REQUIRED_VARS FFMPEG_LIBRARIES FFMPEG_INCLUDE_DIRS)
+FOREACH(_component ${FFmpeg_FIND_COMPONENTS})
+  LIST(APPEND _FFmpeg_REQUIRED_VARS ${_component}_LIBRARIES ${_component}_INCLUDE_DIRS)
+ENDFOREACH()
 
 # Give a nice error message if some of the required vars are missing.
-find_package_handle_standard_args(FFmpeg DEFAULT_MSG ${_FFmpeg_REQUIRED_VARS})
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(FFmpeg DEFAULT_MSG ${_FFmpeg_REQUIRED_VARS})

cmake/ModulesFct.cmake

@@ -1,67 +1,68 @@
-
-MACRO(ADD_EXTRA_MODULES dir)
-  SET( MODULE_LOCATION  "${dir}/" )
-  ADD_SUBDIRECTORY( ${dir} ${CMAKE_CURRENT_BINARY_DIR}/extra-modules )
-  INCLUDE_DIRECTORIES( ${dir} )
-  SET( MODULE_LOCATION  "${dir}/" PARENT_SCOPE )
-ENDMACRO()
-
-MACRO(ADD_MODULE name file )
+# General function to add a module It receives the name of the module and the filename where it is defined. Used in modules/CMakeLists.txt
+MACRO(ADD_MODULE name file)
   SET(__modulename "Module${name}")
-  OPTION(MODULE_${name} "Use module ${name}" ON )
-  ADD_FEATURE_INFO(${name} MODULE_${name} "Module ${name}" )
-  IF( MODULE_${name} )
-    list(APPEND Calyp_Mod_SRCS ${MODULE_LOCATION}${file} )
-    LIST(APPEND MODULES_LIST_NAME ${name} )
-    LIST(APPEND MODULES_LIST_FILES ${file} )
-    SET( Calyp_Mod_SRCS "${Calyp_Mod_SRCS}" PARENT_SCOPE )
-    SET( MODULES_LIST_NAME "${MODULES_LIST_NAME}" PARENT_SCOPE )
-    SET( MODULES_LIST_FILES "${MODULES_LIST_FILES}" PARENT_SCOPE )
+  OPTION(MODULE_${name} "Use module ${name}" ON)
+  ADD_FEATURE_INFO(${name} MODULE_${name} "Module ${name}")
+  IF(MODULE_${name})
+    LIST(APPEND Calyp_Mod_SRCS ${MODULE_LOCATION}${file}.cpp)
+    LIST(APPEND MODULES_LIST_NAME ${name})
+    LIST(APPEND MODULES_LIST_FILES ${file})
+    SET(Calyp_Mod_SRCS
+        "${Calyp_Mod_SRCS}"
+        PARENT_SCOPE
+    )
+    SET(MODULES_LIST_NAME
+        "${MODULES_LIST_NAME}"
+        PARENT_SCOPE
+    )
+    SET(MODULES_LIST_FILES
+        "${MODULES_LIST_FILES}"
+        PARENT_SCOPE
+    )
   ENDIF()
   UNSET(__modulename)
 ENDMACRO()
 
-
-MACRO(ADD_MODULE_USE_OPENCV name file )
-  IF( USE_OPENCV )
-    SET( ADD_MODULE_USE_OPENCV_VERSION "2.4" )
-    CMAKE_PARSE_ARGUMENTS(ADD_MODULE_USE_OPENCV "" "VERSION" "MODULES" ${ARGN} )
-    IF( NOT ( ${OpenCV_VERSION} VERSION_LESS ${ADD_MODULE_USE_OPENCV_VERSION} ) )
-      SET( _HAS_MODULES TRUE )
-      FOREACH(opencv_module IN LISTS ADD_MODULE_USE_OPENCV_MODULES )
-        string(TOUPPER "${opencv_module}" opencv_moduleUP)
-        FIND_PACKAGE( OpenCV QUIET COMPONENTS ${opencv_module} )
-        IF( NOT ${OPENCV_${opencv_moduleUP}_FOUND} EQUAL "1" )
-          SET( _HAS_MODULES FALSE )
+# General function to add a module It receives the name of the module and the filename where it is defined. Moreover it receives a VERSION and MODULES
+# (OpenCV modules required) Used in modules/CMakeLists.txt
+MACRO(ADD_MODULE_USE_OPENCV name file)
+  IF(USE_OPENCV)
+    SET(ADD_MODULE_USE_OPENCV_VERSION "2.4")
+    CMAKE_PARSE_ARGUMENTS(ADD_MODULE_USE_OPENCV "" "VERSION" "MODULES" ${ARGN})
+    IF(NOT (${OpenCV_VERSION} VERSION_LESS ${ADD_MODULE_USE_OPENCV_VERSION}))
+      SET(_HAS_MODULES TRUE)
+      FOREACH(opencv_module IN LISTS ADD_MODULE_USE_OPENCV_MODULES)
+        STRING(TOUPPER "${opencv_module}" opencv_moduleUP)
+        FIND_PACKAGE(OpenCV QUIET COMPONENTS ${opencv_module})
+        IF(NOT ${OPENCV_${opencv_moduleUP}_FOUND} EQUAL "1")
+          SET(_HAS_MODULES FALSE)
         ELSE()
-          LIST(APPEND OPENCV_MODULES ${opencv_module} )
+          LIST(APPEND OPENCV_MODULES ${opencv_module})
         ENDIF()
       ENDFOREACH()
-      IF( _HAS_MODULES )
-        ADD_MODULE( ${name} ${file} )
+      IF(_HAS_MODULES)
+        ADD_MODULE(${name} ${file})
       ENDIF()
-      UNSET( OPENCV_${opencv_moduleUP}_FOUND )
-      UNSET( _HAS_MODULES )
+      UNSET(OPENCV_${opencv_moduleUP}_FOUND)
+      UNSET(_HAS_MODULES)
     ENDIF()
-    UNSET( ADD_MODULE_USE_OPENCV_VERSION )
+    UNSET(ADD_MODULE_USE_OPENCV_VERSION)
   ENDIF()
 ENDMACRO()
 
-
-#
 # Create header
-#
-MACRO(CREATE_MODULE_MACROS )
-  file( WRITE ${CMAKE_CURRENT_BINARY_DIR}/ModulesListHeader.h   "// This files add the header files of each module\n"
-                                                              "#ifndef __MODULESLISTHEADER_H__\n#define __MODULESLISTHEADER_H__\n" )
-  foreach(module ${MODULES_LIST_FILES})
-    file(APPEND ${CMAKE_CURRENT_BINARY_DIR}/ModulesListHeader.h   "#include \"${module}.h\"\n")
-  endforeach(module ${MODULES_LIST_FILES})
+MACRO(CREATE_MODULE_MACROS)
+  FILE(WRITE ${CMAKE_CURRENT_BINARY_DIR}/ModulesListHeader.h "// This files add the header files of each module\n"
+                                                             "#ifndef __MODULESLISTHEADER_H__\n#define __MODULESLISTHEADER_H__\n"
+  )
+  FOREACH(module ${MODULES_LIST_FILES})
+    FILE(APPEND ${CMAKE_CURRENT_BINARY_DIR}/ModulesListHeader.h "#include \"${module}.h\"\n")
+  ENDFOREACH(module ${MODULES_LIST_FILES})
 
-  file( APPEND ${CMAKE_CURRENT_BINARY_DIR}/ModulesListHeader.h   "#define REGISTER_ALL_MODULES \\\n" )
-  foreach(module ${MODULES_LIST_NAME})
-    file(APPEND ${CMAKE_CURRENT_BINARY_DIR}/ModulesListHeader.h   "Register( \"${module}\", &(${module}::Create) ); \\\n")
-  endforeach(module ${MODULES_LIST_NAME})
+  FILE(APPEND ${CMAKE_CURRENT_BINARY_DIR}/ModulesListHeader.h "#define REGISTER_ALL_MODULES \\\n")
+  FOREACH(module ${MODULES_LIST_NAME})
+    FILE(APPEND ${CMAKE_CURRENT_BINARY_DIR}/ModulesListHeader.h "Register( \"${module}\", &(${module}::Create) ); \\\n")
+  ENDFOREACH(module ${MODULES_LIST_NAME})
 
-  file( APPEND ${CMAKE_CURRENT_BINARY_DIR}/ModulesListHeader.h   "\n#endif // __MODULESLISTHEADER_H__\n" )
+  FILE(APPEND ${CMAKE_CURRENT_BINARY_DIR}/ModulesListHeader.h "\n#endif // __MODULESLISTHEADER_H__\n")
 ENDMACRO()

cmake/Win32.cmake

@@ -1,63 +1,81 @@
-#####################################################################################
+# ####################################################################################################################################################
 # DLLs and Win32 specific code
-######################################################################################
+# ####################################################################################################################################################
 
-foreach( OUTPUTCONFIG ${CMAKE_CONFIGURATION_TYPES} )
-    string( TOUPPER ${OUTPUTCONFIG} OUTPUTCONFIG )
-    set( CMAKE_RUNTIME_OUTPUT_DIRECTORY_${OUTPUTCONFIG} "." )
-    set( CMAKE_LIBRARY_OUTPUT_DIRECTORY_${OUTPUTCONFIG} "." )
-    set( CMAKE_ARCHIVE_OUTPUT_DIRECTORY_${OUTPUTCONFIG} "." )
-endforeach( OUTPUTCONFIG CMAKE_CONFIGURATION_TYPES )
+FOREACH(OUTPUTCONFIG ${CMAKE_CONFIGURATION_TYPES})
+  STRING(TOUPPER ${OUTPUTCONFIG} OUTPUTCONFIG)
+  SET(CMAKE_RUNTIME_OUTPUT_DIRECTORY_${OUTPUTCONFIG} ".")
+  SET(CMAKE_LIBRARY_OUTPUT_DIRECTORY_${OUTPUTCONFIG} ".")
+  SET(CMAKE_ARCHIVE_OUTPUT_DIRECTORY_${OUTPUTCONFIG} ".")
+ENDFOREACH(OUTPUTCONFIG CMAKE_CONFIGURATION_TYPES)
 
-SET(MSVC_DLL_DIR "MSVC_DLL_DIR" CACHE PATH "Where to find MSVC dlls")
-#INSTALL(FILES ${MSVC_DLL_DIR}/msvcr120.dll DESTINATION bin )
-#INSTALL(FILES ${MSVC_DLL_DIR}/msvcp120.dll DESTINATION bin )
+SET(MSVC_DLL_DIR
+    "MSVC_DLL_DIR"
+    CACHE PATH "Where to find MSVC dlls"
+)
+# INSTALL(FILES ${MSVC_DLL_DIR}/msvcr120.dll DESTINATION bin ) INSTALL(FILES ${MSVC_DLL_DIR}/msvcp120.dll DESTINATION bin )
 
-SET(QT_DIR "QT-Dir" CACHE PATH "Where to find QT Lib on Windows")
-SET(QT_ICU_VERSION "" CACHE STRING "Qt ICU version of dll's" )
-SET(QT_DLL_POSTFIX "" CACHE STRING "Postfix to dll's name for debug" )
-SET(CMAKE_PREFIX_PATH "${CMAKE_PREFIX_PATH} ${QT_DIR}" )
+SET(QT_DIR
+    "QT-Dir"
+    CACHE PATH "Where to find QT Lib on Windows"
+)
+SET(QT_ICU_VERSION
+    ""
+    CACHE STRING "Qt ICU version of dll's"
+)
+SET(QT_DLL_POSTFIX
+    ""
+    CACHE STRING "Postfix to dll's name for debug"
+)
+SET(CMAKE_PREFIX_PATH "${CMAKE_PREFIX_PATH} ${QT_DIR}")
 
-SET(WINDLLIB "Dl-location" CACHE PATH "Where to find DL Lib on Windows")
+SET(WINDLLIB
+    "Dl-location"
+    CACHE PATH "Where to find DL Lib on Windows"
+)
 
+IF(NOT USE_QT4)
+  INSTALL(FILES ${QT_DIR}/bin/Qt5Core${QT_DLL_POSTFIX}.dll DESTINATION bin)
+  INSTALL(FILES ${QT_DIR}/bin/Qt5Gui${QT_DLL_POSTFIX}.dll DESTINATION bin)
+  INSTALL(FILES ${QT_DIR}/bin/Qt5Widgets${QT_DLL_POSTFIX}.dll DESTINATION bin)
+  INSTALL(FILES ${QT_DIR}/bin/Qt5PrintSupport${QT_DLL_POSTFIX}.dll DESTINATION bin)
+  INSTALL(FILES ${QT_DIR}/plugins/platforms/qwindows${QT_DLL_POSTFIX}.dll DESTINATION bin/platforms)
+  INSTALL(FILES ${QT_DIR}/plugins/platforms/qminimal${QT_DLL_POSTFIX}.dll DESTINATION bin/platforms)
+  INSTALL(FILES ${QT_DIR}/plugins/platforms/qoffscreen${QT_DLL_POSTFIX}.dll DESTINATION bin/platforms)
 
-IF( NOT USE_QT4 )
-  INSTALL(FILES ${QT_DIR}/bin/Qt5Core${QT_DLL_POSTFIX}.dll DESTINATION bin )
-  INSTALL(FILES ${QT_DIR}/bin/Qt5Gui${QT_DLL_POSTFIX}.dll DESTINATION bin )
-  INSTALL(FILES ${QT_DIR}/bin/Qt5Widgets${QT_DLL_POSTFIX}.dll DESTINATION bin )
-  INSTALL(FILES ${QT_DIR}/bin/Qt5PrintSupport${QT_DLL_POSTFIX}.dll DESTINATION bin )
-  INSTALL(FILES ${QT_DIR}/plugins/platforms/qwindows${QT_DLL_POSTFIX}.dll DESTINATION bin/platforms )
-  INSTALL(FILES ${QT_DIR}/plugins/platforms/qminimal${QT_DLL_POSTFIX}.dll DESTINATION bin/platforms )
-  INSTALL(FILES ${QT_DIR}/plugins/platforms/qoffscreen${QT_DLL_POSTFIX}.dll DESTINATION bin/platforms )
-
-  IF( USE_FERVOR )
-    INSTALL(FILES ${QT_DIR}/bin/Qt5Network${QT_DLL_POSTFIX}.dll DESTINATION bin )
-    INSTALL(FILES ${QT_DIR}/bin/Qt5WebKit${QT_DLL_POSTFIX}.dll DESTINATION bin )
-    INSTALL(FILES ${QT_DIR}/bin/Qt5WebKitWidgets${QT_DLL_POSTFIX}.dll DESTINATION bin )
-    INSTALL(FILES ${QT_DIR}/bin/Qt5Quick${QT_DLL_POSTFIX}.dll DESTINATION bin )
-    INSTALL(FILES ${QT_DIR}/bin/Qt5Qml${QT_DLL_POSTFIX}.dll DESTINATION bin )
-    INSTALL(FILES ${QT_DIR}/bin/Qt5Multimedia${QT_DLL_POSTFIX}.dll DESTINATION bin )
-    INSTALL(FILES ${QT_DIR}/bin/Qt5Sql${QT_DLL_POSTFIX}.dll DESTINATION bin )
-    INSTALL(FILES ${QT_DIR}/bin/Qt5Positioning${QT_DLL_POSTFIX}.dll DESTINATION bin )
-    INSTALL(FILES ${QT_DIR}/bin/Qt5Sensors${QT_DLL_POSTFIX}.dll DESTINATION bin )
-    INSTALL(FILES ${QT_DIR}/bin/Qt5MultimediaWidgets${QT_DLL_POSTFIX}.dll DESTINATION bin )
-    INSTALL(FILES ${QT_DIR}/bin/Qt5OpenGL${QT_DLL_POSTFIX}.dll DESTINATION bin )
+  IF(USE_FERVOR)
+    INSTALL(FILES ${QT_DIR}/bin/Qt5Network${QT_DLL_POSTFIX}.dll DESTINATION bin)
+    INSTALL(FILES ${QT_DIR}/bin/Qt5WebKit${QT_DLL_POSTFIX}.dll DESTINATION bin)
+    INSTALL(FILES ${QT_DIR}/bin/Qt5WebKitWidgets${QT_DLL_POSTFIX}.dll DESTINATION bin)
+    INSTALL(FILES ${QT_DIR}/bin/Qt5Quick${QT_DLL_POSTFIX}.dll DESTINATION bin)
+    INSTALL(FILES ${QT_DIR}/bin/Qt5Qml${QT_DLL_POSTFIX}.dll DESTINATION bin)
+    INSTALL(FILES ${QT_DIR}/bin/Qt5Multimedia${QT_DLL_POSTFIX}.dll DESTINATION bin)
+    INSTALL(FILES ${QT_DIR}/bin/Qt5Sql${QT_DLL_POSTFIX}.dll DESTINATION bin)
+    INSTALL(FILES ${QT_DIR}/bin/Qt5Positioning${QT_DLL_POSTFIX}.dll DESTINATION bin)
+    INSTALL(FILES ${QT_DIR}/bin/Qt5Sensors${QT_DLL_POSTFIX}.dll DESTINATION bin)
+    INSTALL(FILES ${QT_DIR}/bin/Qt5MultimediaWidgets${QT_DLL_POSTFIX}.dll DESTINATION bin)
+    INSTALL(FILES ${QT_DIR}/bin/Qt5OpenGL${QT_DLL_POSTFIX}.dll DESTINATION bin)
   ENDIF()
 ENDIF()
 
-IF( USE_OPENCV )
-  SET(OpenCV_DLL_DIR "${OpenCV_DIR}/bin" CACHE PATH "Where to find OpenCV dlls")
-  SET(OpenCV_INSTALL_MODULES ${OPENCV_MODULES} CACHE STRING "List of OpenCV modules")
-  FOREACH(opencv_module IN LISTS OpenCV_INSTALL_MODULES )
-    INSTALL(FILES ${OpenCV_DLL_DIR}/opencv_${opencv_module}${OpenCV_VERSION_MAJOR}${OpenCV_VERSION_MINOR}${OpenCV_VERSION_PATCH}.dll DESTINATION bin )
+IF(USE_OPENCV)
+  SET(OpenCV_DLL_DIR
+      "${OpenCV_DIR}/bin"
+      CACHE PATH "Where to find OpenCV dlls"
+  )
+  SET(OpenCV_INSTALL_MODULES
+      ${OPENCV_MODULES}
+      CACHE STRING "List of OpenCV modules"
+  )
+  FOREACH(opencv_module IN LISTS OpenCV_INSTALL_MODULES)
+    INSTALL(FILES ${OpenCV_DLL_DIR}/opencv_${opencv_module}${OpenCV_VERSION_MAJOR}${OpenCV_VERSION_MINOR}${OpenCV_VERSION_PATCH}.dll DESTINATION bin)
   ENDFOREACH()
 ENDIF()
 
-IF( USE_FFMPEG )
-  SET(FFMPEG_DIR "FFmpeg-Dir" CACHE PATH "Where to find FFmpeg Lib on Windows")
-  INSTALL(FILES ${FFMPEG_DIR}/bin/avcodec-${AVCODEC_VERSION}.dll DESTINATION bin )
-  INSTALL(FILES ${FFMPEG_DIR}/bin/avformat-${AVFORMAT_VERSION}.dll DESTINATION bin )
-  INSTALL(FILES ${FFMPEG_DIR}/bin/avutil-${AVUTIL_VERSION}.dll DESTINATION bin )
-  INSTALL(FILES ${FFMPEG_DIR}/bin/swscale-${SWSCALE_VERSION}.dll DESTINATION bin )
-  INSTALL(FILES ${FFMPEG_DIR}/bin/swresample-${SWRESAMPLE_VERSION}.dll DESTINATION bin )
+IF(USE_FFMPEG)
+  SET(FFMPEG_DIR
+      "FFmpeg-Dir"
+      CACHE PATH "Where to find FFmpeg Lib on Windows"
+  )
+  INSTALL(DIRECTORY ${FFMPEG_DIR}/bin/ DESTINATION bin)
 ENDIF()

config.h.in

@@ -1,5 +1,5 @@
 /*    This file is a part of Calyp project
- *    Copyright (C) 2014-2019  by Joao Carreira   (jfmcarreira@gmail.com)
+ *    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
@@ -26,10 +26,10 @@
 #define __CONFIG_CALYP_H__
 
 /* Version definition */
-#define CALYP_VERSION_MAJOR @CALYP_VERSION_MAJOR@
-#define CALYP_VERSION_MINOR @CALYP_VERSION_MINOR@
-#define CALYP_VERSION_PATCH @CALYP_VERSION_PATCH@
-#define CALYP_VERSION @CALYP_VERSION@
+#define CALYP_VERSION_MAJOR @CALYP_VERSION_MAJOR @
+#define CALYP_VERSION_MINOR @CALYP_VERSION_MINOR @
+#define CALYP_VERSION_PATCH @CALYP_VERSION_PATCH @
+#define CALYP_VERSION @CALYP_VERSION @
 #define CALYP_VERSION_STRING "@CALYP_VERSION_STRING@"
 
 #define UPDATE_CHANNEL "@UPDATE_CHANNEL@"
@@ -55,4 +55,7 @@
 /* Fervor update lib */
 #cmakedefine USE_FERVOR
 
+/* Use a resource manager to manage streams in different threads */
+#cmakedefine CALYP_MANAGED_RESOURCES
+
 #endif  // __CONFIG_CALYP_H__

examples/CMakeLists.txt

@@ -1,7 +1,6 @@
-###
-### CMakeLists for examples
-###
-
-
-ADD_SUBDIRECTORY( modules )
+#
+# CMakeLists for examples
+#
 
+ADD_SUBDIRECTORY(modules)
+ADD_SUBDIRECTORY(stream)

examples/modules/AbsoluteFrameDifferenceExample.cpp

@@ -1,5 +1,5 @@
 /*    This file is a part of Calyp project
- *    Copyright (C) 2014-2019  by Joao Carreira   (jfmcarreira@gmail.com)
+ *    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
@@ -23,6 +23,7 @@
  */
 
 #include "AbsoluteFrameDifferenceExample.h"
+
 #include <cstdlib>
 
 REGISTER_CLASS_MAKER( AbsoluteFrameDifferenceExample )
@@ -32,15 +33,15 @@ AbsoluteFrameDifferenceExample::AbsoluteFrameDifferenceExample()
   /* Module Definition */
   m_iModuleAPI = CLP_MODULE_API_2;                         // Use API version 2 (recommended).
                                                            // See this example for details on the functions prototype
-  m_iModuleType = CLP_FRAME_PROCESSING_MODULE;             // Apply module to the frames or to the whole sequence.
+  m_iModuleType = ClpModuleType::FrameProcessing;          // Apply module to the frames or to the whole sequence.
   m_pchModuleCategory = "Measurements";                    // Category (sub-menu)
   m_pchModuleName = "AbsoluteDifferenceExample";           // Name
   m_pchModuleLongName = "Absolute Difference Example";     // Name
   m_pchModuleTooltip = "Measure the absolute difference "  // Description
                        "between two images (Y plane), e. g., abs( Y1 - Y2 )";
-  m_uiNumberOfFrames = 2;                                   // Number of Frames required (ONE_FRAME, TWO_FRAMES, THREE_FRAMES)
-  m_uiModuleRequirements = CLP_MODULE_REQUIRES_NEW_WINDOW;  // Module requirements (check CalypModulesIf.h).
-                                                            // Several requirements should be "or" between each others.
+  m_uiNumberOfFrames = 2;                                // Number of Frames required (ONE_FRAME, TWO_FRAMES, THREE_FRAMES)
+  m_uiModuleRequirements = ClpModuleFeature::NewWindow;  // Module requirements (check CalypModulesIf.h).
+                                                         // Several requirements should be "or" between each others.
   m_pcFrameDifference = NULL;
 }
 
@@ -55,7 +56,7 @@ bool AbsoluteFrameDifferenceExample::create( std::vector<CalypFrame*> apcFrameLi
       return false;
 
   m_pcFrameDifference =
-      new CalypFrame( apcFrameList[0]->getWidth(), apcFrameList[0]->getHeight(), CLP_GRAY );
+      new CalypFrame( apcFrameList[0]->getWidth(), apcFrameList[0]->getHeight(), ClpPixelFormats::Gray );
   return true;
 }
 

examples/modules/AbsoluteFrameDifferenceExample.h

@@ -1,5 +1,5 @@
 /*    This file is a part of Calyp project
- *    Copyright (C) 2014-2019  by Joao Carreira   (jfmcarreira@gmail.com)
+ *    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
@@ -25,10 +25,10 @@
 #ifndef __ABSOLUTEFRAMEDIFFERENCEEXAMPLE_H__
 #define __ABSOLUTEFRAMEDIFFERENCEEXAMPLE_H__
 
-#include "CalypModuleIf.h"
-
 #include <cassert>
 
+#include "CalypModuleIf.h"
+
 class AbsoluteFrameDifferenceExample : public CalypModuleIf
 {
   REGISTER_CLASS_FACTORY( AbsoluteFrameDifferenceExample )

examples/modules/CMakeLists.txt

@@ -1,21 +1,16 @@
-###
-### CMakeLists for modules_example
-###
+#
+# CMakeLists for modules_example
+#
 
+CMAKE_MINIMUM_REQUIRED(VERSION 3.5.0)
 
-CMAKE_MINIMUM_REQUIRED( VERSION 2.8.9 )
+PROJECT("modules_example")
 
-PROJECT( "modules_example" )
+# THIS FIND_PACKAGE( Calyp ) INCLUDE_DIRECTORIES( ${CALYP_INCLUDE_DIRS} ) OR
+INCLUDE_DIRECTORIES(../../lib)
 
-# THIS
-# FIND_PACKAGE( Calyp )
-#INCLUDE_DIRECTORIES( ${CALYP_INCLUDE_DIRS} )
-# OR
-INCLUDE_DIRECTORIES( ../../lib )
-
-ADD_LIBRARY(FrameBinarization SHARED FrameBinarization_APIv1.cpp)
-TARGET_LINK_LIBRARIES( FrameBinarization ${CALYP_LINKER_LIBS}  )
+ADD_LIBRARY(FrameBinarizationAPIv1 SHARED FrameBinarizationAPIv1.cpp)
+TARGET_LINK_LIBRARIES(FrameBinarizationAPIv1 ${PROJECT_LIBRARY})
 
 ADD_LIBRARY(AbsoluteFrameDifferenceExample SHARED AbsoluteFrameDifferenceExample.cpp)
-TARGET_LINK_LIBRARIES( AbsoluteFrameDifferenceExample ${PROJECT_LIBRARY} ${CALYP_LINKER_LIBS}  )
-
+TARGET_LINK_LIBRARIES(AbsoluteFrameDifferenceExample ${PROJECT_LIBRARY})

examples/modules/FrameBinarizationAPIv1.cpp

@@ -1,5 +1,5 @@
 /*    This file is a part of Calyp project
- *    Copyright (C) 2014-2019  by Joao Carreira   (jfmcarreira@gmail.com)
+ *    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
@@ -18,24 +18,24 @@
  */
 
 /**
- * \file     FrameBinarization_APIv1.cpp
+ * \file     FrameBinarizationAPIv1.cpp
  * \brief    Binarize frame module (example of APIv1)
  */
 
-#include "FrameBinarization_APIv1.h"
+#include "FrameBinarizationAPIv1.h"
 
-REGISTER_CLASS_MAKER( FrameBinarization_APIv1 )
+REGISTER_CLASS_MAKER( FrameBinarizationAPIv1 )
 
-FrameBinarization_APIv1::FrameBinarization_APIv1()
+FrameBinarizationAPIv1::FrameBinarizationAPIv1()
 {
   /* Module Definition */
-  m_iModuleType = CLP_FRAME_PROCESSING_MODULE;
+  m_iModuleType = ClpModuleType::FrameProcessing;
   m_pchModuleCategory = "Utilities";
-  m_pchModuleName = "FrameBinarization_APIv1";
+  m_pchModuleName = "FrameBinarizationAPIv1";
   m_pchModuleLongName = "Frame Binarization API v1";
   m_pchModuleTooltip = "Binarize frame";
   m_uiNumberOfFrames = 1;
-  m_uiModuleRequirements = CLP_MODULE_REQUIRES_OPTIONS;
+  m_uiModuleRequirements = ClpModuleFeature::Options;
 
   m_cModuleOptions.addOptions() /**/
       ( "threshold", m_uiThreshold, "Threshold level for binarization (0-255) [128]" );
@@ -44,13 +44,13 @@ FrameBinarization_APIv1::FrameBinarization_APIv1()
   m_uiThreshold = 128;
 }
 
-void FrameBinarization_APIv1::create( CalypFrame* frame )
+void FrameBinarizationAPIv1::create( CalypFrame* frame )
 {
   m_pcBinFrame = NULL;
-  m_pcBinFrame = new CalypFrame( frame->getWidth(), frame->getHeight(), CLP_GRAY, 8 );
+  m_pcBinFrame = new CalypFrame( frame->getWidth(), frame->getHeight(), ClpPixelFormats::Gray, 8 );
 }
 
-CalypFrame* FrameBinarization_APIv1::process( CalypFrame* frame )
+CalypFrame* FrameBinarizationAPIv1::process( CalypFrame* frame )
 {
   const ClpPel* pPelInput = frame->getPelBufferYUV()[0][0];
   ClpPel* pPelBin = m_pcBinFrame->getPelBufferYUV()[0][0];
@@ -62,7 +62,7 @@ CalypFrame* FrameBinarization_APIv1::process( CalypFrame* frame )
   return m_pcBinFrame;
 }
 
-void FrameBinarization_APIv1::destroy()
+void FrameBinarizationAPIv1::destroy()
 {
   if( m_pcBinFrame )
     delete m_pcBinFrame;

examples/modules/FrameBinarizationAPIv1.h

@@ -1,5 +1,5 @@
 /*    This file is a part of Calyp project
- *    Copyright (C) 2014-2019  by Joao Carreira   (jfmcarreira@gmail.com)
+ *    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
@@ -18,29 +18,29 @@
  */
 
 /**
- * \file     FrameBinarization_APIv1.h
+ * \file     FrameBinarizationAPIv1.h
  * \brief    Binarize frame module (example of APIv1)
  */
 
-#ifndef __FRAMEBINARIZATION_APIV1_H__
-#define __FRAMEBINARIZATION_APIV1_H__
+#ifndef __FRAMEBINARIZATIONAPIV1_H__
+#define __FRAMEBINARIZATIONAPIV1_H__
 
 #include "CalypModuleIf.h"
 
-class FrameBinarization_APIv1 : public CalypModuleIf
+class FrameBinarizationAPIv1 : public CalypModuleIf
 {
-  REGISTER_CLASS_FACTORY( FrameBinarization_APIv1 )
+  REGISTER_CLASS_FACTORY( FrameBinarizationAPIv1 )
 
 private:
   CalypFrame* m_pcBinFrame;
   unsigned int m_uiThreshold;
 
 public:
-  FrameBinarization_APIv1();
-  virtual ~FrameBinarization_APIv1() {}
+  FrameBinarizationAPIv1();
+  virtual ~FrameBinarizationAPIv1() {}
   void create( CalypFrame* );
   CalypFrame* process( CalypFrame* );
   void destroy();
 };
 
-#endif  // __FRAMEBINARIZATION_APIV1_H__
+#endif  // __FRAMEBINARIZATIONAPIV1_H__

examples/stream/CMakeLists.txt

@@ -0,0 +1,9 @@
+#
+# CMakeLists for modules_example
+#
+INCLUDE_DIRECTORIES(../../lib)
+
+ADD_DEFINITIONS(-DCALYP_TEST_DATA_DIR=\"${CALYP_TEST_DATA_DIR}\")
+
+ADD_EXECUTABLE(testStreamReading testStreamReading.cpp)
+TARGET_LINK_LIBRARIES(testStreamReading ${PROJECT_LIBRARY})

examples/stream/testStreamReading.cpp

@@ -0,0 +1,68 @@
+/*    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     testStreamReading.cpp
+ * \brief    Example of open and reading from a stream
+ */
+
+#include <chrono>
+#include <iostream>
+
+#include "CalypFrame.h"
+#include "CalypStream.h"
+
+int main( int argc, char* argv[] )
+{
+  // Use auto keyword to avoid typing long
+  // type definitions to get the timepoint
+  // at this instant use function now()
+  auto start = std::chrono::high_resolution_clock::now();
+
+  double n = 0;
+  CalypStream stream;
+  stream.open( std::string( CALYP_TEST_DATA_DIR ) + std::string( "/Foreman.yuv" ), 352, 288, 0, 8, CLP_BIG_ENDIAN, 1, true );
+
+  while( 1 )
+  {
+    CalypFrame* frame = stream.getCurrFrame();
+    frame->fillRGBBuffer();
+    n++;
+    if( stream.setNextFrame() )
+      break;
+    stream.readNextFrame();
+  }
+
+  // After function call
+  auto stop = std::chrono::high_resolution_clock::now();
+
+  // Subtract stop and start timepoints and
+  // cast it to required unit. Predefined units
+  // are nanoseconds, microseconds, milliseconds,
+  // seconds, minutes, hours. Use duration_cast()
+  // function.
+  auto duration = std::chrono::duration_cast<std::chrono::microseconds>( stop - start );
+
+  // To get the value of duration use the count()
+  // member function on the duration object
+  std::cout << duration.count() / 1000.0 / n << std::endl;
+
+  return 0;
+}

lib/CMakeLists.txt

@@ -1,22 +1,16 @@
-###
-### CMakeLists for calyp lib component
-###
+#
+# CMakeLists for calyp lib component
+#
 
 INCLUDE(GNUInstallDirs)
+SET(CMAKE_EXPORT_PACKAGE_REGISTRY ON)
+EXPORT(PACKAGE MyLib)
 
-INCLUDE_DIRECTORIES( ${CMAKE_CURRENT_SOURCE_DIR} )
+INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/..)
 
-set(Calyp_Lib_SRCS
-    LibMemory.h
-    CalypLib.h
-    CalypDefs.h
-    # Frame
-    CalypFrame.h
-    CalypFrame.cpp
-    CalypPixel.cpp
-    PixelFormats.h
-    PixelFormats.cpp
-    # Stream
+SET(Calyp_Lib_Frame_SRCS CalypPixel.cpp PixelFormats.h PixelFormats.cpp CalypFrame.h CalypFrame.cpp)
+
+SET(Calyp_Lib_Stream_SRCS
     CalypStream.h
     CalypStream.cpp
     CalypStreamHandlerIf.h
@@ -24,78 +18,91 @@ set(Calyp_Lib_SRCS
     StreamHandlerRaw.cpp
     StreamHandlerPortableMap.h
     StreamHandlerPortableMap.cpp
-    # Options Parser
-    CalypOptions.h
-    CalypOptions.cpp
-    # Modules
-    CalypModuleIf.h
 )
 
-LIST(APPEND CMAKE_CFG_LINKER_LIBSS ${PROJECT_LIBRARY} )
-LIST(APPEND CMAKE_CFG_INCLUDE_DIRS ${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_INCLUDEDIR} )
+SET(Calyp_Lib_OptionParser_SRCS CalypOptions.h CalypOptions.cpp)
 
+SET(Calyp_Lib_Modules_SRCS CalypOptions.h CalypOptions.cpp)
 
-IF( USE_FFMPEG )
-  LIST( APPEND Calyp_Lib_SRCS StreamHandlerLibav.h )
-  LIST( APPEND Calyp_Lib_SRCS StreamHandlerLibav.cpp )
+SET(Calyp_Lib_SRCS CalypLib.h CalypDefs.h ${Calyp_Lib_Frame_SRCS} ${Calyp_Lib_Stream_SRCS} ${Calyp_Lib_OptionParser_SRCS} ${Calyp_Lib_Modules_SRCS})
 
-  LIST(APPEND CMAKE_CFG_LINKER_LIBSS ${FFMPEG_LIBRARIES} )
-  LIST(APPEND CMAKE_CFG_INCLUDE_DIRS ${FFMPEG_INCLUDE_DIRS} )
+LIST(APPEND CMAKE_CFG_INCLUDE_DIRS ${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_INCLUDEDIR})
+
+IF(USE_FFMPEG)
+  LIST(APPEND Calyp_Lib_SRCS StreamHandlerLibav.h)
+  LIST(APPEND Calyp_Lib_SRCS StreamHandlerLibav.cpp)
+
+  LIST(APPEND CMAKE_CFG_LINKER_LIBSS ${FFMPEG_LIBRARIES})
+  LIST(APPEND CMAKE_CFG_INCLUDE_DIRS ${FFMPEG_INCLUDE_DIRS})
+
+  INCLUDE_DIRECTORIES(${FFMPEG_INCLUDE_DIRS})
+
+  LIST(APPEND CALYP_LIB_LINKER_DEPENDENCIES ${FFMPEG_LIBRARIES})
 ENDIF()
 
-IF( USE_OPENCV )
-  LIST( APPEND Calyp_Lib_SRCS StreamHandlerOpenCV.h )
-  LIST( APPEND Calyp_Lib_SRCS StreamHandlerOpenCV.cpp )
+IF(USE_OPENCV)
+  LIST(APPEND Calyp_Lib_SRCS StreamHandlerOpenCV.h)
+  LIST(APPEND Calyp_Lib_SRCS StreamHandlerOpenCV.cpp)
 
-  LIST(APPEND CMAKE_CFG_LINKER_LIBSS ${OpenCV_LIBRARIES} )
-  LIST(APPEND CMAKE_CFG_INCLUDE_DIRS ${OpenCV_INCLUDE_DIRS} )
+  LIST(APPEND Calyp_Lib_SRCS CalypOpenCVModuleIf.cpp)
+
+  LIST(APPEND CMAKE_CFG_LINKER_LIBSS ${OpenCV_LIBRARIES})
+  LIST(APPEND CMAKE_CFG_INCLUDE_DIRS ${OpenCV_INCLUDE_DIRS})
+
+  LIST(APPEND CMAKE_CFG_LINKER_LIBSS ${PROJECT_LIBRARY})
+  LIST(APPEND CMAKE_CFG_INCLUDE_DIRS ${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_INCLUDEDIR})
+
+  INCLUDE_DIRECTORIES(${OpenCV_INCLUDE_DIRS})
+
+  LIST(APPEND CALYP_LIB_LINKER_DEPENDENCIES ${OpenCV_LIBRARIES})
 ENDIF()
 
-set(Calyp_Lib_HEADERS
-    CalypDefs.h
-    CalypFrame.h
-    CalypStream.h
-    CalypOptions.h
-    CalypModuleIf.h
+SET(Calyp_Lib_HEADERS CalypFrame.h CalypStream.h CalypOptions.h CalypModuleIf.h)
+
+INCLUDE(CMakePackageConfigHelpers)
+
+CONFIGURE_PACKAGE_CONFIG_FILE(CalypConfig.cmake.in CalypConfig.cmake INSTALL_DESTINATION share/calyp)
+
+WRITE_BASIC_PACKAGE_VERSION_FILE(
+  CalypConfigVersion.cmake
+  VERSION ${CALYP_VERSION}
+  COMPATIBILITY SameMajorVersion
 )
 
-CONFIGURE_FILE( CalypConfig.cmake.in CalypConfig.cmake @ONLY)
+# CONFIGURE_FILE(CalypConfig.cmake.in CalypConfig.cmake @ONLY)
 
-INCLUDE_DIRECTORIES( ${FFMPEG_INCLUDE_DIRS} ${OpenCV_INCLUDE_DIRS} )
-
-IF( USE_STATIC )
-  ADD_LIBRARY( ${PROJECT_LIBRARY} STATIC ${Calyp_Lib_SRCS} )
+IF(USE_STATIC)
+  ADD_LIBRARY(${PROJECT_LIBRARY} STATIC ${Calyp_Lib_SRCS})
 ELSE()
-  ADD_LIBRARY( ${PROJECT_LIBRARY} SHARED ${Calyp_Lib_SRCS} )
+  ADD_LIBRARY(${PROJECT_LIBRARY} SHARED ${Calyp_Lib_SRCS})
 ENDIF()
 
+TARGET_LINK_LIBRARIES(${PROJECT_LIBRARY} ${CALYP_LIB_LINKER_DEPENDENCIES})
+# TARGET_INCLUDE_DIRECTORIES(${PROJECT_LIBRARY} PUBLIC $<INSTALL_INTERFACE:include> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/..>)
+SET_TARGET_PROPERTIES(${PROJECT_LIBRARY} PROPERTIES VERSION ${CALYP_VERSION} SOVERSION ${CALYP_VERSION_MAJOR})
 
-TARGET_LINK_LIBRARIES( ${PROJECT_LIBRARY}
-    ${FFMPEG_LIBRARIES}
-    ${OpenCV_LIBRARIES}
-)
+IF(USE_IWYU)
+  SET_PROPERTY(TARGET ${PROJECT_LIBRARY} PROPERTY CXX_INCLUDE_WHAT_YOU_USE ${iwyu_path})
+ENDIF()
 
-TARGET_INCLUDE_DIRECTORIES(${PROJECT_LIBRARY}
-    PUBLIC
-        $<INSTALL_INTERFACE:include>
-        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/..>
-)
+EXPORT(TARGETS ${PROJECT_LIBRARY} FILE ${CMAKE_CURRENT_BINARY_DIR}/CalypTargets.cmake)
+EXPORT(PACKAGE ${PROJECT_LIBRARY})
 
-SET_TARGET_PROPERTIES( ${PROJECT_LIBRARY}
-   PROPERTIES VERSION ${CALYP_VERSION}
-   SOVERSION ${CALYP_VERSION_MAJOR}
-)
-
-IF( NOT USE_STATIC )
-  INSTALL( TARGETS ${PROJECT_LIBRARY}
+IF(NOT USE_STATIC)
+  INSTALL(
+    TARGETS ${PROJECT_LIBRARY}
+    EXPORT "${PROJECT_LIBRARY}Targets"
     RUNTIME DESTINATION bin
     LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}"
     ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}"
   )
-  INSTALL(FILES ${Calyp_Lib_HEADERS} DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}" )
-  INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/CalypConfig.cmake DESTINATION share/calyp )
+  INSTALL(FILES ${Calyp_Lib_HEADERS} DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}")
+  INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/CalypConfig.cmake ${CMAKE_CURRENT_BINARY_DIR}/CalypConfigVersion.cmake DESTINATION share/calyp)
+  INSTALL(EXPORT CalypTargets DESTINATION share/calyp)
+
 ENDIF()
 
-IF( BUILD_TESTS )
-  ADD_SUBDIRECTORY( tests )
+IF(BUILD_TESTS)
+  ADD_SUBDIRECTORY(tests)
+  ADD_SUBDIRECTORY(catch2)
 ENDIF()

lib/CalypConfig.cmake.in

@@ -12,7 +12,7 @@
 #
 #
 #    This file will define the following variables:
-#      - CALYP_LINKER_LIBS              : The list of all imported targets for OpenCV modules.
+#      - CALYP_LIBRARIES              : The list of all imported targets for OpenCV modules.
 #      - CALYP_CXX_FLAGS
 #      - CALYP_INCLUDE_DIRS             : The Calyp include directories.
 #      - CALYP_VERSION                  : The version of this Calyp build: "@CALYP_VERSION@"
@@ -22,15 +22,18 @@
 #
 # ===================================================================================================================
 
+@PACKAGE_INIT@
 
-# ======================================================
-#  Variables:
-# ======================================================
 SET(CALYP_VERSION @CALYP_VERSION@)
 SET(CALYP_VERSION_MAJOR  @CALYP_VERSION_MAJOR@)
 SET(CALYP_VERSION_MINOR  @CALYP_VERSION_MINOR@)
 SET(CALYP_VERSION_PATCH  @CALYP_VERSION_PATCH@)
 
+FIND_LIBRARY(CALYP_LIBRARY NAMES Calyp HINTS @CMAKE_INSTALL_PREFIX@/@CMAKE_INSTALL_LIBDIR@ )
+
 SET( CALYP_CXX_FLAGS "" )
-SET( CALYP_INCLUDE_DIRS "@CMAKE_CFG_INCLUDE_DIRS@" )
-SET( CALYP_LINKER_LIBS "@CMAKE_CFG_LINKER_LIBSS@" )
+SET( CALYP_LIBRARIES "${CALYP_LIBRARY}" )
+LIST( APPEND CALYP_LIBRARIES "@CALYP_LIB_LINKER_DEPENDENCIES@")
+set_and_check( CALYP_INCLUDE_DIRS "@CMAKE_CFG_INCLUDE_DIRS@" )
+
+CHECK_REQUIRED_COMPONENTS(Calyp)

lib/CalypDefs.h

@@ -1,5 +1,5 @@
 /*    This file is a part of Calyp project
- *    Copyright (C) 2014-2019  by Joao Carreira   (jfmcarreira@gmail.com)
+ *    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
@@ -27,15 +27,9 @@
 #define __CALYPDEFS_H__
 
 #include <algorithm>
-#include <string>
-#include <vector>
 #include <iterator>
-
-typedef unsigned short ClpPel;  ///< 16-bit pixel type
-typedef unsigned char ClpByte;
-typedef unsigned long long ClpULong;
-
-typedef std::string ClpString;
+#include <memory>
+#include <string>
 
 enum CLP_LOG_LEVEL
 {
@@ -45,94 +39,37 @@ enum CLP_LOG_LEVEL
   CLP_LOG_ERROR = 4,
 };
 
-/**
- * \enum CalypColorSpace
- * \brief List of supported color spaces
- * \ingroup CalypLibGrp
- */
-enum CalypColorSpace
-{
-  CLP_COLOR_INVALID = -1,  //!< Invalid
-  CLP_COLOR_YUV = 0,       //!< YUV
-  CLP_COLOR_RGB = 1,       //!< RGB
-  CLP_COLOR_GRAY = 2,      //!< Grayscale
-  CLP_COLOR_RGBA = 3,      //!< RGB + Alpha
-  CLP_COLOR_MAX = 255,     //!< Account for future formats
-};
-
-/**
- * \enum CalypPixelFormats
- * \brief List of supported pixel formats
- * \ingroup CalypLibGrp
- */
-enum CalypPixelFormats
-{
-  CLP_INVALID_FMT = -1,  //!< Invalid
-  CLP_YUV420P = 0,       //!< YUV 420 progressive
-  CLP_YUV422P,           //!< YUV 422 progressive
-  CLP_YUV444P,           //!< YUV 444 progressive
-  CLP_YUYV422,           //!< YUV 422 interleaved
-  CLP_GRAY,              //!< Grayscale
-  CLP_RGB24P,            //!< RGB 32 bpp progressive
-  CLP_RGB24,             //!< RGB 32 bpp
-  CLP_BGR24,             //!< BGR 32 bpp
-  CLP_RGBA32,            //!< RGBA 32 bpp
-  CLP_BGRA32,            //!< BGRA 32 bpp
-  CLP_MAX_FMT = 255,     //!< Account for future formats
-};
-
-enum CLP_YUV_Components
-{
-  CLP_LUMA = 0,
-  CLP_CHROMA_U,
-  CLP_CHROMA_V,
-};
-
-enum CLP_RGB_Components
-{
-  CLP_COLOR_R = 0,
-  CLP_COLOR_G,
-  CLP_COLOR_B,
-  CLP_COLOR_A,
-};
-
-enum CLP_Endianness
-{
-  CLP_BIG_ENDIAN = 0,
-  CLP_LITTLE_ENDIAN = 1,
-};
-
 static const double S_PI = 3.14159265358979323846;
 static const double S_PI_2 = 1.57079632679489661923;
 
-inline ClpString clpLowercase( const ClpString& in )
+inline std::string clpLowercase( const std::string& in )
 {
-  ClpString out;
-  transform( in.begin(), in.end(), std::back_inserter( out ), tolower );
+  std::string out;
+  std::transform( in.begin(), in.end(), std::back_inserter( out ), tolower );
   return out;
 }
 
-inline ClpString clpUppercase( const ClpString& in )
+inline std::string clpUppercase( const std::string& in )
 {
-  ClpString out;
-  transform( in.begin(), in.end(), std::back_inserter( out ), toupper );
+  std::string out;
+  std::transform( in.begin(), in.end(), std::back_inserter( out ), toupper );
   return out;
 }
 
 struct CalypFailure : public std::exception
 {
-  ClpString m_class_name;
-  ClpString m_error_msg;
-  CalypFailure( ClpString error_msg ) throw()
+  std::string m_class_name;
+  std::string m_error_msg;
+  CalypFailure( std::string error_msg ) throw()
       : m_error_msg( error_msg ) {}
-  CalypFailure( ClpString class_name, ClpString error_msg ) throw()
+  CalypFailure( std::string class_name, std::string error_msg ) throw()
       : m_class_name( class_name ), m_error_msg( error_msg )
   {
   }
   ~CalypFailure() throw() {}
   const char* what() const throw()
   {
-    ClpString* msg = new ClpString( "[" + m_class_name + "] " + m_error_msg );
+    std::string* msg = new std::string( "[" + m_class_name + "] " + m_error_msg );
     return msg->c_str();
   }
 };

lib/CalypFrame.h

@@ -1,5 +1,5 @@
 /*    This file is a part of Calyp project
- *    Copyright (C) 2014-2019  by Joao Carreira   (jfmcarreira@gmail.com)
+ *    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
@@ -26,13 +26,79 @@
 #ifndef __CALYPFRAME_H__
 #define __CALYPFRAME_H__
 
-#include "CalypDefs.h"
+#include <array>
+#include <map>
+#include <memory>
+#include <optional>
+#include <span>
+#include <string>
+#include <vector>
 
 namespace cv
 {
 class Mat;
 }
 
+using ClpPel = std::uint16_t;
+using ClpByte = std::uint8_t;
+
+/**
+ * \enum CalypColorSpace
+ * \brief List of supported color spaces
+ * \ingroup CalypLibGrp
+ */
+enum CalypColorSpace
+{
+  CLP_COLOR_INVALID = -1,  //!< Invalid
+  CLP_COLOR_YUV = 0,       //!< YUV
+  CLP_COLOR_RGB = 1,       //!< RGB
+  CLP_COLOR_GRAY = 2,      //!< Grayscale
+  CLP_COLOR_RGBA = 3,      //!< RGB + Alpha
+  CLP_COLOR_MAX = 255,     //!< Account for future formats
+};
+
+/**
+ * \enum ClpPixelFormats
+ * \brief List of supported pixel formats
+ * \ingroup CalypLibGrp
+ */
+enum class ClpPixelFormats : int
+{
+  Invalid = -1,  //!< Invalid
+  YUV420p = 0,   //!< YUV 420 progressive
+  YUV422p,       //!< YUV 422 progressive
+  YUV444p,       //!< YUV 444 progressive
+  YUYV422,       //!< YUV 422 interleaved
+  Gray,          //!< Grayscale
+  RGB24p,        //!< RGB 32 bpp progressive
+  RGB24,         //!< RGB 32 bpp
+  BGR24,         //!< BGR 32 bpp
+  RGBA32,        //!< RGBA 32 bpp
+  BGRA32,        //!< BGRA 32 bpp
+};
+
+enum CLP_YUV_Components
+{
+  CLP_LUMA = 0,
+  CLP_CHROMA_U,
+  CLP_CHROMA_V,
+};
+
+enum CLP_RGB_Components
+{
+  CLP_COLOR_R = 0,
+  CLP_COLOR_G,
+  CLP_COLOR_B,
+  CLP_COLOR_A,
+};
+
+enum CLP_Endianness
+{
+  CLP_INVALID_ENDIANESS = -1,
+  CLP_BIG_ENDIAN = 0,
+  CLP_LITTLE_ENDIAN = 1,
+};
+
 #define CHROMASHIFT( SIZE, SHIFT ) (unsigned int)( -( ( -( (int)( SIZE ) ) ) >> ( SHIFT ) ) )
 
 /**
@@ -42,38 +108,95 @@ class Mat;
  */
 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 constexpr 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 std::size_t channel ) const { return m_pelComp[channel]; }
+  ClpPel& operator[]( const std::size_t 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;
+
+  auto operator==( const CalypPixel& other ) const -> bool;
+
+  friend std::ostream& operator<<( std::ostream& os, const CalypPixel& p );
 
   /**
-	 * Convert a Pixel to a new color space
-	 * @param inputPixel input pixel (CalypPixel)
-	 * @param eOutputSpace output color space
-	 * @return converted pixel
-	 */
-  CalypPixel convertPixel( CalypColorSpace eOutputSpace );
+   * Convert a Pixel to a new color space
+   * @param inputPixel input pixel (CalypPixel)
+   * @param eOutputSpace output color space
+   * @return converted pixel
+   */
+  CalypPixel convertPixel( CalypColorSpace eOutputSpace ) const;
+};
+
+std::ostream& operator<<( std::ostream& os, const CalypPixel& p );
+
+/**
+ * \class    CalypPlane
+ * \ingroup	 CalypLibGrp CalypPlaneGrp
+ * \brief    Frame handling class
+ */
+template <typename T>
+class CalypPlane
+{
+public:
+  CalypPlane() noexcept = default;
+  CalypPlane( std::size_t width, std::size_t height ) noexcept { resize( width, height ); }
+
+  ~CalypPlane() noexcept = default;
+  CalypPlane( const CalypPlane& buffer ) noexcept = default;
+  CalypPlane( CalypPlane&& buffer ) noexcept = default;
+  auto operator=( const CalypPlane& buffer ) -> CalypPlane& = default;
+  auto operator=( CalypPlane&& buffer ) noexcept -> CalypPlane& = default;
+
+  auto operator[]( std::size_t row ) const& noexcept -> const std::span<T>& { return m_rows[row]; }
+  auto operator[]( std::size_t row ) & noexcept -> std::span<T>& { return m_rows[row]; }
+
+  auto operator[]( std::size_t row ) const&& noexcept { return m_rows[row]; }
+  auto operator[]( std::size_t row ) && noexcept { return m_rows[row]; }
+
+  auto data() noexcept { return std::span<T>( m_data ); }
+  auto data() const noexcept { return std::span<const T>( m_data ); }
+
+  void resize( std::size_t width, std::size_t height ) noexcept
+  {
+    m_data.resize( width * height );
+    m_rows.resize( height );
+    for( std::size_t y = 0; y < height; y++ )
+    {
+      m_rows[y] = std::span<T>( m_data ).subspan( y * width, width );
+    }
+  }
 
 private:
-  struct CalypPixelPrivate* d;
+  std::vector<T> m_data;
+  std::vector<std::span<T>> m_rows;
 };
 
 /**
@@ -85,60 +208,93 @@ class CalypFrame
 {
 public:
   /**
-	 * Function that handles the supported color space
-	 * of CalypFrame
-	 * @return vector of strings with pixel formats names
-	 */
-  static std::vector<ClpString> supportedColorSpacesListNames();
+   * Function that handles the supported color space
+   * of CalypFrame
+   * @return vector of strings with pixel formats names
+   */
+  static std::vector<std::string> supportedColorSpacesListNames();
 
   /**
-	 * Function that handles the supported pixel formats
-	 * of CalypFrame
-	 * @return vector of strings with pixel formats names
-	 */
-  static std::vector<ClpString> supportedPixelFormatListNames();
-  static std::vector<ClpString> supportedPixelFormatListNames( int colorSpace );
-  static int numberOfFormats();
-  static int findPixelFormat( const ClpString& name );
-  static int pelformatColorSpace( const int idx );
+   * Function that handles the supported pixel formats
+   * of CalypFrame
+   * @return vector of strings with pixel formats names
+   */
+  static constexpr auto numberOfFormats() -> std::size_t;
+  static auto findPixelFormat( const std::string& name ) -> std::optional<ClpPixelFormats>;
+  static auto findPixelFormat( const std::string_view name ) -> std::optional<ClpPixelFormats>;
+  static auto pelformatColorSpace( ClpPixelFormats idx ) -> int;
+  static auto supportedPixelFormatListNames() -> std::map<ClpPixelFormats, std::string_view>;
+  static auto supportedPixelFormatListNames( int colorSpace ) -> std::map<ClpPixelFormats, std::string_view>;
+  static auto pixelFormatName( ClpPixelFormats idx ) -> const std::string_view;
 
   /**
-	 * Creates a new frame using the following configuration
-	 *
-	 * @param width width of the frame
-	 * @param height height of the frame
-	 * @param pel_format pixel format index (always use PixelFormats enum)
-	 *
-	 * @note this function might misbehave if the pixel format enum is not correct
-	 */
-  CalypFrame( unsigned int width, unsigned int height, int pelFormat, unsigned bitsPixel = 8 );
+   * Creates a new frame using the following configuration
+   *
+   * @param width width of the frame
+   * @param height height of the frame
+   * @param pel_format pixel format index (always use PixelFormats enum)
+   *
+   * @note this function might misbehave if the pixel format enum is not correct
+   */
+  CalypFrame( unsigned int width, unsigned int height, ClpPixelFormats pelFormat, unsigned bitsPixel = 8 );
 
   /**
-	 * Copy contructor
-	 *
-	 * @param other existing frame to copy from
-	 */
+   * Creates a new frame using the following configuration
+   *
+   * @param width width of the frame
+   * @param height height of the frame
+   * @param pel_format pixel format index (always use PixelFormats enum)
+   *
+   * @note this function might misbehave if the pixel format enum is not correct
+   */
+  CalypFrame( unsigned int width, unsigned int height, ClpPixelFormats pelFormat, unsigned bitsPixel, bool has_negative_values );
+
+  /**
+   * Move contructor
+   *
+   * @param other existing frame to copy from
+   */
+  CalypFrame( CalypFrame&& other ) noexcept;
+
+  /**
+   * Move assignement contructor
+   *
+   * @param other existing frame to copy from
+   */
+  CalypFrame& operator=( CalypFrame&& other ) noexcept;
+
+  /**
+   * Copy contructor
+   *
+   * @param other existing frame to copy from
+   */
   CalypFrame( const CalypFrame& other );
-  CalypFrame( const CalypFrame* other );
 
   /**
-	 * Creates and new frame with the configuration of an existing one and copy
-	 * its contents. This function only copies a specific region from the existing
-	 * frame
-	 *
-	 * @param other existing frame to copy from
-	 * @param posX position X to crop from
-	 * @param posY position Y to crop from
-	 * @param areaWidth crop width
-	 * @param areaHeight crop height
-	 */
+   * Copy-assignement contructor
+   *
+   * @param other existing frame to copy from
+   */
+  CalypFrame& operator=( const CalypFrame& other );
+
+  /**
+   * Creates and new frame with the configuration of an existing one and copy
+   * its contents. This function only copies a specific region from the existing
+   * frame
+   *
+   * @param other existing frame to copy from
+   * @param posX position X to crop from
+   * @param posY position Y to crop from
+   * @param areaWidth crop width
+   * @param areaHeight crop height
+   */
   CalypFrame( const CalypFrame& other, unsigned int x, unsigned int y, unsigned int width, unsigned int height );
   CalypFrame( const CalypFrame* other, unsigned int x, unsigned int y, unsigned int width, unsigned int height );
 
   ~CalypFrame();
 
   /** Format match opts
-	 */
+   */
   enum FormatMatching
   {
     MATCH_COLOR_SPACE = 1,
@@ -151,189 +307,197 @@ public:
   };
 
   /**
-	 * Check if two CalypFrames have the same fmt
-	 * @param other frame to compare with
-	 * @param match matching conditions (use enum FormatMatching)
-	 * @return true if format matches
-	 */
+   * Check if two CalypFrames have the same fmt
+   * @param other frame to compare with
+   * @param match matching conditions (use enum FormatMatching)
+   * @return true if format matches
+   */
   bool haveSameFmt( const CalypFrame& other, unsigned int match = MATCH_ALL ) const;
   bool haveSameFmt( const CalypFrame* other, unsigned int match = MATCH_ALL ) const;
 
   /**
-	 * Get pixel format information
-	 * @return pixel format index
-	 */
-  int getPelFormat() const;
+   * Get pixel format information
+   * @return pixel format index
+   */
+  ClpPixelFormats getPelFormat() const;
 
   /**
-	 * Get pixel format information
-	 * @return pixel format name
-	 */
-  ClpString getPelFmtName();
+   * Get pixel format information
+   * @return pixel format name
+   */
+  auto getPelFmtName() const -> std::string;
 
   /**
-	 * Get color space information
-	 * @return get color space index
-	 */
+   * Get color space information
+   * @return get color space index
+   */
   int getColorSpace() const;
 
   /**
-	 * Get the number of channels
-	 * @return number of channels
-	 */
+   * Get the number of channels
+   * @return number of channels
+   */
   unsigned getNumberChannels() const;
 
   /**
-	 * Get width of the frame
-	 * @param channel/component
-	 * @return number of pixels
-	 */
+   * Get width of the frame
+   * @param channel/component
+   * @return number of pixels
+   */
   unsigned int getWidth( unsigned channel = 0 ) const;
 
   /**
-	 * Get height of the frame
-	 * @param channel/component
-	 * @return number of pixels
-	 */
+   * Get height of the frame
+   * @param channel/component
+   * @return number of pixels
+   */
   unsigned int getHeight( unsigned channel = 0 ) const;
 
   /**
-	 * Get number of pixels of the frame
-	 * @param channel/component
-	 * @return number of pixels
-	 */
-  ClpULong getPixels( unsigned channel = 0 ) const;
+   * Check if frame has negative values
+   * @return Boolean with the flag value
+   */
+  bool getHasNegativeValues() const;
+
+  /**
+   * Get number of pixels of the frame
+   * @param channel/component
+   * @return number of pixels
+   */
+  std::uint64_t getPixels( unsigned channel = 0 ) const;
 
   /**
    * Get the total number of pixels of the frame
    * @return number of pixels
    */
-  ClpULong getTotalNumberOfPixels() const;
+  std::uint64_t getTotalNumberOfPixels() const;
 
   /**
-	 * Get chroma width ratio
-	 * @return ratio multiple of 2
-	 */
+   * Get chroma width ratio
+   * @return ratio multiple of 2
+   */
   unsigned getChromaWidthRatio() const;
 
   /**
-	 * Get chroma height ratio
-	 * @return ratio multiple of 2
-	 */
+   * Get chroma height ratio
+   * @return ratio multiple of 2
+   */
   unsigned getChromaHeightRatio() const;
 
   /**
-	 * Get number of pixels in each chroma channel
-	 * @return number of pixels
-	 */
-  ClpULong getChromaLength() const;
+   * Get number of pixels in each chroma channel
+   * @return number of pixels
+   */
+  std::uint64_t getChromaLength() const;
 
   /**
-	 * Get number of bits per pixel
-	 * @return number of bits
-	 */
+   * Get number of bits per pixel
+   * @return number of bits
+   */
   unsigned int getBitsPel() const;
 
   /**
-	 * Get number of bytes per frame of an existing frame
-	 * @return number of bytes per frame
-	 */
-  ClpULong getBytesPerFrame() const;
+   * Get number of bytes per frame of an existing frame
+   * @return number of bytes per frame
+   */
+  std::uint64_t getBytesPerFrame() const;
 
   /**
-	 * Get number of bytes per frame of a specific pixel format
-	 * @return number of bytes per frame
-	 */
-  static ClpULong getBytesPerFrame( unsigned int uiWidth, unsigned int uiHeight, int iPixelFormat, unsigned int bitsPixel );
+   * Get number of bytes per frame of a specific pixel format
+   * @return number of bytes per frame
+   */
+  static std::uint64_t getBytesPerFrame( unsigned int uiWidth, unsigned int uiHeight, ClpPixelFormats pelFormat, unsigned int bitsPixel );
 
   /**
-	 * Reset frame pixels to zero
-	 */
+   * Reset frame pixels to zero
+   */
   void reset();
 
   ClpPel*** getPelBufferYUV() const;
   ClpPel*** getPelBufferYUV();
 
-  unsigned char* getRGBBuffer() const;
+  auto getRGBBuffer() const -> const unsigned char*;
 
   /**
-	 * Get pixel value at coordinates
-	 * @param ch frame channel
-	 * @param xPos position in X axis
-	 * @param yPos position in Y axis
-	 * @return pixel value
-	 */
-  ClpPel operator()( unsigned int ch, unsigned int xPos, unsigned int yPos );
+   * Get pixel value at coordinates
+   * @param ch frame channel
+   * @param xPos position in X axis
+   * @param yPos position in Y axis
+   * @param absolute whether it should return positive/negative values
+   * @return pixel value
+   */
+  ClpPel operator()( unsigned int ch, unsigned int xPos, unsigned int yPos, bool absolute = true ) const;
 
   /**
-	 * Get pixel value at coordinates
-	 * @param xPos position in X axis
-	 * @param yPos position in Y axis
-	 * @return pixel value
-	 */
-  CalypPixel operator()( unsigned int xPos, unsigned int yPos );
+   * Get pixel value at coordinates
+   * @param xPos position in X axis
+   * @param yPos position in Y axis
+   * @return pixel value
+   */
+  CalypPixel operator()( unsigned int xPos, unsigned int yPos ) const;
 
   /**
-	 * Get pixel value at coordinates
-	 * @param xPos position in X axis
-	 * @param yPos position in Y axis
-	 * @return pixel value
-	 */
-  CalypPixel getPixel( unsigned int xPos, unsigned int yPos );
+   * Get pixel value at coordinates
+   * @param xPos position in X axis
+   * @param yPos position in Y axis
+   * @return pixel value
+   */
+  CalypPixel getPixel( unsigned int xPos, unsigned int yPos ) const;
 
   /**
-	 * Get pixel value at coordinates
-	 * in the desired color space
-	 * @param xPos position in X axis
-	 * @param yPos position in Y axis
-	 * @param eColorSpace desired color space
-	 * @return pixel value
-	 */
-  CalypPixel getPixel( unsigned int xPos, unsigned int yPos, CalypColorSpace eColorSpace );
+   * Get pixel value at coordinates
+   * in the desired color space
+   * @param xPos position in X axis
+   * @param yPos position in Y axis
+   * @param eColorSpace desired color space
+   * @return pixel value
+   */
+  CalypPixel getPixel( unsigned int xPos, unsigned int yPos, CalypColorSpace eColorSpace ) const;
 
   /**
-	 * Set pixel value at coordinates to a given value
-	 * @param xPos position in X axis
-	 * @param yPos position in Y axis
-	 */
+   * Set pixel value at coordinates to a given value
+   * @param xPos position in X axis
+   * @param yPos position in Y axis
+   */
   void setPixel( unsigned int xPos, unsigned int yPos, CalypPixel pixel );
 
   /**
-     * Copy a frame into the current buffer
-     * @param other frame to be copied
-     */
+   * Copy a frame into the current buffer
+   * @param other frame to be copied
+   */
   void copyFrom( const CalypFrame& other );
   void copyFrom( const CalypFrame* other );
 
   /**
-     * Copy a region from a reference corresponding to the size
-     * of the size of the current frame
-     * @param other frame to be copied
-     * @param x x position on the reference frame
-     * @param y y position on the reference frame
-     */
+   * Copy a region from a reference corresponding to the size
+   * of the size of the current frame
+   * @param other frame to be copied
+   * @param x x position on the reference frame
+   * @param y y position on the reference frame
+   */
   void copyFrom( const CalypFrame& other, unsigned x, unsigned y );
   void copyFrom( const CalypFrame* other, unsigned x, unsigned y );
 
   /**
-     * Copy a reference frame to a specific location on the current frame
-     * The whole reference frame is copied
-     * @param other frame to be copied
-     * @param x x position on the current frame
-     * @param y y position on the current frame
-     */
-  void copyTo( const CalypFrame& other, unsigned x, unsigned y );
-  void copyTo( const CalypFrame* other, unsigned x, unsigned y );
+   * Copy a reference frame to a specific location on the current frame
+   * The whole reference frame is copied
+   * @param other frame to be copied
+   * @param x x position on the current frame
+   * @param y y position on the current frame
+   */
+  void copyTo( const CalypFrame& other, unsigned x, unsigned y ) const;
+  void copyTo( const CalypFrame* other, unsigned x, unsigned y ) const;
 
-  void frameFromBuffer( ClpByte*, int, unsigned long );
-  void frameFromBuffer( ClpByte*, int );
-  void frameToBuffer( ClpByte*, int );
+  void frameFromBuffer( const std::vector<ClpByte>&, int, unsigned long );
+  void frameFromBuffer( const std::vector<ClpByte>&, int );
+  void frameToBuffer( std::vector<ClpByte>&, int ) const;
 
-  void fillRGBBuffer();
+  void fillRGBBuffer( std::optional<std::size_t> channel ) const;
+  void fillRGBBuffer() const;
 
   /**
-	 * Histogram
-	 */
+   * Histogram
+   */
   enum HistogramChannels
   {
     HIST_CHAN_ONE = 0,
@@ -352,31 +516,32 @@ public:
   };
   void calcHistogram();
 
-  unsigned int getMinimumPelValue( unsigned channel );
-  unsigned int getMaximumPelValue( unsigned channel );
+  unsigned int getMinimumPelValue( unsigned channel ) const;
+  unsigned int getMaximumPelValue( unsigned channel ) const;
 
-  unsigned int getMaximum( unsigned channel );
-  unsigned int getNumPixelsRange( unsigned channel, unsigned int start, unsigned int end );
-  double getMean( unsigned channel, unsigned int start, unsigned int end );
-  int getMedian( unsigned channel, unsigned int start, unsigned int end );
-  double getStdDev( unsigned channel, unsigned int start, unsigned int end );
-  double getHistogramValue( unsigned channel, unsigned int bin );
-  unsigned int getNEBins( unsigned channel );
-  int getNumHistogramSegment();
+  unsigned int getMaximum( unsigned channel ) const;
+  unsigned int getNumPixelsRange( unsigned channel, unsigned int start, unsigned int end ) const;
+  double getMean( unsigned channel, unsigned int start, unsigned int end ) const;
+  int getMedian( unsigned channel, unsigned int start, unsigned int end ) const;
+  double getStdDev( unsigned channel, unsigned int start, unsigned int end ) const;
+  double getHistogramValue( unsigned channel, unsigned int bin ) const;
+  unsigned int getNEBins( unsigned channel ) const;
+  int getNumHistogramSegment() const;
+  double getEntropy( unsigned channel, unsigned int start, unsigned int end ) const;
 
   /**
-	 * interface with OpenCV lib
-	 */
-  bool toMat( cv::Mat& cvMat, bool convertToGray = false, bool scale = true, unsigned channel = 0 );
+   * interface with OpenCV lib
+   */
+  bool toMat( cv::Mat& cvMat, bool convertToGray = false, bool scale = true, unsigned channel = 0 ) const;
   bool fromMat( cv::Mat& cvMat, int iChannel = -1 );
 
   /**
-	 * \ingroup	 CalypFrameGrp
-	 * @defgroup CalypFrameQualityMetricsGrp Calyp Frame Quality Metrics interface
-	 * @{
-	 * Quality metrics interface
-	 *
-	 */
+   * \ingroup	 CalypFrameGrp
+   * @defgroup CalypFrameQualityMetricsGrp Calyp Frame Quality Metrics interface
+   * @{
+   * Quality metrics interface
+   *
+   */
 
   enum QualityMetrics
   {
@@ -388,8 +553,8 @@ public:
     NUMBER_METRICS,
   };
 
-  static std::vector<ClpString> supportedQualityMetricsList();
-  static std::vector<ClpString> supportedQualityMetricsUnitsList();
+  static std::vector<std::string> supportedQualityMetricsList();
+  static std::vector<std::string> supportedQualityMetricsUnitsList();
   double getQuality( int Metric, CalypFrame* Org, unsigned int component );
   double getMSE( CalypFrame* Org, unsigned int component );
   double getPSNR( CalypFrame* Org, unsigned int component );
@@ -398,7 +563,8 @@ public:
   /** @} */
 
 private:
-  struct CalypFramePrivate* d;
+  class CalypFramePrivate;
+  std::unique_ptr<CalypFramePrivate> d;
 };
 
 #endif  // __CALYPFRAME_H__

lib/CalypLib.h

@@ -1,5 +1,5 @@
 /*    This file is a part of Calyp project
- *    Copyright (C) 2014-2019  by Joao Carreira   (jfmcarreira@gmail.com)
+ *    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

lib/CalypModuleIf.h

@@ -1,5 +1,5 @@
 /*    This file is a part of Calyp project
- *    Copyright (C) 2014-2019  by Joao Carreira   (jfmcarreira@gmail.com)
+ *    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
@@ -34,15 +34,25 @@
  * @}
  */
 
+#include <memory>
+#include <type_safe/flag_set.hpp>
+#include <vector>
+
 #include "CalypFrame.h"
 #include "CalypOptions.h"
 
 #define REGISTER_CLASS_MAKER( X ) \
-  extern "C" CalypModuleIf* Maker() { return new X; }
-#define REGISTER_CLASS_FACTORY( X )                  \
-public:                                              \
-  static CalypModuleIf* Create() { return new X(); } \
-  void Delete() { delete this; }
+  extern "C" CalypModulePtr Maker() { return std::make_unique<X>(); }
+#define REGISTER_CLASS_FACTORY( X )                   \
+public:                                               \
+  X( const X& buffer )                                \
+  noexcept = delete;                                  \
+  X( X&& buffer )                                     \
+  noexcept = delete;                                  \
+  auto operator=( const X& buffer )->X& = delete;     \
+  auto operator=( X&& buffer ) noexcept->X& = delete; \
+  static CalypModulePtr Create() { return std::make_unique<X>(); }
+
 #define _BASIC_MODULE_API_2_CHECK_                        \
   if( apcFrameList.size() != m_uiNumberOfFrames )         \
     return false;                                         \
@@ -62,8 +72,9 @@ public:                                              \
  */
 enum Module_API_Version
 {
-  CLP_MODULE_API_1,
-  CLP_MODULE_API_2,
+  CLP_MODULE_API_INVALID = -1,
+  CLP_MODULE_API_1 = 0,
+  CLP_MODULE_API_2 = 1,
   CLP_MODULE_API_3,
 };
 
@@ -72,11 +83,11 @@ enum Module_API_Version
  * Type of module
  * @see m_iModuleType
  */
-enum Module_Type
+enum class ClpModuleType : std::uint8_t
 {
-  CLP_FRAME_PROCESSING_MODULE,
-  CLP_FRAME_MEASUREMENT_MODULE,
-  CLP_MODULE_TYPE_MAX = 255,
+  Invalid,
+  FrameProcessing,
+  FrameMeasurement,
 };
 
 /** Module_Features Enum
@@ -84,18 +95,20 @@ enum Module_Type
  * Features/Requirements of a module
  * @see m_uiModuleRequirements
  */
-enum Module_Features
+enum class ClpModuleFeature
 {
-  CLP_MODULE_REQUIRES_NOTHING = 0,
-  CLP_MODULE_REQUIRES_SKIP_WHILE_PLAY = 1,
-  CLP_MODULE_REQUIRES_OPTIONS = 2,
-  CLP_MODULE_REQUIRES_NEW_WINDOW = 4,
-  CLP_MODULE_USES_KEYS = 8,
-  CLP_MODULES_VARIABLE_NUM_FRAMES = 16,
-  CLP_MODULES_HAS_INFO = 32,
-  CLP_MODULE_REQURES_MAX = 1024,
+  None,
+  SkipWhilePlaying,
+  Options,
+  NewWindow,
+  KeysShortcuts,
+  VariableNumOfFrames,
+  HasInfo,
+  _flag_set_size
 };
 
+using ClpModuleFeatures = type_safe::flag_set<ClpModuleFeature>;
+
 enum Module_Key_Supported
 {
   MODULE_KEY_LEFT,
@@ -112,34 +125,14 @@ enum Module_Key_Supported
 class CalypModuleIf
 {
 public:
-  int m_iModuleAPI;
-  int m_iModuleType;
-  const char* m_pchModuleCategory;
-  const char* m_pchModuleName;
-  const char* m_pchModuleTooltip;
-  const char* m_pchModuleLongName;
+  CalypModuleIf() = default;
+  CalypModuleIf( const CalypModuleIf& buffer ) noexcept = delete;
+  CalypModuleIf( CalypModuleIf&& buffer ) noexcept = delete;
+  auto operator=( const CalypModuleIf& buffer ) -> CalypModuleIf& = delete;
+  auto operator=( CalypModuleIf&& buffer ) noexcept -> CalypModuleIf& = delete;
 
-  //! Number of frames
-  unsigned int m_uiNumberOfFrames;
-  //! Features/Requirements
-  unsigned int m_uiModuleRequirements;
-
-  unsigned int m_iFrameBufferCount;
-  CalypFrame* m_pcOutputFrame;
-
-  CalypOptions m_cModuleOptions;
-
-  CalypModuleIf()
-  {
-    m_iModuleAPI = CLP_MODULE_API_1;
-    m_uiModuleRequirements = CLP_MODULE_REQUIRES_NOTHING;
-    m_pchModuleLongName = NULL;
-    m_pcOutputFrame = NULL;
-    m_iFrameBufferCount = 0;
-  }
-  virtual ~CalypModuleIf() {}
-  virtual void Delete() = 0;
-  virtual void destroy() = 0;
+  virtual ~CalypModuleIf() = default;
+  virtual void destroy(){};
 
   const char* getModuleLongName()
   {
@@ -159,17 +152,80 @@ public:
   virtual CalypFrame* process( std::vector<CalypFrame*> ) { return NULL; }
   virtual double measure( std::vector<CalypFrame*> ) { return 0; }
   virtual bool keyPressed( enum Module_Key_Supported ) { return false; }
-  virtual ClpString moduleInfo() { return ClpString(); }
+  virtual std::string moduleInfo() { return std::string(); }
   /**
    * Module API version 3
    */
-  virtual CalypFrame* getProcessedFrame() { return m_pcOutputFrame; }
-  virtual bool needFrame() { return m_iFrameBufferCount == 0? true : false; };
+  virtual CalypFrame* getProcessedFrame() { return nullptr; }
+  virtual bool needFrame() { return m_iFrameBufferCount == 0 ? true : false; };
   virtual bool flush()
   {
     m_iFrameBufferCount = 0;
     return true;
   };
+
+public:
+  int m_iModuleAPI{ CLP_MODULE_API_1 };
+  ClpModuleType m_iModuleType{ ClpModuleType::Invalid };
+  const char* m_pchModuleCategory{ "" };
+  const char* m_pchModuleName{ "" };
+  const char* m_pchModuleTooltip{ "" };
+  const char* m_pchModuleLongName{ nullptr };
+
+  //! Number of frames
+  unsigned int m_uiNumberOfFrames{ 1 };
+  //! Features/Requirements
+  ClpModuleFeatures m_uiModuleRequirements{ ClpModuleFeature::None };
+
+  unsigned int m_iFrameBufferCount{ 0 };
+
+  CalypOptions m_cModuleOptions;
+};
+
+namespace cv
+{
+class Mat;
+}
+
+/**
+ * \class    CalypOpenCVModuleIf
+ * \ingroup  CalypLib Calyp_Modules
+ * \brief    Abstract class for modules using OpenCV library
+ */
+class CalypOpenCVModuleIf : public CalypModuleIf
+{
+  using Mat = cv::Mat;
+
+public:
+  CalypOpenCVModuleIf() { m_bConvertToGray = false; };
+  virtual ~CalypOpenCVModuleIf() {}
+
+  // Common API
+  bool create( std::vector<CalypFrame*> apcFrameList );
+  CalypFrame* process( std::vector<CalypFrame*> apcFrameList );
+  void destroy();
+
+  // API using OpenCV
+  virtual cv::Mat* create_using_opencv( const std::vector<Mat>& apcFrameList )
+  {
+    return nullptr;
+  };
+  virtual Mat* process_using_opencv( const std::vector<Mat>& apcFrameList ) = 0;
+  virtual void destroy_using_opencv(){};
+
+protected:
+  // const char* m_pchPythonFunctionName;
+  std::unique_ptr<CalypFrame> m_pcOutputFrame;
+  bool m_bConvertToGray;
+};
+
+using CalypModulePtr = std::unique_ptr<CalypModuleIf>;
+
+template <typename T>
+class CalypModuleInstace
+{
+public:
+  static CalypModulePtr Create() { return std::make_unique<T>(); }
 };
 
 #endif  // __CALYPMODULESIF_H__

lib/CalypOpenCVModuleIf.cpp

@@ -0,0 +1,71 @@
+/*    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     CalypOpenCVModuleIf.cpp
+ * \brief    Calyp modules interface for OpenCV
+ */
+
+#include "CalypFrame.h"
+#include "CalypModuleIf.h"
+
+// OpenCV
+#include <opencv2/opencv.hpp>
+
+#include "PixelFormats.h"
+
+bool CalypOpenCVModuleIf::create( std::vector<CalypFrame*> apcFrameList )
+{
+  _BASIC_MODULE_API_2_CHECK_
+  bool bRet = false;
+  std::vector<Mat> acMatList( apcFrameList.size() );
+  for( unsigned i = 0; i < apcFrameList.size(); i++ )
+  {
+    apcFrameList[i]->toMat( acMatList[i], m_bConvertToGray );
+  }
+  Mat* outputMat = create_using_opencv( acMatList );
+  if( outputMat )
+  {
+    auto pelFormat = m_bConvertToGray ? ClpPixelFormats::Gray : apcFrameList[0]->getPelFormat();
+    m_pcOutputFrame = std::make_unique<CalypFrame>( outputMat->cols, outputMat->rows, pelFormat, apcFrameList[0]->getBitsPel() );
+    bRet = true;
+  }
+  else
+  {
+    return false;
+  }
+  return bRet;
+}
+
+CalypFrame* CalypOpenCVModuleIf::process( std::vector<CalypFrame*> apcFrameList )
+{
+  m_pcOutputFrame->reset();
+  std::vector<Mat> acMatList( apcFrameList.size() );
+  for( unsigned i = 0; i < apcFrameList.size(); i++ )
+  {
+    apcFrameList[i]->toMat( acMatList[i], m_bConvertToGray );
+  }
+  Mat* cvOutput = process_using_opencv( acMatList );
+  m_pcOutputFrame->fromMat( *cvOutput );
+  return m_pcOutputFrame.get();
+}
+
+void CalypOpenCVModuleIf::destroy()
+{
+}

lib/CalypOptions.cpp

@@ -38,53 +38,53 @@
 
 #include "CalypOptions.h"
 
+#include <cstring>
+#include <iostream>
+#include <memory>
+#include <sstream>
+
 #include "config.h"
 #include "lib/CalypModuleIf.h"
 
-#include <cstring>
-#include <iostream>
-#include <sstream>
-
-using namespace std;
-
 struct ParseFailure : public std::exception
 {
-  ClpString arg;
-  ClpString val;
-  ParseFailure( ClpString arg0, ClpString val0 ) throw()
-      : arg( arg0 ), val( val0 ) {}
+  std::string arg;
+  std::string val;
+  ParseFailure( std::string arg0, std::string val0 ) throw()
+      : arg{ std::move( arg0 ) }, val{ std::move( val0 ) } {}
+  ParseFailure( ParseFailure&& other ) noexcept = delete;
+  ParseFailure& operator=( ParseFailure&& other ) noexcept = delete;
+  ParseFailure( const ParseFailure& other ) = delete;
+  ParseFailure& operator=( const ParseFailure& other ) = delete;
   ~ParseFailure() throw() {}
-  const char* what() const throw() { return "Option Parse Failure"; }
+  const char* what() const throw() override { return "Option Parse Failure"; }
 };
 
 /** Type specific option storage */
-class boolOption : public OptionBase
+class boolOption : public CalypOptions::OptionBase
 {
 public:
-  boolOption( const ClpString& name, const ClpString& desc )
-      : OptionBase( name, desc, "(1-0)" ) { is_binary = true; }
-  void parse( const ClpString& arg ) { arg_count++; }
+  boolOption( const std::string& name, const std::string& desc )
+      : CalypOptions::OptionBase( name, desc, "(1-0)" ) { is_binary = true; }
+  void parse( const std::string& arg ) override { arg_count++; }
 };
 
 /** Type specific option storage */
 template <typename T>
-class StandardOption : public OptionBase
+class StandardOption : public CalypOptions::OptionBase
 {
 public:
-  StandardOption( const ClpString& name, T& storage, const ClpString& desc, const ClpString& def )
-      : OptionBase( name, desc, def ), opt_storage( storage )
-  {
-    is_binary = false;
-  }
+  StandardOption( const std::string& name, T& storage, const std::string& desc, const std::string& def )
+      : CalypOptions::OptionBase( name, desc, def ), opt_storage( storage ) {}
 
-  void parse( const ClpString& arg );
+  void parse( const std::string& arg ) override;
   T& opt_storage;
   std::vector<T> opt_storage_array;
 };
 
 /* Generic parsing */
 template <typename T>
-inline void StandardOption<T>::parse( const ClpString& arg )
+inline void StandardOption<T>::parse( const std::string& arg )
 {
   if( !is_binary )
   {
@@ -103,9 +103,9 @@ inline void StandardOption<T>::parse( const ClpString& arg )
 }
 
 template <>
-inline void StandardOption<std::vector<unsigned int>>::parse( const ClpString& arg )
+inline void StandardOption<std::vector<unsigned int>>::parse( const std::string& arg )
 {
-  unsigned int aux_opt_storage;
+  unsigned int aux_opt_storage{ 0 };
   std::istringstream arg_ss( arg, std::istringstream::in );
   arg_ss.exceptions( std::ios::failbit );
   try
@@ -121,9 +121,9 @@ inline void StandardOption<std::vector<unsigned int>>::parse( const ClpString& a
 }
 
 template <>
-inline void StandardOption<std::vector<int>>::parse( const ClpString& arg )
+inline void StandardOption<std::vector<int>>::parse( const std::string& arg )
 {
-  int aux_opt_storage;
+  int aux_opt_storage{ 0 };
   std::istringstream arg_ss( arg, std::istringstream::in );
   arg_ss.exceptions( std::ios::failbit );
   try
@@ -140,7 +140,7 @@ inline void StandardOption<std::vector<int>>::parse( const ClpString& arg )
 
 /* string parsing is specialized */
 template <>
-inline void StandardOption<ClpString>::parse( const ClpString& arg )
+inline void StandardOption<std::string>::parse( const std::string& arg )
 {
   opt_storage = arg;
   arg_count++;
@@ -148,33 +148,33 @@ inline void StandardOption<ClpString>::parse( const ClpString& arg )
 
 /* string vector parsing is specialized */
 template <>
-inline void StandardOption<std::vector<ClpString>>::parse( const ClpString& arg )
+inline void StandardOption<std::vector<std::string>>::parse( const std::string& arg )
 {
   opt_storage.push_back( arg );
   arg_count++;
 }
 
 /** Option class for argument handling using a user provided function */
-struct FunctionOption : public OptionBase
+struct FunctionOption : public CalypOptions::OptionBase
 {
-public:
-  typedef void( Func )( CalypOptions&, const ClpString& );
+  using OptFunc = std::function<void( CalypOptions&, const std::string& )>;
 
-  FunctionOption( const ClpString& name, CalypOptions& parent_, Func* func_, const ClpString& desc, const ClpString& def )
-      : OptionBase( name, desc, def ), parent( parent_ ), func( func_ )
+public:
+  FunctionOption( const std::string& name, CalypOptions& parent, OptFunc func, const std::string& desc, const std::string& def )
+      : CalypOptions::OptionBase( name, desc, def ), m_parent( parent ), m_func( func )
   {
     is_binary = false;
   }
 
-  void parse( const ClpString& arg )
+  void parse( const std::string& arg ) override
   {
-    func( parent, arg );
+    m_func( m_parent, arg );
     arg_count++;
   }
 
 private:
-  CalypOptions& parent;
-  void ( *func )( CalypOptions&, const ClpString& );
+  CalypOptions& m_parent;
+  OptFunc m_func;
 };
 
 /* Helper method to initiate adding options to Options */
@@ -185,9 +185,15 @@ private:
  *   with default_val as the default value
  *   with desc as an optional help description
  */
-CalypOptions& CalypOptions::operator()( const ClpString& name, const ClpString& desc )
+CalypOptions& CalypOptions::operator()( const std::string& name, const std::string& desc )
 {
-  addOption( new boolOption( name, desc ) );
+  addOptionInternal( std::make_unique<boolOption>( name, desc ) );
+  return *this;
+}
+
+CalypOptions& CalypOptions::addOption( const std::string& name, const std::string& desc )
+{
+  addOptionInternal( std::make_unique<boolOption>( name, desc ) );
   return *this;
 }
 
@@ -197,114 +203,99 @@ CalypOptions& CalypOptions::operator()( const ClpString& name, const ClpString&
  *   with desc as an optional help description
  */
 template <typename T>
-CalypOptions& CalypOptions::operator()( const ClpString& name, T& storage, const ClpString& desc )
+CalypOptions& CalypOptions::operator()( const std::string& name, T& storage, const std::string& desc )
 {
-  addOption( new StandardOption<T>( name, storage, desc, ClpString( "" ) ) );
+  addOptionInternal( std::make_unique<StandardOption<T>>( name, storage, desc, std::string( "" ) ) );
+  return *this;
+}
+template <typename T>
+CalypOptions& CalypOptions::addOption( const std::string& name, T& storage, const std::string& desc )
+{
+  addOptionInternal( std::make_unique<StandardOption<T>>( name, storage, desc, std::string( "" ) ) );
   return *this;
 }
 
 template <typename T>
-CalypOptions& CalypOptions::operator()( const ClpString& name, T& storage, const ClpString& desc, const ClpString& defaults )
+CalypOptions& CalypOptions::operator()( const std::string& name, T& storage, const std::string& desc, const std::string& defaults )
 {
-  addOption( new StandardOption<T>( name, storage, desc ) );
+  addOptionInternal( std::make_unique<StandardOption<T>>( name, storage, desc ) );
   return *this;
 }
 
-template CalypOptions& CalypOptions::operator()( const ClpString& name, bool& storage, const ClpString& desc );
-template CalypOptions& CalypOptions::operator()( const ClpString& name, unsigned int& storage, const ClpString& desc );
-template CalypOptions& CalypOptions::operator()( const ClpString& name, int& storage, const ClpString& desc );
-template CalypOptions& CalypOptions::operator()( const ClpString& name, long& storage, const ClpString& desc );
-template CalypOptions& CalypOptions::operator()( const ClpString& name, long long int& storage, const ClpString& desc );
-template CalypOptions& CalypOptions::operator()( const ClpString& name, ClpString& storage, const ClpString& desc );
-template CalypOptions& CalypOptions::operator()( const ClpString& name, std::vector<unsigned int>& storage,
-                                                 const ClpString& desc );
-template CalypOptions& CalypOptions::operator()( const ClpString& name, std::vector<int>& storage,
-                                                 const ClpString& desc );
-template CalypOptions& CalypOptions::operator()( const ClpString& name, std::vector<ClpString>& storage,
-                                                 const ClpString& desc );
-
-CalypOptions::Option::Option()
-    : opt( 0 ) {}
-
-CalypOptions::Option::~Option()
+template <typename T>
+CalypOptions& CalypOptions::addOption( const std::string& name, T& storage, const std::string& desc, const std::string& defaults )
 {
-  if( opt )
-    delete opt;
+  addOptionInternal( std::make_unique<StandardOption<T>>( name, storage, desc ) );
+  return *this;
 }
 
-CalypOptions::CalypOptions( const ClpString& name )
+template CalypOptions& CalypOptions::operator()( const std::string& name, bool& storage, const std::string& desc );
+template CalypOptions& CalypOptions::operator()( const std::string& name, unsigned int& storage, const std::string& desc );
+template CalypOptions& CalypOptions::operator()( const std::string& name, int& storage, const std::string& desc );
+template CalypOptions& CalypOptions::operator()( const std::string& name, long& storage, const std::string& desc );
+template CalypOptions& CalypOptions::operator()( const std::string& name, long long int& storage, const std::string& desc );
+template CalypOptions& CalypOptions::operator()( const std::string& name, std::string& storage, const std::string& desc );
+template CalypOptions& CalypOptions::operator()( const std::string& name, std::vector<unsigned int>& storage,
+                                                 const std::string& desc );
+template CalypOptions& CalypOptions::operator()( const std::string& name, std::vector<int>& storage,
+                                                 const std::string& desc );
+template CalypOptions& CalypOptions::operator()( const std::string& name, std::vector<std::string>& storage,
+                                                 const std::string& desc );
+
+CalypOptions::CalypOptions( std::string name )
+    : m_cOptionGroupName{ std::move( name ) }
 {
-  m_cOptionGroupName = name;
-  m_bAllowUnkonw = true;
 }
 
-CalypOptions::~CalypOptions()
-{
-  for( CalypOptions::OptionsList::iterator it = opt_list.begin(); it != opt_list.end(); it++ )
-  {
-    delete *it;
-  }
-}
-
-OptionBase* CalypOptions::operator[]( const ClpString& optName )
+CalypOptions::OptionBase* CalypOptions::operator[]( const std::string& optName )
 {
   return getOption( optName );
 }
 
-OptionBase* CalypOptions::getOption( const ClpString& optName )
+CalypOptions::OptionBase* CalypOptions::getOption( const std::string& optName )
 {
-  CalypOptions::OptionMap::iterator opt_it;
+  std::map<std::string, std::list<Option*>>::iterator opt_it;
   opt_it = opt_short_map.find( optName );
   if( opt_it != opt_short_map.end() )
   {
-    OptionsList opt_list = ( *opt_it ).second;
-    for( CalypOptions::OptionsList::iterator it = opt_list.begin(); it != opt_list.end(); ++it )
+    auto opt_list = ( *opt_it ).second;
+    for( auto& option : opt_list )
     {
-      return ( *it )->opt;
+      return option->base_opt.get();
     }
   }
   opt_it = opt_long_map.find( optName );
   if( opt_it != opt_long_map.end() )
   {
-    OptionsList opt_list = ( *opt_it ).second;
-    for( CalypOptions::OptionsList::iterator it = opt_list.begin(); it != opt_list.end(); ++it )
+    auto opt_list = ( *opt_it ).second;
+    for( auto& option : opt_list )
     {
-      return ( *it )->opt;
+      return option->base_opt.get();
     }
   }
   return NULL;
 }
 
-bool CalypOptions::hasOpt( const ClpString& optName )
+bool CalypOptions::hasOpt( const std::string& optName )
 {
   OptionBase* opt = getOption( optName );
   return opt ? opt->count() > 0 ? true : false : false;
 }
 
-void CalypOptions::addDefaultOptions()
-{
-  addOptions()                                                /**/
-      ( "help,h", "produce help message" )                    /**/
-      ( "version", "show version and exit" )                  /**/
-      ( "pel_fmts", "list pixel formats" )                    /**/
-      ( "quality_metrics", "list supported quality metrics" ) /**/
-      ( "module_list", "list supported modules" )             /**/
-      ( "module_list_full", "detailed list supported modules" );
-}
-
 CalypOptions& CalypOptions::addOptions()
 {
   return *this;
 }
 
-void CalypOptions::addOption( OptionBase* opt )
+void CalypOptions::addOptionInternal( std::unique_ptr<OptionBase> opt )
 {
-  Option* names = new Option();
-  names->opt = opt;
-  string& opt_string = opt->opt_string;
+  auto names = std::make_unique<Option>();
+  names->base_opt = std::move( opt );
+  opt = nullptr;
+  const std::string& opt_string = names->base_opt->opt_string;
 
   size_t opt_start = 0;
-  for( size_t opt_end = 0; opt_end != string::npos; )
+  for( size_t opt_end = 0; opt_end != std::string::npos; )
   {
     opt_end = opt_string.find_first_of( ',', opt_start );
     bool force_short = 0;
@@ -313,36 +304,37 @@ void CalypOptions::addOption( OptionBase* opt )
       opt_start++;
       force_short = 1;
     }
-    string opt_name = opt_string.substr( opt_start, opt_end - opt_start );
+    std::string opt_name = opt_string.substr( opt_start, opt_end - opt_start );
     if( force_short || opt_name.size() == 1 )
     {
       names->opt_short.push_back( opt_name );
-      opt_short_map[opt_name].push_back( names );
+      opt_short_map[opt_name].push_back( names.get() );
     }
     else
     {
       names->opt_long.push_back( opt_name );
-      opt_long_map[opt_name].push_back( names );
+      opt_long_map[opt_name].push_back( names.get() );
     }
     opt_start += opt_end + 1;
   }
-  opt_list.push_back( names );
+  opt_list.push_back( std::move( names ) );
 }
 
-static void setOptions( CalypOptions::OptionsList& opt_list, const string& value )
+static void setOptions( std::list<CalypOptions::Option*>& opt_list, const std::string& value )
 {
   /* multiple options may be registered for the same name:
-   *   allow each to parse value */
-  for( CalypOptions::OptionsList::iterator it = opt_list.begin(); it != opt_list.end(); ++it )
+   *   allow each to parse value
+   */
+  for( auto& option : opt_list )
   {
-    ( *it )->opt->parse( value );
+    option->base_opt->parse( value );
   }
 }
 
-bool CalypOptions::storePair( bool allow_long, bool allow_short, const string& name, const string& value )
+bool CalypOptions::storePair( bool allow_long, bool allow_short, const std::string& name, const std::string& value )
 {
   bool found = false;
-  CalypOptions::OptionMap::iterator opt_it;
+  std::map<std::string, std::list<Option*>>::iterator opt_it;
   if( allow_long )
   {
     opt_it = opt_long_map.find( name );
@@ -367,7 +359,7 @@ bool CalypOptions::storePair( bool allow_long, bool allow_short, const string& n
     if( !m_bAllowUnkonw )
     {
       /* not found */
-      cerr << "Unknown option: `" << name << "' (value:`" << value << "')" << endl;
+      std::cerr << "Unknown option: `" << name << "' (value:`" << value << "')" << std::endl;
     }
     return false;
   }
@@ -376,7 +368,7 @@ bool CalypOptions::storePair( bool allow_long, bool allow_short, const string& n
   return true;
 }
 
-bool CalypOptions::storePair( const string& name, const string& value )
+bool CalypOptions::storePair( const std::string& name, const std::string& value )
 {
   return storePair( true, true, name, value );
 }
@@ -384,19 +376,19 @@ bool CalypOptions::storePair( const string& name, const string& value )
 /**
  * returns number of extra arguments consumed
  */
-unsigned int CalypOptions::parseLONG( unsigned int argc, char* argv[] )
+unsigned int CalypOptions::parseLONG( unsigned int argc, char* argv[] )  // NOLINT
 {
   /* gnu style long options can take the forms:
    *  --option=arg
    *  --option arg
    */
-  string arg( argv[0] );
-  size_t arg_opt_start = arg.find_first_not_of( '-' );
-  size_t arg_opt_sep = arg.find_first_of( '=' );
-  string option = arg.substr( arg_opt_start, arg_opt_sep - arg_opt_start );
+  std::string arg( argv[0] );
+  std::size_t arg_opt_start = arg.find_first_not_of( '-' );
+  std::size_t arg_opt_sep = arg.find_first_of( '=' );
+  std::string option = arg.substr( arg_opt_start, arg_opt_sep - arg_opt_start );
 
   unsigned int extra_argc_consumed = 0;
-  if( arg_opt_sep == string::npos )
+  if( arg_opt_sep == std::string::npos )
   {
 /* no argument found => argument in argv[1] (maybe) */
 /* xxx, need to handle case where option isn't required */
@@ -416,7 +408,7 @@ unsigned int CalypOptions::parseLONG( unsigned int argc, char* argv[] )
   else
   {
     /* argument occurs after option_sep */
-    string val = arg.substr( arg_opt_sep + 1 );
+    std::string val = arg.substr( arg_opt_sep + 1 );
     storePair( true, false, option, val );
   }
   return extra_argc_consumed;
@@ -425,7 +417,7 @@ unsigned int CalypOptions::parseLONG( unsigned int argc, char* argv[] )
 /**
  * returns number of extra arguments consumed
  */
-unsigned int CalypOptions::parseLONG( string arg )
+unsigned int CalypOptions::parseLONG( const std::string& arg )
 {
   /* gnu style long options can take the forms:
    *  --option=arg
@@ -433,10 +425,10 @@ unsigned int CalypOptions::parseLONG( string arg )
    */
   size_t arg_opt_start = arg.find_first_not_of( '-' );
   size_t arg_opt_sep = arg.find_first_of( '=' );
-  string option = arg.substr( arg_opt_start, arg_opt_sep - arg_opt_start );
+  std::string option = arg.substr( arg_opt_start, arg_opt_sep - arg_opt_start );
 
   unsigned int extra_argc_consumed = 0;
-  if( arg_opt_sep == string::npos )
+  if( arg_opt_sep == std::string::npos )
   {
     /* no argument found => argument in argv[1] (maybe) */
     /* xxx, need to handle case where option isn't required */
@@ -448,62 +440,62 @@ unsigned int CalypOptions::parseLONG( string arg )
   else
   {
     /* argument occurs after option_sep */
-    string val = arg.substr( arg_opt_sep + 1 );
+    std::string val = arg.substr( arg_opt_sep + 1 );
     storePair( true, false, option, val );
   }
   return extra_argc_consumed;
 }
 
-unsigned int CalypOptions::parseSHORT( unsigned int argc, char* argv[] )
+unsigned int CalypOptions::parseSHORT( unsigned int argc, char* argv[] )  // NOLINT
 {
   /* short options can take the forms:
    *  --option arg
    *  -option arg
    */
-  string arg( argv[0] );
-  size_t arg_opt_start = arg.find_first_not_of( '-' );
-  string option = arg.substr( arg_opt_start );
+  std::string arg( argv[0] );
+  std::size_t arg_opt_start = arg.find_first_not_of( '-' );
+  std::string option = arg.substr( arg_opt_start );
   /* lookup option */
 
   /* argument in argv[1] */
   /* xxx, need to handle case where option isn't required */
   if( argc == 1 )
   {
-    cerr << "Not processing option without argument `" << option << "'" << endl;
+    std::cerr << "Not processing option without argument `" << option << "'" << std::endl;
     return 0; /* run out of argv for argument */
   }
-  storePair( false, true, option, string( argv[1] ) );
+  storePair( false, true, option, std::string( argv[1] ) );
 
   return 1;
 }
 
-bool CalypOptions::parse( unsigned int argc, char* argv[] )
+int CalypOptions::parse( unsigned int argc, char* argv[] )  // NOLINT
 {
   try
   {
     m_aUnhandledArgs = scanArgv( argc, argv );
-
     if( checkListingOpts() )
     {
-      return false;
+      return 1;
     }
   }
   catch( std::exception& e )
   {
     std::cerr << "error: " << e.what() << "\n";
-    return false;
+    return -1;
   }
   catch( ... )
   {
     std::cerr << "Exception of unknown type!\n";
   }
-  return true;
+  return 0;
 }
 
-list<const char*> CalypOptions::scanArgv( unsigned int argc, char* argv[] )
+// NOLINTNEXTLINE(*-avoid-c-arrays)
+std::list<const char*> CalypOptions::scanArgv( unsigned int argc, char* argv[] )
 {
   /* a list for anything that didn't get handled as an option */
-  list<const char*> non_option_arguments;
+  std::list<const char*> non_option_arguments;
 
   for( unsigned int i = 1; i < argc; i++ )
   {
@@ -546,7 +538,7 @@ list<const char*> CalypOptions::scanArgv( unsigned int argc, char* argv[] )
   return non_option_arguments;
 }
 
-void CalypOptions::parse( std::vector<ClpString> args_array )
+void CalypOptions::parse( std::vector<std::string> args_array )
 {
   for( unsigned int i = 0; i < args_array.size(); i++ )
   {
@@ -561,13 +553,13 @@ static const char spaces[41] = "                                        ";
  * using the formatting: "-x, --long",
  * if a short/long option isn't specified, it is not printed
  */
-static void doHelpOpt( ostream& out, const CalypOptions::Option& entry, unsigned int pad_short = 0 )
+static void doHelpOpt( std::ostream& out, const CalypOptions::Option& entry, unsigned int pad_short = 0 )
 {
-  pad_short = min( pad_short, 8u );
+  pad_short = std::min( pad_short, 8u );
 
   if( !entry.opt_short.empty() )
   {
-    unsigned int pad = max( (int)pad_short - (int)entry.opt_short.front().size(), 0 );
+    unsigned int pad = std::max( (int)pad_short - (int)entry.opt_short.front().size(), 0 );
     out << "-" << entry.opt_short.front();
     if( !entry.opt_long.empty() )
     {
@@ -588,19 +580,19 @@ static void doHelpOpt( ostream& out, const CalypOptions::Option& entry, unsigned
 }
 
 /* format the help text */
-void CalypOptions::doHelp( ostream& out, unsigned int columns )
+void CalypOptions::doHelp( std::ostream& out, unsigned int columns )
 {
   const unsigned int pad_short = 3;
   /* first pass: work out the longest option name */
   unsigned int max_width = 0;
-  for( CalypOptions::OptionsList::iterator it = opt_list.begin(); it != opt_list.end(); it++ )
+  for( auto& opt : opt_list )
   {
-    ostringstream line( ios_base::out );
-    doHelpOpt( line, **it, pad_short );
-    max_width = max( max_width, (unsigned int)line.tellp() );
+    std::ostringstream line( std::ios_base::out );
+    doHelpOpt( line, *opt, pad_short );
+    max_width = std::max( max_width, (unsigned int)line.tellp() );
   }
 
-  unsigned int opt_width = min( max_width + 2, 28u + pad_short ) + 2;
+  unsigned int opt_width = std::min( max_width + 2, 28u + pad_short ) + 2;
   unsigned int desc_width = columns - opt_width;
 
   /* second pass: write out formatted option and help text.
@@ -608,17 +600,17 @@ void CalypOptions::doHelp( ostream& out, unsigned int columns )
    *  - if the option text is longer than opt_width, place the help
    *    text at opt_width on the next line.
    */
-  for( CalypOptions::OptionsList::iterator it = opt_list.begin(); it != opt_list.end(); it++ )
+  for( auto& opt : opt_list )
   {
-    ostringstream line( ios_base::out );
+    std::ostringstream line( std::ios_base::out );
     line << "  ";
-    doHelpOpt( line, **it, pad_short );
+    doHelpOpt( line, *opt, pad_short );
 
-    const string& opt_desc = ( *it )->opt->opt_desc;
+    const std::string& opt_desc = opt->base_opt->opt_desc;
     if( opt_desc.empty() )
     {
       /* no help text: output option, skip further processing */
-      cout << line.str() << endl;
+      std::cout << line.str() << std::endl;
       continue;
     }
     size_t currlength = size_t( line.tellp() );
@@ -626,17 +618,17 @@ void CalypOptions::doHelp( ostream& out, unsigned int columns )
     {
       /* if option text is too long (and would collide with the
        * help text, split onto next line */
-      line << endl;
+      line << std::endl;
       currlength = 0;
     }
     /* split up the help text, taking into account new lines,
      *   (add opt_width of padding to each new line) */
-    for( size_t newline_pos = 0, cur_pos = 0; cur_pos != string::npos; currlength = 0 )
+    for( std::size_t newline_pos = 0, cur_pos = 0; cur_pos != std::string::npos; currlength = 0 )
     {
       /* print any required padding space for vertical alignment */
       line << &( spaces[40 - opt_width + currlength] );
       newline_pos = opt_desc.find_first_of( '\n', newline_pos );
-      if( newline_pos != string::npos )
+      if( newline_pos != std::string::npos )
       {
         /* newline found, print substring (newline needn't be stripped) */
         newline_pos++;
@@ -653,14 +645,14 @@ void CalypOptions::doHelp( ostream& out, unsigned int columns )
       /* find a suitable point to split text (avoid spliting in middle of word)
        */
       size_t split_pos = opt_desc.find_last_of( ' ', cur_pos + desc_width );
-      if( split_pos != string::npos )
+      if( split_pos != std::string::npos )
       {
         /* eat up multiple space characters */
         split_pos = opt_desc.find_last_not_of( ' ', split_pos ) + 1;
       }
 
       /* bad split if no suitable space to split at.  fall back to width */
-      bool bad_split = split_pos == string::npos || split_pos <= cur_pos;
+      bool bad_split = split_pos == std::string::npos || split_pos <= cur_pos;
       if( bad_split )
       {
         split_pos = cur_pos + desc_width;
@@ -678,10 +670,9 @@ void CalypOptions::doHelp( ostream& out, unsigned int columns )
       {
         break;
       }
-      line << endl;
+      line << std::endl;
     }
-
-    cout << line.str() << endl;
+    std::cout << line.str() << std::endl;
   }
 }
 
@@ -691,24 +682,25 @@ bool CalypOptions::checkListingOpts()
 
   if( hasOpt( "version" ) )
   {
-    std::cout << "Calyp version " << CALYP_VERSION_STRING << "\n";
+    std::cout << "Calyp version" << CALYP_VERSION_STRING << std::endl;
     bRet |= true;
   }
   if( hasOpt( "pel_fmts" ) )
   {
-    printf( "Calyp supported pixel formats: \n" );
-    for( unsigned int i = 0; i < CalypFrame::supportedPixelFormatListNames().size(); i++ )
+    std::cout << "Calyp supported pixel formats:" << std::endl;
+    const auto& fmt_list = CalypFrame::supportedPixelFormatListNames();
+    for( const auto& [key, name] : fmt_list )
     {
-      printf( "   %s\n", CalypFrame::supportedPixelFormatListNames()[i].c_str() );
+      std::cout << "   " << name << std::endl;
     }
     bRet |= true;
   }
   if( hasOpt( "quality_metrics" ) )
   {
-    printf( "Calyp supported quality metrics: \n" );
+    std::cout << "Calyp supported quality metrics:" << std::endl;
     for( unsigned int i = 0; i < CalypFrame::supportedQualityMetricsList().size(); i++ )
     {
-      printf( "   %s\n", CalypFrame::supportedQualityMetricsList()[i].c_str() );
+      std::cout << "   " << CalypFrame::supportedQualityMetricsList()[i] << std::endl;
     }
     bRet |= true;
   }