Version bump 2.0.1

- Now histogram update if some windows is playing but not the current window
- If the current window is a module window it will check if the source
  window is playing
- The white fill of the window is only drawn after 500ms. Trying to
  reduce the continuous refreshing even on simple modules

.appveyor.yml

@@ -4,34 +4,35 @@ 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'
   - 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 -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_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 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
@@ -39,7 +40,7 @@ build_script:
 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,43 @@
+---
+Checks:          'clang-diagnostic-*,clang-analyzer-*,cppcoreguidelines-*,-cppcoreguidelines-pro-bounds-array-to-pointer-decay'
+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'

.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,35 @@
+name: Build on Linux
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+env:
+  # Customize the CMake build type here (Release, Debug, RelWithDebInfo, etc.)
+  BUILD_TYPE: Release
+
+jobs:
+  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 install cmake qtbase5-dev libavcodec-dev libavformat-dev libavutil-dev libopencv-dev libopencv-video-dev libopencv-contrib-dev
+
+    - uses: actions/checkout@v2
+
+    - 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 -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} -DUSE_WERROR=OFF
+
+    - name: Build
+      # Build your program with the given configuration
+      run: cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}}
+

.gitignore

@@ -4,6 +4,8 @@
 ### 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,299 @@
-###
-### 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 "0")
+SET(CALYP_VERSION_PATCH "1")
+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 Google Tests" OFF)
+OPTION(BUILD_TESTS_CATCH2 "Build Catch2 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)
 
-
-######################################################################################
+# ####################################################################################################################################################
 # 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
-######################################################################################
+# ####################################################################################################################################################
 
-IF( BUILD_DOC )
+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
+)
 
+IF(BUILD_TESTS)
+  INCLUDE(FetchContent)
+  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_MAKEAVAILABLE(googletest)
 
-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(
+    googletest PROPERTIES
+    URL "https://github.com/google/googletest"
+    DESCRIPTION "Google unit tests"
+    TYPE OPTIONAL
+  )
+  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 )
+IF(BUILD_TESTS_CATCH2)
+  INCLUDE(FetchContent)
+  FETCHCONTENT_DECLARE(
+    Catch2
+    GIT_REPOSITORY https://github.com/catchorg/Catch2.git
+    GIT_TAG v2.13.1
+  )
+  FETCHCONTENT_MAKEAVAILABLE(Catch2)
+  SET_PACKAGE_PROPERTIES(
+    Catch2 PROPERTIES
+    URL "https://github.com/catchorg/Catch2"
+    DESCRIPTION "Catch2 unit tests"
+    TYPE OPTIONAL
+  )
+  INCLUDE(${CMAKE_CURRENT_BINARY_DIR}/_deps/catch2-src/contrib/Catch.cmake)
+  ENABLE_TESTING()
+ENDIF()
 
-  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 )
+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()
+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()
+SET(CMAKE_CXX_STANDARD 20)
+ADD_DEFINITIONS(-std=gnu++2a)
 
-IF (NOT CMAKE_BUILD_TYPE )
-    MESSAGE(STATUS "No build type selected, default to Release")
-    SET(CMAKE_BUILD_TYPE "Release")
+IF(NOT CMAKE_BUILD_TYPE)
+  MESSAGE(STATUS "No build type selected, default to Release")
+  SET(CMAKE_BUILD_TYPE "Release")
 ENDIF()
 
-SET( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall" )
+SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -funroll-loops")
 
-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
-               )
+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" 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(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()
 
-SET( CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -g -O0" )
-SET( CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O2" )
+IF(USE_WERROR)
+  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror")
+ENDIF()
 
+SET(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -g -O0")
+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()
 
-######################################################################################
+# ####################################################################################################################################################
 # 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)
+ADD_SUBDIRECTORY(modules)
 
-IF( ${BUILD_TOOLS} )
-  ADD_SUBDIRECTORY( tools )
+IF(${BUILD_TOOLS})
+  ADD_SUBDIRECTORY(tools)
 ENDIF()
 
-IF( ${BUILD_APP} )
-  ADD_SUBDIRECTORY( app )
+IF(${BUILD_APP})
+  ADD_SUBDIRECTORY(app)
 ENDIF()
 
-IF( ${BUILD_EXAMPLES} )
-  ADD_SUBDIRECTORY( examples )
+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,9 @@
 
 ## 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!
+![Build Action](https://github.com/pixlra/calyp/actions/workflows/build.yml/badge.svg?branch=master) [![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) 
 
 
 ## Features
@@ -20,7 +20,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 +30,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 +73,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,167 @@
-###
-### 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}/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
+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
     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}
+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}
+    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()
-
-
-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 )
+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,31 +24,56 @@
 
 #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 "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();
+  }
+  if( m_pcDisplaySubWindow )
+  {
+    auto* ptr = m_pcDisplaySubWindow;
+    m_pcDisplaySubWindow = NULL;
+    ptr->closeSubWindow();
+  }
+  if( m_pcDockWidget )
+  {
+    m_pcDockWidget->close();
+  }
+  if( m_pcModule )
+  {
+    m_pcModule->destroy();
+    m_pcModule = nullptr;
   }
 }
 
-void CalypAppModuleIf::update()
+void CalypAppModuleIf::update( bool isPlaying )
 {
   if( m_pcDisplaySubWindow )
   {
@@ -56,7 +81,15 @@ void CalypAppModuleIf::update()
   }
   else
   {
-    apply();
+    apply( isPlaying );
+  }
+}
+
+void CalypAppModuleIf::setPlaying( bool isPlaying )
+{
+  if( m_pcDisplaySubWindow )
+  {
+    m_pcDisplaySubWindow->setPlaying( isPlaying );
   }
 }
 
@@ -69,11 +102,19 @@ 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 );
+  bool moduleExecuted = false;
   if( m_pcModule->m_iModuleType == CLP_FRAME_PROCESSING_MODULE )
   {
     if( m_pcDisplaySubWindow )
@@ -87,6 +128,17 @@ bool CalypAppModuleIf::apply( bool isPlaying, bool disableThreads )
   }
   if( !( isPlaying && ( m_pcModule->m_uiModuleRequirements & CLP_MODULE_REQUIRES_SKIP_WHILE_PLAY ) ) )
   {
+    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 +148,52 @@ 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 )
   {
+    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 )
   {
     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 +202,54 @@ 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()
 {
   switch( m_pcModule->m_iModuleType )
   {
-  case CLP_FRAME_PROCESSING_MODULE:
-    if( m_pcDisplaySubWindow )
+  case CLP_FRAME_PROCESSING_MODULE: {
+    auto displayWindow = 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();
+      m_pcDisplaySubWindow->setCurrFrame( m_pcProcessedFrame );
+      m_Mutex.unlock();
     }
+#endif
+    m_pcDisplaySubWindow->setFillWindow( false );
+    m_pcDisplaySubWindow->setCurrFrame( m_pcProcessedFrame );
     break;
+  }
   case CLP_FRAME_MEASUREMENT_MODULE:
-    m_pcModuleDock->setModulueReturnValue( m_dMeasurementResult );
+    m_pcModuleDock->setModuleReturnValue( m_dMeasurementResult );
     break;
   }
 }
 
-void CalypAppModuleIf::destroy()
+void CalypAppModuleIf::disable()
 {
-  if( m_bIsRunning )
+  QApplication::setOverrideCursor( Qt::WaitCursor );
+#ifdef CALYP_THREADED_MODULES
+  QMutexLocker locker( &m_Mutex );
+  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,101 @@
 #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;
+class CalypStream;
+class CalypFrame;
 
 #define CLP_MODULE_MAX_NUM_FRAMES 5
 
 class VideoSubWindow;
 
-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; }
+  auto getSubWindowList() -> const std::vector<VideoSubWindow*>& { return m_pcSubWindow; }
+
+  CalypModuleIf* getModule() { return m_pcModule.get(); }
   unsigned int getModuleRequirements() { return m_pcModule->m_uiModuleRequirements; }
   ClpString moduleInfo() { return m_pcModule->moduleInfo(); }
-  void update();
+  void update( bool isPlaying );
   bool apply( bool isPlaying = false, bool disableThreads = false );
+  bool process();
+  void setPlaying( bool isPlaying );
   bool isRunning();
   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
+  VideoSubWindow* 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;
+#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 );
@@ -80,11 +83,11 @@ MainWindow::MainWindow()
   setAcceptDrops( true );
   setBackgroundRole( QPalette::Background );
 
-  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::update );
+  connect( m_pcWindowHandle, &SubWindowHandle::changed, this, &MainWindow::update, Qt::QueuedConnection );
+  connect( m_appModuleVideo, &VideoHandle::changed, this, &MainWindow::update, Qt::QueuedConnection );
+  connect( m_appModuleQuality, &QualityHandle::changed, this, &MainWindow::update, Qt::QueuedConnection );
+  connect( m_appModuleExtensions, &ModulesHandle::changed, this, &MainWindow::update, Qt::QueuedConnection );
 }
 
 bool MainWindow::parseArgs( int argc, char* argv[] )
@@ -101,7 +104,7 @@ bool MainWindow::parseArgs( int argc, char* argv[] )
       ( "size,s", strResolution, "size (WxH)" ) /**/
       ( "pel_fmt", strPelFmt, "pixel format" );
 
-  if( !pcCmdParser.parse( argc, argv ) )
+  if( pcCmdParser.parse( argc, argv ) < 0 )
   {
     bRet |= true;
   }
@@ -196,6 +199,8 @@ void MainWindow::loadFile( QString fileName, CalypFileInfo* pStreamInfo )
     return;
   }
   videoSubWindow = new VideoSubWindow( VideoSubWindow::VIDEO_STREAM_SUBWINDOW );  // createSubWindow();
+  videoSubWindow->setResourceManaget( m_appResourceHandle.get() );
+
   if( !pStreamInfo )
   {
     int idx = findCalypStreamInfo( m_aRecentFileStreamInfo, fileName );

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,17 @@
 #ifndef __MAINWINDOW_H__
 #define __MAINWINDOW_H__
 
+#include <QMainWindow>
+#include <QString>
+#include <QVector>
+
 #include "CommonDefs.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;
@@ -158,6 +159,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,10 +24,10 @@
 
 #include "MdiSubWindow.h"
 
-#include "SubWindowAbstract.h"
-
 #include <QCloseEvent>
 
+#include "SubWindowAbstract.h"
+
 MdiSubWindow::MdiSubWindow( QWidget* parent )
     : QMdiSubWindow( parent )
 {

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/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
@@ -91,7 +91,6 @@ QMenu* ModulesHandle::createMenu()
 
 void ModulesHandle::buildMenu()
 {
-  CalypModuleIf* pcCurrModuleIf;
   QString ModuleIfinternalName;
   QAction* currAction;
   QMenu* currSubMenu;
@@ -108,7 +107,7 @@ void ModulesHandle::buildMenu()
   CalypModulesFactoryMap::iterator it = moduleFactoryMap.begin();
   for( ; it != moduleFactoryMap.end(); ++it )
   {
-    pcCurrModuleIf = it->second();
+    auto pcCurrModuleIf = it->second();
     ModuleIfinternalName = QString::fromLocal8Bit( it->first );
 
     currSubMenu = NULL;
@@ -147,8 +146,6 @@ void ModulesHandle::buildMenu()
       currSubMenu->addAction( currAction );
     else
       m_pcModulesMenu->addAction( currAction );
-
-    pcCurrModuleIf->Delete();
   }
 
   m_pcModulesMenu->addAction( m_arrayActions[LOAD_EXTERNAL_ACT] );
@@ -183,11 +180,11 @@ 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();
+    auto apcCurrentModule = pcSubWindow->getModuleArray();
     m_arrayActions[DISABLE_ACT]->setEnabled( apcCurrentModule.size() > 0 );
     if( pcSubWindow->getDisplayModule() )
     {
@@ -278,9 +275,8 @@ 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() );
+  auto pcCurrAppModuleIf = std::make_shared<CalypAppModuleIf>( this, pcAction, std::move( pcCurrModuleIf ) );
 
   QList<VideoSubWindow*> videoSubWindowList;
   int numberOfFrames = pcCurrAppModuleIf->m_pcModule->m_uiNumberOfFrames;
@@ -337,7 +333,7 @@ void ModulesHandle::activateModule()
         {
           videoSubWindowList.clear();
           qobject_cast<MainWindow*>( m_pcParent )->printMessage( "Error! Incompatible frames", CLP_LOG_ERROR );
-          destroyModuleIf( pcCurrAppModuleIf );
+          //destroyModuleIf( pcCurrAppModuleIf );
           return;
         }
       }
@@ -352,7 +348,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;
   }
 
@@ -363,11 +359,11 @@ void ModulesHandle::activateModule()
 
   if( pcCurrAppModuleIf->m_pcModule->m_uiModuleRequirements & CLP_MODULE_REQUIRES_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;
     }
   }
@@ -381,7 +377,7 @@ void ModulesHandle::activateModule()
   {
     if( ( pcCurrAppModuleIf->m_pcModule->m_uiModuleRequirements & CLP_MODULE_REQUIRES_NEW_WINDOW ) || bShowModulesNewWindow )
     {
-      pcModuleSubWindow = new VideoSubWindow( VideoSubWindow::MODULE_SUBWINDOW );
+      pcModuleSubWindow = new VideoSubWindow( VideoSubWindow::MODULE_SUBWINDOW, pcCurrAppModuleIf.get() );
       windowName.append( QStringLiteral( "Module " ) );
       windowName.append( pcCurrAppModuleIf->m_pcModule->m_pchModuleLongName );
       pcCurrAppModuleIf->m_pcDisplaySubWindow = pcModuleSubWindow;
@@ -392,11 +388,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 )
   {
     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" );
@@ -408,19 +408,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
@@ -443,11 +433,12 @@ 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 )
@@ -465,44 +456,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() );
   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 )
@@ -552,12 +538,11 @@ void ModulesHandle::applyAllModuleIf( CalypAppModuleIf* pcCurrModuleIf )
       BitsPixel = pcCurrModuleIf->m_pcProcessedFrame->getBitsPel();
       FrameRate = pcCurrModuleIf->m_pcSubWindow[0]->getInputStream()->getFrameRate();
 
-      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 ) )
       {
-        delete pcCurrModuleIf->m_pcModuleStream;
-        pcCurrModuleIf->m_pcModuleStream = NULL;
+        pcCurrModuleIf->m_pcModuleStream = nullptr;
         return;
       }
     }
@@ -579,7 +564,7 @@ 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();
@@ -609,12 +594,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;
@@ -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,6 +24,10 @@
 
 #include "PlotSubWindow.h"
 
+#include <QGuiApplication>
+#include <QScreen>
+#include <QSize>
+
 #include "qcustomplot.h"
 //#include "external/qcustomplot/qcustomplot.h"
 
@@ -174,7 +178,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,16 +24,16 @@
 
 #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 )
 {

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
@@ -27,6 +27,7 @@
 
 #include <QtCore>
 #include <QtWidgets>
+
 #include "CommonDefs.h"
 #include "QFuture"
 #include "QualityMeasurementSidebar.h"

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,14 @@
 
 #include "SubWindowAbstract.h"
 
-#include "MdiSubWindow.h"
-
 #include <QCloseEvent>
 #include <QFocusEvent>
 #include <QHBoxLayout>
 #include <QIcon>
 #include <QScrollBar>
 
+#include "MdiSubWindow.h"
+
 SubWindowAbstract::SubWindowAbstract( QWidget* parent, unsigned int category )
     : QWidget( parent ), m_cSubWindow( NULL )
 {

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"
 

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,22 +25,24 @@
 
 #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:
@@ -154,7 +156,7 @@ void SubWindowHandle::setWindowMode( int iWindowMode )
     parentWidget()->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() );
@@ -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();
   }
@@ -378,7 +395,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 )
     {

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;
@@ -51,7 +51,7 @@ public:
 
   void processLogMsg( const QString& msg );
 
-  void addSubWindow( SubWindowAbstract* widget, Qt::WindowFlags flags = 0 );
+  void addSubWindow( SubWindowAbstract* widget );
 
   SubWindowAbstract* activeSubWindow() const;
 

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,6 +24,16 @@
 
 #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"
@@ -32,29 +42,20 @@
 #include "SubWindowSelectorDialog.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
-
 VideoHandle::VideoHandle( QWidget* parent, SubWindowHandle* windowManager )
     : m_pcParet( 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()
 {
@@ -240,6 +241,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 +259,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 );
@@ -317,11 +325,8 @@ void VideoHandle::update()
 {
   if( m_pcCurrentVideoSubWindow )
   {
-    CalypStream* pcStream = m_pcCurrentVideoSubWindow->getInputStream();
-    CalypFrame* pcFrame = m_pcCurrentVideoSubWindow->getCurrFrame();
-
-    unsigned long frame_num = 0;
-    unsigned long total_frame_num = 1;
+    const CalypStream* pcStream = m_pcCurrentVideoSubWindow->getInputStream();
+    const CalypFrame* pcFrame = m_pcCurrentVideoSubWindow->getCurrFrame();
 
     m_pcVideoFormatLabel->setText( m_pcCurrentVideoSubWindow->getStreamInformation() );
 
@@ -331,6 +336,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 +362,7 @@ void VideoHandle::update()
       }
     }
     m_pcResolutionLabel->setText( resolution );
-
-    m_pcFramePropertiesSideBar->setFrame( pcFrame );
+    m_pcFramePropertiesSideBar->setFrame( m_pcCurrentVideoSubWindow->getCurrFrameAsset(), m_pcCurrentVideoSubWindow->isPlaying() );
 
     m_pcFrameNumInfo->setTotalFrameNum( total_frame_num );
     m_pcFrameNumInfo->setCurrFrameNum( frame_num );
@@ -366,6 +372,11 @@ 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" );
@@ -379,6 +390,7 @@ void VideoHandle::update()
   }
   else
   {
+    m_pcPlayingFPSLabel->setText( "" );
     m_pcVideoFormatLabel->setText( "" );
     m_pcResolutionLabel->setText( "" );
     m_pcFramePropertiesSideBar->reset();
@@ -426,13 +438,17 @@ void VideoHandle::closeSubWindow( SubWindowAbstract* subWindow )
   if( m_acPlayingSubWindows.contains( videoSubWindow ) )
   {
     int pos = m_acPlayingSubWindows.indexOf( videoSubWindow );
-    m_acPlayingSubWindows.at( pos )->stop();
+    // m_acPlayingSubWindows.at( pos )->stop();
     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 )
@@ -559,30 +575,25 @@ 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 )
@@ -593,8 +604,6 @@ void VideoHandle::play()
 
   if( !m_pcCurrentVideoSubWindow->isPlaying() )  // Not playing
   {
-    double frameRate;
-    unsigned int timeinterval;
     if( m_acPlayingSubWindows.size() < 2 )
     {
       for( int i = 0; i < m_acPlayingSubWindows.size(); i++ )
@@ -610,9 +619,7 @@ void VideoHandle::play()
       {
         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
@@ -638,9 +645,9 @@ 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,28 +663,50 @@ 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 )
@@ -690,7 +719,13 @@ void VideoHandle::playEvent()
     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 )
@@ -702,9 +737,9 @@ void VideoHandle::seekEvent( int direction )
       if( !( (unsigned int)( m_pcCurrentVideoSubWindow->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 );
         }
       }
     }
@@ -713,7 +748,6 @@ void VideoHandle::seekEvent( int direction )
       m_pcCurrentVideoSubWindow->seekRelativeEvent( direction > 0 ? true : false );
     }
     emit changed();
-    // update();
   }
 }
 
@@ -730,9 +764,9 @@ void VideoHandle::seekVideo()
       {
         if( m_acPlayingSubWindows.contains( m_pcCurrentVideoSubWindow ) )
         {
-          for( int i = 0; i < m_acPlayingSubWindows.size(); i++ )
+          for( auto playingSubWindow : m_acPlayingSubWindows )
           {
-            m_acPlayingSubWindows.at( i )->seekAbsoluteEvent( (unsigned int)newFrameNum );
+            playingSubWindow->seekAbsoluteEvent( (unsigned int)newFrameNum );
           }
         }
         else
@@ -751,9 +785,9 @@ void VideoHandle::seekSliderEvent( int new_frame_num )
   {
     if( m_acPlayingSubWindows.contains( m_pcCurrentVideoSubWindow ) )
     {
-      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
@@ -773,9 +807,9 @@ void VideoHandle::videoSelectionButtonEvent()
   {
     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 ) );
+      videoSubWindow = qobject_cast<VideoSubWindow*>( subWindow );
       m_acPlayingSubWindows.append( videoSubWindow );
     }
   }
@@ -784,18 +818,18 @@ void VideoHandle::videoSelectionButtonEvent()
     SubWindowSelectorDialog dialogWindowsSelection( m_pcParet, 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 ) );
+        videoSubWindow = qobject_cast<VideoSubWindow*>( window );
         m_acPlayingSubWindows.append( videoSubWindow );
       }
     }
@@ -807,7 +841,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 );

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,28 @@
 #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 "config.h"
 
 class QToolBar;
 class QDockWidget;
 class QSignalMapper;
 class QLabel;
 class QSlider;
-class QElapsedTimer;
 
 class SubWindowHandle;
 class SubWindowAbstract;
 class VideoSubWindow;
 class FramePropertiesDock;
 class FrameNumberWidget;
+class QTimer;
 
 class VideoHandle : public QObject
 {
@@ -113,6 +112,7 @@ private:
   QDockWidget* m_pcFramePropertiesDock;
   FramePropertiesDock* m_pcFramePropertiesSideBar;
 
+  QLabel* m_pcPlayingFPSLabel;
   QLabel* m_pcVideoFormatLabel;
   QLabel* m_pcResolutionLabel;
 
@@ -122,12 +122,12 @@ private:
   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();
 
@@ -140,8 +140,10 @@ 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 );

app/VideoSubWindow.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,15 +23,18 @@
  */
 
 #include "VideoSubWindow.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"
 
-#include <cassert>
-
 #define QT_NO_CONCURRENT
 
 /**
@@ -54,7 +57,7 @@ QDataStream& operator<<( QDataStream& out, const CalypFileInfoVector& array )
 QDataStream& operator>>( QDataStream& in, CalypFileInfoVector& array )
 {
   CalypFileInfo d;
-  int array_size;
+  int array_size{ 0 };
   in >> array_size;
   for( int i = 0; i < array_size; i++ )
   {
@@ -87,6 +90,7 @@ int findCalypStreamInfo( CalypFileInfoVector array, QString filename )
 class VideoInformation : public QWidget
 {
 private:
+  QTimer* m_pcRefreshTimer;
   QList<QStaticText> m_cTopLeftTextList;
   QFont m_cTopLeftTextFont;
   QFont m_cCenterTextFont;
@@ -100,6 +104,8 @@ public:
     setAttribute( Qt::WA_TransparentForMouseEvents );
     m_cTopLeftTextFont.setPointSize( 8 );
     m_cCenterTextFont.setPointSize( 12 );
+    m_pcRefreshTimer = new QTimer;
+    m_pcRefreshTimer->setSingleShot( true );
   }
   void setInformationTopLeft( const QStringList& textLines )
   {
@@ -109,7 +115,12 @@ public:
       m_cTopLeftTextList.append( QStaticText( textLines.at( i ) ) );
     }
   }
-  void setBusyWindow( bool bFlag ) { m_bBusyWindow = bFlag; }
+  void setBusyWindow( bool bFlag )
+  {
+    m_bBusyWindow = bFlag;
+    // Do not show the refresh screen if it takes less than 500 ms
+    m_pcRefreshTimer->start( 500 );
+  }
 
 protected:
   void paintEvent( QPaintEvent* event )
@@ -125,7 +136,7 @@ protected:
         topLeftCorner += QPoint( 0, 15 );
       }
     }
-    if( m_bBusyWindow )
+    if( m_bBusyWindow && !m_pcRefreshTimer->isActive() )
     {
       painter.setFont( m_cCenterTextFont );
       painter.drawText( rect(), Qt::AlignHCenter | Qt::AlignVCenter, QStringLiteral( "Refreshing..." ) );
@@ -136,10 +147,9 @@ protected:
 
 VideoSubWindow::VideoSubWindow( enum VideoSubWindowCategories category, QWidget* parent )
     : SubWindowAbstract( parent, SubWindowAbstract::VIDEO_SUBWINDOW | category )
+    , m_pcResourceManager( nullptr )
     , m_bWindowBusy( false )
     , m_pCurrStream( NULL )
-    , m_pcCurrFrame( NULL )
-    , m_pcCurrentDisplayModule( NULL )
     , m_pcReferenceSubWindow( NULL )
     , m_bIsPlaying( false )
     , m_pcUpdateTimer( NULL )
@@ -174,7 +184,7 @@ VideoSubWindow::VideoSubWindow( enum VideoSubWindowCategories category, QWidget*
   m_pcScrollArea->setWidgetResizable( true );
   setWidget( m_pcScrollArea );
 
-  m_apcCurrentModule.clear();
+  m_associatedModules.clear();
 
   m_pcUpdateTimer = new QTimer();
   m_pcUpdateTimer->setInterval( 800 );
@@ -184,14 +194,18 @@ VideoSubWindow::VideoSubWindow( enum VideoSubWindowCategories category, QWidget*
   m_pcVideoInfo = new VideoInformation( this );
 }
 
+VideoSubWindow::VideoSubWindow( enum VideoSubWindowCategories category, CalypAppModuleIf* displayModule, QWidget* parent )
+    : VideoSubWindow( category, parent )
+{
+  m_pcCurrentDisplayModule = displayModule;
+}
+
 VideoSubWindow::~VideoSubWindow()
 {
-  m_pcCurrFrame = NULL;
-  disableModule();
-  delete m_cViewArea;
+  m_pcCurrFrameAsset = nullptr;
+  if( m_pcResourceManager )
+    m_pcResourceManager->removeResource( m_uiResourceId );
   delete m_pcUpdateTimer;
-  if( m_pCurrStream )
-    delete m_pCurrStream;
 }
 
 /**
@@ -200,7 +214,19 @@ VideoSubWindow::~VideoSubWindow()
 
 void VideoSubWindow::closeEvent( QCloseEvent* event )
 {
-  stop();
+  //stop();
+  auto tmpModules = m_associatedModules;
+  m_associatedModules.clear();
+  for( auto module : tmpModules )
+  {
+    module->disable();
+  }
+  if( m_pcCurrentDisplayModule )
+  {
+    m_pcCurrentDisplayModule->disable();
+    event->ignore();
+    return;
+  }
   SubWindowAbstract::closeEvent( event );
 }
 
@@ -257,7 +283,7 @@ QSize VideoSubWindow::sizeHint() const
   }
   else
   {
-    maxSize = QApplication::desktop()->availableGeometry().size();
+    maxSize = QGuiApplication::screens()[0]->availableGeometry().size();
   }
   return sizeHint( maxSize );
 }
@@ -265,8 +291,8 @@ QSize VideoSubWindow::sizeHint() const
 QSize VideoSubWindow::sizeHint( const QSize& maxSize ) const
 {
   QSize isize;
-  if( m_pcCurrFrame )
-    isize = QSize( m_pcCurrFrame->getWidth() + 50, m_pcCurrFrame->getHeight() + 50 );
+  if( m_pcCurrFrameAsset )
+    isize = QSize( m_pcCurrFrameAsset->getWidth() + 50, m_pcCurrFrameAsset->getHeight() + 50 );
   else if( m_pCurrStream )
     isize = QSize( m_pCurrStream->getWidth() + 50, m_pCurrStream->getHeight() + 50 );
 
@@ -296,12 +322,17 @@ void VideoSubWindow::refreshSubWindow()
 {
   if( getCategory() & SubWindowAbstract::VIDEO_STREAM_SUBWINDOW )
   {
+#ifdef CALYP_MANAGED_RESOURCES
+    m_pcResourceManager->stopResourceWorker( m_uiResourceId );
+#endif
     if( !m_pCurrStream->reload() )
     {
       close();
       return;
     }
-    // seekAbsoluteEvent( currFrameNum );
+#ifdef CALYP_MANAGED_RESOURCES
+    m_pcResourceManager->startResourceWorker( m_uiResourceId );
+#endif
   }
   updateVideoWindowInfo();
   refreshFrame();
@@ -309,21 +340,33 @@ void VideoSubWindow::refreshSubWindow()
 
 bool VideoSubWindow::loadFile( QString cFilename, bool bForceDialog )
 {
+  assert( m_pcResourceManager != nullptr );
+
   ConfigureFormatDialog formatDialog( this );
   unsigned int Width = 0, Height = 0, BitsPel = 8, FrameRate = 30;
   int Endianness = CLP_LITTLE_ENDIAN;
   int InputFormat = CLP_YUV420P;
+  QSettings appSettings;
 
   if( m_pCurrStream )
     m_pCurrStream->getFormat( Width, Height, InputFormat, BitsPel, Endianness, FrameRate );
+  else
+    m_uiResourceId = m_pcResourceManager->getResource( nullptr );
+
+  m_pCurrStream = m_pcResourceManager->getResourceAsset( m_uiResourceId );
 
-  if( !m_pCurrStream )
-  {
-    m_pCurrStream = new CalypStream;
-  }
   bool bConfig = true;
   if( !bForceDialog )
+  {
     bConfig = guessFormat( cFilename, Width, Height, InputFormat, BitsPel, Endianness, FrameRate );
+    if( bConfig )
+    {
+      // Pre-load values with last opened file
+      Width = appSettings.value( "VideoSubWindow/LastWidth" ).value<unsigned int>();
+      Height = appSettings.value( "VideoSubWindow/LastHeight" ).value<unsigned int>();
+      BitsPel = appSettings.value( "VideoSubWindow/LastBitsPerPixel" ).value<unsigned int>();
+    }
+  }
   bool bRet = false;
   for( int iPass = 0; iPass < 2 && !bRet; iPass++ )
   {
@@ -355,6 +398,18 @@ bool VideoSubWindow::loadFile( QString cFilename, bool bForceDialog )
   m_sStreamInfo.m_uiFrameRate = FrameRate;
   m_sStreamInfo.m_uiFileSize = QFileInfo( cFilename ).size();
 
+  QVariant var;
+  var.setValue<unsigned int>( Width );
+  appSettings.setValue( "VideoSubWindow/LastWidth", var );
+  var.setValue<unsigned int>( Height );
+  appSettings.setValue( "VideoSubWindow/LastHeight", var );
+  var.setValue<unsigned int>( BitsPel );
+  appSettings.setValue( "VideoSubWindow/LastBitsPerPixel", var );
+
+#ifdef CALYP_MANAGED_RESOURCES
+  m_pcResourceManager->startResourceWorker( m_uiResourceId );
+#endif
+
   QApplication::restoreOverrideCursor();
 
   refreshFrame();
@@ -363,15 +418,16 @@ bool VideoSubWindow::loadFile( QString cFilename, bool bForceDialog )
 
   updateVideoWindowInfo();
   setWindowName( QFileInfo( m_cFilename ).fileName() );
+
   return true;
 }
 
 bool VideoSubWindow::loadFile( CalypFileInfo* streamInfo )
 {
-  if( !m_pCurrStream )
-  {
-    m_pCurrStream = new CalypStream;
-  }
+  assert( m_pcResourceManager != nullptr );
+
+  m_uiResourceId = m_pcResourceManager->getResource( m_pCurrStream );
+  m_pCurrStream = m_pcResourceManager->getResourceAsset( m_uiResourceId );
 
   if( !m_pCurrStream->open( streamInfo->m_cFilename.toStdString(), streamInfo->m_uiWidth, streamInfo->m_uiHeight,
                             streamInfo->m_iPelFormat, streamInfo->m_uiBitsPelPixel, streamInfo->m_iEndianness,
@@ -382,6 +438,10 @@ bool VideoSubWindow::loadFile( CalypFileInfo* streamInfo )
 
   m_sStreamInfo = *streamInfo;
 
+#ifdef CALYP_MANAGED_RESOURCES
+  m_pcResourceManager->startResourceWorker( m_uiResourceId );
+#endif
+
   QApplication::restoreOverrideCursor();
 
   refreshFrame();
@@ -398,15 +458,15 @@ void VideoSubWindow::updateVideoWindowInfo()
   if( m_pcCurrentDisplayModule )
   {
     m_cStreamInformation = "Module";
-    QList<VideoSubWindow*> arraySubWindows = m_pcCurrentDisplayModule->getSubWindowList();
+    const auto& arraySubWindows = m_pcCurrentDisplayModule->getSubWindowList();
     QStringList windowInfoList;
     if( arraySubWindows.size() > 0 )
     {
-      for( int i = 0; i < arraySubWindows.size(); i++ )
+      for( std::size_t i = 0; i < arraySubWindows.size(); i++ )
       {
-        if( arraySubWindows.at( i )->getWindowName() != getWindowName() )
+        if( arraySubWindows[i]->getWindowName() != getWindowName() )
         {
-          windowInfoList.append( QString( "Input %1 - " + arraySubWindows.at( i )->getWindowName() ).arg( i + 1 ) );
+          windowInfoList.append( QString( "Input %1 - " + arraySubWindows[i]->getWindowName() ).arg( i + 1 ) );
         }
       }
     }
@@ -415,7 +475,6 @@ void VideoSubWindow::updateVideoWindowInfo()
       QStringList list = QString::fromStdString( m_pcCurrentDisplayModule->moduleInfo() ).split( '\n' );
       windowInfoList.append( list );
     }
-    // qDebug( ) << sourceWindowList;
     if( windowInfoList.size() > 0 )
     {
       m_pcVideoInfo->setInformationTopLeft( windowInfoList );
@@ -427,16 +486,14 @@ void VideoSubWindow::updateVideoWindowInfo()
     QString m_cCodedName = QString::fromStdString( m_pCurrStream->getCodecName() );
     m_cStreamInformation = m_cFormatName + " | " + m_cCodedName;
   }
-  //#if 0
-  if( m_pcCurrFrame )
+  if( m_pcCurrFrameAsset )
   {
-    QString m_cPelFmtName = QString::fromStdString( m_pcCurrFrame->getPelFmtName() );
+    QString m_cPelFmtName = QString::fromStdString( m_pcCurrFrameAsset->getPelFmtName() );
     if( m_pCurrStream )
       if( !m_pCurrStream->isNative() )
         m_cPelFmtName += "*";
     m_cStreamInformation += " | " + m_cPelFmtName;
   }
-  //#endif
   if( m_cStreamInformation.isEmpty() )
   {
     m_cStreamInformation = "          ";
@@ -604,78 +661,127 @@ void VideoSubWindow::updateSelectedArea( QRect area )
  * Functions to enable a module in the
  * current SubWindow
  */
-void VideoSubWindow::enableModule( CalypAppModuleIf* pcModule )
+// void VideoSubWindow::enableModule( std::shared_ptr<CalypAppModuleIf> pcModule )
+// {
+//   auto it = std::find_if( m_associatedModules.begin(), m_associatedModules.end(),
+//                           [&]( const auto& module ) { return module.get() == pcModule.get(); } );
+//   if( it != m_associatedModules.end() )
+//   {
+//     m_associatedModules.erase( it );
+//   }
+//   m_pcCurrentDisplayModule = std::move( pcModule );
+//   updateVideoWindowInfo();
+// }
+
+bool VideoSubWindow::hasAssociatedModule()
 {
-  if( m_pcCurrentDisplayModule )
+  if( m_pcCurrentDisplayModule == nullptr )
+    return !m_associatedModules.empty();
+  return m_associatedModules.size() > 1;
+}
+
+void VideoSubWindow::setDisplayModule( CalypAppModuleIf* pcModule )
+{
+  if( m_pcCurrentDisplayModule != nullptr )
   {
-    disableModule( m_pcCurrentDisplayModule );
+    m_pcCurrentDisplayModule->disable();
   }
   m_pcCurrentDisplayModule = pcModule;
   updateVideoWindowInfo();
 }
 
+void VideoSubWindow::associateModule( std::shared_ptr<CalypAppModuleIf> pcModule )
+{
+  auto it = std::find_if( m_associatedModules.begin(), m_associatedModules.end(),
+                          [&]( const auto& module ) { return module.get() == pcModule.get(); } );
+  if( it == m_associatedModules.end() )
+  {
+    m_associatedModules.push_back( std::move( pcModule ) );
+  }
+}
+
 void VideoSubWindow::disableModule( CalypAppModuleIf* pcModule )
 {
+  if( pcModule == nullptr )
+    return;
   bool bRefresh = false;
-  if( pcModule )
+
+  auto it = std::find_if( m_associatedModules.begin(), m_associatedModules.end(),
+                          [&]( const auto& module ) { return module.get() == pcModule; } );
+  if( it != m_associatedModules.end() )
   {
-    int modIdx = m_apcCurrentModule.indexOf( pcModule );
-    if( modIdx != -1 )
-    {
-      m_apcCurrentModule.removeAt( modIdx );
-      ModulesHandle::destroyModuleIf( pcModule );
-      bRefresh |= true;
-    }
-    if( pcModule == m_pcCurrentDisplayModule )
-    {
-      pcModule = m_pcCurrentDisplayModule;
-      m_pcCurrentDisplayModule = 0;
-      ModulesHandle::destroyModuleIf( pcModule );
-      setWindowName( QFileInfo( m_cFilename ).fileName() );
-      bRefresh |= true;
-    }
+    m_associatedModules.erase( it );
   }
-  else
+  if( pcModule == m_pcCurrentDisplayModule )
   {
-    QList<CalypAppModuleIf*> apcCurrentModule = m_apcCurrentModule;
-    for( int i = 0; i < apcCurrentModule.size(); i++ )
-    {
-      m_apcCurrentModule.removeOne( apcCurrentModule.at( i ) );
-      ModulesHandle::destroyModuleIf( apcCurrentModule.at( i ) );
-      bRefresh |= true;
-    }
-    assert( m_apcCurrentModule.size() == 0 );
-    if( m_pcCurrentDisplayModule )
-    {
-      pcModule = m_pcCurrentDisplayModule;
-      m_pcCurrentDisplayModule = NULL;
-      ModulesHandle::destroyModuleIf( pcModule );
-      setWindowName( QFileInfo( m_cFilename ).fileName() );
-      bRefresh |= true;
-    }
+    bRefresh |= true;
+    m_pcCurrentDisplayModule = nullptr;
+    setWindowName( QFileInfo( m_cFilename ).fileName() );
   }
   if( bRefresh )
   {
     refreshFrame();
     updateVideoWindowInfo();
   }
+  // if( pcModule )
+  // {
+  //   int modIdx = m_apcCurrentModule.indexOf( pcModule );
+  //   if( modIdx != -1 )
+  //   {
+  //     m_apcCurrentModule.removeAt( modIdx );
+  //     ModulesHandle::destroyModuleIf( pcModule );
+  //     bRefresh |= true;
+  //   }
+  //   if( pcModule == m_pcCurrentDisplayModule )
+  //   {
+  //     pcModule = m_pcCurrentDisplayModule;
+  //     m_pcCurrentDisplayModule = 0;
+  //     ModulesHandle::destroyModuleIf( pcModule );
+  //     setWindowName( QFileInfo( m_cFilename ).fileName() );
+  //     bRefresh |= true;
+  //   }
+  // }
+  // else
+  // {
+  //   QList<CalypAppModuleIf*> apcCurrentModule = m_apcCurrentModule;
+  //   for( int i = 0; i < apcCurrentModule.size(); i++ )
+  //   {
+  //     m_apcCurrentModule.removeOne( apcCurrentModule.at( i ) );
+  //     ModulesHandle::destroyModuleIf( apcCurrentModule.at( i ) );
+  //     bRefresh |= true;
+  //   }
+  //   assert( m_apcCurrentModule.size() == 0 );
+  //   if( m_pcCurrentDisplayModule )
+  //   {
+  //     pcModule = m_pcCurrentDisplayModule;
+  //     m_pcCurrentDisplayModule = NULL;
+  //     ModulesHandle::destroyModuleIf( pcModule );
+  //     setWindowName( QFileInfo( m_cFilename ).fileName() );
+  //     bRefresh |= true;
+  //   }
+  // }
 }
 
-void VideoSubWindow::associateModule( CalypAppModuleIf* pcModule )
+bool VideoSubWindow::disableAllModules()
 {
-  m_apcCurrentModule.append( pcModule );
+  if( m_associatedModules.empty() )
+    return false;
+  // For loop is required as we will invalidate the iterator
+  while( m_associatedModules.size() > 0 )
+  {
+    auto module = m_associatedModules.back();
+    module->disable();
+    m_associatedModules.pop_back();
+  }
+  return true;
 }
 
 bool VideoSubWindow::hasRunningModule()
 {
   bool bRet = false;
-  if( m_pcCurrentDisplayModule )
+  for( int i = 0; i < m_associatedModules.size() && !bRet; i++ )
   {
-    bRet |= m_pcCurrentDisplayModule->isRunning();
-  }
-  for( int i = 0; i < m_apcCurrentModule.size() && !bRet; i++ )
-  {
-    bRet |= m_apcCurrentModule.at( i )->isRunning();
+    bRet |= m_associatedModules.at( i )->isRunning();
   }
   return bRet;
 }
@@ -685,10 +791,24 @@ void VideoSubWindow::setFillWindow( bool bFlag )
   m_pcVideoInfo->setBusyWindow( bFlag );
 }
 
-void VideoSubWindow::setCurrFrame( CalypFrame* pcCurrFrame )
+std::shared_ptr<CalypFrame> VideoSubWindow::getCurrFrameAsset()
 {
-  m_pcCurrFrame = pcCurrFrame;
-  m_cViewArea->setImage( m_pcCurrFrame );
+  if( m_pcCurrFrameAsset == nullptr && m_pCurrStream != nullptr )
+  {
+    m_pcCurrFrameAsset = m_pCurrStream->getCurrFrameAsset();
+  }
+  return m_pcCurrFrameAsset;
+};
+
+void VideoSubWindow::setCurrFrame( std::shared_ptr<CalypFrame> pcCurrFrame )
+{
+  m_pcCurrFrameAsset = std::move( pcCurrFrame );
+  m_cViewArea->setImage( m_pcCurrFrameAsset );
+  for( auto& module : m_associatedModules )
+  {
+    if( module.get() != m_pcCurrentDisplayModule )
+      module->update( m_bIsPlaying );
+  }
 }
 
 void VideoSubWindow::refreshFrameOperation()
@@ -696,22 +816,25 @@ void VideoSubWindow::refreshFrameOperation()
   bool bSetFrame = false;
   if( m_pCurrStream )
   {
-    m_pcCurrFrame = m_pCurrStream->getCurrFrame();
-    bSetFrame = m_pcCurrFrame ? true : false;
+    m_pcCurrFrameAsset = m_pCurrStream->getCurrFrameAsset();
+    bSetFrame |= true;
   }
+
   if( m_pcCurrentDisplayModule )
   {
     m_bWindowBusy = true;
-    m_pcCurrentDisplayModule->apply( m_bIsPlaying, !m_bIsPlaying && m_apcCurrentModule.size() );
+    bool disableThreads = !m_bIsPlaying && hasAssociatedModule();
+    m_pcCurrentDisplayModule->apply( m_bIsPlaying, disableThreads );
     bSetFrame = false;
   }
   if( bSetFrame )
   {
-    m_cViewArea->setImage( m_pcCurrFrame );
-  }
-  for( int i = 0; i < m_apcCurrentModule.size(); i++ )
-  {
-    m_apcCurrentModule.at( i )->update();
+    m_cViewArea->setImage( m_pcCurrFrameAsset );
+    for( auto& module : m_associatedModules )
+    {
+      if( module.get() != m_pcCurrentDisplayModule )
+        module->update( m_bIsPlaying );
+    }
   }
 }
 
@@ -735,22 +858,32 @@ bool VideoSubWindow::goToNextFrame( bool bThreaded )
 #ifndef QT_NO_CONCURRENT
   m_cRefreshResult.waitForFinished();
   m_cReadResult.waitForFinished();
+#endif
+#ifdef CALYP_MANAGED_RESOURCES
+  while( !m_pCurrStream->hasNextFrame() && !m_pCurrStream->isEof() )
+    ;
 #endif
   bool bEndOfSeq = m_pCurrStream->setNextFrame();
+#ifdef CALYP_MANAGED_RESOURCES
+  bThreaded = false;
+  m_pcResourceManager->wakeResourceWorker( m_uiResourceId );
+#endif
   if( !bEndOfSeq )
   {
 #ifndef QT_NO_CONCURRENT
     m_cRefreshResult.waitForFinished();
     if( bThreaded )
     {
-      refreshFrame();
       m_cReadResult = QtConcurrent::run( m_pCurrStream, &CalypStream::readNextFrameFillRGBBuffer );
+      refreshFrame( bThreaded );
     }
     else
 #endif
     {
-      refreshFrame();
+      refreshFrame( bThreaded );
+#ifndef CALYP_MANAGED_RESOURCES
       m_pCurrStream->readNextFrameFillRGBBuffer();
+#endif
     }
   }
   return bEndOfSeq;
@@ -761,17 +894,17 @@ bool VideoSubWindow::save( QString filename )
   bool iRet = false;
   QApplication::setOverrideCursor( Qt::WaitCursor );
 
-  CalypFrame* saveFrame = m_pcCurrFrame;
+  CalypFrame* saveFrame = m_pcCurrFrameAsset.get();
   if( m_cSelectedArea.isValid() )
   {
-    saveFrame = new CalypFrame( m_pcCurrFrame, m_cSelectedArea.x(), m_cSelectedArea.y(), m_cSelectedArea.width(),
+    saveFrame = new CalypFrame( m_pcCurrFrameAsset.get(), m_cSelectedArea.x(), m_cSelectedArea.y(), m_cSelectedArea.width(),
                                 m_cSelectedArea.height() );
   }
   if( !saveFrame )
   {
     return false;
   }
-  iRet = CalypStream::saveFrame( filename.toStdString(), saveFrame );
+  iRet = CalypStream::saveFrame( filename.toStdString(), *saveFrame );
   QApplication::restoreOverrideCursor();
   return iRet;
 }
@@ -786,16 +919,37 @@ bool VideoSubWindow::saveStream( QString filename )
   return iRet;
 }
 
+void VideoSubWindow::setPlaying( bool isPlaying )
+{
+  m_bIsPlaying = isPlaying;
+  for( auto module : m_associatedModules )
+  {
+    module->setPlaying( isPlaying );
+  }
+}
+
+bool VideoSubWindow::isPlaying()
+{
+  if( getCategory() & SubWindowCategory::MODULE_SUBWINDOW )
+  {
+    for( auto window : m_pcCurrentDisplayModule->getSubWindowList() )
+    {
+      if( window->isPlaying() )
+        return true;
+    }
+    return false;
+  }
+  return m_bIsPlaying;
+}
+
 bool VideoSubWindow::play()
 {
+  bool isPlaying = false;
   if( m_pCurrStream && m_pCurrStream->getFrameNum() > 1 )
   {
-    m_bIsPlaying = true;
-  }
-  else
-  {
-    m_bIsPlaying = false;
+    isPlaying = true;
   }
+  setPlaying( isPlaying );
   return m_bIsPlaying;
 }
 
@@ -811,20 +965,25 @@ bool VideoSubWindow::playEvent()
 
 void VideoSubWindow::pause()
 {
-  m_bIsPlaying = false;
+  setPlaying( false );
   refreshFrame();
 }
 
 void VideoSubWindow::seekAbsoluteEvent( unsigned int new_frame_num )
 {
   if( m_pCurrStream )
+  {
     if( m_pCurrStream->seekInput( new_frame_num ) )
       refreshFrame();
+
+#ifdef CALYP_MANAGED_RESOURCES
+    m_pcResourceManager->wakeResourceWorker( m_uiResourceId );
+#endif
+  }
 }
 
 void VideoSubWindow::seekRelativeEvent( bool bIsFoward )
 {
-  bool bRefresh = false;
   if( m_pCurrStream )
   {
     if( bIsFoward )
@@ -833,13 +992,13 @@ void VideoSubWindow::seekRelativeEvent( bool bIsFoward )
     }
     else
     {
-      bRefresh = m_pCurrStream->seekInputRelative( bIsFoward );
+      m_pCurrStream->seekInputRelative( bIsFoward );
+#ifdef CALYP_MANAGED_RESOURCES
+      m_pcResourceManager->wakeResourceWorker( m_uiResourceId );
+#endif
+      refreshFrame();
     }
   }
-  if( bRefresh )
-  {
-    refreshFrame();
-  }
 }
 
 void VideoSubWindow::stop()
@@ -848,7 +1007,7 @@ void VideoSubWindow::stop()
   m_cRefreshResult.waitForFinished();
   m_cReadResult.waitForFinished();
 #endif
-  m_bIsPlaying = false;
+  setPlaying( false );
   seekAbsoluteEvent( 0 );
   return;
 }
@@ -988,8 +1147,8 @@ void VideoSubWindow::scaleView( double scale, QPoint center )
 void VideoSubWindow::scaleView( const QSize& size, QPoint center )
 {
   QSize imgViewSize;
-  if( m_pcCurrFrame )
-    imgViewSize = QSize( m_pcCurrFrame->getWidth(), m_pcCurrFrame->getHeight() );
+  if( m_pcCurrFrameAsset )
+    imgViewSize = QSize( m_pcCurrFrameAsset->getWidth(), m_pcCurrFrameAsset->getHeight() );
   else
     imgViewSize = QSize( m_pCurrStream->getWidth(), m_pCurrStream->getHeight() );
   QSize newSize = imgViewSize;
@@ -1019,22 +1178,22 @@ void VideoSubWindow::scaleView( const QSize& size, QPoint center )
 
 void VideoSubWindow::updatePixelValueStatusBar( const QPoint& pos )
 {
-  if( m_pcCurrFrame )
+  if( m_pcCurrFrameAsset )
   {
     int iWidth, iHeight;
     int posX = pos.x();
     int posY = pos.y();
     QString strStatus;
 
-    iWidth = m_pcCurrFrame->getWidth();
-    iHeight = m_pcCurrFrame->getHeight();
+    iWidth = m_pcCurrFrameAsset->getWidth();
+    iHeight = m_pcCurrFrameAsset->getHeight();
 
     if( ( posX < iWidth ) && ( posX >= 0 ) && ( posY < iHeight ) && ( posY >= 0 ) )
     {
       strStatus = QString( "(%1,%2)   " ).arg( posX ).arg( posY );
 
-      int colorSpace = m_pcCurrFrame->getColorSpace();
-      CalypPixel pixelValue = m_pcCurrFrame->getPixel( pos.x(), pos.y() );
+      int colorSpace = m_pcCurrFrameAsset->getColorSpace();
+      CalypPixel pixelValue = m_pcCurrFrameAsset->getPixel( pos.x(), pos.y() );
       switch( colorSpace )
       {
       case CLP_COLOR_GRAY:

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
@@ -30,6 +30,8 @@
 #include <QRect>
 #include <QString>
 #include <QVector>
+
+#include "CalypAppModuleIf.h"
 #include "CommonDefs.h"
 #include "SubWindowAbstract.h"
 #include "ViewArea.h"
@@ -40,6 +42,7 @@ class QScrollArea;
 
 class VideoInformation;
 class VideoSubWindow;
+class ResourceHandle;
 class CalypAppModuleIf;
 
 typedef struct
@@ -64,6 +67,8 @@ class VideoSubWindow : public SubWindowAbstract
   Q_OBJECT
 
 private:
+  ResourceHandle* m_pcResourceManager;
+
   bool m_bWindowBusy;
 
   QScrollArea* m_pcScrollArea;
@@ -78,13 +83,15 @@ private:
   QString m_cFilename;
   QString m_cStreamInformation;
   CalypFileInfo m_sStreamInfo;
+  std::size_t m_uiResourceId;
   CalypStream* m_pCurrStream;
-
-  CalypFrame* m_pcCurrFrame;
+  std::shared_ptr<CalypFrame> m_pcCurrFrameAsset;
+  //CalypFrame* m_pcCurrFrame;
   QRect m_cSelectedArea;
 
-  CalypAppModuleIf* m_pcCurrentDisplayModule;
-  QList<CalypAppModuleIf*> m_apcCurrentModule;
+  CalypAppModuleIf* m_pcCurrentDisplayModule{ nullptr };
+  std::vector<std::shared_ptr<CalypAppModuleIf>> m_associatedModules;
+  bool m_hasAssociatedModules;
 
   VideoSubWindow* m_pcReferenceSubWindow;
 
@@ -108,8 +115,11 @@ public:
     MODULE_SUBWINDOW = SubWindowAbstract::MODULE_SUBWINDOW,
   };
   VideoSubWindow( enum VideoSubWindowCategories category, QWidget* parent = 0 );
+  VideoSubWindow( enum VideoSubWindowCategories category, CalypAppModuleIf* displayModule, QWidget* parent = 0 );
   ~VideoSubWindow();
 
+  void setResourceManaget( ResourceHandle* resourceManager ) { m_pcResourceManager = resourceManager; }
+
   void updateVideoWindowInfo();
 
   bool loadFile( QString cFilename, bool bForceDialog = false );
@@ -126,23 +136,25 @@ public:
   bool playEvent();
   void stop();
 
-  bool isPlaying() { return m_bIsPlaying; }
+  void setPlaying( bool isPlaying );
+  bool isPlaying();
   void seekAbsoluteEvent( unsigned int new_frame_num );
   void seekRelativeEvent( bool bIsFoward );
 
-  void setCurrFrame( CalypFrame* pcCurrFrame );
+  void setCurrFrame( std::shared_ptr<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; }
+  const CalypStream* getInputStream() { return m_pCurrStream; }
+  const CalypStream* getCurrStream() { return m_pCurrStream; }
+  CalypFrame* getCurrFrame() { return m_pcCurrFrameAsset.get(); }
+  std::shared_ptr<CalypFrame> getCurrFrameAsset();
   ViewArea* getViewArea() { return m_cViewArea; }
   void setRefSubWindow( VideoSubWindow* subWindow )
   {
     m_pcReferenceSubWindow = NULL;
     if( subWindow )
-      if( m_pcCurrFrame->haveSameFmt( subWindow->getCurrFrame() ) )
+      if( m_pcCurrFrameAsset->haveSameFmt( subWindow->getCurrFrame() ) )
         m_pcReferenceSubWindow = subWindow;
   }
 
@@ -151,17 +163,23 @@ public:
    * Functions to enable a module in the
    * current SubWindow
    */
-  void enableModule( CalypAppModuleIf* pcModule );
-  void disableModule( CalypAppModuleIf* pcModule = NULL );
-  void associateModule( CalypAppModuleIf* pcModule );
+  //void enableModule( std::shared_ptr<CalypAppModuleIf> pcModule );
+  bool hasAssociatedModule();
+  void setDisplayModule( CalypAppModuleIf* pcModule );
+  void associateModule( std::shared_ptr<CalypAppModuleIf> pcModule );
+  void disableModule( CalypAppModuleIf* pcModule );
+  bool disableAllModules();
 
   CalypAppModuleIf* getDisplayModule() { return m_pcCurrentDisplayModule; }
-  QList<CalypAppModuleIf*> getModuleArray()
+  QVector<CalypAppModuleIf*> getModuleArray()
   {
-    QList<CalypAppModuleIf*> apcModulesArray;
+    QVector<CalypAppModuleIf*> apcModulesArray;
     if( m_pcCurrentDisplayModule )
       apcModulesArray.append( m_pcCurrentDisplayModule );
-    apcModulesArray.append( m_apcCurrentModule );
+    for( const auto& module : m_associatedModules )
+    {
+      apcModulesArray.append( module.get() );
+    }
     return apcModulesArray;
   }
 
@@ -181,7 +199,6 @@ public:
   QSize sizeHint( const QSize& ) const;
 
   QString getCurrentFileName() { return m_cFilename; }
-  bool getIsModule() { return getCategory() | SubWindowAbstract::MODULE_SUBWINDOW; }
   void clearWindowBusy() { m_bWindowBusy = false; }
   void setFillWindow( bool bFlag );
 
@@ -205,9 +222,9 @@ private:
   QSize getScrollSize();
 
 protected:
-  void keyPressEvent( QKeyEvent* event );
-  void resizeEvent( QResizeEvent* event );
-  void closeEvent( QCloseEvent* event );
+  void keyPressEvent( QKeyEvent* event ) override;
+  void resizeEvent( QResizeEvent* event ) override;
+  void closeEvent( QCloseEvent* event ) override;
 
 public Q_SLOTS:
   void updateWindowOnTimeout();
@@ -218,7 +235,7 @@ public Q_SLOTS:
   void updatePixelValueStatusBar( const QPoint& pos );
 };
 
-Q_DECLARE_METATYPE( CalypFileInfo )
-Q_DECLARE_METATYPE( CalypFileInfoVector )
+Q_DECLARE_METATYPE( CalypFileInfo )        // NOLINT
+Q_DECLARE_METATYPE( CalypFileInfoVector )  // NOLINT
 
 #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,8 +25,6 @@
 
 #include "ViewArea.h"
 
-#include "GridManager.h"
-
 #include <QColor>
 #include <QCoreApplication>
 #include <QDebug>
@@ -38,9 +36,10 @@
 #include <QRectF>
 #include <QString>
 #include <QWidget>
-
 #include <cmath>
 
+#include "GridManager.h"
+
 static const QColor selectionColor = Qt::cyan;
 static const QColor imageMaskColor = Qt::green;
 static const QColor eraserColor = Qt::red;
@@ -49,9 +48,6 @@ ViewArea::ViewArea( QWidget* parent )
     : QWidget( parent )
 {
   setMouseTracking( true );
-
-  m_pcCurrFrame = NULL;
-  m_pixmap = QPixmap();
   m_grid = GridManager();
   m_mask = QBitmap();
   m_selectedArea = QRect();
@@ -70,31 +66,27 @@ ViewArea::ViewArea( QWidget* parent )
   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 );
+  m_nextFrame->fillRGBBuffer();
+  m_image = QImage( m_nextFrame->getRGBBuffer(),
+                    m_nextFrame->getWidth(),
+                    m_nextFrame->getHeight(),
+                    QImage::Format_ARGB32 );
 
-void ViewArea::setImage( const QPixmap& pixmap )
-{
-  m_pixmap = pixmap;
-  m_mask = QBitmap( pixmap.width(), pixmap.height() );
-  m_mask.clear();
+  // m_mask = QBitmap( pixmap.width(), pixmap.height() );
+  // m_mask.clear();
   updateSize();
   update();
   updateGeometry();
-
   initZoomWinRect();
 }
 
 void ViewArea::clear()
 {
-  m_pixmap = QPixmap();
+  m_image = QImage();
   m_mask = QBitmap();
   m_mode = NormalMode;
   updateSize();
@@ -168,7 +160,7 @@ 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() );
+  double minZoom = 0.01;  //( 1.0 / m_image.width() );
   double new_scale = 1.0;
 
   if( ( m_dZoomFactor == minZoom ) && ( scale < 1 ) )
@@ -184,10 +176,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();
 
@@ -320,45 +312,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 +362,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 +381,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 +404,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 +417,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 +434,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,13 +459,13 @@ 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();
@@ -484,18 +474,18 @@ void ViewArea::paintEvent( QPaintEvent* event )
   /*  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() *
+	 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 +503,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,15 +550,15 @@ 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 );
@@ -586,7 +576,7 @@ void ViewArea::paintEvent( QPaintEvent* event )
     painter.setPen( QColor( 50, 50, 50, 128 ) );
     //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() );
@@ -643,7 +633,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
@@ -688,8 +678,7 @@ void ViewArea::paintEvent( QPaintEvent* event )
     {
       switch( tool() )
       {
-      case MaskTool:
-      {
+      case MaskTool: {
         if( m_maskColor.isValid() )
           color = m_maskColor;
         else
@@ -697,8 +686,7 @@ void ViewArea::paintEvent( QPaintEvent* event )
 
         break;
       }
-      case EraserTool:
-      {
+      case EraserTool: {
         color = eraserColor;
         break;
       }
@@ -733,7 +721,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
@@ -919,7 +907,7 @@ void ViewArea::mouseMoveEvent( QMouseEvent* event )
       // 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 +991,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 +1063,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 +1072,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 +1082,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,8 +56,8 @@ public:
 
   ViewArea( QWidget* parent = 0 );
 
-  void setImage( CalypFrame* pcFrame );
-  void setImage( const QPixmap& pixmap );
+  QImage& image() { return m_image; };
+  void setImage( std::shared_ptr<CalypFrame> frame );
 
   void setMode( int mode );
   void setMaskColor( const QColor& color = QColor() );
@@ -83,8 +83,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; }
@@ -150,7 +148,8 @@ private:
   QPoint viewToWindow( const QPoint& pt ) const;
   QRect viewToWindow( const QRect& rc ) const;
 
-  CalypFrame* m_pcCurrFrame;
+  std::shared_ptr<CalypFrame> m_currFrame;
+  std::shared_ptr<CalypFrame> m_nextFrame;
 
   ClpPel m_uiPixelHalfScale;
 
@@ -161,7 +160,8 @@ private:
   double m_dZoomWinRatio;
   double m_dZoomFactor;
 
-  QPixmap m_pixmap;
+  QImage m_image;
+  //QPixmap m_pixmap;
   QBitmap m_mask;
   QRect m_selectedArea;
   QPoint m_lastPos;

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 )

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

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,6 +32,8 @@
 #include <QVector>
 #include <QWidget>
 
+#include "lib/CalypOptions.h"
+
 class QLineEdit;
 
 class OpionConfiguration : public QWidget

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,13 +25,13 @@
 #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;
 
 /**

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,17 @@ 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 )
+      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,7 +435,7 @@ void FramePropertiesDock::updateDataHistogram()
         fullImageButton->hide();
         selectionImageButton->hide();
       }
-      histogramWidget->updateData( m_pcFrame, m_pcSelectedFrame );
+      histogramWidget->updateData( m_pcFrame, m_cSelectionArea.isValid() ? m_pcSelectedFrame : nullptr );
     }
     else
     {
@@ -443,7 +461,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 +490,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 +534,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,12 @@
-###
-### 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
-)
+ADD_LIBRARY(QCustomPlotLib STATIC ${qcustomplot_SRCS})
+TARGET_LINK_LIBRARIES(QCustomPlotLib Qt5::Core Qt5::Gui Qt5::Widgets Qt5::PrintSupport)
 
-TARGET_INCLUDE_DIRECTORIES(QCustomPlotLib PUBLIC . )
+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,37 +41,33 @@ class HistogramWorker : public QThread
 {
 private:
   QObject* m_parent;
-  CalypFrame* m_pcFrame;
+  std::shared_ptr<CalypFrame> m_pcFrame;
 
 public:
   HistogramWorker( QObject* parent )
   {
-    m_pcFrame = NULL;
     m_parent = parent;
   }
 
-  void setup( CalypFrame* frame )
+  void reset()
+  {
+    m_pcFrame = nullptr;
+  }
+
+  void setup( std::shared_ptr<CalypFrame> frame )
   {
     m_pcFrame = frame;
-    // run();
-    start();
+    run();
+    //start();
   }
   void run()
   {
-    if( m_pcFrame && m_parent )
+    if( m_pcFrame != nullptr && m_parent != 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 );
@@ -94,7 +90,7 @@ public:
 
     bool starting;
     bool success;
-    CalypFrame* frame;
+    std::shared_ptr<CalypFrame> frame;
   };
 };
 
@@ -239,8 +235,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();
 }
 
@@ -379,7 +377,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 +495,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 +936,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 )

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}  )
+TARGET_LINK_LIBRARIES(FrameBinarization ${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/FrameBinarization_APIv1.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

examples/modules/FrameBinarization_APIv1.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

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,69 @@
+/*    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( ClpString( CALYP_TEST_DATA_DIR ) + ClpString( "/Kendo_c4_1024x768_yuv420p.yuv" ), 1024, 768, 0, 8, CLP_BIG_ENDIAN, 1, true );
+  stream.open( ClpString( CALYP_TEST_DATA_DIR ) + ClpString( "/SteamLocomotiveTrain_2560x1600_60_10bit_crop.yuv" ), 2560, 1600, 0, 10, CLP_LITTLE_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,14 @@
-###
-### CMakeLists for calyp lib component
-###
+#
+# CMakeLists for calyp lib component
+#
 
 INCLUDE(GNUInstallDirs)
 
-INCLUDE_DIRECTORIES( ${CMAKE_CURRENT_SOURCE_DIR} )
+INCLUDE_DIRECTORIES(${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,81 +16,76 @@ set(Calyp_Lib_SRCS
     StreamHandlerRaw.cpp
     StreamHandlerPortableMap.h
     StreamHandlerPortableMap.cpp
-    # Options Parser
-    CalypOptions.h
-    CalypOptions.cpp
-    # Modules
-    CalypModuleIf.h
-    CalypOpenCVModuleIf.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)
 
-IF( USE_FFMPEG )
-  LIST( APPEND Calyp_Lib_SRCS StreamHandlerLibav.h )
-  LIST( APPEND Calyp_Lib_SRCS StreamHandlerLibav.cpp )
+SET(Calyp_Lib_Modules_SRCS CalypOptions.h CalypOptions.cpp)
 
-  LIST(APPEND CMAKE_CFG_LINKER_LIBSS ${FFMPEG_LIBRARIES} )
-  LIST(APPEND CMAKE_CFG_INCLUDE_DIRS ${FFMPEG_INCLUDE_DIRS} )
-ENDIF()
-
-IF( USE_OPENCV )
-  LIST( APPEND Calyp_Lib_SRCS StreamHandlerOpenCV.h )
-  LIST( APPEND Calyp_Lib_SRCS StreamHandlerOpenCV.cpp )
-
-  LIST( APPEND Calyp_Lib_SRCS CalypOpenCVModuleIf.cpp )
-
-  LIST(APPEND CMAKE_CFG_LINKER_LIBSS ${OpenCV_LIBRARIES} )
-  LIST(APPEND CMAKE_CFG_INCLUDE_DIRS ${OpenCV_INCLUDE_DIRS} )
-ENDIF()
-
-set(Calyp_Lib_HEADERS
+SET(Calyp_Lib_SRCS
+    LibMemory.h
+    CalypLib.h
     CalypDefs.h
-    CalypFrame.h
-    CalypStream.h
-    CalypOptions.h
-    CalypModuleIf.h
-    CalypOpenCVModuleIf.h
+    ${Calyp_Lib_Frame_SRCS}
+    ${Calyp_Lib_Stream_SRCS}
+    ${Calyp_Lib_OptionParser_SRCS}
+    ${Calyp_Lib_Modules_SRCS}
 )
 
-CONFIGURE_FILE( CalypConfig.cmake.in CalypConfig.cmake @ONLY)
+LIST(APPEND CMAKE_CFG_LINKER_LIBSS ${PROJECT_LIBRARY})
+LIST(APPEND CMAKE_CFG_INCLUDE_DIRS ${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_INCLUDEDIR})
 
-INCLUDE_DIRECTORIES( ${FFMPEG_INCLUDE_DIRS} ${OpenCV_INCLUDE_DIRS} )
+IF(USE_FFMPEG)
+  LIST(APPEND Calyp_Lib_SRCS StreamHandlerLibav.h)
+  LIST(APPEND Calyp_Lib_SRCS StreamHandlerLibav.cpp)
 
-IF( USE_STATIC )
-  ADD_LIBRARY( ${PROJECT_LIBRARY} STATIC ${Calyp_Lib_SRCS} )
-ELSE()
-  ADD_LIBRARY( ${PROJECT_LIBRARY} SHARED ${Calyp_Lib_SRCS} )
+  LIST(APPEND CMAKE_CFG_LINKER_LIBSS ${FFMPEG_LIBRARIES})
+  LIST(APPEND CMAKE_CFG_INCLUDE_DIRS ${FFMPEG_INCLUDE_DIRS})
 ENDIF()
 
+IF(USE_OPENCV)
+  LIST(APPEND Calyp_Lib_SRCS StreamHandlerOpenCV.h)
+  LIST(APPEND Calyp_Lib_SRCS StreamHandlerOpenCV.cpp)
 
-TARGET_LINK_LIBRARIES( ${PROJECT_LIBRARY}
-    ${FFMPEG_LIBRARIES}
-    ${OpenCV_LIBRARIES}
-)
+  LIST(APPEND Calyp_Lib_SRCS CalypOpenCVModuleIf.cpp)
 
-TARGET_INCLUDE_DIRECTORIES(${PROJECT_LIBRARY}
-    PUBLIC
-        $<INSTALL_INTERFACE:include>
-        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/..>
-)
+  LIST(APPEND CMAKE_CFG_LINKER_LIBSS ${OpenCV_LIBRARIES})
+  LIST(APPEND CMAKE_CFG_INCLUDE_DIRS ${OpenCV_INCLUDE_DIRS})
+ENDIF()
 
-SET_TARGET_PROPERTIES( ${PROJECT_LIBRARY}
-   PROPERTIES VERSION ${CALYP_VERSION}
-   SOVERSION ${CALYP_VERSION_MAJOR}
-)
+SET(Calyp_Lib_HEADERS CalypDefs.h CalypFrame.h CalypStream.h CalypOptions.h CalypModuleIf.h CalypOpenCVModuleIf.h)
 
-IF( NOT USE_STATIC )
-  INSTALL( TARGETS ${PROJECT_LIBRARY}
+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})
+ELSE()
+  ADD_LIBRARY(${PROJECT_LIBRARY} SHARED ${Calyp_Lib_SRCS})
+ENDIF()
+
+TARGET_LINK_LIBRARIES(${PROJECT_LIBRARY} ${FFMPEG_LIBRARIES} ${OpenCV_LIBRARIES})
+
+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})
+
+IF(NOT USE_STATIC)
+  INSTALL(
+    TARGETS ${PROJECT_LIBRARY}
     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 DESTINATION share/calyp)
 ENDIF()
 
-IF( BUILD_TESTS )
-  ADD_SUBDIRECTORY( tests )
+IF(BUILD_TESTS)
+  ADD_SUBDIRECTORY(tests)
+ENDIF()
+
+IF(BUILD_TESTS_CATCH2)
+  ADD_SUBDIRECTORY(catch2)
 ENDIF()

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,15 @@
 #define __CALYPDEFS_H__
 
 #include <algorithm>
-#include <string>
-#include <vector>
+#include <cstdint>
 #include <iterator>
+#include <memory>
+#include <string>
 
-typedef unsigned short ClpPel;  ///< 16-bit pixel type
-typedef unsigned char ClpByte;
-typedef unsigned long long ClpULong;
-
-typedef std::string ClpString;
+using ClpByte = std::uint8_t;
+using ClpPel = std::uint16_t;
+using ClpULong = std::uint64_t;
+using ClpString = std::string;
 
 enum CLP_LOG_LEVEL
 {
@@ -108,14 +108,14 @@ static const double S_PI_2 = 1.57079632679489661923;
 inline ClpString clpLowercase( const ClpString& in )
 {
   ClpString out;
-  transform( in.begin(), in.end(), std::back_inserter( out ), tolower );
+  std::transform( in.begin(), in.end(), std::back_inserter( out ), tolower );
   return out;
 }
 
 inline ClpString clpUppercase( const ClpString& in )
 {
   ClpString out;
-  transform( in.begin(), in.end(), std::back_inserter( out ), toupper );
+  std::transform( in.begin(), in.end(), std::back_inserter( out ), toupper );
   return out;
 }
 

lib/CalypFrame.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,19 +24,25 @@
 
 #include "CalypFrame.h"
 
+#include <cassert>
+#include <cmath>
+#include <cstdint>
+#include <memory>
+#include <vector>
+
 #include "LibMemory.h"
 #include "PixelFormats.h"
 #include "config.h"
 
-#include <cassert>
-#include <cmath>
-
 #ifdef USE_OPENCV
 #include <opencv2/core/core.hpp>
 #include <opencv2/highgui/highgui.hpp>
 #include <opencv2/imgproc/imgproc.hpp>
 #endif
 
+constexpr auto kMinBitsPerPixel = 8;
+constexpr auto kMaxBitsPerPixel = 16;
+
 std::vector<ClpString> CalypFrame::supportedColorSpacesListNames()
 {
   return std::vector<ClpString>{
@@ -70,7 +76,7 @@ std::vector<ClpString> CalypFrame::supportedPixelFormatListNames( int colorSpace
 
 int CalypFrame::numberOfFormats()
 {
-  return g_CalypPixFmtDescriptorsMap.size();
+  return static_cast<int>( g_CalypPixFmtDescriptorsMap.size() );
 }
 
 int CalypFrame::findPixelFormat( const ClpString& name )
@@ -88,59 +94,60 @@ int CalypFrame::pelformatColorSpace( const int idx )
   return g_CalypPixFmtDescriptorsMap.at( idx ).colorSpace;
 }
 
-struct CalypFramePrivate
+class CalypFrame::CalypFramePrivate
 {
 public:
-  bool m_bInit;
+  bool m_bInit{ false };
 
   //! Struct with the pixel format description.
-  const CalypPixelFormatDescriptor* m_pcPelFormat;
+  const CalypPixelFormatDescriptor* m_pcPelFormat{ nullptr };
   ClpString m_cPelFmtName;
 
-  unsigned int m_uiWidth;         //!< Width of the frame
-  unsigned int m_uiHeight;        //!< Height of the frame
-  int m_iPixelFormat;             //!< Pixel format number (it follows the list of supported pixel formats)
-  unsigned int m_uiBitsPel;       //!< Bits per pixel/channel
-  unsigned int m_uiHalfPelValue;  //!< Bits per pixel/channel
+  unsigned int m_uiWidth{ 0 };         //!< Width of the frame
+  unsigned int m_uiHeight{ 0 };        //!< Height of the frame
+  int m_iPixelFormat{ 0 };             //!< Pixel format number (it follows the list of supported pixel formats)
+  unsigned int m_uiBitsPel{ 0 };       //!< Bits per pixel/channel
+  unsigned int m_uiHalfPelValue{ 0 };  //!< Bits per pixel/channel
+  bool m_bHasNegativeValues{ false };  //!< Half of the scale correspond to negative values
 
-  ClpPel*** m_pppcInputPel;
+  ClpPel*** m_pppcInputPel{ nullptr };
 
-  bool m_bHasRGBPel;          //!< Flag indicating that the ARGB buffer was computed
-  unsigned char* m_pcARGB32;  //!< Buffer with the ARGB pixels used in Qt libs
+  bool m_bHasRGBPel{ false };            //!< Flag indicating that the ARGB buffer was computed
+  std::vector<std::uint8_t> m_pcARGB32;  //!< Buffer with the ARGB pixels used in Qt libs
 
   /** Histogram control variables **/
-  bool m_bHasHistogram;
-  bool m_bHistogramRunning;
+  bool m_bHasHistogram{ false };
+  bool m_bHistogramRunning{ false };
   /** The histogram data.*/
-  unsigned int* m_puiHistogram;
+  std::vector<unsigned int> m_puiHistogram;
   /** If the image is RGB and calcLuma is true, we have 1 more channel */
-  unsigned int m_uiHistoChannels;
+  unsigned int m_uiHistoChannels{ 0 };
   /** Numbers of histogram segments depending of image bytes depth*/
-  unsigned int m_uiHistoSegments;
+  unsigned int m_uiHistoSegments{ 0 };
+
+  CalypFramePrivate() = default;
+  CalypFramePrivate( const CalypFramePrivate& ) = delete;
+  CalypFramePrivate( CalypFramePrivate&& ) = delete;
+  CalypFramePrivate& operator=( const CalypFramePrivate& ) = delete;
+  CalypFramePrivate& operator=( CalypFramePrivate&& ) = delete;
 
-  /**
-     * Common constructor function of a frame
-     *
-     * @param width width of the frame
-     * @param height height of the frame
-     * @param pel_format pixel format index (always use PixelFormats enum)
-     *
-     */
   void init( unsigned int width, unsigned int height, int pel_format, unsigned bitsPixel )
   {
-    m_bInit = false;
-    m_bHasRGBPel = false;
-    m_pppcInputPel = NULL;
-    m_pcARGB32 = NULL;
+    init( width, height, pel_format, bitsPixel, false );
+  }
+
+  void init( unsigned int width, unsigned int height, int pel_format, unsigned bitsPixel, bool has_negative_values )
+  {
     m_uiWidth = width;
     m_uiHeight = height;
     m_iPixelFormat = pel_format;
-    m_uiBitsPel = bitsPixel < 8 ? 8 : bitsPixel;
+    m_uiBitsPel = bitsPixel < kMinBitsPerPixel ? kMinBitsPerPixel : bitsPixel;
     m_uiHalfPelValue = 1 << ( m_uiBitsPel - 1 );
+    m_bHasNegativeValues = has_negative_values;
 
-    if( m_uiWidth == 0 || m_uiHeight == 0 || m_iPixelFormat == -1 || bitsPixel > 16 )
+    if( m_uiWidth == 0 || m_uiHeight == 0 || m_iPixelFormat == -1 || bitsPixel > kMaxBitsPerPixel )
     {
-      throw CalypFailure( "CalypFrame", "Cannot create a PlYUVerFrame of this type" );
+      throw CalypFailure( "CalypFrame", "Cannot create a CalypFrame of this type" );
     }
 
     m_pcPelFormat = &( g_CalypPixFmtDescriptorsMap.at( pel_format ) );
@@ -177,9 +184,8 @@ public:
     }
 
     /* Alloc ARGB memory */
-    getMem1D( &m_pcARGB32, m_uiHeight * m_uiWidth * 4 );
+    m_pcARGB32.resize( m_uiHeight * m_uiWidth * 4 );
 
-    m_puiHistogram = NULL;
     m_bHasHistogram = false;
     m_bHistogramRunning = false;
 
@@ -191,7 +197,7 @@ public:
     else
       m_uiHistoChannels = m_pcPelFormat->numberChannels;
 
-    getMem1D<unsigned int>( &( m_puiHistogram ), m_uiHistoSegments * m_uiHistoChannels );
+    m_puiHistogram.resize( m_uiHistoSegments * m_uiHistoChannels );
 
     m_cPelFmtName = CalypFrame::supportedPixelFormatListNames()[m_iPixelFormat].c_str();
 
@@ -243,47 +249,78 @@ public:
   {
     while( m_bHistogramRunning )
       ;
-    if( m_puiHistogram )
-      freeMem1D( m_puiHistogram );
     m_bHasHistogram = false;
 
     if( m_pppcInputPel )
       xFreeMem( m_pppcInputPel );
-
-    if( m_pcARGB32 )
-      freeMem1D( m_pcARGB32 );
   }
 };
 
 /*!
  * \brief Constructors
  */
-
 CalypFrame::CalypFrame( unsigned int width, unsigned int height, int pelFormat, unsigned bitsPixel )
-    : d( new CalypFramePrivate )
+    : d{ std::make_unique<CalypFramePrivate>() }
 {
   d->init( width, height, pelFormat, bitsPixel );
 }
 
-CalypFrame::CalypFrame( const CalypFrame& other )
-    : d( new CalypFramePrivate )
+CalypFrame::CalypFrame( unsigned int width, unsigned int height, int pelFormat, unsigned bitsPixel, bool has_negative_values )
+    : d{ std::make_unique<CalypFramePrivate>() }
 {
-  d->init( other.getWidth(), other.getHeight(), other.getPelFormat(), other.getBitsPel() );
+  d->init( width, height, pelFormat, bitsPixel, has_negative_values );
+}
+
+CalypFrame::CalypFrame( CalypFrame&& other ) noexcept
+    : d{ std::move( other.d ) }
+{
+}
+
+CalypFrame& CalypFrame::operator=( CalypFrame&& other ) noexcept
+{
+  // Self-assignment detection
+  if( &other == this )
+    return *this;
+
+  // Transfer ownership of a.m_ptr to m_ptr
+  d = std::move( other.d );
+
+  return *this;
+}
+
+CalypFrame::CalypFrame( const CalypFrame& other )
+    : d{ std::make_unique<CalypFramePrivate>() }
+{
+  d->init( other.getWidth(), other.getHeight(), other.getPelFormat(), other.getBitsPel(), other.getHasNegativeValues() );
   copyFrom( &other );
 }
 
-CalypFrame::CalypFrame( const CalypFrame* other )
-    : d( new CalypFramePrivate )
+// CalypFrame::CalypFrame( const CalypFrame* other )
+//     : d{ std::make_unique<CalypFramePrivate>() }
+// {
+//   if( other )
+//   {
+//     d->init( other->getWidth(), other->getHeight(), other->getPelFormat(), other->getBitsPel(), other->getHasNegativeValues() );
+//     copyFrom( other );
+//   }
+// }
+
+CalypFrame& CalypFrame::operator=( const CalypFrame& other )
 {
-  if( other )
-  {
-    d->init( other->getWidth(), other->getHeight(), other->getPelFormat(), other->getBitsPel() );
-    copyFrom( other );
-  }
+  // Self-assignment detection
+  if( &other == this )
+    return *this;
+
+  // Copy the resource
+  d = std::make_unique<CalypFramePrivate>();
+  d->init( other.getWidth(), other.getHeight(), other.getPelFormat(), other.getBitsPel(), other.getHasNegativeValues() );
+  copyFrom( &other );
+
+  return *this;
 }
 
 CalypFrame::CalypFrame( const CalypFrame& other, unsigned int x, unsigned int y, unsigned int width, unsigned int height )
-    : d( new CalypFramePrivate )
+    : d{ std::make_unique<CalypFramePrivate>() }
 {
   const CalypPixelFormatDescriptor* pcPelFormat = &( g_CalypPixFmtDescriptorsMap.at( other.getPelFormat() ) );
   if( pcPelFormat->log2ChromaWidth )
@@ -308,7 +345,7 @@ CalypFrame::CalypFrame( const CalypFrame& other, unsigned int x, unsigned int y,
 }
 
 CalypFrame::CalypFrame( const CalypFrame* other, unsigned int posX, unsigned int posY, unsigned int areaWidth, unsigned int areaHeight )
-    : d( new CalypFramePrivate )
+    : d{ std::make_unique<CalypFramePrivate>() }
 {
   if( !other )
     return;
@@ -335,10 +372,7 @@ CalypFrame::CalypFrame( const CalypFrame* other, unsigned int posX, unsigned int
   copyFrom( other, posX, posY );
 }
 
-CalypFrame::~CalypFrame()
-{
-  delete d;
-}
+CalypFrame::~CalypFrame() = default;
 
 bool CalypFrame::haveSameFmt( const CalypFrame& other, unsigned int match ) const
 {
@@ -397,6 +431,11 @@ unsigned CalypFrame::getHeight( unsigned channel ) const
   return CHROMASHIFT( d->m_uiHeight, channel > 0 ? d->m_pcPelFormat->log2ChromaHeight : 0 );
 }
 
+bool CalypFrame::getHasNegativeValues() const
+{
+  return d->m_bHasNegativeValues;
+}
+
 ClpULong CalypFrame::getPixels( unsigned channel ) const
 {
   return getWidth( channel ) * getHeight( channel );
@@ -481,28 +520,33 @@ ClpPel*** CalypFrame::getPelBufferYUV()
   return d->m_pppcInputPel;
 }
 
-unsigned char* CalypFrame::getRGBBuffer() const
+auto CalypFrame::getRGBBuffer() const -> const unsigned char*
 {
   if( d->m_bHasRGBPel )
   {
-    return d->m_pcARGB32;
+    return d->m_pcARGB32.data();
   }
   return NULL;
 }
 
-ClpPel CalypFrame::operator()( unsigned int ch, unsigned int xPos, unsigned int yPos )
+ClpPel CalypFrame::operator()( unsigned int ch, unsigned int xPos, unsigned int yPos, bool absolute ) const
 {
+  int retValue = 0;
   if( ch < d->m_pcPelFormat->numberChannels )
-    return d->m_pppcInputPel[ch][yPos][xPos];
-  return 0;
+  {
+    retValue = d->m_pppcInputPel[ch][yPos][xPos];
+    if( !absolute && d->m_bHasNegativeValues )
+      retValue = retValue - int( d->m_uiHalfPelValue );
+  }
+  return ClpPel( retValue );
 }
 
-CalypPixel CalypFrame::operator()( unsigned int xPos, unsigned int yPos )
+CalypPixel CalypFrame::operator()( unsigned int xPos, unsigned int yPos ) const
 {
   return getPixel( xPos, yPos );
 }
 
-CalypPixel CalypFrame::getPixel( unsigned int xPos, unsigned int yPos )
+CalypPixel CalypFrame::getPixel( unsigned int xPos, unsigned int yPos ) const
 {
   CalypPixel PixelValue( d->m_pcPelFormat->colorSpace );
   for( unsigned int ch = 0; ch < d->m_pcPelFormat->numberChannels; ch++ )
@@ -572,7 +616,7 @@ void CalypFrame::copyFrom( const CalypFrame* other, unsigned x, unsigned y )
     copyFrom( *other, x, y );
 }
 
-void CalypFrame::copyTo( const CalypFrame& other, unsigned x, unsigned y )
+void CalypFrame::copyTo( const CalypFrame& other, unsigned x, unsigned y ) const
 {
   if( !haveSameFmt( other, MATCH_COLOR_SPACE | MATCH_PEL_FMT | MATCH_BITS ) )
     return;
@@ -593,13 +637,13 @@ void CalypFrame::copyTo( const CalypFrame& other, unsigned x, unsigned y )
   d->m_bHasHistogram = false;
 }
 
-void CalypFrame::copyTo( const CalypFrame* other, unsigned x, unsigned y )
+void CalypFrame::copyTo( const CalypFrame* other, unsigned x, unsigned y ) const
 {
   if( other )
     copyTo( *other, x, y );
 }
 
-void CalypFrame::frameFromBuffer( ClpByte* Buff, int iEndianness, unsigned long uiBuffSize )
+void CalypFrame::frameFromBuffer( const std::vector<ClpByte>& Buff, int iEndianness, unsigned long uiBuffSize )
 {
   if( uiBuffSize != getBytesPerFrame() )
     return;
@@ -607,19 +651,14 @@ void CalypFrame::frameFromBuffer( ClpByte* Buff, int iEndianness, unsigned long
   frameFromBuffer( Buff, iEndianness );
 }
 
-void CalypFrame::frameFromBuffer( ClpByte* Buff, int iEndianness )
+void CalypFrame::frameFromBuffer( const std::vector<ClpByte>& Buff, int iEndianness )
 {
-  ClpByte* ppBuff[MAX_NUMBER_PLANES];
-  ClpByte* pTmpBuff;
-  ClpPel* pPel;
+  const ClpByte* ppBuff[MAX_NUMBER_PLANES];
   unsigned int bytesPixel = ( d->m_uiBitsPel - 1 ) / 8 + 1;
-  int ratioH, ratioW, step;
-  unsigned int i, ch;
   int startByte = 0;
   int endByte = bytesPixel;
   int incByte = 1;
-  int b;
-  int maxval = pow( 2, d->m_uiBitsPel ) - 1;
+  int maxval = ( 1 << d->m_uiBitsPel ) - 1;
 
   if( iEndianness == CLP_BIG_ENDIAN )
   {
@@ -628,37 +667,36 @@ void CalypFrame::frameFromBuffer( ClpByte* Buff, int iEndianness )
     incByte = -1;
   }
 
-  ppBuff[0] = Buff;
-  for( i = 1; i < MAX_NUMBER_PLANES; i++ )
+  ppBuff[0] = Buff.data();
+  for( unsigned i = 1; i < MAX_NUMBER_PLANES; i++ )
   {
-    ratioW = i > 1 ? d->m_pcPelFormat->log2ChromaWidth : 0;
-    ratioH = i > 1 ? d->m_pcPelFormat->log2ChromaHeight : 0;
+    int ratioW = i > 1 ? d->m_pcPelFormat->log2ChromaWidth : 0;
+    int ratioH = i > 1 ? d->m_pcPelFormat->log2ChromaHeight : 0;
     ppBuff[i] = ppBuff[i - 1] + CHROMASHIFT( d->m_uiHeight, ratioH ) * CHROMASHIFT( d->m_uiWidth, ratioW ) * bytesPixel;
   }
 
-  for( ch = 0; ch < d->m_pcPelFormat->numberChannels; ch++ )
+  xMemSet( ClpPel, getTotalNumberOfPixels(), d->m_pppcInputPel[0][0] );
+
+  for( unsigned ch = 0; ch < d->m_pcPelFormat->numberChannels; ch++ )
   {
-    ratioW = ch > 0 ? d->m_pcPelFormat->log2ChromaWidth : 0;
-    ratioH = ch > 0 ? d->m_pcPelFormat->log2ChromaHeight : 0;
-    step = ( d->m_pcPelFormat->comp[ch].step_minus1 ) * bytesPixel;
+    int ratioW = ch > 0 ? d->m_pcPelFormat->log2ChromaWidth : 0;
+    int ratioH = ch > 0 ? d->m_pcPelFormat->log2ChromaHeight : 0;
+    int step = ( d->m_pcPelFormat->comp[ch].step_minus1 ) * bytesPixel;
 
-    pPel = d->m_pppcInputPel[ch][0];
-    pTmpBuff = ppBuff[d->m_pcPelFormat->comp[ch].plane] + ( d->m_pcPelFormat->comp[ch].offset_plus1 - 1 ) * bytesPixel;
+    ClpPel* pPel = d->m_pppcInputPel[ch][0];
+    const ClpByte* pTmpBuff = ppBuff[d->m_pcPelFormat->comp[ch].plane] + ( d->m_pcPelFormat->comp[ch].offset_plus1 - 1 ) * bytesPixel;
 
-    for( i = 0; i < CHROMASHIFT( d->m_uiHeight, ratioH ) * CHROMASHIFT( d->m_uiWidth, ratioW ); i++ )
+    for( unsigned p = 0; p < CHROMASHIFT( d->m_uiHeight, ratioH ) * CHROMASHIFT( d->m_uiWidth, ratioW ); p++ )
     {
-      *pPel = 0;
-      for( b = startByte; b != endByte; b += incByte )
+      for( int b = startByte; b != endByte; b += incByte )
       {
-        *pPel += *pTmpBuff << ( b * 8 );
+        pPel[p] += *pTmpBuff << ( b * 8 );
         pTmpBuff++;
-        // Check max value and bound it to "maxval" to prevent segfault when
-        // calculating histogram
-        if( *pPel > maxval )
-          *pPel = 0;
-        // -----
       }
-      pPel++;
+      // Check max value and bound it to "maxval" to prevent segfault when
+      // calculating histogram
+      if( pPel[p] > maxval )
+        pPel[p] = 0;
       pTmpBuff += step;
     }
   }
@@ -666,7 +704,7 @@ void CalypFrame::frameFromBuffer( ClpByte* Buff, int iEndianness )
   d->m_bHasHistogram = false;
 }
 
-void CalypFrame::frameToBuffer( ClpByte* output_buffer, int iEndianness )
+void CalypFrame::frameToBuffer( std::vector<ClpByte>& output_buffer, int iEndianness ) const
 {
   unsigned int bytesPixel = ( d->m_uiBitsPel - 1 ) / 8 + 1;
   ClpByte* ppBuff[MAX_NUMBER_PLANES];
@@ -686,7 +724,7 @@ void CalypFrame::frameToBuffer( ClpByte* output_buffer, int iEndianness )
     incByte = -1;
   }
 
-  ppBuff[0] = output_buffer;
+  ppBuff[0] = output_buffer.data();
   for( int i = 1; i < MAX_NUMBER_PLANES; i++ )
   {
     ratioW = i > 1 ? d->m_pcPelFormat->log2ChromaWidth : 0;
@@ -716,11 +754,10 @@ void CalypFrame::frameToBuffer( ClpByte* output_buffer, int iEndianness )
   }
 }
 
-void CalypFrame::fillRGBBuffer()
-{
 #define PEL_ARGB( a, r, g, b ) ( ( a & 0xff ) << 24 ) | ( ( r & 0xff ) << 16 ) | ( ( g & 0xff ) << 8 ) | ( b & 0xff )
 #define PEL_RGB( r, g, b ) PEL_ARGB( 0xffu, r, g, b )
-#define CLAMP_YUV2RGB( X ) X = X < 0 ? 0 : X > 255 ? 255 : X;
+#define CLAMP_YUV2RGB( X ) X = X < 0 ? 0 : X > 255 ? 255 : \
+                                                     X;
 #define YUV2RGB( iY, iU, iV, iR, iG, iB )                          \
   iR = iY + ( ( 1436 * ( iV - 128 ) ) >> 10 );                     \
   iG = iY - ( ( 352 * ( iU - 128 ) + 731 * ( iV - 128 ) ) >> 10 ); \
@@ -729,16 +766,51 @@ void CalypFrame::fillRGBBuffer()
   CLAMP_YUV2RGB( iG )                                              \
   CLAMP_YUV2RGB( iB )
 
+void fillRGBBufferYUV420p( ClpPel*** pppInputPel, uint32_t* pARGB, unsigned uiWidth, unsigned uiHeight, int shiftBits )
+{
+  ClpPel* pY = pppInputPel[CLP_LUMA][0];
+  ClpPel* pU = pppInputPel[CLP_CHROMA_U][0];
+  ClpPel* pV = pppInputPel[CLP_CHROMA_V][0];
+
+  for( unsigned y = 0; y < uiHeight; y += 2 )
+  {
+    for( unsigned x = 0; x < uiWidth; x += 2 )
+    {
+      int iY, iU, iV, iR, iG, iB;
+      iY = pY[y * uiWidth + x] >> shiftBits;
+      iU = pU[y * uiWidth / 4 + x / 2] >> shiftBits;
+      iV = pV[y * uiWidth / 4 + x / 2] >> shiftBits;
+      YUV2RGB( iY, iU, iV, iR, iG, iB );
+      pARGB[y * uiWidth + x] = PEL_RGB( iR, iG, iB );
+
+      iY = pY[y * uiWidth + x + 1] >> shiftBits;
+      YUV2RGB( iY, iU, iV, iR, iG, iB );
+      pARGB[y * uiWidth + x + 1] = PEL_RGB( iR, iG, iB );
+
+      iY = pY[y * uiWidth + uiWidth + x] >> shiftBits;
+      YUV2RGB( iY, iU, iV, iR, iG, iB );
+      pARGB[y * uiWidth + uiWidth + x] = PEL_RGB( iR, iG, iB );
+
+      iY = pY[y * uiWidth + uiWidth + x + 1] >> shiftBits;
+      YUV2RGB( iY, iU, iV, iR, iG, iB );
+      pARGB[y * uiWidth + uiWidth + x + 1] = PEL_RGB( iR, iG, iB );
+    }
+  }
+}
+
+void CalypFrame::fillRGBBuffer() const
+{
   if( d->m_bHasRGBPel )
     return;
   int shiftBits = d->m_uiBitsPel - 8;
 
+  d->m_bHasRGBPel = true;
   // 4 bytes for A, R, G and B
-  uint32_t* pARGB = (uint32_t*)d->m_pcARGB32;
+  uint32_t* pARGB = (uint32_t*)d->m_pcARGB32.data();
   if( d->m_pcPelFormat->colorSpace == CLP_COLOR_GRAY )
   {
     ClpPel* pY = d->m_pppcInputPel[CLP_LUMA][0];
-    unsigned char finalPel;
+    unsigned char finalPel{ 0 };
     for( unsigned int i = 0; i < d->m_uiHeight * d->m_uiWidth; i++ )
     {
       finalPel = ( *pY++ ) >> shiftBits;
@@ -764,36 +836,37 @@ void CalypFrame::fillRGBBuffer()
   }
   else if( d->m_pcPelFormat->colorSpace == CLP_COLOR_YUV )
   {
+    if( d->m_iPixelFormat == CLP_YUV420P )
+    {
+      fillRGBBufferYUV420p( d->m_pppcInputPel, pARGB, d->m_uiWidth, d->m_uiHeight, shiftBits );
+      return;
+    }
     ClpPel* pLineY = d->m_pppcInputPel[CLP_LUMA][0];
     ClpPel* pLineU = d->m_pppcInputPel[CLP_CHROMA_U][0];
     ClpPel* pLineV = d->m_pppcInputPel[CLP_CHROMA_V][0];
     unsigned int uiChromaStride = CHROMASHIFT( d->m_uiWidth, d->m_pcPelFormat->log2ChromaWidth );
-    ClpPel* pY;
-    ClpPel* pU;
-    ClpPel* pV;
-    int iY, iU, iV, iR, iG, iB;
+
+    int iR, iG, iB;
     uint32_t* pARGBLine = pARGB;
     uint32_t* pARGBAux;
 
-    unsigned int y, x;
-    int i, j;
-    for( y = 0; y < CHROMASHIFT( d->m_uiHeight, d->m_pcPelFormat->log2ChromaHeight ); y++ )
+    for( int y = 0; y < CHROMASHIFT( d->m_uiHeight, d->m_pcPelFormat->log2ChromaHeight ); y++ )
     {
-      for( i = 0; i < 1 << d->m_pcPelFormat->log2ChromaHeight; i++ )
+      for( int i = 0; i < 1 << d->m_pcPelFormat->log2ChromaHeight; i++ )
       {
-        pY = pLineY;
-        pU = pLineU;
-        pV = pLineV;
+        ClpPel* pY = pLineY;
+        ClpPel* pU = pLineU;
+        ClpPel* pV = pLineV;
         pARGBAux = pARGBLine;
-        for( x = 0; x < CHROMASHIFT( d->m_uiWidth, d->m_pcPelFormat->log2ChromaWidth ); x++ )
+        for( int x = 0; x < CHROMASHIFT( d->m_uiWidth, d->m_pcPelFormat->log2ChromaWidth ); x++ )
         {
-          iU = *pU++;
+          int iU = *pU++;
           iU >>= shiftBits;
-          iV = *pV++;
+          int iV = *pV++;
           iV >>= shiftBits;
-          for( j = 0; j < ( 1 << d->m_pcPelFormat->log2ChromaWidth ); j++ )
+          for( int j = 0; j < ( 1 << d->m_pcPelFormat->log2ChromaWidth ); j++ )
           {
-            iY = *pY++;
+            int iY = *pY++;
             iY >>= shiftBits;
             YUV2RGB( iY, iU, iV, iR, iG, iB );
             *pARGBAux++ = PEL_RGB( iR, iG, iB );
@@ -806,7 +879,6 @@ void CalypFrame::fillRGBBuffer()
       pLineV += uiChromaStride;
     }
   }
-  d->m_bHasRGBPel = true;
 }
 
 /**
@@ -815,12 +887,12 @@ void CalypFrame::fillRGBBuffer()
 
 void CalypFrame::calcHistogram()
 {
-  if( d->m_bHasHistogram || !d->m_puiHistogram )
+  if( d->m_bHasHistogram || d->m_puiHistogram.empty() )
     return;
 
   d->m_bHistogramRunning = true;
 
-  xMemSet( unsigned int, d->m_uiHistoSegments * d->m_uiHistoChannels, d->m_puiHistogram );
+  std::fill( d->m_puiHistogram.begin(), d->m_puiHistogram.end(), 0 );
 
   unsigned int numberChannels = d->m_pcPelFormat->numberChannels;
   for( unsigned int ch = 0; ch < numberChannels; ch++ )
@@ -1117,13 +1189,39 @@ double CalypFrame::getHistogramValue( unsigned channel, unsigned int bin )
   return d->m_puiHistogram[indexStart + bin];
 }
 
+double CalypFrame::getEntropy( unsigned channel, unsigned int start, unsigned int end )
+{
+  if( !d->m_bHasHistogram )
+    return 0;
+
+  channel = d->getRealHistogramChannel( channel );
+  if( channel < 0 )
+    return 0;
+
+  int indexStart = channel * d->m_uiHistoSegments;
+  double numValues = getNumPixelsRange( channel, start, end );
+  double entropy = 0.0;
+
+  for( unsigned b = start; b <= end; b++ )
+  {
+    if( d->m_puiHistogram[indexStart + b] == 0 )
+      continue;
+
+    double prob = d->m_puiHistogram[indexStart + b] / numValues;
+
+    entropy -= prob * log2( prob );
+  }
+
+  return entropy;
+}
+
 /*
  **************************************************************
  * interface to other libs
  **************************************************************
  */
 
-bool CalypFrame::toMat( cv::Mat& cvMat, bool convertToGray, bool scale, unsigned channel )
+bool CalypFrame::toMat( cv::Mat& cvMat, bool convertToGray, bool scale, unsigned channel ) const
 {
   bool bRet = false;
 #ifdef USE_OPENCV

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,6 +26,8 @@
 #ifndef __CALYPFRAME_H__
 #define __CALYPFRAME_H__
 
+#include <vector>
+
 #include "CalypDefs.h"
 
 namespace cv
@@ -73,7 +75,8 @@ public:
   CalypPixel convertPixel( CalypColorSpace eOutputSpace );
 
 private:
-  struct CalypPixelPrivate* d;
+  class CalypPixelPrivate;
+  std::unique_ptr<CalypPixelPrivate> d;
 };
 
 /**
@@ -113,13 +116,44 @@ public:
 	 */
   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, int 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 );
+
+  /**
+   * 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
@@ -197,6 +231,12 @@ public:
 	 */
   unsigned int getHeight( 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
@@ -254,16 +294,17 @@ public:
   ClpPel*** getPelBufferYUV() const;
   ClpPel*** getPelBufferYUV();
 
-  unsigned char* getRGBBuffer() const;
+  auto getRGBBuffer() const -> const unsigned char*;
 
   /**
-	 * Get pixel value at coordinates
+   * 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 );
+  ClpPel operator()( unsigned int ch, unsigned int xPos, unsigned int yPos, bool absolute = true ) const;
 
   /**
 	 * Get pixel value at coordinates
@@ -271,7 +312,7 @@ public:
 	 * @param yPos position in Y axis
 	 * @return pixel value
 	 */
-  CalypPixel operator()( unsigned int xPos, unsigned int yPos );
+  CalypPixel operator()( unsigned int xPos, unsigned int yPos ) const;
 
   /**
 	 * Get pixel value at coordinates
@@ -279,7 +320,7 @@ public:
 	 * @param yPos position in Y axis
 	 * @return pixel value
 	 */
-  CalypPixel getPixel( unsigned int xPos, unsigned int yPos );
+  CalypPixel getPixel( unsigned int xPos, unsigned int yPos ) const;
 
   /**
 	 * Get pixel value at coordinates
@@ -322,14 +363,14 @@ public:
      * @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 );
+  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() const;
 
   /**
 	 * Histogram
@@ -363,11 +404,12 @@ public:
   double getHistogramValue( unsigned channel, unsigned int bin );
   unsigned int getNEBins( unsigned channel );
   int getNumHistogramSegment();
+  double getEntropy( unsigned channel, unsigned int start, unsigned int end );
 
   /**
 	 * interface with OpenCV lib
 	 */
-  bool toMat( cv::Mat& cvMat, bool convertToGray = false, bool scale = true, unsigned channel = 0 );
+  bool toMat( cv::Mat& cvMat, bool convertToGray = false, bool scale = true, unsigned channel = 0 ) const;
   bool fromMat( cv::Mat& cvMat, int iChannel = -1 );
 
   /**
@@ -398,7 +440,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,17 @@
  * @}
  */
 
+#include <memory>
+#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:                             \
+  static CalypModulePtr Create() { return std::make_unique<X>(); }
 #define _BASIC_MODULE_API_2_CHECK_                        \
   if( apcFrameList.size() != m_uiNumberOfFrames )         \
     return false;                                         \
@@ -138,7 +140,6 @@ public:
     m_iFrameBufferCount = 0;
   }
   virtual ~CalypModuleIf() {}
-  virtual void Delete() = 0;
   virtual void destroy() = 0;
 
   const char* getModuleLongName()
@@ -164,7 +165,7 @@ public:
    * Module API version 3
    */
   virtual CalypFrame* getProcessedFrame() { return m_pcOutputFrame; }
-  virtual bool needFrame() { return m_iFrameBufferCount == 0? true : false; };
+  virtual bool needFrame() { return m_iFrameBufferCount == 0 ? true : false; };
   virtual bool flush()
   {
     m_iFrameBufferCount = 0;
@@ -172,4 +173,6 @@ public:
   };
 };
 
+using CalypModulePtr = std::unique_ptr<CalypModuleIf>;
+
 #endif  // __CALYPMODULESIF_H__

lib/CalypOpenCVModuleIf.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

lib/CalypOpenCVModuleIf.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/CalypOptions.cpp

@@ -38,13 +38,13 @@
 
 #include "CalypOptions.h"
 
-#include "config.h"
-#include "lib/CalypModuleIf.h"
-
 #include <cstring>
 #include <iostream>
 #include <sstream>
 
+#include "config.h"
+#include "lib/CalypModuleIf.h"
+
 using namespace std;
 
 struct ParseFailure : public std::exception
@@ -284,7 +284,7 @@ bool CalypOptions::hasOpt( const ClpString& optName )
 void CalypOptions::addDefaultOptions()
 {
   addOptions()                                                /**/
-      ( "help,h", "produce help message" )                    /**/
+      ( "help", "produce help message" )                      /**/
       ( "version", "show version and exit" )                  /**/
       ( "pel_fmts", "list pixel formats" )                    /**/
       ( "quality_metrics", "list supported quality metrics" ) /**/
@@ -477,27 +477,26 @@ unsigned int CalypOptions::parseSHORT( unsigned int argc, char* argv[] )
   return 1;
 }
 
-bool CalypOptions::parse( unsigned int argc, char* argv[] )
+int CalypOptions::parse( unsigned int argc, char* argv[] )
 {
   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[] )

lib/CalypOptions.h

@@ -40,10 +40,11 @@
 #ifndef __CALYPOPTIONS_H__
 #define __CALYPOPTIONS_H__
 
-#include "CalypDefs.h"
-
 #include <list>
 #include <map>
+#include <vector>
+
+#include "CalypDefs.h"
 
 /**
  * \class    OptionBase
@@ -90,7 +91,7 @@ public:
   CalypOptions( const ClpString& name = "" );
   ~CalypOptions();
 
-  bool parse( unsigned int argc, char* argv[] );
+  int parse( unsigned int argc, char* argv[] );
   void parse( std::vector<ClpString> args_array );
 
   std::list<const char*>& getUnhandledArgs() { return m_aUnhandledArgs; }

lib/CalypPixel.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
@@ -22,15 +22,17 @@
  * \brief    Video Frame handling
  */
 
-#include "CalypFrame.h"
+#include <memory>
 
+#include "CalypFrame.h"
 #include "PixelFormats.h"
 #include "config.h"
 
 #define MAX_NUMBER_COMPONENTS 4
 
-struct CalypPixelPrivate
+class CalypPixel::CalypPixelPrivate
 {
+public:
   CalypPixelPrivate( const int& ColorSpace )
   {
     iColorSpace = ColorSpace == CLP_COLOR_GRAY ?
@@ -51,9 +53,12 @@ static inline void yuvToRgb( const int& iY, const int& iU, const int& iV, int& i
   iR = iY + ( ( 1436 * ( iV - 128 ) ) >> 10 );
   iG = iY - ( ( 352 * ( iU - 128 ) + 731 * ( iV - 128 ) ) >> 10 );
   iB = iY + ( ( 1812 * ( iU - 128 ) ) >> 10 );
-  iR = iR < 0 ? 0 : iR > 255 ? 255 : iR;
-  iG = iG < 0 ? 0 : iG > 255 ? 255 : iG;
-  iB = iB < 0 ? 0 : iB > 255 ? 255 : iB;
+  iR = iR < 0 ? 0 : iR > 255 ? 255 :
+                               iR;
+  iG = iG < 0 ? 0 : iG > 255 ? 255 :
+                               iG;
+  iB = iB < 0 ? 0 : iB > 255 ? 255 :
+                               iB;
 }
 
 static inline void rgbToYuv( const int& iR, const int& iG, const int& iB, int& iY, int& iU, int& iV )
@@ -69,18 +74,18 @@ int CalypPixel::getMaxNumberOfComponents()
 }
 
 CalypPixel::CalypPixel( const int& ColorSpace )
-    : d( new CalypPixelPrivate( ColorSpace ) )
+    : d{ std::make_unique<CalypPixelPrivate>( ColorSpace ) }
 {
 }
 
 CalypPixel::CalypPixel( const int& ColorSpace, const ClpPel& c0 )
-    : d( new CalypPixelPrivate( ColorSpace ) )
+    : d{ std::make_unique<CalypPixelPrivate>( ColorSpace ) }
 {
   d->PelComp[0] = c0;
 }
 
 CalypPixel::CalypPixel( const int& ColorSpace, const ClpPel& c0, const ClpPel& c1, const ClpPel& c2 )
-    : d( new CalypPixelPrivate( ColorSpace ) )
+    : d{ std::make_unique<CalypPixelPrivate>( ColorSpace ) }
 {
   d->PelComp[0] = c0;
   d->PelComp[1] = c1;
@@ -88,7 +93,7 @@ CalypPixel::CalypPixel( const int& ColorSpace, const ClpPel& c0, const ClpPel& c
 }
 
 CalypPixel::CalypPixel( const int& ColorSpace, const ClpPel& c0, const ClpPel& c1, const ClpPel& c2, const ClpPel& c3 )
-    : d( new CalypPixelPrivate( ColorSpace ) )
+    : d{ std::make_unique<CalypPixelPrivate>( ColorSpace ) }
 {
   d->PelComp[0] = c0;
   d->PelComp[1] = c1;
@@ -97,7 +102,8 @@ CalypPixel::CalypPixel( const int& ColorSpace, const ClpPel& c0, const ClpPel& c
 }
 
 CalypPixel::CalypPixel( const CalypPixel& other )
-    : d( new CalypPixelPrivate( other.colorSpace() ) )
+    : d{ std::make_unique<CalypPixelPrivate>( other.colorSpace() ) }
+
 {
   for( int i = 0; i < MAX_NUMBER_COMPONENTS; i++ )
   {
@@ -105,10 +111,7 @@ CalypPixel::CalypPixel( const CalypPixel& other )
   }
 }
 
-CalypPixel::~CalypPixel()
-{
-  delete d;
-}
+CalypPixel::~CalypPixel() = default;
 
 int CalypPixel::colorSpace() const
 {

lib/CalypStream.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,6 +25,12 @@
 // Self
 #include "CalypStream.h"
 
+#include <cassert>
+#include <deque>
+#include <iostream>
+#include <memory>
+#include <mutex>
+
 #include "CalypFrame.h"
 #include "CalypStreamHandlerIf.h"
 #include "LibMemory.h"
@@ -40,6 +46,9 @@
 
 #include <cstdio>
 
+constexpr auto kDefaultBitsPerPixel = 8;
+constexpr auto kDefaultFrameRate = 30;
+
 std::vector<CalypStreamFormat> CalypStream::supportedReadFormats()
 {
   INI_REGIST_CALYP_SUPPORTED_FMT;
@@ -96,76 +105,139 @@ std::vector<CalypStandardResolution> CalypStream::stdResolutionSizes()
   return stdResList;
 }
 
-class CalypStreamBufferPrivate
+struct CalypStreamFrameBuffer : std::enable_shared_from_this<CalypStreamFrameBuffer>
 {
-private:
-  std::vector<CalypFrame*> m_apcFrameBuffer;
-  unsigned int m_uiIndex;
+  std::mutex buffer_mutex;
+  std::vector<std::unique_ptr<CalypFrame>> framePool;
+  std::size_t bufferIdx{ 0 };
 
-public:
-  CalypStreamBufferPrivate( unsigned int size, unsigned int width, unsigned int height, int pelFormat, int bitsPixel )
+  CalypStreamFrameBuffer( std::size_t size, unsigned int width, unsigned int height, int pelFormat, unsigned int bitsPixel, bool hasNegative )
   {
-    for( unsigned int i = 0; i < size; i++ )
+    framePool.reserve( size );
+    for( std::size_t i = 0; i < size; i++ )
     {
-      CalypFrame* pFrame = new CalypFrame( width, height, pelFormat, bitsPixel );
-      m_apcFrameBuffer.push_back( pFrame );
+      framePool.push_back( std::make_unique<CalypFrame>( width, height, pelFormat, bitsPixel, hasNegative ) );
     }
-    m_uiIndex = 0;
+    bufferIdx = framePool.size();
   }
 
-  ~CalypStreamBufferPrivate()
-  {
-    while( m_apcFrameBuffer.size() > 0 )
-    {
-      delete m_apcFrameBuffer.back();
-      m_apcFrameBuffer.pop_back();
-    }
-  }
-  void increase( unsigned int newSize )
-  {
-    for( unsigned int i = m_apcFrameBuffer.size(); i < newSize; i++ )
-    {
-      CalypFrame* pFrame = new CalypFrame( m_apcFrameBuffer.at( 0 ) );
-      m_apcFrameBuffer.push_back( pFrame );
-    }
-  }
-  unsigned int size() { return m_apcFrameBuffer.size(); }
-  void setIndex( unsigned int i ) { m_uiIndex = i; }
-  CalypFrame* frame( int i ) { return m_apcFrameBuffer.at( i ); }
+  CalypStreamFrameBuffer( const CalypStreamFrameBuffer& ) = delete;
+  CalypStreamFrameBuffer( CalypStreamFrameBuffer&& ) = delete;
+  CalypStreamFrameBuffer& operator=( const CalypStreamFrameBuffer& ) = delete;
+  CalypStreamFrameBuffer& operator=( CalypStreamFrameBuffer&& ) = delete;
 
-  CalypFrame* current() { return m_apcFrameBuffer.at( m_uiIndex ); }
-  CalypFrame* next() { return m_apcFrameBuffer.at( nextIndex() ); }
-  void setNextFrame() { m_uiIndex = nextIndex(); }
+  ~CalypStreamFrameBuffer() = default;
 
-private:
-  inline int nextIndex() { return m_uiIndex + 1 >= m_apcFrameBuffer.size() ? 0 : m_uiIndex + 1; }
-  inline int prevIndex() { return m_uiIndex - 1 < 0 ? m_apcFrameBuffer.size() - 1 : m_uiIndex - 1; }
+  void increase( std::size_t newSize )
+  {
+    framePool.reserve( newSize );
+    auto oldSize = framePool.size();
+    for( std::size_t i = oldSize; i < newSize; i++ )
+    {
+      framePool.push_back( std::make_unique<CalypFrame>( framePool[0]->getWidth(),
+                                                         framePool[0]->getHeight(),
+                                                         framePool[0]->getPelFormat(),
+                                                         framePool[0]->getBitsPel(),
+                                                         framePool[0]->getHasNegativeValues() ) );
+    }
+    bufferIdx += newSize - oldSize;
+  }
+
+  CalypFrame* ref() { return framePool[0].get(); }
+
+  std::shared_ptr<CalypFrame> getFrame()
+  {
+    const std::lock_guard<std::mutex> lock( buffer_mutex );
+    assert( bufferIdx > 0 );
+    bufferIdx--;
+    auto frame = framePool[bufferIdx].release();
+    auto deleter = [this, lifetime = shared_from_this()]( CalypFrame* p ) {
+      const std::lock_guard<std::mutex> lock( buffer_mutex );
+      framePool[bufferIdx].reset( p );
+      bufferIdx++;
+    };
+    return std::shared_ptr<CalypFrame>{ frame, deleter };
+  }
 };
 
-struct CalypStreamPrivate
+class CalypStream::CalypStreamPrivate
 {
+public:
+  std::recursive_mutex stream_mutex;
   bool isInit;
   bool isInput;
 
   CalypStreamHandlerIf* handler;
   CreateStreamHandlerFn pfctCreateHandler;
 
-  CalypStreamBufferPrivate* frameBuffer;
+  std::shared_ptr<CalypStreamFrameBuffer> frameBuffer;
+  std::deque<std::shared_ptr<CalypFrame>> frameFifo;
+
+  // std::vector<std::unique_ptr<CalypFrame>> framePool;
+  // std::deque<std::shared_ptr<CalypFrame>> frameFifo;
+  // std::size_t bufferIdx{ 0 };
 
   ClpString cFilename;
   long long int iCurrFrameNum;
   bool bLoadAll;
 
+  CalypStreamPrivate( const CalypStreamPrivate& ) = delete;
+  CalypStreamPrivate( CalypStreamPrivate&& ) = delete;
+  CalypStreamPrivate& operator=( const CalypStreamPrivate& ) = delete;
+  CalypStreamPrivate& operator=( CalypStreamPrivate&& ) = delete;
   CalypStreamPrivate()
   {
-    handler = NULL;
-    pfctCreateHandler = NULL;
+    handler = nullptr;
+    pfctCreateHandler = nullptr;
     isInput = true;
     isInit = false;
     bLoadAll = false;
     iCurrFrameNum = -1;
     cFilename = "";
   }
+
+  ~CalypStreamPrivate()
+  {
+    close();
+  }
+
+  void close()
+  {
+    if( handler )
+    {
+      handler->closeHandler();
+      handler->Delete();
+    }
+
+    bLoadAll = false;
+    isInit = false;
+  }
+
+  bool readNextFrame( bool fillRgbBuffer = false )
+  {
+    const std::lock_guard<std::recursive_mutex> lock( stream_mutex );
+
+    if( !isInit || !isInput || handler->m_uiCurrFrameFileIdx >= handler->m_uiTotalNumberFrames )
+      return false;
+
+    if( bLoadAll )
+      return true;
+
+    auto frame = frameBuffer->getFrame();
+
+    if( !handler->read( *frame ) )
+    {
+      throw CalypFailure( "CalypStream", "Cannot read frame from stream" );
+      return false;
+    }
+    frameFifo.push_back( frame );
+
+    if( fillRgbBuffer )
+    {
+      frame->fillRGBBuffer();
+    }
+    return true;
+  }
 };
 
 std::vector<ClpString> CalypStreamFormat::getExts()
@@ -220,14 +292,11 @@ CreateStreamHandlerFn CalypStream::findStreamHandler( ClpString strFilename, boo
 }
 
 CalypStream::CalypStream()
-    : d( new CalypStreamPrivate )
+    : d{ std::make_unique<CalypStreamPrivate>() }
 {
 }
 
-CalypStream::~CalypStream()
-{
-  close();
-}
+CalypStream::~CalypStream() = default;
 
 ClpString CalypStream::getFormatName() const
 {
@@ -238,7 +307,7 @@ ClpString CalypStream::getCodecName() const
   return !d->handler ? "" : d->handler->getCodecName();
 }
 
-bool CalypStream::open( ClpString filename, ClpString resolution, ClpString input_format_name, unsigned int bitsPel, int endianness,
+bool CalypStream::open( ClpString filename, ClpString resolution, ClpString input_format_name, unsigned int bitsPel, int endianness, bool hasNegative,
                         unsigned int frame_rate, bool bInput )
 {
   unsigned int width = 0;
@@ -261,15 +330,21 @@ bool CalypStream::open( ClpString filename, ClpString resolution, ClpString inpu
       break;
     }
   }
-  return open( filename, width, height, input_format, bitsPel, endianness, frame_rate, bInput );
+  return open( filename, width, height, input_format, bitsPel, endianness, hasNegative, frame_rate, bInput );
 }
 
 bool CalypStream::open( ClpString filename, unsigned int width, unsigned int height, int input_format, unsigned int bitsPel, int endianness,
                         unsigned int frame_rate, bool bInput )
+{
+  return open( filename, width, height, input_format, bitsPel, endianness, false, frame_rate, bInput );
+}
+
+bool CalypStream::open( ClpString filename, unsigned int width, unsigned int height, int input_format, unsigned int bitsPel, int endianness, bool hasNegative,
+                        unsigned int frame_rate, bool bInput )
 {
   if( d->isInit )
   {
-    close();
+    d->close();
   }
   d->isInit = false;
   d->isInput = bInput;
@@ -299,45 +374,54 @@ bool CalypStream::open( ClpString filename, unsigned int width, unsigned int hei
 
   if( !d->handler->openHandler( d->cFilename, d->isInput ) )
   {
-    close();
+    d->close();
     return d->isInit;
   }
 
   if( d->handler->m_uiWidth <= 0 || d->handler->m_uiHeight <= 0 || d->handler->m_iPixelFormat < 0 )
   {
-    close();
+    d->close();
     //throw CalypFailure( "CalypStream", "Incorrect configuration: width, height or pixel format" );
     return d->isInit;
   }
 
+  d->frameFifo.clear();
+
   // Keep past, current and future frames
+  std::size_t bufferSize = d->isInput ? 6 : 1;
   try
   {
-    d->frameBuffer = new CalypStreamBufferPrivate( d->isInput ? 3 : 1, d->handler->m_uiWidth, d->handler->m_uiHeight,
-                                                   d->handler->m_iPixelFormat, d->handler->m_uiBitsPerPixel );
+    d->frameBuffer = std::make_shared<CalypStreamFrameBuffer>( bufferSize,
+                                                               d->handler->m_uiWidth,
+                                                               d->handler->m_uiHeight,
+                                                               d->handler->m_iPixelFormat,
+                                                               d->handler->m_uiBitsPerPixel,
+                                                               hasNegative );
   }
   catch( CalypFailure& e )
   {
-    close();
+    d->close();
     throw CalypFailure( "CalypStream", "Cannot allocated frame buffer" );
     return d->isInit;
   }
 
-  d->handler->m_uiNBytesPerFrame = d->frameBuffer->current()->getBytesPerFrame();
+  const CalypFrame* refFrame = d->frameBuffer->ref();
+
+  d->handler->m_uiNBytesPerFrame = refFrame->getBytesPerFrame();
 
   // Some handlers need to know how long is a frame to get frame number
   d->handler->calculateFrameNumber();
 
   if( d->isInput && d->handler->m_uiTotalNumberFrames == 0 )
   {
-    close();
+    d->close();
     throw CalypFailure( "CalypStream", "Incorrect configuration: less than one frame" );
     return d->isInit;
   }
 
-  if( !d->handler->configureBuffer( d->frameBuffer->current() ) )
+  if( !d->handler->configureBuffer( *refFrame ) )
   {
-    close();
+    d->close();
     throw CalypFailure( "CalypStream", "Cannot allocated buffers" );
     return d->isInit;
   }
@@ -353,15 +437,17 @@ bool CalypStream::open( ClpString filename, unsigned int width, unsigned int hei
 
 bool CalypStream::reload()
 {
+  d->frameFifo.clear();
   d->handler->closeHandler();
   if( !d->handler->openHandler( d->cFilename, d->isInput ) )
   {
     throw CalypFailure( "CalypStream", "Cannot open stream " + d->cFilename + " with the " +
                                            ClpString( d->handler->m_pchHandlerName ) + " handler" );
   }
-  d->handler->m_uiNBytesPerFrame = d->frameBuffer->current()->getBytesPerFrame();
+  const CalypFrame* refFrame = d->frameBuffer->ref();
+  d->handler->m_uiNBytesPerFrame = refFrame->getBytesPerFrame();
   d->handler->calculateFrameNumber();
-  d->handler->configureBuffer( d->frameBuffer->current() );
+  d->handler->configureBuffer( *refFrame );
 
   if( d->handler->m_uiWidth <= 0 || d->handler->m_uiHeight <= 0 || d->handler->m_iPixelFormat < 0 ||
       d->handler->m_uiBitsPerPixel == 0 || d->handler->m_uiTotalNumberFrames == 0 )
@@ -372,26 +458,12 @@ bool CalypStream::reload()
   {
     d->iCurrFrameNum = 0;
   }
-  int currFrameNum = d->iCurrFrameNum;
+  auto currFrameNum = d->iCurrFrameNum;
   d->iCurrFrameNum = -1;
   seekInput( currFrameNum );
   return true;
 }
 
-void CalypStream::close()
-{
-  if( !d->isInit )
-    return;
-
-  d->handler->closeHandler();
-  d->handler->Delete();
-
-  delete d->frameBuffer;
-
-  d->bLoadAll = false;
-  d->isInit = false;
-}
-
 ClpString CalypStream::getFileName() const
 {
   return d->cFilename;
@@ -442,21 +514,36 @@ void CalypStream::getFormat( unsigned int& rWidth, unsigned int& rHeight, int& r
     rInputFormat = d->handler->m_iPixelFormat;
     rBitsPerPel = d->handler->m_uiBitsPerPixel;
     rEndianness = d->handler->m_iEndianness;
-    rFrameRate = d->handler->m_dFrameRate;
+    rFrameRate = static_cast<unsigned>( std::max( 0.0, d->handler->m_dFrameRate ) );
   }
   else
   {
     rWidth = 0;
     rHeight = 0;
     rInputFormat = CLP_YUV420P;
-    rBitsPerPel = 8;
+    rBitsPerPel = kDefaultBitsPerPixel;
     rEndianness = 0;
-    rFrameRate = 30;
+    rFrameRate = kDefaultFrameRate;
   }
 }
 
+auto CalypStream::hasNextFrame() -> bool
+{
+  return d->frameFifo.size() > 1;
+}
+
+auto CalypStream::hasWritingSlot() -> bool
+{
+  return !d->bLoadAll && d->frameBuffer->bufferIdx > 0;
+}
+
+/**
+ * @brief Read operations
+ */
+
 void CalypStream::loadAll()
 {
+  const std::lock_guard<std::recursive_mutex> lock( d->stream_mutex );
   if( d->bLoadAll || !d->isInput )
     return;
 
@@ -466,64 +553,79 @@ void CalypStream::loadAll()
   }
   catch( CalypFailure& e )
   {
-    close();
+    d->close();
     throw CalypFailure( "CalypStream", "Cannot allocated frame buffer for the whole stream" );
   }
-
   seekInput( 0 );
-  for( unsigned int i = 2; i < d->frameBuffer->size(); i++ )
+  for( unsigned int i = 2; i < d->handler->m_uiTotalNumberFrames; i++ )
   {
-    readFrame( d->frameBuffer->frame( i ) );
+    d->readNextFrame( false );
   }
   d->bLoadAll = true;
   d->iCurrFrameNum = 0;
 }
 
-void CalypStream::getDuration( int* duration_array ) const
+std::unique_ptr<CalypFrame> CalypStream::getCurrFrame( std::unique_ptr<CalypFrame> buffer )
 {
-  //   int hours, mins, secs = 0;
-  // #ifdef USE_FFMPEG
-  //   if( m_iStreamHandler == FFMPEG )
-  //   {
-  //     secs = m_cLibAvContext->getStreamDuration();
-  //   }
-  //   else
-  // #endif
-  //   if( m_iStreamHandler == YUV_IO )
-  //   {
-  //     secs = m_uiTotalFrameNum / m_dFrameRate;
-  //   }
-  //   mins = secs / 60;
-  //   secs %= 60;
-  //   hours = mins / 60;
-  //   mins %= 60;
-  //   *duration_array++ = hours;
-  //   *duration_array++ = mins;
-  //   *duration_array++ = secs;
+  if( buffer == nullptr )
+    buffer = std::make_unique<CalypFrame>( *d->frameFifo.front() );
+  else
+    buffer->copyFrom( *d->frameFifo.front() );
+  return buffer;
 }
 
-bool CalypStream::readFrame( CalypFrame* frame )
+auto CalypStream::getCurrFrameAsset() -> std::shared_ptr<CalypFrame>
 {
-  if( !d->isInit || !d->isInput || d->handler->m_uiCurrFrameFileIdx >= d->handler->m_uiTotalNumberFrames )
-    return false;
-
   if( d->bLoadAll )
-    return true;
-
-  if( !d->handler->read( frame ) )
-  {
-    throw CalypFailure( "CalypStream", "Cannot read frame from stream" );
-    return false;
-  }
-  return true;
+    return d->frameFifo[d->iCurrFrameNum];
+  return d->frameFifo.front();
 }
 
-void CalypStream::writeFrame()
+auto CalypStream::getCurrFrame() -> CalypFrame*
 {
-  writeFrame( d->frameBuffer->current() );
+  if( d->bLoadAll )
+    return d->frameFifo[d->iCurrFrameNum].get();
+  return d->frameFifo.front().get();
 }
 
-void CalypStream::writeFrame( CalypFrame* pcFrame )
+bool CalypStream::isEof()
+{
+  if( d->iCurrFrameNum + 1 >= (long)( d->handler->m_uiTotalNumberFrames ) )
+  {
+    return true;
+  }
+  return false;
+}
+
+bool CalypStream::setNextFrame()
+{
+  if( isEof() )
+  {
+    return true;
+  }
+  d->iCurrFrameNum++;
+  if( !d->bLoadAll )
+  {
+    assert( d->frameFifo.size() > 1 );
+    d->frameFifo.pop_front();
+  }
+  return false;
+}
+
+void CalypStream::readNextFrame()
+{
+  d->readNextFrame();
+}
+
+void CalypStream::readNextFrameFillRGBBuffer()
+{
+  d->readNextFrame( true );
+}
+
+/**
+ * @brief Write operations
+ */
+void CalypStream::writeFrame( const CalypFrame& pcFrame )
 {
   if( !d->handler->write( pcFrame ) )
   {
@@ -534,64 +636,24 @@ void CalypStream::writeFrame( CalypFrame* pcFrame )
 
 bool CalypStream::saveFrame( const ClpString& filename )
 {
-  return saveFrame( filename, d->frameBuffer->current() );
+  return saveFrame( filename, *getCurrFrame() );
 }
 
-bool CalypStream::saveFrame( const ClpString& filename, CalypFrame* saveFrame )
+bool CalypStream::saveFrame( const ClpString& filename, const CalypFrame& saveFrame )
 {
   CalypStream auxSaveStream;
-  if( !auxSaveStream.open( filename, saveFrame->getWidth(), saveFrame->getHeight(), saveFrame->getPelFormat(),
-                           saveFrame->getBitsPel(), CLP_LITTLE_ENDIAN, 1, false ) )
+  if( !auxSaveStream.open( filename, saveFrame.getWidth(), saveFrame.getHeight(), saveFrame.getPelFormat(),
+                           saveFrame.getBitsPel(), CLP_LITTLE_ENDIAN, 1, false ) )
   {
     return false;
   }
   auxSaveStream.writeFrame( saveFrame );
-  auxSaveStream.close();
   return true;
 }
 
-bool CalypStream::setNextFrame()
-{
-  bool bEndOfSeq = false;
-
-  if( d->iCurrFrameNum + 1 < (long)( d->handler->m_uiTotalNumberFrames ) )
-  {
-    d->frameBuffer->setNextFrame();
-    d->iCurrFrameNum++;
-  }
-  else
-  {
-    bEndOfSeq = true;
-  }
-  return bEndOfSeq;
-}
-
-void CalypStream::readNextFrame()
-{
-  readFrame( d->frameBuffer->next() );
-}
-
-void CalypStream::readNextFrameFillRGBBuffer()
-{
-  readNextFrame();
-  d->frameBuffer->next()->fillRGBBuffer();
-  return;
-}
-
-CalypFrame* CalypStream::getCurrFrame( CalypFrame* pyuv_image ) const
-{
-  if( pyuv_image == NULL )
-    pyuv_image = new CalypFrame( d->frameBuffer->current() );
-  else
-    pyuv_image->copyFrom( d->frameBuffer->current() );
-  return pyuv_image;
-}
-
-CalypFrame* CalypStream::getCurrFrame() const
-{
-  return d->frameBuffer->current();
-}
-
+/**
+ * @brief Seek operations
+ */
 bool CalypStream::seekInputRelative( bool bIsFoward )
 {
   if( !d->isInit || !d->isInput )
@@ -601,7 +663,7 @@ bool CalypStream::seekInputRelative( bool bIsFoward )
   if( bIsFoward )
   {
     bRet = !setNextFrame();
-    readFrame( d->frameBuffer->next() );
+    d->readNextFrame();
   }
   else
   {
@@ -613,26 +675,24 @@ bool CalypStream::seekInputRelative( bool bIsFoward )
 
 bool CalypStream::seekInput( unsigned long new_frame_num )
 {
+  const std::lock_guard<std::recursive_mutex> lock( d->stream_mutex );
+
   if( !d->isInit || new_frame_num >= d->handler->m_uiTotalNumberFrames || long( new_frame_num ) == d->iCurrFrameNum )
     return false;
 
   d->iCurrFrameNum = new_frame_num;
 
   if( d->bLoadAll )
-  {
-    d->frameBuffer->setIndex( d->iCurrFrameNum );
     return true;
-  }
 
+  d->frameFifo.clear();
   if( !d->handler->seek( d->iCurrFrameNum ) )
   {
     throw CalypFailure( "CalypStream", "Cannot seek file into desired position" );
   }
 
-  d->frameBuffer->setIndex( 0 );
-  readFrame( d->frameBuffer->current() );
+  d->readNextFrame();
   if( d->handler->m_uiTotalNumberFrames > 1 )
-    readFrame( d->frameBuffer->next() );
-
+    d->readNextFrame();
   return true;
 }

lib/CalypStream.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,28 +26,31 @@
 #ifndef __CALYPSTREAM_H__
 #define __CALYPSTREAM_H__
 
-#include "CalypDefs.h"
+#include <memory>
+#include <vector>
+
+#include "CalypDefs.h"
+#include "CalypFrame.h"
 
-class CalypFrame;
 class CalypStreamHandlerIf;
 
 typedef CalypStreamHandlerIf* ( *CreateStreamHandlerFn )( void );
 
-typedef struct
+struct CalypStreamFormat
 {
   ClpString formatName;
   ClpString formatExt;
   std::vector<ClpString> getExts();
   ClpString formatPattern;
   CreateStreamHandlerFn formatFct;
-} CalypStreamFormat;
+};
 
-typedef struct
+struct CalypStandardResolution
 {
   ClpString shortName;
   unsigned int uiWidth;
   unsigned int uiHeight;
-} CalypStandardResolution;
+};
 
 /**
  * \class CalypStream
@@ -65,19 +68,23 @@ public:
   static std::vector<CalypStandardResolution> stdResolutionSizes();
 
   CalypStream();
+  CalypStream( CalypStream&& other ) noexcept = delete;
+  CalypStream& operator=( CalypStream&& other ) noexcept = delete;
+  CalypStream( const CalypStream& other ) = delete;
+  CalypStream& operator=( const CalypStream& other ) = delete;
   ~CalypStream();
 
   ClpString getFormatName() const;
-  ;
   ClpString getCodecName() const;
-  ;
 
-  bool open( ClpString filename, ClpString resolution, ClpString input_format, unsigned int bitsPel, int endianness, unsigned int frame_rate,
+  bool open( ClpString filename, ClpString resolution, ClpString input_format, unsigned int bitsPel, int endianness, bool hasNegative, unsigned int frame_rate,
              bool bInput );
   bool open( ClpString filename, unsigned int width, unsigned int height, int input_format, unsigned int bitsPel, int endianness, unsigned int frame_rate,
              bool bInput );
+  bool open( ClpString filename, unsigned int width, unsigned int height, int input_format, unsigned int bitsPel, int endianness, bool hasNegative, unsigned int frame_rate,
+             bool bInput );
+
   bool reload();
-  void close();
 
   bool isNative() const;
   ClpString getFileName() const;
@@ -91,32 +98,29 @@ public:
   void getFormat( unsigned int& rWidth, unsigned int& rHeight, int& rInputFormat, unsigned int& rBitsPerPel, int& rEndianness,
                   unsigned int& rFrameRate ) const;
 
+  auto hasNextFrame() -> bool;
+  auto hasWritingSlot() -> bool;
+
   void loadAll();
-
-  void writeFrame();
-  void writeFrame( CalypFrame* pcFrame );
-
-  bool saveFrame( const ClpString& filename );
-  static bool saveFrame( const ClpString& filename, CalypFrame* saveFrame );
-
-  CalypFrame* getCurrFrame( CalypFrame* ) const;
-
-  // continuous read control
+  std::unique_ptr<CalypFrame> getCurrFrame( std::unique_ptr<CalypFrame> buffer );
+  auto getCurrFrameAsset() -> std::shared_ptr<CalypFrame>;
+  auto getCurrFrame() -> CalypFrame*;
+  bool isEof();
   bool setNextFrame();
   void readNextFrame();
   void readNextFrameFillRGBBuffer();
-  CalypFrame* getCurrFrame() const;
+
+  void writeFrame( const CalypFrame& pcFrame );
+
+  bool saveFrame( const ClpString& filename );
+  static bool saveFrame( const ClpString& filename, const CalypFrame& saveFrame );
 
   bool seekInputRelative( bool bIsFoward );
   bool seekInput( unsigned long new_frame_num );
 
-  void getDuration( int* duration_array ) const;
-
 private:
-  bool readFrame( CalypFrame* frame );
-
-private:
-  struct CalypStreamPrivate* d;
+  class CalypStreamPrivate;
+  std::unique_ptr<CalypStreamPrivate> d;
 };
 
 #endif  // __CALYPSTREAM_H__